Home/Anonymous/Answers
  1. Asked: September 11, 2026In:

    PyTorch RuntimeError: CUDA out of memory: Why torch.cuda.empty_cache() fails & how to fix fragmentation

    Anonymous
    Anonymous Begginer

    Direct Technical Solution: torch.cuda.empty_cache() releases only cached (unallocated) blocks back to the CUDA driver; it never frees memory occupied by active tensors (weights, optimizer states, computation graph nodes). Calling it inside your training loop hurts performance because CUDA must constRead more

    Direct Technical Solution: torch.cuda.empty_cache() releases only cached (unallocated) blocks back to the CUDA driver; it never frees memory occupied by active tensors (weights, optimizer states, computation graph nodes). Calling it inside your training loop hurts performance because CUDA must constantly re-allocate OS memory via costly system calls.

    1. Root Cause: PyTorch Allocator Memory Fragmentation

    Look closely at your error message: 18.21 GiB allocated + 4.80 GiB reserved. PyTorch had nearly 5 GB of memory held in its internal caching allocator, but it was split into scattered, non-contiguous memory chunks. When a tensor required 512 MiB of contiguous VRAM, the allocator failed to find a single chunk large enough.

    2. The Modern Fix: Expandable Segments (PyTorch 2.0+)

    The definitive solution in modern PyTorch is activating virtual memory management via the expandable_segments flag. This instructs CUDA to map physical memory pages to a contiguous virtual memory space, virtually eliminating memory fragmentation:

    # Terminal / Docker Entrypoint (Set before launching Python)
export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True

# Or directly in Python before calling any CUDA operations:
import os
os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
import torch

    3. The 4 Golden Rules to Prevent CUDA OOM

    • Detach Loss Values: Never accumulate raw tensor losses: total_loss += loss retains the entire backward computation graph in VRAM! Always use total_loss += loss.item().
    • Use Automatic Mixed Precision (AMP): Halve activation memory using native BF16/FP16:
      with torch.autocast(device_type="cuda", dtype=torch.bfloat16):
    outputs = model(inputs)
    loss = criterion(outputs, targets)
    • Gradient Accumulation: Instead of a batch size of 64 that OOMs, use a micro-batch size of 16 and accumulate gradients across 4 backward steps:
      loss = loss / 4
loss.backward()
if (step + 1) % 4 == 0:
    optimizer.step()
    optimizer.zero_grad(set_to_none=True)
    • Zero Gradients with `set_to_none=True`: optimizer.zero_grad(set_to_none=True) deallocates memory instead of zeroing tensors with zeros of equal size.
    See less
    • 0
  2. Asked: September 11, 2026In: ,

    Task Scheduler with Cooldowns: Closed-form mathematical formula vs Priority Queue simulation

    Anonymous
    Anonymous Begginer

    Here is the C++20 Closed-Form Math implementation for Task Scheduler. It eliminates all simulation loops and runs in O(N) time and O(1) space. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> #includRead more

    Here is the C++20 Closed-Form Math implementation for Task Scheduler. It eliminates all simulation loops and runs in O(N) time and O(1) space.

    Modern C++20 Solution (Fully Runnable)

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

int leastInterval(const std::vector<char>& tasks, int n) {
    std::array<int, 26> freq{};
    for (char c : tasks) {
        freq++;
    }

    int max_freq = *std::max_element(freq.begin(), freq.end());
    int max_count = 0;
    for (int count : freq) {
        if (count == max_freq) ++max_count;
    }

    int formula_ans = (max_freq - 1) * (n + 1) + max_count;
    return std::max(static_cast<int>(tasks.size()), formula_ans);
}

int main() {
    std::vector<char> tasks = {'A', 'A', 'A', 'B', 'B', 'B'};
    int n = 2;
    std::cout << "Minimum Task Scheduling Intervals: " << leastInterval(tasks, n) << "n"; // Expected: 8
    return 0;
}

    Complexity: O(N) time to tally frequencies and O(1) space using a fixed 26-element array.

    See less
    • 0
  3. Asked: September 11, 2026In: ,

    Lowest Common Ancestor: Why Binary Lifting in O(log N) beats naive DFS in high-scale DAGs

    Anonymous
    Anonymous Begginer

    Here is the full C++20 Binary Lifting LCA implementation. Any LCA query runs in O(log N) time. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> #include <cmath> #include <algorithm> classRead more

    Here is the full C++20 Binary Lifting LCA implementation. Any LCA query runs in O(log N) time.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

class TreeLCA {
    int n, max_log;
    std::vector<int> depth;
    std::vector<std::vector<int>> up;

    void dfs(int u, int p, int d, const std::vector<std::vector<int>>& adj) {
        depth[u] = d;
        up[u][0] = p;
        for (int i = 1; i < max_log; ++i) {
            up[u][i] = up[ up[u][i - 1] ][i - 1];
        }
        for (int v : adj[u]) {
            if (v != p) dfs(v, u, d + 1, adj);
        }
    }

public:
    TreeLCA(int nodes, int root, const std::vector<std::vector<int>>& adj) : n(nodes) {
        max_log = std::ceil(std::log2(n)) + 1;
        depth.assign(n, 0);
        up.assign(n, std::vector<int>(max_log, root));
        dfs(root, root, 0, adj);
    }

    int queryLCA(int u, int v) const {
        if (depth[u] < depth[v]) std::swap(u, v);

        int diff = depth[u] - depth[v];
        for (int i = 0; i < max_log; ++i) {
            if ((diff >> i) & 1) u = up[u][i];
        }
        if (u == v) return u;

        for (int i = max_log - 1; i >= 0; --i) {
            if (up[u][i] != up[v][i]) {
                u = up[u][i];
                v = up[v][i];
            }
        }
        return up[u][0];
    }
};

int main() {
    int n = 7;
    std::vector<std::vector<int>> adj(n);
    adj[0] = {1, 2};
    adj[1] = {0, 3, 4};
    adj[2] = {0, 5, 6};
    adj[3] = {1}; adj[4] = {1};
    adj[5] = {2}; adj[6] = {2};

    TreeLCA lca(n, 0, adj);
    std::cout << "LCA(3, 4): " << lca.queryLCA(3, 4) << "n"; // Expected: 1
    std::cout << "LCA(3, 6): " << lca.queryLCA(3, 6) << "n"; // Expected: 0
    return 0;
}

    Complexity: O(N log N) preprocessing and O(log N) per query.

    See less
    • 0
  4. Asked: September 11, 2026In: ,

    Minimum Window Substring: Why an integer frequency array beats HashMap in low-latency parsers

    Anonymous
    Anonymous Begginer

    Here is the C++20 Minimum Window Substring using a stack-allocated 128-element integer array and std::string_view to avoid memory allocations. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <string> #includRead more

    Here is the C++20 Minimum Window Substring using a stack-allocated 128-element integer array and std::string_view to avoid memory allocations.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <string>
#include <string_view>
#include <array>

std::string_view minWindow(std::string_view s, std::string_view t) {
    if (s.empty() || t.empty() || s.size() < t.size()) return "";

    std::array<int, 128> freq{};
    for (char c : t) freq[static_cast<uint8_t>(c)]++;

    int required = static_cast<int>(t.size());
    int min_len = 1e9;
    int start_idx = 0;
    int left = 0;

    for (int right = 0; right < static_cast<int>(s.size()); ++right) {
        uint8_t r_char = static_cast<uint8_t>(s[right]);
        if (freq[r_char] > 0) required--;
        freq[r_char]--;

        while (required == 0) {
            int window_len = right - left + 1;
            if (window_len < min_len) {
                min_len = window_len;
                start_idx = left;
            }

            uint8_t l_char = static_cast<uint8_t>(s[left]);
            freq[l_char]++;
            if (freq[l_char] > 0) required++;
            left++;
        }
    }
    return min_len == 1e9 ? "" : s.substr(start_idx, min_len);
}

int main() {
    std::string s = "ADOBECODEBANC";
    std::string t = "ABC";
    std::cout << "Minimum Window Substring: " << minWindow(s, t) << "n"; // Expected: "BANC"
    return 0;
}

    Zero Allocations: std::string_view creates no heap strings; the array fits into CPU L1 cache.

    See less
    • 0
  5. Asked: September 11, 2026In: ,

    How does a Fenwick Tree (Binary Indexed Tree) query and update prefix sums in O(log N) using i & (-i)?

    Anonymous
    Anonymous Begginer

    Here is the clean C++20 Fenwick Tree (BIT) implementation. It uses int64_t for precision and i & (-i) for logarithmic index jumps. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> #include <csRead more

    Here is the clean C++20 Fenwick Tree (BIT) implementation. It uses int64_t for precision and i & (-i) for logarithmic index jumps.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>
#include <cstdint>

class FenwickTree {
    int n;
    std::vector<int64_t> tree;

    static inline int lowbit(int x) noexcept {
        return x & (-x);
    }

public:
    FenwickTree(int size) : n(size), tree(size + 1, 0) {}

    void add(int i, int64_t delta) {
        for (; i <= n; i += lowbit(i)) {
            tree[i] += delta;
        }
    }

    int64_t queryPrefix(int i) const {
        int64_t sum = 0;
        for (; i > 0; i -= lowbit(i)) {
            sum += tree[i];
        }
        return sum;
    }

    int64_t queryRange(int l, int r) const {
        if (l > r) return 0;
        return queryPrefix(r) - queryPrefix(l - 1);
    }
};

int main() {
    FenwickTree bit(10);
    bit.add(1, 5);
    bit.add(2, 3);
    bit.add(3, 7);
    bit.add(4, 2);

    std::cout << "Prefix sum [1..3]: " << bit.queryPrefix(3) << "n";  // 15
    std::cout << "Range sum [2..4]:  " << bit.queryRange(2, 4) << "n"; // 12
    return 0;
}

    Complexity: O(log N) updates and queries with strictly 1N memory footprint.

    See less
    • 0
  6. Asked: September 11, 2026In: ,

    How does the Dutch National Flag 3-way partition work in a single pass with zero branch mispredictions?

    Anonymous
    Anonymous Begginer

    Here is the in-place C++20 Dutch National Flag algorithm. Notice that std::swap compiles to a single XCHG or register mov instruction on x86_64. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> #inclRead more

    Here is the in-place C++20 Dutch National Flag algorithm. Notice that std::swap compiles to a single XCHG or register mov instruction on x86_64.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>
#include <utility>

void sortColors(std::vector<int>& nums) {
    int low = 0;
    int mid = 0;
    int high = static_cast<int>(nums.size()) - 1;

    while (mid <= high) {
        if (nums[mid] == 0) {
            std::swap(nums[low], nums[mid]);
            ++low;
            ++mid;
        } else if (nums[mid] == 1) {
            ++mid;
        } else { // nums[mid] == 2
            std::swap(nums[mid], nums[high]);
            --high;
            // Note: mid is intentionally NOT incremented here!
        }
    }
}

int main() {
    std::vector<int> colors = {2, 0, 2, 1, 1, 0};
    sortColors(colors);
    std::cout << "Sorted Colors: ";
    for (int c : colors) std::cout << c << " ";
    std::cout << "n";
    return 0;
}

    Complexity: Single pass O(N) with O(1) space.

    See less
    • 0
  7. Asked: September 11, 2026In: ,

    How does a Count-Min Sketch estimate heavy-hitter item frequencies under bounded RAM?

    Anonymous
    Anonymous Begginer

    Here is a modern C++ implementation of the Count-Min Sketch for streaming frequency tracking under strict memory caps. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> #include <string> #includRead more

    Here is a modern C++ implementation of the Count-Min Sketch for streaming frequency tracking under strict memory caps.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <algorithm>
#include <cstdint>

class CountMinSketch {
    int w; // Width (columns)
    int d; // Depth (rows)
    std::vector<std::vector<uint32_t>> table;

    uint32_t hash(const std::string& str, int seed) const {
        // FNV-1a 32-bit hash with seed variation
        uint32_t h = 2166136261u ^ seed;
        for (char c : str) {
            h ^= static_cast<uint8_t>(c);
            h *= 16777619u;
        }
        return h % w;
    }

public:
    CountMinSketch(double epsilon = 0.001, double delta = 0.01) {
        w = static_cast<int>(std::ceil(2.71828 / epsilon));
        d = static_cast<int>(std::ceil(std::log(1.0 / delta)));
        table.assign(d, std::vector<uint32_t>(w, 0));
    }

    void add(const std::string& item, uint32_t count = 1) {
        for (int r = 0; r < d; ++r) {
            uint32_t col = hash(item, r * 31 + 7);
            table[r][col] += count;
        }
    }

    uint32_t query(const std::string& item) const {
        uint32_t min_val = UINT32_MAX;
        for (int r = 0; r < d; ++r) {
            uint32_t col = hash(item, r * 31 + 7);
            min_val = std::min(min_val, table[r][col]);
        }
        return min_val;
    }
};

int main() {
    CountMinSketch cms(0.01, 0.01);
    cms.add("192.168.1.100", 500);
    cms.add("10.0.0.1", 20);

    std::cout << "Estimated frequency 192.168.1.100: " << cms.query("192.168.1.100") << "n";
    std::cout << "Estimated frequency 10.0.0.1:     " << cms.query("10.0.0.1") << "n";
    return 0;
}

    Guarantees: Strictly bounded RAM overhead and zero underestimations.

    See less
    • 0
  8. Asked: September 11, 2026In: ,

    Gas Station Circular Tour: Mathematical proof of why a single pass in O(N) is sufficient

    Anonymous
    Anonymous Begginer

    Here is the clean C++20 Single-Pass Greedy solution for the Gas Station problem. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #include <iostream> #include <vector> int canCompleteCircuit(const std::vector<int>& gas, const sRead more

    Here is the clean C++20 Single-Pass Greedy solution for the Gas Station problem.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>

int canCompleteCircuit(const std::vector<int>& gas, const std::vector<int>& cost) {
    int total_tank = 0;
    int curr_tank = 0;
    int start_station = 0;

    for (size_t i = 0; i < gas.size(); ++i) {
        int diff = gas[i] - cost[i];
        total_tank += diff;
        curr_tank += diff;

        if (curr_tank < 0) {
            // Greedy restart at next station
            start_station = i + 1;
            curr_tank = 0;
        }
    }
    return total_tank >= 0 ? start_station : -1;
}

int main() {
    std::vector<int> gas  = {1, 2, 3, 4, 5};
    std::vector<int> cost = {3, 4, 5, 1, 2};

    int start = canCompleteCircuit(gas, cost);
    std::cout << "Valid Starting Station Index: " << start << "n"; // Station 3 (0-indexed)
    return 0;
}

    Complexity: Strictly O(N) time and O(1) auxiliary space.

    See less
    • 0
  9. Asked: September 11, 2026In: ,

    How does Brian Kernighan’s bit algorithm work, and why does n & (n – 1) clear the lowest set bit?

    Anonymous
    Anonymous Begginer

    Here is the modern C++20 bit-manipulation implementation. In modern C++ (C++20), you also have std::popcount from the <bit> header which compiles to the hardware POPCNT instruction. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++ Runner #includeRead more

    Here is the modern C++20 bit-manipulation implementation. In modern C++ (C++20), you also have std::popcount from the <bit> header which compiles to the hardware POPCNT instruction.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <cstdint>
#include <bit>

// Brian Kernighan's Algorithm: runs in O(k) loops where k = set bits
int countSetBitsKernighan(uint64_t n) {
    int count = 0;
    while (n > 0) {
        n &= (n - 1); // Clears the lowest set bit
        ++count;
    }
    return count;
}

int main() {
    uint64_t val = 0b101100101101; // 7 set bits
    std::cout << "Kernighan Set Bits: " << countSetBitsKernighan(val) << "n";
    // Modern C++20 hardware intrinsic alternative:
    std::cout << "std::popcount (HW): " << std::popcount(val) << "n";
    return 0;
}

    Efficiency: Runs only as many iterations as there are 1 bits in the integer.

    See less
    • 0
  10. Asked: September 11, 2026In: ,

    0/1 Knapsack: Why does reverse iteration turn O(N*W) space into O(W) space?

    Anonymous
    Anonymous Begginer

    Here is the modern C++20 implementation of the 0/1 Knapsack with 1D Backward Sweep. By reserving contiguous memory and sweeping from capacity down to weight[i], we eliminate all intermediate row allocations. Modern C++20 Solution (Fully Runnable) Copy C++ Code ► Compile & Run in Online C++Read more

    Here is the modern C++20 implementation of the 0/1 Knapsack with 1D Backward Sweep. By reserving contiguous memory and sweeping from capacity down to weight[i], we eliminate all intermediate row allocations.

    Modern C++20 Solution (Fully Runnable)

    #include <iostream>
#include <vector>
#include <algorithm>

int knapsack01(const std::vector<int>& weights, const std::vector<int>& values, int capacity) {
    std::vector<int> dp(capacity + 1, 0);

    for (size_t i = 0; i < weights.size(); ++i) {
        // Must sweep backwards from capacity down to weights[i]!
        for (int w = capacity; w >= weights[i]; --w) {
            dp[w] = std::max(dp[w], dp[w - weights[i]] + values[i]);
        }
    }
    return dp[capacity];
}

int main() {
    std::vector<int> weights = {2, 3, 4, 5};
    std::vector<int> values  = {3, 4, 5, 6};
    int capacity = 5;

    std::cout << "Max Knapsack Value: " << knapsack01(weights, values, capacity) << "n";
    return 0;
}

    Complexity: O(N * W) time, but auxiliary space drops from O(N * W) to just O(W).

    See less
    • 0