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

update

Browse source
This commit is contained in:
Maieul BOYER 2024-01-23 13:19:18 +01:00
parent b16030f661
commit 63d62aec4d
No known key found for this signature in database
16 changed files with 193 additions and 165 deletions
Download patch file Download diff file Expand all files Collapse all files

26
include/app/cost.h
View file

@ -6,27 +6,27 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 21:13:51 by maiboyer #+# #+# */
/* Updated: 2024/01/12 23:37:23 by maiboyer ### ########.fr */
/* Updated: 2024/01/17 15:32:25 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef COST_H
#define COST_H
# define COST_H
#include "app/element.h"
#include "app/state.h"
#include "app/types/type_cost.h"
#include "me/types.h"
# include "app/element.h"
# include "app/state.h"
# include "app/types/type_cost.h"
# include "me/types.h"
t_cost alloc_cost(t_state *s);
void free_cost(t_cost self);
void calculate_cost(t_state *s);
void cost_for_index(t_state *s, t_usize index);
t_cost alloc_cost(t_state *s);
void free_cost(t_cost self);
t_cost *calculate_cost(t_state *s);
void cost_for_index(t_state *s, t_usize index);
typedef struct s_cost_iter_state
{
t_cost *current_minimum;
t_usize max_index;
} t_cost_iter_state;
t_cost *current_minimum;
t_usize max_index;
} t_cost_iter_state;
#endif /* COST_H */

14
include/app/dup_state.h
View file

@ -11,16 +11,16 @@
/* ************************************************************************** */
#ifndef DUP_STATE_H
#define DUP_STATE_H
# define DUP_STATE_H
#include "app/element.h"
#include "me/types.h"
# include "app/element.h"
# include "me/types.h"
typedef struct s_dup_state
{
t_element *lhs;
t_usize index_to_skip;
bool found_dup;
} t_dup_state;
t_element *lhs;
t_usize index_to_skip;
bool found_dup;
} t_dup_state;
#endif /* DUP_STATE_H */

10
include/app/element.h
View file

@ -11,15 +11,15 @@
/* ************************************************************************** */
#ifndef ELEMENT_H
#define ELEMENT_H
# define ELEMENT_H
#include "me/types.h"
# include "me/types.h"
typedef struct s_element
{
t_i64 value;
} t_element;
t_i64 value;
} t_element;
void free_element(t_element elem);
void free_element(t_element elem);
#endif /* ELEMENT_H */

10
include/app/lis.h
View file

@ -11,12 +11,12 @@
/* ************************************************************************** */
#ifndef LIS_H
#define LIS_H
# define LIS_H
#include "me/types.h"
#include "me/vec/vec_element.h"
#include "me/vec/vec_i64.h"
# include "me/types.h"
# include "me/vec/vec_element.h"
# include "me/vec/vec_i64.h"
t_vec_i64 lis(t_vec_element *elements);
t_vec_i64 lis(t_vec_element *elements);
#endif /* LIS_H */

13
include/app/moves.h
View file

@ -11,14 +11,13 @@
/* ************************************************************************** */
#ifndef MOVES_H
#define MOVES_H
# define MOVES_H
#include "app/element.h"
#include "app/state.h"
#include "app/types/type_move.h"
# include "app/element.h"
# include "app/state.h"
# include "app/types/type_move.h"
# include "me/types.h"
#include "me/types.h"
void do_move(t_move m, t_state *s);
void do_move(t_move m, t_state *s);
#endif /* MOVES_H */

20
include/app/state.h
View file

@ -11,20 +11,20 @@
/* ************************************************************************** */
#ifndef STATE_H
#define STATE_H
# define STATE_H
#include "me/types.h"
#include "me/vec/vec_element.h"
#include "me/vec/vec_cost.h"
# include "me/types.h"
# include "me/vec/vec_cost.h"
# include "me/vec/vec_element.h"
typedef struct s_state
{
t_vec_element stack_a;
t_vec_element stack_b;
t_vec_cost costs;
} t_state;
t_vec_element stack_a;
t_vec_element stack_b;
t_vec_cost costs;
} t_state;
t_state parses_arguments(t_usize count, t_str nums[]);
void free_state(t_state state);
t_state parses_arguments(t_usize count, t_str nums[]);
void free_state(t_state state);
#endif /* STATE_H */

10
include/app/types/type_cost.h
View file

@ -11,16 +11,16 @@
/* ************************************************************************** */
#ifndef TYPE_COST_H
#define TYPE_COST_H
# define TYPE_COST_H
#include "me/types.h"
#include "me/vec/vec_moves.h"
# include "me/types.h"
# include "me/vec/vec_moves.h"
typedef struct s_cost
{
t_usize index;
t_vec_moves moves;
t_vec_moves moves;
bool active;
} t_cost;
} t_cost;
#endif /* TYPE_COST_H */

4
include/app/types/type_move.h
View file

@ -11,7 +11,7 @@
/* ************************************************************************** */
#ifndef TYPE_MOVE_H
#define TYPE_MOVE_H
# define TYPE_MOVE_H
typedef enum e_move
{
@ -26,6 +26,6 @@ typedef enum e_move
REVERSE_ROTATE_A = 1 << 6,
REVERSE_ROTATE_B = 1 << 7,
REVERSE_ROTATE_BOTH = REVERSE_ROTATE_A | REVERSE_ROTATE_B,
} t_move;
} t_move;
#endif /* TYPE_MOVE_H */

63
src/app/cost.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/12 21:22:44 by maiboyer #+# #+# */
/* Updated: 2024/01/13 00:58:47 by maiboyer ### ########.fr */
/* Updated: 2024/01/18 17:01:34 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,35 +16,65 @@
#include "me/vec/vec_cost.h"
#include "me/vec/vec_moves.h"
void reset_cost(t_usize _index, t_cost *c, void *_state)
void reset_cost(t_usize _index, t_cost *c, void *_state)
{
(void)(_index + (t_usize)_state);
c->active = false;
c->moves.len = 0;
}
void find_minimum(t_usize index, t_cost *c, t_cost_iter_state *s)
void find_minimum(t_usize index, t_cost *c, t_cost_iter_state *s)
{
if (index >= s->max_index || !c->active)
return;
return ;
if (c->moves.len < s->current_minimum->moves.len)
s->current_minimum = c;
}
void cost_for_index(t_state *s, t_usize index)
typedef struct s_max_iter_state
{
t_usize current_index;
t_vec_element *v;
} t_max_iter_state;
void find_maximum_iter(t_usize index, t_element *c, t_max_iter_state *s)
{
if (s->v->buffer[s->current_index].value < c->value)
s->current_index = index;
}
void free_cost(t_cost self)
static t_usize find_max(t_vec_element *v)
{
t_max_iter_state state;
state.v = v;
state.current_index = 0;
vec_element_iter(v, (void (*)())find_maximum_iter, &state);
return (state.current_index);
}
void cost_for_index(t_state *s, t_usize index)
{
t_usize rotate_a;
t_usize rotate_b;
t_element *elem;
t_usize max_index;
rotate_a = 0;
rotate_b = 0;
elem = &s->stack_a.buffer[index];
max_index = find_max(&s->stack_b);
}
void free_cost(t_cost self)
{
vec_moves_free(self.moves);
}
t_cost alloc_cost(t_state *s)
t_cost alloc_cost(t_state *s)
{
t_cost out;
t_cost out;
(void)(s);
out = (t_cost){};
out.active = false;
out.index = s->costs.len;
@ -52,12 +82,12 @@ t_cost alloc_cost(t_state *s)
return (out);
}
void calculate_cost(t_state *s)
t_cost *calculate_cost(t_state *s)
{
t_vec_cost *costs;
t_cost *cur;
t_usize index;
t_cost_iter_state iter_state;
t_vec_cost *costs;
t_cost *cur;
t_usize index;
t_cost_iter_state iter_state;
costs = &s->costs;
vec_cost_iter(costs, &reset_cost, NULL);
@ -67,10 +97,11 @@ void calculate_cost(t_state *s)
cur = &costs->buffer[index];
cost_for_index(s, index);
if (cur->moves.len == 1)
break;
break ;
index++;
}
iter_state = (t_cost_iter_state){.current_minimum = costs->buffer,
.max_index = index};
.max_index = index};
vec_cost_iter(costs, (void (*)())find_minimum, &iter_state);
return (iter_state.current_minimum);
}

38
src/app/lis/lis.c
View file

@ -68,7 +68,7 @@ return S
//}
// static t_vec_i64 lis_inner(t_vec_element *elements, t_i64 L, t_i64 m[],
// t_i64 p[])
// t_i64 p[])
//{
// }
@ -88,7 +88,7 @@ http://www.algorithmist.com/index.php?title=Longest_Increasing_Subsequence.cpp&o
// If `items` is empty, then the result is also empty.
if items.is_empty() {
return result;
return (result);
}
// This vector stores, for each item,
@ -108,7 +108,7 @@ subsequence,
if selector(&items[*result.last().unwrap()]) < selector(&items[i]) {
previous_chain[i] = *result.last().unwrap();
result.push(i);
continue;
continue ;
}
// Perform a binary search to find the index of an item in `result` to
@ -157,11 +157,11 @@ is larger than `items[i]`.
}
*/
t_i64 binary_search(t_vec_element *items, t_i64 i)
t_i64 binary_search(t_vec_element *items, t_i64 i)
{
t_i64 lo;
t_i64 hi;
t_i64 mid;
t_i64 lo;
t_i64 hi;
t_i64 mid;
lo = 0;
hi = items->len - 1;
@ -176,11 +176,11 @@ t_i64 binary_search(t_vec_element *items, t_i64 i)
return (lo);
}
void lis_inner(t_vec_element *elements, t_vec_i64 *result,
t_vec_i64 *previous_chain)
void lis_inner(t_vec_element *elements, t_vec_i64 *result,
t_vec_i64 *previous_chain)
{
t_i64 i;
t_i64 next_element_index;
t_i64 i;
t_i64 next_element_index;
i = 1;
while (i < (t_i64)elements->len)
@ -190,27 +190,27 @@ void lis_inner(t_vec_element *elements, t_vec_i64 *result,
{
previous_chain->buffer[i] = result->buffer[result->len - 1];
vec_i64_push(result, i++);
continue;
continue ;
}
next_element_index = binary_search(elements, i);
if (-elements->buffer[i].value >
-elements->buffer[result->buffer[next_element_index]].value)
{
if (next_element_index > 0)
previous_chain->buffer[i] =
result->buffer[next_element_index - 1];
previous_chain->buffer[i] = result->buffer[next_element_index
- 1];
result->buffer[next_element_index] = i;
}
i++;
}
}
t_vec_i64 lis(t_vec_element *elements)
t_vec_i64 lis(t_vec_element *elements)
{
t_vec_i64 result;
t_i64 u;
t_i64 v;
t_vec_i64 previous_chain;
t_vec_i64 result;
t_i64 u;
t_i64 v;
t_vec_i64 previous_chain;
result = vec_i64_new(elements->len, NULL);
if (elements->len == 0)

85
src/app/main.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/01/11 14:14:18 by maiboyer #+# #+# */
/* Updated: 2024/01/12 23:41:30 by maiboyer ### ########.fr */
/* Updated: 2024/01/18 13:45:26 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -27,23 +27,23 @@
#include <stdlib.h>
#include <string.h>
void free_element(t_element elem)
void free_element(t_element elem)
{
(void)(elem);
}
void free_state(t_state state)
void free_state(t_state state)
{
vec_element_free(state.stack_a);
vec_element_free(state.stack_b);
vec_cost_free(state.costs);
}
t_error parse_element(t_str s, t_element *e)
t_error parse_element(t_str s, t_element *e)
{
t_usize i;
t_i64 value;
t_element out;
t_usize i;
t_i64 value;
t_element out;
if (s == NULL || e == NULL)
return (ERROR);
@ -61,17 +61,17 @@ t_error parse_element(t_str s, t_element *e)
*e = out;
return (NO_ERROR);
}
void check_eq(t_usize i, const t_element *rhs, t_dup_state *dup_state)
void check_eq(t_usize i, const t_element *rhs, t_dup_state *dup_state)
{
dup_state->found_dup =
dup_state->found_dup ||
(i != dup_state->index_to_skip && rhs->value == dup_state->lhs->value);
dup_state->found_dup = dup_state->found_dup
|| (i != dup_state->index_to_skip
&& rhs->value == dup_state->lhs->value);
}
void check_no_duplicate(t_vec_element *stack, t_vec_element *to_free_in_need)
void check_no_duplicate(t_vec_element *stack, t_vec_element *to_free_in_need)
{
t_usize i;
t_dup_state s;
t_dup_state s;
i = 0;
while (i < stack->len)
@ -84,18 +84,17 @@ void check_no_duplicate(t_vec_element *stack, t_vec_element *to_free_in_need)
vec_element_iter(stack, (void (*)())check_eq, &s);
if (s.found_dup)
return (me_eprintf("Error:\nDuplicate numbers (%i)\n",
stack->buffer[i]),
vec_element_free(*stack),
vec_element_free(*to_free_in_need), exit(1));
stack->buffer[i]), vec_element_free(*stack),
vec_element_free(*to_free_in_need), exit(1));
i++;
}
}
t_state parses_arguments(t_usize count, t_str nums[])
t_state parses_arguments(t_usize count, t_str nums[])
{
t_state out;
t_usize i;
t_element e;
t_state out;
t_usize i;
t_element e;
i = 0;
out.stack_a = vec_element_new(count + 1, free_element);
@ -106,36 +105,37 @@ t_state parses_arguments(t_usize count, t_str nums[])
(me_eprintf("Error:\nArgument '%s' isn't a valid number for this "
"program!\n",
nums[i]),
vec_element_free(out.stack_a), vec_element_free(out.stack_b),
exit(1));
vec_element_free(out.stack_a),
vec_element_free(out.stack_b),
exit(1));
vec_element_push(&out.stack_a, e);
i++;
}
vec_element_reverse(&out.stack_a);
check_no_duplicate(&out.stack_a, &out.stack_b);
return out;
return (out);
}
#define LEFT(str, w) \
({ \
int m = w + strlen(str); \
m % 2 ? (m + 1) / 2 : m / 2; \
#define LEFT(str, w) \
({ \
int m = w + strlen(str); \
m % 2 ? (m + 1) / 2 : m / 2; \
})
#define RIGHT(str, w) \
({ \
int m = w - strlen(str); \
m % 2 ? (m - 1) / 2 : m / 2; \
#define RIGHT(str, w) \
({ \
int m = w - strlen(str); \
m % 2 ? (m - 1) / 2 : m / 2; \
})
#define STR_CENTER(str, width) LEFT(str, width), str, RIGHT(str, width), ""
#define STACK_WIDTH 12
bool check_sorted(t_state *s)
bool check_sorted(t_state *s)
{
t_usize not_in_order;
t_usize i;
t_usize not_in_order;
t_usize i;
not_in_order = 0;
i = 0;
@ -148,21 +148,20 @@ bool check_sorted(t_state *s)
return (not_in_order == 0);
}
void print_state(t_state *s)
void print_state(t_state *s)
{
t_usize max_len;
t_usize max_len;
t_str s_a;
t_str s_b;
if (s->stack_a.len > s->stack_b.len)
max_len = s->stack_a.len;
else
max_len = s->stack_b.len;
printf("|%*s%*s|%*s%*s|\n", STR_CENTER("Stack A", STACK_WIDTH),
STR_CENTER("Stack B", STACK_WIDTH));
STR_CENTER("Stack B", STACK_WIDTH));
for (t_usize i = 0; i < max_len; i++)
{
t_str s_a;
t_str s_b;
if (i < s->stack_a.len)
s_a = me_itoa(s->stack_a.buffer[s->stack_a.len - i - 1].value);
else
@ -172,16 +171,16 @@ void print_state(t_state *s)
else
s_b = str_clone("");
printf("|%*s%*s|%*s%*s|\n", STR_CENTER(s_a, STACK_WIDTH),
STR_CENTER(s_b, STACK_WIDTH));
STR_CENTER(s_b, STACK_WIDTH));
free(s_a);
free(s_b);
}
printf("\n");
}
int main(t_i32 argc, t_str argv[])
int main(t_i32 argc, t_str argv[])
{
t_state state;
t_state state;
state = parses_arguments(--argc, ++argv);
state.costs = vec_cost_new(state.stack_a.len, &free_cost);

20
src/app/moves.c
View file

@ -10,20 +10,20 @@
/* */
/* ************************************************************************** */
#include "app/moves.h"
#include "app/element.h"
#include "app/moves.h"
#include "app/state.h"
void push_a(t_state *s);
void push_b(t_state *s);
void swap_a(t_state *s);
void swap_b(t_state *s);
void rotate_a(t_state *s);
void rotate_b(t_state *s);
void rev_rotate_a(t_state *s);
void rev_rotate_b(t_state *s);
void push_a(t_state *s);
void push_b(t_state *s);
void swap_a(t_state *s);
void swap_b(t_state *s);
void rotate_a(t_state *s);
void rotate_b(t_state *s);
void rev_rotate_a(t_state *s);
void rev_rotate_b(t_state *s);
void do_move(t_move m, t_state *s)
void do_move(t_move m, t_state *s)
{
if (m & PUSH_A)
push_a(s);

12
src/app/moves/push.c
View file

@ -14,24 +14,24 @@
#include "app/state.h"
#include "me/vec/vec_element.h"
static inline void push_inner(t_vec_element *to, t_vec_element *from,
t_const_str tag)
static inline void push_inner(t_vec_element *to, t_vec_element *from,
t_const_str tag)
{
t_element e;
t_element e;
(void)(tag);
if (from->len == 0)
return;
return ;
vec_element_pop(from, &e);
vec_element_push(to, e);
}
void push_a(t_state *s)
void push_a(t_state *s)
{
push_inner(&s->stack_a, &s->stack_b, "Push A");
}
void push_b(t_state *s)
void push_b(t_state *s)
{
push_inner(&s->stack_b, &s->stack_a, "Push B");
}

10
src/app/moves/rev_rotate.c
View file

@ -13,23 +13,23 @@
#include "app/element.h"
#include "app/state.h"
static inline void rev_rotate_inner(t_vec_element *stack, t_const_str tag)
static inline void rev_rotate_inner(t_vec_element *stack, t_const_str tag)
{
t_element e;
t_element e;
(void)(tag);
if (stack->len <= 1)
return;
return ;
vec_element_pop(stack, &e);
vec_element_push_front(stack, e);
}
void rev_rotate_a(t_state *s)
void rev_rotate_a(t_state *s)
{
rev_rotate_inner(&s->stack_a, "RevRotate A");
}
void rev_rotate_b(t_state *s)
void rev_rotate_b(t_state *s)
{
rev_rotate_inner(&s->stack_b, "RevRotate B");
}

11
src/app/moves/rotate.c
View file

@ -13,24 +13,23 @@
#include "app/element.h"
#include "app/state.h"
static inline void rotate_inner(t_vec_element *stack, t_const_str tag)
static inline void rotate_inner(t_vec_element *stack, t_const_str tag)
{
t_element e;
t_element e;
(void)(tag);
if (stack->len <= 1)
return;
return ;
vec_element_pop(stack, &e);
vec_element_push_front(stack, e);
}
void rotate_a(t_state *s)
void rotate_a(t_state *s)
{
rotate_inner(&s->stack_a, "Rotate A");
}
void rotate_b(t_state *s)
void rotate_b(t_state *s)
{
rotate_inner(&s->stack_b, "Rotate B");
}

12
src/app/moves/swap.c
View file

@ -14,26 +14,26 @@
#include "app/state.h"
#include "me/vec/vec_element.h"
static inline void swap_inner(t_vec_element *stack, t_const_str tag)
static inline void swap_inner(t_vec_element *stack, t_const_str tag)
{
t_element first;
t_element second;
t_element first;
t_element second;
(void)(tag);
if (stack->len <= 1)
return;
return ;
vec_element_pop(stack, &first);
vec_element_pop(stack, &second);
vec_element_push(stack, first);
vec_element_push(stack, second);
}
void swap_a(t_state *s)
void swap_a(t_state *s)
{
swap_inner(&s->stack_a, "Swap A");
}
void swap_b(t_state *s)
void swap_b(t_state *s)
{
swap_inner(&s->stack_b, "Swap B");
}