Curso Java Intermedio #37 | Recursividad - Ejercicio práctico (Factorial de un número) 

¿Te gustaría que este contenido siga siendo gratuito?, puedes apoyar al canal de las siguientes maneras: 1. Donaciones: www.paypal.me/LaGeekipedia 2. Desactivando Adblock y Adblock Plus en RU-vid. 3. Compartiendo los vídeos del canal en foros y redes sociales. Cualquier opción es de gran ayuda. ¡Muchas gracias!

Volvió Ernesto!!! Fabuloso, que el profe del 33 al 35 no vuelva mas. Y que quede Ernesto para siempre!!!!! Gracias. Por todo.

Lo pude programar sin ver tu solución!!!, he aprendido mucho contigo Ernesto, Muahcas gracias

No se explico como tal el como se llego al resultado, pero que mas puedo pedir, eso ya nos queda investigarlo a nosotros. gracias! para quien todavía tiene dudas, la recursividad con el return digamos que empieza a llenar una pila desde desde el final es por eso que se pone el 1 en el ultimo return (el cual nos sirve como ancla), el proceso que hace el codigo con el factorial de 4 seria algo como: 1*1 =1 2*1 =2 3*2 =6 4*6 =24 Aquí es donde entra el termino "Pila" donde lo primero que entra sera lo ultimo que sale, lo que nos lleva en pocas palabras a un proceso inverso donde se crea un ciclo imaginario controlado por nosotros. Para quien tiene duda de en que se diferencia o por que es mejor utilizar la recursividad en vez de un ciclo normal, la respuesta es por que nos da mejor eficiencia en complejidad espacio-tiempo haciendo mas rápido el programa y ahorrándonos lineas de código.

Holaa Ernesto muchas gracias muy clara la explicación saludos desde Guanajuato México, también que tocas temas de objetos adelante

Hola Ernesto! Excelente Curso!! Muchas gracias por compartir tanto conocimiento!! Hice una variación en el método Factorial() package clases; class Recursividad { public int Factorial(int parametro) { if (parametro == 0) { return 1; } else{ return parametro * Factorial(parametro - 1); } } }

Soy nuevo en tu canal y me dejaste una buena enseñanza :D. Gracias :D

Muy bien Ernesto! , yo aparte le agregue interfaz y quedo excelente :)

Excelente explicación, muchísimas gracias

muchas gracias , excelente explicación....

Estoy mirando el video en la parte que explicas que es el factorial. Obvio, no se como termina el video, Pero ya estoy pensando que el factorial de 0 es uno y como programar eso.

"gracias Ernesto"

Hola, compañeros. Yo creé un código totalmente distinto para el cálculo del factorial que funciona, aunque reconozco que el utilizado en el vídeo por Ernesto es más correcto y sencillo. Aquí os lo dejo: public class Recursividad { int factorial; public Recursividad() { factorial = 1; } public int Factorial(int numero) { int numero2 = numero - 1; if (numero > 1) { factorial = factorial * numero * numero2; numero = numero - 2; Factorial(numero); } return factorial; } }

Lo resolví muy diferente y viendo cuando Ernesto propuso return 1; pensé que si por error ingreso un 0 me va a dar como respuesta 1... pero claro, si pongo return 0; cuando ingrese 1! (1factorial) entonces me dará como resultado 0... Lo bueno es que con todas las herramientas que nos enseñó a lo largo de los cursos, y si uno se quiere a poner a solucionar este error claro que se puede... podríamos usar un condicional para que si por error o a propósito alguien ingresa 0 entonces que la clase main no llame al método y simplemente muestre un sout que diga que debe ingresar un numero mayor a cero.... igual, a mi no se me ocurrió como a Ernesto la recursividad y lo solucioné de esta manera: package clases; public class ClaseRecursividad_Ejercicio extends ClaseMain { int longitudfactorial = 1, resultado = 1; public void ClaseRecursividad_Ejercicio(int n) { if (n >= 2) { // uso que el n que viene por parámetro tiene que ser >=2 porque si viene 1 se multiplicaría por 0 y daría error en el calculo if (longitudfactorial < n) { resultado = resultado * (longitudfactorial + 1); longitudfactorial++; // use esta variable como un contador de cada vez que el método recurría a ejecutarse ClaseRecursividad_Ejercicio(n); } } } public void Imprimir(int n) { // acá en el método imprimir le doy solución para los número que no quiero usar el método recursivo if (n = 2) { System.out.println(n + " factorial = " + resultado); // se muestra resultado para todos los números que ingresaron al método } } me parece que en Imprimir() podría estar de más n>=2 y usar solo un else if (n>=1) pero eso lo pienso ahora que lo publiqué antes no me di cuenta Xd

Aún estoy por la clase número 14 de java desde cero pero pasaré por aquí cuando termine todo :D

Hola profesor Ernesto, Muy buenos sus cursos. Aquí en este video tengo una sugerencia, sería más apropiado usar el tipo de variable "long" en lugar de un "int" porque si el usuario ingresa el número 15 por ejemplo, el programa dará un resultado incorrecto ya que el resultado del factorial de 15 no encajar dentro de un tipo Int. Está más allá de la capacidad de almacenamiento del Int. Gracias, sigue adelante.

Muchas gracias Hernesto... Con un poco de practica pude entender perfectamente la recursividad. Pero me costo. xD

Subscrito, Amigo excelentes videos, mil gracias

Impecable crack.

Buen video Ernesto Quería saber si estas pensando en curso con redes neuronales o si lo planeas hacer junto a este curso java

Wow, yo apenas voy en el 6 y heme aquí para el like.. xD

Hola a todos: Yo decidí modificar un poco el código del profesor Ernesto, lo dejo abajo por si alguien puede interesarle. Un saludo. //Metodo para calcular el factorial package clases; public class Recursividad { int resultado = 1; public int Factorial(int parametro){ if(parametro > 0){ resultado = parametro * resultado; Factorial(parametro - 1); } return resultado; } } //La clase principal package clases; import java.util.Scanner; public class Clase_Principal { public static void main(String[] args){ Scanner entrada = new Scanner(System.in); System.out.print("Introduce el numero para calcular su factorial; "); int numero = entrada.nextInt(); Recursividad recursividad = new Recursividad(); int factorial = recursividad.Factorial(numero); System.out.println("El factorial de " + numero + " es " + factorial); } }

una duda, espero que responda.... entonces al final del dia si yo pongo que me de el factorial de 4 seria... 4*3=12 y se regresa ese valor luego 3*2=6 y se regresa ese valor luego 2*1=2 y se regresa ese valor hasta llegar a 1 pero mi duda es que le pasa a los valores de 12, 6 y 2. porq como no se almacenan esos valores no entiendo como llega al resultado

Buen Video como siempre GRACIAS sigue adelante y FUERZA SALUDOS DESDE ECUADOR

No entiendo la funcion especifica del return 1 en el minuto 8:34, si alguien la entendio se agradece la ayuda.

Buenísimo

Muchas gracias Ernesto. Yo por mi parte traté de resolver el ejercicio antes de ver el video y lo hice de esta forma: public class Recursividad { public int ValorCalculado = 1; public int Factorial(int x) { if (x >= 1) { ValorCalculado = ValorCalculado * x; Factorial(x - 1); } return ValorCalculado; } } ******************************************************************************************** public class ClasePrincipal { public static void main(String[] args) { Scanner entrada = new Scanner(System.in); System.out.print("Ingresa el valor para la operación: "); int valor = entrada.nextInt(); Recursividad mensajero = new Recursividad(); mensajero.Factorial(valor); System.out.println("El resultado de la operación es: " + mensajero.ValorCalculado); } } ******************************************************************************************** Quería pedirles amigos por favor si alguien me puede ayudar indicándome si existe alguna mala práctica que debería corregir en el código q escribí. O algo para mejorar.

Disculpa Me aparece un error en la clase principal en "recursividad.Factorial(numero)"

yo lo hize con un for

Lo resolvi asi el num lo declare en otra clase como num = x -1 public class Recursividad { public void NumFactorial(int x, int num) { if(num > 0) { x = x * num; NumFactorial(x, num -1); }else { System.out.println("El numero factorial es: " + x + "!"); } } }

Porque daría un resultado no deseado poner un valor diferente a 1 en el return? Porqué es tan importante ese 1? Es lo único que no termino de entender. Gracias por tus videos.

Oye amigo.. Y si quiera que fuera mediante rangos... Ejemolo factorial de 3 a 5 = 60, como calculas los rangos?

voy a intentar hacerlo yo solo

yo lo hice de esta manera para quien le interese: public class Recursividad { int resultado = 1; String lista = ""; public void Imprimir(int n) { if (n > 1) { resultado = resultado*n; lista += Integer.toString(n) + "*"; Imprimir(n - 1); } if (n == 1) { lista += Integer.toString(n); } } } public class ClasePrincipal { public static void main(String[] args) { Scanner in = new Scanner(System.in); int n = 0; Recursividad mensajero = new Recursividad(); System.out.println("ingresa el numero el cual desees encontrar su factorial"); n = in.nextInt(); mensajero.Imprimir(n); System.out.println(n +"!" + " = " + mensajero.lista + " = " + mensajero.resultado); } }

buen vídeo pero como se haría incrementando

No entiendo en que parte decrece el parametro para que llegue a cero y termine la recursividad, si alguien lo entendio y tiene ganas de explicarme un poco esa estructura es bienvenido.

soy el único que al poner numero grandes comienzan a aparecerle con negativo o directamente salen mal, cuando pongo el factorial de 34 me pone 0, ¿que hice mal si copie todo el programa?

hola, buen video! Solo una duda. La recursividad ocupa mas memoria que un for?

public class Recursividad { int factorial = 1; public int Factorial(int n){ if(n > 1){ factorial = factorial * n; Factorial(n - 1); } return factorial; } }

Demasiado sencillo fue usar recursividad para el factorial :D

public class NewClass { int count = 2; int factor = 1; public void Bucle(int value1){ factor *= count; if(count == value1){ System.out.println(factor); System.exit(0); }else{ count++; Bucle(value1); } } public static void main(String[] args) { Scanner value = new Scanner(System.in); int value1 = value.nextInt(); NewClass recur = new NewClass(); recur.Bucle(value1); } }

no entendi :(

el 90% de mi tecnico profesional son mi profe copiando tus clases xd un saludo

:3 like

por que dices que el 4 solo se multiplica por 3? si para ser factorial debe de ser 4*3*2*1, o quisiste decir que en el del 3 se multiplica por el del 2 en donde se multiplica por el 1? .Ya no entendi :,v

che jair, lo saco de aqui xd