[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.");
}
}
}
[JAVA] Ejercicio: Tiempo
Enviado el miércoles, 7 de mayo de 2008 a las en 15:47Acabo de terminar este ejercicio. Puede verse un poco complicado, pero no lo es tanto. Intenté explicar todo dentro del mismo ejercicio, pero cualquier duda ya saben.
Clase plano
class Tiempo{
private int hora, minutos;
private char tipo;
int cantidadDigitosHora(){
int c=0; // Contador de digitos
while(hora>0){
hora=hora/10;
c++; // Sumamos +1 al contador de digitos
}
return c;
}
int cantidadDigitosMinutos(){
int c=0; // Contador de digitos
/* En el caso de que los minutos sean 0
* se indica inmediatamente que solo es
* 1 digito. Ya que no podemos dividir
* 0 por 10 en el caso de abajo
* Gracias a Fito por avisparse!
*/
if(minutos == 0){
c=1;
} else {
while(minutos>0){
minutos=minutos/10;
c++; // Sumamos +1 al contador de digitos
}
}
return c;
}
boolean horaInvalida(){
if(hora<1 || hora>12){
return true; //La hora es menor a 1 o mayor que 12. INVALIDA.
} else {
return false; //La hora se encuentra en el rango 1-12. VALIDA.
}
}
boolean minutoInvalido(){
if(minutos<0 || minutos>59){
return true; //Los minutos son menor a 0 o mayor que 60. INVALIDA.
} else {
return false; //Los minutos son encuentran en el rango 0-59. VALIDA.
}
}
void restableceHora(){
if(horaInvalida()){
hora=1; // Cambiamos la hora a 1
}
}
void restableceMinutos(){
if(minutoInvalido()){
minutos=30; // Cambiamos los minutos a 30
}
}
void avanzaMinuto(){
if(tipo=='a' && hora==12 && minutos==59){ // 1er caso: 12:59 am + 1 = 1:00 pm
/* Cambia la hora de AM a PM
* en el caso de que fuesen las 12:59 am
* quedando 1:00 pm
*/
hora=1;
minutos=0;
tipo='p';
} else if(tipo=='p' && hora==12 && minutos==59){ // 2do caso: 12:59 pm + 1 = 1:00 am
/* Cambia la hora de PM a AM
* en el caso de que fuesen las 12:59 pm
* quedando 1:00 am
*/
hora=1;
minutos=0;
tipo='a';
} else if(minutos==59){ // 3er caso: hh:59 am/pm + 1 minuto = hh+1:00 am/pm
/* Suma una hora en el caso
* de que fuesen las hh:59
* Ejemplo: 4:59 pm cambia a 5:00 pm
*/
hora=hora+1;
minutos=0;
} else { // 4to caso: hh:mm am/pm + 1 minuto = hh:mm+1
minutos=minutos+1;
}
}
void disminuyeMinuto(){
if(tipo=='a' && hora==1 && minutos==00){ // 1er caso: 1:00 am - 1 = 12:59 pm
/* Cambia la hora de AM a PM
* en el caso de que fuesen las 1:00 am
* quedando 12:59 pm
*/
hora=12;
minutos=59;
tipo='p';
} else if(tipo=='p' && hora==1 && minutos==00){ // 2do caso: 1:00 pm - 1 = 12:59 am
/* Cambia la hora de PM a AM
* en el caso de que fuesen las 1:00 pm
* quedando 12:59 am
*/
hora=12;
minutos=59;
tipo='a';
} else if(minutos==00){ // 3er caso: hh:00 am/pm - 1 minuto = hh-1:59 am/pm
/* Resta una hora en el caso
* de que fuesen las hh:00
* Ejemplo: 5:00 pm cambia a 4:59 pm
*/
hora=hora-1;
minutos=59;
} else { // 4to caso: hh:mm am/pm - 1 minuto = hh:mm-1
minutos=minutos-1;
}
}
}
App
class AppTiempo{
public static void main(String[]arg){
int hora, minutos;
char tipo;
// OBJETO UNO //
System.out.println("Hora: ");
hora=Leer.datoInt();
System.out.println("Minutos: ");
minutos=Leer.datoInt();
System.out.println("AM/PM (a o p): ");
tipo=Leer.datoChar();
Tiempo uno = new Tiempo(hora, minutos, tipo);
// OBJETO DOS //
System.out.println("Hora: ");
hora=Leer.datoInt();
System.out.println("Minutos: ");
minutos=Leer.datoInt();
System.out.println("AM/PM (a o p): ");
tipo=Leer.datoChar();
Tiempo dos = new Tiempo(hora, minutos, tipo);
// OBJETO TRES //
System.out.println("Hora: ");
hora=Leer.datoInt();
System.out.println("Minutos: ");
minutos=Leer.datoInt();
System.out.println("AM/PM (a o p): ");
tipo=Leer.datoChar();
Tiempo tres = new Tiempo(hora, minutos, tipo);
System.out.println("");
System.out.println("Tiempo Hora:Minutos am/pm");
System.out.println(" 1 "+uno.getHora()+":"+uno.getMinutos()+" "+uno.getTipo());
System.out.println(" 2 "+dos.getHora()+":"+dos.getMinutos()+" "+dos.getTipo());
System.out.println(" 3 "+tres.getHora()+":"+tres.getMinutos()+" "+tres.getTipo());
uno.restableceHora();
uno.restableceMinutos();
dos.restableceHora(); // Se restablecen los tiempos
dos.restableceMinutos();
tres.restableceHora();
tres.restableceMinutos();
System.out.println("");
System.out.println("## Tiempos restablecidos ##");
System.out.println("Tiempo Hora:Minutos am/pm");
System.out.println(" 1 "+uno.getHora()+":"+uno.getMinutos()+" "+uno.getTipo());
System.out.println(" 2 "+dos.getHora()+":"+dos.getMinutos()+" "+dos.getTipo());
System.out.println(" 3 "+tres.getHora()+":"+tres.getMinutos()+" "+tres.getTipo());
uno.avanzaMinuto();
tres.avanzaMinuto(); // +1 minutos tiempo 1 y 3. -1 minuto tiempo 2
dos.disminuyeMinuto();
System.out.println("");
System.out.println("## Se avanzo +1 minuto a los tiempos 1 y 3; y -1 minuto al tiempo2 ##");
System.out.println("Tiempo Hora:Minutos am/pm");
System.out.println(" 1 "+uno.getHora()+":"+uno.getMinutos()+" "+uno.getTipo());
System.out.println(" 2 "+dos.getHora()+":"+dos.getMinutos()+" "+dos.getTipo());
System.out.println(" 3 "+tres.getHora()+":"+tres.getMinutos()+" "+tres.getTipo());
}
}
[JAVA] Ejercicio: Termómetro
Enviado el lunes, 5 de mayo de 2008 a las en 22:00Desde ahora en adelante no pondré los métodos get, set ni los constructores en la clase plano.
Clase Plano
class Termometro{
private double temperatura, minima, maxima;
/* Estos metodos son void porque no retornan nada
* si se fijan en la guia dice que solo cumplen
* un proceso especifico. No tienen retorno alguno.
*/
void subeTemperatura(double incremento){
if(temperatura+incremento > maxima){
temperatura=maxima;
} else {
temperatura=temperatura+incremento;
}
}
void bajaTemperatura(double incremento){
if(temperatura-incremento < minima){
temperatura=minima;
} else {
temperatura=temperatura-incremento;
}
}
}
App
class AppTermometro{
public static void main(String[]arg){
double temperatura, minima, maxima;
// OBJETO UNO //
System.out.println("Temperatura: ");
temperatura=Leer.datoInt();
System.out.println("Minima: ");
minima=Leer.datoInt();
System.out.println("Maxima: ");
maxima=Leer.datoInt();
Termometro uno=new Termometro(temperatura, minima, maxima);
// OBJETO DOS //
System.out.println("Temperatura: ");
temperatura=Leer.datoInt();
System.out.println("Minima: ");
minima=Leer.datoInt();
System.out.println("Maxima: ");
maxima=Leer.datoInt();
Termometro dos=new Termometro(temperatura, minima, maxima);
// INFORMACION //
System.out.println("Temperatura objeto uno: "+uno.getTemperatura()+"ºC | Temperatura objeto dos: "+dos.getTemperatura()+"ºC");
// MODIFICAR //
System.out.println("Subir temperatura primer objeto en: ");
temperatura=Leer.datoInt();
uno.subeTemperatura(temperatura); // Subimos la temperatura
System.out.println("Bajar temperatura segundo objeto en: ");
temperatura=Leer.datoInt();
dos.bajaTemperatura(temperatura); // Subimos la temperatura
// INFORMACION //
System.out.println("Temperatura objeto uno: "+uno.getTemperatura()+"ºC | Temperatura objeto dos: "+dos.getTemperatura()+"ºC");
}
}
[JAVA] Ejercicio: Punto
Enviado el a las en 8:08Este ejercicio no tiene mayor dificultad, así que dudo en verdad que hayan tenido problemas con el.
Clase plano
class Punto{
private int x, y;
Punto(int x, int y){
this.x=x;
this.y=y;
}
void setX(int x){
this.x=x;
}
void setY(int y){
this.y=y;
}
int getX(){
return x;
}
int getY(){
return y;
}
int cuadrante(){
if(x>0 && y>0){ // Cuadrante 1
return 1;
} else if(x<0 && y>0){ // Cuadrante 2
return 2;
} else if(x<0 && y<0){ // Cuadrante 3
return 3;
} else if(x>0 && y<0){ // Cuadrante 4
return 4;
} else { // Punto (0,0). Escapa de todos los cuadrantes.
return 0; // Devolvemos 0 indicando que no es parte de ningun cuadrante
}
}
int mayor(){
/* Voy a hacer este metodo con if
* aunque se puede hacer usando
* la clase Math.
*/
if(x>y){
return x;
} else {
return y;
}
}
}
App
class AppPunto{
public static void main(String[]arg){
int x, y;
// OBJETO UNO //
System.out.println("Ingrese X: ");
x=Leer.datoInt();
System.out.println("Ingrese Y: ");
y=Leer.datoInt();
Punto uno=new Punto(x, y);
// OBJETO DOS //
System.out.println("Ingrese X: ");
x=Leer.datoInt();
System.out.println("Ingrese Y: ");
y=Leer.datoInt();
Punto dos=new Punto(x, y);
// INFORMACION //
System.out.println("P1: ("+uno.getX()+","+uno.getY()+") P2: ("+dos.getX()+","+dos.getY()+")");
System.out.println("P1 se encuentra en el cuadrante: "+uno.cuadrante()+" | P2 se encuentra en el cuadrante: "+dos.cuadrante());
System.out.println("Cordenada mayor P1: "+uno.mayor()+" | Cordenada mayor P2: "+dos.mayor());
// MODIFICAR COORDENADAS //
System.out.println("Nueva coordenada X P1: ");
x=Leer.datoInt();
uno.setX(x); // Se modifica X en el P1(objeto uno)
System.out.println("Nueva coordenada Y P2: ");
y=Leer.datoInt();
dos.setY(y); // Se modifica Y en el P2(objeto dos)
System.out.println("P1: ("+uno.getX()+","+uno.getY()+") P2: ("+dos.getX()+","+dos.getY()+")");
}
}
[JAVA] Ejercicio: Celular (actualizado)
Enviado el viernes, 2 de mayo de 2008 a las en 2:23A continuación les dejo la clase plano que hice para el ejercicio Celular, faltaría hacer el App el cual lo pondré mas adelante en este mismo post.
No coloqué los métodos get y set por motivos obvios. Se supone que ya todos saben hacerlos, así se ahorra espacio.
Cualquier duda ya saben, sólo comenten y les respondo.
------------------------------
Actualización: Modifiqué la clase plano y agregué el App del ejercicio.Modifiqué el tipo de dato de tipoPlan de char a String por motivos de correcto funcionamiento del programa. No sé porque motivo tuve problemas con el char al pedir el dato TipoPlan en el App. El programa se quedaba colgado. Cambiándolo a String se solucionó el problema.
Volví a cambiar de String a char el atributo tipoPlan. En la clase de hoy (06 de mayo) el profesor explicó el problema por el cual se quedaba colgado el programa.
Para los que no vinieron tienen que cambiar lo siguiente en la clase Leer:
System.in.skip(1000);
Busquen esa línea de código y modifiquen el 1000 por 1. Debería quedar así:
System.in.skip(1);
Otro cambio que hice fue en los if. Si bien recuerdan Java diferencia ente mayúsculas y minúsculas, por lo que tuve que agregar nuevas condiciones en los if de los métodos cambioPlan(), totalAlto() y totalBajo(). De este modo, si el usuario ingresa una A, B o C minúscula o mayúscula da lo mismo, el programa la reconocerá como corresponde.
Para poder llegar y copiar el código tienen que hacer clic donde dice "view plain" justo arriba de la línea número uno de cada código. Al hacer clic se abrirá una nueva ventana con el texto sin tratar y podrán copiarlo sin problemas
Clase plano
class Celular{
private int numeroTelefono, minutosBajo, minutosAlto;
private char tipoPlan;
Celular(int numeroTelefono, int minutosBajo, int minutosAlto, char tipoPlan){
this.numeroTelefono=numeroTelefono;
this.minutosBajo=minutosBajo;
this.minutosAlto=minutosAlto;
this.tipoPlan=tipoPlan;
}
void cambioPlan(){
/* Ojo con las comillas!
* Se utilizan comillas simples '' en este caso y no dobes ""
* Por el simple hecho de que estamos trabajando con char
* Si fuese String serian dobles ""
*/
if(tipoPlan=='A' || tipoPlan=='a'){
tipoPlan='B';
} else if(tipoPlan=='B' || tipoPlan=='b'){
tipoPlan='C';
} else {
tipoPlan='A';
}
}
int totalAlto(int minutos){
if(tipoPlan=="'A' || tipoPlan=='a'){
return 55*minutos;
} else if(tipoPlan=='B' || tipoPlan=='b'){
return 85*minutos;
} else {
return 130*minutos;
}
}
int totalBajo(int minutos){
if(tipoPlan=='A' || tipoPlan=='a'){
return 10*minutos;
} else if(tipoPlan=='B' || tipoPlan=='b'){
return 35*minutos;
} else {
return 55*minutos;
}
}
int pagoCelular(int minutosAlto, int minutosBajo){
int total;
total=totalAlto(minutosAlto)+totalBajo(minutosBajo);
return (int)((total*0.19)+total);
}
}
App
class AppCelular{
static public void main(String[]arg){
int numeroTelefono, minutosBajo, minutosAlto, habladoAlto, op;
char tipoPlan;
// OBJETO NUMERO UNO //
System.out.println("Numero Telefono: ");
numeroTelefono=Leer.datoInt();
System.out.println("Minutos Horario Bajo: ");
minutosBajo=Leer.datoInt();
System.out.println("Minutos Horario Alto: ");
minutosAlto=Leer.datoInt();
System.out.println("Tipo Plan:");
tipoPlan=Leer.datoChar();
Celular uno=new Celular(numeroTelefono, minutosBajo, minutosAlto, tipoPlan);
// OBJETO NUMERO DOS //
System.out.println("");
System.out.println("Numero Telefono: ");
numeroTelefono=Leer.datoInt();
System.out.println("Minutos Horario Bajo: ");
minutosBajo=Leer.datoInt();
System.out.println("Minutos Horario Alto: ");
minutosAlto=Leer.datoInt();
System.out.println("Tipo Plan: ");
tipoPlan=Leer.datoChar();
Celular dos=new Celular(numeroTelefono, minutosBajo, minutosAlto, tipoPlan);
// Pedimos que celular desea ver //
System.out.println("");
System.out.println("Que celular desea ver: ");
System.out.println("");
System.out.println("[1] Primer Celular");
System.out.println("[2] Segundo Celular");
op=Leer.datoInt();
System.out.println("");
// Se muestran los datos segun el celular seleccionado //
switch(op){
case 1:
System.out.println("Numero Telefono: "+uno.getNumeroTelefono());
System.out.println("Tipo Plan: "+uno.getTipoPlan());
System.out.println("Minutos Horario Alto: "+uno.getMinutosAlto()+" / Minutos Horario Bajo: "+uno.getMinutosBajo());
System.out.println("Pago Total Celular: $"+uno.pagoCelular(uno.getMinutosAlto(), uno.getMinutosBajo()));
System.out.println("");
System.out.println("Cambiar Plan a: - El plan actual es: "+uno.getTipoPlan()+" -");
tipoPlan=Leer.datoChar();
uno.setTipoPlan(tipoPlan); // Modificamos el plan
break;
case 2:
System.out.println("Numero Telefono: "+dos.getNumeroTelefono());
System.out.println("Tipo Plan: "+dos.getTipoPlan());
System.out.println("Minutos Horario Alto: "+dos.getMinutosAlto()+" / Minutos Horario Bajo: "+dos.getMinutosBajo());
System.out.println("Pago Total Celular: $"+dos.pagoCelular(dos.getMinutosAlto(), dos.getMinutosBajo()));
System.out.println("");
System.out.println("Cambiar Plan a: - El plan actual es: "+dos.getTipoPlan()+" -");
tipoPlan=Leer.datoChar();
dos.setTipoPlan(tipoPlan); // Modificamos el plan
break;
default: System.out.println("Opcion no valida");
}
// Se imprimen los resultados de los 2 celulares(objetos) //
System.out.println("[Celular 1] Numero: "+uno.getNumeroTelefono()+" / Plan: "+uno.getTipoPlan()+" / Mins. Horario Alto: "+
uno.getMinutosAlto()+" / Mins. Horario Bajo: "+uno.getMinutosBajo()+" / Pago Total Celular: $"+
uno.pagoCelular(uno.getMinutosAlto(), uno.getMinutosBajo()));
System.out.println("[Celular 2] Numero: "+dos.getNumeroTelefono()+" / Plan: "+dos.getTipoPlan()+" / Mins. Horario Alto: "+
dos.getMinutosAlto()+" / Mins. Horario Bajo: "+dos.getMinutosBajo()+" / Pago Total Celular: $"+
dos.pagoCelular(dos.getMinutosAlto(), dos.getMinutosBajo()));
}
}
Bienvenidos
Enviado el a las en 2:14Bueno queridos compañeros, les doy la más dulce y gay bienvenida a el blog de nuestro curso el cual será estrictamente manejado por mí y por nadie más. Seré un estricto dictador el cual censurará todo comentario o contenido que no me agrade.
Dejando el webeo de lado, espero que este blog sea de mucha utilidad para todos y que TODOS aporten en él. ¿Cuál será el fin de este?: bueno lo principal es tenerlo como respaldo y ayuda para todos. También será usado como recordatorio, comunicación entre nosotros, etcétera.
Voy a tratar de mantenerlo bien actualizado y tenerlos al tanto de todo de lo que ocurre a nivel de nuestras clases (pruebas, material, guías de apoyo, ejercicios resueltos). Lo ideal sería que todos participaran, ya sea simplemente comentando en cada post del blog o mejor aún participando activamente en él colocando contenido.
Es bueno que nos ayudemos entre todos y esta es una gran opción para hacerlo.
Saludos.