079902b834
normed out most files still need to split functions accordingly still need to check for hidden norm errors
337 lines
6.8 KiB
C
337 lines
6.8 KiB
C
/* ************************************************************************** */
|
|
/* */
|
|
/* ::: :::::::: */
|
|
/* push_swap.c :+: :+: :+: */
|
|
/* +:+ +:+ +:+ */
|
|
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
|
|
/* +#+#+#+#+#+ +#+ */
|
|
/* Created: 2019/03/03 11:41:49 by tmaze #+# #+# */
|
|
/* Updated: 2019/03/15 16:17:37 by tmaze ### ########.fr */
|
|
/* */
|
|
/* ************************************************************************** */
|
|
|
|
#include "push_swap.h"
|
|
|
|
void mark_groups(t_psdata *data)
|
|
{
|
|
t_stack *ptr;
|
|
int inds;
|
|
|
|
ptr = data->a;
|
|
inds = 1;
|
|
while (ptr)
|
|
{
|
|
ptr->ind = inds;
|
|
if (ptr->next && ptr->nb > ptr->next->nb)
|
|
inds++;
|
|
ptr = ptr->next;
|
|
}
|
|
}
|
|
|
|
void get_min_max(t_psdata *data, int *min_max, int *ind_min_max)
|
|
{
|
|
t_stack *ptr;
|
|
int i;
|
|
|
|
min_max[0] = FT_INT_MAX;
|
|
min_max[1] = FT_INT_MIN;
|
|
ptr = data->a;
|
|
i = 0;
|
|
while (ptr)
|
|
{
|
|
if (ptr->nb < min_max[0] && (ind_min_max[0] = i) == i)
|
|
min_max[0] = ptr->nb;
|
|
if (ptr->nb > min_max[1] && (ind_min_max[1] = i) == i)
|
|
min_max[1] = ptr->nb;
|
|
i++;
|
|
ptr = ptr->next;
|
|
}
|
|
}
|
|
|
|
void sortfor3(t_psdata *data)
|
|
{
|
|
int min_max[2];
|
|
int ind_min_max[2];
|
|
|
|
get_min_max(data, min_max, ind_min_max);
|
|
while (ind_min_max[0] != 0 || ind_min_max[1] != 2)
|
|
{
|
|
if (ind_min_max[0] == ind_min_max[1] - 1)
|
|
ft_printf("sa\n");
|
|
if (ind_min_max[0] == ind_min_max[1] - 1)
|
|
ps_swap(data, 'a');
|
|
if (ind_min_max[1] == 0)
|
|
ft_printf("ra\n");
|
|
if (ind_min_max[1] == 0)
|
|
ps_rot(data, 'a');
|
|
if (ind_min_max[0] == 2 && ind_min_max[1] == 1)
|
|
ft_printf("rra\n");
|
|
if (ind_min_max[0] == 2 && ind_min_max[1] == 1)
|
|
ps_rerot(data, 'a');
|
|
get_min_max(data, min_max, ind_min_max);
|
|
}
|
|
}
|
|
|
|
void sortfor5(t_psdata *data)
|
|
{
|
|
ft_printf("pb\n");
|
|
ps_push(data, 'b');
|
|
ft_printf("pb\n");
|
|
ps_push(data, 'b');
|
|
if (data->b->nb > data->b->next->nb)
|
|
ft_printf("sb\n");
|
|
if (data->b->nb > data->b->next->nb)
|
|
ps_swap(data, 'b');
|
|
sortfor3(data);
|
|
data->b->ind = 1;
|
|
data->b->next->ind = 1;
|
|
data->a->ind = 2;
|
|
data->a->next->ind = 2;
|
|
data->a->next->next->ind = 2;
|
|
while (data->a->ind == 2 || data->size_b > 0)
|
|
{
|
|
if (data->a->ind != 2 || (data->b && data->b->nb < data->a->nb))
|
|
ft_printf("pa\n");
|
|
if (data->a->ind != 2 || (data->b && data->b->nb < data->a->nb))
|
|
ps_push(data, 'a');
|
|
data->a->ind = 3;
|
|
ft_printf("ra\n");
|
|
ps_rot(data, 'a');
|
|
}
|
|
}
|
|
|
|
t_stack *get_last_a(t_psdata *data)
|
|
{
|
|
t_stack *ptr;
|
|
|
|
ptr = data->a;
|
|
while (ptr && ptr->next)
|
|
ptr = ptr->next;
|
|
return (ptr);
|
|
}
|
|
|
|
int get_size_firsts(t_psdata *data)
|
|
{
|
|
t_stack *ptr;
|
|
int inds;
|
|
int i;
|
|
|
|
inds = data->a->ind;
|
|
i = 0;
|
|
ptr = data->a;
|
|
while (ptr && ptr->ind == inds && (i += 1))
|
|
ptr = ptr->next;
|
|
if (ptr)
|
|
{
|
|
inds = ptr->ind;
|
|
while (ptr && ptr->ind == inds && (i += 1))
|
|
ptr = ptr->next;
|
|
}
|
|
return (i);
|
|
}
|
|
|
|
int get_size_last(t_psdata *data)
|
|
{
|
|
t_stack *ptr;
|
|
int inds;
|
|
int i;
|
|
|
|
i = 0;
|
|
ptr = data->a;
|
|
while (ptr && ptr->next)
|
|
ptr = ptr->next;
|
|
inds = ptr->ind;
|
|
ptr = data->a;
|
|
while (ptr)
|
|
{
|
|
i += (ptr->ind == inds) ? 1 : 0;
|
|
ptr = ptr->next;
|
|
}
|
|
return (i);
|
|
}
|
|
|
|
int get_nb_groups(t_psdata *data)
|
|
{
|
|
t_stack *ptr;
|
|
int ind;
|
|
int ret;
|
|
|
|
ret = 0;
|
|
ptr = data->a;
|
|
ind = ptr->ind;
|
|
while (ptr)
|
|
{
|
|
if (ret == 0 || ptr->ind != ind)
|
|
{
|
|
ret++;
|
|
ind = ptr->ind;
|
|
}
|
|
ptr = ptr->next;
|
|
}
|
|
return (ret);
|
|
}
|
|
|
|
int join_lists(t_psdata *data, t_stack **last, int inds, int inds2)
|
|
{
|
|
while ((*last)->ind == inds2 || data->size_b > 0)
|
|
if (((*last)->ind != inds2 && data->size_b > 0)
|
|
|| (data->size_b > 0 && data->b->nb > (*last)->nb))
|
|
{
|
|
if (add_op(data, "pa\0") == NULL)
|
|
return (0);
|
|
ps_push(data, 'a');
|
|
data->a->ind = inds;
|
|
}
|
|
else if (data->size_b == 0 || data->b->nb < (*last)->nb)
|
|
{
|
|
if (add_op(data, "rra") == NULL)
|
|
return (0);
|
|
ps_rerot(data, 'a');
|
|
data->a->ind = inds;
|
|
(*last) = get_last_a(data);
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
int rotate_list(t_psdata *data, t_stack **last)
|
|
{
|
|
t_list *tmp;
|
|
|
|
if (get_nb_groups(data) > 2)
|
|
{
|
|
if (get_nb_groups(data) != 2
|
|
&& data->a->ind != (*last)->ind && add_op(data, "rra") == NULL)
|
|
return (0);
|
|
else if (get_nb_groups(data) != 2 && data->a->ind != (*last)->ind)
|
|
{
|
|
ps_rerot(data, 'a');
|
|
(*last) = get_last_a(data);
|
|
while ((*last)->ind == data->a->ind
|
|
&& (tmp = add_op(data, "rra")) != NULL)
|
|
{
|
|
ps_rerot(data, 'a');
|
|
(*last) = get_last_a(data);
|
|
}
|
|
}
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
int sort(t_psdata *data)
|
|
{
|
|
t_list *tmp;
|
|
t_stack *last;
|
|
int inds;
|
|
int inds2;
|
|
|
|
last = get_last_a(data);
|
|
inds = last->ind + 1;
|
|
while (data->a->ind != last->ind)
|
|
{
|
|
inds2 = data->a->ind;
|
|
while (data->a && data->a->ind == inds2
|
|
&& (tmp = add_op(data, "pb\0")) != NULL)
|
|
ps_push(data, 'b');
|
|
if (tmp == NULL)
|
|
return (0);
|
|
inds2 = last->ind;
|
|
if (join_lists(data, &last, inds, inds2) == 0)
|
|
return (0);
|
|
if (rotate_list(data, &last) == 0)
|
|
return (0);
|
|
inds++;
|
|
}
|
|
return (1);
|
|
}
|
|
|
|
void clean_op(t_psdata *data)
|
|
{
|
|
t_list *it;
|
|
t_list **prec;
|
|
char *ct1;
|
|
char *ct2;
|
|
char *ct3;
|
|
|
|
it = data->op;
|
|
prec = &(data->op);
|
|
while (it && it->next)
|
|
{
|
|
ct1 = (char*)(it->content);
|
|
ct2 = (char*)(it->next->content);
|
|
if (ct1[0] == 'p' && ct2[0] == 'p' && ct1[1] != ct2[1])
|
|
{
|
|
*prec = it->next->next;
|
|
ft_memdel(&(it->next->content));
|
|
ft_memdel((void**)(&(it->next)));
|
|
ft_memdel(&(it->content));
|
|
ft_memdel((void**)(&it));
|
|
it = data->op;
|
|
prec = &(data->op);
|
|
}
|
|
else if (it->next->next)
|
|
{
|
|
ct3 = (char*)(it->next->next->content);
|
|
if (ct1[0] == 'p' && ct1[1] == 'b' && ct3[0] == 'p'
|
|
&& ct3[1] == 'a' && ft_strcmp(ct2, "rra") == 0)
|
|
{
|
|
*prec = it->next;
|
|
ft_strcpy((char*)(it->next->next->content), "sa");
|
|
ft_memdel(&(it->content));
|
|
ft_memdel((void**)&it);
|
|
it = data->op;
|
|
prec = &(data->op);
|
|
}
|
|
else
|
|
{
|
|
prec = &(it->next);
|
|
it = it->next;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
prec = &(it->next);
|
|
it = it->next;
|
|
}
|
|
}
|
|
}
|
|
|
|
void print_ops(t_psdata *data)
|
|
{
|
|
t_list *it;
|
|
|
|
it = data->op;
|
|
while (it)
|
|
{
|
|
ft_printf("%s\n", (char*)(it->content));
|
|
it = it->next;
|
|
}
|
|
}
|
|
|
|
int main(int ac, char **av)
|
|
{
|
|
t_psdata data;
|
|
|
|
ps_initdata(&data);
|
|
if (!get_params(&data, ac, av, 0))
|
|
return (0);
|
|
if (data.a == NULL)
|
|
ft_putendl_fd("Error", 2);
|
|
if (data.size_a == 3)
|
|
sortfor3(&data);
|
|
else if (data.size_a == 5)
|
|
sortfor5(&data);
|
|
if (data.size_a != 0 && data.size_a != 3 && data.size_a != 5)
|
|
{
|
|
mark_groups(&data);
|
|
if (sort(&data) == 0)
|
|
ft_putendl_fd("Error\n", 2);
|
|
else
|
|
{
|
|
clean_op(&data);
|
|
print_ops(&data);
|
|
}
|
|
}
|
|
ps_stkclean(&data);
|
|
return (0);
|
|
}
|