Make the knowledge yours

Write two formulas: area = length × width; perimeter = 2 × (length + width).

Read both dimensions, calculate each expression, and print the two results with an explicit separator. Parentheses ensure that both dimensions are doubled for the perimeter.

#include <iostream>

int main() {
    long long length = 0, width = 0;
    std::cin >> length >> width;
    std::cout << length * width << ' ' << 2 * (length + width) << '\n';
    return 0;
}

The product can reach 10¹⁸. Make the multiplication itself use long long.

Read both values into long long. Their product is then computed with the wider type, and the maximum allowed product fits a signed 64-bit integer.

#include <iostream>

int main() {
    long long a = 0, b = 0;
    std::cin >> a >> b;
    std::cout << a + b << ' ' << a * b << '\n';
    return 0;
}

Take a quotient for complete units and a remainder for what is left. A duration of 86400 seconds has 24 hours.

Divide by 3600 for hours. Split the remainder by 60 into minutes and seconds. Check that 3600 × hours + 60 × minutes + seconds reconstructs the input.

#include <iostream>

int main() {
    long long total = 0;
    std::cin >> total;
    long long hours = total / 3600;
    long long remaining = total % 3600;
    std::cout << hours << ' ' << remaining / 60 << ' ' << remaining % 60 << '\n';
    return 0;
}

First require all three pairwise sums to exceed the remaining side. Then test all-equal before any-equal.

Validity must come before classification. Equality in a triangle inequality is a flattened shape. Among valid triangles, all equal comes first because it also satisfies “some pair is equal.”

#include <iostream>

int main() {
    long long a = 0, b = 0, c = 0;
    std::cin >> a >> b >> c;
    if (!(a + b > c && a + c > b && b + c > a)) {
        std::cout << "INVALID\n";
    } else if (a == b && b == c) {
        std::cout << "EQUILATERAL\n";
    } else if (a == b || a == c || b == c) {
        std::cout << "ISOSCELES\n";
    } else {
        std::cout << "SCALENE\n";
    }
    return 0;
}

Use a char for the operator and long long for arithmetic. Guard the division within its branch.

Each case computes one operation and breaks. The divisor check is only needed for division. The task guarantees one of the four operators.

#include <iostream>

int main() {
    long long a = 0, b = 0;
    char operation = ' ';
    std::cin >> a >> operation >> b;
    switch (operation) {
        case '+': std::cout << a + b << '\n'; break;
        case '-': std::cout << a - b << '\n'; break;
        case '*': std::cout << a * b << '\n'; break;
        case '/':
            if (b == 0) { std::cout << "ERROR\n"; }
            else { std::cout << a / b << '\n'; }
            break;
    }
    return 0;
}

Visit 2, 4, 6, … and use a long long total initialized before the loop.

Each iteration adds the next positive even value exactly once. For n < 2, no additions happen, so the answer remains zero.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    long long sum = 0;
    for (int i = 2; i <= n; i += 2) {
        sum += i;
    }
    std::cout << sum << '\n';
    return 0;
}

A count adds one per match. Read the next value even when the current value is not positive.

Keep the input update outside the positivity condition so every iteration advances. The initial sentinel produces a count of zero.

#include <iostream>

int main() {
    int x = 0, positive = 0;
    std::cin >> x;
    while (x != 0) {
        if (x > 0) { ++positive; }
        std::cin >> x;
    }
    std::cout << positive << '\n';
    return 0;
}

The starting flag handles values below 2. A matching divisor makes further checks unnecessary.

The outputs for the five suggested inputs are NO, NO, YES, NO, YES. For eligible n, the loop examines every possible divisor other than 1 and n until it finds a counterexample.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    bool prime = (n >= 2);
    for (int divisor = 2; divisor < n; ++divisor) {
        if (n % divisor == 0) {
            prime = false;
            break;
        }
    }
    std::cout << (prime ? "YES" : "NO") << '\n';
    return 0;
}

The first read establishes the candidate. Exactly n − 1 reads remain.

After each read, best is the maximum of everything consumed. This uses one running candidate and works for equal values, all-negative values, and n = 1.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    long long best = 0;
    std::cin >> best;
    for (int i = 1; i < n; ++i) {
        long long x = 0;
        std::cin >> x;
        if (x > best) { best = x; }
    }
    std::cout << best << '\n';
    return 0;
}

The inner loop’s bound is the current row number.

Row r prints exactly r stars. The outer loop visits every required row once, and the newline ends each row.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    for (int row = 1; row <= n; ++row) {
        for (int column = 1; column <= row; ++column) {
            std::cout << '*';
        }
        std::cout << '\n';
    }
    return 0;
}

Increment a counter each time you remove one digit. Ensure one iteration happens for zero.

A do-while handles zero without a separate branch. Each iteration removes exactly one digit and increments the count once.

#include <iostream>

int main() {
    long long n = 0;
    std::cin >> n;
    int count = 0;
    do {
        ++count;
        n /= 10;
    } while (n > 0);
    std::cout << count << '\n';
    return 0;
}

What must be remembered between iterations? Is n included? How many final answers are required?

Place the long long sum before the loop, use i <= n, and print once after the loop. For n = 0 the loop does no work and prints 0.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    long long sum = 0;
    for (int i = 1; i <= n; ++i) {
        sum += i;
    }
    std::cout << sum << '\n';
    return 0;
}

Store first, then visit signed indices from n − 1 down to 0. An empty input starts at −1 and skips the loop.

The output traversal changes the visiting order without assigning to any cell. Use a signed counter so the stopping value −1 is representable.

#include <iostream>

int main() {
    int a[1000]{};
    int n = 0;
    std::cin >> n;
    for (int i = 0; i < n; ++i) { std::cin >> a[i]; }
    for (int i = n - 1; i >= 0; --i) {
        if (i < n - 1) { std::cout << ' '; }
        std::cout << a[i];
    }
    std::cout << '\n';
    return 0;
}

Avoid dividing: multiply the candidate by the positive n using wide arithmetic.

The first pass computes the total and stores the values. The second applies the equivalent exact comparison. For [−10, −4, −4], the average is −6 and the answer is 2.

#include <iostream>

int main() {
    int a[1000]{};
    int n = 0;
    std::cin >> n;
    long long sum = 0;
    for (int i = 0; i < n; ++i) {
        std::cin >> a[i];
        sum += a[i];
    }
    int count = 0;
    for (int i = 0; i < n; ++i) {
        if (1LL * a[i] * n > sum) { ++count; }
    }
    std::cout << count << '\n';
    return 0;
}

The first element has no predecessor. Start the scan at index 1.

Only 5 > 2 and 4 > 1 are rises. Equal neighbours do not count. Zero- and one-element lists naturally return zero.

#include <iostream>

int main() {
    int a[1000]{};
    int n = 0;
    std::cin >> n;
    for (int i = 0; i < n; ++i) { std::cin >> a[i]; }
    int rises = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i] > a[i - 1]) { ++rises; }
    }
    std::cout << rises << '\n';
    return 0;
}

Use one if condition: r == c OR r + c == n − 1.

The shared centre enters one addition, because a single true condition performs one update. A long long safely holds the sum under these bounds.

#include <iostream>

int main() {
    int n = 0;
    std::cin >> n;
    int a[30][30]{};
    for (int r = 0; r < n; ++r) {
        for (int c = 0; c < n; ++c) { std::cin >> a[r][c]; }
    }
    long long sum = 0;
    for (int r = 0; r < n; ++r) {
        for (int c = 0; c < n; ++c) {
            if (r == c || r + c == n - 1) { sum += a[r][c]; }
        }
    }
    std::cout << sum << '\n';
    return 0;
}

Check the digit range before subtracting '0'.

The range check proves the conversion represents a decimal digit. Input 7 gives 7 14; input A gives NOT A DIGIT.

#include <iostream>

int main() {
    char c = ' ';
    std::cin >> c;
    if ('0' <= c && c <= '9') {
        int digit = c - '0';
        std::cout << digit << ' ' << digit * 2 << '\n';
    } else {
        std::cout << "NOT A DIGIT\n";
    }
    return 0;
}

Initialize the candidate from the first element of the current case, not from an earlier case.

The two suggested answers are 90 and −5. Each case’s fresh candidate and active length keep state independent.

#include <iostream>

int main() {
    int a[1000]{};
    int t = 0;
    std::cin >> t;
    for (int test = 0; test < t; ++test) {
        int n = 0;
        std::cin >> n;
        for (int i = 0; i < n; ++i) { std::cin >> a[i]; }
        int best = a[0];
        for (int i = 1; i < n; ++i) {
            if (a[i] > best) { best = a[i]; }
        }
        std::cout << best << '\n';
    }
    return 0;
}

Use a fresh result string. Append only when the complete vowel condition is false.

The source word remains unchanged during traversal, so no indices shift. A word containing only vowels produces an empty output line.

#include <iostream>
#include <string>

int main() {
    std::string s;
    std::cin >> s;
    std::string result;
    int n = static_cast<int>(s.size());
    for (int i = 0; i < n; ++i) {
        char c = s[i];
        bool vowel = c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
        if (!vowel) { result.push_back(c); }
    }
    std::cout << result << '\n';
    return 0;
}

Compare the strings directly, rather than comparing only their lengths.

Use a <= b to choose the first string when it is smaller or equal; otherwise print b. No sorting algorithm is necessary for this two-value decision.

#include <iostream>
#include <string>

int main() {
    std::string a, b;
    std::cin >> a >> b;
    if (a <= b) { std::cout << a << '\n'; }
    else { std::cout << b << '\n'; }
    return 0;
}

Bounds first, equality second. Ordinary getline calls already consume each line ending.

The counter is the number of leading characters proven equal. Stop at a mismatch or either end. substr(0, length) then extracts exactly that common prefix.

#include <iostream>
#include <string>

int main() {
    std::string a, b;
    std::getline(std::cin, a);
    std::getline(std::cin, b);
    int n = static_cast<int>(a.size());
    int m = static_cast<int>(b.size());
    int length = 0;
    while (length < n && length < m && a[length] == b[length]) {
        ++length;
    }
    std::cout << length << '\n' << a.substr(0, length) << '\n';
    return 0;
}

A word begins at a non-space whose predecessor does not exist or is a space.

The i == 0 part must come first within the OR, so the previous-character access is skipped at the start. An empty or all-space line contributes no word starts.

#include <iostream>
#include <string>

int main() {
    std::string line;
    std::getline(std::cin, line);
    int words = 0;
    int n = static_cast<int>(line.size());
    for (int i = 0; i < n; ++i) {
        if (line[i] != ' ' && (i == 0 || line[i - 1] == ' ')) {
            ++words;
        }
    }
    std::cout << words << '\n';
    return 0;
}

Save the last value before shifting. Copy from right to left.

The saved value wraps into index zero, while every earlier element moves exactly one place right. The guard makes the empty case safe and a one-element list stays unchanged.

#include <iostream>

int main() {
    int a[1000]{};
    int n = 0;
    std::cin >> n;
    for (int i = 0; i < n; ++i) { std::cin >> a[i]; }
    if (n > 0) {
        int last = a[n - 1];
        for (int i = n - 1; i > 0; --i) { a[i] = a[i - 1]; }
        a[0] = last;
    }
    for (int i = 0; i < n; ++i) {
        if (i > 0) { std::cout << ' '; }
        std::cout << a[i];
    }
    std::cout << '\n';
    return 0;
}

Use a writable reference to each stored character.

char& c aliases the current character. Assigning through it changes the string; a plain char c would be only a copy.

#include <iostream>
#include <string>

int main() {
    std::string s;
    std::getline(std::cin, s);
    for (char& c : s) {
        if (c == '-') { c = '+'; }
    }
    std::cout << s << '\n';
    return 0;
}

Compare a with b first, then compare that result with c.

The largest of the first two values is the only candidate from that pair that can win the final comparison. This uses constant time and constant auxiliary space.

// Complete C++23 program. Input: three integers.
#include <iostream>
int larger(int a, int b) { return a > b ? a : b; }
int maximumOfThree(int a, int b, int c) {
    return larger(larger(a, b), c);
}
int main() {
    int a = 0, b = 0, c = 0;
    std::cin >> a >> b >> c;
    std::cout << maximumOfThree(a, b, c) << '\n';
}

Use two early returns for values outside the range; the remaining path is already inside.

The three cases cover all permitted inputs. Each performs a fixed number of comparisons, so the helper uses O(1) time and auxiliary space.

// Complete C++23 program. Input: value low high, with low <= high.
#include <iostream>
int clampToRange(int value, int low, int high) {
    if (value < low) return low;
    if (value > high) return high;
    return value;
}
int main() {
    int value = 0, low = 0, high = 0;
    std::cin >> value >> low >> high;
    std::cout << clampToRange(value, low, high) << '\n';
}

Swap only when a > b; preserve the old a in a temporary before assigning.

If a is already no greater than b, the contract is satisfied. Otherwise the swap reverses the two values without losing either one. The helper has O(1) time and auxiliary space.

// Complete C++23 program. Input: two integers.
#include <iostream>
void orderPair(int& a, int& b) {
    if (a > b) {
        int temporary = a;
        a = b;
        b = temporary;
    }
}
int main() {
    int a = 0, b = 0;
    std::cin >> a >> b;
    orderPair(a, b);
    std::cout << a << ' ' << b << '\n';
}

Keep a best index, initialized from a real element. Replace it only when a strictly smaller value appears.

After each visited index, best points to the earliest minimum of that prefix. Strict comparison preserves the earlier index on equality. The helper is O(n) time and O(1) auxiliary space.

// Complete C++23 program. Input: n, then n integers; 1 <= n <= 1000.
#include <iostream>
int indexOfMinimum(const int a[], int n) {
    int best = 0;
    for (int i = 1; i < n; ++i) {
        if (a[i] < a[best]) best = i;
    }
    return best;
}
int main() {
    int a[1000]{};
    int n = 0;
    std::cin >> n;
    for (int i = 0; i < n; ++i) std::cin >> a[i];
    std::cout << indexOfMinimum(a, n) << '\n';
}

Compare the leftmost and rightmost remaining characters. A single mismatch is enough to reject.

After every successful comparison, the already-checked outside characters match. When the indices meet or cross, no unchecked pair remains. Each step removes two candidates, giving O(L) time and O(1) auxiliary space.

// Complete C++23 program. Input: one ASCII line, length <= 100000.
#include <iostream>
#include <string>
bool isPalindrome(const std::string& text) {
    int left = 0;
    int right = static_cast<int>(text.size()) - 1;
    while (left < right) {
        if (text[left] != text[right]) return false;
        ++left;
        --right;
    }
    return true;
}
int main() {
    std::string text;
    std::getline(std::cin, text);
    std::cout << (isPalindrome(text) ? "YES\n" : "NO\n");
}

List 0, 3, 6, … below n. A partial final group still contributes one visit.

The exact count is ceil(n/3), or (n + 2) / 3 under these bounds: 0, 1, and 3 for the requested cases. Including setup, time is Θ(n + 1); conventional positive-size shorthand is Θ(n). The counter and index use O(1) auxiliary space.

The widths below 10 are 1, 2, 4, and 8. Add them rather than multiplying the number of widths by 10.

The count is 1 + 2 + 4 + 8 = 15. For any n ≥ 1, the geometric sum is less than 2n and at least a constant fraction of n, so the total is Θ(n), with O(1) auxiliary space.

Reject values below two. Return false on a divisor; place the final true after the loop.

Every composite positive value has a tested divisor at or below its square root. A divisor is sufficient evidence to reject; no divisor in the required range proves primality for values at least two.

// Complete C++23 program. Input: -10^9 <= value <= 10^9.
#include <iostream>
bool isPrime(int value) {
    if (value < 2) return false;
    for (int divisor = 2; divisor <= value / divisor; ++divisor) {
        if (value % divisor == 0) return false;
    }
    return true;
}
int main() {
    int value = 0;
    std::cin >> value;
    std::cout << (isPrime(value) ? "YES\n" : "NO\n");
}

Charge one full scan to each query, plus per-query setup and output.

The query batch takes O(q(n + 1)) time and O(1) helper auxiliary space. A const array parameter avoids mutation and does not copy all array elements, but the body still visits n values per query. The stored input itself uses separate storage.

Keep a local passed counter inside solve. Process each score as it arrives.

A local counter resets for each case. Streaming uses O(1) extra storage and O(t + Σnᵢ) total time. Test an empty case immediately after a case containing several passing scores.

// Complete C++23 program. Input: t, then n and n scores for each case.
#include <iostream>
bool isPassing(int score) { return score >= 50; }
void solve() {
    int n = 0, passed = 0;
    std::cin >> n;
    for (int i = 0; i < n; ++i) {
        int score = 0;
        std::cin >> score;
        if (isPassing(score)) ++passed;
    }
    std::cout << passed << '\n';
}
int main() {
    int t = 0;
    std::cin >> t;
    for (int test = 0; test < t; ++test) solve();
}

Share a constant column width between the caller’s array and the helper’s parameter. Use long long for the total.

The helper visits three cells per active row, so it has O(rows + 1) time and O(1) auxiliary space. The input wrapper allocates 100 × 3 integers regardless of the active row count.

// Complete C++23 program. Input: rows, then rows * 3 integers.
#include <iostream>
constexpr int COLUMNS = 3;
long long sumMatrix(const int a[][COLUMNS], int rows) {
    long long total = 0;
    for (int row = 0; row < rows; ++row) {
        for (int col = 0; col < COLUMNS; ++col) total += a[row][col];
    }
    return total;
}
int main() {
    int a[100][COLUMNS]{};
    int rows = 0;
    std::cin >> rows;
    for (int row = 0; row < rows; ++row) {
        for (int col = 0; col < COLUMNS; ++col) std::cin >> a[row][col];
    }
    std::cout << sumMatrix(a, rows) << '\n';
}

Write a separate line for each unfinished call. The second print waits for the smaller call to return.

The output is 3, 2, 1, 1, 2, 3 on separate lines. There are n + 1 calls and 2n output lines, so time and ordinary call-stack space are O(n + 1). For zero, it prints no lines.

// Complete C++23 program. Input: 0 <= n <= 20.
#include <iostream>
void downAndUp(int n) {
    if (n == 0) return;
    std::cout << n << '\n';
    downAndUp(n - 1);
    std::cout << n << '\n';
}
int main() {
    int n = 0;
    std::cin >> n;
    downAndUp(n);
}

Start with an empty vector. Append only when x > 0; zero is not positive.

After every input, the vector contains exactly the positive values seen so far in arrival order. The n input steps and amortized appends give O(n + 1) time and O(k + 1) stored elements, where k is the kept count.

// Complete C++23 program. Input: n, then n integers.
#include <iostream>
#include <vector>
int main() {
    int n = 0;
    std::cin >> n;
    std::vector<int> kept;
    for (int i = 0; i < n; ++i) {
        int x = 0;
        std::cin >> x;
        if (x > 0) kept.push_back(x);
    }
    std::cout << kept.size() << '\n';
    for (int i = 0; i < static_cast<int>(kept.size()); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << kept[i];
    }
    std::cout << '\n';
}

Track the existing elements separately from allocated room. Check inequalities for capacity rather than a guessed exact value.

The lines are 0 1, 4 2, 2 8, and 1 1. Reserve creates no elements. Resize and push create 8 8 8 2; shrinking leaves 8 8. Clear removes those elements and retains capacity.

// Complete C++23 program. No input.
#include <iostream>
#include <vector>
int main() {
    std::vector<int> values;
    values.reserve(5);
    std::cout << values.size() << ' ' << (values.capacity() >= 5) << '\n';
    values.resize(3, 8);
    values.push_back(2);
    std::cout << values.size() << ' ' << values.back() << '\n';
    values.resize(2);
    std::cout << values.size() << ' ' << values.back() << '\n';
    values.clear();
    std::cout << values.empty() << ' ' << (values.capacity() >= 5) << '\n';
}

Use the current indices after every operation, not the original ones.

After reversal: 10 40 30 20 50. After insertion: 10 40 99 30 20 50. After erasing current index 3: 10 40 99 20 50. The erased value is 30. The insertion changed where later values lived.

std::erase removes target matches. Then sort, unique, and erase the tail after the returned iterator.

Removing matches is linear. Sorting groups duplicate values; unique keeps one in its logical prefix and the final erase changes the actual size. Overall time is O(1 + n log(n + 1)); stored input is O(n + 1), plus sorting implementation workspace.

// Complete C++23 program. Input: 0 <= n <= 200000, target, then n integers.
#include <algorithm>
#include <iostream>
#include <vector>
int main() {
    int n = 0, target = 0;
    std::cin >> n >> target;
    std::vector<int> values(n);
    for (int& x : values) std::cin >> x;
    std::cout << std::erase(values, target) << '\n';
    std::sort(values.begin(), values.end());
    auto newEnd = std::unique(values.begin(), values.end());
    values.erase(newEnd, values.end());
    for (int i = 0; i < static_cast<int>(values.size()); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << values[i];
    }
    std::cout << '\n';
}

For each column, reset one long long total, then visit that column in every row.

The inner loop visits exactly the requested column. Repeating across all columns visits every cell once, giving O(rows × cols) processing time and stored cells. Wide totals handle sums exceeding int.

// Complete C++23 program. Input: rows cols, then the matrix row by row.
#include <iostream>
#include <vector>
int main() {
    int rows = 0, cols = 0;
    std::cin >> rows >> cols;
    std::vector<std::vector<int>> grid(rows, std::vector<int>(cols));
    for (auto& row : grid) {
        for (int& x : row) std::cin >> x;
    }
    for (int col = 0; col < cols; ++col) {
        long long total = 0;
        for (int row = 0; row < rows; ++row) total += grid[row][col];
        if (col != 0) std::cout << ' ';
        std::cout << total;
    }
    std::cout << '\n';
}

Initialize from the first score. Update only when a strictly higher score appears.

The pair tracks the earliest best score in each processed prefix. Strict comparison keeps the first occurrence on ties. For the sample, the result is (95, 2); time is O(n), with O(1) helper auxiliary space.

// Complete C++23 program. Input: 1 <= n <= 200000, then n scores.
#include <iostream>
#include <utility>
#include <vector>
std::pair<int, int> firstHighest(const std::vector<int>& scores) {
    std::pair<int, int> answer{scores[0], 1};
    for (int i = 1; i < static_cast<int>(scores.size()); ++i) {
        if (scores[i] > answer.first) answer = {scores[i], i + 1};
    }
    return answer;
}
int main() {
    int n = 0;
    std::cin >> n;
    std::vector<int> scores(n);
    for (int& x : scores) std::cin >> x;
    auto answer = firstHighest(scores);
    std::cout << answer.first << ' ' << answer.second << '\n';
}

Append at the back. If size is greater than k, discard the front.

The deque always represents the desired suffix of processed arrivals. If k exceeds n, nothing is discarded. If k is zero, all arrivals are immediately discarded and the output line is blank.

// Complete C++23 program. Input: n k, then n integers.
#include <deque>
#include <iostream>
int main() {
    int n = 0, k = 0;
    std::cin >> n >> k;
    std::deque<int> recent;
    for (int i = 0; i < n; ++i) {
        int x = 0;
        std::cin >> x;
        recent.push_back(x);
        if (static_cast<int>(recent.size()) > k) recent.pop_front();
    }
    for (int i = 0; i < static_cast<int>(recent.size()); ++i) {
        if (i != 0) std::cout << ' ';
        std::cout << recent[i];
    }
    std::cout << '\n';
}

Handle insertion first, then guard all remaining accesses with empty(). Only type 2 removes.

The invariant is that the queue contains exactly the unserved arrivals in their original order. Each command uses O(1) queue operations, so total time is O(q + 1), with O(q + 1) possible stored items.

// Complete C++23 program. Input: q, then commands 1 id, 2, or 3.
#include <iostream>
#include <queue>
int main() {
    int q = 0;
    std::cin >> q;
    std::queue<int> waiting;
    while (q--) {
        int type = 0;
        std::cin >> type;
        if (type == 1) {
            int id = 0;
            std::cin >> id;
            waiting.push(id);
        } else if (waiting.empty()) {
            std::cout << "EMPTY\n";
        } else {
            std::cout << waiting.front() << '\n';
            if (type == 2) waiting.pop();
        }
    }
}

Store the fields as (time, ID), and use std::greater for that same pair type.

The minimum pair is exactly the earliest event with the required tie rule. Copy the top before popping. Individual pushes and all removals take O(1 + n log(n + 1)) total amortized time, with O(n + 1) storage.

// Complete C++23 program. Input: 0 <= n <= 200000, then time ID pairs.
#include <functional>
#include <iostream>
#include <queue>
#include <utility>
#include <vector>
int main() {
    int n = 0;
    std::cin >> n;
    using Event = std::pair<int, int>;
    std::priority_queue<Event, std::vector<Event>, std::greater<Event>> events;
    for (int i = 0; i < n; ++i) {
        int time = 0, id = 0;
        std::cin >> time >> id;
        events.push({time, id});
    }
    while (!events.empty()) {
        Event next = events.top();
        events.pop();
        std::cout << next.second << '\n';
    }
}

Store unmatched openings. Every closing bracket must match the top, and the stack must be empty at the end.

After each accepted prefix, the stack is precisely its unmatched openings in order. Rejecting an empty or mismatched top detects invalid prefixes; final emptiness ensures every opening was closed.

// Complete C++23 program. Input: one bracket-only line, length <= 200000.
#include <iostream>
#include <stack>
#include <string>
bool matches(char open, char close) {
    return (open == '(' && close == ')') ||
           (open == '[' && close == ']') ||
           (open == '{' && close == '}');
}
bool balanced(const std::string& text) {
    std::stack<char> pending;
    for (char c : text) {
        if (c == '(' || c == '[' || c == '{') pending.push(c);
        else {
            if (pending.empty() || !matches(pending.top(), c)) return false;
            pending.pop();
        }
    }
    return pending.empty();
}
int main() {
    std::string text;
    std::getline(std::cin, text);
    std::cout << (balanced(text) ? "YES\n" : "NO\n");
}

Store each addition in a stack and maintain a long long total. Undo changes the total before popping its amount.

The stack holds exactly the actions still contributing to the total. Each action is pushed once and removed at most once, so the whole program is O(q + 1) time with O(q + 1) worst-case storage.

// Complete C++23 program. Input: q, then commands 1 x, 2, or 3.
#include <iostream>
#include <stack>
int main() {
    int q = 0;
    std::cin >> q;
    std::stack<long long> history;
    long long total = 0;
    while (q--) {
        int type = 0;
        std::cin >> type;
        if (type == 1) {
            long long amount = 0;
            std::cin >> amount;
            history.push(amount);
            total += amount;
        } else if (type == 2) {
            if (!history.empty()) {
                total -= history.top();
                history.pop();
            }
        } else {
            std::cout << total << '\n';
        }
    }
}

Maintain the largest k arrivals in a min-heap. At the end, its smallest retained value has exactly the required rank.

After each arrival, the invariant keeps the largest k occurrences seen so far. The final minimum of those retained values is the kth largest overall. The program does not store the whole input and costs O(n log(k + 1)) amortized time.

// Complete C++23 program. Input: n k, then n integers; 1 <= k <= n.
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
int main() {
    int n = 0, k = 0;
    std::cin >> n >> k;
    std::priority_queue<int, std::vector<int>, std::greater<int>> best;
    for (int i = 0; i < n; ++i) {
        int x = 0;
        std::cin >> x;
        best.push(x);
        if (static_cast<int>(best.size()) > k) best.pop();
    }
    std::cout << best.top() << '\n';
}

After each insertion, write only the distinct keys. The insertion flag changes only for a previously absent key.

The lines are NEW 1, NEW 2, OLD 2, OLD 2, NEW 3. The set state ends as {2, 4, 7}; repeated insertions have discarded multiplicity. Use a frequency map or multiset to preserve that information.

Use the same two-branch loop, replacing the condition with *it % 2 == 0.

Erase -2, 0, and 4; the survivors are 3 and 7. After the loop, check empty() before accessing either extreme. If the container is empty, print the task’s explicit empty result instead of dereferencing an iterator.

Separate the boundary that is too large from the affordable predecessor.

The predecessor answers are NONE, 5, 5, 9. The value interval uses [lower_bound(3), upper_bound(8)); it visits only 5. The backward guard handles the first query, and a nonempty end() boundary handles the last.

Count the matching entries visited by one count call, then count how many calls are made.

Each count may traverse all 100000 matching copies, and there are 100000 calls. That is O(n²) work. Store 5 → 100000 in a frequency map if the required operation is repeatedly reading the number of copies.

The declaration can stay the same; the repeated-key policy is expressed by the update.

First: 10 using insert or try_emplace. Latest: 7 using assignment or insert_or_assign. Total: 21 using +=. Query with find when absence is possible, so inspecting an unknown product does not add a record.

Every original position belongs to one group only.

2 → [2, 5], 4 → [1, 3, 6], 7 → [4]. The groups print in key order, while positions within each group retain input order. Output visits six positions, even though the loops are nested.

Separate exact-key lookup from output ordering.

Use find(99); its end() result means output zero, and size() stays 3. For deterministic numeric order, copy entries into a vector of pairs and sort it, or build an ordered map originally. A direct hash traversal does not guarantee 2, 3, 8.

Write the set of prior keys immediately before each lookup.

The one-value case finds no prior 5 and returns NO. In the longer input, the first 5 misses, 1 misses complement 9, and the second 5 finds the earlier 5. The algorithm returns YES while still reading the remaining 8.

List the distinct keys and their zero-based ranks first.

The output is 3, 1, 7, 1 on separate lines. The tree contains {2, 7, 9}; ranks are 0, 1, 2. Rank 3 is past the last key, so the comparison with end() is true.

Rebuild the sorted state after every update.

The states are {5, 8, 12, 20}, then {8, 12, 20}. Rank 1 is now 12, and one key is below 12. An earlier rank can identify a different item after updates; retain the key when identity matters.

Write each distinct collection before performing the requested membership rule.

Intersection: {2, 8}. Union: {1, 2, 5, 8, 9}. A minus B: {5}. Each appears once because the requested results are sets of distinct values, not lists of physical occurrences.

Input is a stream; consuming an extra integer steals part of the next command.

Reading x after command 3 consumes the next command type and misaligns all subsequent input. Handle type 3 immediately and continue; only commands 1 and 2 read an x. The operation contract controls both the container update and input parsing.

There are four prefix lengths: 0, 1, 2, and 3.

P = [0, 6, 2, 4]. The full sum is 4 − 0 = 4. Positions [2, 3] sum to 4 − 6 = −2. They are zero-based indices [1, 3), so the same answer is P[3] − P[1].

Check where arithmetic happens, where it is stored, and what type the function returns.

The answer is 3000000000. Use long long summands, prefix entries, and return type, with a const-reference vector parameter. Test [1,1], [n,n], [1,n], an interior interval, all-negative input, and a sum above the 32-bit signed limit.

Balance compares sums, not side lengths. Positivity is a separate 0/1 transformation.

Position 1 is balanced: its empty left side totals 0 and its right side totals 2 − 2 + 0 = 0. Only the value 2 is positive, so the whole-range positive count is 1.

Use x − LOW with LOW = −3.

Allocate 7 entries. The values map to indices 0, 3, and 6. Taking absolute values would merge −3 and 3, even though the task counts them as different values.

For each value, either count earlier matches or use f(f − 1)/2. For words, compare all 26 counts.

Value 3 occurs three times and contributes 3 pairs; value 0 occurs twice and contributes 1. Total: 4. The words are anagrams: both have two as, one b, and two cs.

Write positions 1 through 7 above the letters. A prefix row i consumes text[i − 1].

The answers are 2, 2, and 0. The a occurrences in [2,6] are positions 3 and 5; b occurs at 2 and 6; position 4 is c. Convert the one-based character position i to string index i − 1 only when reading the character.

Add all boundary contributions first, then take one running sum.

Markers at indices 1..6 are [−1, 3, 1, 2, −3, −2]. The five final values are [−1, 2, 3, 5, 2]. Including the sentinel returns the running added amount to zero.

Reconstruct added amounts first, then combine them with the original values before building prefixes.

Added amounts are [−1, 2, 3, 3, 0]. Final values are [3, 0, 10, 3, 3]. The queried sums are 19, 13, and 3. These answers assume both updates have already happened.

The desired cells are six values. The four needed prefix totals are 14, 5, 7, and 2.

Directly: 4 + 2 − 2 − 3 + 1 + 2 = 4. Inclusion-exclusion gives 14 − 5 − 7 + 2 = 4. Agreement verifies both the chosen rectangle and the corner formula.

The first value in the queried range must have weight 1, not its global index.

The weighted answer is 1×(−2) + 2×7 + 3×0 + 4×3 = 24. The normalized residue of −1 modulo 5 is 4. A global weighted prefix needs the (l − 1) correction to produce these local weights.

The overlap at row 2, column 2 receives both additions.

The first row is [4, 4, 0] and the second is [4, 3, −1]. The four-corner method combines each update’s contribution and reconstructs exactly these cell values.

The padded prefixes are [0, 1, 3, 2, 3, 5]. For each right prefix, look for an earlier value three smaller.

The matching ranges are [1,2], [1,4], and [4,5]. The initial zero prefix supplies the left boundary before position 1 for the first two matches. Looking up before insertion keeps all counted subarrays nonempty.