Revisiting Core Problems Regularly

Why this lesson matters

You have moved fast: data structures, recursion, sorting, hash tables, graphs, divide and conquer, and dynamic programming.

A 30-day crash course only works if you keep old ideas alive while adding new ones. Otherwise, you solve a hash table problem on Monday, learn graphs on Wednesday, and forget the hash table pattern by Friday.

This final lesson turns the course into a repeatable system:

• revisit core problems every 2 days
• rotate across problem families
• track mistakes, not just completions
• rebuild confidence under time pressure

Think of this as the bridge from “I watched lessons” to “I can solve problems on my own.”

Solving once is not ownership

When you first solve a problem, you often remember the hint, the lesson context, or the exact trick.

When you revisit it two days later, you test something deeper:

• Can I recognize the pattern without being told?
• Can I choose the right data structure quickly?
• Can I explain the time complexity?
• Can I code it cleanly from a blank file?

This is especially important for easy and medium problems. The goal is not to memorize answers. The goal is to build pattern recall.

A strong review loop makes familiar problems feel automatic, so harder problems become combinations of things you already trust.

A tiny review schedule

Here is a simple Python version of the review idea.

Each problem has a first-solved day. We schedule it again every 2 days. In a real crash course, you would keep this in a notebook, spreadsheet, or small script.

Notice the pattern: your daily work is not only “new topic today.” It is also “what should I revisit today?”

```python
problems = {
    "Two Sum": 1,
    "Valid Parentheses": 1,
    "Binary Search": 2,
    "Number of Islands": 3,
    "Climbing Stairs": 4,
}

review_interval = 2
last_day = 8

for day in range(1, last_day + 1):
    due_today = []
    for name, first_solved_day in problems.items():
        if day >= first_solved_day and (day - first_solved_day) % review_interval == 0:
            due_today.append(name)

    print(f"Day {day}: {due_today}")
```

You solved a medium hash table problem two days ago. Today it appears in your review queue.

What is the main purpose of retrying it?

Rotate across families

A useful review queue should not contain only your favorite topic.

Build a small matrix of core problems from the lessons you already completed:

Family Review examples What you are testing Data structures stack, queue, set/map tasks choosing the right tool Recursion tree/list recursion, branching calls base case and call flow Sorting custom sort, interval ordering ordering before solving Hash tables Two Sum, frequency counts fast lookup and counting Graphs BFS/DFS traversal visited sets and neighbors Divide/conquer binary search, merge logic shrinking the search space Dynamic programming climbing stairs, min cost state and recurrence

For a beginner Python learner, this matrix is powerful because it keeps decisions concrete: “What family is this problem from, and what operation matters most?”

True or false:

If you can solve a problem once after seeing a hint, you should permanently remove it from your review loop.

Track the reason, not just the result

When you miss a review problem, do not write only “wrong.” That is too vague to help.

Use mistake tags:

• pattern: I did not recognize the family
• structure: I chose the wrong data structure
• edge: I missed an edge case
• complexity: my solution was too slow
• code: I knew the idea but implemented it poorly
• trace: I could not manually walk through the algorithm

This turns mistakes into instructions. If many misses are tagged structure, revisit Introduction to Data Structures and Understanding Hash Tables. If many are tagged trace, slow down and use the tracing habits from Mastering Recursion and Graph Basics.

```python
mistakes = [
    ("Two Sum", "pattern"),
    ("Valid Parentheses", "edge"),
    ("Binary Search", "edge"),
    ("Number of Islands", "trace"),
    ("Climbing Stairs", "state"),
    ("Min Cost Climbing Stairs", "state"),
]

counts = {}
for problem, tag in mistakes:
    counts[tag] = counts.get(tag, 0) + 1

print("Mistake summary:")
for tag, count in sorted(counts.items()):
    print(f"{tag}: {count}")

most_common = max(counts, key=counts.get)
print(f"Focus next: {most_common}")
```

In this crash course, the default revisit rhythm is to retry core problems every ___ days.

Fill in the blank: _____________

A practical 45-minute block

When time is limited, use a fixed structure instead of improvising.

1. Warm up: 5 minutes

Pick one easy problem from two days ago. Solve quickly or explain the approach out loud.

2. Main review: 20 minutes

Retry one medium problem. Start from a blank file. No solution tab.

3. New problem: 15 minutes

Do one new easy or medium problem from the current topic mix.

4. Log: 5 minutes

Record:

• solved independently? yes/no
• mistake tag
• time spent
• next review day

The point is consistency. A small daily loop beats a heroic five-hour session once a week.

Keep the loop alive

Here is a small review queue simulation.

Each reviewed problem gets a result:

• easy: you solved it cleanly, so it stays on the normal 2-day rhythm
• hard: you struggled, so it comes back tomorrow

This is the key adjustment: difficult problems should return sooner, not disappear.

```python
from collections import deque

queue = deque([
    {"name": "Two Sum", "due": 10},
    {"name": "Binary Search", "due": 10},
    {"name": "Number of Islands", "due": 10},
])

results = {
    "Two Sum": "easy",
    "Binary Search": "hard",
    "Number of Islands": "easy",
}

today = 10
new_queue = deque()

while queue:
    item = queue.popleft()
    name = item["name"]
    result = results[name]

    next_due = today + 1 if result == "hard" else today + 2
    new_queue.append({"name": name, "due": next_due})
    print(f"Reviewed {name}: {result}, next due day {next_due}")

print("Updated queue:")
print(list(new_queue))
```

You now have a system

This crash course gave you the core tools:

• Introduction to Data Structures taught you to choose by operation.
• Mastering Recursion taught you base cases, call flow, and tracing.
• Sorting Algorithms taught you ordering as a strategy.
• Understanding Hash Tables gave you fast lookup and counting patterns.
• Graph Basics introduced BFS, DFS, neighbors, and visited sets.
• Divide and Conquer Strategies trained you to split and shrink problems.
• Dynamic Programming Essentials taught you state, recurrence, and reuse.

Now this lesson gives you the maintenance plan.

For the next 30 days, do not chase only new problems. Revisit your core set every 2 days, tag mistakes, and rotate families. That is how beginner understanding becomes real proficiency.