Incremental Memory Leak - Practice Coding Problems

Incremental Memory Leak - Problem

Math Simulation Medium

Imagine you're managing a computer system with two memory sticks that are being consumed by a faulty program. This program has a peculiar behavior: it consumes an increasing amount of memory each second!

You start with two memory sticks containing memory1 and memory2 bits respectively. At the i-th second (starting from second 1), the program tries to allocate exactly i bits of memory. The allocation always goes to the memory stick with more available memory, or to the first stick if both have equal memory.

The program will crash when neither memory stick has enough bits to satisfy the current allocation request. Your task is to determine exactly when this crash occurs and how much memory remains in each stick.

Goal: Return [crashTime, memory1crash, memory2crash] where crashTime is when the program crashed, and the other values are the remaining memory in each stick.

Input & Output

example_1.py — Basic Case

$ Input: memory1 = 2, memory2 = 2

› Output: [3, 1, 0]

💡 Note: Second 1: Both have 2 bits, choose memory1 → memory1=1, memory2=2. Second 2: memory2 > memory1, choose memory2 → memory1=1, memory2=0. Second 3: Need 3 bits, but memory1=1 and memory2=0, so crash at second 3.

example_2.py — Unequal Memory

$ Input: memory1 = 8, memory2 = 11

› Output: [6, 0, 4]

💡 Note: Sec 1: Choose memory2 (11≥8) → [8,10]. Sec 2: Choose memory2 (10≥8) → [8,8]. Sec 3: Choose memory1 (equal, pick first) → [5,8]. Sec 4: Choose memory2 (8≥5) → [5,4]. Sec 5: Choose memory1 (5≥4) → [0,4]. Sec 6: Need 6 bits but max available is 4, crash.

example_3.py — Large Memory

$ Input: memory1 = 100, memory2 = 1

› Output: [15, 85, 1]

💡 Note: Memory2 will be eliminated early since it's small. After that, memory1 will be consistently chosen until it can't satisfy the allocation. The mathematical optimization approach really shines here.

Constraints

0 ≤ memory1, memory2 ≤ 2³¹ - 1
The program always starts from second 1
Memory allocation always goes to the stick with more memory, or to memory1 if equal

Visualization

Tap to expand

Understanding the Visualization

Hour 1

Drain 1 liter from fuller tank (or first if equal)

Hour 2

Drain 2 liters from fuller tank

Hour 3

Drain 3 liters from fuller tank

Pattern Recognition

If one tank is much fuller, it gets drained for many consecutive hours

System Failure

When neither tank can supply the required amount

Key Takeaway

🎯 Key Insight: When memory values differ significantly, we can use mathematical formulas to calculate how many consecutive allocations will go to the larger memory stick, dramatically reducing simulation time from O(√n) to O(log√n).

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 Apple 20

This problem can be solved with simulation or mathematical optimization. The brute force approach simulates each second individually with O(√n) time complexity. The optimal approach uses quadratic formulas to skip ahead when one memory stick will be consistently chosen, reducing time complexity to O(log√n). Both approaches maintain O(1) space complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(√n)	O(1)	Simulate each second one by one until crash occurs
Mathematical Optimization	O(log(√n))	O(1)	Use math to skip ahead when one memory stick will be consistently drained

Brute Force Simulation — Algorithm Steps

Start from second 1 with initial memory values
At each second i, determine which memory stick has more available memory
Subtract i bits from the chosen memory stick
Check if either memory stick can handle the next allocation (i+1 bits)
If neither can handle it, return the current second as crash time

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial State

Two memory sticks with their initial values

Second 1

Allocate 1 bit from the fuller stick (or first if equal)

Second 2

Allocate 2 bits from the fuller stick

Continue

Keep allocating increasing amounts until crash

Crash

When neither stick can satisfy the current demand

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>

int* memoryLeak(int memory1, int memory2) {
    int* result = (int*)malloc(3 * sizeof(int));
    int second = 1;
    
    while (1) {
        // Choose which memory stick to allocate from
        if (memory1 >= memory2) {
            // Allocate from memory1
            if (memory1 >= second) {
                memory1 -= second;
            } else {
                break;
            }
        } else {
            // Allocate from memory2
            if (memory2 >= second) {
                memory2 -= second;
            } else {
                break;
            }
        }
        
        second++;
    }
    
    result[0] = second;
    result[1] = memory1;
    result[2] = memory2;
    return result;
}

int main() {
    int memory1, memory2;
    scanf("%d %d", &memory1, &memory2);
    int* result = memoryLeak(memory1, memory2);
    printf("[%d, %d, %d]\n", result[0], result[1], result[2]);
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(√n)

Where n is the total memory. We simulate roughly √(memory1 + memory2) seconds since memory consumption grows quadratically (1+2+3+...+k = k(k+1)/2)

✓ Linear Growth

Space Complexity

O(1)

Only uses a constant amount of extra space for variables

✓ Linear Space

89.2K Views

Medium Frequency

~18 min Avg. Time

1.8K Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler