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

Recursividad

26/42
Recursos

La recursividad es la capacidad de una funci贸n de llamarse a si misma.

Las funciones recursivas tienen las siguientes caracteristicas.

  • Se llaman a si mismas.
  • Tienen de argumento un valor que cambio por cada iteraci贸n.
  • Regresan alg煤n valor definido en cada iteraci贸n.
  • Tienen una condicional que define el fin del ciclo.
  • Manejan un stack que es el 贸rden de las ejecuciones de las iteraciones de la funci贸n, empezando por la 煤ltima a llamar.

Aportes 262

Preguntas 4

Ordenar por:

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

o inicia sesi贸n.

Recursos para hacer la tarea 馃憖馃槒:

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 (n
factorial(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.

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 鈥淪tack鈥, 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 鈥渞egistros 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(鈥淔actorial de %d es 1.\n鈥 , n);
else
{
for(i=0; i<n; i++)
f=f*(n-i);
printf(鈥淔actorial 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(鈥渙rinum鈥);
}

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

<h4>Diferencias entre uno y otro</h4>
  • 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 鈥渇or鈥:

#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 鈥渃apa鈥 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))```