void ft_putchar(char c)
{
	write(1, &c, 1);
}

void	ft_print_alphabet(void)
{
	char ltr;

	ltr = 'a'; // ltr = 97;
	while (ltr <= 'z') // While (ltr <= 122)
	{
		ft_putchar(ltr);
		ltr++;
	}
}

int	main(void)
{
	ft_print_alphabet();
	return (0);
}

> $> abcd...z

void	ft_print_numbers(void)
{
	char nbr;

	nbr = '0';
	while (nbr >= '0' && nbr <= '9')
	{
		ft_putchar(nbr);
		nbr++;
}

void	ft_is_negative(int n)
{
	if (n < 0)
		ft_putchar('N');
	else
		ft_putchar('P');
}

int	main(void)
{
	int i;
	int *nbr;

	i = 0;
	nbr = &i;
	ft_putnbr(i);
		ft_putchar('\n');
	ft_ft(nbr);
	ft_putnbr(i);
		ft_putchar('\n');
	return(0);
}

void	ft_ft(int *nbr)
{
	*nbr = 42;
}

int	main()
{
	int nb1;
	int nb2;
	int *a;
	int *b;

	nb1 = 0;
	nb2 = 1;
	a = &nb1;
	b = &nb2;
	ft_putnbr(nb1);
		ft_putchar('\n');
	ft_putnbr(nb2);
		ft_putchar('\n');
	ft_swap(a, b);
	ft_putnbr(nb1);
		ft_putchar('\n');
	ft_putnbr(nb2);
		ft_putchar('\n');
	return(0);
}

void	ft_swap(int *a, int *b)
{
	int tmp;
	tmp = *a;
	*a = *b;
	*b = tmp;
}

int	main(void)
{
	int a;
	int b;
	int div;
	int mod;
	int *pdiv;
	int *pmod;

	a = 6;
	b = 2;
	div = 0;
	mod  = 0;
	pdiv = ÷
	pmod = &mod;
	ft_putnbr(a);
		ft_putchar('\n');
	ft_putnbr(b);
		ft_putchar('\n');
	ft_div_mod(a, b, pdiv, pmod);
	ft_putnbr(div);
		ft_putchar('\n');
	ft_putnbr(mod);
		ft_putchar('\n');
	return(0);
}

void	ft_div_mod(int a, int b, int *div, int *mod)
{
	*div = a / b;
	*mod = a % b;
}

int	ft_iterative_factorial(int nb)
{
	int product;

	if (nb > 12)
		return (0);
	if (nb < 0)
		return (0);
	product = 1;
	while(nb >= 1)
	{
		product = product * nb;
		nb--;
	}
	return (product);
}

int	main(void)
{
	int i;
	i = 5;

	ft_putnbr(i);
		ft_putchar('\n');
	ft_putnbr(ft_iterative_factorial(i));
		ft_putchar('\n');
	return (0);

}

int ft_recursive_factorial(int nb);

int	ft_recursive_factorial(int nb)
{
	if (nb == 0)
		return(1);
	else if (nb < 0 || nb > 12)
		return(0);
	else
		return (nb * ft_recursive_factorial(nb - 1));
}

int ft_sqrt(int nb);

int	ft_sqrt(int nb)
{
	int sqrt;

	sqrt = 0;
	while(sqrt <= nb / 2)
	{
		if ((sqrt * sqrt) == nb)
			return (nb);
		else
			sqrt++;
    }
  return (0);
}

/*This function displays the string s to the standard output. We do this using
 our ft_putchar function. We start by declaring a i variable that we
 will use to move through our string. We use a i because it is
 guaranteed to be big enough to contain the size of the biggest object your
 system can handle. This way we can display the absolute biggest string that
 our computer can handle. We set i equal to 0 to start at the beginning of
 the parameter string s. We then do a simple loop stating that so long as we
 have not reached the end of our string we want the loop to continue. We move
 to each index position of our string and place the character in that
 position as a parameter for our ft_putchar function. The ft_putchar function
 will put that character in the standard output and then we increment the i
 variable to continue moving through the string. We do this until we reach
 the terminating '\0' of the string.*/

void	ft_putstr(char *str)
{
	int i;

	i = 0;
	while (str[i] != '\0')
	{
		ft_putchar(str[i]);
		i++;
	}
}

int	main(void)
{
	char str[] = "vlad is cool";
	ft_putstr(str);
		ft_putchar('\n');
	write(1, "-----\n", 6);
	char str1[] = "";
	ft_putstr(str1);
		ft_putchar('\n');
	write(1, "-----\n", 6);
	char str2[] = "Pipe this to another | and export the $";
	ft_putstr(str2);
		ft_putchar('\n');
	write(1, "-----\n", 6);
	return (EXIT_SUCCESS);
}

int	ft_strlen(char *str)
{
	int len;

	len = 0;
	while (str[len] != '\0')
	{
		len++;
	}
	return(len);
}

int	main()
{
	int i;

	i = 0;
	char str[] = "Hello world";
	ft_putstr(str);
		ft_putchar('\n');
	i = ft_strlen(i);
	ft_putnbr(i);
		ft_putchar('\n');
	return(0);
}

	/*Compare S1 and S2, returning less than, equal to or
	greater than zero if S1 is lexicographically less than,
	equal to or greater than S2.*/
int	strcmp (const char *p1, const char *p2)
{
	const unsigned char *s1 = (const unsigned char *) p1;
	const unsigned char *s2 = (const unsigned char *) p2;
	unsigned char c1, c2;
	do
	{
		c1 = (unsigned char) *s1++;
		c2 = (unsigned char) *s2++;
		if (c1 == '\0')
		return c1 - c2;
	}
	while (c1 == c2);
	return c1 - c2;
}

	/*According to the man this function lexicographically compares the NULL
	terminated strings s1 and s2 that are passed into it's parameters. The
	function returns an integer greater than, equal to, or less than 0 depending
	on whether the string s1 is greater than, equal to, or less than string s2.
	The comparison is done using unsigned characters, so that '\200' is greater
	than '\0'.*/

int	ft_strcmp(char *s1, char *s2)
{
	/*i will start by creating an index variable i (counter), and making it an unsigned
	 int in case the input is a  long string. hen i set it equal to 0 to
	 place the counter at the start of the string inside the while loop.*/
	
	unsigned int i;

	i = 1;
	
	/*The while loop requires two conditions to be true for it to begin looping
	and to continue looping ofc. i the loop to happen as long as i have
	not reached the end of the string s1 && i want the loop to happen only
	so long as the character at position i in s1 is the same as the character
	in postion i in s2. The second we find a difference in the string i want
	to compare the difference. */
	while (s1[i] != '\0' && s1[i] == s2[i])
	{
		i++;

	
	/*When it has either found a non matching character or it has reached the 
	end of s1 the function should return the difference between the character in position i in
	s1 and the character in position i in s2.
	*/
	}
	return (s1[i] - s2[i]);
}

void	ft_putchar(char c);
void	ft_pustr(char *str);
void	ft_putnbr(int nb);
int	ft_ft_strcmp(char *s1, char *s2);

int	main(void)
{
	int i;

	i = '1';
	char str1[] = "Vlad";
	char str2[] = "Vlad";
	write(1, "-----\n", 6);
	ft_putstr(str1);
		ft_putchar('\n');
	ft_putstr(str2);
		ft_putchar('\n');
	i = ft_strcmp(str1, str2);
	ft_putnbr(ft_strcmp(str1, str2));
		ft_putchar('\n');
	write(1, "-----\n", 6);
	
	char str3[] = "a";
	char str4[] = "ab";
	ft_putstr(str3);
		ft_putchar('\n');
	ft_putstr(str4);
		ft_putchar('\n');
	i = ft_strcmp(str3, str4);
	ft_putnbr(ft_strcmp(str3, str4));
		ft_putchar('\n');
	write(1, "-----\n", 6);

	char str5[] = "ab";
	char str6[] = "a";
	ft_putstr(str5);
		ft_putchar('\n');
	ft_putstr(str6);
		ft_putchar('\n');
	i = ft_strcmp(str5, str6);
	ft_putnbr(ft_strcmp(str5, str6));
		ft_putchar('\n');
	write(1, "-----\n", 6);

	return (EXIT_SUCCESS);
}

#include <unistd.h>

void	ft_putchar(char c)
{
	write(1, &c, 1);
}

void	ft_putstr(char *str)
{
	int i;

	i = 0;
	while(str[i] != '\0')
	{
		ft_putchar(str[i]);
		i++;
	}
}

void	ft_putnbr(int nb)
{
	if (nb < 0)
	{
		nb = -nb;
		ft_putchar('-');
	}
	if (nb >= 10)
	{
		ft_putnbr(nb / 10);
		ft_putnbr(nb % 10);
	}
	if (nb >= 0 && nb < 10)
		ft_putchar(nb + '0');
}

int	main(int argc, char **argv)
{
	int i;

	i = 1;
	(void)argc;
	(void)argv;
	while (i < argc)
	{
		ft_putstr(argv[i]);
			ft_putchar('\n');
		i++;
	}
	write(1, "Arguments count = ", 20);
	ft_putnbr(argc);
	ft_putchar('\n');
	return (0);
}

#include <unistd.h>

void	ft_putchar(char c)
{
	write(1, &c, 1);
}

void	ft_putstr(char *str)
{
	int i;

	i = 0;
	while (str[i] != '\0')
	{
		ft_putchar(str[i]);
		i++;
	}
}

int		ft_strcmp(char *s1, char *s2)
{
	int i;

	i = 0;
	while ((s1[i] == s2[i]) && (s1[i] != '\0' && s2[i] != '\0'))
		i++;
	return (s1[i] - s2[i]);
}

int		main(int argc, char **argv)
{
	int i;
	int j;
	char *tmp;

	i = 0;
	while (++i < argc)
	{
		j = i;
		while (++j < argc)
		{
			if (ft_strcmp(argv[i], argv[j]) > 0)
			{
				tmp = argv[i];
				argv[i] = argv[j];
				argv[j] = tmp;
			}
		}
	}
	i = 0;
	while (++i < argc)
	{
		ft_putstr(argv[i]);
		ft_putchar('\n');
	}
	return (0);
}

char	*ft_strdup(char *src)
{
	int		i;
	char	*dest;

	i = 0;
	dest = malloc(sizeof(*src) * ((ft_strlen((char *)src)) + 1));
	if (dest == NULL)
		return (NULL);
	while (src[i] != '\0')
	{
		dest[i] = src[i];
		i++;
	}
	dest[i] = '\0';
	return (dest);
}

void	ft_putchar(char c);
void	ft_pustr(char *str);
int	ft_strlen(char *str);
int	*ft_strdup(char *src);

int main(void)
{
	char str[] = "Duplicate me motherfucker";

	ft_putstr(str);
		ft_putchar('\n');
	printf("%p\n", str);
	write(1, "-----\n", 6);
	ft_strdup(str);
	ft_putstr(str);
		ft_putchar('\n');
	printf("%p\n", str);
	write(1, "-----\n", 6);
	return (EXIT_SUCCESS);
}