War Story: How a Bad LeetCode 2025 Score Cost Me a Job at Google 2026

import threading
import heapq
import time
from typing import Dict, List, Optional, Tuple
from dataclasses import dataclass
import logging

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

@dataclass
class CacheEntry:
    """Represents a single entry in the distributed cache with TTL and invalidation metadata."""
    key: str
    value: bytes
    ttl_ms: int  # Time to live in milliseconds
    created_at: int  # Epoch timestamp in ms
    node_id: str  # ID of the node that created the entry
    last_accessed: int  # Last access timestamp in ms

    def is_expired(self) -> bool:
        """Check if the cache entry has exceeded its TTL."""
        return (time.time_ns() // 1_000_000) - self.created_at > self.ttl_ms

class DistributedCacheNode:
    """Simulates a single node in a distributed cache cluster, with LeetCode 2025 contest problem logic."""
    def __init__(self, node_id: str, max_entries: int = 10_000):
        self.node_id = node_id
        self.max_entries = max_entries
        self.cache: Dict[str, CacheEntry] = {}
        self.eviction_heap: List[Tuple[int, str]] = []  # Min-heap sorted by last_accessed
        self.lock = threading.Lock()  # For thread-safe operations
        logger.info(f"Initialized cache node {node_id} with max {max_entries} entries")

    def get(self, key: str) -> Optional[bytes]:
        """Retrieve a value from the cache, updating last accessed time if found."""
        with self.lock:
            entry = self.cache.get(key)
            if not entry:
                logger.debug(f"Key {key} not found in node {self.node_id}")
                return None
            if entry.is_expired():
                logger.info(f"Key {key} expired, evicting from node {self.node_id}")
                self._evict(key)
                return None
            # Update last accessed time and heap
            entry.last_accessed = time.time_ns() // 1_000_000
            # Remove old heap entry and push new one (lazy eviction)
            heapq.heappush(self.eviction_heap, (entry.last_accessed, key))
            logger.debug(f"Retrieved key {key} from node {self.node_id}")
            return entry.value

    def put(self, key: str, value: bytes, ttl_ms: int = 60_000) -> None:
        """Insert or update a cache entry, evicting expired or LRU entries if over max capacity."""
        with self.lock:
            current_time = time.time_ns() // 1_000_000
            if key in self.cache:
                # Update existing entry
                self.cache[key].value = value
                self.cache[key].ttl_ms = ttl_ms
                self.cache[key].last_accessed = current_time
                heapq.heappush(self.eviction_heap, (current_time, key))
                logger.debug(f"Updated key {key} in node {self.node_id}")
                return
            # Check if we need to evict
            if len(self.cache) >= self.max_entries:
                self._evict_lru()
            # Create new entry
            entry = CacheEntry(
                key=key,
                value=value,
                ttl_ms=ttl_ms,
                created_at=current_time,
                node_id=self.node_id,
                last_accessed=current_time
            )
            self.cache[key] = entry
            heapq.heappush(self.eviction_heap, (current_time, key))
            logger.debug(f"Inserted key {key} into node {self.node_id}")

    def _evict(self, key: str) -> None:
        """Remove a specific key from the cache."""
        if key in self.cache:
            del self.cache[key]
            logger.info(f"Evicted key {key} from node {self.node_id}")

    def _evict_lru(self) -> None:
        """Evict the least recently used non-expired entry from the cache."""
        while self.eviction_heap:
            last_accessed, key = heapq.heappop(self.eviction_heap)
            if key not in self.cache:
                continue  # Stale heap entry
            entry = self.cache[key]
            if entry.is_expired():
                self._evict(key)
                continue
            # This is the LRU valid entry, evict it
            self._evict(key)
            break

    def purge_expired(self) -> int:
        """Purge all expired entries from the cache, returns count of purged entries."""
        purged = 0
        with self.lock:
            expired_keys = [key for key, entry in self.cache.items() if entry.is_expired()]
            for key in expired_keys:
                self._evict(key)
                purged +=1
        logger.info(f"Purged {purged} expired entries from node {self.node_id}")
        return purged

if __name__ == "__main__":
    # Benchmark the cache node as per LeetCode 2025 contest requirements
    node = DistributedCacheNode("node-1", max_entries=100)
    # Insert 100 entries
    for i in range(100):
        node.put(f"key-{i}", f"value-{i}".encode(), ttl_ms=1000)
    # Access 50 entries
    for i in range(50):
        node.get(f"key-{i}")
    # Purge expired
    time.sleep(1.1)  # Wait for TTL to expire
    purged = node.purge_expired()
    print(f"Purged {purged} expired entries")
    assert purged == 100, f"Expected 100 purged, got {purged}"
    print("Benchmark passed!")

package main

import (
    "encoding/json"
    "fmt"
    "log"
    "math"
    "os"
    "time"
)

// LeetCode2025Score calculates the annual LeetCode score per the 2025 scoring algorithm
// Scoring rules (per LeetCode 2025 TOS update):
// - Base score: 10 points per problem solved (max 1000 problems = 10,000 base)
// - Contest bonus: 50 points per contest participated, 200 points per top 100 finish, 500 per top 10
// - Consistency penalty: 0.5% score reduction per week with <3 problems solved (max 20% reduction)
// - Annual multiplier: 1.2x if >= 150 problems solved in Q4 2025

const (
    basePointsPerProblem    = 10
    contestParticipationPts = 50
    contestTop100Pts        = 200
    contestTop10Pts         = 500
    consistencyPenaltyPct   = 0.5 // % per week with <3 solves
    maxConsistencyPenalty   = 20.0 // Max % penalty
    annualMultiplier        = 1.2
    q4SolveThreshold        = 150
)

// UserActivity represents a user's LeetCode activity for a year
type UserActivity struct {
    UserID        string    `json:"user_id"`
    Year          int       `json:"year"`
    ProblemsSolved []int    `json:"problems_solved"` // Count per week, 52 weeks
    Contests      []Contest `json:"contests"`
}

// Contest represents a single LeetCode contest participation
type Contest struct {
    ID        string `json:"id"`
    Date      time.Time `json:"date"`
    Rank      int    `json:"rank"` // 0 if did not finish
    Participated bool `json:"participated"`
}

// CalculateScore computes the total LeetCode 2025 score for the user
func CalculateScore(activity UserActivity) (float64, error) {
    if activity.Year != 2025 {
        return 0, fmt.Errorf("unsupported year: %d, only 2025 scores are calculated", activity.Year)
    }
    if len(activity.ProblemsSolved) != 52 {
        return 0, fmt.Errorf("invalid problems solved count: expected 52 weeks, got %d", len(activity.ProblemsSolved))
    }

    // 1. Calculate base score from problems solved
    totalProblems := 0
    for _, weekly := range activity.ProblemsSolved {
        if weekly < 0 {
            return 0, fmt.Errorf("negative problems solved in week: %d", weekly)
        }
        totalProblems += weekly
    }
    baseScore := float64(totalProblems) * basePointsPerProblem
    if baseScore > 10000 { // Cap base score at 10k per rules
        baseScore = 10000
    }

    // 2. Calculate contest bonus
    contestBonus := 0
    q4Contests := 0
    for _, contest := range activity.Contests {
        if !contest.Participated {
            continue
        }
        contestBonus += contestParticipationPts
        if contest.Rank <= 10 {
            contestBonus += contestTop10Pts
        } else if contest.Rank <= 100 {
            contestBonus += contestTop100Pts
        }
        // Check if contest is in Q4 2025 (Oct-Dec)
        if contest.Date.Year() == 2025 && contest.Date.Month() >= 10 {
            q4Contests++
        }
    }

    // 3. Calculate consistency penalty
    penaltyWeeks := 0
    for _, weekly := range activity.ProblemsSolved {
        if weekly < 3 {
            penaltyWeeks++
        }
    }
    penaltyPct := float64(penaltyWeeks) * consistencyPenaltyPct
    if penaltyPct > maxConsistencyPenalty {
        penaltyPct = maxConsistencyPenalty
    }
    penaltyMultiplier := 1 - (penaltyPct / 100)

    // 4. Apply annual multiplier if Q4 solves >= 150
    annualMult := 1.0
    q4Solves := 0
    // Q4 is weeks 40-52 (Oct-Dec)
    for i := 39; i < 52; i++ {
        if i < len(activity.ProblemsSolved) {
            q4Solves += activity.ProblemsSolved[i]
        }
    }
    if q4Solves >= q4SolveThreshold {
        annualMult = annualMultiplier
    }

    // 5. Calculate final score
    finalScore := (baseScore + float64(contestBonus)) * penaltyMultiplier * annualMult
    return math.Round(finalScore), nil
}

func main() {
    // Load sample activity from JSON (simulate my 2025 activity)
    sampleActivity := UserActivity{
        UserID: "senior-dev-123",
        Year: 2025,
        ProblemsSolved: make([]int, 52),
        Contests: []Contest{},
    }
    // Fill sample data: 40 problems per week for 52 weeks = 2080 total
    for i := 0; i < 52; i++ {
        sampleActivity.ProblemsSolved[i] = 40
    }
    // Add 12 contests, 2 top 10, 4 top 100
    for i := 0; i < 12; i++ {
        contest := Contest{
            ID: fmt.Sprintf("contest-2025-%d", i+1),
            Date: time.Date(2025, time.Month(i+1), 15, 0, 0, 0, 0, time.UTC),
            Participated: true,
        }
        if i < 2 {
            contest.Rank = 5 // Top 10
        } else if i < 6 {
            contest.Rank = 50 // Top 100
        } else {
            contest.Rank = 500 // Participated only
        }
        sampleActivity.Contests = append(sampleActivity.Contests, contest)
    }

    score, err := CalculateScore(sampleActivity)
    if err != nil {
        log.Fatalf("Failed to calculate score: %v", err)
    }
    fmt.Printf("My 2025 LeetCode Score: %.0f\n", score)
    fmt.Printf("Google 2026 L4 Threshold: 1580\n")
    fmt.Printf("Deficit: %.0f points\n", 1580 - score)

    // Marshal to JSON for output
    jsonData, err := json.MarshalIndent(sampleActivity, "", "  ")
    if err != nil {
        log.Fatalf("Failed to marshal activity: %v", err)
    }
    os.WriteFile("my-2025-activity.json", jsonData, 0644)
}

import fetch from 'node-fetch';
import { GraphQLClient } from 'graphql-request';
import { writeFileSync } from 'fs';
import { config } from 'dotenv';

config(); // Load .env for LEETCODE_SESSION cookie

const LEETCODE_API = 'https://leetcode.com/graphql/';
const USER_AGENT = 'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';

interface LeetCodeUserScore {
  username: string;
  totalSolved: number;
  contestRating: number;
  annualScore2025: number;
  contestParticipation: number;
  top100Finishes: number;
  top10Finishes: number;
}

interface ContestHistory {
  contestId: string;
  rank: number;
  participated: boolean;
  date: string;
}

const GET_USER_QUERY = `
  query getUserScore($username: String!) {
    matchedUser(username: $username) {
      username
      submitStats: submitStatsGlobal {
        acSubmissionNum {
          difficulty
          count
        }
      }
      userContestRanking {
        rating
        participationCount
        top100Count
        top10Count
      }
      contestHistory {
        contestId
        rank
        participated
        startTime
      }
    }
  }
`;

/**
 * Fetches a user's LeetCode 2025 score and activity, with retry logic for rate limiting.
 * @param username - LeetCode username to fetch
 * @param retries - Number of retries for failed requests (default 3)
 * @returns LeetCodeUserScore object with annual score
 */
async function fetchLeetCodeScore(username: string, retries = 3): Promise {
  const sessionCookie = process.env.LEETCODE_SESSION;
  if (!sessionCookie) {
    throw new Error('LEETCODE_SESSION environment variable is required');
  }

  const client = new GraphQLClient(LEETCODE_API, {
    headers: {
      Cookie: `LEETCODE_SESSION=${sessionCookie}`,
      'User-Agent': USER_AGENT,
      Referer: 'https://leetcode.com/',
    },
  });

  for (let attempt = 1; attempt <= retries; attempt++) {
    try {
      const data: any = await client.request(GET_USER_QUERY, { username });
      const user = data.matchedUser;
      if (!user) {
        throw new Error(`User ${username} not found`);
      }

      // Calculate total problems solved
      const totalSolved = user.submitStats.acSubmissionNum.reduce(
        (acc: number, curr: any) => acc + curr.count,
        0
      );

      // Filter 2025 contest history
      const contestHistory2025: ContestHistory[] = user.contestHistory.filter(
        (contest: any) => {
          const contestDate = new Date(contest.startTime * 1000);
          return contestDate.getFullYear() === 2025 && contest.participated;
        }
      );

      // Calculate annual score using the same logic as the Go example
      const baseScore = Math.min(totalSolved * 10, 10000);
      const contestBonus =
        contestHistory2025.length * 50 +
        user.userContestRanking.top100Count * 200 +
        user.userContestRanking.top10Count * 500;
      // Simplified consistency penalty for demo
      const consistencyPenalty = 0; // Assume no penalty for demo
      const penaltyMultiplier = 1 - consistencyPenalty / 100;
      const annualMultiplier = totalSolved >= 150 ? 1.2 : 1.0; // Simplified Q4 check

      const annualScore2025 = Math.round(
        (baseScore + contestBonus) * penaltyMultiplier * annualMultiplier
      );

      return {
        username: user.username,
        totalSolved,
        contestRating: user.userContestRanking.rating,
        annualScore2025,
        contestParticipation: user.userContestRanking.participationCount,
        top100Finishes: user.userContestRanking.top100Count,
        top10Finishes: user.userContestRanking.top10Count,
      };
    } catch (error: any) {
      if (attempt === retries) {
        throw new Error(`Failed to fetch score after ${retries} attempts: ${error.message}`);
      }
      // Exponential backoff for rate limits
      const backoffMs = Math.pow(2, attempt) * 1000;
      console.warn(`Attempt ${attempt} failed, retrying in ${backoffMs}ms: ${error.message}`);
      await new Promise(resolve => setTimeout(resolve, backoffMs));
    }
  }

  throw new Error('Unreachable code');
}

/**
 * Compares user score against Google 2026 L4 threshold and outputs a report.
 */
async function generateScoreReport(username: string) {
  try {
    const scoreData = await fetchLeetCodeScore(username);
    const googleThreshold = 1580;
    const deficit = googleThreshold - scoreData.annualScore2025;

    const report = {
      timestamp: new Date().toISOString(),
      user: scoreData,
      googleL4Threshold2026: googleThreshold,
      isEligible: scoreData.annualScore2025 >= googleThreshold,
      deficit: deficit > 0 ? deficit : 0,
    };

    writeFileSync(
      `leetcode-score-report-${username}.json`,
      JSON.stringify(report, null, 2)
    );

    console.log(`\n=== LeetCode 2025 Score Report for ${username} ===`);
    console.log(`Total Problems Solved: ${scoreData.totalSolved}`);
    console.log(`Contest Rating: ${scoreData.contestRating}`);
    console.log(`2025 Annual Score: ${scoreData.annualScore2025}`);
    console.log(`Google L4 Threshold: ${googleThreshold}`);
    console.log(`Eligible for Google 2026 L4: ${report.isEligible ? 'YES' : 'NO'}`);
    if (!report.isEligible) {
      console.log(`DEFICIT: ${deficit} points (need ${deficit} more to qualify)`);
    }
  } catch (error: any) {
    console.error(`Failed to generate report: ${error.message}`);
    process.exit(1);
  }
}

// Run the report for my username
if (require.main === module) {
  const username = process.argv[2] || 'senior-dev-123';
  generateScoreReport(username);
}

#!/bin/bash
# Auto-register for LeetCode contests via GraphQL API
LEETCODE_SESSION="your_session_cookie_here"
CONTEST_ID=$1

curl -X POST 'https://leetcode.com/graphql/' \
  -H "Cookie: LEETCODE_SESSION=$LEETCODE_SESSION" \
  -H 'Content-Type: application/json' \
  -H 'User-Agent: Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36' \
  -d '{
    "query": "mutation registerForContest($contestId: String!) { registerForContest(contestId: $contestId) { success } }",
    "variables": { "contestId": "'$CONTEST_ID'" }
  }'

# Run the LeetCode score calculator with your username
export LEETCODE_SESSION="your_session_cookie_here"
go run main.go senior-dev-123

import requests
import os

GREENHOUSE_API_KEY = os.getenv("GREENHOUSE_API_KEY")
LEETCODE_SCORE = 1568  # Replace with calculated score
CANDIDATE_ID = "12345"

response = requests.post(
    f"https://harvest.greenhouse.io/v1/candidates/{CANDIDATE_ID}/custom_fields",
    auth=(GREENHOUSE_API_KEY, ""),
    json={
        "custom_fields": [
            {
                "name": "leetcode_2025_score",
                "value": LEETCODE_SCORE
            }
        ]
    }
)

if response.status_code == 200:
    print("Synced LeetCode score to Greenhouse")
else:
    print(f"Failed to sync: {response.text}")