Erro no Programa Java

Programação Java
, , , ,
#1

Boa noite, gostaria de que alguém olhasse meu código e me falasse o que está errado, já tentei de várias maneiras e ele não dá os resultados certos.

Enunciado do problema:
Uma imagem em preto e branco, de tamanho m x n, pode ser representada por uma matriz cujos elementos assumem valores no conjunto {0,1}. Dado um padrão representado por uma matriz 3x3 também assumindo valores em {0,1}, escreva um programa que determine se o padrão existe ou não na imagem.

Matriz exemplo:
0 0 1 0 0 0 0 1 0
0 1 1 1 1 1 1 0 0
0 0 1 0 1 1 1 0 0
0 0 0 0 0 0 0 0 0
0 0 0 0 1 0 1 0 0
0 0 0 0 0 1 0 0 0
1 1 1 0 1 0 1 0 0
1 0 1 0 0 0 0 0 0
1 1 1 0 0 1 1 1 0

Matriz padrão:
0 1 0
1 1 1
0 1 0

Meu programa:
package javaapplication27;

import java.util.Scanner;

public class JavaApplication27 {

public static void main(String[] args) {
    Scanner dd = new Scanner(System.in);

    int M;
    int N;
    int igual = 0;

    System.out.println("Informe o tamanho da matriz (X,Y)");
    M = dd.nextInt();
    N = dd.nextInt();

    int matriz[][] = new int[M][N];

    System.out.println("Insira a matriz:");
    for (int entrada1 = 0; entrada1 < matriz.length; entrada1++) {
        for (int entrada2 = 0; entrada2 < matriz[entrada1].length; entrada2++) {
            matriz[entrada1][entrada2] = dd.nextInt();
        }
    }

    int padrao[][] = new int[3][3];

    System.out.println("Insira a matriz de consulta:");
    for (int entrada11 = 0; entrada11 < padrao.length; entrada11++) {
        for (int entrada22 = 0; entrada22 < padrao[entrada11].length; entrada22++) {
            padrao[entrada11][entrada22] = dd.nextInt();
        }
    }

    for (int teste1 = 0; teste1 < matriz.length-2; teste1++) { //coloquei menos 2 para ele não ultrapassar a matriz
        for (int teste2 = 0; teste2 < matriz[teste1].length-2; teste2++) { // mesma coisa vale
            if ((matriz[teste1][teste2] == padrao[0][0])
                    && (matriz[teste1][teste2 + 1] == padrao[0][1])
                    && (matriz[teste1][teste2 + 2] == padrao[0][2])
                    && (matriz[teste1 + 1][teste2] == padrao[0][0])
                    && (matriz[teste1 + 1][teste2 + 1] == padrao[1][1])
                    && (matriz[teste1 + 1][teste2 + 2] == padrao[2][2])
                    && (matriz[teste1 + 2][teste2] == padrao[0][0])
                    && (matriz[teste1 + 2][teste2 + 1] == padrao[1][1])
                    && (matriz[teste1 + 2][teste2 + 2] == padrao[2][2])) {
                igual++;
            }
        }
    }

    if (igual > 0) {
        System.out.println("Existe padrão!");
    } else {
        System.out.println("Não existe padrão!");
    }
}

}

No caso era pra mostrar que existe 1 padrão, mas no programa mostra que não existe padrão, por isso gostaria que alguém revisasse meu código e olhasse o erro. Agradeceria muito!

#2

Sua codificação não esta ajustada para teste de forma adequada, pois tem que inserir várias entradas o tempo todo.
Assim, fiz uma implementação aproveitando sua codificação, onde você pode realizar testes de forma mais eficiente:

public static void main(String[] args) {

        int matriz[][] = {//altere qualquer valor, e veja se o padrão é encontrado
            {0, 0, 1, 0, 0, 0, 0, 1, 0},//9
            {0, 0, 1, 1, 1, 1, 1, 0, 0},//18
            {0, 0, 1, 0, 1, 1, 1, 0, 0},//27
            {0, 0, 0, 0, 0, 0, 0, 0, 0},//36
            {0, 0, 0, 0, 1, 0, 1, 0, 0},//45
            {0, 0, 0, 1, 1, 1, 0, 0, 0},//54
            {1, 1, 1, 0, 1, 0, 1, 0, 0},//63
            {1, 0, 1, 0, 0, 1, 0, 0, 0},//72
            {1, 1, 1, 0, 0, 1, 1, 1, 0}};//90
        int M = matriz.length;
        int N = matriz[0].length;
        int igual = -1;//o padrão pode coincidir na primeira linha da matriz, por isso inicie em um valor negativo e não em 0

        int padrao[][] = {{0, 1, 0}, {1, 1, 1}, {0, 1, 0}};

        a:
        for (int linha = 0; linha < matriz.length - padrao.length; linha++) { //coloquei menos 2 para ele não ultrapassar a matriz
            for (int coluna = 0; coluna < matriz[linha].length - padrao[0].length; coluna++) { // mesma coisa vale
                if ((matriz[linha][coluna] == padrao[0][0])
                        && (matriz[linha][coluna + 1] == padrao[0][1])
                        && (matriz[linha][coluna + 2] == padrao[0][2])
                        && (matriz[linha + 1][coluna] == padrao[1][0])
                        && (matriz[linha + 1][coluna + 1] == padrao[1][1])
                        && (matriz[linha + 1][coluna + 2] == padrao[1][2])
                        && (matriz[linha + 2][coluna] == padrao[2][0])
                        && (matriz[linha + 2][coluna + 1] == padrao[2][1])
                        && (matriz[linha + 2][coluna + 2] == padrao[2][2])) {
                    igual = indexOnAnyArray(linha, coluna, N);
                    break a;
                }
            }
        }

        if (igual > -1) {
            //o index para vetores em java inicia em 0, o mesmo para as coordenadas da matriz
            System.out.println("Existe padrão a partir da coordenada" + Arrays.toString(coordenadas(igual, N))+" index: "+igual);
        } else {
            System.out.println("Não existe padrão!");
        }
    }

    private static int indexOnAnyArray(int linha, int coluna, int colunas) {
        return linha * colunas + coluna;
    }

    private static int[] coordenadas(int indexOnArray, int colunas) {
        int coluna = indexOnArray % colunas;
        return new int[]{(indexOnArray - coluna) / colunas, coluna};
    }

.
Agora,
vejas estas anotações quanto a sua codificação:

int igual = 0;//DEVE SER ATRIBUÍDO O VALOR -1, pois o padrão pode ocorrer em 0
.

        a://label para quebra de loop
        for (int teste1 = 0; teste1 < matriz.length - 2; teste1++) { //coloquei menos 2 para ele não ultrapassar a matriz
            for (int teste2 = 0; teste2 < matriz[teste1].length - 2; teste2++) { // mesma coisa vale
                if ((matriz[teste1][teste2] == padrao[0][0])
                        && (matriz[teste1][teste2 + 1] == padrao[0][1])
                        && (matriz[teste1][teste2 + 2] == padrao[0][2])
                        && (matriz[teste1 + 1][teste2] == padrao[0][0])//ERRO AQUI, DEVE SER [1][0]
                        && (matriz[teste1 + 1][teste2 + 1] == padrao[1][1])
                        && (matriz[teste1 + 1][teste2 + 2] == padrao[2][2])//ERRO AQUI, DEVE SER[1][2]
                        && (matriz[teste1 + 2][teste2] == padrao[0][0])//ERRO AQUI, DEVE SER[2][0]
                        && (matriz[teste1 + 2][teste2 + 1] == padrao[1][1])//ERRO AQUI, DEVE SER[2][1]
                        && (matriz[teste1 + 2][teste2 + 2] == padrao[2][2])) {
                    igual++;
                    break a;//tem que interromper o laço marcado com label a:, quando encontrar o padrão
                }
            }
        }

.

if (igual > 0) {//ERRO AQUI, deve ser > -1, pois o padrão pode ocorrer em 0
            System.out.println("Existe padrão!");
        } else {
            System.out.println("Não existe padrão!");
        }

Tente corrigir os problemas, caso não consiga informe.
Vi que você esta usando o dd.nextInt(), se der problema nas entradas, troque para Integer.parseInt(dd.nextLine());
Eu não testei sua codificação natural, pois são muitas entradas.

Té+

1 curtida
#3

Addller, valeu cara! Corrigi o meu código com base nas suas anotações sobre minha codificação e deu certo os testes. Como não sei muito sobre Orientada a Objetos e Funções não entendi muito bem sua implementação. mas agradeço a ajuda, deu certo aqui!