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.

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

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

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

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

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

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.

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.

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

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

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

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.

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

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

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

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.

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 😄

ok