Recursividad

Recursos para hacer la tarea 👀😏:

• 🍩 Iteration vs Recursion by Bolaji - Medium (ganan los ciclos)
• 🤔 Recursion or while loops - Software Engineering (depende, en algunos casos es mejor la recursividad)
• 🔪 Is recursion faster than loops? (la batalla más épica que podrán encontrar, una maravilla 😍🔥🔥🔥)

Shale… entender su letra a mano le agrega un grado más de dificultad

Usando ciclos:

#include <stdio.h>

int factorial(int n)
{   int i, result;
    result = i = 1;
    while(n >= i)
    {
        result *= i;
        i++;
    }
    return result;
}

int main() {
    int num, result;
    printf("Introduce un valor: ");
    scanf("%d", &num);
    result = factorial(num);
    printf("El factorial de %d es %d", num, result);
    return 0;
}

En el caso de este programa:

• La función factorial usando ciclos tiene más líneas de código que empleando recursividad.
• Para guardar y retornar el resultado se emplea una variable local que luego es destruida al salir de la función pero con recursividad sólo retornas el resultado de las llamadas a la función factorial.
• Usando ciclos se invoca a la función solamente una vez y el número de iteraciones es igual al valor n que recibe como argumento, en cambio, con recursividad la función factorial es invocada n veces.

La diferencia más importante entre las operaciones recursivas y las iterativas es que los pasos de una operación iterativa se realizan uno cada vez y dirigen la ejecución directamente al siguiente paso. En una operación recursiva, cada paso después del paso inicial es una réplica del paso anterior.

La diferencia esta en que al usar un loop la ejecución del código se completa en una sola llamada al método con sus variables locales, en cambio al utilizar la recursion este se llama a si mismo la cantidad de veces que sean necesarias creando una pila de variables locales por cada llamada al método. Ambos tienen sus propios enfoques.

Adjunto reto:
La diferencia de usar ciclos y la recursividad esta en el ahorro de recursos y ahorro de lineas de codigo, a la vez que permite que la aplicacion sea mas flexible.

#include <stdio.h>

int main(int argc, char const *argv[])
{
  int i, n = 1, valor;
  printf("Que numero desea saber el valor factorial?: ");
  scanf("%d", &valor);
  for(i=1; i<=valor; i++)
  {
    n = n * i;
  }
  printf("El factorial de %d es: %d\n", valor, n);

  return 0;
}

RECURSIVIDAD:
Es donde vamos resolviendo problemas desde la parte mas pequeña o problema pequeño hasta solucionarlo todo.
RECURSION: es la capacidad que tiene una función de llamarse así misma dentro de su código

Int factorial(int n) //programa para hallar el factorial de n(numero ingresado)
{
If(n==0) //n es igual a cero? Si no es igual pasa a la operación (Return (nfactorial(n-1)); )
Return (1); // hasta que la operación llegue a cero, retorna un 1 para terminar
Return (nfactorial(n-1)); // si n no es igual a cero realiza esta operación hasta llegar a cero
} // fin del programa.

CICLOS:
Int factorial(int n)
{
for(int i=1; i<=n; i++)
result +=i;
}

Diferencia de usar recursividad y un iteraciones en este programa:
RECURSIVIDAD: Se llama a sí misma, o sea que puede reutilizar la misma línea de código.
ITERACIONES: se entiende como un ciclo que se repite hasta que se termina, según las líneas programadas.

Aquí está explicado.

https://www.youtube.com/watch?v=YsFX7jf9Js4

Esta clase del curso de Introducción al pensamiento computacional con Python también explica bastante bien este concepto de recursividad:

https://platzi.com/clases/1764-python-cs/25243-recursividad/

Recursividad usando el ciclo for

#include <stdio.h>
#include <math.h>

int fact =1;

void recursividad(int n)
{
	
	int acum,i;
	acum=n;
	for(i=0;i<acum;i++)
	{
		fact = fact * n;
		n--;
	}
	printf("Resultado de la Recursividad %d ",fact);
}

main (int argc ,char const *argv[])
{
	recursividad(10);
	return 0;
}

n = int(input('ingresa el valor para calcular su factorial: '))

factorial = 1


if n == 0 or n == 1:
    factorial = 1
else:
    for i in range(1, n + 1):
        factorial *= i
        print(i-1)
    print(f'{n}!= {factorial}')```

Hola
Para complementar. Hay 4 grandes diferencias entre la recursión y la iteración

1. Tiempo: En la recursión el tiempo está en función del llamado n de la misma función. Mientras que en la iteración este está determinado por el número de ciclos a realizar.
2. Uso: Cuando se está priorizando el tiempo de ejecución es mejor utilizar la iteración, mientras que si estamos priorizando la brevedad del código es mejor la recursión.
3. Recursos computacionales requeridos: La recursión usa bastante recursos computacionales, mientras que la iteración no.
4. Probabilidad de repeticiones infinitas: en la recursión se corre este riesgo por una mala especificación del caso base, mientras que en la iteración esto sucede si hay algún error en el loop.
   Les dejo una tabla resumen
   
   
   
   

De igual forma, comparto mi código para el reto en python de iteración y les dejo el source de donde tomé la info.

def iteration(n):
  base = 1

  for i in range(2, n+1):
    base *= i
  return base

n = int(input("Escoja un número para encontrar su factorial: "))
print("Factorial of",n,"using iteration is:", iteration(n));

https://www.geeksforgeeks.org/difference-between-recursion-and-iteration/

Y claro, si alguien quiere corregir, le agradezco 🙂

Les adjunto ambas formas (recursiva y ciclo for) en python:

Recursiva:

  
numero = input('Introduce un numero entero: ')
n = int(numero)

def factorial(n):
    if n == 0:
        return 1
    elif n > 0:
        return n*factorial(n-1)

print('El factorial de {} es:'.format(n),factorial(n))

Ciclo for:

numero = input('Introduce un numero entero : ')
n = int(numero)

if n == 0:
    fac = 1
elif n > 0:
    fac = 1
    for i in range(1,n+1):
        fac *= i

print('El factorial de {} es: {}'.format(n,fac))

Análisis…
Me di cuenta que al introducir números de 4 dígitos (10^4) en la forma recursiva me da el siguiente error:

RuntimeError: maximum recursion depth exceeded

Según entendí al investigar un poco…
Este error ocurre en python debido que tiene un límite de memoria para casos de recursión para evitar recursión infinitas, sin embargo, mediante el método sys.setrecursionlimit(10ˆn) podemos aumentar el número de dígitos.

Si alguien entiende mejor esto, favor de compartirlo.
Muchas gracias!

Hay algo importante por explicar, y espero no estar equivocado.
Cuando Ricardo habla de “Stack”, se refiere ah que en el momento en el que el compilador pasa todo tú código a lenguaje ensamblador, el compilador al reconocer que se hace una llamada a una función, este guarda “registros necesarios” en un stack, para así no perder su valor actual, ya que no se cuenta con una cantidad infinita de registros, entonces piensa que en recursividad se cebe estar creando un nuevo stack cada que la función se llame a sí misma para almacenar los valores actuales y poder acceder a ellos más adelante, esto claro es mucho más costoso computacionalmente, ya que imaginate una función recursiva que se llame a si misma 100 veces.

#include <stdio.h>
#include <stdlib.h>

int resultado = 1;
int x, i;
int main()
{

    printf("Ingrese un numero para saber su factorial\n\n");
    scanf("%d",&x);

    for( i = x ; i > 0; i--)
    {
        resultado *= i;
        printf(" %d %d\n", i, resultado);
    }


}

python recursividad

def facto(num):
    if num == 0:
        return 1
    else:
        return num * facto(num-1)

if __name__ == "__main__":
    num = int(input("Que factorial quieres: "))
    factorial = facto(num)
    print(factorial)

Python ciclo for

def facto(num):
    factorial = 1
    for i in range(1,num+1):
        factorial *= i
    return factorial

if __name__ == "__main__":
    num = int(input("Que factorial quieres: "))
    factorial = facto(num)
    print(factorial)

Python usando ciclos

numero = int(input("---> "))
fact = 1
for i in range(1, numero + 1):
    fact = fact * i

print(fact)

Con la recursividad se puede ahorra un poco mas de lineas de codigo y sera mucho mas legible, aqui esta mi codigo en c++

#include<iostream>
using namespace std;
int main()
{
	int Nfac = 1,num,i;
	
	cout<<"Digite el numero que desea conocer el factorial: "<<endl;
	cin>>num;
	
	for(i=1;i<=num;i++)
	{
		Nfac = Nfac * i;
	}
	
	cout<<"El factorial es: "<<Nfac;

	return 0;
}

La recursividad agiliza procesos y hace uso eficiente de los recursos de las computadoras, pero requiere habilidad mayor de abstracción de los problemas para diseñar su respectiva solución. Los ciclos son más intuitivos para las personas.

#include <stdio.h>

void factorial(int n)
{
    int ans = n,  m = n;
    if (n == 0)
    {
        ans = 1;
    }
    else
    {
        while (n > 1)
        {
            n--;
            ans = ans * n;
        }
    }

    printf("El factorial de %d, es: %d\n", m, ans);
}

int main(int argc, char const *argv[])
{
    int no;
    printf("Ingrese valor para cálculo de factorial:  ");
    scanf("%d", &no);
    printf("\n");
    factorial(no);
    return 0;
}

La recursividad nos permite reutilizar parte del código, ya que se llama a si misma la función.
Al realizarlo con ciclos se tiende a realizar un código más largo y tedioso a la lectura del programador.

<code>
#include <stdio.h>

int resolve_fact(int n){
    int fact = 1;
    for( ; n > 1; fact =  fact * n--);  
    return fact;
}

int main(int argc, char const *argv[])
{
    int num = 0;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 1;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 2;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 3;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 4;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 5;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    num = 6;
    printf("El factorial de %d es = %d\n",num,resolve_fact(num));
    return 0;
}

Salida
El factorial de 0 es = 1
El factorial de 1 es = 1
El factorial de 2 es = 2
El factorial de 3 es = 6
El factorial de 4 es = 24
El factorial de 5 es = 120
El factorial de 6 es = 720

Mi ejemplo con ciclo while en Javascript

        const factorial = (n) => {
            let factorial = n;
            let i = 1;

            while (i < n) {
                factorial *= (n - i);
                i++;
            }
            return factorial
        }

        const factorialDe8 = factorial(8) /* 40320 */
        console.log(factorialDe8)

la diferencia entre recursividad y ciclos;es que la recursividad se llama a una funcion ya definida en el programa. Mientras que en los ciclos nosotros definimos el paso a paso y las operaciones que debe realizar. para concluir seria que se ahorra codigo con la recursividad

segun lo que ntiendo es que la recursividad permite ahorrarnos los ciclos por medio de [return(n*fact(n-1)] , y los ciclos son un paso a paso para desarrollar el factorial.

Mi implementacion de este algoritmo. Puedes ponerle el numero desde los argumentos o por consola

#include <stdio.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>


// Calcula el factorial de cualquier numero
int fact( int n ) {

  // Base case
  if ( n <= 1 ) {
    return 1;
  }

  // Recursive
  else {
    return ( n * fact( n - 1) );
  }
}

int main(int argc, char const *argv[]) {

  // El numero a calcular
  int entrada;

  // Si el numero se prepociono por argumento
  if( argc > 1 ) {
    char help[20];
    strcpy(help, argv[1]);
    entrada = atoi(help);
  }

  // Si no, pedirlo al usuario
  else {
    printf("Introduce un numero: ");
    scanf("%d", &entrada);
  }

  // Calcular y mostrar
  int factorial = fact(entrada);
  printf("El factorial de %d es %d\n", entrada, factorial);
  return 0;
}

import java.util.Scanner; //Import Scanner Class
public class FactorialCiclos {
    public static void main(String[] args) {
        int numeroRecibido, contadorAtras; // Declaracion de Variables
        Scanner scan = new Scanner(System.in);

        System.out.println("Por favor ingresar el valor al cual quiere capturarle su factorial: ");
        numeroRecibido = scan.nextInt();
        int numeroRecibidoMem = numeroRecibido;
        if (numeroRecibido > 1)
        {
            for (contadorAtras = numeroRecibido; contadorAtras > 1; contadorAtras--)
            {
                numeroRecibido = numeroRecibido * (contadorAtras - 1 );
                System.out.println(numeroRecibido);
            }
            System.out.print("EL factorial de " + numeroRecibidoMem + " es :" + numeroRecibido);
        }
    }
}

Que alegría se siente cuando los otros cursos aprobados te hacen entender y avanzar en tus clases. Estos dos cursos son fundamentales que los aprueben antes de hacer este:

1. Curso de introducción al Lenguaje C

2. Curso de Pensamiento Lógico

Factorial con ciclo FOR en JavaScript:

function factorialize(number) {
  let factorial = 1;

  for (let index = 0; index <= number; index++) {
    if (index > 0) {
      factorial = factorial * index
    };
  }
  return factorial;
}

La recursividad (una función que se llama a si misma) se usa para realizar algoritmos cortos de forma elegante, que tenga un caso base que permita terminar. Sin embargo el costo computacional es más alto y puede provocar desbordamiento de la memoria en problemas muy grandes.

#include <stdio.h>

int main (int argc, char const *argv[])
{
    unsigned int num;
    unsigned long long int factorial; // Solo funciona hasta 12

    printf( "Ingrese un numero: ", num);
    scanf("%d",&num);

    for(factorial = 1 ; num > 1; factorial =  factorial * num-- );

    printf( "El factorial es: %d\n ", factorial);

    return 0;
}

Ejercicio de factoriales con while en Python:

def test(n):
     while n > 0:
        return (n * fact(n-1))

Aquí están distintos códigos usando ciclos

Factorial usando For loop:

me queda pendiente simular el stack en un array.

Jejeje lo de mundos paralelos me recuerda el concepto del multiverso.

Dividir una parte de un problema complejo en problemas más sencillos no seria Modularidad o Abstracción.

Reto: Factorial de un número:

Este es mi solución al ejercicio usando Python:

def factorial(n):
    if not isinstance(n, int):
        raise TypeError("Function expects integer")

    result = 1
    # Start in 1 (auto-documents what this does) and ends in
    # n (adding 1 because range does not include second argument)
    for i in range(2, n + 1):
        result *= i
    return result

La diferencia, creo yo, radica en que la mayoría de lenguajes tienen un tope máximo de elementos que pueden estar almacenados en el stack, si tenemos un algoritmo recursivo que agregue muchas llamadas a ese stack, vamos a llegar a un punto donde tendremos un error. Estos errores tienen formas de solucionarse, como usando memoización o programación dinámica, pero es otro tema.

Programa en C

#include <stdio.h>

int main(int argc, char const *argv[])
{
    int factorial, conteo, resultado = 1;
    printf("Introduce the number you want to make a factorial\n");
    scanf("%d", &factorial);
    for (int i = 0; i < factorial; i++)
    {
        conteo = i+1;
        resultado *= conteo;

    }
    printf("The factorial of %d, is %d", factorial, resultado);
    
    return 0;
}

Ejemplo BÁSICO de recursividad en Javascript
Simplicidad y elegancia

let countdown = numero => { 
  // base case 
  if(numero === 0) { 
    return;
  }
  console.log(numero);
  return countdown(numero - 1); 
};
console.log(countdown(10))   

Python3 para todos.

• Ciclo for:

python
numero = int(input('Ingresa un número entero: '))

ftor = 1

for i in range(1, (numero+1)):
    ftor = ftor * i

print(f'El factorial de {numero} es {ftor}')

• Recursividad:

python
def calc_fact_recu(numero):
    if numero > 1:
        numero = numero * calc_fact_recu(numero - 1)
    return numero

numero = int(input('Dame un número entero para hacer el factorial con la recursividad: '))

print(calc_fact_recu(numero))

Jajajaja, me encanto la explicacion es como si estuvieras en mundos paralelos con diferentes versiones de si mismo, clarisimo, jaja

#Las dos funciones tanto recursiva como con ciclos en python
#Funcion en ciclo
def factorial (num):
data = 1
for i in range(1, num+1):
data = data * i
return data
print(factorial(4))

#Funcion con recursividad
def recursividad(num_1):
if num_1 == 0:
return 1
return(num_1 * recursividad(num_1-1))
print(recursividad(4))

Realizado en C, función Recursiva y Función con Ciclo para hallar el factorial.

Recursividad: Se llama así misma almacenando valores en un stack.
Loops: Se ejecuta el ciclo siempre y cuando se cumpla la condición dada y cambiando el estado de las variables en cada iteración.

#include <stdio.h>

int facRecursion(int number)
{
    if (number == 0)
    {
        return 1;
    }

    return number * facRecursion(number - 1);
}

int facLoop(int number)
{
    int temp = 1, i;
    for (i = 1; i <= number; i++)
    {
        temp = temp * i;
    }
    return temp;
}



int main(int argc, char const *argv[])
{
    printf("El factorial recursivo de 5 es %d  \n", facRecursion(5));
    printf("El factorial en ciclos de 5 es %d  \n", facLoop(5));
    return 0;
}

Hola
Para complementar. Hay 4 grandes diferencias entre la recursión y la iteración

1. Tiempo: En la recursión el tiempo está en función del llamado n de la misma función. Mientras que en la iteración este está determinado por el número de ciclos a realizar.
2. Uso: Cuando se está priorizando el tiempo de ejecución es mejor utilizar la iteración, mientras que si estamos priorizando la brevedad del código es mejor la recursión.
3. Recursos computacionales requeridos: La recursión usa bastante recursos computacionales, mientras que la iteración no.
4. Probabilidad de repeticiones infinitas: en la recursión se corre este riesgo por una mala especificación del caso base, mientras que en la iteración esto sucede si hay algún error en el loop.
   Les dejo una tabla resumen
   
   
   
   

De igual forma, comparto mi código para el reto en python de iteración y les dejo el source de donde tomé la info.

def iteration(n):
  base = 1

  for i in range(2, n+1):
    base *= i
  return base

n = int(input("Escoja un número para encontrar su factorial: "))
print("Factorial of",n,"using iteration is:", iteration(n));

Y claro, si alguien quiere corregir, le agradezco 🙂

Esta seria la funcion con ciclos

def factorial_c(n):
    j = 1
    for i in range(1,n+1):
        j = j * i
    return j

#include <stdio.h>
#include <math.h>

void factorial(int n){
    int valor=1;
    for(int i=1;i<=n;i++){
        valor = valor*i;
    }
    printf("Factorial: %d",valor);
}

int main(){
    int n=10;
    factorial(n);

    return 0;
}```

Python

def factorial(n):
    if n == 0:
        return(1)
    return (n * factorial(n-1))


if __name__ == "__main__":
    n = int(input("ingrese un numero: "))
    print(factorial(n))```

Hola Amig@s
Comparto mi codigo del factorial con ciclo For.

#include<stdio.h>

int factorial(int n)
{
int f = 1;
int i;
if(n==0)
printf(“Factorial de %d es 1.\n” , n);
else
{
for(i=0; i<n; i++)
f=f*(n-i);
printf(“Factorial de %d es %d”, n, f);
}
}

void main()
{
int n, f;
n = 5;
factorial(n);

}

Todos los lenguajes de programación que soporten recursividad, realizaran uso del Stack.

estas diciendo que existe un multiverso?

Muy buena clase aprendiendo cosas nuevas para establecer mis bases que antes solo programaba pero sentía que me faltaban cosas 😃 y necesito aprender mas matemáticas prácticamente no sabia como era la factorial o la pude haber olvidado que es lo mas probable 😕 pero bueno viendo las creaciones de códigos de los demás pude entender el conceptos mas a fondo comparándolos y leyendo. Están fantásticas las clases

Un ejemplo de la función factorial implementada en C con un ciclo for

#include <stdio.h>
#include <math.h>

void cycle(int orinum, befnum)
{
int orinum = 5;
int befnum = orinum -1;
if(befnum > 1)
{
(orinum * befnum);
orinum–;

}

}

int main(int orinum)
{
printf(“orinum”);
}

La verdad no me sale, alguien puede decirme q falta?

Este es mi código, para calcular el factorial de un numero

int factorial(int n) {
		int result=1;
		for(int i=1; i<n; i++) {
			result += result*i;	
		}
		return result;
	}

La diferencia que veo, es que las al función recursiva tiene menos lineas de código, pero por lo que he estado leyendo las funciones recursivas utilizan mas espacio en memoria ya que tiene que ir almacenado en forma de pila el retorno de cada iteracion, mientras que los bucles las variables van cambiando su valor pero no abre otro espacio en la memoria,

El curso de pensamiento lógico es excelente!!! Citado en el curso…

Vale destacar que el caso base de la recursiòn, pudo haber sido (n==1), y te ahorras una recursión ya que no es necesario hacer 1*1 = 1.

Aqui la funcion en java

	public int factorialoop(int n)
	{
		int factor= n;
		for(int i = 2; i<n; i++){
			factor *=i;
		}
		return factor;
	}

Funcion factorial usando un bucle for :

#include<stdio.h>

void factorial(int n)
{
    int i, return_number;
    for(i = 1; i <= n; i++)
    {
        if(i == 1)
            return_number = i * i;
            
        return_number = return_number * i;
    }
    printf("Factorial magico %d \n", return_number);
}


int main(int argc, char const *argv[])
{
    int n = 6;
    factorial(n);
    return 0;
}

Algoritmo Factorial

#include <stdio.h>
#include <stdlib.h>

int factorialRecursivo(int valor)
{
  if(valor == 0) return 1;
  return valor * factorialRecursivo(valor-1);
}

int factorialCiclos(int valor)
{
  int res=1;
  for(int i=valor;i>=1;i--)
  {
    res *= i;
  }
  return res;
}

int main()
{
  int valor;
  printf("Programa que usa la logica de dos factoriales diferentes,\n\n");

  printf("Ingrese el valor:" );
  scanf("%i",&valor);

  printf("\nEl valor de factorial de Forma Recursiva es: %i\n\n", factorialRecursivo(valor));
  printf("El Valor de factorial por Ciclos es: %i\n", factorialCiclos(valor));
  return 0;
}

Ejecucion

• El algoritmo recursivo puede ser mas costoso hablando de recursos del sistema
• El nivel de abstraccion del desarrollador debe ser alto, un fallo puede producir un bucle infinito
• El algoritmo recursivo es mas reducido en terminos de lineas de codigo
• El algoritmo recursivo es mas cercano a una funcion matematica o al menos tiene ese comportamiento

Mi solución:

long recursive(int number)
{
  long n = number;
  long result = 1;

  for(n;  n > 0 ; n--)
  {
    result = result * n;
  }
  return result;
}```

#include <stdio.h>
#include <stdlib.h>

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

int main()
{
	int res,num;
	printf("Da el valor de num:  \n");
	scanf("%i",&num);
	res = factorial(num);
	printf("El factorial de %i es : %i", num, res);
	return 0;
}

#include <iostream>
using namespace std;

int main(){
int n = 5;

for(int i = n - 1; i >= 1; i–){
n *= i;
}

cout << n << endl;
}

Ya había hecho un comentario acerca de ello aquí ^^

Factorial utilizando el ciclo for

#include <stdio.h> 

int n, i;

int factorial(int n)
{
     unsigned long long factorial = 1;

     if(n < 0)
     {
     	printf("Error! No existe el factorial de un numero negativo.");
     }
     if(n==1)
     {
          return 1;
     }
     if(n >=0)
     {
        for(i=1; i<=n; i++)
        {
            factorial *= i;                  }
      	printf("Factorial of %d = %llu", n, factorial);
     }
}

int main(int argc, char const *argv[])
{
	printf("Digite un numero entero\n");
	scanf ("%d", &n);
	factorial(n);
	return 0; 
}

#include <stdio.h>
#include <stdlib.h>

main(){
    int numero,i,resultado = 1;
    numero = 5;
    for(i=1;i<=numero;i++)
    {
        resultado = resultado * i;
    }
    printf("%i",resultado);
}

La recursion es un poco mas lenta que hacer el calculo matemático por el funcionamiento en si de la propia recursion, eso es lo que creo. Me gustaría saber la opinión de los demás. Aquí los dos códigos.

#include <stdio.h>

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

    return n * factorial(n - 1);
}

int main (){
    int n;
    long long int fact;
    
    printf("Ingresa un numero para calcular el factorial: \n");

    scanf("%d",&n);
    fact = factorial(n);
    printf("%lld\n", fact);

}

#include <stdio.h>

int main()
{
    int n;
    long long int fact = 1;

    printf("Ingresa un numero para calcular el factorial: \n");
    scanf("%d", &n);

    for(int i = 1; i <= n ; i++ ){
        fact *= i;
    }
            
    printf("%lld\n", fact);
}

Factorial usando for en JS

function fact(n) {
if (n > 0) {
let rn = 1 //Return Number
for (let i = 1; i <= n; i++) {
rn = rn * i
}
return rn
}
}
VS Recursividad en JS

function fact(n){
if (n===0){return 1}
else return (n*fact(n-1))
}
Veo que el time complexity se reduce, no muy dramáticamente y por lo que puedo ver el Space complexity se reduce, utilizando la herramienta de console.time que tiene JS veo los siguientes tiempos

Comprobando con el factorial de 500
For Loop se tarda 0.188ms
Recursividad 0.067ms

Así que, si se puede usar la Recusrsividad, usala! jaja

Aquí esta el código por si quieren hacer pruebas, yo las hice en NodeJS

console.time('factfor');
function factfor(n) {
    if (n > 0) {
        let rn = 1
        for (let i = 1; i <= n; i++) {
            rn = rn * i
        }
        return rn
    }
}
factfor(1000)
console.timeEnd('factfor');

console.time('factRecursivity');
function factRecursivity(n) {
    if (n === 0) { return 1 }
    else return (n * factRecursivity(n - 1))
}
factRecursivity(1000)
console.timeEnd('factRecursivity');

Aquí va la función que cree para el factorial con un ciclo!

int factorialCiclo(int n)
{
    int i,factorial=n;
    for(i=n-1; i > 1; i--) factorial *= i;
    return factorial;
}

También si a alguien le interesa, aquí está el código recursivo que explicó el profe en esta clase, modifique el n == 0 por n == 1 porque no es necesario llegar hasta el cero, así nos ahorramos una recursión:

int factorialRecursivo(int n)
{
    if(n == 1) return 1;
    else return (n * factorialRecursivo(n-1));
}

En mi caso noté que en realidad el método cíclico me realizó menos iteraciones que el recursivo sin embargo, el recursivo no requiere la creación de variables adicionales.

main(int argc, char const *argv[])
{
int factorial = 1;
int i = 0;
int n = 5;

printf("¿Cual es el numero que deseas hallar el factorial? ");
scanf("%d",&n);

for(i = 1; i<= n; i++){
   factorial = factorial *i;
}
printf("El factorial de %d es %d \n",n,factorial);

return 0;

Para este caso única diferencia la función recursiva me itero una vez más que la función del ciclo for

#include <stdio.h>
int p = 0;
void main(){
	
	int n = 0;
	printf("Ingrese un número para calcular su factorial\n");
		scanf("%d",&n);
			
	int i, factorial = 1;
	
	for(i = 1; i <= n; i++){
		factorial = factorial * i;
		printf("Interaciones %d \n", i);
	}
	
	printf("%d \n", factorial);
	printf("%d \n", fact(n));
	
}

int fact(int n){
	p++;
	printf("Interaciones %d \n", p);
	if(n == 0){
		return 1;
	}else{
		return(n*fact(n-1));
	}
}```

Reto recursividad usando ciclos

#include <stdio.h>
#include <stdlib.h>


int main(int argc, char *argv[]) {

    int num;
    int resultado = 1;

    printf("ingresa un numero para calcular su factorial: ");
    scanf("%d", &num);
    printf("%d\n", num);

    for (int i = 1; i <= num; i++) {
            resultado = resultado * i; 
    }
    printf("resultado: %d\n", resultado);

    return 0;
}

Every loop can be a factorial, every factorial can be a loop, both of them have advantages and disadvantages

Aqui dejo mi codigo en c# de las dos funciones

static void Main(string[] args)
        {
            double n = 3;
            double factorial = recursive_For(n);
            Console.WriteLine("n = 3");
            Console.WriteLine("FUNCION CON CICLO FOR: {0}", factorial);

            n = 6;
            factorial = recursive_rec(n);
            Console.WriteLine("n = 6");
            Console.WriteLine("FUNCION CON FUNCION RECURSIVA: {0}", factorial);
        }

        //FUNCION RECURSIVA CON CICLO FOR
        public static double recursive_For(double n)
        {
            double fact = 1;
            if (n != 0)
            {
                for (int i = 1; i < n; i++)
                {
                    fact *= i+1;
                }
                return fact;
            }
            else
            {
                return 0;
            }
           
        }


        //FUNCION RECURSIVA
        public static double recursive_rec(double n)
        {

            if (n == 0)
                return 1;

            return (n * recursive_rec(n - 1));
        }

La principal diferencia creo que es el uso de la stack que hace la función recursiva y la cual se puede llegar a desbordar si se meten demasiados elementos a la pila, cosa que no pasa con los ciclos, ademas de que la función recursiva suele ser algo lenta.

Buenas, aquí mi código de factorial recursivo a factorial cíclico:

#include <stdio.h>

void main()
{
    int i;
    int tope = 11;
    int resultado= 1;
    if(tope == 0)
        printf("\nFactorial de %d es = %d", tope, resultado);
    else if(tope < 0)
        printf("No existe factorial de numeros negativos.");
    else
    {
        for(i=1; i<tope; i++)
            resultado = resultado * (i+1);
        printf("\nFactorial de %d es = %d", tope, resultado);
    }    
}

Considero que la principal diferencia entre recursividad y ciclos, es que con el primero se escribe menos código, pero puede ser confuso para que alguien ajeno lo interprete, y con el segundo se obtiene claridad a costa de mayor líneas.
En cuanto a qué es mejor usar, depende totalmente del estilo de programación; en aras de la regla 80/20, creo ciclos sería opción predominante.

Con tan solo 15 líneas de código, les comparto mi aporte con un ciclo “for”:

#include <stdio.h>

void fact(int n){
    int resultado = 1;
    for (int i = 1; i <= n; i++){
        resultado = resultado * i;
    }
    printf("%d\n", resultado);
}

int main(){
    int n = 5;
    fact(n);
    return 0;
}

Funcion recursiva en python

def my_factorial3(x):
    if x > 1:
        return x * my_factorial3(x-1)
    return 1```

#include <stdio.h>
#include <stdlib.h>

int factorial (int numero) {

    int respuesta;
    respuesta = 1;
    int limite = numero;

    for (int i = 2; i <= limite; i++) {

        respuesta *= i;

    }

    return respuesta;

}

// Use esta funcion para validar los resultados
/*
int factorialDos (int numero) {

    if (numero == 0) {

        return 1;

    }

    return numero * factorialDos(numero - 1);

}*/

int main() {

    int respuesta;
    printf("Cual es el numero que quieres?");
    scanf("%i", &respuesta);

    printf("\nEl numero es: %d", factorial(respuesta));
    //printf("\nEl numero 2 es: %d", factorialDos(respuesta));

}```
- La primera cosa que note- y que veo que muchas personas han notado -es que hay mas lineas de codigo en el codigo de la iteracion que en el codigo de la recursividad.
- Tambien, por lo que he invastigado, es que la recursion es mas lenta que la iteracion, por que se sigue llamando a si misma, cual significa que hay mas codigo que ejecutar.
- Una diferencia tambien entre ellos es que la recursion es llamando una funcion repetidamente dentro de la misma funcion. La iteracion es ejecutar lineas de codigo repetidamente hasta que se cumpla una cierta condicion.

#include <stdio.h>
#include <stdlib.h>

int factorial (int numero) {

    int respuesta;
    respuesta = 1;
    int limite = numero;

    for (int i = 2; i <= limite; i++) {

        respuesta *= i;

    }

    return respuesta;

}

// Use esta funcion para validar los resultados
/*
int factorialDos (int numero) {

    if (numero == 0) {

        return 1;

    }

    return numero * factorialDos(numero - 1);

}*/

int main() {

    int respuesta;
    printf("Cual es el numero que quieres?");
    scanf("%i", &respuesta);

    printf("\nEl numero es: %d", factorial(respuesta));
    //printf("\nEl numero 2 es: %d", factorialDos(respuesta));

}

• La primera cosa que note- y que veo que muchas personas han notado -es que hay mas lineas de codigo en el codigo de la iteracion que en el codigo de la recursividad.
• Tambien, por lo que he invastigado, es que la recursion es mas lenta que la iteracion, por que se sigue llamando a si misma, cual significa que hay mas codigo que ejecutar.
• Una diferencia tambien entre ellos es que la recursion es llamando una funcion repetidamente dentro de la misma funcion. La iteracion es ejecutar lineas de codigo repetidamente hasta que se cumpla una cierta condicion.

#include <stdio.h>
#include <stdlib.h>

int factorial (int numero) {

    int respuesta;
    respuesta = 1;
    int limite = numero;

    for (int i = 2; i <= limite; i++) {

        respuesta *= i;

    }

    return respuesta;

}

// Use esta funcion para validar los resultados
/*
int factorialDos (int numero) {

    if (numero == 0) {

        return 1;

    }

    return numero * factorialDos(numero - 1);

}*/

int main() {

    int respuesta;
    printf("Cual es el numero que quieres?");
    scanf("%i", &respuesta);

    printf("\nEl numero es: %d", factorial(respuesta));
    //printf("\nEl numero 2 es: %d", factorialDos(respuesta));

}

La primera cosa que note- y que veo que muchas personas han notado -es que hay mas lineas de codigo en el codigo de la iteracion que en el codigo de la recursividad.
Tambien, por lo que he invastigado, es que la recursion es mas lenta que la iteracion, por que se sigue llamando a si misma, cual significa que hay mas codigo que ejecutar.
Una diferencia tambien entre ellos es que la recursion es llamando una funcion repetidamente dentro de la misma funcion. La iteracion es ejecutar lineas de codigo repetidamente hasta que se cumpla una cierta condicion.

#include <stdio.h>

int resultado;

int factorial(int n)
{
    resultado = 1;
    for (int i = 1; i <= n; i++)
    {
        resultado = resultado * i;
    }

    return resultado;
}

int main(int argc, char const *argv[])
{
    int numero = factorial(3);
    printf("%d",numero);
    return 0;
}

#include <stdio.h>

int fact(int n)
{
	int result = 1;
	for (int i = 1; i <= n; i++)
		result = result * i;
	return result;
}

main(int argc, char const *argv[])
{
	int result = fact(5);
	printf("The result is: %d", result);
	return 0;
}

const factorial = (n: number) => {
  let factorial = n
  for(let i=n-1 ; i>0 ; i--) {
    factorial = factorial * i
  }
  return factorial;
}

#include<stdio.h>

void fact(int n)
{
    int resultado = 1;
    for(int i = 1; i <= n; i++)
    {
        resultado = resultado * i;
    }

    printf("El resultado del factorial es: %d \n", resultado);
}
int main()
{
    int n = 5;
    fact(n);
    return 0;
}

def factorial(num):    
    if num > 1:
        return num * factorial(num -1)
    else:
        return 1
    

if __name__ == '__main__':
    print(factorial(5))

Me llevo un poco de tiempo pero aquí esta:

// RECURSIVIDAD CON CICLO FOR

#include <stdio.h>
#include <stdlib.h>

int main()
{
    int n, f=1, i;
    printf("FACTORIAL DE UN NUMERO \n");
    printf("Ingrese el numero: ");
    scanf("%d", &n);
    for (i=1;i<=n;i++)
    {
       f = f * i;
    }
    printf("El factorial es: %d \n", f);
    return 0;
}


// RECURSIVIDAD CON FUNCIONES

#include <stdio.h>
#include <stdlib.h>

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

int main()
{
    int n;
    printf("Factorial the a number\n");
    printf("Enter the number: ");
    scanf("%d", &n);
    fact(n);
    printf("the factorial number is: ");
    printf("%d",fact(n));
    return 0;
}

#include <stdio.h>

int var=0,cont=1;
long R=1;

int main()
{
    do {
        printf("Ingresa el numero hasta el que se va a multiplicar\n");
        scanf("%d",&var);
        if ((var<1)||(var >20)) {
            printf("Tienes que meter numeros positivos menor o igual a 20\n");
        }
    } while((var<1)||(var >20));
    
    
    while (cont<=var)
        {
            R=R*cont;
            cont++;
        }
        printf("%ld\n",R);
    

    return 0;
}

Yo entiendo la recursividad como una solucion para resolver problemas fractales, osea uno dentro de otro, o la misma estructura anidandose a si misma, ya sea intanciandose, haciendo la misma operación, o realizando la misma operacion en datos o carpetas anidadas.

Un ejemplo de fractalidad, es la portada de los cartones de chocolate, donde la mascota de la marca sale sosteniendo el mismo carton de chocolate, con la misma mascota adentro sosteniendo otro cartón de chocolate 🍫

Un ejemplo de programa que no se puede hacer sin la recursividad es la exploración de directorio.
Supongamos que tenemos la función de buscar directorio, esta hará scrolling por cada archivo, PERO si encuentra un archivo sin terminación quiere decir que este es carpeta (No es del todo cierto, pero funciona en este ejemplo), y va a llamarse otra vez así misma con el contenido de la carpeta, y cuando acabe va a seguir el ciclo que llevaba el programa inicial.

La diferencia entre usar recursividad y un bucle es que en el ciclo las operaciones se hacen un paso a la vez, mientras en la recursividad todo se sintetiza en una sola operacion.

#include <stdio.h>
#include <stdlib.h>

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

int main()
{
    int opMenu, numFactorial, ops, bucle;
    printf("----PRACTICA DE RECURSIVIDAD -FACTORIAL ----

");
    printf("Programa con bucle ...................1
");
    printf("Programa con funcion recursiva ...... 2
");
    printf("Elija opcion: ");
    scanf("%i", &opMenu);
    if(opMenu == 1) {
        printf("

Ingrese un numero entero: ");
        scanf("%i", &numFactorial);
        bucle = numFactorial;
        ops = 1;
        numFactorial = 1;
        for(int i=1; i<bucle; i++){
            ops = ops * (numFactorial+1);
            numFactorial++;
        }
        printf("La factorial es: %i", ops);
    }
    else if (opMenu == 2) {
        printf("

Ingrese un numero entero: ");
        scanf("%i", &numFactorial);
        printf("La factorial es: %i", factorial(numFactorial));
    }
    else{
        printf("

Opcion no valida");
    }
    return 0;
}```

Código en javascript
ejercicio de calculo factorial de un numero usando ciclos

function factorial(n){
    let r=1
    if(n<0){
        console.log(n+" no tiene factorial")
    }else{
        if(n>1){
            for(var i=1;i<=n;i++){
                r*=i
            }
        }
        console.log(r)
    }
}
factorrial(-2)
factorial(3)
factorial(4)
factorial(5)

Diferencia entre usar ciclos y recursividad
el uso de los ciclos es obviamente el proceso de repetición de cierta parte de código que resuelve un problema a partir del caso base (normalmente).
a diferencia de los ciclos el propósito del uso de la recursividad es de dividir un problema grande hasta llegar al caso base y después regresar calculando los resultados con el fin de que el código sea mas optimo o fácil de entender para ciertos problemas.
en algunos casos la implementación de ciclos a recursibidad o viceversa puede ser sencilla dependiendo del problema a resolver.

//Practica de recursividad. Factorizar usando ciclos.
#include<stdio.h>

int fact(int n) {
    int res = 1;
    for(int i = n; i > 0; i--){
        res *= i;
    }
    return res;
}

int main(int argc, char const *argv[]){
    int res = fact(4);
    printf("El resultado es: %i \n", res);
}```

La diferencia en el uso de Recursividad y Ciclos:

Recursividad: Usa pila para almacenar los valores mientras se ejecuta y por tanto se usa un espacio de memoria para cada iteracion.

Ciclos: Se usa una variable que se va actualizando por cada repeticion.

public class Borrador {
    public static void main(String args[]){
        int num = fact(4);
        System.out.println("El resultado es: " + num);
    }   
    
    public static int fact(int n){
        while(n == 0){
            return 1;
        }
        return n * fact(n-1);
    }
}

envio ejercicio.

#include <stdio.h>

int factorial(int numero){
	int cont;
	long acum=1;
	for(cont=1;cont<=numero;cont++){
		
		acum = acum * cont ;
		printf("%d\n",acum);
	}
	
	return acum;
}

int main(){
	int inicial,resultado;
    printf("Digite el Numero:");
    scanf("%d",&inicial);
    resultado=factorial(inicial);
    printf("el factorial es %d",resultado);
}

La diferencia entre usar un ciclo y usar recursividad esta en que mientras usamos un ciclo debemos utilizar una o mas variables para almacenar datos temporales, en el caso del factorial la variable temporal seria un indice que indique que numero de la secuencia se esta multiplicando. En la recursividad ese indice se convierte en un parámetro que se envía como una nueva instancia de la función, creando una nueva “capa” con la misma función ejecutándose con otro parámetro.
Se puede observar utilizando una herramienta de Debug.
Ciclos

Recursiva

Codigo

def Factorial_Recursivo(n = int):
    if n is 0:
        return 1
    return n * Factorial_Recursivo(n - 1)


def Factorial_ciclos(n):
    fact = n
    temp = n
    while temp != 1:
        fact = fact * (temp - 1)
        temp -= 1
    return fact


if __name__ == "__main__":
    print(Factorial_Recursivo(3))
    print("\n")
    print(Factorial_ciclos(4))

hice un ejemplo en python:

#-*- coding:utf-8 -*-


def factorial(recursivo_entrada):
    if recursivo_entrada == 0:
        return(1)

    return (recursivo_entrada * factorial(recursivo_entrada - 1) )


if __name__ == '__main__':
    recursivo_entrada = int(input('Ingresa el Numero del que quieres conocer factorial: '))
    result = factorial(recursivo_entrada)
    print('El factorial de {} es {}'.format(recursivo_entrada, result))```

Ahora utilizando un ciclo, peor con el for.
He de admitir que me dio bastante dolor de cabeza, porque la interpretaciòn es diferente, en el for vas incremental pero solo hasta n -1 es decir si tu numero de entrada es 3 el va a ir 0, 1,2 por lo que debes agregar el +1 del range. tambièn la operaciòn era diferente, ya que no era restando.
tampoco puedes inicializar en 0 ya que al ser multiplicaciòn siempre te quedarìa cero

#-*- coding:utf-8 -*-


def factorial_recursivo(recursivo_entrada):
    if recursivo_entrada == 0:
        return(1)

    return (recursivo_entrada * factorial_recursivo(recursivo_entrada - 1) )


def factorial_ciclo(recursivo_entrada):
    factorial_loop = 1

    for temporal in range(1, recursivo_entrada + 1):
        factorial_loop *= temporal

    return(factorial_loop)


if __name__ == '__main__':
    recursivo_entrada = int(input('Ingresa el Numero del que quieres conocer factorial: '))

    result = factorial_recursivo(recursivo_entrada)
    print('El factorial  utilizando la función recursiva de {} es: {}'.format(recursivo_entrada, result))

    result_ciclo = factorial_ciclo(recursivo_entrada)
    print('El factorial  utilizando ciclo de {} es: {}'.format(recursivo_entrada, result_ciclo))```