C Piscine — Rush 00

El primer proyecto en grupo. Una función, rush(x, y), que dibuja un rectángulo de x columnas por y filas con letras en las esquinas y los bordes. Solo con write, y con un fin de semana para ponerse de acuerdo con gente que no conocías el viernes.

Qué es un rush — Los rushes son los proyectos de fin de semana de la piscine: el sistema te asigna un grupo de dos o tres personas y hay que entregar en el repositorio común antes del domingo por la noche. No hay Moulinette: se defiende en una evaluación en directo donde cualquier miembro del grupo tiene que poder explicar cualquier línea. En el Rush 00 cada grupo recibe una de cinco variantes del mismo dibujo (cambian los caracteres de las esquinas y los bordes). La de este grupo pone A en la esquina superior izquierda y en la inferior derecha, C en las otras dos y B en los bordes — el patrón de la variante que el enunciado llama rush04, aunque el fichero se llame rush00.c. En el pack no está el PDF del enunciado; lo que sigue sale del código.
$> ./a.out      (rush(5, 3))
ABBBC
B   B
CBBBA
El código es del grupo (la cabecera 42 de los ficheros la firma el compañero, y la última edición de rush00.c es de xalara).

GGlosario de teoría

El Rush 00 es corto, pero toca casi todo lo básico de C: cómo sale un carácter por pantalla, cómo se recorre una cuadrícula y cómo se juntan varios ficheros en un programa. Aquí está cada idea explicada desde cero y con un ejemplo sacado del propio rush. En el resto de la página, la primera vez que sale uno de estos términos en cada tarjeta lleva un enlace a su entrada.

Salida por pantalla

write: la única forma de escribir

write(fd, direccion, n) es una llamada al sistema: le pide al sistema operativo que copie n bytes, empezando en direccion, al destino fd. No sabe nada de números ni de formatos; solo copia bytes. Por eso el enunciado prohíbe printf y obliga a construir lo demás encima.

En el rush, todo pasa por una función de tres líneas: ft_putchar(c) hace write(1, &c, 1), es decir, «escribe en la salida estándar 1 byte, el que hay en la dirección de c». El & hace falta porque write pide una dirección, no un valor.

Descriptor de fichero y salida estándar

Un descriptor de fichero (file descriptor, fd) es un número pequeño con el que el programa se refiere a algo donde se puede leer o escribir: un fichero, la terminal, una tubería. Todo programa arranca con tres abiertos: el 0 es la entrada estándar (stdin), el 1 la salida estándar (stdout) y el 2 la salida de errores (stderr).

El rush escribe siempre en el 1. Si lo ejecutas con ./a.out | cat -e, la salida no va a la pantalla sino a cat, que marca cada fin de línea con un $: es la forma de ver si sobran o faltan espacios al final de las filas.

char y la tabla ASCII

Un char es un entero de un byte. Lo que lo convierte en «letra» es la tabla ASCII, el acuerdo que dice qué número corresponde a cada carácter: 'A' es 65, 'B' 66, 'C' 67, el espacio ' ' es 32 y el salto de línea '\n' es 10. Escribir 'A' entre comillas simples es solo una forma legible de escribir 65.

Cada ft_putchar('B') del rush manda a la terminal el byte 66, y es la terminal la que dibuja la B.

Salto de línea: la salida es una fila de bytes

La pantalla parece una cuadrícula, pero lo que el programa produce es una sola secuencia de bytes. El salto de línea '\n' es un byte más que le dice a la terminal «sigue en la línea de abajo». Sin él, todo el rectángulo saldría en una sola fila.

rush(5, 3) escribe 5 caracteres y un '\n' por fila, tres veces: 18 bytes en total, que la terminal muestra como tres líneas de cinco.

Recorrer la cuadrícula

Bucles anidados

Un bucle dentro de otro: por cada vuelta del exterior, el interior da todas las suyas. Es la forma natural de recorrer algo de dos dimensiones. El número total de vueltas del interior es el producto de los dos: filas × columnas.

En rush, el exterior recorre las filas (i, de 1 a y) y el interior las columnas (j, de 1 a x). rush(123, 42), el último caso del main, llama 123 × 42 = 5166 veces a print_character. Si se cambiaran de sitio los dos bucles, el dibujo saldría traspuesto: y columnas por x filas.

Contar desde 0 o desde 1

En C los arrays empiezan en 0, y por costumbre los contadores también: i = 0; while (i < n) da n vueltas con i de 0 a n−1. Pero un contador que no indexa ningún array puede empezar donde sea más claro: i = 1; while (i <= n) da las mismas n vueltas, con i de 1 a n.

El rush usa la segunda forma: «primera fila» es i == 1 y «última» es i == y. Con contadores desde 0 las condiciones serían i == 0 e i == y - 1, igual de correctas pero más fáciles de equivocar en un -1.

Cadena if / else if

Una serie de condiciones en la que se evalúan en orden y solo se ejecuta la rama de la primera que se cumple; las de detrás ni se miran. Si ninguna se cumple, va al else final. Cuando dos condiciones se pueden cumplir a la vez, el orden decide cuál gana.

En print_character una esquina cumple también «está en un borde». Como las esquinas se preguntan antes, sale A o C; si la pregunta del borde fuera la primera, las esquinas saldrían como B.

Operadores lógicos y precedencia

&& («y») es cierto si lo son los dos lados; || («o») si lo es al menos uno. Los dos se evalúan de izquierda a derecha y se paran en cuanto saben el resultado (en A || B, si A es cierto, B no se evalúa). Y && tiene más precedencia que ||: se agrupa antes, igual que la multiplicación antes que la suma.

Por eso los paréntesis de (i == 1 && j == 1) || (i == y && j == x) no cambian el resultado: sin ellos se agruparía igual. Aun así ayudan a leerlo como «esquina de arriba a la izquierda o esquina de abajo a la derecha».

Caso límite (caso degenerado)

Una entrada en el extremo de lo posible, donde el problema se deforma: cero, negativos, un solo elemento, el valor más grande. En el caso general las reglas no chocan, y en el límite sí, por eso es donde aparecen los fallos.

En el rush: rush(0, 6) y rush(-1, 6) no deben dibujar nada (el if (x <= 0 || y <= 0) lo resuelve); rush(1, 1) es a la vez las cuatro esquinas; y rush(5, 1) tiene una celda que es «última columna» de la primera fila y de la última a la vez.

Compilar y entregar

Prototipo (declaración de una función)

El compilador lee cada .c de arriba abajo y por separado. Para poder llamar a una función que está en otro fichero necesita saber antes cómo es: su nombre, qué recibe y qué devuelve. Eso es el prototipo: la primera línea de la función terminada en ;, sin cuerpo.

rush00.c empieza con void ft_putchar(char c); porque la función vive en ft_putchar.c, y main.c con void rush(int x, int y); por lo mismo. Sin ese prototipo, -Werror convierte el aviso de «declaración implícita» en un error y no compila.

Compilación separada y enlazado

Compilar un programa de varios ficheros son dos pasos: cada .c se traduce por separado a código máquina (un fichero objeto), y después el enlazador (linker) los junta y conecta cada llamada con la función que le corresponde, esté en el fichero que esté. Tiene que haber exactamente un main y ninguna función definida dos veces.

El rush se compila con cc -Wall -Wextra -Werror ft_putchar.c main.c rush00.c: tres traducciones y un enlazado que produce a.out. En la evaluación se cambia main.c por otro y el resto no se toca.

-Wall -Wextra -Werror

Opciones del compilador. -Wall y -Wextra activan muchos avisos (variables sin usar, comparaciones sospechosas, funciones sin declarar…) y -Werror convierte cualquier aviso en error, así que el programa no compila si hay alguno. En 42 son obligatorias: si no compila con ellas, la nota es 0.

Los tres ficheros del rush compilan con las tres sin un solo aviso.

La Norma y norminette

La Norma es el reglamento de estilo de 42: como mucho 25 líneas por función y 5 funciones por fichero, tabulaciones para sangrar, declaraciones al principio de la función, nada de for, cabecera de 42 en cada fichero… norminette es el programa que lo comprueba, y un error de Norma es un 0.

Las condiciones largas de print_character están partidas en dos líneas para no pasar de 80 columnas. norminette sobre ex00/ da OK! en los tres ficheros.

ex00rush

Entrega: ex00/rush00.c, ex00/ft_putchar.c, ex00/main.cAutorizado: write

Recorre el rectángulo fila a fila (i, de 1 a y) y, dentro de cada fila, columna a columna (j, de 1 a x). Cada celda se delega a print_character y al final de cada fila se escribe el salto de línea. Las medidas nulas o negativas no dibujan nada.

void	rush(int x, int y)
{
	int	i;
	int	j;

	if (x <= 0 || y <= 0)
		return ;
	i = 1;
	while (i <= y)
	{
		j = 1;
		while (j <= x)
		{
			print_character(i, j, x, y);
			j++;
		}
		ft_putchar('\n');
		i++;
	}
}

Un detalle que facilita la lectura: los contadores empiezan en 1, no en 0. Así «primera fila» es i == 1 y «última fila» es i == y, que se parece mucho a cómo se describe el dibujo en español.

Qué te obliga a aprender — A pensar una salida en dos dimensiones como una secuencia de bytes: la pantalla no es una cuadrícula, es un flujo de caracteres donde '\n' marca dónde empieza la siguiente fila. El bucle exterior son las filas y el interior las columnas, y confundirlos (o el orden de x e y) es el error típico que la defensa busca.

celdaprint_character

Entrega: ex00/rush00.cAutorizado: write (vía ft_putchar)

Toda la lógica del dibujo está en una cadena de if / else if que decide la letra según la posición. El orden de las condiciones importa: primero las esquinas A, luego las esquinas C, luego cualquier borde, y si no es nada de eso, un espacio.

void	print_character(int i, int j, int x, int y)
{
	if ((i == 1 && j == 1)
		|| (i == y && j == x))
		ft_putchar('A');
	else if ((i == 1 && j == x)
		|| (i == y && j == 1))
		ft_putchar('C');
	else if (i == 1 || i == y
		|| j == 1 || j == x)
		ft_putchar('B');
	else
		ft_putchar(' ');
}
Qué te obliga a aprender — Que una cadena de else if es una tabla de prioridades: la primera condición que se cumple gana. Las esquinas también son borde, así que si la comprobación de borde fuera primero nunca saldría una A ni una C. Separar «qué carácter va aquí» del «recorrer el rectángulo» en dos funciones es además lo que hace que el código sea defendible por cualquiera del grupo.

mainmain

Entrega: ex00/main.cAutorizado: write

El enunciado de los Rush 00 deja que el grupo entregue su propio main, y en la evaluación se cambia por otros valores. El de este grupo prueba casos normales y los bordes: 1×1, una fila, una columna, ceros, negativos y uno grande.

	rush(6, 4);
	rush(1, 1);
	rush(1, 4);
	rush(4, 1);
	rush(2, 2);
	rush(0, 6);
	rush(6, 0);
	rush(0, 0);
	rush(-1, 6);
	rush(6, -1);
	rush(-3, -5);
	rush(123, 42);
Qué te obliga a aprender — A probar antes de que te prueben. Un main que solo llama a rush(5, 3) no demuestra nada; uno con los casos degenerados (0, negativos, 1×N) es la lista de lo que el evaluador va a intentar romper.

ojoUna sola fila o una sola columna

Afecta a: print_character

Con una sola fila (y == 1), la primera y la última fila son la misma. En la última celda se cumplen a la vez «última fila y última columna» (A) y «primera fila y última columna» (C), y como la comprobación de A va primero, gana la A. Lo mismo pasa con una sola columna. Compilado y ejecutado tal cual:

rush(5, 1)      rush(1, 5)
ABBBA           A
                B
                B
                B
                A

Ojo: en esta variante del enunciado, los ejemplos de una fila y de una columna terminan en C (ABBBC y A B B B C en vertical). Con los rectángulos de dos o más filas y columnas (rush(5, 3), rush(4, 4)) la salida es la esperada, y el 1×1 da A.

Qué te obliga a aprender — Que los casos degenerados son donde dos reglas que nunca chocan en el caso general empiezan a solaparse. Cuando una celda es a la vez «primera» y «última», el orden de los if deja de ser un detalle de estilo y pasa a decidir el resultado.

?Preguntas probables de la evaluación

Lo que es fácil que pregunte quien te evalúe, con una respuesta corta y el enlace a la sección donde está explicado a fondo. En un rush la pregunta puede ir a cualquiera del grupo, sobre cualquier línea. Antes de mirar la respuesta, intenta contestar tú.

El código

¿Por qué las esquinas se comprueban antes que los bordes?

Porque una esquina también es borde, y en una cadena de else if gana la primera condición que se cumple. Con el borde primero, las cuatro esquinas saldrían como B. → print_character

¿Cuál es x y cuál es y? ¿Qué cambia si los cambio de sitio?

x son las columnas (el ancho) e y las filas (el alto). El bucle exterior recorre las filas y el interior las columnas. rush(6, 4) da 4 líneas de 6 caracteres; rush(4, 6), 6 líneas de 4. → rush

¿Por qué los contadores empiezan en 1?

Para que las condiciones se lean como el dibujo: primera fila es i == 1 y última i == y. Con contadores desde 0 serían i == 0 e i == y - 1; funciona igual, pero es más fácil equivocarse en un -1. → contar desde 0 o desde 1

Si te piden otra variante del dibujo, ¿qué tocas?

Solo print_character: las letras de cada ft_putchar y, si cambian las esquinas que se emparejan, qué esquinas van en cada condición. rush no se toca, porque solo recorre la cuadrícula. → print_character

Casos límite

¿Qué pasa con rush(0, 6) o con números negativos?

No se dibuja nada, ni un salto de línea: el if (x <= 0 || y <= 0) return ; de rush sale antes de empezar: con el || basta con que una de las dos medidas no sea positiva. El main prueba 0 y negativos en cada posición. → rush, main

¿Qué sale con rush(5, 1)?

ABBBA, y rush(1, 5) da A, B, B, B, A en vertical. Con una sola fila, la última celda cumple la condición de A (última fila y última columna) y la de C (primera fila y última columna), y gana la A porque va primero. Los ejemplos de esta variante terminan en C: mejor tenerlo explicado antes de que lo encuentre el evaluador. → una sola fila o una sola columna

¿Y con un rectángulo muy grande?

Funciona igual: no se reserva memoria, cada celda se escribe al momento. rush(123, 42) está en el main. Lo único que limita es que x e y son int; con tamaños enormes tardaría, porque son x · y llamadas a write de un byte. → bucles anidados

Reglas de la piscine

¿Por qué ft_putchar y no printf?

Porque la única función autorizada es write. ft_putchar es write(1, &c, 1): un byte, el código ASCII de la letra, a la salida estándar. → write, descriptor de fichero

¿Pasa la Norma? ¿Compila con los flags?

Sí: norminette da OK! en los tres ficheros y cc -Wall -Wextra -Werror compila sin avisos. Los prototipos al principio de rush00.c y main.c son los que evitan el error de «declaración implícita». → la Norma, prototipo

¿Por qué entregáis un main.c aparte?

Porque en la evaluación lo cambian por el suyo con otros valores, y así se puede sustituir sin tocar rush00.c. Los tres ficheros se compilan por separado y el enlazador los junta. → main, compilación separada

Sobre el trabajo en grupo

¿Quién hizo qué? ¿Cómo os organizasteis?

Esta te la tienes que preparar tú. La cabecera de rush00.c la firma un compañero y la última edición es de xalara, pero en la defensa cualquiera del grupo tiene que poder explicar cualquier línea. Si piden un cambio en directo, lo típico es otra variante de letras o el caso de una sola fila. → print_character, ojo