Technical Architecture

# Priority-based selection with rating and performance optimization
def select_high_rated_solutions(submissions, user_info, language_filter, num_solutions):
    # 1. Find absolute fastest submission (O(n))
    fastest = min(submissions, key=lambda x: x['timeConsumedMillis'])

    # 2. Map users to their best submission - single pass (O(n))
    best_by_user = {}
    for sub in submissions:
        handle = sub['author']['members'][0]['handle']
        if handle not in best_by_user or \
           sub['timeConsumedMillis'] < best_by_user[handle]['timeConsumedMillis']:
            best_by_user[handle] = sub

    # 3. Sort by rating descending (O(n log n))
    user_submissions = [(h, user_info.get(h, {'rating': -1})['rating'], sub)
                        for h, sub in best_by_user.items()]
    user_submissions.sort(key=lambda x: x[1], reverse=True)

    # 4. Build result: fastest + high-rated users (O(k) where k = num_solutions)
    results = [fastest]  # Always include fastest
    selected_handles = {fastest['author']['members'][0]['handle']}

    for handle, rating, sub in user_submissions:
        if len(results) >= num_solutions: break
        if handle not in selected_handles:
            results.append(sub)
            selected_handles.add(handle)

    return results

# Finds standout solutions using statistical thresholds
def find_exceptional_solutions(submissions, user_info):
    # Calculate statistical baselines
    avg_time = sum(s['timeConsumedMillis'] for s in submissions) / len(submissions)
    avg_memory = sum(s['memoryConsumedBytes'] for s in submissions) / len(submissions)

    exceptional = []

    # 1. Exceptionally fast: 50% faster than average
    fastest = min(submissions, key=lambda x: x['timeConsumedMillis'])
    if fastest['timeConsumedMillis'] < avg_time * 0.5:
        exceptional.append({'submission': fastest, 'reason': 'Exceptionally Fast'})

    # 2. Memory efficient: 50% less memory than average
    efficient = min(submissions, key=lambda x: x['memoryConsumedBytes'])
    if efficient['memoryConsumedBytes'] < avg_memory * 0.5:
        exceptional.append({'submission': efficient, 'reason': 'Memory Efficient'})

    # 3. Hidden gem: Low-rated user with excellent performance
    for sub in submissions:
        rating = user_info.get(sub['author']['handle'], {}).get('rating', 0)
        if rating < 1600 and sub['timeConsumedMillis'] < avg_time * 0.7:
            exceptional.append({'submission': sub, 'reason': 'Lower-Rated Excellence'})
            break

    return exceptional[:3]  # Top 3 exceptional solutions

# Intelligent cache invalidation with version control
def _generate_cache_key(url, num_solutions, language_filter):
    CACHE_VERSION = "v2"  # Increment to invalidate all old cache
    key_data = f"{CACHE_VERSION}:{url}:{num_solutions}:{language_filter}"
    return hashlib.md5(key_data.encode()).hexdigest()

# Two-tier caching strategy:
# 1. Specific request cache (url + filters + count)
# 2. Base cache with raw submissions (allows filtering without re-fetch)