Ayuda urgente con Arrays
Publicado por anonymous (1 intervención) el 06/12/2021 17:55:32
Hola compañeros, me llamo Javi y os escribo desde Jerez. Hace pocos días me han admitido en un grado a distancia y llevo mucho retraso con respecto a mis compañeros. Tengo dudas con varios ejercicios con arrays. Os los pongo por aquí y agradeceré enormemente la ayuda que me deis con cualquiera si no os importa. Os beberé una cervecita cuando paséis por aquí.
Ejercicio 1: cálculo de puntuaciones.
Juego de tablero indeterminado, con diferentes tipos de piezas
Estamos analizando la posibilidad de implementar un juego de mesa donde las puntuaciones de cada mano se anotan de la siguiente manera:
en cada mano puede haber entre uno y cuatro turnos;
para cada turno se puede haber ganado o perdido. Si se ha ganado se indica con el símbolo "X" o "x" (letra "equis" mayúscula o minúscula, ambas son válidas). Si no se ha ganado, se anota con el símbolo "O" u "o" (letra "o" mayúscula o minúscula, ambas son válidas);
cada turno ganado supone un punto. Un turno sin ganar supone cero puntos;
al anotarse la puntuación, la información de cada turno debe ir separada del carácter guion ("-");
la puntuación total de una mano se obtiene sumando los puntos de cada turno. Podrá estar por tanto entre cero puntos como mínimo y cuatro como máximo.
Aquí tienes algunos ejemplos cadenas de caracteres que indicarían anotaciones válidas de puntuaciones de distintas manos:
"X", que representaría un único turno en el que se ha ganado. La puntuación sería por tanto de 1;
"O", que indicaría un único turno en el que no se ha ganado. La puntuación sería de 0.
"X-O", con un turno ganado y otro que no. Puntuación de 1;
"X-X-X-X", que indicaría que se han ganado cuatro turnos. Puntuación de 4;
"o-X-x-O", con solo dos turnos ganados de un total de cuatro. Recuerda que debemos ser indiferentes a mayúsculas o minúsculas. Puntuación de 2;
"o-O-o", ningún turno ganado de un total de tres. Puntuación de 0;
Si la anotación de un turno no cumple esas reglas, se considera no válida y tendrá una puntuación de -1.
Se nos ha pedido que ideemos alguna manera de recibir todas las anotaciones de las manos de una partida y que calculemos la puntuación de cada mano.
Para ello tendrás que escribir un programa en Java que:
declare un array de objetos String con el siguiente contenido: {"a", "a-b", "X-A", "O-O-B", "X--X", "O-X-", "-X-X", "O-X-O-X-O", "o", "O-o", "X", "o-x-o", "x", "x-x", "O-x-X", "X-X-X", "x-X-X-x"}. Eso nos servirá como entrada para probar nuestro programa y evitaremos tener que estar tecleando continuamente casos de prueba;
muestre por pantalla el contenido de ese array de entradas (anotaciones de turnos). Para ello lo más sencillo es utilizar la herramienta Arrays.toString;
recorra cada elemento del array (cada anotación) y lo analice para ver si cumple o no con el patrón de anotación válida para un turno:
si cumple con el patrón, se considerará una anotación válida y se calculará su puntuación. La manera más sencilla de hacer esta comprobación es mediante expresiones regulares. Para obtener la puntuación de una anotación tendrás que descomponer cada uno de sus componentes (de tipo X/x o bien O/o) y acumular su valor;
si no cumple con el patrón, se considerará una anotación inválida y su puntuación será de -1;
tanto en un caso como en otro se incluirá la puntuación obtenida en un objeto cadena de tipo StringBuilder que al final del proceso contendrá las puntuaciones de cada anotación separadas por comas;
Una vez explorado el array completo se mostrarán por pantalla los siguientes resultados:
la lista completa de puntuaciones de cada mano separadas por comas. Será el contenido de la cadena StringBuilder que has tenido que ir construyendo durante el proceso;
la cantidad de anotaciones válidas encontradas;
la cantidad de anotaciones no válidas encontradas.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
CÁLCULO DE PUNTUACIONES
-----------------------
Anotaciones obtenidas de cada mano del juego:
[a, a-b, X-A, O-O-B, X--X, O-X-, -X-X, O-X-O-X-O, o, O-o, X, o-x-o, x, x-x, O-x-X, X-X-X, x-X-X-x]
RESULTADO: PUNTUACIONES CALCULADAS
----------------------------------
Puntuaciones: -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 1, 1, 1, 2, 2, 3, 4
Número de anotaciones válidas: 9.
Número de anotaciones inválidas: 8.
Ejercicio 2: reconocimiento de palíndromos.
Un palíndromo consiste en una palabra o frase que se lee igual en un sentido que en otro (por ejemplo, “Ana”, o “Ligar es ser ágil”). Nos han pedido que ideemos una forma sencilla de comprobar si un conjunto de textos son palíndromos o no.
Para ello tendrás que escribir un programa en Java que:
Declare un array de objetos String de entrada. Este array contendrá una serie de textos de ejemplo. Esos textos no contendrán otros caracteres salvo los alfabéticos (mayúsculas y minúsculas, sin acentos ni eñes), el espacio y los signos de puntuación (coma, punto, dos puntos, punto y coma) y nos servirán como entrada para probar nuestro programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Los textos que debe contener el array son:
"Reconocer";
"AMANECER";
"Esto no es un palindromo";
"Dabale arroz a la zorra el abad.";
"A man, a plan, a canal: Panama.";
"A man a plan and a canal, Panama.";
"No deseo ese don...".
Declare un array de boolean para los resultados. Servirá para almacenar en cada posición i si la cadena que hay en la posición i del array anterior es un palíndromo o no.
Reserve en memoria el tamaño apropiado para el array de boolean. No debes indicar el literal 7, sino que debes calcular el tamaño del array de entrada para que si éste cambiara de tamaño no hubiera que modificar nada más.
Recorra cada uno de los textos del array de entrada y los muestre por pantalla cada uno en una línea diferente, numerando cada línea y empezando por 1.
Vuelva a recorrer cada uno de los textos del array de entrada y para cada uno de ellos:
compruebe si se trata o no de un palíndromo, teniendo en cuenta que para este análisis solo se tienen en cuenta las letras y no los espacios o signos de puntuación. Y no olvides que aquí da igual que sean mayúsculas o minúsculas;
si se trata de un palíndromo, almacenaremos en la posición correspondiente del array de resultados el valor true. En caso contrario almacenaremos el valor false.
Muestre por pantalla el contenido de ese array de resultados.
Resultado del Ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
RECONOCIMIENTO DE PALÍNDROMOS
-----------------------------
Los textos que vamos a analizar son:
-Texto 1: Reconocer
-Texto 2: AMANECER
-Texto 3: Esto no es un palindromo
-Texto 4: Dabale arroz a la zorra el abad.
-Texto 5: A man, a plan, a canal: Panama
-Texto 6: A man a plan and a canal, Panama
-Texto 7: No deseo ese don...
RESULTADOS OBTENIDOS
--------------------
Palíndromos encontrados: [true, false, false, true, true, false, true]
Ejercicio 3: inversión de palabras.
Continuando con la manipulación de cadenas de caracteres, textos y palabras, nos piden ahora que pensemos en cómo podríamos invertir las letras de cada palabra de un texto, generando una lista de palabras invertidas para cada texto.
Para ello tendrás que escribir un programa en Java que:
Declare un array de objetos String de entrada. Este array contendrá una serie de textos de ejemplo. Son los mismos ejemplos que en el ejercicio anterior. Esos textos no contendrán otros caracteres salvo los alfabéticos (mayúsculas y minúsculas, sin acentos ni eñes), el espacio y los signos de puntuación (coma, punto, dos puntos, punto y coma) y nos servirán como entrada para probar nuestro programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Los textos que debe contener el array son:
"Reconocer";
"AMANECER";
"Esto no es un palindromo";
"Dabale arroz a la zorra el abad.";
"A man, a plan, a canal: Panama.";
"A man a plan and a canal, Panama.";
"No deseo ese don...".
Declare un array de String para los resultados. Servirá para almacenar en cada posición i la lista de palabras invertidas (separadas por espacios) correspondiente a cada texto.
Reserve en memoria el tamaño apropiado para el array de String. No debes indicar el literal 7, sino que debes calcular el tamaño del array de entrada para que si este cambiara de tamaño no hubiera que modificar nada más.
Recorra cada uno de los textos del array de entrada y los muestre por pantalla cada uno en una línea diferente, numerando cada línea y empezando por 1.
Vuelva a recorrer cada uno de los textos del array de entrada y para cada uno de ellos:
obtenga cada palabra del texto, teniendo en cuenta que se considera palabra toda acumulación de letras (tanto mayúsculas como minúsculas) hasta que se encuentren espacios o signos de puntuación. Aquí podría venirte muy bien el uso de métodos como trim o split;
se invierta cada una de esas palabras;
se almacenen todas en una misma cadena separándolas por un espacio. Esa cadena resultante se almacenará en el array de textos de resultados en la misma posición en la que se encontrara el texto original en el array de entrada.
Muestre por pantalla el contenido de ese array de resultados, imprimiendo para cada texto primero el original (en una línea) y a continuación el texto con las palabras invertidas (y ya sin signos de puntuación) en la siguiente línea.
Resultado del Ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
INVERSIÓN DE PALABRAS
---------------------
Los textos que vamos a analizar son:
-Texto 1: Reconocer
-Texto 2: AMANECER
-Texto 3: Esto no es un palindromo
-Texto 4: Dabale arroz a la zorra el abad.
-Texto 5: A man, a plan, a canal: Panama
-Texto 6: A man a plan and a canal, Panama
-Texto 7: No deseo ese don...
RESULTADOS OBTENIDOS
--------------------
Texto 1: "Reconocer"
Palabras invertidas: "reconoceR"
Texto 2: "AMANECER"
Palabras invertidas: "RECENAMA"
Texto 3: "Esto no es un palindromo"
Palabras invertidas: "otsE on se nu omordnilap"
Texto 4: "Dabale arroz a la zorra el abad."
Palabras invertidas: "elabaD zorra a al arroz le daba"
Texto 5: "A man, a plan, a canal: Panama"
Palabras invertidas: "A nam a nalp a lanac amanaP"
Texto 6: "A man a plan and a canal, Panama"
Palabras invertidas: "A nam a nalp dna a lanac amanaP"
Texto 7: "No deseo ese don..."
Palabras invertidas: "oN oesed ese nod"
Ejercicio 4: ¡línea!
Cartón de juego del bingo de nueve filas por cuatro columnas con una serie de números
Estamos modelando una aplicación para simular el juego del bingo y nos ha tocado implementar un comprobador de líneas para los cartones. Los cartones de nuestro bingo tienen una estructura de nueve filas por cuatro columnas con diecinueve números en cada cartón.
Vamos a modelar los cartones usando un array de dos dimensiones de números enteros donde la primera dimensión representará las filas del cartón. Será por tanto un array base de nueve elementos (la primera dimensión). Al tratarse de un array bidimensional, los elementos de la primera dimensión serán a su vez referencias a otros arrays cuyo tamaño máximo será de cuatro, pues estarán representando a cada una de las columnas o elementos que hay en cada fila. Estos arrays sí albergarán en su interior números enteros. No todos los arrays de la segunda dimensión serán de tamaño cuatro, pues no todas las filas del cartón contienen los cuatro elementos, tal y como puedes apreciar en la figura de ejemplo.
Esto significa que no vamos a tener un array "bidimensional regular" con nueve subarrays de cuatro elementos cada uno en forma de rectángulo "perfecto", pues algunos tendrán cuatro elementos, pero otros tendrán menos. No se trata de una tabla de nueve por cuatro con treinta y seis elementos. Por tanto tendrás que declarar el array apropiadamente para rellenarlo con la disposición que aparece en la ilustración de ejemplo.
Por otro lado, la representación de las bolas que han salido del bombo hasta el momento actual la modelaremos mediante un array unidimensional de números enteros. Vamos a suponer que las bolas que han salido hasta el momento son las siguientes: 1, 2, 5, 10, 11, 12, 14, 15, 22, 55, 56, 57, 59, 60, 61, 66, 78, 89, 90.
El programa deberá generar a partir de esa información un array de String que contenga un elemento por cada línea. Si esa línea ya se ha completado, se colocará el texto "línea" en ese elemento. Si aún faltan números por tachar, entonces se colocará el texto "no".
Para implementar nuestro prototipo tendrás que escribir un programa en Java que lleve a cabo las siguientes operaciones:
Declarar un array unidimensional de números enteros que represente las bolas que han salido hasta el momento. Contendrá la lista de números que se nos ha indicado.
Declarar un array bidimensional de números enteros para representar a un cartón específico con las normas que se nos han explicado. Los números que contendrá el array serán los indicados en la estructura irregular de nueve filas y cuatro columnas de la ilustración anterior.
Declarar un array unidimensional de String para almacenar los resultados (si se ha producido línea o no).
Mostrar por pantalla el contenido del cartón. La forma más sencilla es mediante la herramienta Arrays.deepToString.
Mostrar por pantalla la lista de bolas que han salido hasta el momento. La forma más sencilla es mediante la herramienta Arrays.ToString.
Reservar espacio para el array de resultados. Tendrá que ser del mismo tamaño que la cantidad de filas del cartón. Procura no usar un literal.
Recorrer cada fila del cartón (primera dimensión del array bidimensional):
para cada fila, habrá que recorrer todos los números que contenga (segunda dimensión del array) y comprobar si ya han salido o no;
si han salido todos, se marca esa fila como "línea" en el array de resultados;
si no han salido todos, se "marcará" como "no".
Mostrar por pantalla el array de resultados indicando las líneas que se han marcado y cuántas son.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
BUSCADOR DE LÍNEAS EN UN CARTÓN DE BINGO
----------------------------------------
Cartón: [[1, 2, 5, 9], [11, 15], [22, 29], [34], [47, 49], [55, 59, 60], [61], [71, 75], [88, 90]]
Números que ya han salido: [1, 2, 5, 10, 11, 12, 14, 15, 22, 55, 56, 57, 59, 60, 61, 66, 78, 89, 90]
RESULTADO
---------
Resultado de la búsqueda de líneas en el cartón de bingo:
[no, línea, no, no, no, línea, línea, no, no]
Número de líneas obtenidas: 3
Ejercicio 5: sopa de letras.
Sopa de letras de tamaño 5x5
Nuestro siguiente encargo está relacionado con el famoso pasatiempo de las "Sopas de letras". Nos han pedido que ideemos un mecanismo para averiguar si las palabras contenidas en una lista se encuentran o no en una determinada sopa. Para simplificar, solo vamos a realizar búsquedas en horizontal y de izquierda a derecha.
Para representar la sopa de letras vamos a usar un array bidimensional de char de tamaño 5x5. Esta vez sí será completamente regular (un rectángulo "perfecto"). El contenido será el de la ilustración adjunta. Las letras en la sopa estarán todas en mayúsculas. Numeraremos las filas y las columnas partiendo del cero, de manera que irán desde 0 hasta 4.
La lista de palabras será representada mediante un array de String. Las palabras de la lista serán "Hola", "sol", "AMOR", "ARA", "Casa", "dos". Como puedes observar a veces se usan mayúsculas y en otras ocasiones minúsculas. Nuestro programa no debería tener problema con eso.
El programa deberá generar a partir de esa información un array de String del mismo tamaño que la lista de palabras. En cada String de ese array se almacenará lo siguiente:
el texto "no", si la palabra no se encuentra horizontalmente en la sopa;
el texto "fila xxx columna yyy", si la palabra sí se encuentra horizontalmente en la sopa, en la fila xxx y columna yyy.
Para implementar nuestro prototipo tendrás que escribir un programa en Java que lleve a cabo las siguientes operaciones:
Declarar un array unidimensional de String que represente la lista de palabras que se desean buscar en la sopa. Contendrá la lista de palabras que se nos ha indicado.
Declarar un array bidimensional de caracteres (tipo char) para representar la sopa de letras. Los caracteres que contendrá el array serán las letras indicadas en la ilustración anterior.
Declarar un array unidimensional de String para almacenar los resultados.
Mostrar por pantalla el contenido de la sopa de letras en forma de tabla. La forma más sencilla es mediante un doble bucle que recorra filas y columnas.
Mostrar por pantalla la lista de palabras que van a ser buscadas en la sopa. La forma más sencilla es mediante la herramienta Arrays.ToString.
Reservar espacio para el array de resultados. Tendrá que ser del mismo tamaño que la cantidad de palabras que van a ser buscadas. Procura no usar un literal.
Explorar la sopa de letras para buscar horizontalmente cada una de las palabras de la lista. Para cada palabra, se almacenará en el array de resultados:
el texto "no", si la palabra no se encuentra horizontalmente en la sopa;
el texto "fila xxx columna yyy", si la palabra sí se encuentra horizontalmente en la sopa, ubicada en la fila xxx, columna yyy.
Mostrar por pantalla el array de resultados indicando las palabras que se han encontrado y cuántas son.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
BUSCADOR DE PALABRAS EN HORIZONTAL
----------------------------------
Sopa de letras:
H J S O L
O E C A U
L Y K D A
A A M O R
V C A S A
Lista de palabras de prueba:
[Hola, sol, AMOR, ARA, Casa, dos]
RESULTADO
---------
Resultado de la búsqueda horizontal:
[no, fila 0 columna 2, fila 3 columna 1, no, fila 4 columna 1, no]
Número de palabras encontradas: 3
Ejercicio 1: cálculo de puntuaciones.
Juego de tablero indeterminado, con diferentes tipos de piezas
Estamos analizando la posibilidad de implementar un juego de mesa donde las puntuaciones de cada mano se anotan de la siguiente manera:
en cada mano puede haber entre uno y cuatro turnos;
para cada turno se puede haber ganado o perdido. Si se ha ganado se indica con el símbolo "X" o "x" (letra "equis" mayúscula o minúscula, ambas son válidas). Si no se ha ganado, se anota con el símbolo "O" u "o" (letra "o" mayúscula o minúscula, ambas son válidas);
cada turno ganado supone un punto. Un turno sin ganar supone cero puntos;
al anotarse la puntuación, la información de cada turno debe ir separada del carácter guion ("-");
la puntuación total de una mano se obtiene sumando los puntos de cada turno. Podrá estar por tanto entre cero puntos como mínimo y cuatro como máximo.
Aquí tienes algunos ejemplos cadenas de caracteres que indicarían anotaciones válidas de puntuaciones de distintas manos:
"X", que representaría un único turno en el que se ha ganado. La puntuación sería por tanto de 1;
"O", que indicaría un único turno en el que no se ha ganado. La puntuación sería de 0.
"X-O", con un turno ganado y otro que no. Puntuación de 1;
"X-X-X-X", que indicaría que se han ganado cuatro turnos. Puntuación de 4;
"o-X-x-O", con solo dos turnos ganados de un total de cuatro. Recuerda que debemos ser indiferentes a mayúsculas o minúsculas. Puntuación de 2;
"o-O-o", ningún turno ganado de un total de tres. Puntuación de 0;
Si la anotación de un turno no cumple esas reglas, se considera no válida y tendrá una puntuación de -1.
Se nos ha pedido que ideemos alguna manera de recibir todas las anotaciones de las manos de una partida y que calculemos la puntuación de cada mano.
Para ello tendrás que escribir un programa en Java que:
declare un array de objetos String con el siguiente contenido: {"a", "a-b", "X-A", "O-O-B", "X--X", "O-X-", "-X-X", "O-X-O-X-O", "o", "O-o", "X", "o-x-o", "x", "x-x", "O-x-X", "X-X-X", "x-X-X-x"}. Eso nos servirá como entrada para probar nuestro programa y evitaremos tener que estar tecleando continuamente casos de prueba;
muestre por pantalla el contenido de ese array de entradas (anotaciones de turnos). Para ello lo más sencillo es utilizar la herramienta Arrays.toString;
recorra cada elemento del array (cada anotación) y lo analice para ver si cumple o no con el patrón de anotación válida para un turno:
si cumple con el patrón, se considerará una anotación válida y se calculará su puntuación. La manera más sencilla de hacer esta comprobación es mediante expresiones regulares. Para obtener la puntuación de una anotación tendrás que descomponer cada uno de sus componentes (de tipo X/x o bien O/o) y acumular su valor;
si no cumple con el patrón, se considerará una anotación inválida y su puntuación será de -1;
tanto en un caso como en otro se incluirá la puntuación obtenida en un objeto cadena de tipo StringBuilder que al final del proceso contendrá las puntuaciones de cada anotación separadas por comas;
Una vez explorado el array completo se mostrarán por pantalla los siguientes resultados:
la lista completa de puntuaciones de cada mano separadas por comas. Será el contenido de la cadena StringBuilder que has tenido que ir construyendo durante el proceso;
la cantidad de anotaciones válidas encontradas;
la cantidad de anotaciones no válidas encontradas.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
CÁLCULO DE PUNTUACIONES
-----------------------
Anotaciones obtenidas de cada mano del juego:
[a, a-b, X-A, O-O-B, X--X, O-X-, -X-X, O-X-O-X-O, o, O-o, X, o-x-o, x, x-x, O-x-X, X-X-X, x-X-X-x]
RESULTADO: PUNTUACIONES CALCULADAS
----------------------------------
Puntuaciones: -1, -1, -1, -1, -1, -1, -1, -1, 0, 0, 1, 1, 1, 2, 2, 3, 4
Número de anotaciones válidas: 9.
Número de anotaciones inválidas: 8.
Ejercicio 2: reconocimiento de palíndromos.
Un palíndromo consiste en una palabra o frase que se lee igual en un sentido que en otro (por ejemplo, “Ana”, o “Ligar es ser ágil”). Nos han pedido que ideemos una forma sencilla de comprobar si un conjunto de textos son palíndromos o no.
Para ello tendrás que escribir un programa en Java que:
Declare un array de objetos String de entrada. Este array contendrá una serie de textos de ejemplo. Esos textos no contendrán otros caracteres salvo los alfabéticos (mayúsculas y minúsculas, sin acentos ni eñes), el espacio y los signos de puntuación (coma, punto, dos puntos, punto y coma) y nos servirán como entrada para probar nuestro programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Los textos que debe contener el array son:
"Reconocer";
"AMANECER";
"Esto no es un palindromo";
"Dabale arroz a la zorra el abad.";
"A man, a plan, a canal: Panama.";
"A man a plan and a canal, Panama.";
"No deseo ese don...".
Declare un array de boolean para los resultados. Servirá para almacenar en cada posición i si la cadena que hay en la posición i del array anterior es un palíndromo o no.
Reserve en memoria el tamaño apropiado para el array de boolean. No debes indicar el literal 7, sino que debes calcular el tamaño del array de entrada para que si éste cambiara de tamaño no hubiera que modificar nada más.
Recorra cada uno de los textos del array de entrada y los muestre por pantalla cada uno en una línea diferente, numerando cada línea y empezando por 1.
Vuelva a recorrer cada uno de los textos del array de entrada y para cada uno de ellos:
compruebe si se trata o no de un palíndromo, teniendo en cuenta que para este análisis solo se tienen en cuenta las letras y no los espacios o signos de puntuación. Y no olvides que aquí da igual que sean mayúsculas o minúsculas;
si se trata de un palíndromo, almacenaremos en la posición correspondiente del array de resultados el valor true. En caso contrario almacenaremos el valor false.
Muestre por pantalla el contenido de ese array de resultados.
Resultado del Ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
RECONOCIMIENTO DE PALÍNDROMOS
-----------------------------
Los textos que vamos a analizar son:
-Texto 1: Reconocer
-Texto 2: AMANECER
-Texto 3: Esto no es un palindromo
-Texto 4: Dabale arroz a la zorra el abad.
-Texto 5: A man, a plan, a canal: Panama
-Texto 6: A man a plan and a canal, Panama
-Texto 7: No deseo ese don...
RESULTADOS OBTENIDOS
--------------------
Palíndromos encontrados: [true, false, false, true, true, false, true]
Ejercicio 3: inversión de palabras.
Continuando con la manipulación de cadenas de caracteres, textos y palabras, nos piden ahora que pensemos en cómo podríamos invertir las letras de cada palabra de un texto, generando una lista de palabras invertidas para cada texto.
Para ello tendrás que escribir un programa en Java que:
Declare un array de objetos String de entrada. Este array contendrá una serie de textos de ejemplo. Son los mismos ejemplos que en el ejercicio anterior. Esos textos no contendrán otros caracteres salvo los alfabéticos (mayúsculas y minúsculas, sin acentos ni eñes), el espacio y los signos de puntuación (coma, punto, dos puntos, punto y coma) y nos servirán como entrada para probar nuestro programa. De este modo evitaremos tener que estar tecleando continuamente casos de prueba. Los textos que debe contener el array son:
"Reconocer";
"AMANECER";
"Esto no es un palindromo";
"Dabale arroz a la zorra el abad.";
"A man, a plan, a canal: Panama.";
"A man a plan and a canal, Panama.";
"No deseo ese don...".
Declare un array de String para los resultados. Servirá para almacenar en cada posición i la lista de palabras invertidas (separadas por espacios) correspondiente a cada texto.
Reserve en memoria el tamaño apropiado para el array de String. No debes indicar el literal 7, sino que debes calcular el tamaño del array de entrada para que si este cambiara de tamaño no hubiera que modificar nada más.
Recorra cada uno de los textos del array de entrada y los muestre por pantalla cada uno en una línea diferente, numerando cada línea y empezando por 1.
Vuelva a recorrer cada uno de los textos del array de entrada y para cada uno de ellos:
obtenga cada palabra del texto, teniendo en cuenta que se considera palabra toda acumulación de letras (tanto mayúsculas como minúsculas) hasta que se encuentren espacios o signos de puntuación. Aquí podría venirte muy bien el uso de métodos como trim o split;
se invierta cada una de esas palabras;
se almacenen todas en una misma cadena separándolas por un espacio. Esa cadena resultante se almacenará en el array de textos de resultados en la misma posición en la que se encontrara el texto original en el array de entrada.
Muestre por pantalla el contenido de ese array de resultados, imprimiendo para cada texto primero el original (en una línea) y a continuación el texto con las palabras invertidas (y ya sin signos de puntuación) en la siguiente línea.
Resultado del Ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
INVERSIÓN DE PALABRAS
---------------------
Los textos que vamos a analizar son:
-Texto 1: Reconocer
-Texto 2: AMANECER
-Texto 3: Esto no es un palindromo
-Texto 4: Dabale arroz a la zorra el abad.
-Texto 5: A man, a plan, a canal: Panama
-Texto 6: A man a plan and a canal, Panama
-Texto 7: No deseo ese don...
RESULTADOS OBTENIDOS
--------------------
Texto 1: "Reconocer"
Palabras invertidas: "reconoceR"
Texto 2: "AMANECER"
Palabras invertidas: "RECENAMA"
Texto 3: "Esto no es un palindromo"
Palabras invertidas: "otsE on se nu omordnilap"
Texto 4: "Dabale arroz a la zorra el abad."
Palabras invertidas: "elabaD zorra a al arroz le daba"
Texto 5: "A man, a plan, a canal: Panama"
Palabras invertidas: "A nam a nalp a lanac amanaP"
Texto 6: "A man a plan and a canal, Panama"
Palabras invertidas: "A nam a nalp dna a lanac amanaP"
Texto 7: "No deseo ese don..."
Palabras invertidas: "oN oesed ese nod"
Ejercicio 4: ¡línea!
Cartón de juego del bingo de nueve filas por cuatro columnas con una serie de números
Estamos modelando una aplicación para simular el juego del bingo y nos ha tocado implementar un comprobador de líneas para los cartones. Los cartones de nuestro bingo tienen una estructura de nueve filas por cuatro columnas con diecinueve números en cada cartón.
Vamos a modelar los cartones usando un array de dos dimensiones de números enteros donde la primera dimensión representará las filas del cartón. Será por tanto un array base de nueve elementos (la primera dimensión). Al tratarse de un array bidimensional, los elementos de la primera dimensión serán a su vez referencias a otros arrays cuyo tamaño máximo será de cuatro, pues estarán representando a cada una de las columnas o elementos que hay en cada fila. Estos arrays sí albergarán en su interior números enteros. No todos los arrays de la segunda dimensión serán de tamaño cuatro, pues no todas las filas del cartón contienen los cuatro elementos, tal y como puedes apreciar en la figura de ejemplo.
Esto significa que no vamos a tener un array "bidimensional regular" con nueve subarrays de cuatro elementos cada uno en forma de rectángulo "perfecto", pues algunos tendrán cuatro elementos, pero otros tendrán menos. No se trata de una tabla de nueve por cuatro con treinta y seis elementos. Por tanto tendrás que declarar el array apropiadamente para rellenarlo con la disposición que aparece en la ilustración de ejemplo.
Por otro lado, la representación de las bolas que han salido del bombo hasta el momento actual la modelaremos mediante un array unidimensional de números enteros. Vamos a suponer que las bolas que han salido hasta el momento son las siguientes: 1, 2, 5, 10, 11, 12, 14, 15, 22, 55, 56, 57, 59, 60, 61, 66, 78, 89, 90.
El programa deberá generar a partir de esa información un array de String que contenga un elemento por cada línea. Si esa línea ya se ha completado, se colocará el texto "línea" en ese elemento. Si aún faltan números por tachar, entonces se colocará el texto "no".
Para implementar nuestro prototipo tendrás que escribir un programa en Java que lleve a cabo las siguientes operaciones:
Declarar un array unidimensional de números enteros que represente las bolas que han salido hasta el momento. Contendrá la lista de números que se nos ha indicado.
Declarar un array bidimensional de números enteros para representar a un cartón específico con las normas que se nos han explicado. Los números que contendrá el array serán los indicados en la estructura irregular de nueve filas y cuatro columnas de la ilustración anterior.
Declarar un array unidimensional de String para almacenar los resultados (si se ha producido línea o no).
Mostrar por pantalla el contenido del cartón. La forma más sencilla es mediante la herramienta Arrays.deepToString.
Mostrar por pantalla la lista de bolas que han salido hasta el momento. La forma más sencilla es mediante la herramienta Arrays.ToString.
Reservar espacio para el array de resultados. Tendrá que ser del mismo tamaño que la cantidad de filas del cartón. Procura no usar un literal.
Recorrer cada fila del cartón (primera dimensión del array bidimensional):
para cada fila, habrá que recorrer todos los números que contenga (segunda dimensión del array) y comprobar si ya han salido o no;
si han salido todos, se marca esa fila como "línea" en el array de resultados;
si no han salido todos, se "marcará" como "no".
Mostrar por pantalla el array de resultados indicando las líneas que se han marcado y cuántas son.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
BUSCADOR DE LÍNEAS EN UN CARTÓN DE BINGO
----------------------------------------
Cartón: [[1, 2, 5, 9], [11, 15], [22, 29], [34], [47, 49], [55, 59, 60], [61], [71, 75], [88, 90]]
Números que ya han salido: [1, 2, 5, 10, 11, 12, 14, 15, 22, 55, 56, 57, 59, 60, 61, 66, 78, 89, 90]
RESULTADO
---------
Resultado de la búsqueda de líneas en el cartón de bingo:
[no, línea, no, no, no, línea, línea, no, no]
Número de líneas obtenidas: 3
Ejercicio 5: sopa de letras.
Sopa de letras de tamaño 5x5
Nuestro siguiente encargo está relacionado con el famoso pasatiempo de las "Sopas de letras". Nos han pedido que ideemos un mecanismo para averiguar si las palabras contenidas en una lista se encuentran o no en una determinada sopa. Para simplificar, solo vamos a realizar búsquedas en horizontal y de izquierda a derecha.
Para representar la sopa de letras vamos a usar un array bidimensional de char de tamaño 5x5. Esta vez sí será completamente regular (un rectángulo "perfecto"). El contenido será el de la ilustración adjunta. Las letras en la sopa estarán todas en mayúsculas. Numeraremos las filas y las columnas partiendo del cero, de manera que irán desde 0 hasta 4.
La lista de palabras será representada mediante un array de String. Las palabras de la lista serán "Hola", "sol", "AMOR", "ARA", "Casa", "dos". Como puedes observar a veces se usan mayúsculas y en otras ocasiones minúsculas. Nuestro programa no debería tener problema con eso.
El programa deberá generar a partir de esa información un array de String del mismo tamaño que la lista de palabras. En cada String de ese array se almacenará lo siguiente:
el texto "no", si la palabra no se encuentra horizontalmente en la sopa;
el texto "fila xxx columna yyy", si la palabra sí se encuentra horizontalmente en la sopa, en la fila xxx y columna yyy.
Para implementar nuestro prototipo tendrás que escribir un programa en Java que lleve a cabo las siguientes operaciones:
Declarar un array unidimensional de String que represente la lista de palabras que se desean buscar en la sopa. Contendrá la lista de palabras que se nos ha indicado.
Declarar un array bidimensional de caracteres (tipo char) para representar la sopa de letras. Los caracteres que contendrá el array serán las letras indicadas en la ilustración anterior.
Declarar un array unidimensional de String para almacenar los resultados.
Mostrar por pantalla el contenido de la sopa de letras en forma de tabla. La forma más sencilla es mediante un doble bucle que recorra filas y columnas.
Mostrar por pantalla la lista de palabras que van a ser buscadas en la sopa. La forma más sencilla es mediante la herramienta Arrays.ToString.
Reservar espacio para el array de resultados. Tendrá que ser del mismo tamaño que la cantidad de palabras que van a ser buscadas. Procura no usar un literal.
Explorar la sopa de letras para buscar horizontalmente cada una de las palabras de la lista. Para cada palabra, se almacenará en el array de resultados:
el texto "no", si la palabra no se encuentra horizontalmente en la sopa;
el texto "fila xxx columna yyy", si la palabra sí se encuentra horizontalmente en la sopa, ubicada en la fila xxx, columna yyy.
Mostrar por pantalla el array de resultados indicando las palabras que se han encontrado y cuántas son.
Resultado del ejercicio
Dado que no hay que introducir datos de entrada y todos los valores son fijos, la ejecución de tu programa siempre deberá proporcionar el mismo resultado. Aquí tienes una muestra de cómo podría quedar:
BUSCADOR DE PALABRAS EN HORIZONTAL
----------------------------------
Sopa de letras:
H J S O L
O E C A U
L Y K D A
A A M O R
V C A S A
Lista de palabras de prueba:
[Hola, sol, AMOR, ARA, Casa, dos]
RESULTADO
---------
Resultado de la búsqueda horizontal:
[no, fila 0 columna 2, fila 3 columna 1, no, fila 4 columna 1, no]
Número de palabras encontradas: 3
Valora esta pregunta
-1