Hola foro :D
Aquí dos ejercicios.
1ro. Realizar un programa en Java que de forma recursiva verifique si un número es positivo. El método debe ser booleano, osea devolver true o false, dependiendo del número introducido.
2do. Realizar un programa en Java que de forma recursiva sume 2 números naturales.
Sencillo cierto?
Espero sus respuestas.
Un saludo
No me parecen tareas recursivas.
public boolean esPositivo(int numero)
{
return numero >=0;
}
Cita de: carlitos.dll en 3 Septiembre 2008, 00:06 AM
No me parecen tareas recursivas.
public boolean esPositivo(int numero)
{
return numero >=0;
}
Lamento decirte que tu ejercicio esta mal.
Cualquiera, uno de 1ro puede hacer lo que hiciste, no te ofendas pero
yo lo pedí de forma recursiva.Mira, cuando me plantearon el ejercicio creí lo mismo que tú.
CitarOsea para que lo hago de forma recursiva si es muy simple sacarlo.
Pero te pido que intentes hacerlo de forma recursiva, haber si es tan sencillo.
Ahora, lo de sumar dos números, de la misma forma, se puede hacer muy simple sin recursividad, pero yo lo estoy pidiendo
recursivo, porque te hace analizar un poco mas el ejercicio, no digo que sea difícil, pero al menos el procedimiento cambia, con solo decirte que para sumar dos números, debes utilizar la resta.
Espero lo resuelvan de forma
recursiva.
Un saludo
¿Con un if de pormedio?
Cita de: ArcheritONE en 3 Septiembre 2008, 23:38 PM
¿Con un if de pormedio?
Si, el if es la condicionante que determina el axioma.
Mira, voy a resolver la suma de dos números de forma recursiva.
static int sumar(int a, int b)
{
if(b==0) return a;
else
return sumar(a, b-1) + 1;
}
Explicando un poco
if(b==0) return a;
Osea si uno de los dos números, en mi caso el que este en la variable "b" es cero entonces no tiene caso sumar nada, asi que retornamos el número de la otra variable, ejemplo:
a = 5; b = 0;
sumar = a;
else
return sumar(a, b-1) + 1;
ahora, por falso, lo que hacemos es reducimos el segundo parámetro que esta en nuestra variable "b" la cantidad de veces que se pueda hasta que llegue a cero.
Y una ves que llegue a cero que hacemos?
Pues, necesitamos un contador que nos diga cuantas veces se ha reducido el número y eso nos dará como resultado el número introducido.
Entonces en lo que haya sumado el contador le aumentamos a; que esta fijado en el axioma, lo cual nos devuelve a + b, pero de forma recursiva.
Nose si está claro, a veces no soy bueno explicando.
Un saludo
No me ofendo, pero en el primer ejercicio, donde esta la recursividad?
Y en tu segundo código, si quieres sumar 3 + -2, queda recursando infinitamente, y se cae por StackOverflowError.
Wikipedia dice, que la recursividad debe utilizarse en procesos recursivos, como la factorización.
Cita de: carlitos.dll en 4 Septiembre 2008, 03:09 AM
No me ofendo, pero en el primer ejercicio, donde esta la recursividad?
Pues, cuando encuentres la recursividad habrás resuelto el ejercicio.
Citar
Y en tu segundo código, si quieres sumar 3 + -2, queda recursando infinitamente, y se cae por StackOverflowError.
no estoy sumando 3 + -2, analiza nuevamente el código y te darás cuenta que no sumo la 2da variable.
return sumar(a, b-1) + 1;
Lo que en verdad sumo es a + el contador
Citarreturn sumar(a, b-1) + 1;
, ese
+1 esta incrementando cada ves que el número dentro la variable b se va reduciendo.
Ahora claro está de que si no existiera el axioma
if(b==0) return a;
nada tendría sentido.
Pero ese
if, es el encargado de para el proceso y lanzar un resultado.
Mira, cuando a mi me dijeron que lo haga, yo lo creí loco a mi docente, porque pensaba lo mismo que tu, pero a tanta insistencia me hizo pensar un poco y alcancé el resultado.Un saludo
1ro. Realizar un programa en Java que de forma recursiva verifique si un número es positivo. El método debe ser booleano, osea devolver true o false, dependiendo del número introducido:
public boolean tipo(int num)
{
if(num==0)
return tipo(num);
else
{
if(num>0) return true;
else
return false;
}
}
2do. Realizar un programa en Java que de forma recursiva sume 2 números naturales.
static int sumar(int a, int b)
{
if(b==0) return a;
else
{
if(b>0) return sumar(a, b-1) + 1;
else
sumar(a, b+1) - 1;
}
}
Creo que es asi.
;D ;D ;D ;D
ohk, me refería a que tu code, si le pasas parámetros al método, como por ejemplo:
System.out.println(sumar(3, -2));
Se queda infinitamente recursando.
El code que postió hadess_inf, funciona.
public static int sumar(int a, int b)
{
if(b==0) return a;
else
{
if(b>0) return sumar(a, b-1) + 1;
else
sumar(a, b+1) - 1;
}
}
Pero a este si se le pasa 0, queda en un ciclo infinito.
public boolean tipo(int num)
{
if(num==0)
return tipo(num);
else
{
if(num>0) return true;
else
return false;
}
}
Me rectifico, en el sentido de que si se podía sumar dos números recursivamente, pero en cuanto a verificar el tipo, pienso que no es recursivo.
Le encuentran un pero a todo no?
Bueno si, en caso de que quieran meter un número negativo para "b" pues si.
Pero:
Citar
2do. Realizar un programa en Java que de forma recursiva sume 2 números naturales.
es.wikipedia.org/wiki/Número natural (http://es.wikipedia.org/wiki/N%C3%BAmero%20natural)
Bueno, igual el ejercicio esta bien resuelto.
Lo de verificar si un número es positivo lo posteo luego, ya tengo sueño :P
Un saludo
Ahora si.
public static boolean tipo(int num)
{
if (num == 0)
{
return true;
} else
{
if (num < 0){
return tipo(num +- num) && false;
}else {
return tipo(num - num) || true;
}
}
}
Cita de: carlitos.dll en 4 Septiembre 2008, 05:11 AM
public static boolean tipo(int num)
{
if (num == 0)
{
return true;
}
else {
if (num < 0){
return tipo(num + 1) && false;
}
else {
return tipo(num - 1);
}
}
}
CongratulationsWell done, Carlitos.dll :D
have a nice day ::)
Lo modifiqué justo, para que sea más efectivo.
Parece código ofuscado. :D
Ojalá coloques más ejercicios.
Cita de: carlitos.dll en 4 Septiembre 2008, 05:18 AM
Lo modifiqué justo, para que sea más efectivo.
Parece código ofuscado. :D
Ojalá coloques más ejercicios.
:D
viste que si había una solución :P
Bien hecho, solo tenías que ser mas perseverante. ;)
Ahora, a pedido tuyo voy a seguir posteando ejercicios mañana.
Un saludo
OHK
Hola :D
Como lo prometido es deuda, aquí les traigo resuelto el ejercicio de verificar si un número es positivo.
Ya sé que lo resolvieron pero lo tengo resuelto de otra forma, un poco mas "compleja".
Espero les sirva y le entiendan.
public boolean positivo(int n){
if(n>0) return true;
else return negativo(n);
}
public boolean negativo(int n){
if(n<0) return false;
else return positivo(n);
}
Bueno que al final es lo mismo, pero utiliza recursividad cruzada o indirecta.
Recursividad cruzada o indirecta
Son algoritmos donde una función provoca una llamada a sí misma de forma indirecta, a través de otras funciones.
Un saludo
OHK
Está bueno, pero, y no es que diga pero por decir, si lo analizas, si se ingresa un 0, quedará "rebotando" todo el rato.
Cita de: carlitos.dll en 4 Septiembre 2008, 16:17 PM
Está bueno, pero, y no es que diga pero por decir, si lo analizas, si se ingresa un 0, quedará "rebotando" todo el rato.
Pues, si
pero en mi caso no estoy tomando en cuenta el montón de posibilidades que existen de que un usuario introduzca cualquier valor, pero bueno...
Estos ejercicios están para ayudarnos a crear lógica.
He preparado un par de ejercicios mas de este tipo, los posteo mas tarde.
Un saludo
OHK
Hola :D
Bueno aquí les dejo otro ejercicio, que tampoco esta muy difícil.
Utilizando Java y Recusrividad, hacer un método que calcule el Máximo Común Divisor de 2 Números Naturales.
Espero sus respuestas.
Un saludo
OHK
Cita de: ohk en 4 Septiembre 2008, 20:01 PM
Hola :D
Bueno aquí les dejo otro ejercicio, que tampoco esta muy difícil.
Utilizando Java y Recusrividad, hacer un método que calcule el Máximo Común Divisor de 2 Números Naturales.
Espero sus respuestas.
Un saludo
OHK
¿Vale el algoritmo de Euclides?
public static uint MCD(uint a, uint b)
{
return (b != 0) ? MCD(b, a % b) : a ;
}
Esta en c# pero es prácticamente igual que Java.
:¬¬
Citarprácticamente
:¬¬
static int sacar_mcd(int a, int b)
{
if(b==0)
return a;
else
return sacar_mcd(b, a % b);
}
Alguien me puede decir si mi algoritmo es igual al de ArcheritONE :huh:
:¬¬ :¬¬
Que malo es saber solo Php, Java y un poco de Delphi :P
Citarese es el operador ternario.
Código:
return (b != 0) ? MCD(b, a % b) : a ;
Eso es lo mismo que
Código:
if (b != 0) {return MCD(b, a % b);}
else {return a;}
ah muy bien, gracias :D
Resuelto por:
Un saludo
OHK
ese es el operador ternario.
return (b != 0) ? MCD(b, a % b) : a ;
Eso es lo mismo que
if (b != 0) {return MCD(b, a % b);}
else {return a;}