Обтекание сетки с помощью modulo

Question

Я пытаюсь написать программу, которая реализует игру Жизни Конвея на сетке из ячеек 20х60. Сетка должна обернуться так, чтобы левая сторона была подключена к правой стороне, а верхняя часть - к нижней.

Таким образом, любая ячейка с положением (0, col), будет иметь соседа по адресу (maxRow, col). Любая ячейка с положением (row, 0) будет иметь соседа по адресу (row, maxCol).

Следующая функция должна подсчитывать количество соседних ячеек. Он работает для координат не по краям, а не по тем, которые есть. Например, если есть точки в (0, 10), (0, 11), (0, 12) и (0, 10) передается в функцию, он будет возвращать большое число в качестве соседнего счета вместо 1. Я знаю, что оператору мод % было бы полезно, но я не понимаю, как его использовать.

{ 
    int i, j; 
    int count = 0; 
    for (i = row - 1; i <= row + 1; i++) 
     for (j = col - 1; j <= col + 1; j++) 
      count += grid[i][j]; } 

    if (row==maxrow-1 || row==0) 
     count = count+ grid [(row-(maxrow-1))*-1][col-1]+grid[(row-(maxrow-1))*-1][col]+grid[(row-(maxrow-1))*-1][col+1]; 

    if (col==0 || col==maxcol-1) 
     count=count +grid[row-1][(col-(maxcol-1))*-1]+grid[row][(col-(maxcol-1))*-1]+grid[row+1][(col-(maxcol-1))*-1]; 



    count -= grid[row][col]; 
    return count; 
    } 

Answer 1

Прежде чем предлагать решение, позвольте мне сделать некоторые замечания.

• Добавление некоторых значений сетки и последующее вычитание других значений сетки - не очень хорошая идея. Вы должны сначала вычислить правильные координаты сетки.

• Когда вы пишете count += grid[i][j];, вы используете индексы массива, которые могут быть недействительными. Например, i = row - 1, когда row равен нулю, дает значение i-1.

• Ваш код подразумевает, что maxrow этого числа строк, потому что вы пишете maxrow-1, но название maxrow предлагает максимальный индекс строки. Это смущает. Лучше было бы назвать количество строк numRows, а затем наибольший индекс строки - numRows - 1. Аналогичным образом, было бы лучше заменить maxcol на numCols.

Теперь к сути вопроса. Значение row - 1 может быть равно -1, а row + 1 может быть равно numRows. Оба они являются недопустимыми индексами строк. Аналогичным образом, col - 1 и col + 1 могут приводить к недопустимым индексам столбцов -1 и numCols. Одним из способов решения этой проблемы заключается в проверке этих конкретных значений и заменить их с сервоприводом показателями:

int count = 0; 
for (int i = row - 1; i <= row + 1; i++) { 
    int R = i; 
    if (R == -1) { 
    R = numRows - 1; 
    } else if (R == numRows) { 
    R = 0; 
    } 
    for (int j = col - 1; j <= col + 1; j++) { 
    if (i == row && j == col) { 
     continue; // Skip grid[row][col]. 
    } 
    int C = j; 
    if (C == -1) { 
     C = numCols - 1; 
    } else if (C == numCols) { 
     C = 0; 
    } 
    count += grid[R][C]; 
    } 
} 

Это путь высокоэффективного решить проблему, поскольку тестирование и назначение более быстрые операции, чем по модулю, но это также много кода. Мы можем написать более сжатый код с помощью оператора modulo.

Мы хотели бы написать i % numRows, за исключением того, что C++ оценивает это как -1, когда i равно -1. Это связано с тем, что операция modulo неоднозначна для отрицательных значений и C++ has chosen an interpretation, что не гарантирует неотрицательных результатов.

Для решения этой проблемы добавьте numRows в i, прежде чем принимать по модулю numRows. Это гарантирует, что мы всегда принимаем по модулю положительное число.Теперь мы можем подсчитать количество живых клеток среди восьми соседей grid[row][col] следующим образом.

int count = 0; 
for (int i = row - 1; i <= row + 1; i++) { 
    for (int j = col - 1; j <= col + 1; j++) { 
    if (i == row && j == col) { 
     continue; // Skip grid[row][col]. 
    } 
    count += grid[(i + numRows) % numRows][(j + numCols) % numCols]; 
    } 
}