Solving Easy Contest Problems (A/B Problems)

Real-world analogy

What is it?

This lesson teaches you how to approach and solve easy competitive programming problems (A and B problems on Codeforces). These are the foundation of competitive programming — mastering them builds your confidence and teaches you the core patterns (math, simulation, greedy, counting) that appear in harder problems too.

Real-world relevance

The step-by-step problem-solving approach works everywhere in life. Engineers break big projects into small solvable pieces. Doctors diagnose by eliminating possibilities one by one. Even cooking follows a process — read the recipe, gather ingredients, follow steps, taste and adjust. Systematic problem-solving is a universal life skill!

Key points

• What Are A/B Problems? — On Codeforces, each contest has problems labeled A, B, C, D, etc. A is the easiest and B is second easiest. They're designed to be solvable by beginners in 15-30 minutes. Your first goal should be: solve A and B in every contest you enter!
• Common Pattern: Simple Math — Many A problems are just math. 'Is n divisible by 2?' 'What's the minimum number of coins?' 'Can you split n into two even numbers?' These require no fancy algorithms — just careful thinking and basic operations (+, -, *, /, %).
• Common Pattern: Simulation — Some problems say 'do this process step by step.' Just simulate it! If the problem says 'repeat until X happens,' write a while loop that does exactly what the problem describes. Don't overthink — sometimes the brute force IS the solution.
• Common Pattern: Greedy — Greedy problems ask you to make the best choice at each step. 'Always pick the biggest item' or 'always sort first.' If the problem feels like you should sort the data and then make choices from largest to smallest (or smallest to largest), it's probably greedy!
• Common Pattern: Counting and Frequency — Many B problems ask you to count occurrences. How many times does each letter appear? What's the most frequent number? Use an array or map to count frequencies, then answer the question based on those counts.
• Step-by-Step Problem Solving — 1) Read the problem completely. 2) Understand with examples. 3) Think of the approach (math? simulation? greedy?). 4) Consider edge cases. 5) Code it up. 6) Test with the given examples. 7) Think of corner cases. 8) Submit!
• Don't Overthink A Problems! — The biggest mistake beginners make is overcomplicating A problems. If your solution needs more than 20 lines of logic, you might be overthinking. A problems are meant to be simple. Step back and look for a simpler approach.
• Learn from Wrong Answers — Getting Wrong Answer (WA) is normal! Check: did you read the problem right? Did you handle all edge cases? Is your output format correct (YES vs Yes)? Try the examples again. Try edge cases like n=1, n=0, all same numbers, maximum values.

Code example

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

// Example A Problem: "Watermelon"
// Can you split weight w into two EVEN positive numbers?
void watermelon() {
    int w;
    cin >> w;
    // Two even numbers sum to an even number >= 4
    if (w >= 4 && w % 2 == 0)
        cout << "YES\n";
    else
        cout << "NO\n";
}

// Example B Problem: "Most Frequent Character"
// Given a string, find the most frequent character
void mostFrequent() {
    string s;
    cin >> s;
    int freq[26] = {0};  // Count each letter
    for (char c : s) freq[c - 'a']++;
    
    int maxFreq = 0;
    char result = 'a';
    for (int i = 0; i < 26; i++) {
        if (freq[i] > maxFreq) {
            maxFreq = freq[i];
            result = 'a' + i;
        }
    }
    cout << result << "\n";
}

// Example: Multiple test cases (very common!)
void solveMultiple() {
    int t;      // Number of test cases
    cin >> t;
    while (t--) {
        int n;
        cin >> n;
        // Solve for each test case
        // Example: Is n a perfect square?
        int sq = sqrt(n);
        if (sq * sq == n)
            cout << "YES\n";
        else
            cout << "NO\n";
    }
}

int main() {
    // Uncomment the function you want to test:
    // watermelon();
    // mostFrequent();
    solveMultiple();
    return 0;
}

Line-by-line walkthrough

1. 1. The watermelon function: we read a weight w. To split it into two even positive numbers, both numbers must be at least 2, so the minimum sum is 4. Also, even + even = even, so w must be even. Therefore: w >= 4 AND w is even.
2. 2. The mostFrequent function: we use a frequency array of size 26 (for each letter a-z). For each character, freq[c - 'a']++ counts it. Then we scan the array to find the highest count.
3. 3. freq[c - 'a']++ — this is a classic trick! 'a' - 'a' = 0, 'b' - 'a' = 1, ..., 'z' - 'a' = 25. So each letter maps to an index 0-25.
4. 4. The solveMultiple function shows the most common CP pattern: read t (number of test cases), then solve each one in a while(t--) loop.
5. 5. int sq = sqrt(n); if (sq * sq == n) — to check if n is a perfect square, we take the square root, round it to an integer, and check if squaring it gives back n. Simple and effective!
6. 6. Each function demonstrates a different common pattern: math (watermelon), counting (most frequent), and multiple test cases (perfect square check).

Spot the bug

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

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

Explain like I'm 5

Fun fact

Hands-on challenge

More resources

• Codeforces Problem 4A — Watermelon (Codeforces)
• How to Approach CP Problems (Errichto)
• Easiest Codeforces Problems (sorted by solved count) (Codeforces)