Claude/new session 2o7hte

prisma/content/courses/csharp-poo-1/index.ts

@@ -1,49 +1,61 @@
-// =====================================================================
-// Paquete de curso: Programación Orientada a Objetos I con C#.
-//
-// Legacy: las 8 unidades y los 8 sets de práctica siguen viviendo en
-// `prisma/content/csharp/unidad-*.ts` y
-// `prisma/content/exercises/csharp/u*.ts` — NO se movieron ni se
-// editaron. Aquí sólo se reutilizan y se pasan por `adaptLegacyUnits` +
-// `defineCourse` para entrar a la misma capa de authoring que los cursos
-// nuevos.
-//
-// Segundo caso de `curriculum`, deliberadamente distinto de C++: UNA sola
-// sección (3.er semestre) que envuelve las 8 unidades existentes tal
-// cual, en su mismo orden. Demuestra que la agrupación curricular no está
-// hardcodeada para C++ ni para dos semestres.
-// =====================================================================
-
 import { adaptLegacyUnits, defineCourse } from "../../authoring";
 import { cursoCsharpPoo1 } from "../../csharp";
 import { csharpPracticeSets } from "../../exercises/csharp";
 
-const authoredUnits = adaptLegacyUnits(cursoCsharpPoo1, csharpPracticeSets);
+import { csharpPoo2Colecciones } from "./units/09-colecciones";
+import { csharpPoo2Diccionarios } from "./units/10-diccionarios";
+import { csharpPoo2Ordenamiento } from "./units/11-ordenamiento";
+import { csharpPoo2Xml } from "./units/12-xml";
+import { csharpPoo2Genericos } from "./units/13-genericos";
+import { csharpPoo2Concurrencia } from "./units/14-concurrencia";
+import { csharpPoo2Redes } from "./units/15-redes";
+import { csharpPoo2Integrador } from "./units/16-integrador";
+
+// =====================================================================
+// Paquete de curso: Programación Orientada a Objetos con C#.
+//
+// S3 (legacy): las 8 unidades y los 8 sets de práctica de POO I siguen
+// viviendo en `prisma/content/csharp/unidad-*.ts` y
+// `prisma/content/exercises/csharp/u*.ts` — NO se movieron ni se editaron.
+// Aquí sólo se reutilizan vía `adaptLegacyUnits`.
+//
+// S4 (nueva, POO II): capa de authoring completa, colocalizada por unidad
+// bajo `./units/`. Las 8 unidades entran con `published: false` — el
+// release gate de S4 es una tarea posterior.
+// =====================================================================
 
-const {
-  slug,
-  title,
-  description,
-  subjectName,
-  academicContext,
-  language,
-  executionProfile,
-} = cursoCsharpPoo1;
+const authoredUnitsS3 = adaptLegacyUnits(cursoCsharpPoo1, csharpPracticeSets);
 
 export const csharpPoo1 = defineCourse({
-  slug,
-  title,
-  description,
-  subjectName,
-  academicContext,
-  language,
-  executionProfile,
+  slug: "csharp-poo-1",
+  title: "Programación Orientada a Objetos con C#",
+  description:
+    "Modela, implementa y conecta aplicaciones orientadas a objetos en C#, desde clases y relaciones hasta colecciones, persistencia, concurrencia y redes.",
+  subjectName: "Programación Orientada a Objetos",
+  academicContext: "CETI · Tecnólogo en Desarrollo de Software",
+  language: cursoCsharpPoo1.language,
+  executionProfile: cursoCsharpPoo1.executionProfile,
   curriculum: [
     {
       key: "s3-programacion-orientada-objetos-1",
       semester: 3,
       subjectName: "Programación Orientada a Objetos I",
-      units: authoredUnits,
+      units: authoredUnitsS3,
+    },
+    {
+      key: "s4-programacion-orientada-objetos-2",
+      semester: 4,
+      subjectName: "Programación Orientada a Objetos II",
+      units: [
+        csharpPoo2Colecciones,
+        csharpPoo2Diccionarios,
+        csharpPoo2Ordenamiento,
+        csharpPoo2Xml,
+        csharpPoo2Genericos,
+        csharpPoo2Concurrencia,
+        csharpPoo2Redes,
+        csharpPoo2Integrador,
+      ],
     },
   ],
 });

prisma/content/courses/csharp-poo-1/units/09-colecciones/index.ts

@@ -0,0 +1,20 @@
+import { defineUnit } from "../../../../authoring";
+
+import { leccion01 } from "./lessons/01-de-arreglos-a-colecciones";
+import { leccion02 } from "./lessons/02-list-de-objetos";
+import { leccion03 } from "./lessons/03-stack-y-queue";
+import { leccion04 } from "./lessons/04-agregar-buscar-eliminar";
+import { leccion05 } from "./lessons/05-inventario-en-memoria";
+
+import { practice } from "./practice";
+
+export const csharpPoo2Colecciones = defineUnit({
+  slug: "csharp-poo2-01-colecciones",
+  title: "Colecciones y estructuras lineales",
+  description:
+    "Sustituye arreglos de tamaño fijo por colecciones dinámicas y elige entre lista, pila y cola según la operación del problema.",
+  icon: "📚",
+  published: false,
+  lessons: [leccion01, leccion02, leccion03, leccion04, leccion05],
+  practice,
+});

prisma/content/courses/csharp-poo-1/units/09-colecciones/lessons/01-de-arreglos-a-colecciones.ts

@@ -0,0 +1,139 @@
+import { defineLesson } from "../../../../../authoring";
+
+export const leccion01 = defineLesson({
+  slug: "de-arreglos-a-colecciones",
+  title: "De arreglos fijos a colecciones",
+  description:
+    "Reconoce cuándo el tamaño fijo de un arreglo deja de representar bien un conjunto de objetos.",
+  estimatedMinutes: 13,
+  xpReward: 45,
+  steps: [
+    {
+      type: "theory",
+      markdown: `# El problema no es el arreglo: es conocer el tamaño de antemano
+
+Un arreglo funciona muy bien cuando la cantidad de elementos está definida desde el inicio. Si declaras \`Producto[] productos = new Producto[20]\`, reservaste exactamente veinte lugares.
+
+En un inventario real normalmente no sabes cuántos productos existirán mañana. Puedes llenar el arreglo, dejar huecos o copiar todo a uno más grande, pero entonces empiezas a programar manualmente el crecimiento de una estructura que debería ayudarte a resolver el problema.
+
+Una **colección dinámica** separa dos ideas:
+
+- cuántos elementos existen ahora;
+- cuánta memoria necesita internamente para guardarlos.
+
+En C#, \`List<T>\` representa una secuencia cuyo tamaño puede crecer o disminuir. \`T\` indica qué tipo de elementos admite: \`List<int>\`, \`List<string>\`, \`List<Producto>\`.
+
+No reemplaza a todos los arreglos. Si el tamaño es fijo por naturaleza, un arreglo sigue siendo una opción válida. La elección depende del problema.`,
+    },
+    {
+      type: "code_example",
+      code: `using System;
+using System.Collections.Generic;
+
+class Program
+{
+    static void Main()
+    {
+        List<string> productos = new List<string>();
+
+        productos.Add("Mouse");
+        productos.Add("Teclado");
+        productos.Add("Monitor");
+
+        Console.WriteLine("Cantidad: " + productos.Count);
+        Console.WriteLine(productos[1]);
+    }
+}`,
+      explanation:
+        "`Add` incorpora un elemento sin que el programa tenga que calcular un nuevo tamaño. `Count` es la cantidad real de elementos y el acceso por índice conserva la idea conocida de los arreglos.",
+      runnable: true,
+      expectedOutput: `Cantidad: 3
+Teclado`,
+    },
+    {
+      type: "matching",
+      pairs: [
+        { left: "Producto[30]", right: "Cantidad máxima conocida de antemano." },
+        {
+          left: "List<Producto>",
+          right: "Cantidad de objetos que puede crecer o disminuir.",
+        },
+        { left: "Count", right: "Cantidad actual de elementos." },
+        { left: "Add", right: "Agrega un elemento al final." },
+      ],
+      explanation:
+        "Una colección dinámica no elimina los índices; elimina la obligación de fijar el tamaño útil antes de conocer los datos.",
+    },
+    {
+      type: "code_challenge",
+      exercise: {
+        prompt:
+          "Lee `n`, después `n` enteros. Guarda todos los valores en un `List<int>`. Al final imprime primero `Cantidad: X` y después `Suma: Y`.\n\nNo calcules la cantidad con una variable paralela: usa `Count` de la lista.",
+        starterCode: `using System;
+using System.Collections.Generic;
+
+class Program
+{
+    static void Main()
+    {
+        int n = int.Parse(Console.ReadLine());
+        List<int> valores = new List<int>();
+
+        // agrega los n valores
+
+        // imprime Count y la suma
+    }
+}`,
+        solutionCode: `using System;
+using System.Collections.Generic;
+
+class Program
+{
+    static void Main()
+    {
+        int n = int.Parse(Console.ReadLine());
+        List<int> valores = new List<int>();
+
+        for (int i = 0; i < n; i++)
+        {
+            valores.Add(int.Parse(Console.ReadLine()));
+        }
+
+        int suma = 0;
+        for (int i = 0; i < valores.Count; i++)
+        {
+            suma += valores[i];
+        }
+
+        Console.WriteLine("Cantidad: " + valores.Count);
+        Console.WriteLine("Suma: " + suma);
+    }
+}`,
+        hints: [
+          "Crea `new List<int>()` una sola vez.",
+          "Usa `Add` dentro del primer `for`.",
+          "El segundo recorrido debe terminar en `valores.Count`.",
+        ],
+        difficulty: "easy",
+        xpReward: 24,
+        testCases: [
+          {
+            visible: true,
+            stdin: "3\n4\n5\n6\n",
+            expectedStdout: "Cantidad: 3\nSuma: 15\n",
+          },
+          {
+            visible: false,
+            stdin: "1\n-7\n",
+            expectedStdout: "Cantidad: 1\nSuma: -7\n",
+          },
+          {
+            visible: false,
+            stdin: "5\n0\n2\n0\n8\n-3\n",
+            expectedStdout: "Cantidad: 5\nSuma: 7\n",
+          },
+        ],
+      },
+    },
+  ],
+});