oprations done

Makefile

@@ -6,7 +6,7 @@
 #    By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2023/11/01 11:03:22 by adjoly            #+#    #+#              #
-#    Updated: 2024/02/08 18:39:49 by adjoly           ###   ########.fr        #
+#    Updated: 2024/02/13 14:04:13 by adjoly           ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -25,6 +25,8 @@ SRCS = main.c \
 		stack/ft_stacksize.c \
 		operations/ft_swapstack.c \
 		operations/ft_pushstack.c \
+		operations/ft_rotatestack.c \
+		operations/ft_reverserotate.c \
 
 OBJS = $(SRCS:.c=.o)
 

main.c

@@ -6,7 +6,7 @@
 /*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/04 12:14:22 by adjoly            #+#    #+#             */
-/*   Updated: 2024/02/12 14:18:37 by adjoly           ###   ########.fr       */
+/*   Updated: 2024/02/13 14:04:47 by adjoly           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,21 +14,20 @@
 
 int	main(int ac, char **av)
 {
-	t_stack	*stack;
+	t_stack	*stack_a;
 	t_stack	*tmp;
 	t_stack	*stack_b;
 
-	stack = ft_parsing(ac, av);
-	tmp = stack;
+	stack_a = ft_parsing(ac, av);
+	tmp = stack_a;
 	stack_b = NULL;
 	while (tmp)
 	{
 		ft_printf("%d\n", tmp->nb);
 		tmp = tmp->next;
 	}
-	ft_push_b(&stack, &stack_b);
-	ft_swap_a(stack);
-	tmp = stack;
+	ft_reverserotate_a(&stack_a);
+	tmp = stack_a;
 	while (tmp)
 	{
 		ft_printf("%d\n", tmp->nb);
@@ -41,7 +40,7 @@ int	main(int ac, char **av)
 		ft_printf("%d\n", tmp->nb);
 		tmp = tmp->next;
 	}
-	ft_stackclear(&stack);
+	ft_stackclear(&stack_a);
 	ft_stackclear(&stack_b);
 	return (0);
 }

operations/ft_pushstack.c

@@ -6,7 +6,7 @@
 /*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/08 18:08:51 by adjoly            #+#    #+#             */
-/*   Updated: 2024/02/09 15:48:39 by adjoly           ###   ########.fr       */
+/*   Updated: 2024/02/12 17:24:55 by adjoly           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 

operations/ft_reverserotate.c

@@ -0,0 +1,42 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_reverserotate.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/02/13 13:41:25 by adjoly            #+#    #+#             */
+/*   Updated: 2024/02/13 14:05:13 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../push_swap.h"
+
+void	ft_reverserotate(t_stack **stack)
+{
+	t_stack	*bfrlast;
+	t_stack	*last;
+	t_stack	*stack_start;
+
+	if (!stack || !(*stack) || !(*stack)->next)
+		return ;
+	bfrlast = ft_stackbeforelast(*stack);
+	last = ft_stacklast(*stack);
+	bfrlast->next = NULL;
+	stack_start = (*stack);
+	(*stack) = last;
+	(*stack)->next = stack_start;
+}
+
+void	ft_reverserotate_a(t_stack **stack_a)
+{
+	ft_putendl_fd("rra", STDOUT_FILENO);
+	ft_reverserotate(stack_a);
+}
+
+void	ft_reverserotate_b(t_stack **stack_b)
+{
+	ft_putendl_fd("rrb", STDOUT_FILENO);
+	ft_reverserotate(stack_b);
+}
+

operations/ft_rotatestack.c

@@ -0,0 +1,38 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   ft_rotatestack.c                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/02/13 12:53:55 by adjoly            #+#    #+#             */
+/*   Updated: 2024/02/13 13:36:51 by adjoly           ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../push_swap.h"
+
+void	ft_rotatestack(t_stack **stack)
+{
+	t_stack	*tmp_last;
+	t_stack	*start;
+
+	start = (*stack)->next;
+	tmp_last = ft_stacklast(*stack);
+	tmp_last->next = *stack;
+	(*stack)->next = NULL;
+	(*stack) = start;
+}
+
+void	ft_rotatestack_a(t_stack **stack_a)
+{
+	ft_putendl_fd("ra", STDOUT_FILENO);
+	ft_rotatestack(stack_a);
+}
+
+void	ft_rotatestack_b(t_stack **stack_b)
+{
+	ft_putendl_fd("rb", STDOUT_FILENO);
+	ft_rotatestack(stack_b);
+}
+

push_swap.h

@@ -6,7 +6,7 @@
 /*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/04 12:18:29 by adjoly            #+#    #+#             */
-/*   Updated: 2024/02/09 15:49:14 by adjoly           ###   ########.fr       */
+/*   Updated: 2024/02/13 14:03:29 by adjoly           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -30,6 +30,7 @@ void	ft_stackdelone(t_stack *stack);
 t_stack	*ft_stacklast(t_stack *stack);
 t_stack	*ft_stacknew(int content);
 size_t	ft_stacksize(t_stack *stack);
+t_stack *ft_stackbeforelast(t_stack *stack);
 
 void	ft_swap_a(t_stack *stack_a);
 void	ft_swap_b(t_stack *stack_b);
@@ -37,4 +38,10 @@ void	ft_stack_ss(t_stack *stack_a, t_stack *stack_b);
 
 void	ft_push_a(t_stack **stack_a, t_stack **stack_b);
 void	ft_push_b(t_stack **stack_a, t_stack **stack_b);
+
+void	ft_rotatestack_a(t_stack **stack_a);
+void	ft_rotatestack_b(t_stack **stack_b);
+
+void	ft_reverserotate_a(t_stack **stack_a);
+void	ft_reverserotate_b(t_stack **stack_b);
 #endif

push_swap_tuto.c

@@ -1,178 +0,0 @@
-#include <stdio.h>
-#include <stdlib.h>
-
-typedef struct s_stack
-{
-	int				nb_init;
-	int				nb;
-	struct s_stack	*next;
-}					t_stack;
-
-t_stack	*ft_stacknew(int content)
-{
-	/* creer avec malloc(), un maillon avec comme nb_init -> content*/
-	t_stack	*new;
-
-	new = malloc(sizeof(t_stack));
-	return (NULL);
-}
-
-int	ft_stacksize(t_stack *stack)
-{
-	/*donne la taille d'une t_stack*/
-	return (0);
-}
-
-void	ft_stackadd_back(t_stack **stack, t_stack *new)
-{
-	/* ajoute a la fin de stack -> new*/
-	return ;
-}
-
-t_stack	*ft_stacklast(t_stack *stack)
-{
-	/* renvoie le dernier maillon*/
-	return (NULL);
-}
-
-void	ft_stackadd_front(t_stack **stack, t_stack *new)
-{
-	/* ajoute au debut de stack -> new*/
-	return ;
-}
-
-int	ft_verif_nb(char const *str)
-{
-	/*verifie que un str est un nombre valable,
-	qu'il passe dans atoi,
-	et qu'il ne depasse pas les limites des int*/
-
-	/*renvoie un booléen si le nb est 
-	valide(1)
-	invalide (0)*/
-	return (0);
-}
-
-t_stack *fill_struct(int ac, char **av)
-{
-	/*remplie la structure avec les élements de av
-	-> il faut split chaque av
-	"3 2" "1 10" "5" -> 3 2 1 10 5
-	et verifier que chaque nb passe dans atoi
-	
-	puis utiliser atoi pour remplir la structure choisit
-	
-	si un nb est invalide, ne pas oublier de free, et renvoyer NULL*/
-}
-
-int	verif_double(t_stack *stack)
-{
-	/*verifie si la liste ne contient aucun doublons*/
-
-	/*renvoie un booléen si la liste est
-	bonne (aucun doublons) -> (1)
-	pas bonne (1 ou plusieurs doublons) -> (0)*/
-	return (0);
-}
-
-//j'espere que le debut étais pas trop dur car voici un premier gros defi
-// tu dois "lisser" toutes les valeur, a partir de 0, et il n'y aura pas d'ecart superieur a 1
-// pour ca tu va assiger a chaque maillon->nb une valeur
-// qui depend de toute les nb_init de la list
-// 0 1000 2 2000 -> 0 2 1 3
-// -4 1 9 5 2 8 4 -> 0 1 6 4 2 5 3
-// une vision simple de le voir/le coder:
-//compter combien d'element dans toute la liste possede un nb_init en dessous du nb_init conserner
-void	replace_nb_init(t_stack *stack)
-{
-	/*assigne pour chaque maillon, un nb,
-	ce nb est la possition finale dans la liste trier qu'il aura*/
-}
-
-
-
-// mtn que tu a modifier tous et simplifier les nb_init dans nb
-// a partir de mtn tu ne touche plus du tout a nb_init,
-// uniquement a nb
-
-int	is_sorted(t_stack *stack_a)
-{
-	/*verifie si la liste est trier*/
-
-	/*renvoie un booléen si la liste est
-	trier(1)
-	pas trier(0)*/
-	return (0);
-}
-
-
-
-// il va falloir attendre la v2 pour les tests des fonctions a partir de mtn
-//, et pour les explications plus soffistiquer de la sutie:)
-// mais tu peux quand meme les faire sans aide ? :)
-
-void	sa(t_stack *stack_a)
-{
-	/*echange les 2 elements en haut de la pile
-	print "sa"*/
-}
-
-void	sb(t_stack *stack_b)
-{
-	/*echange les 2 elements en haut de la pile
-	print "sb"*/
-}
-
-void	ss(t_stack *stack_a, t_stack *stack_b)
-{
-	/*effectue sa et sb
-	print "ss"*/
-}
-
-void	pa(t_stack *stack_a, t_stack *stack_b)
-{
-	/*envoie l'element en haut de la pile b -> en haut de la pile a
-	print "pa"*/
-}
-
-void	pb(t_stack *stack_a, t_stack *stack_b)
-{
-	/*envoie l'element en haut de la pile a -> en haut de la pile b
-	print "pb"*/
-}
-
-void	ra(t_stack *stack_a)
-{
-	/*envoie l'element en haut de la pile a -> en bas de la pile a
-	print "ra"*/
-}
-
-void	rb(t_stack *stack_b)
-{
-	/*envoie l'element en haut de la pile b -> en bas de la pile b
-	print "rb"*/
-}
-
-void	rr(t_stack *stack_a, t_stack *stack_b)
-{
-	/*effectue ra et rb
-	print "rr"*/
-}
-
-void	rra(t_stack *stack_a)
-{
-	/*envoie l'element en bas de la pile a -> en haut de la pile a
-	print "rra"*/
-}
-
-void	rrb(t_stack *stack_b)
-{
-	/*envoie l'element en bas de la pile b -> en haut de la pile b
-	print "rrb"*/
-}
-
-void	rrr(t_stack *stack_a, t_stack *stack_b)
-{
-	/*effectue rra et rrb
-	print "rrr"*/
-}

stack/ft_stacklast.c

@@ -6,7 +6,7 @@
 /*   By: adjoly <adjoly@student.42angouleme.fr>     +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/02/06 10:18:01 by adjoly            #+#    #+#             */
-/*   Updated: 2024/02/08 16:24:36 by adjoly           ###   ########.fr       */
+/*   Updated: 2024/02/13 13:40:36 by adjoly           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -25,3 +25,16 @@ t_stack *ft_stacklast(t_stack *stack)
 
 }
 
+t_stack *ft_stackbeforelast(t_stack *stack)
+{
+	t_stack	*tmp;
+
+	if (!stack)
+		return (NULL);
+	tmp = stack;
+	while (tmp && tmp->next && tmp->next->next)
+		tmp = tmp->next;
+	return (tmp);
+
+}
+