jack/42-archive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

faster version, under 10s for 12

Browse source
This commit is contained in:
Jack Halford 2016-09-14 22:42:10 +02:00
parent c4bf6b9e55
commit 105404cbed
14 changed files with 233 additions and 508 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
fillit/Makefile
View file

@ -17,7 +17,7 @@ F_LIB = ft
F_LIB := $(addprefix -l, $(F_LIB))
W_FLAGS = -Wall -Wextra -Werror
D_FLAGS = -g
D_FLAGS =
MKDIR = mkdir -p
RM = /bin/rm -rf

37
fillit/includes/fillit.h
View file

@ -22,33 +22,26 @@ typedef struct s_ttmn
int pos[4][2];
} t_ttmn;
t_list *ft_get_ttmn(char *filename);
t_list *ft_parse_ttmn(char *filename);
void ft_map_clean(t_list *list);
void ft_map_switch(t_list *list);
t_list *ft_stack_new_range(int a, int b);
void ft_map_stack_stars(t_list **amap, t_list **astack, char c);
void ft_put_stack(t_stack *content);
int ft_stack_cmp_num(t_stack *a, int *b);
int ft_stack_cmp_num2(t_stack *a, t_stack *b);
void ft_stack_as_board(t_list **stack, int size);
void ft_unstack_char(t_list **amap, t_list **astack, char c);
void ft_unstack_ttmn(t_list **amap, t_list **astack, char c);
int ft_solver(char **board, t_list *lttmn, int space, int size);
int ft_solved(char **board);
int ft_check_ttmnfit(t_list **amap, int anchor, int pos[4][2], int size);
void ft_stack_ttmn(t_list **amap, t_list **astack, int anchor, int pos[4][2], int size, char id);
int ft_check_waste(char **board, t_list *lttmn, int space, int size);
int ft_flood_fill(char **board, int size, int i, char c);
int ft_blobs(char **board, t_list *lttmn, int space, int size);
int ft_fit_blob(char **board, t_list *lttmn, int space, int size, int blob_size, int i);
int ft_check_waste(t_list **amap, t_list **astack, t_list *lttmn, int space, int size);
void ft_board_print(char **board);
char **ft_board_init(size_t size);
char **ft_board_copy(char **board);
void ft_board_fill(char **dst, char **src);
void ft_board_free(char ***board);
void ft_board_replace(char **board, char a, char b);
void ft_board_remove(char **board, char c);
int ft_board_add(char **board, t_ttmn ttmn, int i, int size);
void ft_show_ttmn(t_ttmn ttmn);
void ft_ttmn_reset(t_list *ttmn);
int ft_solver(t_list **amap, t_list **astack, t_list *lttmn, int space, int size);
int ft_solved(t_list **astack, t_list **amap, int size);
int ft_fit_blob(t_list **amap, t_list **astack, t_list *lttmn, int blob_size, int space, int size);
int ft_blobs(t_list **amap, t_list **astack, t_list *lttmn, int space, int size);
int ft_flood_fill(t_list *map, int size, int i, char c);
#endif

2
fillit/lib/libft

@ -1 +1 @@
Subproject commit b1f0ae385b169c0ca6bad6dd19b9610619e78413
Subproject commit 5ca17908609b5437724eb2072f56476fb0f211c2

136
fillit/src/board_lib.c Normal file
View file

@ -0,0 +1,136 @@
#include "fillit.h"
void ft_board_print(char **board)
{
/* ft_putendl("-s-"); */
while (*board)
ft_putendl(*board++);
ft_putendl("");
}
char **ft_board_init(size_t size)
{
char **board;
int i;
int j;
board = (char **)malloc(sizeof(char *) * (size + 1));
i = -1;
while (++i < (int)size)
{
board[i] = ft_strnew(size);
j = -1;
while (++j < (int)size)
board[i][j] = '.';
}
board[i] = NULL;
return (board);
}
char **ft_board_copy(char **board)
{
size_t size;
char **copy;
size = ft_strlen(*board);
copy = ft_board_init(size);
ft_board_fill(copy, board);
return (copy);
}
void ft_board_fill(char **dst, char **src)
{
int i;
int j;
i = 0;
while (src[i])
{
j = 0;
while (src[i][j])
{
dst[i][j] = src[i][j];
j++;
}
i++;
}
}
void ft_board_free(char ***board)
{
int i;
i = 0;
while ((*board)[i])
{
free((*board)[i]);
i++;
}
free(*board);
*board = NULL;
}
void ft_board_replace(char **board, char a, char b)
{
int i;
int j;
i = -1;
while (board[++i])
{
j = -1;
while (board[i][++j])
{
if (board[i][j] == a)
board[i][j] = b;
}
}
}
void ft_board_remove(char **board, char c)
{
int i;
int j;
i = -1;
while (board[++i])
{
j = -1;
while (board[i][++j])
{
if (board[i][j] == c)
board[i][j] = '.';
}
}
}
int ft_board_add(char **board, t_ttmn ttmn, int i, int size)
{
int x;
int y;
int k;
k = 0;
while (k < 4)
{
x = i % size + ttmn.pos[k][1];
y = i / size + ttmn.pos[k][0];
/* printf("adding %c to %i,%i\n", block.id, y, x); */
/* fflush(stdout); */
if (x > size - 1 || y > size - 1 || x < 0 || y < 0)
return (1);
if (board[y][x] != '.' && board[y][x] != '*')
return (1);
k++;
}
k = 0;
while (k < 4)
{
x = i % size + ttmn.pos[k][1];
y = i / size + ttmn.pos[k][0];
board[y][x] = ttmn.id;
/* ft_show_board(board); */
k++;
}
return (0);
}

74
fillit/src/fillit_blobs.c
View file

@ -1,74 +0,0 @@
#include "fillit.h"
int ft_blobs(t_list **amap, t_list **astack, t_list *lttmn, int space, int size)
{
t_list *map;
/* static int id = 0;; */
int sup_space = 0;
int blob_size;
int i;
if (!lttmn)
return (ft_solved(amap, astack, size));
map = *amap;
ft_lstiter(*amap, &ft_map_clean);
while (map)
{
i = ((t_stack *)map->content)->num;
ft_lstiter(*amap, &ft_map_switch);
blob_size = ft_flood_fill(map, size, i, '*');
map = map->next;
if (blob_size == 0)
continue ;
/* printf("found blob_size=%i\n", blob_size); */
/* fflush(stdout); */
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
/* fflush(stdout); */
if (blob_size / 4 == 0)
{
space -= blob_size % 4;
if (space + sup_space < 0)
return (0);
/* ft_putendl("stacking stars:"); */
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
ft_map_stack_stars(amap, astack, '.');
map = *amap;
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
}
else if (blob_size / 4 == 1)
{
space -= blob_size % 4;
if (space + sup_space < 0)
return (0);
/* ft_putendl("stacking stars:"); */
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
ft_map_stack_stars(amap, astack, '*');
map = *amap;
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
if (ft_fit_blob(amap, astack, lttmn, blob_size, space, size))
return (1);
else
{
space -= 4;
if (space + sup_space < 0)
return (0);
}
}
else
{
sup_space -= blob_size % 4;
if (space + sup_space < 0)
return (0);
}
}
return (ft_solver(amap, astack, lttmn, space, size));
}

55
fillit/src/fillit_check_waste.c
View file

@ -1,43 +1,46 @@
#include "fillit.h"
int ft_check_waste(t_list **amap, t_list **astack, t_list *lttmn, int space, int size)
int ft_check_waste(char **board, t_list *lttmn, int space, int size)
{
t_stack *stack;
t_ttmn *ttmn;
t_list *map;
int i;
int blob_size;
if (!lttmn)
return (ft_solved(amap, astack, size));
return (ft_solved(board));
ttmn = (t_ttmn *)lttmn->content;
if (ttmn->placed)
return (ft_solver(amap, astack, lttmn->next, space, size));
space = 0;
return (ft_solver(board, lttmn->next, space, size));
space = size * size - 4 * g_ttmn;
i = -1;
map = *amap;
while (map)
while (++i < size * size)
{
stack = (t_stack *)map->content;
map = map->next;
i = stack->num;
if (stack->id != '.')
if (board[i / size][i % size] != '.')
continue ;
ft_lstiter(*amap, &ft_map_switch);
blob_size = ft_flood_fill(map, size, i, '*');
ft_board_replace(board, '*', '^');
blob_size = ft_flood_fill(board, size, i, '*');
space -= blob_size % 4;
if (space > size * size - 4 * g_ttmn)
if (space < 0)
{
ft_board_remove(board, '^');
ft_board_remove(board, '*');
return (0);
/* if (blob_size / 4 == 1) */
/* { */
/* ft_board_remove(board, '*'); */
/* blob = ft_empty_here(board, size, i); */
/* if (ft_fit_blob2(board, amap, lttmn, i, blob_size, space)) */
/* return (1); */
/* space -= 4; */
/* if (space > size * size - 4 * g_ttmn) */
/* return (0); */
/* } */
}
if (blob_size / 4 == 1)
{
if (ft_fit_blob(board, lttmn, space, size, blob_size, i))
return (1);
space -= 4;
if (space < 0)
{
ft_board_remove(board, '^');
ft_board_remove(board, '*');
return (0);
}
}
}
return (ft_solver(amap, astack, lttmn, space, size));
ft_board_remove(board, '^');
ft_board_remove(board, '*');
return (ft_solver(board, lttmn, space, size));
}

52
fillit/src/fillit_fit_blob.c
View file

@ -1,44 +1,36 @@
#include "fillit.h"
int ft_fit_blob(t_list **amap, t_list **astack, t_list *lttmn, int blob_size, int space, int size)
int ft_fit_blob(char **board, t_list *lttmn, int space, int size, int blob_size, int y)
{
t_ttmn *ttmn;
t_list *list;
t_list *blob;
t_stack *stack;
int n;
int i;
int n;
n = blob_size;
blob = *astack;
while (blob)
i = y - 1;
while (++i < size * size)
{
stack = blob->content;
/* ft_put_stack(stack); */
if (stack->id != '*')
if (board[i / size][i % size] == '*')
{
/* ft_putendl("iwtbf"); */
break ;
}
stack->id = '.';
/* ft_lst_print(*astack, &ft_put_stack); */
/* ft_put_stack(stack); */
blob = blob->next;
i = stack->num;
list = lttmn;
while (list)
{
ttmn = (t_ttmn *)list->content;
list = list->next;
/* if (ttmn->placed */
/* || ft_stack_ttmn(amap, astack, i, ttmn->pos, ttmn->id, size)) */
/* continue ; */
ttmn->placed = 1;
if (ft_solver(amap, astack, lttmn, space, size))
return (1);
ttmn->placed = 0;
n--;
list = lttmn;
while (list)
{
ttmn = (t_ttmn *)list->content;
list = list->next;
if (ttmn->placed || ft_board_add(board, *ttmn, i, size))
continue ;
ttmn->placed = 1;
/* ft_board_print(board); */
if (ft_solver(board, lttmn, space, size))
return (1);
ft_board_replace(board, ttmn->id, '*');
ttmn->placed = 0;
}
}
if (n < 4)
return (0);
}
/* ft_lst_print(*astack, &ft_put_stack); */
return (0);
}

40
fillit/src/fillit_solver.c
View file

@ -1,48 +1,40 @@
#include "fillit.h"
int ft_solved(t_list **amap, t_list **astack, int size)
int ft_solved(char **board)
{
ft_putendl("found solution:");
ft_lst_sort(astack, &ft_stack_cmp_num2);
ft_lst_sorted_merge(astack, *amap, &ft_stack_cmp_num2);
ft_lstiter(*astack, &ft_map_clean);
ft_stack_as_board(astack, size);
ft_board_remove(board, '^');
ft_board_remove(board, '*');
g_sol = ft_board_copy(board);
ft_board_print(board);
return (1);
}
int ft_solver(t_list **amap, t_list **astack, t_list *lttmn, int space, int size)
int ft_solver(char **board, t_list *lttmn, int space, int size)
{
int i;
t_ttmn *ttmn;
t_list *map;
if (!lttmn)
return (ft_solved(amap, astack, size));
return (ft_solved(board));
ttmn = (t_ttmn *)lttmn->content;
if (ttmn->placed)
return (ft_solver(amap, astack, lttmn->next, space, size));
map = *amap;
return (ft_solver(board, lttmn->next, space, size));
/* ft_lst_print(*amap, &ft_put_stack); */
/* ft_lst_print(*astack, &ft_put_stack); */
/* ft_stack_as_board(astack, size); */
while (map)
/* ft_board_show(board); */
i = -1;
while (++i < size * size)
{
i = ((t_stack *)map->content)->num;
map = map->next;
if (ft_check_ttmnfit(amap, i, ttmn->pos, size))
if (ft_board_add(board, *ttmn, i, size))
continue ;
ft_stack_ttmn(amap, astack, i, ttmn->pos, size, ttmn->id);
/* if (ft_check_waste(amap, astack, lttmn->next, space, size)) */
/* return (1); */
/* if (ft_blobs(amap, astack, lttmn->next, space, size)) */
/* return (1); */
/* if (ft_solver(amap, astack, lttmn->next, space, size)) */
/* if (ft_solver(board, lttmn->next, space, size)) */
/* return (1); */
if (ft_check_waste(board, lttmn->next, space, size))
return (1);
ft_unstack_ttmn(amap, astack, ttmn->id);
ft_board_remove(board, ttmn->id);
}
return (0);
}

23
fillit/src/flood_fill.c
View file

@ -1,25 +1,18 @@
#include "fillit.h"
int ft_flood_fill(t_list *map, int size, int i, char c)
int ft_flood_fill(char **board, int size, int i, char c)
{
int n;
char id;
t_list *list;
n = 0;
list = ft_lst_find(map, &i, &ft_stack_cmp_num);
if (list)
if (board[i / size][i % size] == '.')
{
id = ((t_stack *)list->content)->id;
if (id != c)
{
((t_stack *)list->content)->id = c;
n++;
n += i % size < size - 1 ? ft_flood_fill(map, size, i + 1, c) : 0;
n += i / size > 0 ? ft_flood_fill(map, size, i - size, c) : 0;
n += i % size > 0 ? ft_flood_fill(map, size, i - 1, c) : 0;
n += i / size < size - 1 ? ft_flood_fill(map, size, i + size, c) : 0;
}
board[i / size][i % size] = c;
n++;
n += i % size < size - 1 ? ft_flood_fill(board, size, i + 1, c) : 0;
n += i / size > 0 ? ft_flood_fill(board, size, i - size, c) : 0;
n += i % size > 0 ? ft_flood_fill(board, size, i - 1, c) : 0;
n += i / size < size - 1 ? ft_flood_fill(board, size, i + size, c) : 0;
}
/* printf("list at %i: ", i); */
/* fflush(stdout); */

138
fillit/src/legacy_board_lib.c
View file

@ -1,138 +0,0 @@
/* #include "fillit.h" */
/* void ft_show_board(char **board) */
/* { */
/* /1* ft_putendl("-s-"); *1/ */
/* while (*board) */
/* ft_putendl(*board++); */
/* ft_putendl(""); */
/* } */
/* char **ft_empty_board(size_t size) */
/* { */
/* char **board; */
/* int i; */
/* int j; */
/* board = (char **)malloc(sizeof(char *) * (size + 1)); */
/* i = -1; */
/* while (++i < (int)size) */
/* { */
/* board[i] = ft_strnew(size); */
/* j = -1; */
/* while (++j < (int)size) */
/* board[i][j] = '.'; */
/* } */
/* board[i] = NULL; */
/* return (board); */
/* } */
/* char **ft_copy_board(char **board) */
/* { */
/* size_t size; */
/* char **copy; */
/* size = ft_strlen(*board); */
/* copy = ft_empty_board(size); */
/* ft_fill_board(copy, board); */
/* return (copy); */
/* } */
/* void ft_fill_board(char **dst, char **src) */
/* { */
/* int i; */
/* int j; */
/* i = 0; */
/* while (src[i]) */
/* { */
/* j = 0; */
/* while (src[i][j]) */
/* { */
/* dst[i][j] = src[i][j]; */
/* j++; */
/* } */
/* i++; */
/* } */
/* } */
/* void ft_free_board(char ***board) */
/* { */
/* int i; */
/* i = 0; */
/* while ((*board)[i]) */
/* { */
/* free((*board)[i]); */
/* i++; */
/* } */
/* free(*board); */
/* *board = NULL; */
/* } */
/* void ft_board_replace(char **board, char a, char b) */
/* { */
/* int i; */
/* int j; */
/* i = -1; */
/* while (board[++i]) */
/* { */
/* j = -1; */
/* while (board[i][++j]) */
/* { */
/* if (board[i][j] == a) */
/* board[i][j] = b; */
/* } */
/* } */
/* } */
/* void ft_board_remove(char **board, char c) */
/* { */
/* int i; */
/* int j; */
/* i = -1; */
/* while (board[++i]) */
/* { */
/* j = -1; */
/* while (board[i][++j]) */
/* { */
/* if (board[i][j] == c) */
/* board[i][j] = '.'; */
/* } */
/* } */
/* } */
/* int ft_board_add(char **board, t_ttmn block, int i) */
/* { */
/* int x; */
/* int y; */
/* int k; */
/* int size; */
/* size = ft_strlen(*board); */
/* k = 0; */
/* while (k < 4) */
/* { */
/* x = i % size + block.pos[k][1]; */
/* y = i / size + block.pos[k][0]; */
/* /1* printf("adding %c to %i,%i\n", block.id, y, x); *1/ */
/* /1* fflush(stdout); *1/ */
/* if (x > size - 1 || y > size - 1 || x < 0 || y < 0) */
/* return (1); */
/* if (board[y][x] != '.' && board[y][x] != '*') */
/* return (1); */
/* k++; */
/* } */
/* k = 0; */
/* while (k < 4) */
/* { */
/* x = i % size + block.pos[k][1]; */
/* y = i / size + block.pos[k][0]; */
/* board[y][x] = block.id; */
/* /1* ft_show_board(board); *1/ */
/* k++; */
/* } */
/* return (0); */
/* } */

10
fillit/src/main.c
View file

@ -10,11 +10,10 @@ void ft_usage(void)
int main(int ac, char **av)
{
t_list *lttmn;
t_list *map;
t_list *stack;
char **board;
int size;
if (ac != 2 || !(lttmn = ft_get_ttmn(av[1])))
if (ac != 2 || !(lttmn = ft_parse_ttmn(av[1])))
{
ft_usage();
return (1);
@ -22,10 +21,9 @@ int main(int ac, char **av)
size = g_target + 2;
while (size >= g_target)
{
map = ft_stack_new_range(0, size * size);
stack = NULL;
board = ft_board_init(size);
ft_lstiter(lttmn, &ft_ttmn_reset);
ft_solver(&map, &stack, lttmn, size * size - 4 * g_ttmn, size);
ft_solver(board, lttmn, size * size - 4 * g_ttmn, size);
size--;
}
return (0);

2
fillit/src/parser.c
View file

@ -32,7 +32,7 @@ int ft_validate_ttmn(t_ttmn ttmn)
return (0);
}
t_list *ft_get_ttmn(char *filename)
t_list *ft_parse_ttmn(char *filename)
{
int fd;
char buf[BUF_SIZE + 1];

143
fillit/src/stack_lib.c
View file

@ -1,143 +0,0 @@
#include "fillit.h"
void ft_put_stack_id(t_list *list)
{
t_stack *stack;
stack = list->content;
ft_putchar(stack->id);
}
void ft_stack_as_board(t_list **astack, int size)
{
int i;
t_list *list;
list = *astack;
i = 1;
while (list)
{
ft_put_stack_id(list);
list = list->next;
if (i++ % size == 0)
ft_putendl("");
}
}
void ft_put_stack(t_stack *content)
{
ft_putnbr(content->num);
ft_putchar(',');
ft_putchar(content->id);
}
t_list *ft_stack_new_range(int a, int b)
{
t_list *lst;
t_stack stack;
if (a >= b)
return (NULL);
lst = NULL;
while (a < b)
{
b--;
stack.num = b;
stack.id = '.';
ft_lstadd(&lst, ft_lstnew(&stack, sizeof(t_stack)));
}
return (lst);
}
int ft_stack_cmp_num(t_stack *a, int *b)
{
return (a->num - *b);
}
int ft_stack_cmp_num2(t_stack *a, t_stack *b)
{
return (a->num - b->num);
}
int ft_stack_cmp_id(t_stack *a, char *b)
{
char id;
id = a->id;
/* printf("id:%c, ref:%c, cmp:%i\n", id, *b, strncmp(&id, b, 1)); */
/* fflush(stdout); */
return (strncmp(&id, b, 1));
}
void ft_map_clean(t_list *list)
{
t_stack *stack;
stack = (t_stack *)list->content;
if (stack->id == '^')
stack->id = '.';
}
void ft_map_switch(t_list *list)
{
t_stack *stack;
stack = (t_stack *)list->content;
if (stack->id == '*')
stack->id = '^';
}
void ft_map_stack_stars(t_list **amap, t_list **astack, char c)
{
t_list *link;
t_stack *content;
char star;
star = '*';
while ((link = ft_lst_removeif(amap, &star, &ft_stack_cmp_id)))
{
content = (t_stack *)link->content;
content->id = c;
ft_lstadd(astack, link);
}
}
int ft_check_ttmnfit(t_list **amap, int anchor, int pos[4][2], int size)
{
int i;
int j;
int x;
int y;
i = -1;
while (++i < 4)
{
x = anchor % size + pos[i][1];
y = anchor / size + pos[i][0];
j = anchor + size * pos[i][0] + pos[i][1];
if (x > size - 1 || y > size - 1 || x < 0 || y < 0)
return (1);
if (!ft_lst_find(*amap, &j, &ft_stack_cmp_num))
return (1);
}
return (0);
}
void ft_stack_ttmn(t_list **amap, t_list **astack, int anchor, int pos[4][2], int size, char id)
{
int i;
int j;
t_stack *stack;
t_list *link;
i = -1;
while (++i < 4)
{
j = anchor + size * pos[i][0] + pos[i][1];
link = ft_lst_removeif(amap, &j, &ft_stack_cmp_num);
stack = (t_stack *)link->content;
stack->id = id;
ft_lstadd(astack, link);
}
}

27
fillit/src/unstack_lib.c
View file

@ -1,27 +0,0 @@
#include "fillit.h"
void ft_unstack_char(t_list **amap, t_list **astack, char c)
{
t_list *link;
t_stack *stack;
link = *astack;
stack = link->content;
while (stack->id == c)
{
stack->id = '.';
*astack = (*astack)->next;
ft_lst_sorted_insert(amap, link, &ft_stack_cmp_num2);
link = *astack;
if (!link)
break ;
stack = link->content;
}
}
void ft_unstack_ttmn(t_list **amap, t_list **astack, char c)
{
ft_unstack_char(amap, astack, '.');
ft_unstack_char(amap, astack, c);
}