int main(int argc, char **argv)
{
char BUF[547];
char **map;
char save[16][16];
char tab[27];
char end;
int taille;
int cpt;
if (argc != 2)
ft_ragequit();
ft_bzero(tab, 27);
ft_file(argv[1], BUF);
ft_erreur(BUF);
ft_search(BUF, tab);
taille = ft_sqrt(8 * tab[0]);
map = ft_init(taille);
ft_clean(save, 15);
cpt = 1;
end = 0;
while (end == 0 && taille >= ft_sqrt(4 * tab[0]))
{
end = ft_treatment(map, save, tab, cpt);
if (taille > ft_sqrt(4 * tab[0]))
{
taille--;
map = ft_init(taille);
cpt = ft_try_copy(map, save, taille);
}
}
ft_exit(save, ft_len_save(save));
return (0);
}
void normalize(double vec[3])
{
double len;
len = sqrt(ft_sqrt(vec[0]) + ft_sqrt(vec[1]) + ft_sqrt(vec[2]));
vec[0] = vec[0] / len;
vec[1] = vec[1] / len;
vec[2] = vec[2] / len;
}
t_pnt *ft_pt(int alt, int ts, int ss)
{
t_pnt *pnt;
pnt = (t_pnt*)malloc(sizeof(t_pnt));
alt *= RATIO;
pnt->x = (ft_sqrt(2.) / 2.) * (ss - ts);
pnt->y = -((ft_sqrt(2. / 3.) * alt) - (1 / ft_sqrt(6.) * (ts + ss)));
pnt->alt = alt;
return (pnt);
}
int s_opti(char *map)
{
int opt_n;
opt_n = 2 * ft_sqrt(ft_count_splits(map));
return (opt_n);
}
void ft_calcul_tetri(t_tetri **list)
{
char **map;
double tmp;
int size;
t_pos p;
t_nb nb;
nb.nb_list = ft_count_tetri(*list);
tmp = ft_sqrt(nb.nb_list * 4);
size = tmp;
if (tmp - size > 0.0)
size++;
map = ft_generate_map(size);
nb.max = ft_strlen(map[0]);
p.y = 0;
p.x = 0;
while (ft_place_tetri(*list, map, p, nb) == 0)
{
free(map);
size++;
map = ft_generate_map(size);
nb.max = ft_strlen(map[0]);
}
ft_print_map(map);
ft_clean_memory(list, map);
}
int main(int ac, char **av)
{
int fd;
char **tab;
int size;
t_tetri *tet;
fd = 0;
tet = tetri_new('A');
if (ac != 2)
print_error();
fd = open(av[1], O_RDONLY);
(fd == -1) ? print_error() : 0;
init_shape(tet, fd);
if (!file_valide(tet))
print_error();
size = ft_sqrt(tetri_count(tet) * 4);
tab = create_double_tab(size, '.');
while (fillit(tab, size, tet) == 0)
{
free_double_tab(&tab, size);
size++;
tab = create_double_tab(size, '.');
}
end_fillit(&tab, size, fd, tet);
return (0);
}
int ft_next_sqrt(int nb)
{
int ret;
while (!(ret = ft_sqrt(nb)))
nb++;
return (ret);
}
int getsquare(t_list *start)
{
int i;
i = 1;
while ((start = start->next))
i++;
if (i > 26)
return (0);
i = ft_sqrt(i * 4);
return (i);
}
int ft_size_map(int nb)
{
int size;
nb = nb * 4;
size = nb;
while ((size = ft_sqrt(size)) == -1)
{
nb++;
size = nb;
}
return (size);
}
int ft_resolve(t_list *begin_list, int tetrinb)
{
t_list *list;
t_ret ret;
int i;
int count;
t_alg *structure;
int count2;
ret.i = 0;
count2 = 0;
if (!(structure = (t_alg *)malloc(sizeof(t_alg) * tetrinb + 1)))
return (0);
count = tetrinb;
i = 0;
list = begin_list;
ret.str = ft_tab_init(ft_sqrt(tetrinb * 4));
list = list->next;
while (list)
{
structure[count2].str = list->str;
structure[count2].a = list->a;
list = list->next;
count2++;
}
structure[count2].str = NULL;
count2 = 0;
while (structure[count2].str != NULL)
{
while (ft_strcmp(gl_placetab[i].s, structure[count2].str) != 0 && i < 19)
i++;
ret = ft_call_func(ret, i, ft_sqrt(tetrinb * 4), structure[count2].a);
i = 0;
count2++;
count--;
}
ft_putab(ret.str);
return (0);
}
int main(int argc, char **argv)
{
if (argc > 1)
{
int nb;
int result;
printf("ce que j ai recu :[%s]\n", argv[1]);
nb = ft_atoi(argv[1]);
printf("a t il ete caste ? %d\n", nb);
result = ft_sqrt(nb);
printf("le carre du nombre (%d) est %d \n", nb, result);
}
return (0);
}
void init_square(t_square **sq, int tetri_nb)
{
int n;
int n_block;
n = 0;
n_block = tetri_nb * 4;
while (!n)
{
n = ft_sqrt(n_block);
n_block++;
}
(*sq)->x_max = n;
(*sq)->y_max = n;
}
int ft_save(char **ptr_map, char ptr_map_saved[16][16], char taille, char nb_figure)
{
unsigned int i;
unsigned int j;
int cpt;
i = 0;
j = 0;
cpt = 0;
ft_clean(ptr_map_saved, (int)taille);
ft_copy(ptr_map, ptr_map_saved, taille);
ft_free(ptr_map);
if (taille > ft_sqrt(nb_figure * 4))
return (nb_figure);
return (-1);
}
int ft_is_prime(int nb)
{
int i;
if (nb <= 3)
return (nb > 1);
if (!(nb % 2) || !(nb % 3))
return (0);
i = 5;
while (i < ft_sqrt(nb) + 1)
{
if (!(nb % i) || !(nb % (i + 2)))
return (0);
i += 6;
}
return (1);
}
char ft_taille_min(char tab[27])
{
int taille;
int i;
taille = ft_sqrt(4 * tab[0]);
i = 1;
while (tab[i] != 0)
{
if ((tab[i] == 1 || tab[i] == 19) && taille < 4)
taille = 4;
else if (tab[0] == 1 && tab[i] == 6)
return (2);
i++;
}
if (taille > 3)
return (taille);
return (3);
}
t_map *map_solve(t_map *map, t_trimino *tetriminos)
{
map->target = ft_sqrt(tetrimino_count(tetriminos) * SIZE) - 1;
while (recursive(map, tetriminos))
{
if (map->count < 0)
{
tetriminos = map->current;
map->count = 0;
}
else
{
while (tetriminos->prev)
tetriminos = tetriminos->prev;
map_reset_tetriminos(map, tetriminos);
map->target++;
}
}
return (map);
}
int ft_isprime(int nb)
{
int i;
int square;
i = 3;
square = ft_sqrt(nb) + 1;
if (nb % 2 == 0)
return (1);
else
{
while (i < square)
{
if (nb % i == 0)
return (1);
i++;
}
}
return (0);
}
int main(int ac, char **av)
{
int fd;
int size;
char *line;
t_tetris *tr;
size = 0;
tr = NULL;
if (ac != 2)
{
ft_putendl_fd("usage: ./fillit file", 1);
exit(EXIT_SUCCESS);
}
fd = open(av[1], O_RDONLY);
if (fd < 0)
exit_error();
line = read_file(fd);
check_all(line);
tr = get_all_tetri(line);
size = ft_sqrt(count_tetri(line) * 4);
solve(size, tr);
return (0);
}
int main(void)
{
printf("%d", ft_sqrt(100000000));
return (0);
}
