Piscine 42 — Cheat Sheet

ft_putchar

Imprime un solo carácter

print

void ft_putchar(char c);

1Usa write(1, &c, 1) para imprimir el carácter
2No devuelve nada → void

void    ft_putchar(char c)
{
    write(1, &c, 1);
}

casos borde

Cualquier char válido funciona, incluido '\n'

ft_putstr

Imprime un string con write

print

void ft_putstr(char *str);

1Recorre el string con while (str[i] != '\0')
2En cada iteración imprime str[i] con write
3Avanza i++ hasta el final

void    ft_putstr(char *str)
{
    int i;

    i = 0;
    while (str[i] != '\0')
    {
        write(1, &str[i], 1);
        i++;
    }
}

casos borde

str = "" → no imprime nada, el while no entra

ft_putnbr

Imprime un entero con write

print

void ft_putnbr(int nb);

1Si es negativo: imprime '-' y convierte a positivo
2Si tiene más de un dígito: llama recursivamente con nb / 10
3Imprime el último dígito con (nb % 10) + '0'

void    ft_putnbr(int nb)
{
    char c;

    if (nb < 0)
    {
        write(1, "-", 1);
        nb = -nb;
    }
    if (nb >= 10)
        ft_putnbr(nb / 10);
    c = (nb % 10) + '0';
    write(1, &c, 1);
}

casos borde

nb = 0 → imprime "0" | nb = -7 → imprime "-7"

ft_strlen

Longitud de un string

string

int ft_strlen(char *str);

1Recorre el string mientras str[i] != '\0'
2Incrementa i en cada carácter
3Devuelve i → la longitud sin contar el '\0'

int     ft_strlen(char *str)
{
    int i;

    i = 0;
    while (str[i] != '\0')
        i++;
    return (i);
}

casos borde

str = "" → devuelve 0 | no cuenta el '\0' final

ft_strcpy

Copia src en dest

string

char *ft_strcpy(char *dest, char *src);

1Recorre src mientras src[i] != '\0'
2Copia cada carácter: dest[i] = src[i]
3Añade el '\0' al final de dest
4Devuelve dest

char    *ft_strcpy(char *dest, char *src)
{
    int i;

    i = 0;
    while (src[i] != '\0')
    {
        dest[i] = src[i];
        i++;
    }
    dest[i] = '\0';
    return (dest);
}

casos borde

Siempre copia el '\0' final | devuelve dest siempre

ft_strcmp

Compara dos strings

string

int ft_strcmp(char *s1, char *s2);

1Avanza mientras s1[i] == s2[i] y no sea '\0'
2Al parar, devuelve s1[i] - s2[i]
30 = iguales | negativo = s1 menor | positivo = s1 mayor

int     ft_strcmp(char *s1, char *s2)
{
    int i;

    i = 0;
    while (s1[i] == s2[i] && s1[i] != '\0')
        i++;
    return (s1[i] - s2[i]);
}

casos borde

"" == "" → 0 | "abc" vs "abd" → negativo

ft_strcat

Concatena src al final de dest

string

char *ft_strcat(char *dest, char *src);

1Avanza hasta el final de dest con while (dest[i] != '\0')
2Desde ahí, copia src carácter a carácter
3Añade '\0' al final y devuelve dest

char    *ft_strcat(char *dest, char *src)
{
    int i;
    int j;

    i = 0;
    j = 0;
    while (dest[i] != '\0')
        i++;
    while (src[j] != '\0')
    {
        dest[i] = src[j];
        i++;
        j++;
    }
    dest[i] = '\0';
    return (dest);
}

casos borde

dest debe tener espacio suficiente para src

ft_atoi

Convierte string a entero

número

int ft_atoi(char *str);

1Salta espacios en blanco al inicio
2Detecta signo + o -, guarda en sign
3Lee dígitos: resu = resu * 10 + str[i] - '0'
4Devuelve resu * sign

int     ft_atoi(char *str)
{
    int i;
    int sign;
    int resu;

    i = 0;
    sign = 1;
    resu = 0;
    while (str[i] == ' ' || str[i] == '\t' || str[i] == '\n'
        || str[i] == '\r' || str[i] == '\f' || str[i] == '\v')
        i++;
    if (str[i] == '-' || str[i] == '+')
    {
        if (str[i] == '-')
            sign = -1;
        i++;
    }
    while (str[i] >= '0' && str[i] <= '9')
    {
        resu = resu * 10 + str[i] - '0';
        i++;
    }
    return (resu * sign);
}

casos borde

" -42" → -42 | "42abc" → 42 | "abc" → 0

ft_iterative_factorial

Factorial con bucle

math

int ft_iterative_factorial(int nb);

1Si nb < 0 → devuelve 0
2Inicializa result = 1
3Multiplica result *= i desde 1 hasta nb

int     ft_iterative_factorial(int nb)
{
    int result;
    int i;

    if (nb < 0)
        return (0);
    result = 1;
    i = 1;
    while (i <= nb)
    {
        result *= i;
        i++;
    }
    return (result);
}

casos borde

nb = 0 → 1 | nb negativo → 0 | 5! = 120

ft_recursive_factorial

Factorial con recursión

math

int ft_recursive_factorial(int nb);

1Si nb < 0 → devuelve 0
2Caso base: si nb == 0 → devuelve 1
3Caso recursivo: nb * factorial(nb - 1)

int     ft_recursive_factorial(int nb)
{
    if (nb < 0)
        return (0);
    if (nb == 0)
        return (1);
    return (nb * ft_recursive_factorial(nb - 1));
}

casos borde

nb = 0 → 1 | nb negativo → 0

ft_swap

Intercambia dos enteros con punteros

número

void ft_swap(int *a, int *b);

1Guarda *a en una variable temporal tmp
2Asigna *a = *b
3Asigna *b = tmp

void    ft_swap(int *a, int *b)
{
    int tmp;

    tmp = *a;
    *a = *b;
    *b = tmp;
}

casos borde

*a == *b → funciona igual | usa * para acceder al valor

ft_fibonacci

Devuelve el índice N de Fibonacci

math

int ft_fibonacci(int index);

1Si index < 0 → devuelve -1
2Si index == 0 → devuelve 0
3Si index == 1 → devuelve 1
4Si no: fib(n-1) + fib(n-2)

int     ft_fibonacci(int index)
{
    if (index < 0)
        return (-1);
    if (index == 0)
        return (0);
    if (index == 1)
        return (1);
    return (ft_fibonacci(index - 1)
        + ft_fibonacci(index - 2));
}

casos borde

index negativo → -1 | serie: 0,1,1,2,3,5,8,13...