Ejercicios: Refactorización de Código Ofuscado

Prerrequisitos Técnicos y Entorno Requerido¶

Antes de abordar esta guía de deconstrucción y refactorización, el estudiante requiere:

Entorno de Compilación: Compilador GCC 9+ o Clang bajo estándar estricto ISO C11 (-std=c11 -Wall -Wextra -Werror -pedantic).
Estilo Institucional: Dominio del catálogo de reglas de estilo de la cátedra: indentación Allman (0x0007h: Las llaves deben ubicarse en líneas independientes según el estilo Allman), constantes simbólicas (0x0003h: Un espacio antes y después de cada operador binario) y nombres autoexplicativos (0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas).
Eliminación de Antipatrones: Prohibición estricta de variables globales (0x2004h: No se permite el uso de variables globales) y reemplazo del operador ternario por bifurcaciones explícitas (0x1007h: No utilizar el operador condicional (ternario) ?:).
Verificación de Equivalencia: Diseño sistemático de suites de prueba con assert() en C11 para garantizar invariancia funcional.

Acerca de¶

En el desarrollo profesional de software, la mayor parte del tiempo se destina a leer, entender y mantener código existente. Con frecuencia te encontrarás con código mal estructurado, con nombres crípticos de una sola letra, números mágicos sin explicación, anidaciones excesivas o dependencias ocultas de variables globales.

El objetivo de este cuadernillo es desarrollar tu agudeza analítica mediante la deconstrucción y refactorización de fragmentos de código intencionalmente ofuscados.

Metodología de Trabajo para Cada Ejercicio¶

Para resolver cada ejercicio debés:

Analizar el código ofuscado: Determinar qué hace el algoritmo, cuáles son sus datos de entrada y salida, y qué invariantes o precondiciones asume.
Identificar “olores de código” (code smells) y violaciones de estilo: Nombres crípticos, operador ternario no permitido, falta de llaves Allman, variables reutilizadas, números mágicos, efectos secundarios, etc.
Refactorizar a C limpio e idiomático: Reescribir la solución aplicando:
- Formato Allman (0x0007h: Las llaves deben ubicarse en líneas independientes según el estilo Allman).
- Nombres autoexplicativos en snake_case (0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas).
- Eliminación estricta de variables globales (0x2004h: No se permite el uso de variables globales).
- Cláusulas de guarda para evitar anidaciones (0x2001h: Las funciones deben usar cláusulas de guarda y retornos anticipados para reducir la anidación profunda).
- Constantes simbólicas para números mágicos (0x0003h: Un espacio antes y después de cada operador binario).
- Desacople total de printf/scanf (0x2002h: Las funciones no deben contener printf o scanf, a menos que ese sea su propósito explícito).
Diseñar una suite de pruebas con assert(): Validar que la versión refactorizada preserve exactamente el comportamiento esperado ante casos normales y bordes.

1. Expresiones Aritméticas, Asignaciones y Nombres Crípticos¶

Ejercicio 1.07.01 - El Máximo Comprimido ⭐☆☆☆☆¶

Exercise 1

Analizá y refactorizá la siguiente función que utiliza el operador ternario prohibido y nombres crípticos:

int f(int a,int b){return(a>b)?a:b;}

Tabla de Vectores de Prueba:

Caso de Prueba	Primer Número	Segundo Número	Retorno Esperado
Primero mayor	`10`	`5`	`10`
Negativos	`-3`	`-8`	`-3`
Iguales	`7`	`7`	`7`

Solution to Exercise 1

Diagnóstico:

Violación de la 0x1007h: No utilizar el operador condicional (ternario) ?:: uso del operador ternario ?:.
Violación de la 0x0007h: Las llaves deben ubicarse en líneas independientes según el estilo Allman: llaves en la misma línea (no es Allman).
Violación de la 0x0102h: Los argumentos de función y las variables locales deben usar snake_case en minúsculas: identificadores de una letra f, a, b.

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#include <assert.h>

int obtener_mayor(int primer_numero, int segundo_numero)
{
    if (primer_numero > segundo_numero)
    {
        return primer_numero;
    }
    else
    {
        return segundo_numero;
    }
}

void test_obtener_mayor(void)
{
    assert(obtener_mayor(10, 5) == 10);
    assert(obtener_mayor(-3, -8) == -3);
    assert(obtener_mayor(7, 7) == 7);
}

int main(void)
{
    test_obtener_mayor();
    return 0;
}

Ejercicio 1.07.02 - Geometría sin Nombres ⭐☆☆☆☆¶

Exercise 2

Descifrá el propósito geométrico del siguiente fragmento y refactorizalo:

double x(double a,double b){return a*b/2.0;}

Tabla de Vectores de Prueba:

Caso de Prueba	Base (`a`)	Altura (`b`)	Retorno Esperado
Estándar	`10.0`	`5.0`	`25.0`
Dimensión inválida	`-2.0`	`5.0`	`-1.0`
Altura nula	`10.0`	`0.0`	`-1.0`

Solution to Exercise 2

Diagnóstico: Calcula el área de un triángulo con base a y altura b. No valida dimensiones no positivas.

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <assert.h>

double calcular_area_triangulo(double base, double altura)
{
    if (base <= 0.0 || altura <= 0.0)
    {
        return -1.0;
    }
    return (base * altura) / 2.0;
}

void test_area_triangulo(void)
{
    assert(calcular_area_triangulo(10.0, 5.0) == 25.0);
    assert(calcular_area_triangulo(-2.0, 5.0) == -1.0);
    assert(calcular_area_triangulo(10.0, 0.0) == -1.0);
}

int main(void)
{
    test_area_triangulo();
    return 0;
}

Ejercicio 1.07.03 - Suma de Cuadrados en Una Línea ⭐⭐☆☆☆¶

Exercise 3

Analizá el siguiente lazo comprimido y refactorizalo para que sea claro, robusto y testeable:

int p(int n){int s=0;for(int i=1;i<=n;i++)s+=i*i;return s;}

Tabla de Vectores de Prueba:

Caso de Prueba	Límite `n`	Operación Matemática	Retorno Esperado
Cero	`0`	Suma vacía	`0`
Normal ( $n=3$ )	`3`	$1^2 + 2^2 + 3^2 = 1 + 4 + 9$	`14`
Normal ( $n=4$ )	`4`	$14 + 16$	`30`
Error (Negativo)	`-5`	Fuera de dominio	`-1`

Solution to Exercise 3

Diagnóstico: Calcula $\sum_{i=1}^n i^2$ . Carece de espacios, llaves Allman y validación para $n < 0$ .

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <assert.h>

int calcular_suma_cuadrados(int limite)
{
    if (limite < 0)
    {
        return -1;
    }
    int acumulador = 0;
    for (int i = 1; i <= limite; i++)
    {
        acumulador += (i * i);
    }
    return acumulador;
}

void test_suma_cuadrados(void)
{
    assert(calcular_suma_cuadrados(0) == 0);
    assert(calcular_suma_cuadrados(3) == 14); // 1 + 4 + 9 = 14
    assert(calcular_suma_cuadrados(4) == 30);
    assert(calcular_suma_cuadrados(-5) == -1);
}

int main(void)
{
    test_suma_cuadrados();
    return 0;
}

Ejercicio 1.07.04 - Conversión Térmica con División Entera Peligrosa ⭐⭐☆☆☆¶

Solution to Exercise 4

Diagnóstico: Nombres opacos, falta de constantes simbólicas y sin verificación del límite físico del cero absoluto.

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <assert.h>
#include <math.h>
#include <stdbool.h>

#define CERO_ABSOLUTO_CELSIUS -273.15
#define FACTOR_ESCALA (9.0 / 5.0)
#define DESPLAZAMIENTO_FAHRENHEIT 32.0

double convertir_celsius_a_fahrenheit(double temperatura_celsius, bool *es_valida)
{
    if (temperatura_celsius < CERO_ABSOLUTO_CELSIUS || es_valida == NULL)
    {
        if (es_valida != NULL)
        {
            *es_valida = false;
        }
        return 0.0;
    }
    *es_valida = true;
    return (temperatura_celsius * FACTOR_ESCALA) + DESPLAZAMIENTO_FAHRENHEIT;
}

void test_conversion_celsius(void)
{
    bool ok = false;
    double f = convertir_celsius_a_fahrenheit(0.0, &ok);
    assert(ok && fabs(f - 32.0) < 1e-6);
    f = convertir_celsius_a_fahrenheit(100.0, &ok);
    assert(ok && fabs(f - 212.0) < 1e-6);
}

Ejercicio 1.07.05 - Suma de Dígitos Ofuscada ⭐⭐☆☆☆¶

Solution to Exercise 5

Diagnóstico: Suma los dígitos de un número. Para -123, n % 10 produce restos negativos en C99+, dando una suma errónea (-1 + -2 + -3 = -6).

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <assert.h>
#include <stdlib.h>

int sumar_digitos(int numero)
{
    int n = abs(numero);
    int suma = 0;
    while (n > 0)
    {
        suma += (n % 10);
        n /= 10;
    }
    return suma;
}

void test_sumar_digitos(void)
{
    assert(sumar_digitos(1234) == 10);
    assert(sumar_digitos(-505) == 10);
    assert(sumar_digitos(0) == 0);
}

Ejercicio 1.07.06 - Año Bisiesto Críptico ⭐☆☆☆☆¶

Solution to Exercise 6

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <assert.h>
#include <stdbool.h>

bool es_anio_bisiesto(int anio)
{
    if (anio <= 0)
    {
        return false;
    }
    bool es_div_4 = (anio % 4 == 0);
    bool es_div_100 = (anio % 100 == 0);
    bool es_div_400 = (anio % 400 == 0);

    return (es_div_4 && !es_div_100) || es_div_400;
}

void test_es_anio_bisiesto(void)
{
    assert(es_anio_bisiesto(2024) == true);
    assert(es_anio_bisiesto(2023) == false);
    assert(es_anio_bisiesto(1900) == false);
    assert(es_anio_bisiesto(2000) == true);
    assert(es_anio_bisiesto(-4) == false);
}

Ejercicio 1.07.07 - Sumatoria de Gauss con Nombres Inadecuados ⭐☆☆☆☆¶

Solution to Exercise 7

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <assert.h>

long long calcular_sumatoria_gauss(int limite_superior)
{
    if (limite_superior < 0)
    {
        return -1;
    }
    long long n = limite_superior;
    return (n * (n + 1)) / 2;
}

void test_sumatoria_gauss(void)
{
    assert(calcular_sumatoria_gauss(0) == 0);
    assert(calcular_sumatoria_gauss(10) == 55);
    assert(calcular_sumatoria_gauss(100) == 5050);
    assert(calcular_sumatoria_gauss(-5) == -1);
}

Ejercicio 1.07.08 - Cilindro con Número Mágico ⭐⭐☆☆☆¶

Solution to Exercise 8

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <assert.h>
#include <math.h>

#define CONSTANTE_PI 3.14159265358979323846

double calcular_volumen_cilindro(double radio, double altura)
{
    if (radio <= 0.0 || altura <= 0.0)
    {
        return -1.0;
    }
    return CONSTANTE_PI * radio * radio * altura;
}

void test_volumen_cilindro(void)
{
    double vol = calcular_volumen_cilindro(1.0, 10.0);
    assert(fabs(vol - (CONSTANTE_PI * 10.0)) < 1e-6);
    assert(calcular_volumen_cilindro(-1.0, 5.0) == -1.0);
}

2. Control de Flujo Espagueti y Anidaciones Profundas¶

Ejercicio 1.07.09 - El Monstruo de la Flecha (Arrow Code) ⭐⭐⭐☆☆¶

Exercise 9

Refactorizá la siguiente función anidada en forma de flecha aplicando cláusulas de guarda según la 0x2001h: Las funciones deben usar cláusulas de guarda y retornos anticipados para reducir la anidación profunda:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
int calificar(int nota, int asistencia)
{
    int r = 0;
    if (asistencia >= 75)
    {
        if (nota >= 0)
        {
            if (nota <= 100)
            {
                if (nota >= 60)
                {
                    if (nota >= 90)
                    {
                        r = 3; // Sobresaliente
                    }
                    else
                    {
                        r = 2; // Aprobado
                    }
                }
                else
                {
                    r = 1; // Reprobado
                }
            }
            else
            {
                r = -1; // Error nota
            }
        }
        else
        {
            r = -1; // Error nota
        }
    }
    else
    {
        r = 0; // Libre
    }
    return r;
}

Solution to Exercise 9

Diagnóstico: Anidación excesiva de 5 niveles que dificulta el seguimiento de los casos de error.

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
#include <assert.h>

#define ESTADO_NOTA_INVALIDA -1
#define ESTADO_LIBRE 0
#define ESTADO_REPROBADO 1
#define ESTADO_APROBADO 2
#define ESTADO_SOBRESALIENTE 3

int clasificar_desempenio(int nota, int asistencia_porcentaje)
{
    if (nota < 0 || nota > 100)
    {
        return ESTADO_NOTA_INVALIDA;
    }
    if (asistencia_porcentaje < 75)
    {
        return ESTADO_LIBRE;
    }
    if (nota >= 90)
    {
        return ESTADO_SOBRESALIENTE;
    }
    if (nota >= 60)
    {
        return ESTADO_APROBADO;
    }
    return ESTADO_REPROBADO;
}

void test_clasificar_desempenio(void)
{
    assert(clasificar_desempenio(95, 80) == ESTADO_SOBRESALIENTE);
    assert(clasificar_desempenio(70, 80) == ESTADO_APROBADO);
    assert(clasificar_desempenio(50, 80) == ESTADO_REPROBADO);
    assert(clasificar_desempenio(80, 50) == ESTADO_LIBRE);
    assert(clasificar_desempenio(105, 80) == ESTADO_NOTA_INVALIDA);
}

Ejercicio 1.07.10 - Menú con Ifs Caóticos ⭐⭐☆☆☆¶

Exercise 10

Refactorizá la siguiente selección de opciones a una estructura switch clara con cláusula default (0x1003h: Utilizá el lazo for para iteraciones con rango o contador definido y while para lazos controlados por condiciones lógicas):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
double operacion(int op, double a, double b)
{
    if (op == 1) {
        return a + b;
    } else if (op == 2) {
        return a - b;
    } else if (op == 3) {
        return a * b;
    } else if (op == 4) {
        if (b != 0) return a / b;
        else return 0;
    } else {
        return 0;
    }
}

Solution to Exercise 10

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
#include <assert.h>
#include <stdbool.h>

typedef enum
{
    OP_SUMAR = 1,
    OP_RESTAR = 2,
    OP_MULTIPLICAR = 3,
    OP_DIVIDIR = 4
} tipo_operacion_t;

double calcular_operacion(tipo_operacion_t operacion, double a, double b, bool *exito)
{
    if (exito == NULL)
    {
        return 0.0;
    }
    *exito = true;
    switch (operacion)
    {
        case OP_SUMAR:
            return a + b;
        case OP_RESTAR:
            return a - b;
        case OP_MULTIPLICAR:
            return a * b;
        case OP_DIVIDIR:
            if (b == 0.0)
            {
                *exito = false;
                return 0.0;
            }
            return a / b;
        default:
            *exito = false;
            return 0.0;
    }
}

void test_operaciones(void)
{
    bool ok = false;
    assert(calcular_operacion(OP_SUMAR, 3.0, 4.0, &ok) == 7.0 && ok);
    assert(calcular_operacion(OP_DIVIDIR, 10.0, 2.0, &ok) == 5.0 && ok);
    calcular_operacion(OP_DIVIDIR, 10.0, 0.0, &ok);
    assert(!ok);
}

Ejercicio 1.07.11 - Lazo Espagueti con Banderas Confusas ⭐⭐⭐☆☆¶

Exercise 11

Refactorizá la siguiente función que utiliza lazos infinitos while(1), variables flag crípticas y break desordenados para verificar si un número es primo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
int check(int n)
{
    int flag = 1;
    int i = 2;
    if (n <= 1) return 0;
    while (1)
    {
        if (i * i > n) break;
        if (n % i == 0)
        {
            flag = 0;
            break;
        }
        i++;
    }
    return flag;
}

Ejercicio 1.07.12 - Tarifa de Taxi con Variables Reutilizadas ⭐⭐☆☆☆¶

Exercise 12

Analizá qué hace la variable t en el siguiente fragmento y refactorizá el cálculo declarando variables de propósito único y constantes claras:

1
2
3
4
5
6
7
double calc(double k, int n)
{
    double t = 150.0; // Bajada de bandera
    if (k > 0) t += k * 80.0;
    if (n == 1) t = t * 1.20; // Recargo nocturno
    return t;
}

Solution to Exercise 12

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
#include <assert.h>
#include <stdbool.h>

#define BAJADA_DE_BANDERA 150.0
#define COSTO_POR_KILOMETRO 80.0
#define FACTOR_RECARGO_NOCTURNO 1.20

double calcular_tarifa_taxi(double kilometros, bool es_tarifa_nocturna)
{
    if (kilometros < 0.0)
    {
        return -1.0;
    }
    double costo_distancia = kilometros * COSTO_POR_KILOMETRO;
    double subtotal = BAJADA_DE_BANDERA + costo_distancia;

    if (es_tarifa_nocturna)
    {
        return subtotal * FACTOR_RECARGO_NOCTURNO;
    }
    return subtotal;
}

void test_tarifa_taxi(void)
{
    assert(calcular_tarifa_taxi(10.0, false) == 950.0);
    assert(calcular_tarifa_taxi(10.0, true) == 1140.0);
    assert(calcular_tarifa_taxi(-5.0, false) == -1.0);
}

Ejercicio 1.07.13 - Expresión Booleana Monolítica de Validación de Fecha ⭐⭐⭐☆☆¶

Exercise 13

El siguiente código comprueba la validez de una fecha en una sola expresión booleana incomprensible de difícil depuración:

bool v(int d,int m,int y){return(y>0&&m>=1&&m<=12&&d>=1)&&((m==2&&(((y%4==0&&y%100!=0)||(y%400==0))?d<=29:d<=28))||((m==4||m==6||m==9||m==11)?d<=30:d<=31));}

Ejercicio 1.07.14 - Descuento Escalonado con Condiciones Solapadas ⭐⭐☆☆☆¶

Exercise 14

Analizá el siguiente código con condiciones redundantes y números mágicos:

1
2
3
4
5
6
7
8
double desc(double m)
{
    if (m > 0 && m < 1000) return m;
    if (m >= 1000 && m < 5000) return m * 0.95;
    if (m >= 5000 && m < 10000) return m * 0.90;
    if (m >= 10000) return m * 0.80;
    return 0;
}

Solution to Exercise 14

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <assert.h>

#define UMBRAL_NIVEL_1 1000.0
#define UMBRAL_NIVEL_2 5000.0
#define UMBRAL_NIVEL_3 10000.0

#define FACTOR_DESCUENTO_1 0.95
#define FACTOR_DESCUENTO_2 0.90
#define FACTOR_DESCUENTO_3 0.80

double aplicar_descuento_escalonado(double monto_compra)
{
    if (monto_compra <= 0.0)
    {
        return 0.0;
    }
    if (monto_compra >= UMBRAL_NIVEL_3)
    {
        return monto_compra * FACTOR_DESCUENTO_3;
    }
    if (monto_compra >= UMBRAL_NIVEL_2)
    {
        return monto_compra * FACTOR_DESCUENTO_2;
    }
    if (monto_compra >= UMBRAL_NIVEL_1)
    {
        return monto_compra * FACTOR_DESCUENTO_1;
    }
    return monto_compra;
}

void test_descuentos(void)
{
    assert(aplicar_descuento_escalonado(500.0) == 500.0);
    assert(aplicar_descuento_escalonado(2000.0) == 1900.0);
    assert(aplicar_descuento_escalonado(6000.0) == 5400.0);
    assert(aplicar_descuento_escalonado(12000.0) == 9600.0);
}

Ejercicio 1.07.15 - Función Contaminada con Entrada/Salida ⭐⭐☆☆☆¶

Exercise 15

La siguiente función viola la 0x2002h: Las funciones no deben contener printf o scanf, a menos que ese sea su propósito explícito porque realiza printf adentro del cálculo. Refactorizala para que sea una función pura y testeable:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>

void clasificar_temperatura_ambiente(double temp)
{
    if (temp < 10.0)
    {
        printf("Hace frio\n");
    }
    else if (temp <= 25.0)
    {
        printf("Templado\n");
    }
    else
    {
        printf("Caluroso\n");
    }
}

Solution to Exercise 15

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <assert.h>

typedef enum
{
    CLIMA_FRIO,
    CLIMA_TEMPLADO,
    CLIMA_CALUROSO
} tipo_clima_t;

tipo_clima_t clasificar_temperatura(double temperatura_celsius)
{
    if (temperatura_celsius < 10.0)
    {
        return CLIMA_FRIO;
    }
    if (temperatura_celsius <= 25.0)
    {
        return CLIMA_TEMPLADO;
    }
    return CLIMA_CALUROSO;
}

void test_clasificar_clima(void)
{
    assert(clasificar_temperatura(5.0) == CLIMA_FRIO);
    assert(clasificar_temperatura(18.0) == CLIMA_TEMPLADO);
    assert(clasificar_temperatura(30.0) == CLIMA_CALUROSO);
}

Ejercicio 1.07.16 - Búsqueda Lineal con Variables Globales ⭐⭐☆☆☆¶

Exercise 16

Refactorizá la siguiente función que depende de variables globales mutables para retornar la posición de un elemento en un arreglo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
int pos_encontrada = -1;

void buscar(int arr[], int n, int x)
{
    pos_encontrada = -1;
    for (int i = 0; i < n; i++)
    {
        if (arr[i] == x)
        {
            pos_encontrada = i;
            break;
        }
    }
}

Solution to Exercise 16

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <assert.h>

int buscar_primera_aparicion(const int arreglo[], int cantidad_elementos, int objetivo)
{
    if (arreglo == NULL || cantidad_elementos <= 0)
    {
        return -1;
    }
    for (int i = 0; i < cantidad_elementos; i++)
    {
        if (arreglo[i] == objetivo)
        {
            return i;
        }
    }
    return -1;
}

void test_buscar_aparicion(void)
{
    int datos[] = {10, 20, 30, 40};
    assert(buscar_primera_aparicion(datos, 4, 30) == 2);
    assert(buscar_primera_aparicion(datos, 4, 99) == -1);
}

3. Algoritmos Comprimidos y Lazos Crípticos¶

Ejercicio 1.07.17 - Euclides con Operador Coma y Asignaciones Crípticas ⭐⭐⭐☆☆¶

Ejercicio 1.07.18 - Inversor de Números con Variables Reutilizadas ⭐⭐☆☆☆¶

Solution to Exercise 18

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <assert.h>
#include <stdlib.h>

int invertir_numero_entero(int numero)
{
    int signo = (numero < 0) ? -1 : 1;
    int n = abs(numero);
    int invertido = 0;

    while (n > 0)
    {
        invertido = (invertido * 10) + (n % 10);
        n /= 10;
    }
    return invertido * signo;
}

void test_invertir_numero(void)
{
    assert(invertir_numero_entero(1234) == 4321);
    assert(invertir_numero_entero(-580) == -85);
    assert(invertir_numero_entero(0) == 0);
}

Ejercicio 1.07.19 - Fibonacci Iterativo Micro-comprimido ⭐⭐☆☆☆¶

Solution to Exercise 19

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
#include <assert.h>

long long calcular_fibonacci(int posicion)
{
    if (posicion < 0)
    {
        return -1;
    }
    if (posicion == 0)
    {
        return 0;
    }
    if (posicion == 1)
    {
        return 1;
    }

    long long anterior = 0;
    long long actual = 1;

    for (int i = 2; i <= posicion; i++)
    {
        long long siguiente = anterior + actual;
        anterior = actual;
        actual = siguiente;
    }
    return actual;
}

void test_fibonacci(void)
{
    assert(calcular_fibonacci(0) == 0);
    assert(calcular_fibonacci(1) == 1);
    assert(calcular_fibonacci(6) == 8);
    assert(calcular_fibonacci(10) == 55);
}

Ejercicio 1.07.20 - Conteo de Números Armstrong Desordenado ⭐⭐⭐☆☆¶

Exercise 20

El siguiente código verifica si un número de 3 dígitos es igual a la suma del cubo de sus dígitos, pero está escrito de forma ilegible:

int arm(int x){int a=x/100,b=(x/10)%10,c=x%10;return(a*a*a+b*b*b+c*c*c==x)?1:0;}

Ejercicio 1.07.21 - Factorial con Detección de Desbordamiento Oculto ⭐⭐☆☆☆¶

Solution to Exercise 21

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <assert.h>

#define MAX_N_FACTORIAL_64BITS 20

long long calcular_factorial(int n)
{
    if (n < 0 || n > MAX_N_FACTORIAL_64BITS)
    {
        return -1;
    }
    long long resultado = 1;
    for (int factor = 2; factor <= n; factor++)
    {
        resultado *= factor;
    }
    return resultado;
}

void test_factorial(void)
{
    assert(calcular_factorial(0) == 1);
    assert(calcular_factorial(5) == 120);
    assert(calcular_factorial(21) == -1); // Error de desbordamiento
}

Ejercicio 1.07.22 - Números Perfectos con Lazo Ineficiente ⭐⭐⭐☆☆¶

Exercise 22

Refactorizá la siguiente función que verifica números perfectos (donde la suma de divisores propios es igual al número):

int perf(int n){int s=0;for(int i=1;i<n;i++){if(n%i==0)s+=i;}return s==n;}

Ejercicio 1.07.23 - Cálculo de Potencia Rápida Oculto ⭐⭐⭐☆☆¶

Ejercicio 1.07.24 - Desglose de Dinero con Lazos Confusos ⭐⭐☆☆☆¶

Solution to Exercise 24

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <assert.h>
#include <stdbool.h>

bool desglosar_cambio(int monto, int *monedas_100, int *monedas_50, int *monedas_10)
{
    if (monto < 0 || monedas_100 == NULL || monedas_50 == NULL || monedas_10 == NULL)
    {
        return false;
    }
    *monedas_100 = monto / 100;
    monto %= 100;

    *monedas_50 = monto / 50;
    monto %= 50;

    *monedas_10 = monto / 10;
    return true;
}

void test_desglose_cambio(void)
{
    int m100 = 0, m50 = 0, m10 = 0;
    bool ok = desglosar_cambio(370, &m100, &m50, &m10);
    assert(ok && m100 == 3 && m50 == 1 && m10 == 2);
}

4. Descomposición Modular y Funciones Reutilizables¶

Ejercicio 1.07.25 - La Función Monstruo de Facturación ⭐⭐⭐☆☆¶

Exercise 25

La siguiente función viola el Principio de Responsabilidad Única (0x2005h: Cada función debe tener una única responsabilidad (Principio de Responsabilidad Única)) y mezcla E/S con cálculos. Descomponela en al menos 3 funciones atómicas puras y un main interactivo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>

void facturar(double p, int cant, int tipo, double saldo)
{
    double sub = p * cant;
    double desc = 0;
    if (tipo == 1) desc = sub * 0.10;
    else if (tipo == 2) desc = sub * 0.20;
    double iva = (sub - desc) * 0.21;
    double total = (sub - desc) + iva;
    printf("Total: %.2f\n", total);
    if (saldo >= total) {
        printf("Pago exitoso. Saldo restante: %.2f\n", saldo - total);
    } else {
        printf("Saldo insuficiente\n");
    }
}

Ejercicio 1.07.26 - Herón y Clasificación de Triángulos Todo-en-Uno ⭐⭐⭐☆☆¶

Exercise 26

Refactorizá la siguiente función separando la validación geométrica, el cálculo del área por fórmula de Herón y la clasificación del triángulo en funciones independientes:

1
2
3
4
5
6
7
8
9
10
11
#include <math.h>

double tri(double a, double b, double c, int *tipo)
{
    if (a+b<=c||a+c<=b||b+c<=a) { *tipo=0; return 0; }
    if (a==b&&b==c) *tipo=1;
    else if (a==b||b==c||a==c) *tipo=2;
    else *tipo=3;
    double s=(a+b+c)/2.0;
    return sqrt(s*(s-a)*(s-b)*(s-c));
}

Ejercicio 1.07.27 - Duplicación de Código de Tiempo (Violación DRY) ⭐⭐☆☆☆¶

Exercise 27

El siguiente programa repite tres veces la misma lógica de cálculo de segundos a HH:MM:SS en diferentes lugares. Aplicá el principio DRY (Don’t Repeat Yourself) abstrayendo la lógica en una función reutilizable:

1
2
3
4
5
6
7
void imprimir_tres_horarios(int t1, int t2, int t3)
{
    int h1 = t1 / 3600; int m1 = (t1 % 3600) / 60; int s1 = t1 % 60;
    int h2 = t2 / 3600; int m2 = (t2 % 3600) / 60; int s2 = t2 % 60;
    int h3 = t3 / 3600; int m3 = (t3 % 3600) / 60; int s3 = t3 % 60;
    // ...
}

Solution to Exercise 27

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <assert.h>
#include <stdbool.h>

bool descomponer_segundos(int total_segundos, int *horas, int *minutos, int *segundos)
{
    if (total_segundos < 0 || horas == NULL || minutos == NULL || segundos == NULL)
    {
        return false;
    }
    *horas = total_segundos / 3600;
    int resto = total_segundos % 3600;
    *minutos = resto / 60;
    *segundos = resto % 60;
    return true;
}

void test_descomponer_segundos(void)
{
    int h = 0, m = 0, s = 0;
    assert(descomponer_segundos(3665, &h, &m, &s));
    assert(h == 1 && m == 1 && s == 5);
}

Ejercicio 1.07.28 - Máquina de Estados con Estados Mágicos ⭐⭐⭐☆☆¶

Exercise 28

Refactorizá la siguiente máquina de estados que usa números enteros mágicos (0, 1, 2, 3) para procesar palabras, sustituyéndolos por un enum autoexplicativo y funciones de transición puras:

1
2
3
4
5
6
7
8
9
int st = 0;

void step(char c)
{
    if (st == 0 && c != ' ') st = 1;
    else if (st == 1 && c == ' ') st = 2;
    else if (st == 2 && c != ' ') st = 1;
    else if (c == '\n') st = 3;
}

Ejercicio 1.07.29 - Validación de Entrada con Lazos Desacoplados ⭐⭐☆☆☆¶

Exercise 29

Refactorizá la siguiente función para separar la lógica de validación matemática de la lógica interactiva de reintento:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <stdio.h>

int pedir_entero_rango(int min, int max)
{
    int val;
    while (1) {
        printf("Ingrese valor entre %d y %d: ", min, max);
        if (scanf("%d", &val) == 1) {
            if (val >= min && val <= max) {
                return val;
            }
        }
        printf("Invalido, reintente.\n");
        while (getchar() != '\n'); // Limpia buffer
    }
}

Solution to Exercise 29

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <assert.h>
#include <stdbool.h>

bool esta_en_rango(int valor, int limite_inferior, int limite_superior)
{
    return (valor >= limite_inferior && valor <= limite_superior);
}

void test_esta_en_rango(void)
{
    assert(esta_en_rango(5, 1, 10) == true);
    assert(esta_en_rango(1, 1, 10) == true);
    assert(esta_en_rango(10, 1, 10) == true);
    assert(esta_en_rango(0, 1, 10) == false);
    assert(esta_en_rango(11, 1, 10) == false);
}

Ejercicio 1.07.30 - Tabla de Multiplicar Formateada y Modularizada ⭐⭐☆☆☆¶

Exercise 30

Refactorizá la siguiente función que imprime tablas de multiplicar desacoplando la generación del producto de la salida por pantalla:

1
2
3
4
5
6
7
#include <stdio.h>

void tabla(int n)
{
    for (int i = 1; i <= 10; i++)
        printf("%d x %d = %d\n", n, i, n * i);
}

Solution to Exercise 30

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <assert.h>
#include <stdio.h>

int calcular_producto(int multiplicando, int multiplicador)
{
    return multiplicando * multiplicador;
}

void imprimir_tabla_multiplicar(int numero)
{
    for (int factor = 1; factor <= 10; factor++)
    {
        int resultado = calcular_producto(numero, factor);
        printf("%2d x %2d = %4d\n", numero, factor, resultado);
    }
}

void test_calcular_producto(void)
{
    assert(calcular_producto(7, 8) == 56);
    assert(calcular_producto(0, 5) == 0);
    assert(calcular_producto(-3, 4) == -12);
}

Ejercicio 1.07.31 - Algoritmo de Luhn Comprimido ⭐⭐⭐⭐⭐¶

Exercise 31

El siguiente código implementa el algoritmo de validación de identificación (Algoritmo de Luhn) para números enteros de longitud variable, pero fue ofuscado deliberadamente en 4 líneas densas con asignaciones dobles y operadores ternarios anidados:

int l(long long n){int s=0,c=0,d;while(n>0){d=n%10;if(c%2!=0){d*=2;if(d>9)d-=9;}s+=d;n/=10;c++;}return(s%10==0)?1:0;}

Tu tarea:

Desentrañar cómo opera el conteo de posiciones de derecha a izquierda y la duplicación alternada.
Identificar todos los code smells (nombres mudos l, s, c, d, ternario ?:, falta de llaves Allman, falta de validación de entradas negativas).
Refactorizar el algoritmo en funciones modulares puras:
- int transformar_digito_luhn(int digito): multiplica por 2 y resta 9 si supera 9.
- bool validar_numero_luhn(long long numero_cuenta): calcula la suma total y verifica si es múltiplo de 10.
Escribir una suite de pruebas con assert() que verifique números válidos e inválidos reales (ej. 49927398716 es válido).

Ejercicio 1.07.32 - Congruencia de Zeller Astronómica ⭐⭐⭐⭐⭐¶

Exercise 32

Analizá el siguiente bloque de código. Es un algoritmo astronómico comprimido que calcula el día de la semana (0=Domingo, 1=Lunes, ..., 6=Sábado) para cualquier fecha del calendario gregoriano utilizando la Congruencia de Zeller con meses ajustados (marzo=3, ..., diciembre=12, enero=13 del año anterior, febrero=14 del año anterior):

int z(int d,int m,int y){if(m<3)m+=12,y--;int k=y%100,j=y/100;int h=(d+13*(m+1)/5+k+k/4+j/4+5*j)%7;return(h+6)%7;}

Tu tarea:

Desarmar la fórmula críptica identificando qué representan k, j, h y la constante 13*(m+1)/5.
Validar que la fecha sea válida antes de evaluar la fórmula (usando es_fecha_valida).
Refactorizar el cálculo en funciones puras, legibles, documentadas con Doxygen, con constantes claras y estilo Allman.
Escribir una suite de pruebas con assert() para fechas históricas conocidas:
- 25 de Mayo de 1810 $\rightarrow$ Viernes (5).
- 9 de Julio de 1816 $\rightarrow$ Martes (2).
- 1 de Enero de 2000 $\rightarrow$ Sábado (6).
- 29 de Febrero de 2024 $\rightarrow$ Jueves (4).

5. Lazos Anidados, Matrices y Patrones Numéricos¶

Ejercicio 1.07.33 - Rectángulo de Asteriscos Comprimido ⭐☆☆☆☆¶

Exercise 33

Analizá el siguiente código que imprime un rectángulo en consola mediante lazos anidados en una sola línea y refactorizalo:

void r(int w,int h){for(int i=0;i<h;i++){for(int j=0;j<w;j++)printf("*");printf("\n");}}

Solution to Exercise 33

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>

void imprimir_fila_caracter(char caracter, int longitud)
{
    for (int columna = 0; columna < longitud; columna++)
    {
        putchar(caracter);
    }
    putchar('\n');
}

void imprimir_rectangulo(int ancho, int alto)
{
    if (ancho <= 0 || alto <= 0)
    {
        return;
    }
    for (int fila = 0; fila < alto; fila++)
    {
        imprimir_fila_caracter('*', ancho);
    }
}

Ejercicio 1.07.34 - Matriz Identidad con Ternario Críptico ⭐⭐☆☆☆¶

Solution to Exercise 34

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <assert.h>

int obtener_valor_identidad(int fila, int columna)
{
    if (fila < 0 || columna < 0)
    {
        return -1;
    }
    if (fila == columna)
    {
        return 1;
    }
    return 0;
}

void test_valor_identidad(void)
{
    assert(obtener_valor_identidad(0, 0) == 1);
    assert(obtener_valor_identidad(2, 2) == 1);
    assert(obtener_valor_identidad(0, 3) == 0);
    assert(obtener_valor_identidad(-1, 0) == -1);
}

Ejercicio 1.07.35 - Conteo de Vocales con Cascada Repetitiva ⭐⭐☆☆☆¶

Exercise 35

El siguiente código cuenta vocales en un arreglo de caracteres pero repite condiciones if de manera poco idiomática:

int v(char a[], int n){int c=0;for(int i=0;i<n;i++){char x=a[i];if(x=='a'||x=='e'||x=='i'||x=='o'||x=='u'||x=='A'||x=='E'||x=='I'||x=='O'||x=='U')c++;}return c;}

Solution to Exercise 35

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>

bool es_vocal(char caracter)
{
    char c = (char)tolower((unsigned char)caracter);
    switch (c)
    {
        case 'a':
        case 'e':
        case 'i':
        case 'o':
        case 'u':
            return true;
        default:
            return false;
    }
}

int contar_vocales_secuencia(const char caracteres[], int longitud)
{
    if (caracteres == NULL || longitud <= 0)
    {
        return 0;
    }
    int total_vocales = 0;
    for (int i = 0; i < longitud; i++)
    {
        if (es_vocal(caracteres[i]))
        {
            total_vocales++;
        }
    }
    return total_vocales;
}

void test_conteo_vocales(void)
{
    char mensaje[] = {'H', 'o', 'l', 'a', 'M', 'u', 'n', 'd', 'o'};
    assert(contar_vocales_secuencia(mensaje, 9) == 4);
    assert(contar_vocales_secuencia(NULL, 0) == 0);
}

Ejercicio 1.07.36 - Coeficiente Binomial Redundante ⭐⭐⭐☆☆¶

Exercise 36

Refactorizá la siguiente función que calcula $\binom{n}{k}$ recalculando 3 factoriales completos de forma ineficiente y propensa a desbordamientos:

long long fact(int n){long long r=1;for(int i=2;i<=n;i++)r*=i;return r;}
long long binom(int n,int k){if(k<0||k>n)return 0;return fact(n)/(fact(k)*fact(n-k));}

Ejercicio 1.07.37 - Primos Gemelos con Variables Globales ⭐⭐☆☆☆¶

Exercise 37

Refactorizá la siguiente función que utiliza variables globales para verificar si dos números son primos gemelos ( $p_2 = p_1 + 2$ ):

1
2
3
4
5
6
int g_p1, g_p2;
int son_gem(void)
{
    if (g_p2 != g_p1 + 2) return 0;
    // ...
}

Solution to Exercise 37

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <assert.h>
#include <stdbool.h>

static bool es_primo_auxiliar(int n)
{
    if (n <= 1)
    {
        return false;
    }
    if (n == 2)
    {
        return true;
    }
    if (n % 2 == 0)
    {
        return false;
    }
    for (int d = 3; d * d <= n; d += 2)
    {
        if (n % d == 0)
        {
            return false;
        }
    }
    return true;
}

bool son_primos_gemelos(int primer_numero, int segundo_numero)
{
    if (segundo_numero != primer_numero + 2)
    {
        return false;
    }
    return es_primo_auxiliar(primer_numero) && es_primo_auxiliar(segundo_numero);
}

void test_primos_gemelos(void)
{
    assert(son_primos_gemelos(3, 5) == true);
    assert(son_primos_gemelos(11, 13) == true);
    assert(son_primos_gemelos(7, 9) == false);
    assert(son_primos_gemelos(4, 6) == false);
}

Ejercicio 1.07.38 - Criba de Divisores Estática ⭐⭐⭐☆☆¶

Exercise 38

Refactorizá la siguiente función que llena un arreglo indicando la cantidad de divisores propios de cada número:

void c(int a[],int n){for(int i=1;i<=n;i++){a[i-1]=0;for(int j=1;j<i;j++)if(i%j==0)a[i-1]++;}}

Ejercicio 1.07.39 - Suma de Diagonales en Arreglo 2D Plano ⭐⭐☆☆☆¶

Exercise 39

Refactorizá la siguiente función que suma la diagonal principal y secundaria de una matriz cuadrada de tamaño $N \times N$ representada en un arreglo unidimensional plano (arr[i * n + j]):

int d(int a[],int n){int s=0;for(int i=0;i<n;i++)s+=a[i*n+i]+a[i*n+(n-1-i)];if(n%2!=0)s-=a[(n/2)*n+(n/2)];return s;}

Solution to Exercise 39

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
#include <assert.h>
#include <stddef.h>

int calcular_suma_diagonales(const int matriz_plana[], int dimension)
{
    if (matriz_plana == NULL || dimension <= 0)
    {
        return 0;
    }
    int suma = 0;
    for (int i = 0; i < dimension; i++)
    {
        int indice_diag_principal = (i * dimension) + i;
        int indice_diag_secundaria = (i * dimension) + (dimension - 1 - i);

        suma += matriz_plana[indice_diag_principal];
        suma += matriz_plana[indice_diag_secundaria];
    }

    // Si la dimensión es impar, el elemento central fue sumado dos veces
    if (dimension % 2 != 0)
    {
        int centro = dimension / 2;
        int indice_centro = (centro * dimension) + centro;
        suma -= matriz_plana[indice_centro];
    }

    return suma;
}

void test_suma_diagonales(void)
{
    int m3[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    assert(calcular_suma_diagonales(m3, 3) == 25);
}

Ejercicio 1.07.40 - Conjetura de Collatz Caótica ⭐⭐⭐☆☆¶

Exercise 40

Refactorizá la siguiente función que cuenta la cantidad de pasos hasta llegar a 1 en la secuencia de Collatz ( $3n+1$ ), la cual mezcla ternarios y lazos while(1):

int col(long long n){int c=0;if(n<=0)return -1;while(1){if(n==1)break;n=(n%2==0)?n/2:3*n+1;c++;}return c;}

Ejercicio 1.07.41 - Transposición de Matriz $3 \times 3$ ⭐⭐☆☆☆¶

Solution to Exercise 41

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
#include <assert.h>
#include <stddef.h>

#define MAT_FILAS 3
#define MAT_COLUMNAS 3

void transponer_matriz_3x3(const int origen[9], int destino[9])
{
    if (origen == NULL || destino == NULL)
    {
        return;
    }
    for (int fila = 0; fila < MAT_FILAS; fila++)
    {
        for (int col = 0; col < MAT_COLUMNAS; col++)
        {
            int idx_origen = (fila * MAT_COLUMNAS) + col;
            int idx_destino = (col * MAT_FILAS) + fila;
            destino[idx_destino] = origen[idx_origen];
        }
    }
}

void test_transposicion_3x3(void)
{
    int orig[9] = {1, 2, 3, 4, 5, 6, 7, 8, 9};
    int dest[9] = {0};
    transponer_matriz_3x3(orig, dest);

    assert(dest[0] == 1 && dest[1] == 4 && dest[2] == 7);
    assert(dest[3] == 2 && dest[4] == 5 && dest[5] == 8);
    assert(dest[6] == 3 && dest[7] == 6 && dest[8] == 9);
}

Ejercicio 1.07.42 - Multiplicación de Matrices Cuadradas Comprimida ⭐⭐⭐⭐☆¶

Exercise 42

Analizá y refactorizá la siguiente función que multiplica dos matrices cuadradas de tamaño $N \times N$ representadas en arreglos unidimensionales planos:

void mx(int a[],int b[],int c[],int n){for(int i=0;i<n;i++)for(int j=0;j<n;j++){int s=0;for(int k=0;k<n;k++)s+=a[i*n+k]*b[k*n+j];c[i*n+j]=s;}}

Tu tarea:

Descomponer el triple lazo anidado aplicando estilo Allman riguroso y nombres autoexplicativos (fila, columna, indice_k).
Validar que los punteros no sean nulos y que la dimensión $N > 0$ .
Escribir una función auxiliar para calcular el producto escalar entre una fila de $A$ y una columna de $B$ .
Diseñar pruebas unitarias con assert() multiplicando matrices identidad y matrices con números enteros conocidos.

6. Validación de Formatos, Parsing y Protocolos Simples¶

Ejercicio 1.07.43 - Validador de Hora Militar Comprimido ⭐☆☆☆☆¶

Solution to Exercise 43

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
#include <assert.h>
#include <stdbool.h>

#define MIN_HORAS 0
#define MAX_HORAS 23
#define MIN_MINUTOS 0
#define MAX_MINUTOS 59
#define MIN_SEGUNDOS 0
#define MAX_SEGUNDOS 59

bool es_horario_valido(int horas, int minutos, int segundos)
{
    if (horas < MIN_HORAS || horas > MAX_HORAS)
    {
        return false;
    }
    if (minutos < MIN_MINUTOS || minutos > MAX_MINUTOS)
    {
        return false;
    }
    if (segundos < MIN_SEGUNDOS || segundos > MAX_SEGUNDOS)
    {
        return false;
    }
    return true;
}

void test_es_horario_valido(void)
{
    assert(es_horario_valido(14, 30, 0) == true);
    assert(es_horario_valido(23, 59, 59) == true);
    assert(es_horario_valido(24, 0, 0) == false);
    assert(es_horario_valido(12, -1, 0) == false);
}

Ejercicio 1.07.44 - Conversor de Caracteres a Entero (`atoi` Casero) ⭐⭐☆☆☆¶

Exercise 44

Refactorizá la siguiente función que parsea una secuencia de dígitos ASCII a un entero:

int parse(char s[], int n){int r=0,i=0,sg=1;if(s[0]=='-'){sg=-1;i=1;}for(;i<n;i++)r=r*10+(s[i]-'0');return r*sg;}

Solution to Exercise 44

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>

int convertir_caracteres_a_entero(const char digitos[], int longitud, bool *exito)
{
    if (digitos == NULL || longitud <= 0 || exito == NULL)
    {
        if (exito != NULL)
        {
            *exito = false;
        }
        return 0;
    }

    *exito = true;
    int signo = 1;
    int indice_inicio = 0;

    if (digitos[0] == '-')
    {
        signo = -1;
        indice_inicio = 1;
        if (longitud == 1)
        {
            *exito = false;
            return 0;
        }
    }

    int acumulador = 0;
    for (int i = indice_inicio; i < longitud; i++)
    {
        if (!isdigit((unsigned char)digitos[i]))
        {
            *exito = false;
            return 0;
        }
        acumulador = (acumulador * 10) + (digitos[i] - '0');
    }

    return acumulador * signo;
}

void test_convertir_a_entero(void)
{
    bool ok = false;
    char num1[] = {'1', '2', '3', '4'};
    assert(convertir_caracteres_a_entero(num1, 4, &ok) == 1234 && ok);

    char num2[] = {'-', '5', '0'};
    assert(convertir_caracteres_a_entero(num2, 3, &ok) == -50 && ok);

    char inv[] = {'1', '2', 'x', '4'};
    convertir_caracteres_a_entero(inv, 4, &ok);
    assert(!ok);
}

Ejercicio 1.07.45 - Validador de Octetos IPv4 Caótico ⭐⭐⭐☆☆¶

Exercise 45

Refactorizá la siguiente función que valida si 4 enteros representan una dirección IPv4 válida ( $0 \le x \le 255$ ):

int v4(int a,int b,int c,int d){if(a<0||a>255)return 0;if(b<0||b>255)return 0;if(c<0||c>255)return 0;if(d<0||d>255)return 0;return 1;}

Ejercicio 1.07.46 - Verificador de CUIT/CUIL con Módulo 11 ⭐⭐☆☆☆¶

Exercise 46

Refactorizá el siguiente cálculo del dígito verificador de un CUIT argentino de 10 dígitos (factores: 5, 4, 3, 2, 7, 6, 5, 4, 3, 2):

int dv(int d[10]){int f[10]={5,4,3,2,7,6,5,4,3,2},s=0;for(int i=0;i<10;i++)s+=d[i]*f[i];int r=11-(s%11);if(r==11)return 0;if(r==10)return 9;return r;}

Solution to Exercise 46

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <assert.h>
#include <stddef.h>

#define CANTIDAD_DIGITOS_BASE_CUIT 10

int calcular_digito_verificador_cuit(const int primeros_10_digitos[10])
{
    if (primeros_10_digitos == NULL)
    {
        return -1;
    }
    static const int factores_ponderacion[10] = {5, 4, 3, 2, 7, 6, 5, 4, 3, 2};

    int suma_ponderada = 0;
    for (int i = 0; i < CANTIDAD_DIGITOS_BASE_CUIT; i++)
    {
        if (primeros_10_digitos[i] < 0 || primeros_10_digitos[i] > 9)
        {
            return -1;
        }
        suma_ponderada += (primeros_10_digitos[i] * factores_ponderacion[i]);
    }

    int resto = suma_ponderada % 11;
    int digito_calculado = 11 - resto;

    if (digito_calculado == 11)
    {
        return 0;
    }
    if (digito_calculado == 10)
    {
        return 9;
    }
    return digito_calculado;
}

void test_cuit_verificador(void)
{
    int digitos_test[10] = {2, 0, 1, 2, 3, 4, 5, 6, 7, 8};
    int dv = calcular_digito_verificador_cuit(digitos_test);
    assert(dv >= 0 && dv <= 9);
}

Ejercicio 1.07.47 - Compactador de Espacios Repetidos ⭐⭐⭐☆☆¶

Exercise 47

Refactorizá la siguiente función que copia caracteres de orig a dest colapsando múltiples espacios consecutivos en uno solo:

int comp(char o[],int n,char d[]){int j=0,e=0;for(int i=0;i<n;i++){if(o[i]==' '){if(!e){d[j++]=' ';e=1;}}else{d[j++]=o[i];e=0;}}return j;}

Ejercicio 1.07.48 - Validador de Fortaleza de Contraseña ⭐⭐☆☆☆¶

Exercise 48

Refactorizá la siguiente función que evalúa si una contraseña en arreglo tiene al menos 8 caracteres, al menos una mayúscula y al menos un dígito:

int pass(char p[],int n){int u=0,d=0;if(n<8)return 0;for(int i=0;i<n;i++){if(p[i]>='A'&&p[i]<='Z')u=1;if(p[i]>='0'&&p[i]<='9')d=1;}return(u&&d)?1:0;}

Solution to Exercise 48

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
#include <assert.h>
#include <ctype.h>
#include <stdbool.h>
#include <stddef.h>

#define LONGITUD_MINIMA_CLAVE 8

bool validar_fortaleza_clave(const char clave[], int longitud)
{
    if (clave == NULL || longitud < LONGITUD_MINIMA_CLAVE)
    {
        return false;
    }

    bool tiene_mayuscula = false;
    bool tiene_digito = false;

    for (int i = 0; i < longitud; i++)
    {
        if (isupper((unsigned char)clave[i]))
        {
            tiene_mayuscula = true;
        }
        if (isdigit((unsigned char)clave[i]))
        {
            tiene_digito = true;
        }
    }

    return tiene_mayuscula && tiene_digito;
}

void test_fortaleza_clave(void)
{
    char c1[] = {'P', 'a', 's', 's', 'w', 'o', 'r', 'd', '1'};
    assert(validar_fortaleza_clave(c1, 9) == true);

    char c2[] = {'p', 'a', 's', 's', '1'};
    assert(validar_fortaleza_clave(c2, 5) == false);

    char c3[] = {'p', 'a', 's', 's', 'w', 'o', 'r', 'd', 's'};
    assert(validar_fortaleza_clave(c3, 9) == false);
}

Ejercicio 1.07.49 - Decodificador Run-Length (RLE) Numérico ⭐⭐⭐☆☆¶

Exercise 49

Refactorizá la siguiente función que decodifica pares (valor, repeticiones) en un arreglo plano:

1
2
3
4
5
6
7
8
9
10
11
12
int rle_dec(int pares[], int n_pares, int sal[], int max_sal)
{
    int k=0;
    for(int i=0;i<n_pares*2;i+=2){
        int val=pares[i]; int rep=pares[i+1];
        for(int r=0;r<rep;r++){
            if(k>=max_sal) return -1;
            sal[k++]=val;
        }
    }
    return k;
}

Ejercicio 1.07.50 - Conversor de Números Romanos Básicos ⭐⭐☆☆☆¶

Exercise 50

Refactorizá la siguiente función que convierte un carácter romano individual a su valor numérico:

int r2d(char c){if(c=='I')return 1;if(c=='V')return 5;if(c=='X')return 10;if(c=='L')return 50;if(c=='C')return 100;if(c=='D')return 500;if(c=='M')return 1000;return 0;}

Solution to Exercise 50

Código Refactorizado:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <assert.h>

int obtener_valor_simbolo_romano(char simbolo)
{
    switch (simbolo)
    {
        case 'I':
            return 1;
        case 'V':
            return 5;
        case 'X':
            return 10;
        case 'L':
            return 50;
        case 'C':
            return 100;
        case 'D':
            return 500;
        case 'M':
            return 1000;
        default:
            return -1;
    }
}

void test_simbolos_romanos(void)
{
    assert(obtener_valor_simbolo_romano('X') == 10);
    assert(obtener_valor_simbolo_romano('M') == 1000);
    assert(obtener_valor_simbolo_romano('A') == -1);
}

Ejercicio 1.07.51 - Checksum de Paridad Longitudinal ⭐⭐⭐⭐☆¶

Exercise 51

Analizá el siguiente algoritmo que calcula la suma de verificación módulo 256 con residuo ajustado sobre un bloque de datos:

int chk(int d[],int n){int s=0;for(int i=0;i<n;i++)s=(s+d[i])%256;return(256-s)%256;}

Tu tarea:

Determinar cómo este checksum asegura que la suma de todos los datos más el checksum sea congruente con 0 módulo 256.
Refactorizar la función en estilo Allman con constantes simbólicas #define MODULO_CHECKSUM 256.
Validar entradas negativas o punteros nulos.
Escribir tests unitarios que verifiquen la invariante $\sum \text{datos} + \text{checksum} \equiv 0 \pmod{256}$ .

Ejercicio 1.07.52 - Mini Intérprete de Pila de 4 Instrucciones ⭐⭐⭐⭐☆¶

Exercise 52

El siguiente código implementa una máquina virtual de pila simple para evaluar expresiones en notación postfija con 4 códigos (1=PUSH, 2=ADD, 3=SUB, 4=HALT):

int vm(int prg[],int n){int st[32],top=0;for(int i=0;i<n;i++){int op=prg[i];if(op==1)st[top++]=prg[++i];else if(op==2){int b=st[--top],a=st[--top];st[top++]=a+b;}else if(op==3){int b=st[--top],a=st[--top];st[top++]=a-b;}else if(op==4)break;}return st[top-1];}

Tu tarea:

Identificar riesgos de desbordamiento de pila (stack overflow y stack underflow).
Refactorizar usando un enum con los opcodes OP_PUSH, OP_ADD, OP_SUB, OP_HALT.
Extraer funciones auxiliares seguras para push y pop con verificación de límites.
Escribir tests unitarios que ejecuten programas de prueba válidos y detecten programas con errores.

7. Desafíos Avanzados y Extra Difíciles¶

Ejercicio 1.07.53 - Conversor de Base Numérica a Arreglo ⭐⭐⭐☆☆¶

Exercise 53

Refactorizá la siguiente función que convierte un entero positivo a sus dígitos en una base entre 2 y 16:

1
2
3
4
5
6
7
8
int base_conv(int n, int b, char out[], int max_len)
{
    char dig[]="0123456789ABCDEF"; int len=0;
    if(n==0){out[0]='0'; return 1;}
    while(n>0&&len<max_len){ out[len++]=dig[n%b]; n/=b; }
    for(int i=0;i<len/2;i++){ char t=out[i]; out[i]=out[len-1-i]; out[len-1-i]=t; }
    return len;
}

Ejercicio 1.07.54 - Búsqueda Binaria con Riesgo de Desbordamiento ⭐⭐⭐☆☆¶

Exercise 54

El siguiente código implementa búsqueda binaria pero utiliza el cálculo riesgoso int m = (l + r) / 2 que puede desbordar enteros grandes:

int bsearch(int a[],int n,int x){int l=0,r=n-1;while(l<=r){int m=(l+r)/2;if(a[m]==x)return m;if(a[m]<x)l=m+1;else r=m-1;}return -1;}

Ejercicio 1.07.55 - Ordenamiento Burbuja con Salida Temprana ⭐⭐⭐⭐☆¶

Exercise 55

Refactorizá la siguiente función de ordenamiento burbuja escrita en un solo lazo críptico:

void bsort(int a[],int n){int s=1;while(s){s=0;for(int i=0;i<n-1;i++)if(a[i]>a[i+1]){int t=a[i];a[i]=a[i+1];a[i+1]=t;s=1;}}}

Tu tarea:

Descomponer el algoritmo en dos lazos estructurados for en estilo Allman.
Extraer la función auxiliar pura void intercambiar_enteros(int *a, int *b).
Escribir tests unitarios con assert() verificando arreglos desordenados, ordenados e invertidos.

Ejercicio 1.07.56 - Algoritmo de Kadane Comprimido ⭐⭐⭐⭐☆¶

Exercise 56

Analizá el siguiente algoritmo que calcula la suma máxima de un subarreglo contiguo (Algoritmo de Kadane) en una sola línea ofuscada:

int kad(int a[],int n){int m=a[0],c=a[0];for(int i=1;i<n;i++)c=(a[i]>c+a[i])?a[i]:c+a[i],m=(c>m)?c:m;return m;}

Tu tarea:

Eliminar los operadores ternarios y el operador coma ,.
Escribir la lógica en estilo Allman con nombres claros (maximo_global, maximo_actual).
Validar que $N > 0$ y puntero no nulo.
Escribir tests unitarios para arreglos con números positivos, negativos y mixtos (ej. {-2, 1, -3, 4, -1, 2, 1, -5, 4} da 6).

Ejercicio 1.07.57 - Generador Pseudoaleatorio Congruencial (LCG) ⭐⭐⭐☆☆¶

Exercise 57

Refactorizá la siguiente función que genera el siguiente número pseudoaleatorio usando la fórmula $X_{n+1} = (a X_n + c) \pmod m$ :

int lcg(int seed){return(seed*1103515245+12345)&0x7FFFFFFF;}

Ejercicio 1.07.58 - Ordenamiento por Inserción Compacto ⭐⭐⭐⭐☆¶

Exercise 58

Refactorizá la siguiente implementación de Insertion Sort:

void isort(int a[],int n){for(int i=1;i<n;i++){int k=a[i],j=i-1;while(j>=0&&a[j]>k){a[j+1]=a[j];j--;}a[j+1]=k;}}

Tu tarea:

Formatear en estilo Allman con llaves explícitas en todos los bloques.
Renombrar variables (elemento_clave, indice_anterior).
Escribir tests unitarios que validen el orden no decreciente del arreglo tras la ejecución.

Ejercicio 1.07.59 - Distancias Manhattan y Euclidiana Todo-en-Uno ⭐⭐⭐⭐☆¶

Exercise 59

Refactorizá la siguiente función que calcula distancias entre dos vectores de $N$ dimensiones según un selector de modo:

double dist(double a[],double b[],int n,int m){double s=0;for(int i=0;i<n;i++){double d=fabs(a[i]-b[i]);s+=(m==1)?d:d*d;}return(m==1)?s:sqrt(s);}

Tu tarea:

Descomponer en dos funciones puras independientes: calcular_distancia_manhattan y calcular_distancia_euclidiana.
Eliminar el parámetro selector m y los operadores ternarios.
Escribir tests unitarios con assert() comparando con tolerancia 1e-6.

Ejercicio 1.07.60 - Conteo de Componentes Conexas 1D ⭐⭐⭐⭐☆¶

Exercise 60

El siguiente código cuenta cuántas secuencias continuas de números positivos existen en un arreglo:

int comp1d(int a[],int n){int c=0,in=0;for(int i=0;i<n;i++){if(a[i]>0&&!in){c++;in=1;}else if(a[i]<=0){in=0;}}return c;}

Tu tarea:

Refactorizar aplicando estilo Allman y nombres booleanos claros (en_segmento_positivo).
Validar casos de borde: todo positivo, todo negativo, arreglo vacío.
Escribir tests unitarios estructurados.

Ejercicio 1.07.61 - Vecinos de Conway en Cuadrícula $5 \times 5$ ⭐⭐⭐⭐☆¶

Exercise 61

Analizá y refactorizá la siguiente función que cuenta los vecinos vivos (valor

alrededor de una celda $(r, c)$ en una cuadrícula $5 \times 5$ :

int nb(int g[25],int r,int c){int cnt=0;for(int dr=-1;dr<=1;dr++)for(int dc=-1;dc<=1;dc++){if(!dr&&!dc)continue;int nr=r+dr,nc=c+dc;if(nr>=0&&nr<5&&nc>=0&&nc<5)cnt+=g[nr*5+nc];}return cnt;}

Tu tarea:

Formatear la doble iteración en estilo Allman.
Definir constantes #define GRILLA_DIMENSION 5.
Extraer la función bool esta_dentro_de_grilla(int fila, int columna).
Escribir tests con assert() para celdas esquinas, bordes y centrales.

Ejercicio 1.07.62 - Balanceador de Paréntesis Lineal ⭐⭐⭐⭐☆¶

Exercise 62

Refactorizá la siguiente función que verifica si los paréntesis ( y ) de una cadena están correctamente balanceados:

int bal(char s[],int n){int d=0;for(int i=0;i<n;i++){if(s[i]=='(')d++;else if(s[i]==')'){d--;if(d<0)return 0;}}return(d==0)?1:0;}

Tu tarea:

Eliminar el operador ternario y retornar un bool.
Validar que un cierre sin apertura previa (d < 0) corte inmediatamente retornando false.
Escribir tests unitarios para "(())", "())(", "(" y "".

Ejercicio 1.07.63 - [EXTRA DIFÍCIL] El Cuadrado Mágico y Verificador de Sudoku $3 \times 3$ ⭐⭐⭐⭐⭐¶

Exercise 63

El siguiente código evalúa si una matriz $3 \times 3$ plana de 9 elementos contiene exactamente los dígitos del 1 al 9 sin repetir y si las sumas de todas sus filas, columnas y diagonales son iguales a 15 (Cuadrado Mágico / Mini Sudoku):

int sm(int m[9]){int u[10]={0},s=0;for(int i=0;i<9;i++){int v=m[i];if(v<1||v>9||u[v])return 0;u[v]=1;}for(int i=0;i<3;i++){int r=m[i*3]+m[i*3+1]+m[i*3+2],c=m[i]+m[i+3]+m[i+6];if(r!=15||c!=15)return 0;}int d1=m[0]+m[4]+m[8],d2=m[2]+m[4]+m[6];return(d1==15&&d2==15)?1:0;}

Tu tarea:

Desarmar la lógica monolítica identificando los tres pasos:
- Verificación de permutación de dígitos 1 a 9.
- Verificación de sumas de las 3 filas y 3 columnas igual a 15.
- Verificación de las 2 diagonales igual a 15.
Descomponer el algoritmo en funciones auxiliares puras y modulares:
- bool contiene_digitos_1_a_9_unicos(const int matriz[9])
- bool verificar_filas_y_columnas_magicas(const int matriz[9], int suma_esperada)
- bool verificar_diagonales_magicas(const int matriz[9], int suma_esperada)
- bool es_cuadrado_magico_3x3(const int matriz[9])
Aplicar estilo Allman riguroso, constantes #define CONSTANTE_MAGICA_3X3 15 y contratos Doxygen.
Escribir una suite de pruebas con assert() para el cuadrado mágico clásico de Lo Shu:
$\begin{pmatrix} 4 & 9 & 2 \\ 3 & 5 & 7 \\ 8 & 1 & 6 \end{pmatrix}$
(1)

Ejercicio 1.07.64 - [EXTRA DIFÍCIL] El Cifrador Vigenère Aritmético Cripto-Comprimido ⭐⭐⭐⭐⭐¶

Exercise 64

Analizá el siguiente bloque de código. Aplica el cifrado de Vigenère sobre un arreglo de caracteres usando una clave alfabética repetida, ajustando las letras mayúsculas y minúsculas módulo 26, pero fue condensado en 5 líneas de expresiones confusas:

void vig(char t[],int n,char k[],int m,int dec){for(int i=0,j=0;i<n;i++){char c=t[i];if((c>='A'&&c<='Z')||(c>='a'&&c<='z')){int base=(c>='a')?'a':'A';int kbase=(k[j%m]>='a')?'a':'A';int sh=k[j%m]-kbase;if(dec)sh=26-(sh%26);t[i]=(char)(base+((c-base+sh)%26));j++;}}}

Tu tarea:

Desentrañar la aritmética modular del desplazamiento tanto para cifrado (dec = 0) como para descifrado (dec = 1).
Identificar todos los code smells (ternarios anidados, falta de llaves Allman, nombres mudos t, n, k, m, dec, sh).
Refactorizar el algoritmo en funciones puras y desacopladas:
- char desplazar_caracter(char c, int desplazamiento, bool descifrar)
- int obtener_desplazamiento_clave(char c_clave)
- void cifrar_vigenere(char texto[], int long_texto, const char clave[], int long_clave)
- void descifrar_vigenere(char texto[], int long_texto, const char clave[], int long_clave)
Escribir una suite completa de pruebas unitarias con assert() que verifique que descifrar un texto cifrado recupere exactamente el mensaje original (propiedad de reversibilidad).

Prerrequisitos Técnicos y Entorno Requerido¶

Acerca de¶

Metodología de Trabajo para Cada Ejercicio¶

1. Expresiones Aritméticas, Asignaciones y Nombres Crípticos¶

Ejercicio 1.07.01 - El Máximo Comprimido ⭐☆☆☆☆¶

Ejercicio 1.07.02 - Geometría sin Nombres ⭐☆☆☆☆¶

Ejercicio 1.07.03 - Suma de Cuadrados en Una Línea ⭐⭐☆☆☆¶

Ejercicio 1.07.04 - Conversión Térmica con División Entera Peligrosa ⭐⭐☆☆☆¶

Ejercicio 1.07.05 - Suma de Dígitos Ofuscada ⭐⭐☆☆☆¶

Ejercicio 1.07.06 - Año Bisiesto Críptico ⭐☆☆☆☆¶

Ejercicio 1.07.07 - Sumatoria de Gauss con Nombres Inadecuados ⭐☆☆☆☆¶

Ejercicio 1.07.08 - Cilindro con Número Mágico ⭐⭐☆☆☆¶

2. Control de Flujo Espagueti y Anidaciones Profundas¶

Ejercicio 1.07.09 - El Monstruo de la Flecha (Arrow Code) ⭐⭐⭐☆☆¶

Ejercicio 1.07.10 - Menú con Ifs Caóticos ⭐⭐☆☆☆¶

Ejercicio 1.07.11 - Lazo Espagueti con Banderas Confusas ⭐⭐⭐☆☆¶

Ejercicio 1.07.12 - Tarifa de Taxi con Variables Reutilizadas ⭐⭐☆☆☆¶

Ejercicio 1.07.13 - Expresión Booleana Monolítica de Validación de Fecha ⭐⭐⭐☆☆¶

Ejercicio 1.07.14 - Descuento Escalonado con Condiciones Solapadas ⭐⭐☆☆☆¶

Ejercicio 1.07.15 - Función Contaminada con Entrada/Salida ⭐⭐☆☆☆¶

Ejercicio 1.07.16 - Búsqueda Lineal con Variables Globales ⭐⭐☆☆☆¶

3. Algoritmos Comprimidos y Lazos Crípticos¶

Ejercicio 1.07.17 - Euclides con Operador Coma y Asignaciones Crípticas ⭐⭐⭐☆☆¶

Ejercicio 1.07.18 - Inversor de Números con Variables Reutilizadas ⭐⭐☆☆☆¶

Ejercicio 1.07.19 - Fibonacci Iterativo Micro-comprimido ⭐⭐☆☆☆¶

Ejercicio 1.07.20 - Conteo de Números Armstrong Desordenado ⭐⭐⭐☆☆¶

Ejercicio 1.07.21 - Factorial con Detección de Desbordamiento Oculto ⭐⭐☆☆☆¶

Ejercicio 1.07.22 - Números Perfectos con Lazo Ineficiente ⭐⭐⭐☆☆¶

Ejercicio 1.07.23 - Cálculo de Potencia Rápida Oculto ⭐⭐⭐☆☆¶

Ejercicio 1.07.24 - Desglose de Dinero con Lazos Confusos ⭐⭐☆☆☆¶

4. Descomposición Modular y Funciones Reutilizables¶

Ejercicio 1.07.25 - La Función Monstruo de Facturación ⭐⭐⭐☆☆¶

Ejercicio 1.07.26 - Herón y Clasificación de Triángulos Todo-en-Uno ⭐⭐⭐☆☆¶

Ejercicio 1.07.27 - Duplicación de Código de Tiempo (Violación DRY) ⭐⭐☆☆☆¶

Ejercicio 1.07.28 - Máquina de Estados con Estados Mágicos ⭐⭐⭐☆☆¶

Ejercicio 1.07.29 - Validación de Entrada con Lazos Desacoplados ⭐⭐☆☆☆¶

Ejercicio 1.07.30 - Tabla de Multiplicar Formateada y Modularizada ⭐⭐☆☆☆¶

Ejercicio 1.07.31 - Algoritmo de Luhn Comprimido ⭐⭐⭐⭐⭐¶

Ejercicio 1.07.32 - Congruencia de Zeller Astronómica ⭐⭐⭐⭐⭐¶

5. Lazos Anidados, Matrices y Patrones Numéricos¶

Ejercicio 1.07.33 - Rectángulo de Asteriscos Comprimido ⭐☆☆☆☆¶

Ejercicio 1.07.34 - Matriz Identidad con Ternario Críptico ⭐⭐☆☆☆¶

Ejercicio 1.07.35 - Conteo de Vocales con Cascada Repetitiva ⭐⭐☆☆☆¶

Ejercicio 1.07.36 - Coeficiente Binomial Redundante ⭐⭐⭐☆☆¶

Ejercicio 1.07.37 - Primos Gemelos con Variables Globales ⭐⭐☆☆☆¶

Ejercicio 1.07.38 - Criba de Divisores Estática ⭐⭐⭐☆☆¶

Ejercicio 1.07.39 - Suma de Diagonales en Arreglo 2D Plano ⭐⭐☆☆☆¶

Ejercicio 1.07.40 - Conjetura de Collatz Caótica ⭐⭐⭐☆☆¶

Ejercicio 1.07.41 - Transposición de Matriz 3×33 \times 33×3 ⭐⭐☆☆☆¶

Ejercicio 1.07.42 - Multiplicación de Matrices Cuadradas Comprimida ⭐⭐⭐⭐☆¶

6. Validación de Formatos, Parsing y Protocolos Simples¶

Ejercicio 1.07.43 - Validador de Hora Militar Comprimido ⭐☆☆☆☆¶

Ejercicio 1.07.44 - Conversor de Caracteres a Entero (atoi Casero) ⭐⭐☆☆☆¶

Ejercicio 1.07.45 - Validador de Octetos IPv4 Caótico ⭐⭐⭐☆☆¶

Ejercicio 1.07.46 - Verificador de CUIT/CUIL con Módulo 11 ⭐⭐☆☆☆¶

Ejercicio 1.07.47 - Compactador de Espacios Repetidos ⭐⭐⭐☆☆¶

Ejercicio 1.07.48 - Validador de Fortaleza de Contraseña ⭐⭐☆☆☆¶

Ejercicio 1.07.49 - Decodificador Run-Length (RLE) Numérico ⭐⭐⭐☆☆¶

Ejercicio 1.07.50 - Conversor de Números Romanos Básicos ⭐⭐☆☆☆¶

Ejercicio 1.07.51 - Checksum de Paridad Longitudinal ⭐⭐⭐⭐☆¶

Ejercicio 1.07.52 - Mini Intérprete de Pila de 4 Instrucciones ⭐⭐⭐⭐☆¶

7. Desafíos Avanzados y Extra Difíciles¶

Ejercicio 1.07.53 - Conversor de Base Numérica a Arreglo ⭐⭐⭐☆☆¶

Ejercicio 1.07.54 - Búsqueda Binaria con Riesgo de Desbordamiento ⭐⭐⭐☆☆¶

Ejercicio 1.07.55 - Ordenamiento Burbuja con Salida Temprana ⭐⭐⭐⭐☆¶

Ejercicio 1.07.56 - Algoritmo de Kadane Comprimido ⭐⭐⭐⭐☆¶

Ejercicio 1.07.57 - Generador Pseudoaleatorio Congruencial (LCG) ⭐⭐⭐☆☆¶

Ejercicio 1.07.58 - Ordenamiento por Inserción Compacto ⭐⭐⭐⭐☆¶

Ejercicio 1.07.59 - Distancias Manhattan y Euclidiana Todo-en-Uno ⭐⭐⭐⭐☆¶

Ejercicio 1.07.60 - Conteo de Componentes Conexas 1D ⭐⭐⭐⭐☆¶

Ejercicio 1.07.61 - Vecinos de Conway en Cuadrícula 5×55 \times 55×5 ⭐⭐⭐⭐☆¶

Ejercicio 1.07.62 - Balanceador de Paréntesis Lineal ⭐⭐⭐⭐☆¶

Ejercicio 1.07.63 - [EXTRA DIFÍCIL] El Cuadrado Mágico y Verificador de Sudoku 3×33 \times 33×3 ⭐⭐⭐⭐⭐¶

Ejercicio 1.07.64 - [EXTRA DIFÍCIL] El Cifrador Vigenère Aritmético Cripto-Comprimido ⭐⭐⭐⭐⭐¶

Notas Finales¶

Ejercicio 1.07.41 - Transposición de Matriz $3 \times 3$ ⭐⭐☆☆☆¶

Ejercicio 1.07.44 - Conversor de Caracteres a Entero (`atoi` Casero) ⭐⭐☆☆☆¶

Ejercicio 1.07.61 - Vecinos de Conway en Cuadrícula $5 \times 5$ ⭐⭐⭐⭐☆¶

Ejercicio 1.07.63 - [EXTRA DIFÍCIL] El Cuadrado Mágico y Verificador de Sudoku $3 \times 3$ ⭐⭐⭐⭐⭐¶