Competitive programming is the sport of solving well-defined algorithmic problems under time and memory limits, where your code must produce correct output fast. Most top contestants use C++ because it runs quickly and ships with a powerful Standard Template Library. This roadmap shows beginners in Bangladesh how to start, what to learn, and where to practice.

What competitive programming actually is

In competitive programming, you read a problem statement, design an algorithm, write code, and submit it to an online judge. The judge runs your program against hidden test cases. If every case passes within the time limit (often 1 to 2 seconds) and the memory limit (commonly 256 MB), you get "Accepted." Otherwise you see verdicts like Wrong Answer, Time Limit Exceeded, or Runtime Error.

The skill being tested is not typing speed. It is choosing the right data structure and algorithm so your solution stays within the limits. A problem that looks simple can fail if your approach is too slow for large inputs. That is why understanding efficiency matters as much as getting a correct answer on small examples.

Why C++ is the preferred language

Three reasons make C++ the common choice among contestants:

• Speed. Compiled C++ runs much faster than interpreted languages, so solutions that would time out elsewhere pass comfortably.
• The STL. Ready-made containers and algorithms (vectors, sets, maps, sorting) let you write less code and avoid bugs.
• Control. You manage memory and types directly, which helps when limits are tight.

You do not need advanced C++ to begin. A small subset gets you far: input and output, loops, functions, arrays, and a handful of STL containers. Here is a minimal program that reads two integers and prints their sum.

#include <iostream>
using namespace std;

int main() {
    int a, b;
    cin >> a >> b;
    cout << a + b << "\n";
    return 0;
}

Compile it with g++ on your machine: g++ -O2 -o sol sol.cpp, then run ./sol.

STL essentials you will use daily

The Standard Template Library is the reason C++ feels productive in contests. Learn these first.

vector: a resizable array

A vector grows as you add elements and supports fast indexed access. Use it instead of raw arrays in almost every problem.

#include <vector>
#include <iostream>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> v(n);
    for (int i = 0; i < n; i++) cin >> v[i];
    v.push_back(42);          // add one more
    cout << v.size() << "\n"; // number of elements
    return 0;
}

sort: ordering in O(n log n)

The sort algorithm orders a range quickly. Pass a comparator to control the order.

#include <algorithm>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {5, 2, 9, 1};
    sort(v.begin(), v.end());                 // ascending: 1 2 5 9
    sort(v.begin(), v.end(), greater<int>()); // descending: 9 5 2 1
    return 0;
}

map and set: keyed and unique data

A map stores key-value pairs in sorted order; a set stores unique sorted values. Both give logarithmic insert and lookup. Use unordered_map and unordered_set when you need average constant-time access and do not care about order.

#include <map>
#include <iostream>
using namespace std;

int main() {
    map<string, int> freq;
    freq["dhaka"]++;   // counts occurrences
    freq["dhaka"]++;
    cout << freq["dhaka"] << "\n"; // prints 2
    return 0;
}

Time complexity: the core skill

Time complexity describes how the number of operations grows as the input size n grows. We write it with Big-O notation. A judge with a 1-second limit can handle roughly 100 million simple operations, so you estimate whether your approach fits before you code it.

• O(1) constant: a single arithmetic step.
• O(log n) logarithmic: binary search on sorted data.
• O(n) linear: one pass over the input.
• O(n log n): sorting an array.
• O(n²) quadratic: nested loops over the same array.

Suppose n = 100000. An O(n²) solution does 10 billion operations and will time out. An O(n log n) solution does about 1.7 million and passes easily. Training yourself to estimate this before writing code is the habit that separates passing from failing.

Where to practice

Use judges that have beginner-friendly problem sets and editorials:

• Codeforces runs frequent rated contests; filter problems by difficulty and start near the bottom.
• AtCoder has the Beginner Contest (ABC) series with clear, well-ordered problems.
• LeetCode focuses on interview-style problems, useful if jobs are your goal.
• CSES Problem Set is a free, curated list that covers fundamental topics in order.

In Bangladesh, many universities run programming clubs and host events such as the National Collegiate Programming Contest, and teams compete in the ICPC regional. Joining a campus club gives you a study group, mentors, and practice contests, which speeds up learning far more than studying alone.

A practical roadmap for beginners

Follow these stages in order. Do not rush; depth beats speed.

1. Master C++ basics. Input/output, conditionals, loops, functions, arrays, and strings.
2. Learn the core STL. vector, sort, pair, map, set, and stack/queue.
3. Understand complexity. Practice estimating Big-O for your solutions before submitting.
4. Drill fundamentals. Two pointers, prefix sums, binary search, and simple greedy logic.
5. Study basic algorithms. Sorting variants, recursion, and basic graph traversal (BFS and DFS).
6. Compete regularly. Enter at least one contest a week and read editorials for problems you miss.
7. Review weaknesses. Keep a list of topics that trip you up and solve more problems on each.

Consistency is the real secret. Solving two or three problems a day for several months builds pattern recognition that no single tutorial can give you. When a problem feels impossible, read the editorial, understand the idea, then re-solve it from scratch a few days later.

Turning the skill into a career

The problem-solving discipline you build here transfers directly to software engineering interviews and day-to-day backend work. If you want to put these skills to professional use, browse openings at Avian™ Career once you are comfortable solving medium-level problems.

Frequently asked questions

Do I need to be good at math to start competitive programming? No. Basic arithmetic, logic, and comfort with numbers are enough at the beginning. Some advanced problems use number theory or combinatorics, but you can learn those topics gradually as you progress. Strong problem-solving habits matter more than a heavy math background early on.

Which is better for beginners, C++ or Python? Both work for learning. Python is easier to read, but C++ runs faster and is the standard in serious contests, so solutions are less likely to time out. Starting with C++ saves you from rewriting later, and the STL keeps your code short once you learn it.

How long does it take to get reasonably good? With steady daily practice, most beginners reach an intermediate level in roughly six months to a year. Progress depends on consistency, not talent. Solving problems regularly and reviewing editorials carefully matters far more than the total hours you log in one weekend.

Should I memorize algorithms or understand them? Understand them. Memorized code breaks the moment a problem varies slightly. When you grasp why an algorithm works, you can adapt it to new situations and debug it quickly. Re-implement key algorithms from scratch until you can write them without looking anything up.