In our last lesson, we focused on the crucial moments after you discover a bug in your code, learning how to systematically reduce a large failing test case to its minimal form and pinpoint the exact invariant your code violated. That was a micro-level skill for dealing with a single problem. Today, we zoom out to the macro-level strategy that governs your entire performance in an online assessment.
This lesson addresses the final, and perhaps most critical, aspect of test-taking execution: applying a fixed time budget for reading, attempting, parking, and revisiting OA problems. An online assessment isn't just a test of your DSA knowledge; it's a test of your ability to score the maximum number of points under intense time pressure. The most brilliant algorithm is worthless if you spend 80 minutes on it and have no time left for two easier problems. By the end of this lesson, you will have a concrete, actionable framework for managing your time, ensuring you never again lose points to the clock.
The Tyranny of the Clock and the Power of a Budget
In a high-stakes OA, your biggest enemy isn't a hard problem; it's getting stuck. Getting stuck on one problem can create a cascade of failures: you burn time, increase stress, and leave easier points on the table. A time budget is your pre-committed defense against this. It's a discipline you impose on yourself before the test begins, so that in the heat of the moment, you don't have to make strategic decisions—you just execute the plan.
We will break this down into a four-phase strategy:
- Read & Triage: The initial intelligence-gathering phase.
- Attempt: A time-boxed, focused attack on a problem.
- Park: The disciplined decision to move on.
- Revisit: A strategic return to previously difficult problems.
Phase 1: Read & Triage (First ~15 Minutes)
Your first move in any OA should be to understand the entire battlefield. Do not immediately start coding the first problem you see. Instead, dedicate a fixed block of time at the very beginning to read all the problem statements.
The goal here isn't to solve anything. It is to perform a quick triage and categorize each problem:
- Category A (Easy): "I've seen this pattern. I'm confident I can solve it." (e.g., standard frequency count, two-pointer traversal).
- Category B (Medium): "I have some ideas, but the path isn't 100% clear. It might involve a standard algorithm with a twist." (e.g., DP on a grid, graph traversal with extra state).
- Category C (Hard): "This looks unfamiliar or requires a niche algorithm. I have no immediate ideas."
This initial assessment is crucial for planning the rest of your time. A top competitive programmer outlines a similar strategy for OI (Olympiad-style) contests, which directly applies here.
How to Effectively Practice CP + Problem Solving Guide - Codeforces
This blog post on Codeforces by a high-rated competitor provides an excellent model for contest time allocation. We'll use it to structure our own OA strategy.
In the section "Allocating Time in an OI Contest", focus on the approach described in the first paragraph. Pay attention to the idea of reading all problems first and then spending a short amount of time thinking about each one to determine an attack plan. This initial triage is the foundation of your entire strategy.
Phase 2 & 3: The Attempt/Park Cycle
Once you've triaged the problems, you begin the main phase of the contest: a cycle of attempting and, if necessary, parking problems. You should always start with the problem you identified as the easiest.
The Attempt Rule: Allocate a fixed, non-negotiable time block for your first attempt on a problem. For a 90-minute, 3-problem OA, a reasonable budget might be:
- 15 mins: Read & Triage
- 25 mins: Attempt Problem 1 (your "easy" pick)
- 30 mins: Attempt Problem 2 (your "medium" pick)
- Remaining 20 mins: Revisit & Buffer
This structure is not arbitrary. It's a proven method for managing contest time, as shown in the example budget below.
Contest Strategy - Dev Weekends
This resource from Dev Weekends provides several concrete templates for contest execution. We'll look at a specific time budget.
Find the heading "Time Management" and examine the Codeforces Time Budget (2 hours) table. Notice how it carves out distinct blocks for each problem and, crucially, reserves time at the end to "revisit earlier problems". Your personal budget should look similar: a series of time-boxed attempts followed by a review period.
The Parking Rule: This is the hardest part and requires the most discipline. If your 25-minute timer for Problem 1 goes off and you do not have a clear, implementable solution, you must stop and move to Problem 2. This is called "parking" the problem. It feels counterintuitive, but it is essential for maximizing your score. You might solve Problem 2 in 15 minutes, which is a far better outcome than spending another 15 fruitless minutes on Problem 1.
But what if you feel you're "almost there"? Before parking a problem, run a quick diagnostic.
Contest Strategy - Dev Weekends
Knowing why you are stuck can help you decide whether to spend another five minutes or to park the problem immediately.
Read the section "When You’re Stuck" and focus on the list under the Escape Strategies heading. This gives you a mental checklist. Are you stuck on the high-level approach or just a tricky implementation detail? If it's the latter, maybe write some pseudocode and move on. If it's the former, it's a clear signal to park the problem.
Phase 4: The Strategic Revisit
After you've made a first pass through all the problems according to your budget, you'll enter the revisit phase. You might have one solved problem, one parked problem, and one you haven't really touched. Now, with the remaining time, you can go back.
This is often where breakthroughs happen. By moving on, you've allowed your subconscious mind to continue processing the parked problem. When you return to it, you are looking at it with a fresh perspective, free from the mental rut you might have been in before. You may suddenly see the simple observation you were missing.
Cultivating the Right Mindset
This entire framework is a form of applied metacognition—thinking about your own thinking process. It forces you to be deliberate about how you spend your most valuable resource: focused attention.
Candidate Master in 1 Year - This Strategy Works Wonders
Competitive programming coach Colin Galen explains the mindset behind effective practice, which is identical to the mindset required for successful test-taking.
First, watch from this segment where he discusses how long to try a problem. His concept of "30 minutes of effort" is precisely what your time-boxed attempt should be: a period of intense, focused thinking, not just passive staring. Next, watch his explanation of metacognition starting at this point. A time budget is your primary tool for enforcing this. It stops you from getting "stuck in a single failing idea" by forcing a context switch.
Your Action Plan for the Upcoming OAs
Before your next assessment, create a tangible plan.
- Determine the Format: Find out the duration and number of questions.
- Create Your Budget: Based on the format, write down your time budget on a piece of paper. A 90-minute, 3-question test might look like this:
0:00 - 0:15: Read all, Triage, Order problems0:15 - 0:40: Attempt P1 (Easiest)0:40 - 1:10: Attempt P2 (Medium)1:10 - 1:30: Attempt P3 (Hardest)1:30 - 1:30: Revisit / Cleanup / Submit
- Execute with Discipline: During the test, stick to the plan. Use a timer. When the alarm for a block goes off, move on.
Conclusion
This lesson concludes our "Emergency Sprint" module on OA execution and reliability. You have now assembled a complete strategic and tactical toolkit. You know how to translate a problem statement, infer complexity targets, choose the right language, build robust tests, debug failures systematically, and now, how to manage your time across the entire assessment.
You are no longer just solving problems; you are executing a professional performance under pressure.
Our focus now shifts from strategy to substance. In the next module, "Arrays, Hashing, and Windows," we will begin our intensive drills of the high-frequency problem patterns you're likely to encounter, starting with the foundational skill of choosing the right hash map structure to answer a specific query.