Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » Java » contar letras con switch

Java - contar letras con switch

Volver
Nuevo Tema
<<>>
 
Vista:

contar letras con switch

Publicado por Gloria López (1 intervención) el 30/11/2021 15:51:32
Estoy aprendiendo programación y estoy realizando una actividad con la que tengo dudas. A ver si alguien me puede explicar en qué fallo por favor.

La actividad consiste en escribir un programa en el que se solicite al usuario un texto de al menos cinco caracteres de longitud. Si no contiene al menos cinco caracteres se le volverá a pedir hasta que cumpla con el requisito.

Cuando cumpla el primer requisito, se solicitará un número entero que servirá como "multiplicador", y que debe estar obligatoriamente entre 1 y 3. De nuevo, si se introduce cualquier otro valor que no se encuentre en ese rango, habrá que volver a solicitarlo hasta que lo cumpla.

Una vez que se disponga del texto y el multiplicador, se procederá al cálculo de la puntuación inicial del texto, teniendo en cuenta las siguientes reglas:

cada vocal, tanto si es minúscula como mayúscula, valdrá un punto;
las letras x, y, z (minúsculas), valdrán dos puntos;
la letra X (mayúscula), valdrá cinco puntos;
cualquier otro carácter (tanto si es letra como si es otra cosa), restará un punto.
Una vez obtenida esa puntuación inicial, deberás multiplicarla por el valor "multiplicador" para calcular la puntuación final.

Para ello, os dejo el código que yo he formulado. Tengo que ir trabajando caracter a caracter con texto.charAt(), pero me da error porque String no puede coinvertirse en char.

public static void main(String[] args) {
//----------------------------------------------
// Declaración de variables
//----------------------------------------------
// Constantes

// Variables de entrada
String texto;
int multiplicador = 0;
int index;
int a = 0, e = 0, i = 0, o = 0, u = 0, A = 0, E = 0, I = 0, O = 0, U = 0, X = 0, x = 0, y = 0, z = 0, r=0;
// Variables de salida
int vocales, consonantes, mayuscula, restante;
// Variables auxiliares
boolean entradaValida1=false, entradaValida2=false;

// Clase Scanner para petición de datos
Scanner teclado = new Scanner(System.in);

//----------------------------------------------
// Entrada de datos
//----------------------------------------------
System.out.println("VALOR DE UN TEXTO");
System.out.println("------------------");
do {
System.out.println("Introduzca un texto con al menos 5 caracteres: ");
texto=teclado.nextLine();
if (texto.length() >=5) { //Si el texto tiene más de 5 caracteres, la entrada es válida y se pide el siguiente dato (multiplicador).
entradaValida1= true;
do {
System.out.println("Introduzca el valor del multiplicador (entre 1-3): ");
multiplicador=teclado.nextInt();
if (multiplicador>=1 && multiplicador<=3) {
entradaValida2=true;
}
}while (!entradaValida2);
}
}while (!entradaValida1);



//----------------------------------------------
// Procesamiento
//----------------------------------------------
for (index=0; index<texto.length(); index++){
switch (texto.charAt(index)) {
case "a": case "e": case "i": case "o": case "u": case "A": case "E": case "I": case "O": case "U": //Conteo de vocales maúsculas y minúculas
a++; e++; i++; o++; u++; A++; E++; I++; O++; U++;
break;
case "x": case "y": case "z": //Conteo de las letras x, y, y z que aparece en el texto.
x++; y++; z++;
break;
case "X": //Conteo de la letra X que hay en el texto.
X++;
break;
default: //Conteo de restos de caracteres que hay en el texto.
r++;
break;
}
}
//Calculo del total de puntos que hay de cada caracter en el texto.
vocales= (a + e + i + o + u + A + E + I + O + U);
consonantes= (x + y + z) * 2;
mayuscula= X * 5;
restante= r;


//----------------------------------------------
// Salida de resultados
//----------------------------------------------
System.out.println();
System.out.println("RESULTADO");
System.out.println("---------");
System.out.println("El valor del texto es " + ((vocales+consonantes+mayuscula)-restante)*multiplicador + "."); //Se suma los puntos y multiplicar por el multiplicador que el usuario introduce.

}
}
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

contar letras con switch

Publicado por Kabuto (1381 intervenciones) el 01/12/2021 00:57:57
Hola.

El método charAt() te da un dato de tipo char.

Pero en el switch estás intentando compararlos con Strings, y como son datos de tipos distintos, no te lo admite.

Sin embargo, es muy fácil de corregir.
En Java, cualquier cosa que esté dentro de comillas dobles, es un String ---> "A"
Los caracteres de tipo char, en cambio, están dentro de comillas simples ---> 'A'

Así que tan solo necesitas cambiar las comillas dobles del switch, por comillas simples, y ahora si estarás trabajando con char y no con String.


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
for (index=0; index<texto.length(); index++){
			switch (texto.charAt(index)) {
			case 'a': case 'e': case 'i': case 'o': case 'u': case 'A': case 'E': case 'I': case 'O': case 'U': //Conteo de vocales maúsculas y minúculas
				a++; e++; i++; o++; u++; A++; E++; I++; O++; U++;
				break;
			case 'x': case 'y': case 'z': //Conteo de las letras x, y, y z que aparece en el texto.
				x++; y++; z++;
				break;
			case 'X': //Conteo de la letra X que hay en el texto.
				X++;
				break;
			default: //Conteo de restos de caracteres que hay en el texto.
				r++;
				break;
			}
		}


A parte de esto, te comento que puedas ahorrar/optimizar código en la entrada de datos.
Puedes prescindir de los boolean auxiliares y los if.
Basta con que en los bucles do while uses como condiciones, las expresiones que usabas en los if, pero invirtiendo su sentido.

Es decir, puedes decir que la entrada de la cadena String se repita mientras que su longitud sea menor que 5

Y que la entrada del multiplicador se repita mientras que su valor sea menor que 1 ó si es mayor que 3

Además no hace falta anidar un bucle dentro del otro.

Si hacemos estos cambios, se reducen líneas de código y queda más legible a ojos humanos.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
		//----------------------------------------------
		// Entrada de datos
		//----------------------------------------------
		System.out.println("VALOR DE UN TEXTO");
		System.out.println("------------------");
 
		do {
			System.out.println("Introduzca un texto con al menos 5 caracteres: ");
			texto=teclado.nextLine();
		} while(texto.length() < 5);
 
		do {
			System.out.println("Introduzca el valor del multiplicador (entre 1-3): ");
			multiplicador=teclado.nextInt();
		} while(multiplicador < 1 || multiplicador > 3);


Luego, el procesamiento no es correcto.
Por ejemplo, para contar las vocales, tal y como lo has expresado, basta con que haya una sola vocal, para que se incrementen los 10 contadores:
1
2
3
case 'a': case 'e': case 'i': case 'o': case 'u': case 'A': case 'E': case 'I': case 'O': case 'U': //Conteo de vocales maúsculas y minúculas
				a++; e++; i++; o++; u++; A++; E++; I++; O++; U++;
				break;
Cada vez que se cumple uno solo de esos "cases", se incrementan los 10 contadores por igual.
Para evitarlo, cada "case" tendría que ir por separado, incrementar su contador asociado y hacer break;

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
switch (texto.charAt(index)) {
			case 'a':
				a++;
				break;
			case 'e':
				e++;
				break;
			case 'i':
				i++;
				break;
			case 'o':
				o++;
				break;
			case 'u':
				u++;
				break;
			case 'A':
				A++;
				break;
			case 'E':
				E++;
				break;
			case 'I':
				i++;
				break;
			case 'O':
				o++;
				break;
			case 'U':
				u++;
				break;

Pero es que en realidad, NO NECESITAS 10 contadores

Si necesitáramos detallar cada vocal encontrada, entonces sí.
O si cada vocal tuviera un valor distinto...

Pero no es el caso, cada vocal encontrada vale 1 punto, da igual la que sea.
Así que en realidad, si necesitas 10 cases, pero con un solo contador.

1
2
3
case 'a': case 'e': case 'i': case 'o': case 'u': case 'A': case 'E': case 'I': case 'O': case 'U': //Conteo de vocales maúsculas y minúculas
				vocalesContadas++;
				break;

Con las minúsculas x, y, z, te pasa lo mismo.
Por cada una, se aumentan tres contadores..., y tampoco necesitas tres contadores, también te basta con uno solo.
1
2
3
case 'x': case 'y': case 'z': //Conteo de las letras x, y, y z que aparece en el texto.
				xyzContadas++;
				break;


Entonces, al reducir contadores, también se reducen la cantidad de variables declaradas y se simplifica un poco los cálculos al final del programa.
El código final podría quedar así:
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
public static void main(String[] args) {
		//----------------------------------------------
		// Declaración de variables
		//----------------------------------------------
		// Constantes
 
		// Variables de entrada
		String texto;
		int multiplicador = 0;
		int index;
		int vocalesContadas = 0, xyzContadas = 0, X = 0, r=0;
		// Variables de salida
		int consonantes, mayuscula;
 
		// Clase Scanner para petición de datos
		Scanner teclado = new Scanner(System.in);
 
		//----------------------------------------------
		// Entrada de datos
		//----------------------------------------------
		System.out.println("VALOR DE UN TEXTO");
		System.out.println("------------------");
 
		do {
			System.out.println("Introduzca un texto con al menos 5 caracteres: ");
			texto=teclado.nextLine();
		} while(texto.length() < 5);
 
		do {
			System.out.println("Introduzca el valor del multiplicador (entre 1-3): ");
			multiplicador=teclado.nextInt();
		} while(multiplicador < 1 || multiplicador > 3);
 
		//----------------------------------------------
		// Procesamiento
		//----------------------------------------------
		for (index=0; index<texto.length(); index++){
			switch (texto.charAt(index)) {
 
			case 'a': case 'e': case 'i': case 'o': case 'u': case 'A': case 'E': case 'I': case 'O': case 'U': //Conteo de vocales maúsculas y minúculas
				vocalesContadas++;
				break;
			case 'x': case 'y': case 'z': //Conteo de las letras x, y, y z que aparece en el texto.
				xyzContadas++;
				break;
			case 'X': //Conteo de la letra X que hay en el texto.
				X++;
				break;
			default: //Conteo de restos de caracteres que hay en el texto.
				r++;
				break;
			}
		}
		//Calculo del total de puntos que hay de cada caracter en el texto.
		consonantes= xyzContadas * 2;
		mayuscula= X * 5;
 
		//----------------------------------------------
		// Salida de resultados
		//----------------------------------------------
		System.out.println();
		System.out.println("RESULTADO");
		System.out.println("---------");
		System.out.println("El valor del texto es " + ((vocalesContadas+consonantes+mayuscula)-r)*multiplicador + "."); //Se suma los puntos y multiplicar por el multiplicador que el usuario introduce.
 
	}

Si algo no ha quedado claro, solo tienes que preguntar.

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
0
Comentar