42_adjoly/42-2nd-piscine
Archived
1
0
Fork 0
Code Activity

first commit

Browse Source
This commit is contained in:
Adam Joly
2023-08-03 23:16:27 +02:00
parent 7f3254f1c5
commit a80c4d61d7
133 changed files with 4293 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
finish/rush01/ex00/bruteforce.c Normal file
View File

@ -0,0 +1,108 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* bruteforce.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jmikola <jmikola@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 12:00:11 by psalame #+# #+# */
/* Updated: 2023/07/23 12:43:04 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
int get_area_size(void);
int ft_test_possibility(int **tab, int i);
int verif_non_double(int i, int **tab);
int verif_col_down(int i, int **tab);
int verif_col_up(int i, int **tab);
int verif_row_right(int i, int **tab);
int verif_row_left(int i, int **tab);
int **get_row(void);
int **get_col(void);
int verif_all_row(int i, int **tab)
{
int row_left;
int row_right;
int area_size;
area_size = get_area_size();
row_left = verif_row_left(i, tab);
row_right = verif_row_right(i, tab);
if (((i % area_size) == area_size - 1))
{
if (row_left != get_row()[i / area_size][0]
|| row_right != get_row()[i / area_size][1])
return (0);
}
else if (row_left > get_row()[i / area_size][0])
return (0);
return (1);
}
int verif_all_col(int i, int **tab)
{
int col_up;
int col_down;
int area_size;
area_size = get_area_size();
col_up = verif_col_up(i, tab);
col_down = verif_col_down(i, tab);
if (((i / area_size) == area_size - 1))
{
if (col_up != get_col()[i % area_size][0]
|| col_down != get_col()[i % area_size][1])
return (0);
}
else if (col_up > get_col()[i % area_size][0])
return (0);
return (1);
}
int verif(int i, int **tab)
{
if (!verif_non_double(i, tab))
return (0);
return (verif_all_row(i, tab) && verif_all_col(i, tab));
}
int is_possibility_valid(int **tab, int i)
{
int area_size;
area_size = get_area_size();
if (i == area_size * area_size - 1)
return (1);
else
return (ft_test_possibility(tab, i + 1));
}
int ft_test_possibility(int **tab, int i)
{
int area_size;
int height;
area_size = get_area_size();
if (tab[i / area_size][i % area_size] == 0)
{
height = 0;
while (++height <= area_size)
{
tab[i / area_size][i % area_size] = height;
if (verif(i, tab))
{
if (is_possibility_valid(tab, i))
return (1);
}
}
tab[i / area_size][i % area_size] = 0;
return (0);
}
else
{
if (!verif(i, tab))
return (0);
return (is_possibility_valid(tab, i));
}
}

26
finish/rush01/ex00/ft_free_tabtab.c Normal file
View File

@ -0,0 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_free_tabtab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: psalame <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 14:18:27 by psalame #+# #+# */
/* Updated: 2023/07/22 16:25:32 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
void ft_free_tabtab(int **tab, int size)
{
int i;
i = 0;
while (i < size)
{
free(tab[i]);
i++;
}
free(tab);
}

94
finish/rush01/ex00/init_tables.c Normal file
View File

@ -0,0 +1,94 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* init_tables.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: psalame <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 19:12:44 by psalame #+# #+# */
/* Updated: 2023/07/23 17:44:52 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
int get_area_size(void);
int **get_row_args(char **argv)
{
int i_row;
int tab_index;
int **row;
int s;
s = get_area_size();
row = malloc(s * sizeof(int *));
if (row == NULL)
return (NULL);
i_row = s * 4;
tab_index = 0;
while (i_row < (s * 6 - 1))
{
if (argv[1][i_row] != ' ')
{
row[tab_index] = malloc(2 * sizeof(int));
row[tab_index][0] = argv[1][i_row] - '0';
row[tab_index][1] = argv[1][i_row + s * 2] - '0';
tab_index ++;
}
i_row ++;
}
return (row);
}
int **get_col_args(char **argv)
{
int i_col;
int tab_index;
int **col;
int s;
s = get_area_size();
col = (int **) malloc(s * sizeof(int *));
if (col == NULL)
return (NULL);
i_col = 0;
tab_index = 0;
while (i_col < (s * 2 - 1))
{
if (argv[1][i_col] != ' ')
{
col[tab_index] = malloc(2 * sizeof(int));
col[tab_index][0] = argv[1][i_col] - '0';
col[tab_index][1] = argv[1][i_col + s * 2] - '0';
tab_index++;
}
i_col ++;
}
return (col);
}
int **init_res(void)
{
int i;
int j;
int **res;
res = malloc(get_area_size() * sizeof(int *));
if (res == NULL)
return (NULL);
i = 0;
j = 0;
while (i < get_area_size())
{
res[i] = malloc(get_area_size() * sizeof(int));
j = 0;
while (j < get_area_size())
{
res[i][j] = 0;
j++;
}
i++;
}
return (res);
}

47
finish/rush01/ex00/is_args_valid.c Normal file
View File

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* is_args_valid.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: psalame <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 13:31:00 by psalame #+# #+# */
/* Updated: 2023/07/23 11:19:18 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
int ft_strlen(char *str)
{
int i;
i = 0;
while (str[i])
i++;
return (i);
}
int is_args_valid(int argc, char **argv)
{
int i;
int area_size;
if (argc != 2)
return (0);
area_size = (ft_strlen(argv[1]) + 1) / 2 / 2 / 2;
if (area_size < 2 || (ft_strlen(argv[1]) + 1) % area_size != 0)
return (0);
i = 0;
while (argv[1][i] && area_size != 0)
{
if (i % 2 == 0)
{
if (argv[1][i] < '1' || argv[1][i] > '0' + area_size)
area_size = 0;
}
else
if (argv[1][i] != ' ')
area_size = 0;
i++;
}
return (area_size);
}

70
finish/rush01/ex00/main.c Normal file
View File

@ -0,0 +1,70 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ale-gal <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 12:32:28 by ale-gal #+# #+# */
/* Updated: 2023/07/23 17:45:59 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
int get_area_size(void);
int **get_col_args(char **argv);
int **get_row_args(char **argv);
void ft_free_tabtab(int **tab, int size);
void ft_print_double_tab(int **tab, int size);
int **ft_place_sure(int **row, int **col, int **result);
int is_args_valid(int argc, char **argv);
int ft_test_possibility(int **tab, int i);
int **init_res(void);
int **g_col;
int **g_row;
int g_area_size;
int **get_col(void)
{
return (g_col);
}
int **get_row(void)
{
return (g_row);
}
int main(int argc, char **argv)
{
int **res;
g_area_size = is_args_valid(argc, argv);
if (g_area_size == 0)
{
write(1, "Error\n", 6);
return (0);
}
g_col = get_col_args(argv);
g_row = get_row_args(argv);
res = init_res();
if (g_col == NULL || g_row == NULL || res == NULL)
{
write(1, "Error\n", 6);
return (0);
}
ft_place_sure(g_row, g_col, res);
if (ft_test_possibility(res, 0))
ft_print_double_tab(res, get_area_size());
else
write(1, "Error\n", 6);
ft_free_tabtab(res, get_area_size());
ft_free_tabtab(g_col, get_area_size());
ft_free_tabtab(g_row, get_area_size());
return (0);
}
int get_area_size(void)
{
return (g_area_size);
}

115
finish/rush01/ex00/place_sure.c Normal file
View File

@ -0,0 +1,115 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* place_sure.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: adjoly <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 11:37:10 by adjoly #+# #+# */
/* Updated: 2023/07/23 11:11:18 by psalame ### ########.fr */
/* */
/* ************************************************************************** */
int get_area_size(void);
void con_col(int **result, int i, int j, int **col)
{
int k;
k = 0;
if (col[i][j] == 1)
{
if (j == 1)
result[get_area_size() - 1][i] = get_area_size();
else
result[0][i] = get_area_size();
}
else if (col[i][j] == get_area_size())
{
if (j == 1)
{
k = get_area_size() + 1;
while (--k > 0)
result[k - 1][i] = (get_area_size() - k + 1);
}
else
{
while (++k <= get_area_size())
result[k - 1][i] = k;
}
}
}
void con_row(int **result, int i, int j, int **row)
{
int k;
k = 0;
if (row[i][j] == 1)
{
if (j == 1)
result[i][get_area_size() - 1] = get_area_size();
else
result[i][0] = get_area_size();
}
else if (row[i][j] == get_area_size())
{
if (j == 1)
{
k = get_area_size();
while (--k > 0)
result[i][k - 1] = (get_area_size() - k + 1);
}
else
{
while (++k <= get_area_size())
result[i][k - 1] = k;
}
}
}
void place_col(int size, int **col, int **result)
{
int i;
int j;
i = 0;
while (i < size)
{
j = 0;
while (j < 2)
{
con_col(result, i, j, col);
j++;
}
i++;
}
}
void place_row(int size, int **row, int **result)
{
int i;
int j;
i = 0;
while (i < size)
{
j = 0;
while (j < 2)
{
con_row(result, i, j, row);
j++;
}
i++;
}
}
int **ft_place_sure(int **row, int **col, int **result)
{
int size;
size = get_area_size();
place_row(size, row, result);
place_col(size, col, result);
return (result);
}

36
finish/rush01/ex00/print_double_tab.c Normal file
View File

@ -0,0 +1,36 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print_double_tab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ale-gal <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 11:42:20 by ale-gal #+# #+# */
/* Updated: 2023/07/22 16:51:52 by ale-gal ### ########.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
void ft_print_double_tab(int **tab, int size)
{
int i_x;
int i_y;
char chr;
i_y = 0;
while (i_y < size)
{
i_x = 0;
while (i_x < size)
{
chr = '0' + tab[i_y][i_x];
write(1, &chr, 1);
if (i_x != size - 1)
write(1, " ", 1);
i_x++;
}
write(1, "\n", 1);
i_y++;
}
}

128
finish/rush01/ex00/verif.c Normal file
View File

@ -0,0 +1,128 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* verif.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jmikola <jmikola@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/22 13:01:37 by jmikola #+# #+# */
/* Updated: 2023/07/23 10:53:36 by jmikola ### ########.fr */
/* */
/* ************************************************************************** */
int get_area_size(void);
int verif_row_left(int i, int **tab)
{
int val_row_left;
int v_max;
int j;
int area_size;
j = 0;
val_row_left = 0;
v_max = 0;
area_size = get_area_size();
while (j < area_size)
{
if (tab[i / area_size][j] > v_max)
{
val_row_left++;
v_max = tab[i / area_size][j];
}
j++;
}
return (val_row_left);
}
int verif_row_right(int i, int **tab)
{
int val_row_right;
int v_max;
int j;
int area_size;
area_size = get_area_size();
j = area_size - 1;
v_max = 0;
val_row_right = 0;
while (j >= 0)
{
if (tab[i / area_size][j] > v_max)
{
val_row_right++;
v_max = tab[i / area_size][j];
}
j--;
}
return (val_row_right);
}
int verif_col_up(int i, int **tab)
{
int val_col_up;
int v_max;
int j;
int area_size;
j = 0;
v_max = 0;
val_col_up = 0;
area_size = get_area_size();
while (j < area_size)
{
if (tab[j][i % area_size] > v_max)
{
val_col_up++;
v_max = tab[j][i % area_size];
}
j++;
}
return (val_col_up);
}
int verif_col_down(int i, int **tab)
{
int val_col_down;
int v_max;
int j;
int area_size;
area_size = get_area_size();
j = area_size - 1;
v_max = 0;
val_col_down = 0;
while (j >= 0)
{
if (tab[j][i % area_size] > v_max)
{
val_col_down++;
v_max = tab[j][i % area_size];
}
j--;
}
return (val_col_down);
}
int verif_non_double(int i, int **tab)
{
int j;
int area_size;
j = 0;
area_size = get_area_size();
while (j < i % area_size)
{
if (tab[i / area_size][j] == tab[i / area_size][i % area_size])
return (0);
j++;
}
j = 0;
while (j < i / area_size)
{
if (tab[j][i % area_size] == tab[i / area_size][i % area_size])
return (0);
j++;
}
return (1);
}