¿Cómo realizar una función recursiva en Python?

### Me costo trabajo entender la función recursiva. Asi que aqui va una explicacion de chatGPT Call Stack en Recursión Cuando llamas a una función en Python (o en la mayoría de los lenguajes de programación), la llamada a la función se añade al call stack. El call stack lleva un registro de todas las llamadas a funciones que necesitan resolverse. Cuando una función devuelve un valor, se elimina del call stack. ### Ejemplo: factorial(5) Veamos el call stack mientras se evalúa factorial(5): 1. **Llamada inicial**: Se llama a `factorial(5)` y se añade al call stack. * Call stack: `[factorial(5)]` 2. **Segunda llamada**: `factorial(5)` llama a `factorial(4)`. * Call stack: `[factorial(5), factorial(4)]` 3. **Tercera llamada**: `factorial(4)` llama a `factorial(3)`. * Call stack: `[factorial(5), factorial(4), factorial(3)]` 4. **Cuarta llamada**: `factorial(3)` llama a `factorial(2)`. * Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2)]` 5. **Quinta llamada**: `factorial(2)` llama a `factorial(1)`. * Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1)]` 6. **Sexta llamada**: `factorial(1)` llama a `factorial(0)`. * Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1), factorial(0)]` ### Caso base alcanzado Cuando se llama a `factorial(0)`, se alcanza el caso base y devuelve 1. Este valor de retorno comienza el proceso de desenrollar el call stack. ### Devolviendo valores y desenrollando el stack Ahora, cada llamada devuelve su resultado y se elimina del call stack: 1. `factorial(0)` devuelve 1. * Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2), factorial(1)]` 2. `factorial(1)` devuelve `1 * 1 = 1`. * Call stack: `[factorial(5), factorial(4), factorial(3), factorial(2)]` 3. `factorial(2)` devuelve `2 * 1 = 2`. * Call stack: `[factorial(5), factorial(4), factorial(3)]` 4. `factorial(3)` devuelve `3 * 2 = 6`. * Call stack: `[factorial(5), factorial(4)]` 5. `factorial(4)` devuelve `4 * 6 = 24`. * Call stack: `[factorial(5)]` 6. `factorial(5)` devuelve `5 * 24 = 120`. * Call stack: `[]` ### Resultado final El resultado final de `factorial(5)` es 120, y el call stack está vacío una vez que todas las llamadas a funciones han devuelto sus valores. ### Resumen * Cada llamada a `factorial(n)` se añade al call stack. * El caso base `factorial(0)` detiene la recursión y comienza a devolver valores. * El call stack se desenrolla, devolviendo valores paso a paso hasta que se resuelve la llamada inicial. * El call stack asegura que el contexto de cada llamada (su propio valor de `n`) se preserve hasta que pueda resolverse.

```js #reto def sumatoria(n): if n == 0: return 0 else: return n + sumatoria(n - 1) # Probar la función con varios valores for i in range(11): print(f"Sumatoria de {i} es: {sumatoria(i)}") ```

### Recursividad La recursividad es una técnica de programación en la que una función se llama a sí misma para resolver un problema. Un problema se divide en subproblemas más pequeños y la función se llama recursivamente hasta que se alcanza una condición base que finaliza las llamadas recursivas. ### Consideraciones sobre la Recursividad 1. **Condición Base**: Es crucial definir correctamente una condición base para evitar llamadas recursivas infinitas. 2. **Eficiencia**: Las implementaciones recursivas pueden ser ineficientes para problemas complejos debido a la sobrecarga de llamadas a funciones. En el caso de Fibonacci, una implementación recursiva simple tiene una complejidad exponencial `O(2^n)`. Esto puede mejorarse utilizando memoización o una implementación iterativa. ```js def fibonacci_memo(n, memo={}): if n in memo: return memo[n] if n == 0: return 0 elif n == 1: return 1 else: memo[n] = fibonacci_memo(n - 1, memo) + fibonacci_memo(n - 2, memo) return memo[n] # Ejemplo de uso print(fibonacci_memo(10)) # Salida: 55 ```

Hay que tener cuidado en donde **SI** y en donde **NO** se debe usar la recursividad. En el caso de resolver Fibonacci o la sumatoria de los números naturales de 1 a n la recursividad no es el mejor método y explico porque. Para Fibonacci: Para no extenderme dejo una captura de mi código agregando una variable que va contando las veces que se invoca la función y al final imprime cuantas veces fue invocada. Si la comparamos con la versión de Fibonacci usando un generador en la que cada vez que se entra a calcular se imprime lo que se está calculando (equivalente a cada vez que se llama) se puede ver que es mucho más eficiente el método por generadores. Para la sumatoria: Doy por hecho que conocen la historia de Gauss y su forma de resolver la sumatoria de 1 a 100. Programar esta sumatoria de forma recursiva (o incluso con un ciclo for o while) es como el castigo que se les puso a los niños y programarlo usando una formula para hacer el cálculo es como lo habría hecho Gauss, en resumen, mi función puede ser calculada "n" siendo "n" el número hasta donde quiero sumar pero si en lugar de hacerlo recursivo mejor solo uso n(n+1)/2 esta forma es mucho más rápida que incluso se puede hacer mentalmente. Con esto no quiero decir que la recursividad no sirva porque en los casos de calcular un factorial o escribir los pasos de los movimientos de los discos para resolver las torres de Hanoi sería más complicado no usar recursividad. 

Os dejo una función recursiva para generar la serie de fibonacci hasta un número limite: `def fibonacci(f1, f2, n):` ` print(f1)` ` if n > f2:` ` print(f2)` ` fibonacci ( f1 + f2, f1 + f2 + f2 , n)` ` else:` ` print ("fin")` `fibonacci(0,1,int(input("Generar fibonacci con limite: ")))`

Quise hacer algo un poco más amigable con el usuario ```js def sumatoria(n): if n == 0: return 0 else: return n + sumatoria(n-1) n = int(input("Ingrese un número entero: ")) print(f"La suma de números naturales hasta {n} es: {sumatoria(n)}") ```

Después de repetir como 10 veces la clase, creo que ya mas o menos me quedo un poco más claro.

1. **Cuándo Usar Recursión**: * La recursión es útil cuando un problema se puede dividir en casos más pequeños y similares al problema original. * Algunos ejemplos comunes de uso de recursión son: * Cálculo de factoriales. * Búsqueda en árboles o grafos. * Resolución de problemas matemáticos o algorítmicos. 1. **Importante**: * Siempre debes tener un **caso base** que marque el final de las llamadas recursivas. De lo contrario, podrías entrar en un ciclo infinito. * Además, asegúrate de que cada llamada recursiva se acerque al caso base.

```python #Solución Reto Suma de Números Naturales def suma_numeros(n): if n == 0: return 0 else: return n + suma_numeros(n - 1) def print_suma(count): sequence = [] for i in range(1, count + 1): sum_result = suma_numeros(i) sequence.append(sum_result) if i == count: print(f"{i} = {sum_result}", end=" ") else: print(f"{i} +", end=" ") # Ejecución. count = 7 print_suma(count) ```

Reto sumatoria número naturales: ```js def summationOfNaturalNumbers(n): if n <= 1: return n else: return n + summationOfNaturalNumbers(n - 1) print(summationOfNaturalNumbers(5)) ```

Este es otro curso de python en el cual toca este tema de recursividad. Espero les ayude. <https://platzi.com/home/clases/1764-python-cs/25243-recursividad/>

```python # Reto sumatoria de numeros naturales def sumatoria(N): if N==0: return 0 else: return N+sumatoria(N-1) num=3 print("La sumatoria de todos los numeros menores que ",num,"es:",sumatoria(num)) ```

Quise que el usuario ponga el número del cual quiere el factorial así que le añadí el input: def factorial(n): if n == 0: return 1 else: return n * factorial (n-1) x = int(input("Ingrese número: ")) factorial_n = print(factorial(x)) 🙌

Quería obtener la lista completa con la cantidad de números indicado así que modifiqué el print. 🤗 def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 else: return fibonacci(n-1) + fibonacci(n-2) print([fibonacci(n) for n in range(5)])

Gente aquí les dejo una variante al **ejercicio de Fibonacci** que me pareció interesante**:** ```python def fib_r(n): if n < 2: return n else: return fib_r(n-1) + fib_r(n-2) n = int(input("Ingrese la cantidad de elementos para fibonacci: ")) for x in range(n): print(fib_r(x)) ```

```js def numeros_naturales(numero): if numero == 0: return 0 else: return numero + numeros_naturales(numero - 1) numero_usuario = int(input("ingrese un número natural: ")) resultado = numeros_naturales(numero_usuario) print(f"La suma de números naturales hasta {numero_usuario} es de : {resultado}") ```def numeros\_naturales(numero): if numero == 0: return 0 else: return numero + numeros\_naturales(numero - 1) numero\_usuario = int(input("ingrese un número natural: ")) resultado = numeros\_naturales(numero\_usuario) print(f"La suma de números naturales hasta {numero\_usuario} es de : {resultado}")

```python def fibonacci(n): if n==0: fiboncito=[0] return fiboncito if n==1: fiboncito=[0,1] return fiboncito else: fiboncito=fibonacci(n-1) fiboncito.append(fiboncito[-1]+fiboncito[-2]) return fiboncito n=7; print("Los primeros %i terminos de la serie de Fibonacci son:"%(n),fibonacci(n-1)) ```

```js #reto calcula la sumatoria de números naturales a partir de n hacía atras def sumatoria(n): if n > 0: print(n) return n + sumatoria(n-1) else: return 0 print(sumatoria(8)) ```

Os comparto una función recursiva para generar la serie de fibonacci con un límite. ![]()

la sumatoria esta muy aburrida, que tal si le hacemos a esto Exercise: Prime Number Analyzer Create a Python program that performs the following tasks: 1\. Generate Prime Numbers: Use a generator function to produce an infinite sequence of prime numbers. 2\. Iterator for N Primes: Create an iterator that allows you to iterate over the first N prime numbers. 3\. Recursive Sum of Primes: Implement a recursive function that calculates the sum of the first N prime numbers. 4\. Filter and Map: Use filter and map functions to filter out primes that are less than a given threshold and then create a list of their squares. 5\. Lambda Functions: Integrate lambda functions within map and filter operations.

Respuesta del reto def suma (numero):    if numero == 0:        return 0    else:        return numero + suma(numero-1) variab = print(suma(10))

Para calcular la serie de Fibonacci usando recursividad, se define una función que toma un número `n` como parámetro. El código básico sería: ```python def fibonacci(n): if n == 0: return 0 # Caso base elif n == 1: return 1 # Caso base else: return fibonacci(n - 1) + fibonacci(n - 2) # Caso recursivo ``` Si llamamos a `fibonacci(5)`, el flujo sería: 1. `fibonacci(5)` llama a `fibonacci(4)` y `fibonacci(3)`. 2. `fibonacci(4)` llama a `fibonacci(3)` y `fibonacci(2)`. 3. `fibonacci(3)` llama a `fibonacci(2)` y `fibonacci(1)`. 4. `fibonacci(2)` llama a `fibonacci(1)` y `fibonacci(0)`. Los casos base devolverán 1 y 0, respectivamente, y luego se sumarán: - `fibonacci(0)` = 0 - `fibonacci(1)` = 1 - `fibonacci(2)` = `1 + 0` = 1 - `fibonacci(3)` = `1 + 1` = 2 - `fibonacci(4)` = `2 + 1` = 3 - `fibonacci(5)` = `3 + 2` = 5 Así, el resultado final de `fibonacci(5)` es 5.


*def* exp(n, e):    *if* n == 0:        *return* 0    *elif* e == 0:        *return* 1    *elif* e == 1:        *return* n    *elif* e < 0:        *return* 1 / exp(n, (e \* -1))    *else*:        *return* n \* exp(n, e - 1) print(exp(2, -1))

**Recursividad** para calcular potencia: `def exp(n, e):` ` if n == 0:` ` return 0` ` elif e == 0:` ` return 1` ` elif e == 1:` ` return n` ` elif e < 0:` ` return 1 / exp(n, (e * -1))` ` else:` ` return n * exp(n, e - 1)` `print(exp(2, -1))`

MI DESAFIO 😁👍😶‍🌫️☠️ ```python # LA RECURSIVIDAD # 1 2 3 4 5 6 7 8 9 10 n = int(input("INGRESE UN LIMITE : ")) def suma_numeros (n): if n == 0: return 0 else: return n + suma_numeros(n-1) # <--LA RECURSIVIDAD for i in range(n): print(f"SUMANDO DE {i} ES: {suma_numeros(i)}") ```

Ejercicio de Tarea. 

def suma(n):    if n == 0:        return 0    else:        return n + suma(n - 1)    numero = 6 print (suma (numero)) ese fue el codigo que realice entendi el concepto pero no como se usa en el entorno laboral

De esta manera resolví el reto: 

Bueno, ps asi lo resolvi a la primera jeje, ya me quedo un poco mas claro aunque me tomo bastante tiempo y con ayuda de Chatgpt que me lo explico mas detalladamente. 

Gracias por este tema que así como a Juan Pablo es de cuidado, y muy interesante para aplicarlo.

\#Reto sumatoria numeros naturales  

No es mucho pero es trabajo honesto, no se hasta que punto este bien el "<=": ```js def summation(n): if n <= 0: return 0 else: return n + summation(n-1) number = 7 print(summation(number)) ```def summation(n):    if n <= 0:        return 0    else:        return n + summation(n-1) number = 7print(summation(number))

aquí mi forma de resolver el ejercicio: 

Solución al reto ```js def naturals(n): if n == 0: return 0 else: result = n + naturals(n - 1) print(f"La suma del número natural {n} es igual a: {result}") return result nat = int(input("Ingrese el valor del número natural a calcular: ")) print(naturals(nat)) ```

### ¿Qué hace `return`? 1. **Finaliza la Ejecución de la Función**: * Cuando Python encuentra una declaración `return` dentro de una función, detiene la ejecución de esa función inmediatamente y vuelve al punto donde la función fue llamada. 2. **Devuelve un Valor**: * `return` puede devolver un valor (o varios valores) al lugar donde se llamó la función. Este valor puede ser de cualquier tipo de dato: números, cadenas, listas, objetos, etc. * Si no se especifica un valor después de `return`, la función devuelve `None` por defecto. ### Ejemplos de Uso #### Ejemplo Básico `def suma(a, b`): ` return` a + b `resultado = suma(3, 4`) `print(resultado) # Imprime: 7` En este ejemplo, `return a + b` devuelve la suma de `a` y `b` a la variable `resultado`. #### Uso en Condicionales `def es_par(numero`): ` if numero % 2 == 0`: ` return True` ` else`: ` return False` `print(es_par(4)) # Imprime: True` `print(es_par(5)) # Imprime: False` Aquí, `return` se usa para devolver `True` o `False` dependiendo de si el número es par o no. #### Uso en Recursión Como vimos en tu función de factorial, `return` es crucial para devolver el resultado de cada llamada recursiva: `def factorial(n`): ` if n == 0`: ` return 1` ` else`: ` return n * factorial(n - 1`) ### ¿Por Qué es Importante? * **Control del Flujo**: `return` permite controlar cuándo y qué valor se devuelve desde una función, lo que es esencial para la lógica del programa. * **Modularidad**: Permite que las funciones sean modulares y reutilizables, ya que pueden devolver resultados que otras partes del programa pueden usar. * **Claridad**: Hace que el código sea más claro y fácil de entender, ya que especifica explícitamente qué valor se espera que devuelva una función.

reto 


def SumaNaturales(*n*):    *if* *n* == 0:        *return* 0    *else*:        *return* *n*+SumaNaturales(*n*-1)    num=10print(SumaNaturales(num))

```js def SumaNaturales(n): if n == 0: return 0 else: return n+SumaNaturales(n-1) num=int(input("inserta numero a calcular: ")) print(SumaNaturales(num)) ```RETO..

Les comparto mi funcion: ```python def sumatoria(ini, n): if n == ini: return n else: return n + sumatoria(ini, n - 1) ```

Hola! Les comparto el ejercicio de Fibonacci con una modificación para mostrar la serie completa y no solo el resultado de la posición indicada. ```python def fibonacci(n): if n == 0: return 0 elif n == 1: return 1 else: return fibonacci(n - 1) + fibonacci(n - 2) numbers = range(10) serie = list(map(fibonacci, numbers)) print(serie) ```Además la solución al reto: ```python def sum_numbers(numbers): if not numbers: return 0 else: return numbers[0] + sum_numbers(numbers[1:]) numbers = range(5) print(sum_numbers(numbers)) numbers = [2, 3, 4, 7] print(sum_numbers(numbers)) ```

Mi solución al ejercicio de la clase ```js def sum_natural(n): if n == 0: return 0 else: return n + sum_natural(n - 1) sum_natural_n = print(sum_natural(50)) ```

Quizás alguien más tenga la misma inquietud. Me preguntaba en qué momento le dimos un ciclo FOR a nuestro código. Y es que estamos llamando la función dentro de la función, por eso se genera un ciclo de repetición hasta que n vale 0. También, es muy curioso que si hacemos una corrida en frío, y según yo, cuando n vale 0 y retorna 1, es cuando empieza a salir los factoriales, digamos, en reversa. En mi cabeza el orden de la operación se ve así: 5\*(4\*(3\*(2\*(1))))

el ejercicio lo realice de esta manera```python def sumatoria(n): if n == 0: return else: return (n*(n-1))/2 n= float(input("ingrese el numero hasta donde desa sumar: ")) print(f"el resultado de la suma de los primeros {n} numeros enteros es:", sumatoria(n)) ```

```python # serie de Fibonnacci # caso base cuando es cero y uno # caso recursivo : f(n-1) + f(n-2) def fibonnacci(n): if n in [0, 1]: return n else: return fibonnacci(n-1) + fibonnacci(n-2) # imprime los primeros 11 números de la serie for number in range(11): print(fibonnacci(number), end=" ") ```# serie de Fibonnacci# caso base cuando es cero y uno# caso recursivo : f(n-1) + f(n-2)def fibonnacci(n):    if n in \[0, 1]:        return n    else:        return fibonnacci(n-1) + fibonnacci(n-2) \# imprime los primero 11 números de la seriefor number in range(11):    print(fibonnacci(number), end=" ")

Hola a todos, esta es la solución al reto planteado: def sumatoria(n): if n == 1: return 1 else: return n + sumatoria(n - 1)

Mi solución al reto :D 

Una **función recursiva** en Python es una función que se llama a sí misma para resolver un problema dividiéndolo en partes más pequeñas. Se usa cuando un problema puede ser resuelto al descomponerlo en versiones más simples de sí mismo, y siempre debe tener una **condición base** que detenga la recursión. Ejemplo: Calcular el factorial de un número (n!) usando recursión. def factorial(n): if n == 1: # Condición base return 1 else: return n \* factorial(n - 1) # Llamada recursiva

La recursividad es una técnica empleada para resolver problemas que implican la repetición de un proceso, como la búsqueda o el cálculo matemático. Se realiza con funciones que se llaman a sí mismas una y otra vez y se puede entender como una especie de bucle que itera hasta que se cumple una condición

Hola!! Para poder entender mejor el tema de la recursividad, intenten hacer debugging en visual studio code. Esto me ayudo para entender la recursividad. Saludos

Mi aporte al reto suma\_naturales 

de esta forma lo podemos hacer con un for ```python def sumatoria(limite): n = 0 while n < limite: yield n n += 1 for numero in sumatoria(11): print(numero) ```def sumatoria(limite):        n = 0        while n < limite:            yield n            n += 1    for numero in sumatoria(11):    print(numero)

Descubri una forma tambien de hacerlo usando un ciclo for ```python def sumatoria(limite): n = 0 while n < limite: yield n n += 1 for numero in sumatoria(11): print(numero) ```

El Fibonacci de 1 no es caso base, porque n-1 = 0 se puede resolver fácilmente. Me quedó así: ```js def fibonacci(n): if n == 0: return 0 else: return n + fibonacci(n-1) print(fibonacci(1)) ```def fibonacci(n): if n == 0: return 0 else: return n + fibonacci(n-1)

```python # RETO: Suma de los primeros n numeros naturales def sum_consecutive_numbers(n): if n == 0: return 0 else: return n + sum_consecutive_numbers(n-1) n=4 print("Suma:", sum_consecutive_numbers(n)) ```

Hice un programa en el que puedo elegir la operación que quiero realizar (Factorial o Fibonacci) y el número que quiero procesar: ```js print("Bienvenido al programa de cálculos") print("Escribe 1 para Factorial") print("Escribe 2 para Fibonacci") option = int(input("Elige una opción")) def factorial(n): if n == 0: return 1 else: return n * factorial(n-1) def fibonacci(y): if y == 0: return 0 elif y == 1: return 1 else: return y + fibonacci(y-1) def operacion(): while True: if option == 1: print("Has elegido factorial") factorial_n = int(input("Escriba el número del cuál desea saber el factorial = ")) print(f"El factorial de {factorial_n} es {factorial(factorial_n)}") break elif option == 2: print("Has elegido Fibonacci") fibonacci_n = int(input("Escriba el número del cuál desea saber el fibonacci = ")) for num in range(fibonacci_n): fibonacci(num) print(f"El fibonacci de {fibonacci_n} es {fibonacci(num)}") break else: print("Por favor elige una opción correcta") continue operacion() ```**Resultado:** 

Concuerdo la primer vez que aprendi recursion fue complejo de paso muy buena explicacion profe. Factorial tambien es un tipo de crecimiento de Big O entender como funciona la recursividad es vital para identificar cuando una algoritmo tiene crecimiento Factorial :)

Acá me encontre con un problema, y fue al momento de realizar operaciones con números grandes, ya que al tener que realizar operaciones más complejas e ir recurriendo a los valores anteriores, el procesamiento de la operación se hace mucho más lento. Pero si uno emplea un diccionario o cache, para almacenar esos valores puede ser más rápida la respuesta: ```js # Serie de fibonacci con memorización cache = {} # Diccionario vacío def fibonacci(n): if n in cache: return cache[n] elif n == 0: result = 0 elif n == 1: result = 1 else: result = fibonacci(n-1) + fibonacci(n-2) cache[n] = result # Se guarda el resultado en el diccionario return result # Se retorna el resultado10 curvita_1 = (int(input("Ingrese un numero para fibonnaci: "))) print(fibonacci(curvita_1)) ```# Serie de fibonacci con memorizacióncache = {} # Diccionario vacío def fibonacci(n):    if n in cache:        return cache\[n]    elif n == 0:        result = 0    elif n == 1:        result = 1    else:         result = fibonacci(n-1) + fibonacci(n-2)            cache\[n] = result # Se guarda el resultado en el diccionario    return result # Se retorna el resultado10curvita\_1 = (int(input("Ingrese un numero para fibonnaci: ")))print(fibonacci(curvita\_1))

También si son más avanzados, este tema si se me complico al comienzo que era el tema de los doble factoriales: ```js # Ejercicio 3 ## Calcular el numero de doble factorialde un número factor = input('ingresa un numero para el n!!: ') print('El doble factorial de', factor, 'es: ') if factor.isdigit(): factor = int(factor) # Se convierte el número a entero factorial = 1e0 # Se incia el factorial en 1 #Para numeros pares if factor % 2 == 0: # Se verifica si el número es par for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2 factorial *= i # Se calcula el factorial #Para numeros impares else: for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2 factorial *= i # Se calcula el factorial print(factorial) ```# Ejercicio 3## Calcular el numero de doble factorialde un número factor = input('ingresa un numero para el n!!: ') print('El doble factorial de', factor, 'es: ') if factor.isdigit():    factor = int(factor) # Se convierte el número a entero    factorial = 1e0 # Se incia el factorial en 1        #Para numeros pares    if factor % 2 == 0: # Se verifica si el número es par        for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2            factorial \*= i # Se calcula el factorial            #Para numeros impares    else:        for i in range(factor, 0, -2): # El factorial se calcula de manera descendente comenzando desde el número ingresado y se decrementa de 2 en 2            factorial \*= i # Se calcula el factorial            print(factorial)

Me acordo a este ejercicio que habia realizado antes como una calculadora de factoriales:# Ejercicio 2## Calcula el factorial de un número factor = input("Ingresa un número para calcular su factorial: ") print("El factorial de", factor, "es: ") if factor.isdigit():    factor = int(factor) # Se convierte el número a entero    factorial = 1e0 # Se inicializa el factorial en 1e0, se coloca el e0 para que empieze desde exponente 1 que es el mismo número.    for i in range(1, factor+1): # Se recorre el rango del número ingresado        factorial \*= i # Se calcula el factorial            print(factorial) # Se imprime los numeros factoriales del número ingresado ```js # Ejercicio 2 ## Calcula el factorial de un número factor = input("Ingresa un número para calcular su factorial: ") print("El factorial de", factor, "es: ") if factor.isdigit(): factor = int(factor) # Se convierte el número a entero factorial = 1e0 # Se inicializa el factorial en 1e0, se coloca el e0 para que empieze desde exponente 1 que es el mismo número. for i in range(1, factor+1): # Se recorre el rango del número ingresado factorial *= i # Se calcula el factorial print(factorial) # Se imprime los numeros factoriales del número ingresado ```

def fibonacci(n):    if n == 0:        return 0    elif n == 1:        return 1    else:        return fibonacci(n - 1) + fibonacci(n - 2)    number = 3print(fibonacci(number)) def number\_natural(n):    if n == 0:        return 0    else:            return n + number\_natural(n-1)    number = 8print("Suma:",number\_natural(number))

```python def num_nat(n): if n == 0: return 0 elif n < 0: return "No es un número natural" else: return n + num_nat(n - 1) number = 10 print(f"La sumatoria de {number} es: {num_nat(number)}") ```

Hola con todos colegas, les envío mi reto:. Lo que yo quise hacer, es tambien hacer participar al usuario y que el ponga el numero, pero si no es no numero natural entonces seguira preguntando por numero valido para la realización de la función: ```js def recursividad(n): if n == 0 : return 0 else : return n + recursividad(n-1) def perdir_numero(): while True: try: n = int(input("Ingrese tu valor entero :")) except ValueError: print("Entrada no válida. Intente de nuevo") n = perdir_numero() print(recursividad(n)) ```def recursividad(n):    if n == 0 :        return 0    else :        return n + recursividad(n-1) def perdir\_numero():    while True:        try:            n = int(input("Ingrese tu valor entero :"))        except ValueError:            print("Entrada no válida. Intente de nuevo")n = perdir\_numero()print(recursividad(n))

def naturales(n): if n==0: return 0 else: return n+naturales(n-1) print(naturales(10))

😄 Solución al reto: def sumatoria(n): if n == 0: return 0 else: return sumatoria(n-1) + n x = int(input("Ingrese número: ")) print("La sumatoria de todos los números que son menor o igual a", x, "es: ", sumatoria(x))

Hola , quería saber que aplicacion usa para escribir a mano con ese estilo de letra. Gracias

Reto: ```js def num_natural(num): if num == 0: return 0 if num == 1: return 1 else: return (num_natural(num-1)+num) # num = 5 devería dar por resultado 4 + 3 + 2 + 1 = 10 print ("Resultado suma números naturales:",num_natural(5)) ```def num\_natural(num):    if num == 0:        return 0    if num == 1:         return 1    else:       return (num\_natural(num-1)+num)                # num = 5 devería dar por resultado 4 + 3 + 2 + 1 = 10 print ("Resultado suma números naturales:",num\_natural(5))

La sentencia `else` se puede omitir en algunos casos, como en el siguiente ejemplo: ```js def sumatoria(n): if n == 0: return n return n + sumatoria(n-1) print(sumatoria(10)) ```

```python # Acá dejo mi posible solución: def naturales(n, x = 0): if n == 0: return x else: return naturales(n-1, x+n) print(naturales(10)) ```# Acá dejo mi posible solución: def naturales(n, x = 0):    if n == 0:        return x    else:        x += n        return naturales(n-1, x)    print(naturales(10))

este es mi código de sumatoria con concurrencia: ```js # suma de numeros concurrente num = 255 def concuSum(n): # la suma se limita a los numeros enteros mayores que cero if n < 0: return "numero no valido" elif n == 0: return 0 else: return n + concuSum(n-1) print(f"la suma de los numeros entre cero y {num} es de {concuSum(num)}") ```

*#RETO SUMATORIA DE NUMEROS NATURALES* `def`` suma_de_numeros_naturales(``n``):    if n == 0:        return 0    else:        return n + suma_de_numeros_naturales(n-1)` `print(suma_de_numeros_naturales(4))` `for i in range(5):    print(``f``"la suma de numeros naturales hasta {i} es: {suma_de_numeros_naturales(i)}")` # #Resultado: 10 la suma de numeros naturales hasta 0 es: 0 la suma de numeros naturales hasta 1 es: 1 la suma de numeros naturales hasta 2 es: 3 la suma de numeros naturales hasta 3 es: 6 la suma de numeros naturales hasta 4 es: 10

Esta es mi propuesta de solución: ```python # sumatoria de numeros naturales def sumatoria_numeros_naturales(n): return (( n * (n + 1) )/2) sumatoria = print(sumatoria_numeros_naturales(100)) ```

Mi aporte al reto `def sumaNatural(numero):    if numero == 0:         return 0    else:        return numero  + sumaNatural(numero-1)    print(f"El resultado de la suma es: {sumaNatural(10)}")`

def sumaNatural(numero):    if numero == 0:         return 0    else:        return numero  + sumaNatural(numero-1)    print(f"El resultado de la suma es: {sumaNatural(10)}")

La mejor explicación...!!!!


Esta es mi solución def numeros\_naturales(number): if number == 0: return 0 else: return number + numeros\_naturales(number-1)

```js def number_natural(n): if n == 0: return 0 else: return n + number_natural(n-1) number = 8 print("Suma:",number_natural(number)) ```

def suma\_numeros(n):    # Caso base: si n es 0, la suma es 0    if n == 0:        return 0    # Llamada recursiva: suma el número actual n con la suma de los números anteriores    else:        return n + suma\_numeros(n - 1) \# Ejemplo de uson = 10resultado = suma\_numeros(n)print(f"La suma de los primeros {n} números naturales es: {resultado}")

```python def natural(n): if n == 0: return 0 else: return n + natural(n-1) number = 8 print(natural(number)) ```

Tengo una duda, que diferencia hay si termino la sumatoria en 0 o si la termino en 1... solamente estoy ahorrandome un proceso de la recursividad. ¿Es mejor terminar en uno que en cero, ya que para ambos casos se cumple el obtetivo?def sumatoria(num):    if num == 1:        return 1    else:         return num + sumatoria(num-1) def sumatoria(num):    if num == 0:        return 0    else:         return num + sumatoria(num-1) ```python def sumatoria(num): if num == 1: return 1 else: return num + sumatoria(num-1) def sumatoria(num): if num == 0: return 0 else: return num + sumatoria(num-1) ```

Función para la sumatoria de n números ```js num = int(input('Ingrese un numero: ')) def sumatoria(num): if num==1: return 1 else: return num+sumatoria(num-1) print(sumatoria(num)) ```

```js #Mis soluciones #fibonaccion sin funcion con while recursivo lista_inicial = [0,1] while len(lista_inicial) < 20: #tamano maximo de la lista lista_inicial.append(lista_inicial[len(lista_inicial)-2] + lista_inicial[len(lista_inicial)-1]) print(lista_inicial) #fibonacci con funcion y recursividad def next_value(penultimo, ultimo, limite): while len(lista_inicial) < limite: if len(lista_inicial) == 0: lista_inicial.append(penultimo) elif len(lista_inicial) == 1: lista_inicial.append(ultimo) else: nuevo_valor = penultimo + ultimo lista_inicial.append(nuevo_valor) next_value(ultimo, nuevo_valor, limite) lista_inicial = [] next_value(0, 1, 10) print(lista_inicial[:10]) ```

```python Mis soluciones #fibonaccion sin funcion con while recursivo lista_inicial = [0,1] while len(lista_inicial) < 20: #tamano maximo de la lista lista_inicial.append(lista_inicial[len(lista_inicial)-2] + lista_inicial[len(lista_inicial)-1]) print(lista_inicial) #fibonacci con funcion y recursividad def next_value(penultimo, ultimo, limite): while len(lista_inicial) < limite: if len(lista_inicial) == 0: lista_inicial.append(penultimo) elif len(lista_inicial) == 1: lista_inicial.append(ultimo) else: nuevo_valor = penultimo + ultimo lista_inicial.append(nuevo_valor) next_value(ultimo, nuevo_valor, limite) lista_inicial = [] next_value(0, 1, 10) print(lista_inicial[:10]) ```*#fibonaccion sin funcion con while recursivo*lista\_inicial = \[0,1]while len(lista\_inicial) < 20: *#tamano maximo de la lista*    lista\_inicial.append(lista\_inicial\[len(lista\_inicial)-2] + lista\_inicial\[len(lista\_inicial)-1])print(lista\_inicial) *#fibonacci con funcion y recursividad*def next\_value(penultimo, ultimo, limite):    while len(lista\_inicial) < limite:        if len(lista\_inicial) == 0:            lista\_inicial.append(penultimo)         elif len(lista\_inicial) == 1:            lista\_inicial.append(ultimo)         else:            nuevo\_valor = penultimo + ultimo            lista\_inicial.append(nuevo\_valor)            next\_value(ultimo, nuevo\_valor, limite) lista\_inicial = \[]next\_value(0, 1, 10)print(lista\_inicial\[:10])

\#Aporte Fibonacci optimizado sin funcion `#fibonacci x mi` `lista_inicial = [0,1]` `while len(lista_inicial) < 20: ``#tamano maximo de la lista+``    lista_inicial.append(lista_inicial[len(lista_inicial)-2] + lista_inicial[len(lista_inicial)-1])` `print(lista_inicial)` \#Fibonaccion con funcion que genera la serie al tamano deseado: `def next_value(penultimo, ultimo, limite):` `    while len(lista_inicial) < limite:` `        if len(lista_inicial) == 0:` `            lista_inicial.append(penultimo)` `         elif len(lista_inicial) == 1:` `            lista_inicial.append(ultimo)` `         else:` `            nuevo_valor = penultimo + ultimo` `            lista_inicial.append(nuevo_valor)` `            next_value(ultimo, nuevo_valor, limite)` `lista_inicial = []` `next_value(0, 1, 10)` `print(lista_inicial)`

Yo lo entendí de la siguiente manera: Cada llamada a la función que aún no obtiene un valor sino que se llama a sí misma se va almacenando en el stack en la memoria RAM en un status de "espera", hasta obtener un valor, y en la ultima iteración cuando al fin se obtiene un valor, en este caso 1, entonces asigna ese valor a la última función que se llamo y a medida que cada una va obteniendo un valor, esas llamadas de la función en el stack se van resolviendo hasta obtener un valor final.

```js def sumatoria(n): if n == 0: return 0 else: return n + sumatoria(n-1) sumatoria_5 = sumatoria(5) print(sumatoria_5) ```

```js def sumar_numeros_naturales(n): if n==1: return 1 else: return n + sumar_numeros_naturales(n-1) print(sumar_numeros_naturales(5)) ```def sumar\_numeros\_naturales(n):    if n==1:        return 1    else:        return n + sumar\_numeros\_naturales(n-1)    print(sumar\_numeros\_naturales(5))

def sumar\_numeros\_naturales(n): if n==1: return 1 else:         return n +sumar\_numeros\_naturales(n-1) print(sumar\_numeros\_naturales(5))

```python def sumatoria(n): if n==0: return 0 else: return n+sumatoria(n-1) number=int(input("Ingrese la cantidad de numeros que quiere sumar: ")) print(sumatoria(number)) print("--------------------------------------------") ```

La sumatoria de los primeros n números naturales se puede calcular utilizando la fórmula: Sumatoria=n(n+1)​ / 2 ```python # Sumatoria de números naturales def sumatoria(n): if n == 0: return 0 else: return n * (n + 1) / 2 numero = 10 print(sumatoria(numero)) ```

def natural\_numbers(n):     if n == 0:         return 0 if n > 0:         for i in range(n):             n += i        return n        print("Los primeros 4 números naturales son: ") print(natural\_numbers(4))

```python def summation(n): if n==0: return 0 else: return (n+ summation(n-1)) num = 50 print('The summation is: ', summation(num)) ```def summation(n): if n==0: return 0 else: return (n+ summation(n-1)) num = 50 print('The summation is: ', summation(num))

La recursividad en las funciones es lo mismo que la recursividad en las estructuras condicionales del if dentro de un if? Les comparto mi solución :D ```js #reto sumar los números anteriores de un número def sumaprevia(n): if n == 0: return 0 else: return n + sumaprevia(n - 1) print(sumaprevia(5)) ```#reto sumar los números anteriores de un númerodef sumaprevia(n):    if n == 0:        return 0    else:        return n + sumaprevia(n - 1)    print(sumaprevia(5))

```python def sumNumNatural(n): if n == 0: return 0 else: return n + sumNumNatural(n-1) sumaNaturales8 = print(sumNumNatural(8)) ```def sumNumNatural(n):    if n == 0:        return 0    else:        return n + sumNumNatural(n-1)    sumaNaturales8 = print(sumNumNatural(8))

Solucion interactiva del ejercicio 

Es muy curiosa la recursión de fibonacci en este caso, lo descompone en numero binarios practicamente. from chatGPT: ```js fibonacci(5) = fibonacci(4) + fibonacci(3) = (fibonacci(3) + fibonacci(2)) + (fibonacci(2) + fibonacci(1)) = ((fibonacci(2) + fibonacci(1)) + (fibonacci(1) + fibonacci(0))) + ((fibonacci(1) + fibonacci(0)) + 1) = (((fibonacci(1) + fibonacci(0)) + 1) + (1 + 0)) + ((1 + 0) + 1) = (((1 + 0) + 1) + (1 + 0)) + ((1 + 0) + 1) = (1 + 1 + 1) + (1 + 1) = 3 + 2 = 5 ```

En primera instancia no entendí donde estaba el bucle. pero lo que pasa es que la función se llama a si misma, y ahí es donde se genera el bucle. Por lo que pasa esto: * `return n \* <u>factorial(n-1)</u>` se itera sobre si mismo, restandole 1 a n. * La nueva iteracion, trabajando con n-1 como el nuevo `n` va a mutiplicar este por `factorial(n-1)` nuevamente, repitiendo el bucle hasta llegar a 0, donde no volvería a llamarse a si mismo.

```js #reto def sumatoria(n): if n == 0: return 0 else: return n + sumatoria(n - 1) # Probar la función con varios valores #for i in range(11): # print(f"Sumatoria de {i} es: {sumatoria(i)}") #Pedir el numero num = int(input('Ingresa el número: ')) #Calcular y mostrar el resultado for i in range(num + 1 ): resultado = sumatoria(i) print(f'La sumatoria para {i} es: {resultado}') ```