char		*dec2bin(int n)
{
	char	*binary;
	int	max;
	int	i;

	i = max = 0;
	while ((2 << max) <= n)
		++max;
	binary = malloc(max + 1);
	while (max >= 0)
		{
			if (n >= (1 << max))
				{
					binary[i] = '1';
					n = n - (1 << max);
				}
			else
				binary[i] = '0';
			--max;
			++i;
		}
	binary[i] = '\0';
	return (binary);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

void		swap(unsigned int *a, unsigned int *b);
size_t		my_strlen(char const * const str);
int		my_atoi(char *nbstr);
char		my_read(void);
char		*my_readstr(void);
void		*xmalloc(size_t size);
void		*xrealloc(void *ptr, size_t size);
unsigned int	*create_tab(size_t n);
unsigned int	*tri_insertion(unsigned int *tab, size_t n);
unsigned int	*tri_selectif(unsigned int *tab, size_t n);
unsigned int	*tri_bulle(unsigned int *tab, size_t n);

void		swap(unsigned int *a, unsigned int *b)
{
	*a ^= *b;
	*b ^= *a;
	*a ^= *b;
}

size_t	my_strlen(char const * const str)
{
	size_t	i;

	i = 0;
	while (str[i])
		++i;
	return (i);
}

int	my_atoi(char *nbstr)
{
	size_t i;
	int nb;
	int pow;

	nb = 0;
	i = my_strlen(nbstr) - 1;
	pow = 1;
	while (nbstr[i])
		{
			nb += (nbstr[i] - 48) * pow;
			pow *= 10;
			--i;
		}
	return nb;
}

char	my_read(void)
{
	char	c;

	return ((fread(&c, 1, 1, stdin)) ? c : 0);
}

char	*my_readstr(void)
{
	size_t	i;
	char	*buff;

	buff = xmalloc(BUFSIZ);
	i = 0;
	while(((buff[i] = my_read()) != '\n') && i <= BUFSIZ)
		++i;
	buff[i] = '\0';
	if (xrealloc(buff, strlen(buff) + 1) == NULL)
		exit(EXIT_FAILURE);
	return (buff);
}

void	*xmalloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		{
			fprintf(stderr, "Virtual memory exhausted\n");
			exit(EXIT_FAILURE);
		}
	return (ptr);
}

void	*xrealloc(void *ptr, size_t size)
{
	if (realloc(ptr, size) == NULL)
		{
			fprintf(stderr, "Virtual memory exhausted\n");
			exit(EXIT_FAILURE);
		}
	return (ptr);
}

unsigned int	*create_tab(size_t n)
{
	size_t i;
	unsigned int *tab;

	i = 0;
	tab = malloc(n * sizeof(int));
	while (i < n)
			tab[i++] = rand();
	return (tab);
}

unsigned int	*tri_insertion(unsigned int *tab, size_t n)
{
	size_t i;
	size_t j;
	size_t x;

	i = 1;
	while (i < n)
		{	
			x = tab[i];
			j = i;
			while ((j > 0) && (tab[j - 1] > x))
				{
					tab[j] = tab[j - 1];
					--j;
				}
			tab[j] = x;
			++i;
		}

	return (tab);
}

unsigned int	*tri_selectif(unsigned int *tab, size_t n)
{
	size_t i;
	size_t j;
	size_t min;

	i = 0;
	while (i < (n - 1))
		{
			min = i;
			j = i + 1;
			while (j < n)
				{
					if (tab[j] < tab[min])
						min = j;
					++j;
				}
			if (min != i)
				{
					swap(&tab[i], &tab[min]);
				}
			++i;
		}

	return (tab);
}

unsigned int	*tri_bulle(unsigned int *tab, size_t n)
{
	size_t i;
	int no_exchange;

	no_exchange = 0;
	while (!no_exchange)
		{
			no_exchange = 1;
			i = 0;
			while (i < (n - 1))
				{
					if (tab[i] > tab[i + 1])
						{
							swap(&tab[i], &tab[i + 1]);
							no_exchange	=	0;
						}
					++i;
				}
			n--;
		}
	return (tab);
}


int	main(void)
{
	size_t n;
	int time_start, time_end;

	srand(time(NULL));
	printf("Combien d'éléments voulez-vous trier ? ");
	n = my_atoi(my_readstr());

	printf("Tri à insertion en cours ........ ");
	time_start = time(NULL);
	tri_insertion(create_tab(n), n);
	time_end = time(NULL);
	printf("%3d secondes\n", (time_end - time_start));

	printf("Tri à selection en cours ........ ");
	time_start = time(NULL);
	tri_selectif(create_tab(n), n);
	time_end = time(NULL);
	printf("%3d secondes\n", (time_end - time_start));

	printf("Tri à bulles en cours ........... ");
	time_start = time(NULL);
	tri_bulle(create_tab(n), n);
	time_end = time(NULL);
	printf("%3d secondes\n", (time_end - time_start));

    return (0);
}

int	isupper(const int c)
{
	return (c > 64 && c < 91);
}

int	islower(const int c)
{
	return (c > 96 && c < 123);
}

int	tolower(const int c)
{
	return ((isupper(c)) ? c + 32 : c);
}

int	toupper(const int c)
{
	return ((islower(c)) ? c - 32 : c);
}

void	*xmalloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		{
			fprintf(stderr, "Virtual memory exhausted\n");
			exit(EXIT_FAILURE);
		}
	return (ptr);
}

size_t	my_strlen(char const * const str)
{
	size_t i;

	i = 0;
	while (str[i])
		++i;
	return (i);
}

char	*strcapitalize(char *str)
{
	char *new_str;
	size_t i;

	i = 0;
	new_str = xmalloc(my_strlen(str) + 1);
	while (str[i])
		{
			if (!i)
				new_str[i] = toupper(str[i]);
			else
				new_str[i] = tolower(str[i]);
			++i;
		}
	new_str[i] = '\0';
	return (new_str);
}

int	isupper(const int c)
{
	return (c > 64 && c < 91);
}

int	islower(const int c)
{
	return (c > 96 && c < 123);
}

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>

typedef struct matrice {
	int *value;
	size_t height;
	size_t width;
} matrice;

int		xrand(int a, int b);
void	*xmalloc(size_t size);
matrice	create_matrice(size_t height, size_t width);
matrice	merge_matrice(matrice mat1, matrice mat2);
void	print_matrice(matrice mat);

int	xrand(int a, int b)
{
	return ((rand() % (b - a + 1)) + a);
}

void	*xmalloc(size_t size)
{
	void *ptr;

	if ((ptr = malloc(size)) == NULL)
		{
			fprintf(stderr, "Virtual memory exhausted\n");
			exit(EXIT_FAILURE);
		}
	return (ptr);
}

matrice	create_matrice(size_t height, size_t width)
{
	struct matrice mat;
	size_t i;
	size_t j, t;

	mat.value = xmalloc(height * width * sizeof(int));
	mat.height = height;
	mat.width = width;
	i = j = 0;
	t = 0;
	while (i < height)
		{
			j = 0;
			while (j < width)
				{
					mat.value[t] = rand() % 99;
					++t;
					++j;
				}
			++i;
		}
	return (mat);
}

matrice	merge_matrice(matrice mat1, matrice mat2)
{
	struct matrice mat_merged;
	size_t i;
	size_t j;
	size_t a;
	size_t b;

	mat_merged.value = xmalloc(mat1.height * mat1.width * mat2.width * sizeof(int));
	mat_merged.height = mat1.height;
	mat_merged.width = mat1.width + mat2.width;
	i = j = a = b = 0;
	while (i < mat1.height)
		{
			j = 0;
			while (j < mat_merged.width)
				{
					if (j < mat1.width)
						{
							mat_merged.value[a + b] = mat1.value[a];
							++a;
						}
					else
						{
							mat_merged.value[a + b] = mat2.value[b];
							++b;
						}
					++j;
				}
			++i;
		}
	return (mat_merged);
}

void	print_matrice(matrice mat)
{
	size_t i;
	size_t j;
	size_t t;

	i = j = t = 0;
	while (i < mat.height)
		{
			j = 0;
			while (j < mat.width)
				{
					printf("%.2d ", mat.value[t]);
					++t;
					++j;
				}
			printf("\n");
			++i;
		}
	printf("\n");
}

int	main(void)
{
	matrice	matrix1;
	matrice	matrix2;
	matrice	matrix_f;
	size_t	heigth;

	srand(time(NULL));
	heigth = xrand(1, 5);

	matrix1 = create_matrice(heigth,  xrand(1, 5));
	matrix2 = create_matrice(heigth, xrand(1, 5));

	printf("Matrice 1 :\n");
	print_matrice(matrix1);
	printf("Matrice 2 :\n");
	print_matrice(matrix2);

	printf("Fusion en cours...\n\n");
	matrix_f = merge_matrice(matrix1, matrix2);

	printf("Matrice 3 :\n");
	print_matrice(matrix_f);
    return (0);
}

int _tolower(int c)
{
    return c | 32;
}
int _toupper(int c)
{
    return ~(~c|32);
}