System: Reach Pupil (1200+) on Codeforces

Goal: Go from a beginner (or Newbie) to Pupil (rating 1200+) on Codeforces.
Timeline: 8–12 weeks of consistent effort.
Daily commitment: 1.5–2.5 hours.

What is Pupil?

On Codeforces, ratings map to titles:

Rating	Title	Color
0 – 1199	Newbie	Grey
1200 – 1399	Pupil	Green
1400 – 1599	Specialist	Cyan
1600 – 1899	Expert	Blue

Reaching Pupil means you can consistently solve A and B problems in Codeforces rounds (Div. 2/3/4), and occasionally crack C. It proves solid fundamentals.

Prerequisites

Before starting this system, make sure you have:

Proficiency in one language (C++, Python, or Java) — you can write basic programs without Googling syntax
Understanding of input/output, loops, conditionals, arrays, and strings
A Codeforces account
Familiarity with the Codeforces contest format (2 hours, 5–7 problems, rated)

Language recommendation: C++ is the de facto standard for competitive programming due to speed and STL. If you're starting fresh, learn basic C++ I/O, vectors, sorting, and maps first (1–2 weeks).

The 4-Phase System

Overview

Phase	Focus	Duration	Target
1. Foundation	Language basics, brute-force thinking	Weeks 1–2	Solve A-level problems comfortably
2. Core Topics	Learn the Big 5 patterns	Weeks 3–6	Solve B-level problems in 15–20 min
3. Contest Mode	Real contests + upsolving	Weeks 7–10	Consistent positive delta in Div 3/4
4. Push to Pupil	Targeted weakness fixing	Weeks 11–12	Cross 1200 and stabilize

Phase 1 — Foundation (Weeks 1–2)

Goal: Get comfortable solving simple problems quickly and correctly.

What to do daily (1.5 hrs):

Solve 3–5 problems rated 800 on Codeforces problemset
After each problem, read the editorial even if you solved it (learn cleaner approaches)
Practice fast I/O and using your language’s standard library

Topics to cover:

Reading problems carefully (edge cases!)
Basic math: divisibility, modular arithmetic, GCD
String manipulation: reverse, count, compare
Simple array operations: min, max, sum, frequency counting
Conditionals and simulation ("just do what the problem says")

Problem sources:

Codeforces Problemset → Difficulty 800
Sort by “Number of Solvers” descending for well-known classics

Milestone: Solve 40+ problems rated 800

Phase 2 — Core Topics: The Big 5 (Weeks 3–6)

Goal: Learn the 5 fundamental patterns that cover 90% of A–B problems.

Spend ~1 week on each topic. For each topic: learn the concept (30 min), then solve 8–10 problems.

Topic 1: Sorting + Greedy (Week 3)

The most common pattern in competitive programming. Many problems reduce to: “sort the array, then greedily pick.”

Key ideas:

Sort and iterate — often the answer is at the beginning or end
Greedy choice: at each step, pick the locally optimal option
Common: minimize/maximize by sorting, pair smallest with largest

Practice problems (800–1100):

Problem	Rating	Key idea
A – Watermelon	800	Simple check
A – Divisible Sum Pairs	800	Iteration
B – Sort the Array	900	Sorting logic
B – Increase and Decrease	900	Greedy sum
B – Hungry Sequence	900	Greedy construction

Can sort arrays and use sorted order to simplify problems
Can identify when a greedy approach works
Know sort(), min(), max() in your language

Topic 2: Frequency Counting / Hashing (Week 3–4)

Many problems ask “how many of X?” or “does Y exist?” — solved with hashmaps/arrays.

Key ideas:

Count frequency of each element using a map or array
Use frequency to detect duplicates, find majority, check conditions
Alphabet frequency for string problems (array of size 26)

Practice problems (800–1100):

Problem	Rating	Key idea
A – Word	800	Count upper vs lower
A – Helpful Maths	800	Frequency / sorting
B – Unique Bid Auction	800	Frequency map
B – Balanced Array	800	Even/odd counting
B – Drinks	800	Averaging

Can use map / unordered_map / Counter for frequency
Can use frequency arrays for character counting
Understand when to use set vs map

Topic 3: Two Pointers / Sliding Window (Week 4–5)

For problems involving subarrays, subsequences, or ranges.

Key ideas:

Two pointers: one slow, one fast — move them based on conditions
Sliding window: fixed or variable size window over an array
Often reduces O(n²) brute force to O(n)

Practice problems (800–1200):

Problem	Rating	Key idea
A – Nearly Lucky Number	800	Simple counting
B – Books	1000	Sliding window
C – Number of Pairs	1100	Two pointers + sorting
B – Longest Subsequence	1100	LCM-based window

Can identify two-pointer / sliding-window opportunities
Can maintain a window sum/count efficiently
Know when to shrink/expand the window

Topic 4: Basic Math & Number Theory (Week 5)

Many Codeforces problems have a math trick at their core.

Key ideas:

GCD/LCM — Euclidean algorithm
Parity (even/odd) — huge number of problems use this
Divisors and prime checking
Modular arithmetic (especially mod 10⁹+7)
Digit sums, digit manipulation

Practice problems (800–1100):

Problem	Rating	Key idea
A – Even Odds	900	Math formula
B – Sum of Digits	900	Digit sum
B – GCD Length	900	GCD construction
B – Almost GCD	1000	Brute-force GCD
A – Parity	900	Even/odd pattern

Can compute GCD/LCM quickly
Comfortable with modular arithmetic
Can spot parity-based arguments
Can check primality and find divisors

Topic 5: Simple Binary Search (Week 6)

Binary search isn’t just for sorted arrays — it’s a powerful technique for any monotonic condition.

Key ideas:

Classic binary search on sorted array
Binary search on answer: “what’s the minimum X such that condition is true?”
Lower bound / upper bound in STL

Practice problems (900–1200):

Problem	Rating	Key idea
B – Worms	900	Binary search / prefix sum
C – Binary Search	1200	Binary search on answer
B – Aggressive Cows	—	Classic BS on answer
C – Maximum Median	1200	Greedy + BS

Can write bug-free binary search (be careful with bounds!)
Can identify "binary search on answer" opportunities
Understand monotonicity requirement

Milestone: 100+ total problems solved, comfortable with A+B in virtual contests

Phase 3 — Contest Mode (Weeks 7–10)

Goal: Build contest skills — speed, accuracy, and the ability to perform under pressure.

Weekly schedule:

Day	Activity	Time
Mon	Solve 3–4 problems from weak topic (900–1100)	1.5 hrs
Tue	Virtual contest — recent Div 3 or Div 4 round	2 hrs
Wed	Upsolve the problems you couldn't solve in yesterday's virtual	1.5 hrs
Thu	Solve 3–4 problems from weak topic (900–1100)	1.5 hrs
Fri	Virtual contest — recent Div 3 or Div 4 round	2 hrs
Sat	Rated contest (if available) or virtual contest + upsolve	2–2.5 hrs
Sun	Review the week: what went wrong? What topics need more work?	1 hr

The Upsolving Protocol (CRITICAL):

Upsolving is the #1 skill that separates improvers from stagnaters. After every contest:

Attempt unsolved problems for 30 more minutes without the editorial
Read the editorial. Understand the approach — don't just read the code
Code it yourself from scratch (don't copy-paste)
Add the problem and technique to your notes

Contest strategy for Div 3/4:

First 10 minutes: Read A and B completely. Solve A quickly (should take 3–8 min).
Minutes 10–40: Solve B carefully. Double-check edge cases BEFORE submitting.
Minutes 40–90: Attempt C. If stuck after 20 min, move to D (sometimes D is easier than C).
Last 30 minutes: Return to any unsolved problem. Even partial progress helps rating.

Rating tip: At this level, not getting WA on A and B matters more than solving C. A failed submission costs time (penalty) and confidence. Read problems twice before coding.

Milestone: Consistently solving A+B in Div 3/4 within 30 minutes, attempting C

Phase 4 — Push to Pupil (Weeks 11–12)

Goal: Fix weaknesses, polish speed, and cross 1200.

By now you should have identified your weaknesses. Common ones:

Weakness	Fix
Slow on A problems	Practice 50 more 800-rated problems for speed (timer: 5 min each)
WA on B problems	Spend 5 extra minutes checking edge cases: n=1, all same, all different, max values
Can’t solve C	Learn 2-3 more intermediate topics: prefix sums, basic DP, constructive algorithms
Rating anxiety	Participate in MORE rated contests, not fewer. Rating variance decreases with participation.
Time management	Do virtual contests with a physical timer. Practice the 10-40-90 split above.

Targeted practice:

Solve 15–20 problems rated 1100–1200 in the last 2 weeks
Focus on problem types you’ve failed in contests
Do at least 2 rated contests per week

Milestone: Rating 1200+ — you’re Pupil! 🎉

Topic Checklist — Complete Reference

Everything you need to know at the Pupil level:

Sorting: sort(), custom comparators, sort by frequency/second element
Greedy: activity selection, minimum coins, greedy construction
Frequency counting: maps, sets, frequency arrays
Strings: palindrome check, substring, character frequency, basic manipulation
Math: GCD/LCM, parity, divisors, modular arithmetic, digit manipulation
Two pointers: sorted pair finding, sliding window min/max/sum
Binary search: on sorted array, on answer (monotonic predicate)
Prefix sums: range sum queries in O(1), difference arrays
Brute force: knowing when O(n²) or O(n³) is acceptable (n ≤ 1000 or n ≤ 300)
Implementation: simulation problems, following instructions precisely
Constructive algorithms: building a valid answer that satisfies constraints
Basic STL/Library: vector, map, set, pair, priority_queue, string functions

Common Mistakes That Keep You Below 1200

Not reading the problem fully. 50% of WAs come from misunderstanding the problem. Read it TWICE.
Integer overflow. If numbers can be up to 10⁹ and you multiply two of them, use long long (C++) or handle large numbers.
Off-by-one errors. Array indices, loop bounds, "strictly less than" vs "less than or equal to".
Not handling edge cases. n=1, n=0, all elements equal, negative numbers, empty strings.
Submitting without testing. Always test with the sample inputs. Then test with at least one custom edge case.
Giving up after 1 contest. Rating is volatile when you have few contests. After 15+ contests, it stabilizes. Keep going.
Only solving easy problems. If you only do 800-rated problems, you'll plateau. Push into 1000–1200.
Not upsolving. Solving problems you CAN solve doesn't teach you. Upsolving problems you COULDN'T is where growth happens.

Essential Tools & Resources

Resource	What it’s for
Codeforces Problemset	Filter by rating, tag, and status
Codeforces Contests	Virtual and rated contests
CLIST.by	Upcoming contests across all platforms
CP-Algorithms	Algorithm explanations with code
USACO Guide	Structured curriculum (Bronze → Silver ≈ Pupil level)
A2OJ Ladders	Curated problem lists by rating
CF Stress Testing	How to stress test your solutions

C++ Template for Contests

If you’re using C++, start every contest with a clean template:

#include <bits/stdc++.h>
using namespace std;

#define ll long long
#define vi vector<int>
#define vll vector<long long>
#define pii pair<int,int>
#define all(v) v.begin(), v.end()
#define fast ios::sync_with_stdio(0); cin.tie(0);

void solve() {
    // Your solution here
}

int main() {
    fast
    int t;
    cin >> t;
    while (t--) solve();
    return 0;
}

Why this template?

bits/stdc++.h — includes everything (contest only, not production code)
fast macro — speeds up I/O significantly
solve() function — handles multiple test cases cleanly
ll — saves typing long long dozens of times

Rating Progression — What to Expect

Don’t expect a linear climb. Here’s a realistic trajectory:

Week 1-2:  -------- (unrated, solving easy problems)
Week 3-4:  First rated contests → rating ~700-900
Week 5-6:  Some ups, some downs → rating ~900-1050
Week 7-8:  Getting consistent → rating ~1000-1100
Week 9-10: Breaking through → rating ~1100-1200
Week 11-12: Stabilizing at 1200+ → PUPIL ✅

Reality check: You WILL lose rating in some contests. Everyone does. A bad contest doesn't erase your learning. The system works because of consistent volume — if you do 15+ rated contests and solve 200+ problems, reaching 1200 is almost guaranteed.

The Golden Rules

Consistency > Intensity. 1.5 hours daily beats 10 hours once a week.
Upsolve every contest. This is non-negotiable.
Read problems twice before writing a single line of code.
Test before submitting. Run sample tests + one custom edge case.
Track your progress. Keep a log of problems solved, contests done, and topics learned.
Don’t compare with others. Compare with your past self. Everyone has a different pace.

← Back to Systems | Back to Learning