Exam Rank 02 · Prep Sheet

Cheat Sheet
& Checklist

Repasa cada concepto clave, marca lo que ya dominas y consulta los man pages disponibles en el examen. Click en cualquier ítem para marcarlo.

01 — Flujo mental en el examen

Lee el enunciado ENTERO antes de escribir código

Fíjate en el prototipo, el nombre del archivo, las funciones autorizadas

Identifica el tipo de ejercicio

¿Es un programa (main) o una función? ¿Necesita malloc? ¿Usa write o printf?

Escribe el include y la firma correctos PRIMERO

#include <unistd.h> para write · #include <stdlib.h> para malloc/atoi

Casos borde ANTES de la lógica principal

argc incorrecto · puntero NULL · min >= max · división por 0 · n=0 o n=1

Compila con las flags correctas

cc -Wall -Wextra -Werror archivo.c — sin warnings = bien

Testea los casos del ejemplo Y los extremos

String vacío · solo espacios · string de 1 char · números negativos · 0

Verifica el newline final

Casi todos los programas terminan con write(1, "\n", 1) — ¡no te lo olvides!

Revisa la Norma antes de entregar

Indentación con tabs · max 25 líneas por función · nombres correctos de archivo

02 — Conceptos clave por dominar

Esencial

write() — la función fundamental

Solo puedes usar write() en la mayoría de ejercicios. Sin printf, sin puts.

write(1, &c, 1); // 1 char write(1, "hola", 4); // string literal write(1, "\n", 1); // newline

Esencial

argc / argv — argumentos del programa

argc incluye el nombre del programa. Con 1 argumento, argc == 2.

argc == 1 // sin argumentos argc == 2 // 1 argumento (argv[1]) argc == 4 // 3 argumentos argv[1][0] // primer char del 1er arg

Strings

Iterar un string correctamente

El string termina en '\0'. El índice i empieza en 0.

i = 0; while (str[i]) // mientras no sea '\0' { // ... i++; }

Strings

Calcular longitud de un string

Patrón usado en ft_strlen, rev_print, last_word y muchos más.

i = 0; while (str[i]) i++; // i == longitud del string

Strings

Conversión mayúsculas ↔ minúsculas

La diferencia entre 'A' y 'a' en ASCII es exactamente 32.

c += 32; // mayúscula → minúscula c -= 32; // minúscula → mayúscula // Comprueba SIEMPRE si es letra antes

Strings

Rotaciones en el alfabeto (rot)

Fórmula universal con % 26 para wrapping automático.

// ROT-N minúsculas: c = (c - 'a' + N) % 26 + 'a'; // ROT-N mayúsculas: c = (c - 'A' + N) % 26 + 'A';

Memoria

malloc — patrón básico

Calcula el tamaño, malloc, comprueba NULL, usa, pon el '\0' final.

ptr = malloc(sizeof(char) * (len + 1)); if (!ptr) return (NULL); // ... rellenar ... ptr[len] = '\0';

Memoria

malloc — array de ints

Para ft_range, ft_rrange. El tamaño es (max - min) ints.

arr = malloc(sizeof(int) * size); // NO hay '\0' — es un array de ints // El caller sabe el tamaño por contexto

Números

putnbr — imprimir un número sin printf

Función recursiva esencial. Divide entre 10, imprime de izquierda a derecha.

void putnbr(int n) { char c; if (n < 0) { write(1, "-", 1); n = -n; } if (n >= 10) putnbr(n / 10); c = '0' + n % 10; write(1, &c, 1); }

Números

ft_atoi — 3 fases

Whitespace → signo → dígitos. Los 6 whitespace: ' ' \t \n \r \f \v

// Fase 1: salta whitespace while (str[i] == ' ' || str[i] == '\t' ...) // Fase 2: signo if (str[i] == '-') sign = -1; // Fase 3: acumula dígitos result = result * 10 + (str[i] - '0');

Números

ft_itoa — rellena de derecha a izquierda

Usa long para evitar overflow con INT_MIN. Calcula longitud → malloc → rellena.

// Rellena al revés: str[--len] = '0' + (num % 10); num /= 10; // Usa long num = (long)n

Patrones

Detectar separadores (espacio / tab)

Patrón recurrente en first_word, last_word, epur_str, str_capitalizer...

// Separador básico: c == ' ' || c == '\t' // Saltar separadores iniciales: while (str[i] == ' ' || str[i] == '\t') i++;

Patrones

Flag de "nueva palabra"

Patrón para str_capitalizer, epur_str. El flag se activa tras separador.

new_word = 1; // inicio = nueva palabra while (str[i]) { if (is_sep(str[i])) new_word = 1; else if (new_word) { /* capitalizar */ new_word = 0; } else { /* minúscula */ } }

Patrones

Subsecuencia — patrón dos índices

Usado en wdmatch, hidenp. i solo avanza cuando hay coincidencia.

i = 0; j = 0; while (s1[i] && s2[j]) { if (s1[i] == s2[j]) i++; j++; } if (!s1[i]) // s1 está en s2

Bits

Operaciones de bits fundamentales

Para print_bits, reverse_bits, swap_bits, is_power_of_2.

(n >> i) & 1 // extrae bit en posición i n & (n - 1) // 0 si potencia de 2 (n >> 4) | (n << 4) // swap nibbles result = (result << 1) | (n & 1)

Recursión

Recursión — estructura básica

Caso base primero, luego la llamada recursiva. Usada en putnbr, pgcd, flood_fill.

int pgcd(int a, int b) { if (b == 0) return (a); // caso base return (pgcd(b, a % b)); // recursión }

Estructuras

Lista enlazada — recorrer

Avanza con ->next hasta NULL. Estructura: data + next.

while (list) { // usar list->data list = list->next; } // al salir, list == NULL

Recursión

Flood Fill — lógica recursiva

Guarda target, marca como 'F', llama a los 4 vecinos si tienen target. tab[y][x].

target = tab[y][x]; if (target == 'F') return; // ya visitado tab[y][x] = 'F'; // Comprobar límites antes de llamar: // x > 0, x < size.x-1, y > 0, y < size.y-1

Algoritmos

Bubble Sort — ordenar array

Dos bucles anidados. El bucle interno puede reducirse en i cada iteración.

i = 0; while (i < size - 1) { j = 0; while (j < size - 1 - i) { if (tab[j] > tab[j+1]) swap(&tab[j], &tab[j+1]); j++; } i++; }

Strings

Espejo del alfabeto (alpha_mirror)

a↔z, b↔y. La posición desde el inicio = posición desde el final.

// Minúscula: c = 'z' - (c - 'a'); // Mayúscula: c = 'Z' - (c - 'A');

Norma

Norma — reglas básicas

Incumplir la Norma = 0. No opcional.

// ✓ Tabs para indentar (NO espacios) // ✓ Max 25 líneas por función // ✓ Max 4 parámetros por función // ✓ Declarar variables al inicio del bloque // ✓ Solo un return por función (recomendado)

03 — Fórmulas que debes memorizar

🔁 ROT-N (rotaciones)

c = (c - 'a' + N) % 26 + 'a'; // minús c = (c - 'A' + N) % 26 + 'A'; // mayús

N=1 para rotone · N=13 para rot_13

🔢 Acumular dígitos (atoi)

result = result * 10 + (str[i] - '0');

También aplica para ft_atoi_base con la base

🪞 Espejo del alfabeto

c = 'z' - (c - 'a'); // minúsculas c = 'Z' - (c - 'A'); // mayúsculas

alpha_mirror: a↔z, b↔y, c↔x...

📐 Máximo Común Divisor

int pgcd(int a, int b) { if (b == 0) return (a); return (pgcd(b, a % b)); }

Algoritmo de Euclides — memorízalo

⚡ Potencia de 2 (bits)

n != 0 && (n & (n - 1)) == 0

is_power_of_2 — truco bit a bit

🔄 Swap nibbles (bits)

return ((octet >> 4) | (octet << 4));

swap_bits — una sola línea

📦 ft_itoa — rellenar al revés

str[--len] = '0' + (num % 10); num /= 10;

Siempre usa long para manejar INT_MIN

🧮 MCM a partir del MCD

lcm = (a / gcd(a, b)) * b;

Divide primero para evitar overflow

🔡 Posición en alfabeto

pos = c - 'a' + 1; // 'a'=1, 'b'=2... pos = c - 'A' + 1; // mayúsculas

repeat_alpha: imprime el char 'pos' veces

04 — Trampas y errores frecuentes

🪤

Olvidar el '\0' final en malloc

Si haces malloc para un string y no pones el '\0' al final, obtendrás comportamiento indefinido o segfault.

✓ Siempre: malloc(len + 1) y str[len] = '\0';

🪤

Olvidar el newline final en programas

Casi todos los programas del examen deben terminar con un newline, incluso cuando no hay argumento.

✓ write(1, "\n", 1); — siempre al final del main antes del return

🪤

fizzbuzz: orden incorrecto de comprobaciones

Si compruebas % 3 antes que % 15, los múltiplos de 15 imprimirán "fizz" en vez de "fizzbuzz".

✓ Siempre: % 15 → % 3 → % 5 → número

🪤

do_op: división o módulo por cero

Si b == 0 y el operador es / o %, el programa crashea con un error de división.

✓ Comprueba b != 0 antes de dividir. Si b == 0, imprime solo '\n'.

🪤

ft_itoa con INT_MIN (-2147483648)

Cambiar el signo de INT_MIN en un int causa overflow porque 2147483648 no cabe en int.

✓ Usa long: long num = (long)n; — luego opera con num

🪤

flood_fill: acceder fuera de los límites

Si no compruebas los límites antes de llamar recursivamente, accederás a memoria inválida.

✓ Siempre: if (x > 0) antes de acceder a tab[y][x-1]

🪤

ulstr: los no-alfabéticos SÍ cuentan como posición

Un espacio o número avanza i aunque no se modifique, cambiando la paridad del siguiente carácter.

✓ Siempre incrementa i, independientemente del tipo de carácter

🪤

ft_split: NULL al final del array

El array de strings de ft_split debe terminar con NULL. Sin él, no funciona correctamente.

✓ result[words] = NULL; — después del loop de relleno

🪤

Usar printf o funciones no autorizadas

Cada ejercicio especifica las funciones autorizadas. Usar printf cuando solo se permite write = 0 puntos.

✓ Lee las funciones autorizadas en el enunciado ANTES de escribir cualquier código

05 — man pages disponibles en el examen

Durante el examen puedes consultar el manual con man <función> en la terminal. Estas son las más útiles:

man write

Escribe bytes en un file descriptor. fd=1 es stdout.

ssize_t write(int fd, const void *buf, size_t count);

man malloc

Reserva memoria en el heap. Devuelve NULL si falla.

void *malloc(size_t size);

man free

Libera memoria reservada con malloc.

void free(void *ptr);

man atoi

Convierte string a int. Ignora whitespace inicial.

int atoi(const char *nptr);

man atol

Como atoi pero devuelve long. Útil para lcm.

long atol(const char *nptr);

man strdup

Duplica un string con malloc. Referencia para ft_strdup.

char *strdup(const char *s);

man strlen

Longitud de un string. Sin contar el '\0' final.

size_t strlen(const char *s);

man strcmp

Compara dos strings. 0=igual, <0 o >0 si no.

int strcmp(const char *s1, const char *s2);

man strcpy

Copia src en dest, incluyendo el '\0'. Devuelve dest.

char *strcpy(char *dest, const char *src);

man strcspn

Longitud hasta primer char de reject. Referencia para ft_strcspn.

size_t strcspn(const char *s, const char *reject);

man strspn

Longitud del segmento inicial con chars de accept.

size_t strspn(const char *s, const char *accept);

man ascii

Tabla ASCII completa. 'a'=97, 'A'=65, '0'=48, diferencia=32.

man ascii → tabla de referencia completa

man limits

Constantes límite. INT_MAX=2147483647, INT_MIN=-2147483648.

man limits.h o man INT_MAX

man qsort

Ordenar arrays con función comparadora. Alternativa a bubble sort.

void qsort(void *base, size_t nmemb, size_t size, int (*compar)(...));

06 — Includes necesarios por función

📁 #include <unistd.h>

write() // Todos los programas que usan write

El más usado en el examen

📁 #include <stdlib.h>

malloc() free() atoi() atol() // Cualquier ejercicio con memoria dinámica

ft_strdup, ft_range, ft_split, ft_itoa...

📁 Sin includes necesarios

ft_strlen ft_strcmp ft_strcpy ft_swap ft_strrev is_power_of_2 print_bits reverse_bits swap_bits

Solo operan con tipos básicos de C

Cheat Sheet& Checklist

Cheat Sheet
& Checklist