El operador MOD nos da el residuo de una división. Si tienes 65 segundos y los divides entre 60 (1 minuto), sobra 5. Ese «5» es lo que obtenemos con 65 MOD 60. Es esencial para calcular los segundos y minutos restantes.

Al dividir segundos para obtener horas, el resultado suele tener decimales. En PSeInt, la función trunc() elimina los decimales, quedándose solo con la parte entera. Ejemplo: trunc(90 / 60) da 1 (no 1.5).

Algoritmo SegundosAHoras
    // 1. Definición de Variables
    // Todo debe ser Entero porque no existen "medias horas" en formato reloj digital
    Definir totalSeg, horas, minutos, seg, residuo Como Entero;
    
    // 2. Entrada de Datos
    Escribir "=== Conversor de Tiempo ===";
    Escribir "Ingrese la cantidad total de segundos:";
    Leer totalSeg;
    
    // 3. Proceso
    // Paso A: Calcular Horas (1 hora = 3600 segundos)
    horas <- trunc(totalSeg / 3600);
    
    // Paso B: Ver cuánto "sobra" después de quitar las horas
    residuo <- totalSeg MOD 3600;
    
    // Paso C: De lo que sobró, calcular Minutos (1 minuto = 60 segundos)
    minutos <- trunc(residuo / 60);
    
    // Paso D: Los segundos finales son lo que sobra de dividir entre 60
    seg <- residuo MOD 60;
    
    // 4. Salida de Resultados
    Escribir "--------------------------------";
    Escribir "El tiempo equivalente es:";
    Escribir horas, " Horas";
    Escribir minutos, " Minutos";
    Escribir seg, " Segundos";
    Escribir "Formato: ", horas, ":", minutos, ":", seg;
    Escribir "--------------------------------";
    
FinAlgoritmo

Si escribes horas <- total / 3600, PSeInt devolverá un decimal (ej: 1.5 horas). Un reloj no muestra "1.5 horas y 30 minutos", muestra "1 hora y 30 minutos". Es obligatorio cortar los decimales con trunc().

Error frecuente: minutos <- trunc(totalSeg / 60). Esto te dará el total absoluto de minutos (ej: 90 minutos), no los minutos *restantes* (30 minutos) después de sacar la hora. Debes usar el residuo, no el total original.

Algoritmo ConversorValidado
    Definir ts, h, m, s, r Como Entero;
    
    // Ciclo de validación: No acepta negativos
    Repetir
        Escribir "Ingrese los segundos totales (positivo):";
        Leer ts;
        Si ts < 0 Entonces
            Escribir "Error: El tiempo no puede ser negativo.";
        FinSi
    Hasta Que ts >= 0
    
    h <- trunc(ts / 3600);
    r <- ts MOD 3600;  // Residuo de horas
    m <- trunc(r / 60);
    s <- r MOD 60;     // Residuo final
    
    Escribir "Tiempo Convertido:";
    
    // Condicional para plurales (Estética)
    Si h = 1 Entonces
        Escribir h, " hora";
    SiNo
        Escribir h, " horas";
    FinSi
    
    Escribir m, " min y ", s, " seg";
    
FinAlgoritmo

La computadora no entiende el símbolo «%» directamente en una fórmula matemática. Debes recordar que un porcentaje es una fracción de 100.
• 21% se escribe como 0.21
• 16% se escribe como 0.16
• 50% se escribe como 0.50

Al trabajar con dinero, los decimales son obligatorios. Un precio puede ser $10.50 y su impuesto $1.68. Si defines las variables como Entero, PSeInt truncará los centavos, generando un error de cálculo financiero grave. Siempre usa Definir ... Como Real.

Algoritmo CalcularPrecioConIVA
    // 1. Definición de Variables
    // Todo dinero debe ser Real
    Definir precioBase, porcentajeIVA, montoIVA, precioFinal Como Real;
    
    // 2. Entrada de Datos
    Escribir "=== Calculadora de Impuestos (IVA) ===";
    Escribir "Ingrese el precio del producto (sin impuestos):";
    Leer precioBase;
    
    Escribir "Ingrese el % de IVA a aplicar (ej: 21, 16, 19):";
    Leer porcentajeIVA;
    
    // 3. Proceso
    // Convertimos el número entero (21) a decimal (0.21) dividiendo por 100
    montoIVA <- precioBase * (porcentajeIVA / 100);
    
    // Sumamos el impuesto al precio original
    precioFinal <- precioBase + montoIVA;
    
    // 4. Salida de Resultados (Desglose tipo Factura)
    Escribir "-----------------------------------";
    Escribir "Subtotal:      $", precioBase;
    Escribir "IVA (", porcentajeIVA, "%):      $", montoIVA;
    Escribir "-----------------------------------";
    Escribir "TOTAL A PAGAR: $", precioFinal;
    Escribir "-----------------------------------";
    
FinAlgoritmo

Error grave: impuesto <- precio * 21.
Esto multiplica el precio por 21 veces, no por el 21%. Si el usuario ingresa el número "21", tu código debe dividirlo entre 100 para convertirlo a 0.21.

Error: total <- precio + 0.21.
No puedes sumar dinero ($100) con un factor decimal (0.21). Debes sumar el *resultado* de la multiplicación: total <- precio + (precio * 0.21).

Algoritmo FacturaCompleta
    Definir precio, descuento, subtotal, iva, total Como Real;
    
    Escribir "Ingrese precio del producto:";
    Leer precio;
    
    // Si compra más de $1000, recibe 10% de descuento
    Si precio > 1000 Entonces
        descuento <- precio * 0.10;
        Escribir "¡Descuento aplicado del 10%!";
    SiNo
        descuento <- 0;
    FinSi
    
    subtotal <- precio - descuento;
    
    // Calculamos IVA sobre el precio ya descontado (Norma común)
    // Suponemos IVA fijo del 21%
    iva <- subtotal * 0.21; 
    
    total <- subtotal + iva;
    
    Escribir "=== FACTURA ===";
    Escribir "Precio Lista:  $", precio;
    Escribir "Descuento:    -$", descuento;
    Escribir "Subtotal:      $", subtotal;
    Escribir "IVA (21%):    +$", iva;
    Escribir "TOTAL:         $", total;
FinAlgoritmo

El dinero no es un número entero. Un pago por hora puede ser $15.50 o un salario total $450.75. Por ello, es obligatorio definir las variables de dinero (y usualmente las horas) como Real. Usar enteros provocaría pérdidas de centavos que, a gran escala, son graves errores contables.

En su forma más simple, el salario es Horas * Tarifa (Secuencial). Sin embargo, si el problema implica «Horas Extra» (pagar doble después de las 40 horas), necesitamos usar estructuras Si-Entonces para bifurcar el cálculo.

Algoritmo CalculoSalarioBasico
    // 1. Definición de Variables
    // Usamos Real para permitir centavos y fracciones de hora
    Definir horasTrabajadas, pagoPorHora, salarioSemanal Como Real;
    Definir nombreObrero Como Caracter;
    
    // 2. Entrada de Datos
    Escribir "=== Sistema de Nómina ===";
    Escribir "Ingrese el nombre del trabajador:";
    Leer nombreObrero;
    
    Escribir "Ingrese las horas trabajadas esta semana:";
    Leer horasTrabajadas;
    
    Escribir "Ingrese el pago por hora ($):";
    Leer pagoPorHora;
    
    // 3. Proceso
    salarioSemanal <- horasTrabajadas * pagoPorHora;
    
    // 4. Salida
    Escribir "--------------------------------";
    Escribir "Reporte de Pago para: ", nombreObrero;
    Escribir "Total a pagar: $", salarioSemanal;
    Escribir "--------------------------------";
    
FinAlgoritmo

Permitir que el usuario ingrese "-10 horas" o un precio de "-50 pesos". Matemáticamente la multiplicación funciona, pero en la lógica de negocios es un error grave. El código siempre debe validar que los números sean positivos.

En muchos países, trabajar más de 40 horas implica un pago doble por el tiempo excedente. Usar la fórmula simple H*P para alguien que trabajó 50 horas resultará en un pago menor al legal, lo cual es incorrecto en ejercicios intermedios.

Algoritmo SalarioConHorasExtra
    Definir horas, tarifa, salarioTotal, horasExtra, pagoExtra Como Real;
    
    Escribir "Ingrese horas trabajadas:";
    Leer horas;
    Escribir "Ingrese tarifa por hora:";
    Leer tarifa;
    
    // Validación de datos positivos
    Si horas > 0 Y tarifa > 0 Entonces
        
        // Lógica de Horas Extra
        Si horas > 40 Entonces
            horasExtra <- horas - 40;
            // Las primeras 40 normales + las extra al doble
            salarioTotal <- (40 * tarifa) + (horasExtra * tarifa * 2);
            
            Escribir "Horas normales: 40";
            Escribir "Horas extras (x2): ", horasExtra;
        SiNo
            // Si no hay extras, cálculo simple
            salarioTotal <- horas * tarifa;
        FinSi
        
        Escribir ">>> Sueldo Semanal Neto: $", salarioTotal;
        
    SiNo
        Escribir "Error: Los valores deben ser positivos.";
    FinSi
FinAlgoritmo

Para bajar en la «escalera» de unidades métricas, multiplicamos por potencias de 10:
• 1 Metro = 100 Centímetros (×100)
• 1 Metro = 1000 Milímetros (×1000)
En programación, usaremos el operador asterisco (*).

¿Qué pasa si el usuario quiere convertir «Medio metro» (0.5m)? Si declaramos la variable como Entero, PSeInt podría redondear a 0 o 1, dando un resultado falso. Por eso, siempre definiremos las unidades de medida como Real.

Algoritmo MetrosACentimetrosYMilimetros
    // 1. Definición de Variables
    // Definimos todo como Real para soportar decimales (ej: 1.5 metros)
    Definir metros, centimetros, milimetros Como Real;
    
    // 2. Entrada de Datos
    Escribir "=== Conversor de Unidades de Longitud ===";
    Escribir "Ingrese la cantidad de metros:";
    Leer metros;
    
    // 3. Proceso: Operaciones Aritméticas
    // 1 metro tiene 100 centímetros
    centimetros <- metros * 100;
    
    // 1 metro tiene 1000 milímetros
    milimetros <- metros * 1000;
    
    // 4. Salida de Resultados
    Escribir "---------------------------------------";
    Escribir "Resultados de la conversión:";
    Escribir metros, " metros equivalen a:";
    Escribir "> ", centimetros, " cm (Centímetros)";
    Escribir "> ", milimetros, " mm (Milímetros)";
    Escribir "---------------------------------------";
    
FinAlgoritmo

Error clásico: cm <- metros / 100. Esto sería correcto si estuviéramos convirtiendo de centímetros a metros. Recuerda: de unidad grande a pequeña se multiplica; de pequeña a grande se divide.

Si al ejecutar escribes "1,5", PSeInt podría lanzar un error dependiendo de su configuración regional. Acostúmbrate a usar el punto decimal "1.5" en programación.

Algoritmo ConversorValidado
    Definir metros, cm, mm Como Real;
    
    // Usamos un ciclo 'Repetir' para obligar a un dato válido
    Repetir
        Escribir "Ingrese la cantidad de metros (debe ser positivo):";
        Leer metros;
        
        Si metros < 0 Entonces
            Escribir "ERROR: La distancia no puede ser negativa.";
            Escribir "Inténtelo de nuevo.";
        FinSi
    Hasta Que metros >= 0
    
    // Una vez validado, procedemos al cálculo
    cm <- metros * 100;
    mm <- metros * 1000;
    
    Escribir "--- Conversión Exitosa ---";
    Escribir metros, " m = ", cm, " cm";
    Escribir metros, " m = ", mm, " mm";
    
FinAlgoritmo

Imagina que tienes un vaso con Jugo (A) y otro con Agua (B). Si viertes el agua directamente en el vaso del jugo, el jugo se pierde (se derrama o se mezcla). En programación, hacer A <- B destruye instantáneamente el valor original de A.

Para intercambiar los líquidos sin perderlos, necesitas un tercer vaso vacío (Auxiliar). 1. Viertes el Jugo (A) en el Vaso Vacío (Aux). 2. Viertes el Agua (B) en el vaso de Jugo (A). 3. Viertes el contenido del Vaso Auxiliar en el vaso de Agua (B).

Algoritmo IntercambioDeVariables
    // 1. Definición de variables
    // Necesitamos una variable 'aux' del mismo tipo que las originales
    Definir valorA, valorB, aux Como Entero;
    
    // 2. Entrada de datos
    Escribir "--- Antes del Intercambio ---";
    Escribir "Ingrese el valor de A:";
    Leer valorA;
    Escribir "Ingrese el valor de B:";
    Leer valorB;
    
    Escribir "Original -> A vale: ", valorA, " y B vale: ", valorB;
    
    // 3. Proceso de Intercambio (Swap)
    // Paso 1: Resguardamos el valor de A en Aux
    aux <- valorA;
    
    // Paso 2: Ahora es seguro sobrescribir A con el valor de B
    valorA <- valorB;
    
    // Paso 3: Recuperamos el valor original de A (desde Aux) y lo ponemos en B
    valorB <- aux;
    
    // 4. Salida de resultados
    Escribir "";
    Escribir "--- Después del Intercambio ---";
    Escribir "Ahora -> A vale: ", valorA, " y B vale: ", valorB;
    
FinAlgoritmo

Escribir:
A <- B
B <- A
¿Qué pasa aquí? En la primera línea, A toma el valor de B. El valor original de A desaparece. En la segunda línea, B toma el valor de A (que ahora es igual a B). Resultado: Ambas variables terminan valiendo lo mismo que B originalmente.

Si A y B son Reales (decimales) pero defines aux como Entero, perderás los decimales durante el intercambio. La variable auxiliar siempre debe ser del mismo tipo que las variables que estás moviendo.

Algoritmo SwapMatematico
    Definir A, B Como Entero;
    
    A <- 50;
    B <- 20;
    
    Escribir "Inicio: A=", A, " B=", B;
    
    // Truco matemático:
    // Imaginemos que A y B son contenedores de "peso"
    
    // 1. Sumamos ambos pesos en A
    A <- A + B;  // A ahora vale 70 (50+20)
    
    // 2. Quitamos el peso original de B a la suma total
    B <- A - B;  // 70 - 20 = 50. ¡B ahora tiene el valor original de A!
    
    // 3. Quitamos el nuevo peso de B a la suma total
    A <- A - B;  // 70 - 50 = 20. ¡A ahora tiene el valor original de B!
    
    Escribir "Final: A=", A, " B=", B;
    
FinAlgoritmo

Las calificaciones académicas suelen tener decimales (ej: 8.5 o 4.7). Si definimos las variables como Entero, PSeInt eliminará la parte decimal, generando un cálculo inexacto. Por ello, es obligatorio usar Definir ... Como Real.

La regla de oro en matemáticas: la división tiene prioridad sobre la suma. Si escribes n1+n2+n3/3, la computadora solo dividirá la última nota. Debemos agrupar la suma con paréntesis: (n1+n2+n3)/3.

Algoritmo CalcularPromedioNotas
    // 1. Definición de Variables
    // Usamos Real para soportar notas como 4.5 o 9.8
    Definir nota1, nota2, nota3, promedio Como Real;
    
    // 2. Entrada de Datos
    Escribir "=== SISTEMA DE CALIFICACIONES ===";
    Escribir "Ingrese la calificación del primer parcial:";
    Leer nota1;
    Escribir "Ingrese la calificación del segundo parcial:";
    Leer nota2;
    Escribir "Ingrese la calificación del tercer parcial:";
    Leer nota3;
    
    // 3. Proceso: Cálculo Matemático
    // IMPORTANTE: Los paréntesis obligan a sumar antes de dividir
    promedio <- (nota1 + nota2 + nota3) / 3;
    
    // 4. Salida de Resultados y Condicional
    Escribir "-----------------------------";
    Escribir "El promedio final es: ", promedio;
    
    // Suponemos que la nota mínima para aprobar es 6.0
    Si promedio >= 6.0 Entonces
        Escribir "Estado: APROBADO. ¡Felicidades!";
    SiNo
        Escribir "Estado: REPROBADO. Necesitas mejorar.";
    FinSi
    Escribir "-----------------------------";
    
FinAlgoritmo

Error: prom = n1 + n2 + n3 / 3.
Consecuencia: Si las notas son 10, 10 y 10, el resultado será 23.33 en lugar de 10. La máquina divide 10/3 y le suma 20.

No validar que las notas estén entre 0 y 10. Si el usuario ingresa «50» por error, el promedio será imposiblemente alto, rompiendo la lógica del sistema escolar.

Algoritmo PromedioSeguro
    Definir n1, n2, n3, prom Como Real;
    Definir datosValidos Como Logico;
    
    Repetir
        Escribir "Ingrese las 3 notas (separadas por Enter):";
        Leer n1, n2, n3;
        
        // Validamos que todas las notas estén en rango 0-10
        Si (n1<0 O n1>10) O (n2<0 O n2>10) O (n3<0 O n3>10) Entonces
            Escribir "ERROR: Alguna nota no está entre 0 y 10.";
            datosValidos <- Falso;
        SiNo
            datosValidos <- Verdadero;
        FinSi
    Hasta Que datosValidos = Verdadero;
    
    prom <- (n1 + n2 + n3) / 3;
    
    // Redondeamos a 2 decimales para mejor presentación
    prom <- redon(prom * 100) / 100;
    
    Escribir "Promedio Final Validado: ", prom;
    
    // Estructura Si-Entonces anidada para mensajes específicos
    Si prom >= 9 Entonces
        Escribir "Nivel: EXCELENTE";
    SiNo
        Si prom >= 6 Entonces
            Escribir "Nivel: REGULAR (Aprobado)";
        SiNo
            Escribir "Nivel: INSUFICIENTE (Reprobado)";
        FinSi
    FinSi
FinAlgoritmo

La temperatura rara vez es un número entero exacto (ej: 36.6°C). Por tanto, es obligatorio definir nuestras variables (tanto para Celsius como Fahrenheit) como Real. Si usamos Entero, PSeInt truncará los resultados, perdiendo precisión crítica en la conversión.

La relación matemática estándar es: F = (C × 1.8) + 32.
Nota: A veces verás 9/5 en lugar de 1.8. En programación, ambas son válidas, pero usar 1.8 es más directo y evita posibles confusiones con la división entera en otros lenguajes.

Algoritmo CelsiusAFahrenheit
    // 1. Definición de Variables
    // Es CRUCIAL usar 'Real' para temperaturas precisas
    Definir gradosC, gradosF Como Real;
    
    // 2. Entrada de Datos
    Escribir "=== Conversor de Temperatura ===";
    Escribir "Ingrese la temperatura en grados Celsius (°C):";
    Leer gradosC;
    
    // 3. Proceso: Fórmula (C * 1.8) + 32
    // Se puede usar 9/5 en lugar de 1.8, es equivalente.
    gradosF <- (gradosC * 1.8) + 32;
    
    // 4. Salida de Datos
    Escribir "--------------------------------";
    Escribir gradosC, "° Celsius equivalen a:";
    Escribir gradosF, "° Fahrenheit";
    Escribir "--------------------------------";
    
FinAlgoritmo

Escribir C + 32 * 1.8 dará un resultado incorrecto porque la multiplicación se ejecuta antes que la suma. La fórmula correcta suma 32 después de multiplicar.

No confundas la fórmula de ida con la de vuelta.
De °C a °F se multiplica y suma.
De °F a °C se resta y divide: (F - 32) / 1.8.

Algoritmo ConversorPro
    Definir tempEntrada, tempSalida Como Real;
    Definir opcion Como Entero;
    
    Escribir "=== MASTER CONVERTER 2026 ===";
    Escribir "1. Convertir Celsius a Fahrenheit";
    Escribir "2. Convertir Fahrenheit a Celsius";
    Escribir "Elija una opción (1 o 2):";
    Leer opcion;
    
    Segun opcion Hacer
        1:
            Escribir "Ingrese grados Celsius:";
            Leer tempEntrada;
            tempSalida <- (tempEntrada * 1.8) + 32;
            Escribir tempEntrada, "°C son ", tempSalida, "°F";
        2:
            Escribir "Ingrese grados Fahrenheit:";
            Leer tempEntrada;
            // Ojo a los paréntesis aquí: primero la resta
            tempSalida <- (tempEntrada - 32) / 1.8;
            Escribir tempEntrada, "°F son ", tempSalida, "°C";
        De Otro Modo:
            Escribir "Opción no válida. Reinicie el programa.";
    FinSegun
    
FinAlgoritmo

En matemáticas, PI es aproximadamente 3.14159… En programación, en lugar de escribir este número manualmente (lo cual es propenso a errores), utilizamos la función incorporada de PSeInt llamada PI. Esto garantiza la máxima precisión posible en nuestros cálculos de área y perímetro.

La fórmula del área requiere elevar el radio al cuadrado ($r^2$). En PSeInt, esto se logra con el operador circunflejo ^ (ej: radio ^ 2). Es un error común intentar usar la multiplicación simple cuando se requiere una operación exponencial.

Algoritmo AreaYPerimetroCirculo
    // 1. Definición de Variables
    // Es vital usar 'Real' porque PI tiene decimales infinitos
    Definir radio, area, perimetro Como Real;
    
    // 2. Entrada de Datos
    Escribir "Bienvenido al calculador geométrico.";
    Escribir "Por favor, ingrese el radio del círculo:";
    Leer radio;
    
    // 3. Proceso: Aplicación de Fórmulas
    // Usamos la función interna PI de PSeInt para mayor precisión
    // El operador '^' eleva al cuadrado
    area <- PI * (radio ^ 2);
    
    // Fórmula del perímetro: 2 * PI * r
    perimetro <- 2 * PI * radio;
    
    // 4. Salida de Datos
    Escribir "-----------------------------------";
    Escribir "Resultados para un radio de ", radio, ":";
    Escribir "El AREA del círculo es: ", area;
    Escribir "El PERÍMETRO del círculo es: ", perimetro;
    Escribir "-----------------------------------";
    
FinAlgoritmo

Muchos estudiantes escriben radio * 2 en lugar de radio ^ 2. Multiplicar por 2 es duplicar; elevar a la 2 es multiplicar el número por sí mismo. ¡Esto cambia drásticamente el resultado del área!

En la geometría euclidiana real, no existen círculos con radio negativo. Si el usuario ingresa "-5", las fórmulas darán un resultado numérico, pero geométricamente carece de sentido. Es buena práctica validar esto.

Algoritmo CirculoValidado
    Definir radio, area, perimetro Como Real;
    
    Escribir "Ingrese el radio del círculo:";
    Leer radio;
    
    // Validación lógica: El radio debe ser positivo
    Si radio > 0 Entonces
        // Solo calculamos si el dato es válido
        area <- PI * (radio ^ 2);
        perimetro <- 2 * PI * radio;
        
        // Función redon para mostrar menos decimales (opcional)
        // Multiplicamos por 100 y dividimos por 100 para dejar 2 decimales
        area <- redon(area * 100) / 100;
        perimetro <- redon(perimetro * 100) / 100;
        
        Escribir "Área: ", area;
        Escribir "Perímetro: ", perimetro;
    SiNo
        // Mensaje de error si el usuario ingresa 0 o negativos
        Escribir "ERROR: El radio debe ser un número mayor a cero.";
        Escribir "Intente ejecutar el programa nuevamente.";
    FinSi
    
FinAlgoritmo

En matemáticas, si divides un número impar entre 2 (ejemplo: 7 de base y 1 de altura), el resultado es 3.5. En programación, si defines tus variables como Entero, el sistema podría truncar el decimal y devolver «3», lo cual es un error lógico grave. Por ello, en PSeInt utilizaremos el tipo Real para garantizar la precisión en divisiones.

La computadora sigue un orden estricto al resolver matemáticas. Aunque en la fórmula (b * h) / 2 la multiplicación y la división tienen la misma jerarquía (se resuelven de izquierda a derecha), el uso de paréntesis es una buena práctica de programación para asegurar que la multiplicación ocurra antes de la división, manteniendo el código legible y ordenado.

Algoritmo AreaTriangulo
    // 1. Declaración de Variables
    // Es fundamental usar 'Real' para no perder los decimales en la división
    Definir base, altura, area Como Real;
    
    // 2. Entrada de Datos (Interacción con el usuario)
    Escribir "--- CALCULADORA DE ÁREA DE TRIÁNGULOS ---";
    Escribir "Por favor, ingrese el valor de la base:";
    Leer base;
    
    Escribir "Por favor, ingrese el valor de la altura:";
    Leer altura;
    
    // 3. Proceso (Operación Aritmética)
    // Usamos paréntesis para agrupar la multiplicación
    area <- (base * altura) / 2;
    
    // 4. Salida de Resultados
    Escribir "-----------------------------------------";
    Escribir "El área del triángulo es: ", area;
FinAlgoritmo

Si defines las variables como Como Entero e intentas ingresar una base de 5.5, PSeInt lanzará un error de ejecución "No coinciden los tipos". Siempre usa Como Real para medidas geométricas, ya que la realidad rara vez se mide en números enteros perfectos.

Matemáticamente, el algoritmo aceptará si ingresas una base de "-10". El programa calculará un área negativa, lo cual es geométricamente imposible. Este es un error de lógica de negocio, no de sintaxis, y se soluciona agregando validación de datos.

Algoritmo AreaTrianguloValidado
    Definir base, altura, area Como Real;
    
    Escribir "Ingrese la base del triángulo (> 0):";
    Leer base;
    
    Escribir "Ingrese la altura del triángulo (> 0):";
    Leer altura;
    
    // Validamos que ambos valores sean positivos
    Si base > 0 Y altura > 0 Entonces
        area <- (base * altura) / 2;
        Escribir ">> El área calculada es: ", area;
    SiNo
        // Mensaje de error si los datos son incorrectos
        Escribir "❌ Error: La base y la altura deben ser mayores a cero.";
        Escribir "   No existen distancias negativas en geometría.";
    FinSi
FinAlgoritmo

En PSeInt, debemos especificar qué tipo de datos guardaremos. Para este ejercicio usamos Como Entero, lo que significa que el programa solo aceptará números completos (ej: 5, 10, -3) y no permitirá decimales (ej: 4.5), optimizando el uso de memoria.

A diferencia de las matemáticas donde usamos el igual (=), en pseudocódigo usamos una flecha <-. Esto indica que el resultado de la suma (derecha) se «guarda» dentro de la variable destino (izquierda).

Algoritmo SumarDosNumeros
    // 1. Definición de variables (Solo números enteros)
    Definir num1, num2, resultado Como Entero;
    
    // 2. Entrada de Datos
    Escribir "Ingrese el primer número entero:";
    Leer num1;
    
    Escribir "Ingrese el segundo número entero:";
    Leer num2;
    
    // 3. Proceso (Operación Matemática)
    resultado <- num1 + num2;
    
    // 4. Salida de Información
    Escribir "La suma de ", num1, " + ", num2, " es: ", resultado;
FinAlgoritmo

Si intentas ingresar un número decimal (ej. 4.5) cuando la variable se definió Como Entero, PSeInt lanzará un error de ejecución. Asegúrate de ingresar solo números completos.

Un error frecuente es intentar sumar resultado <- num1 + num2 antes de usar el comando Leer. La computadora lee el código de arriba a abajo; si no tiene los datos primero, la suma será 0 o dará error.

Algoritmo SumaContinua
    Definir n1, n2, res Como Entero;
    Definir tecla Como Caracter;
    
    Repetir
        Limpiar Pantalla;
        Escribir "--- SUMADORA DE ENTEROS ---";
        Escribir "Ingrese primer número:";
        Leer n1;
        Escribir "Ingrese segundo número:";
        Leer n2;
        
        res <- n1 + n2;
        
        Escribir ">> Resultado: ", res;
        Escribir "";
        Escribir "¿Desea sumar de nuevo? (S/N)";
        Leer tecla;
    Hasta Que tecla = "N" o tecla = "n"
    
    Escribir "Programa finalizado.";
FinAlgoritmo