Hola y bienvenido.
En los métodos donde se van a modificar las cadenas, está bien usar StringBuilder porque seguramente vamos a seguir un proceso donde vamos a reconstruir una cadena haciendo la modificaciones que nos piden, por ejemplo, insertar asteriscos allá donde encontremos un diptongo.
Pero la cadena original sobre la que se va a trabajar no es necesario que sea StringBuilder.
Podría serlo, pero diría que es más correcto que sea un String normal.
La cadena original se supone que se ha de pedir al usuario por teclado, pero ahora mismo es más cómodo hacer pruebas con una cadena ya escrita en el código.
Lo de pedir cadena por teclado lo dejaría para el final, cuando todo lo demás esté terminado.
Sobre encontrar diptongos, te voy a proponer un código para resolverlo.
No es la única forma de hacerlo y de hecho seguramente hay formas más sencillas de hacerlo utilizando algunos métodos que ofrece la clase String como el replace() y/o usando
expresiones regulares (no importa si no sabes lo que son, ya llegarás a ellas cuando toque)
Pero la forma que propongo, digamos que es un poco más "artesanal", es usando lógica creada por nosotros y no lógica que ya venga programada de serie por otros.
Lo primero es saber qué es un diptongo.
Un diptongo es cuando en una palabra encontramos dos vocales juntas, y una de ellas o ambas, es una
vocal débil (Vocales débiles son : i, u)Así que vamos a tener que recorrer la cadena original, letra a letra, buscando vocales.
Por tanto, para facilitar la tarea, nos vendría bien un método que nos diga si un carácter (una letra) es vocal o no.
Por ejemplo, este método:
private static boolean esVocal(char caracter) {
switch(caracter) {
case 'a':
case 'e':
case 'i':
case 'o':
case 'u':
return true;
default:
return false;
}
}Es muy sencillo, si el caracter es a,e,i,o,u.. retorna TRUE.
Si es CUALQUIER otra cosa, retorna FALSE.
Bien, además de esto, nos puede interesar otro método que nos diga si el caracter que recibe, es una vocal débil o no.
Por ejemplo:
private static boolean esDebil(char caracter) {
if (caracter == 'i' || caracter == 'u')
return true;
else
return false;
}Es tan sencillo que no requiere explicación.
Fíjate que son porciones de código muy simples, y casi podríamos pensar que para tan poca cosa, no vale la pena crear métodos.
Pero lo cierto es que esto luego ayudará a que el código que escribamos después, sea más sencillo de leer y de entender.
Y ahora vamos con el método
diptongos()Haremos un método que reciba un String con la cadena original,y retornará otro String nuevo, con las modificaciones que hayan sido necesarias hacer en la cadena original.
Estas modificaciones van a consistir en señalar con asteriscos los diptongos que pueda contener esa cadena.
La lógica a seguir será:
- Iniciar un StringBuilder
- Recorrer cada carácter de la cadena original con un bucle e ir añadiéndolos al StringBuilder, intercalando asteriscos en caso de encontrar diptongos.
- Al seleccionar un carácter, comprobamos si es vocal.
Si no es vocal, no hacemos nada, lo añadimos al StringBuilder y pasamos al siguiente
Pero si es vocal, entonces tenemos que seleccionar también el siguiente carácter.
- Si el siguiente carácter NO es vocal, tampoco hacemos nada. Lo ignoramos y añadimos la vocal seleccionada al StringBuilder.
Pero, si el siguiente carácter SI es vocal, ahora tenemos que comprobar si una de estas vocales, o ambas, son DÉBILES.
- Si ninguna es débil, no hacemos nada. Ignoramos la vocal siguiente y añadimos la vocal actual al StringBuilder.
Pero, si una o ambas son DÉBILES, entonces al StringBuilder añadimos un asterisco, luego las dos vocales, y por último otro asterisco, quedando así señalizado el diptongo.
Además, en este caso, debemos hacer un incremento extra en el indice del bucle que recorre las letras, porque ya hemos comprobado y seleccionado la letra actual y la siguiente.
Así que el indice del bucle ha de hacer doble incremento para no que no seleccione el carácter siguiente al actual, ya que ambos ya han sido comprobados.
Este sería el código:
public static String diptongos(String cadena){
/*
* Un DIPTONGO es cuando se juntan una vocal fuerte y una débil,
* o bien dos vocales débiles.
* Así que buscaremos caracteres que sean VOCALES.
* Al encontrar una VOCAL, comprobaremos el carácter siguiente.
* Si también es VOCAL, comprobaremos si una de ellas,
* o ambas, son débiles, en cuyo caso tendremos un DIPTONGO
*/
StringBuilder aux = new StringBuilder();
char caracter = ' ';
//Comprobaremos todos los caracteres, uno a uno
try {
for (int i = 0 ; i < cadena.length(); i++){
//Cogemos un caracter de la cadena
caracter = cadena.toLowerCase().charAt(i);
//comprobamos si es vocal
if (esVocal(caracter)) {
//Es vocal, comprobemos siguiente caracter
char siguiente = cadena.toLowerCase().charAt(i+1);
if (esVocal(siguiente)) {
/*
* Si alguno de estos caracteres, o ambos,
* son vocales DÉBILES, entonces tenemos
* un DIPTONGO
*/
if (esDebil(caracter) || esDebil(siguiente)) {
//Es DIPTONGO, añadimos caracteres rodeados de asteriscos
aux.append('*');
aux.append(cadena.charAt(i));
aux.append(cadena.charAt(i+1));
aux.append('*');
/*
* Como ya hemos comprobado este caracter y el siguiente,
* aumentamos indice del bucle para evitar volver a comprobar
* el siguiente caracter
*/
i++;
}
else //No hay diptongo, agregamos caracter sin hacer nada
aux.append(cadena.charAt(i));
}
else //Segundo caracter no es vocal, añadimos primer caracter sin hacer nada
aux.append(cadena.charAt(i));
}
else //Primer caracter no es vocal, agregamos caracter sin hacer nada
aux.append(cadena.charAt(i));
}
}
catch(IndexOutOfBoundsException ex) {
/*
* Hemos intentado acceder a una posición de la cadena
* que está fuera de rango.
* Esto ocurrirá cuando el último carácter de la cadena es vocal
* y queremos comprobar el siguiente carácter para ver
* si hay diptongo, pero como ya estamos en el último
* no hay un caracter siguiente.
*
* En este caso, lo único que tenemos que hacer
* es agregar este último carácter al StringBuilder sin hacer nada
* más.
*/
aux.append(cadena.charAt(cadena.length() - 1 ));
}
//Retornamos el StringBuilder, convertido en un String "normal"
return aux.toString();
}Parece que hay mucho código, pero es por los comentarios.
Si los quitas, verás que en realidad son unas pocas líneas y que además son muy legibles gracias a los dos métodos que hemos escrito previamente.
Ahora, vamos preparar el método main() para poner a prueba este método.
Como dije, mejor usar un String normal y además ya escrito en el código para agilizar las pruebas.
Interesa que primero se muestre la cadena original, y luego se vaya mostrando de nuevo sucesivamente cada vez que se le haga modificaciones.
public static void main(String []args){
// -- Pedir la cadena y guardar en CadenaUsuario
String cadenaUsuario = "Ejemplos de DIPTONGOS: piensa, reino, puesto, pausa";
if (isNull(cadenaUsuario) ){
System.out.println("La cadena es vacia");
}else{
System.out.println("Cadena original:");
System.out.println(cadenaUsuario);
System.out.println("\n- Busqueda de DIPTONGOS:");
cadenaUsuario = diptongos(cadenaUsuario);
System.out.println(cadenaUsuario);
}
}En este caso, veremos la cadena original, y luego la volveremos a ver con los diptongos señalizados con asteriscos.
En pantalla sale esto:
Cadena original:
Ejemplos de DIPTONGOS: piensa, reino, puesto, pausa
- Busqueda de DIPTONGOS:
Ejemplos de DIPTONGOS: p*ie*nsa, r*ei*no, p*ue*sto, p*au*saParece que funciona correctamente
Analiza bien el código que he propuesto. Comprueba que entiendes cada línea de código, intenta discernir por ti mismo lo que te pueda resultar extraño, por ejemplo por qué estoy usando el método
.toLowerCase(). para seleccionar caracteres...
Y lo que no entiendas, no dudes en preguntarlo.
Y una vez lo entiendas, a ver si te sirve de inspiración para realizar el resto de cosas que pide el enunciado.
Si no, también te ayudaremos, no te preocupes.
Un saludo
Mostrar Mensajes
je je.
Felices fiestas a todos, y tomad todas las precauciones posibles contra el COVID.
RSS