La función Factorial, calculando el factorial recursivamente

Vista grafica del algoritmo

printf("Calmate por favor")

😅

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)}`)
}```

Python

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

    return n * factorial(n-1)

n = int(input("Dame un numero entero: "))

print(factorial(n))```

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;
}```

¿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.

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))

#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;
}

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.

Mi codigo en C#

    class Factorial
    {
        /// <summary>
        /// Funcion para calcular el factorial de un numero.
        /// </summary>
        /// <param name="numero"> El numero del que queremos saber el factorial.</param>
        /// <returns></returns>
        public static long CalcularFactorial(int numero) {

            long resultado = 0;

            if (numero < 0)
            {

                Console.WriteLine("El numero debe ser positivo.");

            }
            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<stdio.h>
//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("Ingrese el numero a calcular \n");
    scanf("%d",&n);
    if(n<0)
    {
        printf("El numero debe ser positivo \n");
    }
    else
        resultado = factorial(n);
        printf("%d! = %ld\n", n, resultado);
    
    return 0;
}```

En python

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

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

print("El factorial es {} " .format(factorial(number)))





if __name__ == "__main__":
     factorial(number)

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

Ciclo For

Recursividad

Mi desafio en JS

const factorial = num => {
  if (num === 0) {
    return 1;
  } else {
    return num * (factorial(num-1));
  }
}

let user = (prompt('ingrese el numero a calcular: '))
if(user < 0) {
  console.log('El numero debe de ser positivo');
} else {
  console.log(`${user} = ${factorial(user)}`)
}

def factorial(0), do: 1
def factorial(n), do: n * factorial(n - 1)

En elixir, por si no lo conocían

#include <stdio.h>

int main(void) {

int fact = 1, i;
int n;
printf(“Type a number to get factorial\n”);
scanf("%d",&n);

for (i = 1; i <= n; i++) {

fact *= i;

} printf(“Factorial is: %d\n”, fact);

return 0;
}

def calculo_factorial(numero):
    i=numero
    factorial=numero
    if numero == 0:
        return 1
    else:
        while i >1:
            factorial = factorial*(i-1)
            i-=1
    return factorial

def main():
    numero = int(input('Ingresa un número: '))
    resultado = calculo_factorial(numero)
    print(resultado)
if __name__ == '__main__':
    main()    
    

Código en C:

#include <stdio.h>

unsigned long long int factorial(int);

int main(int argc, char const *argv[])
{
    int number = 20;

    if (number > 0)
        printf("Factorial(%d) = %llu", number, factorial(number));
    else
        printf("The number must be positive\n");
    
    return 0;
}

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

Salida:

Factorial(20) = 2432902008176640000

Verificación

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

    
n = int(input('Escribe un número a calcular: '))
if n <0:
    print('Por favor ingresa un número positivo')
elif n==0:
    print('El factorial de 0 es 0')
else: 
    print(f'el factorial de {n} es {factorial(n)}')```

Aquí mi código pulido:

# Python program to find the factorial of a number
# using "recursion" and "for loop"

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


def loop_factorial(n):
    fact = 1
    if n == 0:
        return 1
    for i in range (1, n+1):
        fact = fact*i
    return fact

def run():
    n = int(input('Enter a number: '))
    if n < 0:
        print('Sorry, factorial does not exist for negative numbers')
    else: 
        print(f'Using recursion: {recursive_factorial(n)}')
        print(f'Using for loop: {loop_factorial(n)}')

if __name__ == "__main__":
    run()```

PYTHON

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


if __name__ == "__main__":
    n = int(input("ingrese un numero: "))
    if n < 0:  
        print("numero negativo")  
    elif n == 0:  
        print("El factorial de 0 es 1")  
    else:  
        print(factorial(n))```

Ahora entiendo un poco mas de funciones recursivas, que maravilla de explicación por parte del profe

Si intentan sacar factorial de un numero grande (mayor a 10) se les va a desbordar y no imprimirá un resultado correcto. cambie el tipo de dato por un double que tiene el doble de memoria que el long, 8 bytes.

#include "stdio.h"

double result;
int n;

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

double 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! = %f\n", n, result);
  }

  return 0;
}

CÓDIGO EN JAVA

import java.util.Scanner;

public class Factorial {

public static void main(String[] args) {

    int n;
    Scanner teclado;
    teclado = new Scanner(System.in);
    Factorial obj = new Factorial();
    System.out.println("<<<FACTORIAL>>>\n");
    System.out.println("Ingrese un numero:");
    n = teclado.nextInt();
    if (n > 0) {
        System.out.println("" + n + "! (factorial) es:" + obj.factorial(n));
    } else {
        System.out.println(n + " no es valido, ingrese un valor positivo");
    }
}

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

}

Dejo mi aporte el factorial de forma recursiva y por ciclo

const factOne = n => n ? (n * factOne(n - 1)) : 1

const factTwo = n => {
  let result = n
  for (let i = n - 1; i > 0; i--) {
    result *= i
  }
  return result || 1
}

#include<stdio.h>

long result;
int n;

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

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;
}

const factorialRec = (n: number): number => {
  if (n === 0) return 1
  return n * factorialRec(n-1);
}

en c#

using System;

namespace Nfactorial {
    class Program {
        static void Main (string[] args) {

            int numero = 10;
            int factorial = 1;

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

            Console.WriteLine (factorial);

        }

    }

}

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

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

En java

/**
     * <h1>Factorial de un número</h1>
     *En ésta función, el caso base es que el numero factorial sea menor o igual que 1.
     * La solución al problema 'más grande' puede ser resuelto convirtiendo el número
     * a un número más pequeño (de 1 en 1) hasta que se llegue al caso base.
     * */
    public int factorial(int factorialNumber) {

        if (factorialNumber <= 1) { // <-- Caso base.
            return 1;
        } else {
            return factorialNumber * factorial(factorialNumber-1);
        }

    }

En JS:

const factorial = numero => {
	// Sacar valor absoluto
	numero = Math.abs(numero);
	if (numero <= 1) return 1;
	return numero * factorial(numero - 1);
};
num = 5;
for (let x = 0; x < num; x++) {
    console.log(`El factorial de ${x} es ${factorial(x)}`);
};```

JAVA:
Mi aporte espero les sirva

Así sería la función factorial con recursividad en JS.

function fact(num){
    if (num <= 1) {
        return 1;
    }

    return num * fact(num -1);
}```

Python:

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

print(factorial(5))>

Resultado

120

Entendido, pero tengo problemas con mi editor.

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

En python:

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

print('Ingresar numero a calcular... ')
n = input()
n = int(n)
if n > 0:
    print(f'Factorial de {n} = {factorial(int(n))}')
else:
    print('Ingrese valor mayor a 0.')```

Todo bien! todo bello <3

using System;

namespace Factorial
{
    class Factorial
    {
        

        static public void Main(string[] args){
          
               GetFactorial();
       }

      static public int FactRecursive(int n)
      {
              if( n == 0)
              {
                  return 1;             
              }
             
                 return n * FactRecursive(n-1);     
       }

      static public void GetFactorial()
      {
          Console.WriteLine("Insert a number to obtain the factorial: ");
        
            bool Numparsed = int.TryParse(Console.ReadLine(), out int n);
          
         if (Numparsed)
         {
                
                 Console.WriteLine("{0}! is: {1}", n, FactRecursive(n));
                   
             
         }else {
           
            while (!Numparsed || n < 0)
            {
                Console.WriteLine("Negative numbers and letters are not allowed");
                Console.WriteLine("Insert a number to obtain the factorial: ");
                Numparsed = int.TryParse(Console.ReadLine(), out n);
                
            }
         }
      }

    }
}

JAVA

package Platzi;

import java.util.Scanner;

public class factorial {
   
    //metodo
 public static int fact( int n){
     if(n<0){
         System.out.println(" el número no es positivo");
         System.exit(0);
     }else if(n==0){
     return 1;}
        
     return (n*fact(n-1));
 }   
    
 public static void main (String[] args){
     
     Scanner entrada = new Scanner(System.in);
     int numero;
     
     //ingreso de un valor
     System.out.print("por favor ingreseel numero factorial: ");
     numero=entrada.nextInt();
     
   // impresión del factorial 
     System.out.println("el factorial es: "+factorial.fact(numero));
 }

}

me gusto mucho usar la recursividad, tengo mas claro como usarlo y el termino. Gracias ✌

#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("Ingresa un valor positivo\n");
    }
    else
    {
        result = factorial(n);
        printf("%d! = %ld\n",n, result);

    }
    
    return 0;
}

Es muy interesante usar la recursividad

#include<stdio.h>
long result;
int n;
long factorial(int n)
{
  if(n == 0)
  {
    return  1;
  }
  else
  {
    return(n* factorial(n-1));
  }
}

 main(int argc, char const *argv[])
{
  printf("Ingrese el número a calcular\n");
  scanf("%d", &n);

  if (n<0)
  {
    printf("El número debe ser positivo\n");
  }
  else
  {
    result = factorial(n);
    printf("%d! = %ld\n", n, result);
  }
  return 0;
}

super interesante , me ha quedado un poco mas claro

excelente estas clases vas aprendiendo a corregir cada que sale un error al compilar

genial esto se pone mejor de lo que esperaba.
![](

Funcion implementada en Javascript:

var c = document.getElementById("calcular");
c.addEventListener("click" , calcularFactorial);

var resultado = document.getElementById("resultado");
var result;

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

    else
    {
        return (n * factorial(n-1));
    }
}

function calcularFactorial(n)
{
    var d = document.getElementById("numero");
    var n = parseInt(d.value);  

    if(n < 0)
    {
    alert("Por favor ingrese un numero positivo");
    }

    else
    {
    result = factorial(n);
    resultado.innerHTML = ( n + "! = " + result);
    }
}

Se puede probar aqui:
https://repl.it/@enriqueorozcog/recursividad

¡Súper genial… motivado a seguir con todo el power! jajajaja

#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("Ingreso el número a calular\n");
  scanf("%d", &n);
  if (n<0)
  {
    printf("El número debe ser positivo\n");
  }
  else
  {
    result = factorial(n);
    printf("%d! = %ld\n", n, result);
  }

  return 0;
}

Se necesitan muchos conocimientos previos para poder entender al profesor. Esta mal hecha la ruta de aprendizaje o faltan cursos. En cada curso deberia haber un apartado que diga cuáles son los conocimientos previos requeridos para poder entender.

Aquí dejos mi una función que calcula el factorial usando ciclos y no la recursividad.

long long int factorialConCiclos(int n)
{
    int current_value = 1;
    for(int i = 1; i < n; i++)
    {
        current_value = current_value * (i +1);
    }

    return current_value;    
}

Si tienes cualquier pregunta no dudes en consultarme.

Genial, Gracias por enseñarnos con tanto amor y paciencia 😃

Código en Java:

public class Factorial
{
	public static void main(String[] args)
	{
		Factorial f = new Factorial();
		Scanner scn = new Scanner(System.in);
		
		int n;
		
		do
		{
			System.out.print("Valor al que desea sacarle factorial: ");
			n = scn.nextInt();
			if (n < 0)
				System.out.println("El valor debe ser positivo\n");
		}while(n < 0);
		scn.close();

		System.out.println("\tEl factorial de " + n + " es: " + f.FactorialRecursivo(n));
	}

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

en Java

import java.util.Scanner;

public class Factorial {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        System.out.println("Plese write the number you want to get Factorial to: ");
        int number = in.nextInt();
        System.out.println("Factorial of the number " + number + " is: " + factorial(number));

    }

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

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

long factorial(int n);

int main(int argc, const char * argv[])
{
    long result = 0;
    int n = 0;

    do
    {
        system("cls");
        printf("Ingrese un numero para calcular su factorial\n");
        scanf("%d", &n);
        if(n<0)
        {
            printf("No se puede calcular el factorial de numeros negativos\n");
            system("pause");
        }else
        {
            result=factorial(n);
            printf("El factorial de %d es: %ld", n, result);
        }
    }while(n<0);


    return 0;
}

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

Aquí mi solución

int factorial(int n)
{
    if(n < 0) {
        return -1;
    }
    int fac = n;
    for(int i = n-1; i > 1; i--) {
        fac *= i;
    }
    return fac;
}

js too

const recursividad = (n) => {
    if(n == 0){
        return 1;
    }
    return (n * recursividad(n-1));
};

let n = 5

console.log(`El factorial de ${n} es igual a ${recursividad(n)}`);```

gracias

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


// Calcula el factorial de cualquier numero
// de forma iterativa (sin recursividad)
long factCiclos( int n ) {
  long resultado = 1;
  for ( int i = n; i > 1;  i--) {
    resultado *= i;
  }
  return resultado;
}

// Calcula el factorial de cualquier numero de forma recursiva
long 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
  long factorialRecursivo = fact(entrada);
  long factorialCiclos = factCiclos(entrada);
  printf("El factorial (recursivo) de %d es %ld\n", entrada, factorialRecursivo);
  printf("El factorial (ciclos) de %d es %ld\n", entrada, factorialCiclos);
  return 0;
}

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


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

int main()
{
    bool start =  true;
    while(start == true){
    printf("Ingreso el numero a calcular\n");
    scanf("%d",&n);
    if(n<0){
        printf("El numero debe ser positivo\n");
    }
    else{
        result = factorial(n);
        printf("%d! = %d\n", n, result);
    }
}
    return 0;
}

Version en javascript

Ingrese un numero: 20
20! es 2432902008176640000

#include <stdio.h>

unsigned long long int result;
int n;

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

int main (int argc, char const *argv[])
{
    printf( "Ingrese un numero: ");
    scanf("%d",&n);

    if (n < 0)
    {
        printf( "El numero debe ser positivo\n" );
    }else
    {
        result = factorial(n);
        printf( "%d! es %lld\n", n, result);
    }

    return 0;
}

implemente una función re-cursiva para que se vuelva a llamar mientras el numero no sea positivo:

int confirmation(int n){
    scanf("%d", &n);
    if (n < 0){
        printf("a positive number pls: ");
        confirmation(n);//si no es positivo ejecutate otra vez
    }
    else
        printf("%d! = %ld \n", n, recursiveFact(4));
}

//Hacer algoritmo de recursividad (Factorial de u numero)

#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 dato a calcular: \n");
    scanf("%d",&n);    
    if (n<0)
    {
        printf("El numero debe ser positivo\n");
    }
    else
    {
        result = factorial(n); 
        printf("El factorial de %d != %ld \n", n, result);
    }    
    return 0;
}```

Amo la recursividad, es de las cosas más locas que he aprendido hasta ahora.

Ese Warning que ve el profesor es por que esta declarando argumentos de la función main si no los declara elimina el Warning cuando compila.

Alguien sabe por qué en el editor de código el main, le hace esa estructura y variables por defecto?

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

#include <stdio.h>
#include <stdlib.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, result);
	}
	
	return 0;	
}```

Aquí mi código para la función factorial, utilicé un do while para no dejar al usuario introducir un número negativo.

#include "stdio.h"

long result;
int n = -1;

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

int main(int argc, char const *argv[])
{
    do {
    printf("Insert number to calculate factorial: ");
    scanf("%i", &n);
    printf("\n");
    } while(n < 0);
    result = factorial(n);
    printf("%i! = %li\n", n, result);
    return 0;
}```

Versión en JavaScript

//Factorial de un número

const factorial = (n) => {
    if(n == 0){
        return 1;
    }
    else{
        return n * factorial(n-1)
    };
};

const printAnswer = () =>{
    let result = factorial(3)
    console.log(result)
}

printAnswer()

Acá esta mi ejemplo:

Hmmm… Una cosa sobre Celis. No tiene estilo o estándar cuando escribe código, es decir en ocasiones usa llaves, en otras no, los nombres de variables, muchas líneas de código al resolver el problema (¿será porque usa C?). Aunque eso no es un problema a mayor escala, tiende a ser confuso.

El método factorial en java

 public static void main(String[] args) {
 System.out.println(factorial(n));
}
 public static int factorial(int x){
        return (x>0) ? x * factorial(x-1): 1 ;
 }

Por alguna extraña razon cada vez que doy compilar me muestra este resultado
0! = 1 <-

Este es mi codigo, no se que tengo mal:s

#include <stdio.h>
#include <stdlib.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");
        }
    else 
         {
         result = factorial(n);
         printf("%d! = %ld\n", n,  result);
         }
     return 0;
}

Done!

Excelente!!! también lo hice con interacciones y funciona perfectamente.

Sustituí la función factorial del profesor por la mía.

long result=1;
int n; 
long factorial (int n)
{
    
    for (int step=1;step<=n ; step++)
    
    {
        result*=step;    

    } 
    return result;  
}

realizado

Mi código den C# del factorial

using System;

namespace Factorial
{
    class Program
    {
        static void Main(string[] args)
        {
            int numero;
            Console.WriteLine("FACTORIAL");
            Console.WriteLine("=========\n");
            Console.WriteLine("Ingrese un número para calcular su factorial: ");
            numero = int.Parse(Console.ReadLine());
            if (numero < 0)
                Console.WriteLine("El número debe ser positivo!");
            else
            {
                Console.Write($"El factorial de {numero} es: ");
                Console.Write(Factorial(numero));
            }

        }

        public static long Factorial(int x)
        {
            if (x == 0)
                return 1;
            return (x * Factorial(x - 1));
        }
    }

}

Codigo en JS:

var num = parseInt(prompt("Digita un numero mayor a 0: "));

if (num < 0) {
    console.log("Emmm... Creo que " + num + " es menor que 0...");
}else if (num == 0){
    console.log("Emmm... Por eso el shampoo tiene instrucciones...");
}else{
    console.log("El factorial de " + num + " es: " + fact(num));
}

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

En C++
![](

genia!! 😃

Factorial en Python.

c++
😃

#include <iostream>

using namespace std;
int n;
long result;
char r;
long factorial(int n)
{
    if (n == 0)
    return 1;

 else
  {
    return (n* factorial(n-1));
  }
}
int main()
{
    cout << "presiona cualquier letra para continuar y p para detener" << '\n';
    cin  >> r;
    while(r != 'p')
    {
        cout << "introduce un numero positivo" << '\n';
    cin >> n;
    if (n < 0)
    cout << "introduce un valor positivo" << '\n';
    else
    {
        result =  factorial(n);
    cout << n<< " = "<<result << '\n';
    }
    cin >> r;
    ;
    }

    return 0;
}

Factorial recursivo en python:

def factorial(n):
    if n < 0:
        return ('Por favor ingresa un numero positivo')
    elif n== 0:
        return 1
    else:
        return (n * factorial(n-1))

if __name__ == '__main__':
    n = int(input('Ingresa un numero: '))
    factorial(n)
    print(factorial(n))

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

long recursivo(int num){
    printf("\nEntra a la función recursiva, num=%i\n", num);
    
    if(num>1){
        printf("La función se llamará a sí misma de nuevo.");
        return num * recursivo(num-1);
    }else{
        printf("Se acaba la recursividad, num=1");
        return 1;
    }   
}

long ciclo(int num){
	printf("\nEntra a la función ciclo, num=%i\n\n", num);
	long res=num;
	for(int i=1; i<num; i++){
		printf("%li*%i=", res, i);
		res *= i;
		printf("%li\n", res);
	}
	return res;
}

void menu(){
	int option=0, num=0;
	long res=0;
	do{
		num=0;
		printf("\n---------------------------------------------");
		printf("\nRECURSIVIDAD: FACTORIAL\n\n");			//Diferencia entre usar la recursividad y usar un ciclo para conseguir el factorial de un número
		printf("1. Ejecutar de forma recursiva\n");
		printf("2. Ejecutar con ciclos\n");
		printf("3. Salir\n");
		printf("---------------------------------------------\n");
		printf("Digite su opción: ");
		scanf("%i", &option);
		printf("\n");
		if((option == 1) || (option == 2)){
			printf("Digita un valor para enviarlo como parámetro a la función recursiva: ");
			scanf("%i", &num);
		}
		
		switch(option){
			case 1:
				res = recursivo(num);
			break;
			case 2:
				res = ciclo(num);
			break;
			case 3:
				printf("Gracias por usar");
			break;
			default:
				printf("Opción inválida");
		}
		if((option == 1) || (option == 2)){
			printf("\n\nEl resultado es: %li", res);
		}
		printf("\n");
	}while(option != 3);
}

int main(){	
    menu();
    
    return 0;
}

En c

#include <stdio.h>
#include <stdlib.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("Inserta numero a factorizar: \n");
    scanf("%d", &n);

    for (int i = 0; n < 0; i++ ){ // por si el usuario es muy insistente en introducir numeros negativos

                printf("inserte un numero que sea positivo\n");
                scanf("%d", &n);
        }
    if (n>=0){
        result = factorial(n);
        printf("El factorial de %d = %ld\n",n, result);

    }

    return 0;
}

Python:

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


def main():
    num = float(input('Ingrese el número a calcular:\n'))
    if num < 0:
        print('Calmate, el numero debe ser positivo.\n')
    else:
        result = factorial(num)
        print(f'El factorial de {int(num)}! es {result}')

if __name__ == '__main__':
    main()

Un mini programa

function factorial(n){

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

const prog = () => {
    document.addEventListener('DOMContentLoaded', () => {
        
        let num = prompt("Ingrese un numero")
       
        if(num < 0 ){
            alert('El numero tiene que se positivo')
        }else{
            console.log(`El valor de n es : ${num}`)
            result = factorial(num)
        }

        alert(`El factorial de ${num} es: ${result}`)
    })
}

prog()```

#include <stdio.h>
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("Ingrese el # de factorial\n" );
    scanf("%d",&n );
    if(n<0){
      printf("No valores negativos :V\n");
    }else{
      resultado = factorial(n);
      printf("%d! = %ld\n",n,resultado );
    }
  return 0;
}

¡Les comparto mi código, en C, mostrando ambas funciones (con loop y recursiva) para calcular el factorial!

#include <stdio.h>

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

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

int main(void)
{
    int n;
    long loopResult,result;
    printf("Please enter the factorial you want: ");
    scanf("%i",&n);
    if(n<0)
    {
        printf("The number must be positive!\n");
    }
    else
    {
    result=loopFactorial(n);
    printf("\nThe factorial (loop) of %i! is: %ld\n",n,result);
    loopResult=recursiveFactorial(n);
    printf("\nThe factorial (recursive) of %i! is: %ld\n",n,loopResult);
    }
    return 0;
}

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


if __name__ == "__main__":
    num = int(input('Ingresa el numero a encontrar su factorial: '))
    print(factorial(num)) ```

Buena clase!

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

if __name__ == "__main__":
    n = int(input("Escribe el numero a calcular: "))
    
    resultado = factorial(n)
    print(f"El factorial de {n} es: {resultado}")

En python