listadobasico3 garcia maliga rafael
TRANSCRIPT
Rafael García Maliga | 1º DAW | October 15, 2012
Listado de Ejercicios JAVA BÁSICO 3
PAGE 1
1. Indica el resultado de las siguientes expresiones, suponiendo que inicialmente x vale 1:
a. (1 > x) && ( 1 > x++)
b. (1 == x) || (10 > x++)
c. (++x) + x;
d. x + (++x)
Código:
/**
Indica el resultado de las siguientes expresiones, suponiendo que
inicialmente x vale 1:
a. (1 > x) && ( 1 > x++)
b. (1 == x) || (10 > x++)
c. (++x) + x;
d. x + (++x)
* @author Rafael García Maliga
* @version 0.1
*/
public class ResultadoExpresiones {
/**
* Indica el resultado de las siguientes expresiones, suponiendo
que inicialmente x vale 1
*/
public static void main (String[] args){
int x = 1;
//a
if((1>x) && (1>x++)){
System.out.println("Resultado a: Verdadero");
}else{
System.out.println("Resultado a: Falso");
}
//b
if((1 == x) || (10 > x++)){
System.out.println("Resultado b: Verdadero");
}else{
System.out.println("Resultado b: Falso");
}
//c
System.out.println("Resultado c: " + (++x) + x);
//d
System.out.println("Resultado d: " + x + (++x));
}
}
PAGE 2
Resultado:
2. Define la clase EcuacionSegundoGrado que muestre las soluciones de una ecuación de segundo
grado ax2 + bx + c = 0.
Código:
/**
* Define la clase EcuacionSegundoGrado que muestre las soluciones de
una ecuación de
* segundo grado ax2 + bx + c = 0.
* http://www.vadenumeros.es/tercero/ecuaciones-de-segundo-grado.htm
*
* @author Rafael García Maliga
* @version 0.1
*/
public class EcuacionSegundoGrado {
/**
* Muestra las soluciones de una ecuación de segundo grado
*/
public static void main (String[] args){
int a=2, b=4, c=-6;
double x1, x2, discriminante;
//Calulamos el discriminate
discriminante= (Math.pow(b, 2)) - (4*a*c); //Math.pow base y
exponente
//Comprobamos si se trata de una ecuación de segundo grado
if (a==0){
System.out.println("No se trata de una ecuación de segundo
grado");
}else if(discriminante > 0){ //Calculamos la ecuación
x1 = (-b + Math.sqrt(discriminante)) / (2*a); //Math.sqrt
eleva a la raiz cuadrada
x2 = (-b - Math.sqrt(discriminante)) / (2*a);
System.out.println(" x1 = "+ x1 + "\n x2 = " + x2);
}else if(discriminante == 0){ //Tiene solución doble dado que
el discriminante es 0
x1=-b/(2*a);
System.out.println(" Tiene solución doble = "+ x1);
}else{//En caso contrario no tiene solución real
System.out.println("Discriminante igual a " + discriminante
+ ". No riene solución real");
}
}
}
PAGE 3
Resultado:
3. Define la clase OrdenaTres que ordene tres números enteros introducidos por teclado y los
muestre por pantalla de forma decreciente.
Código:
/**
* Define la clase OrdenaTres que ordene tres números enteros
* introducidos por teclado y los muestre por pantalla
* de forma decreciente.
*
* @author Rafael García Maliga
* @version 0.1
*/
import java.util.Arrays;
public class OrdenaTres {
/**
* Ordena tres números enteros introducidos por teclado
* y los muestre por pantalla de forma decreciente.
*/
public static void main (String[] args){
int[] numeros = new int[3];
System.out.println("Escribe un número 1: ");
numeros[0] = Teclado.leerEntero(); // lee el entero introducido
System.out.println("Escribe un número 2: ");
numeros[1] = Teclado.leerEntero(); // lee el entero introducido
System.out.println("Escribe un número 3: ");
numeros[2] = Teclado.leerEntero(); // lee el entero introducido
//Mostramos el array con el orden original
System.out.print("Orden introducido : \n");
for(int index=0; index < numeros.length ; index++){
System.out.print(" " + numeros[index] + "\n");
}
//Ordenamos el array con el método sort
Arrays.sort(numeros);
//Mostramos el array ordenado
System.out.print("Números ordenados : \n");
for(int index=0; index < numeros.length ; index++){
System.out.print(" " + numeros[index] + "\n");
}
}
}
PAGE 4
Resultado:
4. Define la clase Factorial que muestre el factorial de un número introducido por teclado. Realízalo
con los tres bucles. (Factorial (4) = 4*3*2*1; Factorial (0) = 1).
Código:
/**
* Define la clase Factorial que muestre el factorial de un número
introducido por
* teclado. Realízalo con los tres bucles. (Factorial (4) = 4*3*2*1;
Factorial (0) = 1)
*
* @author Rafael García Maliga
* @version 0.1
*/
public class Factorial {
/**
* Muestra el factorial de un número
* introducido por teclado
*/
public static void main (String[] args){
System.out.println("Introduce un número: ");
int numero = Teclado.leerEntero(); // lee el entero introducido
//Comprobamos si es cero o menor
if(numero <=0){
System.out.println("Factorial (" + numero + ") = 1");
}else{
//Bucle FOR
System.out.print("\nBucle FOR => Factorial (" + numero + ")
= ");
for(int i=numero; i>=1; i--){
if(i == numero) //Omitimos el primer símbolo *
System.out.print(i);
else //Al resto le agregamos el símbolo *
System.out.print("*" + i);
PAGE 5
}
System.out.print(";\n");
//Fin bucle FOR
//Bucle WHILE
System.out.print("Bucle WHILE => Factorial (" + numero + ")
= ");
int i = numero;
while(i>=1){
if(i == numero) //Omitimos el primer símbolo *
System.out.print(i);
else //Al resto le agregamos el símbolo *
System.out.print("*" + i);
i--;
}
System.out.print(";\n");
//Fin bucle WHILE
//Bucle DO WHILE
System.out.print("Bucle DO WHILE => Factorial (" + numero +
") = ");
i = numero;
do{
if(i == numero) //Omitimos el primer símbolo *
System.out.print(i);
else //Al resto le agregamos el símbolo *
System.out.print("*" + i);
i--;
}while(i>=1);
System.out.print(";\n\n");
//Fin bucle DO WHILE
}
}
}
Resultado:
PAGE 6
5. Define la clase LeeCinco que lea cinco valores numéricos y calcule su producto.
Código:
/**
* Define la clase LeeCinco que lea cinco valores numéricos y calcule su
producto.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class LeeCinco {
/**
* Lee cinco valores numéricos y calcula su producto
*/
public static void main (String[] args){
long producto = 1L;
for(int i=0; i < 4; i++){
System.out.print("\n Introduce un número: ");
producto = (long) (producto * Teclado.leerEntero()); // lee
el entero introducido
//Imprimimos en pantalla el parcial
System.out.println(" Parcial producto final = " +
producto);
}
//Imprimimos en pantalla el total
System.out.println("\n******************************************\n" +
" Total producto final = " + producto +
"\n******************************************\n");
}
}
Resultado:
PAGE 7
6. Define la clase MultiplicaImpares que multiplique los 20 primeros números impares y muestre el
resultado en pantalla.
Código:
/**
* Define la clase MultiplicaImpares que multiplique los 20 primeros
* números impares y muestre el resultado en pantalla.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class MultiplicaImpares {
/**
* Multiplica los 20 primeros números impares
* y muestre el resultado en pantalla.
*/
public static void main (String[] args){
int producto = 1;
for(int i=1; i<=20; i++){
//Comprobamos si es impar, en caso contrario lo descartamos
if(i%2 != 0){
producto = producto * i;
}
}
//Imprimimos en pantalla el total
System.out.println("\n*************************************************
****************\n" +
" Producto total de los 20 primeros impares = " + producto +
"\n*****************************************************************\n"
);
}
}
Resultado:
PAGE 8
7. Define la clase MediaPositivos que calcule la media de una serie de números positivos,
introducidos por teclado. Dejará de leer cuando el usuario introduzca el 0.
Código:
/**
* Define la clase MediaPositivos que calcule la media de una serie de
* números positivos, introducidos por teclado. Dejará de leer cuando
* el usuario introduzca el 0.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class MediaPositivos {
/**
* calcule la media de una serie de números
* positivos, introducidos por teclado.
*/
public static void main (String[] args){
int numPositivo = 0;
int totalPositivos = 0;
while(true){
//Leemos el número en pantalla
numPositivo = Teclado.leerEntero();
//Salida del bucle "0"
if(numPositivo == 0)
break;
//Comprobamos si es positivo
if(numPositivo > 0){
totalPositivos += numPositivo;
//Realizamos la media e imprimimos en pantalla
System.out.println("Total => " + totalPositivos + "
Media => " + (totalPositivos/2));
}
}
}
}
Resultado:
PAGE 9
8. Define la clase CerosYUnos que lea una secuencia de ceros y unos. Mostrará el número de ceros
de la secuencia. Dejará de leer cuando el usuario introduzca el número 2.
Código:
/**
* Define la clase CerosYUnos que lea una secuencia de ceros y unos.
* Mostrará el número de ceros de la secuencia.
* Dejará de leer cuando el usuario introduzca el número 2.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class CerosYUnos {
/**
* Lee una secuencia de ceros y unos.
* Mostrará el número de ceros de la secuencia.
*/
public static void main (String[] args){
int numPositivo = 0;
int totalCeros = 0;
while(true){
//Leemos el número en pantalla
numPositivo = Teclado.leerEntero();
//Salida del bucle "2" o mayor
if(numPositivo >= 2)
break;
//Comprobamos si es positivo
if(numPositivo == 0){
totalCeros++;
}
}
// Imprimimos en pantalla
System.out.println("Total de ceros introducidos => " +
totalCeros);
}
}
Resultado:
PAGE 10
9. Define la clase ProductoPotencias que calcule y visualice el producto de las potencias de 2 entre
0 y 10.
Código:
/**
* Define la clase ProductoPotencias que calcule y visualice
* el producto de las potencias de 2 entre 0 y 10.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class ProductoPotencias {
/**
* Calcula y visualiza el producto de las
* potencias de 2 entre 0 y 10.
*/
public static void main (String[] args){
int potencia = 0;
long productoTotal = 1;
for(int i=0; i<=10; i++){
// Imprimimos en pantalla
potencia = (int) (Math.pow(2,i));
productoTotal = productoTotal * potencia;
System.out.println("2 elevado a " + i + " = " + potencia);
}
System.out.println("Producto total: " + productoTotal);
}
}
Resultado:
PAGE 11
10. Define la clase Potencia que calcule y visualice la potencia de un número dada la base y el
exponente.
Código:
/**
* Define la clase Potencia que calcule y visualice
* la potencia de un número dada la base y el exponente.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class Potencia {
/**
* Calcula y visualiza la potencia de un número
* dada la base y el exponente.
*/
public static void main (String[] args){
System.out.print("Base: ");
int base = Teclado.leerEntero();
System.out.print("Exponente: ");
int exponente = Teclado.leerEntero();
// Imprimimos en pantalla
System.out.println(base + " elevado a " + exponente + " = " +
(int) (Math.pow(base,exponente)));
}
}
Resultado:
PAGE 12
11. Define la clase Alumnos que obtenga aleatoriamente las notas de 30 alumnos y calcule el número
de aprobados. La nota será un número decimal comprendido entre 0 y 10, ambos inclusive.
Código:
/**
* Define la clase Alumnos que obtenga aleatoriamente las notas
* de 30 alumnos y calcule el número de aprobados. La nota será
* un número decimal comprendido entre 0 y 10, ambos inclusive.
*
* @author Rafael García Maliga
* @version 0.1
*/
import java.text.DecimalFormat;
public class Alumnos {
/**
* Obtiene aleatoriamente las notas
* de 30 alumnos y calcule el número
* de aprobados.
*/
public static void main (String[] args){
int totalAprobados = 0;
double nota = 0;
DecimalFormat df = new DecimalFormat("#.#"); //Método para
formatear decimales
for(int i=1; i<31; i++){
/* Generamos la nota entre 0 y el 10 + un decimal
* y comprobamos si está aprobado.
*/
nota = (double)(Math.random()*10);
/* Alternativa
* nota = Math.rint(Math.random()*100)/10;
*/
System.out.println("Alumno #" + i + " nota => " +
df.format(nota)); // se imprime y se le da formato de 1 decimal
if(nota >= 5){
totalAprobados++;
}
}
//Imprimimos el total de aprobados y suspensos
System.out.println("\n" + totalAprobados + " alumnos aprovados
" +
(30 - totalAprobados) + " alumnos suspendidos\n");
}
}
PAGE 13
Resultado:
12. Define la clase Tiempo que dada una medida de tiempo expresada en horas, minutos y segundos
con valores arbitrarios, elabore un programa que transforme dicha medida en una expresión
correcta. Por ejemplo, dada la medida 3h 118m 195s, se deberá obtener como resultado 5h 1m 15s.
Código:
/**
* Define la clase Tiempo que dada una medida de tiempo expresada
* en horas, minutos y segundos con valores arbitrarios, elabore
* un programa que transforme dicha medida en una expresión correcta.
* Por ejemplo, dada la medida 3h 118m 195s, se deberá obtener como
* resultado 5h 1m 15s.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class Tiempo {
/**
* Expresa de forma correcta una medida de tiempo dada.
*/
public static void main (String[] args){
int horas = 3;
int minutos = 118;
int segundos = 195;
//Pasar horas y minutos a segundos
minutos += horas*60;
segundos += minutos*60;
//Calcular Horas Minutos y Segundos
horas = segundos/3600; // 1h => 3600s
PAGE 14
segundos = (segundos - (horas*3600));
minutos = segundos/60; // 1m => 60s
segundos = (segundos - (minutos*60));
//Iimprimir tiempo en el formato correcto
System.out.println(horas + "h " + minutos + "m " + segundos
+"s");
}
}
Resultado:
13. Define la clase CambioCaja que calcule el cambio que debe dar la caja de un supermercado.
Dado un precio y una cantidad de dinero, el resultado será el número de monedas que deben darse
como cambio de tal forma que el número total de monedas sea mínimo.
Código:
/**
* Define la clase CambioCaja que calcule el cambio que debe dar la caja
de un
* supermercado. Dado un precio y una cantidad de dinero, el resultado
será el número
* de monedas que deben darse como cambio de tal forma que el número
total de
* monedas sea mínimo
*
* @author Rafael García Maliga
* @version 0.1
*/
import java.text.DecimalFormat;
public class CambioCaja {
/**
* Calcula el cambio dado un precio y cantidad.
*/
public static void main (String[] args){
double precio = 63.23; //Precio del artículo
double cantidad = 73; //Cantidad dada
double cambio = 0; //Cambio a devolver
int monedas = 0; //Contador de monedas
//Imprimimos el precio y cantidad (solo en carácter
informativo)
System.out.println("Precio => " + precio +
"€ \nCantidad => " + cantidad + "€");
//Primero comprobamos que hemos dado suficiente dinero
if(cantidad < precio){
PAGE 15
//Dinero insuficiente
System.out.println("Dinero insuficiente.");
}else if(cantidad == precio){
//Cantidad exacta
System.out.println("No hay cambio, cantidad exacta.");
}else{ //Hay que devolver cambio
cambio = cantidad - precio; // Restamos la cantidad al
precio y nos quedamos con el cambio.
//Imprimimos el cambio el total a devolver
DecimalFormat df = new DecimalFormat("#.##"); //Método para
formatear decimales
System.out.println("Cambio => " + df.format(cambio) +
"€\n");
//Calculo solo en mondedas 2€, 1€, 0.50, 0.20, 0.10, 0.05,
0.01.
while(cambio >= 2){ // 2€
cambio -= 2;
monedas++;
}
//Impriminos la cantidad de monedas y reiniciamos el
contador "monedas".
System.out.println("Monedas de 2€ => x" + monedas);
monedas = 0;
while(cambio >= 1){ // 1€
cambio-= 1;
monedas++;
}
System.out.println("Monedas de 1€ => x" + monedas);
monedas = 0;
while(cambio >= 0.50){ // 0.50€
cambio-= 0.50;
monedas++;
}
System.out.println("Monedas de 0.50€ => x" + monedas);
monedas = 0;
while(cambio >= 0.20){ // 0.20€
cambio-= 0.20;
monedas++;
}
System.out.println("Monedas de 0.20€ => x" + monedas);
monedas = 0;
while(cambio >= 0.10){ // 0.10€
cambio-= 0.10;
monedas++;
}
System.out.println("Monedas de 0.10€ => x" + monedas);
monedas = 0;
while(cambio >= 0.05){ // 0.05€
cambio-= 0.05;
monedas++;
}
PAGE 16
System.out.println("Monedas de 0.05€ => x" + monedas);
monedas = 0;
while(cambio >= 0.01){ // 0.01€
cambio-= 0.01;
monedas++;
}
System.out.println("Monedas de 0.01€ => x" + monedas +
"\n");
}
}
}
Resultado:
14. Define la clase PrecioFinal. Se sabe que el precio final de un producto para un comprador es la
suma total del costo del producto, un porcentaje de beneficios que obtiene el vendedor y el I.V.A.
Escribe un programa para obtener el precio final de un producto sabiendo su costo, el porcentaje de
beneficios y el I.V.A. aplicable. Obtener el resultado redondeando a los cinco céntimos (p.ej. 5.94€ -
> 5.95€).
Código:
/**
* Define la clase PrecioFinal. Se sabe que el precio final de un
producto para un
* comprador es la suma total del costo del producto, un porcentaje de
beneficios que
* obtiene el vendedor y el I.V.A. Escribe un programa para obtener el
precio final de un
* producto sabiendo su costo, el porcentaje de beneficios y el I.V.A.
aplicable. Obtener el
* resultado redondeando a los cinco céntimos (p.ej. 5.94€ -> 5.95€).
*
* @author Rafael García Maliga
PAGE 17
* @version 0.1
*/
public class PrecioFinal {
/**
* Calcula el cambio dado un precio y cantidad.
*/
public static void main (String[] args){
double costo = 63.23; //Costo del artículo €
double beneficios = 3; //Beneficio 300%
double iva = 0.22; //IVA 22%
//Calculamos el beneficio sobre el costo
beneficios = ((costo * beneficios) - costo);
//Calculamos el iva
iva = ((costo + beneficios) * iva);
//Imprimimos el precio final
System.out.println("Costo del artículo =>\t" + Math.rint(costo
* 100)/100 +
"\nBeneficios sobre el artículo =>\t" + Math.rint(beneficios *
100)/100 +
"\nIVA aplicable =>\t" + Math.rint(iva * 100)/100 +
"\nPrecio final =>\t" + Math.rint((costo + beneficios +
iva)*100)/100 + "€");
}
}
Resultado:
PAGE 18
15. Define la clase CambioDolares. Un banco recibe todos los días del Banco Mundial una lista de
cómo está el cambio de las divisas del mundo respecto del dólar americano (USD). Escribe un
programa que, a partir de una cantidad de dólares que deseamos comprar, nos devuelva la cantidad
en euros que nos costarían esos dólares. Suponga que el banco obtiene en el cambio un tanto por
ciento variable de beneficios.
Código:
/**
* Define la clase CambioDolares. Un banco recibe todos los días del
Banco Mundial una
* lista de cómo está el cambio de las divisas del mundo respecto del
dólar americano
* (USD). Escribe un programa que, a partir de una cantidad de dólares
que deseamos
* comprar, nos devuelva la cantidad en euros que nos costarían esos
dólares. Suponga
* que el banco obtiene en el cambio un tanto por ciento variable de
beneficios.
*
* @author Rafael García Maliga
* @version 0.1
*/
public class CambioDolares {
/**
* Cambio de dolares.
*/
public static void main (String[] args){
double dolares = 63.23; //Cantidad de dolares $(USD)
double beneficios = 0.02; //Beneficio banco %
double valorCambio = 0.766166105; //Valor del cambio 1$(USD)
==> 0.766166105€
double euros = 0;
//Calculamos el cambio
euros = dolares * valorCambio;
//Imprimimos el precio final
System.out.println("Dolares =>\t$" + Math.rint(dolares *
100)/100 +
"\nCambio =>\t" + Math.rint(euros * 100)/100 + "€\n" +
"\nCambio menos beneficios =>\t" + Math.rint((euros *
valorCambio ) * 100)/100 + "€\n");
}
}
Resultado: