maix/push_swap
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update stuff

Browse source
This commit is contained in:
Maieul BOYER 2024-02-08 18:49:19 +01:00
parent ebf62307e6
commit 9752ce84fb
No known key found for this signature in database
8 changed files with 375 additions and 16 deletions
Download patch file Download diff file Expand all files Collapse all files

1
.gitignore vendored
View file

@ -57,3 +57,4 @@ test
output/
push_swap
push_swap_visualizer
Push-Swap-Tester

2
input.toml
View file

@ -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"

2
mecstd

@ -1 +1 @@
Subproject commit 4cb7e19ed8aaa0c910f38fb6947f91b363556b4c
Subproject commit e9c4ce89ea79ba399f8995f3c14e66e78555661d

3
src.list
View file

@ -11,4 +11,7 @@ app/moves/rotate
app/moves/swap
app/rotate
app/run_with_items
app/sort2
app/sort3
app/sort5
app/target

71
src/app/main.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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);
}

33
src/app/sort2.c Normal file
View file

@ -0,0 +1,33 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
}

138
src/app/sort3.c Normal file
View file

@ -0,0 +1,138 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort3.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
}

141
src/app/sort5.c Normal file
View file

@ -0,0 +1,141 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort5.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
}