Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » ArrayList - contador de "palabras"/letras iguales

Java - ArrayList - contador de "palabras"/letras iguales

Volver
Nuevo Tema
<<>>
 
Vista:
sin imagen de perfil

ArrayList - contador de "palabras"/letras iguales

Publicado por Guido (1 intervención) el 09/09/2022 23:52:26
Buenas a todos.

Quisiera saber si pueden ayudarme a resolver lo siguiente: Tengo que contar la cantidad de letras repetidas en un ArrayList usando ciclos for (puede ser anidado o no).

El ArrayList (llamado palabras) está compuesto de "letras"/"palabras" que ingresa el usuario por teclado. Luego de ello, las ordeno mediante el método Collections.sort(), e intento compararlas, pero tengo el problema de que, en primer lugar, el sout me imprime las letras repetidamente (no puedo lograr que imprima una vez por letra) y también, que la última letra en el Array, si es una, no la cuenta porque no entra en el "else".

for (int i = 0; i < palabras.size(); i++) {
for (int j = 0; j < palabras.size(); j++) {
if (palabras.get(i).equals(palabras.get(j))) {
contador++;
} else {
System.out.println(palabras.get(i) + " = se repite " + contador + "veces");
contador = 0;
}

}
}

Cualquier ayuda es bienvenida, desde ya, muchas gracias!
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

ArrayList - contador de "palabras"/letras iguales

Publicado por adivino (1 intervención) el 10/09/2022 00:05:10
Existen muchas formas de hacer esto.

Puedes apoyarte en la instrucción set para collections, ya que set no permite elementos duplicados

List aLista = Arrays.asList(ar);
Set<Integer> miSet = new HashSet<Integer>(aLista);
for(int s: miSet){
System.out.println(s + " " +Collections.frequency(aLista,s));
}

O bien crea un nuevo array y en éste vas ingresando todos los caracteres únicos, lógicamente tendrás que estar recorriendo muchas veces, para poder comparar y saber si hay ya un elemento que existe, una vez tengas ese array de elementos únicos, lo recorres contra el original y vas incrementando un contador por cada vez que lo encuentre, imprimes el contador y ahí tienes las veces que se repite cada uno.

O bien haz esto

int[] ar = {1, 2, 2, 1, 1, 3, 5,1, 2};
Arrays.sort(ar);
int contador=0;
int aux=ar[0];
for (int i = 0; i < ar.length; i++) {
if(aux == ar[i]){
contador++;
} else {
System.out.print(contador + ",");
contador=1;
aux=ar[i];
}
}
System.out.print(contador );
}

Para este caso te debe imprimir: 4,3,1,1
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

ArrayList - contador de "palabras"/letras iguales

Publicado por Cristian (2 intervenciones) el 27/10/2022 21:35:57
Hola estoy tratando de organizar lo siguiente tengo que buscar en un txt cuantas veces se repite una palabra e indicarlo
mi codigo seria el sigiente

Pero este no esta funconando bien

System.out.println(" "+tokens[0]);

switch (tokens[0]) {

case "begin":

String[] palabras = {linea};
Arrays.sort(palabras);
int contador =0;
String comp = palabras[0];
for (int i = 0; i < palabras.length; i++) {

if (comp == palabras[i]) {

contador = 1;
comp = palabras[i];

}else{

contador++;
escribirNuevo.write("Error 001 : Palabra no puede estar repetida");
escribirNuevo.newLine();
}

}

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

ArrayList - contador de "palabras"/letras iguales

Publicado por Kabuto (1381 intervenciones) el 28/10/2022 10:09:50
Si para empezar a comparar, inicializas la variable con la primera palabra que hay en el array:
1
String comp = palabras[0];

Entonces, el bucle que recorre las palabras no puede empezar desde 0. Porque entonces al comenzar SIEMPRE estás comparando la primera palabra, con ella misma, y por tanto te la va a detectar como repetida.
1
for (int i = 0; i < palabras.length; i++) {

Haz que el bucle comience por la segunda palabra, es decir, que comience en 1
1
for (int i = 1; i < palabras.length; i++) {

Luego, aquí la lógica te está fallando estrepitosamente:
1
2
3
4
5
6
7
8
9
10
11
if (comp == palabras[ i]) {
 
contador = 1;
comp = palabras[ i];
 
}else{
 
contador++;
escribirNuevo.write("Error 001 : Palabra no puede estar repetida");
escribirNuevo.newLine();
}

Ahí estas diciendo:
Si la palabra está repetida (comp == palabras[ i])
entonces contador es igual a 1

Por tanto, por muchas repeticiones que hayan de una misma palabra, el contador siempre será 1.

Y luego dices:
Si no hay repetición(o sea, si comp es distinto de palabras[ i])
entonces incrementas contador y escribes mensaje de error diciendo que hay repetición(cuando no la hay)


Así que todo ese proceso lógico hay que cambiarlo.

Y ahora tengo una duda.
¿Qué tiene que hacer exactamente el ejercicio?

- Usuario indica una palabra y comprobamos cuántas veces se repite ESA PALABRA en un texto.

- Recorrer un texto e indicar cuántas veces se repite CADA PALABRA de ese texto.


Lo pregunto porque la segunda opción, es bastante más complicada que la primera. ¿Cuál de las dos es?
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

ArrayList - contador de "palabras"/letras iguales

Publicado por crisitan (2 intervenciones) el 28/10/2022 20:46:48
El ejercicio es un compilador tengo que buscar difrentes temas por ejemplo que inicie con la palabra begin que tenga ; entre otros detalles si puedes me hablas a [email protected] y te doy mas claro el ejercicio que estoy desarrollando


esta lineas que me indican lo que hacen es recorrer un texto.txt

- Recorrer un texto e indicar cuántas veces se repite CADA PALABRA de ese texto.


gracias por las aclaraciones las voy a implementar
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
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

ArrayList - contador de "palabras"/letras iguales

Publicado por Kabuto (1381 intervenciones) el 28/10/2022 23:38:13
En ese caso, una forma sencilla se solucionarlo es usando dos ArrayList.

Un ArrayList será para guardar cada palabra encontrada en el texto.
Por cada palabra encontrada, se añade también un contador en el segundo ArrayList, inicializado a valor 0.

Antes de guardar cada palabra encontrada, comprobaremos si no existe ya en el ArrayList.
Si no existe, se añade junto con un contador en el segundo ArrayList.
Pero si existe, lo que hacemos es obtener en que posición del ArrayList se encuentra esa palabra.

En dicha posición, encontraremos su contador correspondiente en el otro ArrayList, y lo que haremos será incrementar ese contador.

Así al final podremos mostrar todas las palabras encontradas, junto con su contador de repeticiones.

Te dejo un código de ejemplo:
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
public class ContarRepetidas {
 
	public static void main(String[] args) {
 
		//Leemos archivo texto
		String texto = "";
		try {
			BufferedReader lector = new BufferedReader(new FileReader("d:/textos/machado3.txt"));
			String linea = lector.readLine();
			while (linea != null) {
				texto += linea;
				linea = lector.readLine();
			}
			lector.close();
		} catch (FileNotFoundException e) {
			System.out.println("Fichero no encontrado");
		} catch (IOException e) {
			System.out.println("Error de lectura");
		}
 
		//Separamos texto en palabras
		String[] palabras = texto.split(" ");
 
		/*
		 * Usamos dos ArrayList.
		 * Uno para añadir palabras encontradas.
		 * Por cada palabra añadida, se añade un contador al segundo ArrayList
		 * Cuando una palabra está repetida, es decir, ya existe en el primer ArrayList,
		 * entonces lo que hacemos es incrementar el contador correspondiente
		 */
		var encontradas = new ArrayList<String>();
		var contadores = new ArrayList<Integer>();
		//Recorremos las palabras del texto
		for (int i = 0; i < palabras.length; i++) {
			 //Si esta palabra ya consta como encontrada
			if (encontradas.contains(palabras[i])) {
				//Pedimos posicion que ocupa en ArrayList
				int posicion = encontradas.indexOf(palabras[i]);
				//Obtenemos contador asociado a esa palabra
				int contador =  contadores.get(posicion);
				//Lo incrementamos
				contador++;
				//Volvemos a colocar en su posicion del ArrayList
				contadores.set(posicion, contador);
			}
			else { //Si la palabra NO consta todavía como encontrada
				//Añadimos al ArrayList
				encontradas.add(palabras[i]);
				//Añadimos contador asociado
				contadores.add(0);
			}
		}
 
		//Bucle FOR ha terminado, mostramos los datos
		System.out.println("\t   PALABRAS ENCONTRADAS\t   REPETICIONES");
		System.out.println("\t   -------- -----------\t   ------------\n");
		for (int i = 0; i < encontradas.size(); i++)
			System.out.printf("\t\t%-20s\t%d\n", encontradas.get(i), contadores.get(i));
 
	}
 
}

En pantalla veremos que tenemos el resultado que buscamos:
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
Resultado:
 
	   PALABRAS ENCONTRADAS	   REPETICIONES
	   -------- -----------	   ------------
 
		Anoche              	3
		cuando              	3
		dormía              	3
		soñé                	3
		bendita             	3
		ilusión             	3
		que                 	4
		una                 	1
		fontana             	0
		fluía               	0
		dentro              	3
		de                  	6
		mi                  	3
		corazón             	3
		Di                  	0
		por                 	0
		qué                 	0
		acequia             	0
		escondida           	0
		agua                	0
		vienes              	0
		hasta               	0
		mí                  	0
		manantial           	0
		nueva               	0
		vida                	0
		donde               	0
		nunca               	0
		bebí                	0
		colmena             	0
		tenía               	1
		y                   	3
		las                 	1
		doradas             	0
		abejas              	0
		iban                	0
		fabricando          	0
		en                  	0
		él                  	0
		con                 	0
		amarguras           	0
		viejas              	0
		blanca              	0
		cera                	0
		dulce               	0
		miel                	0
		un                  	0
		ardiente            	1
		sol                 	1
		lucía               	0
		Era                 	0
		porque              	2
		daba                	0
		calores             	0
		rojo                	0
		hogar               	0
		era                 	1
		alumbraba           	0
		hacía               	0
		llorar              	0
		Dios                	0
		lo                  	0
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