Algoritmo para Calcular el Factorial (N!) en PSeInt (Guía 2026)

Nivel: Intermedio Tiempo: ~15 min

El cálculo del factorial es un clásico de las matemáticas y la programación, esencial para entender probabilidad, estadística y algoritmos de permutación. Representado como N!, consiste en multiplicar un número por todos sus antecesores hasta llegar al 1 (ejemplo: 5! = 5*4*3*2*1 = 120). En este tutorial de Lógica de Programación con PSeInt, aprenderás a implementar este cálculo utilizando Ciclos (Bucles) y, lo más importante, comprenderás el concepto de Acumulador Multiplicativo, una técnica vital que diferencia a los programadores novatos de los intermedios.

Conceptos Clave: Acumuladores y Matemáticas

Antes de codificar, debemos aclarar dos reglas de oro que harán que tu algoritmo funcione correctamente:

Inicialización en 1 (No en 0)

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.

El Caso del Cero (0!)

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.

Análisis del Algoritmo

El flujo para calcular N! sigue estos pasos estructurados:

  • ENTRADA Solicitar un número entero positivo (N). Si el usuario ingresa negativos, el factorial no está definido (en los reales básicos).
  • PROCESO 1. Inicializar resultado = 1.
    2. Usar un ciclo (Para o Mientras) que vaya desde 1 hasta N.
    3. En cada vuelta, actualizar: resultado = resultado * contador.
  • SALIDA Mostrar el valor final acumulado. Ej: "El factorial de 5 es 120".

Código Fuente (Solución con Ciclo Para)

Archivo: Factorial.psc
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

Diagrama de Flujo

⚠️ Errores Comunes: Por qué tu código da Cero

El cálculo factorial tiene trampas específicas que debes evitar:

Inicializar en Cero

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.

Desbordamiento (Overflow)

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.

Reto: Validación Robusta y Ciclo Repetitivo

Vamos a profesionalizar el código. Esta versión usa un ciclo Repetir para asegurar que el usuario ingrese un número válido (no negativo) y maneja el caso especial del 0 de forma explícita.

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

Preguntas Frecuentes (FAQ)

¿Qué es la Recursividad en Factorial?
Es una técnica avanzada donde una función se llama a sí misma. Factorial(n) = n * Factorial(n-1). PSeInt soporta subprocesos recursivos, pero los ciclos (iterativo) son más eficientes en memoria.
¿Por qué el factorial de 0 es 1?
Es una convención matemática necesaria para que fórmulas de combinatoria y series de Taylor funcionen. Representa que hay "una sola forma" de ordenar cero elementos (el conjunto vacío).
¿Cuál es el número más grande que puedo calcular?
Depende de tu computadora, pero generalmente 170! es el límite para variables de tipo doble precisión (Real) antes de devolver "Infinito".
¿Puedo usar el ciclo Mientras?
¡Sí! Inicializa i=1 antes, y dentro del ciclo haces fact = fact * i y luego i = i + 1. El resultado es idéntico.

¿Listo para el siguiente nivel?

Domina la lógica de programación con nuestra colección completa.

Ver Más Ejercicios Resueltos

Publicaciones Similares

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *