كود بايثون لانتاج جداول سودوكو من ٤ أرقام

import numpy as np
import random

# Brand Definition
PROGRAM_NAME = "Chameleon"

def create_initial_grid(size=4):
    grid = np.zeros((size, size), dtype=int)
    grid[0] = np.arange(size)
    return grid

def is_valid(grid, row, col, num):
    for i in range(row):
        if grid[i, col] == num:
            return False
    for j in range(col):
        if grid[row, j] == num:
            return False
    return True

# NEW: This function finds ALL possible solutions
def find_all_solutions_with_backtracking(grid, row, col, solutions, possibilities_counter):
    size = grid.shape[0]
    if row == size - 1 and col == size:
        solutions.append(grid.copy())
        return
    if col == size:
        row += 1
        col = 0
    if row == 0:
        find_all_solutions_with_backtracking(grid, 0, col + 1, solutions, possibilities_counter)
        return
    
    numbers_to_try = list(range(size))
    random.shuffle(numbers_to_try)
    
    for num in numbers_to_try:
        if is_valid(grid, row, col, num):
            possibilities_counter['count'] += 1
            grid[row, col] = num
            find_all_solutions_with_backtracking(grid, row, col + 1, solutions, possibilities_counter)
            grid[row, col] = 0

def transform_grid(grid, transformation_type):
    if transformation_type == 'reverse_rows':
        return np.fliplr(grid)
    elif transformation_type == 'reverse_cols':
        return np.flipud(grid)
    return grid

# NEW: This function orchestrates finding all solutions and filtering them
def generate_and_check_grids(num_initial_grids):
    all_generated_grids = []
    total_all_possibilities_counter = {'count': 0}
    
    solutions_found = []
    initial_grid = create_initial_grid(size=4)
    find_all_solutions_with_backtracking(initial_grid, 0, 0, solutions_found, total_all_possibilities_counter)
    
    selected_solutions = solutions_found[:num_initial_grids]

    for grid_item in selected_solutions:
        all_generated_grids.append({'grid': grid_item, 'type': 'أساسي'})
        all_generated_grids.append({'grid': transform_grid(grid_item.copy(), 'reverse_rows'), 'type': 'أفقي عكسي'})
        all_generated_grids.append({'grid': transform_grid(grid_item.copy(), 'reverse_cols'), 'type': 'عمودي عكسي'})

    unique_grids_hash = {}
    for item in all_generated_grids:
        grid_tuple = tuple(map(tuple, item['grid']))
        if grid_tuple not in unique_grids_hash:
            unique_grids_hash[grid_tuple] = item['type']
            
    final_grids = []
    for grid_tuple, grid_type in unique_grids_hash.items():
        final_grids.append({'grid': np.array(grid_tuple), 'type': grid_type})

    for i, item in enumerate(final_grids):
        print(f"\n--- الجدول النهائي رقم {i + 1} ({item['type']}) ---")
        for row in item['grid']:
            print(''.join(map(str, row)))
    
    print("\n" + "="*50)
    print("التقارير النهائية")
    print("="*50)

    total_grids_count = len(final_grids)
    vertical_inverse_count = sum(1 for item in final_grids if item['type'] == 'عمودي عكسي')
    horizontal_inverse_count = sum(1 for item in final_grids if item['type'] == 'أفقي عكسي')
    
    print(f"عدد الجداول الفريدة المتبقية: {total_grids_count} جدول.")
    print(f"منها:")
    print(f"   - {vertical_inverse_count} جدول عمودي عكسي.")
    print(f"   - {horizontal_inverse_count} جدول أفقي عكسي يمين إلى اليسار.")
    print("\n" + "-"*50)
    
    is_unique = True
    for i in range(len(final_grids)):
        for j in range(i + 1, len(final_grids)):
            if np.array_equal(final_grids[i]['grid'], final_grids[j]['grid']):
                print(f"❌ تم العثور على جداول متشابهة: الجدول رقم {i + 1} والجدول رقم {j + 1}")
                is_unique = False
    
    if is_unique:
        print("✅ التحقق من عدم التشابه: كل الجداول فريدة من نوعها.")

    print("\n" + "-"*50)
    print("التحقق من تكرار الأرقام في كل سطر")
    print("-" * 50)
    has_row_duplicates = False
    for i, item in enumerate(final_grids):
        for row_index, row in enumerate(item['grid']):
            unique_numbers = len(np.unique(row))
            if unique_numbers != len(row):
                print(f"❌ يوجد رقم مكرر في السطر {row_index + 1} من الجدول رقم {i + 1}.")
                has_row_duplicates = True
    
    if not has_row_duplicates:
        print("✅ لم يتم العثور على أي أرقام مكررة في أي سطر.")

    print("\n" + "-"*50)
    print(f"إجمالي الاحتمالات التي تم فحصها: {total_all_possibilities_counter['count']} احتمال.")
    print("\n" + "---" * 15)
    print("Chameleon by khalifa")
    print(f"الموقع: infinitycipher.com")
    print("الاحتمالات ستزيد مع كثرة الاستخدام تلقائيا.")
    print("---" * 15)


# Main program execution block
if PROGRAM_NAME == "Chameleon":
    desired_production = 5
    generate_and_check_grids(num_initial_grids=desired_production)