Advertisement
max2201111

super koncovka 10 hodin vypoctu

Jun 19th, 2024
552
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Python 4.93 KB | Science | 0 0
  1. import chess
  2. import random
  3. from itertools import combinations, permutations
  4. from functools import lru_cache
  5. from concurrent.futures import ThreadPoolExecutor, as_completed
  6. import time
  7. import threading
  8.  
  9. # Generování unikátních šachových pozic
  10. def generate_chess_positions(pieces):
  11.     all_squares = [chess.SQUARES[i] for i in range(64)]
  12.     unique_fens = set()
  13.     for squares in combinations(all_squares, len(pieces)):
  14.         perm = permutations(squares)
  15.         for square_perm in perm:
  16.             board = chess.Board(None)
  17.             board.clear_board()
  18.             for piece, square in zip(pieces, square_perm):
  19.                 board.set_piece_at(square, chess.Piece.from_symbol(piece))
  20.             if board.is_valid():
  21.                 if random.choice([True, False]):
  22.                     board.turn = chess.BLACK  # Náhodně nastavíme tah pro černého
  23.                 unique_fens.add(board.fen())
  24.     return unique_fens
  25.  
  26. # Hodnocení šachovnice
  27. def evaluate_board(board, depth):
  28.     if board.is_checkmate():
  29.         return 1000 - depth if not board.turn else -1000 + depth
  30.     elif board.is_stalemate() or board.is_insufficient_material():
  31.         return 0
  32.     return 4  # Basic heuristic for non-terminal positions
  33.  
  34. # Minimax s LRU cache pro zrychlení
  35. @lru_cache(maxsize=None)
  36. def minimax(fen, depth, alpha, beta, maximizing_player, max_depth):
  37.     board = chess.Board(fen)
  38.     if depth == max_depth or board.is_game_over():
  39.         return evaluate_board(board, depth), None  # Vrátit tuple s hodnocením a None pro tah
  40.  
  41.     best_eval = float('-inf') if maximizing_player else float('inf')
  42.     best_move = None
  43.     for move in board.legal_moves:
  44.         board.push(move)
  45.         eval, _ = minimax(board.fen(), depth + 1, alpha, beta, not maximizing_player, max_depth)
  46.         board.pop()
  47.  
  48.         if maximizing_player:
  49.             if eval > best_eval:
  50.                 best_eval = eval
  51.                 best_move = move
  52.             alpha = max(alpha, eval)
  53.             if beta <= alpha:
  54.                 break
  55.         else:
  56.             if eval < best_eval:
  57.                 best_eval = eval
  58.                 best_move = move
  59.             beta = min(beta, eval)
  60.             if beta <= alpha:
  61.                 break
  62.  
  63.     return best_eval, best_move  # Vrátit tuple s hodnocením a nejlepším tahem
  64.  
  65. # Funkce pro paralelní zpracování
  66. def process_position(fen, max_depth, dot_event):
  67.     evaluation, best_move = minimax(fen, 0, float('-inf'), float('inf'), chess.Board(fen).turn == chess.WHITE, max_depth)
  68.     dot_event.set()  # Nastavit událost pro tisk tečky
  69.     return (fen, evaluation, best_move)
  70.  
  71. # Funkce pro výpis uplynulého času
  72. def print_elapsed_time(stop_event):
  73.     start_time = time.time()
  74.     while not stop_event.is_set():
  75.         time.sleep(1)
  76.         elapsed_time = time.time() - start_time
  77.         days, remainder = divmod(elapsed_time, 86400)
  78.         hours, remainder = divmod(remainder, 3600)
  79.         minutes, seconds = divmod(remainder, 60)
  80.         print(f"\rUplynulý čas: {int(days)}d {int(hours):02}h {int(minutes):02}m {int(seconds):02}s", end='', flush=True)
  81.  
  82. # Funkce pro tisk teček
  83. def print_dots(dot_event, stop_event):
  84.     while not stop_event.is_set():
  85.         if dot_event.wait(0.1):  # Čekat na nastavení události s timeoutem
  86.             print(".", end='', flush=True)
  87.             dot_event.clear()
  88.  
  89. # Hlavní část kódu
  90. initial_pieces = ['K', 'k', 'Q']
  91. unique_positions = generate_chess_positions(initial_pieces)
  92. evaluations = []
  93.  
  94. print("Počet unikátních pozic:", len(unique_positions))
  95.  
  96. # Nastavení a spuštění vlákna pro výpis času
  97. stop_event = threading.Event()
  98. dot_event = threading.Event()
  99. time_thread = threading.Thread(target=print_elapsed_time, args=(stop_event,))
  100. dot_thread = threading.Thread(target=print_dots, args=(dot_event, stop_event))
  101.  
  102. time_thread.start()
  103. dot_thread.start()
  104.  
  105. # Paralelní zpracování pozic
  106. max_depth = 19  # Limit depth for demonstration purposes
  107. batch_size = 100  # Zpracovat menší dávky paralelně
  108. with ThreadPoolExecutor(max_workers=16) as executor:
  109.     for i in range(0, len(unique_positions), batch_size):
  110.         batch_positions = list(unique_positions)[i:i + batch_size]
  111.         futures = [executor.submit(process_position, fen, max_depth, dot_event) for fen in batch_positions]
  112.         for future in as_completed(futures):
  113.             fen, evaluation, best_move = future.result()
  114.             evaluations.append((fen, evaluation, best_move))
  115.             dot_event.set()  # Nastavit událost pro tisk tečky po dokončení úlohy
  116.  
  117. # Zastavení vlákna pro výpis času a teček
  118. stop_event.set()
  119. time_thread.join()
  120. dot_thread.join()
  121.  
  122. # Print results
  123. print()
  124. for position, eval, move in evaluations:
  125.     if eval != 0 and eval != 4 and eval < 983:
  126.         turn = "White" if chess.Board(position).turn == chess.WHITE else "Black"
  127.         print(f"FEN: {position}, Turn: {turn}, Best Move: {move}, Evaluation: {eval}")
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement