WORKING <700 OPS WOOO

diff --git a/algorithm_splitsort.c b/algorithm_splitsort.c
index 6fe5492c9c2d705a4706966fc2193e08b76deca7..f6fe542f8c04cd2f2a45276ddd4e8193066fff17 100644 (file)
--- a/algorithm_splitsort.c
+++ b/algorithm_splitsort.c
@@ -6,7 +6,7 @@
 /*   By: agilliar <marvin@42.fr>                    +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2025/12/11 12:45:16 by agilliar          #+#    #+#             */
-/*   Updated: 2025/12/15 20:42:44 by agilliar         ###   ########.fr       */
+/*   Updated: 2025/12/16 01:54:24 by agilliar         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -135,27 +135,50 @@ static void       splitsort_part(t_splitsort sort, t_list range, t_mode mode)
        t_iter  bottomi;
        t_part  part;
        size_t  top_count;
-       size_t  bottom_count;
 
        bottomi = iter_new(range, sort.blocks, mode == MODE_A);
        topi = iter_splitoff(&bottomi, sort.blocks / 2);
        bottomi.rev = mode == MODE_B;
        topi.rev = !bottomi.rev;
        top_count = 0;
-       bottom_count = 0;
-       part.rev = false;
        part.mirror = mode == MODE_B;
+       part.rev = false;
        while (iter_nexti(&topi, &part.top) | iter_nexti(&bottomi, &part.bottom))
        {
-               splitsort_part_once(part, sort, range.len - top_count - bottom_count);
+               splitsort_part_once(part, sort, range.len - top_count);
                part.rev = !part.rev;
                top_count += part.top.len;
-               bottom_count += part.bottom.len;
+               range.len -= part.bottom.len;
        }
        while (mode != MODE_A_WRAP && top_count--)
                closure_callm(sort.cb, OP_RRB, mode == MODE_B);
 }
 
+// Paritions b while also sorting the leaves of a
+void   splitsort_final_mixed(t_splitsort sort, t_list range)
+{
+       t_iter  iter;
+       t_part  part;
+
+       iter = iter_new(range, sort.blocks, true);
+       part.mirror = true;
+       part.rev = false;
+       while (iter_nexti(&iter, &part.bottom) | iter_nexti(&iter, &part.top))
+       {
+               splitsort_part_once(part, sort, range.len);
+               part.rev = !part.rev;
+               range.len -= part.bottom.len + part.top.len;
+               leaf_top_a_a(sort.stacks, sort.cb, part.bottom.len);
+               leaf_bot_a_a(sort.stacks, sort.cb, part.top.len);
+       }
+}
+
+void   splitsort_final_simple(t_splitsort sort, t_list range)
+{
+       leaf_top_b_a(sort.stacks, sort.cb, range.len);
+}
+
+
 // Parts range elements from stack a (which is in ascending order) onto stack b
 // in descending order
 static void    splitsort_part_a(t_splitsort sort, t_list range)
@@ -179,16 +202,6 @@ static void        splitsort_part_b(t_splitsort sort, t_list range)
 
 typedef void (t_layer_func) (t_splitsort, t_list);
 
-void   splitsort_leaf_a(t_splitsort sort, t_list range)
-{
-       leaf_bot_a_a(sort.stacks, sort.cb, range.len);
-}
-
-static void    splitsort_leaf_b(t_splitsort sort, t_list range)
-{
-       leaf_top_b_a(sort.stacks, sort.cb, range.len);
-}
-
 static t_layer_func    *layer_from_info(size_t depth, size_t blocks, size_t len)
 {
        size_t  i;
@@ -198,16 +211,14 @@ static t_layer_func       *layer_from_info(size_t depth, size_t blocks, size_t len)
        state = 4;
        while (i++ < depth)
                state *= blocks;
-       if (len <= state)
-       {
-               if (depth % 2 == 0)
-                       return (&splitsort_leaf_a);
-               return (&splitsort_leaf_b);
-       }
        if (depth == 0)
                return (&splitsort_part_a_wrap);
        if (depth % 2 == 0)
                return (&splitsort_part_a);
+       if (len <= state)
+               return (&splitsort_final_simple);
+       if (len <= state * blocks)
+               return (&splitsort_final_mixed);
        return (&splitsort_part_b);
 }
 
@@ -254,6 +265,6 @@ void        test_splitsort(const t_stacks *stacks, t_closure cb)
        range = list_new(stacks->a);
        list_sort(range);
        i = 0;
-       while (!stacks_is_solved(stacks) && i < 3)
+       while (!stacks_is_solved(stacks))
                splitsort_part_layer(sort, range, i++);
 }