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

Cuando hay más de dos opciones (ej: sin descuento, 10% y 20%), un simple Si-Entonces no basta. Necesitamos colocar un Si dentro de otro para crear una «escalera» de decisiones que verifique los montos de mayor a menor.

Recuerda: En programación no restamos «20» a 100. Multiplicamos por el factor decimal.
• Descuento = Monto * 0.20
• Total = Monto - Descuento

Algoritmo CalcularDescuentoCompra
    // 1. Definición de Variables
    // Todo dinero debe ser Real por los centavos
    Definir montoCompra, montoDescuento, totalPagar Como Real;
    Definir porcentaje Como Real; // Variable auxiliar para mostrar info
    
    // 2. Entrada de Datos
    Escribir "=== CAJA REGISTRADORA 2026 ===";
    Escribir "Ingrese el monto total de la compra:";
    Leer montoCompra;
    
    // 3. Lógica de Descuentos (Condicionales Anidados)
    // Importante: Evaluar del mayor al menor para evitar errores de rango
    
    Si montoCompra > 1000 Entonces
        // Caso: Compra mayor a $1000
        montoDescuento <- montoCompra * 0.20;
        porcentaje <- 20;
    SiNo
        Si montoCompra > 500 Entonces
            // Caso: Entre $501 y $1000
            montoDescuento <- montoCompra * 0.10;
            porcentaje <- 10;
        SiNo
            // Caso: $500 o menos (Sin descuento)
            montoDescuento <- 0;
            porcentaje <- 0;
        FinSi
    FinSi
    
    // Cálculo final
    totalPagar <- montoCompra - montoDescuento;
    
    // 4. Salida (Formato Ticket)
    Escribir "-------------------------------";
    Escribir "Subtotal:        $", montoCompra;
    Escribir "Descuento (", porcentaje, "%): -$", montoDescuento;
    Escribir "-------------------------------";
    Escribir "TOTAL A PAGAR:   $", totalPagar;
    Escribir "-------------------------------";
    
    // Mensaje de cortesía
    Si montoDescuento > 0 Entonces
        Escribir "¡Felicidades! Ahorraste dinero hoy.";
    FinSi
    
FinAlgoritmo

Si preguntas primero Si compra > 500, una compra de $2000 entrará en esa condición (porque 2000 es mayor que 500) y recibirá solo el 10% en lugar del 20%. Siempre evalúa del mayor al menor (o usa rangos con operador Y).

El código básico acepta «-100» como monto. En un sistema real, esto podría generar un «crédito» incorrecto. Siempre debemos validar que monto > 0.

Algoritmo DescuentoValidado
    Definir compra, desc, total Como Real;
    
    // Ciclo para asegurar un monto válido
    Repetir
        Escribir "Ingrese monto de compra (Positivo):";
        Leer compra;
        Si compra <= 0 Entonces
            Escribir "Error: El monto debe ser mayor a 0.";
        FinSi
    Hasta Que compra > 0
    
    // Usamos rangos explícitos con operador 'Y' para mayor seguridad
    Si compra > 1000 Entonces
        desc <- compra * 0.20;
    SiNo
        // Aquí decimos explícitamente el rango
        Si compra > 500 Y compra <= 1000 Entonces
            desc <- compra * 0.10;
        SiNo
            desc <- 0;
        FinSi
    FinSi
    
    total <- compra - desc;
    
    // Redondeo matemático a 2 decimales
    total <- redon(total * 100) / 100;
    
    Escribir "Total Final: $", total;
    
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

Si descubrimos que el número A es mayor que el número B, necesitamos intercambiar sus posiciones. Para hacer esto sin perder datos, utilizamos una variable auxiliar. (Recordar la analogía de los vasos: para intercambiar agua y jugo, necesitas un tercer vaso vacío).

Para garantizar que tres números (N1, N2, N3) queden ordenados, debemos realizar tres verificaciones estratégicas: comparar N1 con N2, N1 con N3, y finalmente N2 con N3. Si realizamos los intercambios necesarios en cada paso, los números «flotarán» a su posición correcta.

Algoritmo OrdenarTresNumeros
    // 1. Definición de Variables
    Definir n1, n2, n3, aux Como Real;
    
    // 2. Entrada de Datos
    Escribir "=== Ordenamiento Ascendente ===";
    Escribir "Ingrese el primer número:";
    Leer n1;
    Escribir "Ingrese el segundo número:";
    Leer n2;
    Escribir "Ingrese el tercer número:";
    Leer n3;
    
    // 3. Proceso: Método de Intercambio (Burbuja simplificada)
    
    // Paso A: Comparamos el 1ro con el 2do
    // Si n1 es mayor, los cambiamos de lugar.
    Si n1 > n2 Entonces
        aux <- n1;
        n1 <- n2;
        n2 <- aux;
    FinSi
    
    // Paso B: Comparamos el 1ro (que ya podría ser nuevo) con el 3ro
    // Esto asegura que n1 sea el más pequeño de todos
    Si n1 > n3 Entonces
        aux <- n1;
        n1 <- n3;
        n3 <- aux;
    FinSi
    
    // Paso C: Comparamos el 2do con el 3ro
    // Esto ordena los dos restantes
    Si n2 > n3 Entonces
        aux <- n2;
        n2 <- n3;
        n3 <- aux;
    FinSi
    
    // 4. Salida
    Escribir "-----------------------------";
    Escribir "Números Ordenados: ", n1, ", ", n2, ", ", n3;
    Escribir "-----------------------------";
    
FinAlgoritmo

Error clásico: Escribir n1 <- n2 y luego n2 <- n1. Al hacer la primera asignación, el valor original de n1 se borra para siempre. Siempre usa una variable aux.

Para ordenar de menor a mayor (ascendente), preguntamos si el anterior es Mayor (>) que el siguiente para cambiarlo. Si usas <, ordenarás de mayor a menor.

Algoritmo OrdenarConSiAnidados
    Definir a, b, c Como Real;
    Leer a, b, c;
    
    // Evaluamos quién es el menor de todos primero
    Si a < b Y a < c Entonces
        // 'a' es el menor. Ahora comparamos 'b' y 'c'
        Si b < c Entonces
            Escribir a, ", ", b, ", ", c;
        SiNo
            Escribir a, ", ", c, ", ", b;
        FinSi
    SiNo
        Si b < a Y b < c Entonces
            // 'b' es el menor. Comparamos 'a' y 'c'
            Si a < c Entonces
                Escribir b, ", ", a, ", ", c;
            SiNo
                Escribir b, ", ", c, ", ", a;
            FinSi
        SiNo
            // 'c' es el menor. Comparamos 'a' y 'b'
            Si a < b Entonces
                Escribir c, ", ", a, ", ", b;
            SiNo
                Escribir c, ", ", b, ", ", a;
            FinSi
        FinSi
    FinSi
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

Casi cualquier año divisible por 4 es bisiesto.
Ejemplo: 2004, 2008, 2024.
En PSeInt: anio MOD 4 == 0

Los años fin de siglo (divisibles por 100) NO son bisiestos, a menos que cumplan la tercera regla.
Ejemplo: 1700, 1800, 1900 no fueron bisiestos.

Si el año es divisible por 100, pero también por 400, SÍ es bisiesto.
Ejemplo: El año 2000 sí fue bisiesto.

Algoritmo DeterminarBisiesto
    // 1. Definición de Variables
    Definir anio Como Entero;
    
    // 2. Entrada de Datos
    Escribir "=== Validador de Años Bisiestos ===";
    Escribir "Ingrese el año a verificar (ej: 2024):";
    Leer anio;
    
    // 3. Proceso Lógico Compuesto
    // Leemos: Si (es divisible por 4 Y NO por 100) O (es divisible por 400)
    
    Si ((anio MOD 4 = 0) Y (anio MOD 100 <> 0)) O (anio MOD 400 = 0) Entonces
        Escribir "--------------------------------";
        Escribir "El año ", anio, " SÍ ES BISIESTO.";
        Escribir "Tiene 366 días (Febrero tiene 29).";
    SiNo
        Escribir "--------------------------------";
        Escribir "El año ", anio, " NO ES BISIESTO.";
        Escribir "Tiene 365 días (Febrero tiene 28).";
    FinSi
    
FinAlgoritmo

Escribir simplemente: Si anio MOD 4 = 0.
Por qué falla: Según este código incorrecto, el año 1900 sería bisiesto. Sin embargo, 1900 NO fue bisiesto porque es divisible por 100 pero no por 400. Esto desajusta el calendario solar.

En la expresión lógica, el orden importa.
Condicion1 Y Condicion2 O Condicion3 puede evaluarse distinto sin paréntesis. Siempre agrupa: (C1 Y C2) O C3 para asegurar que las excepciones se procesen juntas.

Algoritmo BisiestoAnidado
    Definir anio Como Entero;
    Escribir "Ingrese año:";
    Leer anio;
    
    // Paso 1: ¿Es divisible por 4?
    Si anio MOD 4 = 0 Entonces
        // Paso 2: ¿Es divisible por 100?
        Si anio MOD 100 = 0 Entonces
            // Paso 3: ¿Es divisible por 400?
            Si anio MOD 400 = 0 Entonces
                Escribir "ES BISIESTO (Divisible por 400)";
            SiNo
                Escribir "NO ES BISIESTO (Divisible por 100 pero no 400)";
            FinSi
        SiNo
            Escribir "ES BISIESTO (Divisible por 4 y no por 100)";
        FinSi
    SiNo
        Escribir "NO ES BISIESTO (No divisible por 4)";
    FinSi
FinAlgoritmo