Work on optimization (still not working)

diff --git a/cmd_optimization.c b/cmd_optimization.c
index 63be895526c98205a8a5fcba2db6ee2b87587675..3aeaf8b716ad0e33b95607d6af6012c5ed75a233 100644 (file)
--- a/cmd_optimization.c
+++ b/cmd_optimization.c
@@ -6,13 +6,14 @@
 /*   By: dkaiser <dkaiser@student.42heilbronn.de    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2024/04/13 16:42:34 by dkaiser           #+#    #+#             */
-/*   Updated: 2024/04/16 13:15:34 by dkaiser          ###   ########.fr       */
+/*   Updated: 2024/04/16 17:33:54 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "libft/ft_printf.h"
 #include "libft/libft.h"
 #include "push_swap.h"
+#include <stdlib.h>
 
 static enum e_pscmd get_cmd(t_list *cmd)
 {
@@ -22,7 +23,7 @@ static enum e_pscmd get_cmd(t_list *cmd)
         return NO_CMD;
 }
 
-static void optimize_redundant_pushes(t_psdata *data)
+static void optimize_redundant(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2)
 {
     t_list *cur;
     t_list *last;
@@ -32,9 +33,11 @@ static void optimize_redundant_pushes(t_psdata *data)
     last = cur;
     optimizations = 0;
 
-    while (cur->next)
+    if (!cur)
+        return ;
+    while (cur && cur->next)
     {
-        if ((get_cmd(cur) == PA && get_cmd(cur->next) == PB) || (get_cmd(cur) == PB && get_cmd(cur->next) == PA))
+        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);
@@ -42,70 +45,82 @@ static void optimize_redundant_pushes(t_psdata *data)
             optimizations++;
         }
         last = last->next;
-        cur = last->next;
+        if (last)
+            cur = last->next;
+        else
+            cur = NULL;
     }
     if (optimizations)
-        optimize_redundant_pushes(data);
+        optimize_redundant(data, cmd1, cmd2);
+}
+
+static void lstinsert(t_list *list, t_list *elem)
+{
+    t_list *next;
+
+    next = list->next;
+    list->next = elem;
+    elem->next = next;
 }
 
 static void fake_command(t_psdata *data, enum e_pscmd cmd)
 {
     if (cmd == PA)
     {
-        data->a->size++;
-        data->b->size--;
+        if (data->b->size > 0)
+            stack_push(data->a, data->b);
     }
     else if (cmd == PB)
     {
-        data->a->size--;
-        data->b->size++;
+        if (data->a->size > 0)
+            stack_push(data->b, data->a);
     }
 }
 
 static void optimize_rotate(t_psdata *data)
 {
-    t_list *cur;
+    t_list *cmd;
     t_list *last_before;
-    t_list *first_after;
-    enum e_pscmd *cmd;
+    t_list *new_elem;
+    enum e_pscmd *rra;
+    int ras;
     int i;
 
-    cur = data->cmds;
-    while(cur)
+    cmd = data->cmds;
+
+    while (cmd)
     {
-        if (get_cmd(cur->next) == RA)
+        ras = 0;
+        if (get_cmd(cmd) != RA)
+            last_before = cmd;
+        while (get_cmd(cmd) == RA)
         {
-            last_before = cur;
-            cur = cur->next;
+            ras++;
+            cmd = cmd->next;
+        }
+        if (ras > data->a->size / 2) {
             i = 0;
-            while (cur && get_cmd(cur) == RA)
-            {
-                i++;
-                cur = cur->next;
-            }
-            first_after = cur;
-            if (i >= (data->a->size - 1) / 2)
+            while(i++ <= data->a->size)
             {
-                cmd = malloc(sizeof(enum e_pscmd));
-                *cmd = RRA;
-                cur = last_before->next;
-                while (i < data->a->size)
-                {
-                    cur->next = ft_lstnew(cmd);
-                    cur = cur->next;
-                    i++;
-                }
-                cur->next = first_after;
-                ft_printf("i: %d\n", i);
+                rra = malloc(sizeof(enum e_pscmd));
+                if (!rra)
+                    ft_printf("ERROR!!!");
+                *rra = RRA;
+                new_elem = ft_lstnew(rra);
+                if (!new_elem)
+                    ft_printf("AAAAAAAAAAA");
+                lstinsert(last_before, new_elem);
             }
         }
-        fake_command(data, get_cmd(cur));
-        cur = cur->next;
+        fake_command(data, get_cmd(cmd));
+        cmd = cmd->next;
     }
 }
 
 void optimize_commands(t_psdata *data)
 {
-    optimize_redundant_pushes(data);
+    /* ft_printf("SIZE A: %d\n", data->a->size); */
+    optimize_redundant(data, PA, PB);
     optimize_rotate(data);
+    optimize_redundant(data, RA, RRA);
 }

diff --git a/stack_utils.c b/stack_utils.c
index f240395ba6578938d97a1c40729ceba3d0a10ba8..720d13c9ae6a0bb67ff8adc6c2cc4cfd62266d89 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/16 16:48:32 by dkaiser          ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -28,21 +28,23 @@ void        stack_push(t_stack *dst_stack, t_stack *src_stack)
 {
        int i;
 
-       i = dst_stack->size;
-       while (i > 0)
-       {
-               dst_stack->stack[i] = dst_stack->stack[i-1];
-               i--;
-       }
-       dst_stack->stack[0] = src_stack->stack[0];
-       dst_stack->size++;
-       i = 1;
-       while (i < src_stack->size)
-       {
-               src_stack->stack[i-1] = src_stack->stack[i];
-               i++;
+       if (src_stack->size > 0) {
+               i = dst_stack->size;
+               while (i > 0)
+               {
+                       dst_stack->stack[i] = dst_stack->stack[i-1];
+                       i--;
+               }
+               dst_stack->stack[0] = src_stack->stack[0];
+               dst_stack->size++;
+               i = 1;
+               while (i < src_stack->size)
+               {
+                       src_stack->stack[i-1] = src_stack->stack[i];
+                       i++;
+               }
+               src_stack->size--;
        }
-       src_stack->size--;
 }
 
 void   stack_rotate(t_stack *stack)