https://xpuzzlecorner.substack.com/p/oceans-4

prop.py

import random
import math
from collections import Counter

def sample_unit_circle(n) -> list[tuple[float, float]]:
    points = []
    while len(points) < n:
        x = random.uniform(-1, 1)
        y = random.uniform(-1, 1)
        if x*x + y*y <= 1:
            points.append((x, y))
    return points

# Returns points at center of each quadrant of unit circle
# Each point is sqrt(2)/4 distance from origin in x and y
_D = math.sqrt(2) / 4
Q1 = (_D, _D)      # Quadrant 1 (+,+)
Q2 = (-_D, _D)     # Quadrant 2 (-,+)
Q3 = (-_D, -_D)    # Quadrant 3 (-,-)
Q4 = (_D, -_D)     # Quadrant 4 (+,-)
win_ratio = None

def closest_quad_point(point: tuple[float, float]) -> int:
    x, y = point
    q1_dist = math.sqrt((x - Q1[0])**2 + (y - Q1[1])**2)
    q2_dist = math.sqrt((x - Q2[0])**2 + (y - Q2[1])**2)
    q3_dist = math.sqrt((x - Q3[0])**2 + (y - Q3[1])**2)
    q4_dist = math.sqrt((x - Q4[0])**2 + (y - Q4[1])**2)
    dists = [q1_dist, q2_dist, q3_dist, q4_dist]
    return dists.index(min(dists)) + 1

def random_diff(scale: float = 1.0) -> tuple[float, float]:
    dx = random.uniform(-0.1 * scale, 0.1 * scale)
    dy = random.uniform(-0.1 * scale, 0.1 * scale)
    return (dx, dy)

def evaluate_diff(current_q1, diff, points):
    """Evaluate a specific diff by temporarily moving Q1 and calculating win ratio"""
    global Q1
    original_q1 = Q1
    Q1 = (current_q1[0] + diff[0], current_q1[1] + diff[1])
    
    quad_counters = Counter([closest_quad_point(point) for point in points])
    q1_win_ratio = quad_counters[1] / sum(quad_counters.values())
    
    Q1 = original_q1  # Restore original Q1
    return q1_win_ratio, quad_counters

for i in range(10_000):
    scale = 1.0 / (i + 1)
    
    # Generate sample points once for this iteration
    points = sample_unit_circle(10_000)
    
    # Generate and evaluate 100 candidate diffs
    best_diff = None
    best_win_ratio = -1
    best_quad_counters = None
    best_winner = None
    
    for _ in range(100):
        diff = random_diff(scale)
        win_ratio_candidate, quad_counters = evaluate_diff(Q1, diff, points)
        winner_candidate = max(quad_counters, key=quad_counters.get)
        
        if win_ratio_candidate > best_win_ratio:
            best_win_ratio = win_ratio_candidate
            best_diff = diff
            best_quad_counters = quad_counters
            best_winner = winner_candidate
    
    # Apply the best diff only if it meets the acceptance criteria
    if win_ratio is None:
        win_ratio = best_quad_counters[1] / sum(best_quad_counters.values())
    
    next_win_ratio = best_quad_counters[1] / sum(best_quad_counters.values())
    
    if best_winner == 1:
        Q1 = (Q1[0] + best_diff[0], Q1[1] + best_diff[1])
        win_ratio = next_win_ratio
        print(f"ACCEPTED: Applied best diff")
    else:
        print(f"REJECTED: Best diff didn't meet criteria")
    
    print(f"Candidate: {Q1}")
    print(f"Q2: {Q2}")
    print(f"Q3: {Q3}")
    print(f"Q4: {Q4}")
    print(f"quad_counters: {best_quad_counters}")
    print(f"winner: {best_winner}")
    print(f"win_ratio: {win_ratio}")
    print(f"next_win_ratio: {next_win_ratio}")
    print(f"best_diff: {best_diff}")
    print(f"i: {i}")
    print(f"scale: {scale}")
    print(f"--------------------------------")