Hola a todos, hoy os dejo una serie de ejercicios de Java para practicar todo aquello que hemos explicado en anteriores posts.
Todos los ejercicios que proponemos están resueltos en este mismo post, intenta hacerlo por ti mismo y si te quedas atascado puedes mirar la solución. Recuerda, que no tiene por que estar igual tu solución con la del post, el objetivo es que aprendas no que me copies la solución.
El nombre de la aplicación es de tu elección, excepto en el ejercicio 25. Crea un proyecto en Java por ejercicio. Colocare en las soluciones algunos comentarios para que sean más fácilmente entendible.
Te recomiendo que uses mensajes de trazas, donde te sean necesarios. Si tienes problemas también puedes usar el depurador.
Aquí tienes todos los posts relacionados con Java:
También tenemos el curso en formato video:
Si tienes alguna duda, recuerda que puedes consultarnos escribiendo un comentario en este post o enviándonos un e-mail a administrador@discoduroderoer.es
En la página «auriculares-inalambricos.es» podrás obtener auriculares sin cables con los que escuchar música mientras realizas nuestros ejercicios :D.
1) Declara dos variables numéricas (con el valor que desees), muestra por consola la suma, resta, multiplicación, división y módulo (resto de la división).
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 |
public class OperacionesApp { public static void main(String[] args) { //Declaramos las variables int num1=10; int num2=5; /*Realizamos las operaciones. * Tambien lo podemos guardar el resultado en variables. */ System.out.println("El resultado de la suma es "+(num1+num2)); System.out.println("El resultado de la resta es "+(num1-num2)); System.out.println("El resultado de la multiplicación es "+(num1*num2)); System.out.println("El resultado de la división es "+(num1/num2)); } } |
2) Declara 2 variables numéricas (con el valor que desees), he indica cual es mayor de los dos. Si son iguales indicarlo también. Ves cambiando los valores para comprobar que funciona.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class NumeroMayorApp { public static void main(String[] args) { //Declaramos las variables int num1=30; int num2=15; //Hacemos la comprobación if (num1>=num2){ //If anidado if(num1==num2){ System.out.println("Los numeros "+num1+" y "+num2+" son iguales"); }else{ System.out.println("El número "+num1+" es mayor que el número "+num2); } }else{ System.out.println("El número "+num2+" es mayor que el número "+num1); } } } |
3) Declara un String que contenga tu nombre, después muestra un mensaje de bienvenida por consola. Por ejemplo: si introduzco «Fernando», me aparezca «Bienvenido Fernando».
Spoiler
|
1 2 3 4 5 6 7 8 9 |
public class SaludoApp { public static void main(String[] args) { String nombre="Fernando"; System.out.println("Bienvenido "+nombre); } } |
4) Modifica la aplicación anterior, para que nos pida el nombre que queremos introducir (recuerda usar JOptionPane).
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
import java.util.Scanner; public class SaludoPersonalizadoApp { public static void main(String[] args) { //Nos aparece un cuadro de dialogo Scanner sc = new Scanner(System.in); System.out.println("Introduce tu nombre"); String nombre=sc.nextLine(); System.out.println("Bienvenido "+nombre); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 |
import javax.swing.JOptionPane; public class SaludoPersonalizadoApp { public static void main(String[] args) { //Nos aparece un cuadro de dialogo String nombre=JOptionPane.showInputDialog("Introduce tu nombre"); System.out.println("Bienvenido "+nombre); } } |
5) Haz una aplicación que calcule el área de un círculo(pi*R2). El radio se pedirá por teclado (recuerda pasar de String a double con Double.parseDouble). Usa la constante PI y el método pow de Math.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import java.util.Scanner; public class AreaCirculoApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un radio"); sc.useLocale(Locale.US); double radio=sc.nextDouble(); //Formula area circulo, usamos algunos de los metodos de Math double area=Math.PI*Math.pow(radio, 2); System.out.println("El area del circulo es "+area); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import javax.swing.JOptionPane; public class AreaCirculoApp { public static void main(String[] args) { String texto=JOptionPane.showInputDialog("Introduce un radio"); //Pasamos el String a double double radio=Double.parseDouble(texto); //Formula area circulo, usamos algunos de los metodos de Math double area=Math.PI*Math.pow(radio, 2); System.out.println("El area del circulo es "+area); } } |
6) Lee un número por teclado e indica si es divisible entre 2 (resto = 0). Si no lo es, también debemos indicarlo.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.util.Scanner; public class DivisibleApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un numero"); int numero=sc.nextInt(); //Comprobamos si es divisible entre 2, es decir, si el resto de la division es 0 if (numero%2==0){ System.out.println("El numero "+numero+" es divisible entre 2"); }else{ System.out.println("El numero "+numero+" no es divisible entre 2"); } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import javax.swing.JOptionPane; public class DivisibleApp { public static void main(String[] args) { String texto=JOptionPane.showInputDialog("Introduce un numero"); //Pasamos el String a int int numero=Integer.parseInt(texto); //Comprobamos si es divisible entre 2, es decir, si el resto de la division es 0 if (numero%2==0){ System.out.println("El numero "+numero+" es divisible entre 2"); }else{ System.out.println("El numero "+numero+" no es divisible entre 2"); } } } |
7) Lee un número por teclado y muestra por consola, el carácter al que pertenece en la tabla ASCII. Por ejemplo: si introduzco un 97, me muestre una a.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
import javax.swing.JOptionPane; public class CodigoASCIIApp { public static void main(String[] args) { String texto=JOptionPane.showInputDialog("Introduce un codigo de la tabla ASCII"); //Pasamos el String a int int codigo=Integer.parseInt(texto); //Pasamos el codigo a caracter char caracter=(char)codigo; System.out.println(caracter); } } |
8) Modifica el ejercicio anterior, para que en lugar de pedir un número, pida un carácter (char) y muestre su código en la tabla ASCII.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import java.util.Scanner; public class CaracterASCIIApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un caracter ASCII"); char caracter = sc.next().charAt(0); //Pasamos el caracter a codigo int codigo = (int) caracter; System.out.println(codigo); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import javax.swing.JOptionPane; public class CaracterASCIIApp { public static void main(String[] args) { String texto=JOptionPane.showInputDialog("Introduce un caracter ASCII"); //Pasamos el String a char con el metodo charAt char caracter=texto.charAt(0); //Pasamos el caracter a codigo int codigo=(int)caracter; System.out.println(codigo); } } |
9) Lee un número por teclado que pida el precio de un producto (puede tener decimales) y calcule el precio final con IVA. El IVA sera una constante que sera del 21%.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
import java.util.Scanner; public class PrecioProductoApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un caracter ASCII"); char caracter = sc.next().charAt(0); //Pasamos el caracter a codigo int codigo = (int) caracter; System.out.println(codigo); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import javax.swing.JOptionPane; public class PrecioProductoApp { public static void main(String[] args) { //Declaramos una constante final double IVA=0.21; String texto=JOptionPane.showInputDialog("Introduce el precio de un producto"); //Pasamos el String a double double precio=Double.parseDouble(texto); //Obtenemos el precio final (precio+(precio*IVA)) double precioFinal=precio+(precio*IVA); System.out.println(precioFinal); } } |
10) Muestra los números del 1 al 100 (ambos incluidos). Usa un bucle while.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
public class MuestraNumWhileApp { public static void main(String[] args) { int num=1; //Definimos el bucle, incluye el 100 while (num<=100){ System.out.println(num); //Incrementamos num num++; } } } |
11) Haz el mismo ejercicio anterior con un bucle for.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 |
public class MuestraNumForApp { public static void main(String[] args) { //Definimos el bucle, incluye el 100 for (int num=1;num<=100;num++){ System.out.println(num); } } } |
12) Muestra los números del 1 al 100 (ambos incluidos) divisibles entre 2 y 3. Utiliza el bucle que desees.
Spoiler
— Con While
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 |
public class DivisiblesWhileApp { public static void main(String[] args) { int num=1; //Definimos el bucle, incluye el 100 while (num<=100){ if (num%2==0 || num%3==0){ System.out.println(num); } //Incrementamos num num++; } } } |
— Con For
|
1 2 3 4 5 6 7 8 9 10 11 12 13 |
public class DivisiblesForApp { public static void main(String[] args) { //Definimos el bucle, incluye el 100 for (int num=1;num<=100;num++){ //Comprobamos si es divisible entre 2 o 3 if (num%2==0 || num%3==0){ System.out.println(num); } } } } |
13) Realiza una aplicación que nos pida un número de ventas a introducir, después nos pedirá tantas ventas por teclado como número de ventas se hayan indicado. Al final mostrara la suma de todas las ventas. Piensa que es lo que se repite y lo que no.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
import java.util.Scanner; public class VentasApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce el número de ventas"); int numVentas=sc.nextInt(); /*Declaramos una variable para sumar las ventas, * si lo declaramos dentro del bucle, no podriamos * acceder fuera del bucle a la suma de las ventas. * Esto es por el ámbito. */ int sumaVentas=0; for (int i=0;i<numVentas;i++){ //indico el numero de venta System.out.println("Introduce el precio de la venta "+(i+1)); int venta=sc.nextInt(); //Acumulamos el valor de la venta sumaVentas=sumaVentas+venta; } System.out.println(sumaVentas); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
import javax.swing.JOptionPane; public class VentasApp { public static void main(String[] args) { String texto=JOptionPane.showInputDialog("Introduce el número de ventas"); //Pasamos el String a int int numVentas=Integer.parseInt(texto); /*Declaramos una variable para sumar las ventas, * si lo declaramos dentro del bucle, no podriamos * acceder fuera del bucle a la suma de las ventas. * Esto es por el ámbito. */ int sumaVentas=0; for (int i=0;i<numVentas;i++){ //indico el numero de venta texto=JOptionPane.showInputDialog("Introduce el precio de la venta"+(i+1)); int venta=Integer.parseInt(texto); //Acumulamos el valor de la venta sumaVentas=sumaVentas+venta; } System.out.println(sumaVentas); } } |
14) Realiza una aplicación que nos calcule una ecuación de segundo grado. Debes pedir las variables a, b y c por teclado y comprobar antes que el discriminante (operación en la raíz cuadrada). Para la raíz cuadrada usa el método sqlrt de Math. Te recomiendo que uses mensajes de traza.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
import java.util.Scanner; public class Ecuacion2GradoApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce el valor de a"); int a=sc.nextInt(); System.out.println("Introduce el valor de b"); int b=sc.nextInt(); System.out.println("Introduce el valor de c"); int c=sc.nextInt(); double discriminante=Math.pow(b, 2)-(4*a*c); //Mensaje de traza System.out.println(">>"+discriminante); if (discriminante>0){ //Tambien se puede hacer por parte si lo ves más facil //recuerda que debes tener en cuenta la prioridad de elementos double x1=((b*(-1))+Math.sqrt(discriminante))/(2*a); double x2=((b*(-1))-Math.sqrt(discriminante))/(2*a); System.out.println("El valor de x1 es "+x1+" y el valor de x2 es "+x2); }else{ System.out.println("El discriminante es negativo"); } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import javax.swing.JOptionPane; public class Ecuacion2GradoApp { public static void main(String[] args) { String textoA=JOptionPane.showInputDialog("Introduce el valor de a"); int a=Integer.parseInt(textoA); String textoB=JOptionPane.showInputDialog("Introduce el valor de b"); int b=Integer.parseInt(textoB); String textoC=JOptionPane.showInputDialog("Introduce el valor de c"); int c=Integer.parseInt(textoC); double discriminante=Math.pow(b, 2)-(4*a*c); //Mensaje de traza System.out.println(">>"+discriminante); if (discriminante>0){ //Tambien se puede hacer por parte si lo ves más facil //recuerda que debes tener en cuenta la prioridad de elementos double x1=((b*(-1))+Math.sqrt(discriminante))/(2*a); double x2=((b*(-1))-Math.sqrt(discriminante))/(2*a); System.out.println("El valor de x1 es "+x1+" y el valor de x2 es "+x2); }else{ System.out.println("El discriminante es negativo"); } } } |
15) Lee un número por teclado y comprueba que este numero es mayor o igual que cero, si no lo es lo volverá a pedir (do while), después muestra ese número por consola.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import java.util.Scanner; public class Ejercicio_DiscoDurodeRoer_Basicos_15_Scanner { public static void main(String[] args) { /* Declaramos la varible ya que sino no podemos usarla * en el while por el tema de ámbito */ int codigo; Scanner sc = new Scanner(System.in); do{ System.out.println("Introduce un numero mayor que 0"); codigo=sc.nextInt(); }while(codigo<=0); System.out.println(codigo); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import javax.swing.JOptionPane; public class ComprobacionApp { public static void main(String[] args) { /* Declaramos la varible ya que sino no podemos usarla * en el while por el tema de ámbito */ int codigo; do{ String texto=JOptionPane.showInputDialog("Introduce un numero mayor que 0"); codigo=Integer.parseInt(texto); }while(codigo<=0); System.out.println(codigo); } } |
16) Escribe una aplicación con un String que contenga una contraseña cualquiera. Después se te pedirá que introduzcas la contraseña, con 3 intentos. Cuando aciertes ya no pedirá mas la contraseña y mostrara un mensaje diciendo «Enhorabuena». Piensa bien en la condición de salida (3 intentos y si acierta sale, aunque le queden intentos).
Spoiler
—Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import java.util.Scanner; public class ContraseñaApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); String contraseña="eureka"; final int INTENTOS = 3; //Esta variable booleana, nos controlara que en caso de que acierte la condicion cambie boolean acierto=false; String password; for (int i=0;i<INTENTOS && !acierto;i++){ System.out.println("Introduce una contraseña"); password = sc.next(); //Comprobamos si coincide, no usamos ==, usamos el metodo equals if (password.equals(contraseña)){ System.out.println("Enhorabuena, acertaste"); acierto=true; } } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import javax.swing.JOptionPane; public class ContraseñaApp { public static void main(String[] args) { String contraseña="eureka"; final int INTENTOS = 3; //Esta variable booleana, nos controlara que en caso de que acierte la condicion cambie boolean acierto=false; String password; for (int i=0;i<3 && !acierto;i++){ password=JOptionPane.showInputDialog("Introduce una contraseña"); //Comprobamos si coincide, no usamos ==, usamos el metodo equals if (password.equals(contraseña)){ System.out.println("Enhorabuena, acertaste"); acierto=true; } } } } |
17) Crea una aplicación que nos pida un día de la semana y que nos diga si es un dia laboral o no. Usa un switch para ello.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import java.util.Scanner; public class DiaApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un dia de la semana"); String dia = sc.next(); switch(dia){ case "lunes": case "martes": case "miercoles": case "jueves": case "viernes": System.out.println("Es un dia laboral"); break; case "sabado": case "domingo": System.out.println("Es un dia festivo"); default: System.out.println("Introduce un dia de la semana"); } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import javax.swing.JOptionPane; public class DiaApp { public static void main(String[] args) { String dia=JOptionPane.showInputDialog("Introduce un dia de la semana"); switch(dia){ case "lunes": case "martes": case "miercoles": case "jueves": case "viernes": System.out.println("Es un dia laboral"); break; case "sabado": case "domingo": System.out.println("Es un dia festivo"); default: System.out.println("Introduce un dia de la semana"); } } } |
18) Pide por teclado dos número y genera 10 números aleatorios entre esos números. Usa el método Math.random para generar un número entero aleatorio (recuerda el casting de double a int).
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
import java.util.Scanner; public class GeneraNumApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce el primero numero"); int num1=sc.nextInt(); System.out.println("Introduce el segundo numero"); int num2=sc.nextInt(); for (int i=0;i<10;i++){ //Generamos un numero aleatorio int numAleatorio=(int)Math.floor(Math.random()*(num1-num2)+num2); System.out.println(numAleatorio); } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 |
import javax.swing.JOptionPane; public class GeneraNumApp { public static void main(String[] args) { String texto1=JOptionPane.showInputDialog("Introduce el primero numero"); int num1=Integer.parseInt(texto1); String texto2=JOptionPane.showInputDialog("Introduce el segundo numero"); int num2=Integer.parseInt(texto2); for (int i=0;i<10;i++){ //Generamos un numero aleatorio int numAleatorio=(int)Math.floor(Math.random()*(num1-num2)+num2); System.out.println(numAleatorio); } } } |
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 |
import java.util.Scanner; public class CuentaCifrasApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int numero=0; do{ System.out.println("Introduce un numero"); numero=sc.nextInt(); }while(numero<0); int contador=0; for (int i=numero;i>0;i/=10){ //Incrementamos el contador contador++; } //Controlamos en el caso de que haya una cifra o mas if (contador==1){ System.out.println("El numero "+numero+ " tiene "+contador+" cifra"); }else{ System.out.println("El numero "+numero+ " tiene "+contador+" cifras"); } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import javax.swing.JOptionPane; public class CuentaCifrasApp { public static void main(String[] args) { int numero=0; do{ String texto=JOptionPane.showInputDialog("Introduce un numero"); numero=Integer.parseInt(texto); }while(numero<0); int contador=0; for (int i=numero;i>0;i/=10){ //Incrementamos el contador contador++; } //Controlamos en el caso de que haya una cifra o mas if (contador==1){ System.out.println("El numero "+numero+ " tiene "+contador+" cifra"); }else{ System.out.println("El numero "+numero+ " tiene "+contador+" cifras"); } } } |
20) Pide un número por teclado e indica si es un número primo o no. Un número primo es aquel solo puede dividirse entre 1 y si mismo. Por ejemplo: 25 no es primo, ya que 25 es divisible entre 5, sin embargo, 17 si es primo.
Un buen truco para calcular la raíz cuadrada del numero e ir comprobando que si es divisible desde ese numero hasta 1.
NOTA: Si se introduce un numero menor o igual que 1, directamente es no primo.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
import java.util.Scanner; public class PrimoApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); System.out.println("Introduce un numero"); int numero = sc.nextInt(); //Un numero negativo, el 0 y el 1, son directamente no primos. if (numero <= 1) { System.out.println("El numero " + numero + " no es primo"); } else { //Hacemos un casting para que nos devuelva un numero entero int raiz = (int) Math.sqrt(numero); int contador = 0; //Contamos el numero de divisibles for (int i = raiz; i > 1; i--) { if (numero % i == 0) { contador++; } } /*Segun el numero de divisibles, sabemos si es primo o no * Si es primo el contador sera 0 */ //Mensaje de traza System.out.println(">>" + contador); if (contador < 1) { System.out.println("El numero " + numero + " es primo"); } else { System.out.println("El numero " + numero + " no es primo"); } } } } |
— Version con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 |
import javax.swing.JOptionPane; public class Ejercicio_DiscoDurodeRoer_Basicos_20 { public static void main(String[] args) { String texto = JOptionPane.showInputDialog("Introduce un numero"); int numero = Integer.parseInt(texto); //Un numero negativo, el 0 y el 1, son directamente no primos. if (numero <= 1) { System.out.println("El numero " + numero + " no es primo"); } else { //Hacemos un casting para que nos devuelva un numero entero int raiz = (int) Math.sqrt(numero); int contador = 0; //Contamos el numero de divisibles for (int i = raiz; i > 1; i--) { if (numero % i == 0) { contador++; } } /*Segun el numero de divisibles, sabemos si es primo o no * Si es primo el contador sera 0 */ //Mensaje de traza System.out.println(">>" + contador); if (contador < 1) { System.out.println("El numero " + numero + " es primo"); } else { System.out.println("El numero " + numero + " no es primo"); } } } } |
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
import java.util.Scanner; public class MuestraPrimosApp { public static void main(String[] args) { for (int i=1;i<=100;i++){ //Hacemos un casting para que nos devuelva un numero entero int raiz=(int)Math.sqrt(i); int contador=0; //Hacemos otro bucle para contar los divisibles for (int j=raiz;j>1;j--){ if (i%j==0){ contador++; } } /*Segun el numero de divisibles, sabemos si es primo o no * Si es primo el contador sera 0 */ if (contador<1){ System.out.println(i); } } } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 |
public class MuestraPrimosApp { public static void main(String[] args) { for (int i=1;i<=100;i++){ //Hacemos un casting para que nos devuelva un numero entero int raiz=(int)Math.sqrt(i); int contador=0; //Hacemos otro bucle para contar los divisibles for (int j=raiz;j>1;j--){ if (i%j==0){ contador++; } } /*Segun el numero de divisibles, sabemos si es primo o no * Si es primo el contador sera 0 */ if (contador<1){ JOptionPane.showMessageDialog(null, "El numero "+i+" es primo", "Primo", JOptionPane.INFORMATION_MESSAGE); } } } } |
22) Del siguiente String «La lluvia en Sevilla es una maravilla» cuenta cuantas vocales hay en total (recorre el String con charAt).
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 |
public class Principal { public static void main(String[] args) { String cadena="La lluvia en Sevilla es una maravilla"; int contador=0; for (int i=0;i<cadena.length();i++){ //Comprobamos si el caracter es una vocal if(cadena.charAt(i)=='a' || cadena.charAt(i)=='e' || cadena.charAt(i)=='i' || cadena.charAt(i)=='o' || cadena.charAt(i)=='u'){ contador++; } } System.out.println("Hay "+contador+" vocales"); } } |
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 |
public class CambioLetrasApp { public static void main(String[] args) { String cadena="La lluvia en Sevilla es una maravilla"; //Aviso, de esta forma no modifica el String original System.out.print(cadena.replace('a', 'e')); } } |
24) Recorre el String del ejercicio 22 y transforma cada carácter a su código ASCII. Muestralos en linea recta, separados por un espacio entre cada carácter.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 |
public class ListaCaracteresApp { public static void main(String[] args) { String cadena="La lluvia en Sevilla es una maravilla"; for (int i=0;i<cadena.length();i++){ //Hacemos un casting para convertir el char a int System.out.print((int)cadena.charAt(i)+" "); } } } |
Los signos aritméticos disponibles son:
- +: suma los dos operandos.
- -: resta los operandos.
- *: multiplica los operandos.
- /: divide los operandos, este debe dar un resultado con decimales (double)
- ^: 1º operando como base y 2º como exponente.
- %: módulo, resto de la división entre operando1 y operando2.
Spoiler
— Versión con Scanner
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 |
import java.util.Locale; import java.util.Scanner; public class CalculadoraPolacaInversaApp { public static void main(String[] args) { Scanner sc = new Scanner(System.in); sc.useLocale(Locale.US); //no importa que sean int o double double operando1; double operando2; double resultado=0; //Nos pide los operandos y el signo de operacion System.out.println("Escribe el operando 1"); operando1=sc.nextDouble(); System.out.println("Escribe el codigo de operacion"); String operacion = sc.next(); System.out.println("Escribe el operando 2"); operando2=sc.nextDouble(); //segun el codigo de operacion, haremos una u otra accion switch (operacion){ case "+": resultado=operando1+operando2; break; case "-": resultado=operando1-operando2; break; case "*": resultado=operando1*operando2; break; case "/": resultado=operando1/operando2; break; case "^": resultado=(int)Math.pow(operando1, operando2); break; case "%": resultado=operando1%operando2; break; } System.out.println( operando1+" "+operacion+" "+operando2+" = "+resultado); } } |
— Versión con JOptionPane
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 |
import javax.swing.JOptionPane; public class CalculadoraPolacaInversaApp { public static void main(String[] args) { //no importa que sean int o double double operando1; double operando2; double resultado=0; //Nos pide los operandos y el signo de operacion String texto=JOptionPane.showInputDialog("Escribe el operando 1"); operando1=Integer.parseInt(texto); String operacion=JOptionPane.showInputDialog("Escribe el codigo de operacion"); String texto2=JOptionPane.showInputDialog("Escribe el operando 2"); operando2=Integer.parseInt(texto2); //segun el codigo de operacion, haremos una u otra accion switch (operacion){ case "+": resultado=operando1+operando2; break; case "-": resultado=operando1-operando2; break; case "*": resultado=operando1*operando2; break; case "/": resultado=operando1/operando2; break; case "^": resultado=(int)Math.pow(operando1, operando2); break; case "%": resultado=operando1%operando2; break; } JOptionPane.showMessageDialog(null, operando1+" "+operacion+" "+operando2+" = "+resultado); } } |
26) Realizar la suma del 1 al numero que indiquemos, este debe ser mayor que 1.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import java.util.Scanner; public class Ejercicio_26 { public static void main(String[] args) { Scanner sn=new Scanner(System.in); System.out.println("Inserta un numero entero mayor que 1"); int num; do{ //Pedimos el primer número num=sn.nextInt(); if(num<=1){ System.out.println("Error. No has introducido un valor correcto." + "Vuelve a intentarlo"); } }while(!(num>=1)); //condición para salir int suma=0; //Realizamos la suma for(int contador=1;contador<=num;contador++){ suma+=contador; } System.out.println("La suma es: "+suma); } } |
27)
Crear una aplicación que nos permite insertar números hasta que insertemos un -1. Calcular el numero de números introducidos.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
import java.util.Scanner; public class Ejercicio_27 { public static void main(String[] args) { //Pedimos el numero Scanner sn=new Scanner(System.in); int num=sn.nextInt(); int contador=0; //Hasta que no se introduzca -1 no se sale while(num!=-1){ contador++; num=sn.nextInt(); //Pedimos de nuevo el número } System.out.println("Fin, se ha introducido "+contador+" numeros"); } } |
28) Eliminar los espacios de una frase pasada por consola por el usuario.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 |
import javax.swing.JOptionPane; public class Ejercicio_basicos_DDR_28 { public static void main(String[] args) { String texto=JOptionPane.showInputDialog(null, "Inserta una frase", "Inserción", JOptionPane.INFORMATION_MESSAGE); //usado para almacenar el texto final String texto_sin_espacios=""; char caracterActual; //recorro el array for(int i=0;i<texto.length();i++){ caracterActual=texto.charAt(i); //Cuando es un espacio no lo copia a la cadena if(caracterActual!=' '){ texto_sin_espacios+=String.valueOf(caracterActual); } } JOptionPane.showMessageDialog(null, "La frase tiene sin espacios es "+texto_sin_espacios, "Resultado", JOptionPane.INFORMATION_MESSAGE); } } |
29) Pedir al usuario que nos escriba frases de forma infinita hasta que insertemos una cadena vacia. Mostrar la cadena resultante
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 |
import javax.swing.JOptionPane; public class Ejercicio_basicos_DDR_29 { public static void main(String[] args) { String texto=JOptionPane.showInputDialog(null, "Introduce un texto, cadena vacia para terminar", "Introducir texto", JOptionPane.INFORMATION_MESSAGE); String cadenaResultante=""; //Mientras no este vacio la cadena escrita continuo while(!texto.isEmpty()){ //Concatenamos el texto cadenaResultante+=texto; //Reintroducimos de nuevo una cadena texto=JOptionPane.showInputDialog(null, "Introduce un texto, cadena vacia para terminar", "Introducir texto", JOptionPane.INFORMATION_MESSAGE); } JOptionPane.showMessageDialog(null, cadenaResultante, "Resultado", JOptionPane.INFORMATION_MESSAGE); } } |
30)
Convertir una frase a mayúsculas o minúsculas, que daremos opción a que el usuario lo pida y mostraremos el resultado por pantalla.
Spoiler
— Version 1
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 |
import javax.swing.JOptionPane; public class Ejercicio_basicos_DDR_30_v1 { public static void main(String[] args) { String texto=JOptionPane.showInputDialog(null, "Por favor, introduce una frase", "Introducción", JOptionPane.INFORMATION_MESSAGE); String cadenaResultante=""; //true = Lo pasamos todo a mayusculas //false= Lo pasamos todo a minusculas boolean isMayus; final int DIFERENCIA=32; String[] opciones={"Mayusculas", "Minusculas"}; int eleccion=JOptionPane.showOptionDialog(null, "Elige tu opcion", "Eleccion", JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE, null, opciones, opciones[0]); isMayus= (eleccion==JOptionPane.YES_OPTION); char caracterActual; for(int i=0;i<texto.length();i++){ //obtenemos el caracter de la pos i caracterActual=texto.charAt(i); if(isMayus){ //Si esta entre esos valores, lo cambia a mayucula // Puedes sustituir 97 por 'a' y asi con todos if(caracterActual>=97 && caracterActual<=122){ cadenaResultante+=(char)(caracterActual-DIFERENCIA); }else{ //Si no es un caracter alfabetico en minuscula, lo agregamos // sin hacerle nada cadenaResultante+=caracterActual; } }else{ //Si esta entre esos valores, lo cambia a minuscula // Puedes sustituir 65 por 'A' y asi con todos if(caracterActual>=65 && caracterActual<=90){ cadenaResultante+=(char)(caracterActual+DIFERENCIA); }else{ //Si no es un caracter alfabetico en minuscula, lo agregamos // sin hacerle nada cadenaResultante+=caracterActual; } } } //Mostramos la cadena resultante JOptionPane.showMessageDialog(null, cadenaResultante, "Resultado", JOptionPane.INFORMATION_MESSAGE); } } |
— Version 2
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 |
import javax.swing.JOptionPane; /** *Ejercicio 30 version 2 Básicos * @author Discoduroderoer */ public class Ejercicio_basicos_DDR_30_v2 { public static void main(String[] args) { String texto=JOptionPane.showInputDialog(null, "Por favor, introduce una frase", "Introducción", JOptionPane.INFORMATION_MESSAGE); String cadenaResultante; //true = Lo pasamos todo a mayusculas //false= Lo pasamos todo a minusculas boolean isMayus; int eleccion=JOptionPane.showConfirmDialog(null, "¿Quieres que se pase a mayusculas?", "Eleccion", JOptionPane.YES_NO_OPTION); isMayus= (eleccion==JOptionPane.YES_OPTION); //Segun lo elegido, lo transformaremos a mayuscula o minuscula if(isMayus){ cadenaResultante=texto.toUpperCase(); }else{ cadenaResultante=texto.toLowerCase(); } //Mostramos el mensaje resultante JOptionPane.showMessageDialog(null, cadenaResultante, "Resultado", JOptionPane.INFORMATION_MESSAGE); } } |
31) Mostrar la longitud de una cadena.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 |
public class Ejercicio_basicos_DDR_31 { public static void main(String[] args) { String cadena="Hola mundo"; System.out.println("La cadena tiene "+cadena.length()+" caracteres"); } } |
32) Pedir dos palabras por teclado, indicar si son iguales.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_32 { public static void main(String[] args) { //Creamos un scanner para leer Scanner sn = new Scanner(System.in); //Pedimos las palabras System.out.println("Escribe la palabra 1"); String palabra1 = sn.next(); System.out.println("Escribe la palabra 2"); String palabra2 = sn.next(); //Comparamos con el método equals //Con equalsIgnoreCase, no considera las mayusculas if(palabra1.equals(palabra2)){ System.out.println("Las palabras son iguales"); }else{ System.out.println("Las palabras no son iguales"); } } |
33) Dada una cadena, extraer la cuarta y quinta letra usando el método substring.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class Ejercicio_basicos_DDR_33 { public static void main(String[] args) { String cadena= "Hola mundo"; //CUIDADO: es 3 porque empieza en 0 las cadenas(cuarta letra) //el 5 es porque siempre hay que sumarle uno, ya que sino no mostraria lo que deseamos (quinta letra) String subcadena = cadena.substring(3, 5); System.out.println(subcadena); } } |
34)
Dada una frase, separarlo en palabras.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_18 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); //Hace que podamos escribir espacios en la frase y coja todo el String sn.useDelimiter("\n"); System.out.println("Escribe una frase"); String frase=sn.next(); //Divido la frase en palabras String palabras[] = frase.split(" "); for(int i=0;i<palabras.length;i++){ System.out.println(palabras[i]); } } } |
35) Crea un enum con los días de la semana, pide un día de la semana e indica si es laboral o no (en el main).
Spoiler
— Dia de la semana
|
1 2 3 4 5 6 7 8 9 10 |
public enum DiasSemana { LUNES, MARTES, MIERCOLES, JUEVES, VIERNES, SABADO, DOMINGO; } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_35 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); System.out.println("Escribe un dia de la semana"); String dia = sn.next(); DiasSemana diaS = DiasSemana.valueOf(dia.toUpperCase()); switch(diaS){ case LUNES: case MARTES: case MIERCOLES: case JUEVES: case VIERNES: System.out.println("El dia "+diaS.name().toLowerCase()+" es laborable"); break; case SABADO: case DOMINGO: System.out.println("El dia "+diaS+" no es laborable"); break; } } } |
36) Modifica el anterior enum para indicar que es día laborable directamente (usar toString).
Spoiler
— DiaSemana
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 |
public enum DiasSemana { LUNES(true), MARTES(true), MIERCOLES(true), JUEVES(true), VIERNES(true), SABADO(false), DOMINGO(false); private boolean laborable; private DiasSemana(boolean laborable){ this.laborable = laborable; } @Override public String toString() { if(laborable){ return "El dia "+ this.name().toLowerCase() +" es laborable"; }else{ return "El dia "+ this.name().toLowerCase() +" no es laborable"; } } } |
— Main
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_36 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); System.out.println("Escribe un dia de la semana"); String dia = sn.next(); DiasSemana diaS = DiasSemana.valueOf(dia.toUpperCase()); System.out.println(diaS.toString()); } } |
37) Crea el enum Mes, que contenga como parametros el orden(1,2,3,etc) y el numero de dias (febrero tendra 28 dias siempre).
Estos datos pueden pedirse por separado, asi que tienes que hacer sus respectivos get. No son necesarios los setters.
Create un arrays de Mes (mirate la funcion values), pide un numero por teclado e indica que meses tienen ese numero de dias (toda su informacion).
Por ejemplo, si escribes un 28, este te devolvera la informacion de FEBRERO.
Spoiler
— Mes
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 |
public enum Mes { ENERO(1,31), FEBRERO(2,28), MARZO(3,31), ABRIL(4,30), MAYO(5,31), JUNIO(6,30), JULIO(7,31), AGOSTO(8,31), SEPTIEMBRE(9,30), OCTUBRE(10,31), NOVIEMBRE(11,30), DICIEMBRE(12,31); private int orden; private int numDias; private Mes(int orden, int numDias){ this.orden=orden; this.numDias=numDias; } public int getOrden() { return orden; } public int getNumDias() { return numDias; } @Override public String toString() { return "El mes "+this.name().toLowerCase()+" es el mes "+orden+"º y tiene "+numDias+" dias"; } } |
— Principal
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_24 { public static void main(String[] args) { Scanner sn = new Scanner(System.in); Mes[] meses = Mes.values(); System.out.println("Escribe un numero de dias"); int dias = sn.nextInt(); for(int i=0;i<meses.length;i++){ if(meses[i].getNumDias()==dias){ System.out.println(meses[i].toString()); } } } |
38) Pedir números al usuario y cuando el usuario meta un -1 se terminará el programa.
Al terminar, mostrará lo siguiente:
– mayor numero introducido
– menor numero introducido
– suma de todos los numeros
– suma de los numeros positivos
– suma de los numeros negativos
– media de la suma (la primera que pido)
El número -1 no contara como número.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 |
import java.util.Scanner; public class Ejercicio_basicos_DDR_25 { public static void main(String[] args) { //Variables necesarias int numeroUsuario=0; int menor=0; int mayor=0; int suma=0; double media; int contador=-1; int sumaPositivos=0; int sumaNegativos=0; //Creamos el Scanner Scanner sn = new Scanner(System.in); do{ //Comprobamos si el numero es menor //que el actual menor if(menor>numeroUsuario){ menor = numeroUsuario; } //Comprobamos si el numero es mayor //que el actual mayor if(mayor<numeroUsuario){ mayor=numeroUsuario; } //Suma el numero y lo acumulamos suma+=numeroUsuario; //Si el numero es positivo, suma a la variable de los positivos // y sino a la de los negativos if(numeroUsuario>=0){ sumaPositivos+=numeroUsuario; }else{ sumaNegativos+=numeroUsuario; } //aumento el contador contador++; //pido un numero al usuario System.out.println("Introduce un numero"); numeroUsuario = sn.nextInt(); //Cuando el usuario ponga un -1, saldremos //Se puede usar un while normal }while(numeroUsuario!=-1); //Calculamos la media media = (double) suma / contador; //Mostramos los valores System.out.println("El menor es: "+menor); System.out.println("El mayor es: "+mayor); System.out.println("La suma es: "+suma); System.out.println("La suma de los positivos es: "+sumaPositivos); System.out.println("La suma de los negativos es: "+sumaNegativos); System.out.println("La media es: "+media); } } |
39)
Realiza un reloj digital que muestre la hora sin parar.
Debe esperar un segundo real para darle mas realismo.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 |
public class Ejercicio_basicos_DDR_26 { public static void main(String[] args) throws InterruptedException { //Variables int horas = 0, minutos = 0, segundos = 0; while (true) { //Mostrar //Si es menor que 10, escribimos un cero delante if (horas < 10) { System.out.print("0"); } System.out.print(horas + ":"); if (minutos < 10) { System.out.print("0"); } System.out.print(minutos + ":"); if (segundos < 10) { System.out.print("0"); } //salto de linea System.out.println(segundos); //Aumentar el tiempo segundos++; //Comprobar el tiempo if (segundos == 60) { //reinicio los segundos segundos = 0; //aumento los minutos minutos++; if (minutos == 60) { //Reinicio los minutos minutos = 0; //Aumento las horas horas++; if (horas == 24) { //Reinicio las horas horas = 0; } } } Thread.sleep(1000); } } } |
También os dejamos videos de nuestro canal de YouTube para que veais como se hace paso a paso.
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Como puedo encontrar la posición de varios números en un array en java;
digamos que tengo un arreglo de N elementos y al introducir un numero x me tenga que mostrar la posicion que ocupa ese numero en el arreglo y si el numero x que introduje esta varias veces en el arreglo me muestre todas las posiciones en las que esta.
alguien sabe como plantearlo ??
1. Se pretende realizar una aplicación para esta facultad que gestione la
información sobre las personas vinculadas con la misma, que se pueden
clasificar en tres tipos: estudiantes, profesores y personal de servicio.
A continuación, se detalla qué tipo de información debe gestionar esta
aplicación:
• Por cada persona, se debe conocer, al menos, su nombre y apellidos, su
número de identificación y su estado civil.
• Con respecto a los empleados, sean del tipo que sean, hay que saber su
año de incorporación a la facultad y qué número de despacho tienen
asignado.
• En cuanto a los estudiantes, se requiere almacenar el curso en el que
están matriculados.
• Por lo que se refiere a los profesores, es necesario gestionar a qué
departamento pertenecen (lenguajes, matemáticas, arquitectura, …).
• Sobre el personal de servicio, hay que conocer a qué sección están
asignados (biblioteca, decanato, secretaría, …).
El ejercicio consiste, en primer lugar, en definir la jerarquía de clases de esta
aplicación. A continuación, debe programar las clases definidas en las que,
además de los constructores, hay que desarrollar los métodos correspondientes a
las siguientes acciones:
• Cambio del estado civil de una persona.
• Reasignación de despacho a un empleado.
• Matriculación de un estudiante en un nuevo curso.
• Cambio de departamento de un profesor.
• Traslado de sección de un empleado del personal de servicio.
• Imprimir toda la información de cada tipo de individuo.
Incluya un programa de prueba que instancie objetos de los distintos tipos y
pruebe los métodos desarrollados.
1.De un número indeterminado de personas se pide leer su estatura; el número de personas
será introducido por el usuario y debe controlarse que sea un entero positivo. De acuerdo
con ese número de personas y sus estaturas calcular lo siguiente:
a. La estatura promedio.
b. Calcular cuántas personas tienen una estatura superior al promedio
c. Calcular cuántas personas tienen una estatura inferior al promedio.
d. Mostrar cuál es la estatura máxima.
e. Mostrar cuál es la estatura mínima.
2. Se pide construir una clase con el nombre ClaseAlumnos, dicha clase tendrá como atributos
los siguientes:
DocIdentidad→ tipo integer
NomAlumno→ Tipo string
Materia→ Tipo String
Notas→ tipo Double
En dicha clase, se deben definir unos métodos de la siguiente forma:
a) Un método que permita capturar los datos de los estudiantes con sus materias y notas
b) Un método que de acuerdo con el alumno que se envíe como parámetro
(DocIdentidad), devuelva las materias que tiene asignadas y las notas correspondientes.
c) Un método que calcule el promedio total de cada estudiante de acuerdo con el número
de materias que tiene ingresadas.
En el programa principal, debe aparecer un menú con las siguientes opciones:
• Ingreso de información: Esta opción captura por teclado la información y llena
el vector definido como tipo Objeto con la información relacionada en
ClaseAlumnos.
• Consulta Materias por Alumno: En esta opción se envía como parámetro
un documento que se ingrese por pantalla y busca en el vector creado si
existe datos para ese documento. En caso afirmativo devuelve los datos
de las materias y notas correspondientes y en caso de que no existe
muestra el mensaje “Alumno no existe”.
• Consulte Promedio de estudiantes: Al seleccionar esta opción se deberá
mostrar por pantalla los alumnos con su promedio (no se muestran las
materias)
3. Crear dos matrices de 2×2 y llenarla con valores ingresados por teclado. Una vez las
matrices estén llenas, debe de mostrarse una tercera matriz cuyos datos será la suma de las
posiciones iguales de las matrices anteriores. Se debe mostrar por pantalla las 3 matrices.
Ejemplo
Matriz 1 Matriz 2 Matriz Resultado
2 1 3 4 5 5
3 4 6 5 9 9
4.Crear un programa que pida por pantalla cuatro ciudades y a continuación tres
municipios de cada una de estas ciudades. Los nombres de ciudades y municipios deben
almacenarse en un array multidimensional. Luego de ingresarlos por pantalla se deberá
mostrar por pantalla el arreglo lleno. Ejemplo de lo que se debe visualizar:
[MEDELLÍN-ENVIGADO, MEDELLÍN-SABANETA, MEDELLÍN-CALDAS]
[CALI-BUENAVENTURA, CALI-BUGA, CALI-ANDALUCÍA]
[BARRANQUILLA-MALAMBO, BARRANQUILLA-BARANOA, BARRANQUILLA-GALAPA]
5. Crear un programa donde se defina una matriz de 8×6 e imprima por pantalla la matriz
rellena de “*” en su marco exterior y “x” en parte interior
1.De un número indeterminado de personas se pide leer su estatura; el número de personas
será introducido por el usuario y debe controlarse que sea un entero positivo. De acuerdo
con ese número de personas y sus estaturas calcular lo siguiente:
a. La estatura promedio.
b. Calcular cuántas personas tienen una estatura superior al promedio
c. Calcular cuántas personas tienen una estatura inferior al promedio.
d. Mostrar cuál es la estatura máxima.
e. Mostrar cuál es la estatura mínima.
2. Se pide construir una clase con el nombre ClaseAlumnos, dicha clase tendrá como atributos
los siguientes:
DocIdentidad→ tipo integer
NomAlumno→ Tipo string
Materia→ Tipo String
Notas→ tipo Double
En dicha clase, se deben definir unos métodos de la siguiente forma:
a) Un método que permita capturar los datos de los estudiantes con sus materias y notas
b) Un método que de acuerdo con el alumno que se envíe como parámetro
(DocIdentidad), devuelva las materias que tiene asignadas y las notas correspondientes.
c) Un método que calcule el promedio total de cada estudiante de acuerdo con el número
de materias que tiene ingresadas.
En el programa principal, debe aparecer un menú con las siguientes opciones:
• Ingreso de información: Esta opción captura por teclado la información y llena
el vector definido como tipo Objeto con la información relacionada en
ClaseAlumnos.
• Consulta Materias por Alumno: En esta opción se envía como parámetro
un documento que se ingrese por pantalla y busca en el vector creado si
existe datos para ese documento. En caso afirmativo devuelve los datos
de las materias y notas correspondientes y en caso de que no existe
muestra el mensaje “Alumno no existe”.
• Consulte Promedio de estudiantes: Al seleccionar esta opción se deberá
mostrar por pantalla los alumnos con su promedio (no se muestran las
materias)
3. Crear dos matrices de 2×2 y llenarla con valores ingresados por teclado. Una vez las
matrices estén llenas, debe de mostrarse una tercera matriz cuyos datos será la suma de las
posiciones iguales de las matrices anteriores. Se debe mostrar por pantalla las 3 matrices.
Ejemplo
Matriz 1 Matriz 2 Matriz Resultado
2 1 3 4 5 5
3 4 6 5 9 9
4.Crear un programa que pida por pantalla cuatro ciudades y a continuación tres
municipios de cada una de estas ciudades. Los nombres de ciudades y municipios deben
almacenarse en un array multidimensional. Luego de ingresarlos por pantalla se deberá
mostrar por pantalla el arreglo lleno. Ejemplo de lo que se debe visualizar:
[MEDELLÍN-ENVIGADO, MEDELLÍN-SABANETA, MEDELLÍN-CALDAS]
[CALI-BUENAVENTURA, CALI-BUGA, CALI-ANDALUCÍA]
[BARRANQUILLA-MALAMBO, BARRANQUILLA-BARANOA, BARRANQUILLA-GALAPA]
5. Crear un programa donde se defina una matriz de 8×6 e imprima por pantalla la matriz
rellena de “*” en su marco exterior y “x” en parte interior
Diseñe un programa que determine la categoría de un estudiante en base a su promedio, de acuerdo a la siguiente tabla:
Promedio
Categoría
20 – 17
16 – 14
13 – 12
11 – 0
A
B
C
D
COMO LO HAGO EN JAVA AYUDAAAA
Hacer un programa que ingrese números y muestre cuales de ellos son menores que 100 (con while), se terminará al ingresar un 999.
necesito ayuda con este programa se los agradecería.
El órgano judicial le solicita que usted desarrolle una aplicación que le permita contabilizar la cantidad de juicios ganados por los defensor de oficio de un juzgado, cada defensor tiene a la semana 5 juicios con el objetivo de bajar la mora judicial, cada juicio cuenta con 7 jurados de conciencia, el veredicto dado por cada jurado se encuentra almacenado en un arreglo llamado veredicto, en el mismo se encuentra la palabra SI si lo consideran culpable y NO si lo consideran inocente, cada jurado. Ahora considere los siguientes lineamientos para los procesos:
Determine cuál fue el veredicto, para determinar el veredicto el valor que obtenga el mayor puntaje gana, y debe decir inocente o culpable.
Guarde el veredicto obtenida en un arreglo llamado juicio.
Al final se quiere que indique de los juicios en los que participo el defensor cuantos gano.
Buenas tardes! tengo muchos ejercicios les pueden servir, he aquí un breve video : https://www.youtube.com/watch?v=KU6iV2DbEAE
He aquí videos de gran ayuda en JAVA : https://www.youtube.com/watch?v=JUYWxcC4y-Y
Espero y te gusten!
hola me pueden ayudar con esto soy principiante y me hago lio con las clases metodos como llamarlos desde otra clase me han dicho q use metodos para hacer mas simplificada las clases pero es q me hago un lio.
ayudenmen en esto
Objectius – Practicar funcionalitats bàsiques com variables, bucles i arrays.
Entrega Enviar la URL al repositori que conté la solució per Slack als mentors. S’ha d’entregar cada Fase per separat en un mateix repositori.
Temps 2 dies
Recursos Videos: Pildoras informaticas videos del 14 al 21 y 36 al 40 Texto: Introduccion C# y javascript (punto 2.2)
Exercici:
L’exercici consisteix en mostrar per consola diferents noms de ciutats partint d’un array i modificar els noms canviant lletres posant a proba la teva capacitat algoritmica.
FASE 1
● Crea sis variables tipu string buides.
● Demana per consola que s’introdueixin els noms.
● Introdueix els següents noms de ciutats (Barcelona, Madrid, Valencia, Malaga, Cadis, Santander) per teclat.
● Mostra per consola el nom de les 6 ciutats.
FASE 2
● Un cop tenim els noms de les ciutats guardats en variables haurem de pasar l’informacio a un array (arrayCiutats).
● Quan tinguem l’array ple, haurem de mostrar per consola el nom de les ciutats ordenadas per ordre alfabetic. [No utilitzis LINQ]
FASE 3
● Cambieu les vocals “a” dels noms de les ciutats per el numero 4 i guardeu els noms modificats en un nou array(ArrayCiutatsModificades).
● Mostreu per consola l’array modificat i ordenat per ordre alfabetic.
FASE 4
● Creeu un nou array per cada una de les ciutats que tenim. La mida dels nous arrays sera la llargada de cada string ( string nomCiutat.Length).
● Ompliu els nous arrays lletra per lletra.
● Mostreu per consola els nous arrays amb els noms invertits (Ex: Barcelona – anolecraB).