Java - Matriz Capicúa

 
Vista:

Matriz Capicúa

Publicado por Mariana (1 intervención) el 13/09/2018 15:00:25
Dada una matriz, indicar la cantidad de filas que son capicúas. Ejemplo de fila capicúa: 15 120 -4 120 15.

Necesito resolver esto, ideas?
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

Matriz Capicúa

Publicado por Kabuto (1381 intervenciones) el 25/09/2018 23:47:10
Hola Mariana.

Lo ideal aquí es crear un método que reciba las filas y sepa decir si es capicua o no.

Pongamos esta matriz de ejemplo:
1
2
3
4
5
6
7
//Matriz ejemplo con dos filas capicuas
static int[][] matriz = {
    {23, 4, 0, 4, 23},
    {12, 2, 4, 8, 12},
    {90, 50, 25, 50, 90},
    {0, 1, 2, 3, 4},
};

Si te fijas, en realidad una matriz es una sucesión de arrays, donde cada array equivale a una "fila".
Así pues, podemos extraer estas filas completas y pasárselas a un metodo booleano que nos diga si es capicua o no.

Para comprobar, si la fila (que es un array en verdad) es capicua, basta con seguir el mismo proceso que hacemos mentalmente como humanos para saber si es capicua o no.
Nosotros, mentalmente, comparamos el primer numero con el último.
Si son distintos ya sabemos que no es capicua, pero si son iguales, seguimos comprobando el segundo número con el penúltimo..
Luego el tercero con el antepenúltimo... y así sucesivamente hasta llegar al centro de la fila.

Pues al ordenador, le vamos a decir que haga esto mismo. Para ello, usaremos dos indices para recorrer el array.
Uno de ellos empezará desde el principio, es decir, desde la posición 0 e irá incrementándose para ir avanzando por la fila.
El otro, empezará desde el final, es decir, desde la posicion (array.length - 1) e irá decrementándose para ir retrocediendo por la fila.

Todo esto dentro de un bucle while que se irá repitiendo hasta que dos números sean distintos (por lo tanto, ya no es capicua) o bien hasta que el primer indice sea superior al segundo indice, es decir, ya se han comparado todos los numeros de la fila.

Tras esto, el método ya sabra decirnos si esta fila es capicua o no. Este podría ser el código:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
static boolean filaEsCapicua(int[] fila) {
    int indice1 = 0; //Empieza del principio hacia adelante
    int indice2 = fila.length - 1;//Empieza desde el final hacia atrás
    boolean esCapicua = true;
 
    while ((indice1 <= indice2) && esCapicua) {
 
        if (fila[indice1] != fila[indice2])//Encontrados dos numeros no coincidentes. NO es capicua
            esCapicua = false;//Esto hará que el bucle deje de ejecutarse
        else {
            //De momento parece capicua, actualizamos indices para seguir comprobando
            indice1++;//Avanza hacia adelante
            indice2--;//Retrocede hacia atrás
        }
    }
 
    return esCapicua;
}

Pues con esto, desde el main, recorremos la matriz y en lugar de extraer numeros sueltos, extraemos filas completas, se las pasamos a este metodo y por cada fila detectada como capicua, incrementamos un contador que al final de todo nos dirá cuantas filas capicuas se han encontrado.
1
2
3
4
5
6
7
8
9
10
public static void main(String[] args) {
 
    int contador = 0;
 
    for (int i = 0; i < matriz.length; i++)
        if (filaEsCapicua(matriz[i]))//Usando un solo indice, la matriz nos da una fila/array completo
            contador++;
 
    System.out.println("Numero de filas capicua: " + contador);
}
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