42/42_old_fillit
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

catastrophe merge

Browse Source
This commit is contained in:
Hugo LAMY
2019-06-01 16:00:49 +02:00
parent c81b7515be 5bdc944da9
commit d7dc746779
8 changed files with 839 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

100
f_bonus_opti.c Normal file
View File

@@ -0,0 +1,100 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* bonus.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/05/24 14:42:46 by hulamy #+# #+# */
/* Updated: 2019/06/01 14:11:32 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** Test optimisation for not testing wrong maps when tetri are identical
*/
int check_tetri_memory(t_fillist *list, int pos)
{
t_fillist *tetri;
unsigned int mask;
tetri = list;
mask = 1 << ((pos % 32) - 1);
if (tetri->same)
{
if (!(tetri->same->memory[pos / 32] & mask))
return (tetri->same->memory[pos / 32] |= mask);
}
else
{
if (!(tetri->memory[pos / 32] & mask))
return (tetri->memory[pos / 32] |= mask);
}
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);
}
/*
** Function that free the list->memory each time it's malloc
*/
t_fillist *clean_list_memory(t_fillist *list, t_fillist *tmp)
{
while (tmp)
{
if (tmp->memory)
free(tmp->memory);
tmp = tmp->next;
}
return (list);
}
/*
** 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 = clean_list_memory(list, list);
while (curr_tetri != 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->total_num = num;
curr_tetri = curr_tetri->next;
}
return (0);
}

78
f_bonus_print.c Normal file
View File

@@ -0,0 +1,78 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* f_bonus_print.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/05/27 13:46:29 by hulamy #+# #+# */
/* Updated: 2019/06/01 15:00:01 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** function that print the given tetris if flag p is present
*/
t_fillist *print_tetri(t_fillist *list)
{
unsigned int print;
t_fillist *tmp;
tmp = list;
if (list->dope[2])
{
while (tmp)
{
check_same_tetri(list, 1);
print = tmp->tetribit;
print <<= 16;
print_sized_map(&print, tmp->width, tmp->height, tmp->letter);
if (tmp->same && list->dope[1])
{
print = tmp->same->tetribit;
print <<= 16;
ft_putstr("same --> ");
ft_put_tetri_color(tmp->same->letter);
ft_putchar('\n');
}
ft_putchar('\n');
tmp = tmp->next;
}
}
return (list);
}
/*
** function that print the map in binary if flag p is present
** it returns anyway the size of the map for main to print it
*/
int print_binary_map(unsigned int *map, int size, int *dope)
{
size--;
if (dope[2])
{
ft_putendl("result in binary :");
print_sized_map(map, size, size, '#');
ft_putchar('\n');
}
free(map);
return (size);
}
/*
** function that print the flags usage
*/
int print_flags_usage(void)
{
ft_putendl("flags usage :");
ft_putendl("d : debug print (print the map during the backtracking)");
ft_putendl("o : optimisation ultra fast but with some errors still");
ft_putendl("p : print the tetri and the map in different formats");
ft_putendl("e : error msgs more precise AND no error for too much tetri\n");
return (0);
}

136
f_handle_errors.c Normal file
View File

@@ -0,0 +1,136 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* f_handle_errors.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: vmanzoni <vmanzoni@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/01 13:29:05 by vmanzoni #+# #+# */
/* Updated: 2019/06/01 14:49:01 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** Function that display error message *s on fd and exit program
*/
void print_error(char *str)
{
write(1, str, ft_strlen(str));
exit(0);
}
/*
** Function that display error message *s on fd with more informations
*/
void print_error_extended(int error, int *dope)
{
if (!dope[3])
print_error("error\n");
if (error == 1)
print_error("error: File contains char other than '.','#' and '\\n'\n");
if (error == 2)
print_error("error: File contains two tetriminos not"
"separated by a '\\n'\n");
if (error == 3)
print_error("error: File contains more than 2 '\\n' in a row\n");
if (error == 4)
print_error("error: File contains less than 1 tetrimino\n");
if (error == 5)
print_error("error: File contains more than 26 tetriminos\n");
if (error == 6)
print_error("error: Tetrimino has more or less than 4 #\n");
if (error == 7)
print_error("error: Tetrimino # are not all connected\n");
print_error("error\n");
}
/*
** Function to see if there if an error if the file
** - less than 4 lines
** - more than 104 (26 tetri) + 25 (\n) = 129 lines
** - two \n in a row
*/
void check_file_errors(char *file, int *dope)
{
int i;
int line_nbr;
i = 0;
line_nbr = 0;
while (file[i])
{
if (file[i] != '.' && file[i] != '#' && file[i] != '\n')
print_error_extended(1, dope);
else if (file[i] == '\n')
line_nbr++;
if (file[i] == '\n' && line_nbr % 5 == 0 && file[i - 1] != '\n')
print_error_extended(2, dope);
if (file[i] == '\n' && file[i + 1] != '\0' && \
file[i + 2] != '.' && file[i + 2] != '#')
print_error_extended(3, dope);
i++;
}
if (line_nbr < 4)
print_error_extended(4, dope);
if (!dope[3] && line_nbr > 129)
print_error_extended(5, dope);
}
/*
** Function that check if tetrimino square contains:
** - 4 x #
** - 12 x .
*/
int check_tetri_errors(char *tetri)
{
int i;
int htg;
int dot;
i = 0;
htg = 0;
dot = 0;
while (tetri[i])
{
if (tetri[i] == '#')
htg++;
else if (tetri[i] == '.')
dot++;
i++;
}
if (htg != 4 || dot != 12 || check_tetri_errors_proxy(tetri))
return (6 + check_tetri_errors_proxy(tetri));
return (0);
}
/*
** Function that check if 4 # (tetrimino parts) are linked
*/
int check_tetri_errors_proxy(char *tetri)
{
int i;
int j;
i = 0;
j = 0;
while (tetri[i])
{
if (i < 19 && tetri[i] == '#' && tetri[i + 1] == '#')
j++;
if (i > 0 && tetri[i] == '#' && tetri[i - 1] == '#')
j++;
if (i < 15 && tetri[i] == '#' && tetri[i + 5] == '#')
j++;
if (i > 4 && tetri[i] == '#' && tetri[i - 5] == '#')
j++;
i++;
}
return ((j < 6) ? 1 : 0);
}

51
f_print_map_with_colors.c Normal file
View File

@@ -0,0 +1,51 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print_map_with_colors.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: vmanzoni <vmanzoni@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/05/03 20:27:22 by vmanzoni #+# #+# */
/* Updated: 2019/06/01 14:27:30 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
void ft_putchar_color(char c, char color)
{
if (color == 'R')
write(1, RED, 5);
else if (color == 'B')
write(1, BLU, 5);
else if (color == 'G')
write(1, GRN, 5);
else if (color == 'Y')
write(1, YEL, 5);
else if (color == 'M')
write(1, MAG, 5);
else if (color == 'C')
write(1, CYN, 5);
else if (color == 'W' || !c)
write(1, RESET, 5);
ft_putchar(c);
write(1, RESET, 5);
}
void ft_put_tetri_color(char c)
{
if (c == 'A' || c == 'G' || c == 'M' || c == 'S' || c == 'Y')
ft_putchar_color(c, 'R');
else if (c == 'B' || c == 'H' || c == 'N' || c == 'T' || c == 'Z')
ft_putchar_color(c, 'B');
else if (c == 'C' || c == 'I' || c == 'O' || c == 'U')
ft_putchar_color(c, 'G');
else if (c == 'D' || c == 'J' || c == 'P' || c == 'V')
ft_putchar_color(c, 'Y');
else if (c == 'E' || c == 'K' || c == 'Q' || c == 'W')
ft_putchar_color(c, 'M');
else if (c == 'F' || c == 'L' || c == 'R' || c == 'X')
ft_putchar_color(c, 'C');
else
ft_putchar(c);
}

50
f_read_file.c Normal file
View File

@@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* read_file.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: vmanzoni <vmanzoni@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/13 12:09:46 by vmanzoni #+# #+# */
/* Updated: 2019/06/01 15:12:03 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** Function that read and return a ptr to file content
*/
char *read_file(char *file)
{
char buf[BUFF_SIZE];
int fd;
int rv;
int i;
char *result;
if (((fd = open(file, O_RDONLY)) < 0) \
|| ((rv = read(fd, &buf, BUFF_SIZE)) < 0) \
|| !(result = malloc(sizeof(char) * rv)))
return (NULL);
buf[rv - 1] = '\0';
i = -1;
while (buf[++i])
result[i] = buf[i];
result[i] = '\0';
close(fd);
return (result);
}
/*
** Function that init num and size for search_map
*/
void init_num_and_size(int num, int *size, t_fillist *tmp)
{
while ((tmp = tmp->next))
num++;
while (*size * *size < num * 4)
(*size)++;
}

167
f_search_map.c Normal file
View File

@@ -0,0 +1,167 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* f_search_map.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: hulamy <hulamy@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/27 20:47:22 by hulamy #+# #+# */
/* Updated: 2019/06/01 15:12:08 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** function that look if a tretri fit in a place
*/
unsigned int fit_in_place(unsigned int *map, t_fillist *lst, int sze, int i)
{
unsigned int tmp;
unsigned int mask;
unsigned int tetri;
int n;
int r;
n = lst->num;
r = lst->rank;
i = lst->height;
tetri = lst->tetribit << 16 >> lst->width;
tmp = 0;
mask = ~0u << (32 - lst->width);
while (i--)
{
if (tmp & tetri)
return (0);
if (r >= 32 && ++n)
r -= 32;
tmp = (mask & (map[n] << r));
if (n + 1 < lst->total_num)
tmp |= (mask & (map[n + 1] >> (32 - r)));
tetri <<= lst->width;
r += sze;
}
return (!(tmp & tetri));
}
/*
** function that look for the first place in the map for a tetri
*/
int find_place(unsigned int *map, t_fillist *list, int size)
{
int limit;
int pos;
pos = list->position;
list->place = pos % size;
list->rank = pos % 32;
list->num = pos / 32;
limit = (size - list->height + 1) * size;
while (pos < limit)
{
if (list->rank >= 32 && ++list->num)
list->rank -= 32;
if (list->place > size - list->width)
{
list->place = -1;
pos += list->width - 2;
list->rank += list->width - 2;
}
else if (fit_in_place(map, list, size, 0))
return ((list->position = pos + 1));
pos++;
list->place++;
list->rank++;
}
return (0);
}
/*
** function that add or remove a tetri on the map
*/
void add_remove(unsigned int *map, t_fillist *list, int size)
{
unsigned int msk;
unsigned short tetri;
int i;
int j;
tetri = list->tetribit;
msk = ~0u << (32 - list->width);
i = (list->height - 1) * list->width;
j = (list->height - 1) * size + list->position;
while (j >= list->position)
{
map[(j - 1) / 32] ^= (msk & tetri << (16 + i)) >> (j - 1);
if ((j - 1) / 32 + 1 < list->total_num)
map[(j - 1) / 32 + 1] ^= (msk & tetri << (16 + i)) << (32 - j) << 1;
j -= size;
i -= list->width;
}
}
/*
** Function that recursively try to fill the map with the tetris
*/
int fill_map(unsigned int *map, t_fillist *list, int size)
{
if (!list)
return (1);
list->position = 0;
while (find_place(map, list, size))
{
add_remove(map, list, size);
list->test = 1;
if (list->dope[0])
{
print_letter_map(list->start, size, 1);
ft_putchar('\n');
}
if (list->dope[1])
if (check_tetri_memory(list, list->position))
if (fill_map(map, list->next, size))
return (1);
if (!list->dope[1])
if (fill_map(map, list->next, size))
return (1);
add_remove(map, list, size);
list->test = 0;
}
return (0);
}
/*
** Function that send to "fill_map" a map of a certain size
** and increment its size untill it's solved
*/
int search_map(t_fillist *list)
{
t_fillist *tmp;
unsigned int *map;
int size;
int num;
int i;
size = 2;
tmp = print_tetri(list);
init_num_and_size(1, &size, tmp);
i = 0;
while (!i)
{
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++);
if (!i)
free(map);
}
return (print_binary_map(map, size, list->dope));
}

143
fillit.h Normal file
View File

@@ -0,0 +1,143 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* fillit.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: vmanzoni <vmanzoni@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/01 13:34:46 by vmanzoni #+# #+# */
/* Updated: 2019/06/01 15:12:00 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FILLIT_H
# define FILLIT_H
# include <stdlib.h>
# include <unistd.h>
# include <fcntl.h>
# include <stdbool.h>
# include "libft/includes/libft.h"
/*
** DEFINE
*/
# define BUFF_SIZE 1024
# define RED "\x1B[31m"
# define GRN "\x1B[32m"
# define YEL "\x1B[33m"
# define BLU "\x1B[34m"
# define MAG "\x1B[35m"
# define CYN "\x1B[36m"
# define RESET "\x1B[0m"
/*
** STRUCTURE
** tetribit : tetri ecrit en binaire dans un short de 16 bits
** width : largeur du tetri
** height : hauteur du tetri
** position : memorise la position d tetri bit a bit
** place : position sur l'axe des abscisses de la map (position % size)
** rank : position de 1 a 32 dans l'int du tableau d'int (position % 32)
** num : memorise dans quel int du tableau on se trouve (position / 32)
** test :
** letter : letter of the tetrimino for printing final map
** dope : flags for details, optimisation, printing and error
** memory : positions already tested by a tetrimino in bitwise
** same : pointer to previous identical tetrimino
** next : pointer to next tetrimino
** start : pointer to first tetrimino of input file
*/
typedef struct s_fillist
{
unsigned short tetribit;
int width;
int height;
int position;
int place;
int rank;
int num;
int total_num;
int test;
char letter;
int *dope;
unsigned int *memory;
struct s_fillist *same;
struct s_fillist *next;
struct s_fillist *start;
} t_fillist;
/*
** bonus_opti.c
*/
int check_tetri_memory(t_fillist *list, int pos);
int compare_tetri(t_fillist *tetri_a, t_fillist *tetri_b);
t_fillist *clean_list_memory(t_fillist *list, t_fillist *tmp);
int check_same_tetri(t_fillist *list, int num);
/*
** bonus_print.c
*/
t_fillist *print_tetri(t_fillist *list);
int print_binary_map(unsigned int *map, int size, int *dope);
int print_flags_usage(void);
/*
** main.c
*/
int *create_dope(char *av, int mdp);
int is_mdp(int ac, char **av);
void clean_list(t_fillist *list, t_fillist *tmp);
int main(int argc, char **argv);
/*
** read_file.c
*/
char *read_file(char *file);
void init_num_and_size(int num, int *size, t_fillist *tmp);
/*
** handle_errors.c
*/
void print_error(char *s);
void print_error_extended(int error, int *dope);
void check_file_errors(char *file, int *dope);
int check_tetri_errors(char *tetri);
int check_tetri_errors_proxy(char *tetri);
/*
** parse_input.c
*/
unsigned short tab_to_bin(char line[]);
unsigned short reduce_tetri(unsigned short tetri, int width);
void fill_list(char line[], t_fillist *list);
int add_to_list(char *sqr, t_fillist **lst, char lett, int *dope);
int parse_input(char *input, t_fillist **list, int *dope);
/*
** search_map.c
*/
unsigned int fit_in_place(unsigned int *map, t_fillist *lst, int siz, int i);
int find_place(unsigned int *map, t_fillist *list, int size);
void add_remove(unsigned int *map, t_fillist *list, int size);
int fill_map(unsigned int *map, t_fillist *list, int size);
int search_map(t_fillist *list);
/*
** print.c
*/
void print_sized_map(unsigned int *tab, int wdth, int hgt, char ltr);
char *init_print_map(t_fillist *list, int size);
void print_letter_map(t_fillist *list, int size, int flag);
void print_final_map(t_fillist *list, int size);
/*
** print_map_with_colors.c
*/
void ft_putchar_color(char c, char color);
void ft_put_tetri_color(char c);
#endif

114
main.c Normal file
View File

@@ -0,0 +1,114 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: vmanzoni <vmanzoni@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/12 13:20:48 by vmanzoni #+# #+# */
/* Updated: 2019/06/01 14:40:58 by hulamy ### ########.fr */
/* */
/* ************************************************************************** */
#include "fillit.h"
/*
** Function that put the flags for bonus into a tab of int
**
** d : debug print (print the map during the backtracking)
** o : optimisation ultra fast but with some errors still
** p : print extended (print the tetri and the map in different formats)
** e : error extended (message more precise AND no error if too much tetri)
*/
int *create_dope(char *av, int mdp)
{
char *comp;
int *dope;
int i;
int j;
comp = "dope";
if (!(dope = (int*)malloc(sizeof(*dope) * 4)))
return (NULL);
i = 0;
while (i < 4)
dope[i++] = 0;
if (!mdp)
return (dope);
i = -1;
while (++i < 4 && (j = -1))
while (av[++j])
if (comp[i] == av[j])
dope[i] = 1;
return (dope);
}
/*
** Function that check if the password is good to unlock the flags
*/
int is_mdp(int ac, char **av)
{
char *mdp;
int i;
if (ac < 3 || ac > 4)
return (0);
mdp = "trompette";
i = 0;
while (av[2][i] && mdp[i] && mdp[i] == av[2][i])
i++;
if (av[2][i] || mdp[i])
return (0);
if (ac == 3)
return (print_flags_usage());
return (1);
}
/*
** Function that free the list
*/
void clean_list(t_fillist *list, t_fillist *tmp)
{
tmp = list;
while (list)
{
list = tmp->next;
free(tmp->memory);
free(tmp);
tmp = list;
}
}
/*
** Main function
*/
int main(int ac, char **av)
{
t_fillist *list;
char *input;
int *dope;
int size;
int mdp;
list = NULL;
mdp = is_mdp(ac, av);
dope = create_dope(av[3], mdp);
if (ac == 2 || mdp)
{
if (!(input = read_file(av[1])))
print_error(dope[3] ? "error: Could not read file.\n" : "error\n");
check_file_errors(input, dope);
size = parse_input(input, &list, dope);
print_final_map(list, size);
free(input);
clean_list(list, list);
}
else
print_error("usage: Please submit a file.\n> ./fillit file.fillit\n");
free(dope);
return (0);
}