1.04 · Pseudocódigo y Diagramas de Flujo (PSeInt + draw.io)

🎯 Objetivo de aprendizaje

Al terminar este tema vas a poder:

1. Escribir pseudocódigo con sintaxis correcta usando las palabras clave estándar (INICIO, FIN, LEER, ESCRIBIR, SI-ENTONCES-SINO, MIENTRAS, PARA, SEGÚN).
2. Ejecutar pseudocódigo en PSeInt (editor gratuito que interpreta pseudocódigo en español) y depurar errores lógicos.
3. Dibujar diagramas de flujo con la simbología estándar ANSI/ISO para representar algoritmos visualmente.
4. Usar draw.io (editor gratuito) para crear diagramas de flujo profesionales exportables a PNG, PDF y SVG.
5. Convertir un mismo algoritmo entre pseudocódigo, diagrama de flujo y diagrama N-S (las 3 representaciones deben ser equivalentes).
6. Aplicar PSeInt y draw.io a 5 problemas propios del LAB 1.3, verificando que las 3 representaciones producen el mismo resultado.

Este tema es el último sin código real. El Tema 1.5 introduce variables y tipos de datos. El Tema 1.7 ya es código en C++/Java/Python. Pero antes, la representación visual del algoritmo.

🧠 Teoría y conceptos — 1.4.1 — Pseudocódigo: sintaxis, palabras clave y convenciones

Qué es exactamente el pseudocódigo

El pseudocódigo es una forma de escribir algoritmos usando palabras en lenguaje natural (en este curso, en español) pero imitando la estructura de un programa real. No es un lenguaje que la computadora entienda: es un lenguaje para que los humanos se entiendan entre sí (y consigo mismos) sobre lo que el algoritmo hace.

Características:

Las 10 palabras clave que vas a usar

Hay muchas convenciones de pseudocódigo. En este curso usamos la convención de PSeInt (que es la más popular en universidades latinoamericanas), con adaptaciones propias:

Reglas de sintaxis del pseudocódigo

1. Las palabras clave van en MAYÚSCULAS.

✅ INICIO

❌ inicio

❌ Inicio

1. Los mensajes al usuario van entre comillas.

✅ ESCRIBIR "Ingresa tu edad"

❌ ESCRIBIR Ingresa tu edad

1. Las variables NO van entre comillas.

✅ ESCRIBIR "Tu edad es: " + edad

❌ ESCRIBIR "Tu edad es: " + "edad"

1. Las asignaciones usan el signo `=`.

✅ promedio = suma / N

❌ promedio := suma / N (esto es Pascal, no pseudocódigo estándar)

1. Las comparaciones usan `==` para igualdad y `!=` para diferencia.

✅ SI edad == 18 ENTONCES

❌ SI edad = 18 ENTONCES (esto es asignación, no comparación)

1. La indentación (sangría) es OBLIGATORIA para mostrar estructura.

✅ SI edad >= 18 ENTONCES

ESCRIBIR "Mayor de edad"

SINO

ESCRIBIR "Menor de edad"

FIN SI

*7. Los comentarios se ponen con `//` o `/ ... /`.*

// Esto es un comentario de una línea

/* Esto es un comentario

de varias líneas */

Ejemplo completo: algoritmo "Determinar si un número es positivo, negativo o cero"

INICIO

// Entrada

ESCRIBIR "Ingresa un número:"

LEER n

// Proceso + Salida

SI n > 0 ENTONCES

ESCRIBIR n + " es positivo"

SINO SI n < 0 ENTONCES

ESCRIBIR n + " es negativo"

SINO

ESCRIBIR n + " es cero"

FIN SI

FIN

El mismo algoritmo en 3 estilos de pseudocódigo

Estilo 1 — PSeInt (que vamos a usar):

INICIO

LEER n

SI n > 0 ENTONCES

ESCRIBIR "positivo"

SINO

SI n < 0 ENTONCES

ESCRIBIR "negativo"

SINO

ESCRIBIR "cero"

FIN SI

FIN SI

FIN

Estilo 2 — Español estructurado (sin sangría):

INICIO

LEER n

SI n > 0 ENTONCES ESCRIBIR "positivo" SINO

SI n < 0 ENTONCES ESCRIBIR "negativo" SINO ESCRIBIR "cero" FIN_SI

FIN_SI

FIN

Estilo 3 — Español "tipo Pascal":

Programa Numero

Var

n: Entero

Inicio

Leer(n);

Si n > 0 Entonces

Escribir('positivo')

Sino

Si n < 0 Entonces

Escribir('negativo')

Sino

Escribir('cero')

FinSi

FinSi

Fin.

Todos son equivalentes. En este curso usaremos el Estilo 1 (PSeInt) por ser el más claro y porque es el que PSeInt ejecuta directamente.

1.4.2 — PSeInt: instalación, interfaz y ejecución paso a paso

Qué es PSeInt

PSeInt (abreviatura de PSeudocódigo Intérprete) es un editor gratuito de pseudocódigo que además lo ejecuta, mostrando paso a paso lo que pasa con las variables. Es la herramienta estándar en universidades de Latinoamérica para enseñar algoritmia.

Características:

• Gratis y libre (licencia GPL).
• En español: las palabras clave son en español (LEER, ESCRIBIR, etc.).
• Multiplataforma: Windows, Mac, Linux.
• Ejecuta el pseudocódigo: no solo lo escribe, lo corre.
• Modo paso a paso: muestra el estado de las variables en cada línea.
• Exporta a C++, Java, Python: traduce tu pseudocódigo a código real.

Cómo instalar PSeInt (Windows)

Paso 1: Abre tu navegador y ve a [https://pseint.sourceforge.net/](https://pseint.sourceforge.net/).

Paso 2: En la página principal, busca el botón "Descargar" y haz clic.

Paso 3: Selecciona la versión para Windows (pseint-win64-xxx.exe o similar). El archivo pesa alrededor de 30-40 MB.

Paso 4: Ejecuta el instalador descargado. Acepta los términos, deja la carpeta por defecto (C:\Program Files\PSeInt) y haz clic en "Instalar".

Paso 5: Al terminar, abre PSeInt desde el menú Inicio o el acceso directo en el escritorio.

La interfaz de PSeInt

Al abrir PSeInt verás 3 áreas principales:

┌─────────────────────────────────────────────────────────┐

│ Barra de menú (Archivo, Editar, Ejecutar, etc.) │

├──────────┬──────────────────────────┬───────────────────┤

│ │ │ │

│ Panel de │ Editor de código │ Panel de salida │

│ comandos │ (aquí escribes) │ (resultados) │

│ (atajos) │ │ │

│ │ │ │

└──────────┴──────────────────────────┴───────────────────┘

• Panel de comandos (izquierda): atajos para insertar estructuras (SI, MIENTRAS, PARA, etc.) sin tener que escribirlas a mano.
• Editor de código (centro): donde escribes tu pseudocódigo.
• Panel de salida (derecha): donde aparecen los mensajes ESCRIBIR y los resultados.

Escribir y ejecutar tu primer pseudocódigo

Paso 1: En el editor, escribe:

INICIO

ESCRIBIR "Hola, mundo"

FIN

Paso 2: Haz clic en el botón "Ejecutar" (o presiona F9). Verás que aparece "Hola, mundo" en el panel de salida.

Paso 3: Ahora prueba con un algoritmo que use LEER:

INICIO

ESCRIBIR "¿Cómo te llamas?"

LEER nombre

ESCRIBIR "Hola, " + nombre + ", bienvenido a PSeInt"

FIN

Paso 4: Ejecuta (F9). Te pedirá tu nombre. Escríbelo. Verás el saludo personalizado.

Ejecución paso a paso (depuración)

Esta es la función más útil de PSeInt para encontrar errores lógicos. En lugar de ejecutar todo de golpe, puedes ir paso a paso viendo qué pasa con cada variable.

Cómo activar el modo paso a paso:

1. Escribe un algoritmo con variables.
2. En el menú Ejecutar, selecciona Ejecutar paso a paso (o presiona Shift+F9).
3. Verás cómo aparece una ventana de ejecución con el estado de las variables en cada línea.
4. Usa el botón "Avanzar un paso" para ver la siguiente línea.
5. Cuando el algoritmo pide un dato con LEER, escribe el valor en la ventana emergente.

Ejemplo para practicar paso a paso:

INICIO

LEER a

LEER b

suma = a + b

ESCRIBIR "La suma es: " + suma

FIN

Cuando ejecutes paso a paso con a=5 y b=3, verás:

• Después de LEER a: a = 5
• Después de LEER b: b = 3
• Después de suma = a + b: suma = 8
• Se imprime "La suma es: 8".

Exportar pseudocódigo a C++, Java, Python

Una vez que tengas un pseudocódigo que funciona, PSeInt puede traducirlo automáticamente a código real:

Paso 1: Escribe tu pseudocódigo en PSeInt y asegúrate de que funciona.

Paso 2: En el menú Archivo, selecciona Exportar a... → C++ (o Java, o Python).

Paso 3: PSeInt genera el código equivalente. Cópialo y pégalo en tu IDE preferido.

Ojo: el código generado por PSeInt es funcional pero básico. No es el código que escribiría un programador profesional, pero es un excelente punto de partida.

Las 3 opciones de configuración del perfil

Antes de empezar a programar en PSeInt, revisa la configuración:

Menú `Configurar` → `Opciones del perfil`:

1.4.3 — Diagramas de flujo: simbología ANSI/ISO

Qué es un diagrama de flujo

Un diagrama de flujo (o flowchart) es una representación gráfica de un algoritmo usando símbolos estandarizados conectados por flechas que indican el orden de ejecución. Es otra forma (alternativa al pseudocódigo) de representar algoritmos.

Ventajas:

• Visual: una persona que no sabe programar puede entender el algoritmo.
• Universal: los símbolos son estándar internacional (ANSI/ISO 5807).
• Comunicable: sirve para explicar el algoritmo a otras personas.

Desventajas:

• Para algoritmos grandes, se vuelve inmantenible.
• Es más lento de hacer que el pseudocódigo.
• En la práctica profesional, se usan poco (se prefiere el pseudocódigo o el código).

La simbología estándar (ANSI/ISO 5807)

Ejemplo: diagrama de flujo de "Determinar si un número es positivo"

┌──────────┐

│ INICIO │

└────┬─────┘

↓

┌──────────┐

│ LEER n │

└────┬─────┘

↓

◆─────◆ n > 0

╱ ╲

Sí No

╱ ╲

┌────────┐ ┌────────┐

│"positi-│ │"no es │

│ vo" │ │positivo"│

└────┬───┘ └────┬───┘

└──────┬──────┘

↓

┌──────────┐

│ FIN │

└──────────┘

Ejemplo: diagrama de flujo de "Sumar los primeros N números"

┌──────────┐

│ INICIO │

└────┬─────┘

↓

┌──────────┐

│ LEER N │

└────┬─────┘

↓

┌────────┐

│suma = 0│

│i = 1 │

└────┬───┘

↓

◆────◆ i <= N

╱ ╲

Sí No

╱ ╲

┌────────────┐ │

│suma=suma+i │ │

│i=i+1 │ │

└────┬───────┘ │

└─────┬─────┘

↓

┌─────────┐

│ESCRIBIR │

│"Suma: "+│

│suma │

└────┬────┘

↓

┌──────────┐

│ FIN │

└──────────┘

Reglas para dibujar buenos diagramas de flujo

1. Toda línea de flujo debe tener una flecha. No se asume la dirección.
2. El diagrama debe caber en una página (o usar conectores si es muy grande).
3. Los rombos de decisión siempre tienen 2 salidas (Sí/No, Verdadero/Falso). Si necesitas más, usa varios rombos anidados o un SEGÚN.
4. Los símbolos de proceso son rectángulos, no cuadrados. Mantener proporciones.
5. El flujo va de arriba hacia abajo por defecto. Solo se sale del flujo vertical cuando es estrictamente necesario.
6. Cada decisión tiene una pregunta clara dentro del rombo. No "evaluar" sino "¿x > 0?".

1.4.4 — draw.io: instalación y creación de diagramas profesionales

Qué es draw.io

draw.io (también conocido como diagrams.net) es un editor gratuito de diagramas que funciona en el navegador. Es la herramienta estándar para hacer diagramas de flujo, UML, arquitecturas, y cualquier diagrama técnico.

Características:

• Gratis y sin registro (se puede usar anónimamente).
• En el navegador: no requiere instalación (aunque hay versión de escritorio).
• Exporta a PNG, PDF, SVG, HTML.
• Guarda en la nube (Google Drive, OneDrive, Dropbox) o local.
• Simbología completa: incluye plantillas para diagramas de flujo, UML, etc.

Cómo acceder a draw.io

Opción 1 (recomendada): Abre tu navegador y ve a [https://app.diagrams.net/](https://app.diagrams.net/). Listo, no necesitas instalar nada.

Opción 2 (escritorio): Descarga la versión offline desde [https://github.com/jgraph/drawio-desktop/releases](https://github.com/jgraph/drawio-desktop/releases). Te da una app de escritorio que no necesita internet.

Crear tu primer diagrama de flujo

Paso 1: Abre [https://app.diagrams.net/](https://app.diagrams.net/). Te preguntará dónde guardar. Selecciona "Device" (local) o "Google Drive" (si tienes cuenta).

Paso 2: En la galería de plantillas, busca "Flowchart" y haz clic. Te mostrará una paleta con los símbolos estándar.

Paso 3: En la paleta izquierda verás todos los símbolos. Los más importantes para nosotros son:

• General → Terminator (el óvalo de inicio/fin)
• General → Process (el rectángulo de proceso)
• General → Decision (el rombo de decisión)
• General → Data (el paralelogramo de entrada/salida)

Paso 4: Arrastra cada símbolo al lienzo. Conecta con flechas usando el menú "Connector" o haciendo clic en el borde de un símbolo y arrastrando al siguiente.

Paso 5: Haz doble clic en cada símbolo para escribir el texto.

Paso 6: Cuando termines, ve a Archivo → Exportar como → PNG (o PDF o SVG).

Ejemplo: diagrama de flujo en draw.io de "Número par o impar"

Paso 1: Arrastra un Terminator (óvalo) y escribe "INICIO".

Paso 2: Arrastra un Data (paralelogramo) y escribe "LEER n". Conéctalo con el INICIO.

Paso 3: Arrastra un Process (rectángulo) y escribe "residuo = n % 2". Conéctalo.

Paso 4: Arrastra un Decision (rombo) y escribe "¿residuo == 0?". Conéctalo. Etiqueta las dos salidas: "Sí" (a la izquierda) y "No" (a la derecha).

Paso 5: Arrastra dos Data más: uno con "ESCRIBIR 'par'" (para el Sí) y otro con "ESCRIBIR 'impar'" (para el No).

Paso 6: Conecta ambos a un Terminator con "FIN".

Paso 7: Ajusta colores (opcional): en Format → Style puedes poner fondo azul a los procesos, verde a las entradas, amarillo a las decisiones, rojo a los terminales.

Paso 8: Exporta a PNG y pega la imagen en tu cuaderno o en el README de tu proyecto.

Consejos profesionales para draw.io

• Usa la rejilla (View → Grid) para alinear bien los símbolos.
• Nombra los archivos con la convención diagrama-NNN-descripcion.drawio (ej: diagrama-001-par-impar.drawio).
• Guarda el archivo .drawio además del PNG: si necesitas editar después, el PNG no se puede editar, pero el .drawio sí.
• Usa colores con sentido: por ejemplo, azul para entrada, verde para proceso, amarillo para decisión, rojo para inicio/fin.
• Agrupa elementos relacionados con Arrange → Group para mover varios a la vez.

1.4.5 — Diagramas N-S (Nassi-Shneiderman): alternativa estructurada

Qué es un diagrama N-S

El diagrama Nassi-Shneiderman (también llamado diagrama de Chapin o diagrama estructurado) es una representación gráfica del algoritmo que no usa flechas, sino cajas anidadas. Fue creado en 1972 por Isaac Nassi y Ben Shneiderman.

Por qué importa: fuerza al algoritmo a ser estructurado (sin GOTO, sin saltos). Es perfecto para la programación estructurada que verás en el Capítulo 2.

Simbología básica

Ejemplo: diagrama N-S de "Determinar si es mayor de edad"

┌─────────────────────────────────┐

│ INICIO │

├─────────────────────────────────┤

│ LEER edad │

├─────────────────────────────────┤

│ SI edad >= 18 ─┬─ ESCRIBIR │

│ │ "Mayor" │

│ ├─ ESCRIBIR │

│ │ "Menor" │

├─────────────────────────────────┤

│ FIN │

└─────────────────────────────────┘

Ejemplo: diagrama N-S de "Sumar del 1 al N"

┌──────────────────────────────────────┐

│ INICIO │

├──────────────────────────────────────┤

│ LEER N │

│ suma = 0 │

├──────────────────────────────────────┤

│ ╔═════════════ MIENTRAS i <= N ═════╗│

│ ║ suma = suma + i ║│

│ ║ i = i + 1 ║│

│ ╚════════════════════════════════════╝│

├──────────────────────────────────────┤

│ ESCRIBIR "Suma: " + suma │

├──────────────────────────────────────┤

│ FIN │

└──────────────────────────────────────┘

¿Cuándo usar N-S en lugar de diagrama de flujo tradicional?

En la práctica profesional, el pseudocódigo ha ganado la batalla y los diagramas de flujo son cada vez menos comunes. Pero entender las 3 representaciones (pseudocódigo, diagrama de flujo tradicional, diagrama N-S) te da una visión completa.

1.4.6 — Conversión entre las 3 representaciones

Por qué importa la conversión

El mismo algoritmo se puede expresar de 3 formas:

• Pseudocódigo (texto, ideal para programar)
• Diagrama de flujo tradicional (gráfico, ideal para comunicar)
• Diagrama N-S (gráfico estructurado, ideal para enseñar)

Las 3 deben producir el mismo resultado con los mismos datos. Si no lo hacen, hay un error en alguna de las representaciones.

Reglas de conversión pseudocódigo → diagrama de flujo

Ejemplo completo: conversión de las 3 representaciones

Algoritmo: "Calcular el área de un rectángulo pidiendo base y altura, validar que sean positivos."

Pseudocódigo (PSeInt):

INICIO

ESCRIBIR "Base:"

LEER base

ESCRIBIR "Altura:"

LEER altura

SI base <= 0 O altura <= 0 ENTONCES

ESCRIBIR "Error: valores deben ser positivos"

SINO

area = base * altura

ESCRIBIR "Área: " + area

FIN SI

FIN

Diagrama de flujo tradicional (draw.io):

┌──────────┐

│ INICIO │

└────┬─────┘

↓

╱──────────╲

╱ LEER base ╲

╲ ╱

╲──────────╱

↓

╱──────────╲

╱ LEER altura╲

╲ ╱

╲──────────╱

↓

◆────◆ base<=0 O

╱ ╲ altura<=0

Sí No

╱ ╲

┌───────────┐ ┌──────────┐

│"Error: │ │area = │

│ valores │ │base*alt │

│ deben ser │ └────┬─────┘

│ positivos"│ ↓

└────┬──────┘ ╱──────────╲

└────┬───╱ ESCRIBIR ╲

↓ ╲ "Área: " ╱

┌──────────╲ +area ╱

│ FIN ╲ ╱

└───────────╲─────╱

Diagrama N-S:

┌────────────────────────────────────┐

│ INICIO │

├────────────────────────────────────┤

│ LEER base │

├────────────────────────────────────┤

│ LEER altura │

├────────────────────────────────────┤

│ SI base<=0 O ─┬─ ESCRIBIR │

│ altura<=0 │ "Error..." │

│ ├─ area = base*altura│

│ │ ESCRIBIR "Área:" │

├────────────────────────────────────┤

│ FIN │

└────────────────────────────────────┘

⚠️ Errores típicos — ❌ Errores típicos del razonamiento

Error 1: "El pseudocódigo debe ser idéntico al código real"

Idea equivocada: "Si mi pseudocódigo no se parece a C++, está mal."

Realidad: el pseudocódigo es un lenguaje intermedio. No tiene que parecerse a ningún lenguaje real. Su trabajo es que un humano entienda el algoritmo, no que la computadora lo ejecute.

Cómo evitarlo: si tu pseudocódigo es claro para ti y para un compañero, está bien, sin importar el estilo.

Error 2: "Los diagramas de flujo son obsoletos, no los voy a usar"

Idea equivocada: "Esto es del siglo XX, hoy solo se programa."

Realidad: los diagramas de flujo siguen siendo la mejor forma de comunicar un algoritmo a personas no técnicas. En reuniones con clientes, en presentaciones a directivos, en tutorías, un buen diagrama vale más que 50 líneas de código.

Cómo evitarlo: aprende a hacerlos bien, aunque no los uses todos los días. Son una herramienta de comunicación.

Error 3: "Si PSeInt dice que está bien, está bien"

Idea equivocada: "PSeInt ejecutó mi pseudocódigo sin errores, entonces el algoritmo es correcto."

Realidad: PSeInt verifica sintaxis y ejecución, pero no puede verificar que el algoritmo resuelva el problema correcto. Un pseudocódigo puede ejecutarse perfectamente y dar resultados equivocados porque el algoritmo mismo está mal diseñado.

Cómo evitarlo: la traza en papel sigue siendo necesaria, incluso después de que PSeInt apruebe el pseudocódigo.

Error 4: "Hago el pseudocódigo una vez y nunca lo actualizo"

Idea equivocada: "Mi pseudocódigo está listo, no necesito tocarlo más."

Realidad: cuando codifiques, vas a descubrir casos borde que no habías considerado. El pseudocódigo debe evolucionar con el código. Es un documento vivo, no una foto fija.

Cómo evitarlo: cada vez que corrijas un bug en el código, revisa si el pseudocódigo también necesita actualizarse.

Error 5: "Draw.io es solo para diagramas de flujo"

Idea equivocada: "draw.io solo sirve para hacer los diagramas de este curso."

Realidad: draw.io sirve para cualquier diagrama técnico: UML, arquitecturas de software,业务流程, mapas mentales, mockups, diagramas de red, etc. Una vez que lo domines, lo vas a usar toda tu carrera.

Cómo evitarlo: experimenta con otros tipos de diagramas en draw.io: organigramas, mapas mentales, diagramas de Gantt.

🤖 IA como copiloto — 🤖 AI Mission 1.4 — Validación con IA

Regla de los 3 minutos (obligatoria): primero intenta por tu cuenta, después la IA.

Lo que la IA NO debe hacer

• ❌ No debe diseñar tus algoritmos en las 3 representaciones.
• ❌ No debe dibujar los diagramas por ti.
• ❌ No debe darte la solución de los ejercicios.

Lo que SÍ debe hacer

• ✅ Explicarte un símbolo ANSI/ISO que no entendiste.
• ✅ Verificar que tus 3 representaciones son equivalentes.
• ✅ Sugerir mejoras de claridad en el pseudocódigo.

Prompts sugeridos

Prompt 1 — Explicar un símbolo:

"Explícame con un ejemplo cuándo se usa el símbolo de 'conector fuera de página' en un diagrama de flujo. No me des código. Máximo 100 palabras."

Prompt 2 — Verificar equivalencia de representaciones:

"Te voy a pegar el pseudocódigo y la descripción de un diagrama de flujo del MISMO algoritmo. NO me des la solución. Solo dime: (1) ¿producen el mismo resultado? (2) ¿qué decisión del pseudocódigo no está reflejada en el diagrama? (3) ¿qué decisión del diagrama no está en el pseudocódigo? Máximo 150 palabras."

Prompt 3 — Exportar a código real:

"Tengo este pseudocódigo en PSeInt que funciona. ¿Me puedes ayudar a traducirlo a C++? Pero NO me lo des hecho: dame primero las equivalencias palabra por palabra entre pseudocódigo y C++, y luego yo lo intento. Máximo 200 palabras."

Prompt 4 — Comparar herramientas:

"Compara PSeInt, draw.io y un IDE real (como VS Code) para enseñar programación a principiantes. ¿Cuál usarías para cada etapa del aprendizaje? No me des código. Máximo 200 palabras."

🧪 Laboratorio — 🧪 LAB 1.4 — 5 algoritmos en 3 representaciones

Tiempo total: 2 h 30 min | Entregable: 5 algoritmos en pseudocódigo (PSeInt) + diagrama de flujo (draw.io) + diagrama N-S (cuaderno).

Regla de oro: un algoritmo en 3 representaciones debe producir el MISMO resultado con los MISMOS datos. Verifícalo con PSeInt, con la traza en papel del diagrama de flujo, y con la del N-S.

Ejercicio 1 — Suma de 2 números (básico, 20 min)

Enunciado. Algoritmo que pide 2 números al usuario e imprime su suma.

Aplica:

• Pseudocódigo en PSeInt (ejecútalo con 5+3 y verifica que da 8).
• Diagrama de flujo en draw.io (exporta como PNG).
• Diagrama N-S en el cuaderno (a mano).

Criterio de éxito: las 3 representaciones son correctas y equivalentes.

Rúbrica (10 pts): pseudocódigo funcional (4 pts) + diagrama de flujo correcto (3 pts) + N-S correcto (3 pts).

Ejercicio 2 — Par o impar (básico, 25 min)

Enunciado. Algoritmo que pide un número entero y dice si es par o impar.

Aplica las 3 representaciones + ejecuta en PSeInt con 7, 12, 25, 100.

Criterio de éxito: maneja correctamente los 4 casos de prueba.

Rúbrica (10 pts): pseudocódigo (4 pts) + diagrama de flujo (3 pts) + ejecución correcta en PSeInt (3 pts).

Ejercicio 3 — Mayor de 3 números (intermedio, 30 min)

Enunciado. Algoritmo que pide 3 números y dice cuál es el más grande.

Aplica las 3 representaciones + ejecuta con (3,7,2), (10,5,10), (1,2,3).

Criterio de éxito: maneja correctamente empates (cuando hay 2 o 3 números iguales al máximo).

Rúbrica (10 pts): pseudocódigo (3 pts) + diagrama de flujo (3 pts) + N-S (2 pts) + casos de prueba correctos (2 pts).

Ejercicio 4 — Tabla de multiplicar (intermedio, 30 min)

Enunciado. Algoritmo que pide un número N y muestra su tabla de multiplicar del 1 al 10.

Aplica las 3 representaciones + ejecuta con N=5 y N=9.

Criterio de éxito: el pseudocódigo usa un PARA, el diagrama de flujo muestra el bucle, y el N-S lo refleja.

Rúbrica (10 pts): uso correcto de PARA (3 pts) + diagrama de flujo con bucle (3 pts) + N-S con bucle (2 pts) + ejecución correcta (2 pts).

Ejercicio 5 — Factorial (avanzado, 45 min)

Enunciado. Algoritmo que pide un número N y calcula su factorial (N!).

Aplica las 3 representaciones + ejecuta con N=5 (debe dar 120) y N=10 (debe dar 3,628,800).

Criterio de éxito: el pseudocódigo maneja el caso N=0 (0! = 1) y el caso de números negativos (mensaje de error).

Rúbrica (10 pts): pseudocódigo (3 pts) + diagrama de flujo (3 pts) + N-S (2 pts) + manejo de casos borde (2 pts).

Ejercicio bonus — Adivina el número (avanzado, opcional, 30 min)

Enunciado. Algoritmo que "piensa" un número entre 1 y 100, y el usuario tiene que adivinarlo. El algoritmo le dice si el número pensado es mayor o menor que el del usuario, hasta que adivine.

Aplica las 3 representaciones + ejecuta y juega con un compañero.

Rúbrica bonus (5 pts extra): pseudocódigo funcional (2 pts) + diagrama de flujo con bucle (2 pts) + juego con compañero (1 pt).

Entregable final del LAB: 5 algoritmos (o 6 con el bonus) en las 3 representaciones. Sello del cuaderno para acreditar el Boss 1.

🎯 Cierre del tema

Lo que aprendiste hoy:

• Sintaxis de pseudocódigo PSeInt.
• Cómo instalar y usar PSeInt para ejecutar y depurar pseudocódigo.
• Simbología estándar ANSI/ISO para diagramas de flujo.
• Cómo usar draw.io para diagramas profesionales.
• Diagramas N-S como alternativa estructurada.
• Las 3 representaciones del mismo algoritmo deben ser equivalentes.

Lo que sigue: en el Tema 1.5 — Constantes, Variables, Tipos de Datos y Operadores (8h), vas a entrar a los ladrillos fundamentales de cualquier programa. Una variable es una cajita con nombre que guarda un valor; un tipo de dato dice qué clase de valor puede guardar; un operador es un símbolo que hace una operación. Después de este tema, vas a tener todo lo necesario para escribir tu primer programa real (que viene en el Tema 1.7).

Antes de seguir, asegúrate de tener en tu cuaderno:

• [ ] 5 algoritmos en las 3 representaciones (LAB 1.4).
• [ ] 1 diagrama de flujo profesional en draw.io (exportado a PNG).
• [ ] Captura de pantalla de PSeInt con al menos 1 algoritmo ejecutado.
• [ ] Glosario con los términos: pseudocódigo, INICIO, FIN, LEER, ESCRIBIR, SI, MIENTRAS, PARA, SEGÚN, PSeInt, draw.io, diagrama de flujo, simbología ANSI/ISO, diagrama N-S, terminal, proceso, decisión.

XP obtenida al completar este tema: 100 base + 30 por LAB (5 algoritmos × 3 representaciones) + 20 por Quest = 150 XP. Insignia desbloqueada al cerrar el capítulo: Visual Flow Master (parcial).

*"Un buen algoritmo se entiende en pseudocódigo. Un gran algoritmo se entiende en 3 representaciones a la vez."* — De la introducción de este manual.

Fin del Tema 1.4

📝 Quest · Cuestionario — 📝 Quest — Reactivos para autoevaluación

Sección A · Opción múltiple

Elige la opción correcta (A, B, C o D). Las respuestas están en la sección Respuestas modelo.

1. ¿Qué herramienta se usa commonly para diagramas de flujo?
   • PSeInt
   • draw.io
   • Word
   • Paint
2. En PSeInt, ¿cómo se asigna un valor a una variable?
   • =
   • := o <-
   • ==
   • ===
3. ¿Qué representa un rombo en un diagrama de flujo?
   • Inicio
   • Proceso
   • Decisión
   • Entrada/Salida
4. El paralelogramo en un diagrama de flujo representa:
   • Inicio/fin
   • Proceso
   • Decisión
   • Entrada/Salida
5. ¿Para qué sirve PSeInt?
   • Compilar C++
   • Aprender algoritmia con pseudocódigo en español
   • Diseñar páginas web
   • Crear bases de datos
6. ¿Qué símbolo se usa para el inicio/fin en un diagrama de flujo?
   • Rectángulo
   • Rombo
   • Óvalo
   • Círculo
7. En pseudocódigo, ¿cómo se lee un número del usuario?
   • print "dame un número"
   • Leer numero
   • scanf(numero)
   • input numero
8. ¿Qué es un diagrama de flujo?
   • Un programa
   • Representación gráfica de un algoritmo
   • Una base de datos
   • Un lenguaje
9. ¿Por qué es importante el pseudocódigo?
   • Para ejecutar directamente
   • Para diseñar algoritmos antes de codificar
   • Para hacer más lento el código
   • Para confundir a otros
10. Un buen pseudocódigo debe ser:
    • Complejo
    • Claro, ordenado y fácil de traducir a código
    • Inglés solamente
    • Corto siempre

Sección B · Preguntas abiertas

Desarrolla tu respuesta en al menos 3 líneas. Compara con la respuesta modelo después de escribir.

1. Convierte este pseudocódigo a diagrama de flujo: LEER n; PARA i DESDE 1 HASTA n: SI i%2==0: ESCRIBIR i; FIN SI; FIN PARA
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
2. ¿Por qué es útil representar un algoritmo en pseudocódigo ANTES de codificarlo?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…
3. Explica la diferencia entre un diagrama de flujo y pseudocódigo. ¿Cuándo usarías cada uno?
   → Escribe tu respuesta aquí (en tu cuaderno o mentalmente)…