int get_next_line(int const fd, char **line)
{
static char *rest;
char buf[BUFF_SIZE];
int rd;
if (line == NULL || (fd < 0 || BUFF_SIZE < 1))
return (-1);
*line = (char *)ft_memalloc(1);
if ((ft_traiting_value_rest(rest, buf, line)) == 1)
return (1);
while (((rd = read(fd, buf, BUFF_SIZE)) > 0) && ((ft_check(buf, 0)) == 0))
ft_storage_in_line(buf, line, rd, 0);
if (rd == (-1))
return (-1);
if ((rd == 0 && (!rest || rest[0] == '\0')) && *line[0] == '\0')
return (0);
if (rest && rest[0] != '\0')
ft_storage_in_line(rest, line, rd, (ft_check(rest, 0)));
if ((ft_check(buf, 0)) == 1)
{
ft_storage_in_line(buf, line, rd, 1);
rest = ft_storage_rest(buf, rd);
}
if (((ft_check(buf, 0)) == 2) && (rd > 0))
ft_storage_in_line(buf, line, rd, 0);
return (1);
}
t_lst *algo(t_lst *lst_a, t_lst *lst_b, t_lst *tmp, int c)
{
lst_a = tmp;
while (ft_check(lst_a, lst_b, tmp) == 0)
{
if (ft_check(lst_a = swap(lst_a, tmp, lst_b), lst_b, tmp) == 1)
return (lst_a);
c = add(lst_a, tmp, c);
lst_a = add2(lst_a, lst_b, tmp, c);
if (lst_a->content == c && ft_check(tmp, lst_b, tmp) == 0)
{
lst_a = tmp;
lst_b = push(lst_b, lst_a, tmp, "pb ");
lst_a = push2(lst_a, lst_b, tmp);
}
if (lst_a == NULL)
while (lst_b != NULL)
{
if (lst_b->next == NULL)
lst_a = push(lst_a, lst_b, tmp, "pa\n");
else
lst_a = push(lst_a, lst_b, tmp, "pa ");
lst_a = tmp;
lst_b = push3(lst_b, lst_a, tmp);
}
}
return (lst_a);
}
int main(int argc, char **argv)
{
if (argc > 1)
while (*++argv != '\0')
{
ft_check(ft_openfile(*argv));
}
else
ft_check(ft_read_standard());
return (0);
}
int get_next_line(int const fd, char **line)
{
static t_gnl tab[1000] = { T_GNL_INIT_100 };
char buf[BUFF_SIZE + 1];
int ret;
buf[BUFF_SIZE] = '\0';
while (42)
{
if ((ret = read(fd, buf, BUFF_SIZE)) == 0)
tab[fd].status = END;
else {
buf[ret] = '\0';
tab[fd].data = ft_strjoin(tab[fd].data , buf);
}
ft_check(&tab[fd], *line);
if (tab[fd].status != WORK)
{
if (tab[fd].lss == FALSE)
{
tab[fd].status = WORK;
tab[fd].lss = TRUE;
}
return (tab[fd].status);
}
}
return(0);
}
t_data *ft_read(char *entry)
{
int i;
char **tmp;
static t_data *ptr;
i = -1;
if (ft_check(entry) == 0)
return (NULL);
if (!ptr)
{
ptr = (t_data *)malloc(sizeof(t_data));
ptr->entry = (int **)malloc(sizeof(int *) * 100000);
ptr->index = 0;
ptr->width = 0;
}
if (!(ptr->entry[ptr->index]))
ptr->entry[ptr->index] = (int *)malloc(sizeof(int) * 100000);
tmp = ft_strsplit(entry, ' ');
while (tmp[++i])
ptr->entry[ptr->index][i] = ft_atoi(tmp[i]);
if (ptr->index != 0 && i != ptr->width)
return (NULL);
ptr->index++;
ptr->width = i;
return (ptr);
}
t_square *ft_bsq(char **map, int nb_lines, char *c)
{
t_square *sqr;
t_square *tmp;
sqr = NULL;
tmp = NULL;
sqr = ft_init_square(sqr);
tmp = ft_init_square(tmp);
while (tmp->y < nb_lines - sqr->size)
{
while (tmp->x < ft_strlen(map[tmp->y]) - sqr->size)
{
if (map[tmp->y][tmp->x] == c[0])
{
tmp->size = ft_check(*tmp, c, map, nb_lines);
if (tmp->size > sqr->size)
*sqr = *tmp;
}
tmp->x++;
}
tmp->x = 0;
tmp->y++;
}
return (sqr);
}
int ft_rec(unsigned short map[16], t_tet *tets, t_tet *tet, int size)
{
int i;
int j;
if (tet->blocs == 0)
return (0);
i = (tet->ident != -1) ? HGH(((tets + tet->ident)->pos) & 0xff) - 1 : -1;
j = (tet->ident != -1) ? LOW(((tets + tet->ident)->pos) & 0xff) : -1;
while (++i + HGH(tet->max) < size)
{
while (++j + LOW(tet->max) < size)
{
if (ft_check(map, tet->blocs + (STK((i << 4) + j))) == 0)
{
ft_toggle(map, tet->blocs + (tet->pos = STK((i << 4) + j)));
if (ft_rec(map, tets, tet + 1, size) == 0)
return (0);
ft_toggle(map, tet->pos + tet->blocs);
}
}
j = -1;
}
return (-1);
}
int ft_atoi(const char *str)
{
char *cp;
int i;
int n;
n = 0;
i = 0;
cp = ft_strtrim_extended(str);
if (ft_check(cp, i) != 1)
return (0);
i++;
while (ft_isdigit(cp[i]) == 1)
i++;
cp[i] = '\0';
if (ft_isdigit(cp[0]) == 1)
i = 0;
else
i = 1;
while (i < ft_strlen(cp))
n = 10 * n + (int)cp[i++] - 48;
if (cp[0] == 45)
n = -n;
return (n);
}
void ft_putll(long long to_print)
{
int boul;
int boul2;
boul2 = 0;
boul = 0;
boul2 = ft_check(to_print, boul2);
if (boul2 == 1)
{
if (to_print < 0)
{
to_print = to_print * (-1);
boul++;
}
if (boul == 1)
ft_putchar('-');
if (to_print >= 10)
{
ft_putll(to_print / 10);
ft_putll(to_print % 10);
}
else
ft_putchar(to_print + '0');
}
}
int creat_str(t_pf *ptf, int flag, int dot)
{
char *str;
int size;
size = 0;
(flag & 16 && flag & 1 && ptf->type == '%') ? ptf->flag -= 16 : 0;
if (ptf->type == 'n' && free_ptf(ptf) < 0)
return (0);
if (ptf->type == '%' && ptf->dot && !(ptf->dot = 0))
ptf->prec = 0;
if (!ptf->dot && ptf->flag & 16)
{
ptf->prec = ptf->width;
if (ptf->value[0] == '-' || ptf->flag & 2 || ptf->flag & 4)
ptf->prec--;
}
if (dot && !ptf->prec && ptf->value[0] && ft_check(ptf))
ptf->value[0] = 0;
if (!(str = makeoptions(ptf)))
return (-1);
(ptf->type == 'X') ? upstr(&str) : 0;
size = p_var(ptf, str);
free(str);
str = NULL;
free_ptf(ptf);
return (size);
}
void ft_check2(char *check)
{
int octet = 0;
int dieze = 0;
int rline = 0;
if(!ft_check(check))
return ;
while (*check)
{
if (*check == '#')
dieze = dieze + 1;
if (*check == '\n')
rline = rline + 1;
if (octet == 21 && dieze != 4 && rline != 5)
{
ft_putstr("tetriminos invalide");
break;
}
if (octet == 21 && dieze == 4 && rline == 5)
{
octet = 0;
dieze = 0;
rline = 0;
}
check++;
octet++;
}
}
void ft_readbsq_file(char *av, t_caract *bsq, t_infos *elem)
{
bsq->err = 0;
bsq->fd = ft_open(av, bsq);
if (bsq->err == 1)
return ;
bsq->st_size = ft_size_file(av, bsq->err);
ft_buff_size(bsq);
if (bsq->err == 1)
return ;
ft_check(bsq, elem);
if (bsq->err == 1)
return ;
ft_position(bsq);
if (bsq->err == 1)
return ;
ft_buff_int(bsq, elem, 0, 0);
if (bsq->err == 1)
return ;
ft_bsq(bsq, elem, bsq->square->x, bsq->square->y);
if (bsq->err == 1)
return ;
ft_print_bsq(bsq->double_buff, bsq);
if (bsq->err == 1)
return ;
ft_free_all(bsq, elem);
}
void ft_readbsq_stdin(t_caract *bsq, t_infos *elem)
{
if ((bsq->simple_buff = ft_buff_size_stdin(bsq)) == 0)
{
write(1, "map error\n", 10);
return ;
}
bsq->simple_buff[bsq->st_size] = '\0';
if (bsq->err == 1)
return ;
ft_check(bsq, elem);
if (bsq->err == 1)
return ;
ft_position(bsq);
if (bsq->err == 1)
return ;
ft_buff_int(bsq, elem, 0, 0);
if (bsq->err == 1)
return ;
ft_bsq(bsq, elem, bsq->square->x, bsq->square->y);
if (bsq->err == 1)
return ;
ft_print_bsq(bsq->double_buff, bsq);
if (bsq->err == 1)
return ;
ft_free_all(bsq, elem);
}
int ft_strlen_tw(char *str, char *charset)
{
int i;
int len;
i = 0;
len = 0;
while (str[i])
{
while (str[i] && (ft_check(str, charset, i) == 1))
i = i + ft_strlen(charset);
while (str[i] && (ft_check(str, charset, i) == 0))
{
len++;
i++;
}
}
return (len);
}
int ft_get_score(t_ctx *ctx, t_move *move)
{
int score;
if (ft_check(move->grid, move->col, move->row))
return (1000);
score = 0;
score += ft_neighbours(ctx, move, move->grid);
score += ft_annoy(ctx, move, move->grid);
return (score);
}
int ft_printf_part1(t_glob *global, va_list ap, t_list *tmp, int result)
{
if (ft_check(tmp, 0) < 0)
exit(EXIT_FAILURE);
while (global->first->next)
{
if (ft_strlen(global->first->txt) > 0)
result += ft_putstr(global->first->txt);
result += ft_print_end(ap, global->first, global->first->conv, 0);
global->first = global->first->next;
}
return (result);
}
int ft_strlen_w(char *str, char *charset, int i)
{
int len;
int j;
len = 0;
j = 0;
while (str[i] && charset[j] && !ft_check(str, charset, i))
{
i++;
len++;
}
return (len);
}
int main(int argc, char **argv)
{
int **sudoku;
if (argc == 10)
{
if (!ft_check(argv))
return (write(2, "Erreur\n", 8));
sudoku = ft_chartoint(argv);
ft_resolve(sudoku, 0, 1);
ft_aff(sudoku);
}
else
write(2, "Erreur\n", 8);
return (0);
}
t_lst *swap(t_lst *lst_a, t_lst *tmp, t_lst *lst_b)
{
if (lst_a->next != NULL)
{
while (lst_a->next->next != NULL)
lst_a = lst_a->next;
if (lst_a->content < lst_a->next->content)
{
lst_a = tmp;
lst_a = swap_ab(lst_a, lst_b, tmp, "sa ");
}
lst_a = tmp;
if (ft_check(lst_a, lst_b, tmp) == 1)
return (lst_a);
lst_a = tmp;
}
return (lst_a);
}
void ft_solve(int row, int n)
{
int col;
col = 1;
while (col <= n)
{
if (ft_check(row, col) == 1)
{
board[row] = col; /* placing queen b'cos no attacks */
if ( row == n) /* end of grid */
ft_print(n); /* print out grid */
else /* try next position */
ft_solve(row + 1, n);
}
col++;
}
}
void ft_queen(int row, int n) //backtracking function
{
int column;
column = 1;
while (column<=n)
{
if (ft_check(row, column))
{
board[row] = column;
if (row == n)
print(n);
else
ft_queen(row+1, n);
}
column++;
}
}
int ft_check_at(t_map *map, t_square *square, int x, int y)
{
int count_size;
int result;
count_size = square->size;
if ((result = ft_check(map, x, y, count_size + 1)) == -2)
while (x + ++count_size <= map->width
&& y + count_size <= map->height
&& ft_check_two(map, x, y, count_size))
{
square->size = count_size;
square->x = x;
square->y = y;
}
else
return (result);
return (0);
}
void ft_launch(char **av, int ac)
{
t_stack *pa;
t_stack *pb;
char *opt;
int a;
opt = ft_strdup("00000");
if ((a = ft_check(av, ac, opt)) > 0)
{
if ((ac - a + 1) < 1)
exit (write(1, "\n", 1));
pa = ft_create_stack(av, ac - a + 1, "stack a", opt);
pb = ft_create_stack(NULL, ac - a + 1, "stack b", opt);
ft_exec(*pa, *pb);
}
else
ft_putendl("Error");
free(opt);
}
static int ft_fl(const char *format, int *i, int *ret, va_list var)
{
const char *s;
const char *e;
char *fl;
int len;
fl = NULL;
s = (format + *i + 1);
e = s;
len = 0;
while (ft_check(*e))
e++;
len = e - s;
fl = malloc(sizeof(char) * (len + 1));
fl = ft_strncpy_printf(fl, s, len);
*ret += ft_tab(var, fl);
free(fl);
*i += len;
return (*ret);
}
static int ft_putpcs(t_map *map, t_coord *ret)
{
int count;
count = 0;
ret->y_b = ret->b_index / map->b_weidth;
ret->x_b = ret->b_index % map->b_weidth;
ret->x = ret->x_b;
ret->y = ret->y_b;
ret->p_index = 0;
while (map->pcs[ret->p_index])
{
if (map->pcs[ret->p_index] == '*')
{
if (ft_check(map, ret, &count) == 1)
return (1);
}
ret->p_index++;
}
if (count == 0)
return (1);
return (0);
}
static int ft_traiting_value_rest(char *rest, char *buf, char **line)
{
int len;
int edl;
char *r_tmp;
if (rest && rest[0] != '\0')
{
len = ft_strlen(rest);
edl = ft_check(rest, len);
ft_storage_in_line(rest, line, len, edl);
if (edl == 1)
{
r_tmp = ft_strdup(rest);
ft_strclr(rest);
ft_strcpy(rest, ft_storage_rest(r_tmp, len));
free(r_tmp);
return (1);
}
rest[0] = '\0';
}
ft_bzero(buf, BUFF_SIZE);
return (0);
}
char *ft_itoa(int n)
{
char *str;
size_t countn;
int i;
i = 0;
countn = 0;
str = NULL;
if (n == -2147483648)
return (str = ft_except(str));
if (n < 0)
{
n = n * -1;
i = 1;
}
countn = ft_countn(n) + i;
if ((str = ft_strnew(countn + 1)) == NULL)
return (NULL);
ft_check(str, n, countn);
if (i == 1)
str[0] = '-';
return (str);
}
int main(int ac, char **av)
{
int fd;
t_file file;
char **tab;
fd = 0;
file = ft_init(file);
tab = NULL;
if (ac != 2)
write(1, "usage: ./fillit input_file\n", 27);
else
{
tab = ft_convert(ft_open(av[1], &fd, 0), &file.m, 0, 0);
if (tab != NULL && ft_check(tab, file) != -1 && close(fd) != -1)
{
if (!(ft_resolve(tab, file, NULL)))
write(1, "error\n", 6);
}
else
write(1, "error\n", 6);
}
return (0);
}
int main(int argc, char **argv)
{
if (argc == 2)
ft_check(ft_stock(argv[1]));
return (0);
}
