Bienvenido al Curso

1

Introducci贸n al curso b谩sico de algoritmos y estructuras de datos

Introducci贸n a los algoritmos

2

驴Qu茅 entiende una computadora?

3

Lenguajes de programaci贸n

4

Estructuras de datos

5

驴Qu茅 es un algoritmo?

6

Metodolog铆a para la construcci贸n de un algoritmo

7

Variables y tipos de datos

8

User defined data types

9

Instalando Ubuntu Bash en Windows

10

Creando nuestro user defined data type

11

Abstract Data Types b谩sicos: Lists, Stacks, Queues

12

Explicaci贸n gr谩fica Data Types b谩sicos

13

Glosario de funciones para Abstract Data Types

14

Clases y objetos

15

Creando tu primera Queue: Arrays

16

Creando tu primera Queue: implementaci贸n.

17

Creando tu primera Queue: implementar la funci贸n enQueue

18

Creando tu primera Queue: implementar la funci贸n deQueue

19

Creando tu primera Queue: main code

Algoritmos de ordenamiento

20

Algoritmos de ordenamiento

21

Bubble sort

22

Bubble sort: implementaci贸n

23

Bubble sort: main code

24

Insertion sort

25

Desaf铆o: implementa un algoritmo de ordenamiento

Recursividad

26

Recursividad

27

La funci贸n Factorial, calculando el factorial recursivamente

28

Manejo de cadenas de caracteres

29

Arte: Generando arte recursivo

Divide and conquer y programaci贸n din谩mica

30

Divide and Conquer (divide y vencer谩s)

31

Qu茅 es la programaci贸n din谩mica (divide y vencer谩s v2.0)

32

MergeSort

33

Desaf铆o: Buscar el algortimo m谩s r谩pido de sort

34

Implementando QuickSort con Python

35

Implementando QuickSort con Python: main code

Algoritmos 'Greedy'

36

Qu茅 son los Greedy Algorithm

37

Ejercicio de programaci贸n greedy

38

Ejercio de programaci贸n greedy: main code

Grafos y 谩rboles

39

Grafos y sus aplicaciones

40

脕rboles

驴C贸mo comparar Algoritmos?

41

C贸mo comparar algoritmos y ritmo de crecimiento

驴Qu茅 sigue?

42

Cierre del curso y siguientes pasos

No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

La funci贸n Factorial, calculando el factorial recursivamente

27/42
Recursos

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!

Aportes 103

Preguntas 2

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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 鈥榬ecursi贸n鈥 y la funci贸n correspondiente es llamada 鈥榝unci贸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 鈥榥鈥 si sabemos el factorial de 鈥榥-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(鈥淭ype a number to get factorial\n鈥);
scanf("%d",&n);

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

fact *= i;

} printf(鈥淔actorial 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

Algo muy curioso es que el factorial de 20 sale negativo, esto se debe al stack de limite 100 ?

al quien sabe a que se debe este warning no me ejecuta el programa.

![](