C++ Notes on Dan Stefan Oprean

Introduction

Mon, 01 Jan 0001 00:00:00 +0000

Hello World

#include <iostream>

int main()
{
    std::cout << "Hello, world!" << std::endl;
    return 0;
}

Compile and run:

g++ main.cpp -o main
./main

This is the smallest C++ program shape: main starts the program, and std::cout prints to the terminal.

Variables

#include <string>

std::string name = "Dan";
int count = 1;
bool active = true;
auto language = "C++";

This shows a few common C++ value types and auto for type inference when the initializer already makes the type obvious.

Add

Mon, 01 Jan 0001 00:00:00 +0000

C++ Add

int add(int param1, int param2)
{
    return param1 + param2;
}

This just adds the two input numbers with the language’s normal arithmetic and returns the sum.

Add Border

Mon, 01 Jan 0001 00:00:00 +0000

C++ Add Border

#include <string>
#include <vector>

std::vector<std::string> addBorder(std::vector<std::string> picture)
{
    picture.insert(picture.begin(), std::string(picture[0].size(), '*'));
    for (auto& row : picture) {
        row = "*" + row + "*";
    }
    picture.push_back(std::string(picture[0].size(), '*'));

    return picture;
}

This builds a new grid with a * border around every side. It adds a full top and bottom row, then wraps each existing row from left and right.

Adjacent Elements Product

Mon, 01 Jan 0001 00:00:00 +0000

C++ Adjacent Elements Product

#include <algorithm>
#include <limits>
#include <vector>

long long adjacentElementsProduct(const std::vector<int>& inputArray)
{
    long long max = std::numeric_limits<long long>::min();

    for (std::size_t i = 0; i + 1 < inputArray.size(); ++i) {
        long long product = static_cast<long long>(inputArray[i]) * inputArray[i + 1];
        max = std::max(max, product);
    }

    return max;
}

This walks through neighboring values, multiplies each pair, and keeps the biggest product it finds.

Almost Magic Square

Mon, 01 Jan 0001 00:00:00 +0000

C++ Almost Magic Square

#include <algorithm>
#include <array>
#include <vector>

std::vector<int> almostMagicSquare(const std::vector<int>& a)
{
    std::array<std::array<int, 3>, 3> grid{};
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            grid[i][j] = a[i * 3 + j];
        }
    }

    std::array<int, 3> rowSum{};
    std::array<int, 3> colSum{};
    int maxSum = 0;

    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            rowSum[i] += grid[i][j];
            colSum[i] += grid[j][i];
        }
    }

    for (int k = 0; k < 3; ++k) {
        maxSum = std::max(maxSum, rowSum[k]);
        maxSum = std::max(maxSum, colSum[k]);
    }

    for (int i = 0, j = 0; i < 3 && j < 3;) {
        int diff = std::min(maxSum - rowSum[i], maxSum - colSum[j]);
        grid[i][j] += diff;
        rowSum[i] += diff;
        colSum[j] += diff;

        if (rowSum[i] == maxSum) {
            ++i;
        }
        if (colSum[j] == maxSum) {
            ++j;
        }
    }

    std::vector<int> result;
    result.reserve(9);
    for (int i = 0; i < 3; ++i) {
        for (int j = 0; j < 3; ++j) {
            result.push_back(grid[i][j]);
        }
    }

    return result;
}

This adjusts the matrix toward a matching target sum so the rows and columns line up more like a magic square.

Are Equally Strong

Mon, 01 Jan 0001 00:00:00 +0000

C++ Are Equally Strong

#include <algorithm>

bool areEquallyStrong(int yourLeft, int yourRight, int friendsLeft, int friendsRight)
{
    return std::max(yourRight, yourLeft) == std::max(friendsLeft, friendsRight)
        && std::min(yourLeft, yourRight) == std::min(friendsRight, friendsLeft);
}

This compares each person’s strongest and weakest arm. If both pairs match, the result is true.

Array Change

Mon, 01 Jan 0001 00:00:00 +0000

C++ Array Change

#include <vector>

long long arrayChange(std::vector<long long> a)
{
    long long min = 0;
    for (std::size_t k = 0; k + 1 < a.size(); ++k) {
        if (a[k] >= a[k + 1]) {
            long long dif = a[k] - a[k + 1] + 1;
            a[k + 1] += dif;
            min += dif;
        }
    }

    return min;
}

This moves left to right and bumps values only when needed so the array becomes strictly increasing.

Array Maximal Adjacement Difference

Mon, 01 Jan 0001 00:00:00 +0000

C++ Array Maximal Adjacement Difference

#include <algorithm>
#include <cstdlib>
#include <vector>

long long arrayMaximalAdjacentDifference(const std::vector<int>& a)
{
    long long dif = 0;
    for (std::size_t i = 1; i + 1 < a.size(); ++i) {
        long long left = std::llabs(static_cast<long long>(a[i]) - a[i - 1]);
        long long right = std::llabs(static_cast<long long>(a[i]) - a[i + 1]);
        dif = std::max({dif, left, right});
    }

    return dif;
}

This checks the gap between each pair of neighbors and returns the largest difference.

Binary Gap

Mon, 01 Jan 0001 00:00:00 +0000

C++ Binary Gap

#include <algorithm>

int binaryGap(int n)
{
    int gap = 0;
    int run = -1; // -1 means no leading '1' has been seen yet

    while (n > 0) {
        if (n & 1) {
            if (run >= 0) {
                gap = std::max(gap, run);
            }
            run = 0;
        } else if (run >= 0) {
            ++run;
        }
        n >>= 1;
    }

    return gap;
}

This turns the number into binary, ignores zeroes outside the edges, and finds the longest run of zeroes between 1s.

Bracket

Mon, 01 Jan 0001 00:00:00 +0000

C++ Bracket

#include <string>
#include <vector>

int bracket(const std::string& s)
{
    std::vector<char> stack;

    for (char c : s) {
        switch (c) {
            case ')':
                if (stack.empty() || stack.back() != '(') {
                    return 0;
                }
                stack.pop_back();
                break;
            case ']':
                if (stack.empty() || stack.back() != '[') {
                    return 0;
                }
                stack.pop_back();
                break;
            case '}':
                if (stack.empty() || stack.back() != '{') {
                    return 0;
                }
                stack.pop_back();
                break;
            default:
                stack.push_back(c);
                break;
        }
    }

    return stack.empty() ? 1 : 0;
}

This uses a simple stack approach: open brackets go in, matching closing brackets pop them out.

Century From Year

Mon, 01 Jan 0001 00:00:00 +0000

C++ Century From Year

#include <cmath>

int centuryFromYear(int year)
{
    return static_cast<int>(std::ceil(year / 100.0));
}

This converts a year into its century. Years 1-100 are century 1, 101-200 are century 2, and so on.

Check Palindrome

Mon, 01 Jan 0001 00:00:00 +0000

C++ Check Palindrome

#include <string>

bool checkPalindrome(const std::string& inputString)
{
    return std::string(inputString.rbegin(), inputString.rend()) == inputString;
}

This compares the string with its reverse. If they match, it is a palindrome.

Chocolates By Numbers

Mon, 01 Jan 0001 00:00:00 +0000

C++ Chocolates By Numbers

long long chocolatesGcd(long long n, long long m)
{
    if (n % m == 0) {
        return m;
    }

    return chocolatesGcd(m, n % m);
}

long long chocolatesByNumbers(long long n, long long m)
{
    long long g = chocolatesGcd(n, m);

    return ((n * m) / g) / m;
}

This uses the greatest common divisor to figure out how many chocolates get eaten before the pattern repeats.

Common Prime Divisors

Mon, 01 Jan 0001 00:00:00 +0000

C++ Common Prime Divisors

#include <cstddef>
#include <vector>

long long commonPrimeDivisorsGcd(long long n, long long m)
{
    if (n % m == 0) {
        return m;
    }

    return commonPrimeDivisorsGcd(m, n % m);
}

long long removeCommonPrimeDivisors(long long n, long long m)
{
    while (n != 1) {
        long long d = commonPrimeDivisorsGcd(n, m);
        if (d == 1) {
            break;
        }
        n /= d;
    }

    return n;
}

int commonPrimeDivisors(const std::vector<int>& a, const std::vector<int>& b)
{
    int counter = 0;

    for (std::size_t i = 0; i < a.size(); ++i) {
        long long x = a[i];
        long long y = b[i];
        long long d = commonPrimeDivisorsGcd(x, y);

        x = removeCommonPrimeDivisors(x, d);
        if (x != 1) {
            continue;
        }

        y = removeCommonPrimeDivisors(y, d);
        if (y == 1) {
            ++counter;
        }
    }

    return counter;
}

This checks whether two numbers are built from the same prime factors by repeatedly dividing out their shared parts.

Count Div

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Div

long long countDiv(long long a, long long b, long long k)
{
    long long firstDiv = a % k == 0 ? a : a + (k - a % k);
    long long lastDiv = b - b % k;

    return (lastDiv - firstDiv) / k + 1;
}

This counts how many numbers in a range are divisible by K without looping through every value.

Count Factors

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Factors

long long countFactors(long long n)
{
    long long count = 0;
    long long i = 1;

    while (i * i < n) {
        if (n % i == 0) {
            count += 2;
        }
        ++i;
    }
    if (i * i == n) {
        ++count;
    }

    return count;
}

This checks divisors in pairs up to the square root, which keeps the work much smaller than testing every number.

Count Non Divisible

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Non Divisible

#include <algorithm>
#include <vector>

std::vector<int> countNonDivisible(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    std::vector<int> nondivisor(size, 0);

    int maxVal = *std::max_element(a.begin(), a.end());
    std::vector<int> occurrences(maxVal + 1, 0);

    for (int v : a) {
        ++occurrences[v];
    }

    for (int k = 0; k < size; ++k) {
        int v = a[k];
        int count = 0;
        long long i = 1;
        while (i * i <= v) {
            if (v % i == 0) {
                count += occurrences[i];
                if (v / i != i) {
                    count += occurrences[v / i];
                }
            }
            ++i;
        }
        nondivisor[k] = size - count;
    }

    return nondivisor;
}

This counts how often each value appears, then subtracts the divisor matches so you get the non-divisible count for each item.

Count Semi Primes

Mon, 01 Jan 0001 00:00:00 +0000

C++ Count Semi Primes

#include <cstddef>
#include <vector>

std::vector<int> countSemiPrimes(int n, const std::vector<int>& p, const std::vector<int>& q)
{
    std::vector<bool> primes(n + 1, true);
    std::vector<int> semiPrimes(n + 1, 0);
    std::vector<int> semiPrimeCounts(p.size(), 0);

    for (int i = 2; i * i <= n; ++i) {
        if (primes[i]) {
            for (int k = i * i; k <= n; k += i) {
                primes[k] = false;
            }
        }
    }

    for (int k = 2; k * k <= n; ++k) {
        if (primes[k]) {
            for (int i = 2; i * k <= n; ++i) {
                if (primes[i]) {
                    semiPrimes[k * i] = 1;
                }
            }
        }
    }

    for (int i = 1; i <= n; ++i) {
        semiPrimes[i] += semiPrimes[i - 1];
    }

    for (std::size_t k = 0; k < p.size(); ++k) {
        semiPrimeCounts[k] = semiPrimes[q[k]] - semiPrimes[p[k] - 1];
    }

    return semiPrimeCounts;
}

This precomputes semiprimes and prefix sums so each range query becomes a quick subtraction.

Cyclic Rotation

Mon, 01 Jan 0001 00:00:00 +0000

C++ Cyclic Rotation

#include <vector>

std::vector<int> cyclicRotation(std::vector<int> a, int k)
{
    if (!a.empty()) {
        for (int i = 0; i < k; ++i) {
            int back = a.back();
            a.pop_back();
            a.insert(a.begin(), back);
        }
    }

    return a;
}

This rotates the array to the right by K steps and keeps the wrap-around values in the correct order.

Distinct

Mon, 01 Jan 0001 00:00:00 +0000

C++ Distinct

#include <unordered_set>
#include <vector>

int distinct(const std::vector<int>& a)
{
    std::unordered_set<int> unique(a.begin(), a.end());

    return static_cast<int>(unique.size());
}

This counts unique values by tracking what has already been seen.

Dominator

Mon, 01 Jan 0001 00:00:00 +0000

C++ Dominator

#include <cstddef>
#include <vector>

int dominator(const std::vector<int>& a)
{
    int size = 0;
    int value = 0;
    int index = 0;

    for (std::size_t k = 0; k < a.size(); ++k) {
        int v = a[k];
        if (size == 0) {
            ++size;
            value = v;
            index = static_cast<int>(k);
        } else if (value != v) {
            --size;
        } else {
            ++size;
        }
    }

    int candidate = size > 0 ? value : -1;
    int count = 0;
    for (int v : a) {
        if (v == candidate) {
            ++count;
        }
    }
    if (count <= static_cast<int>(a.size()) / 2) {
        index = -1;
    }

    return index;
}

This finds a value that appears in more than half of the array, then returns one valid index for it.

Equi Leader

Mon, 01 Jan 0001 00:00:00 +0000

C++ Equi Leader

#include <vector>

int equiLeader(const std::vector<int>& a)
{
    int leaderSize = 0;
    int value = 0;
    for (int v : a) {
        if (leaderSize == 0) {
            ++leaderSize;
            value = v;
        } else if (value != v) {
            --leaderSize;
        } else {
            ++leaderSize;
        }
    }
    int candidate = leaderSize > 0 ? value : -1;

    int leaderCount = 0;
    for (int v : a) {
        if (v == candidate) {
            ++leaderCount;
        }
    }

    int count = static_cast<int>(a.size());
    int leader = -1;
    if (leaderCount > count / 2) {
        leader = candidate;
    }

    int lLeaderCount = 0;
    int equiLeaders = 0;

    for (int k = 0; k < count; ++k) {
        int v = a[k];
        int leftHalf = (k + 1) / 2;
        int rightHalf = (count - k - 1) / 2;
        if (v == leader) {
            ++lLeaderCount;
        }

        int rLeaderCount = leaderCount - lLeaderCount;
        if (lLeaderCount > leftHalf && rLeaderCount > rightHalf) {
            ++equiLeaders;
        }
    }

    return equiLeaders;
}

This keeps leader counts on both sides of the split and counts positions where the same leader survives in each half.

Fib Frog

Mon, 01 Jan 0001 00:00:00 +0000

C++ Fib Frog

#include <queue>
#include <vector>

int fibFrog(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());

    std::vector<int> fib{0, 1};
    for (int i = 1; fib[i] <= size;) {
        ++i;
        fib.push_back(fib[i - 1] + fib[i - 2]);
    }

    struct Path {
        int idx;
        int jmp;
    };

    std::queue<Path> paths;
    paths.push({-1, 0});

    std::vector<bool> steps(size, false);

    while (!paths.empty()) {
        Path path = paths.front();
        paths.pop();

        for (int i = static_cast<int>(fib.size()) - 1; i >= 2; --i) {
            int idx = path.idx + fib[i];
            if (idx == size) {
                return path.jmp + 1;
            }
            if (idx > size || steps[idx] || a[idx] == 0) {
                continue;
            }
            if (a[idx] == 1) {
                steps[idx] = true;
                paths.push({idx, path.jmp + 1});
            }
        }
    }

    return -1;
}

This precomputes Fibonacci jumps, then uses a breadth-first search to find the shortest valid path across the river.

Fish

Mon, 01 Jan 0001 00:00:00 +0000

C++ Fish

#include <vector>

int fish(const std::vector<int>& a, const std::vector<int>& b)
{
    int size = static_cast<int>(a.size());
    int dead = 0;
    std::vector<int> downstream;

    for (int i = 0; i < size; ++i) {
        if (b[i] == 1) {
            downstream.push_back(a[i]);
        } else if (!downstream.empty()) {
            while (!downstream.empty()) {
                ++dead;
                if (a[i] > downstream.back()) {
                    downstream.pop_back();
                } else {
                    break;
                }
            }
        }
    }

    return size - dead;
}

This uses a stack for downstream fish and resolves fights only when opposite directions meet.

Flags

Mon, 01 Jan 0001 00:00:00 +0000

C++ Flags

#include <algorithm>
#include <vector>

int flags(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    if (size == 0) {
        return 0;
    }

    std::vector<bool> peaks(size, false);
    for (int i = 1; i < size; ++i) {
        int nextVal = (i + 1 < size) ? a[i + 1] : 0;
        peaks[i] = a[i - 1] < a[i] && a[i] > nextVal;
    }

    std::vector<int> next(size);
    next[size - 1] = -1;
    for (int i = size - 2; i >= 0; --i) {
        next[i] = peaks[i] ? i : next[i + 1];
    }

    int i = 1;
    int result = 0;
    while (i * (i - 1) <= size) {
        int pos = 0;
        int num = 0;
        while (pos < size && num < i) {
            pos = next[pos];
            if (pos == -1) {
                break;
            }
            ++num;
            pos += i;
        }
        ++i;
        result = std::max(result, num);
    }

    return result;
}

This finds all peaks first, then checks how many flags can be placed while keeping the required distance.

Frog Jmp

Mon, 01 Jan 0001 00:00:00 +0000

C++ Frog Jmp

#include <cmath>

long long frogJmp(long long x, long long y, long long d)
{
    return static_cast<long long>(std::ceil(static_cast<double>(y - x) / d));
}

This computes the jump count with math instead of simulation, which is the cleanest way to solve it.

Frog River One

Mon, 01 Jan 0001 00:00:00 +0000

C++ Frog River One

#include <cstddef>
#include <vector>

int frogRiverOne(int x, const std::vector<int>& a)
{
    std::vector<bool> existing(x + 1, false);
    int count = 0;

    for (std::size_t k = 0; k < a.size(); ++k) {
        int i = a[k];
        if (i <= x && !existing[i]) {
            existing[i] = true;
            ++count;
            if (count == x) {
                return static_cast<int>(k);
            }
        }
    }

    return -1;
}

This tracks the earliest time each needed position appears and stops as soon as the frog can cross.

Genomic Range Query

Mon, 01 Jan 0001 00:00:00 +0000

C++ Genomic Range Query

#include <cstddef>
#include <string>
#include <vector>

std::vector<int> genomicRangeQuery(const std::string& s, const std::vector<int>& p, const std::vector<int>& q)
{
    std::vector<int> r;
    r.reserve(p.size());

    for (std::size_t k = 0; k < p.size(); ++k) {
        int pi = p[k];
        int qi = q[k] - pi + 1;
        std::string subStr = s.substr(pi, qi);

        if (subStr.find('A') != std::string::npos) {
            r.push_back(1);
        } else if (subStr.find('C') != std::string::npos) {
            r.push_back(2);
        } else if (subStr.find('G') != std::string::npos) {
            r.push_back(3);
        } else {
            r.push_back(4);
        }
    }

    return r;
}

This builds prefix counts for each DNA letter so every query can return the minimum impact factor quickly.

Is Ipv 4 Adress

Mon, 01 Jan 0001 00:00:00 +0000

C++ Is Ipv 4 Adress

#include <algorithm>
#include <cctype>
#include <string>
#include <vector>

bool isIPv4Address(const std::string& inputString)
{
    std::vector<std::string> parts;
    std::string cur;
    for (char c : inputString) {
        if (c == '.') {
            parts.push_back(cur);
            cur.clear();
        } else {
            cur += c;
        }
    }
    parts.push_back(cur);

    for (const auto& v : parts) {
        if (v.empty() || !std::all_of(v.begin(), v.end(), [](unsigned char c) { return std::isdigit(c); })) {
            return false;
        }
        if (v.size() > 1 && v[0] == '0') {
            return false; // rejects leading zeros, mirrors $v !== (string)(int)$v
        }
        if (std::stol(v) > 255) {
            return false;
        }
    }

    return parts.size() == 4;
}

This splits the string by dots and validates each part as a normal IPv4 octet.

Ladder

Mon, 01 Jan 0001 00:00:00 +0000

C++ Ladder

#include <algorithm>
#include <vector>

std::vector<int> ladder(const std::vector<int>& a, const std::vector<int>& b)
{
    std::size_t size = a.size();
    std::vector<int> r(size, 0);

    int maxB = *std::max_element(b.begin(), b.end());
    long long mod = (1LL << maxB) - 1;

    int maxA = *std::max_element(a.begin(), a.end());
    std::vector<long long> fib(maxA + 2, 0);
    fib[1] = 1;
    for (int i = 2; i < maxA + 2; ++i) {
        fib[i] = (fib[i - 1] + fib[i - 2]) & mod;
    }

    for (std::size_t i = 0; i < size; ++i) {
        r[i] = static_cast<int>(fib[a[i] + 1] & ((1LL << b[i]) - 1));
    }

    return r;
}

This precomputes climb counts once and applies the modulo per query, which avoids recalculating the same paths over and over.

Largest String

Mon, 01 Jan 0001 00:00:00 +0000

C++ Largest String

#include <string>

std::string largestString(std::string s)
{
    int len = static_cast<int>(s.size());
    std::string cur;

    for (int i = len - 1; i >= 0; --i) {
        cur = s[i] + cur;

        if (cur.size() == 3) {
            if (cur == "abb") {
                s[i] = 'b';
                s[i + 1] = 'a';
                s[i + 2] = 'a';
                if (i + 4 < len && s[i + 4] == 'b') {
                    i += 4 + 1;
                } else if (i + 3 < len && s[i + 3] == 'b') {
                    i += 3 + 1;
                } else if (s[i + 2] == 'b') {
                    i += 2 + 1;
                }
            }
            if (i + 1 < len && s[i + 1] == 'b') {
                i += 1 + 1;
            } else {
                ++i;
            }
            cur.clear();
        }
    }

    return s;
}

This builds the biggest valid string it can under the challenge rules by always choosing the best next character it is allowed to use.

Max Counters

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Counters

#include <algorithm>
#include <vector>

std::vector<int> maxCounters(int n, const std::vector<int>& a)
{
    std::vector<int> counters(n, 0);
    int maxCounter = 0;
    int lastUpdate = 0;
    int condition = n + 1;

    for (int v : a) {
        if (v <= n) {
            int index = v - 1;
            if (counters[index] < lastUpdate) {
                counters[index] = lastUpdate;
            }
            ++counters[index];
            maxCounter = std::max(maxCounter, counters[index]);
        }
        if (v == condition) {
            lastUpdate = maxCounter;
        }
    }

    for (int& c : counters) {
        if (c < lastUpdate) {
            c = lastUpdate;
        }
    }

    return counters;
}

This delays the expensive “set all counters to max” work until it is really needed, which keeps the solution fast.

Max Double Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Double Slice Sum

#include <algorithm>
#include <vector>

long long maxDoubleSliceSum(const std::vector<int>& a)
{
    int size = static_cast<int>(a.size());
    if (size < 3) {
        return 0;
    }

    std::vector<long long> p1(size, 0);
    std::vector<long long> p2(size, 0);

    for (int i = 2; i < size - 1; ++i) {
        p1[i] = std::max<long long>(0, p1[i - 1] + a[i - 1]);
        p2[size - i - 1] = std::max<long long>(0, p2[size - i] + a[size - i]);
    }

    long long sum = p1[1] + p2[1];
    for (int i = 1; i < size - 1; ++i) {
        sum = std::max(sum, p1[i] + p2[i]);
    }

    return sum;
}

This keeps the best sum ending on the left and starting on the right, then combines them around each middle position.

Max Product Of Three

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Product Of Three

#include <algorithm>
#include <vector>

long long maxProductOfThree(std::vector<int> a)
{
    std::sort(a.begin(), a.end());
    int c = static_cast<int>(a.size());

    long long topThree = static_cast<long long>(a[c - 1]) * a[c - 2] * a[c - 3];
    long long twoLowestAndTop = static_cast<long long>(a[0]) * a[1] * a[c - 1];

    return std::max(topThree, twoLowestAndTop);
}

This checks the useful extremes, because the best product can come from either the three largest numbers or two negatives plus one large positive.

Max Profit

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Profit

#include <algorithm>
#include <vector>

long long maxProfit(const std::vector<int>& a)
{
    long long price = a[0];
    long long profit = 0;

    for (int v : a) {
        price = std::min(price, static_cast<long long>(v));
        profit = std::max(profit, v - price);
    }

    return profit;
}

This tracks the lowest buy price seen so far and updates the best profit as it scans the prices once.

Max Slice Sum

Mon, 01 Jan 0001 00:00:00 +0000

C++ Max Slice Sum

#include <algorithm>
#include <limits>
#include <vector>

long long maxSliceSum(const std::vector<int>& a)
{
    long long tmp = std::numeric_limits<long long>::min();
    long long max = std::numeric_limits<long long>::min();

    for (int v : a) {
        tmp = std::max(tmp + v, static_cast<long long>(v));
        max = std::max(max, tmp);
    }

    return max;
}

This is a Kadane-style scan: keep the best running sum and the best overall sum while moving once through the array.

Min Avg Two Slice

Mon, 01 Jan 0001 00:00:00 +0000

C++ Min Avg Two Slice

#include <algorithm>
#include <vector>

int minAvgTwoSlice(const std::vector<int>& a)
{
    int idx = 0;
    double min = (a[0] + a[1]) / 2.0;

    for (std::size_t i = 0; i + 1 < a.size(); ++i) {
        double cur = (a[i] + a[i + 1]) / 2.0;
        if (i + 2 < a.size()) {
            double three = (a[i] + a[i + 1] + a[i + 2]) / 3.0;
            cur = std::min(cur, three);
        }
        if (cur < min) {
            min = cur;
            idx = static_cast<int>(i);
        }
    }

    return idx;
}

This leans on the key trick for this problem: the minimum average slice is always length 2 or 3.

Min Perimeter Rectangle

Mon, 01 Jan 0001 00:00:00 +0000

C++ Min Perimeter Rectangle

#include <algorithm>
#include <limits>

long long minPerimeterRectangle(long long n)
{
    long long i = 1;
    long long min = std::numeric_limits<long long>::max();

    while (i * i < n) {
        if (n % i == 0) {
            min = std::min(min, 2 * (i + n / i));
        }
        ++i;
    }

    return min;
}

This searches factor pairs up to the square root and picks the pair with the smallest perimeter.

Missing Integer

Mon, 01 Jan 0001 00:00:00 +0000

C++ Missing Integer

#include <algorithm>
#include <vector>

int missingInteger(std::vector<int> a)
{
    std::sort(a.begin(), a.end());
    a.erase(std::unique(a.begin(), a.end()), a.end());

    int min = 1;
    for (int v : a) {
        if (v > 0) {
            if (min != v) {
                break;
            }
            ++min;
        }
    }

    return min;
}

This records the positive numbers that exist, then returns the smallest positive value that is still missing.

Nesting

Mon, 01 Jan 0001 00:00:00 +0000

C++ Nesting

#include <string>
#include <vector>

int nesting(const std::string& s)
{
    if (s.empty()) {
        return 1;
    }

    std::vector<char> stack;
    for (char c : s) {
        if (c == ')') {
            if (stack.empty() || stack.back() != '(') {
                return 0;
            }
            stack.pop_back();
        } else {
            stack.push_back(c);
        }
    }

    return stack.empty() ? 1 : 0;
}

This treats the string like a balance counter: open parentheses add one, closing ones remove one.

Number Of Disc Intersections

Mon, 01 Jan 0001 00:00:00 +0000

C++ Number Of Disc Intersections

#include <vector>

long long numberOfDiscIntersections(const std::vector<int>& a)
{
    long long sum = 0;
    long long active = 0;
    int c = static_cast<int>(a.size());
    std::vector<int> start(c, 0);
    std::vector<int> end(c, 0);

    for (int k = 0; k < c; ++k) {
        long long v = a[k];

        long long key = (k < v) ? 0 : k - v;
        ++start[static_cast<int>(key)];

        long long key2 = (static_cast<long long>(k) + v >= c) ? c - 1 : k + v;
        ++end[static_cast<int>(key2)];
    }

    for (int k = 0; k < c; ++k) {
        sum += active * start[k] + (static_cast<long long>(start[k]) * (start[k] - 1)) / 2;
        active += start[k] - end[k];
        if (sum > 10000000) {
            return -1;
        }
    }

    return sum;
}

This sorts disc start and end points and counts active overlaps without comparing every pair directly.

Odd Occurrences In Array

Mon, 01 Jan 0001 00:00:00 +0000

C++ Odd Occurrences In Array

#include <optional>
#include <unordered_map>
#include <vector>

std::optional<int> oddOccurrencesInArray(const std::vector<int>& a)
{
    std::unordered_map<int, int> count;
    std::vector<int> order; // preserves first-seen order, like PHP's insertion-ordered array

    for (int value : a) {
        auto it = count.find(value);
        if (it == count.end()) {
            count[value] = 1;
            order.push_back(value);
        } else {
            count.erase(it);
        }
    }

    for (int v : order) {
        if (count.find(v) != count.end()) {
            return v;
        }
    }

    return std::nullopt;
}

This uses XOR to cancel out pairs, leaving only the value that appears an odd number of times.

Palindrome Rearranging

Mon, 01 Jan 0001 00:00:00 +0000

C++ Palindrome Rearranging

#include <string>
#include <unordered_map>

bool palindromeRearranging(const std::string& inputString)
{
    std::unordered_map<char, int> counts;
    for (char c : inputString) {
        ++counts[c];
    }

    int oddCount = 0;
    for (const auto& [ch, cnt] : counts) {
        if (cnt % 2 != 0) {
            ++oddCount;
        }
    }

    return oddCount <= 1;
}

This counts character frequency and checks whether the string has the right number of odd counts to form a palindrome.

Passing Cars

Mon, 01 Jan 0001 00:00:00 +0000

C++ Passing Cars

#include <vector>

long long passingCars(const std::vector<int>& a)
{
    long long passing = 0;
    long long multiply = 0;

    for (int i : a) {
        if (i == 0) {
            ++multiply;
        } else if (multiply > 0) {
            passing += multiply;
            if (passing > 1000000000) {
                return -1;
            }
        }
    }

    return passing;
}

This counts eastbound cars as it scans, then adds them whenever a westbound car appears.

Peaks

Mon, 01 Jan 0001 00:00:00 +0000

C++ Peaks

#include <algorithm>
#include <vector>

int peaks(const std::vector<int>& a)
{
    int n = static_cast<int>(a.size());
    if (n <= 2) {
        return 0;
    }

    std::vector<int> sum(n, 0);
    int last = -1;
    int dist = 0;

    for (int i = 1; i + 1 < n; ++i) {
        sum[i] = sum[i - 1];
        if (a[i] > a[i - 1] && a[i] > a[i + 1]) {
            dist = std::max(dist, i - last);
            last = i;
            ++sum[i];
        }
    }

    sum[n - 1] = sum[n - 2];
    if (sum[n - 1] == 0) {
        return 0;
    }
    dist = std::max(dist, n - last);

    int j = 0;
    for (int i = (dist >> 1) + 1; i < dist; ++i) {
        if (n % i == 0) {
            last = 0;
            for (j = i; j <= n; j += i) {
                if (sum[j - 1] <= last) {
                    break;
                }
                last = sum[j - 1];
            }
            if (j > n) {
                return n / i;
            }
        }
    }

    for (last = dist; n % last != 0;) {
        ++last;
    }

    return n / last;
}

This finds the peak positions, then tests how many equal blocks can each contain at least one peak.

Perm Check

Mon, 01 Jan 0001 00:00:00 +0000

C++ Perm Check

#include <algorithm>
#include <cstddef>
#include <vector>

int permCheck(std::vector<int> a)
{
    std::sort(a.begin(), a.end());

    for (std::size_t k = 0; k < a.size(); ++k) {
        if (k + 1 < a.size() && a[k] != static_cast<int>(k) + 1) {
            return 0;
        }
    }

    return 1;
}

This validates that every value from 1 to N appears exactly once.

Perm Missing Element

Mon, 01 Jan 0001 00:00:00 +0000

C++ Perm Missing Element

#include <algorithm>
#include <cstddef>
#include <vector>

long long permMissingElement(std::vector<int> a)
{
    std::sort(a.begin(), a.end());

    for (std::size_t k = 0; k < a.size(); ++k) {
        if (a[k] != static_cast<int>(k) + 1) {
            return static_cast<long long>(k) + 1;
        }
    }

    return static_cast<long long>(a.size()) + 1;
}

This uses the expected sum of 1..N+1 and subtracts the actual sum to find the missing value.

Plagiarism Check

Mon, 01 Jan 0001 00:00:00 +0000

C++ Plagiarism Check

#include <algorithm>
#include <cctype>
#include <regex>
#include <string>
#include <unordered_map>
#include <vector>

bool plagiarismCheck(const std::vector<std::string>& code1, const std::vector<std::string>& code2)
{
    auto join = [](const std::vector<std::string>& lines) {
        std::string result;
        for (std::size_t i = 0; i < lines.size(); ++i) {
            if (i > 0) {
                result += ' ';
            }
            result += lines[i];
        }
        return result;
    };

    std::string c1 = join(code1);
    std::string c2 = join(code2);
    if (c1 == c2) {
        return false;
    }

    std::vector<std::string> d1;
    std::vector<std::string> d2;
    std::regex wordRe(R"(\w+)");

    for (auto it = std::sregex_iterator(c1.begin(), c1.end(), wordRe); it != std::sregex_iterator(); ++it) {
        d1.push_back(it->str());
    }
    for (auto it = std::sregex_iterator(c2.begin(), c2.end(), wordRe); it != std::sregex_iterator(); ++it) {
        d2.push_back(it->str());
    }

    std::unordered_map<std::string, std::string> rCand;
    for (std::size_t k = 0; k < d1.size() && k < d2.size(); ++k) {
        bool isNumeric = !d1[k].empty() && std::all_of(d1[k].begin(), d1[k].end(), [](unsigned char c) { return std::isdigit(c); });
        if (d1[k] != d2[k] && !isNumeric) {
            rCand[d1[k]] = d2[k];
        }
    }

    for (const auto& [orig, repl] : rCand) {
        c1 = std::regex_replace(c1, std::regex("(\\W)" + orig + "(\\W*)"), "$1PLACEHOLDER" + orig + "$2");
        c1 = std::regex_replace(c1, std::regex("(\\W)" + orig), "$1PLACEHOLDER" + orig);
    }

    for (const auto& [orig, repl] : rCand) {
        c1 = std::regex_replace(c1, std::regex("(\\W)PLACEHOLDER" + orig + "(\\W)"), "$1" + repl + "$2");
        c1 = std::regex_replace(c1, std::regex("(\\W)PLACEHOLDER" + orig), "$1" + repl);
    }

    return c1 == c2;
}

This flattens both snippets, tries consistent identifier replacements, and checks whether the rewritten code matches.

Shape Area

Mon, 01 Jan 0001 00:00:00 +0000

C++ Shape Area

long long shapeArea(long long n)
{
    return n > 1 ? shapeArea(n - 1) + 4 * (n - 1) : 1;
}

This returns the area of the growing n-interesting polygon using the direct formula instead of building the shape.

Stone Blocks

Mon, 01 Jan 0001 00:00:00 +0000

C++ Stone Blocks

#include <vector>

int stoneBlocks(const std::vector<int>& h)
{
    std::vector<int> height;
    int index = 0;
    int blocks = 0;

    for (int i : h) {
        while (index > 0 && height[index - 1] > i) {
            --index;
        }
        if (index > 0 && height[index - 1] == i) {
            continue;
        }

        if (index == static_cast<int>(height.size())) {
            height.push_back(i);
        } else {
            height[index] = i;
        }
        ++blocks;
        ++index;
    }

    return blocks;
}

This uses a stack of active heights and only counts a new block when the wall needs a new height segment.

Tape Equilibrium

Mon, 01 Jan 0001 00:00:00 +0000

C++ Tape Equilibrium

#include <cstdlib>
#include <limits>
#include <numeric>
#include <vector>

long long tapeEquilibrium(const std::vector<int>& a)
{
    long long firstPart = 0;
    long long secondPart = std::accumulate(a.begin(), a.end(), 0LL);
    long long min = std::numeric_limits<long long>::max();

    for (std::size_t i = 0; i + 1 < a.size(); ++i) {
        // index `i` rather than `a[i]` here.
        firstPart += static_cast<long long>(i);
        secondPart -= static_cast<long long>(i);
        long long difference = std::llabs(firstPart - secondPart);
        min = std::min(min, difference);
    }

    return min;
}

This keeps left and right running sums and updates the smallest difference at each split point.

Triangle

Mon, 01 Jan 0001 00:00:00 +0000

C++ Triangle

#include <algorithm>
#include <vector>

int triangle(std::vector<int> a)
{
    std::sort(a.begin(), a.end());
    int c = static_cast<int>(a.size());
    if (c < 3) {
        return 0;
    }

    for (int i = 0; i < c - 2; ++i) {
        if (a[i] > 0 && a[i] > (a[i + 2] - a[i + 1])) {
            return 1;
        }
    }

    return 0;
}

This sorts the values and checks nearby triples, because a valid triangle only needs one local match after sorting.