Make norminette happy

diff --git a/cmd_optimization.c b/cmd_optimization.c
index d0928f5b13da4580e8c7f7cc2655aed218eb68e9..ac023c54ef11b2eea81b9054e6b28f361f9bd0c4 100644 (file)
--- a/cmd_optimization.c
+++ b/cmd_optimization.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 16:42:34 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/17 09:41:10 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:55:55 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,79 +14,77 @@
 #include "libft/libft.h"
 #include "push_swap.h"
 
-static enum e_pscmd get_cmd(t_list *cmd)
+static enum e_pscmd    get_cmd(t_list *cmd)
 {
-    if (cmd)
-        return (*(enum e_pscmd*)cmd->content);
-    else
-        return NO_CMD;
+       if (cmd)
+               return (*(enum e_pscmd *)cmd->content);
+       else
+               return (NO_CMD);
 }
 
-static void optimize_redundant(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2)
+static void    optimize_redundant(t_psdata *data, enum e_pscmd cmd1,
+               enum e_pscmd cmd2)
 {
-    t_list *cur;
-    t_list *last;
-    int optimizations;
+       t_list  *cur;
+       t_list  *last;
+       int             optimizations;
 
-    cur = data->cmds;
-    last = cur;
-    optimizations = 0;
-
-    if (!cur)
-        return ;
-    while (cur && cur->next)
-    {
-        if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
-        {
-            last->next = cur->next->next;
-            ft_lstdelone(cur->next, free);
-            ft_lstdelone(cur, free);
-            optimizations++;
-        }
-        last = last->next;
-        if (last)
-            cur = last->next;
-        else
-            cur = NULL;
-    }
-    if (optimizations)
-        optimize_redundant(data, cmd1, cmd2);
+       cur = data->cmds;
+       last = cur;
+       optimizations = 0;
+       while (cur && cur->next)
+       {
+               if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+                       || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+               {
+                       last->next = cur->next->next;
+                       ft_lstdelone(cur->next, free);
+                       ft_lstdelone(cur, free);
+                       optimizations++;
+               }
+               last = last->next;
+               if (last)
+                       cur = last->next;
+               else
+                       cur = NULL;
+       }
+       if (optimizations)
+               optimize_redundant(data, cmd1, cmd2);
 }
 
-static void optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2, enum e_pscmd new_cmd)
+static void    optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1,
+               enum e_pscmd cmd2, enum e_pscmd new_cmd)
 {
-    t_list *cur;
-    t_list *last;
-    int optimizations;
-
-    cur = data->cmds;
-    last = cur;
-    optimizations = 0;
+       t_list  *cur;
+       t_list  *last;
+       int             optimizations;
 
-    if (!cur)
-        return ;
-    while (cur && cur->next)
-    {
-        if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
-        {
-            last->next = cur->next;
-            *(enum e_pscmd*)cur->next->content = new_cmd;
-            ft_lstdelone(cur, free);
-            optimizations++;
-        }
-        last = last->next;
-        if (last)
-            cur = last->next;
-        else
-            cur = NULL;
-    }
-    if (optimizations)
-        optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
+       cur = data->cmds;
+       last = cur;
+       optimizations = 0;
+       while (cur && cur->next)
+       {
+               if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+                       || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+               {
+                       last->next = cur->next;
+                       *(enum e_pscmd *)cur->next->content = new_cmd;
+                       ft_lstdelone(cur, free);
+                       optimizations++;
+               }
+               last = last->next;
+               if (last)
+                       cur = last->next;
+               else
+                       cur = NULL;
+       }
+       if (optimizations)
+               optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
 }
 
-void optimize_commands(t_psdata *data)
+void   optimize_commands(t_psdata *data)
 {
-    optimize_redundant(data, PA, PB);
-    optimize_redundant(data, RB, RRB);
-    optimize_two_stack_ops(data, RA, RB, RR);
+       optimize_redundant(data, PA, PB);
+       optimize_redundant(data, RB, RRB);
+       optimize_two_stack_ops(data, RA, RB, RR);
 }

diff --git a/command_handling.c b/command_handling.c
index 0b5f335c7e6e83cbc650a3bc8b72554ce83671e7..7599bdf73c0dbb49f5fc954db83fb97006ac2a74 100644 (file)
--- a/command_handling.c
+++ b/command_handling.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 14:38:47 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 09:27:41 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:55:07 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -20,7 +20,7 @@ static int    add_cmd_to_queue(t_list **cmds, enum e_pscmd cmd)
        ptr_cmd = malloc(sizeof(enum e_pscmd));
        if (!ptr_cmd)
                return (1);
-    *ptr_cmd = cmd;
+       *ptr_cmd = cmd;
        new_elem = ft_lstnew(ptr_cmd);
        if (!new_elem)
        {
@@ -96,5 +96,5 @@ static void   print_cmd(void *ptr_cmd)
 
 void   print_commands(t_list *cmds)
 {
-    ft_lstiter(cmds, print_cmd);
+       ft_lstiter(cmds, print_cmd);
 }

diff --git a/input_handling.c b/input_handling.c
index 078ab7fadd64fec97baf9a951702983ab9818c6d..274a0fbe36e41dc095580fb9ee8b44963299186c 100644 (file)
--- a/input_handling.c
+++ b/input_handling.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 17:31:49 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 16:24:51 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:55:13 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -39,8 +39,8 @@ static int    is_input_only_nbrs(int argc, char *argv[])
 
 static int     are_numbers_unique(int *stack, int size)
 {
-       int i;
-       int k;
+       int     i;
+       int     k;
 
        i = 0;
        while (i < size - 1)
@@ -54,36 +54,33 @@ static int  are_numbers_unique(int *stack, int size)
                }
                i++;
        }
-
        return (1);
 }
 
 static int     *get_array_from_input(int argc, char *argv[])
 {
-       int *stack;
-       int i;
+       int     *stack;
+       int     i;
 
        stack = malloc(sizeof(int) * (argc - 1));
        if (!stack)
-               return NULL;
-
+               return (NULL);
        i = 0;
        while (i < argc - 1)
        {
                stack[i] = ft_atoi(argv[i + 1]);
                i++;
        }
-
        return (stack);
 }
 
 t_stack        *create_stack(int argc, char *argv[])
 {
-       t_stack *result;
+       t_stack *result;
 
        result = malloc(sizeof(t_stack));
        if (!result)
-               return NULL;
+               return (NULL);
        if (!is_input_only_nbrs(argc, argv))
                return (free(result), NULL);
        result->stack = get_array_from_input(argc, argv);
@@ -96,6 +93,5 @@ t_stack       *create_stack(int argc, char *argv[])
                return (NULL);
        }
        result->size = argc - 1;
-
        return (result);
 }

diff --git a/main.c b/main.c
index 3881df03ddbfcd50e98b745ebb2ff9d5a2758d58..b7ce3ab2f9275e465c0548ebfe1c15a6d8ad1e00 100644 (file)
--- a/main.c
+++ b/main.c
@@ -6,14 +6,14 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 17:03:30 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/17 09:42:43 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:54:51 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "libft/ft_printf.h"
 #include "push_swap.h"
 
-static void free_data(t_psdata *data)
+static void    free_data(t_psdata *data)
 {
        if (data)
        {
@@ -33,9 +33,9 @@ static void free_data(t_psdata *data)
        }
 }
 
-static t_psdata *initialize_data(int argc, char *argv[])
+static t_psdata        *initialize_data(int argc, char *argv[])
 {
-       t_psdata *result;
+       t_psdata        *result;
 
        result = malloc(sizeof(t_psdata));
        if (result)
@@ -50,18 +50,18 @@ static t_psdata *initialize_data(int argc, char *argv[])
                                if (result->b->stack)
                                {
                                        result->b->size = 0;
-                                       return result;
+                                       return (result);
                                }
                        }
                }
        }
        free_data(result);
-       return NULL;
+       return (NULL);
 }
 
 int    main(int argc, char *argv[])
 {
-       t_psdata *data;
+       t_psdata        *data;
 
        data = initialize_data(argc, argv);
        if (!data)
@@ -73,9 +73,5 @@ int   main(int argc, char *argv[])
        stack_sort(data);
        optimize_commands(data);
        print_commands(data->cmds);
-       /* ft_printf("\nA: "); */
-       /* stack_print(data->a); */
-       /* ft_printf("B: "); */
-       /* stack_print(data->b); */
        return (0);
 }

diff --git a/push_swap.h b/push_swap.h
index fc7b51a51fa5f7de8e573c55570a22a1479ff547..3091fb8bce5f530a4ef432c076d2b32d849ddde5 100644 (file)
--- a/push_swap.h
+++ b/push_swap.h
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 16:59:09 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 17:57:33 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:54:38 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -15,7 +15,7 @@
 # include "libft/libft.h"
 # include <stdlib.h>
 
-enum   e_pscmd
+enum           e_pscmd
 {
        SA,
        SB,
@@ -33,31 +33,31 @@ enum        e_pscmd
 
 typedef struct s_stack
 {
-       int *stack;
-       int size;
-} t_stack;
+       int             *stack;
+       int             size;
+}                      t_stack;
 
 typedef struct s_psdata
 {
-       t_stack *a;
-       t_stack *b;
-       t_list *cmds;
-} t_psdata;
+       t_stack *a;
+       t_stack *b;
+       t_list  *cmds;
+}                      t_psdata;
 
-t_stack        *create_stack(int argc, char *argv[]);
+t_stack                *create_stack(int argc, char *argv[]);
 
-void   stack_swap(t_stack *stack);
-void   stack_push(t_stack *dst_stack, t_stack *src_stack);
-void   stack_rotate(t_stack *stack);
-void   stack_rrotate(t_stack *stack);
-void stack_print(t_stack *stack);
+void           stack_swap(t_stack *stack);
+void           stack_push(t_stack *dst_stack, t_stack *src_stack);
+void           stack_rotate(t_stack *stack);
+void           stack_rrotate(t_stack *stack);
+void           stack_print(t_stack *stack);
 
-void   run_command(t_psdata *data, enum e_pscmd cmd);
-void   print_commands(t_list *cmds);
+void           run_command(t_psdata *data, enum e_pscmd cmd);
+void           print_commands(t_list *cmds);
 
-int    stack_optimize(t_stack *stack);
-void   optimize_commands(t_psdata *data);
+int                    stack_optimize(t_stack *stack);
+void           optimize_commands(t_psdata *data);
 
-void   stack_sort(t_psdata *data);
+void           stack_sort(t_psdata *data);
 
 #endif // PUSH_SWAP_H

diff --git a/sorting.c b/sorting.c
index 8f5d31f35c9ddc7a562215ee00f78587df0f3457..ec8a33647506c0933bf60757b2113feeccee514e 100644 (file)
--- a/sorting.c
+++ b/sorting.c
@@ -6,13 +6,51 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 15:04:19 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 09:27:53 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:54:26 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "push_swap.h"
 
-void stack_sort(t_psdata *data)
+static int     is_sorted(t_stack *stack)
 {
+       int     i;
 
+       if (stack->size < 2)
+               return (1);
+       i = 1;
+       while (i < stack->size)
+       {
+               if (stack->stack[i] < stack->stack[i - 1])
+                       return (0);
+               i++;
+       }
+       return (1);
+}
+
+static void    ps_radixsort(t_psdata *data, int bit)
+{
+       int     i;
+       int     size;
+
+       i = 0;
+       size = data->a->size;
+       while (i < size)
+       {
+               if (data->a->size && ((data->a->stack[0] >> bit) & 1) == 0)
+                       run_command(data, PB);
+               else if (data->a->size > 1)
+                       run_command(data, RA);
+               i++;
+       }
+       while (data->b->size > 0)
+               run_command(data, PA);
+       if (!is_sorted(data->a))
+               ps_radixsort(data, bit + 1);
+}
+
+void   stack_sort(t_psdata *data)
+{
+       if (!is_sorted(data->a))
+               ps_radixsort(data, 0);
 }

diff --git a/stack_optimization.c b/stack_optimization.c
index eabf04a5e3e5f93df375ff166cfe54133ea8bcb3..18b8bf9f73f0b80549b83edaa29847f38d5828a0 100644 (file)
--- a/stack_optimization.c
+++ b/stack_optimization.c
@@ -6,36 +6,35 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 15:25:05 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 16:20:51 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:53:59 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "push_swap.h"
 #include <stdlib.h>
 
-static int *copy_stack(int *stack, int size)
+static int     *copy_stack(int *stack, int size)
 {
-       int i;
-       int *cpy;
+       int     i;
+       int     *cpy;
 
        cpy = malloc(sizeof(int) * size);
        if (!cpy)
-               return NULL;
+               return (NULL);
        i = 0;
        while (i < size)
        {
                cpy[i] = stack[i];
                i++;
        }
-
-       return cpy;
+       return (cpy);
 }
 
-static void sort_stack(int *stack, int size)
+static void    sort_stack(int *stack, int size)
 {
-       int i;
-       int k;
-       int tmp;
+       int     i;
+       int     k;
+       int     tmp;
 
        i = 0;
        while (i < size - 1)
@@ -55,10 +54,10 @@ static void sort_stack(int *stack, int size)
        }
 }
 
-static void override_stack(int *stack, int *tmp_stack, int size)
+static void    override_stack(int *stack, int *tmp_stack, int size)
 {
-       int i;
-       int k;
+       int     i;
+       int     k;
 
        i = 0;
        while (i < size)
@@ -73,13 +72,13 @@ static void override_stack(int *stack, int *tmp_stack, int size)
 
 int    stack_optimize(t_stack *stack)
 {
-       int *tmp_stack;
+       int     *tmp_stack;
 
        tmp_stack = copy_stack(stack->stack, stack->size);
        if (!tmp_stack)
-               return 1;
+               return (1);
        sort_stack(tmp_stack, stack->size);
        override_stack(stack->stack, tmp_stack, stack->size);
        free(tmp_stack);
-       return 0;
+       return (0);
 }

diff --git a/stack_utils.c b/stack_utils.c
index f240395ba6578938d97a1c40729ceba3d0a10ba8..d798d7098dff4478a3650660d153aa18d5245725 100644 (file)
--- a/stack_utils.c
+++ b/stack_utils.c
@@ -6,7 +6,7 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/12 20:31:30 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/15 21:53:40 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/26 13:56:13 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,7 +14,7 @@
 
 void   stack_swap(t_stack *stack)
 {
-       int tmp;
+       int     tmp;
 
        if (stack->size > 1)
        {
@@ -26,12 +26,12 @@ void        stack_swap(t_stack *stack)
 
 void   stack_push(t_stack *dst_stack, t_stack *src_stack)
 {
-       int i;
+       int     i;
 
        i = dst_stack->size;
        while (i > 0)
        {
-               dst_stack->stack[i] = dst_stack->stack[i-1];
+               dst_stack->stack[i] = dst_stack->stack[i - 1];
                i--;
        }
        dst_stack->stack[0] = src_stack->stack[0];
@@ -39,7 +39,7 @@ void  stack_push(t_stack *dst_stack, t_stack *src_stack)
        i = 1;
        while (i < src_stack->size)
        {
-               src_stack->stack[i-1] = src_stack->stack[i];
+               src_stack->stack[i - 1] = src_stack->stack[i];
                i++;
        }
        src_stack->size--;
@@ -47,37 +47,37 @@ void        stack_push(t_stack *dst_stack, t_stack *src_stack)
 
 void   stack_rotate(t_stack *stack)
 {
-       int tmp;
-       int i;
+       int     tmp;
+       int     i;
 
        tmp = stack->stack[0];
        i = 1;
        while (i < stack->size)
        {
-               stack->stack[i-1] = stack->stack[i];
+               stack->stack[i - 1] = stack->stack[i];
                i++;
        }
-       stack->stack[i-1] = tmp;
+       stack->stack[i - 1] = tmp;
 }
 
 void   stack_rrotate(t_stack *stack)
 {
-       int tmp;
-       int i;
+       int     tmp;
+       int     i;
 
        i = stack->size - 1;
        tmp = stack->stack[i];
        while (i > 0)
        {
-               stack->stack[i] = stack->stack[i-1];
+               stack->stack[i] = stack->stack[i - 1];
                i--;
        }
        stack->stack[0] = tmp;
 }
 
-void stack_print(t_stack *stack)
+void   stack_print(t_stack *stack)
 {
-       int i;
+       int     i;
 
        i = 0;
        while (i < stack->size)