Maximum Running Time of N Computers - Practice Coding Problems

Maximum Running Time of N Computers - Problem

Imagine you're managing a data center with n computers that need to run simultaneously for as long as possible. You have a collection of rechargeable batteries, each with different capacities measured in minutes.

Here's the challenge: You can hot-swap batteries between computers at any time - meaning you can remove a depleted battery from one computer and instantly insert it into another, or swap in a fresh battery. The goal is to keep all n computers running simultaneously for the maximum possible duration.

Input: An integer n (number of computers) and an array batteries where batteries[i] represents the capacity of the i-th battery in minutes.

Output: The maximum number of minutes you can keep all n computers running simultaneously.

Key Insight: This isn't about assigning batteries to computers - it's about optimally distributing the total battery capacity across time to maximize runtime!

Input & Output

example_1.py — Basic Case

$ Input: n = 2, batteries = [3,3,3]

› Output: 4

💡 Note: We have 2 computers and 3 batteries each with 3 minutes. Total capacity = 9 minutes. We can run 2 computers for 4 minutes (requiring 8 total minutes) by smart battery swapping. At minute 3, we swap batteries to keep both computers running for the 4th minute.

example_2.py — Uneven Distribution

$ Input: n = 2, batteries = [1,1,1,1]

› Output: 2

💡 Note: Total capacity = 4 minutes. We can run 2 computers for 2 minutes total (4 total minutes needed). We can achieve this by swapping the 1-minute batteries optimally.

example_3.py — Large Battery Edge Case

$ Input: n = 3, batteries = [10,10,3,5]

› Output: 8

💡 Note: Total capacity = 28 minutes. For 3 computers, we might think we can run for 28/3 ≈ 9 minutes, but the constraint is that each battery can contribute at most the target runtime. For 8 minutes: contributions are min(10,8) + min(10,8) + min(3,8) + min(5,8) = 8+8+3+5 = 24 ≥ 3×8. For 9 minutes: 8+8+3+5 = 24 < 3×9=27.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ batteries.length ≤ 10⁵
1 ≤ batteries[i] ≤ 10⁹
You can hot-swap batteries between computers at any integer time moment

Visualization

Tap to expand

Understanding the Visualization

Identify the Constraint

Each battery can contribute at most T minutes to a T-minute solution due to hot-swapping logistics

Binary Search Setup

Search space is [0, total_battery_capacity / n_computers]

Feasibility Check

For runtime T: sum all min(battery_capacity, T) and check if ≥ n × T

Converge to Optimum

Binary search converges to maximum feasible runtime

Key Takeaway

🎯 Key Insight: The problem transforms from complex scheduling to simple binary search when you realize that if runtime T is achievable, then any runtime < T is also achievable (monotonic property).

Asked in

G Google 15 a Amazon 12 f Meta 8 ⊞ Microsoft 6

The optimal solution uses binary search on the answer combined with a greedy feasibility check. Key insight: if we can run all computers for T minutes, we can run them for any time ≤ T. We binary search for the maximum feasible runtime, where feasibility is determined by checking if sum of min(battery_capacity, target_time) ≥ n × target_time.

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Runtime (Optimal)	O(B × log(S))	O(1)	Binary search for maximum feasible runtime with greedy feasibility check
Brute Force (Try All Time Distributions)	O(T × 2^(B×T))	O(T × B)	Simulate all possible ways to distribute battery power over time

Binary Search on Runtime (Optimal) — Algorithm Steps

Binary search on possible runtime from 0 to sum(batteries)/n
For each candidate runtime T, check if it's achievable
Feasibility check: batteries larger than T can only contribute T minutes each
Sum all effective contributions and compare with needed capacity (n × T)
Adjust search bounds based on feasibility

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Search Space

Set left=0, right=total_battery_sum/n computers

Test Middle Runtime

Check if mid runtime is achievable with current batteries

Feasibility Check

Sum min(battery_capacity, target_time) for all batteries

Adjust Search Bounds

If feasible: search right half, else: search left half

Code -

solution.c — C

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

long long min(long long a, long long b) {
    return a < b ? a : b;
}

int canRunForTime(int n, int* batteries, int batterySize, long long targetTime) {
    long long totalContribution = 0;
    
    for (int i = 0; i < batterySize; i++) {
        totalContribution += min((long long)batteries[i], targetTime);
    }
    
    return totalContribution >= (long long)n * targetTime;
}

long long maxRunTime(int n, int* batteries, int batterySize) {
    long long left = 0;
    long long totalSum = 0;
    
    for (int i = 0; i < batterySize; i++) {
        totalSum += batteries[i];
    }
    long long right = totalSum / n;
    
    long long result = 0;
    while (left <= right) {
        long long mid = left + (right - left) / 2;
        
        if (canRunForTime(n, batteries, batterySize, mid)) {
            result = mid;
            left = mid + 1;
        } else {
            right = mid - 1;
        }
    }
    
    return result;
}

int main() {
    int batteries[] = {3, 3, 3};
    int n = 2;
    printf("%lld\n", maxRunTime(n, batteries, 3));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(B × log(S))

Where B is number of batteries and S is sum of all batteries - log factor from binary search

⚡ Linearithmic

Space Complexity

O(1)

Only use constant extra space for binary search variables

✓ Linear Space

78.5K Views

Medium Frequency

~25 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

Binary Search on Runtime (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler