[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 :)!");
}
}
[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!");
}
}
[JAVA] Ejercicio: Números
Enviado el lunes, 19 de mayo de 2008 a las en 18:09En realidad el nombre de este ejercicio es Ejercicio While, pero yo lo llamo Números.
Este ejercicio fue el que hicimos en la clase pasada del jueves 15, que decia lo siguiente:
Construir una clase que tiene por atributos dos enteros ingresados por el usuario y los siguientes métodos:
- multiplicación(): devuelve la multiplicación de los dos números pero mediante sumas sucesivas.
- división(): devuelve la división de los dos números pero mediante sumas sucesivas.
- primo(): devuelve true si los números (ambos son primos), sino false
- amigos(): devuelve true si el primer numero es amigo del segundo.Dos numeros son amigos si la suma de los divisores del primero sin incluir el numero me dan como resultado el segundo y si la suma de los divisores del segundo sin el numero, me dan como resultado el primero.
- potencia(): devuelve el primer numero elevado al segundo, pero construido como multiplicaciones sucesivas.
Construir una aplicación que permita crear un objeto y mediante un menú mostrar los métodos. Solo se debe salir cuando el usuario quiera.
Clase plano
class Numeros{
private int numero1, numero2;
/* En este metodo teniamos que hacer que 2 numeros se multiplicaran
* pero mediante sumas sucesivas. Entiendase sucesivo como algo
* continuo como un ciclo, osea en nuestro caso un 'while'.
* La mas pura base de la multiplicacion se basa en la suma sucesiva.
*
* Ejemplo:
* Tenemos como Numero1=2 y Numero2=3. ¿Esto que significa?: que
* el numero 2 tiene que sumarse a si mismo 3 veces. Osea, tenemos
* que: 2+2+2 = 6. Eso es una suma sucesiva y es lo que tenemos
* que llevar a nuestro lenguaje de programacion.
*
* Ya nos dimos cuenta que lo que necesitmos para aquello es usar
* el ciclo 'while' de tal forma que sume 'Numero1' tantas veces
* como diga 'Numero2'. ¿Como saber cuantas veces he sumado 'Numero1'?
* Usando un CONTADOR, que en este caso tiene el nombre de 'i'.
* Entonces decimos que mientras 'i' sea menor que 'Numero2' haga el
* proceso de guardar en 'resultado' la suma sucesiva de 'Numero1'.
* Por cada suma que haga, se le aumenta el valor en 1 a el contador
* 'i'. Pero aun falta algo. Y es el lugar en donde ira guardando esa
* suma. En este caso ese lugar se llama 'resultado' y por cada vuelta
* que de el 'while' a 'resultado' se le suma 'Numero1'.
*
* Traza:
* | Numreo1 | Numero2 | Resultado | i |
* -------------------------------------
* | 2 | 3 | 0 | 0 | // Valores iniciales
* | 2 | 3 | 2 | 1 |
* | 2 | 3 | 4 | 2 |
* | 2 | 3 | 6 | 3 | // 3 no es menor que 3. Fin 'while'.
* -------------------------------------
*/
int multiplicacion(){
int resultado=0, i=0;
while(i < numero2){ // Mientras 'i' sea menor que 'numero2'
resultado=resultado+numero1; // Sumamos 'numero1' a 'resultado'
i++; // +1 al contador. OJO!: 'i++' es lo mismo que 'i=i+1'
}
return resultado; // Devolvemos 'resultado'
}
/* Puede que este metodo se vea un poco parecido al anterior, pero
* no lo es. El razonamiento de este es bastante distinto al anterior
* y en vez de sumas sucevias tenemos restas sucevias.
*
* Hay que partir preguntandose como saber mediante restas sucevias
* cuanto es A/B. Sabemos que la division nos ayuda a resolver cuantas
* veces cabe B en A. Por ejemplo: 8/2 = 4. Entonces 2 cabe 4 veces en
* 8. ¿Pero como llevamos eso a nuestro lenguaje y mediante restas
* sucevias?. Simple, es cosa de hacer un ciclo que vaya restando A-B
* mientras A sea mayor que B y almacenando en un contador cuantas
* veces se logro hacer esa operacion. Y luego devolver nuestro contador
* ya que es el, el que nos dira cuantas veces cabe B en A.
*
* Es muy importante usar una COPIA de 'Numero1', por
* el simple motivo que en este caso necesitamos trabajar y modificar
* un valor que esta entro del objeto. y no podemos trabajar directamente
* con el valor original para no perderlo. Digamos que tenemos un numero X
* con un valor X, y en un metodo X trabajamos DIRECTAMENTE con el para
* que nos entregue X resultado. Para llegar a ese X resultado
* necesitamos restarle cosas al numero, sumarle cosas, multiplicar ese
* numero, etc. Hacer cosas con ese numero. Luego de hacer todo eso
* obtenemos nuestro resultado. Todo bien, hasta que llamamos a otro
* metodo que tambien necesita trabajar con ese numero X y su valor
* ORIGINAL. Pero no va a trabajar con su valor ORIGINAL, si no con
* un valor modificado por el metodo anterior. Para que no suceda eso
* y todos los metodos puedan trabajar con los valores del metodos sin
* afectarlos se usan COPIAS de los valores en los meteodos.
*
* Otro detalle importante es que cambia nuestra condicion del 'while'.
* Esta vez dice que mientras 'copia' (entiendase como 'numero1') sea mayor
* o igual que 'numero2' vamos a restar a 'copia' lo que se encuentra en
* 'numero2'. Y luego aumentaremos el valor del contador 'i' en +1, que
* vendria a ser la cantidad de divisiones. ¿Por que menor o igual?.
* Porque en el caso de que tengamos dividiendo dos numeros iguales
* devolveria 0 como resultado ya que no entraria al 'while' porque no
* cumpliria la condicion.
*
* Hagamos una traza con los valores 9(copia de numero1) y 2:
* | Copia | Numero2 | i |
* ----------------------
* | 9 | 2 | 0 | // Valores iniciales
* | 7 | 2 | 1 |
* | 5 | 2 | 2 |
* | 3 | 2 | 3 |
* | 1 | 2 | 4 | // 1 menor que 2. Fin 'while'
* -----------------------
*
* Esta forma de division mediantes restas sucevias NO entrega decimales
* (cosa obvia) por lo tanto siempre va a entregar el valor entero
* de una division.
*/
int division(){
int resultado=0, i=0, copia=numero1;
while(copia > numero2){ // Mientras 'copia' se mayor o igual que 'numero2'
copia=copia-numero2; // Restamos 'numero2' a 'copia'
i++; // +1 al contador
}
return i; // Devolvemos la cantidida de restas sucevias realizadas
}
/* Para saber si un numero es primo o no tiene que cumplir una condicion:
* que solo sea divisible por el mismo y por 1. Osea solo tener 2 divisores.
*
* ¿Como sacar los divisores de un numero?. Primero tenemos que tener claro
* que es un divisor. Un numero es divisor de otro cuando el RESTO de la
* division de ellos es igual a 0. Ahora que sabemos si un numero es
* divisor de otro, debes pensar como sacar TODOS los divisores de un numero.
* Para eso tenemos que recorrer el numero desde 1 hasta si mismo. Osea, si
* queremos sacar el divisor de 10, tenemos que dividirlo desde 1 hasta 10 e
* ir preguntando en todas las divisiones de 1 a 10 cuales dieron resto 0.
* Sabiendo la cantidad de divisones que dieron resto 0, podemos saber si un
* numero es primo o no.
*
* Para poder dividir un numero desde 1 a si mismo tenemos que usar un ciclo
* 'while', tener un divisor y un contador de divisores. Para aquello hay
* que tener encuenta lo siguiente.
*
* 1) En este caso NO se usa una copia del numero, ya que el numero no sera
* tratado, modificado, alterado de ninguna forma. En este caso se usa
* como un valor estable para obtener un resultado.
*
* 2) 'i sera nuestro numero divisor que ira desde 1 hasta el numero necesario.
* OJO: Este debe partir en UNO y no en CERO, ya que la division por cero
* NO EXISTE.
*
* Ahora bien, ¿como saber si un numero es divisor?. Como explique anteriormente
* saber si un numero es divisor de otro se ve con el resto, lo cual en Java
* es el %. Entonces preguntamos:
*
* if(copia_numero%i == 0) { es divisor }
*
* Arriba estamos diciendo que si al dividir 'copia_numero' por 'i' nos da un
* resto igual a cero significa que 'i' es divisor del numero. ¿Entonces?
* Es ahi en donde necesitamos guardar esa informacion en otro contador.
* Cuando se cumpla el caso de arriba se necesita aumentar en uno el contador
* de divisores indicando que fue encontrado otro divisor y agregandolo a la
* cuenta.
*
* Por ultimo lugar, luego del termino del 'if' se aumenta en +1 'i'. De este
* modo 'i' va a ir desde 1 hasta el numero en si mismo. Y va a ir diviendo el
* numero por 1, 2, 3, etc...
*
* Una traza con el numero 6:
* | Numero | i | divisores |
* --------------------------
* | 6 | 1 | 0 | // Valores iniciales
* | 6 | 1 | 1 | // 6/1 -> 1 es divisor -> divisores + 1
* | 6 | 2 | 2 | // 6/2 -> 2 es divisor -> divisores + 1
* | 6 | 3 | 3 | // 6/3 -> 3 es divisor -> divisores + 1
* | 6 | 4 | 3 | // 6/4 -> 4 NO es divisor
* | 6 | 5 | 3 | // 6/5 -> 5 NO es divisor
* | 6 | 6 | 4 | // 6/6 -> 6 es divisor -> divisores + 1
* --------------------------
*
* Esa traza devuelve como resultado que 6 tiene 4 divisores, que son
* 1, 2, 3 y 6.
*
* Una traza con el numero 5:
* | Numero | i | divisores |
* --------------------------
* | 5 | 1 | 0 | // Valores iniciales
* | 5 | 1 | 1 | // 5/1 -> 1 es divisor -> divisores + 1
* | 6 | 2 | 0 | // 5/2 -> 2 NO es divisor
* | 5 | 3 | 0 | // 5/3 -> 3 NO es divisor
* | 5 | 4 | 0 | // 5/4 -> 4 NO es divisor
* | 5 | 5 | 2 | // 5/5 -> 5 es divisor -> divisores + 1
* --------------------------
*
* Esa traza devuelve como resultado que 5 tiene 2 divisores, que son
* 1 y 5. Osea... es PRIMO!
*
* Hay que repetir el proceso con los 2 numeros que tenemos, 'numero1'
* y 'numero2' y luego en un 'if' final preguntar si los DOS numeros
* tienen solo 2 divisores (osea los DOS son primos) devuelve 'true'
* de lo contrario 'false'.
*/
boolean primo(){
int i=1, divisores_num1=0, divisores_num2=0;
while(i <= numero1){ // Mientras 'i' sea menor o igual a 'numero1'
if(numero1%i == 0){ // Si 'numero1'%'i' es igual a 0
divisores_num1++; // Es divisor
}
i++;
}
/* Ojo que aqui lo unico que hago es restablecer el contador 'i'
* a su valor original UNO para no usar otro contador y asi
* re-utilizar el mismo.
*/
i=1; // Restablecemos el contador 'i' = 1 para usarlo en el siguiente while
while(i <= numero2){ // Mientras 'i' sea menor o igual a 'numero2'
if(numero2%i == 0){ // Si 'numero2'%'i' es igual a 0
divisores_num2++; // Es divisor
}
i++;
}
if(divisores_num1 == 2 && divisores_num2 == 2){ // Si los 2 son primos
return true;
} else {
return false;
}
}
/* Dos numeros son amigos tal que la suma de los divisores propios de A den B y
* la suma de los divisores de B den A. Entiendase 'divisores propios' como
* todos los divisores de un numero sin el mismo. Osea, divisores propios de 6:
* 1,2 y 3. Se excluye el numero 6.
*
* Como ya sabemos como sacar los divisores de un numero, sera un poco mas facil
* entender el funcionamiento de esta parte. Pero aun asi hay cosas que explicar,
* como la gran diferencia que ahora no necesitamos CONTAR cuantos divisores
* tiene X numero, si no que hay que SUMARLOS y que la condicion de nuestro 'while'
* cambia, de 'i'<='numero' a 'i'<'numero'. Ya que debemos EXCLUIR el mismo 'numero''.
*
* Si nos fijamos en el codigo, la condicion del 'if' es la misma, pero esta vez
* no usamos un contador, si no que sumamos divisores. Entonces debemos tener un
* lugar donde ir guardando la suma de estos para luego preguntar si la suma
* de los divisores, para luego hacer la comparacion pertinente.
*
* Fijense en esta linea:
*
* if(divisores_num1 == numero2){
*
* Esta linea va solo por un metodo de optimizacion de codigo. Ya que si no se cumple
* eso, seria inutil revisar el segundo numero, ya que aunque se cumpla en el segundo
* caso seguiran siendo NO AMIGOS. Asi se evita hacer un 'while' innecesario y
* devuelve inmediatamente 'false' indicando que NO son amigos. En el caso de que
* esa condicion se cumpla se hace el mismo trabajo que hicimos con el primer numero
* pero esta vez con el segundo. Luego preguntamos si la suma de los divisores del
* segundo numero es IGUAL al primer numero devolvemos 'true' indicando que SI son
* amigos, de lo contrario devolvemos 'false'.
*/
boolean amigos(){
int i=1, divisores_num1=0, divisores_num2=0;
while(i < numero1){
if(numero1%i == 0){
divisores_num1=divisores_num1+i;
}
i++;
}
if(divisores_num1 == numero2){
i=1; /// Restablecemos el contador 'i' = 1 para usarlo en el siguiente while
while(i < numero2){
if(numero2%i == 0){
divisores_num2=divisores_num2+i;
}
i++;
}
if(divisores_num2 == numero1){
return true;
} else {
return false;
}
} else {
return false;
}
}
/* Sabemos que una potencia en palabras simples es mutiplicar un numero (base)
* tantas veces lo indique otro (exponente).
*
* Entonces necesitamos multiplicar el 'numero1' tantas veces indique 'numero2'.
* Debemos recorrer 'numero2' desde 1 hasta si mismo. Para aquello usamos un
* contador 'i' que se vaya aumentando en +1 por cada vuelta que de el 'while'. Y
* de este modo iremos almacenando en 'resultado' las multiplicaciones de 'numero1'
* o mejor dicho las multiplicaciones sucevias de 'numero1'.
*
* Traza con los valores 2 y 4:
* | Numero1 | Numero2 | i | Resultado |
* -------------------------------------
* | 2 | 4 | 0 | 0 | // Valores iniciales
* | 2 | 4 | 1 | 4 | // 2*2 = 4
* | 2 | 4 | 2 | 8 | // 4*2 = 8
* | 2 | 4 | 3 | 16 | // 8*2 = 16 <- Resultado
* -------------------------------------
*/
int potencia(){
int i=0, resultado=1;
while(i < numero2){ // Mientras 'i' sea menor que 'numero2'
resultado=resultado*numero1; // Almacenamos 'resultado'*'numero1'
i++; // Aumentamos el contador
}
return resultado; // Devolvemos 'resultado'
}
}
App
class AppNumeros{
public static void main(String[]arg){
int numero1, numero2, op=1;
while(op!=0){
System.out.println("");
System.out.println("Numero 1: ");
numero1=Leer.datoInt();
System.out.println("Numero 2: ");
numero2=Leer.datoInt();
Numeros uno = new Numeros(numero1, numero2);
while(op!=0 && op!=6){
System.out.println("");
System.out.println("[1] Multiplicacion");
System.out.println("[2] Division");
System.out.println("[3] Primo");
System.out.println("[4] Amigos");
System.out.println("[5] Potencia");
System.out.println("");
System.out.println("[6] Nuevos Numeros");
System.out.println("[0] Salir del Programa");
System.out.println("");
op=Leer.datoInt();
switch(op){
case 1: // Multiplicacion
System.out.println("Numero 1 por numero 2: "+uno.multiplicacion());
break;
case 2: // Division
System.out.println("Numero 1 dividido numero 2: "+uno.division());
break;
case 3: // Primos
if(uno.primo()){
System.out.println("Los 2 numeros son primos!");
} else {
System.out.println("Ambos o uno de ellos no son primos :(");
}
break;
case 4: // Amigos
if(uno.amigos()){
System.out.println("Son amigos :)");
} else {
System.out.println("No son amigos :(");
}
case 5:
System.out.println("Numero 1 elvedao numero 2: "+uno.potencia());
break;
case 6: // Crear nuevos numeros o salir
case 0:
break;
default: System.out.println("No es una opcion valida. Intente nuevamente");
}
}
}
System.out.println("Adios!");
}
}
[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!");
}
}
[H&S] Libro IT Essensials y Clase a clase
Enviado el viernes, 9 de mayo de 2008 a las en 2:30A raíz de que a la gran mayoría de nosotros nos fue pésimo en la prueba de Hardware & Software que hicimos en clase con nuestra querida profesora Nancy les voy a dejar dos cosas que les puden servir de ayuda:
[ Libro IT Essensials ]: Este es el libro del cual sí o sí tienen que estudiar. Realmente yo por lo menos no recomiendo estudiar de otro lado que no sea este libro, ya sea la página de Cisco o los Power Point que nos muestra la profesora en clase, que está todo extremadamente resumido.
[ Clase a clase ]: Aquí les dejo el clase a clase de este ramo. Contiene 16 semanas de clases, las cuales equivalen a los 14 módulos que tiene el Libro IT Essensials de Cisco. En cada semana encontrarán los Power Point que vemos en clase más los Worksheet de cada módulo. Hay que tener mucho ojo con estos, los estuve revisando y la profesora saco gran cantidad de preguntas de ellos. Es más, pienso que se basó en los Worksheet para hacer la prueba anterior. Así que seria bueno que para futuras pruebas los hicieran. Ya que si sigue con la misma práctica, será más fácil para nosotros.
Espero que les sea de ayuda y cualquier aporte es bien recibido.
[JAVA] Solemne 1 - Forma B
Enviado el a las en 2:11Este es el ejercicio de nuestra primera solemne. Por lo menos esto fue lo que yo hice, pero no aseguro que esté 100% correcto.
Para los que tienen la Forma A, no son muchos los cambios. Si se fijan, cambian algunos valores al validar al pasajero, rebajar el pasaje, los impuestos (ustedes no tenían el impuesto al lujo), en vez de RUT ustedes tenian Nombre y por último que en vez de disminuir en X porcentaje el valor del pasaje, ustedes tenían que aumentarlo. Pero la base de las pruebas era la misma.
Saludos, ojalá les haya ido bien.
Clase plano
class Crucero{
private String rut;
private int camarote, valor, literas;
boolean pasajeroValido(){
if(camarote >= 1 && camarote <= 300 && literas >= 1 && literas <=6){
return true;
} else {
return false;
}
}
void rebajaValorPasaje(){
if(literas == 1 || literas == 2){
valor=valor;
} else if(literas == 3 || literas == 4){
valor=(int)(valor-(valor*0.066));
} else if(literas == 5 || literas == 6) {
valor=(int)(valor-(valor*0.139));
}
}
int impuestos(){
double impuestos;
impuestos=valor*0.1345; // Impuesto al viaje
impuestos=impuestos+(valor*0.032); // Impuesto al lujo
impuestos=impuestos+(valor*0.19); // IVA
return (int)(impuestos);
}
int valorAPagar(){
return (valor+impuestos())*literas;
}
}
App
class AppCrucero{
public static void main(String[]arg){
String rut;
int camarote, valor, literas, op, rebaja;
System.out.println("RUT: ");
rut=Leer.dato();
System.out.println("Camarote: ");
camarote=Leer.datoInt();
System.out.println("Valor: ");
valor=Leer.datoInt();
System.out.println("Literas: ");
literas=Leer.datoInt();
Crucero uno = new Crucero(rut, camarote, valor, literas);
System.out.println("");
System.out.println("[1] Validar Pasajero");
System.out.println("[2] Valor a Pagar");
System.out.println("[3] Impuestos cancelados");
System.out.println("[4] Disminuir Pasaje");
op=Leer.datoInt();
System.out.println("");
switch(op){
case 1:
if(uno.pasajeroValido()){
System.out.println("Pasajero valido.");
} else {
System.out.println("Pasajero NO valido.");
}
break;
case 2:
uno.rebajaValorPasaje(); // Se aplica la rebaja
System.out.println("El total a pagar es: $"+uno.valorAPagar());
break;
case 3:
uno.rebajaValorPasaje(); // Se aplica la rebaja
System.out.println("Impuestos cancelados: $"+uno.impuestos());
break;
case 4:
System.out.println("Rebajar pasaje en (Valor actual: $ "+uno.getValor()+"): ");
rebaja=Leer.datoInt();
uno.setValor(uno.getValor()-(uno.getValor()*rebaja/100));
System.out.println("");
System.out.println("Pasaje rebajado: $"+uno.getValor());
break;
default: System.out.println("Opcion no valida.");
}
}
}