faster version, under 10s for 12

fillit/Makefile

@@ -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

fillit/includes/fillit.h

@@ -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);
+int		ft_solver(char **board, t_list *lttmn, int space, int size);
-void	ft_map_switch(t_list *list);
+int		ft_solved(char **board);
-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_check_ttmnfit(t_list **amap, int anchor, int pos[4][2], int size);
+int		ft_check_waste(char **board, t_list *lttmn, int space, int size);
-void	ft_stack_ttmn(t_list **amap, t_list **astack, int anchor, int pos[4][2], int size, char id);
+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

fillit/lib/libft

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

fillit/src/board_lib.c

@@ -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);
+}

fillit/src/fillit_blobs.c

@@ -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));
-}

fillit/src/fillit_check_waste.c

@@ -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));
+		return (ft_solver(board, lttmn->next, space, size));
-	space = 0;
+	space = size * size - 4 * g_ttmn;
 	i = -1;
-	map = *amap;
+	while (++i < size * size)
-	while (map)
 	{
-		stack = (t_stack *)map->content;
+		if (board[i / size][i % size] != '.')
-		map = map->next;
-		i = stack->num;
-		if (stack->id != '.')
 			continue ;
-		ft_lstiter(*amap, &ft_map_switch);
+		ft_board_replace(board, '*', '^');
-		blob_size = ft_flood_fill(map, size, i, '*');
+		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); */
-		/* } */
 		}
-	return (ft_solver(amap, astack, lttmn, space, size));
+		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);
+			}
+		}
+	}
+	ft_board_remove(board, '^');
+	ft_board_remove(board, '*');
+	return (ft_solver(board, lttmn, space, size));
 }

fillit/src/fillit_fit_blob.c

@@ -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;
+	i = y - 1;
-	while (blob)
+	while (++i < size * size)
 	{
-		stack = blob->content;
+		if (board[i / size][i % size] == '*')
-		/* ft_put_stack(stack); */
-		if (stack->id != '*')
 		{
-			/* ft_putendl("iwtbf"); */
+			n--;
-			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 */
+				if (ttmn->placed || ft_board_add(board, *ttmn, i, size))
-				/* || ft_stack_ttmn(amap, astack, i, ttmn->pos, ttmn->id, size)) */
+					continue ;
-				/* continue ; */
 				ttmn->placed = 1;
-			if (ft_solver(amap, astack, lttmn, space, size))
+				/* ft_board_print(board); */
+				if (ft_solver(board, lttmn, space, size))
 					return (1);
+				ft_board_replace(board, ttmn->id, '*');
 				ttmn->placed = 0;
 			}
 		}
-	/* ft_lst_print(*astack, &ft_put_stack); */
+		if (n < 4)
+			return (0);
+	}
 	return (0);
 }

fillit/src/fillit_solver.c

@@ -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_board_remove(board, '^');
-	ft_lst_sorted_merge(astack, *amap, &ft_stack_cmp_num2);
+	ft_board_remove(board, '*');
-	ft_lstiter(*astack, &ft_map_clean);
+	g_sol = ft_board_copy(board);
-	ft_stack_as_board(astack, size);
+	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));
+		return (ft_solver(board, lttmn->next, space, size));
-	map = *amap;
 
-	/* ft_lst_print(*amap, &ft_put_stack); */
+	/* ft_board_show(board); */
-	/* ft_lst_print(*astack, &ft_put_stack); */
+	i = -1;
-	/* ft_stack_as_board(astack, size); */
+	while (++i < size * size)
-	while (map)
 	{
-		i = ((t_stack *)map->content)->num;
+		if (ft_board_add(board, *ttmn, i, size))
-		map = map->next;
-		if (ft_check_ttmnfit(amap, i, ttmn->pos, size))
 			continue ;
-		ft_stack_ttmn(amap, astack, i, ttmn->pos, size, ttmn->id);
 
-		/* if (ft_check_waste(amap, astack, lttmn->next, space, size)) */
+		/* if (ft_solver(board, 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)) */
 		/* 	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);
 }

fillit/src/flood_fill.c

@@ -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 (board[i / size][i % size] == '.')
-	if (list)
 	{
-		id = ((t_stack *)list->content)->id;
+		board[i / size][i % size] = c;
-		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 < size - 1 ?  ft_flood_fill(board, 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(board, size, i - size, c) : 0;
-			n += i % size > 0 ? ft_flood_fill(map, size, i - 1, c) : 0;
+		n += i % size > 0 ? ft_flood_fill(board, size, i - 1, c) : 0;
-			n += i / size < size - 1 ? ft_flood_fill(map, size, i + size, c) : 0;
+		n += i / size < size - 1 ? ft_flood_fill(board, size, i + size, c) : 0;
-		}
 	}
 	/* printf("list at %i: ", i); */
 	/* fflush(stdout); */

fillit/src/legacy_board_lib.c

@@ -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); */
-/* } */

fillit/src/main.c

@@ -10,11 +10,10 @@ void	ft_usage(void)
 int		main(int ac, char **av)
 {
 	t_list	*lttmn;
-	t_list	*map;
+	char	**board;
-	t_list	*stack;
 	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);
+		board = ft_board_init(size);
-		stack = NULL;
 		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);

fillit/src/parser.c

@@ -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];

fillit/src/stack_lib.c

@@ -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);
-	}
-}

fillit/src/unstack_lib.c

@@ -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);
-}