[JAVA] Ejercicio: Random
Enviado el miércoles, 14 de mayo de 2008 a las en 22:46Les dejo el ejercicio terminando que hicimos en clases este martes 13.
Clase plano
class Random{
private int numero;
Random(){
/* En este caso el constructor no necesita resivir ningun
* tipo de parametro, ya que al llamar al constructor, este
* generara un numero al azar con la clase Math.random()
*
* Para lograr crear numeros al azar entre un rango de digitos
* se usa la siguiente formula:
*
* Math.random()*(numero_mayor+1-numero_menor0)+numero_menor)
*
* Usando esa formula, se crean numeros en el rango 100-999999999
* Hay que tener en cuenta que Math.random devuelve un tipo de dato
* 'double', por lo cual necesitamos transformar ese numero a 'int'
* con (int)(), como se muestra mas abajo.
*/
numero=(int)(Math.random()*(999999999+1-100)+100);
}
void setNumero(int numero){
this.numero=numero;
}
int getNumero(){
return numero;
}
int cuentaDigitos(){
int i=0, copia=numero;
/* Para lograr contar la cantidad de digitos que tiene un numero
* se necesita saber cuantas veces el numero puede ser divido por 10
* mientras el resultado sea mayor que 0. Por cada vez que el numero es
* divido por 10, se suma +1 a un contador(i) el cual contiene la cantidad
* de divisines realizadas o mejor dicho la cantidad de digitos.
*/
while(copia>0){
copia=copia/10; // Se realiza la division por 10
i++; // +1 al contador de digitos
}
return i;
}
int sumaDigitos(){
int i=0, copia=numero, digito=0, suma=0;
/* Para este metodos no nos basta saber cuantas veces podemos dividir por 10
* un numero para saber la cantidad de digitos. Si no que necesitamos saber
* que digitos tiene X numero para luego sumarlos uno por uno.
*
* Lo que se hace en este caso es el uso del modulo(%) para poder obtener
* el ultimo digito de un numero. En este caso aplicamos el %10 a X numero
* obteniendo como resultado su ultimo digito. Ejemplo: 15%10 -> 5.
*
* Ya sabiendo como obtener el ultimo digito de un numero (con %10) y sabiendo
* como recorrer el numero para ir avanzando entre numero (con /10) podemos
* ir sumando digito a digito.
*
* Les hago una traza para que quede mas claro con el numero 123:
* | Copia | Digito | Suma |
* --------------------------
* | 123 | 0 | 0 | <- Valores de inicio
* | 12 | 3 | 3 | <- Valores finales primera vuelta
* | 1 | 2 | 5 | <- Valores finles segunda vuelta
* | 0 | 1 | 6 | <- El while se corta y como resultado da 6 (suma)
* --------------------------
*/
while(copia>0){
digito=copia%10; // Modulo 10 del numero, devolviendo el ultimo digito
suma=suma+digito; // Se suma el digito con los demas
copia=copia/10; // Dividimos el numero para avanzar al siguiente digito
}
return suma;
}
int digitoMayor(){
int mayor=0, digito, i=0, copia=numero;
/* Utilizamos el mismo proceso que el metodo anterior, pero agregamos una
* pregunta (if). Si el digito es mayor al digito que tenemos guardado
* este se almacena. De lo contrario sigue con su camino recorriendo el resto
* del numero y sus digitos.
*
* De este modo vamos revisando todos los digitos y comparando uno por uno
* para lograr indentificar el mayor usando un 'if'.
*/
while(copia>0){
digito=copia%10; // Almacenamos el ultimo digito
if(digito>mayor){ // Si nuestro 'digito' es mayor que 'mayor'
mayor=digito; // a 'mayor' se le asigna 'digito'
}
copia=copia/10; // Dividimos para avanzar al siguiente digito
i++;
}
return mayor;
}
int numeroInvertido(){
int invertido=0, digito, i=0, copia=numero;
/* Para poder invertir un numero, obviante primero necesitamos sacar digito
* por digito y colocarlos en la forma correspondiente. Como saben (supongo)
* estos algoritmos trabajan con el numero recorriendolo de derecha a izquierda
* por lo cual cuando saquemos el primer digito, este debe ser el primero de
* nuestro nuevo numero invertido. Entonces el procedimiento es simple sabiendo
* como ir agregando los digitos al nuevo numero invertido.
*
* Esto se hace de la siguiente manera:
* invertido=invertido*10+digito
*
* 'digito' es el digito que queremos agregar a nuestro nuevo numero invertido.
* Por lo tanto si queremos invertir el numero 123, seria algo asi: en primer
* lugar tenemos que el ultimo digito es 3, por lo tanto -> 0*10+3 -> 3
* En este caso invertido es 0 por que aun no le asignamos valor. 3 quedara
* como nuevo valor de 'invertido'. El siguiente digito es 2, por lo tanto
* 3*10+2 -> 32. Nuestro ultimo es digito es 1, por lo tanto -> 32*10+1 -> 321
* Ahi ya tenemos invertido el numero.
*
* Les hare una traza del programa con el numero 123:
* | Copia | Digito | Invertido |
* -------------------------------
* | 123 | 0 | 0 | <- Valores de inicio
* | 12 | 3 | 3 | <- Valores finales primera vuelta
* | 1 | 2 | 32 | <- Valores finles segunda vuelta
* | 0 | 1 | 321 | <- El while se corta y como resultado da 321
* -------------------------------
*/
while(copia>0){
digito=copia%10; // Almacenamos el ultimo digito
invertido=invertido*10+digito; // Agregamos el digito a nuestro numero invertido
copia=copia/10; // Dividimos para avanzar al siguiente digito
i++;
}
return invertido;
}
int cambia(){
int i=0, digito=0, copia=numero, cambiado=0, cambiado_invertido=0;
/* En este caso necesitamos cambiar los digitos pares por 2 y los impares por 1.
* Puede sonar un poco mas complicado pero no lo es tanto. Es cosa de saber
* mezclar nuestros otros algoritmos para realizar la tarea.
*
* Lo primero es como siempre recorrer el numero entero e ir sacando digito por
* digito. Partimos sacando el ultimo digito del numero y preguntando si el numero
* es par o impar (lo vimos en clases pasadas). En el caso de que fuese par se hace
* lo siguiente:
*
* cambiado=cambiado*10+2
*
* Es la misma base de cuando invertimos un numero para ir agregando digitos. Pero
* en este casao en vez de agregar X digito, agregamos un 2. En el caso de que
* fuese impar, en vez de agregar un 2, agregamos un 1.
*
* Por ultimo lugar, como ya sabemos que lee los digitos de derecha a izquierda
* el resultado final quedaria al reves de lo que deseamos, por lo tanto tenemos
* que invertir el numero.
*/
while(copia>0){
digito=copia%10; // Accedemos al ultimo digito
if(digito%2 == 0){ // Par
cambiado=cambiado*10+2; // Agregamos digito 2 al numero
} else { // Impar
cambiado=cambiado*10+1; // Agregamos el digito 1 al numero
}
copia=copia/10;
while(cambiado>0){ // Invertimos el resultado
digito=cambiado%10; // Almacenamos el ultimo digito
cambiado_invertido=cambiado_invertido*10+digito; // Agregamos el digito a nuestro numero invertido
cambiado=cambiado/10; // Dividimos para avanzar al siguiente digito
i++;
}
}
return cambiado_invertido;
}
int mayorDos(){
int i=0, copia=numero, digitos=0, mayor=0, invertido=0;
/* En este caso necesitamos dividir el numero en pares y obtner el par mayor de
* numeros. Osea, si tenemos 1234, se separa en 2 pares: 12 y 34, obteniendo 34
* como el par mayor.
*
* Para trabajar con un par de numeros debemos cambiar el modulo y la division
* de este por 100 en vez de por 10. De este modo trabajamos siempre obteniendo
* las 2 ultimas cifras de un numero. Si fuese 1000 serian las 3 ultimas y asi.
*
* El proceso es el mismo que digitoMayor(), pero trabajando con 2 digitos.
*
* OJO!: Este proceso funciona solo para una cantidad de digitos pares. Osea
* si tenemos un 1234 funcionara, pero si tenemos 54124 no funcionara. Nosotros
* sabemos que en ese numero el par de digitos mayor es 54, pero como el
* algoritmo trabaja de derecha a izquierda lo haria en el siguiente orden
* 24 -> 41 -> 05. Como resultado mayor obtenemos el 41, y no el 51. Esto se debe
* simplemente por que trabaja de derecha a izquierda, y no de izquierda a derecha
* como deseamos. ¿Es posible hacerlo en el orden correcto?... Si, segun yo si.
* Pero estoy cansado T_T!
*/
while(copia>0){
digitos=copia%100; // Obtenemos el ultimo par de digitos del numero
if(digitos>mayor){ // Si es mayor que nuestro 'mayor' se almacena
mayor=digitos;
}
copia=copia/100; // Dividimos por 100 y avanzamos 2 digitos
i++;
}
return mayor;
}
}
App
class AppRandom{
public static void main(String[]arg){
int numero, op=0;
while(op != 2){
System.out.println("[1] Crear numero");
System.out.println("[2] Salir");
op=Leer.datoInt();
switch(op){
case 1:
Random uno = new Random();
System.out.println("");
System.out.println("El numero es: "+uno.getNumero());
System.out.println("Cantidad de digitos: "+uno.cuentaDigitos());
System.out.println("Suma de digitos: "+uno.sumaDigitos());
System.out.println("Numero invertido: "+uno.numeroInvertido());
System.out.println("Cambia par por 2 y impar por 1: "+uno.cambia());
System.out.println("Mayor par de digitos: "+uno.mayorDos());
break;
case 2:
op=2;
break;
default: System.out.println("Opcion no valida. Intente nuevamente");
}
}
System.out.println("");
System.out.println("Adios!");
}
}
Solo quería agradecerte por lo buena onda, en nuestro curso hay bastantes compañeros que están super colgados, y bueno a mi me ayudo arto, aclaré todas las dudas que tenía.
muy buena ayuda con este ejemplo graacias
Esto esto demasiado bueno, que dedicacion la tuya.. todo muy claro , se agradece.
Saludos de Lima - Peru