[JAVA] Control: Nº2 Sección 3 Vespertino Forma A
Enviado el martes, 10 de junio de 2008 a las en 2:43Hace unos días me llegó por ahí el control de la sección 3 de vespertino. Y bueno, lo desarrollé para aquellos que son de esa sección o para todos los interesados.
Si se van dando cuenta, cada vez explico menos los métodos por motivos obvios. La gran mayoría de los métodos ya los hemos hecho en ejercicios anteriores, y sería tonto explicarlos de nuevos. Siempre la forma de hacer las cosas se va repitiendo.
Les dejo el control para los que no lo tegan:
[ Control 2 ]
De todas formas, cualquier duda ya saben a mi e-mail, que coloqué en unos post más abajo o comenten.
Gracias Pablo por el control.
Ah, se me olvida en la parte donde se crea el número al azar, no logre que me creara un número de entre 6 y 14 dígitos, sólo entre 6 y 9. ¿Por qué?, no sé. Tengo que investigar.
Saludos.
Clase plano
class Control2{
private long numero;
Control2(){
numero = (long)(Math.random()*(999999999+1-100000)+100000); // Entre 6 y 14
}
long getNumero(){
return numero;
}
void setNumero(long numero){
this.numero = numero;
}
/*
* Metodo tan simple (para algunos, claro) como sacar la cantidad
* de pares y impares. Osea, si tenemos el numero 123456, este
* contiene 3 pares (2, 4, 6) y 3 impares (1, 3, y 5) y hacer un
* if final con la condicion que corresponde, que en este caso
* era que si los pares son mayor o igual que los impares se
* devuelve true.
*/
boolean digitoPar(){
int pares = 0, impares = 0;
long copia = numero, digito = 0;
while(copia > 0){
digito = copia%10; // Extraemos el digito
if(digito%2 == 0){ // Es par
pares++;
} else { // Es impar
impares++;
}
copia = copia/10; // Avanzamos de digito
}
if(pares >= impares){ // Hacemos la pregunta
return true;
} else {
return false;
}
}
/*
* En este metodo teniamos que saber CUALES digitos eran
* pares y separarlos en un nuevo numero. Osea, si tenemos
* 123456, teniamos que separarlos y entregar un nuevo numero
* solo con los pares, que seria: 246.
*
* Bueno, en realidad en el control en ningun lado decia
* textual que el numero tenia que venir en ese orden, porque
* para que quede en ese orden hay que invertirlo (cosa
* que hicimos antes y lo puse aqui abajo) pero segun yo
* basta con obtener los numeros pares y hacer un nuevo numero
* con ellos.
*
* OJO: el CERO se toma como par. Pero basta cambiar la condicion
* del if y agregar que 'digito' sea distinto de 0 para que no
* sea contabilizado.
*/
long numeroDivisible(){
int i = 0;
long copia = numero, nuevo_numero = 0, digito = 0, nuevo_invertido = 0;
while(copia > 0){
digito = copia%10; // Extraemos el digito
if(digito%2 == 0){ // Si es par
nuevo_numero = (nuevo_numero*10)+digito; // Se agrega a una nueva cadena
}
copia = copia/10; // Avanzamos de digito
}
/*
* Aqui es donde invertimos el numero, cosa que ya vimos antes.
*/
while(nuevo_numero > 0){
digito = nuevo_numero%10; // Almacenamos el ultimo digito
nuevo_invertido = nuevo_invertido*10+digito; // Agregamos el digito a nuestro numero invertido
nuevo_numero = nuevo_numero/10; // Dividimos para avanzar al siguiente digito
i++;
}
return nuevo_invertido;
}
/*
* Aqui no se trabaja con UN digio, si no con DOS, por lo tanto
* algunas cosas cambian, nuestros '10' cambian por '100'. Fijense
* en 'digitos' y cuando avanzo de digito al final del primer while.
* Ahora tomo los 2 utimos digitos del numero luego sumo esos 2 digitos
* en el mismo if:
*
* if(digitos%10 + digitos/10 < 10)
*
* Si se complican con eso, es facil de entender. Por ejemplo, tenemos
* de digitos 68 -> 68%10 -> 8 ahi ya tenemos un digito de los 2. Luego
* decimos 68/10 -> 6 ahi esta el otro (claro, 6,8 pero se toma como entero)
* y los sumamos y hacemos la comparacion que si es menor de 10 aquella suma
* digitos pasa a ser 99 como dice el ejercicio.
*
* Luego vamos agregando nuestros digitos a un nuevo numero generado
* por nosotros. Esta vez se multiplica por 100 por que vamos agregando
* de 2 digitos a la vez.
*
* Por ultimo invertimos el numero para que lo muestre como debe, osea, en verdad
* como lo muestra el control mas que nada. Pero con que hayan hecho lo primero
* ya esta bueno segun yo, y es un logro.
*
* Les voy a hacer una traza de este, por si no lo entiende con el numero 123456:
*
*
* **** Primer while ****
* | copia | digitos | nuevo_numero |
* -----------------------------------
* | 123456 | 0 | 0 | Valores iniciales
* | 123456 | 56 | 56 |
* | 1234 | 99 | 5699 |
* | 12 | 99 | 569999 |
* -----------------------------------
*
* **** Segundo while ****
* | nuevo_numero | digito | nuevo_invertido |
* ------------------------------------------
* | 569999 | 0 | 0 | Valores iniciales
* | 569999 | 99 | 99 |
* | 5699 | 99 | 9999 |
* | 56 | 56 | 999956 |
* ------------------------------------------
*
* OJO: Esto funciona con cantidad de digitos pares, osea con un 1234567
* funciona mal.
*
*/
long modificaMenores9(){
int i = 0;
long copia = numero, nuevo_numero = 0, digitos = 0, nuevo_invertido = 0, digito = 0;
while(copia > 0){
digitos = copia%100;
if(digitos%10 + digitos/10 < 10){
digitos = 99;
}
nuevo_numero = (nuevo_numero*100)+digitos;
copia = copia/100;
}
/*
* Invertimos el numero, pero de a dos digitos
*/
while(nuevo_numero > 0){
digito = nuevo_numero%100; // Almacenamos el ultimo digito
nuevo_invertido = nuevo_invertido*100+digito; // Agregamos el digito a nuestro numero invertido
nuevo_numero = nuevo_numero/100; // Dividimos para avanzar al siguiente digito
i++;
}
return nuevo_invertido;
}
}
App
class AppControl2{
public static void main(String[]arg){
int op=1, op2=1, numero;
while(op != 0){
Control2 uno = new Control2();
while(op2 != 0){
System.out.println("");
System.out.println("[1] Numero generado");
System.out.println("[2] Digito Par");
System.out.println("[3] Numero Divisible");
System.out.println("[4] Modificado 9");
System.out.println("");
System.out.println("[0] Salir");
op2=Leer.datoInt();
System.out.println("");
switch(op2){
case 1:
System.out.println("El numero es: "+uno.getNumero());
break;
case 2:
if(uno.digitoPar()){
System.out.println("El numero SI es Numero Par");
} else {
System.out.println("El numero NO es Numero Par");
}
break;
case 3:
System.out.println("Divisibles por 2: "+uno.numeroDivisible());
break;
case 4:
System.out.println("Modificado 9: "+uno.modificaMenores9());
break;
case 0: // Si coloca SALIR no se hace nada, pero si se corta este while
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
}
}
/*
* Al salir del menu, se pregunta si se desea genera otro numero
* con las opciones SI(1) y NO(2). Esa opcion es verificada en un
* switch que solo permite esas dos opcions. En el caso de que fuese
* SI 'op2' toma el valor de 1 para que entre nuevamente al segundo
* while. En el caso de que fuese NO, 'op' toma el valor de 0, y
* de este modo corta el while principal saliendo del programa.
*/
System.out.println("");
System.out.println("¿Desea generar otro numero? [1] SI | [2] NO");
op=Leer.datoInt();
switch(op){
case 1:
op2=1;
break;
case 2:
op=0;
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
op2 = 0; // En el caso de colocar una opcion incorrecta
// Indicamos que 'op2' es 0 para que no entre al menu
// y se repita el while principala
}
}
System.out.println("Adios :)!");
}
}
[JAVA] Control: Nº2 Sección 3
Enviado el domingo, 1 de junio de 2008 a las en 20:46Les dejo las dos formas de controles (A y B) que hicimos el jueves pasado.
Como yo soy parte de la Sección 3, no les podría decir a las demás personas de otras secciones que visitan el blog si la prueba fue la misma. De todas formas les dejo las dos formas que hicimos como sección para que las descarguen:
[ Control Nº Sección 3 (forma A y B) ]
Forma A
Clase plano
class Control2{
private int numero;
Control2(){
numero=(int)(Math.random()*(99+1-1)+1); // Entre 2 y 1 digitos
}
int potencia(int exponente){
int i=0, resultado=1;
while(i < exponente){ // Mientras 'i' sea menor que 'numero'
resultado=resultado*numero; // Almacenamos 'resultado'*'numero'
i++; // Aumentamos el contador
}
return resultado; // Devolvemos 'resultado'
}
int factorial(){
/*
* Lo que se hace en este metdodo es recorrer el numero pero
* desde el mismo hasta 0. Osea, si fuese 5: 5->4->3->2->1
* De esa forma vamos multiplicando y sacamos el factorial.
*
* Una traza con el numero 3:
* | i | numero | factorial |
* -------------------------
* | 3 | 3 | 1 | Valores iniciales
* | 3 | 3 | 3 |
* | 2 | 3 | 6 |
* | 1 | 3 | 6 | Factorial: 6
* -------------------------
*/
int i=numero, factorial=1;
while(i > 0){ // Mientras 'i' exista
factorial=factorial*i;
i--; // Restamos -1 a 'i'
}
return factorial;
}
boolean perfecto(){
int i=1, suma_divisores=0;
while(i < numero){ // Recorremos el numero, no incluyendolo a si mismo
if(numero%i == 0){ // Si 'i' es divisor
suma_divisores=suma_divisores+i; // Lo sumamos a la suma de divisores
}
i++;
}
if(suma_divisores == numero){ // Si la suma de divisores es igual al numero
return true; // Es perfecto
} else {
return false; // No es perfecto
}
}
}
App
class AppControl2{
public static void main(String[]arg){
int op=1, op2=1, numero;
while(op != 0){
Control2 uno = new Control2();
while(op2 != 0){
System.out.println("");
System.out.println("[1] Numero generado");
System.out.println("[2] Potencia");
System.out.println("[3] Factorial");
System.out.println("[4] Perfecto");
System.out.println("");
System.out.println("[0] Salir");
op2=Leer.datoInt();
System.out.println("");
switch(op2){
case 1:
System.out.println("Ingrese exponente: ");
numero=Leer.datoInt();
System.out.println("");
System.out.println("Potencia: "+uno.potencia(numero));
break;
case 3:
System.out.println("Factorial: "+uno.factorial());
break;
case 4:
if(uno.perfecto()){
System.out.println("El numero SI es PERFECTO");
} else {
System.out.println("El numero NO es PERFECTO");
}
break;
case 0: // Si coloca SALIR no se hace nada, pero si se corta este while
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
}
}
/*
* Al salir del menu, se pregunta si se desea genera otro numero
* con las opciones SI(1) y NO(2). Esa opcion es verificada en un
* switch que solo permite esas dos opcions. En el caso de que fuese
* SI 'op2' toma el valor de 1 para que entre nuevamente al segundo
* while. En el caso de que fuese NO, 'op' toma el valor de 0, y
* de este modo corta el while principal saliendo del programa.
*/
System.out.println("");
System.out.println("¿Desea generar otro numero? [1] SI | [2] NO");
op=Leer.datoInt();
switch(op){
case 1:
op2=1;
break;
case 2:
op=0;
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
}
}
System.out.println("Adios :)!");
}
}
Forma B
Clase plano
class Control2{
private int numero;
Control2(){
numero=(int)(Math.random()*(99999+1-100)+100); // Entre 5 y 3 digitos
}
/*
* En esta ocacion no hay muco que explicar. Todos los metodos
* vistos aqui para resolver una problematica (en este caso sacar
* divisores) han sido resueltos en ejercicios anteriores. Asi que
* me limitare a explicar lo justo y necesario.
*/
boolean numeroDeficiente(){
int i=1, suma_divisores=0;
while(i < numero){ // Recorremos el numero, no incluyendolo a si mismo
if(numero%i == 0){ // Si 'i' es divisor
suma_divisores=suma_divisores+i; // Lo sumamos a la suma de divisores
}
i++;
}
if(suma_divisores < numero){ // Si la suma de divisores es menor que el numero
return true; // Es deficiente
} else {
return false; // No es deficiente
}
}
int sumaDivisibles(int divisor){
/*
* En este caso hay que usar una copia del numero porque lo tenemos
* que ir dividiendo por 10 para ir avanzando de digito y de este
* modo no modificar el numero original del objeto.
*
*/
int copia=numero, digito=0, suma_divisibles=0;
while(copia > 0){ // Mientras 'copia' exista (mayor que 0)
digito=copia%10; // Obtenemos el ultimo digito de 'copia'
/*
* Si el 'digito' extraido de 'copia' es divisible por 'divisor'
* que en este caso un valor que es enviado por el usuario, sumamos
* el digito con los demas.
*/
if(digito%divisor == 0){
suma_divisibles=suma_divisibles+digito; // Sumamos 'digitos' con la suma anterior
}
copia=copia/10; // Desechamos el digito usado y avanzamos de cifra
}
return suma_divisibles;
}
boolean perfecto(){
int i=1, suma_divisores=0;
while(i < numero){ // Recorremos el numero, no incluyendolo a si mismo
if(numero%i == 0){ // Si 'i' es divisor
suma_divisores=suma_divisores+i; // Lo sumamos a la suma de divisores
}
i++;
}
if(suma_divisores == numero){ // Si la suma de divisores es igual al numero
return true; // Es perfecto
} else {
return false; // No es perfecto
}
}
}
App
class AppControl2{
public static void main(String[]arg){
int op=1, op2=1, numero;
while(op != 0){
Control2 uno = new Control2();
while(op2 != 0){
System.out.println("");
System.out.println("[1] Numero generado");
System.out.println("[2] Deficiente");
System.out.println("[3] Divisibles");
System.out.println("[4] Perfecto");
System.out.println("");
System.out.println("[0] Salir");
op2=Leer.datoInt();
System.out.println("");
switch(op2){
case 1:
System.out.println("El numero es: "+uno.getNumero());
break;
case 2:
if(uno.numeroDeficiente()){
System.out.println("El numero SI es DEFICIENTE");
} else {
System.out.println("El numero NO es DEFICIENTE");
}
break;
case 3:
System.out.println("Ingrese numero: ");
numero=Leer.datoInt();
System.out.println("");
System.out.println("Suma digitos divisibles por "+numero+": "+uno.sumaDivisibles(numero));
break;
case 4:
if(uno.perfecto()){
System.out.println("El numero SI es PERFECTO");
} else {
System.out.println("El numero NO es PERFECTO");
}
break;
case 0: // Si coloca SALIR no se hace nada, pero si se corta este while
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
}
}
/*
* Al salir del menu, se pregunta si se desea genera otro numero
* con las opciones SI(1) y NO(2). Esa opcion es verificada en un
* switch que solo permite esas dos opcions. En el caso de que fuese
* SI 'op2' toma el valor de 1 para que entre nuevamente al segundo
* while. En el caso de que fuese NO, 'op' toma el valor de 0, y
* de este modo corta el while principal saliendo del programa.
*/
System.out.println("");
System.out.println("¿Desea generar otro numero? [1] SI | [2] NO");
op=Leer.datoInt();
switch(op){
case 1:
op2=1;
break;
case 2:
op=0;
break;
default: System.out.println("Opcion invalida. Intenta nuevamente.");
}
}
System.out.println("Adios :)!");
}
}