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:
Curso Java
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
–Version 1: sin metodos de String
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
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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;
}
}
|
11) Crea una aplicación que pida un numero por teclado y después comprobaremos si el numero introducido es capicua, es decir, que se lee igual sin importar la dirección. Por ejemplo, si introducimos 30303 es capicua, si introducimos 30430 no es capicua. Piensa como puedes dar la vuelta al número. Una forma de pasar un número a un array es esta
Character.getNumericValue(cadena.charAt(posicion)).
| Spoiler Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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 Inside |
SelectShow> |
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.
Me resulta difícil, no soy muy buena para esto, pero son tan necesarios, saludos
Traffic club, Cuentos de terror y profecias
Gran aportación para la informática, el JAVA ese gran desconocido.
TRAFFIC CLUB, Fútbol y Tenis, más que un juego
Utilice un arreglo de objetos para hacer el 10, crei que asi lo hicieron aqui pero veo que no.
En este caso, no es necesario ya que todos los valores son int, si hubiera algun valor como un boolean o un String y te obliga a tenerlo todo junto, no te quedaria otra que hacer lo que dices, pero ten en cuenta que debes despues parsear los valores y Object gasta mucha mas memoria que si es un tipo de dato concreto.
Un saludo
Ayudaa!
necesito realizar el siguiente programa en java con arreglos:
Una tortillería requiere controlar los paquetes que surten a los repartidores de la localidad(tortilleros) que son mas de 5
La idea es saber cuantos paquetes se les entregan y cuantos vende para saber que eficiencia tienen por dia si trabajan toda la semana
La formula para calcular DNI en el ejercicio 6 es errónea, la correcta es: DNI%23. Simplemente consiste en quedarte con el resto de la division DNI/23.
Tal cual está redactada, siempre te da 0, puesto que por ejemplo: 11111111-(11111111/23*23)=0 [debido a que multiplicas y divides por 23].
OTRA MANERA DE RESOLVER EL 6
public static void main (String args[]) {
Scanner teclado=new Scanner(System.in);
int dni, resul;
char [] letra ={‘T’,’R’,’W’,’A’,’G’,’M’,’Y’,’F’,’P’,’D’,’X’,’B’,’N’,’J’,’Z’,’S’,’Q’,’V’,’H’,’L’,’C’,’K’,’E’};
System.out.print(«Introduce DNI: «);
dni=teclado.nextInt();
resul=dni%23;
for(int i=0;i<letra.length;i++){
if(resul==i){
System.out.println(dni+"-"+letra[i]);
}
}
}
Hola, estoy probando y si funciona, ya que java trunca el resultado si sale parte decimal, por lo que no se anula como tal. Si lo pruebas con 11111111 también funciona.
Si el dni es 70588387, divides entre 23 = 3069060,304 pero en Java la parte decimal la quita y por eso al multiplicar no queda el mismo dni. 3069060 * 23 = 70588380 70588387 – 70588380 = 7 (letra F)
De todas formas, si es cierto que es mas cómodo coger el módulo directamente, eso lo edito. Gracias por tu comentario.
Se puede hacer también así, pero si ya tienes la posición de la letra que lo almacenas en la variable resul, no es necesario realizar un bucle, ya que con System.out.println(dni+»-«+letra[resul]); ya tendrias lo que tu buscas, son cosas pequeñas, pero a la larga en un programa que sea grande hay que buscar la mayor eficiencia posible. Gracias por tu comentario.
Es cierto, no había pensado en ello. Soy bastante nuevo en esto de java, y de la programacion en general. Siempre es de agradecer aprender maneras distintas de hacer las cosas ya que en el futuro es muy posible que, de manera involuntaria, recurra a ellas aun de forma inconsciente :P
PD: no es la primera vez que me ha pasado esto de la ineficiencia , de Madrid a Paris suelo pasar por Roma casi siempre jaja