C++ 获取数独块的坐标

所以我试图解决一个问题，在这个问题中，我需要从数独网格中得到一个给定单元格的数独块的起点

因此，举个例子，考虑到这个董事会：

 2D-ARRAY COORDINATE

[0,0] [0,1] [0,2]  |  [0,3] [0,4] [0,5]  |  [0,6] [0,7] [0,8]
[1,0] [1,1] [1,2]  |  [1,3] [1,4] [1,5]  |  [1,6] [1,7] [1,8]
[2,0] [2,1] [2,2]  |  [2,3] [2,4] [2,5]  |  [2,6] [2,7] [2,8]
-------------------+---------------------+-------------------
[3,0] [3,1] [3,2]  |  [3,3] [3,4] [3,5]  |  [3,6] [3,7] [3,8]
[4,0] [4,1] [4,2]  |  [4,3] [4,4] [4,5]  |  [4,6] [4,7] [4,8]
[5,0] [5,1] [5,2]  |  [5,3] [5,4] [5,5]  |  [5,6] [5,7] [5,8]
-------------------+---------------------+-------------------
[6,0] [6,1] [6,2]  |  [6,3] [6,4] [6,5]  |  [6,6] [6,7] [6,8]
[7,0] [7,1] [7,2]  |  [7,3] [7,4] [7,5]  |  [7,6] [7,7] [7,8]
[8,0] [8,1] [8,2]  |  [8,3] [8,4] [8,5]  |  [8,6] [8,7] [8,8]

假设[y，x]

如果给定的单元格为[1,1]，则函数应该为x值返回0-2，为y值返回0-2。 对于[0,3]，对于x值范围，它应该返回3-5；对于y值范围，它应该返回0-2

这是我写的函数：

std::pair<int, int> getBlock(const double val) const {
        double ourBlock = ceil(val / sqrt(size));
        int blockSize = sqrt(size);
        int currBlock = 1;
        int ourBlkStrt = 0;
        for (int i = 0; i < size; i++) {
            if (currBlock == ourBlock) {
                if (currBlock > 1) {
                    ourBlkStrt = i + blockSize;
                } else {
                    ourBlkStrt = i;
                }
                break;
            } else {
                if (i % blockSize == 0) {
                    currBlock++;
                }
            }
        }
        int ourBlkEnd = 0;
        if (ourBlkStrt != 1) {
        ourBlkEnd = ourBlkStrt + (blockSize);
    } else {
        ourBlkEnd = ourBlkStrt + (blockSize -1);
    }

        return std::pair<int, int>(ourBlkStrt, ourBlkEnd);

    }

std:：pair getBlock（const double val）const{
double-ourBlock=ceil（val/sqrt（尺寸））；
int blockSize=sqrt（大小）；
int currBlock=1；
intourblkstrt=0；
对于（int i=0；i1）{
ourBlkStrt=i+块大小；
}否则{
ourBlkStrt=i；
}
打破
}否则{
如果（i%blockSize==0）{
currBlock++；
}
}
}
int-ourBlkEnd=0；
如果（ourBlkStrt！=1）{
ourBlkEnd=ourBlkStrt+（块大小）；
}否则{
ourBlkEnd=ourBlkStrt+（块大小-1）；
}
返回std:：pair（ourBlkStrt，ourBlkEnd）；
}

我的代码并不是最好的方法。它在大多数情况下都有效，但有时它会给我一个超出所需范围的值

有更好的方法吗？如果是这样的话，有人能给我推荐一种方法吗

---

谢谢。

让我们来定义

f

：

std::pair<unsigned, unsigned> f(unsigned cell_index)
{
    const unsigned block_index = cell_index / 3;
    const unsigned lowest_block_index = block_index * 3;
    const unsigned highest_block_index = (block_index+1) * 3 - 1;
    return { lowest_block_index, highest_block_index };
}

---

然后，设计为

[y，x]

的单元具有范围

[f（y）。首先，f（x）。首先]-[f（y）。第二，f（x）。第二]

或甚至是

constexpr std:：map f={0，{0，2}，{1，{3，5}，{2，{6，8}。请通过您的问题向我们展示您所做的调试。我希望您已经在Valgrind或类似的检查器中运行了自己的代码，并且已经使用诸如GDB之类的调试器进行了调查。确保还启用了一整套编译器警告。这些工具告诉了你什么，它们遗漏了什么信息？读埃里克·利珀特的。
std::pair<unsigned, unsigned> f(unsigned cell_index)
{
    switch (cell_index)
    {
       case 0: return { 0, 2 };
       case 1: return { 3, 5 };
       case 2: return { 6, 8 };
     }
     return { -1, -1 };
}

f(0) == { 0, 2 };
f(1) == { 3, 5 };
f(2) == { 6, 8 };