da7e/42-Push_Swap
1
0
Fork 0
mirror of https://github.com/DavidGailleton/42-Push_Swap.git synced 2026-01-27 08:41:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Compare commits

base: da7e:e2cbea4df9443058e1356eac6108c3b77670d53f
Branches Tags
da7e:master da7e:fix_bench da7e:playtest da7e:readme da7e:error_valgrind da7e:indexer da7e:bonus da7e:medium_algo da7e:radix da7e:headers da7e:pre_sorting da7e:simple_algorithm da7e:parsing da7e:stack_functions
..
compare: da7e:parsing
Branches Tags
da7e:master da7e:fix_bench da7e:playtest da7e:readme da7e:error_valgrind da7e:indexer da7e:bonus da7e:medium_algo da7e:radix da7e:headers da7e:pre_sorting da7e:simple_algorithm da7e:parsing da7e:stack_functions

1 Commits
e2cbea4df9 ... parsing

Author SHA1 Message Date
Maoake Teriierooiterai
67d7509faf all basics functions has been tested we can start the sort algorithms 2025-12-09 11:42:37 +01:00
64 changed files with 126 additions and 3245 deletions
Expand all files Collapse all files

14
.gitignore vendored
View File

@@ -53,17 +53,3 @@ dkms.conf
# debug information files # debug information files
*.dwo *.dwo
# Vim swap files
*.swp
# Executable
push_swap
checker
checker_linux
# File obj
obj/
#playtest
playtest.sh

BIN
.main.c.swp Normal file
View File

Binary file not shown.

BIN
.parsing.c.swp Normal file
View File

Binary file not shown.

169
Makefile
View File

@@ -1,169 +0,0 @@
#============================
# ALL FOLDERS
#============================
STACK_UTILS_DIR = stack_utils
ALGO_UTILS_DIR = algorithms/utils
INSERT_DIR = algorithms/insertion
ALGO_DIR = algorithms
PARS_DIR = parsing
MEDIUM_DIR = medium
COMPLEX_DIR = radix
FLAGS_DIR = flags
CHECKER_DIR = check_error
INCLUDES = includes
#============================
# ALL FILES WITHOUT PATH
#============================
SRC = main.c ft_putnbr.c secure_write.c
INSERTION = insertion.c
FLAGS_FILES = algorithms_sort.c flag.c bench.c
PARSING = ft_atoi.c parsing.c ft_strncmp.c ft_split.c ft_strlen.c ft_substr.c ft_itoa.c ft_isdigit.c \
ft_strjoin.c ft_strlcat.c ft_strlcpy.c parsing_2.c disorder.c indexer.c
CHECKER_FILES = check_error.c verif_flag.c verif_is_digit.c verif_overflow.c verif_double.c
STACK_UTILS = push.c rev_rotate.c rotate.c stack_add.c stack_remove.c stacks_len.c swap.c
MEDIUM_ALGO = utils_medium.c utils_struct_tab.c utils_medium_two.c sort_utils.c sort_utils_two.c medium_algo.c \
move_patha.c move_pathb.c
COMPLEX_ALGO = radix.c
ALGO_UTILS = check_order.c compare.c iterate.c pre_sort.c
#============================
# ADDING PATH TO THE FILES
#============================
ALL_FILES = $(SRC) $(STACK_UTILS_DIR)/$(STACK_UTILS) $(PARS_DIR)/$(PARSING) \
$(ALGO_DIR)/$(MEDIUM_DIR)/$(MEDIUM_ALGO) $(ALGO_UTILS_DIR)/$(ALGO_UTILS) \
$(INSERT_DIR)/$(INSERTION) $(ALGO_DIR)/$(COMPLEX_DIR)/$(COMPLEX_ALGO) \
$(FLAGS_DIR)/$(FLAGS_FILES) $(CHECKER_DIR)/$(CHECKER_FILES)
OBJ_DIR = obj
CC = cc
CFLAGS = -Wall -Werror -Wextra -I$(INCLUDES)
NAME = push_swap
OBJ = $(addprefix $(OBJ_DIR)/, $(notdir $(ALL_FILES:.c=.o)))
DEP = $(OBJ:.o=.d)
#============================
# BONUS CONFIG
#============================
BONUS_DIR = bonus
GNL_D = GNL
GNL_DIR = bonus/GNL
BONUS_FILES = checker_bonus.c
GNL_FILES = get_next_line.c get_next_line_utils.c
SRC_FOR_BONUS = ft_putnbr.c secure_write.c
ALL_BONUS_FILES = $(SRC_FOR_BONUS) $(BONUS_DIR)/$(BONUS_FILES) $(BONUS_DIR)/$(GNL_D)/$(GNL_FILES) \
$(STACK_UTILS_DIR)/$(STACK_UTILS) $(PARS_DIR)/$(PARSING) \
$(ALGO_DIR)/$(MEDIUM_DIR)/$(MEDIUM_ALGO) $(ALGO_UTILS_DIR)/$(ALGO_UTILS) \
$(INSERT_DIR)/$(INSERTION) $(ALGO_DIR)/$(COMPLEX_DIR)/$(COMPLEX_ALGO) \
$(FLAGS_DIR)/$(FLAGS_FILES) $(CHECKER_DIR)/$(CHECKER_FILES)
BONUS_OBJ = $(addprefix $(OBJ_DIR)/, $(notdir $(ALL_BONUS_FILES:.c=.o)))
NAME_BONUS = checker
.PHONY: all clean fclean re bonus
all: $(NAME)
$(NAME): $(OBJ)
@$(CC) $(CFLAGS) $(OBJ) -o $(NAME)
@echo "===================================="
@echo "======= PUSH SWAP COMPILED ========="
@echo "===================================="
$(NAME_BONUS): $(BONUS_OBJ)
@$(CC) $(CFLAGS) $(BONUS_OBJ) -o $(NAME_BONUS)
@echo "===================================="
@echo "======= CHECKER COMPILED ==========="
@echo "===================================="
$(OBJ_DIR)/%.o: $(PARS_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(INSERT_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(STACK_UTILS_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(ALGO_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(ALGO_DIR)/$(MEDIUM_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(ALGO_DIR)/$(COMPLEX_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(ALGO_UTILS_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(FLAGS_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(CHECKER_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(BONUS_DIR)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: $(BONUS_DIR)/$(GNL_D)/%.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR)/%.o: %.c | $(OBJ_DIR)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR_BONUS)/%.o: %.c | $(OBJ_DIR_BONUS)
$(CC) $(CFLAGS) -MMD -MP -c $< -o $@
$(OBJ_DIR):
@mkdir -p $(OBJ_DIR)
clean:
@rm -rf $(OBJ_DIR)
@echo "===================================="
@echo "= ALL OBJECT AND DEPENDENCES CLEAN ="
@echo "===================================="
fclean: clean
@rm -f $(NAME)
@rm -f $(NAME_BONUS)
@echo "========== EXEC DELETED ============"
@echo "===================================="
re: fclean all
bonus: $(NAME_BONUS)
-include $(DEP)

83
README.md
View File

@@ -1,84 +1,5 @@
*This project has been created as part of the 42 curriculum by dgaillet[, mteriier].* This project has been created as part of the 42 curriculum by mteriier[, dgaillet].
## Description ## Description
The **Push swap** project goal is to sort values with push swap operations beetween 2 stack (*a* and *b*) The *Push swap* project goal is to sort values with push swap operations beetween 2 stack (*a* and *b*)
with different algorithms. Depends on the difficulties to solve the stacks. We will select a certain algorithms.
The difficulty is calculate with a disorder function *(compute_disorder)*. Disorder result will be between 0 and 1.
Selected algo depends on the disorder:
**Disorder < 0.2 ( O(n2) ):**
- Insertion sort adaptation ( len = 500 > complexity = 30 000)
**0.2 >= Disorder < 0.5 ( O(n√n) ):**
- Bucket sort adaptations with √n buckets ( len = 500 > complexity = 11900)
**Disorder >= 0.5 ( O(n log n) ):**
- Radix sort adaptation (LSD or MSD) ( len = 500 > complexity = 8000)
## Instructions
### 1. Command to compile push_swap :
```
make
```
### 2. Command to compile bonus :
```
make bonus
```
### 3. Command to delete all objects and exec :
```
make fclean
```
### 3. Command exemples how to use push_swap :
```
./push_swap 7 5 8 12 30 -20
```
```
ARG="7 5 8 12 30 -20"; ./push_swap $ARG
```
### 4. Command exemples how to use checker :
```
./checker 7 5 8 12 30 -20
(put the command like pa,ra,rr,rrr ...)
```
### 5. Command exemples how to use checker and push_swap together :
```
ARG="7 5 8 12 30 -20"; ./push_swap $ARG | ./checker $ARG
```
## Resources
- **For the algorithms**
https://en.wikipedia.org/wiki/Sorting_algorithm
- **For BUCKET SORT**
https://www.meilisearch.com/blog/bucket-sort-guide
- **For RADIX**
https://www.geeksforgeeks.org/dsa/radix-sort/
### AI
AI was utilized to provide a reminder on how to include obj files within a subfolder for the Makefile.
## Additional sections may be required depending on the project
### Justification to why we chose this algorithms
- **Insertion sort**
We select **Insertion** cause that was the more simple to implement with the restrictions.
- **Bucket sort**
We select **Bucket** cause i like how the algorithms sort.
Define the range and the number of buckets.
- **Radix sort**
We select **Radix** cause that was the more simple to implement with the restrictions.

72
algorithms/insertion/insertion.c
View File

@@ -1,72 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* insertion.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 15:38:52 by dgaillet #+# #+# */
/* Updated: 2025/12/15 14:45:54 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static int to_insert(t_stacks *stacks, int sorted)
{
int i;
t_stack *a;
if (is_lowest(stacks->a, stacks->b, sorted)
|| is_highest(stacks->a, stacks->b, sorted))
return (sorted - r_to_lowest(stacks->a, sorted));
i = 0;
a = stacks->a;
while (i < sorted)
{
if (stacks->b->value > a->previous->value
&& stacks->b->value <= a->value)
return (i);
a = a->previous;
i++;
}
return (i);
}
static void ft_extra(t_stacks *stacks, int sorted, int b_len)
{
int to_r_rotate;
if (b_len <= 0)
return ;
if (sorted <= 1)
pa(stacks);
else
{
to_r_rotate = to_insert(stacks, sorted);
optimal_rotate(stacks, sorted - to_r_rotate, sorted, 'a');
pa(stacks);
}
ft_extra(stacks, sorted + 1, b_len - 1);
}
void insertion(t_stacks *stacks, int len)
{
int i;
if (len == 3)
{
sort_three_a(stacks);
return ;
}
if (check_order(stacks->a))
return ;
i = 0;
while (i < len)
{
pb(stacks);
i++;
}
ft_extra(stacks, 0, len);
optimal_rotate(stacks, r_to_lowest(stacks->a, len), len, 'a');
}

51
algorithms/medium/medium_algo.c
View File

@@ -1,51 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* medium_algo.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 07:14:45 by mteriier #+# #+# */
/* Updated: 2026/01/06 12:57:05 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
#include <stdlib.h>
int stack_len(t_stack *stack)
{
t_stack *first;
int i;
first = stack;
i = 1;
while (first->next != stack)
{
first = first->next;
i++;
}
return (i);
}
void bucket_algo(t_stacks *stacks, t_tab *preset, int range)
{
t_tab *tmp;
tmp = preset;
while (stacks->a)
pb(stacks);
while (preset)
{
push_range_to_b(stacks, preset, range);
if (preset->next)
tmp = preset->next;
else
tmp = NULL;
if (preset)
free(preset);
preset = tmp;
}
return ;
}

94
algorithms/medium/move_patha.c
View File

@@ -1,94 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* move_patha.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/16 06:20:47 by mteriier #+# #+# */
/* Updated: 2026/01/16 06:20:55 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "medium_headers.h"
#include "push_swap.h"
static int is_border_a(int value, t_stacks *stacks)
{
t_stack *tmp;
if (!stacks->a)
return (1);
tmp = assign_stack(stacks, 'a');
if ((value < tmp->index && check_order(tmp))
|| (value > tmp->index && value > tmp->previous->index
&& check_order(stacks->a)))
return (1);
return (0);
}
int move_left_to_right(int value, t_stacks *stacks, int is_move)
{
int i;
t_stack *tmp;
i = 0;
tmp = assign_stack(stacks, 'a');
while (value > tmp->index && !is_move)
{
tmp = tmp->next;
i++;
}
while (value > stacks->a->index && is_move)
ra(stacks);
return (i);
}
int move_right_to_left(int value, t_stacks *stacks, int is_move)
{
int i;
t_stack *tmp;
tmp = assign_stack(stacks, 'a');
i = 0;
while (value < tmp->previous->index && !is_move)
{
tmp = tmp->previous;
i++;
}
while (value < stacks->a->previous->index && is_move)
rra(stacks);
return (i);
}
int wich_path_a(int value, t_stacks *stacks)
{
t_stack *tmp;
int move_from_left;
int move_from_right;
tmp = assign_stack(stacks, 'a');
if (is_border_a(value, stacks))
return (-1);
move_from_left = move_left_to_right(value, stacks, 0);
move_from_right = move_right_to_left(value, stacks, 0);
if ((check_order(stacks->a) && move_from_left < move_from_right)
|| (move_from_left > move_from_right && !check_order(stacks->a)))
return (1);
else
return (0);
}
void move_ra_rra(int value, t_stacks *stacks)
{
if (is_border_a(value, stacks))
return ;
if (wich_path_a(value, stacks) == 1)
{
move_left_to_right(value, stacks, 1);
}
else if (wich_path_a(value, stacks) == 0)
{
move_right_to_left(value, stacks, 1);
}
}

115
algorithms/medium/move_pathb.c
View File

@@ -1,115 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* move_pathb.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/16 06:20:38 by mteriier #+# #+# */
/* Updated: 2026/01/16 06:20:42 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "medium_headers.h"
#include "push_swap.h"
static int path_to_end(t_stacks *stacks, int max_range, int range, char c)
{
t_stack *tmp;
t_stack *start;
int i;
int first_pass;
tmp = assign_stack(stacks, c);
start = assign_stack(stacks, c);
tmp = tmp->previous;
i = 0;
first_pass = 1;
while (first_pass || tmp != start->previous)
{
first_pass = 0;
if (in_range(tmp->index, max_range, range))
tmp = start;
tmp = tmp->previous;
i++;
}
return (i);
}
static int path_to_start(t_stacks *stacks, int max_range, int range, char c)
{
t_stack *tmp;
t_stack *start;
int i;
int first_pass;
tmp = assign_stack(stacks, c);
start = assign_stack(stacks, c);
i = 0;
first_pass = 1;
while (first_pass || tmp != start)
{
first_pass = 0;
if (in_range(tmp->index, max_range, range))
{
tmp = start->previous;
}
tmp = tmp->next;
i++;
}
return (i);
}
int wich_path(t_stacks *stacks, int max_range, int range, char c)
{
int path_start;
int path_end;
path_start = path_to_start(stacks, max_range, range, c);
path_end = path_to_end(stacks, max_range, range, c);
if (path_start < path_end)
return (1);
return (0);
}
void normal_move_path(t_stacks *stacks, t_tab *one_preset, int range)
{
if (wich_path(stacks, one_preset->max_range, range, 'b'))
{
while (!in_range(stacks->b->index, one_preset->max_range, range))
rb(stacks);
}
else
{
while (!in_range(stacks->b->index, one_preset->max_range, range))
{
rrb(stacks);
}
}
}
int get_pre_move_b(t_stacks *stacks, t_tab *one_preset, int range)
{
int i;
t_stack *tmp;
i = 0;
tmp = assign_stack(stacks, 'b');
if (wich_path(stacks, one_preset->max_range, range, 'b'))
{
while (!in_range(tmp->index, one_preset->max_range, range))
{
i++;
tmp = tmp->next;
}
}
else
{
while (!in_range(tmp->index, one_preset->max_range, range))
{
i++;
tmp = tmp->previous;
}
}
return (i);
}

91
algorithms/medium/sort_utils.c
View File

@@ -1,91 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/05 14:11:49 by mteriier #+# #+# */
/* Updated: 2026/01/05 14:11:52 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
void move_rr_rrr(t_stacks *stacks, int move, char c)
{
int i;
i = 0;
while (i < move && c == 's')
{
rr(stacks);
i++;
}
while (i < move && c == 'e')
{
i++;
rrr(stacks);
}
}
void put_in_order_ra_rra(t_stacks *stacks)
{
int i;
i = 0;
while (!check_order(stacks->a) && i < 50)
{
ra(stacks);
i++;
}
}
void path_rr_rrr(int value, t_stacks *stacks, t_tab *one_preset, int range)
{
int move_a;
int final_move;
final_move = get_pre_move_b(stacks, one_preset, range);
if (wich_path_a(value, stacks) == 1
&& wich_path(stacks, one_preset->max_range, range, 'b'))
{
move_a = move_left_to_right(value, stacks, 0);
if (move_a < final_move)
final_move = move_a;
move_rr_rrr(stacks, final_move, 's');
}
else if (wich_path_a(value, stacks) == 0
&& !wich_path(stacks, one_preset->max_range, range, 'b'))
{
move_a = move_right_to_left(value, stacks, 0);
if (move_a < final_move)
final_move = move_a;
move_rr_rrr(stacks, final_move, 'e');
}
}
void push_range_to_b(t_stacks *stacks, t_tab *one_preset, int range)
{
int value;
int i;
i = 0;
while (one_preset->nb_in > 0)
{
if (stacks->a)
{
value = get_value_finded(stacks, one_preset, range);
path_rr_rrr(value, stacks, one_preset, range);
}
normal_move_path(stacks, one_preset, range);
move_ra_rra(stacks->b->index, stacks);
pa(stacks);
put_in_order_ra_rra(stacks);
one_preset->nb_in--;
i++;
if (!check_order(stacks->a))
return ;
}
}

43
algorithms/medium/sort_utils_two.c
View File

@@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort_utils_two.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/06 07:52:36 by mteriier #+# #+# */
/* Updated: 2026/01/06 07:52:38 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
int get_value_finded(t_stacks *stacks, t_tab *one_preset, int range)
{
int value;
t_stack *tmp;
tmp = assign_stack(stacks, 'b');
if (wich_path(stacks, one_preset->max_range, range, 'b'))
{
while (!in_range(tmp->index, one_preset->max_range, range))
tmp = tmp->next;
}
else
while (!in_range(tmp->index, one_preset->max_range, range))
tmp = tmp->previous;
value = tmp->index;
return (value);
}
t_stack *assign_stack(t_stacks *stacks, char c)
{
t_stack *tmp;
if (c == 'a')
tmp = stacks->a;
else
tmp = stacks->b;
return (tmp);
}

104
algorithms/medium/utils_medium.c
View File

@@ -1,104 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_medium.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 13:58:40 by mteriier #+# #+# */
/* Updated: 2025/12/10 13:58:42 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int get_first_lower(t_stack *first)
{
t_stack *tmp;
int lower;
int pass;
tmp = first;
lower = tmp->index;
pass = 1;
while (tmp != first || pass == 1)
{
pass = 0;
if (lower > tmp->index)
lower = tmp->index;
tmp = tmp->next;
}
return (lower);
}
int get_next_lower(t_stack *first, int old_lower)
{
t_stack *tmp;
int next_lower;
int skip_first;
tmp = first;
skip_first = 1;
next_lower = 2147483647;
while (tmp != first || skip_first)
{
skip_first = 0;
if (old_lower < tmp->index && tmp->index <= next_lower)
{
next_lower = tmp->index;
if (next_lower == -2147483648)
return (next_lower);
}
tmp = tmp->next;
}
return (next_lower);
}
int calcul_range(int value, int range)
{
int max_range;
max_range = 0;
if (value == 2147483647)
return (value);
if (value < 0)
while (max_range > value)
max_range -= range;
else
while (max_range <= value)
max_range += range;
if (max_range < 0)
return (max_range + range - 1);
return (max_range - 1);
}
int in_range(int value, int max_range, int range)
{
int min_range;
min_range = max_range - (range - 1);
if (value <= max_range && value >= min_range)
return (1);
return (0);
}
int get_number_in_range(int max_range, t_stack *a, int range)
{
int nb_in;
t_stack *tmp;
t_stack *first;
int pass;
nb_in = 0;
tmp = a;
pass = 1;
first = tmp;
while (tmp != first || pass == 1)
{
pass = 0;
if (in_range(tmp->index, max_range, range))
nb_in++;
tmp = tmp->next;
}
return (nb_in);
}

80
algorithms/medium/utils_medium_two.c
View File

@@ -1,80 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_medium_two.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.lyon42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/22 09:36:56 by mteriier #+# #+# */
/* Updated: 2025/12/22 09:38:19 by mteriier ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
static int get_max_number(t_stack *first)
{
int max;
int pass;
t_stack *a;
a = first;
max = a->index;
pass = 1;
while (a != first || pass == 1)
{
pass = 0;
if (max < a->index)
max = a->index;
a = a->next;
}
return (max);
}
static int get_min_number(t_stack *first)
{
int min;
t_stack *a;
int pass;
a = first;
min = a->index;
pass = 1;
while (a != first || pass == 1)
{
pass = 0;
if (min > a->index)
min = a->index;
a = a->next;
}
return (min);
}
static int my_sqrt(int nb)
{
int i;
if (nb < 1)
return (0);
i = 0;
while (i * i <= nb)
i++;
return (i);
}
int range_bucket(t_stack *first)
{
int len;
long diff;
int sqrt;
len = stack_len(first);
diff = (long)get_max_number(first) - (long)get_min_number(first);
sqrt = my_sqrt(len);
if (diff / sqrt < 2)
{
return (get_max_number(first));
}
return (diff / my_sqrt(len));
}

91
algorithms/medium/utils_struct_tab.c
View File

@@ -1,91 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils_struct_tab.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/10 13:36:43 by mteriier #+# #+# */
/* Updated: 2025/12/10 13:36:48 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
#include <stdlib.h>
static t_tab *allocate_tab(int range_max, int nb)
{
t_tab *tab;
tab = malloc(sizeof(t_tab));
if (!tab)
return (NULL);
tab->next = NULL;
tab->max_range = range_max;
tab->nb_in = nb;
return (tab);
}
static t_tab *free_tab(t_tab **first)
{
if (!(*first))
return (NULL);
if ((*first)->next)
free_tab(&(*first)->next);
free(*first);
return (NULL);
}
static t_tab *init_first_tab(t_stack *first, int range)
{
t_tab *tab;
int lower;
int range_max;
lower = get_first_lower(first);
range_max = calcul_range(lower, range);
tab = allocate_tab(range_max, get_number_in_range(range_max, first, range));
if (!tab)
return (NULL);
return (tab);
}
static t_tab *get_next_tab(t_stack *first, t_tab *tab, int range)
{
int lower;
int range_max;
t_tab *next_tab;
lower = get_next_lower(first, tab->max_range);
range_max = calcul_range(lower, range);
next_tab = allocate_tab(range_max,
get_number_in_range(range_max, first, range));
if (!next_tab)
return (NULL);
return (next_tab);
}
t_tab *get_tabs(t_stack *first, int range)
{
t_tab *tmp;
t_tab *first_tab;
int len_stack;
int scan_nb_in_tab;
len_stack = stack_len(first);
first_tab = init_first_tab(first, range);
if (!first_tab)
return (NULL);
scan_nb_in_tab = first_tab->nb_in;
tmp = first_tab;
while (scan_nb_in_tab < len_stack)
{
tmp->next = get_next_tab(first, tmp, range);
if (!(tmp->next))
return (free_tab(&first_tab));
tmp = tmp->next;
scan_nb_in_tab += tmp->nb_in;
}
return (first_tab);
}

69
algorithms/radix/radix.c
View File

@@ -1,69 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* radix.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/06 12:47:06 by dgaillet #+# #+# */
/* Updated: 2026/01/08 11:06:11 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static int still_unit_index(t_stacks *stacks, int unit)
{
t_stack *temp;
temp = stacks->a;
if (!temp || temp->index >= unit)
return (1);
temp = temp->next;
while (temp != stacks->a)
{
if (temp->index >= unit)
return (1);
temp = temp->next;
}
return (0);
}
static void push_by_number_to_b(t_stacks *stacks, int unit, int nb)
{
int i;
int s_len;
s_len = stack_a_len(stacks);
i = 0;
while (i < s_len && still_unit_index(stacks, unit))
{
if (stacks->a && (stacks->a->index % (unit * 10)) / unit == nb)
pb(stacks);
else
ra(stacks);
i++;
}
}
static void rec_sort(t_stacks *stacks, int unit)
{
int i;
i = 0;
if (!still_unit_index(stacks, unit))
return ;
while (i <= 9)
{
push_by_number_to_b(stacks, unit, i);
i++;
}
while (stacks->b)
pa(stacks);
rec_sort(stacks, unit * 10);
}
void radix(t_stacks *stacks)
{
rec_sort(stacks, 1);
}

27
algorithms/utils/check_order.c
View File

@@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_order.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/09 11:57:06 by mteriier #+# #+# */
/* Updated: 2025/12/11 17:50:21 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int check_order(t_stack *stack)
{
t_stack *first;
first = stack;
while (stack->next != first)
{
if (stack->value > stack->next->value)
return (0);
stack = stack->next;
}
return (1);
}

43
algorithms/utils/compare.c
View File

@@ -1,43 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* compare.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/11 17:46:00 by dgaillet #+# #+# */
/* Updated: 2025/12/11 17:46:22 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int is_lowest(t_stack *stack, t_stack *node, int len)
{
int i;
i = 0;
while (i < len)
{
if (node->value > stack->value)
return (0);
stack = stack->next;
i++;
}
return (1);
}
int is_highest(t_stack *stack, t_stack *node, int len)
{
int i;
i = 0;
while (i < len)
{
if (node->value < stack->value)
return (0);
stack = stack->next;
i++;
}
return (1);
}

42
algorithms/utils/iterate.c
View File

@@ -1,42 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* iterate.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/11 17:49:56 by dgaillet #+# #+# */
/* Updated: 2025/12/15 14:44:56 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void iterate_fn(t_stacks *stacks, int i, void (f)(t_stacks *stacks))
{
while (i > 0)
{
f(stacks);
i--;
}
}
void optimal_rotate(t_stacks *stacks, int i, int len, char stack)
{
if (i == len)
return ;
if (i && len / i >= 2)
{
if (stack == 'a')
iterate_fn(stacks, i, &ra);
else
iterate_fn(stacks, i, &rb);
}
else if (i)
{
if (stack == 'a')
iterate_fn(stacks, len - i, &rra);
else
iterate_fn(stacks, len - i, &rrb);
}
}

56
algorithms/utils/pre_sort.c
View File

@@ -1,56 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* pre_sort.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/15 14:21:20 by dgaillet #+# #+# */
/* Updated: 2025/12/15 14:59:52 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int r_to_lowest(t_stack *stack, int len)
{
t_stack *lowest;
int lowest_i;
int i;
i = 1;
lowest_i = 0;
lowest = stack;
stack = stack->next;
while (i < len)
{
if (stack->value < lowest->value)
{
lowest_i = i;
lowest = stack;
}
stack = stack->next;
i++;
}
return (lowest_i);
}
void sort_two(t_stacks *stacks)
{
sa(stacks);
}
void sort_three_a(t_stacks *stacks)
{
if (check_order(stacks->a))
return ;
if (stacks->a->value > stacks->a->next->value)
sa(stacks);
optimal_rotate(stacks, r_to_lowest(stacks->a, 3), 3, 'a');
if (stacks->a->next->value > stacks->a->previous->value)
{
ra(stacks);
sa(stacks);
rra(stacks);
}
}

112
bonus/GNL/get_next_line.c
View File

@@ -1,112 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/21 17:20:41 by dgaillet #+# #+# */
/* Updated: 2025/11/28 13:47:15 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "get_next_line.h"
#include "parsing.h"
#include <unistd.h>
static int del_before_nl(char buf[BUFFER_SIZE])
{
int nl_i;
int i;
char *temp;
nl_i = index_of_nl(buf, BUFFER_SIZE);
if (nl_i >= 0)
{
temp = ft_substr_gnl(buf, nl_i + 1, BUFFER_SIZE - nl_i);
if (!temp)
return (-1);
ft_bzero(buf, BUFFER_SIZE);
i = 0;
while (temp[i])
{
buf[i] = temp[i];
i++;
}
free(temp);
}
return (1);
}
static char *ft_read_one(char buf[BUFFER_SIZE], int fd, char *str)
{
int temp;
str = ft_strjoin_new(str, buf, BUFFER_SIZE);
if (!str)
return (NULL);
ft_bzero(buf, BUFFER_SIZE);
temp = read(fd, buf, BUFFER_SIZE);
if (temp < 0)
{
free(str);
return (NULL);
}
if ((!str || ft_strlen_1(str) == 0) && temp == 0)
{
free(str);
return (NULL);
}
if (temp == 0)
return (str);
return (str);
}
static char *extract_all_nl(char buf[BUFFER_SIZE], int fd, char *str, int nl_i)
{
int temp;
if (!str)
return (NULL);
while (nl_i < 0)
{
str = ft_read_one(buf, fd, str);
if (!str)
return (NULL);
nl_i = index_of_nl(buf, BUFFER_SIZE);
if (nl_i < 0 && !ft_strlen_1(buf))
return (str);
}
str = ft_strjoin_new(str, buf, nl_i);
if (!str)
return (NULL);
temp = del_before_nl(buf);
if (temp < 0)
{
free(str);
return (NULL);
}
return (str);
}
char *get_next_line(int fd)
{
static char buf[BUFFER_SIZE + 1];
int nl_i;
int temp;
char *str;
if (fd < 0 || BUFFER_SIZE <= 0)
return (NULL);
nl_i = index_of_nl(buf, BUFFER_SIZE);
if (nl_i >= 0)
{
str = ft_substr_gnl(buf, 0, nl_i + 1);
temp = del_before_nl(buf);
if (temp < 0)
return (free(str), NULL);
}
else
str = extract_all_nl(buf, fd, ft_substr_gnl("", 0, 1), nl_i);
return (str);
}

102
bonus/GNL/get_next_line_utils.c
View File

@@ -1,102 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/21 17:21:38 by dgaillet #+# #+# */
/* Updated: 2025/11/27 18:06:51 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "get_next_line.h"
#include <stdint.h>
int index_of_nl(char *str, int limit)
{
int i;
if (!str)
return (-1);
i = 0;
while (i < limit && str[i])
{
if (str[i] == '\n')
return (i);
i++;
}
return (-1);
}
size_t ft_strlen_1(const char *s)
{
size_t i;
i = 0;
while (s[i])
i++;
return (i);
}
char *ft_strjoin_new(char const *s1, char const *s2, size_t limit)
{
char *str;
size_t i;
size_t j;
str = malloc(sizeof(char) * (ft_strlen_1(s1) + ft_strlen_1(s2) + 1));
if (!str)
return (NULL);
i = 0;
j = 0;
while (s1[i])
{
str[i] = s1[i];
i++;
}
while (j <= limit && s2[j])
{
str[i + j] = s2[j];
j++;
}
str[i + j] = '\0';
free((void *) s1);
return (str);
}
char *ft_substr_gnl(char const *s, unsigned int start, size_t len)
{
size_t i;
char *sub_str;
size_t s_len;
if (!s)
return (NULL);
s_len = ft_strlen_1(s);
if (start > s_len)
len = 0;
else if (s_len < (start + len))
len = s_len - start;
sub_str = malloc(sizeof(char) * (len + 1));
if (!sub_str)
return (NULL);
i = 0;
while (i < len)
{
sub_str[i] = s[start + i];
i++;
}
sub_str[i] = '\0';
return (sub_str);
}
void ft_bzero(void *s, size_t n)
{
while (n > 0)
{
*((unsigned char *) s) = '\0';
s++;
n--;
}
}

110
bonus/checker_bonus.c
View File

@@ -1,110 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* checker_bonus.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 11:46:36 by dgaillet #+# #+# */
/* Updated: 2026/01/09 14:51:32 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "parsing.h"
#include "get_next_line.h"
#include "check_error.h"
#include <unistd.h>
static int apply_operation(t_stacks *stacks, char buf[1024])
{
if (ft_strncmp("sa\n", buf, ft_strlen(buf)))
return (sa(stacks), 1);
if (ft_strncmp("sb\n", buf, ft_strlen(buf)))
return (sb(stacks), 1);
if (ft_strncmp("ss\n", buf, ft_strlen(buf)))
return (ss(stacks), 1);
if (ft_strncmp("pa\n", buf, ft_strlen(buf)))
return (pa(stacks), 1);
if (ft_strncmp("pb\n", buf, ft_strlen(buf)))
return (pb(stacks), 1);
if (ft_strncmp("ra\n", buf, ft_strlen(buf)))
return (ra(stacks), 1);
if (ft_strncmp("rb\n", buf, ft_strlen(buf)))
return (rb(stacks), 1);
if (ft_strncmp("rr\n", buf, ft_strlen(buf)))
return (rr(stacks), 1);
if (ft_strncmp("rra\n", buf, ft_strlen(buf)))
return (rra(stacks), 1);
if (ft_strncmp("rrb\n", buf, ft_strlen(buf)))
return (rrb(stacks), 1);
if (ft_strncmp("rrr\n", buf, ft_strlen(buf)))
return (rrr(stacks), 1);
return (0);
}
static int is_stacks_b_empty(t_stacks *stacks)
{
if (stacks->b != NULL)
return (0);
return (1);
}
static int tester(t_stacks *stacks)
{
char *buf;
buf = get_next_line(0);
while (buf)
{
if (!apply_operation(stacks, buf))
break ;
free(buf);
buf = get_next_line(0);
}
if (!is_stacks_b_empty(stacks))
{
secure_write(1, "KO\n", 3);
return (0);
}
if (!check_order(stacks->a))
{
secure_write(1, "KO\n", 3);
return (0);
}
secure_write(1, "OK\n", 3);
return (0);
}
static int bonus(char **tab)
{
t_stacks *stacks;
int len;
stacks = NULL;
len = len_split(tab);
stacks = init_stacks(len, tab, 0);
stacks->print = 0;
if (!stacks)
return (0);
tester(stacks);
free_all(stacks);
return (1);
}
int main(int argc, char **argv)
{
char **tab;
if (argc < 2)
return (write(2, "Error\n", 7));
tab = split_all(join_all(argc, argv));
if (!tab)
return (0);
if (!check_error_bonus(tab))
secure_write(2, "Error\n", 7);
else
bonus(tab);
free_tab(tab);
return (0);
}

50
check_error/check_error.c
View File

@@ -1,50 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_error.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 09:31:50 by mteriier #+# #+# */
/* Updated: 2026/01/09 09:31:51 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "check_error.h"
#include "parsing.h"
int verif_is_number(char **tab)
{
int len;
len = len_split(tab);
if (tab[len - 1][0] == '-' && !ft_isdigit(tab[len - 1][1]))
return (0);
return (1);
}
int check_error_bonus(char **tab)
{
if (!verif_is_digit(tab, 0))
return (0);
if (!verif_overflow(tab, 0))
return (0);
if (!verif_double(tab, 0))
return (0);
return (1);
}
int check_error(char **tab, int mod)
{
if (!verif_flag(tab, mod))
return (0);
if (!verif_is_digit(tab, mod))
return (0);
if (!verif_overflow(tab, mod))
return (0);
if (!verif_double(tab, mod))
return (0);
if (!verif_is_number(tab))
return (0);
return (1);
}

47
check_error/verif_double.c
View File

@@ -1,47 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* verif_double.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 10:41:42 by mteriier #+# #+# */
/* Updated: 2026/01/09 10:41:43 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
#include "check_error.h"
static int is_double_in_tab(char **tab, int nb, int pos)
{
int i;
i = pos;
while (tab[i])
{
if (nb == ft_atoi(tab[i]))
return (0);
i++;
}
return (1);
}
int verif_double(char **tab, int mod)
{
int i;
int tmp;
i = wich_mod(mod);
while (tab[i])
{
if (tab[i + 1])
{
tmp = ft_atoi(tab[i]);
if (!is_double_in_tab(tab, tmp, i + 1))
return (0);
}
i++;
}
return (1);
}

73
check_error/verif_flag.c
View File

@@ -1,73 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* verif_flag.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 09:51:11 by mteriier #+# #+# */
/* Updated: 2026/01/09 09:51:12 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
static int is_exist_flag(char **tab, int pos)
{
int verif;
verif = 0;
if (ft_strncmp(tab[pos], "--bench", 30)
|| ft_strncmp(tab[pos], "--simple", 30)
|| ft_strncmp(tab[pos], "--medium", 30)
|| ft_strncmp(tab[pos], "--adaptive", 30)
|| ft_strncmp(tab[pos], "--complex", 30))
verif = 1;
return (verif);
}
static int is_algo_flag(char *str)
{
if (ft_strncmp(str, "--simple", 30)
|| ft_strncmp(str, "--medium", 30)
|| ft_strncmp(str, "--adaptive", 30)
|| ft_strncmp(str, "--complex", 30))
return (1);
return (0);
}
static int verif_exist_flag(char **tab, int mod)
{
int verif;
verif = 0;
if (mod == 1)
verif = (is_exist_flag(tab, 1));
else if (mod == 2)
{
if (is_exist_flag(tab, 1) && is_exist_flag(tab, 2))
verif = 1;
if (is_algo_flag(tab[1]) && is_algo_flag(tab[2]))
verif = 0;
}
return (verif);
}
static int verif_double_flag(char **tab, int mod)
{
int verif;
verif = 1;
if (mod == 2 && ft_strncmp(tab[1], tab[2], 9))
verif = 0;
return (verif);
}
int verif_flag(char **tab, int mod)
{
if (mod == 0)
return (1);
if (verif_double_flag(tab, mod) && verif_exist_flag(tab, mod))
return (1);
return (0);
}

44
check_error/verif_is_digit.c
View File

@@ -1,44 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* verif_is_digit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 10:25:23 by mteriier #+# #+# */
/* Updated: 2026/01/09 10:25:24 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
int scan_str_is_digit(char *tab)
{
int i;
i = 0;
while (tab[i])
{
if ((tab[i] == '+' || tab[i] == '-') && ft_isdigit(tab[i + 1])
&& tab[i + 1])
i++;
if (!ft_isdigit(tab[i]))
return (0);
i++;
}
return (1);
}
int verif_is_digit(char **tab, int mod)
{
int i;
i = wich_mod(mod);
while (tab[i])
{
if (!scan_str_is_digit(tab[i]))
return (0);
i++;
}
return (1);
}

53
check_error/verif_overflow.c
View File

@@ -1,53 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* verif_overflow.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 10:30:39 by mteriier #+# #+# */
/* Updated: 2026/01/09 10:30:40 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
static int verif_atoi(const char *nptr)
{
size_t i;
int tmp;
int before;
i = 0;
tmp = 0;
before = 0;
if (ft_strncmp(nptr, "-2147483648", 15))
return (1);
while ((nptr[i] >= 9 && nptr[i] <= 13) || nptr[i] == ' ')
i++;
if (nptr[i] == '-' || nptr[i] == '+')
i++;
while (nptr[i] >= '0' && nptr[i] <= '9')
{
before = tmp;
tmp = tmp * 10 + nptr[i] - '0';
if (before > tmp)
return (0);
i++;
}
return (1);
}
int verif_overflow(char **tab, int mod)
{
int i;
i = wich_mod(mod);
while (tab[i])
{
if (!verif_atoi(tab[i]))
return (0);
i++;
}
return (1);
}

65
flags/algorithms_sort.c
View File

@@ -1,65 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* algorithms_sort.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 12:15:02 by mteriier #+# #+# */
/* Updated: 2026/01/08 16:07:00 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "medium_headers.h"
#include "parsing.h"
void simple(t_stacks *stacks)
{
int len;
len = stack_a_len(stacks);
insertion(stacks, len);
}
void medium(t_stacks *stacks)
{
t_tab *buckets;
int range;
int len;
len = stack_a_len(stacks);
if (len == 2)
sort_two(stacks);
else
{
range = range_bucket(stacks->a);
buckets = get_tabs(stacks->a, range);
if (!buckets)
return ;
bucket_algo(stacks, buckets, range);
}
}
void complex(t_stacks *stacks)
{
radix(stacks);
}
void adaptive(t_stacks *stacks, char **tab)
{
int i;
float disorder;
i = 0;
while (!ft_isdigit(tab[i][0]) && tab[i])
i++;
disorder = stacks->disorder;
if (disorder < 0.2)
simple(stacks);
else if (disorder < 0.5)
medium(stacks);
else
complex(stacks);
return ;
}

117
flags/bench.c
View File

@@ -1,117 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* bench.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 13:59:52 by dgaillet #+# #+# */
/* Updated: 2026/01/09 12:13:36 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "parsing.h"
#include <unistd.h>
static void print_disorder(t_stacks *stacks)
{
int nbr;
char *str;
stacks->disorder *= 10000;
nbr = (int) stacks->disorder;
str = ft_itoa(nbr);
if (!str)
exit (EXIT_FAILURE);
secure_write(2, "[bench] disorder: ", 18);
if (ft_strlen(str) <= 2)
secure_write(2, "0", 1);
else
secure_write(2, str, ft_strlen(str) - 2);
secure_write(2, ".", 1);
if (ft_strlen(str) == 1)
secure_write(2, "0", 1);
secure_write(2, &str[ft_strlen(str) - 2], ft_strlen(str) - 2);
secure_write(2, "%\n", 2);
stacks->disorder /= 10000;
free(str);
}
static void print_algo(t_stacks *stacks)
{
secure_write(2, "[bench] algo: ", 14);
if (stacks->algo == 0)
{
secure_write(2, "Adaptive", 8);
if (stacks->disorder < 0.2)
secure_write(2, " / O(n2n)\n", 10);
else if (stacks->disorder >= 0.5)
secure_write(2, " / O(nlogn)\n", 12);
else
secure_write(2, " / O(n√n)\n", 12);
}
else if (stacks->algo == 1)
secure_write(2, "Simple / O(n2n)\n", 16);
else if (stacks->algo == 2)
secure_write(2, "Medium / O(n√n)\n", 18);
else if (stacks->algo == 3)
secure_write(2, "Complex / O(nlogn)\n", 19);
}
static void print_total_ops(t_stacks *stacks)
{
unsigned int total_ops;
total_ops = 0;
total_ops += stacks->sa;
total_ops += stacks->sb;
total_ops += stacks->ss;
total_ops += stacks->pa;
total_ops += stacks->pb;
total_ops += stacks->ra;
total_ops += stacks->rb;
total_ops += stacks->rr;
total_ops += stacks->rra;
total_ops += stacks->rrb;
total_ops += stacks->rrr;
secure_write(2, "[bench] total_ops: ", 19);
ft_putnbr_fd((int) total_ops, 2);
secure_write(2, "\n", 1);
}
static void print_ops(t_stacks *stacks)
{
secure_write(2, "[bench] sa: ", 12);
ft_putnbr_fd((int) stacks->sa, 2);
secure_write(2, " sb: ", 5);
ft_putnbr_fd((int) stacks->sb, 2);
secure_write(2, " ss: ", 5);
ft_putnbr_fd((int) stacks->ss, 2);
secure_write(2, " pa: ", 5);
ft_putnbr_fd((int) stacks->pa, 2);
secure_write(2, " pb: ", 5);
ft_putnbr_fd((int) stacks->pb, 2);
secure_write(2, "\n", 1);
secure_write(2, "[bench] ra: ", 12);
ft_putnbr_fd((int) stacks->ra, 2);
secure_write(2, " rb: ", 5);
ft_putnbr_fd((int) stacks->rb, 2);
secure_write(2, " rr: ", 5);
ft_putnbr_fd((int) stacks->rr, 2);
secure_write(2, " rra: ", 6);
ft_putnbr_fd((int) stacks->rra, 2);
secure_write(2, " rrb: ", 6);
ft_putnbr_fd((int) stacks->rrb, 2);
secure_write(2, " rrr: ", 6);
ft_putnbr_fd((int) stacks->rrr, 2);
secure_write(2, "\n", 1);
}
void print_bench(t_stacks *stacks)
{
print_disorder(stacks);
print_algo(stacks);
print_total_ops(stacks);
print_ops(stacks);
}

86
flags/flag.c
View File

@@ -1,86 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* flag.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 12:39:29 by mteriier #+# #+# */
/* Updated: 2026/01/08 16:07:29 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "parsing.h"
#include "flags.h"
int calcul_mod(int argc, char **argv)
{
int mod;
mod = 0;
while (argv[mod] && !ft_isdigit(argv[mod][0])
&& !ft_isdigit(argv[mod][1]) && argv[mod][1] && mod < argc)
mod++;
mod--;
return (mod);
}
int pos_flag(char **argv, int mod)
{
if (mod == 1 || mod == 4)
{
if (!ft_strncmp(argv[1], "--bench", 20))
return (1);
}
else if (mod == 2 || mod == 5)
{
if (!ft_strncmp(argv[1], "--bench", 20))
return (1);
else
return (2);
}
return (0);
}
int pos_bench(char **argv, int mod)
{
if (mod == 1 || mod == 4)
{
if (ft_strncmp(argv[1], "--bench", 20))
return (1);
}
else if (mod == 2 || mod == 5)
{
if (ft_strncmp(argv[1], "--bench", 20))
return (1);
else
return (2);
}
return (0);
}
void flags(int pos, int pos_b, char **argv, t_stacks *stacks)
{
if (ft_strncmp(argv[pos], "--simple", 30) && pos > 0)
{
stacks->algo = 1;
simple(stacks);
}
else if (ft_strncmp(argv[pos], "--medium", 30) && pos > 0)
{
stacks->algo = 2;
medium(stacks);
}
else if (ft_strncmp(argv[pos], "--complex", 30) && pos > 0)
{
stacks->algo = 3;
complex(stacks);
}
else if (ft_strncmp(argv[pos], "--adaptive", 30) && pos > 0)
adaptive(stacks, argv);
else
adaptive(stacks, argv);
if (pos_b > 0)
stacks->bench = 1;
}

0
parsing/ft_atoi.c → ft_atoi.c
View File

31
ft_putnbr.c
View File

@@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_putnbr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 15:17:28 by dgaillet #+# #+# */
/* Updated: 2026/01/09 12:09:55 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void rec_ft_putnbr_fd(int nbr, int fd)
{
char c;
if (!nbr)
return ;
rec_ft_putnbr_fd(nbr / 10, fd);
c = (nbr % 10) + '0';
secure_write(fd, &c, 1);
}
void ft_putnbr_fd(int nbr, int fd)
{
if (!nbr)
secure_write(fd, "0", 1);
rec_ft_putnbr_fd(nbr, fd);
}

24
includes/check_error.h
View File

@@ -1,24 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* check_error.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 10:16:35 by mteriier #+# #+# */
/* Updated: 2026/01/09 10:16:37 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef CHECK_ERROR_H
# define CHECK_ERROR_H
int verif_flag(char **tab, int mod);
int check_error(char **tab, int mod);
int verif_is_digit(char **tab, int mod);
int verif_overflow(char **tab, int mod);
int verif_double(char **tab, int mod);
int scan_str_is_digit(char *tab);
int check_error_bonus(char **tab);
#endif

26
includes/flags.h
View File

@@ -1,26 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* flags.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 13:05:52 by mteriier #+# #+# */
/* Updated: 2026/01/08 15:32:54 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef FLAGS_H
# define FLAGS_H
void simple(t_stacks *stacks);
void medium(t_stacks *stacks);
void complex(t_stacks *stacks);
void adaptive(t_stacks *stacks, char **tab);
void flags(int pos, int pos_b, char **argv, t_stacks *stacks);
int pos_bench(char **argv, int mod);
int pos_flag(char **argv, int mod);
int calcul_mod(int argc, char **argv);
void print_bench(t_stacks *stacks);
#endif

30
includes/get_next_line.h
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* get_next_line.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/21 17:22:03 by dgaillet #+# #+# */
/* Updated: 2025/11/27 18:05:13 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef GET_NEXT_LINE_H
# define GET_NEXT_LINE_H
# ifndef BUFFER_SIZE
# define BUFFER_SIZE 42
# endif
# include <stdlib.h>
char *get_next_line(int fd);
size_t ft_strlen_1(const char *s);
char *ft_strjoin_new(char const *s1, char const *s2, size_t limit);
void ft_bzero(void *s, size_t n);
int index_of_nl(char *str, int limit);
char *ft_substr_gnl(char const *s, unsigned int start, size_t len);
#endif

52
includes/medium_headers.h
View File

@@ -1,52 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* medium_headers.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 07:47:49 by mteriier #+# #+# */
/* Updated: 2026/01/07 07:47:51 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef MEDIUM_HEADERS_H
# define MEDIUM_HEADERS_H
# include "push_swap.h"
typedef struct s_tab
{
int max_range;
int nb_in;
struct s_tab *next;
} t_tab;
/* MEDIUM ALGO FILE */
int wich_path(t_stacks *stacks, int max_range, int range, char c);
int stack_len(t_stack *stack);
void bucket_algo(t_stacks *stacks, t_tab *preset, int range);
/* SORT UTILS FILES */
void push_range_to_b(t_stacks *stacks, t_tab *one_preset, int range);
void normal_move_path(t_stacks *stacks, t_tab *one_preset, int range);
t_stack *assign_stack(t_stacks *stacks, char c);
int get_value_finded(t_stacks *stacks, t_tab *one_preset, int range);
/* MEDIUM UTILS FILES */
int range_bucket(t_stack *first);
int get_first_lower(t_stack *first);
int get_next_lower(t_stack *first, int old_lower);
int calcul_range(int value, int range);
int in_range(int value, int max_range, int range);
int get_number_in_range(int max_range, t_stack *a, int range);
/* UTILS STRUCT TAB FILE */
t_tab *get_tabs(t_stack *first, int range);
/* MOVE PATH FILES*/
int get_pre_move_b(t_stacks *stacks, t_tab *one_preset, int range);
int move_left_to_right(int value, t_stacks *stacks, int is_move);
int move_right_to_left(int value, t_stacks *stacks, int is_move);
int wich_path_a(int value, t_stacks *stacks);
void move_ra_rra(int value, t_stacks *stacks);
void path_rr_rrr(int value, t_stacks *stacks, t_tab *one_preset, int range);
void put_in_order_ra_rra(t_stacks *stacks);
#endif

39
includes/parsing.h
View File

@@ -1,39 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 08:03:08 by mteriier #+# #+# */
/* Updated: 2026/01/09 11:27:39 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef PARSING_H
# define PARSING_H
# include <stdlib.h>
# include "push_swap.h"
int ft_atoi(const char *nptr);
int wich_mod(int mod);
t_stacks *init_stacks(int argc, char **argv, int mod);
int ft_strncmp(const char *s1, const char *s2, int n);
size_t ft_strlen(const char *s);
char *ft_substr(char const *s, unsigned int start, size_t len);
char **ft_split(char const *s, char c);
void free_tab(char **tab);
int checker(int argc, char **argv);
int len_split(char **tab);
char *ft_itoa(int n);
int ft_isdigit(int c);
char *ft_strjoin(char const *s1, char const *s2);
int ft_strlcpy(char *dst, const char *src, int size);
int ft_strlcat(char *dst, const char *src, int size);
char *join_all(int argc, char **argv);
char **split_all(char *tab);
float compute_disorder(char **strs, int pos);
void indexer(t_stacks *stacks);
#endif

90
includes/push_swap.h
View File

@@ -1,90 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push_swap.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 14:18:06 by dgaillet #+# #+# */
/* Updated: 2026/01/08 15:32:04 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef PUSH_SWAP_H
# define PUSH_SWAP_H
typedef struct s_stack
{
int value;
long long index;
struct s_stack *next;
struct s_stack *previous;
} t_stack;
typedef struct s_stacks
{
t_stack *a;
t_stack *b;
int algo;
int bench;
int print;
float disorder;
unsigned int ra;
unsigned int rb;
unsigned int rr;
unsigned int rra;
unsigned int rrb;
unsigned int rrr;
unsigned int pa;
unsigned int pb;
unsigned int sa;
unsigned int sb;
unsigned int ss;
} t_stacks;
/*STACK_FUNCTIONS*/
void pa(t_stacks *stacks);
void pb(t_stacks *stacks);
void rra(t_stacks *stacks);
void rrb(t_stacks *stacks);
void rrr(t_stacks *stacks);
void ra(t_stacks *stacks);
void rb(t_stacks *stacks);
void rr(t_stacks *stacks);
void sa(t_stacks *stacks);
void sb(t_stacks *stacks);
void ss(t_stacks *stacks);
/* STACK ADD AND CLEAR FILES */
t_stack *new_stack(int value);
void stack_add_back(t_stack **stack, t_stack *new);
void stack_add_front(t_stack **stack, t_stack *new);
void stack_clear_all(t_stack *stack, t_stack *first);
void free_all(t_stacks *stacks);
/* STACKS LEN FILES */
int stack_a_len(t_stacks *stacks);
int stack_b_len(t_stacks *stacks);
int highest_stack_len(t_stacks *stacks);
/* PRE SORT */
int r_to_lowest(t_stack *stack, int len);
void sort_three_a(t_stacks *stacks);
void sort_two(t_stacks *stacks);
/* ITERATE FILE */
void optimal_rotate(t_stacks *stacks, int i, int len, char stack);
/* COMPARE FILE */
int is_lowest(t_stack *stack, t_stack *node, int len);
int is_highest(t_stack *stack, t_stack *node, int len);
/* CHECK ORDER FILE */
int check_order(t_stack *stack);
/* INSERTION */
void insertion(t_stacks *stacks, int len);
int test2(char **argv);
/* TEST FILE */
int test1(char **tab, int len, int mod);
/* RADIX */
void radix(t_stacks *stacks);
void secure_write(int fd, char *str, int len);
void ft_putnbr_fd(int nbr, int fd);
#endif

86
main.c
View File

@@ -6,57 +6,65 @@
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */ /* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 18:32:35 by mteriier #+# #+# */ /* Created: 2025/12/08 18:32:35 by mteriier #+# #+# */
/* Updated: 2026/01/08 15:34:59 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/09 11:39:55 by mteriier ### ########lyon.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "push_swap.h"
#include "parsing.h" #include <stdio.h>
#include "check_error.h" #include <stdlib.h>
#include "flags.h"
#include <unistd.h>
static int push_swap(char **tab, int len, int mod) void print_all_stack(t_stack *stack, t_stack *first, char pile)
{ {
t_stacks *stacks; t_stack *tmp;
int i;
stacks = NULL; tmp = stack;
if (mod == -1) i = 0;
return (0); printf("TAB %c : \n", pile);
stacks = init_stacks(len, tab, mod); if (!stack || !first)
if (!stacks) return ;
return (0); while (tmp->next != first)
indexer(stacks);
if (check_order(stacks->a))
{ {
free_all(stacks); printf("[%d] ", tmp->value);
return (0); tmp = tmp->next;
i++;
} }
stacks->disorder = compute_disorder(tab, wich_mod(mod)); printf("[%d] \n", tmp->value);
flags(pos_flag(tab, mod), pos_bench(tab, mod), tab, stacks);
if (stacks->bench == 1)
print_bench(stacks);
free_all(stacks);
return (0);
} }
int main(int argc, char **argv) int main(int argc, char **argv)
{ {
char **tab; t_stacks *stacks;
int mod;
int len;
if (argc < 2) stacks = NULL;
return (0); if (argc > 1)
tab = split_all(join_all(argc, argv)); {
if (!tab) stacks = init_big_stacks(argc, argv);
return (0); print_all_stack(stacks->a, stacks->a, 'A');
len = len_split(tab); print_all_stack(stacks->b, stacks->b, 'B');
mod = calcul_mod(len, tab); sa(stacks);
if (check_error(tab, mod)) print_all_stack(stacks->a, stacks->a, 'A');
push_swap(tab, len, mod); print_all_stack(stacks->b, stacks->b, 'B');
else pb(stacks);
write(2, "Error\n", 6); print_all_stack(stacks->a, stacks->a, 'A');
free_tab(tab); print_all_stack(stacks->b, stacks->b, 'B');
return (0); pa(stacks);
print_all_stack(stacks->a, stacks->a, 'A');
print_all_stack(stacks->b, stacks->b, 'B');
rra(stacks);
print_all_stack(stacks->a, stacks->a, 'A');
print_all_stack(stacks->b, stacks->b, 'B');
pb(stacks);
pb(stacks);
print_all_stack(stacks->a, stacks->a, 'A');
print_all_stack(stacks->b, stacks->b, 'B');
rrb(stacks);
print_all_stack(stacks->a, stacks->a, 'A');
print_all_stack(stacks->b, stacks->b, 'B');
rrr(stacks);
print_all_stack(stacks->a, stacks->a, 'A');
print_all_stack(stacks->b, stacks->b, 'B');
}
stack_clear_all(stacks->a, stacks->a);
} }

44
parsing/parsing.c → parsing.c
View File

@@ -6,26 +6,21 @@
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */ /* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 16:21:05 by mteriier #+# #+# */ /* Created: 2025/12/08 16:21:05 by mteriier #+# #+# */
/* Updated: 2026/01/08 14:01:23 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/09 10:19:17 by mteriier ### ########lyon.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "push_swap.h"
#include "parsing.h" #include <stdlib.h>
int wich_mod(int mod) t_stack *parsing(int argc, char **argv)
{
return (mod % 3 + 1);
}
static t_stack *parsing(int argc, char **argv, int mod)
{ {
int i; int i;
int stock; int stock;
t_stack *first; t_stack *first;
t_stack *new; t_stack *new;
i = wich_mod(mod); i = 1;
first = NULL; first = NULL;
while (i < argc) while (i < argc)
{ {
@@ -44,28 +39,7 @@ static t_stack *parsing(int argc, char **argv, int mod)
return (first); return (first);
} }
static void set_t_stacks(t_stacks *stacks) t_stacks *init_big_stacks(int argc, char **argv)
{
stacks->a = NULL;
stacks->b = NULL;
stacks->algo = 0;
stacks->bench = 0;
stacks->disorder = 0;
stacks->print = 1;
stacks->sa = 0;
stacks->sb = 0;
stacks->ss = 0;
stacks->pa = 0;
stacks->pb = 0;
stacks->ra = 0;
stacks->rb = 0;
stacks->rr = 0;
stacks->rra = 0;
stacks->rrb = 0;
stacks->rrr = 0;
}
t_stacks *init_stacks(int argc, char **argv, int mod)
{ {
t_stacks *stacks; t_stacks *stacks;
t_stack *a; t_stack *a;
@@ -73,13 +47,7 @@ t_stacks *init_stacks(int argc, char **argv, int mod)
stacks = malloc(sizeof(t_stacks)); stacks = malloc(sizeof(t_stacks));
if (!stacks) if (!stacks)
return (NULL); return (NULL);
set_t_stacks(stacks); a = parsing(argc, argv);
a = parsing(argc, argv, mod);
if (!a)
{
free(stacks);
return (NULL);
}
stacks->a = a; stacks->a = a;
return (stacks); return (stacks);
} }

64
parsing/checker.c
View File

@@ -1,64 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* checker.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 12:37:12 by dgaillet #+# #+# */
/* Updated: 2026/01/08 13:17:36 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "parsing.h"
static int check_digits(char *str)
{
int i;
i = 0;
while (str[i])
{
if (!ft_isdigit(str[i]) && str[i] != ' ')
return (0);
i++;
}
return (1);
}
static int check_flags(char *str)
{
if (!ft_strncmp("--simple", str, ft_strlen(str)))
return (1);
else if (!ft_strncmp("--medium", str, ft_strlen(str)))
return (1);
else if (!ft_strncmp("--complex", str, ft_strlen(str)))
return (1);
else if (!ft_strncmp("--adaptative", str, ft_strlen(str)))
return (1);
return (0);
}
int checker(int argc, char **argv)
{
int i;
int methods_flag;
int bench;
bench = 0;
methods_flag = 0;
i = 0;
while (++i < argc)
{
if (check_flags(argv[1]) && !methods_flag)
methods_flag = 1;
else if (!ft_strncmp("--bench", argv[1], ft_strlen(argv[1])) && !bench)
bench = 1;
else if (check_digits(argv[1]))
continue ;
else
return (0);
}
return (1);
}

49
parsing/disorder.c
View File

@@ -1,49 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* disorder.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 11:05:37 by dgaillet #+# #+# */
/* Updated: 2026/01/09 14:53:45 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include "parsing.h"
static int strs_len(char **strs)
{
int i;
i = 0;
while (strs[i])
i++;
return (i);
}
float compute_disorder(char **strs, int pos)
{
float mistakes;
float total_pairs;
int i;
int j;
mistakes = 0;
total_pairs = 0;
i = pos;
while (i < strs_len(strs))
{
j = i + 1;
while (j < strs_len(strs))
{
total_pairs += 1;
if (ft_atoi(strs[i]) > ft_atoi(strs[j]))
mistakes += 1;
j++;
}
i++;
}
return (mistakes / total_pairs);
}

18
parsing/ft_isdigit.c
View File

@@ -1,18 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_isdigit.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 14:13:54 by dgaillet #+# #+# */
/* Updated: 2026/01/08 14:13:59 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
int ft_isdigit(int c)
{
if (c >= '0' && c <= '9')
return (1);
return (0);
}

62
parsing/ft_itoa.c
View File

@@ -1,62 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_itoa.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 14:13:00 by dgaillet #+# #+# */
/* Updated: 2026/01/08 14:13:27 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include <stdlib.h>
static size_t count_digits(int n)
{
size_t size;
size = 0;
if (n <= 0)
size++;
while (n)
{
n /= 10;
size++;
}
return (size);
}
static void insert_char(char *str, unsigned int nbr, size_t index)
{
while (nbr)
{
str[index--] = nbr % 10 + '0';
nbr /= 10;
}
}
char *ft_itoa(int n)
{
unsigned int nbr;
char *str;
size_t size;
nbr = n;
if (n < 0)
nbr = n * -1;
size = count_digits(n);
str = malloc(sizeof(char) * (size + 1));
if (!str)
return (NULL);
str[size] = '\0';
if (nbr == 0)
str[0] = '0';
else
{
if (n < 0)
str[0] = '-';
insert_char(str, nbr, size - 1);
}
return (str);
}

93
parsing/ft_split.c
View File

@@ -1,93 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/11 15:34:04 by mteriier #+# #+# */
/* Updated: 2025/11/13 14:55:21 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
static size_t count_words(char const *s, char c)
{
size_t i;
size_t len;
size_t tester;
i = 0;
len = 0;
while (s[i])
{
while (s[i] == c && s[i])
i++;
tester = 0;
while (s[i] != c && s[i])
{
tester++;
i++;
}
if (tester > 0)
len++;
}
return (len);
}
static size_t len_word(size_t i, char const *s, char c)
{
size_t len;
len = 0;
while (s[i])
{
while (s[i] != c && s[i])
{
len++;
i++;
}
return (len);
}
return (len);
}
void free_tab(char **tab)
{
int i;
i = 0;
while (tab[i])
free(tab[i++]);
free(tab);
}
char **ft_split(char const *s, char c)
{
size_t i;
size_t j;
char **big_tab;
big_tab = malloc((count_words(s, c) + 1) * sizeof(char *));
if (!big_tab)
return (0);
i = 0;
j = 0;
while (s[i])
{
while (s[i] == c && s[i])
i++;
if (s[i])
{
big_tab[j] = ft_substr(s, i, len_word(i, s, c));
if (!big_tab[j])
return (free_tab(big_tab), NULL);
j++;
}
while (s[i] != c && s[i])
i++;
}
big_tab[j] = 0;
return (big_tab);
}

27
parsing/ft_strjoin.c
View File

@@ -1,27 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strjoin.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/11 14:01:54 by mteriier #+# #+# */
/* Updated: 2025/11/12 08:34:59 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
char *ft_strjoin(char const *s1, char const *s2)
{
int total_len;
char *tmp;
total_len = ft_strlen(s1) + ft_strlen(s2);
tmp = malloc((total_len + 1) * sizeof(char));
if (!tmp)
return (0);
ft_strlcpy(tmp, s1, total_len + 1);
ft_strlcat(tmp, s2, total_len + 1);
return (tmp);
}

38
parsing/ft_strlcat.c
View File

@@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/10 09:22:05 by mteriier #+# #+# */
/* Updated: 2025/11/13 11:03:31 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
int ft_strlcat(char *dst, const char *src, int size)
{
int i;
int j;
int len_src;
int len_dst;
i = 0;
len_src = ft_strlen(src);
if (size == 0)
return (len_src);
j = ft_strlen(dst);
len_dst = ft_strlen(dst);
while (j < size - 1 && src[i])
{
dst[j] = src[i];
j++;
i++;
}
dst[j] = '\0';
if (len_dst > size)
return (len_src + size);
return (len_dst + len_src);
}

31
parsing/ft_strlcpy.c
View File

@@ -1,31 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlcpy.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/06 16:33:57 by mteriier #+# #+# */
/* Updated: 2025/11/13 10:58:32 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
int ft_strlcpy(char *dst, const char *src, int size)
{
int i;
int len;
len = ft_strlen(src);
i = 0;
if (size == 0)
return (len);
while (i < size - 1 && src[i])
{
dst[i] = src[i];
i++;
}
dst[i] = '\0';
return (len);
}

33
parsing/ft_strlen.c
View File

@@ -1,33 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strlen.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/06 13:25:17 by mteriier #+# #+# */
/* Updated: 2025/11/13 11:24:39 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include <string.h>
size_t ft_strlen(const char *s)
{
size_t i;
i = 0;
while (s[i])
i++;
return (i);
}
int len_split(char **tab)
{
int i;
i = 0;
while (tab[i])
i++;
return (i);
}

30
parsing/ft_strncmp.c
View File

@@ -1,30 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_strncmp.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/07 12:36:38 by mteriier #+# #+# */
/* Updated: 2026/01/07 12:36:40 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
int ft_strncmp(const char *s1, const char *s2, int n)
{
int i;
int res;
i = 0;
if (n == 0)
return (0);
while (i < n - 1 && s1[i] && s1[i] == s2[i])
{
i++;
}
res = (unsigned char)s1[i] - (unsigned char)s2[i];
if (res == 0)
return (1);
else
return (0);
}

40
parsing/ft_substr.c
View File

@@ -1,40 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_substr.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/11/11 13:46:41 by mteriier #+# #+# */
/* Updated: 2025/11/13 13:42:37 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
char *ft_substr(char const *s, unsigned int start, size_t len)
{
size_t len_s;
size_t i;
char *tmp;
if (!s)
return (0);
len_s = ft_strlen(s);
if (len_s < start)
len = 0;
if (len > len_s - start)
len = len_s - start;
tmp = malloc((len + 1) * sizeof(char));
if (!tmp)
return (0);
i = 0;
while (i < len)
{
tmp[i] = s[start];
i++;
start++;
}
tmp[i] = '\0';
return (tmp);
}

54
parsing/indexer.c
View File

@@ -1,54 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* indexer.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/14 10:14:06 by dgaillet #+# #+# */
/* Updated: 2026/01/14 10:14:08 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static t_stack *first_without_index(t_stack *stack)
{
t_stack *first;
if (stack->index < 0)
return (stack);
first = stack;
stack = stack->next;
while (stack != first)
{
if (stack->index < 0)
return (stack);
stack = stack->next;
}
return ((void *) 0);
}
void indexer(t_stacks *stacks)
{
int i;
int len;
t_stack *lower;
t_stack *temp;
i = 0;
len = stack_a_len(stacks);
while (i < len)
{
lower = first_without_index(stacks->a);
temp = lower->next;
while (temp != stacks->a)
{
if (lower->value > temp->value && temp->index < 0)
lower = temp;
temp = temp->next;
}
lower->index = i;
i++;
}
}

64
parsing/parsing_2.c
View File

@@ -1,64 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parsing_2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/09 08:22:21 by mteriier #+# #+# */
/* Updated: 2026/01/09 08:22:22 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "parsing.h"
static char *free_join(char *tab)
{
free(tab);
return (NULL);
}
static char *join_utils(char *start_tab, char *end_str)
{
char *tab;
char *tmp2;
tmp2 = ft_strjoin(end_str, " ");
if (!tmp2)
return (free_join(start_tab));
tab = ft_strjoin(start_tab, tmp2);
free(start_tab);
free(tmp2);
return (tab);
}
char *join_all(int argc, char **argv)
{
char *tab;
int i;
i = 0;
tab = ft_strjoin(argv[i], " ");
i++;
if (!tab)
return (NULL);
while (i < argc)
{
tab = join_utils(tab, argv[i]);
i++;
}
return (tab);
}
char **split_all(char *tab)
{
char **split;
if (!tab)
return (NULL);
split = ft_split(tab, ' ');
free (tab);
if (!split)
return (NULL);
return (split);
}

50
push_swap.h Normal file
View File

@@ -0,0 +1,50 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push_swap.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 14:18:06 by dgaillet #+# #+# */
/* Updated: 2025/12/09 10:17:27 by mteriier ### ########lyon.fr */
/* */
/* ************************************************************************** */
#ifndef PUSH_SWAP_H
# define PUSH_SWAP_H
typedef struct s_stack
{
int value;
struct s_stack *next;
struct s_stack *previous;
} t_stack;
typedef struct s_stacks
{
t_stack *a;
t_stack *b;
} t_stacks;
/*STACK_FUNCTIONS*/
void pa(t_stacks *stacks);
void pb(t_stacks *stacks);
void rra(t_stacks *stacks);
void rrb(t_stacks *stacks);
void rrr(t_stacks *stacks);
void ra(t_stacks *stacks);
void rb(t_stacks *stacks);
void rr(t_stacks *stacks);
void sa(t_stacks *stacks);
void sb(t_stacks *stacks);
void ss(t_stacks *stacks);
/*FUNCTION UTILS*/
t_stack *new_stack(int value);
void stack_add_back(t_stack **stack, t_stack *new);
void stack_add_front(t_stack **stack, t_stack *new);
void stack_clear_all(t_stack *stack, t_stack *first);
t_stack *parsing(int argc, char **argv);
t_stacks *init_big_stacks(int argc, char **argv);
int ft_atoi(const char *nptr);
#endif

22
secure_write.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* secure_write.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2026/01/08 14:30:38 by dgaillet #+# #+# */
/* Updated: 2026/01/09 14:55:16 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include <unistd.h>
#include <stdlib.h>
void secure_write(int fd, char *str, int len)
{
if (len < 0)
return ;
if (!str || write(fd, str, len) < 0)
exit (EXIT_FAILURE);
}

BIN
stack_utils/.push.c.swp Normal file
View File

Binary file not shown.

BIN
stack_utils/.stack_add.c.swp Normal file
View File

Binary file not shown.

14
stack_utils/push.c
View File

@@ -6,13 +6,12 @@
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */ /* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 15:09:40 by mteriier #+# #+# */ /* Created: 2025/12/08 15:09:40 by mteriier #+# #+# */
/* Updated: 2026/01/08 13:57:56 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/09 11:36:36 by mteriier ### ########lyon.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h>
void pa(t_stacks *stacks) void pa(t_stacks *stacks)
{ {
@@ -30,11 +29,11 @@ void pa(t_stacks *stacks)
stacks->b = stacks->b->next; stacks->b = stacks->b->next;
} }
stack_add_front(&(stacks->a), b_push); stack_add_front(&(stacks->a), b_push);
stacks->pa++;
if (stacks->print)
secure_write(1, "pa\n", 3);
} }
#include <stdio.h>
void pb(t_stacks *stacks) void pb(t_stacks *stacks)
{ {
t_stack *a_push; t_stack *a_push;
@@ -51,7 +50,4 @@ void pb(t_stacks *stacks)
stacks->a = stacks->a->next; stacks->a = stacks->a->next;
} }
stack_add_front(&(stacks->b), a_push); stack_add_front(&(stacks->b), a_push);
stacks->pb++;
if (stacks->print)
secure_write(1, "pb\n", 3);
} }

20
stack_utils/rev_rotate.c
View File

@@ -6,38 +6,26 @@
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */ /* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 14:43:45 by dgaillet #+# #+# */ /* Created: 2025/12/08 14:43:45 by dgaillet #+# #+# */
/* Updated: 2026/01/08 13:57:27 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/08 19:37:26 by mteriier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <unistd.h>
void rra(t_stacks *stacks) void rra(t_stacks *stacks)
{ {
if (stacks && stacks->a && stacks->a->previous) if (stacks && stacks->a && stacks->a->previous)
stacks->a = stacks->a->previous; stacks->a = stacks->a->previous;
stacks->rra++;
if (stacks->print)
secure_write(1, "rra\n", 4);
} }
void rrb(t_stacks *stacks) void rrb(t_stacks *stacks)
{ {
if (stacks && stacks->b && stacks->b->previous) if (stacks && stacks->b && stacks->b->previous)
stacks->b = stacks->b->previous; stacks->b = stacks->b->previous;
stacks->rrb++;
if (stacks->print)
secure_write(1, "rrb\n", 4);
} }
void rrr(t_stacks *stacks) void rrr(t_stacks *stacks)
{ {
if (stacks && stacks->b && stacks->b->previous) rra(stacks);
stacks->b = stacks->b->previous; rrb(stacks);
if (stacks && stacks->a && stacks->a->previous)
stacks->a = stacks->a->previous;
stacks->rrr++;
if (stacks->print)
secure_write(1, "rrr\n", 4);
} }

20
stack_utils/rotate.c
View File

@@ -6,38 +6,26 @@
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */ /* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 14:32:10 by dgaillet #+# #+# */ /* Created: 2025/12/08 14:32:10 by dgaillet #+# #+# */
/* Updated: 2026/01/08 13:57:47 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/08 19:37:44 by mteriier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <unistd.h>
void ra(t_stacks *stacks) void ra(t_stacks *stacks)
{ {
if (stacks && stacks->a && stacks->a->next) if (stacks && stacks->a && stacks->a->next)
stacks->a = stacks->a->next; stacks->a = stacks->a->next;
stacks->ra++;
if (stacks->print)
secure_write(1, "ra\n", 3);
} }
void rb(t_stacks *stacks) void rb(t_stacks *stacks)
{ {
if (stacks && stacks->b && stacks->b->next) if (stacks && stacks->b && stacks->b->next)
stacks->b = stacks->b->next; stacks->b = stacks->b->next;
stacks->rb++;
if (stacks->print)
secure_write(1, "rb\n", 3);
} }
void rr(t_stacks *stacks) void rr(t_stacks *stacks)
{ {
if (stacks && stacks->a && stacks->a->next) ra(stacks);
stacks->a = stacks->a->next; rb(stacks);
if (stacks && stacks->b && stacks->b->next)
stacks->b = stacks->b->next;
stacks->rr++;
if (stacks->print)
secure_write(1, "rr\n", 3);
} }

5
stack_utils/stack_add.c
View File

@@ -6,11 +6,11 @@
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */ /* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 15:52:40 by dgaillet #+# #+# */ /* Created: 2025/12/08 15:52:40 by dgaillet #+# #+# */
/* Updated: 2025/12/12 11:39:09 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/09 08:51:33 by mteriier ### ########lyon.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <stdlib.h> #include <stdlib.h>
t_stack *new_stack(int value) t_stack *new_stack(int value)
@@ -21,7 +21,6 @@ t_stack *new_stack(int value)
if (!new) if (!new)
return (NULL); return (NULL);
new->value = value; new->value = value;
new->index = -1;
new->next = NULL; new->next = NULL;
new->previous = NULL; new->previous = NULL;
return (new); return (new);

13
stack_utils/stack_remove.c
View File

@@ -6,11 +6,11 @@
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */ /* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 16:05:27 by dgaillet #+# #+# */ /* Created: 2025/12/08 16:05:27 by dgaillet #+# #+# */
/* Updated: 2025/12/12 11:39:02 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/08 19:40:01 by mteriier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <stdlib.h> #include <stdlib.h>
void stack_clear_all(t_stack *stack, t_stack *first) void stack_clear_all(t_stack *stack, t_stack *first)
@@ -21,12 +21,3 @@ void stack_clear_all(t_stack *stack, t_stack *first)
stack_clear_all(stack->next, first); stack_clear_all(stack->next, first);
free(stack); free(stack);
} }
void free_all(t_stacks *stacks)
{
if (stacks->a)
stack_clear_all(stacks->a, stacks->a);
if (stacks->b)
stack_clear_all(stacks->b, stacks->b);
free(stacks);
}

63
stack_utils/stacks_len.c
View File

@@ -1,63 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* stacks_len.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: dgaillet <dgaillet@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/09 13:11:50 by dgaillet #+# #+# */
/* Updated: 2025/12/09 13:19:21 by dgaillet ### ########lyon.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int stack_a_len(t_stacks *stacks)
{
t_stack *first;
t_stack *a_stack;
int len;
a_stack = stacks->a;
first = a_stack;
if (!a_stack)
return (0);
len = 1;
while (a_stack->next != first)
{
a_stack = a_stack->next;
len++;
}
return (len);
}
int stack_b_len(t_stacks *stacks)
{
t_stack *first;
t_stack *b_stack;
int len;
b_stack = stacks->b;
first = b_stack;
if (!b_stack)
return (0);
len = 1;
while (b_stack->next != first)
{
b_stack = b_stack->next;
len++;
}
return (len);
}
int highest_stack_len(t_stacks *stacks)
{
int a_len;
int b_len;
a_len = stack_a_len(stacks);
b_len = stack_b_len(stacks);
if (a_len > b_len)
return (a_len);
return (b_len);
}

36
stack_utils/swap.c
View File

@@ -6,12 +6,11 @@
/* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */ /* By: mteriier <mteriier@student.42lyon.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2025/12/08 14:48:44 by mteriier #+# #+# */ /* Created: 2025/12/08 14:48:44 by mteriier #+# #+# */
/* Updated: 2026/01/08 13:58:13 by dgaillet ### ########lyon.fr */ /* Updated: 2025/12/08 19:40:49 by mteriier ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "push_swap.h" #include "../push_swap.h"
#include <unistd.h>
void sa(t_stacks *stacks) void sa(t_stacks *stacks)
{ {
@@ -24,9 +23,6 @@ void sa(t_stacks *stacks)
stock = a->value; stock = a->value;
a->value = a->next->value; a->value = a->next->value;
a->next->value = stock; a->next->value = stock;
stacks->sa++;
if (stacks->print)
secure_write(1, "sa\n", 3);
} }
void sb(t_stacks *stacks) void sb(t_stacks *stacks)
@@ -40,34 +36,10 @@ void sb(t_stacks *stacks)
stock = b->value; stock = b->value;
b->value = b->next->value; b->value = b->next->value;
b->next->value = stock; b->next->value = stock;
stacks->sb++;
if (stacks->print)
secure_write(1, "sb\n", 3);
} }
void ss(t_stacks *stacks) void ss(t_stacks *stacks)
{ {
t_stack *b; sa(stacks);
t_stack *a; sb(stacks);
int stock;
if (!stacks)
return ;
if (stacks->b && stacks->b->next)
{
b = stacks->b;
stock = b->value;
b->value = b->next->value;
b->next->value = stock;
}
if (stacks->a && stacks->a->next)
{
a = stacks->a;
stock = a->value;
a->value = a->next->value;
a->next->value = stock;
}
stacks->ss++;
if (stacks->print)
secure_write(1, "ss\n", 3);
} }