Learning plan / recalibrated
Trinity has moved past beginner syntax drills. The next step is not a leap into advanced NOI topics; it is making familiar patterns deliberate, explainable, and repeatable.
The sequence
Each block earns the next one. If the gate is not secure, repeat the block with fewer new problems.
The raw problem-solving ability is visible. The next gain comes from making each solution explainable and repeatable.
Before coding, write the simplest correct approach and one sentence for why it fits the limits.
Move on when the process is reliable, not when a calendar week ends.
Recent solves already use parity and sorting-shaped ideas; this block turns those wins into deliberate pattern recognition.
Solve one direct counting problem and one sort-then-scan problem. Explain the choice before opening the editor.
The goal is to name the pattern before implementation and justify its complexity.
Once counting is comfortable, preprocessing is the cleanest next step: answer many simple questions without repeating work.
Draw the array with indices first. Build the prefix array by hand on a tiny example before coding.
A correct prefix-sum solution should make its indexing convention obvious.
This is the first block where maintaining an invariant matters more than writing cases. It builds a bridge from scanning to optimization.
Write the invariant in plain language, then trace pointer movement on two tiny arrays.
Do not advance until the pointer movement can be defended, not merely observed to work.
Binary search is useful only after the predicate is clear. It comes after careful scanning, not as a memorized template.
Write the yes/no feasibility question and prove monotonicity before writing the loop.
The proof of the predicate matters as much as the loop mechanics.
Graphs and DP are the destination of the first cycle, not a reason to rush past the fundamentals.
Introduce one small stateful problem only after the earlier gates are consistently secure.
This phase opens conditionally when earlier solutions are accurate, explained, and independently repeatable.
The operating system
The plan is deliberately lighter than four brand-new problems every week. Depth beats the appearance of speed.
Two carefully chosen problems, not a quota.
Rebuild one solution with the key idea named first.
A short, low-pressure set to practise reading and triage.
Repeat an old problem and explain the invariant or recurrence aloud.
Why this level
The original plan moved too quickly. These public snapshots show a learner with real traction, but not yet enough evidence for an advanced-topic sprint.
Direct implementation, simulation, counting, parity, sorting-based greedy, and a basic one-dimensional DP pattern are already appearing in accepted work.
Algorithm choice, complexity estimates, edge-case checks, and independent re-solving are the next layer — not remedial content.
Advanced DP and broad graph technique are conditional. They open after the middle blocks become reliable under light time pressure.