/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/13 16:42:34 by dkaiser #+# #+# */
-/* Updated: 2024/04/17 12:15:41 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:58:14 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft/libft.h"
#include "push_swap.h"
-static enum e_pscmd get_cmd(t_list *cmd)
+static enum e_pscmd get_cmd(t_list *cmd)
{
- if (cmd)
- return (*(enum e_pscmd*)cmd->content);
- else
- return NO_CMD;
+ if (cmd)
+ return (*(enum e_pscmd *)cmd->content);
+ else
+ return (NO_CMD);
}
-static void optimize_redundant(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2)
+static void optimize_redundant(t_psdata *data, enum e_pscmd cmd1,
+ enum e_pscmd cmd2)
{
- t_list *cur;
- t_list *last;
- int optimizations;
+ t_list *cur;
+ t_list *last;
+ int optimizations;
- cur = data->cmds;
- last = cur;
- optimizations = 0;
-
- if (!cur)
- return ;
- while (cur && cur->next)
- {
- if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
- {
- last->next = cur->next->next;
- ft_lstdelone(cur->next, free);
- ft_lstdelone(cur, free);
- optimizations++;
- }
- last = last->next;
- if (last)
- cur = last->next;
- else
- cur = NULL;
- }
- if (optimizations)
- optimize_redundant(data, cmd1, cmd2);
+ cur = data->cmds;
+ last = cur;
+ optimizations = 0;
+ if (!cur)
+ return ;
+ while (cur && cur->next)
+ {
+ if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+ || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+ {
+ last->next = cur->next->next;
+ ft_lstdelone(cur->next, free);
+ ft_lstdelone(cur, free);
+ optimizations++;
+ }
+ last = last->next;
+ if (last)
+ cur = last->next;
+ else
+ cur = NULL;
+ }
+ if (optimizations)
+ optimize_redundant(data, cmd1, cmd2);
}
-static void optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1, enum e_pscmd cmd2, enum e_pscmd new_cmd)
+static void optimize_two_stack_ops(t_psdata *data, enum e_pscmd cmd1,
+ enum e_pscmd cmd2, enum e_pscmd new_cmd)
{
- t_list *cur;
- t_list *last;
- int optimizations;
-
- cur = data->cmds;
- last = cur;
- optimizations = 0;
+ t_list *cur;
+ t_list *last;
+ int optimizations;
- if (!cur)
- return ;
- while (cur && cur->next)
- {
- if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2) || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
- {
- last->next = cur->next;
- *(enum e_pscmd*)cur->next->content = new_cmd;
- ft_lstdelone(cur, free);
- optimizations++;
- }
- last = last->next;
- if (last)
- cur = last->next;
- else
- cur = NULL;
- }
- if (optimizations)
- optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
+ cur = data->cmds;
+ last = cur;
+ optimizations = 0;
+ if (!cur)
+ return ;
+ while (cur && cur->next)
+ {
+ if ((get_cmd(cur) == cmd1 && get_cmd(cur->next) == cmd2)
+ || (get_cmd(cur) == cmd2 && get_cmd(cur->next) == cmd1))
+ {
+ last->next = cur->next;
+ *(enum e_pscmd *)cur->next->content = new_cmd;
+ ft_lstdelone(cur, free);
+ optimizations++;
+ }
+ last = last->next;
+ if (last)
+ cur = last->next;
+ else
+ cur = NULL;
+ }
+ if (optimizations)
+ optimize_two_stack_ops(data, cmd1, cmd2, new_cmd);
}
-void optimize_commands(t_psdata *data)
+void optimize_commands(t_psdata *data)
{
- optimize_redundant(data, PA, PB);
- optimize_redundant(data, RB, RRB);
- optimize_redundant(data, RA, RRA);
- optimize_two_stack_ops(data, RA, RB, RR);
+ optimize_redundant(data, PA, PB);
+ optimize_redundant(data, RB, RRB);
+ optimize_redundant(data, RA, RRA);
+ optimize_two_stack_ops(data, RA, RB, RR);
}
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/13 14:38:47 by dkaiser #+# #+# */
-/* Updated: 2024/04/16 09:27:41 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:59:39 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
ptr_cmd = malloc(sizeof(enum e_pscmd));
if (!ptr_cmd)
return (1);
- *ptr_cmd = cmd;
+ *ptr_cmd = cmd;
new_elem = ft_lstnew(ptr_cmd);
if (!new_elem)
{
void print_commands(t_list *cmds)
{
- ft_lstiter(cmds, print_cmd);
+ ft_lstiter(cmds, print_cmd);
}
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/12 17:31:49 by dkaiser #+# #+# */
-/* Updated: 2024/04/15 16:24:51 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:59:24 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
static int are_numbers_unique(int *stack, int size)
{
- int i;
- int k;
+ int i;
+ int k;
i = 0;
while (i < size - 1)
}
i++;
}
-
return (1);
}
static int *get_array_from_input(int argc, char *argv[])
{
- int *stack;
- int i;
+ int *stack;
+ int i;
stack = malloc(sizeof(int) * (argc - 1));
if (!stack)
- return NULL;
-
+ return (NULL);
i = 0;
while (i < argc - 1)
{
stack[i] = ft_atoi(argv[i + 1]);
i++;
}
-
return (stack);
}
t_stack *create_stack(int argc, char *argv[])
{
- t_stack *result;
+ t_stack *result;
result = malloc(sizeof(t_stack));
if (!result)
- return NULL;
+ return (NULL);
if (!is_input_only_nbrs(argc, argv))
return (free(result), NULL);
result->stack = get_array_from_input(argc, argv);
return (NULL);
}
result->size = argc - 1;
-
return (result);
}
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/12 17:03:30 by dkaiser #+# #+# */
-/* Updated: 2024/04/17 09:42:43 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:58:59 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft/ft_printf.h"
#include "push_swap.h"
-static void free_data(t_psdata *data)
+static void free_data(t_psdata *data)
{
if (data)
{
}
}
-static t_psdata *initialize_data(int argc, char *argv[])
+static t_psdata *initialize_data(int argc, char *argv[])
{
- t_psdata *result;
+ t_psdata *result;
result = malloc(sizeof(t_psdata));
if (result)
if (result->b->stack)
{
result->b->size = 0;
- return result;
+ return (result);
}
}
}
}
free_data(result);
- return NULL;
+ return (NULL);
}
int main(int argc, char *argv[])
{
- t_psdata *data;
+ t_psdata *data;
data = initialize_data(argc, argv);
if (!data)
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/12 16:59:09 by dkaiser #+# #+# */
-/* Updated: 2024/04/16 17:57:33 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:59:05 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
# include "libft/libft.h"
# include <stdlib.h>
-enum e_pscmd
+enum e_pscmd
{
SA,
SB,
typedef struct s_stack
{
- int *stack;
- int size;
-} t_stack;
+ int *stack;
+ int size;
+} t_stack;
typedef struct s_psdata
{
- t_stack *a;
- t_stack *b;
- t_list *cmds;
-} t_psdata;
+ t_stack *a;
+ t_stack *b;
+ t_list *cmds;
+} t_psdata;
-t_stack *create_stack(int argc, char *argv[]);
+t_stack *create_stack(int argc, char *argv[]);
-void stack_swap(t_stack *stack);
-void stack_push(t_stack *dst_stack, t_stack *src_stack);
-void stack_rotate(t_stack *stack);
-void stack_rrotate(t_stack *stack);
-void stack_print(t_stack *stack);
+void stack_swap(t_stack *stack);
+void stack_push(t_stack *dst_stack, t_stack *src_stack);
+void stack_rotate(t_stack *stack);
+void stack_rrotate(t_stack *stack);
+void stack_print(t_stack *stack);
-void run_command(t_psdata *data, enum e_pscmd cmd);
-void print_commands(t_list *cmds);
+void run_command(t_psdata *data, enum e_pscmd cmd);
+void print_commands(t_list *cmds);
-int stack_optimize(t_stack *stack);
-void optimize_commands(t_psdata *data);
+int stack_optimize(t_stack *stack);
+void optimize_commands(t_psdata *data);
-void stack_sort(t_psdata *data);
+void stack_sort(t_psdata *data);
#endif // PUSH_SWAP_H
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/13 15:04:19 by dkaiser #+# #+# */
-/* Updated: 2024/04/17 15:48:53 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:58:02 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
#include "libft/ft_printf.h"
#include "push_swap.h"
-static void presort(t_psdata *data)
+static void presort(t_psdata *data)
{
- int size;
- int pivot;
- int max;
+ int size;
+ int pivot;
+ int max;
- size = data->a->size;
- pivot = size / 2;
- max = data->a->stack[0];
- while (size--)
- {
- if (data->a->stack[0] < max)
- {
- run_command(data, PB);
- if (data->b->stack[0] < pivot)
- run_command(data, RB);
- }
- else
- {
- max = data->a->stack[0];
- run_command(data, RA);
- }
- }
+ size = data->a->size;
+ pivot = size / 2;
+ max = data->a->stack[0];
+ while (size--)
+ {
+ if (data->a->stack[0] < max)
+ {
+ run_command(data, PB);
+ if (data->b->stack[0] < pivot)
+ run_command(data, RB);
+ }
+ else
+ {
+ max = data->a->stack[0];
+ run_command(data, RA);
+ }
+ }
}
-static int calculate_score(t_psdata *data, int pos)
+static int calculate_score(t_psdata *data, int pos)
{
- int moves_to_top;
- int moves_to_spot;
- int i;
+ int moves_to_top;
+ int moves_to_spot;
+ int i;
- if (pos < (data->b->size + 1) / 2)
- moves_to_top = pos;
- else
- moves_to_top = data->b->size - pos;
- i = 0;
- while (i < data->a->size && data->a->stack[i] > data->b->stack[pos])
- i++;
- if (i < (data->a->size + 1) / 2)
- moves_to_spot = 2 * i + 1;
- else
- moves_to_spot = 2 * ((data->a->size - i) + 1);
- return moves_to_top + moves_to_spot;
+ if (pos < (data->b->size + 1) / 2)
+ moves_to_top = pos;
+ else
+ moves_to_top = data->b->size - pos;
+ i = 0;
+ while (i < data->a->size && data->a->stack[i] > data->b->stack[pos])
+ i++;
+ if (i < (data->a->size + 1) / 2)
+ moves_to_spot = 2 * i + 1;
+ else
+ moves_to_spot = 2 * ((data->a->size - i) + 1);
+ return (moves_to_top + moves_to_spot);
}
-
-
-static void move_to_top(t_psdata *data, int idx)
+static void move_to_top(t_psdata *data, int idx)
{
- if (idx < (data->b->size + 1) / 2)
- {
- while (--idx > 0)
- run_command(data, RB);
- }
- else
- {
- idx = data->b->size - idx;
- while (idx--)
- run_command(data, RRB);
- }
+ if (idx < (data->b->size + 1) / 2)
+ {
+ while (--idx > 0)
+ run_command(data, RB);
+ }
+ else
+ {
+ idx = data->b->size - idx;
+ while (idx--)
+ run_command(data, RRB);
+ }
}
-static void move_to_spot(t_psdata *data, int idx)
+static void move_to_spot(t_psdata *data, int idx)
{
- int pos;
- int i;
+ int pos;
+ int i;
- pos = 0;
- while (pos < data->a->size && data->b->stack[0] > data->a->stack[pos])
- pos++;
- if (pos >= data->a->size)
- {
- move_to_top(data, idx);
- run_command(data, PA);
- run_command(data, RA);
- }
- else if (pos < (data->a->size + 1) / 2)
- {
- i = pos;
- while (i--)
- run_command(data, RA);
- move_to_top(data, idx);
- run_command(data, PA);
- i = pos;
- while (i--)
- run_command(data, RRA);
- }
- else
- {
- i = data->a->size - pos;
- while (i--)
- run_command(data, RRA);
- move_to_top(data, idx);
- run_command(data, PA);
- i = data->a->size - pos;
- while (i--)
- run_command(data, RA);
- }
+ pos = 0;
+ while (pos < data->a->size && data->b->stack[0] > data->a->stack[pos])
+ pos++;
+ if (pos >= data->a->size)
+ {
+ move_to_top(data, idx);
+ run_command(data, PA);
+ run_command(data, RA);
+ }
+ else if (pos < (data->a->size + 1) / 2)
+ {
+ i = pos;
+ while (i--)
+ run_command(data, RA);
+ move_to_top(data, idx);
+ run_command(data, PA);
+ i = pos;
+ while (i--)
+ run_command(data, RRA);
+ }
+ else
+ {
+ i = data->a->size - pos;
+ while (i--)
+ run_command(data, RRA);
+ move_to_top(data, idx);
+ run_command(data, PA);
+ i = data->a->size - pos;
+ while (i--)
+ run_command(data, RA);
+ }
}
-static void scoresort(t_psdata *data)
+static void scoresort(t_psdata *data)
{
- int *scores;
- int i;
- int min_score;
-
- scores = malloc(sizeof(int) * data->b->size);
- // Error if allocation fails
- i = 0;
- while (i < data->b->size)
- {
- scores[i] = calculate_score(data, i);
- i++;
- }
- i = 0;
- min_score = 0;
- while (i < data->b->size)
- {
- if (scores[i] < scores[min_score])
- min_score = i;
- i++;
- }
- move_to_spot(data, min_score);
+ int *scores;
+ int i;
+ int min_score;
- free(scores);
- if (data->b->size > 0)
- scoresort(data);
+ scores = malloc(sizeof(int) * data->b->size);
+ // Error if allocation fails
+ i = 0;
+ while (i < data->b->size)
+ {
+ scores[i] = calculate_score(data, i);
+ i++;
+ }
+ i = 0;
+ min_score = 0;
+ while (i < data->b->size)
+ {
+ if (scores[i] < scores[min_score])
+ min_score = i;
+ i++;
+ }
+ move_to_spot(data, min_score);
+ free(scores);
+ if (data->b->size > 0)
+ scoresort(data);
}
-void stack_sort(t_psdata *data)
+void stack_sort(t_psdata *data)
{
- presort(data);
- scoresort(data);
+ presort(data);
+ scoresort(data);
}
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/13 15:25:05 by dkaiser #+# #+# */
-/* Updated: 2024/04/15 16:20:51 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:58:36 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
#include <stdlib.h>
-static int *copy_stack(int *stack, int size)
+static int *copy_stack(int *stack, int size)
{
- int i;
- int *cpy;
+ int i;
+ int *cpy;
cpy = malloc(sizeof(int) * size);
if (!cpy)
- return NULL;
+ return (NULL);
i = 0;
while (i < size)
{
cpy[i] = stack[i];
i++;
}
-
- return cpy;
+ return (cpy);
}
-static void sort_stack(int *stack, int size)
+static void sort_stack(int *stack, int size)
{
- int i;
- int k;
- int tmp;
+ int i;
+ int k;
+ int tmp;
i = 0;
while (i < size - 1)
}
}
-static void override_stack(int *stack, int *tmp_stack, int size)
+static void override_stack(int *stack, int *tmp_stack, int size)
{
- int i;
- int k;
+ int i;
+ int k;
i = 0;
while (i < size)
int stack_optimize(t_stack *stack)
{
- int *tmp_stack;
+ int *tmp_stack;
tmp_stack = copy_stack(stack->stack, stack->size);
if (!tmp_stack)
- return 1;
+ return (1);
sort_stack(tmp_stack, stack->size);
override_stack(stack->stack, tmp_stack, stack->size);
free(tmp_stack);
- return 0;
+ return (0);
}
/* By: dkaiser <dkaiser@student.42heilbronn.de +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/12 20:31:30 by dkaiser #+# #+# */
-/* Updated: 2024/04/15 21:53:40 by dkaiser ### ########.fr */
+/* Updated: 2024/04/24 10:58:30 by dkaiser ### ########.fr */
/* */
/* ************************************************************************** */
void stack_swap(t_stack *stack)
{
- int tmp;
+ int tmp;
if (stack->size > 1)
{
void stack_push(t_stack *dst_stack, t_stack *src_stack)
{
- int i;
+ int i;
i = dst_stack->size;
while (i > 0)
{
- dst_stack->stack[i] = dst_stack->stack[i-1];
+ dst_stack->stack[i] = dst_stack->stack[i - 1];
i--;
}
dst_stack->stack[0] = src_stack->stack[0];
i = 1;
while (i < src_stack->size)
{
- src_stack->stack[i-1] = src_stack->stack[i];
+ src_stack->stack[i - 1] = src_stack->stack[i];
i++;
}
src_stack->size--;
void stack_rotate(t_stack *stack)
{
- int tmp;
- int i;
+ int tmp;
+ int i;
tmp = stack->stack[0];
i = 1;
while (i < stack->size)
{
- stack->stack[i-1] = stack->stack[i];
+ stack->stack[i - 1] = stack->stack[i];
i++;
}
- stack->stack[i-1] = tmp;
+ stack->stack[i - 1] = tmp;
}
void stack_rrotate(t_stack *stack)
{
- int tmp;
- int i;
+ int tmp;
+ int i;
i = stack->size - 1;
tmp = stack->stack[i];
while (i > 0)
{
- stack->stack[i] = stack->stack[i-1];
+ stack->stack[i] = stack->stack[i - 1];
i--;
}
stack->stack[0] = tmp;
}
-void stack_print(t_stack *stack)
+void stack_print(t_stack *stack)
{
- int i;
+ int i;
i = 0;
while (i < stack->size)
projects / 42 / push_swap.git / commitdiff