From 9752ce84fb1268581700a01fc95c11a60542a104 Mon Sep 17 00:00:00 2001 From: Maieul BOYER Date: Thu, 8 Feb 2024 18:49:19 +0100 Subject: [PATCH] update stuff --- .gitignore | 1 + input.toml | 2 +- mecstd | 2 +- src.list | 3 ++ src/app/main.c | 71 +++++++++++++++++++----- src/app/sort2.c | 33 ++++++++++++ src/app/sort3.c | 138 +++++++++++++++++++++++++++++++++++++++++++++++ src/app/sort5.c | 141 ++++++++++++++++++++++++++++++++++++++++++++++++ 8 files changed, 375 insertions(+), 16 deletions(-) create mode 100644 src/app/sort2.c create mode 100644 src/app/sort3.c create mode 100644 src/app/sort5.c diff --git a/.gitignore b/.gitignore index 2dab770..a9b1dd5 100644 --- a/.gitignore +++ b/.gitignore @@ -57,3 +57,4 @@ test output/ push_swap push_swap_visualizer +Push-Swap-Tester diff --git a/input.toml b/input.toml index c245ded..8125265 100644 --- a/input.toml +++ b/input.toml @@ -45,7 +45,7 @@ replace.C__TYPE__ = "t_i64" replace.C__UNSIGNED_TYPE__ = "t_u64" replace.C__PREFIX__ = "i64" replace.C__MAX__ = "9223372036854775807ll" -replace.C__MIN__ = "-9223372036854775808ll" +replace.C__MIN__ = "-(~9223372036854775807ll + 1)" replace.C__ZERO__ = "0ll" replace.C__SIGNED_TYPE__ = "true" diff --git a/mecstd b/mecstd index 4cb7e19..e9c4ce8 160000 --- a/mecstd +++ b/mecstd @@ -1 +1 @@ -Subproject commit 4cb7e19ed8aaa0c910f38fb6947f91b363556b4c +Subproject commit e9c4ce89ea79ba399f8995f3c14e66e78555661d diff --git a/src.list b/src.list index 3b26f15..4cb65a2 100644 --- a/src.list +++ b/src.list @@ -11,4 +11,7 @@ app/moves/rotate app/moves/swap app/rotate app/run_with_items +app/sort2 +app/sort3 +app/sort5 app/target diff --git a/src/app/main.c b/src/app/main.c index deaf59f..e3fb7cd 100644 --- a/src/app/main.c +++ b/src/app/main.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/02/01 21:00:12 by maiboyer #+# #+# */ -/* Updated: 2024/02/08 13:50:09 by maiboyer ### ########.fr */ +/* Updated: 2024/02/08 18:44:58 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,25 +19,51 @@ #include "me/vec/vec_i64_bool.h" #include -void run_with_items(t_state *state); +#define TESTER_ERROR(s) "" -bool sort_i64_bool(t_i64_bool *lhs, t_i64_bool *rhs) +// #define TESTER_ERROR(s) s + +void sort_3(t_state *state); +void sort_2(t_state *state); +void sort_5(t_state *state); + +void run_with_items(t_state *state); + +bool sort_i64_bool(t_i64_bool *lhs, t_i64_bool *rhs) { return (lhs->value <= rhs->value); } -void free_state(t_state state) +void free_state(t_state state) { vec_i64_free(state.stack_a); vec_i64_free(state.stack_b); vec_i64_bool_free(state.sorted); } -t_state parses_arguments(t_usize count, t_str nums[]) +bool duplicate_check(t_state *state) { - t_state state; + t_i64 last; + t_usize index; + + if (state->sorted.len == 0) + return (false); + index = 1; + last = state->sorted.buffer[0].value; + while (index < state->sorted.len) + { + if (last == state->sorted.buffer[index].value) + return (true); + last = state->sorted.buffer[index++].value; + } + return (false); +} + +t_state parses_arguments(t_usize count, t_str nums[]) +{ + t_state state; t_i32 atoi; - t_usize i; + t_usize i; state.stack_a = vec_i64_new(count, NULL); state.stack_b = vec_i64_new(count, NULL); @@ -46,23 +72,40 @@ t_state parses_arguments(t_usize count, t_str nums[]) while (i < count) { if (str_to_i32(nums[i], 10, &atoi)) - (free_state(state), me_eprintf("Error:\nInvalid Number\n"), - exit(1)); + (free_state(state), + me_eprintf("Error\n" TESTER_ERROR("Invalid Number\n")), exit(1)); vec_i64_push(&state.stack_a, atoi); - vec_i64_bool_push(&state.sorted, (t_i64_bool){.value = atoi, - .active = false}); + vec_i64_bool_push(&state.sorted, + (t_i64_bool){.value = atoi, .active = false}); i++; } vec_i64_bool_sort(&state.sorted, sort_i64_bool); + if (duplicate_check(&state)) + (free_state(state), + me_eprintf("Error\n" TESTER_ERROR("Duplicate Number\n")), exit(1)); return (state); } -int main(t_i32 argc, t_str argv[]) +bool is_sorted(t_vec_i64 *v); + +int main(t_i32 argc, t_str argv[]) { - t_state state; + t_state state; (void)(argc--, argv++); state = parses_arguments(argc, argv); - run_with_items(&state); + if (is_sorted(&state.stack_a)) + return (free_state(state), 0); + if (state.stack_a.len == 0) + (free_state(state), me_eprintf("Error\n" TESTER_ERROR("No Input\n")), + exit(1)); + if (state.stack_a.len == 2) + sort_2(&state); + else if (state.stack_a.len == 3) + sort_3(&state); + else if (state.stack_a.len == 5) + sort_5(&state); + else + run_with_items(&state); free_state(state); } diff --git a/src/app/sort2.c b/src/app/sort2.c new file mode 100644 index 0000000..a82f46c --- /dev/null +++ b/src/app/sort2.c @@ -0,0 +1,33 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* sort2.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/02/08 15:50:10 by maiboyer #+# #+# */ +/* Updated: 2024/02/08 16:20:35 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "app/state.h" +#include "me/types.h" +#include "me/vec/vec_i64.h" + +void push_a(void *s); +void push_b(void *s); +void swap_a(void *s); +void swap_b(void *s); +void swap_both(void *s); +void rotate_a(void *s); +void rotate_b(void *s); +void rotate_both(void *s); +void rev_rotate_a(void *s); +void rev_rotate_b(void *s); +void rev_rotate_both(void *s); + +void sort_2(t_state *state) +{ + if (state->stack_a.buffer[0] > state->stack_a.buffer[1]) + swap_a(state); +} diff --git a/src/app/sort3.c b/src/app/sort3.c new file mode 100644 index 0000000..080bfe4 --- /dev/null +++ b/src/app/sort3.c @@ -0,0 +1,138 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* sort3.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/02/08 15:50:10 by maiboyer #+# #+# */ +/* Updated: 2024/02/08 17:53:02 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "app/state.h" +#include "me/types.h" +#include "me/vec/vec_i64.h" + +void push_a(void *s); +void push_b(void *s); +void swap_a(void *s); +void swap_b(void *s); +void swap_both(void *s); +void rotate_a(void *s); +void rotate_b(void *s); +void rotate_both(void *s); +void rev_rotate_a(void *s); +void rev_rotate_b(void *s); +void rev_rotate_both(void *s); + +/* +fn sort_three(state: &mut State, selector: StackSelector, min_first: bool) { + macro_rules! stack { + () => { + match selector { + StackSelector::B => &mut state.b, + StackSelector::A => &mut state.a, + } + }; + } + let [swap, rotate, rev_rotate] = match selector { + StackSelector::A => [sa, ra, rra], + StackSelector::B => [sb, rb, rrb], + }; + match stack!().len() { + 2 => { + let func = match min_first { + true => PartialOrd::gt, + false => PartialOrd::lt, + }; + + if func(&stack!()[0].clone(), &stack!()[1]) { + swap(state); + } + return ; + } + 3 => {} + 0 | 1 | 4.. => return, + } + let mut c = stack!().clone(); + macro_rules! comb { + ($i1:literal, $i2:literal, $i3:literal) => { + &[c[$i1 - 1], c[$i2 - 1], c[$i3 - 1]] + }; + } + c.make_contiguous().sort_unstable(); + if min_first { + c.make_contiguous().reverse(); + } + stack!().make_contiguous(); + + if (stack!() == comb![1, 2, 3] / * abc * /) +{ + swap(state); + rev_rotate(state); +} +else if (stack!() == comb ![ 1, 3, 2 ] / * acb * /) +{ + rotate(state); +} +else if (stack !() == comb ![ 2, 3, 1 ] / * bca * /) +{ + swap(state); +} +else if (stack !() == comb ![ 2, 1, 3 ] / * bac * /) +{ + rotate(state); +} +else if (stack !() == comb ![ 3, 2, 1 ] / * cba * /) +{ +} +else if (stack !() == comb ![ 3, 1, 2 ] / * cab * /) +{ + rotate(state); + swap(state); + rev_rotate(state); +} +} +*/ +// 2 3 1 +bool sort_i64(t_i64 *lhs, t_i64 *rhs) +{ + return (*lhs <= *rhs); +} + +void sort_3_inner(t_state *state, t_i64 data[3], t_i64 sorted[3]) +{ + if ((data[0] == sorted[0]) && (data[1] == sorted[1]) + && (data[2] == sorted[2])) + (swap_a(state), rev_rotate_a(state)); + else if ((data[0] == sorted[0]) && (data[1] == sorted[2]) + && (data[2] == sorted[1])) + rotate_a(state); + else if ((data[0] == sorted[1]) && (data[1] == sorted[2]) + && (data[2] == sorted[0])) + swap_a(state); + else if ((data[0] == sorted[1]) && (data[1] == sorted[0]) + && (data[2] == sorted[2])) + rev_rotate_a(state); + else if ((data[0] == sorted[2]) && (data[1] == sorted[0]) + && (data[2] == sorted[1])) + (rotate_a(state), swap_a(state), rev_rotate_a(state)); +} + +void sort_3(t_state *state) +{ + t_i64 array[3]; + t_vec_i64 why_do_i_do_this; + + why_do_i_do_this.free_func = NULL; + why_do_i_do_this.len = 3; + why_do_i_do_this.capacity = 3; + why_do_i_do_this.buffer = array; + array[0] = state->stack_a.buffer[0]; + array[1] = state->stack_a.buffer[1]; + array[2] = state->stack_a.buffer[2]; + vec_i64_sort(&why_do_i_do_this, sort_i64); + vec_i64_reverse(&why_do_i_do_this); + sort_3_inner(state, state->stack_a.buffer, array); +} diff --git a/src/app/sort5.c b/src/app/sort5.c new file mode 100644 index 0000000..5fb4704 --- /dev/null +++ b/src/app/sort5.c @@ -0,0 +1,141 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* sort5.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/02/08 15:50:10 by maiboyer #+# #+# */ +/* Updated: 2024/02/08 17:53:25 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "app/find_place.h" +#include "app/state.h" +#include "me/printf/printf.h" +#include "me/types.h" +#include "me/vec/vec_i64.h" +#include "me/vec/vec_i64_bool.h" +#include "me/mem/mem_compare.h" +#include "me/mem/mem_copy.h" + +void push_a(void *s); +void push_b(void *s); +void swap_a(void *s); +void swap_b(void *s); +void swap_both(void *s); +void rotate_a(void *s); +void rotate_b(void *s); +void rotate_both(void *s); +void rev_rotate_a(void *s); +void rev_rotate_b(void *s); +void rev_rotate_both(void *s); +void sort_2(t_state *state); + +bool sort_i64(t_i64 *lhs, t_i64 *rhs); + +bool sort_i64_other_way(t_i64 *lhs, t_i64 *rhs) +{ + return (*lhs >= *rhs); +} + +void sort_5_inner(t_state *state, t_i64 data[3], t_i64 sorted[3]) +{ + if ((data[0] == sorted[0]) && (data[1] == sorted[1]) + && (data[2] == sorted[2])) + (swap_a(state), rev_rotate_a(state)); + else if ((data[0] == sorted[0]) && (data[1] == sorted[2]) + && (data[2] == sorted[1])) + rotate_a(state); + else if ((data[0] == sorted[1]) && (data[1] == sorted[2]) + && (data[2] == sorted[0])) + swap_a(state); + else if ((data[0] == sorted[1]) && (data[1] == sorted[0]) + && (data[2] == sorted[2])) + rev_rotate_a(state); + else if ((data[0] == sorted[2]) && (data[1] == sorted[0]) + && (data[2] == sorted[1])) + (rotate_a(state), swap_a(state), rev_rotate_a(state)); +} + +void sort_5_inner2(t_state *state) +{ + t_usize index; + + make_sorted_true_from_stack(state, &state->stack_a); + index = find_place(state->stack_b.buffer[0], state); + if (index == 0) + push_a(state); + else if (index == 1) + (push_a(state), swap_a(state)); + else if (index == 2) + (rotate_a(state), push_a(state), swap_a(state), rev_rotate_a(state)); + else if (index == 3) + (push_a(state), rotate_a(state)); + make_sorted_true_from_stack(state, &state->stack_a); + index = find_place(state->stack_b.buffer[0], state); + if (index == 0) + push_a(state); + else if (index == 1) + (push_a(state), swap_a(state)); + else if (index == 2) + (rotate_a(state), push_a(state), swap_a(state), rev_rotate_a(state)); + else if (index == 3) + (rev_rotate_a(state), push_a(state), rotate_a(state), rotate_a(state)); + else if (index == 4) + (push_a(state), rotate_a(state)); + make_sorted_true_from_stack(state, &state->stack_a); +} + +bool sort_5_specialized(t_state *state, t_i64 cur[5]) +{ + t_i64 target[5]; + t_vec_i64 why_do_i_do_this; + + why_do_i_do_this.free_func = NULL; + why_do_i_do_this.len = 5; + why_do_i_do_this.capacity = 5; + why_do_i_do_this.buffer = target; + mem_copy(target, state->stack_a.buffer, sizeof(t_i64) * 5); + vec_i64_sort(&why_do_i_do_this, sort_i64); + if (cur[0] == target[3 - 1] && cur[1] == target[4 - 1] && cur[2] == target[1 + - 1] && cur[3] == target[5 - 1] && cur[4] == target[2 - 1]) + return (ft_printf("pb\npb\nra\nsa\npa\nsa\npa\nsa\nrra\n"), true); + if (cur[0] == target[3 - 1] && cur[1] == target[4 - 1] && cur[2] == target[5 + - 1] && cur[3] == target[2 - 1] && cur[4] == target[1 - 1]) + return (ft_printf("pb\npb\nsb\nsa\npa\nsa\nrra\nrra\npa\nra\nra\n"), + true); + if (cur[0] == target[4 - 1] && cur[1] == target[3 - 1] && cur[2] == target[1 + - 1] && cur[3] == target[5 - 1] && cur[4] == target[2 - 1]) + return (ft_printf("pb\npb\nra\nsa\npa\nsa\nrra\nrra\npa\nra\nra\n"), + true); + if (cur[0] == target[4 - 1] && cur[1] == target[3 - 1] && cur[2] == target[5 + - 1] && cur[3] == target[2 - 1] && cur[4] == target[1 - 1]) + return (ft_printf("pb\npb\nsb\nsa\npa\nsa\npa\nsa\nrra\n"), true); + return (false); +} + +void sort_5(t_state *state) +{ + t_i64 array[3]; + t_vec_i64 why_do_i_do_this; + + if (sort_5_specialized(state, state->stack_a.buffer)) + return ; + push_b(state); + push_b(state); + if (state->stack_b.buffer[0] >= state->stack_a.buffer[1]) + swap_b(state); + why_do_i_do_this.free_func = NULL; + why_do_i_do_this.len = 3; + why_do_i_do_this.capacity = 3; + why_do_i_do_this.buffer = array; + array[0] = state->stack_a.buffer[0]; + array[1] = state->stack_a.buffer[1]; + array[2] = state->stack_a.buffer[2]; + vec_i64_sort(&why_do_i_do_this, sort_i64_other_way); + // vec_i64_reverse(&why_do_i_do_this); + sort_5_inner(state, state->stack_a.buffer, array); + // vec_i64_bool_reverse(&state->sorted); + sort_5_inner2(state); +}