Добавление значений в несколько массивов, но это выходит за пределы

Question

Мне нужно посчитать для каждой позиции в массиве, сколько 1-значений вокруг него.Я попытался добавить еще один слой 0 вокруг этого, и он будет работать, если r=1, но не могу понять это, например, r = 3?

#include <iostream>
#include <time.h>
#include <cstdlib>
using namespace std;

int main() 
{
const int n=10;

int T[n][n]= {
    {1,0,0,0,1,0,1,0,0,1},
    {1,1,0,0,1,0,1,1,1,0},
    {0,1,0,0,1,0,1,0,0,1},
    {0,1,1,0,1,0,1,1,0,1},
    {0,1,0,1,1,0,0,0,0,0},
    {0,1,0,1,1,0,0,0,1,0},
    {1,1,0,0,1,0,0,0,0,1},
    {1,1,1,1,1,0,1,1,0,0},
    {0,1,0,0,1,0,1,0,0,1},
    {1,1,0,0,1,0,0,1,0,1},
};

int TD[14][14]= {0};

for(int i=2; i<12; i++) 
    for(int j=2; j<12; j++)
        TD[i][j]=T[i-2][j-2];

for(int i=0; i<14; i++) 
{
    for(int j=0; j<14; j++)
        cout<<TD[i][j]<<" ";
    cout<<endl;
}

cout<<endl<<endl<<endl;

for(int i=0; i<n; i++) 
{
    for(int j=0; j<n; j++)
        cout<<T[i][j]<<" ";
    cout<<endl;
}

cout<<endl;
cout<<endl;
cout<<endl;

int G[14][14]= {0};

for(int i=0; i<n; i++) 
{
    for(int j=0; j<n; j++)
        cout<<G[i][j]<<" ";
    cout<<endl;
}

cout<<endl;
cout<<endl;
cout<<endl;

int r=1;

for(int i=2; i<13; i++)
    for(int j=2; j<13; j++) 
    {
        for(int ii=i-r; ii<=i+r; ii++)
            for(int jj=j-r; jj<=j+r; jj++)
                G[i][j]=G[i][j]+TD[ii][jj];
    }

for(int i=2; i<12; i++) 
{
    for(int j=2; j<12; j++)
        cout<<G[i][j]<<" ";
    cout<<endl;
}
return 0;   

Я попытался увеличить слои 0s с увеличением массивано это просто не сработает.

Итак, мой вопрос: если такой подход хорош, если нет, то какое решение вы, ребята, можете предложить?

Answer 1

При приближении к любой проблеме, когда вы выполняете подсчет в фиксированном двумерном отображении ячеек, для определения количества «соседей» требуется определить и «граничные» ячейки, и «внутренние» ячейки, а затем написать алгоритм, который работает вокруг каждой границы. , а также итерации по каждой внутренней ячейке.

В следующем примере сначала читается граница верхней строки, затем вниз по левой границе, через внутреннюю часть, затем по правой границе и, наконец, по нижнему ряду. Код не учитывает значение самой ячейки (то есть cell[i][j] считает от возможных 8-ячеек, которые ее окружают, но не включает свое собственное значение в определении количества соседей, если оно оказалось 1. (Вы можете легко адаптировать это по желанию, активируя закомментированную ячейку в каждом разделе числа соседей.

В целом, вы можете сделать что-то вроде следующего:

#include <iostream>
#include <time.h>
#include <cstdlib>

#define n 10

int main (void) {

    int T[][n]= {
        {1,0,0,0,1,0,1,0,0,1},
        {1,1,0,0,1,0,1,1,1,0},
        {0,1,0,0,1,0,1,0,0,1},
        {0,1,1,0,1,0,1,1,0,1},
        {0,1,0,1,1,0,0,0,0,0},
        {0,1,0,1,1,0,0,0,1,0},
        {1,1,0,0,1,0,0,0,0,1},
        {1,1,1,1,1,0,1,1,0,0},
        {0,1,0,0,1,0,1,0,0,1},
        {1,1,0,0,1,0,0,1,0,1},
    },
    nrow = sizeof T / sizeof *T,
    ncol = n,
    neighbors = 0;

    for (int i = 0; i < nrow; i++) {    /* loop over rows */
        for (int j = 0; j < n; j++) {   /* loop over cols */
            if (!i) {       /* index of first row */
                if (!j) {       /* top-left corner */
                    neighbors = /*T[i][j]*/   T[ i ][j+1] + 
                                T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j < ncol - 1) {    /* top-inside row */
                    neighbors = T[ i ][j-1] + /*T[i][j]*/ + T[ i ][j+1] +
                                T[i+1][j-1] + T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j == ncol - 1) {   /* top-right corner */
                    neighbors = T[ i ][j-1] + /*T[i][j]*/ 
                                T[i+1][j-1] + T[i+1][ j ];
                }
            }
            else if (i < nrow - 1) {    /* interior cells */
                if (!j) {       /* left-side vertical */
                    neighbors = T[i-1][ j ] + T[i-1][j+1] +
                                /*T[i][j]*/ + T[ i ][j+1] +
                                T[i+1][ j ] + T[i+1][j+1];
                }
                else if (j < ncol - 1) {    /* inner cells */
                    neighbors = T[i-1][j-1] + T[i][j-1] + T[i+1][j-1] +
                                T[i-1][ j ] + /*T[i][j]*/ T[i+1][ j ] +
                                T[i-1][j+1] + T[i][j+1] + T[i+1][j+1];
                }
                else if (j == ncol - 1) {   /* right-side vertical */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] +
                                T[ i ][j-1] + /*T[i][j]*/
                                T[i+1][j-1] + T[i+1][ j ];
                }
            }
            else if (i == nrow - 1) {   /* last row */
                if (!j) {       /* bottom-left corner */
                    neighbors = T[i-1][ j ] + T[i-1][j+1] +
                                /*T[i][j]*/ + T[ i ][j+1];
                }
                else if (j < ncol - 1) {    /* bottom-inside row */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] + T[i-1][j+1] +
                                T[ i ][j-1] + /*T[i][j]*/ + T[ i ][j+1];
                }
                else if (j == ncol - 1) {   /* bottom-right corner */
                    neighbors = T[i-1][j-1] + T[i-1][ j ] +
                                T[ i ][j-1]   /*T[i][j]*/;
                }
            }
            std::cout << "T[" << i << "][" << j << "]: " << neighbors << '\n';
        }
    }
}

Пример использования / Вывод

$ ./bin/neighbors
T[0][0]: 2
T[0][1]: 3
T[0][2]: 1
T[0][3]: 2
T[0][4]: 1
T[0][5]: 4
T[0][6]: 2
T[0][7]: 4
T[0][8]: 3
T[0][9]: 1
T[1][0]: 3
T[1][1]: 3
T[1][2]: 2
T[1][3]: 3
T[1][4]: 2
T[1][5]: 6
T[1][6]: 3
T[1][7]: 4
T[1][8]: 3
T[1][9]: 3
...
T[8][0]: 5
T[8][1]: 5
T[8][2]: 5
T[8][3]: 5
T[8][4]: 3
T[8][5]: 5
T[8][6]: 3
T[8][7]: 4
T[8][8]: 4
T[8][9]: 1
T[9][0]: 2
T[9][1]: 2
T[9][2]: 2
T[9][3]: 2
T[9][4]: 1
T[9][5]: 3
T[9][6]: 2
T[9][7]: 1
T[9][8]: 3
T[9][9]: 1

Посмотрите вещи и дайте мне знать, если у вас есть еще вопросы.