12) Se tiene una matriz secuencias de caracteres en sus filas de tamaño 8x10. Las secuencias están separadas por caracteres espacios (uno o más), y cada fila empieza y termina con caracteres espacio. Guardar en un arreglo la secuencia que más se repite en cada fila de la matriz. Se deben guardar en forma consecutiva sin espacios entre secuencias. Dicho arreglo tiene un tamaño igual a la cantidad_de_filas x cantidad_de_columnas de la matriz y puede suponer que se inicializa con espacios.

Aquí te dejo una posible solución en Java:

```java
public class Main {

    public static void main(String[] args) {
        String[][] matriz = {
            {" ", "A", "B", "C", " ", "A", "B", "C", " ", "A"},
            {" ", "D", "E", "F", " ", "D", "E", "F", " ", "D"},
            {" ", "G", "H", "I", " ", "G", "H", "I", " ", "G"},
            {" ", "J", "K", "L", " ", "J", "K", "L", " ", "J"},
            {" ", "M", "N", "O", " ", "M", "N", "O", " ", "M"},
            {" ", "P", "Q", "R", " ", "P", "Q", "R", " ", "P"},
            {" ", "S", "T", "U", " ", "S", "T", "U", " ", "S"},
            {" ", "V", "W", "X", " ", "V", "W", "X", " ", "V"}
        };

        String[] resultado = obtenerSecuenciasRepetidas(matriz);

        System.out.println("Secuencias repetidas:");
        for (String secuencia : resultado) {
            System.out.print(secuencia);
        }
    }

    public static String[] obtenerSecuenciasRepetidas(String[][] matriz) {
        int filas = matriz.length;
        int columnas = matriz[0].length;
        String[] resultado = new String[filas * columnas];

        for (int i = 0; i < filas; i++) {
            String fila = matriz[i][0];
            for (int j = 1; j < columnas - 1; j++) {
                fila += matriz[i][j];
            }
            fila += matriz[i][columnas - 1];

            String maxSecuencia = "";
            int maxRepetidos = 0;
            for (int k = 0; k < fila.length(); k++) {
                int repetidos = 0;
                for (int l = k; l < fila.length(); l++) {
                    if (fila.charAt(k) == fila.charAt(l)) {
                        repetidos++;
                    } else {
                        break;
                    }
                }
                if (repetidos > maxRepetidos) {
                    maxSecuencia = fila.substring(k, k + repetidos);
                    maxRepetidos = repetidos;
                }
            }

            for (int k = 0; k < maxSecuencia.length(); k++) {
                resultado[i * columnas + j] = String.valueOf(maxSecuencia.charAt(k));
            }
        }

        return resultado;
    }
}
```

En este código, la función `obtenerSecuenciasRepetidas` recorre cada fila de la matriz, elimina los espacios y busca la secuencia más larga que se repite en cada fila. Luego, agrega cada carácter de la secuencia más larga al arreglo `resultado` en la posición correspondiente. Finalmente, devuelve el arreglo `resultado`.