diff --git a/fillit.h b/fillit.h index faf090b..15b7219 100644 --- a/fillit.h +++ b/fillit.h @@ -6,7 +6,7 @@ /* By: vmanzoni +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2019/03/01 13:34:46 by vmanzoni #+# #+# */ -/* Updated: 2019/05/17 18:37:47 by hulamy ### ########.fr */ +/* Updated: 2019/05/20 15:18:43 by hulamy ### ########.fr */ /* */ /* ************************************************************************** */ @@ -58,7 +58,7 @@ typedef struct s_fillist int num; int test; char letter; - uint64_t memory; + unsigned int *memory; struct s_fillist *same; struct s_fillist *next; } t_fillist; diff --git a/samples/map_hard b/samples/map_hard index 887429b..50fb7fa 100644 --- a/samples/map_hard +++ b/samples/map_hard @@ -47,3 +47,43 @@ .#.. ##.. .... + +.#.. +.#.. +##.. +.... + +...# +...# +..## +.... + +#... +###. +.... +.... + +.#.. +.#.. +##.. +.... + +.#.. +.#.. +##.. +.... + +...# +...# +..## +.... + +#... +###. +.... +.... + +.#.. +.#.. +##.. +.... diff --git a/search_map.c b/search_map.c index e211921..eb0cfba 100644 --- a/search_map.c +++ b/search_map.c @@ -6,7 +6,7 @@ /* By: hulamy +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2019/04/27 20:47:22 by hulamy #+# #+# */ -/* Updated: 2019/05/18 15:16:26 by hulamy ### ########.fr */ +/* Updated: 2019/05/20 15:41:59 by hulamy ### ########.fr */ /* */ /* ************************************************************************** */ @@ -49,6 +49,73 @@ ** } */ +/* +** function that try to optimize the speed +** SECOND ATTEMPT +** by finding the isolated dots whille fillling the map +** untill they get more numerous than the max amount available +** TOTAL FAILURE :p +** +** int check_others(unsigned int *map, t_fillist *list, int size, int num) +** { +** t_fillist *tmp; +** int dots; +** int total; +** int i; +** int j; +** +** dots = 0; +** i = -1; +** num *= 4; +** total = size * size; +** while (++i < total && dots <= total - num) +** { +** tmp = list->next; +** j = 1; +** // saute les position pas vides +** while (1 << (i % 32) & map[i % 32]) +** i++; +** // pour chaque position vide regarde si chaque tetri non encode places peuvent y rentrer +** while (j && tmp) +** { +** // si le tetri est trop a droite ou trop en bas il ne rentre pas ce n'est pas la peine de chercher donc on passe au tetri suivant +** if (tmp->width > (size - i % size) || (total - i) <= (tmp->height * size)) +** tmp = tmp->next; +** // sinon verifier si on peut le mettre a cette position et si on ne peut pas passer au tetri suivant +** else if (!fit_in_place(map, list, size, i)) +** tmp = tmp->next; +** // si le tetri peut rentrer on arrete la boucle en mettant j = 0 +** else +** j = 0; +** } +** // si j existe c que le tetri ne pouvait pas etre place donc on rajoute 1 au compteur de point isoles +** if (j) +** dots++; +** } +** return (dots > total - num); +** } +*/ + +/* +** function that try to optimize the speed +** FIRST ATTEMPT +** by verifying if the place left is enough to place at least +** one of each tetri left +** TOTAL FAILURE :p +** +** int check_others(unsigned int *map, t_fillist *list, int size, int num) +** { +** t_fillist *tmp; +** +** // verifie que les tetri restant puissent un par un se placer sur la map +** // ca n'optimise qu'en fin de map donc ca ralentit les grosses map en fait +** while ((tmp = tmp->next)) +** if (!find_place(map, tmp, size, 0)) +** return (0); +** return (1); +** } +*/ + /* ** function that look if a tretri fit in a place */ @@ -141,66 +208,26 @@ void add_remove(unsigned int *map, t_fillist *list, int size) ** Test optimisation for not testing wrong maps when tetri are identical */ -int compare_tetri(t_fillist *tetri_a, t_fillist *tetri_b) -{ - if (tetri_a->tetribit != tetri_b->tetribit) - return (0); - if (tetri_a->width != tetri_b->width) - return (0); - if (tetri_a->height != tetri_b->height) - return (0); - return (1); -} - -/* -** Test optimisation for not testing wrong maps when tetri are identical -*/ - -int check_same_tetri(t_fillist *list) -{ - t_fillist *curr_tetri; - t_fillist *next_tetri; - - curr_tetri = list; - - while (curr_tetri != NULL) - { - next_tetri = curr_tetri->next; - while (next_tetri != NULL) - { - if (compare_tetri(curr_tetri, next_tetri)) - { - if (next_tetri->same == NULL) - next_tetri->same = curr_tetri; - printf("%c->%c\n", next_tetri->letter, next_tetri->same->letter); - } - next_tetri = next_tetri->next; - } - curr_tetri = curr_tetri->next; - } - return (0); -} - -/* -** Test optimisation for not testing wrong maps when tetri are identical -*/ - int check_tetri_memory(t_fillist *list, int pos) { - t_fillist *tetri; - uint64_t mask; + t_fillist *tetri; + unsigned int mask; tetri = list; + mask = 1 << ((pos % 32) - 1); if (tetri->same != NULL) { - mask = 1 << (pos - 1); - print_bits(mask, 64); - if (tetri->same->memory & mask) + if (!(tetri->same->memory[pos / 32] & mask)) { - ft_putstr("test\n"); - return (pos + 1); + tetri->same->memory[pos / 32] |= mask; + return (1); } } + else + { + tetri->memory[pos / 32] |= mask; + return (1); + } return (0); } @@ -216,13 +243,61 @@ int fill_map(unsigned int *map, t_fillist *list, int size) while (find_place(map, list, size)) { add_remove(map, list, size); - if (fill_map(map, list->next, size)) - return (1); + if (check_tetri_memory(list, list->position)) + if (fill_map(map, list->next, size)) + return (1); add_remove(map, list, size); } return (0); } +/* +** Test optimisation for not testing wrong maps when tetri are identical +*/ + +int compare_tetri(t_fillist *tetri_a, t_fillist *tetri_b) +{ + if (tetri_a->tetribit != tetri_b->tetribit) + return (0); + if (tetri_a->width != tetri_b->width) + return (0); + if (tetri_a->height != tetri_b->height) + return (0); + return (1); +} + +/* +** Test optimisation for not testing wrong maps when tetri are identical +*/ + +int check_same_tetri(t_fillist *list, int num) +{ + t_fillist *curr_tetri; + t_fillist *next_tetri; + int i; + + curr_tetri = list; + while (curr_tetri != NULL) + { + curr_tetri->same = NULL; + i = 0; + if (!(curr_tetri->memory = (unsigned int *)malloc(sizeof(*curr_tetri->memory) * num))) + return (0); + while (i < num) + curr_tetri->memory[i++] = 0; + next_tetri = curr_tetri->next; + while (next_tetri != NULL) + { + if (compare_tetri(curr_tetri, next_tetri)) + if (next_tetri->same == NULL) + next_tetri->same = curr_tetri; + next_tetri = next_tetri->next; + } + curr_tetri = curr_tetri->next; + } + return (0); +} + /* ** function that send to "fill_map" a map of a certain size and increment its size untill it's solved */ @@ -262,6 +337,7 @@ int search_map(t_fillist *list) num = (size * size) / 32 + 1; if (!(map = (unsigned int *)malloc(sizeof(*map) * num))) return (0); + check_same_tetri(list, num); while (num) map[num--] = 0; i = fill_map(map, list, size++);