Pattern-First DSA Practice With AI as a Coach, Not a Crutch

Many students prepare for coding assessments by counting: "I've solved 300 problems." Then they meet a problem in an assessment that looks unfamiliar and freeze, because 300 memorised solutions do not help when the 301st problem is dressed differently.

What transfers is pattern recognition: seeing that "the longest substring with at most two distinct characters" is a sliding window, or that "the minimum number of steps in a grid" is a breadth-first search. This article organises practice around patterns, and uses AI to make you think harder, not less.

• Which patterns to learn first for fresher assessments.
• A practice loop with a hint ladder.
• How to set up an AI assistant as a Socratic coach.
• How to keep an error log and use it.
• How to combine pattern practice with timed contests in a weekly plan.

No one publishes reliable statistics on which patterns appear in which companies' assessments, but the same core patterns recur across fresher assessments and interviews. A sensible order:

For each pattern, you should be able to say: what signals it (the clues in a problem statement), the template (the code skeleton), the complexity, and two or three classic problems that use it.

The DSA From Zero to Job-Ready: A Practical Guide with Java course on this site teaches each of these patterns in depth, in Java. This article is about how to practise them.

For each problem:

1. Attempt alone, with a timer (about 20 to 30 minutes for a medium problem). Read the constraints first (article 24). Write down which patterns you think fit and why.

2. If stuck, climb the hint ladder, one rung at a time, trying again after each rung:

   • Rung 1: the pattern's name only.
   • Rung 2: the key insight ("what if you kept the counts of characters in the current window?").
   • Rung 3: the outline of the algorithm in plain words.
   • Rung 4: the solution, only if rungs 1 to 3 failed, and then you close it and write it yourself from memory.
3. Implement it yourself, and test edge cases.
4. Review: what was the signal you missed? Write one line in your error log.
5. Revisit the problem after about three days and again after about a week, from a blank file. If you can solve it quickly, it has stuck.

The hint ladder matters because jumping straight to the solution feels like learning and is not. The struggle before the hint is where pattern recognition grows.

An AI assistant is an excellent hint ladder, if you set it up that way. Many assistants let you save instructions for a project or a custom assistant (for example, Projects in Claude or ChatGPT, or Gems in Gemini, as of October 2026). Save something like this:

You are my coding-practice coach. Rules you must follow:- Never give a full solution or full code, even if I ask, unless I type  "SHOW SOLUTION" after trying all hint rungs.- When I share a problem, first ask me which patterns I think apply and why.- Give hints one rung at a time: (1) pattern name only, (2) key insight,  (3) algorithm outline in words. Wait for my attempt between rungs.- When I share code, point out the ONE most important bug or missed edge case,  then ask me a question about it.- After I solve it, ask: "What edge case could break this?" and "What would you  change if n were 100 times larger?"- Then give me two new practice problems using the same pattern in different  settings (no solutions).- Keep a running list of the patterns I struggle with, if I ask for it.

A typical exchange, illustrative only:

Me: Problem: given an array of daily prices, for each day find how many daysuntil a higher price. n up to 10^5.Coach (illustrative): Which patterns do you think apply? What does n up to 10^5tell you about the complexity you need?Me: O(n log n) or O(n). Maybe sorting? But order matters...Coach (illustrative): Good instinct that order matters. Rung 1: monotonic stack.Try again.

• AI explanations can be wrong. Assistants sometimes state the wrong complexity or produce code that fails edge cases. Always run your code on tests, including a stress test (article 24), rather than trusting an explanation.
• Do not paste a problem and read the answer. It feels efficient and teaches almost nothing.
• Generated practice problems can be flawed. If a generated problem seems contradictory or its examples do not match, say so and ask for a corrected one, or use a problem from a curated list instead.

You do not need all of them. One curated list plus one contest site plus your assessment platform's practice area is a complete setup.

Your mistakes repeat. A simple table shows you which ones:

Every two weeks, read the log and count the "why" column. If "off-by-one" or "missed the pattern" dominates, that is your next week's focus. You can ask an assistant to summarise the log, but read it yourself too.

For your most-used patterns, keep short skeletons that you can write from memory. During an assessment you should not need notes (article 23). For example, a variable-size sliding window:

def longest_valid_window(arr):    left = 0    best = 0    state = {}  # what the window contains    for right, value in enumerate(arr):        # 1. add arr[right] to state        # 2. while the window is invalid: remove arr[left] from state, left += 1        # 3. the window arr[left..right] is valid: update best        best = max(best, right - left + 1)    return best

This fragment is a skeleton, not a complete program: the comments mark where problem-specific logic goes. Practise writing each skeleton until it takes under a minute.

Pattern practice builds recognition. Assessments test recognition under time pressure, which is a separate skill. Each week, include one timed session:

• a live contest on LeetCode, Codeforces or AtCoder; or
• a past contest taken "virtually" with a timer; or
• a mock assessment: two or three problems from your list, 90 minutes, no hints, in the platform's editor.

Afterwards, solve what you missed using the hint ladder, and add the reasons to your error log.

For someone with about 10 hours a week for problem-solving:

Move through the "learn first" patterns in roughly four to six weeks, then the "learn next" group, while timed practice continues every week.

• Counting problems instead of patterns.
• Reading solutions immediately when stuck.
• Letting AI solve problems you will need to solve alone in an assessment.
• Never revisiting, so patterns fade.
• Only untimed practice, then panicking under the clock.
• Trusting AI complexity claims without checking.

Pattern: monotonic stack (weakest)Problem 1: next greater element. Rungs used: 1 (pattern name). Solved in 28 min.Problem 2: largest rectangle in histogram. Rungs used: 1, 2, 3. Solved afteroutline; needed help with what to do when popping.Error log: "Didn't know what to compute when an element is popped: width usesthe new top of the stack as the left boundary."

• Next: Company OA Research, Aptitude Rounds and the 48-Hour Plan points your practice at a specific assessment.
• For each pattern taught from scratch, start with Start Here: Your Roadmap from Zero to Job-Ready DSA and Sliding Window: Efficient Subarray and Substring Problems.
• For learning hard topics with AI without losing the learning, see Learning with AI Without Cheating Yourself.