fix conficts

Makefile

@@ -20,7 +20,7 @@ FLAGS_DIR = flags
 
 CHECKER_DIR = checker
 
-INCLUDES = headers
+INCLUDES = includes
 
 #============================
 # ALL FILES WITHOUT PATH 
@@ -37,7 +37,7 @@ PARSING = ft_atoi.c parsing.c ft_strncmp.c ft_split.c ft_strlen.c ft_substr.c ch
 
 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 print_stacks.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
 

algorithms/medium/utils_medium.c

@@ -16,11 +16,14 @@ int	get_first_lower(t_stack *first)
 {
 	t_stack	*tmp;
 	int		lower;
+	int		pass;
 
 	tmp = first;
 	lower = tmp->value;
-	while (tmp->next != first)
+	pass = 1;
+	while (tmp != first || pass == 1)
 	{
+		pass = 0;
 		if (lower > tmp->value)
 			lower = tmp->value;
 		tmp = tmp->next;
@@ -43,6 +46,8 @@ int	get_next_lower(t_stack *first, int old_lower)
 		if (old_lower < tmp->value && tmp->value <= next_lower)
 		{
 			next_lower = tmp->value;
+			if (next_lower == -2147483648)
+				return (next_lower);
 		}
 		tmp = tmp->next;
 	}
@@ -54,6 +59,8 @@ 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;
@@ -80,17 +87,18 @@ 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->next != first)
+	while (tmp != first || pass == 1)
 	{
+		pass = 0;
 		if (in_range(tmp->value, max_range, range))
 			nb_in++;
 		tmp = tmp->next;
 	}
-	if (in_range(tmp->value, max_range, range))
-		nb_in++;
 	return (nb_in);
 }

algorithms/medium/utils_medium_two.c

@@ -16,12 +16,15 @@
 static int	get_max_number(t_stack *first)
 {
 	int		max;
+	int		pass;
 	t_stack	*a;
 
 	a = first;
 	max = a->value;
-	while (a->next != first)
+	pass = 1;
+	while (a != first || pass == 1)
 	{
+		pass = 0;
 		if (max < a->value)
 			max = a->value;
 		a = a->next;
@@ -33,11 +36,14 @@ static int	get_min_number(t_stack *first)
 {
 	int		min;
 	t_stack	*a;
+	int		pass;
 
 	a = first;
 	min = a->value;
-	while (a->next != first)
+	pass = 1;
+	while (a != first || pass == 1)
 	{
+		pass = 0;
 		if (min > a->value)
 			min = a->value;
 		a = a->next;
@@ -59,16 +65,16 @@ static int	my_sqrt(int nb)
 
 int	range_bucket(t_stack *first)
 {
-	int	len;
-	int	diff;
-	int	sqrt;
+	int		len;
+	long	diff;
+	int		sqrt;
 
 	len = stack_len(first);
-	diff = get_max_number(first) - get_min_number(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 ((get_max_number(first) - get_min_number(first)) / my_sqrt(len));
+	return (diff / my_sqrt(len));
 }

checker/check_error.c

@@ -11,6 +11,17 @@
 /* ************************************************************************** */
 
 #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(char **tab, int mod)
 {
@@ -22,7 +33,7 @@ int	check_error(char **tab, int mod)
 		return (0);
 	if (!verif_double(tab, mod))
 		return (0);
+	if (!verif_is_number(tab))
+		return (0);
 	return (1);
 }
-
-

checker/verif_flag.c

@@ -17,10 +17,11 @@ static int	is_exist_flag(char **tab, int pos)
 	int	verif;
 
 	verif = 0;
-	if (ft_strncmp(tab[pos], "--bench", 7)
-		|| ft_strncmp(tab[pos], "--simple", 8)
-		|| ft_strncmp(tab[pos], "--medium", 8)
-		|| ft_strncmp(tab[pos], "--complex", 9))
+	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);
 }
@@ -40,7 +41,7 @@ static int	verif_exist_flag(char **tab, int mod)
 	return (verif);
 }
 
-static int verif_double_flag(char **tab, int mod)
+static int	verif_double_flag(char **tab, int mod)
 {
 	int	verif;
 

checker/verif_is_digit.c

@@ -12,14 +12,17 @@
 
 #include "parsing.h"
 
-static int	scan_str_is_digit(char *tab)
+int	scan_str_is_digit(char *tab)
 {
 	int	i;
 
 	i = 0;
 	while (tab[i])
 	{
-		if (!ft_isdigit(tab[i]) && (tab[i] == '-' && !ft_isdigit(tab[i + 1])))
+		if ((tab[i] == '+' || tab[i] == '-') && ft_isdigit(tab[i + 1])
+			&& tab[i + 1])
+			i++;
+		if (!ft_isdigit(tab[i]))
 			return (0);
 		i++;
 	}

checker/verif_overflow.c

@@ -21,6 +21,8 @@ static int	verif_atoi(const char *nptr)
 	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] == '+')

flags/algorithms_sort.c

@@ -12,6 +12,7 @@
 
 #include "push_swap.h"
 #include "medium_headers.h"
+#include "parsing.h"
 
 void	simple(t_stacks *stacks)
 {
@@ -36,6 +37,8 @@ void	medium(t_stacks *stacks)
 	{
 		range = range_bucket(stacks->a);
 		buckets = get_tabs(stacks->a, range);
+		if (!buckets)
+			return ;
 		bucket_algo(stacks, buckets, range);
 	}
 }
@@ -46,8 +49,20 @@ void	complex(t_stacks *stacks)
 	radix(stacks);
 }
 
-void	adaptive(t_stacks *stacks)
+void	adaptive(t_stacks *stacks, char **tab)
 {
-	(void)stacks;
+	int		i;
+	float	disorder;
+
+	i = 0;
+	while (!ft_isdigit(tab[i][0]) && tab[i])
+		i++;
+	disorder = stacks->disorder;
+	if (disorder < 0.3)
+		simple(stacks);
+	else if (disorder < 0.5)
+		medium(stacks);
+	else
+		complex(stacks);
 	return ;
 }

flags/bench.c

@@ -13,7 +13,6 @@
 #include "push_swap.h"
 #include "parsing.h"
 #include <unistd.h>
-#include <stdlib.h>
 
 static void	print_disorder(t_stacks *stacks)
 {

flags/flag.c

@@ -14,48 +14,14 @@
 #include "parsing.h"
 #include "flags.h"
 
-static int	verif_arg(char *argv)
-{
-	int		len;
-	int		verif;
-	char	**split;
-
-	split = ft_split(argv, ' ');
-	if (!split)
-		return (-1);
-	len = len_split(split);
-	if (len > 1)
-		verif = 1;
-	else
-		verif = 0;
-	free_tab(split);
-	return (verif);
-}
-
 int	calcul_mod(int argc, char **argv)
 {
 	int	mod;
 
-	if (verif_arg(argv[argc -1]) == 0)
-	{
-		if (ft_strncmp("--", argv[1], 2) && ft_strncmp("--", argv[2], 2))
-			mod = 2;
-		else if (ft_strncmp("--", argv[1], 2) && !ft_strncmp("--", argv[2], 2))
-			mod = 1;
-		else
-			mod = 0;
-	}
-	else if (verif_arg(argv[argc -1]) == 1)
-	{
-		if (ft_strncmp("--", argv[1], 2) && ft_strncmp("--", argv[2], 2))
-			mod = 5;
-		else if (ft_strncmp("--", argv[1], 2) && !ft_strncmp("--", argv[2], 2))
-			mod = 4;
-		else
-			mod = 3;
-	}
-	else
-		mod = -1;
+	mod = 0;
+	while (argv[mod] && !ft_isdigit(argv[mod][0]) && mod < argc)
+		mod++;
+	mod--;
 	return (mod);
 }
 
@@ -102,9 +68,9 @@ void	flags(int pos, int pos_b, char **argv, t_stacks *stacks)
 	else if (ft_strncmp(argv[pos], "--complex", 30) && pos > 0)
 		complex(stacks);
 	else if (ft_strncmp(argv[pos], "--adaptive", 30) && pos > 0)
-		adaptive(stacks);
+		adaptive(stacks, argv);
 	else
-		adaptive(stacks);
+		adaptive(stacks, argv);
 	if (pos_b > 0)
 		stacks->bench = 1;
 }

includes/check_error.h

@@ -18,5 +18,6 @@ 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);
 
 #endif

includes/flags.h

@@ -16,7 +16,7 @@
 void	simple(t_stacks *stacks);
 void	medium(t_stacks *stacks);
 void	complex(t_stacks *stacks);
-void	adaptive(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);

includes/parsing.h

@@ -33,6 +33,6 @@ 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);
+float		compute_disorder(char **strs, int pos);
 
 #endif

includes/push_swap.h

@@ -40,8 +40,6 @@ typedef struct s_stacks
 	unsigned int	ss;
 }	t_stacks;
 
-/* PRINT STACK FUNCTION*/
-void	print_stacks(t_stacks *stacks, int len, t_stack *a, t_stack *b);
 /*STACK_FUNCTIONS*/
 void	pa(t_stacks *stacks);
 void	pb(t_stacks *stacks);

main.c

@@ -22,6 +22,8 @@ int	main(int argc, char **argv)
 	int		mod;
 	int		len;
 
+	if (argc < 2)
+		return (0);
 	tab = split_all(join_all(argc, argv));
 	if (!tab)
 		return (0);

parsing/disorder.c

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

parsing/ft_split.c

@@ -10,7 +10,6 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include <stdlib.h>
 #include "parsing.h"
 
 static size_t	count_words(char const *s, char c)

parsing/ft_strjoin.c

@@ -14,7 +14,7 @@
 
 char	*ft_strjoin(char const *s1, char const *s2)
 {
-	int	total_len;
+	int		total_len;
 	char	*tmp;
 
 	total_len = ft_strlen(s1) + ft_strlen(s2);

parsing/ft_substr.c

@@ -10,7 +10,6 @@
 /*                                                                            */
 /* ************************************************************************** */
 
-#include <stdlib.h>
 #include "parsing.h"
 
 char	*ft_substr(char const *s, unsigned int start, size_t len)

parsing/parsing.c

@@ -12,17 +12,10 @@
 
 #include "push_swap.h"
 #include "parsing.h"
-#include <stdlib.h>
 
 int	wich_mod(int mod)
 {
-	if (mod == 0)
-		return (1);
-	else if (mod == 1)
-		return (2);
-	else if (mod == 2)
-		return (3);
-	return (0);
+	return (mod % 3 + 1);
 }
 
 static t_stack	*parsing(int argc, char **argv, int mod)
@@ -51,28 +44,6 @@ static t_stack	*parsing(int argc, char **argv, int mod)
 	return (first);
 }
 
-static t_stack	*special_parsing(char **argv, int mod)
-{
-	t_stack		*a;
-	char		**split_tab;
-	int			len;
-	int			i;
-
-	i = mod % 3 + 1;
-	split_tab = ft_split(argv[i], ' ');
-	if (!split_tab)
-		return (NULL);
-	len = len_split(split_tab);
-	a = parsing(len, split_tab, mod);
-	if (!a)
-	{
-		free_tab(split_tab);
-		return (NULL);
-	}
-	free_tab(split_tab);
-	return (a);
-}
-
 static void	set_t_stacks(t_stacks *stacks)
 {
 	stacks->a = NULL;
@@ -102,10 +73,7 @@ t_stacks	*init_stacks(int argc, char **argv, int mod)
 	if (!stacks)
 		return (NULL);
 	set_t_stacks(stacks);
-	if (mod == 0 || mod == 1 || mod == 2)
-		a = parsing(argc, argv, mod);
-	else
-		a = special_parsing(argv, mod);
+	a = parsing(argc, argv, mod);
 	if (!a)
 	{
 		free(stacks);

stack_utils/print_stacks.c

@@ -1,42 +0,0 @@
-/* ************************************************************************** */
-/*                                                                            */
-/*                                                        :::      ::::::::   */
-/*   print_stacks.c                                     :+:      :+:    :+:   */
-/*                                                    +:+ +:+         +:+     */
-/*   By: dgaillet <dgaillet@student.42.fr>          +#+  +:+       +#+        */
-/*                                                +#+#+#+#+#+   +#+           */
-/*   Created: 2025/12/09 13:10:00 by dgaillet          #+#    #+#             */
-/*   Updated: 2025/12/09 13:36:03 by dgaillet         ###   ########lyon.fr   */
-/*                                                                            */
-/* ************************************************************************** */
-
-#include "push_swap.h"
-#include <stdio.h>
-
-void	print_stacks(t_stacks *stacks, int len, t_stack *a, t_stack *b)
-{
-	int		a_len;
-	int		b_len;
-	int		i;
-
-	i = 0;
-	a_len = stack_a_len(stacks);
-	b_len = stack_b_len(stacks);
-	while (i < len)
-	{
-		if (a_len >= len - i)
-		{
-			printf("%d", a->value);
-			a = a->next;
-		}
-		printf("\t");
-		if (b_len >= len - i)
-		{
-			printf("%d", b->value);
-			b = b->next;
-		}
-		printf("\n");
-		i++;
-	}
-	printf("_\t_\nA\tB\n\n");
-}

test_one.c

@@ -14,7 +14,6 @@
 #include "flags.h"
 #include "parsing.h"
 #include "medium_headers.h"
-#include <stdlib.h>
 
 int	test1(char **tab, int len, int mod)
 {
@@ -27,7 +26,11 @@ int	test1(char **tab, int len, int mod)
 	if (!stacks)
 		return (0);
 	if (check_order(stacks->a))
+	{
+		free_all(stacks);
 		return (0);
+	}
+	stacks->disorder = compute_disorder(tab, wich_mod(mod));
 	flags(pos_flag(tab, mod), pos_bench(tab, mod), tab, stacks);
 	if (stacks->bench == 1)
 		print_bench(stacks);