Проверка смежных индексов в 2-мерном массиве

0

Я должен написать тральщик. Я выяснил способ проверить соседние индексы, чтобы подсчитать, сколько бомб окружает текущий индекс, не выходя за пределы. Но это долго, уродливо и, скорее всего, неэффективно. Это всего лишь куча условных операторов для каждой уникальной ячейки, которая потенциально может выйти за пределы. Мой вопрос в том, есть ли более короткий способ сделать это? И может ли реализация 1-мерного массива деформации сделать его легче/сложнее?

int count = 0;
for (int i = 0; i < WIDTH; i++){
    for (int j = 0; j < HEIGHT; j++){
        **// index 0,0**
        if (i == 0 && j == 0 && field[i][j] != 10){
            if (field[i][j + 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
            if (field[i + 1][j + 1] == 10)
                count++;
        }
        **// index 0,9**
        else if (i == 0 && j == HEIGHT - 1 && field[i][j] != 10){
            if (field[i][j - 1] == 10)
                count++;
            if (field[i + 1][j - 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
        }

        **// index 9,0**
        else if (i == WIDTH - 1 && j == 0 && field[i][j] != 10){
            if (field[i - 1][j] == 10)
                count++;
            if (field[i][j + 1] == 10)
                count++;
            if (field[i - 1][j + 1] == 10)
                count++;
        }

        **// index 9,9**
        else if (i == WIDTH - 1 && j == HEIGHT - 1 && field[i][j] != 10){
            if (field[i - 1][j] == 10)
                count++;
            if (field[i][j - 1] == 10)
                count++;
            if (field[i - 1][j - 1] == 10)
                count++;
        }

        **// if first row**
        else if (i == 0 && (j != 0 && j != HEIGHT - 1) && field[i][j] != 10){
            if (field[i][j - 1] == 10)
                count++;
            if (field[i + 1][j - 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
            if (field[i + 1][j + 1] == 10)
                count++;
            if (field[i][j + 1] == 10)
                count++;
        }

        **// if last row**
        else if (i == WIDTH - 1 && (j != 0 && j != HEIGHT - 1) && field[i][j] != 10){
            if (field[i][j - 1] == 10)
                count++;
            if (field[i - 1][j - 1] == 10)
                count++;
            if (field[i - 1][j] == 10)
                count++;
            if (field[i - 1][j + 1] == 10)
                count++;
            if (field[i][j + 1] == 10)
                count++;
        }

        **// if first col**
        else if (j == 0 && (i != 0 && i != HEIGHT - 1) && field[i][j] != 10){
            if (field[i - 1][j] == 10)
                count++;
            if (field[i - 1][j + 1] == 10)
                count++;
            if (field[i][j + 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
            if (field[i + 1][j + 1] == 10)
                count++;
        }

        **// if last col**
        else if (j == HEIGHT - 1 && (i != 0 && i != WIDTH - 1) && field[i][j] != 10){
            if (field[i - 1][j - 1] == 10)
                count++;
            if (field[i - 1][j] == 10)
                count++;
            if (field[i][j - 1] == 10)
                count++;
            if (field[i + 1][j - 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
        }

        **// Cells that are fully surrounded**
        else if (field[i][j] != 10){
            if (field[i - 1][j - 1] == 10)
                count++;
            if (field[i - 1][j] == 10)
                count++;
            if (field[i - 1][j + 1] == 10)
                count++;
            if (field[i][j - 1] == 10)
                count++;
            if (field[i][j + 1] == 10)
                count++;
            if (field[i + 1][j - 1] == 10)
                count++;
            if (field[i + 1][j] == 10)
                count++;
            if (field[i + 1][j + 1] == 10)
                count++;
        }


        if (field[i][j] != 10)
            field[i][j] = count;
        count = 0;
    }
}
  • 0
    Я нашел похожий вопрос, который может оказаться полезным для вас: stackoverflow.com/questions/20381284/… Принятый ответ на этот вопрос использует оценку короткого замыкания для проверки только четырех ячеек - вверх / вниз / вправо / влево - но вы должны возможность расширить его для работы со всеми 8 окружающими клетками.
  • 0
    Спасибо за эту ссылку
Теги:
arrays
multidimensional-array
minesweeper

1 ответ

1
Лучший ответ

Существует стандартный способ справиться с такими ситуациями - определить массив с вашими действительными ходами и перебрать его. Вот пример того, как вы можете перебирать 8 соседних ячеек:

static int moves[8][2] = {{-1,0}, {-1, -1}, {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}};
for (int i = 0; i < WIDTH; i++) {
    for (int j = 0; j < HEIGHT; j++) {
      for (int l = 0; l < 8 /*sizeof(move) / sizeof(move[0]) */; ++l) {
        int ti = i + move[l][0];
        int tj = j + move[l][1];
        if (ti < 0 || ti >= WIDTH || tj < 0 || tj >= HEIGHT) {
          continue;
        }
        // cell (ti, tj) is valid neighbor do something with it.
      }
    }
}
Поделиться
  • 1
    Ух ты, круто. Я бы никогда не подумал поместить правильные ходы в массив. Благодарю. Кстати, внутри оператора if это должно быть ti <0. В противном случае он не проверяет ячейки в первом ряду. еще раз спасибо
  • 0
    @justin конечно :-) это была опечатка. Исправлено сейчас спасибо.

Ещё вопросы

Сообщество Overcoder
Наверх
Меню