Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » Ayuda con ejercicio java array de letras

Java - Ayuda con ejercicio java array de letras

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil
Val: 23
Ha aumentado su posición en 167 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda con ejercicio java array de letras

Publicado por yorhs (9 intervenciones) el 28/06/2021 19:48:45
1
2
3
4
5
6
7
8
9
10
char[] caracteres = new char[30];
char[]dato=new char[30];
Random numLetra = new Random();
String abc = "ABCDEFGHIJKLMNÑOPQARSTUVWXYZ";
 
for (int i = 0; i < caracteres.length; i++) {
    caracteres[i] = abc.charAt(numLetra.nextInt(abc.length()));
    System.out.println(caracteres[i]);
 
}


ME PODRIAN AYUDAR A COMO SABER CUAL ES LA LETRA QUE MAS SE REPITE
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Kabuto
Val: 3.428
Oro
Ha mantenido su posición en Java (en relación al último mes)
Gráfica de Java

Ayuda con ejercicio java array de letras

Publicado por Kabuto (1381 intervenciones) el 29/06/2021 01:10:23
Se puede usar otro array de tipo int para tener un contador por cada posible caracter.
Hay 27 posibles caracteres, en tu ejercicio salen 28 pero es porque la 'A' se repite dos veces, supongo que es un error.

Así que podemos declarar un array de int con tamaño 27.
Cada posición del array será un contador para cada carácter. Así la posición 0 contará las 'A', la posición 1 contará las 'B', etc...

Cada vez que generamos un carácter al azar, comprobamos cuál ha sido y aumentamos el contador correspondiente.

Luego, recorremos ese array a ver cuál es el contador que más se ha incrementado y así sabremos cuál es el carácter más repetido.
Si por ejemplo el contador de la posición 3 es el mayor de todos, pues sabemos que el carácter más repetido es 'D', ya que es el que le corresponde.

Voy a poner dos versiones.
Esta primera, funciona y es eficaz, pero no es eficiente. Porque se utiliza un switch muy grande, con las 27 posibilidades.

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
public class Main
{
    public static void main(String[] args) {
        char[] caracteres = new char[30];
        int[] contadores = new int[27]; //Hay 27 posibles caracteres
        Random numLetra = new Random();
        String abc = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"; //Estos son los posibles 27 caracteres
 
        for (int i = 0; i < caracteres.length; i++) {
            //Generamos caracter
            caracteres[i] = abc.charAt(numLetra.nextInt(abc.length()));
            //Mostramos en pantalla
            System.out.println(caracteres[i]);
            //Aumentamos contador según caracter generado
            switch(caracteres[i]) {
                case 'A':
                    contadores[0]++;
                    break;
                case 'B':
                    contadores[1]++;
                    break;
                case 'C':
                    contadores[2]++;
                    break;
                case 'D':
                    contadores[3]++;
                    break;
                case 'E':
                    contadores[4]++;
                    break;
                case 'F':
                    contadores[5]++;
                    break;
                case 'G':
                    contadores[6]++;
                    break;
                case 'H':
                    contadores[7]++;
                    break;
                case 'I':
                    contadores[8]++;
                    break;
                case 'J':
                    contadores[9]++;
                    break;
                case 'K':
                    contadores[10]++;
                    break;
                case 'L':
                    contadores[11]++;
                    break;
                case 'M':
                    contadores[12]++;
                    break;
                case 'N':
                    contadores[13]++;
                    break;
                case 'Ñ':
                    contadores[14]++;
                    break;
                case 'O':
                    contadores[15]++;
                    break;
                case 'P':
                    contadores[16]++;
                    break;
                case 'Q':
                    contadores[17]++;
                    break;
                case 'R':
                    contadores[18]++;
                    break;
                case 'S':
                    contadores[19]++;
                    break;
                case 'T':
                    contadores[20]++;
                    break;
                case 'U':
                    contadores[21]++;
                    break;
                case 'V':
                    contadores[22]++;
                    break;
                case 'W':
                    contadores[23]++;
                    break;
                case 'X':
                    contadores[24]++;
                    break;
                case 'Y':
                    contadores[25]++;
                    break;
                case 'Z':
                    contadores[26]++;
                    break;
            }
        }
        //Caracteres generados y contados, vamos a buscar el contador más alto
        int valorMayor = 0;
        int contadorMayor = 0;
        for (int c = 0; c < contadores.length; c++)
            if (contadores[c] > valorMayor) {
                valorMayor = contadores[c];
                contadorMayor = c;
            }
        //Ya tenemos el contador mayor, que nos dice cuál es el caracter más repetido
        System.out.println("Caracter más repetido: " + abc.charAt(contadorMayor));
        System.out.println("Veces se repite: " + contadores[contadorMayor]);
 
    }
}

Como digo, funciona perfectamente. Pero hay que intentar ser más eficientes y buscar como evitar usar un switch tan grande.
Y en realidad basta con conservar el número que nos genera el objeto Random.
Este número nos dice de cuál posición del String de caracteres debemos extraer uno.

Y como las posiciones del String se corresponden con las posiciones de los contadores, esto significa que ese Random también nos está diciendo que contador debemos incrementar, sin tener que usar ningún switch.

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
public class Main
{
    public static void main(String[] args) {
        char[] caracteres = new char[30];
        int[] contadores = new int[27]; //Hay 27 posibles caracteres
        Random numLetra = new Random();
        String abc = "ABCDEFGHIJKLMNÑOPQRSTUVWXYZ"; //Estos son los posibles 27 caracteres
 
        for (int i = 0; i < caracteres.length; i++) {
            //Generamos numero al azar
            int azar = numLetra.nextInt(abc.length());
            //El número al azar nos dice que caracter debemos extraer
            caracteres[i] = abc.charAt(azar);
            //Mostramos en pantalla
            System.out.println(caracteres[i]);
            //El número al azar, también nos dice que contador hay que incrementar
            contadores[azar]++;
        }
        //Caracteres generados y contados, vamos a buscar el contador más alto
        int valorMayor = 0;
        int contadorMayor = 0;
        for (int c = 0; c < contadores.length; c++)
            if (contadores[c] > valorMayor) {
                valorMayor = contadores[c];
                contadorMayor = c;
            }
        //Ya tenemos el contador mayor, que nos dice cuál es el caracter más repetido
        System.out.println("Caracter más repetido: " + abc.charAt(contadorMayor));
        System.out.println("Veces se repite: " + contadores[contadorMayor]);
 
    }
}

Espero que estos dos ejemplos te sirvan.
Si algo no está claro o los ejemplos no son correctos por algún motivo, coméntalo aquí y lo vemos.

Un saludo.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
2
Comentar
sin imagen de perfil
Val: 23
Ha aumentado su posición en 167 puestos en Java (en relación al último mes)
Gráfica de Java

Ayuda con ejercicio java array de letras

Publicado por Yorhs (9 intervenciones) el 29/06/2021 15:32:42
MUCHAS GRACIAS ME SIRVIO MUCHO
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar