Ejercicio 06: ft_print_comb2

Muestra todas las combinaciones posibles de dos números (XX XX) entre 0 y 99, en orden creciente.

Hecho con amor para Laura, por Bogdan.

El archivo

#include <unistd.h>

/*
** Copia local de ft_putchar: el enunciado solo permite entregar este archivo.
** Escribe un unico caracter en la salida estandar.
*/
static void put_char(char c)
{
    write(1, &c, 1);
}

/*
** Imprime un numero entre 0 y 99 siempre con dos digitos: 7 se ve como "07".
** La division y el resto entre 10 separan decenas y unidades.
*/
static void put_two_digits(int number)
{
    put_char('0' + number / 10);
    put_char('0' + number % 10);
}

/*
** Imprime "XX YY". El separador va delante de todas menos la primera,
** para que la salida no termine en ", ".
*/
static void print_pair(int left, int right, int first)
{
    if (!first)
    {
        put_char(',');
        put_char(' ');
    }
    put_two_digits(left);
    put_char(' ');
    put_two_digits(right);
}

/*
** Recorre los dos numeros con dos bucles anidados. El segundo empieza en
** left + 1 para que no se repita ninguna pareja ni salga "05 03".
*/
void    ft_print_comb2(void)
{
    int left;
    int right;
    int first;

    first = 1;
    left = 0;
    while (left <= 98)
    {
        right = left + 1;
        while (right <= 99)
        {
            print_pair(left, right, first);
            first = 0;
            right++;
        }
        left++;
    }
    put_char('\n');
}

Línea por línea

#include <unistd.h>

Declara write. Sin ella, el compilador no conoce la función y -Werror corta la compilación.

static void put_char(char c)

Copia privada de ft_putchar, como en todos los ejercicios del módulo.

static void put_two_digits(int number)

Imprime un número entre 0 y 99 siempre con dos cifras. Es el corazón de este ejercicio: el formato XX XX obliga a que el 7 salga como 07.

put_char('0' + number / 10);

La división entera entre 10 se queda con las decenas. Con 47 da 4; con 7 da 0. Sumar '0' convierte ese 0–9 en el carácter correspondiente.

put_char('0' + number % 10);

El resto entre 10 se queda con la última cifra. Con 47 da 7; con 7 da 7. Otra vez, '0' + lo convierte en carácter.

static void print_pair(int left, int right, int first)

Imprime una pareja completa: separador si toca, primer número, un espacio y segundo número. Es static porque es un ayudante interno del archivo.

if (!first)

!first es verdadero cuando first vale 0. Se lee: «si no es la primera pareja, escribe el separador». Así la salida no termina en ", ".

put_char(','); y put_char(' ');

El separador entre parejas son dos caracteres. Entre los dos números de una pareja va un solo espacio, y eso lo pone print_pair más abajo.

put_two_digits(left);, put_char(' ');, put_two_digits(right);

El formato exacto: XX, espacio, XX. Ni coma dentro de la pareja ni espacio doble.

void ft_print_comb2(void)

La función pública, sin parámetros y sin valor de retorno.

int left; int right; int first;

Los dos números y la bandera. Se declaran arriba por el estilo de la piscina.

first = 1;

Antes de imprimir nada, la primera pareja no lleva separador.

left = 0; y while (left <= 98)

El primer número va de 0 a 98. No llega a 99 porque necesitaría un segundo número mayor, y no queda ninguno.

right = left + 1;

El segundo número arranca uno por encima del primero. Eso evita parejas repetidas y parejas invertidas: si left es 3, right empieza en 4, así que 05 03 nunca aparece.

Esta línea está dentro del bucle de left: se reinicia en cada vuelta del primero. Si la pusieras fuera, solo la primera serie saldría bien.

while (right <= 99)

El segundo número llega hasta 99, el máximo de dos cifras.

print_pair(left, right, first);

Imprime la pareja con el formato y el separador correctos.

first = 0;

Después de la primera pareja, ya no es la primera.

right++; y left++;

Cada bucle avanza. Sin estos incrementos el programa no termina.

put_char('\n');

Un solo salto al final, fuera de los dos bucles.

Cuántas parejas salen

Son las formas de elegir 2 números entre 100, sin importar el orden:

100 × 99 / 2 = 4950

Si te salen 9900, estás generando también las parejas invertidas: revisa que right empiece en left + 1. Si te salen 5050, estás incluyendo las parejas con los dos números iguales (00 00, 01 01…), que no son válidas.

Salida esperada

Abreviada, como en el enunciado:

00 01, 00 02, 00 03, 00 04, ..., 98 99

Casos límite

Errores típicos

Comprobarlo

cat > /tmp/main.c <<'EOF'
void    ft_print_comb2(void);

int main(void)
{
    ft_print_comb2();
    return (0);
}
EOF
cc -Wall -Wextra -Werror ex06/ft_print_comb2.c /tmp/main.c -o /tmp/ex06
/tmp/ex06 > /tmp/salida.txt
wc -w /tmp/salida.txt

La salida completa tiene 4950 parejas. Compara contra el archivo esperado con cmp, que calla cuando coinciden.

Descargar

• ft_print_comb2.c