138 lines
3.7 KiB
C
138 lines
3.7 KiB
C
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* 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);
|
|
}
|