Hola a todos, hoy os dejo una serie de ejercicios de Java para practicar todo aquello que hemos explicado en anteriores posts, haciendo hincapié en los arrays de Java.
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. 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.
Te dejo nuestro curso java para las dudas:
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
1) Crea un array de 10 posiciones de números con valores pedidos por teclado. Muestra por consola el indice y el valor al que corresponde. Haz dos métodos, uno para rellenar valores y otro para mostrar.
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 |
import javax.swing.JOptionPane; public class arrayApp { public static void main(String[] args) { //Esto es opcional final int TAMANIO=10; int num[]=new int[TAMANIO]; //Invocamos las funciones rellenarArray(num); mostrarArray(num); } public static void rellenarArray(int lista[]){ for(int i=0;i<lista.length;i++){ String texto=JOptionPane.showInputDialog("Introduce un número"); lista[i]=Integer.parseInt(texto); } } public static void mostrarArray(int lista[]){ for(int i=0;i<lista.length;i++){ System.out.println("En el indice "+i+" esta el valor "+lista[i]); } } } |
2)
Crea un array de números donde le indicamos por teclado el tamaño del array, rellenaremos el array con números aleatorios entre 0 y 9, al final muestra por pantalla el valor de cada posición y la suma de todos los valores. Haz un método para rellenar el array (que tenga como parámetros los números entre los que tenga que generar), para mostrar el contenido y la suma del array y un método privado para generar número aleatorio (lo puedes usar para otros ejercicios).
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 |
import javax.swing.JOptionPane; public class arrayNumAleatoriosApp { public static void main(String[] args) { //Indicamos el tamaño String texto=JOptionPane.showInputDialog("Introduce un tamaño"); int num[]=new int[Integer.parseInt(texto)]; //Invocamos las funciones rellenarNumAleatorioArray(num, 0, 9); mostrarArray(num); } public static void rellenarNumAleatorioArray(int lista[], int a, int b){ for(int i=0;i<lista.length;i++){ //Generamos un número entre los parametros pasados lista[i]=((int)Math.floor(Math.random()*(a-b)+b)); } } public static void mostrarArray(int lista[]){ for(int i=0;i<lista.length;i++){ System.out.println("En el indice "+i+" esta el valor "+lista[i]); } } } |
3) Crea un array de números de un tamaño pasado por teclado, el array contendrá números aleatorios primos entre los números deseados, por último nos indica cual es el mayor de todos.
Haz un método para comprobar que el número aleatorio es primo, puedes hacer todos lo métodos que necesites.
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 70 71 72 73 |
import javax.swing.JOptionPane; public class Ejercicio_DiscoDurodeRoer_Arrays_3 { public static void main(String[] args) { //Indicamos el tamaño String texto=JOptionPane.showInputDialog("Introduce un tamaño"); int num[]=new int[Integer.parseInt(texto)]; //Invocamos las funciones rellenarNumPrimosAleatorioArray(num, 1, 100); mostrarArray(num); //Saco el primo mayor int primoMayor=mayor(num); System.out.println("El primo más grande es el "+primoMayor); } public static void rellenarNumPrimosAleatorioArray(int lista[], int a, int b){ int i=0; //Usamos mejor un while, ya que solo aumentara cuando genere un primo while(i<lista.length){ int num=((int)Math.floor(Math.random()*(a-b)+b)); if (esPrimo(num)){ lista[i]=num; i++; } } } private static boolean esPrimo (int num){ //Un numero negativo, el 0 y el 1, son directamente no primos. if (num<=1){ return false; }else{ //declaracion int prueba; int contador=0; //Hacemos la raiz cuadrada y lo usamos para dividir el numero original prueba=(int)Math.sqrt(num); //Bucle que cuenta los numeros divisibles, podemos hacerlo con while for (;prueba>1;prueba--){ if (num%prueba==0){ contador+=1; } } return contador < 1; } } public static void mostrarArray(int lista[]){ for(int i=0;i<lista.length;i++){ System.out.println("En el indice "+i+" esta el valor "+lista[i]); } } public static int mayor(int lista[]){ int mayor=0; for(int i=0;i<lista.length;i++){ if(lista[i]>mayor){ mayor=lista[i]; } } return mayor; } } |
4) Crea un array de números de 100 posiciones, que contendrá los números del 1 al 100. Obtén la suma de todos ellos y la media.
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 |
public class SumaMediaArrayApp { public static void main(String[] args) { //Creo un array int[] numeros=new int[100]; //Declaro las variables necesarias int suma=0; double media; //Recorro el array, asigno números y sumo for(int i=0;i<numeros.length;i++){ numeros[i]=i+1; suma+=numeros[i]; } //Calculo la media y muestro la suma y la meda System.out.println("La suma es "+suma); media=(double)suma/numeros.length; System.out.println("La media es "+media); } } |
5) Crea un array de caracteres que contenga de la ‘A’ a la ‘Z’ (solo las mayúsculas). Después, ve pidiendo posiciones del array por teclado y si la posicion es correcta, se añadira a una cadena que se mostrara al final, se dejará de insertar cuando se introduzca un -1.
Por ejemplo, si escribo los siguientes numeros
0 //Añadira la ‘A’
5 //Añadira la ‘F’
25 //Añadira la ‘Z’
50 //Error, inserte otro numero
-1 //fin
Cadena resultante: AFZ
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_DiscoDurodeRoer_Arrays_5 { public static void main(String[] args) { Scanner sc = new Scanner(System.in); char mayusculas[] = new char[26]; for (int i = 65, j = 0; i <= 90; i++, j++) { mayusculas[j] = (char) i; } String cadena = ""; int eleccion = -1; do { System.out.println("Elija un indice entre 0 y " + (mayusculas.length - 1)); eleccion = sc.nextInt(); if (!(eleccion >= 0 && eleccion <= mayusculas.length - 1)) { System.out.println("Error, inserte otro numero"); } else { if (eleccion != -1) { cadena += mayusculas[eleccion]; } } } while (eleccion != -1); System.out.println(cadena); } } |
6) Pide al usuario por teclado una frase y pasa sus caracteres a un array de caracteres. Puedes hacer con o sin métodos de String.
Spoiler
–Version 1: sin metodos de String
|
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 MuestraCaracteresApp { public static void main(String[] args) { Scanner sn=new Scanner(System.in); //Pido al usuario que escriba una frase System.out.println("Escriba una frase"); //Recomiendo usar nextLine en lugar de next por los espacios String frase=sn.nextLine(); //Creamos un array de caracteres char caracteres[]=new char[frase.length()]; //Recorremos la frase y cogemos cada caracter y lo metemos en el array for(int i=0;i<frase.length();i++){ caracteres[i]=frase.charAt(i); System.out.println(caracteres[i]); } } } |
–Version 2: con metodos String
|
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 MuestraCaracteresApp { public static void main(String[] args) { Scanner sn=new Scanner(System.in); //Pido al usuario que escriba una frase System.out.println("Escriba una frase"); //Recomiendo usar nextLine en lugar de next por los espacios String frase=sn.nextLine(); //Creamos un array de caracteres usando el metodo de String char caracteres[]=frase.toCharArray(); //Recorremos la frase y cogemos cada caracter y lo metemos en el array for(int i=0;i<frase.length();i++){ System.out.println(caracteres[i]); } } } |
7) Crea dos arrays de números con una posición pasado por teclado.
Uno de ellos estará rellenado con números aleatorios y el otro apuntara al array anterior, después crea un nuevo array con el primer array (usa de nuevo new con el primer array) con el mismo tamaño que se ha pasado por teclado, rellenalo de nuevo con números aleatorios.
Después, crea un método que tenga como parámetros, los dos arrays y devuelva uno nuevo con la multiplicación de la posición 0 del array1 con el del array2 y así sucesivamente. Por último, muestra el contenido de cada array.
Llama al final al recolector de basura.
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 |
import javax.swing.JOptionPane; public class MultiplicacionApp { public static void main(String[] args) { //Indicamos el tamaño String texto=JOptionPane.showInputDialog("Introduce un tamaño"); int tamanio=Integer.parseInt(texto); //Creamos los arrays int array1[]=new int [tamanio]; int array2[]; //Rellenamos el array1 rellenarNumAleatorioArray(array1, 10, 100); //Apuntamos el array2 al array1 array2=array1; //Creamos un nuevo array, usando el array1. Array1 tendra una nueva direccion. array1=new int[tamanio]; //Lo volvemos a rellenar, ya que al crear el array de nuevo no contiene los numeros anteriores rellenarNumAleatorioArray(array1, 10, 100); //Contiene el array con el resultado de multiplicar los valores de los arrays int array3[]=multiplicador(array1, array2); //Mostramos el contenido de los arrays System.out.println("Array1"); mostrarArray(array1); System.out.println("Array2"); mostrarArray(array2); System.out.println("Array3"); mostrarArray(array3); //Llamamos al recolector de basura System.gc(); } public static void rellenarNumAleatorioArray(int lista[], int a, int b){ for(int i=0;i<lista.length;i++){ //Generamos un número entre los parametros pasados lista[i]=((int)Math.floor(Math.random()*(a-b)+b)); } } public static void mostrarArray(int lista[]){ for(int i=0;i<lista.length;i++){ System.out.println("En el indice "+i+" esta el valor "+lista[i]); } } public static int[] multiplicador(int array1[], int array2[]){ int array3[]=new int[array1.length]; for(int i=0;i<array1.length;i++){ array3[i]=array1[i]*array2[i]; } return array3; } } |
8) Crea un array de números de un tamaño pasado por teclado, el array contendrá números aleatorios entre 1 y 300 y mostrar aquellos números que acaben en un dígito que nosotros le indiquemos por teclado (debes controlar que se introduce un numero correcto), estos deben guardarse en un nuevo array.
Por ejemplo, en un array de 10 posiciones e indicamos mostrar los números acabados en 5, podría salir 155, 25, etc.
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 |
import javax.swing.JOptionPane; public class NumTerminadosEnApp { public static void main(String[] args) { //Indicamos el tamaño String texto=JOptionPane.showInputDialog("Introduce un tamaño"); int num[]=new int[Integer.parseInt(texto)]; int ultimoDigito; do{ texto=JOptionPane.showInputDialog("Introduce numero entre 0 y 9"); ultimoDigito=Integer.parseInt(texto); }while(!(ultimoDigito>=0 && ultimoDigito<=9)); //rellenamos el array rellenarNumAleatorioArray(num, 1, 300); //Creamos un array que contenga los numeros terminados en el numero especificado int terminadosEn[]=numTerminadosEn(num, ultimoDigito); //Mostramos el resultado, mira el metodo de mostrarArrays // mostrarArrayTerminadosEn(num); mostrarArrayTerminadosEn(terminadosEn); } public static void rellenarNumAleatorioArray(int lista[], int a, int b){ for(int i=0;i<lista.length;i++){ //Generamos un número entre los parametros pasados lista[i]=((int)Math.floor(Math.random()*(a-b)+b)); } } public static void mostrarArrayTerminadosEn(int lista[]){ for(int i=0;i<lista.length;i++){ //No incluimos las posiciones que tengan un 0 if(lista[i]!=0){ System.out.println("El numero "+lista[i]+" acaba en el numero deseado"); } } } public static int[] numTerminadosEn (int num[], int ultimo_numero){ //Array que almacenara los numeros terminados en el numero pedido int terminadosEn[]=new int[num.length]; int numeroFinal=0; for (int i=0;i<terminadosEn.length;i++){ /* * Restamos el numero por el mismo numero sin unidades * Por ejemplo, 325-320=5 */ numeroFinal=num[i]-(num[i]/10*10); //Si el numero obtenido es el buscado, lo añadimos if (numeroFinal==ultimo_numero){ terminadosEn[i]=num[i]; } } return terminadosEn; } } |
9) Calcula la letra de un DNI, pediremos el DNI por teclado y nos devolverá el DNI completo.
Para calcular la letra, cogeremos el resto de dividir nuestro dni entre 23, el resultado debe estar entre 0 y 22. Haz un método donde según el resultado de la anterior formula busque en un array de caracteres la posición que corresponda a la letra. Esta es la tabla de caracteres:
Posicion Letra
0 T
1 R
2 W
3 A
4 G
5 M
6 Y
7 F
8 P
9 D
10 X
11 B
12 N
13 J
14 Z
15 S
16 Q
17 V
18 H
19 L
20 C
21 K
22 E
Por ejemplo, si introduzco 70588387, el resultado sera de 7 que corresponde a ‘F’.
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 |
import javax.swing.JOptionPane; public class LetraDNIApp { public static void main(String[] args) { //Declaramos como constante por lo que dividir final int DIVISOR=23; //Insertamos el DNI String texto=JOptionPane.showInputDialog("Escribe los numero de tu DNI"); int dni=Integer.parseInt(texto); //Sacamos el resto int res=dni%DIVISOR; //Invocamos el metodo char letra=letraNIF(res); //Mostramos el DNI completo System.out.println("Tu DNI es " +dni+letra); } public static char letraNIF(int res){ //Definimos el array de char char letrasNIF[]={'T', 'R', 'W', 'A', 'G', 'M', 'Y', 'F', 'P', 'D', 'X', 'B', 'N', 'J', 'Z', 'S', 'Q', 'V', 'H', 'L', 'C', 'K', 'E'}; //Devolvemos el valor en la posicion del array return letrasNIF[res]; } } |
10) Crea un array de números y otro de String de 10 posiciones donde insertaremos notas entre 0 y 10 (debemos controlar que inserte una nota valida), pudiendo ser decimal la nota en el array de números, en el de Strings se insertaran los nombres de los alumnos.
Después, crearemos un array de String donde insertaremos el resultado de la nota con palabras.
- Si la nota esta entre 0 y 4,99 , sera un suspenso
- Si esta entre 5 y 6,99 , sera un bien.
- Si esta entre 7 y 8,99 sera un notable.
- Si esta entre 9 y 10 sera un sobresaliente.
Muestra por pantalla, el alumno su nota y su resultado en palabras. Crea los métodos que creas conveniente.
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 70 71 72 73 74 |
import javax.swing.JOptionPane; public class NotasApp { public static void main(String[] args) { //Tamaño del array final int TAMANIO=10; //Creamos los arrays String nombres[]=new String[TAMANIO]; double notas[]=new double[TAMANIO]; //Rellenamos el array de una vez rellenarArrays(notas, nombres); //Devuelve las notas con palabras String resultado[]=añadeResultado(notas); //Mostramos el resultado mostrarArrays(nombres, notas, resultado); } public static void rellenarArrays(double notas[], String nombres[]){ for(int i=0;i<notas.length;i++){ //Introducimos los valores de una vez, se pueden hacer en metodos separados nombres[i]=JOptionPane.showInputDialog("Introduce el nombre del alumno "+(i+1)); double nota; //Validamos la nota do{ String texto=JOptionPane.showInputDialog("Introduce una nota del alumno "+(i+1)); nota=Double.parseDouble(texto); System.out.println(nota<=0 || nota>=10); }while(nota<=0 || nota>=10); notas[i]=nota; } } public static void mostrarArrays(String nombres[], double notas[], String resultado[]){ for(int i=0;i<nombres.length;i++){ System.out.println("El alumno "+nombres[i]+" tiene una nota de "+notas[i]+", por lo que su resultado es "+resultado[i]); } } public static String[] añadeResultado(double notas[]){ String resultado[]=new String[notas.length]; for(int i=0;i<notas.length;i++){ //Convertimos la nota a entero, despues se quedara como estaba switch((int)notas[i]){ case 1: case 2: case 3: case 4: resultado[i]="Suspenso"; break; case 5: case 6: resultado[i]="Bien"; break; case 7: case 8: resultado[i]="Notable"; break; case 9: case 10: resultado[i]="Sobresaliente"; break; } } return resultado; } } |
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 |
import java.util.Arrays; import javax.swing.JOptionPane; public class CapicuaApp { public static void main(String[] args) { //Introducimos un numero String numero=JOptionPane.showInputDialog("Introduce un número"); /* * Aprovechamos el String para averiguar la longitud del numero, * para crear un array compatible, y para dividirlo digitos */ int digitos[]=convierteNumeroAArray(numero, numero.length()); //Invocamos el metodo, segun el resultado mostramos un mensaje u otro if (EsCapicua(digitos)){ System.out.println("El numero "+numero+" es capicua"); }else{ System.out.println("El numero "+numero+" no es capicua"); } } public static int[] convierteNumeroAArray(String numero, int longitud){ int digitos[]=new int[longitud]; for(int i=0;i<digitos.length;i++){ digitos[i]=Character.getNumericValue(numero.charAt(i)); } return digitos; } public static boolean EsCapicua (int lista[]){ //Creamos otro array int listaprueba[]=new int [lista.length]; /* * Asignamos los valores al nuevo array lo hacemos añadiendo * los ultimos valores del primer array, al principio del nuevo array * ,es decir, le damos la vuelta al array */ for (int i=0, j=1;j<=lista.length;i++, j++){ listaprueba[i]=lista[lista.length-j]; } //Usamos el metodo de java.util.Arrays para comparar los arrays if (Arrays.equals(lista, listaprueba)){ return true; } return false; } } |
12) Dado un array de números de 5 posiciones con los siguiente valores {1,2,3,4,5}, guardar los valores de este array en otro array distinto pero con los valores invertidos, es decir, que el segundo array debera tener los valores {5,4,3,2,1}.
Spoiler
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
public class Ejercicio_DiscoDurodeRoer_Arrays_12 { public static void main(String[] args) { int[] array1={1,2,3,4,5}; int[] array2=new int[array1.length]; for(int i=(array1.length-1),j=0;i>=0;i--,j++){ array2[j]=array1[i]; System.out.println(array2[j]); } } } |
13)
Rellenar un array de numeros (int) usando el metodo fill de Arrays.
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.Arrays; public class Ejercicio_arrays_DDR_13 { public static void main(String[] args) { //creo el array int num[]=new int[10]; //relleno todo el array con 20 Arrays.fill(num, 20); //Relleno desde la posicion 3 hasta el final Arrays.fill(num, 3, num.length, -1); //Muestro el array for(int i=0;i<num.length;i++){ System.out.println(num[i]); } } } |
14) Crear dos arrays, rellenar uno con números y copiarlo al otro usando CopyOf de Arrays.
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.Arrays; public class Ejercicio_arrays_DDR_14 { public static void main(String[] args) { //Creo el array int num[]=new int[10]; //Rellenamos el array con 1 Arrays.fill(num, 1); //Copiamos de las posiciones 2 a la 9 (7 posiciones tendra) int num2[]=Arrays.copyOfRange(num, 2, 9); //Muestro el array for(int i=0;i<num2.length;i++){ System.out.println(num2[i]); } } } |
15) Indica si dos arrays creados por ti son iguales con Equals de Arrays.
Spoiler
|
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.Arrays; public class Ejercicio_arrays_DDR_15 { public static void main(String[] args) { //Creo el array int num1[]=new int[10]; int num2[]=new int[10]; //Comparo el contenido de ambos if(Arrays.equals(num1, num2)){ System.out.println("Son iguales"); }else{ System.out.println("No son iguales"); } } } |
16) Ordena un array de números con Sort de Arrays.
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 |
import java.util.Arrays; public class Ejercicio_arrays_DDR_16 { public static void main(String[] args) { //Creo el array int num[]=new int[5]; //Asigno valores num[0]=6; num[1]=3; num[2]=9; num[3]=4; num[4]=1; //ordeno Arrays.sort(num); //Muestro el array for(int i=0;i<num.length;i++){ System.out.println(num[i]); } } } |
17)
Ordenar un array de números con el método de la burbuja.
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 |
public class Ejercicio_arrays_DDR_17 { public static void main(String[] args) { //array a ordenar int numeros[]={5,6,2,10,1}; //llamada funcion ordenacionBurbuja(numeros); //mostrar el contenido for(int i=0;i<numeros.length;i++){ System.out.println(numeros[i]); } } /** * Ordena un array de enteros por el metodo de la burbuja * @param lista */ public static void ordenacionBurbuja (int lista[]){ int cuentaintercambios=0; //Variable que cuenta los intercambios que hacemos for (boolean ordenado=false;!ordenado;){ //hasta que no haya mas intercambios no sales for (int i=0;i<lista.length-1;i++){ if (lista[i]>lista[i+1]){ //intercambio int variableauxiliar=lista[i]; lista[i]=lista[i+1]; lista[i+1]=variableauxiliar; //indico que ha habido un intercambio mas cuentaintercambios++; } } //Si no hay intercambios, el array esta ordenado if (cuentaintercambios==0){ ordenado=true; } cuentaintercambios=0; //Reinicio la variable } } } |
18) Ordenar un array de números con el método QuickSort.
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 |
public class Ejercicio_arrays_DDR_18 { public static void main(String[] args) { //array a ordenar int numeros[]={5,6,2,10,1}; //llamada funcion ordenacionQuicksort(numeros, 0, numeros.length-1); //mostramos el contenido for(int i=0;i<numeros.length;i++){ System.out.println(numeros[i]); } } /** * Ordena un array por el metodo de ordenacion QuickSort * @param array * @param izq * @param der */ public static void ordenacionQuicksort (int array[], int izq, int der){ int i=izq; int j=der; int pivote=array[(i+j)/2]; //determinamos el pivote do { while (array[i]<pivote){ i++; } while (array[j]>pivote){ j--; } if (i<=j){ //intercambio int aux=array[i]; array[i]=array[j]; array[j]=aux; i++; j--; } }while(i<=j); //llamada de funciones (recursivo) if (izq<j){ ordenacionQuicksort(array, izq, j); } if (i<der){ ordenacionQuicksort(array, i, der); } } } |
19)
Ordenar un array de cadenas con el método Quicksort.
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 |
public class Ejercicio_arrays_DDR_19 { public static void main(String[] args) { //array a ordenar int numeros[]={5,6,2,10,1}; //llamada funcion ordenacionQuicksort(numeros, 0, numeros.length-1); //mostramos el contenido for(int i=0;i<numeros.length;i++){ System.out.println(numeros[i]); } } /** * Ordena un array por el metodo de ordenacion QuickSort * @param array * @param izq * @param der */ public static void ordenacionQuicksort (int array[], int izq, int der){ int i=izq; int j=der; int pivote=array[(i+j)/2]; //determinamos el pivote do { while (array[i]<pivote){ i++; } while (array[j]>pivote){ j--; } if (i<=j){ //intercambio int aux=array[i]; array[i]=array[j]; array[j]=aux; i++; j--; } }while(i<=j); //llamada de funciones (recursivo) if (izq<j){ ordenacionQuicksort(array, izq, j); } if (i<der){ ordenacionQuicksort(array, i, der); } } } |
20) Ordenar un array de números con el método que quieras y hacer una búsqueda binaria de cualquier numero.
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 70 71 72 73 74 75 76 77 78 79 80 81 |
public class Ejercicio_arrays_DDR_20 { public static void main(String[] args) { //array a ordenar int numeros[]={5,6,2,10,1}; //llamada a la funcion ordenacionQuicksort(numeros, 0, numeros.length-1); //mostramos el contenido for(int i=0;i<numeros.length;i++){ System.out.println(numeros[i]); } //realizamos la busqueda binaria System.out.println("El numero 5 esta en la posicion "+buscarBin(numeros, 5)); } /** * Ordena un array por el metodo de ordenacion QuickSort * @param array * @param izq * @param der */ public static void ordenacionQuicksort (int array[], int izq, int der){ int i=izq; int j=der; int pivote=array[(i+j)/2]; //determinamos el pivote do { while (array[i]<pivote){ i++; } while (array[j]>pivote){ j--; } if (i<=j){ //intercambio int aux=array[i]; array[i]=array[j]; array[j]=aux; i++; j--; } }while(i<=j); //llamada de funciones (recursivo) if (izq<j){ ordenacionQuicksort(array, izq, j); } if (i<der){ ordenacionQuicksort(array, i, der); } } /** * Busca un numero entero en un array * Necesita que el array este ordenado * @param array * @param numerobuscado * @return posicion del numero */ public static int buscarBin (int array[], int numerobuscado){ int izq=0; int der=array.length; boolean encontrado=false; int pos=-1; for(int i=0;!encontrado && i<array.length;i++){ int central=array[(izq+der)/2]; //elegimos la casilla central if (central<=numerobuscado){ if (central==numerobuscado){ //encontrado encontrado=true; pos=(izq+der)/2; }else{ izq=(izq+der)/2; //modificamos izq } }else{ der=(izq+der)/2; //modificamos der } } return pos; } } |
21)
Vamos a crear el juego del ahorcado por consola.
Al inicio del programa, pedirá los nombres de los dos jugadores. El primer turno será para el jugador 1.
Uno escribe una palabra y el otro la adivina, si este la adivina obtendrá un punto y escribirá una palabra, sino lo acierta el jugador actual suma un punto y escribe de nuevo otra palabra.
Cuando el jugador inserte su palabra también deberá añadir una pequeña pista, por ejemplo si la palabra es Madrid, la pista puede ser «Ciudad».
El jugador que tenga que acertar la palabra tendrá seis oportunidades (cabeza, cuerpo, brazos y piernas). No es necesario dibujar nada por pantalla, solo mostrar el número de oportunidades restantes.
Deberá mostrase los caracteres que el usuario inserta para esa palabra, para evitar que las repita, en caso de que lo haga, avisarle y no contar como error.
Cada vez que acierte o no la palabra, deberá mostrar la puntuación de ambos. El primero que llegue a 3 puntos gana.
Puedes usar todos los medios a tu alcance.
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 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 |
import java.util.Scanner; /** * Juego del ahorcado * * @author DiscoDurodeRoer */ public class Ejercicio_arrays_DDR_21 { public static void main(String[] args) { //Scanner para las palabras Scanner sn = new Scanner(System.in); sn.useDelimiter("\n"); //Constantes final int PUNTUACION_SUPERAR = 3; final int NUMERO_ERRORES = 6; final int NUMERO_JUGADORES = 2; final int NUMERO_CARACTERES = 26; //Variables y arrays usados String jugadores[] = new String[NUMERO_JUGADORES]; int puntos[] = new int[NUMERO_JUGADORES]; int turno = 0, numeroErrores = NUMERO_ERRORES; //Controla a quien le toca String palabraElegida, pista, palabraAdivinar, palabraUsuario; char abecedario[] = generaCaracteres(); // Genera in array con los caracteres de A-Z, no se incluye la ñ boolean caracteresInsertados[] = new boolean[NUMERO_CARACTERES]; //Pedimos el nombre de los jugadores for (int i = 0; i < jugadores.length; i++) { jugadores[i] = pedirString(sn, "Escribe el nombre del jugador " + (i + 1)); } while (!fin(puntos, PUNTUACION_SUPERAR)) { //Validamos la palabra y la pista palabraElegida = validar(sn, "Escribe una palabra con solo caracteres y sin espacios, Jugador: " + jugadores[turno], "Error, escribe palabra con solo caracteres y sin espacios y de longitud de mas de 1"); pista = validar(sn, "Escribe una pista con solo caracteres y sin espacios, Jugador: " + jugadores[turno], "Error, escribe pista con solo caracteres y sin espacios"); espacios(30); //añadimos espacios para que el otro jugador no vea //rellenamos la palabraAdivinar con guiones palabraAdivinar = rellenaGuiones(palabraElegida); //ahora toca adivinar la palabra while (!palabraCorrecta(palabraElegida, palabraAdivinar) && numeroErrores > 0) { //mostamos la pista, la palabra y los repetidos System.out.println("Pista: " + pista); mostrarPalabra(palabraAdivinar); mostrarRepetidos(abecedario, caracteresInsertados); //el jugador escribe palabraUsuario = pedirString(sn, "Escribe una letra, si escribes una palabra " + "sera como escribir la solucion, Jugador: " + jugadores[turno]).toLowerCase(); //si la longitud es de una, podemos decir que quiere poner una letra if (palabraUsuario.length() == 1) { if (Character.isAlphabetic(palabraUsuario.charAt(0))) { if (caracterIntroducido(caracteresInsertados, palabraUsuario.charAt(0))) { System.out.println("El caracter ya esta puesto, elige otro"); } else if (numRemplazos(palabraElegida, palabraUsuario.charAt(0)) > 0) { palabraAdivinar = remplazar(palabraElegida, palabraAdivinar, palabraUsuario.charAt(0)); } else { numeroErrores--; System.out.println("Error, te quedan " + numeroErrores + " errores"); } actualizarInsertados(caracteresInsertados, palabraUsuario.charAt(0)); } //si es mas de una letra, el jugador quiere intentar adivinarlo } else if (!palabraCorrecta(palabraElegida, palabraUsuario)) { numeroErrores--; System.out.println("Error, no es la palabra correcta"); } else { //Si entramos aqui, significa que la plabra es correcta, //necesitamos asignar la palabra del usuario a la de adivinar //Otra solucion podria ser poner en la condicion otra llamada //al metodo palabraCorrecta palabraAdivinar = palabraUsuario; System.out.println("Correcto, has acertado"); } } //Si el numero de errores es mayor que cero, significa que hemos acertado la palabra if (numeroErrores > 0) { //Suma puntos el resto de jugadores y se cambia el turno sumaPuntosOtroJugador(puntos, 1, turno); turno = cambiaTurno(turno, jugadores.length - 1); } else { //el usuario que puso la palabra suma un punto y continua escribiendo la palabra puntos[turno]++; } //Mostramos las puntuaciones de los jugadores mostrarPuntuaciones(jugadores, puntos); //reiniciamos los errores y los caracteres insertados numeroErrores = NUMERO_ERRORES; actualizarInsertados(caracteresInsertados); } //Indicamos el ganador mostrarGanador(puntos, jugadores, PUNTUACION_SUPERAR); System.out.println("Fin"); } /** * Pide y devuelve un String * * @param sn * @param mensaje * @return valor String */ public static String pedirString(Scanner sn, String mensaje) { System.out.println(mensaje); return sn.next(); } /** * Genera un array de caracteres * * @return Array con caracteres de A-Z */ public static char[] generaCaracteres() { char[] caracteres = new char[26]; for (int i = 0, j = 97; i < caracteres.length; i++, j++) { caracteres[i] = (char) j; } return caracteres; } /** * Comprueba si lo insertado es correcto, sin numeros, espacios, caracteres * no legibles, etc. * * @param cadena * @return true si todo esta bien, false si hay un caracter inválido */ public static boolean comprobarAlfabeticos(String cadena) { char caracter; for (int i = 0; i < cadena.length(); i++) { caracter = cadena.charAt(i); if (!Character.isAlphabetic(caracter)) { return true; } } return false; } /** * Indica si el juego termina * * @param puntos * @param puntuacionSuperar * @return true, fin del juego, false, el juego continua */ public static boolean fin(int puntos[], int puntuacionSuperar) { for (int i = 0; i < puntos.length; i++) { if (puntos[i] >= puntuacionSuperar) { return true; } } return false; } /** * Valida si una palabra insertada es correcta, sino lo es vuelve a pedirlo * * @param sn * @param mensaje * @param mensajeError * @return true, la palabra es válida, false, no lo es */ public static String validar(Scanner sn, String mensaje, String mensajeError) { String palabra; boolean correcto; do { correcto=true; palabra = pedirString(sn, mensaje).toLowerCase(); if (comprobarAlfabeticos(palabra) || palabra.length() <= 1) { System.out.println(mensajeError); correcto=false; } } while (!correcto); return palabra; } /** * Inserta el número de espacios pasados por parámetro * * @param numSaltos */ public static void espacios(int numSaltos) { for (int i = 0; i < numSaltos; i++) { System.out.println(""); } } /** * Crea una nueva cadena con guiones para el juego * * @param cadena * @return String con guiones */ public static String rellenaGuiones(String cadena) { String palabra = ""; for (int i = 0; i < cadena.length(); i++) { palabra += "_"; //le pongo el guion } return palabra; } /** * Muestro una palabra con espacios entre sus caracteres * * @param cadena */ public static void mostrarPalabra(String cadena) { for (int i = 0; i < cadena.length(); i++) { System.out.print(cadena.charAt(i) + " "); } System.out.println(""); } /** * Indica si la palabra insertada por el usuario es correcta * * @param palabraOriginal * @param palabraUsuario * @return true, correcto, false, incorrecto */ public static boolean palabraCorrecta(String palabraOriginal, String palabraUsuario) { return palabraOriginal.equals(palabraUsuario); } /** * Muestra las palabras que hemos repetido durante el turno de un jugador * * @param abecedario * @param insertados */ public static void mostrarRepetidos(char[] abecedario, boolean insertados[]) { System.out.print("Repetidas: "); for (int i = 0; i < insertados.length; i++) { //Si esta insertado, se muestra el caracter if (insertados[i]) { System.out.print(abecedario[i]); } } System.out.println(""); } /** * Suma puntos a todos los jugadores excepto a uno * * @param puntos * @param puntosSuperar * @param pos_excluida */ public static void sumaPuntosOtroJugador(int[] puntos, int puntosSuperar, int pos_excluida) { for (int i = 0; i < puntos.length; i++) { if (i != pos_excluida) { puntos[i]++; } } } /** * Indica el numero de remplazos a realizar * * @param cadenaOriginal * @param caracter * @return numero de remplazos a realizar */ public static int numRemplazos(String cadenaOriginal, char caracter) { int remplazos = 0; char caracterCadena; for (int i = 0; i < cadenaOriginal.length(); i++) { caracterCadena = cadenaOriginal.charAt(i); if (caracterCadena == caracter) { remplazos++; } } return remplazos; } /** * Remplaza los guiones con el caracter dado * * @param cadenaOriginal * @param cadenaRemplazar * @param caracter * @return cadena con guiones remplazados */ public static String remplazar(String cadenaOriginal, String cadenaRemplazar, char caracter) { String cadenaRemplazo = ""; char caracterCadena; for (int i = 0; i < cadenaOriginal.length(); i++) { caracterCadena = cadenaOriginal.charAt(i); if (caracterCadena == caracter) { cadenaRemplazo += caracter; } else { cadenaRemplazo += cadenaRemplazar.charAt(i); } } return cadenaRemplazo; } /** * * @param insertados * @param caracter * @return */ public static boolean caracterIntroducido(boolean[] insertados, char caracter) { return insertados[caracter - 'a']; } public static void actualizarInsertados(boolean[] insertados, char caracter) { insertados[caracter - 'a'] = true; } /** * Cambia el turno del jugador, si llega al final, empieza de cero * * @param turnoActual * @param limite * @return turno del jugador actual */ public static int cambiaTurno(int turnoActual, int limite) { if (turnoActual == limite) { return 0; } else { return ++turnoActual; //importante que sea pre-incremento } } /** * Muestra las puntuaciones de los jugadores * * @param jugadores * @param puntos */ public static void mostrarPuntuaciones(String[] jugadores, int[] puntos) { for (int i = 0; i < jugadores.length; i++) { System.out.println(jugadores[i] + ": " + puntos[i] + " puntos"); } System.out.println(""); } /** * Muestra al ganador del juego * * @param puntos * @param jugadores * @param puntosSuperar */ public static void mostrarGanador(int[] puntos, String jugadores[], int puntosSuperar) { int indiceGanador = 0; for (int i = 0; i < puntos.length; i++) { if (puntos[i] >= puntosSuperar) { indiceGanador = i; //obtenemos el indice break; } } System.out.println("El ganador es " + jugadores[indiceGanador]); } /** * Reiniciamos los caracteres insertados * * @param insertados */ public static void actualizarInsertados(boolean insertados[]) { for (int i = 0; i < insertados.length; i++) { insertados[i] = false; } } } |
22) Generar un arreglo con numero aleatorios no repetidos entre sí.
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 70 71 72 73 74 75 76 77 78 |
import java.util.Arrays; /** * @author Discoduroderoer */ public class Ejercicio_arrays_DDR_22 { public static void main(String[] args) { //Valores usados para generar el arreglo int minimo=5; int maximo=10; int longitud=6; //En caso de que uno sea mayotr que otro //Lo intercambiamos if(maximo<minimo){ int aux=maximo; maximo=minimo; minimo=aux; } //Si caben los numeros del rango //Generamos el array if( (maximo-minimo) >= (longitud-1) ){ int numero_elementos=0; int numeros[]=new int[longitud]; //RECOMENDADO: rellena el arreglo con un numero que nunca se va a generar Arrays.fill(numeros, minimo-1); boolean encontrado; int aleatorio; //Hasta que el numero de elementos no sea como el de la longitud del array no salimos while(numero_elementos<longitud){ aleatorio=generaNumeroAleatorio(minimo,maximo); encontrado=false; //Buscamos si el numero existe for(int i=0;i<numeros.length && !encontrado;i++){ if(aleatorio==numeros[i]){ encontrado=true; } } //Si esta lo indicamos //Sino lo agregamos if(encontrado){ System.out.println("El numero existe: "+aleatorio); }else{ numeros[numero_elementos++] = aleatorio; System.out.println("Agregado el numero: "+aleatorio); } } //Mostramos el arreglo System.out.println("Mostrar arreglo"); for(int i=0;i<numeros.length;i++){ System.out.println(numeros[i]); } }else{ System.out.println("Que no se puede generar"); } } //Genera un numero aleatorio entre el minimo y el maximo, includo el maximo y el minimo public static int generaNumeroAleatorio(int minimo,int maximo){ int num=(int)Math.floor(Math.random()*(maximo-minimo+1)+(minimo)); return num; } } |
23) Teniendo un vector con los valores que queramos, meter en otro de la misma longitud,
aquellos que sean pares y mayores que 25.
Después, mostrar el vector de origen y el de destino, solo los numero 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 27 28 29 30 31 32 33 34 35 36 37 38 39 |
public class Ejercicio_arrays_DDR_23 { public static void main(String[] args) { //Creo el array de origen con los numeros que queramos int origen[] = {4, 7, 5, 0, 2, 1, 15, 93, 25, 12, 86, 87, 100}; //Creamos un array con la misma longitud int destino[] = new int[origen.length]; //Creamos un contador que nos servira de indice en el array de destino int contador = 0; //Rellenamos el array de destino con la condicion indicada for (int i = 0; i < origen.length; i++) { if (origen[i] % 2 == 0 && origen[i] > 25) { destino[contador] = origen[i]; //usamos contador como indice contador++; //aumentamos el contador } } //Muestra el vector de origen System.out.println("Mostrar vector origen"); for (int i = 0; i < origen.length; i++) { System.out.println(origen[i]); } System.out.println("Mostrar Vector destino"); if (contador == 0) { //Si no hay elementos, mostrara un elemento System.out.println("No hay numeros que cumplan la condicion"); } else { //Mostrar el vector de origen for (int i = 0; i < contador; i++) { System.out.println(destino[i]); } } } } |
24)
Se quiere simular un juego en el que participan N jugadores y otra persona que hace de árbitro. Cada jugador elige 4 números en el rango [1, 10], pudiendo estar repetidos. A continuación, el árbitro, sin conocer los números que ha elegido cada jugador, selecciona 2 números A y B.
El programa debe ser capaz de calcular cuántos números de los seleccionados por cada jugador están comprendidos entre los valores A y B. Ganará el jugador que más números tenga en dicho intervalo.
Se pide implementar un programa modular que simule el juego para 3 jugadores, teniendo en cuenta que:
- Tanto los 4 datos de cada jugador, como los valores para A y B se introducirán por teclado. En todos los casos, el programa detectará la entrada de números erróneos, solicitando nuevamente el dato hasta que sea válido.
- Se deben mostrar por pantalla no solo los aciertos de cada jugador sino los datos que ha introducido cada jugador y los que ha seleccionado el árbitro. Por último, hay que imprimir la media aritmética de los aciertos de todos los jugadores
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 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 |
import java.util.Scanner; public class Ejercicio_arrays_DDR_24 { public static void main(String[] args) { //numero de jugadores int n = 3; jugar(n); } public static void jugar(int n) { //Si no hay suficientes jugaores, no se jugara if (n < 2) { System.out.println("Se necesitan mas jugadores"); } else { //matriz donde guardaremos los puntos int numeros_jugadores[][] = new int[n][4]; //array donde guardaremos los numeros del arbitro int numeros_arbitro[] = new int[2]; //Recorro los jugadores for (int i = 0; i < numeros_jugadores.length; i++) { //pedimos los numeros System.out.println("Jugador " + i); pedirNumeros(numeros_jugadores[i]); //array del jugador //mostrar los numeros del jugador System.out.println("Jugador " + i); mostrarArray(numeros_jugadores[i]); } //Numero del arbitro System.out.println("Arbitro"); pedirNumeros(numeros_arbitro); System.out.println("Arbitro"); mostrarArray(numeros_arbitro); //array para almacenar los puntos int puntos_jugador[] = new int[n]; //calculamos los puntos calcularPuntos(puntos_jugador, numeros_arbitro, numeros_jugadores); //muestro los puntos System.out.println("Puntos"); mostrarArray(puntos_jugador); //obtengo la posicion del ganador int ganador = ganador(puntos_jugador); //muestro el ganador y los puntos System.out.println("Ha ganado el jugador " + ganador + " por " + puntos_jugador[ganador] + " puntos"); //obtengo la media double mediaAciertos = mediaArray(puntos_jugador); //muestro la media System.out.println("La media de aciertos es de " + mediaAciertos); } } /** * Añade numeros pedidos al usuario a un array * @param numeros_jugadores */ public static void pedirNumeros(int[] numeros_jugadores) { //recorro el array for (int i = 0; i < numeros_jugadores.length; i++) { //relleno numeros_jugadores[i] = validarNumero(1, 10); } } /** * Valido un numero entre dos numeros * @param minimo * @param maximo * @return */ public static int validarNumero(int minimo, int maximo) { Scanner sn = new Scanner(System.in); int numero = 0; do { System.out.println("Inserta un numero entre " + minimo + " y " + maximo); numero = sn.nextInt(); //muestra un pequeño mensaje de aviso if (!(numero >= minimo && numero <= maximo)) { System.out.println("Solo numeros entre " + minimo + " y " + maximo); } } while (!(numero >= minimo && numero <= maximo)); return numero; } /** * Relleno en puntos los puntos de los jugadores * @param puntos * @param numeros_arbitro * @param numeros_jugadores */ public static void calcularPuntos(int[] puntos, int[] numeros_arbitro, int[][] numeros_jugadores) { int puntos_jugador = 0; //Recorro la matriz for (int i = 0; i < numeros_jugadores.length; i++) { for (int j = 0; j < numeros_jugadores[0].length; j++) { //Segun el orden de los numeros if (numeros_arbitro[0] > numeros_arbitro[1]) { //si esta entre los numeros, aumento los puntos if (numeros_jugadores[i][j] >= numeros_arbitro[1] && numeros_jugadores[i][j] <= numeros_arbitro[0]) { puntos_jugador++; } } else { //si esta entre los numeros, aumento los puntos if (numeros_jugadores[i][j] >= numeros_arbitro[0] && numeros_jugadores[i][j] <= numeros_arbitro[1]) { puntos_jugador++; } } } //Relleno los puntos puntos[i] = puntos_jugador; //Reinicio los puntos puntos_jugador = 0; } } /** * Devuelve la posicion del ganador * @param puntos * @return */ public static int ganador(int[] puntos) { //inicial int maximo = puntos[0]; int pos_jugador_ganador = 0; for (int i = 1; i < puntos.length; i++) { //compruebo el maximo if (puntos[i] > maximo) { maximo = puntos[i]; pos_jugador_ganador = i; } } return pos_jugador_ganador; } /** * Muestra un array * @param array */ public static void mostrarArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.println(array[i]); } } /** * Muestra la media de un array * @param array * @return */ public static double mediaArray(int[] array) { double media = 0; int suma = 0; for (int i = 0; i < array.length; i++) { suma += array[i]; } media = (double) suma / array.length; return media; } } |
Espero que os sea de ayuda. Si tenéis dudas, preguntad. Estamos para ayudarte.
Hola, antes que nada muchas gracias por tu curso de Udemy, lo estoy sigueindo y esta muy interesante, estoy aprendiendo bastante.
Para el ejercicio 8 lo que se puede hacer directamente es sacar el modulo de 10 del numero aleatorio, y si este coincide con el digito que pasemos lo inserta en el array.
Hola podría ver el código del ejercicio 24,no lo tengo muy claro y soy novato solo quiero comprenderlo.
hola.. ayúdeme a resolver este problema..VECTORES en java
Los gemelos del profesor Lucas (Pedro y Paco) son jugadores de fútbol. Cada vez que el profesor los
lleva a partidos debe buscarlos entre los 11 jugadores del equipo y la única manera de identificarlos
es por el número de la camiseta, Pedro usa el número 18 y Paco el número 19.
Usted ha sido seleccionado para desarrollar una solución que le permita al profesor revisar los
números de camisetas de los jugadores de cada equipo participante y saber si sus hijos estarán
jugando. cel.3206783587…sharcamac16@gmail.com
Buenas como va? Les dejo mi solucion del primer ejercicio 1)
Utilice scanner en mi caso.
package practice;
import java.util.Scanner;
public class ArrayEj1 {
private static Scanner sc = new Scanner(System.in);
public static void main(String[] args) {
int[] array = new int[10];
enterValues(array);
showValues(array);
}
public static void enterValues(int[] arrayInput) {
int number = 0;
for (int i = 0; i < arrayInput.length; i++) {
number = sc.nextInt();
System.out.println("Introduce un numero");
arrayInput[i] = number;
System.out.println();
}
}
public static void showValues(int[] array) {
int value = 0;
for (int i = 0; i < array.length; i++) {
value = array[i];
System.out.println();
System.out.println("El indice " + i + " obtiene el valor: " + value);
System.out.println();
}
}
}
Crea un array de números de 5 posiciones, llenarlos por teclado y luego multiplicar a cada elemento por 3, finalmente mostrar el array ya actualizado.
apoyo
Hola, alguien podría ayudarme con este ejercicio:
En esta unidad implementaremos una aplicación capaz de gestionar un Gimnasio. El gimnasio sólo podrá gestionar como máximo 70 personas.
El proyecto se llamará PROG06_Tarea.
Al iniciar nuestra aplicación, se mostrará por pantalla un pequeño menú con las siguientes opciones:
Nueva Persona.
Buscar Persona.
Modificar código taquilla.
Listar Personas.
Eliminar Persona.
Salir.
El funcionamiento de cada opción será el siguiente:
Nueva Persona: Se solicitarán al usuario por teclado los datos de una nueva Persona y, si los datos son correctos, se almacenará en el gimnasio. En caso de error en algún dato se volverá a solicitar hasta introducir un valor correcto. Comprobaremos que no existe esa persona en el gimnasio. Si así fuera lanzaremos una excepción y volveremos a mostrar el menú.
Para añadir una nueva Persona se deberá validar:
o Mediante expresiones regulares que:
El DNI del propietario es correcto y estará formado por 8 números y una letra
El código de la taquilla es correcta. Estará formado por dos caracteres (mayúsculas o minúsculas ) y 3 números(del 0 al 9)
Sin expresiones regulares (utilizando métodos de la clase String):
La longitud del nombre de la persona debe ser mayor a 20 caracteres.
Buscar Persona: Se solicitará el DNI y se buscará en el gimnasio la persona que coincida con el DNI introducido. Si existe se mostrarán su nombre, dni, y casillero por pantalla y en caso contrario el mensaje «No existe Persona con el DNI introducido».
Modificar codigoCasillero : Se solicitará el código del casillero. Buscaremos ese código y lo cambiaremos por el valor introducido siempre que cumpla el formato. Si no existe, se mostrará un mensaje por pantalla.
Listar Personas: Mostrará por pantalla un listado de las personas del gimnasio, mostrando nombre, DNI, edad, codigoTaquilla.
Eliminar Persona: Se solicitará el DNI de la Persona y se buscará en el array de Gimanasio para eliminarla. Se decrementará el número de Personas que hay en el gimnasio
Salir: la aplicación finalizará.
Después de la ejecución de cada opción, se mostrará de nuevo el menú.
Para la implementación TEN EN CUENTA:
a) Haz una clase llamada Persona que siga las siguientes condiciones:
Sus atributos son: nombre, DNI, fechaNacimiento, sexo (H hombre, M mujer), peso, altura y codigoTaquilla. No queremos que se accedan directamente a ellos. Piensa que modificador de acceso es el más adecuado, también su tipo. Si quieres añadir algún atributo puedes hacerlo.
Por defecto, todos los atributos menos el DNI y la fechaNacimiento serán valores por defecto según su tipo (0 números, cadena vacía para String, etc.). Sexo será hombre por defecto, usa una constante para ello.
Se implantarán varios constructores:
· Un constructor por defecto.
· Un constructor con el nombre, edad y sexo, el resto por defecto.
· Un constructor con todos los atributos como parámetro.
Los métodos que se implementaran son:
· calcularIMC(): calculara si la persona está en su peso ideal (peso en kg/(altura^2 en m)), si esta fórmula devuelve un valor menor que 20, la función devuelve un -1, si devuelve un número entre 20 y 25 (incluidos), significa que está por debajo de su peso ideal la función devuelve un 0 y si devuelve un valor mayor que 25 significa que tiene sobrepeso, la función devuelve un 1. Te recomiendo que uses constantes para devolver estos valores.
comprobarSexo(char sexo): comprueba que el sexo introducido es correcto. Si no es correcto, será H. No será visible al exterior.
getAnyos(): Devuelve la edad de la Persona.
esMayorDeEdad(): indica si es mayor de edad, devuelve un booleano.
toString(): devuelve el DNI, nombre, edad y código de la taquilla
Métodos getter y setter
Los métodos de la clase Persona no mostrarán datos por pantalla..
· Desde el programa principal no se podrá llamar directamente a esta clase.
b) Crea una clase llamada Gimansio:
Crea la estructura de datos necesaria para almacenar las Personas, con un tamaño máximo de 70 personas.
Crea un atributo de clase dónde se almacene el número total de personas almacenadas. Llámalo numPersonas. Este atributo te permitirá conocer la posición de inserción de un nueva Persona o hasta qué posición debes recorrer la estructura.
Sus métodos serán:
Constructor o constructores.
buscaPersona: Recibe como parámetro un DNI, buscará la Persona en el gimnasio y si la encuentra devolverá true. En caso contrario false. No debe mostrar nada por pantalla.
devuelvePersona: Recibe como parámetro un DNI, buscará la Persona en el gimnasio y devolverá el objeto Persona o null si la Persona buscada no existe. No debe mostrar nada por pantalla.
datosPersona: Recibe como parámetro un DNI, buscará la Persona y si la encuentra devolverá sus datos en un string.
anadePersona: Recibe todos los datos de una Persona y lo inserta en el gimnasio. Incrementará el atributo que almacena el número de personas almacenadas. El método devuelve true si se insertó correctamente o false si no tiene cabida en el gimnasio. No debe mostrar nada por pantalla.
listaPersonas: Muestra por pantalla los datos de todas las personas del gimnasio
actualizaTaquilla: Recibe por parámetro un DNI y un codigoTaquilla y buscará la Persona con dicho DNI para modificarle el código de Taquilla si este es válido. El método devuelve true si se hizo con éxito y false en caso contrario. No debe mostrar nada por pantalla.
eliminaPersona: Recibe como parámetro un DNI, buscará la Persona en el gimnasio y si la borrará del gimnasio. Decrementa el atributo que almacena el número de personas en el gimnasio.
Utiliza los paquetes que consideres oportuno para organizar las clases.
Desde la clase Principal no debes llamar a la clase Persona. Solo se debe utilizar la clase Gimansio.
IMPORTANTE
mi estimado excelente contenido, me podrias ayudar muchisimo, si puedes hacer los problemas 1-2-3-4-5 pero con Pseint
Saludos desde Venezuela.
hola! en el segundo ejercicio , faltaria la suma de los números del array generado aleatoriamente:
he puesto este codigo, solo mando el del último método
:
public static void mostrarArray(int[]lista) {
int sumaTotal = 0;
for(int i=0;i<lista.length;i++) {
sumaTotal+=lista[i];
System.out.println("el indice del numero es " + i + " y el valor es " + lista[i]);
}
System.out.println("suma " + sumaTotal);
}
me pueden explicar el ejercicio 3 por favor