Necesitamos tres bucles Para, uno dentro del otro.
1. Externo (Horas): De 0 a 23.
2. Medio (Minutos): De 0 a 59.
3. Interno (Segundos): De 0 a 59.
Por cada vuelta del ciclo de horas, el de minutos da 60 vueltas, y el de segundos da 3600.

Para que parezca un reloj y no una lista infinita de números, usamos:
• Esperar 1 Segundos: Frena la ejecución para marcar el ritmo.
• Borrar Pantalla: Limpia la consola antes de escribir la nueva hora, creando la animación.

Algoritmo RelojDigital
    // 1. Definición de Variables
    Definir h, m, s Como Entero;
    
    Escribir "Iniciando Reloj...";
    Esperar 1 Segundos;
    
    // 2. Ciclos Anidados (La lógica del reloj)
    
    // Bucle para las Horas (0 a 23)
    Para h <- 0 Hasta 23 Hacer
        
        // Bucle para los Minutos (0 a 59)
        Para m <- 0 Hasta 59 Hacer
            
            // Bucle para los Segundos (0 a 59)
            Para s <- 0 Hasta 59 Hacer
                
                // 3. Actualización de la Pantalla
                Borrar Pantalla; // Limpia el número anterior
                
                // Dibujo del reloj
                Escribir "=================";
                Escribir "  RELOJ DIGITAL  ";
                Escribir "    ", h, ":", m, ":", s;
                Escribir "=================";
                
                // 4. Pausa de tiempo real
                Esperar 1 Segundos;
                
            FinPara
            
        FinPara
        
    FinPara
    
FinAlgoritmo

Si no borras la pantalla, PSeInt escribirá una hora debajo de la otra infinitamente (00:00:01, 00:00:02...). Para simular un reloj fijo, debes limpiar la consola en cada segundo.

El comando Esperar 1 Segundos debe ir estrictamente dentro del bucle de los Segundos. Si lo pones en el de Minutos, los segundos volarán a la velocidad de la luz y el reloj solo se detendrá cada minuto.

Algoritmo RelojEstetico
    Definir h, m, s Como Entero;
    
    Para h <- 0 Hasta 23 Hacer
        Para m <- 0 Hasta 59 Hacer
            Para s <- 0 Hasta 59 Hacer
                
                Borrar Pantalla;
                Escribir "==================";
                
                // Lógica de visualización (Cero a la izquierda)
                // Usamos 'Sin Saltar' para armar la línea
                
                // Horas
                Si h < 10 Entonces
                    Escribir "0", h, ":" Sin Saltar;
                SiNo
                    Escribir h, ":" Sin Saltar;
                FinSi
                
                // Minutos
                Si m < 10 Entonces
                    Escribir "0", m, ":" Sin Saltar;
                SiNo
                    Escribir m, ":" Sin Saltar;
                FinSi
                
                // Segundos
                Si s < 10 Entonces
                    Escribir "0", s;
                SiNo
                    Escribir s;
                FinSi
                
                Escribir "==================";
                Esperar 1 Segundos; // También puedes probar con 'Esperar 100 Milisegundos' para pruebas rápidas
                
            FinPara
        FinPara
    FinPara
    
FinAlgoritmo

Esta función genera un número aleatorio entero. ¡Ojo con el rango! En PSeInt, Azar(100) genera números del 0 al 99. Si queremos jugar del 1 al 100, debemos sumar 1 a la fórmula: Azar(100) + 1.

A diferencia de una tabla de multiplicar (donde sabemos que son 10 vueltas), aquí no sabemos cuántos intentos necesitará el usuario. Usamos la estructura Repetir... Hasta Que para mantener el juego vivo hasta que el jugador acierte.

Algoritmo JuegoAdivinanza
    // 1. Definición de Variables
    Definir secreto, intento, contador Como Entero;
    
    // 2. Generación del Número Aleatorio (1 al 100)
    // Azar(100) da de 0 a 99, por eso sumamos 1
    secreto <- Azar(100) + 1;
    contador <- 0;
    intento <- 0; // Inicializamos con un valor que no sea el secreto
    
    Escribir "=== JUEGO: ADIVINA EL NÚMERO ===";
    Escribir "He pensado un número entre 1 y 100.";
    Escribir "¡Intenta adivinarlo!";
    Escribir "--------------------------------";
    
    // 3. Bucle Interactivo
    // Usamos 'Mientras' para repetir hasta que acierte
    Mientras intento <> secreto Hacer
        
        Escribir "Ingresa tu número:";
        Leer intento;
        
        // Aumentamos el contador de intentos
        contador <- contador + 1;
        
        // 4. Lógica de Pistas (Alto/Bajo)
        Si intento > secreto Entonces
            Escribir ">> ¡Demasiado ALTO! Prueba uno más bajo.";
        SiNo
            Si intento < secreto Entonces
                Escribir ">> ¡Demasiado BAJO! Prueba uno más alto.";
            SiNo
                // Si no es mayor ni menor, es igual (Victoria)
                Escribir "*********************************";
                Escribir "¡FELICIDADES! ¡ADIVINASTE!";
                Escribir "*********************************";
            FinSi
        FinSi
        
    FinMientras
    
    // 5. Estadísticas Finales
    Escribir "Número secreto: ", secreto;
    Escribir "Total de intentos: ", contador;
    
FinAlgoritmo

Si solo escribes Azar(100), la computadora puede generar el número 0 y nunca generará el 100. Recuerda que en informática contamos desde 0. La corrección +1 es obligatoria si quieres jugar del 1 al 100.

Si usas Mientras intento <> secreto, debes asegurarte de que intento no valga lo mismo que secreto antes de empezar (aunque es improbable por azar). Es más seguro inicializar intento en -1 o un valor fuera de rango.

Algoritmo JuegoVidasLimitadas
    Definir secreto, intento, vidas Como Entero;
    
    secreto <- Azar(50) + 1; // Rango 1-50
    vidas <- 5;
    intento <- 0;
    
    Escribir "=== MODO HARDCORE (1-50) ===";
    Escribir "Tienes ", vidas, " vidas para adivinar.";
    
    // El bucle sigue MIENTRAS no acierte Y le queden vidas
    Mientras intento <> secreto Y vidas > 0 Hacer
        
        Escribir "Vidas restantes: ", vidas;
        Escribir "Ingresa tu número:";
        Leer intento;
        
        Si intento == secreto Entonces
            Escribir "¡VICTORIA! Lo lograste.";
        SiNo
            vidas <- vidas - 1; // Restamos vida
            
            Si vidas == 0 Entonces
                Escribir "--- GAME OVER ---";
                Escribir "El número era: ", secreto;
            SiNo
                // Damos pistas solo si sigue vivo
                Si intento > secreto Entonces
                    Escribir "Pista: Busca más BAJO.";
                SiNo
                    Escribir "Pista: Busca más ALTO.";
                FinSi
            FinSi
        FinSi
        Escribir ""; // Espacio estético
    FinMientras
    
FinAlgoritmo

Representa la «Cantidad de Elementos». Antes de empezar a sumar, debemos preguntar al usuario: «¿Cuántos números vas a ingresar?». Este valor N definirá cuántas vueltas dará nuestro ciclo. Es el denominador de nuestra fórmula de promedio.

No podemos guardar todos los números en variables distintas (n1, n2, n3…) porque no sabemos cuántos son. En su lugar, usamos una sola variable suma que atrapa y acumula el valor en cada iteración: suma <- suma + dato.

Algoritmo CalcularPromedioN
    // 1. Definición de Variables
    // 'n' es la cantidad de datos (Entero)
    // 'dato' es el número que ingresa el usuario en cada vuelta
    // 'suma' es el acumulador
    // 'promedio' es el resultado final (Real)
    Definir n, i Como Entero;
    Definir dato, suma, promedio Como Real;
    
    // 2. Inicialización
    suma <- 0; // ¡Muy importante empezar en 0!
    
    // 3. Obtener la cantidad de datos
    Escribir "=== CÁLCULO DE MEDIA ARITMÉTICA ===";
    Escribir "¿Cuántos números desea ingresar?";
    Leer n;
    
    // 4. Ciclo de Lectura y Acumulación
    // Usamos PARA porque sabemos exactamente cuántas vueltas dar (n)
    Para i <- 1 Hasta n Con Paso 1 Hacer
        Escribir "Ingrese el número ", i, ":";
        Leer dato;
        
        // Acumulamos el valor
        suma <- suma + dato;
    FinPara
    
    // 5. Cálculo Final y Salida
    // Validamos para no dividir por cero si n es 0
    Si n > 0 Entonces
        promedio <- suma / n;
        Escribir "-----------------------------";
        Escribir "La suma total es: ", suma;
        Escribir "La MEDIA (Promedio) es: ", promedio;
        Escribir "-----------------------------";
    SiNo
        Escribir "Error: La cantidad de números debe ser mayor a 0.";
    FinSi
    
FinAlgoritmo

Si no escribes suma <- 0 antes del ciclo, PSeInt podría usar un valor basura o dar error. El acumulador siempre debe empezar limpio.

Un error clásico es poner promedio <- suma / n dentro del Para. Esto hace que la computadora calcule el promedio N veces innecesariamente. La división solo debe hacerse una vez, al finalizar el bucle.

Algoritmo MediaRobusta
    Definir n, i Como Entero;
    Definir dato, suma, promedio Como Real;
    
    suma <- 0;
    
    // Validación: Obligar a ingresar un N positivo
    Repetir
        Escribir "¿Cuántos datos va a procesar? (Debe ser > 0):";
        Leer n;
        Si n <= 0 Entonces
            Escribir "Error: Cantidad inválida.";
        FinSi
    Hasta Que n > 0
    
    Para i <- 1 Hasta n Hacer
        Escribir "Ingrese dato #", i, ":";
        Leer dato;
        suma <- suma + dato;
    FinPara
    
    promedio <- suma / n;
    
    // Redondeo visual (truco matemático)
    promedio <- redon(promedio * 100) / 100;
    
    Escribir ">>> El promedio de los ", n, " datos es: ", promedio;
    
FinAlgoritmo

Es un valor especial que no forma parte de los datos a procesar, sino que sirve como señal de «STOP». Se elige el 0 porque es el elemento neutro de la suma (sumarlo no afecta el resultado), lo que simplifica mucho el código.

A diferencia de una variable normal que sobrescribe su valor, un acumulador suma sobre sí mismo.
Fórmula: suma = suma + nuevo_numero.
¡Regla de oro! Siempre debe inicializarse en 0 antes de entrar al ciclo.

Algoritmo SumarNumerosIndefinidos
    // 1. Definición de Variables
    // 'num' es el valor temporal que ingresa el usuario
    // 'suma' es el acumulador total
    Definir num, suma Como Real;
    
    // 2. Inicialización
    // ¡Fundamental! Si no empieza en 0, la suma será incorrecta.
    suma <- 0;
    
    Escribir "=== SUMADORA INFINITA ===";
    Escribir "Ingrese números para sumar.";
    Escribir "Digite 0 para terminar y ver el resultado.";
    Escribir "-----------------------------";
    
    // 3. Estructura Repetitiva (Bucle)
    // Usamos 'Repetir' porque al menos debemos pedir un número una vez
    Repetir
        Escribir "Ingrese un número:";
        Leer num;
        
        // Acumulamos el valor
        // Nota: Si num es 0, suma + 0 sigue siendo suma. No afecta.
        suma <- suma + num;
        
        // Opcional: Mostrar subtotal parcial
        // Escribir "Subtotal parcial: ", suma;
        
    Hasta Que num = 0
    
    // 4. Salida Final
    Escribir "-----------------------------";
    Escribir "PROCESO TERMINADO (Se ingresó 0)";
    Escribir "La suma total es: ", suma;
    
FinAlgoritmo

Si olvidas poner suma <- 0 al principio, PSeInt podría asignar un valor "basura" o lanzar un error de variable no inicializada, causando que la suma total sea incorrecta desde el inicio.

Si usas Mientras num <> 0, debes leer el número antes del ciclo Y dentro del ciclo. Si olvidas leerlo dentro, el valor de num nunca cambiará y crearás un bucle infinito.

Algoritmo SumaYPromedio
    Definir num, suma, promedio Como Real;
    Definir contador Como Entero;
    
    suma <- 0;
    contador <- 0;
    
    Repetir
        Escribir "Ingrese número (0 para salir):";
        Leer num;
        
        Si num <> 0 Entonces
            suma <- suma + num;
            contador <- contador + 1; // Solo contamos si no es el 0 de salida
        FinSi
        
    Hasta Que num = 0
    
    Escribir "--- RESULTADOS ---";
    Escribir "Suma Total: ", suma;
    Escribir "Números ingresados: ", contador;
    
    // Validación para evitar división por cero si no ingresó nada
    Si contador > 0 Entonces
        promedio <- suma / contador;
        Escribir "Promedio: ", promedio;
    SiNo
        Escribir "Promedio: 0 (No se ingresaron datos)";
    FinSi
    
FinAlgoritmo

A diferencia de las sumas, donde empezamos en 0, en una multiplicación acumulativa debemos empezar en 1. Si inicializas tu variable factorial <- 0, al multiplicar cualquier número, el resultado siempre será cero. El 1 es el elemento neutro de la multiplicación.

Por definición matemática estricta, el factorial de 0 es 1 (0! = 1). Un buen algoritmo debe ser capaz de manejar esta excepción lógica sin romperse.

Algoritmo CalcularFactorial
    // 1. Definición de Variables
    // 'fact' guardará el resultado. 'num' es el dato de entrada. 'i' es el contador.
    // Usamos 'Real' para el factorial porque crecen muy rápido (pueden superar el límite de Entero)
    Definir num, i Como Entero;
    Definir fact Como Real;
    
    // 2. Inicialización CRÍTICA
    fact <- 1;
    
    // 3. Entrada de Datos
    Escribir "=== CÁLCULO DE FACTORIAL (N!) ===";
    Escribir "Ingrese un número entero positivo:";
    Leer num;
    
    // 4. Validación de entrada (No existen factoriales negativos)
    Si num < 0 Entonces
        Escribir "Error: No existe el factorial de números negativos.";
    SiNo
        // 5. Proceso: Ciclo Multiplicativo
        // Recorremos desde 1 hasta el número ingresado
        Para i <- 1 Hasta num Con Paso 1 Hacer
            fact <- fact * i;
            // Prueba de escritorio mental:
            // Vuelta 1: fact = 1 * 1 = 1
            // Vuelta 2: fact = 1 * 2 = 2
            // Vuelta 3: fact = 2 * 3 = 6 ...
        FinPara
        
        // 6. Salida de Resultados
        Escribir "-----------------------------";
        Escribir "El factorial de ", num, "! es: ", fact;
        Escribir "-----------------------------";
    FinSi
    
FinAlgoritmo

El error #1. Si escribes fact <- 0, la primera multiplicación será 0 * 1 = 0, y todo el resultado final será 0. En acumuladores de sumas se usa 0; en acumuladores de productos se usa 1.

Los factoriales crecen explosivamente. 10! es 3.6 millones. 20! es un número gigantesco. Si defines la variable como Entero, al calcular factoriales grandes (ej: >13), PSeInt podría dar error o números negativos extraños. Usa Real para mayor capacidad.

Algoritmo FactorialValidado
    Definir n, i Como Entero;
    Definir f Como Real;
    
    // Validación: Obligar al usuario a ingresar un positivo
    Repetir
        Escribir "Ingrese un número (0 o positivo):";
        Leer n;
        Si n < 0 Entonces
            Escribir "Dato inválido. Intente nuevamente.";
        FinSi
    Hasta Que n >= 0
    
    f <- 1;
    
    Si n = 0 Entonces
        // Caso base matemático explícito
        Escribir "El factorial de 0 es: 1";
    SiNo
        // Ciclo decreciente (otra forma de hacerlo: n hasta 1)
        Para i <- n Hasta 1 Con Paso -1 Hacer
            f <- f * i;
            Escribir "Multiplicando por: ", i, " Acumulado: ", f;
        FinPara
        
        Escribir "Resultado Final: ", n, "! = ", f;
    FinSi
    
FinAlgoritmo

Un número es par si es divisible por 2. En programación, usamos el operador MOD (o %) que nos devuelve el residuo. Si X MOD 2 es igual a 0, entonces X es par.

Podemos recorrer todos los números (1, 2, 3, 4…) y preguntar «¿Eres par?» (Filtro). O podemos ser más astutos y saltar de 2 en 2 comenzando desde el 2 (2, 4, 6…). Veremos ambos métodos.

Algoritmo ImprimirParesFiltro
    // 1. Definición de Variables
    Definir i Como Entero;
    
    Escribir "=== Números Pares del 1 al 100 ===";
    
    // 2. Ciclo Para que recorre TODOS los números
    Para i <- 1 Hasta 100 Hacer
        
        // 3. Condición Lógica (El Filtro)
        // Usamos MOD para ver si el residuo de la división por 2 es cero
        Si i MOD 2 == 0 Entonces
            Escribir i; // Solo se imprime si pasa el filtro
        FinSi
        
    FinPara
    
    Escribir "=== Fin de la Serie ===";
    
FinAlgoritmo

Escribir Si i / 2 == 0. Esto es incorrecto porque la división devuelve el resultado (ej: 4/2 = 2), no el sobrante. Siempre usa MOD o %.

Si intentas optimizar usando saltos pero escribes Para i<-1 Hasta 100 Con Paso 2, obtendrás 1, 3, 5... (Impares). Para obtener pares, debes iniciar el ciclo en 2.

Algoritmo ParesOptimizado
    Definir i Como Entero;
    
    // OPTIMIZACIÓN:
    // 1. Iniciamos 'i' en 2 (el primer par).
    // 2. Usamos "Con Paso 2" para sumar 2 en cada vuelta.
    // Resultado: i valdrá 2, 4, 6, 8... automáticamente.
    
    Para i <- 2 Hasta 100 Con Paso 2 Hacer
        Escribir i; 
        // ¡No necesitamos condicionales aquí dentro!
    FinPara
    
FinAlgoritmo

Es la estructura ideal cuando sabemos exactamente cuántas veces queremos repetir algo. En este caso, sabemos que queremos ir del 1 al 100. El ciclo «Para» maneja automáticamente el contador, incrementándolo en cada vuelta.

Es una variable (comúnmente llamada i, j o contador) que lleva la cuenta de en qué vuelta del ciclo estamos. Comienza en un valor inicial (1) y termina en un valor final (100).

Algoritmo ImprimirNumeros
    // 1. Definición de Variables
    // 'i' es el nombre estándar para iteradores (contadores)
    Definir i Como Entero;
    
    Escribir "=== Generando serie del 1 al 100 ===";
    
    // 2. Estructura Repetitiva PARA (For)
    // Sintaxis: Para [Variable] <- [Inicio] Hasta [Fin] Con Paso [Salto] Hacer
    
    Para i <- 1 Hasta 100 Con Paso 1 Hacer
        // En cada vuelta, 'i' vale 1, luego 2, luego 3... hasta 100
        Escribir "Número: ", i;
        
        // El 'Paso 1' indica que va de 1 en 1.
        // Si pusieras 'Paso 2', imprimiría 1, 3, 5... (impares)
    FinPara
    
    Escribir "=== Fin del Algoritmo ===";
    
FinAlgoritmo

Suele pasar en el ciclo Mientras. Si olvidas incrementar el contador (i <- i + 1), la condición i <= 100 siempre será verdadera y el programa nunca se detendrá, bloqueando la computadora.

Poner Hasta 99 en lugar de 100, o iniciar en 0 cuando debías iniciar en 1. Verifica siempre tus límites de inicio y fin.

Algoritmo SerieConMientras
    Definir contador Como Entero;
    
    // 1. Inicialización manual
    contador <- 1;
    
    // 2. Condición de entrada al ciclo
    Mientras contador <= 100 Hacer
        Escribir "Valor actual: ", contador;
        
        // 3. Incremento MANUAL (¡Fundamental!)
        // Si borras esta línea, crearás un bucle infinito
        contador <- contador + 1;
    FinMientras
    
    Escribir "Ciclo terminado con éxito.";
FinAlgoritmo

Un número entero mayor que 1 es primo si y solo si tiene exactamente dos divisores: el 1 y él mismo.
Ejemplos: 2, 3, 5, 7, 11…
Nota: El 1 NO es primo (solo tiene un divisor).

Para saber si un número A es divisible por B, usamos el módulo.
Si A MOD B == 0 -> La división es exacta (B es divisor de A).
Nuestro algoritmo buscará cuántas veces el residuo es cero.

Algoritmo VerificarNumeroPrimo
    // 1. Definición de Variables
    Definir num, i, divisores Como Entero;
    
    // 2. Entrada de Datos
    Escribir "=== DETECTOR DE NÚMEROS PRIMOS ===";
    Escribir "Ingrese un número entero positivo:";
    Leer num;
    
    // Inicializamos el contador de divisores
    divisores <- 0;
    
    // 3. Proceso: Buscar divisores
    // Recorremos todos los números desde 1 hasta N
    Para i <- 1 Hasta num Con Paso 1 Hacer
        
        // Si el residuo es 0, encontramos un divisor
        Si num MOD i == 0 Entonces
            divisores <- divisores + 1;
        FinSi
        
    FinPara
    
    // 4. Salida y Lógica Final
    // Un primo debe tener EXACTAMENTE 2 divisores (1 y sí mismo)
    Escribir "--------------------------------";
    Si divisores == 2 Entonces
        Escribir "El número ", num, " ES PRIMO.";
    SiNo
        Escribir "El número ", num, " NO es primo.";
        Escribir "(Tiene ", divisores, " divisores)";
    FinSi
    Escribir "--------------------------------";
    
FinAlgoritmo

Si ingresas el número 1 en el código básico, el bucle encontrará solo 1 divisor. Como divisores != 2, dirá correctamente que no es primo. Sin embargo, muchos intentan "arreglar" el código para que el 1 sea primo. ¡No lo hagas! Matemáticamente el 1 no es primo.

Si quieres verificar si el número 1,000,000 es primo, el código básico hará 1 millón de divisiones. Esto es lento. Si encontramos un divisor (ej: 2), ya sabemos que no es primo y deberíamos detener el ciclo inmediatamente.

Algoritmo PrimoOptimizado
    Definir n, i Como Entero;
    Definir esPrimo Como Logico;
    
    Escribir "Ingrese número a verificar:";
    Leer n;
    
    // Casos base: 1 o menores no son primos
    Si n <= 1 Entonces
        esPrimo <- Falso;
    SiNo
        // Asumimos que ES primo hasta demostrar lo contrario
        esPrimo <- Verdadero;
        
        // OPTIMIZACIÓN: Solo buscamos hasta la mitad (n/2) o raíz cuadrada
        // Empezamos en 2 porque todo número es divisible por 1
        Para i <- 2 Hasta trunc(n/2) Hacer
            
            Si n MOD i == 0 Entonces
                // ¡Encontramos un intruso! Ya no es primo.
                esPrimo <- Falso;
                
                // Rompemos el ciclo forzando el iterador al final
                // (En otros lenguajes se usa 'break')
                i <- n; 
            FinSi
            
        FinPara
    FinSi
    
    Si esPrimo Entonces
        Escribir ">> El número ES PRIMO";
    SiNo
        Escribir ">> El número NO ES PRIMO (Es compuesto)";
    FinSi
    
FinAlgoritmo

Cada número nuevo es la suma de los dos anteriores.
Fórmula: C = A + B.
Ejemplo: Para obtener 5, sumamos 2 (A) + 3 (B).

Después de calcular el nuevo número, debemos prepararnos para la siguiente vuelta. El valor que era «el segundo» (B) pasa a ser «el primero» (A), y el nuevo resultado (C) pasa a ser «el segundo» (B).
Lógica: A <- B, luego B <- C.

Algoritmo SerieFibonacci
    // 1. Definición de Variables
    // 'n' es la cantidad de términos a mostrar
    // 'a' y 'b' son los números base, 'c' es el siguiente
    Definir n, a, b, c, i Como Entero;
    
    // 2. Entrada de Datos
    Escribir "=== GENERADOR FIBONACCI ===";
    Escribir "¿Cuántos términos desea generar?";
    Leer n;
    
    // 3. Inicialización de la serie
    // La serie comienza matemáticamente con 0 y 1
    a <- 0;
    b <- 1;
    
    Escribir "La serie es:";
    
    // 4. Ciclo para generar N términos
    Para i <- 1 Hasta n Hacer
        // Paso A: Mostramos el valor actual de 'a' (el más antiguo)
        // Usamos Sin Saltar para que salgan en línea horizontal
        Escribir a, ", " Sin Saltar;
        
        // Paso B: Calculamos el siguiente número (Suma de los dos actuales)
        c <- a + b;
        
        // Paso C: Desplazamiento (Swap)
        // El segundo pasa a ser el primero
        a <- b;
        // El nuevo pasa a ser el segundo
        b <- c;
        
        // PRUEBA DE ESCRITORIO (Iteración 1):
        // Imprime 0. c=0+1=1. a=1, b=1.
        // PRUEBA DE ESCRITORIO (Iteración 2):
        // Imprime 1. c=1+1=2. a=1, b=2.
        // PRUEBA DE ESCRITORIO (Iteración 3):
        // Imprime 1. c=1+2=3. a=2, b=3.
    FinPara
    
    Escribir ""; // Salto de línea final
    Escribir "=== Fin del proceso ===";
    
FinAlgoritmo

Si calculas c = a + b y luego imprimes c directamente, tu serie empezará en 1, 2, 3... omitiendo el 0 y el primer 1. La clave es imprimir 'a' antes de calcular el nuevo valor.

Escribir b <- c y luego a <- b es un error fatal. Al hacer eso, 'a' recibe el valor nuevo de 'c' (porque 'b' ya fue modificado). Debes mover a <- b primero, para salvar el valor antiguo de 'b'.

Algoritmo FibonacciHastaValor
    Definir a, b, c, limite Como Entero;
    
    Escribir "Ingrese el valor límite (ej: 100):";
    Leer limite;
    
    a <- 0;
    b <- 1;
    
    Escribir "Serie menor a ", limite, ":";
    
    // Usamos MIENTRAS porque no sabemos cuántas vueltas serán
    Mientras a <= limite Hacer
        Escribir a, " " Sin Saltar;
        
        c <- a + b;
        a <- b;
        b <- c;
    FinMientras
    
FinAlgoritmo

Es una estructura de control que repite un bloque de instrucciones un número específico de veces. Para una tabla de multiplicar estándar, sabemos que queremos ir del 1 al 10. El ciclo «Para» gestiona automáticamente el contador (la variable que va cambiando: 1, 2, 3…).

Para que el resultado se vea profesional (ej: «5 x 1 = 5»), no basta con imprimir el resultado matemático. Debemos mezclar variables numéricas con cadenas de texto (la «x» y el «=») en el comando Escribir.

Algoritmo GenerarTablaMultiplicar
    // 1. Definición de Variables
    // 'num': el número que elige el usuario
    // 'i': el iterador (contador) del ciclo
    // 'res': donde guardamos el resultado de la multiplicación
    Definir num, i, res Como Entero;
    
    // 2. Entrada de Datos
    Escribir "=== GENERADOR DE TABLAS DE MULTIPLICAR ===";
    Escribir "Ingrese el número del cual desea ver la tabla:";
    Leer num;
    
    Escribir "-------------------------------";
    Escribir "Tabla del ", num, ":";
    Escribir "-------------------------------";
    
    // 3. Estructura Repetitiva PARA
    // Sintaxis: Para variable <- inicio Hasta fin Con Paso 1 Hacer
    
    Para i <- 1 Hasta 10 Con Paso 1 Hacer
        
        // Cálculo matemático
        res <- num * i;
        
        // Salida formateada (Concatenación con comas)
        Escribir num, " x ", i, " = ", res;
        
    FinPara
    
    Escribir "-------------------------------";
    Escribir "Fin del proceso.";
    
FinAlgoritmo

Es común escribir res <- num * num por error. Esto multiplicaría 7x7 diez veces. Recuerda que debes multiplicar el número fijo (num) por el número cambiante (i).

Si solo escribes Escribir res, el usuario verá una lista de números: 7, 14, 21... sin contexto. Es fundamental incluir el texto "x" y "=" para que se entienda que es una tabla de multiplicar.

Algoritmo TablaDinamica
    Definir num, limite, i, res Como Entero;
    
    Escribir "Ingrese el número base:";
    Leer num;
    
    Escribir "¿Hasta qué número quiere multiplicar? (Ej: 10, 20, 50):";
    Leer limite;
    
    // Validación básica: evitar límites negativos
    Si limite < 1 Entonces
        Escribir "Error: El límite debe ser positivo.";
    SiNo
        // Usamos la variable 'limite' en el ciclo Para
        Para i <- 1 Hasta limite Hacer
            res <- num * i;
            Escribir num, " x ", i, " = ", res;
        FinPara
    FinSi
    
FinAlgoritmo