from collections import defaultdict

SOLVED_KEYS = {
    1: 1, 2: 3, 3: 7, 4: 8, 5: 21, 10: 514
}

def calculate_pattern_score(keys):
    score = 0
    patterns = {
        'mersenne': lambda k: all(x == (2**i - 1) for i, x in enumerate(k, start=1)),
        'bitwise': lambda k: all(k[i] == (k[i-1] << 1) + 1 for i in range(1, len(k))),
        'prime': lambda k: sum(is_prime(x) for x in k)
    }
    
    for name, check in patterns.items():
        if name == 'mersenne' and check(keys):
            score += 5
        elif name == 'bitwise' and check(keys):
            score += 3
        elif name == 'prime':
            score += min(check(keys), 2)
    return score

def find_cycles(max_cycle=10):
    cycle_scores = defaultdict(int)
    puzzles = sorted(SOLVED_KEYS.items())
    
    for cycle in range(2, max_cycle+1):
        groups = defaultdict(list)
        for idx, (pn, key) in enumerate(puzzles):
            groups[idx//cycle].append((pn, key))
        
        total_score = sum(
            calculate_pattern_score([k for _, k in group])
            for group in groups.values()
        )
        cycle_scores[cycle] = total_score

    best_cycle = max(cycle_scores, key=cycle_scores.get)
    return best_cycle, cycle_scores

def analyze_groups(cycle_length):
    groups = defaultdict(list)
    puzzles = sorted(SOLVED_KEYS.items())
    for idx, (pn, key) in enumerate(puzzles):
        group_id = idx/ cycle_length
        groups[group_id].append((pn, key))
    
    print(f"\nCycle length: {cycle_length}")
    for group_id, group in groups.items():
        pns = [pn for pn, _ in group]
        keys = [key for _, key in group]
        print(f"Group {group_id+1} (Puzzles {pns}): Keys {keys}")

# Compare groups for cycle lengths 2 and 3
analyze_groups(2)
analyze_groups(3)

def is_prime(n):
    if n < 2: return False
    for i in range(2, int(n**0.5)+1):
        if n % i == 0: return False
    return True

# Run analysis
best_cycle, scores = find_cycles()
print(f"Most likely cycle length: {best_cycle}")
print("Cycle scores:", dict(scores))

%runfilehome/blackangel/untitled21.py --wdir

Cycle length: 2
Group 1 (Puzzles [1, 2]): Keys [1, 3]
Group 2 (Puzzles [3, 4]): Keys [7, 8]
Group 3 (Puzzles [5, 10]): Keys [21, 514]

Cycle length: 3
Group 1 (Puzzles [1, 2, 3]): Keys [1, 3, 7]
Group 2 (Puzzles [4, 5, 10]): Keys [8, 21, 514]
Most likely cycle length: 2
Cycle scores: {2: 10, 3: 10, 4: 2, 5: 5, 6: 2, 7: 2, 8: 2, 9: 2, 10: 2}

import hashlib
import random
import time

TOTAL_SIZE = 10000
SIMULATIONS = 500

def generate_h160(data):
    return hashlib.new('ripemd160', str(data).encode()).hexdigest()

def sequential(dataset, target_hash):
    checks = 0
    for i in range(len(dataset)):
        checks += 1
        if generate_h160(dataset[i]) == target_hash:
            return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def sequential_advanced(dataset, target_hash):
    checks = 0
    for i in range(1, len(dataset)):
        checks += 1
        if generate_h160(dataset[i]) == target_hash:
            return {"checks": checks, "found": True}
    checks += 1  # check 0 at the end
    if generate_h160(dataset[0]) == target_hash:
        return {"checks": checks, "found": True}
    return {"checks": checks, "found": False}

def compare_methods():
    results = {
        "sequential": {"wins": 0, "total_checks": 0, "total_time": 0},
        "sequential_advanced": {"wins": 0, "total_checks": 0, "total_time": 0},
        "ties": 0
    }

    for i in range(SIMULATIONS):
        dataset = list(range(TOTAL_SIZE))
        random.shuffle(dataset)
        target = random.choice(dataset)
        target_hash = generate_h160(target)

        start = time.perf_counter()
        res_seq = sequential(dataset, target_hash)
        time_seq = time.perf_counter() - start

        start = time.perf_counter()
        res_adv = sequential_advanced(dataset, target_hash)
        time_adv = time.perf_counter() - start

        results["sequential"]["total_checks"] += res_seq["checks"]
        results["sequential_advanced"]["total_checks"] += res_adv["checks"]
        results["sequential"]["total_time"] += time_seq
        results["sequential_advanced"]["total_time"] += time_adv

        if res_seq["checks"] < res_adv["checks"]:
            results["sequential"]["wins"] += 1
        elif res_seq["checks"] > res_adv["checks"]:
            results["sequential_advanced"]["wins"] += 1
        else:
            results["ties"] += 1

        print(f"Simulation {i+1}: Sequential = {res_seq['checks']} checks in {time_seq:.6f}s | Sequential-Advanced = {res_adv['checks']} checks in {time_adv:.6f}s")

    # Calcolo medie
    avg_time_seq = results["sequential"]["total_time"] results["sequential"]["wins"] if results["sequential"]["wins"] > 0 else float('inf')
    avg_time_adv = results["sequential_advanced"]["total_time"] results["sequential_advanced"]["wins"] if results["sequential_advanced"]["wins"] > 0 else float('inf')
    avg_checks_seq = results["sequential"]["total_checks"] results["sequential"]["wins"] if results["sequential"]["wins"] > 0 else float('inf')
    avg_checks_adv = results["sequential_advanced"]["total_checks"] results["sequential_advanced"]["wins"] if results["sequential_advanced"]["wins"] > 0 else float('inf')

    print(f"""
=== FINAL RESULTS ===
Wins:
Sequential: {results['sequential']['wins']}
Sequential-Advanced: {results['sequential_advanced']['wins']}
Ties: {results['ties']}

Total Checks:
Sequential: {results['sequential']['total_checks']}
Sequential-Advanced: {results['sequential_advanced']['total_checks']}

Total Time:
Sequential: {results['sequential']['total_time']:.6f} seconds
Sequential-Advanced: {results['sequential_advanced']['total_time']:.6f} seconds

Averages (Total Time Wins):
Sequential : {avg_time_seq:.6f} seconds/victory
Sequential-Advanced : {avg_time_adv:.6f} seconds/victory

Checks per Win:
Sequential : {avg_checks_seq:.2f} checks/win
Sequential-Advanced : {avg_checks_adv:.2f} checks/win
""")

if __name__ == '__main__':
    compare_methods()

=== FINAL RESULTS ===
Wins:
Sequential: 0
Sequential-Advanced: 500
Ties: 0

Total Checks:
Sequential: 2397028
Sequential-Advanced: 2396528

Total Time:
Sequential: 15.394807 seconds
Sequential-Advanced: 12.848593 seconds

Averages (Total Time Wins):
Sequential : inf seconds/victory
Sequential-Advanced : 0.025697 seconds/victory

Checks per Win:
Sequential : inf checks/win
Sequential-Advanced : 4793.06 checks/win