Practice Code Examples

#include <cmath>
bool isPrime(int n) {
    if (n < 2) return false;
    for (int i = 2; i <= std::sqrt(n); i++)
        if (n % i == 0) return false;
    return true;
}
isPrime(17);   // true

long factorial(int n) {
    return n <= 1 ? 1 : n * factorial(n - 1);
}
factorial(5);   // 120

int a = 0, b = 1;
for (int i = 0; i < 8; i++) {
    std::cout << a << ' ';   // 0 1 1 2 3 5 8 13
    int next = a + b; a = b; b = next;
}

#include <algorithm>
std::string s = "hello";
std::reverse(s.begin(), s.end());   // "olleh"

#include <algorithm>
bool isPalindrome(std::string s) {
    std::string r = s;
    std::reverse(r.begin(), r.end());
    return s == r;
}
isPalindrome("racecar");   // true

int a = 5, b = 10;
std::swap(a, b);   // a=10, b=5 — STL swap

double toFahrenheit(double c) { return c * 9 / 5 + 32; }
toFahrenheit(100);   // 212

bool isEven(int n) { return n % 2 == 0; }
isEven(7);   // false

bool isLeap(int y) {
    return (y % 4 == 0 && y % 100 != 0) || y % 400 == 0;
}
isLeap(2024);   // true

int sumUpTo(int n) { return n * (n + 1) / 2; }
sumUpTo(100);   // 5050

int gcd(int a, int b) { return b == 0 ? a : gcd(b, a % b); }
int lcm(int a, int b) { return a / gcd(a, b) * b; }
gcd(36, 60);   // 12

int n = 5;
for (int i = 1; i <= 10; i++)
    std::cout << n << " x " << i << " = " << n * i << '\n';

int digitSum(int n) {
    int sum = 0;
    while (n > 0) { sum += n % 10; n /= 10; }
    return sum;
}
digitSum(1234);   // 10

long power(int base, int exp) {
    long r = 1;
    while (exp > 0) {
        if (exp & 1) r *= base;
        base *= base; exp >>= 1;
    }
    return r;
}
power(2, 10);   // 1024

int countVowels(std::string s) {
    int c = 0;
    for (char ch : s)
        if (std::string("aeiouAEIOU").find(ch) != std::string::npos) c++;
    return c;
}
countVowels("CppLang");   // 1

#include <algorithm>
int largest = std::max({4, 19, 7});   // 19 (initializer_list max)

#include <bitset>
std::string bin = std::bitset<8>(42).to_string();   // "00101010"

for (int i = 1; i <= 15; i++) {
    if (i % 15 == 0) std::cout << "FizzBuzz\n";
    else if (i % 3 == 0) std::cout << "Fizz\n";
    else if (i % 5 == 0) std::cout << "Buzz\n";
    else std::cout << i << '\n';
}

#include <vector>
int n; std::cin >> n;
std::vector<int> v(n);
for (auto& x : v) std::cin >> x;   // read n numbers

bool isArmstrong(int n) {
    int sum = 0, t = n;
    while (t) { int d = t % 10; sum += d * d * d; t /= 10; }
    return sum == n;
}
isArmstrong(153);   // true

int binarySearch(std::vector<int>& a, int target) {
    int lo = 0, hi = a.size() - 1;
    while (lo <= hi) {
        int mid = lo + (hi - lo) / 2;
        if (a[mid] == target) return mid;
        if (a[mid] < target) lo = mid + 1; else hi = mid - 1;
    }
    return -1;
}

void bubbleSort(std::vector<int>& a) {
    for (size_t i = 0; i < a.size(); i++)
        for (size_t j = 0; j + i + 1 < a.size(); j++)
            if (a[j] > a[j + 1]) std::swap(a[j], a[j + 1]);
}

#include <unordered_map>
#include <sstream>
std::unordered_map<std::string, int> freq;
std::istringstream iss("the cat and the dog");
std::string w;
while (iss >> w) freq[w]++;   // {the:2, cat:1, and:1, dog:1}

#include <numeric>
#include <algorithm>
std::vector<int> v = {4, 9, 2, 7};
int sum = std::accumulate(v.begin(), v.end(), 0);   // 22
int mx = *std::max_element(v.begin(), v.end());   // 9

int reverse(int n) {
    int r = 0;
    while (n) { r = r * 10 + n % 10; n /= 10; }
    return r;
}
reverse(1234);   // 4321

#include <set>
std::vector<int> v = {1, 2, 2, 3, 3, 4};
std::set<int> s(v.begin(), v.end());   // {1,2,3,4}

#include <set>
std::set<int, std::greater<>> s = {5, 9, 9, 3};   // {9,5,3}
auto it = ++s.begin();
int second = *it;   // 5

#include <algorithm>
bool isAnagram(std::string a, std::string b) {
    std::sort(a.begin(), a.end());
    std::sort(b.begin(), b.end());
    return a == b;
}
isAnagram("listen", "silent");   // true

#include <algorithm>
std::vector<int> v = {1, 2, 3, 4, 5};
int k = 2;
std::rotate(v.begin(), v.begin() + k, v.end());   // {3,4,5,1,2}

#include <unordered_map>
std::vector<int> twoSum(std::vector<int>& a, int target) {
    std::unordered_map<int, int> seen;
    for (int i = 0; i < (int)a.size(); i++) {
        int need = target - a[i];
        if (seen.count(need)) return {seen[need], i};
        seen[a[i]] = i;
    }
    return {};
}

#include <numeric>
int missing(std::vector<int>& a, int n) {
    int expected = n * (n + 1) / 2;
    return expected - std::accumulate(a.begin(), a.end(), 0);
}

#include <algorithm>
std::vector<int> a = {1, 3, 5}, b = {2, 4, 6}, r(6);
std::merge(a.begin(), a.end(), b.begin(), b.end(), r.begin());
// r = {1,2,3,4,5,6}

#include <cctype>
std::string s = "the quick fox";
bool newWord = true;
for (char& c : s) {
    if (newWord && std::isalpha(c)) c = std::toupper(c);
    newWord = (c == ' ');
}   // "The Quick Fox"

#include <algorithm>
std::vector<std::string> words = {"bb", "a", "ccc"};
std::sort(words.begin(), words.end(),
    [](const auto& x, const auto& y){ return x.size() < y.size(); });
// {"a", "bb", "ccc"}

#include <unordered_map>
std::unordered_map<int, long> memo;
long fib(int n) {
    if (n <= 1) return n;
    if (memo.count(n)) return memo[n];
    return memo[n] = fib(n - 1) + fib(n - 2);
}

void mergeSort(std::vector<int>& a, int lo, int hi) {
    if (lo >= hi) return;
    int mid = lo + (hi - lo) / 2;
    mergeSort(a, lo, mid);
    mergeSort(a, mid + 1, hi);
    std::vector<int> tmp;
    int i = lo, j = mid + 1;
    while (i <= mid && j <= hi) tmp.push_back(a[i] <= a[j] ? a[i++] : a[j++]);
    while (i <= mid) tmp.push_back(a[i++]);
    while (j <= hi) tmp.push_back(a[j++]);
    std::copy(tmp.begin(), tmp.end(), a.begin() + lo);
}

void quickSort(std::vector<int>& a, int lo, int hi) {
    if (lo >= hi) return;
    int pivot = a[hi], i = lo - 1;
    for (int j = lo; j < hi; j++)
        if (a[j] < pivot) std::swap(a[++i], a[j]);
    std::swap(a[i + 1], a[hi]);
    quickSort(a, lo, i);
    quickSort(a, i + 2, hi);
}

template<typename T>
class Stack {
    std::vector<T> data;
public:
    void push(const T& x) { data.push_back(x); }
    T pop() { T t = data.back(); data.pop_back(); return t; }
    bool empty() const { return data.empty(); }
};

class Account {
    double balance = 0;
public:
    void deposit(double amt) {
        if (amt <= 0) throw std::invalid_argument("bad amount");
        balance += amt;
    }
    void withdraw(double amt) {
        if (amt > balance) throw std::runtime_error("insufficient");
        balance -= amt;
    }
    double getBalance() const { return balance; }
};

#include <memory>
struct Node {
    int value;
    std::unique_ptr<Node> next;   // owns the rest of the list
    Node(int v) : value(v), next(nullptr) {}
};

auto head = std::make_unique<Node>(1);
head->next = std::make_unique<Node>(2);
// entire list freed automatically when head goes out of scope