lejulien/stack_sort
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial commit

Browse Source
This commit is contained in:
lejulien
2026-01-09 15:20:33 +01:00
commit d0a9d550e5
31 changed files with 2248 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

108
srcs/checker/actions.c Normal file
View File

@@ -0,0 +1,108 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* actions.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <lejulien@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/03/05 15:57:06 by lejulien #+# #+# */
/* Updated: 2021/03/16 15:32:51 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "checker.h"
int
add_to_stack(t_stack **stack, int value, int is_disp)
{
t_stack *new;
t_stack *ptr;
ptr = *stack;
if (!(new = malloc(sizeof(t_stack))))
return (1);
new->value = value;
new->next = NULL;
new->disp = is_disp;
if (*stack == NULL)
{
*stack = new;
return (0);
}
while (ptr->next != NULL)
ptr = ptr->next;
ptr->next = new;
return (0);
}
void
push(t_stack **a_stack, t_stack **b_stack)
{
t_stack *ptr;
if (*a_stack == NULL)
return ;
ptr = *a_stack;
*a_stack = ptr->next;
ptr->next = *b_stack;
*b_stack = ptr;
}
void
swap(t_stack **stack)
{
t_stack *a;
t_stack *b;
a = *stack;
if (!a)
return ;
b = a->next;
if (!b)
return ;
*stack = b;
a->next = b->next;
b->next = a;
}
void
rotate(t_stack **stack)
{
t_stack *a;
t_stack *b;
a = *stack;
if (!a)
return ;
b = a->next;
if (!b)
return ;
while (b->next != NULL)
b = b->next;
*stack = a->next;
b->next = a;
a->next = NULL;
}
void
r_rotate(t_stack **stack)
{
t_stack *a;
t_stack *b;
a = *stack;
if (!a)
return ;
b = a->next;
if (!b)
return ;
while (b->next != NULL)
{
a = a->next;
b = b->next;
}
a->next = NULL;
b->next = *stack;
*stack = b;
}

44
srcs/checker/check_stack.c Normal file
View File

@@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_stack.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/04/01 13:39:16 by lejulien #+# #+# */
/* Updated: 2021/04/01 13:40:34 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include "checker.h"
#include <stdlib.h>
#include "../utils/utils.h"
void
check_stack(t_stack **stack)
{
t_stack *ptr;
int prev;
ptr = *stack;
if (ptr == NULL)
return (ft_putstr("KO\n"));
if (ptr->next == NULL)
{
ft_putstr("OK\n");
return ;
}
prev = ptr->value;
ptr = ptr->next;
while (ptr != NULL)
{
if (prev > ptr->value)
{
ft_putstr("KO\n");
return ;
}
prev = ptr->value;
ptr = ptr->next;
}
ft_putstr("OK\n");
}

110
srcs/checker/checker.c Normal file
View File

@@ -0,0 +1,110 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* checker.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <lejulien@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/03/05 13:01:57 by lejulien #+# #+# */
/* Updated: 2021/04/02 13:29:50 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include "../utils/utils.h"
#include <unistd.h>
#include "checker.h"
#include <stdlib.h>
int
push_values_to_stack(t_stack **stack, char **av, int ac, int pos)
{
int i;
t_stack *b_stack;
t_stack *ptr;
b_stack = NULL;
i = pos;
while (i < ac)
{
if (add_to_stack(stack, ft_atoi(av[i]), pos))
return (ft_free_stacks(stack, &b_stack, 1));
i++;
}
ptr = *stack;
if (has_double(stack))
return (ft_free_stacks(stack, &b_stack, 1));
if (entry(stack, &b_stack))
return (ft_free_stacks(stack, &b_stack, 1));
return (ft_free_stacks(stack, &b_stack, 1) - 1);
}
static int
is_flag(char *str)
{
if (str[0] == '-' && str[1] == 'v')
return (1);
return (0);
}
int
check_flags(int ac, char **av)
{
int i;
i = 0;
if (ac > 2)
{
if (is_flag(av[1]))
i++;
}
return (1 + i);
}
int
check_num(int ac, char **av)
{
int i;
int j;
i = 1;
while (i < ac)
{
j = 0;
while (av[i][j] != '\0')
{
if (av[i][j] < '0' || av[i][j] > '9')
{
if (av[i][j] != '-')
return (1);
}
j++;
}
i++;
}
return (0);
}
int
check_max(int ac, char **av)
{
int i;
char *tmp;
int i_tmp;
i = 1;
while (i < ac)
{
if (av[i][0] == '\0')
return (1);
i_tmp = ft_atoi(av[i]);
tmp = ft_itoa(i_tmp);
if (i_tmp != 0 && my_strcmp(av[i], tmp))
{
free(tmp);
return (1);
}
free(tmp);
i++;
}
return (0);
}

40
srcs/checker/checker.h Normal file
View File

@@ -0,0 +1,40 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* checker.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/03/05 13:38:15 by lejulien #+# #+# */
/* Updated: 2021/04/01 18:24:46 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef CHECKER_H
# define CHECKER_H
typedef struct s_stack
{
int value;
int disp;
void *next;
} t_stack;
int add_to_stack(t_stack **stack, int value, int pos);
int ft_free_stacks(t_stack **a_stack, t_stack **b_stack, int ret);
void display_stack(t_stack **a_stack, t_stack **b_stack);
int has_double(t_stack **stack);
int entry(t_stack **a_stack, t_stack **b_stack);
void push(t_stack **a_stack, t_stack **b_stack);
void swap(t_stack **stack);
void rotate(t_stack **stack);
void r_rotate(t_stack **stack);
void check_stack(t_stack **stack);
int push_values_to_stack(t_stack **stack, char **av, int ac,
int pos);
int check_flags(int ac, char **av);
int check_num(int ac, char **av);
int check_max(int ac, char **av);
int parse_entry(char *str, t_stack **a_stack, t_stack **b_stack);
int ft_strlen(char *str);
#endif

58
srcs/checker/checker2.c Normal file
View File

@@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* checker2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/04/01 13:45:52 by lejulien #+# #+# */
/* Updated: 2021/04/01 13:52:35 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include "checker.h"
#include "../utils/utils.h"
#include <stdlib.h>
int
is_number(char *c)
{
int i;
i = 0;
while (c[i] != '\0')
{
if (c[i] < '0' || c[i] > '9')
return (0);
i++;
}
return (1);
}
int
main(int ac, char **av)
{
t_stack *a_stack;
int flags;
a_stack = NULL;
if (ac > 1)
{
if (check_num(ac, av) || check_max(ac, av))
{
ft_putstr("Error\n");
return (1);
}
if (!(flags = check_flags(ac, av)))
{
ft_putstr("Error\n");
return (1);
}
if (push_values_to_stack(&a_stack, av, ac, flags))
{
ft_putstr("Error\n");
return (1);
}
}
return (0);
}

74
srcs/checker/entry.c Normal file
View File

@@ -0,0 +1,74 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* entry.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/04/01 13:53:40 by lejulien #+# #+# */
/* Updated: 2021/04/01 14:27:24 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include "checker.h"
#include "../utils/utils.h"
#include <unistd.h>
#include <stdlib.h>
char
*add_char(char *src, char c)
{
char *ret;
int index;
index = 0;
if (src == NULL)
{
if (!(ret = malloc(2 * sizeof(char))))
return (NULL);
ret[0] = c;
ret[1] = '\0';
return (ret);
}
if (!(ret = malloc((ft_strlen(src) + 1) * sizeof(char))))
return (NULL);
while (src[index] != '\0')
{
ret[index] = src[index];
index++;
}
ret[index] = c;
ret[index + 1] = '\0';
free(src);
return (ret);
}
int
entry(t_stack **a_stack, t_stack **b_stack)
{
int run;
char c;
char *entry;
int ret;
run = 1;
entry = NULL;
while (run)
{
ret = read(0, &c, 1);
if (ret == -1 || ret == 0 || c == '\x4')
run = 0;
entry = add_char(entry, c);
if (c == '\n')
{
ret = parse_entry(entry, a_stack, b_stack);
free(entry);
if (ret == 1)
return (1);
entry = NULL;
}
}
free(entry);
(*b_stack != NULL) ? ft_putstr("KO\n") : check_stack(a_stack);
return (0);
}

64
srcs/checker/error.c Normal file
View File

@@ -0,0 +1,64 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* error.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/03/05 15:59:25 by lejulien #+# #+# */
/* Updated: 2021/04/01 13:40:58 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
#include "checker.h"
#include "../utils/utils.h"
static void
ft_free_stack(t_stack **stack)
{
t_stack *tmp;
t_stack *nxt;
if (!*stack)
return ;
tmp = *stack;
while (tmp != NULL)
{
nxt = tmp->next;
free(tmp);
tmp = nxt;
}
*stack = NULL;
}
int
ft_free_stacks(t_stack **a_stack, t_stack **b_stack, int ret)
{
ft_free_stack(a_stack);
if (b_stack != NULL)
ft_free_stack(b_stack);
return (ret);
}
int
has_double(t_stack **stack)
{
t_stack *ptr1;
t_stack *ptr2;
ptr1 = *stack;
ptr2 = ptr1->next;
while (ptr1->next != NULL)
{
ptr2 = ptr1->next;
while (ptr2 != NULL)
{
if (ptr1->value == ptr2->value)
return (1);
ptr2 = ptr2->next;
}
ptr1 = ptr1->next;
}
return (0);
}

99
srcs/checker/parse_entry.c Normal file
View File

@@ -0,0 +1,99 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse_entry.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: lejulien <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2021/04/01 14:15:28 by lejulien #+# #+# */
/* Updated: 2021/04/01 14:16:49 by lejulien ### ########.fr */
/* */
/* ************************************************************************** */
#include "checker.h"
#include "../utils/utils.h"
int
ft_strlen(char *str)
{
int i;
i = 0;
while (str[i] != '\0')
i++;
return (i);
}
int
ft_strcmp(char *src, char *dst)
{
int i;
i = 0;
if (ft_strlen(src) != ft_strlen(dst))
return (0);
while (src[i] != '\0')
{
if (src[i] != dst[i])
return (0);
i++;
}
return (1);
}
static int
parse_entry2(char *str, t_stack **a_stack, t_stack **b_stack)
{
if (ft_strcmp("ss\n", str))
{
swap(a_stack);
swap(b_stack);
return (1);
}
else if (ft_strcmp("ra\n", str))
{
rotate(a_stack);
return (1);
}
else if (ft_strcmp("rb\n", str))
{
rotate(b_stack);
return (1);
}
else if (ft_strcmp("rr\n", str))
{
rotate(a_stack);
rotate(b_stack);
}
return (0);
}
int
parse_entry(char *str, t_stack **a_stack, t_stack **b_stack)
{
if (ft_strcmp("pa\n", str))
push(b_stack, a_stack);
else if (ft_strcmp("pb\n", str))
push(a_stack, b_stack);
else if (ft_strcmp("sa\n", str))
swap(a_stack);
else if (ft_strcmp("sb\n", str))
swap(b_stack);
else if (ft_strcmp("rra\n", str))
r_rotate(a_stack);
else if (parse_entry2(str, a_stack, b_stack))
{
}
else if (ft_strcmp("rrb\n", str))
r_rotate(b_stack);
else if (ft_strcmp("rrr\n", str))
{
r_rotate(a_stack);
r_rotate(b_stack);
}
else if (ft_strcmp("\n", str))
return (0);
else
return (1);
return (0);
}