[JAVA] Control: Nº2 IPF1501
Enviado el viernes, 23 de mayo de 2008 a las en 5:45Este no es ningún ejercicio visto en clases. Es uno de los controles que envió el profesor por TopClass.
Realizaré todos los controles que subió y los colocaré aquí. Puede ser que me demore, no ando con bastante tiempo. Pero sean pacientes.
Los que no tengan los controles (son 6), comenten en esta entrada para subirlos y que puedan descargarlos.
Por último, he visto que hay bastante movimiento en el blog estos días, gracias a que el profesor envio un anuncio sobre el blog. Ya existe uno que otro comentario por ahí y los invito a participar activamente, ya sea como un simple lector solo comentando en las entradas.
Yo se que debe haber mucha gente que se maneja en el tema de Java o que lo entiende facilmente. Pero este no es sólo un blog de Java. La idea es que cubra todos los ramos. Y como hay mucha gente que se maneja en Java también hay gente que se maneja en otras áreas. Así que invito a aquellas personas a que participen en el blog. Yo no tengo problemas en darles acceso y que posteen sus propios ejercicios o lo que sea mientras ayude a los demás. Este es un blog abierto y todos pueden participar.
Les dejo mi e-mail donde pueden contactarme ya sea para dudas, para querer participar en el blog o lo que sea, todo es bienvenido:
champa.despeinada @ gmail.com
Saludos.
Clase plano
class Control{
private int numero;
Control(){
numero=(int)(Math.random()*(99999999+1-10000000)+10000000);
}
/*
* Creo que me va a costar explicar un poco este metodo, pero hare lo mejor
* posible para que entiendan sin problema alguno.
*
* En primer lugar sabes que necesitamos rotar los pares de digitos de un numero
* X tantas veces se indique. Por ejemplo si tenemos el numero 123456 hay que
* partir identificando los pares, que son: 12-34-56. Entonces hay que rotar
* el numero de derecha a izquierda. Si rotamos los pares de digitos de
* 123456 una vez quedarian de esta forma: 561234. El par 56 pasa a primer lugar
* dezplasando a los pares 12 y 34 un lugar a la derecha.
*
* Para lograr esto en programacion, solo basta un poco de ingenio. Partiendo
* de la base que ustede ya saben (y lo vimos en ejercicios pasados) obtener
* los 2 ultimos digitos de un numero. Sabiendo eso, sabemos todo.
*
* Les pido por favor que solo se fijen en primer lugar en el 'while' de abajo
* para entender el codigo en plenitud. De lo contrario se confundiran.
*
* Lo primero que hay que hacer es obtener los 2 ultimos pares de digitos
* del numero. Bien, sigamos con el ejemplo de 123456 (parametro 'rotado)'. Los
* 2 ultimos digitos son 56 que son almacenandos en 'digitos'. Luego necesitamos
* llevar ese par y convertirlo en el primero. Partamos eliminando el 56 de el
* parametro 'rotado', que quedaria: 123456 - 56 = 123400. Ahora tenemos el numero
* 123400, pero esos 00 nos estorban, porque cuando queramos "montar" el 56 en el
* primer lugar quedaria 56123400. Por lo tanto necesitamos eliminar esos 00 que lo
* hacemos dividiendo por 100. Bien, ya tenemos los 00 fuera. Entonces, un recuento:
*
* Por un lado tenemos a los digios 56.
* Por otro lado tenemos al resto del numero 1234 (recuerden que eliminamos los 00).
*
* Bien, ahora...¿como metemos el 56 delante de todos ellos?. Con la siguiente formula:
*
* digito * 10^cantidad_digitos_numero + numero
*
* Donde 'digito' son los digitos que deseamos colocar delante de todos los demas. Y donde
* 'cantidad_de_digitos' es el numero de digitos que tiene el numero que ira despues de
* 'digito'. Osea, en este caso tenemos:
*
* 56 * 10^4 + 1234 -> 56 * 10000 + 1234 -> 560000 + 1234 -> 561234
*
* ¿Como llegue a eso?. Basandome en el metodo 'invertirNumero()' del ejercicio Random.
* En equello esta la base de esto.
*
* Ahora bien. La formula de arriba esta completa. Pero nos falta programar algo para
* que nos entrege un dato que no tenemos: la cantidad de digitos del numero. Es ahí
* donde entra el primer 'while'. El numero se va diviendo por 10 en cada vuelta
* recorriendo el numero entero, digito por digito. Por cada vuelta que da o por
* cada digito que tenga el numero mejor dicho, se va agregando 0's (ceros) a la
* cantidad de digitos. Por ejemplo si tenemos el numero 123456:
*
* 1er digito: 1*10 = 10
* 2do digito: 10*10 = 100
* 3er digito: 100*10 = 1000
* 4to digito: 1000*10 = 10000
* etc...
*
* NOTA: En el primer 'while' necesitamos usar una copia del numero por que este sera
* alterado.
*
* Por lo que para 123456 me entregara 1000000 como resultado. Ok.. tenemos la cantidad
* de digitos del numero COMPLETO, pero necesitamos la cantidad de digitos de numero
* sin el 56. Para aquello dividimos ese resultado por 100 quitandole dos cifras y
* dejando el resultado como un numero 4 digitos.
*
* Todo eso se traduce en esta formula:
*
* (digitos*(cantidad_digitos/100))+((rotado-digitos)/100)
*
* Hagamos una traza con el numero 123456 rotandolo 2 veces:
*
* 1er 'while'
* | copia | cantidad_digitos |
* ----------------------------
* | 123456 | 1 | Valores Iniciales
* | 12345 | 10 |
* | 1234 | 100 |
* | 123 | 1000 |
* | 12 | 10000 |
* | 1 | 100000 |
* | 0 | 1000000 |
* -----------------------------
* Cantidad de digitos: 1000000 (equivalente a 6 digitos)
*
* 2do 'while'
* | i | digitos | rotado |
* ------------------------
* | 0 | 0 | 123456 | Valores Iniciales
* | | | |
* | | | | (digitos*(cantidad_digitos/100))+((rotado-digitos)/100)
* | 1 | 56 | 561234 | (56*(1000000/100))+((123456-56)/100)
* | | | | (56*10000)+(123400/100)
* | | | | 560000+1234
* | | | | 5612345 <- ROTADO!
* | | | |
* | 2 | 34 | 345612 | (34*(1000000/100))+((561234-34)/100)
* | | | | (34*10000)+(561200/100)
* | | | | 340000+5612
* | | | | 345612 <- ROTADO!
* ------------------------
*/
int rotaDeDos(int veces){
int i=0, copia=numero, rotado=numero, digitos=0, cantidad_digitos=1;
while(copia > 0){ // Mientras 'copia' sea mayor que 0
copia=copia/10; // Se realiza la division por 10
cantidad_digitos=cantidad_digitos*10; // Se agrega un 0 por cada digito
}
while(i < veces){
digitos=rotado%100; // Almacenamos los 2 ultimos digitos
rotado=(digitos*(cantidad_digitos/100))+((rotado-digitos)/100); // Se rota el numero
i++; // +1 al contador de veces
}
return rotado; // Devolvemos el numero rotado
}
/*
* Este metodo es mas simple. Mucho mas simple en realidad. Puede ser que
* se enreden un poco en los 'if', pero explicare todo.
*
* Lo que necesitamos hacer es ver que par de digitos sumados es el menor.
* Por lo tanto lo primero que hay que hacer es ir reccoriendo el numero
* par por par. Para ello como ya saben es ir haciendo modulo de 100 al numeo
* y luego dividir por 100 para avanzar hasta el siguiente par.
*
* Ya que tenemos el ultimo par de digitos del numero preguntamos si la suma
* de sus digitos es menor a nuestro par menor que tenemos almacenados. En el
* caso de que sea verdadero nuestro menor se remplaza por el nuevo par menor.
*
* if(digitos%10+digitos/10 < menor && numero%100 != digitos)
*
* Si se fijan en esa condicion lo que estoy haciendo es primero obtener el
* ultimo digito del numero con el modulo de 10 y luego obtener el primer digito
* dividiendo por 10. Al sumar esas dos cosas sumo sus dos digitos. Luego esa
* suma la comparo con nuestro 'menor', PERO si esta es la primera vuelta de
* comparacion se salta esa condicion. ¿Por que?. Porque no tenemos un 'menor'.
* Actualmente 'menor' es 0, y como no trabajamos con numeros negativos, NUNCA
* nada va a ser menor que 0. Por lo tanto si es la primera vuelta hay que asignar
* automaticamente el valor 'digitos' a 'menor' y a partir de ese valor ir
* comparando. Fijense en esta parte del 'if':
*
* ... && numero%100 != digitos)
*
* Aqui estoy diciendo, que si los 2 ultimos digitos del numero es distinto a
* nuestros 'digitos', recien ahi puede entrar al 'if', ya que significa que no
* es su primera vuelta. Por ejemplo, si tuviesemos el numero 1234 y es nuestra
* primera vuelta el valor de 'digitos' seria 34. Entonces 1234%100 = 34.
* ¿34 distinto de 34?. No, son iguales. Por lo tanto es la primera vuelta.
* Al ser la primera vuelta no entra a ese 'if' y se va a el 'else' donde
* se guarda automaticamente el valor de 'digitos' en 'menor' para luego empezar
* a comparar con los otros par de digitos del numero.
*
* Eso mismo, se pudo tambien haber hecho con un contador 'i' que vaya contando
* las vueltas del 'while' y la condicin del 'if' quedaria asi (teniendo en cuenta
* que 'i' es inicializado en 0):
*
* if(digitos%10+digitos/10 < menor && i != 0)
*
*/
int parDedigitosMenor(){
int copia=numero, digitos=0, menor=0;
while(copia > 0){ // Mientras 'copia' sea mayor que 0
digitos=copia%100; // Almacenamos los 2 ultimos digitos
/*
* Si la suma de los digitos es menor que 'menor' y NO es la primera vuelta
*/
if(digitos%10+digitos/10 < menor && numero%100 != digitos){
menor=digitos;
} else { // Si es la primera vuelta
menor=digitos; // Se guarda en 'menor' el valor de 'digitos'
}
copia=copia/100; // Dividimos el numero para avanzar al siguiente digito
}
return menor; // Devolvemos el par menor
}
}
App
class AppControl{
public static void main(String[]arg){
int numero, op=0, veces;
char op2='s';
while(op2=='s'){
op=0;
while(op!=3){
Control uno = new Control();
System.out.println("");
System.out.println("El numero es: "+uno.getNumero());
System.out.println("");
System.out.println("[1] Ver numero rotado de a dos");
System.out.println("[2] Ver par digito menor");
System.out.println("[3] Salir");
op=Leer.datoInt();
switch(op){
case 1:
System.out.println("¿Cuantas veces desea rotarlo?: ");
veces=Leer.datoInt();
System.out.println("Numero rotado "+veces+" veces: "+uno.rotaDeDos(veces));
break;
case 2:
System.out.println("Par de digitos menor: "+uno.parDedigitosMenor());
break;
default: System.out.println("Opcion invalida. Intentelo nuevamente.");
}
}
System.out.println("¿Crear nuevo numero? Si(s) | No(n): ");
op2=Leer.datoChar();
}
System.out.println("");
System.out.println("Adios!");
}
}