Skip to article frontmatterSkip to article content
Site not loading correctly?

This may be due to an incorrect BASE_URL configuration. See the MyST Documentation for reference.

Repositorio de enunciados

Universidad Nacional de Río Negro

Repositorio Integral de Ejercicios de Programación 1

Este repositorio constituye la base pedagógica práctica de la asignatura Programación 1 (UNRN). Su diseño implementa un modelo de aprendizaje andamiado (scaffolded learning) y progresión gradual según la Taxonomía de Bloom Revisada, guiando al estudiante desde la sintaxis básica hasta la ingeniería de software y tipos abstractos en C11.

Requisitos Previos y Entorno de Ejecución

Enfoque Metodológico Formativo y Casos Límite

Cada ejercicio articula cuatro fases de dominio cognitivo:

  1. Contratos Formales: Precondiciones, postcondiciones e invariantes explícitas.

  2. Modularización Pura: Descomposición en funciones sin variables globales ni efectos colaterales.

  3. Casos Borde y Manejo de Errores: Validación defensiva ante punteros NULL, valores frontera (0, NULL, tamaños vacíos) y prevención estricta de división por cero o desbordamientos.

  4. Vectores de Prueba: Pruebas sistemáticas automatizadas en main(void) con macro assert(...).

  5. Higiene de Memoria: Cero fugas en el Heap, verificación con sanitizers y ausencia de dobles liberaciones.

Flujo de Trabajo y Verificación Rápida

¿Y las prácticas?

Esta colección complementa las guías obligatorias de la cátedra para consolidar el aprendizaje autónomo mediante problemas graduados.

Consideraciones Generales

A seguir siempre y cuando no esté indicada otra cosa:

  1. Resuelvan todos los ejercicios de manera iterativa, a no ser que esté indicado puntualmente.

  2. Los números son números enteros, estos incluyen al cero y los negativos.

  3. El nombre del archivo debe ser, el número del ejercicio reemplazando el punto por un guion y su apellido, por ejemplo: 1-1_apellido.c.

  4. Apliquen y completen la plantilla de resolución de ejercicios que está a continuación, copiando el título y consigna del ejercicio y luego completando con sus datos.

  5. Lo que “resuelve” el enunciado debe estar encapsulado en una función, incluso si no está indicado explícitamente.

  6. El código debe seguir estrictamente el catálogo de reglas de estilo de la cátedra.

  7. Los ejercicios marcados como [plus ultra] son variaciones del ejercicio para ir «más allá» de la consigna original.

Plantilla de Archivo y Ejemplo de Referencia

Cada entrega individual debe estructurarse mediante funciones puras, modularización y un conjunto exhaustivo de pruebas en main(void). A continuación se presenta la plantilla estándar de resolución canónica (1-1_apellido.c):

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
/*
===============================================================================
Cátedra de Programación 1 - Universidad Nacional de Río Negro
Ejercicio 1.01.01 - Ejemplo de Estructura Canónica
Consigna: Implementar una función pura que valide si un entero es par.
Autor: Alumno Ejemplo
GitHub: @alumno-unrn
===============================================================================
*/

#include <assert.h>
#include <stdbool.h>
#include <stdio.h>

/**
 * @brief Determina si un número entero es par.
 * @param n Número entero de entrada.
 * @return true si n es divisible por 2, false en caso contrario.
 */
bool es_par(int n)
{
    return (n % 2 == 0);
}

int main(void)
{
    /* Casos de prueba exhaustivos */
    assert(es_par(0) == true);
    assert(es_par(2) == true);
    assert(es_par(-4) == true);
    assert(es_par(1) == false);
    assert(es_par(-7) == false);

    printf("Todos los vectores de prueba superados con éxito.\n");
    return 0;
}

Niveles de Dificultad

Todos los ejercicios se encuentran clasificados con la etiqueta **Dificultad:** según su nivel de complejidad:

Consignas Plus Ultra

Cada ejercicio incluye consignas opcionales marcadas como [*plus ultra*] (frase en latín que significa «más allá»). Estas consignas están diseñadas para ir más allá de la consigna base y profundizar el aprendizaje mediante:

Guía Metodológica de Andamiaje Pedagógico (Scaffolded Learning)

Para asegurar una progresión cognitiva sólida desde los fundamentos sintácticos hasta la creación de arquitecturas complejas de software, recomendamos abordar cada problema aplicando un proceso estructurado en cuatro etapas consecutivas:

1. Descomposición y Contratos Formales (Nivel Bloom 1-2: Recordar y Comprender)

2. Implementación Modular Pura (Nivel Bloom 3: Aplicar)

3. Construcción Sistemática de Vectores de Prueba (Nivel Bloom 4: Analizar)

Antes de dar por concluida la implementación, elaborá una tabla de pruebas exhaustiva que contemple cuatro familias críticas de vectores:

4. Auditoría y Verificación Estricta (Nivel Bloom 5-6: Evaluar y Crear)

Estructura de Ejercicios por Bloques

Los ejercicios se organizan replicando los bloques didácticos de los apuntes para guiar tu proceso de aprendizaje de manera progresiva.

Bloque 1: Fundamentos del Control de Flujo y Modularización

Ejercicios iniciales para asimilar la lógica de programación, el uso de variables, condicionales, lazos iterativos, modularización mediante funciones, recursividad introductoria y compilación con Makefiles.

Bloque 2: Memoria

Ejercicios enfocados en la disposición física de datos en RAM, punteros e indirección, cadenas de caracteres, persistencia en archivos de texto, memoria dinámica en el Heap, estructuras compuestas, alias de tipos y enumeraciones.

Bloque 3: Algoritmos y Estructuras de Datos

Ejercicios sobre matrices multidimensionales, Tipos de Datos Abstractos (TAD), estructuras lineales (listas, pilas, colas) y análisis asintótico de complejidad.

Bloque 4: Temas Avanzados

Ejercicios de nivel avanzado sobre callbacks, operaciones bitwise, archivos binarios, recursividad avanzada, búsqueda/ordenamiento, análisis de código y diseño de APIs.

Matriz Pedagógica y Resultados de Aprendizaje

El plan formativo de la cátedra articula las competencias según la Taxonomía de Bloom Revisada:

Bloque TemáticoNivel Cognitivo PrincipalCompetencia AdquiridaEvidencia Evaluativa
Bloque 1: FundamentosNivel 1 (Recordar) a Nivel 3 (Aplicar)Control de flujo, descomposición algorítmica modular y compilación limpiaProgramas compilables con 0 warnings bajo C11
Bloque 2: MemoriaNivel 3 (Aplicar) a Nivel 4 (Analizar)Gestión del direccionamiento físico, aritmética de punteros y Heap seguroCero fugas de memoria con ASan y Valgrind
Bloque 3: AlgoritmosNivel 4 (Analizar) a Nivel 5 (Evaluar)Abstracción con Tipos Opacos (TADs) y medición de complejidad temporal/espacialInstrumentación empírica y contrastación Big-O
Bloque 4: AvanzadosNivel 5 (Evaluar) a Nivel 6 (Crear)Diseño de APIs seguras, callbacks de orden superior y persistencia binariaArquitecturas basadas en handles y FSM

Verificación Automatizada y Entorno de Pruebas

Toda solución debe validarse localmente antes de integrarse al repositorio mediante el arnés de verificación institucional:

1. Verificación Estructural y de Reglas de Calidad

Comprueba que los bloques {exercise}, tablas de prueba obligatorias y soluciones {solution} cumplan con el estándar de documentación:

node ejercicios/verificar_calidad.mjs

2. Extracción, Compilación C11 y Ejecución de Aserciones

Extrae automáticamente los bloques de código C, invoca a gcc bajo directivas estrictas y ejecuta las aserciones de prueba en un entorno seguro:

node ejercicios/verificar_ejercicios.mjs

Banderas de Compilación Requeridas:

gcc -Wall -Wextra -Werror -pedantic -std=c11 solucion.c -o solucion

3. Criterio de Aceptación Institucional

Una entrega o solución se considera aprobada únicamente cuando:

  1. Compila con cero advertencias (0 warnings) y cero errores.

  2. Todas las aserciones assert(...) del main(void) retornan con código de salida 0.

  3. No existen accesos fuera de límites (out-of-bounds) ni dobles liberaciones (double-free).

  4. El mensaje de commit respeta la convención de commits semánticos (Conventional Commits).

5. Evaluación y Gestión Docente
Manual de Referencia: weyl
Bloque 1: Fundamentos
1. Básicos