Преобразование операторов switch в более элегантное решение

Question

У меня есть матрица 9 х 9. (подумайте о судуко).

   4 2 1 6 8 1 8 5 8 
   3 1 5 8 1 1 7 5 8 
   1 1 4 0 5 6 7 0 4 
   6 2 5 5 4 4 8 1 2 
   6 8 8 2 8 1 6 3 5 
   8 4 2 6 4 7 4 1 1 
   1 3 5 3 8 8 5 2 2 
   2 6 6 0 8 8 8 0 6 
   8 7 2 3 3 1 1 7 4 

теперь я хочу получить "квадрант". например (согласно моему коду) квадрант 2, 2 возвращает следующее:

    5 4 4 
    2 8 1 
    6 4 7 

Если вы заметили, это матрица из самого центра 9 х 9. Я разбил все на пары «3», если вы знаете, что я имею в виду. первое «ROW» от 0 до 3, второе от 3 до 6, третье от 6 до 9 .. Я надеюсь, что это имеет смысл это)

в любом случае, вот мой код. Мне не очень нравится этот способ, хотя он работает. Я действительно хочу скорость, потому что я делаю решатель suduko.

    //a quadrant returns the mini 3 x 3
    //row 1  has three quads,"1", "2", 3"
    //row 2  has three quads "1", "2", "3" etc
    public int[,] GetQuadrant(int rnum, int qnum) {
        int[,] returnMatrix = new int[3, 3];
        int colBegin, colEnd, rowBegin, rowEnd, row, column;

        //this is so we can keep track of the new matrix
        row = 0;
        column = 0;      
        switch (qnum) {
            case 1:
                colBegin = 0;
                colEnd = 3;
                break;
            case 2:
                colBegin = 3;
                colEnd = 6;
                break;
            case 3:
                colBegin = 6;
                colEnd = 9;
                break;
            default:
                colBegin  = 0;
                colEnd = 0;
                break;
        }

        switch (rnum) {
            case 1:
                rowBegin = 0;
                rowEnd = 3;
                break;
            case 2:
                rowBegin = 3;
                rowEnd = 6;
                break;
            case 3:
                rowBegin = 6;
                rowEnd = 9;
                break;
            default:  
                rowBegin = 0;
                rowEnd = 0;
                break;
        }
        for (int i = rowBegin ; i < rowEnd; i++) {
            for (int j = colBegin; j < colEnd; j++) {                 
                returnMatrix[row, column] = _matrix[i, j];
                column++;
            }
            column = 0;
            row++;
        }
        return returnMatrix;
    }

Answer 1

Если я что-то упустил, почему бы не сделать математику? Во-первых, только магазин rowBegin и colBegin.

Теперь просто введите:

rowBegin = (rnum-1)*3
colBegin = (qnum-1)*3

Это карты 1 -> 0, 2 -> 3 и 3-> 6.

Теперь вы выполняете цикл от colBegin до colBegin + 3 и rowBegin до rowBegin + 3. Ваше поведение по умолчанию действительно необходимо? Если это так, особый случай, когда rnum < 1 || rnum > 3 и qnum < 1 || qnum > 3

Answer 2

Обычный шаблон для этого в Python - использовать dict для отображения:

qmap = {
  1: (0, 3),
  2: (3, 6),
  3: (6, 9),
}

print qmap.get(qnum, (0, 0))

Я уверен, что C # поддерживает нечто подобное.

Answer 3

Для общего решения (т. Е. Сетки NxN) я бы использовал некоторые математические (вам понадобится оператор по модулю).

Если вы всегда используете сетку судоку 9x9, вы можете предварительно рассчитать ответы и вставить их в карту или массив.

Конечно, вы можете объединить эти идеи и предварительно рассчитать ответы в вашей функции init (), а затем сохранить их на карте.