Watch vector, map and sort move.

Write any program here and run it. Start from the example below, pick one of the 37 topics from the list, or press Try it on any code block further down the page. Put your program's input in the stdin box, the way you would type it into a terminal.

Raising a number to a power. The loop multiplies result by 2 nine times. pow(2, 9) does the same work but returns a double, so the answer is 512.0 printed as 512.

Doubles can round. A well-known case: some older MinGW builds printed 99 for (int)pow(10, 2). When you need an exact integer, use a loop, or 1LL << n for powers of two.

A pair stores two values in one variable. The two types can differ: pair<char, int> holds a letter and a number. Read them with .first and .second.

Pairs can nest. In pr4 the first slot is itself a pair, so you reach the 3 with pr4.first.first. Click an expression below to see which slot it reads.

A tuple is a pair that can hold any number of values. A student record of roll number, name and grade fits in tuple<int, string, char>. Read a value with get<0>(t), get<1>(t) and so on.

The index inside < > must be a constant. get<i>(t) with a loop variable i does not compile, because each slot can have a different type.

An iterator marks a position inside a container. it is the position, *it is the value stored there. begin() points at the first element. end() points at the slot after the last one, so a loop runs while i != end().

Reverse iterators flip the direction: rbegin() is the last element and rend() sits before the first. Step through both below. Try dereferencing end() to see why it is off limits.

A vector is an array that grows. Elements sit side by side in memory, so vec[i] jumps straight to slot i.

The dashed slots are capacity: memory already reserved but not used yet. When size == capacity and you push again, the vector allocates a bigger block and copies every element over. GCC doubles the capacity each time (1, 2, 4, 8, 16), which keeps push_back fast on average. Push until it happens and watch the capacity counter.

array<int, 5> is a plain C array int arr[5] with container manners: it knows its size(), has begin()/end(), supports at() with bounds checking, and can be copied with =.

The size is part of the type, so there is no push_back or erase. Use it when the count never changes: 12 months, 26 letters, 4 directions in a grid.

Each element lives in its own node, and each node points to the node before and after it (the ⇄ arrows). Adding at the front only rewires two pointers, which is why list has push_front and vector does not.

The price: there is no ls[3]. To reach the fourth element you walk from the head, one node at a time.

Each node points only to the next node, so it uses less memory than list. You can only move forward. Because a node can't see the one before it, you insert and erase after a position: insert_after, erase_after.

There is no push_back and no size(). Counting the nodes means walking all of them with distance(fl.begin(), fl.end()).

A deque (double-ended queue) stores elements in fixed-size blocks plus a small table that tracks the blocks. Pushing to the front fills the first block backwards. When a block is full, the deque adds a new block instead of moving everything.

You get fast pushes at both ends like a list, and dq[i] like a vector. Blocks of 4 below keep it readable; real GCC blocks are 512 bytes.

A string behaves like a vector<char> with text tools on top. push_back, size, iterators, sort and reverse all work.

Watch the arguments. substr(start, length) takes a length, not an end index, so s.substr(0, 5) gives 5 characters. find returns the index of the first match, or string::npos when there is none.

bitset<8> stores 8 on/off flags packed into one byte. Bit 0 is the rightmost when printed. set(i) turns bit i on, reset(i) turns it off, flip(i) toggles it, and count() tells you how many are on.

Click any bit below to flip it and watch the decimal value change.

Last in, first out. You only touch the top: push puts an element on top, top() reads it, pop() removes it. There is no iteration and no indexing, so to print a stack you pop it until empty().

The example pushes 5, 8, 6, 3 and prints 3 6 8 5. Run the while loop below to see why the order flips.

First in, first out, like a line at a ticket counter. push joins at the back, pop leaves from the front. front() and back() read the two ends.

A priority_queue is a binary heap stored inside a vector. Index i has children at 2i+1 and 2i+2. In a max-heap every parent is at least as large as its children, so the maximum always sits at index 0.

push adds the value at the end and swaps it upward while it beats its parent. pop moves the last element to the root and swaps it downward. Each move climbs one level, and a heap of n elements has about log₂ n levels. With 1,000,000 elements that is 20 swaps at most.

A set keeps unique values in ascending order. Insert 12 twice and the second insert is ignored. Internally it is a balanced binary tree, so each operation walks one path from root to leaf: about 20 steps for a million elements.

lower_bound(x) returns the first element ≥ x. upper_bound(x) returns the first element > x. If nothing qualifies you get end(). Try 11, 12 and 214 below.

Same as set, but duplicates stay. Values are still sorted, and equal values sit next to each other.

The trap is erase. ms.erase(2) with a value removes every 2. ms.erase(ms.find(2)) with an iterator removes one. Try both.

A map stores key-value pairs with unique keys, sorted by key. It is the same tree as a set, with a value attached to each key.

Three behaviors catch people out, and all three are buttons below. mpp[k] = v overwrites an existing value. mpp.insert({k, v}) does not overwrite when the key exists. Reading mpp[k] for a missing key creates it with an empty value.

A multimap allows the same key many times. Entries are sorted by key only. Entries with equal keys keep the order you inserted them, which is why the output shows 1 -> a, 1 -> b, 1 -> a.

equal_range(k) returns a pair of iterators. first points at the first entry with key k. second points one past the last one. Loop from first while i != second.

Values go into buckets. A hash function turns the value into a bucket number, so a lookup computes one number and checks only that bucket. No tree to walk, which makes the average cost O(1).

This model uses x % 7 so you can predict where each value lands. GCC hashes an int to itself and then takes value % bucket_count, so the idea matches. Because buckets follow the hash, iteration order looks random, and there is no lower_bound.

A map built on a hash table. The key decides the bucket, the value rides along. You get the same [], insert, find and count as map, faster on average, with no ordering. This model hashes the key with key % 5.

The output of the example came out as 4, 3, 2, 1 on g++ 13.3. Another compiler can print a different order.

sort(first, last) sorts the half-open range: first is included, last is not. So sort(nums + 1, nums + 4) sorts indices 1, 2 and 3 and leaves 0 and 4 alone. The result is 9 1 3 4 0.

For an array, nums + k is a pointer to index k. For a vector, use vec.begin() + k. Same idea.

Two students both scored 90. A stable sort promises that whoever came first in the input still comes first in the output. std::sort makes no such promise and may swap them.

This matters when you sort twice: sort by name first, then stable_sort by marks, and students with equal marks stay alphabetical.

nth_element(first, first + k, last) puts the value that belongs at index k into index k. Everything left of it is ≤, everything right is ≥, and neither side is sorted. That is enough for a median or the k-th smallest score, and it runs in linear time.

partial_sort(first, first + k, last) sorts only the first k positions. Use it for "top 3 scores" when fully sorting 1,000,000 values would waste time.

A comparator answers one question: should a come before b? sort calls it many times and arranges elements from the answers.

complexComparator sorts pairs by second descending, and breaks ties by first ascending. Click any two pairs below to ask the comparator about them, then sort.

Both walk the range from left to right. count checks every element and returns how many match. find stops at the first match and returns an iterator to it. When nothing matches, find returns last (here nums + 5), so compare against that before using *it.

Binary search looks at the middle, throws away the half that can't contain the answer, and repeats. 1,000,000 elements need at most 20 looks.

binary_search only answers yes or no. lower_bound (first ≥ x) and upper_bound (first > x) return positions, and ub - lb counts how many times x appears. Step through the search below and watch lo, mid and hi close in.

These take a condition instead of a value. You write the condition as a lambda: [](int x) { return x % 2 == 0; } is a small unnamed function that returns true for even numbers.

all_of, any_of and none_of stop as soon as the answer is known. Pick a condition and run each one to see how many elements it actually checks.

max_element and min_element return an iterator, not a value. Use *it for the value and it - nums for the index. reverse swaps elements from both ends toward the middle.

rotate(first, middle, last) moves middle to the front and wraps the earlier elements to the back. rotate(v.begin(), v.begin() + 2, v.end()) turns 1 2 3 4 5 6 into 3 4 5 6 1 2: a left rotation by 2.

For a right rotation, use reverse iterators: rotate(v.rbegin(), v.rbegin() + k, v.rend()).

unique slides each new value forward over the repeats and returns an iterator to the new logical end. It does not shrink the vector. The leftover tail still exists with unspecified values until you erase it.

It also only compares neighbours, so sort first. The full idiom is sort, then v.erase(unique(v.begin(), v.end()), v.end()).

fill(first, last, value) writes the same value into every slot of the range. It is the standard way to reset a DP table to -1.

iota(first, last, start) writes start, start + 1, start + 2 and so on. Use it to build the index list 0 1 2 … n-1 that you then sort by some key.

transform reads each input element, calls your function, and writes the result to an output range. The output can be a different vector or the same one.

for_each just calls your function on each element. To change the elements, the lambda must take a reference: [](int &x) { x *= 10; }. Without the & it changes a copy and the vector stays the same.

next_permutation rearranges the range into the next larger order, the way words follow each other in a dictionary. It returns false after the largest order (cba) and resets the range to the smallest (abc). That is why the do { } while loop prints each permutation once.

Start sorted or you miss some: starting from bca prints only bca cab cba. prev_permutation walks backwards, so start it from descending order.

accumulate(first, last, init) starts at init and adds each element. With init 0 you get the plain sum, 16. With init 5 you get 21.

The type of init sets the type of the running total. Summing a vector<long long> with init 0 adds into an int and can overflow. Write 0LL.

partial_sum writes running totals: pre[i] = v[0] + … + v[i]. After that, the sum of any range v[l..r] is pre[r] - pre[l - 1], one subtraction instead of a loop.

With 100,000 queries on 100,000 numbers, a loop per query is 10¹⁰ steps. Prefix sums make it 200,000.

gcd uses Euclid's rule: gcd(a, b) = gcd(b, a % b), stopping when b is 0. 48 and 18 take three steps: 48 % 18 = 12, 18 % 12 = 6, 12 % 6 = 0.

lcm(a, b) equals a / gcd(a, b) × b. Dividing first keeps the intermediate number small.

These walk two sorted ranges with one pointer each. At every step they compare the two current values, emit something, and advance the smaller side. No hashing, no nested loops.

The output goes through an iterator. back_inserter(u) calls u.push_back for each result, so you don't need to size u in advance.

n is the number of elements. "amortized" means fast on average, with an occasional slow step (a vector reallocating). "avg" means average case for hash tables.

Each of these compiles. Most still print something. That is what makes them dangerous.

Eleven quick questions. Each answer explains itself when you click.