Ejercicios de Entrada y Salida Gradual

(ej_b1_c02_02)=
### Ejercicio 1.02.02 - Validación de Formato de Entrada ⭐⭐☆☆☆

:::{exercise}
:label: ej_b1_c02_02_entrada

Diseñá una función pura que procese una cadena de entrada simulando la lectura
de inicial, edad y promedio, validando que los tres campos se analicen
correctamente y rechazando entradas malformadas.

```c
bool parsear_datos(const char *entrada, char *inicial, int *edad, float *promedio);
```

**Tabla de Vectores de Prueba:**

| Cadena de Entrada | Retorno Esperado | Valores Parseados |
| :--- | :--- | :--- |
| `"J 20 8.75"` | `true` | `inicial='J', edad=20, promedio=8.75` |
| `"M 25"` (incompleta) | `false` | Inalterados o rechazados |
| `""` (vacía) | `false` | Retorno `false` |

::::{solution}
```c
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>

bool parsear_datos(const char *entrada, char *inicial, int *edad, float *promedio) {
    if (entrada == NULL || inicial == NULL || edad == NULL || promedio == NULL) {
        return false;
    }
    int leidos = sscanf(entrada, " %c %d %f", inicial, edad, promedio);
    return leidos == 3;
}

int main(void) {
    char ini = ' ';
    int ed = 0;
    float prom = 0.0f;

    assert(parsear_datos("J 20 8.75", &ini, &ed, &prom));
    assert(ini == 'J');
    assert(ed == 20);
    assert(prom > 8.74f && prom < 8.76f);

    assert(!parsear_datos("M 25", &ini, &ed, &prom));
    assert(!parsear_datos("", &ini, &ed, &prom));
    assert(!parsear_datos(NULL, &ini, &ed, &prom));

    return 0;
}
```

(ej_b1_c02_03)=
### Ejercicio 1.02.03 - Determinación de Paridad ⭐☆☆☆☆

:::{exercise}
:label: ej_b1_c02_03_paridad

Implementá una función pura que determine si un número entero es par:
```c
bool es_par(int numero);
```

**Tabla de Vectores de Prueba:**

| Caso de Prueba | Número Entrada | Retorno Esperado | Justificación |
| :--- | :--- | :--- | :--- |
| Par positivo | `42` | `true` | `42 % 2 == 0` |
| Impar positivo | `17` | `false` | `17 % 2 != 0` |
| Cero | `0` | `true` | `0 % 2 == 0` |
| Par negativo | `-8` | `true` | `-8 % 2 == 0` |
| Impar negativo | `-9` | `false` | `-9 % 2 != 0` |

::::{solution}
```c
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>

bool es_par(int numero) {
    return (numero % 2) == 0;
}

int main(void) {
    assert(es_par(42) == true);
    assert(es_par(17) == false);
    assert(es_par(0) == true);
    assert(es_par(-8) == true);
    assert(es_par(-9) == false);

    return 0;
}
```

---

(ej_b1_c02_04)=
### Ejercicio 1.02.04 - Mayor de Tres Números ⭐⭐☆☆☆

:::{exercise}
:label: ej_b1_c02_04_mayor_tres

Implementá una función pura que determine el valor máximo entre tres números enteros:
```c
int mayor_de_tres(int a, int b, int c);
```

**Tabla de Vectores de Prueba:**

| Caso de Prueba | Entrada `(a, b, c)` | Retorno Esperado | Justificación |
| :--- | :--- | :--- | :--- |
| Primero mayor | `(30, 10, 20)` | `30` | `30 > 10` y `30 > 20` |
| Segundo mayor | `(5, 50, -2)` | `50` | `50` es el máximo |
| Tercero mayor | `(-10, -5, 0)` | `0` | `0` supera a los negativos |
| Todos iguales | `(7, 7, 7)` | `7` | Valor común |

::::{solution}
```c
#include <stdio.h>
#include <assert.h>

int mayor_de_tres(int a, int b, int c) {
    int max = a;
    if (b > max) {
        max = b;
    }
    if (c > max) {
        max = c;
    }
    return max;
}

int main(void) {
    assert(mayor_de_tres(30, 10, 20) == 30);
    assert(mayor_de_tres(5, 50, -2) == 50);
    assert(mayor_de_tres(-10, -5, 0) == 0);
    assert(mayor_de_tres(7, 7, 7) == 7);
    return 0;
}
```

(ej_b1_c02_05)=
### Ejercicio 1.02.05 - Determinación de Año Bisiesto ⭐⭐☆☆☆

:::{exercise}
:label: ej_b1_c02_05_bisiesto

Implementá una función que determine si un año del calendario gregoriano es bisiesto:
- Un año es bisiesto si es divisible por 4.
- Excepto si es divisible por 100, salvo que también sea divisible por 400.
- Años menores o iguales a 0 se consideran inválidos y retornan `false`.

```c
bool es_bisiesto(int anio);
```

**Tabla de Vectores de Prueba:**

| Caso de Prueba | Año Entrada | Retorno Esperado | Regla Aplicada |
| :--- | :--- | :--- | :--- |
| Secundario bisiesto | `2024` | `true` | Divisible por 4 y no por 100 |
| Fin de siglo común | `1900` | `false` | Divisible por 100 pero no por 400 |
| Fin de siglo bisiesto | `2000` | `true` | Divisible por 400 |
| Año común | `2023` | `false` | No divisible por 4 |
| Año no positivo | `-4` | `false` | Rechazo por contrato |

::::{solution}
```c
#include <stdio.h>
#include <stdbool.h>
#include <assert.h>

bool es_bisiesto(int anio) {
    if (anio <= 0) {
        return false;
    }
    return (anio % 4 == 0 && anio % 100 != 0) || (anio % 400 == 0);
}

int main(void) {
    assert(es_bisiesto(2024) == true);
    assert(es_bisiesto(1900) == false);
    assert(es_bisiesto(2000) == true);
    assert(es_bisiesto(2023) == false);
    assert(es_bisiesto(0) == false);
    assert(es_bisiesto(-4) == false);

    return 0;
}
```

---

(ej_b1_c02_06)=
### Ejercicio 1.02.06 - Calificación Numérica a Letra Escolar ⭐⭐☆☆☆

:::{exercise}
:label: ej_b1_c02_06_calificacion_letra
:enumerator: gradual-6

Implementá una función pura que convierta una calificación numérica porcentual en el rango $[0, 100]$ a su equivalente en escala alfabética estándar:
- $90 \le \text{nota} \le 100 \implies \text{'A'}$
- $80 \le \text{nota} < 90 \implies \text{'B'}$
- $70 \le \text{nota} < 80 \implies \text{'C'}$
- $60 \le \text{nota} < 70 \implies \text{'D'}$
- $0 \le \text{nota} < 60 \implies \text{'F'}$
- Cualquier valor fuera de $[0, 100]$ debe retornar el carácter de error `'?'`.

```c
char calificacion_a_letra(int nota);
```

**Nivel de Bloom:** Nivel 2 (Comprensión) y Nivel 3 (Aplicación).  
**Conceptos requeridos:** Condicionales mutuamente excluyentes (`if-else if-else`), límites de rango defensivos.  
**Techo conceptual:** Prohibido retornar códigos numéricos arbitrarios o ignorar entradas negativas / superiores a 100.

#### Contrato de la Función
- **Firma:** `char calificacion_a_letra(int nota);`
- **Precondiciones:** Ninguna (función total).
- **Postcondiciones:** Retorna `'A'`, `'B'`, `'C'`, `'D'`, `'F'`, o `'?'` ante nota inválida.

#### Tabla de Vectores de Prueba

| Caso de Prueba | Nota Entrada | Letra Retornada | Justificación Técnica |
| :--- | :--- | :--- | :--- |
| Límite superior A | `100` | `'A'` | Extremo superior válido |
| Límite inferior A | `90` | `'A'` | Umbral exacto |
| Rango intermedio B | `85` | `'B'` | Caso típico |
| Límite inferior D | `60` | `'D'` | Nota mínima de aprobación |
| Rango F | `45` | `'F'` | Desaprobado |
| Error negativo | `-5` | `'?'` | Entrada fuera de rango |
| Error desborde | `105` | `'?'` | Entrada superior al máximo |

---

(ej_b1_c02_08)=
## Ejercicio 1.02.08 - Triángulo Válido ⭐⭐⭐☆☆

Dados tres lados, determiná si forman un triángulo válido y qué tipo es
(equilátero, isósceles, escaleno).

**Orientación:**
- Para ser válido: a + b > c, a + c > b, b + c > a
- Equilátero: los tres lados iguales
- Isósceles: dos lados iguales
- Escaleno: todos diferentes

:::{hint} Lógica y Consideraciones
valores fuera de rango o tipos inválidos.
    un lazo hasta que el usuario elija finalizar.

MENÚ PRINCIPAL
1. Calculadora
   1.1. Básica
   1.2. Científica
2. Conversiones
   2.1. Temperatura
   2.2. Distancia
3. Salir