Do not count the integers 1 and 0 in duplicity when they are above, below or next to an integer 2?

Question

This code counts how many infertile (1) and infertile (0) sectors are covered by at least one irrigator (2). The matrix a[m][n] represents land with irrigators (2), fertile land (1) and infertile land:

#include <stdio.h>

int main() {
    int m, n, i, j, dx, dy, qtdFertil, qtdInfertil;
    int a[10][10];
    scanf("%d %d", &m, &n);
/*ex. de entradas:
4 6
0 0 0 1 1 0
0 2 2 1 1 0
1 0 2 1 2 0
1 1 1 0 0 0
4 5
Obs.: a saida deveria ser 4 e 5 mas está saindo 5 7
*/
    //leitura da matriz
    for (i = 0; i < m; i++) {       //varre as linhas m
        for (j = 0; j < n; j++) {   //varre as colunas n
            scanf("%d", &a[i][j]);
        }
    }
    //calcula setores ferteis/inferteis irrigados
    qtdFertil = 0;
    qtdInfertil = 0;
    for(i = 1; i < m-1; i++) {              //varre as linhas da matriz Aij
        for (j = 1; j < n-1; j++) {         //varre as colunas da matriz Aij
            if (a[i][j] == 2){
                if(a[i-1][j] == 1) {        //elemento a norte de aij
                    qtdFertil++; }
                if(a[i-1][j] == 0) {
                    qtdInfertil++; }
                if(a[i+1][j] == 1) {        //elemento a sul de aij
                    qtdFertil++; }
                if(a[i+1][j] == 0) {
                    qtdInfertil++; }
                if(a[i][j+1] == 1) {        //elemento a leste de aij
                    qtdFertil++; }
                if(a[i][j+1] == 0) {
                    qtdInfertil++; }
                if(a[i][j-1] == 1) {        //elemento a oeste de aij
                    qtdFertil++; }
                if(a[i][j-1] == 0) {
                    qtdInfertil++; }
            }else{
                continue;   //passa para a próxima iteração
            }
        }
    }
    //escreve a quantidade de setires ferteis e inferteis cobertos
    //por pelo menos um irrigador
    printf("%d %d\n", qtdFertil, qtdInfertil);
    return 0;
}

Answer 1

Your program is right, unless you can’t count the same sectors more than once,

Sectors with zeros

  0 0     
0 2 2      
  0 2   2 0
        0  

If you count the occurrences in the highlighted map to the zeroes, you will see that there will be 7 occurrences.

Sectors with a

(linha faltante)
    2 1 1  
    2 1 2  
    1

You’ll find there are five occurrences of one.

To avoid this, you can replace the values already taken into account, as an example below:

#include <stdio.h>

#define JACONTADO  3
#define IRRIGADOR  2
#define FERTIL     1
#define INFERTIL   0

int main()
{
    int m, n, i, j, dx, dy, contagem[4];
    int a[10][10];
    fflush(stdin);
    scanf("%d %d", &m, &n);

    for (i = 0; i < m; ++i)
    {
        fflush(stdin);
        for (j = 0; j < n; ++j)
            scanf("%d", &a[i][j]);
    }

    contagem[INFERTIL] = 0;
    contagem[FERTIL] = 0;
    contagem[IRRIGADOR] = 0;
    contagem[JACONTADO] = 0;

    for (i = 1; i < m - 1; ++i)
        for (j = 1; j < n - 1; ++j)
        {
            if (a[i][j] == IRRIGADOR)
            {
                // Norte.
                ++contagem[a[i - 1][j]];
                // Sul.
                ++contagem[a[i + 1][j]];
                // Leste.
                ++contagem[a[i][j + 1]];
                // Oeste.
                ++contagem[a[i][j - 1]];

                // Substituicao dos setores ja contados.
                a[i - 1][j] = a[i - 1][j] == IRRIGADOR ? IRRIGADOR : JACONTADO;
                a[i + 1][j] = a[i + 1][j] == IRRIGADOR ? IRRIGADOR : JACONTADO;
                a[i][j - 1] = a[i][j - 1] == IRRIGADOR ? IRRIGADOR : JACONTADO;
                a[i][j + 1] = a[i][j + 1] == IRRIGADOR ? IRRIGADOR : JACONTADO;
            }
        }

    printf("%d %d", contagem[FERTIL], contagem[INFERTIL]);

    return 0;
}