Sesión 6: Arreglos/Listas + reportes iterativos

Guardar datos para analizarlos: ciclos + almacenamiento (C#)

Navegación: ← → | Home End | F pantalla completa · Mouse: botones · Touch: swipe

Plan de trabajo

0–10 · Puente: ciclos, contadores y acumuladores (C#).
10–30 · ¿Por qué guardar datos? (cuando el reporte requiere más que “sumar”).
30–55 · Arreglos en C#: qué son, cómo se usan y errores típicos.
55–70 · Listas (List<T>): cuándo convienen.
70–105 · Ejemplo guiado: almacenar N consumos y generar reporte completo.
105–115 · Taller: adaptar el ejemplo al escenario del proyecto (Entrega 2).
115–120 · Exit ticket.

Esta sesión avanza la Unidad 2 reforzando iteración y sumando “estructuras para almacenamiento de datos” y operaciones sobre ellas para generar reportes.

Lo que ya dominamos

for: cuando sabemos N (cantidad de iteraciones).
while: cuando repetimos hasta una condición o centinela.
Contador: “cuántos cumplen…”.
Acumulador: “cuánto llevo…”.
Traza: evidencia de que el ciclo hace lo correcto.

Pregunta guía:

Si ya puedes calcular total y conteos “al vuelo”, ¿por qué guardarías los datos? Porque a veces el reporte necesita revisar valores después: máximos/mínimos, listas filtradas, ordenar, buscar o reimprimir.

Dos enfoques

Hoy practicamos el enfoque B porque prepara el camino para operaciones sobre estructuras.

Cuándo necesitas guardar

Cuando debes imprimir “los que cumplen condición” (lista filtrada).
Cuando el cálculo requiere revisar el conjunto más de una vez.
Cuando necesitas máximo/mínimo con su posición (índice).
Cuando quieres comparar el valor actual con uno anterior (series).

Lo importante para lógica: tu ciclo sigue existiendo, pero ahora además controlas un índice (posición) y respetas los límites del arreglo.

Arreglo (array)

Un arreglo es un conjunto de N elementos del mismo tipo, con posiciones numeradas desde 0 hasta N-1.

Su tamaño se define al crearlo.
Accedes por índice: datos[i].
Tiene longitud: datos.Length.

Error típico: intentar acceder a datos[N] (eso está fuera del arreglo).

Ejemplo en C#

int N = 5; decimal[] consumos = new decimal[N]; consumos[0] = 120m; consumos[1] = 250m; // Recorrer: for (int i = 0; i < consumos.Length; i++) { Console.WriteLine($"Consumo {i} = {consumos[i]}"); }

Observa que el for usa i = 0 y condición i < Length para garantizar límites.

List<T>

Una lista se parece a un arreglo, pero puede crecer dinámicamente. Es útil cuando no conoces N al inicio o cuando quieres ir agregando datos.

Agregas con Add(valor).
Longitud con Count.
Acceso por índice: lista[i].

Ejemplo con centinela

var datos = new List(); while (true) { decimal x = LeerDecimal("Consumo (-1 para terminar): "); if (x == -1m) break; datos.Add(x); } Console.WriteLine($"Se guardaron {datos.Count} consumos.");

Luego puedes recorrer la lista para generar el reporte.

Guardar N consumos y generar reporte

Enunciado: leer N consumos (kWh), guardarlos y calcular: total, promedio (si N>0), máximo, mínimo y cuántos son > 200.

Código (C# consola)

using System; using System.Collections.Generic; class Program { static void Main() { int N = LeerEntero("N (cantidad de consumos): "); // Almacenamiento decimal[] consumos = new decimal[N]; // 1) Lectura y guardado for (int i = 0; i < N; i++) { consumos[i] = LeerDecimal($"Consumo {i+1} (kWh): "); } // 2) Cálculos decimal total = 0m; int mayores200 = 0; decimal max = 0m, min = 0m; bool hayDatos = false; for (int i = 0; i < N; i++) { decimal c = consumos[i]; total += c; if (c > 200m) mayores200++; if (!hayDatos) { max = c; min = c; hayDatos = true; } else { if (c > max) max = c; if (c < min) min = c; } } // 3) Salida Console.WriteLine($"Total: {total}"); Console.WriteLine($">200: {mayores200}"); if (N > 0) { decimal promedio = total / N; Console.WriteLine($"Promedio: {promedio}"); Console.WriteLine($"Máximo: {max}"); Console.WriteLine($"Mínimo: {min}"); } else { Console.WriteLine("N=0: no hay consumos, no se calcula promedio/max/min."); } } static int LeerEntero(string mensaje) { while (true) { Console.Write(mensaje); string s = Console.ReadLine() ?? ""; if (int.TryParse(s, out int n) && n >= 0) return n; Console.WriteLine("Entrada inválida. Debe ser entero >= 0."); } } static decimal LeerDecimal(string mensaje) { while (true) { Console.Write(mensaje); string s = Console.ReadLine() ?? ""; if (decimal.TryParse(s, out decimal x)) return x; Console.WriteLine("Entrada inválida. Debe ser numérica."); } } }

Diagrama de flujo (resumen)

El punto didáctico: separas “capturar” de “analizar”. Esto ayuda a depurar.

Casos de prueba mínimos

Normal: N=4; consumos: 100, 250, 200, 300.
Borde: N=0 (sin datos).
Borde de umbral: consumo=200 exacto (no cuenta como >200).

Si el estudiante no puede explicar un caso borde, el algoritmo no está completamente justificado.

Traza (iteración de cálculo)

i	c	total	>200	max	min
0	100	100	0	100	100
1	250	350	1	250	100
2	200	550	1	250	100
3	300	850	2	300	100

Esta es la evidencia esperada para sustentar el cálculo del reporte.

Objetivo

Tomar el ejemplo de consumos y adaptarlo al escenario del Proyecto — Entrega 2 (Unidad 2). Debe incluir: ciclo(s), almacenamiento (array o List), y reporte verificable.

Define el dominio (notas, ventas, sensores, tiempos de producción, etc.).
Define N o centinela.
Define mínimo 4 salidas: total, promedio (si aplica), un conteo por regla y max/min.

Entregable en clase (evidencia rápida):

IPO en 5 líneas (entradas, proceso, salidas).
Variables: lista de contadores/acumuladores y su significado.
2 casos de prueba: normal + borde.
1 traza corta (2–3 iteraciones) del ciclo de cálculo.

Checklist para revisar tu entrega

Lógica y estructura

El ciclo termina (progreso claro, sin infinitos).
Contadores/acumuladores están inicializados y actualizados en el lugar correcto.
Si usas arreglo: índices dentro de 0..N-1.
Si N=0: el programa no falla y responde coherente.

Evidencia

Incluyes 2 pruebas (normal + borde).
Incluyes traza de 2–3 iteraciones (variables clave).
Resultados coherentes (sanity check: ¿tiene sentido el total/promedio?).
Lectura robusta (TryParse) al menos para N (recomendado).

Este checklist conecta lo visto hoy con los criterios de calidad esperados en la Unidad 2.

Arreglos

IndexOutOfRange: usar i <= Length o acceder a consumos[N].
Confundir “posición” con “número”: consumos[i+1] sin razón.
Inicializar max/min sin controlar el caso N=0.

Entrada y números

Usar Parse sin validar (el programa se cae ante entradas inválidas).
Separador decimal (punto/coma) depende del sistema del estudiante.
Promedio con división por cero si N=0.

Responde individualmente

¿Qué ventaja te da guardar datos en un arreglo/lista en vez de solo acumular “al vuelo”?
¿Cuál es el rango válido de índices para un arreglo de tamaño N?
Propón 1 caso borde para tu Proyecto — Entrega 2 y explica qué valida.

Próximo paso: preparar el terreno para programación modular (Unidad 3), extrayendo funciones para lectura/validación y para cálculos del reporte.

Navegación: ← → | Home End | F · Botones · Swipe

Actividad final: reporte con almacenamiento

Elige un contexto (notas, ventas, sensores, tiempos de producción, etc.) y construye un programa en C# que:

Lea datos repetidos (con N o con centinela).
Guarde todos los valores en un arreglo o en una lista.
Genere un reporte con: total, promedio (si hay datos), un conteo por regla y max/min.
Incluya 2 casos de prueba (normal + borde) y una traza corta del ciclo de cálculo.

En la socialización, tu evidencia principal será la traza y la justificación de variables (qué cuenta y qué acumula).

Checklist de entrega (mínimo):

IPO (5 líneas).
Lista de variables: contadores/acumuladores y significado.
Reporte final impreso con resultados.
Traza (2–3 iteraciones) + 2 pruebas.

Fecha: [Pendiente en la planeación]