Analyze the 150 most frequently asked LeetCode problems at FAANG companies.
Group them by underlying pattern (not by topic tag).
For each pattern, provide:
1. The core insight
2. 3 canonical problems (easy/medium/hard)
3. The key "tell" in the problem description that signals this pattern
4. Common mistakes

Format as a structured study guide.

import anthropic

client = anthropic.Anthropic()

MOCK_INTERVIEWER_SYSTEM = """
You are a senior FAANG technical interviewer. Conduct a realistic 
45-minute coding interview.

RULES:
1. Give ONE problem at a time, matching the difficulty level specified
2. After the candidate describes their approach, give feedback BEFORE 
   they code (this is what real interviewers do)
3. If they're stuck for >2 messages, give a progressive hint
4. After they submit code, review for: correctness, time complexity, 
   edge cases, code style
5. Ask 1-2 follow-up questions (what if we add X constraint?)
6. Rate their performance 1-10 with specific improvement points

Problem areas to draw from: [user's weak areas will be inserted here]
"""

def start_mock_interview(focus_areas: list[str], difficulty: str = "medium"):
    """Start an interactive mock interview session."""

    messages = [
        {"role": "user", "content": 
         f"Start a {difficulty} mock interview. "
         f"Focus on these weak areas: {', '.join(focus_areas)}"}
    ]

    while True:
        response = client.messages.create(
            model="claude-sonnet-4-20250514",
            max_tokens=2048,
            system=MOCK_INTERVIEWER_SYSTEM,
            messages=messages
        )

        interviewer_msg = response.content[0].text
        print(f"\n👤 Interviewer: {interviewer_msg}")
        messages.append({"role": "assistant", "content": interviewer_msg})

        if "interview complete" in interviewer_msg.lower():
            break

        my_response = input("\n🗣️ You: ")
        messages.append({"role": "user", "content": my_response})

# Usage
start_mock_interview(
    focus_areas=["graph BFS", "dynamic programming", "heap"],
    difficulty="medium"
)

Review this solution for a coding interview. Analyze:

1. CORRECTNESS: Does it handle all edge cases? Walk through examples.
2. TIME COMPLEXITY: What is it? Can it be improved?
3. SPACE COMPLEXITY: Can we reduce memory usage?
4. CLEAN CODE: Rate readability 1-10. Suggest improvements.
5. ALTERNATIVE APPROACHES: Name 2 other approaches with trade-offs.
6. INTERVIEW TIPS: What would an interviewer ask about this solution?

Problem: [paste problem]
My solution:
[paste code]

import json
from datetime import datetime, timedelta

class InterviewSRS:
    """Spaced Repetition System for interview patterns."""

    def __init__(self, filename: str = "interview_srs.json"):
        self.filename = filename
        self.cards = self._load()

    def add_pattern(self, pattern: str, problem: str, 
                    solution: str, complexity: str):
        card = {
            "pattern": pattern,
            "problem": problem,
            "solution": solution,
            "complexity": complexity,
            "next_review": datetime.now().isoformat(),
            "interval_days": 1,
            "ease_factor": 2.5,
            "reviews": 0
        }
        self.cards.append(card)
        self._save()

    def review(self):
        """Get all cards due for review today."""
        today = datetime.now().date()
        due = [c for c in self.cards 
               if datetime.fromisoformat(c["next_review"]).date() <= today]

        print(f"📚 {len(due)} patterns due for review today\n")

        for card in due:
            print(f"Pattern: {card['pattern']}")
            print(f"Problem: {card['problem']}")
            print(f"\nYour solution: ", end="")
            my_answer = input()

            print(f"\nCorrect solution: {card['solution']}")
            print(f"Complexity: {card['complexity']}")

            quality = int(input("\nRate recall (0-5): "))
            self._update_card(card, quality)

    def _update_card(self, card, quality):
        """SM-2 algorithm for spaced repetition intervals."""
        if quality >= 3:
            card["interval_days"] *= card["ease_factor"]
            card["ease_factor"] = max(1.3, card["ease_factor"] - 0.15)
        else:
            card["interval_days"] = 1
            card["ease_factor"] += 0.15

        card["next_review"] = (
            datetime.now() + timedelta(days=int(card["interval_days"]))
        ).isoformat()
        card["reviews"] += 1
        self._save()

    def _load(self):
        try:
            with open(self.filename) as f:
                return json.load(f)
        except FileNotFoundError:
            return []

    def _save(self):
        with open(self.filename, "w") as f:
            json.dump(self.cards, f, indent=2)