Ladebeze66/pushswap
1
0
Fork 0
mirror of https://github.com/Ladebeze66/pushswap.git synced 2025-12-15 13:46:55 +01:00
Code Issues Packages Projects Releases Wiki Activity

pushswap

Browse Source
This commit is contained in:
Ladebeze66 2023-12-12 17:44:13 +01:00
commit 08578fcc90
19 changed files with 1222 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

57
Makefile Executable file
View File

@ -0,0 +1,57 @@
# **************************************************************************** #
# #
# ::: :::::::: #
# Makefile :+: :+: :+: #
# +:+ +:+ +:+ #
# By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2023/07/31 21:26:03 by fgras-ca #+# #+# #
# Updated: 2023/08/08 15:05:36 by fgras-ca ### ########.fr #
# #
# **************************************************************************** #
NAME = push_swap
LIBFTPS = libftps.a
SRCPS = cost.c \
do_move.c \
initialization.c \
input_check.c \
input_check_utils.c \
position.c \
push.c \
reverse_rotate.c \
rotate.c \
sort.c \
sort_tiny.c \
stack.c \
swap.c \
utils.c \
ft_split.c \
SRCMAIN = main.c \
OBJPS = $(SRCPS:.c=.o)
OBJMAIN = $(SRCMAIN:.c=.o)
CC = gcc
RM = rm -f
CFLAGS = -Wall -Werror -Wextra
all: $(LIBFTPS) $(OBJMAIN)
$(CC) $(CFLAGS) $(OBJMAIN) $(LIBFTPS) -o $(NAME)
$(LIBFTPS): $(OBJPS)
ar rcs $(LIBFTPS) $(OBJPS)
clean:
$(RM) $(OBJPS) $(OBJMAIN)
fclean:
$(RM) $(NAME) $(LIBFTPS) $(OBJMAIN)
re: fclean all

2212
PUSH_SWAP.pdf Executable file
View File

File diff suppressed because it is too large Load Diff

58
cost.c Executable file
View File

@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cost.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 19:46:52 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 19:57:18 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void get_cost(t_stack **stack_a, t_stack **stack_b)
{
t_stack *tmp_a;
t_stack *tmp_b;
int size_a;
int size_b;
tmp_a = *stack_a;
tmp_b = *stack_b;
size_a = get_stack_size(tmp_a);
size_b = get_stack_size(tmp_b);
while (tmp_b)
{
tmp_b->cost_b = tmp_b->pos;
if (tmp_b->pos > size_b / 2)
tmp_b->cost_b = (size_b - tmp_b->pos) * -1;
tmp_b->cost_a = tmp_b->target_pos;
if (tmp_b->target_pos > size_a / 2)
tmp_b->cost_a = (size_a - tmp_b->target_pos) * -1;
tmp_b = tmp_b->next;
}
}
void do_cheapest_move(t_stack **stack_a, t_stack **stack_b)
{
t_stack *tmp;
int cheapest;
int cost_a;
int cost_b;
tmp = *stack_b;
cheapest = INT_MAX;
while (tmp)
{
if (nb_abs(tmp->cost_a) + nb_abs(tmp->cost_b) < nb_abs(cheapest))
{
cheapest = nb_abs(tmp->cost_b) + nb_abs(tmp->cost_a);
cost_a = tmp->cost_a;
cost_b = tmp->cost_b;
}
tmp = tmp->next;
}
do_move(stack_a, stack_b, cost_a, cost_b);
}

79
do_move.c Executable file
View File

@ -0,0 +1,79 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* do_move.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:00:13 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 20:13:28 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void do_rev_rotate_both(t_stack **a, t_stack **b,
int *cost_a, int *cost_b)
{
while (*cost_a < 0 && *cost_b < 0)
{
(*cost_a)++;
(*cost_b)++;
do_rrr(a, b);
}
}
static void do_rotate_both(t_stack **a, t_stack **b, int *cost_a, int *cost_b)
{
while (*cost_a > 0 && *cost_b > 0)
{
(*cost_a)--;
(*cost_b)--;
do_rr(a, b);
}
}
static void do_rotate_a(t_stack **a, int *cost)
{
while (*cost)
{
if (*cost > 0)
{
do_ra(a);
(*cost)--;
}
else if (*cost < 0)
{
do_rra(a);
(*cost)++;
}
}
}
static void do_rotate_b(t_stack **b, int *cost)
{
while (*cost)
{
if (*cost > 0)
{
do_rb(b);
(*cost)--;
}
else if (*cost < 0)
{
do_rrb(b);
(*cost)++;
}
}
}
void do_move(t_stack **a, t_stack **b, int cost_a, int cost_b)
{
if (cost_a < 0 && cost_b < 0)
do_rev_rotate_both(a, b, &cost_a, &cost_b);
else if (cost_a > 0 && cost_b > 0)
do_rotate_both(a, b, &cost_a, &cost_b);
do_rotate_a(a, &cost_a);
do_rotate_b(b, &cost_b);
do_pa(a, b);
}

98
ft_split.c Executable file
View File

@ -0,0 +1,98 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ft_split.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/02/17 13:12:04 by fgras-ca #+# #+# */
/* Updated: 2023/02/21 11:04:10 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static size_t ft_strlen(const char *s)
{
size_t i;
i = 0;
while (s[i])
i++;
return (i);
}
static int count_words(const char *s, char c)
{
int count;
int trigger;
count = 0;
trigger = 0;
while (*s)
{
if (*s != c && trigger == 0)
{
trigger = 1;
count++;
}
else if (*s == c)
trigger = 0;
s++;
}
return (count);
}
static char *word_cpy(const char *s, int start, int end)
{
char *word;
int i;
i = 0;
word = malloc(sizeof(char) * (end - start + 1));
while (start < end)
word[i++] = s[start++];
word[i] = '\0';
return (word);
}
char **ft_split(char const *s, char c)
{
size_t i;
size_t j;
int index;
char **split;
split = malloc(sizeof(char *) * (count_words(s, c) + 1));
if (!s || !split)
return (0);
i = 0;
j = 0;
index = -1;
while (i <= ft_strlen(s))
{
if (s[i] != c && index < 0)
index = i;
else if ((s[i] == c || i == ft_strlen(s)) && index >= 0)
{
split[j++] = word_cpy(s, index, i);
index = -1;
}
i++;
}
split[j] = 0;
return (split);
}
char **split_args(char *arg)
{
char **numbers;
numbers = ft_split(arg, ' ');
if (!numbers)
{
ft_putstr("error : Not enought memory to split\n");
return (NULL);
}
return (numbers);
}

65
initialization.c Executable file
View File

@ -0,0 +1,65 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* initialization.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 17:32:33 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 17:46:42 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
t_stack *fill_stack_values(int argc, char **argv, int start_idx)
{
t_stack *stack_a;
long int nb;
int i;
stack_a = NULL;
nb = 0;
i = start_idx;
while (i < argc)
{
nb = ft_atoi(argv[i]);
if (nb > INT_MAX || nb < INT_MIN)
exit_error(&stack_a, NULL);
if (i == 0)
stack_a = stack_new((int)nb);
else
stack_add_bottom(&stack_a, stack_new((int)nb));
i++;
}
return (stack_a);
}
void assign_index(t_stack *stack_a, int stack_size)
{
t_stack *ptr;
t_stack *highest;
int value;
while (--stack_size > 0)
{
ptr = stack_a;
value = INT_MIN;
highest = NULL;
while (ptr)
{
if (ptr->value == INT_MIN && ptr->index == 0)
ptr->index = 1;
if (ptr->value > value && ptr->index == 0)
{
value = ptr->value;
highest = ptr;
ptr = stack_a;
}
else
ptr = ptr->next;
}
if (highest != NULL)
highest->index = stack_size;
}
}

82
input_check.c Executable file
View File

@ -0,0 +1,82 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* input_check.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 21:05:07 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 22:01:50 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static int arg_is_number(char *argv)
{
int i;
i = 0;
if (is_sign(argv[i]) && argv[i + 1] != '\0')
i++;
while (argv[i] && is_digit(argv[i]))
i++;
if (argv[i] != '\0' && !is_digit(argv[i]))
return (0);
return (1);
}
static int have_duplicates(char **argv)
{
int i;
int j;
i = 1;
while (argv[i])
{
j = 1;
while (argv[j])
{
if (j != i && nbstr_cmp(argv[i], argv[j]) == 0)
return (1);
j++;
}
i++;
}
return (0);
}
static int arg_is_zero(char *argv)
{
int i;
i = 0;
if (is_sign(argv[i]))
i++;
while (argv[i] && argv[i] == '0')
i++;
if (argv[i] != '\0')
return (0);
return (1);
}
int is_correct_input(char **argv, int start_idx)
{
int i;
int nb_zeros;
nb_zeros = 0;
i = start_idx;
while (argv[i])
{
if (!arg_is_number(argv[i]))
return (0);
nb_zeros += arg_is_zero(argv[i]);
i++;
}
if (nb_zeros > 1)
return (0);
if (have_duplicates(argv))
return (0);
return (1);
}

58
input_check_utils.c Executable file
View File

@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* input_check_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 21:17:55 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 21:23:45 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
int is_digit(char c)
{
return (c >= '0' && c <= '9');
}
int is_sign(char c)
{
return (c == '+' || c == '-');
}
int nbstr_cmp(const char *s1, const char *s2)
{
int i;
int j;
i = 0;
j = i;
if (s1[i] == '+')
{
if (s2[j] != '+')
i++;
}
else
{
if (s2[j] == '+')
j++;
}
while (s1[i] != '\0' && s2[j] != '\0' && s1[i] == s2[j])
{
i++;
j++;
}
return ((unsigned char)s1[i] - (unsigned char)s2[j]);
}
int size_numbers(char **numbers)
{
int i;
i = 0;
while (numbers[i])
i++;
return (i + 1);
}

99
main.c Executable file
View File

@ -0,0 +1,99 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* main.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 18:38:04 by fgras-ca #+# #+# */
/* Updated: 2023/08/08 18:16:52 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
typedef struct s_stacks
{
t_stack **stack_a;
t_stack **stack_b;
int *stack_size;
} t_stacks;
int is_sorted(t_stack *stack)
{
while (stack->next != NULL)
{
if (stack->value > stack->next->value)
return (0);
stack = stack->next;
}
return (1);
}
static void push_swap(t_stack **stack_a, t_stack **stack_b, int stack_size)
{
if (stack_size == 2 && !is_sorted(*stack_a))
do_ra(stack_a);
else if (stack_size == 3)
tiny_sort(stack_a);
else if (stack_size > 3 && !is_sorted(*stack_a))
sort(stack_a, stack_b);
}
void free_split(char **split)
{
int i;
i = 0;
while (split[i])
{
free(split[i]);
i++;
}
free(split);
}
void setup_stacks(int argc, char **argv, t_stacks *stacks)
{
char **args;
*(stacks->stack_b) = NULL;
if (argc == 2)
{
args = split_args(argv[1]);
if (!is_correct_input(args, 0))
exit_error(NULL, NULL);
*(stacks->stack_a) = fill_stack_values(size_numbers(args) - 1, args, 0);
free_split(args);
*(stacks->stack_size) = get_stack_size(*(stacks->stack_a));
}
else
{
if (!is_correct_input(argv, 1))
exit_error(NULL, NULL);
*(stacks->stack_a) = fill_stack_values(argc, argv, 1);
*(stacks->stack_size) = get_stack_size(*(stacks->stack_a));
}
assign_index(*(stacks->stack_a), *(stacks->stack_size) + 1);
}
int main(int argc, char **argv)
{
t_stacks stacks;
int stack_size;
t_stack *stack_a;
t_stack *stack_b;
stack_a = NULL;
stack_b = NULL;
if (argc < 2)
return (0);
stacks.stack_a = &stack_a;
stacks.stack_b = &stack_b;
stacks.stack_size = &stack_size;
setup_stacks(argc, argv, &stacks);
push_swap(stacks.stack_a, stacks.stack_b, stack_size);
free_stack(&stack_a);
free_stack(&stack_b);
return (0);
}

96
position.c Executable file
View File

@ -0,0 +1,96 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* position.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 19:18:25 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 19:35:14 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void get_position(t_stack **stack)
{
t_stack *tmp;
int i;
tmp = *stack;
i = 0;
while (tmp)
{
tmp->pos = i;
tmp = tmp->next;
i++;
}
}
int get_lowest_index_position(t_stack **stack)
{
t_stack *tmp;
int lowest_index;
int lowest_pos;
tmp = *stack;
lowest_index = INT_MAX;
get_position(stack);
lowest_pos = tmp->pos;
while (tmp)
{
if (tmp->index < lowest_index)
{
lowest_index = tmp->index;
lowest_pos = tmp->pos;
}
tmp = tmp->next;
}
return (lowest_pos);
}
static int get_target(t_stack **a, int b_idx, int target_idx, int target_pos)
{
t_stack *tmp_a;
tmp_a = *a;
while (tmp_a)
{
if (tmp_a->index > b_idx && tmp_a->index < target_idx)
{
target_idx = tmp_a->index;
target_pos = tmp_a->pos;
}
tmp_a = tmp_a->next;
}
if (target_idx != INT_MAX)
return (target_pos);
tmp_a = *a;
while (tmp_a)
{
if (tmp_a->index < target_idx)
{
target_idx = tmp_a->index;
target_pos = tmp_a->pos;
}
tmp_a = tmp_a->next;
}
return (target_pos);
}
void get_target_position(t_stack **a, t_stack **b)
{
t_stack *tmp_b;
int target_pos;
tmp_b = *b;
get_position(a);
get_position(b);
target_pos = 0;
while (tmp_b)
{
target_pos = get_target(a, tmp_b->index, INT_MAX, target_pos);
tmp_b->target_pos = target_pos;
tmp_b = tmp_b->next;
}
}

37
push.c Executable file
View File

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:37:31 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 20:40:32 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void push(t_stack **src, t_stack **dest)
{
t_stack *tmp;
if (*src == NULL)
return ;
tmp = (*src)->next;
(*src)->next = *dest;
*dest = *src;
*src = tmp;
}
void do_pa(t_stack **stack_a, t_stack **stack_b)
{
push(stack_b, stack_a);
ft_putstr("pa\n");
}
void do_pb(t_stack **stack_a, t_stack **stack_b)
{
push(stack_a, stack_b);
ft_putstr("pb\n");
}

81
push_swap.h Executable file
View File

@ -0,0 +1,81 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push_swap.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 16:56:54 by fgras-ca #+# #+# */
/* Updated: 2023/08/08 17:58:19 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PUSH_SWAP_H
# define PUSH_SWAP_H
# include <stddef.h>
# include <stdlib.h>
# include <unistd.h>
# include <limits.h>
# include <stdio.h>
typedef struct s_stack
{
int value;
int index;
int pos;
int target_pos;
int cost_a;
int cost_b;
struct s_stack *next;
} t_stack;
t_stack *fill_stack_values(int argc, char **argv, int start_idx);
void assign_index(t_stack *stack_a, int argc);
int is_sorted(t_stack *stack);
void tiny_sort(t_stack **stack);
void sort(t_stack **stack_a, t_stack **stack_b);
int get_lowest_index_position(t_stack **stack);
void get_target_position(t_stack **stack_a, t_stack **b);
void get_cost(t_stack **stack_a, t_stack **stack_b);
void do_cheapest_move(t_stack **stack_a, t_stack **stack_b);
void do_move(t_stack **a, t_stack **b, int cost_a, int cost_b);
void do_pa(t_stack **stack_a, t_stack **stack_b);
void do_pb(t_stack **stack_a, t_stack **stack_b);
void do_sa(t_stack **stack_a);
void do_sb(t_stack **stack_b);
void do_ss(t_stack **stack_a, t_stack **stack_b);
void do_ra(t_stack **stack_a);
void do_rb(t_stack **stack_b);
void do_rr(t_stack **stack_a, t_stack **stack_b);
void do_rra(t_stack **stack_a);
void do_rrb(t_stack **stack_b);
void do_rrr(t_stack **stack_a, t_stack **stack_b);
t_stack *get_stack_bottom(t_stack *stack);
t_stack *get_stack_before_bottom(t_stack *stack);
t_stack *stack_new(int value);
void stack_add_bottom(t_stack **stack, t_stack *new);
int get_stack_size(t_stack *stack);
void free_stack(t_stack **stack);
long int ft_atoi(const char *str);
void ft_putstr(char *str);
int nb_abs(int nb);
void exit_error(t_stack **stack_a, t_stack **stack_b);
int is_correct_input(char **argv, int start_idx);
int is_digit(char c);
int is_sign(char c);
int nbstr_cmp(const char *s1, const char *s2);
int size_numbers(char **numbers);
char **ft_split(char const *s, char c);
char **split_args(char *arg);
#endif

46
reverse_rotate.c Executable file
View File

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* reverse_rotate.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:27:59 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 20:34:10 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void rev_rotate(t_stack **stack)
{
t_stack *tmp;
t_stack *tail;
t_stack *before_tail;
tail = get_stack_bottom(*stack);
before_tail = get_stack_before_bottom(*stack);
tmp = *stack;
*stack = tail;
(*stack)->next = tmp;
before_tail->next = NULL;
}
void do_rra(t_stack **stack_a)
{
rev_rotate(stack_a);
ft_putstr("rra\n");
}
void do_rrb(t_stack **stack_b)
{
rev_rotate(stack_b);
ft_putstr("rrb\n");
}
void do_rrr(t_stack **stack_a, t_stack **stack_b)
{
rev_rotate(stack_a);
rev_rotate(stack_b);
ft_putstr("rrr\n");
}

44
rotate.c Executable file
View File

@ -0,0 +1,44 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* rotate.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:19:35 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 20:25:04 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void rotate(t_stack **stack)
{
t_stack *tmp;
t_stack *tail;
tmp = *stack;
*stack = (*stack)->next;
tail = get_stack_bottom(*stack);
tmp->next = NULL;
tail->next = tmp;
}
void do_ra(t_stack **stack_a)
{
rotate(stack_a);
ft_putstr("ra\n");
}
void do_rb(t_stack **stack_b)
{
rotate(stack_b);
ft_putstr("rb\n");
}
void do_rr(t_stack **stack_a, t_stack **stack_b)
{
rotate(stack_a);
rotate(stack_b);
ft_putstr("rr\n");
}

79
sort.c Executable file
View File

@ -0,0 +1,79 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 18:13:21 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 18:25:49 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void push_all_save_three(t_stack **stack_a, t_stack **stack_b)
{
int stack_size;
int pushed;
int i;
stack_size = get_stack_size(*stack_a);
pushed = 0;
i = 0;
while (stack_size > 6 && i < stack_size && pushed < stack_size / 2)
{
if ((*stack_a)->index <= stack_size / 2)
{
do_pb(stack_a, stack_b);
pushed++;
}
else
do_ra(stack_a);
i++;
}
while (stack_size - pushed > 3)
{
do_pb(stack_a, stack_b);
pushed++;
}
}
static void shift_stack(t_stack **stack_a)
{
int lowest_pos;
int stack_size;
stack_size = get_stack_size(*stack_a);
lowest_pos = get_lowest_index_position(stack_a);
if (lowest_pos > stack_size / 2)
{
while (lowest_pos < stack_size)
{
do_rra(stack_a);
lowest_pos++;
}
}
else
{
while (lowest_pos > 0)
{
do_ra(stack_a);
lowest_pos--;
}
}
}
void sort(t_stack **stack_a, t_stack **stack_b)
{
push_all_save_three(stack_a, stack_b);
tiny_sort(stack_a);
while (*stack_b)
{
get_target_position(stack_a, stack_b);
get_cost(stack_a, stack_b);
do_cheapest_move(stack_a, stack_b);
}
if (!is_sorted(*stack_a))
shift_stack(stack_a);
}

42
sort_tiny.c Executable file
View File

@ -0,0 +1,42 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* sort_tiny.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 18:00:36 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 18:06:35 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static int find_highest_index(t_stack *stack)
{
int index;
index = stack->index;
while (stack)
{
if (stack->index > index)
index = stack->index;
stack = stack->next;
}
return (index);
}
void tiny_sort(t_stack **stack)
{
int highest;
if (is_sorted(*stack))
return ;
highest = find_highest_index(*stack);
if ((*stack)->index == highest)
do_ra(stack);
else if ((*stack)->next->index == highest)
do_rra(stack);
if ((*stack)->index > (*stack)->next->index)
do_sa(stack);
}

74
stack.c Executable file
View File

@ -0,0 +1,74 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* stack.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:52:17 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 21:01:51 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
t_stack *get_stack_bottom(t_stack *stack)
{
while (stack && stack->next != NULL)
stack = stack->next;
return (stack);
}
t_stack *get_stack_before_bottom(t_stack *stack)
{
while (stack && stack->next && stack->next->next != NULL)
stack = stack->next;
return (stack);
}
t_stack *stack_new(int value)
{
t_stack *new;
new = malloc(sizeof * new);
if (!new)
return (NULL);
new->value = value;
new->index = 0;
new->pos = -1;
new->target_pos = -1;
new->cost_a = -1;
new->cost_b = -1;
new->next = NULL;
return (new);
}
void stack_add_bottom(t_stack **stack, t_stack *new)
{
t_stack *tail;
if (!new)
return ;
if (!*stack)
{
*stack = new;
return ;
}
tail = get_stack_bottom(*stack);
tail->next = new;
}
int get_stack_size(t_stack *stack)
{
int size;
size = 0;
if (!stack)
return (0);
while (stack)
{
stack = stack->next;
size++;
}
return (size);
}

46
swap.c Executable file
View File

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* swap.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 20:43:09 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 20:48:52 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
static void swap(t_stack *stack)
{
int tmp;
if (stack == NULL || stack->next == NULL)
return ;
tmp = stack->value;
stack->value = stack->next->value;
stack->next->value = tmp;
tmp = stack->index;
stack->index = stack->next->index;
stack->next->index = tmp;
}
void do_sa(t_stack **stack_a)
{
swap(*stack_a);
ft_putstr("sa\n");
}
void do_sb(t_stack **stack_b)
{
swap(*stack_b);
ft_putstr("sb\n");
}
void do_ss(t_stack **stack_a, t_stack **stack_b)
{
swap(*stack_a);
swap(*stack_b);
ft_putstr("ss\n");
}

81
utils.c Executable file
View File

@ -0,0 +1,81 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: fgras-ca <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/07/31 18:58:53 by fgras-ca #+# #+# */
/* Updated: 2023/07/31 19:12:30 by fgras-ca ### ########.fr */
/* */
/* ************************************************************************** */
#include "push_swap.h"
void free_stack(t_stack **stack)
{
t_stack *tmp;
if (!stack || !(*stack))
return ;
while (*stack)
{
tmp = (*stack)->next;
free(*stack);
*stack = tmp;
}
*stack = NULL;
}
void exit_error(t_stack **stack_a, t_stack **stack_b)
{
if (stack_a == NULL || *stack_a != NULL)
free_stack(stack_a);
if (stack_b == NULL || *stack_b != NULL)
free_stack(stack_b);
write(2, "Error\n", 6);
exit (1);
}
long int ft_atoi(const char *str)
{
long int nb;
int sign;
int i;
nb = 0;
sign = 1;
i = 0;
if (str[i] == '+')
i++;
else if (str[i] == '-')
{
sign *= -1;
i++;
}
while (is_digit(str[i]))
{
nb = (nb * 10) + (str[i] - '0');
i++;
}
return (nb * sign);
}
void ft_putstr(char *str)
{
int i;
i = 0;
while (str[i])
{
write(1, &str[i], 1);
i++;
}
}
int nb_abs(int nb)
{
if (nb < 0)
return (nb * -1);
return (nb);
}