Factorial Recursivo en C: Implementación y Ejemplo

Clase 27 de 42 • Curso Práctico de Estructuras de Datos y Algoritmos

Resumen

En esta clase aplicaremos la función factorial que diseñamos en la clase pasada utilizando recursividad. ¡Prepárate para programar tu primer función recursiva con datos ingresados por los usuarios!

Vander Idme

student•

Vista grafica del algoritmo

Brayan Potosi Dominguez

student•

printf(&quot;Calmate por favor&quot;)

😅

Francisco Angel Núñez Luna

student•

hahaha fue muy cagado

Nicolás Bruno

student•

ja ja jaja

Manuel Rivera

student•

JAVASCRIPT

function factorial_c(num){ 
    if(num === 0){
        return 1
    } 
    return (num * factorial_c(num - 1))
}

let usuario = parseInt((prompt("¿Ingresa un número de 0 y no mayor a 90")))
if ( usuario < 0 ){
    console.log(`El número ${usuario} no es positivo`)

}
else if (usuario > 90){
    console.log(`El número ${usuario} es muy grande `)

} else {
    console.log( `El factorial de ${usuario} es ${factorial_c(usuario)}`)
}```

Mauricio Gomez

student•

Python

def factorial(n):
    if n == 1:
        return 1

    return n * factorial(n-1)

n = int(input(&quot;Dame un numero entero: &quot;))

print(factorial(n))```

Dario Arcos

student•

Algunas optimizaciones a este código para que sea mas limpio y eficiente.

#include<stdio.h>

long factorial(int n)
{   
    if(n == 0) 
        return 1;
    
    return(n * factorial(n-1));
}

int main(int n)
{
    printf("Ingresa el numero a calcular: ");
    scanf("%d", &n);
    if (n<0) 
    {
        printf("El numero debe ser positivo");
    }
    else
    {
       printf("El factorial de %d! es: %ld", n, factorial(n));
    }
    
    return 0;
}```

Ricardo Celis

teacher•

muy buena implementacion!

Juan Castro

teacher•

Adriana Ardila

student•

¿Cómo haces para que las capturas de pantalla se vean así? ¿Qué programa usas?

Juan Castro

teacher•

Puedes usar https://cabon.now.sh. :wink:

Karen Paola Diaz Duarte

student•

Victor Hugo Vázquez Gómez

student•

¿Qué es la recursión? El proceso por el cual una función se llama a sí misma directa o indirectamente se llama 'recursión' y la función correspondiente es llamada 'función recursiva'. Al usar un algoritmo de recursión, ciertos problemas pueden ser resueltos más fácil.

Ejemplos de éstos problemas son: 1.- Las torres de Hanoi. 2.- Recorrido de árboles inorden, preorden, postorden. 3.- El factorial de un número. ¿Qué es la condición base en recursión? En el programa recursivo, se proporciona la solución al caso base y la solución del problema más grande se expresa en términos de problemas más grandes. ¿Cómo un problema en particular es resuelto usando la recursividad? La idea es presentar el problema en términos de uno o más problemas pequeños y añadir uno o más casos base para detener la recursión. Por ejemplo: calculamos el factorial 'n' si sabemos el factorial de 'n-1'. El caso base sería que n=0. Devolvemos 1 cuando n =0.

alexander garcia castañeda

student•

comparto la sucesión de fibonacci

logging.basicConfig(level=logging.INFO)
def fibonacci(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    return fibonacci(n-1)+fibonacci(n-2)

n=6     
fibo=fibonacci(n)
logging.info('el fibonaci de {0} es {1}'.format(n,fibo))

Fernando Reséndiz Bautista

student•

#include <stdio.h>

int factorial(int n){
    if(n == 0){
        return 1;
    }
    return n * factorial(n-1);
}



int main()
{
    int n;
    do{
        printf("Ingrese el numero del que quiere obtener el factorial \n");
        scanf("%d", &n);
    }while(n<0);

    printf("%d! = %d\n", n, factorial(n));

    return 0;
}

Enrique Orozco Gaytán

student•

Hay una extension en VSCode que sirve para identicar Paréntesis y llaves con diferentes colores:

https://marketplace.visualstudio.com/items?itemName=CoenraadS.bracket-pair-colorizer

Realmente es mucha ayuda.

Ezequiel Matías Rolón Pettinari

student•

Mi codigo en C#

    class Factorial
    {
        /// &lt;summary&gt;
        /// Funcion para calcular el factorial de un numero.
        /// &lt;/summary&gt;
        /// &lt;param name=&quot;numero&quot;&gt; El numero del que queremos saber el factorial.&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static long CalcularFactorial(int numero) {

            long resultado = 0;

            if (numero &lt; 0)
            {

                Console.WriteLine(&quot;El numero debe ser positivo.&quot;);

            }
            else
            {
                if (numero == 0)
                {
                    resultado = 1;
                }
                else
                {
                    return (numero * CalcularFactorial( numero - 1 ));
                }

            }

            return resultado;

        }//Final de public long CalcularFactorial(int numero)


        //Ejemplo calcular en Main
        //Calculo factorial
        //Console.WriteLine(Factorial.CalcularFactorial(10) );

    }// Fin de: class Factorial```

Henry Gutierrez Mora

student•

#include&lt;stdio.h&gt;
//Declaramos varaibls
long resultado;
int n;

long factorial(int n){
    if(n == 0)
    return 1;
    else
        return(n* factorial(n-1));
}
int main(int argc, char const *argv[])
{
    printf(&quot;Ingrese el numero a calcular \n&quot;);
    scanf(&quot;%d&quot;,&amp;n);
    if(n&lt;0)
    {
        printf(&quot;El numero debe ser positivo \n&quot;);
    }
    else
        resultado = factorial(n);
        printf(&quot;%d! = %ld\n&quot;, n, resultado);
    
    return 0;
}```

Wilmer Diaz

student•

En python


# Pidiendo el número al usuario
number = int(input(&quot;Ingrese un valor \n&quot;))  

# Estableciendo la función
def factorial(number):
        if number==0: 
            return 1
        elif number&lt;0:
            return &quot;... Ups solo enteros positivos&quot;
        else:    
            return number*factorial(number-1)

print(&quot;El factorial es {} &quot; .format(factorial(number)))





if __name__ == &quot;__main__&quot;:
     factorial(number)

Alfonso Neil Jiménez Casallas

student•

sinceramente prefiero implementar la versión iterativa del factorial antes que la versión recursiva, ya que en este último caso, la complejidad es de O(2^n) y en el primer caso es de O(n), la diferencia es mayor cuando el valor de n es muy grande

Angel Armando Martínez Blanco

student•

Declarar variables dentro de main (locales) las limita a esa función, liberando su memoria al finalizar. Declararlas fuera (globales) las hace accesibles desde cualquier función del programa, pero ocupan memoria durante toda la ejecución.

Gabriel Obregón

student•

✨ Factorial con recursividad en C

👉 Programar una función recursiva que calcule el factorial de un número ingresado por el usuario.

📝 Pasos del programa

🔢 1. Pedir número al usuario

❌ 2. Si es negativo → mostrar error.

✅ 3. Si es 0 o positivo → calcular factorial.

🔄 4. Usar función recursiva.

📤 5. Mostrar el resultado en pantalla.

🧩 Concepto clave

📌 Caso base

factorial(0) = 1

📌 Caso recursivo

factorial(n) = n × factorial(n - 1)

💻 Código esencial

long factorial(int n) {

if (n == 0)

return 1; // Caso base

else

return n * factorial(n-1); // Caso recursivo

}

⚙️ Estructura del programa principal

🔸 Entrada → número entero n 🔸 Condición →

Si n < 0 → ❌ error
Si n >= 0 → ✅ calcular factorial 🔸 Salida → imprimir n! = resultado

🚀 Recuerda

✔️ El factorial solo existe para enteros no negativos.

✔️ La recursividad divide el problema en pasos más pequeños.

✔️ Siempre debe existir un caso base para detener la recursión.

Jose Daniel Hernandez Quiceno

student•

No entiendo muy bien como funcionan los stacks cuando se empiezan a ejecutar al cumplirse el condicional

Entiendo que se acumulan los return (n * factorial(n-1)) pero no entiendo cual es el calculo y el flujo de datos para que al final nos entregue un Return Value correcto

Hector Esau M

student•

Es algo así factorial(3) = 3 * factorial(2) factorial(2) = 2 * factorial(1) factorial(1) = 1 Ya que resolvimos el caso"base" quedaría así factorial(2) = 2 * 1 = 2 factorial(3) = 3 * factorial(2) Recordemos que factorial(2) es igual a 2 así que se haría esto factorial(3) = 3 * 2

Juan Pablo Perez

student•

Hola Jose Es como si se empezaran los otros procesos aparte para llegar al resultado que despues vamos a meter a la parte inicial, un buen ejercicio podría ser tratar de hacer lo que hace la maquina para comprenderlo.

Espero le sirva a alguien.

Carlos Santaniello

student•

Me está generando éste error al momento de compilar:

recursividad.c: In function ‘main’:
recursividad.c:16:9: warning: too many arguments for format [-Wformat-extra-args]
   scanf("$d", &n);
         ^~~~

Adjunto código fuente:

#include<stdio.h>

long result;
int n;

long factorial(int n){
  if (n == 0)
    return 1;
  else
    return (n*factorial(n-1));
}

int main(int argc, char const *argv[])
{
  printf("Ingrese el numero a calcular\n");
  scanf("$d", &n);
  if (n < 0)
  {
    printf("El numero debe ser positivo\n");
  }
  else
  {
    result = factorial(n);
    printf("%d! = %ld\n", n, result);
  }
  return 0;
}

Danelia Sanchez Sanchez

student•

En la función scanf, se usa el especificador de formato con el símbolo %

scanf("%d", &n);

Didier Stiven Niño Alba

student•

Bash:

# !/bin/bash

rx_n="^[0-9]{1,4}$"

function factorial() {

$1

if [[ $1 -eq 0 ]]; then

echo 1

else

prev=$(factorial $(($1-1)))

echo $(($1*prev))

fi

}

read -p "Ingrese el numero que desea sacar factorial: " n

if [[ $n =~ $rx_n ]]; then

factorial $n

else

echo "El numero es demaciado grande o no es un numero.."

fi

function factorial_c(num){ 
    if(num === 0){
        return 1
    } 
    return (num * factorial_c(num - 1))
}

let usuario = parseInt((prompt("¿Ingresa un número de 0 y no mayor a 90")))
if ( usuario < 0 ){
    console.log(`El número ${usuario} no es positivo`)

}
else if (usuario > 90){
    console.log(`El número ${usuario} es muy grande `)

} else {
    console.log( `El factorial de ${usuario} es ${factorial_c(usuario)}`)
}```

#include<stdio.h>

long factorial(int n)
{   
    if(n == 0) 
        return 1;
    
    return(n * factorial(n-1));
}

int main(int n)
{
    printf("Ingresa el numero a calcular: ");
    scanf("%d", &n);
    if (n<0) 
    {
        printf("El numero debe ser positivo");
    }
    else
    {
       printf("El factorial de %d! es: %ld", n, factorial(n));
    }
    
    return 0;
}```

logging.basicConfig(level=logging.INFO)
def fibonacci(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    return fibonacci(n-1)+fibonacci(n-2)

n=6     
fibo=fibonacci(n)
logging.info('el fibonaci de {0} es {1}'.format(n,fibo))

#include <stdio.h>

int factorial(int n){
    if(n == 0){
        return 1;
    }
    return n * factorial(n-1);
}



int main()
{
    int n;
    do{
        printf("Ingrese el numero del que quiere obtener el factorial \n");
        scanf("%d", &n);
    }while(n<0);

    printf("%d! = %d\n", n, factorial(n));

    return 0;
}

    class Factorial
    {
        /// &lt;summary&gt;
        /// Funcion para calcular el factorial de un numero.
        /// &lt;/summary&gt;
        /// &lt;param name=&quot;numero&quot;&gt; El numero del que queremos saber el factorial.&lt;/param&gt;
        /// &lt;returns&gt;&lt;/returns&gt;
        public static long CalcularFactorial(int numero) {

            long resultado = 0;

            if (numero &lt; 0)
            {

                Console.WriteLine(&quot;El numero debe ser positivo.&quot;);

            }
            else
            {
                if (numero == 0)
                {
                    resultado = 1;
                }
                else
                {
                    return (numero * CalcularFactorial( numero - 1 ));
                }

            }

            return resultado;

        }//Final de public long CalcularFactorial(int numero)


        //Ejemplo calcular en Main
        //Calculo factorial
        //Console.WriteLine(Factorial.CalcularFactorial(10) );

    }// Fin de: class Factorial```

#include&lt;stdio.h&gt;
//Declaramos varaibls
long resultado;
int n;

long factorial(int n){
    if(n == 0)
    return 1;
    else
        return(n* factorial(n-1));
}
int main(int argc, char const *argv[])
{
    printf(&quot;Ingrese el numero a calcular \n&quot;);
    scanf(&quot;%d&quot;,&amp;n);
    if(n&lt;0)
    {
        printf(&quot;El numero debe ser positivo \n&quot;);
    }
    else
        resultado = factorial(n);
        printf(&quot;%d! = %ld\n&quot;, n, resultado);
    
    return 0;
}```

# Pidiendo el número al usuario
number = int(input(&quot;Ingrese un valor \n&quot;))  

# Estableciendo la función
def factorial(number):
        if number==0: 
            return 1
        elif number&lt;0:
            return &quot;... Ups solo enteros positivos&quot;
        else:    
            return number*factorial(number-1)

print(&quot;El factorial es {} &quot; .format(factorial(number)))





if __name__ == &quot;__main__&quot;:
     factorial(number)

#include<stdio.h>

long result;
int n;

long factorial(int n){
  if (n == 0)
    return 1;
  else
    return (n*factorial(n-1));
}

int main(int argc, char const *argv[])
{
  printf("Ingrese el numero a calcular\n");
  scanf("$d", &n);
  if (n < 0)
  {
    printf("El numero debe ser positivo\n");
  }
  else
  {
    result = factorial(n);
    printf("%d! = %ld\n", n, result);
  }
  return 0;
}

Factorial Recursivo en C: Implementación y Ejemplo

Bienvenido al Curso

Algoritmos y Estructuras de Datos: Curso Básico

Introducción a los algoritmos

Cómo Funcionan las Computadoras y el Sistema Binario

Introducción a Lenguajes de Programación: Bajo y Alto Nivel

Estructuras de Datos para Rutas Más Cortas en Mapas

Algoritmo de Dijkstra para encontrar la ruta más corta

Metodología para Resolver Algoritmos Paso a Paso

Variables y Tipos de Datos en Programación

Creación de Tipos de Datos Personalizados en C

Configuración de Ubuntu en Windows 10 para C/C++

Implementación de User Defined Data Type en C: Estructuras paso a paso

Tipos de Datos Abstractos y Estructuras de Datos en Programación

Tipos Abstractos de Datos: Lista, Pila, Cola y Diccionario

Tipos Abstractos de Datos: Listas, Pilas y Colas

Clases y objetos

Colas y estructuras de datos: gestión de pedidos en restaurante

Implementación de Queues con Arrays en Visual Studio Code

Implementación de Abstract Data Type en C: Función enqueue

Implementación de la función dequeue en estructuras de datos en C

Implementación de Colas en C: Declaración y Uso de Funciones Básicas

Algoritmos de ordenamiento

Algoritmos de Ordenamiento: Conceptos y Aplicaciones Básicas

Funcionamiento del Algoritmo de Ordenamiento Burbuja

Implementación de Bubble Sort en C paso a paso

Implementación de Bubble Sort en C y función de impresión

Ordenamiento por Inserción en C: Algoritmo y Ejemplo Práctico

Algoritmos de Ordenamiento Descendente: Implementación Práctica

Recursividad

Recursividad en Programación: Entendiendo el Factorial

Factorial Recursivo en C: Implementación y Ejemplo

Inversión de cadenas con recursividad en Java

Recursividad en Python: Arte con Turtle y Funciones Recursivas

Divide and conquer y programación dinámica

Diseño y análisis de algoritmos: Divide y vencerás

Introducción a Programación Dinámica y Quicksort

Ordenamiento de Arrays con MergeSort en C

Algoritmos de Ordenamiento de Datos de Mayor a Menor

Algoritmo Quicksort en Python: Implementación y Funcionamiento

Ordenamiento Quick Sort en Python paso a paso

Algoritmos 'Greedy'

Algoritmos Voraces: Principios y Aplicaciones Prácticas

Implementación de Algoritmo Greedy para Cambio de Monedas

Cambio de Monedas en C++: Implementación y Ejecución

Grafos y árboles

Introducción a Árboles y Grafos: Estructuras de Datos Básicas

Estructura de Datos: Árboles y sus Componentes Básicos

¿Cómo comparar Algoritmos?

Comparación de Algoritmos: Complejidad y Ritmo de Crecimiento

¿Qué sigue?

Resolución de Problemas Básicos con Algoritmos y Estructuras de Datos