为了测试未知来源的算法题，我写了一个本地刷题工具！

class Case:
    def __init__(self,*args, **kw):
        raise NotImplementedError()

    def output(self, data_path, result_path, idx):
        raise NotImplementedError()

class Case3(Case):
    def __init__(self):
        # 创建行列均有序的二维矩阵
        n, m = random.randint(1, 100), random.randint(1, 100)
        nums = sorted([random.randint(0, 100000000) for _ in range(n * m)])
        arr = np.array(nums).reshape((n, m))
        ans, k = 0, 0
        if random.randint(0, 100) > 50:
            ans = 1
            x, y = random.randint(0, n-1), random.randint(0, m-1)
            k = arr[x, y]
        else:
            while True:
                k = random.randint(0, 100000000)
                if k not in nums:
                    break
        self.n, self.m, self.k, self.ans = n, m, k, ans
        self.arr = arr

    def output(self, data_path, result_path, idx):
        # 将测试数据输入data_path，答案输入result_path
        # idx为当前测试样例编号
        with open(data_path, 'a+') as f:
            f.write('{} {} {}\n'.format(self.n, self.m, self.k))
            for i in range(self.n):
                for j in range(self.m):
                    f.write('{} '.format(self.arr[i, j]))
                f.write('\n')

        with open(result_path, 'a+') as f:
            f.write('case :{}\n'.format(idx + 1))
            f.write(str(self.ans))
            f.write('\n')

class Generate:
    def __init__(self, n, problem_id, Case):
        # 将Case的实现子类以参数形式传入
        self.n = n
        self.problem_id = problem_id
        self.output_path = os.path.join(output_path_base, '{}.txt'.format(problem_id))
        self.result_path = os.path.join(result_path_base, '{}.txt'.format(problem_id))
        self.cases = []
        self.Case = Case

    def generate(self):
        for _ in range(self.n):
            # 样例的具体生成逻辑都在Case类的初始化函数当中实现了
            self.cases.append(self.Case())

    def output(self):
        # 生成输入的文件地址
        if os.path.exists(self.output_path):
            os.remove(self.output_path)

        if os.path.exists(self.result_path):
            os.remove(self.result_path)

        f = open(self.output_path, 'w')
        f.write('{}\n'.format(self.n))
        f.close()

        # 打印相关信息
        for i in range(self.n):
            print('generating case{}ing'.format(i))
            self.cases[i].output(self.output_path, self.result_path, i)
        f.close()

g++ xxx.cpp -o cur
./cur < input.txt > output.txt

int tcase;
cin >> tcase;

for (int _i = 0 ; _i < tcase; _i++) {
    int n, m, target;
    cin >> n >> m >> target;
    vector<vector<int>> mat(n, vector<int>(m, 0)); 
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < m; j++) {
            cin >> mat[i][j];
        }
    }
 // 算法实现在findNumberIn2DArray 函数中
    cout << findNumberIn2DArray(mat, target) << endl;
}

def get_cpp_result(code_path, bin_path, data_path, output_path):
    # 编译
    compile_st = os.system('g++ -std=c++17 -o {} {}'.format(bin_path, code_path))
    if compile_st > 0:
        print('compile error!')
        delete_files(bin_path)
        return [], False
    os.system('mkdir cur')
    # 运行
    run_st = os.system('./{} < {} > {}'.format(bin_path, data_path, output_path))

    if run_st > 0:
        print('run time error!')
        delete_files(bin_path)
        os.system('rm -rf {}'.format(output_path))
        return [], False

    ret = []
    with open(output_path, 'r') as f:
        for l in f.readlines():
            ret.append(l)

    delete_files(bin_path)
    return ret, True