ListadoBasico3 Garcia Maliga Rafael

Rafael García Maliga | 1º DAW | October 15, 2012

Listado de Ejercicios JAVA BÁSICO 3

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));

}

}

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

*


* @version 0.1

*/

public class EcuacionSegundoGrado {

/**

* Muestra las soluciones de una ecuación de segundo grado

*/


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");

}

}

}

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.

*


* @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.

*/


int[] numeros = new int[3];

System.out.println("Escribe un número 1: ");

numeros[0] = 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");

}

}

}

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)

*


* @version 0.1

*/

public class Factorial {

/**

* Muestra el factorial de un número

* introducido por teclado

*/


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);

}

System.out.print(";\n");

//Fin bucle FOR

//Bucle WHILE

System.out.print("Bucle WHILE => Factorial (" + numero + ")

= ");

int i = numero;

while(i>=1){





i--;

}

System.out.print(";\n");

//Fin bucle WHILE

//Bucle DO WHILE

System.out.print("Bucle DO WHILE => Factorial (" + numero +

") = ");

i = numero;

do{





i--;

}while(i>=1);

System.out.print(";\n\n");

//Fin bucle DO WHILE

}

}

}

Resultado:

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.

*


* @version 0.1

*/

public class LeeCinco {

/**

* Lee cinco valores numéricos y calcula su producto

*/


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:

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.

*


* @version 0.1

*/

public class MultiplicaImpares {

/**

* Multiplica los 20 primeros números impares

* y muestre el resultado en pantalla.

*/


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:

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.

*


* @version 0.1

*/

public class MediaPositivos {

/**

* calcule la media de una serie de números

* positivos, introducidos por teclado.

*/


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:

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.

*


* @version 0.1

*/

public class CerosYUnos {

/**

* Lee una secuencia de ceros y unos.

* Mostrará el número de ceros de la secuencia.

*/


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:

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.

*


* @version 0.1

*/

public class ProductoPotencias {

/**

* Calcula y visualiza el producto de las

* potencias de 2 entre 0 y 10.

*/


int potencia = 0;

long productoTotal = 1;

for(int i=0; i<=10; i++){


potencia = (int) (Math.pow(2,i));

productoTotal = productoTotal * potencia;

System.out.println("2 elevado a " + i + " = " + potencia);

}

System.out.println("Producto total: " + productoTotal);

}

}

Resultado:

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.

*


* @version 0.1

*/

public class Potencia {

/**

* Calcula y visualiza la potencia de un número

* dada la base y el exponente.

*/


System.out.print("Base: ");

int base = Teclado.leerEntero();

System.out.print("Exponente: ");

int exponente = Teclado.leerEntero();


System.out.println(base + " elevado a " + exponente + " = " +

(int) (Math.pow(base,exponente)));

}

}

Resultado:

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.

*


* @version 0.1

*/

import java.text.DecimalFormat;

public class Alumnos {

/**

* Obtiene aleatoriamente las notas

* de 30 alumnos y calcule el número

* de aprobados.

*/


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");

}

}

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.

*


* @version 0.1

*/

public class Tiempo {

/**

* Expresa de forma correcta una medida de tiempo dada.

*/


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

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

*


* @version 0.1

*/

import java.text.DecimalFormat;

public class CambioCaja {

/**

* Calcula el cambio dado un precio y cantidad.

*/


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){

//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++;

}


monedas = 0;

while(cambio >= 0.10){ // 0.10€

cambio-= 0.10;

monedas++;

}


monedas = 0;

while(cambio >= 0.05){ // 0.05€

cambio-= 0.05;

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€).

*


* @version 0.1

*/

public class PrecioFinal {

/**

* Calcula el cambio dado un precio y cantidad.

*/


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:

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.

*


* @version 0.1

*/

public class CambioDolares {

/**

* Cambio de dolares.

*/


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:

ListadoBasico3 Garcia Maliga Rafael

Documents

Transcript of ListadoBasico3 Garcia Maliga Rafael