Repositorio de enunciados

¿Y las prácticas?¶

La idea de esta sección, como algo separado a las prácticas obligatorias de la cátedra, es que dispongas de una colección amplia de problemas complementarios para consolidar el aprendizaje. Las prácticas de la cátedra siguen un régimen de entrega formal con plazos estrictos y verificación automatizada de estilo y corrección.

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 la guía de estilo.

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

Plantilla de archivo¶

En un archivo llamado 1-1_apellido.c:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
/*
Ejercicio 1.1 – Hola Mundo
Escribir un programa que imprima "Hola, mundo!" en la pantalla.
Este ejercicio nos permitirá verificar que el entorno de programación funciona.
-----------------
Nombre y Apellido
Usuario Github
*/

// prototipos

// main

// implementaciones

Niveles de Dificultad¶

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

• ⭐☆☆☆☆ - Básico: Aplicación directa de 1-2 conceptos fundamentales.

• ⭐⭐☆☆☆ - Fácil: Combina 2-3 conceptos simples o estructuras elementales.

• ⭐⭐⭐☆☆ - Intermedio: Requiere diseño algorítmico o manejo de datos.

• ⭐⭐⭐⭐☆ - Avanzado: Múltiples conceptos integrados, indirección o optimización.

• ⭐⭐⭐⭐⭐ - Experto: Problemas complejos de arquitectura o algoritmos avanzados.

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:

• Validación y Casos de Borde: Manejo robusto de errores, valores límite y prevención de comportamientos indefinidos.

• Optimización y Rendimiento: Mejora en el uso de memoria, tiempo de ejecución y eficiencia algorítmica.

• Extensión y Abstracción: Generalización de soluciones, diseño de interfaces reutilizables o soporte para nuevas funcionalidades.

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.

• 1. Básicos y Secuencias: Ejercicios introductorios para familiarizarse con la sintaxis de C, variables y lógica secuencial.

• 2. C Gradual: Ejercicios simples de traducción y asimilación gradual de sintaxis en C.

• 3. Algoritmos Matemáticos: Problemas centrados en teoría de números (primos, MCD, potencias y secuencias lógicas).

• 5. Control de Flujo y Lazos: Ejercicios de bifurcaciones condicionales y estructuras de repetición seguras.

• 6. Modularización y Funciones: Ejercicios para estructurar subprogramas mediante firmas, parámetros y deconstrucción funcional.

• 7. Librerías de Funciones: Ejercicios centrados en el diseño, encapsulamiento e implementación de módulos reutilizables .h y .c.

• 8. Compilación y Makefiles: Ejercicios sobre las etapas de compilación, enlazado físico y automatización de la construcción con make.

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.

• 1. Punteros e Indirección: Ejercicios para afianzar el uso de punteros, operador de dirección & e indirección *.

• 1b. Punteros y Ejercicios de Referencia: Ejercicios de paso por referencia simulado y manipulación de memoria.

• 2. Arreglos Unidimensionales: Manipulación de arreglos estáticos de tamaño fijo, búsqueda y estadísticas.

• 2b. Cadenas de Caracteres (Strings): Operaciones sobre strings de estilo C y su terminador nulo \0.

• 3. Persistencia y Archivos de Texto: Lectura y escritura persistente de archivos formateados mediante streams.

• 3b. Ejercicios Adicionales de Archivos: Ejercicios de manipulación de flujos de texto complejos.

• 4. Memoria Dinámica Básica: Asignación con malloc, calloc y liberación correcta con free.

• 4b. Memoria Dinámica Avanzada: Detección de fugas de memoria, address sanitizers y análisis físico de fragmentación del heap.

• 4c. Ejercicios Auxiliares de Memoria: Ejercicios adicionales sobre alocación segura de recursos.

• 5. Aritmética de Punteros y Indirección: Ejercicios sobre doble indirección y bloques contiguos de memoria.

• 6. Estructuras Compuestas (structs): Modelado lógico y disposición en memoria física de registros y uniones.

• 7. Alias de Tipos y Proyectos: Uso de typedef para modelar y portar tipos.

• 8. Tipos Enumerativos (enums): Ejercicios sobre enumeraciones y modelado de estados lógicos seguros.

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.

• 1. Matrices Multidimensionales: Disposición Row-Major en RAM y manipulación de arreglos bidimensionales.

• 2. Tipos Abstractos de Datos (TAD): Encapsulamiento estricto e interfaces de TADs empleando tipos incompletos y punteros opacos.

• 3. Estructuras de Datos Lineales: Implementación de listas enlazadas, pilas y colas dinámicas.

• 4. Análisis de Complejidad: Ejercicios teóricos y empíricos sobre notación asintótica Big-O, límites de hardware y Teorema Maestro.

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.

• 1. Punteros Avanzados y Callbacks: Punteros a funciones y diseño genérico parametrizado.

• 2. Operaciones con Bits (Bitwise): Manipulación de banderas a bajo nivel y operadores a nivel de bits.

• 3. Archivos Binarios: Lectura, escritura y procesamiento físico de archivos estructurados en formato binario.

• 4. Recursividad Avanzada: Algoritmos de backtracking, divide y conquista y memoización dinámica.

• 5. Búsqueda y Ordenamiento Avanzado: Algoritmos eficientes de ordenamiento por comparación y búsqueda no lineal.

• 6. Análisis y Debugging de Código: Lectura, comprensión formal y depuración de bases de código heredadas.

• 7. Diseño Profesional de APIs: Principios arquitectónicos de claridad, minimalismo, ocultamiento, versionado e ingeniería de APIs en C.