Qué es recursividad

Tarea del profe

¿Por qué escribir programas recursivos?

• Son mas cercanos a la descripción matemática.
• Generalmente mas fáciles de analizar
• Se adaptan mejor a las estructuras de datos recursivas.
• Los algoritmos recursivos ofrecen soluciones estructuradas, modulares y elegantemente simples.

Factible de utilizar recursividad

• Para simplificar el código.
• Cuando la estructura de datos es recursiva
  ejemplo : árboles.

No factible utilizar recursividad

• Cuando los métodos usen arreglos largos.
• Cuando el método cambia de manera impredecible de campos.
• Cuando las iteraciones sean la mejor opción.

Fuente: https://www.uv.mx/personal/ocastillo/files/2011/04/Recursividad.pdf

🐦 Si quieren divertirse con la recursividad en Twitter: https://twitter.com/freddier/status/1432713290942144519

La recursividad es muy bonita para desarrollar el pensamiento lógico y computacional. La primera vez que tuve mi acercamiento con la recursion me explotó la cabeza jajaj

.
Ya luego te das cuenta que casi todo lo que logras con recursion lo puedas hacer mucho mas rápido con ciclos y bastante mas liviano en temas de esfuerzo para el procesador.

[“✌”,“😂”,“😝”,“😁”,“😱”,“👉”,“🙌”,“🍻”,“🔥”,“🌈”,“☀”,“🎈”,“🌹”,“💄”,“🎀”,“⚽”,“🎾”,“🏁”,“😡”,“👿”,“🐻”,“🐶”,“🐬”,“🐟”,“🍀”,“👀”,“🚗”,“🍎”,“💝”,“💙”,“👌”,“❤”,“😍”,“😉”,“😓”,“😳”,“💪”,“💩”,“🍸”,“🔑”,“💖”,“🌟”,“🎉”,“🌺”,“🎶”,“👠”,“🏈”,“⚾”,“🏆”,“👽”,“💀”,“🐵”,“🐮”,“🐩”,“🐎”,“💣”,“👃”,“👂”,“🍓”,“💘”,“💜”,“👊”,“💋”,“😘”,“😜”,“😵”,“🙏”,“👋”,“🚽”,“💃”,“💎”,“🚀”,“🌙”,“🎁”,“⛄”,“🌊”,“⛵”,“🏀”,“🎱”,“💰”,“👶”,“👸”,“🐰”,“🐷”,“🐍”,“🐫”,“🔫”,“👄”,“🚲”,“🍉”,“💛”,“💚”]

Por si les interesa saber que patricio dejo de ser recursivo, minuto 6:25 sale el patricio que decidio no ser recursivo JAJAJA

Creo que la recursividad solo se deve usar en casos especificos, para lo demas prefiero usar iteraciones con ciclos de repeticon.

En una optativa de la carrera, vi programación funcional con haskell. En ese lenguaje los bucles no existen, por lo tanto, la única forma de hacer iteraciones era usando recursividad. Fue estresante, pero muy divertido.

Qué es recursividad

Es cuando una función se llama a sí misma. Tenemos que tener un caso base para que esta función se detenga.

Ejemplo básico con TypeScript:

function recursiva(){
  if(/*validacion*/){
    // llamados recursivos
  } esle {
    // llamados normales, sin recursividad
  }
}


function recursiva(numerito: number): number {
  console.log(numerito);
  if (numerito < 5) {
    return recursiva(numerito + 1);
  } else {
    return 5;
  }
}

recursiva(0);

function recursiva(numbersArray: number[] | string[]): void {
  if (numbersArray.length !== 0) {
    const firstNum = numbersArray[0];
    console.log(`first number: ${firstNum}`);
    numbersArray.shift(); //* elimina el primer elemento del array
    recursiva(numbersArray);
  }
}

recursiva([9,8,7,6,5,4,3,2,1]);
recursiva(['😎','🤩','😜','🤑']);

También comparto este artículo: ¿Cuándo usar recursividad

Lo malo de la recursividad es que es exponencial, vs un ciclo en tiempos pierde siempre, aunque es muy bonita su implementación.

Aquí un artículo que compara a profundidad los ciclos iterativos vs. los ciclos recursivos.

La recursion nos permite hacer un codigo más elegante, sacrificando la eficiencia (además de ofrecernos soluciones en casos muy particulares)

Ej:

function recursive(num) {
    console.log(num);
    num < 50 && recursive(num+1)
}

vs

function forLoop() {
    for(let i = 1; i <= 50; i++) {
        console.log(i)
    }
}

Las diferencias pueden no ser muy claras con un script tan básico, pero cobra sentido cuando el ciclo se vuelve más complejo. Podemos usarlo si sabemos que un ciclo no va a tener muchas iteraciones (por ej, una llamada a 10 productos)

Podés encontrar ejercicios de recursividad en leetcode y codewars

Me gusta la recursividad por que con 4 lineas de codigo puedo romper mi navegador.

5. ¿Qué es recursividad?

Recursividad es una técnica de programación que consiste en que una función se llama a sí misma y crea una nueva ejecución de nuestra función

let numero = 0;

while(numero < 10){
    console.log(numero);
    numero++;
}

en recursividad sería_

function recursiva(numero){
    console.log(numero);
    if(numero < 5){
return recursiva(numero + 1);
    }else {
        return 5;
    }
}

1. Imprime el número
2. Con un condicional se valida si el número es menor a 5, si es así se llama a la función recursiva, si no, se retorna el número 5.
3. Se llama a la función recursiva, y se le pasa el número + 1.

function recursiva(){
    if (/* validación */){
        //llamados recursivo
    }else {
        //llamados normales, sin recursividad
    }
}

un ejemplo en recursivo sería así:

function recursiva(numbersArray){
    if(numbersArray.length != 0){
        const firstNumber = numbersArray[0];
        console.log(firstNumber);
        numbersArray.shift();
        return recursiva(numbersArray);

    }
}

1. tenemos un condicional que valida si el array tiene algún elemento
2. si es así, se imprime el primer elemento del array
3. se llama a la función shift() para eliminar el primer elemento del array
4. se llama a la función recursiva, pero ahora con el array sin el primer elemento
5. Vamos llamando a la función recursiva con un array cada vez más pequeño hasta que ya no tenga ningún elemento.

Hasta ahora no me gusta porque no entiendo para que me puede funcionar…

En cierta parte me gusta la recursividad en el sentido de que te ayuda a desarrollar ese pensamiento lógico.

Pero por otro lado en algunos casos es difícil de entenderla o implementarla.

Pero siempre es bueno saber como usarla ya que en un futuro es muy probable que la necesitemos

Por lo que sea que te guste la recursividad, se ve muy elegante. Además ayuda a comprender la lógica de programación.

Un ejercicio de recursividad después de dos días de revisar el tema: 🤯

const contenNumbers = [0, 1, "Spiderman", 34, 4, 5, 777,"JuanDC", 6, 7, 8, "Batman", 435678, 900, 2, 3];
let eleWanted = "JuanDC";

const recurPosition = (arr, eleWanted, position) =>{

  if (arr[position] == eleWanted) {
    let element = arr[position];
    return console.log({position, element})
  } else {
   recurPosition(arr, eleWanted, position - 1);
  }

}
recurPosition(contenNumbers, eleWanted, contenNumbers.length - 1);

LA RECURSIVIDAD es bastante peculiar porque suele funcionar autoejecutando funciones con un ámbito menos al problema padre.
Un caso recursivo: Suele ser una función que es capaz de autoinvocarse. La clave de esta autoinvocación es que los elementos que le pasemos tendrán que ser menores que los del problema padre ya que si no nunca podríamos llegar al caso base.

• La recursividad es una técnica muy usada en programación funcional porque nos evita el uso de iteraciones.

Esto es lo que hice antes de ver el capitulo. :3

¿Escribir programas recursivos?
• Son más continuos a la representación matemática.
• son más fáciles de examinar
• Se acomodan mejor a las distribuciones de datos recursivas.
• Los algoritmos recursivos brindan recursos ordenadas.
• modulares y elegantemente simples.
¿Factible de utilizar recursividad?
• Simplifica el código.
• Estructura de datos es recursiva
¿No utilizar recursividad?
• Las técnicas usan arreglos largos.
• Método cambia de modo impredecible de campos.
• las iteraciones sean la mejor opción.

la verdad es que no entiendo la utilidad de la recursividad, mas parece como algo heredado de otro lado o que se utiliza en algunos casos mas específicos. La verdad tratare de darle utilidad por la parte que el código es relativamente mas corto. Sin embargo considero que es muy buen ejemplo pare reforzar los ciclos en JavaScript.

Me encanto la recursividad, lo veo mucho más elegante ye entendible que el ciclo for

Me parece bastante importanten entender esta tecnica de programacion, yo con anterioridad en un proyecto que tuve utilice este metodo, pero no sabia su nombre hastra ahora, se trataba de sacar 2 valores aleatoriaos con la siguiente condicion: no tendria que ser el mismo valor que se muestra, osea, en este caso un post y que no se repitiera. utlizando la ayuda de objetos literales y la recursivad pude resolver el problrme 😛

Lo hice asi,

`function recursive (numeros){
	if (numeros.length != 0) {
		// console.log(numeros.length)
		const x = numeros.shift()
		console.log(x)
		recursive(numeros)
	} else {
		console.log("finish")
	}
}
recursive(array)e> 

El código podría resumirse a:

function recursiva(arrayNumeros) {
  if( arrayNumeros.length != 0 ) {
    // const firstNum = arrayNumeros[0];
    // console.log(firstNum);
    console.log(arrayNumeros.shift());
    recursiva(arrayNumeros);
  }
}

Así pues, La recursividad es cuando una función se llama a sí misma, haciendo que esta se ejecute infinitamente a no ser que tenga un límite.
Así pues, La recursividad

const obj1 = {
    a: "a",
    b: "b",
    c: {
        d: "d",
        e: "e"
    },
    f: ["g", "h"],
    editA(){
        this.a = "AAA"
    }
};

function recursiva(obj1){
    const copiedObj = {}
    for(const prop in obj1){
        if(typeof prop == 'object'){
            recursiva(obj1[prop])
        } else{
            copiedObj[prop] = obj1[prop]
        }
    }
    return copiedObj
}

const obj2 = recursiva(obj1)
console.log(obj1)
console.log(obj2)

Les comparto mi versión de la recursión:

'use strict'

function cuentaRegresiva(num) {
  console.log(num);

  // Caso base
  if (num === 0) {
    return;
  }

  // Recursión
  cuentaRegresiva(num - 1);

}

cuentaRegresiva(10);

Es un poco distinto en como escribí la función recursiva, pero creo que se entiende, además de que me funcionó, solo un poco distinto en la validación que se define:

function serie(list) {
  let number = 0;
  if(number < list.length) {
    console.log(list[number])
    list.shift();
    return serie(list);
  }
}

Una razón por la que me gusta la recursividad es porque puedes usarla para problemas que requieran dividir un problema más grande en problemas pequeños y así sucesivamente.
.
Sin embargo esto puede traer como consecuencia que aumente el uso de memoria, trayendo un aumento en la complejidad espacial (tamaño de memoria utilizado para resolver el problema), ya que cada llamado a la función recursiva implica más uso de memoria.
.
Hay ocasiones donde es útil, como cuando se quiere buscar por un sistema de archivos por ejemplo. Sin embargo hay otras situaciones donde no lo es tanto, ahí siendo mejor implementar un algoritmo iterativo como ciclos.
.
Fuente

¿Qué es la recursividad?
Iterativo vs Recursivo

La recursividad en mi opinión es MUY BUENA para MEJORAR nuestra lógica; sin embargo, en el día a día va a ser más rápido y sencillo usar ciclos for, while, do while. Dejando la recursividad para momentos donde sea 100% necesaria

array de emojis con las comillas correctas

[
  "✌",
  "😂",
  "😝",
  "😁",
  "😱",
  "👉",
  "🙌",
  "🍻",
  "🔥",
  "🌈",
  "☀",
  "🎈",
  "🌹",
  "💄",
  "🎀",
  "⚽",
  "🎾",
  "🏁",
  "😡",
  "👿",
  "🐻",
  "🐶",
  "🐬",
  "🐟",
  "🍀",
  "👀",
  "🚗",
  "🍎",
  "💝",
  "💙",
  "👌",
  "❤",
  "😍",
  "😉",
  "😓",
  "😳",
  "💪",
  "💩",
  "🍸",
  "🔑",
  "💖",
  "🌟",
  "🎉",
  "🌺",
  "🎶",
  "👠",
  "🏈",
  "⚾",
  "🏆",
  "👽",
  "💀",
  "🐵",
  "🐮",
  "🐩",
  "🐎",
  "💣",
  "👃",
  "👂",
  "🍓",
  "💘",
  "💜",
  "👊",
  "💋",
  "😘",
  "😜",
  "😵",
  "🙏",
  "👋",
  "🚽",
  "💃",
  "💎",
  "🚀",
  "🌙",
  "🎁",
  "⛄",
  "🌊",
  "⛵",
  "🏀",
  "🎱",
  "💰",
  "👶",
  "👸",
  "🐰",
  "🐷",
  "🐍",
  "🐫",
  "🔫",
  "👄",
  "🚲",
  "🍉",
  "💛",
  "💚",
]

La recursividad como dice el profesor podria muchas veces ahorrarnos muchas lineas de codigo, pero a mi entender debemos de tener cuidado al utilizarla y tambien tener muy claro donde y cuando la vamos a utilizar porque podria costarnos un monton en la aplicacion! puede generar un bucle infinito si no estamos claro de como se usa esta tecnica

Recursividad es una forma en la podemos trabajar para estar llamando metodo a si mismo, en lo que he investigue no es muy usado en el mundo laboral ya que puede generar un desborde de la memoria que rompa el programa que estamos realizando, asi que si deberia usarlo debe ser muy bien analizado y garantizando que no afecte el programa.

Comparto un ejercicio que hice:

/**
 * Function itera sobre un número dado con una función recursiva
 * @param {number} limit - limite del ciclo, para la condicional
 * @param {function} cb - Un callback donde podemos poner la lógica basado en el limite del clico
 * nos returna, count (index) - position del ciclo
 */

function customLoop(limit, cb) {
  let count = 0

  /**
   * Función recursiva - itera con base en el limite - usando un count
   * @param {number} limit
   * @returns Misma funciónFunción recursiva
   */
  function sum(limit) {
    if (count < limit) {
      cb(count)

      count++
      return sum(limit)
    }
  }
  sum(limit)
}

const names = ['Daniel', 'Fernanda', 'Geraldine']

const namesCopy = []

//Pasamos un array a otro
customLoop(names.length - 1, (count) => {
  namesCopy.push(names.shift())
})

Recursividad:

No se trata de si me gusta o no, se trata de sus casos de aplicación, una funcion recursiva lo que hace es crear un nuevo Scope, en otras palabras crea un pequeño mundo nuevo, asi que si lo que creo que va a pasar en la siguiente clase es que vamos a usar recursividad para poder copiar un objeto con sus propiedades, atributos, acciones en un nuevo Scope, utilizando la recursividad…

me gusta la recursividad porq nos permite romper los ciclos cuando lo necesitemos

Acá dejo un ejemplo claro de función recursiva:

//Series Fibonacci
let num_1 = 1;
let num_2 = 2;
let num_i = num_1 + num_2;
const series_fibonacci = (num) =>{
    console.log(num_1, num_2, num_i);
        if(num_i < num){
            num_1 = num_2;
            num_2 = num_i;
            num_i = num_1 + num_2;
            return series_figonacci(num);
        }
    }

Porque se ve muy maquiavélico

Sabías que el método de los Arrays shift() permite guardar el elemento extraído en una variable simultaneamente

let primerNumero = numbersArray.shift();

me gustará la recursividad cuando la domine por completo jaja

Recursividad es un caso para analizar, muchas veces necesitamos un programa iterativo o recursivo, no son iguales pero son muy utiles que existan

No me gusta la recursividad porque es dificil de implementar, consumen el stack de la memoria y porque no hay que inventarse la rueda. Creo que recursividad es buen para casos puntuales, pero es mejor evitarla.

Al trabajar con recursividad nuestro código es mas fácil de leer y nos ahorramos bastas líneas de código que un ciclo for , es mucho mas intuitivo(declarativo)

Bueno no estoy muy seguro, pero creo que mejoraría la seguridad ya que esta iteración esta encerrada dentro de una función?

Recursividad: Cuando una función se llama así misma y crea una ejecución de la función misma, llamándose a sí misma varias veces.
Un disparador || Una validación es lo que nos permite finalizar una función recursiva: devolvemos un valor y terminamos.

  const numerito = ["1",2,"3",4,[5, 6], 7]
  const recursive = (num: any) => {
    if(num.length !== 0) {
      const firstNum = num[0];
      console.log(`firstNum`, firstNum)
      num.shift();
      recursive(num);
    }
  }
  recursive(numerito)

function recursive(array) {
  if (array.length !== 0) {
    const first = array.shift();
    console.log(first);
    return recursive(array);
  }
  console.log('Finish');
}

recursive(numbers);

Implemente la recursividad de otra forma la comparto por si alguien le parece útil.

function recursiva(array, index = 0) {
    if (index < array.length) {
        console.log(array[index])
        let index2 = index + 1;
        recursiva(array, index2)
    }
}

Hola! como estan?
Para practicar intente hacer una funcion recursiva que funcione como un bucle for!

let array = [1,23,41,52,42,5,656,6,98]
let numeroArray = 0;

let fun = (numerito) => {
    if( numerito < array.length ) {
    let valorArray = array[numerito];
    console.log(valorArray);
    return fun(numerito + 1)
    } else {
        console.log("fin");
    }  
}

let y = fun(numeroArray);

¿Qué es recursividad?📚

La recursividad es cuando una función se llama a sí misma y esta genera una nueva ejecución de la función. Esto sucede reiteradamente hasta que cumpla o no con cierta validación que nosotros declaremos para que deje de llamarse a sí misma en algún punto

Este es otro ejemplo que puede funcionar

function recursivo (EditArray){
    if (EditArray.length > 0){
        console.log(EditArray[0]);
        recursivo(EditArray.slice(1));
    }
}

espero les sirva

Apuntes de la clase
Qué es la recursividad
https://www.notion.so/mriatorres/Recursividad-08488dfb1b994de4aef4e7a6cca7c4e7

function recursiva() {
    if(/* validación */) {
        // llamados recursivos
   } else {
        // llamados normales, sin recursividad
   }
}

function recursiva() { if(/* validación */) { // llamados recursivos } else { // llamados normales, sin recursividad } }

Una aplicación de la recursividad es la copia de objetos con métodos

Mi resumen:

/*------------------Recursividad------------------*/

//Es cuando una función se llama a sí misma y crea una nueva ejecución de esa función.
//Estas ejecuciones pueden ser sucesivas hasta llegar a un punto donde se obtenga un valor en espcífico.
//A partir de ahí se ira resolviendo cada una de las ejecuciones hechas

//Donde haya un ciclo iterativo (while, for, etc), se puede aplicar recursividad en vez de ese ciclo y la elección dependerá del contexto.

//### PROBLEMA: Deseamos imprimir una serie de números desde el 0 hasta n números. En este caso hasta el 4

let numerito = 0;

//Solución con ciclos iterativos

while(numerito < 5) {
	console.log(numerito);
	numerito++;
}

// Solución con función recursiva

function recursiva(numerito) { // Recibe un número
	console.log(numerito); // Imprimimos en consola el número
	if (numerito < 5) { // Evalua si es menor a 5
		// Llamamos nuevamente a nuestra función enviandole el número siguiente:
		return recursiva(numerito + 1);
	} else { // La función deja de llamarse a sí misma:
		return 5;
	}
}

recursiva(numerito);

/*
Output:
0
1
2
3
4
5 //este es por el return al parar las ejecuciones secuenciales
*/

// ### ¿Cuándo SÍ es factible de utilizar recursividad?

/*
    -Para simplificar el código.
    -Cuando la estructura de datos es recursiva. Ejemplo: árboles.
*/

// ### ¿Cuándo NO es factible utilizar recursividad?

/*
    -Cuando los métodos usen arreglos largos.
    -Cuando el método cambia de manera impredecible de campos.
    -Cuando las iteraciones sean la mejor opción
*/

no se si a otros les pasa o solo yo, pero ojo con confundir “length” con"lenght", visual studio no lo marca como error pero en este caso tipiandolo asi te da una recursividad infinita y nunca termina 😄

RECORDATORIO: porque presiento que habemos una clasificación de personas que repetiremos este error por siempre esto por siempre.

Se escribe length… jajaja 😅

el tema de la recursividad es tener ese farol cuando se cumpla y en este momento romper la recursividad pero que tan rapida es sobre otras maneras como for.

function numerito(numero, mayor){
  console.log(`numero actual : ${numero} = ${mayor}`);

  if(numero < mayor){
    numero++;
    numerito(numero,mayor);
  }else{
    console.log(`finalizacion del contador ${numero}`)
  }
}
numerito(1,10)

la recursividad es algo que se deberia enseñar al comienzo de los cursos de programación ya que entiendes mas el porque se hace un ciclo y como no fallar en el intento explotanto el motor V8 o congelando tu computadora corriendo el codigo desde vscode JAJAJ.

Yo creo que una función recursiva o Loops son muy importantes solo que uno tiene menos códigos que el otro pero ambos son importantes.
Pero en que momento deberíamos usar la recursividad?

No lo sé, creo que hace falta un caso de la vida real para que quede más claro, así que de una voy a la próxima clase. 😃

Pues teniendo en cuenta “problema de copiar un objeto” aun no tenemos el metodo ultimateExtraYaNoMasPlussUltraForCopyObjects .
creo que vamos a terminar usando la recursividad para ir evaluando cada propiedad del objeto y copiarla segun convenga.
tantas veces como props tenga el objetoOrigina.

Ya estaba a punto de decir:
¿Y esto qué tiene que ver con POO?

Pregunten a los Devs senior cuantas veces usan recursividad en su trabajo.

En mi opinión personal se me hace mas fácil trabajar con recursividad que con ciclos, aunque he estado leyendo que la recursividad no es tan buena ya que ocupa mucho espacio en memoria y eso hace que sea poco escalable.

ok