Reading Contest Problems Like a Pro

Real-world analogy

What is it?

Reading contest problems is the most underrated skill in competitive programming. It means carefully understanding what a problem is asking before you write a single line of code. This includes parsing the input/output format, studying examples, reading constraints, and identifying the core algorithmic challenge hidden behind the problem's story.

Real-world relevance

In software engineering, misunderstanding requirements is the #1 cause of project failures. Reading problems carefully in CP teaches you to be precise in real life. Lawyers read contracts word by word. Doctors read lab results carefully. Engineers double-check blueprints. The skill of careful reading transfers to every career!

Key points

• Read the ENTIRE Problem First — Before writing any code, read the problem from start to finish. Don't start coding after reading just the first paragraph! Often, crucial information is hidden in the examples, notes section, or constraints. Read it ALL, then read it again.
• Understand the Input Format — The input format tells you exactly what data your program will receive and in what order. 'The first line contains n' means cin >> n first. 'The next line contains n integers' means a loop reading n numbers. Pay attention to whether numbers are on the same line or different lines.
• Understand the Output Format — The output format tells you exactly what to print. 'Print YES or NO' (watch for case sensitivity!). 'Print the answer modulo 10^9+7' means you need to take the remainder. 'Print -1 if impossible' means there's a special case. Match the format EXACTLY.
• Study the Examples Carefully — The examples are your best friends! They show you exactly how the input maps to the output. Trace through each example by hand. If your understanding doesn't produce the right output, you've misunderstood the problem. Re-read!
• Read the Constraints! — Constraints tell you HOW to solve the problem! If n ≤ 1000, an O(n²) solution works. If n ≤ 100000, you need O(n log n). If n ≤ 1000000, you need O(n). Constraints also tell you what data types to use — if values can be up to 10^18, you need long long!
• Look for Special Cases in the Notes — The 'Note' section after the examples often explains tricky cases. It might say 'Note that the array can contain duplicates' or 'The answer is guaranteed to exist.' These notes prevent you from worrying about cases that won't happen — or warn you about cases you might miss!
• Identify What's Being Asked — Break it down: What is the INPUT? What is the OUTPUT? What's the RELATIONSHIP between them? Sometimes problems are dressed up in stories. 'Knights on a chessboard' might just be a grid problem. 'Connecting cities with roads' is a graph problem. Look past the story to the math!
• Constraint Hints Cheat Sheet — n ≤ 10: try all possibilities (brute force). n ≤ 20: bitmask/subset enumeration. n ≤ 100: O(n³) is fine. n ≤ 1000: O(n²) works. n ≤ 100000: O(n log n) needed. n ≤ 1000000: O(n) needed. Memorize these — they guide your approach!

Code example

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

// Example: A typical CP problem template after reading the problem

// Problem: Given n numbers, find how many pairs have a sum equal to k.
// Input: First line: n and k. Second line: n integers.
// Output: Print the number of pairs.
// Constraints: 1 <= n <= 1000, 1 <= k <= 10^6

int main() {
    // Step 1: Read input (exactly as the format says)
    int n, k;
    cin >> n >> k;  // First line: n and k
    
    vector<int> a(n);
    for (int i = 0; i < n; i++) {
        cin >> a[i];  // Second line: n integers
    }
    
    // Step 2: Solve (n <= 1000, so O(n^2) is fine!)
    int count = 0;
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {  // j starts at i+1 to avoid counting pairs twice
            if (a[i] + a[j] == k) {
                count++;
            }
        }
    }
    
    // Step 3: Output (exactly as the format says)
    cout << count << "\n";
    
    return 0;
}

// READING CHECKLIST:
// [x] Read entire problem
// [x] Input format: n, k on first line; n numbers on second line
// [x] Output format: single number (count of pairs)
// [x] Constraints: n <= 1000 -> O(n^2) is OK
// [x] Examples verified by hand
// [x] Special cases: what if no pairs exist? -> print 0

Line-by-line walkthrough

1. 1. The problem says 'First line: n and k' — so we read two numbers with cin >> n >> k. Getting the input format right is step one!
2. 2. The problem says 'Second line: n integers' — so we create a vector of size n and read each number in a loop.
3. 3. Constraints say n <= 1000. That means n^2 = 1,000,000 which is about 10^6 operations — well within the time limit (usually 10^8 operations per second). So a simple double loop is fine!
4. 4. for (int j = i + 1; j < n; j++) — we start j at i+1, not 0, because: (a) we don't want to pair an element with itself, and (b) we don't want to count the pair (a[i], a[j]) twice (once as i,j and once as j,i).
5. 5. if (a[i] + a[j] == k) count++; — this checks if the pair sums to k. Simple and correct!
6. 6. cout << count << '\n'; — we print exactly what the problem asks: a single number. No extra words, no extra spaces. Just the answer.
7. 7. The READING CHECKLIST at the bottom is a great habit! Before coding any CP problem, mentally check off: read the problem, understood input, understood output, checked constraints, verified with examples.

Spot the bug

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

int main() {
    int n;
    cin >> n;
    int a[n];
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    int maxVal = 0;
    for (int i = 1; i <= n; i++) {
        if (a[i] > maxVal) maxVal = a[i];
    }
    cout << maxVal << "\n";
    return 0;
}

Explain like I'm 5

Fun fact

Hands-on challenge

More resources

• How to Read Problem Statements (Codeforces Blog)
• Competitive Programming Tips (Errichto)
• Beginner-Friendly Problems (Codeforces)