Python初心者がナンプレ問題作成プログラムを作ってみた-003（プログラムコード有り）

import random
import time  # 処理時間を計測するためのライブラリ

# 特定のセルに数字を配置できるかを確認する関数
def is_valid(board, row, col, num):
    for i in range(9):
        if board[row][i] == num:  # 同じ行に同じ数字がある場合
            return False
        if board[i][col] == num:  # 同じ列に同じ数字がある場合
            return False
    
    start_row, start_col = 3 * (row // 3), 3 * (col // 3)
    for i in range(start_row, start_row + 3):
        for j in range(start_col, start_col + 3):
            if board[i][j] == num:  # ブロック内に同じ数字がある場合
                return False
    
    return True

# 初期候補リストの生成関数
def generate_candidates(board):
    candidates = [[set(range(1, 10)) for _ in range(9)] for _ in range(9)]
    for i in range(9):
        for j in range(9):
            if board[i][j] != 0:
                candidates[i][j] = set()
            else:
                for num in range(1, 10):
                    if not is_valid(board, i, j, num):
                        candidates[i][j].discard(num)
    return candidates

# X-Wing テクニックを用いて候補を削除する関数
def apply_x_wing(board, candidates):
    x_wing_found = False
    # X-Wing のロジックを実装
    return x_wing_found

# XY-Wing テクニックを用いて候補を削除する関数
def apply_xy_wing(board, candidates):
    xy_wing_found = False
    # XY-Wing のロジックを実装
    return xy_wing_found

# Swordfish テクニックを用いて候補を削除する関数
def apply_swordfish_routine(board, candidates):
    swordfish_found = False
    # Swordfish のロジックを実装
    return swordfish_found

# ナンプレ盤面を解くための再帰的なバックトラッキングアルゴリズムを実装した関数
def solve_sudoku(board, candidates, apply_xwing=False, apply_xywing=False, apply_swordfish=False):
    if apply_xwing:  # X-Wing を適用するかどうか
        x_wing_applied_count = 0  # X-Wing の適用回数を制限するためのカウンター

        while apply_x_wing(board, candidates):
            x_wing_applied_count += 1
            if x_wing_applied_count > 2:  # X-Wing の適用回数を2回に制限
                break

    if apply_xywing:  # XY-Wing を適用するかどうか
        xy_wing_applied_count = 0  # XY-Wing の適用回数を制限するためのカウンター

        while apply_xy_wing(board, candidates):
            xy_wing_applied_count += 1
            if xy_wing_applied_count > 2:  # XY-Wing の適用回数を2回に制限
                break

    if apply_swordfish:  # Swordfish を適用するかどうか
        swordfish_applied_count = 0  # Swordfish の適用回数を制限するためのカウンター

        while apply_swordfish_routine(board, candidates):  # 関数呼び出しを修正
            swordfish_applied_count += 1
            if swordfish_applied_count > 2:  # Swordfish の適用回数を2回に制限
                break

    for i in range(9):
        for j in range(9):
            if board[i][j] == 0:
                for num in candidates[i][j]:
                    if is_valid(board, i, j, num):
                        board[i][j] = num
                        new_candidates = generate_candidates(board)
                        if solve_sudoku(board, new_candidates, apply_xwing, apply_xywing, apply_swordfish):  # 再帰的に次の空白セルを解こうとする
                            return True
                        board[i][j] = 0  # バックトラック
                return False  # 全ての数字が試されて無効だった場合、Falseを返す
    return True  # すべてのセルが埋められた場合

# ナンプレの完全な9x9盤面を生成するための関数
def generate_complete_board_backtracking():
    def fill_board(board):
        for i in range(9):
            for j in range(9):
                if board[i][j] == 0:
                    random_nums = list(range(1, 10))
                    random.shuffle(random_nums)
                    for num in random_nums:
                        if is_valid(board, i, j, num):
                            board[i][j] = num
                            if fill_board(board):
                                return True
                            board[i][j] = 0
                    return False
        return True

    board = [[0] * 9 for _ in range(9)]
    fill_board(board)
    return board

# 完成したナンプレ盤面から数字を削除し、指定された数の空白セルを作成するための関数
def remove_numbers_strict(board, holes):
    attempts = holes
    while attempts > 0:
        row, col = random.randint(0, 8), random.randint(0, 8)
        while board[row][col] == 0:
            row, col = random.randint(0, 8), random.randint(0, 8)
        backup = board[row][col]
        board[row][col] = 0

        board_copy = [row[:] for row in board]
        if count_solutions(board_copy) != 1:
            board[row][col] = backup
        else:
            if count_solutions(board) == 1:
                attempts -= 1
            else:
                board[row][col] = backup
    return board

# ナンプレの盤面がいくつかの解を持っているかをカウントするための関数
def count_solutions(board):
    def solve(board):
        nonlocal count
        for i in range(9):
            for j in range(9):
                if board[i][j] == 0:
                    for num in range(1, 10):
                        if is_valid(board, i, j, num):
                            board[i][j] = num
                            solve(board)
                            board[i][j] = 0
                    return
        count += 1

    count = 0
    solve(board)
    return count

# ナンプレの盤面を視覚的に表示するための関数
def print_sudoku(board):
    print("+-------+-------+-------+")
    for i in range(9):
        row = "| "
        for j in range(9):
            if board[i][j] == 0:
                row += "  "
            else:
                row += str(board[i][j]) + " "
            if (j + 1) % 3 == 0:
                row += "| "
        print(row)
        if (i + 1) % 3 == 0:
            print("+-------+-------+-------+")

# ナンプレの盤面を解いて、その結果を表示するための関数
def solve_sudoku_and_print(board, level, apply_xwing=False, apply_xywing=False, apply_swordfish=False):
    start_time = time.time()  # 処理開始時間を記録
    print(f"\n【{level}】\n★ただいま解答表示準備中...")
    candidates = generate_candidates(board)
    if solve_sudoku(board, candidates, apply_xwing, apply_xywing, apply_swordfish):
        print_sudoku(board)
    else:
        print("解けない")
    end_time = time.time()  # 処理終了時間を記録
    elapsed_time = end_time - start_time
    print(f"処理時間: {elapsed_time:.2f} 秒")  # 処理時間を表示

# ナンプレの問題を指定された難易度に基づいて生成し、その問題を解いて表示するための関数
def sudoku_solver_process(level, apply_xwing=False, apply_xywing=False, apply_swordfish=False):
    # 使用するテクニックに応じたメッセージを生成
    techniques = []
    if apply_xwing:
        techniques.append("X-Wing適用")
    if apply_xywing:
        techniques.append("XY-Wing適用")
    if apply_swordfish:
        techniques.append("Swordfish適用")
    
    technique_message = " ".join(techniques)
    print(f"\n【{level}】 {technique_message}\n★ただいま問題作成中...")
    
    start_time = time.time()  # 処理開始時間を記録

    if level == "初級":
        holes = 30
    elif level == "中級":
        holes = 40
    elif level == "上級":
        holes = 50
    elif level == "難問":
        holes = 57
    else:
        print("無効なレベルです。レベルは「初級」「中級」「上級」「難問」から選んでください。")
        return

    complete_board = generate_complete_board_backtracking()
    puzzle = remove_numbers_strict(complete_board, holes)
    print_sudoku(puzzle)

    solve_sudoku_and_print(puzzle, level, apply_xwing, apply_xywing, apply_swordfish)

    end_time = time.time()  # 処理終了時間を記録
    elapsed_time = end_time - start_time
    print(f"総処理時間: {elapsed_time:.2f} 秒")  # 処理時間を表示

# 例: 難問レベルのナンプレ問題を生成して解く
# X-Wing、XY-Wing、Swordfish適用を選択
sudoku_solver_process("初級", apply_xwing=False, apply_xywing=False, apply_swordfish=False)
sudoku_solver_process("中級", apply_xwing=False, apply_xywing=False, apply_swordfish=False)
sudoku_solver_process("上級", apply_xwing=True, apply_xywing=False, apply_swordfish=False)
sudoku_solver_process("上級", apply_xwing=False, apply_xywing=True, apply_swordfish=False)
sudoku_solver_process("上級", apply_xwing=False, apply_xywing=False, apply_swordfish=True)
sudoku_solver_process("難問", apply_xwing=True, apply_xywing=False, apply_swordfish=False)
sudoku_solver_process("難問", apply_xwing=False, apply_xywing=True, apply_swordfish=False)
sudoku_solver_process("難問", apply_xwing=False, apply_xywing=False, apply_swordfish=True)