C# 将switch语句转换为更优雅的解决方案

我有一个9 x 9的矩阵。（想想suduko）

现在我想得到一个“象限”。例如（根据我的代码），象限2，2返回以下内容：

    5 4 4 
    2 8 1 
    6 4 7 

如果你注意到了，这是从9 x 9的中心开始的矩阵。如果你知道我的意思的话，我把所有的东西都分成了“3”对。第一行是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;
    }

//象限返回mini 3 x 3
//第1行有三个四元组，“1”、“2”和“3”
//第2行有三个四元组“1”、“2”、“3”等
公共int[，]获取象限（int rnum，int qnum）{
int[，]returnMatrix=新的int[3,3]；
int colBegin、colEnd、rowBegin、rowEnd、row、column；
//这样我们就可以跟踪新矩阵了
行=0；
列=0；
开关（qnum）{
案例1：
colBegin=0；
colEnd=3；
打破
案例2：
colBegin=3；
colEnd=6；
打破
案例3：
colBegin=6；
colEnd=9；
打破
违约：
colBegin=0；
colEnd=0；
打破
}
交换机（rnum）{
案例1：
rowBegin=0；
rowEnd=3；
打破
案例2：
rowBegin=3；
rowEnd=6；
打破
案例3：
rowBegin=6；
rowEnd=9；
打破
违约：
rowBegin=0；
rowEnd=0；
打破
}
for（int i=rowBegin；i

Python中的常见模式是使用映射：

---

我确信C支持类似的东西。

除非我遗漏了什么，为什么不做数学呢？首先，只存储

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
对于一般解决方案（即：NxN网格），我会使用一些数学（您将需要模运算符）

如果您总是使用9x9数独网格，那么您可以预先计算答案并将其粘贴到地图或数组中

当然，您可以结合这些想法，在init（）中预先计算答案函数，然后将它们存储在地图中。
哇，谢谢..我想了很久。考虑到我是一名数学本科生，无法掌握模式，这有点令人难过。呵呵。：PI应该知道你有数学背景。你指的是左上角（或左下角）是（1,1）而不是（0,0）疯狂！我正在尝试更广泛地推广这一点。我将不接收坐标类型的点，而是传递一个从1到9的数字。其中1 2 3是两行，4，5，6，从第二行开始，依此类推。这不是数学，而是算术。
qmap = {
  1: (0, 3),
  2: (3, 6),
  3: (6, 9),
}

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

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