char *ft_itoa(int nbr)
{
int sign;
int length;
char *result;
int i;
length = 0;
if ((sign = nbr) < 0)
nbr = -nbr;
while (ft_power(10, length) <= nbr)
length++;
result = (char*)malloc(sizeof(int) * length);
result[0] = (nbr % 10) + 48;
i = 1;
while ((nbr /= 10) > 0)
{
result[i] = (nbr % 10) + 48;
i++;
}
if (sign < 0)
result[i++] = '-';
result[i] = '\0';
return (ft_strrev(result));
}
double ft_atod(char *str)
{
double tmp;
double val;
int i;
int flag;
i = 0;
val = (double)ft_atoi(str);
flag = (str[0] == '-' ? -1 : 1);
while (*str && *str != '.' && *str != ',')
str++;
if (!*str++)
return (val);
while (ft_isdigit(str[i]) && i < 9)
(i)++;
if (!i)
return (val);
while (--(i) >= 0 && str[i] == '0')
;
tmp = (double)ft_atoi_size(str, ++(i));
if (tmp <= 0)
return (val);
tmp /= (double)ft_power(10, i);
val = val + (tmp * flag);
return (val);
}
void bit_convert(char *buf, t_tetri *tetris)
{
int tab[3];
int power;
I = -1;
J = -1;
tetris->tetris = (t_tetris2*)malloc(sizeof(t_tetris2) * tetris->nb_tetris);
while (buf[++I])
{
K = 0;
ft_init_tab(TET[++J].tetris, 16);
TET[J].carac = 'A' + J;
while ((buf[I] != '\n' && buf[I + 1] != '\n') && buf[I--])
{
power = 0;
while (buf[++I] != '\n')
{
if (buf[I] == '#')
TET[J].tetris[K] += ft_power(2, power);
power++;
}
K++;
I++;
}
bit_reset(TET[J].tetris, 4);
}
}
int main(void)
{
char c;
int key;
int *grid;
int g_size;
c = 0;
if (ft_check_win_value(WIN_VALUE, 0) == 0)
{
ft_putendl("WIN_VALUE is not valid");
return (1);
}
c = ft_menu(c);
g_size = ft_grid_size(c);
key = (c != 48 && c != 27) ? ft_key_use() : 0;
if ((c != 48 && c != 27) && (key != 27 && key != 48))
{
grid = ft_nbrnew(ft_power(g_size, g_size));
ft_starting_grid(g_size, grid);
ft_window(g_size, grid, key, 0);
free(grid);
grid = NULL;
}
return (0);
}
void ft_putnbr(int n)
{
int j;
int i;
int power;
if (n == -2147483648)
{
ft_putstr("-2147483648");
return ;
}
i = 0;
j = 0;
if (n < 0)
{
ft_putchar('-');
i++;
n = n * (-1);
}
while (j < ft_val(n))
{
power = ft_val(n) - j - 1;
ft_putchar(48 + (n / (ft_power(10, power)) % 10));
j++;
}
}
int ft_atoi_base(char *str, char *base)
{
int i;
int s;
int nbr;
int nbr_final;
int size_base;
i = 0;
s = 1;
nbr_final = 0;
size_base = 0;
if (ft_check_str(str, base) && ft_check_base(base))
{
while (((str[i] >= 9) && (str[i] <= 13)) || str[i] == 32)
i++;
if (str[i] == '-')
{
s = -1;
i++;
}
else if (str[i] == '+')
i++;
nbr = get_nbr(str, base, i);
while (base[size_base])
size_base++;
i = 0;
nbr *= 10;
while ((nbr /= 10) > 0)
nbr_final += (nbr % 10) * ft_power(size_base, i++);
}
return (nbr_final * s);
}
char *ft_itoa(int n)
{
int i;
int j;
char *tab;
int power;
i = 0;
j = 0;
tab = (char*)malloc(sizeof(*tab) * (ft_val(n) + 1));
if (!tab)
return (NULL);
if (n == -2147483648)
return (ft_strcpy(tab, "-2147483648"));
if (n < 0)
{
tab[0] = '-';
i++;
n = n * (-1);
}
while (j < ft_val(n))
{
power = ft_val(n) - (j++) - 1;
tab[i++] = 48 + (n / (ft_power(10, power)) % 10);
}
tab[i] = '\0';
return (tab);
}
int ft_power(int number, int power)
{
if (power == 0)
return (1);
else if (power < 0)
return (0);
return (number * ft_power(number, power - 1));
}
int ft_power(int nb, int p)
{
if (p < 0)
return (0);
if (p == 0)
return (1);
return (nb * ft_power(nb, p - 1));
}
int ft_power(int nb, int power)
{
if (power == 0)
return (1);
else if (power < 0)
return (0);
return (nb * ft_power(nb, power - 1));
}
static int ft_power(int n)
{
if (n == 0)
return (1);
if (n == 1)
return (10);
else
return (10 * ft_power(n - 1));
}
int ft_power(int n, int pow)
{
if (pow <= 0)
return (1);
else if (pow == 1)
return (n);
else
return (n * ft_power(n, pow - 1));
}
float ft_cos(float angle)
{
float ret;
int n;
angle = ft_check_angle(angle);
angle *= 3.14159;
angle /= 180;
n = 0;
ret = 1;
while (++n < 5)
ret += ft_power(-1, n) * ((ft_power(angle, n + n) / ft_fact(n + n)));
if (ret > 1)
return (EXIT_SUCCESS);
if (ret < -1)
return (EXIT_FAILURE);
return (ret);
}
int ft_power(int nb, int pow)
{
if (pow < 0)
return (0);
if (pow == 0)
return (1);
if (pow >= 2)
return (nb * ft_power(nb, pow - 1));
else
return (nb);
}
uintmax_t ft_tobase10(char *n, int base)
{
int i;
int conv;
int power;
conv = 0;
power = 0;
i = ft_strlen(n);
i--;
while (i != -1)
{
if (base == 16
&& ((n[i] >= 65 && n[i] <= 70) || (n[i] >= 97 && n[i] <= 102)))
conv += (n[i--] - 55) * ft_power(base, power);
else
conv += (n[i--] - 48) * ft_power(base, power);
power++;
}
return (conv);
}
static char *do_itoa(char *str, int n, int len)
{
char *ps;
int dig;
ps = str;
if (n == 0)
*str = '0';
if (n < 0)
{
*ps++ = '-';
len--;
n = n * -1;
}
while (len-- > 0)
{
dig = n / ft_power(10, len);
*ps++ = dig + 48;
n = n % ft_power(10, len);
}
return (str);
}
int ft_atoi(char *str)
{
int i;
int digits;
int result;
result = 0;
i = -1;
digits = count_digits(str);
while (++i < digits)
result += (str[i] - 48) * ft_power(10, digits - i - 1);
return (result);
}
int ft_power(int nb, int power)
{
int nb_pwr;
nb_pwr = nb;
if (power < 0)
return (0);
if (power == 0)
return (1);
if (power == 1)
return (nb_pwr);
nb_pwr = nb * ft_power(nb, power - 1);
return (nb_pwr);
}
long double ft_arrondi_double(long double nb, size_t dec)
{
long double tmp;
int neg;
uintmax_t pow;
intmax_t tmp_int;
pow = ft_power(dec, 10);
tmp = (nb < 0) ? -nb * pow : nb * pow;
neg = (nb < 0) ? -1 : 1;
tmp_int = tmp;
if (tmp - (intmax_t)tmp < 0.5)
return ((long double)tmp_int * neg / pow);
return ((long double)(tmp_int + 1) * neg / pow);
}
float ft_atof(char *str)
{
int ent;
double dec;
float f;
int k;
int m;
ent = 0;
dec = 0;
m = 0;
ent = ft_atoi(str);
k = (neg(str[0]) ? 0 : 1);
k += (ent == 0 && neg(str[0]) ? 1 : 0);
while (ft_isdigit(str[ft_strlen(ft_itoa(ent)) + k + 1 + m]))
m++;
if (str[ft_strlen(ft_itoa(ent)) + k] == '.')
dec = ft_atoi(str + ft_strlen(ft_itoa(ent)) + k + 1);
if (str[0] == '-')
f = ent - (dec / ft_power(10, m));
else
f = ent + (dec / ft_power(10, m));
return (f);
}
int ft_nbrlen_base(long int nb, int base)
{
int len;
char sign;
len = 0;
sign = (nb < 0 ? 'n' : 'p');
nb = (nb < 0 ? -nb : nb);
while (nb / ft_power(base, len) != 0)
(len)++;
len = (nb == 0 ? 1 : len);
if (sign == 'p')
return (len);
return (len + 1);
}
double ft_atof(const char *str)
{
double res;
double res2;
char *c;
c = (char *)str;
res = (double)ft_atoi(c);
while (*c != '.')
{
c++;
}
c++;
res2 = (double)ft_atoi(c);
return (res + res2 / ft_power(10, ft_strclen(' ', c) - 1));
}
int octal_to_decimal(int n)
{
int decimal;
int rest;
int i;
decimal = 0;
i = 0;
while (n != 0)
{
rest = n % 10;
n /= 10;
decimal += rest * ft_power(8, i);
i++;
}
return (decimal);
}
int ft_bintoi(char *str)
{
int i;
int number;
int len;
number = 0;
i = 0;
len = ft_strlen(str);
while (str[i])
{
if (str[i] == '1')
number += ft_power(2, len - (i + 1));
i++;
}
return (number);
}
static int ft_calc(const char *str, int i, int base)
{
int n;
int pow;
int tmp;
n = 0;
i -= 1;
pow = -1;
while (ft_ishexa(str[++i]))
;
while (ft_ishexa(str[--i]))
{
if ((tmp = ft_base(str[i], base)) == -1)
break ;
n += (ft_power(base, ++pow)) * tmp;
}
return (n);
}
char *ft_todecimal(char *number, int base)
{
int i;
int digit;
int decimal;
decimal = 0;
i = 0;
while (number[i + 1])
i++;
while (i >= 0)
{
digit = ft_chartoint(number[i]);
decimal = decimal + (digit * ft_power(base, ft_strlen(number) - i - 1));
i--;
}
number = ft_itoa(decimal);
return (number);
}
int ft_atoi_base(char *nb, int base)
{
int result;
int length;
if (base == 10)
return (ft_atoi(nb));
while (*nb == ' ' || *nb == '\t' || *nb == '\n'
|| *nb == '\v' || *nb == '\r' || *nb == '\f')
nb++;
result = 0;
length = length_number(nb, base) - 1;
while (*nb && length >= 0 && convert_and_check_nb(*nb, base) != -1)
{
result += convert_and_check_nb(*nb, base) * ft_power(base, length);
nb++;
length--;
}
return (result);
}
char *ft_itoa_base(int value, int base)
{
int i;
int length;
char *str;
long sign;
long nb;
if (value < 0 && base == 10)
{
sign = -1;
nb =(long)-value;
}
else if (value < 0 && base != 10)
return (NULL);
else
{
sign = 1;
nb = (long)value;
}
length = 1;
while (ft_power(base, length) <= nb)
length++;
if (!(str = (char *)malloc(sizeof(char) * (length + 2))))
return (NULL);
i = 0;
while (i < length)
{
if (base <= 10 || (base > 10 && (nb % base) < 10 ))
str[i] = (nb % base) + 48;
else
str[i] = (nb % base) - 10 + 65;
nb /= base;
i++;
}
if (sign == -1)
str[i++] = '-';
str[i] = '\0';
return (ft_strrev(str));
}
int nu_len(int n, int base)
{
int i;
i = 0;
if (base == 10)
{
if (n < 0)
n = -n;
while (n > 0)
{
n /= 10;
i++;
}
}
if (base == 2)
{
while (n >= ft_power(2, i))
i++;
}
return (i);
}
int ft_atoi_base(const char *str, int base)
{
int signe;
int re;
int i;
int num;
int p;
i = 0;
p = ft_strlen(str) - 1;
re = 0;
signe = 1;
ft_prep(str, &i, &signe);
while (str[i] != '\0' && (num = ft_ishex(str[i])) != -1)
{
re = re + (ft_power(base, p) * num);
i++;
p--;
}
if (num == -1)
return (-1);
return (re * signe);
}
