逻辑推理 Bingo

import numpy as np
from concurrent.futures import ProcessPoolExecutor


c_1_1 = lambda grid: grid[0, 0] == 1
c_1_2 = lambda grid: grid.sum() <= 12
c_1_3 = lambda grid: grid[:, 2 - 1].sum() < grid[:, 3 - 1].sum()
c_1_4 = lambda grid: grid[1 - 1, :].sum() < grid[:, 4 - 1].sum()
c_1_5 = lambda grid: any([col.sum() == 5 for col in np.rot90(grid)])

c_2_1 = lambda grid: (grid[1 - 1 , 1 - 1] + grid[1 - 1, 2 - 1] + grid[2 - 1, 2 - 1] + grid[3 - 1, 1 - 1] + grid[3 - 1, 2 - 1]) % 2 == 1
c_2_2 = lambda grid: grid.sum() >= 13
def c_2_3(grid):
    for row in range(5):
        for col in range(5):
            if sum([grid[row+1, col+1] if row+1 < 5 and col+1 < 5 else 0,
                    grid[row, col+1] if col+1 < 5 else 0,
                    grid[row-1, col+1] if row-1 >= 0 and col+1 < 5 else 0,
                    grid[row+1, col] if row+1 < 5 else 0,
                    grid[row-1, col] if row-1 >= 0 else 0,
                    grid[row+1, col-1] if row+1 < 5 and col-1 >= 0 else 0,
                    grid[row, col-1] if col-1 >= 0 else 0,
                    grid[row-1, col-1] if row-1 >= 0 and col-1 >= 0 else 0]) == 0:
                return False
    return True
c_2_4 = lambda grid: sum([grid[5 - 1, 5 - 1], grid[1 - 1, 5 - 1], grid[5 - 1, 1 - 1], grid[1 - 1, 1 - 1]]) == 2
c_2_5 = lambda grid: any([row.sum() == 5 for row in grid])

c_3_1 = lambda grid: grid[3 - 1, 3 - 1] == 1
c_3_2 = lambda grid: grid[1 - 1:4 - 1, 1-1:4 - 1].sum() >= 5
c_3_3 = lambda grid: False # 简单推了一下就知道这里肯定是不打勾的，所以懒得写判断了。
def c_3_4(grid):
    for row in range(5):
        for col in range(5):
            if sum([grid[row, col+1] if row+1 < 5 and col+1 < 5 else 0,
                    grid[row, col-1] if row-1 >= 0 and col-1 >= 0 else 0,
                    grid[row+1, col] if row+1 < 5 and col-1 >= 0 else 0,
                    grid[row-1, col] if row-1 >= 0 and col+1 < 5 else 0]) == 4:
                if grid[row, col] != 1:
                    return False
    return True
c_3_5 = lambda grid: np.diagonal(grid).sum() == 5 or np.diagonal(np.rot90(grid)).sum() == 5

def c_4_1(grid):
    for row in range(5):
        for col in range(5):
            if sum([grid[row+1, col+1] if row+1 < 5 and col+1 < 5 else 0,
                    grid[row, col+1] if col+1 < 5 else 0,
                    grid[row-1, col+1] if row-1 >= 0 and col+1 < 5 else 0,
                    grid[row+1, col] if row+1 < 5 else 0,
                    grid[row-1, col] if row-1 >= 0 else 0,
                    grid[row+1, col-1] if row+1 < 5 and col-1 >= 0 else 0,
                    grid[row, col-1] if col-1 >= 0 else 0,
                    grid[row-1, col-1] if row-1 >= 0 and col-1 >= 0 else 0]) >= 7:
                return True
    return False
c_4_2 = lambda grid: grid[4 - 1, :].sum() < grid[:, 2 - 1].sum()
def c_4_3(grid):
    for row in range(4):
        for col in range(4):
            if grid[row:row+2, col:col+2].sum() == 4:
                return True
    return False
c_4_4 = lambda grid: sum([grid[3 - 1, 3-1:5-1].sum(), grid[5-1, 3-1:5-1].sum(), grid[4 - 1, 3 - 1], grid[4 - 1, 5 - 1]]) % 2 == 0
c_4_5 = lambda grid: True

c_5_1 = lambda grid: grid[:, 5 - 1].sum() < 3
c_5_2 = lambda grid: grid[:, 2 - 1].sum() > 3
c_5_3 = lambda grid: grid[:, 1 - 1].sum() > 3
c_5_4 = lambda grid: grid[:, 3 - 1].sum() < min([x.sum() for x in np.rot90(grid)[[0, 1, 3, 4]]])
c_5_5 = lambda grid: any([row.sum() == 0 for row in grid]) or any([col.sum() == 0 for col in grid])

condition_grid = [
    [c_1_1, c_1_2, c_1_3, c_1_4, c_1_5],
    [c_2_1, c_2_2, c_2_3, c_2_4, c_2_5],
    [c_3_1, c_3_2, c_3_3, c_3_4, c_3_5],
    [c_4_1, c_4_2, c_4_3, c_4_4, c_4_5],
    [c_5_1, c_5_2, c_5_3, c_5_4, c_5_5],
]

def condition_fulfilled(grid):
    for i in range(5):
        for j in range(5):
            if grid[i, j] == 0 and condition_grid[i][j](grid):
                    return {"condition": (i+1, j+1), "result": False}
            if grid[i, j] == 1 and not condition_grid[i][j](grid):
                    return {"condition": (i+1, j+1), "result": False}
    if grid[4 - 1, 5 - 1] != 1:
        return {"condition": "先决条件不满足", "result": False}
    if any([c_1_5(grid), c_2_5(grid), c_3_5(grid)]):
        return {"condition": "bingo", "result": True}
    else:
        return {"condition": "no bingo", "result": False}

REPEAT = 25
TOTAL = 1 << REPEAT

def int_to_grid(n: int, repeat: int = REPEAT) -> np.ndarray:
    bits = [(n >> i) & 1 for i in range(repeat - 1, -1, -1)]
    return np.array(bits).reshape((5, 5))

def check_range(start: int, end: int) -> list[np.ndarray]:
    found = []
    for n in range(start, end):
        grid = int_to_grid(n)
        if condition_fulfilled(grid)["result"]:
            found.append(grid)
    return found

def main():
    workers = 8
    chunk_size = 1 << 16
    tasks = []

    final_results = []
    with ProcessPoolExecutor(max_workers=workers) as executor:
        for start in range(0, TOTAL, chunk_size):
            end = min(start + chunk_size, TOTAL)
            tasks.append(executor.submit(check_range, start, end))

        for idx, future in enumerate(tasks, 1):
            results = future.result()
            for grid in results:
                print("Found!")
                final_results.append(grid)
            print(f"Chunk {idx}/{len(tasks)} done")
    print(f"Total found: {len(final_results)}")
    for idx, grid in enumerate(final_results):
        print(f"Result {idx + 1}:")
        print(grid)

if __name__ == "__main__":
    main()