From 63d62aec4d96a29ccdcc7f6b22e2e9b6a022747c Mon Sep 17 00:00:00 2001 From: Maieul BOYER Date: Tue, 23 Jan 2024 13:19:18 +0100 Subject: [PATCH] update --- include/app/cost.h | 26 +++++------ include/app/dup_state.h | 14 +++--- include/app/element.h | 10 ++--- include/app/lis.h | 10 ++--- include/app/moves.h | 13 +++--- include/app/state.h | 20 ++++----- include/app/types/type_cost.h | 10 ++--- include/app/types/type_move.h | 4 +- src/app/cost.c | 63 +++++++++++++++++++------- src/app/lis/lis.c | 38 ++++++++-------- src/app/main.c | 85 +++++++++++++++++------------------ src/app/moves.c | 20 ++++----- src/app/moves/push.c | 12 ++--- src/app/moves/rev_rotate.c | 10 ++--- src/app/moves/rotate.c | 11 +++-- src/app/moves/swap.c | 12 ++--- 16 files changed, 193 insertions(+), 165 deletions(-) diff --git a/include/app/cost.h b/include/app/cost.h index 407edc8..073a603 100644 --- a/include/app/cost.h +++ b/include/app/cost.h @@ -6,27 +6,27 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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 */ diff --git a/include/app/dup_state.h b/include/app/dup_state.h index 69abfeb..f163dfd 100644 --- a/include/app/dup_state.h +++ b/include/app/dup_state.h @@ -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 */ diff --git a/include/app/element.h b/include/app/element.h index 74d625f..cd8855f 100644 --- a/include/app/element.h +++ b/include/app/element.h @@ -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 */ diff --git a/include/app/lis.h b/include/app/lis.h index c1f757b..c44310b 100644 --- a/include/app/lis.h +++ b/include/app/lis.h @@ -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 */ diff --git a/include/app/moves.h b/include/app/moves.h index 4adfee6..4688577 100644 --- a/include/app/moves.h +++ b/include/app/moves.h @@ -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 */ diff --git a/include/app/state.h b/include/app/state.h index 94b7bf3..65bc31e 100644 --- a/include/app/state.h +++ b/include/app/state.h @@ -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 */ diff --git a/include/app/types/type_cost.h b/include/app/types/type_cost.h index 87de305..2efbb54 100644 --- a/include/app/types/type_cost.h +++ b/include/app/types/type_cost.h @@ -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 */ diff --git a/include/app/types/type_move.h b/include/app/types/type_move.h index 9ab4650..761a82a 100644 --- a/include/app/types/type_move.h +++ b/include/app/types/type_move.h @@ -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 */ diff --git a/src/app/cost.c b/src/app/cost.c index c70a865..ec71f30 100644 --- a/src/app/cost.c +++ b/src/app/cost.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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); } diff --git a/src/app/lis/lis.c b/src/app/lis/lis.c index f3e72cd..53b7418 100644 --- a/src/app/lis/lis.c +++ b/src/app/lis/lis.c @@ -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) diff --git a/src/app/main.c b/src/app/main.c index 8ebb919..9f9a5d1 100644 --- a/src/app/main.c +++ b/src/app/main.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* 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 #include -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); diff --git a/src/app/moves.c b/src/app/moves.c index a24428c..d314a7c 100644 --- a/src/app/moves.c +++ b/src/app/moves.c @@ -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); diff --git a/src/app/moves/push.c b/src/app/moves/push.c index 26379bf..85453be 100644 --- a/src/app/moves/push.c +++ b/src/app/moves/push.c @@ -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"); } diff --git a/src/app/moves/rev_rotate.c b/src/app/moves/rev_rotate.c index 7344e6c..1e1649d 100644 --- a/src/app/moves/rev_rotate.c +++ b/src/app/moves/rev_rotate.c @@ -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"); } diff --git a/src/app/moves/rotate.c b/src/app/moves/rotate.c index 6a78f8f..fbbeb2c 100644 --- a/src/app/moves/rotate.c +++ b/src/app/moves/rotate.c @@ -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"); } diff --git a/src/app/moves/swap.c b/src/app/moves/swap.c index 62a316d..76a01d2 100644 --- a/src/app/moves/swap.c +++ b/src/app/moves/swap.c @@ -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"); }