Minimum Time to Repair Cars - Practice Coding Problems

Minimum Time to Repair Cars - Problem

Imagine you're the manager of a busy auto repair shop with mechanics of different skill levels! 🚗

You have an array of mechanics, where each mechanic has a rank representing their skill level. The higher the rank, the slower they work (counterintuitively). A mechanic with rank r takes r × n² minutes to repair n cars.

Your challenge: Given a total number of cars waiting to be repaired, determine the minimum time needed to repair all cars when all mechanics work simultaneously.

Key insight: Since mechanics work in parallel, the total time is determined by when the last car gets fixed. You need to optimally distribute the workload!

Example: If you have mechanics with ranks [4,2,8] and 10 cars to repair, you need to figure out how to assign cars to minimize the maximum time any single mechanic takes.

Input & Output

example_1.py — Basic Case

$ Input: ranks = [4,2,8,7], cars = 10

› Output: 16

💡 Note: The optimal distribution assigns cars to mechanics to minimize the maximum completion time. Mechanic with rank 2 repairs 4 cars (2×4²=32 min), rank 4 repairs 3 cars (4×3²=36 min), others repair fewer cars. The minimum possible maximum time is 16 minutes with careful distribution.

example_2.py — Simple Case

$ Input: ranks = [5,1,8], cars = 6

› Output: 16

💡 Note: With binary search, we find that all 6 cars can be repaired in 16 minutes. The fastest mechanic (rank 1) can repair √(16/1) = 4 cars, rank 5 can repair √(16/5) = 1 car, and rank 8 can repair √(16/8) = 1 car, totaling 6 cars exactly.

example_3.py — Edge Case

$ Input: ranks = [1], cars = 1

› Output: 1

💡 Note: Single mechanic with rank 1 needs 1×1² = 1 minute to repair 1 car. This is the minimum possible case.

Constraints

1 ≤ ranks.length ≤ 10⁵
1 ≤ ranks[i] ≤ 100
1 ≤ cars ≤ 10⁶
Time limit: 2 seconds

Visualization

Tap to expand

Understanding the Visualization

Setup the Problem

You have mechanics with different ranks (higher rank = slower) and a queue of cars

Brute Force Insight

You could try every way to distribute cars, but that's exponentially slow

Key Realization

Instead of asking 'how to distribute?', ask 'can we finish in T minutes?'

Binary Search Magic

If we can finish in T minutes, we can also finish in T+1, T+2, etc.

Calculate Capacity

For time T, each mechanic can repair at most √(T/rank) cars

Find the Answer

Binary search finds the minimum T where total capacity ≥ required cars

Key Takeaway

🎯 Key Insight: Instead of distributing cars optimally (exponential), we binary search on the completion time and check if it's achievable (logarithmic). This transforms a complex optimization problem into an elegant search problem!

Asked in

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

The optimal approach uses binary search on the answer. Instead of trying all possible car distributions, we binary search on the completion time. For any given time T, we can quickly calculate if it's possible to repair all cars by computing the maximum cars each mechanic can handle: max_cars = √(T/rank). This reduces complexity from exponential to O(n log(max_time)).

Common Approaches

Approach	Time	Space	Notes
✓ Binary Search on Answer (Optimal)	O(n log(max_time))	O(1)	Binary search on the completion time and check feasibility
Brute Force (Try All Distributions)	O(n^cars)	O(cars)	Try every possible way to distribute cars among mechanics

Binary Search on Answer (Optimal) — Algorithm Steps

Set binary search bounds: left=1, right=minimum_rank × cars²
For each mid time, check if all cars can be repaired in 'mid' minutes
For each mechanic with rank r, max cars in 'mid' minutes = floor(sqrt(mid/r))
If total capacity >= cars, we can do better (search left half)
Otherwise, we need more time (search right half)

Visualization

Tap to expand

Step-by-Step Walkthrough

Set Search Range

Initialize left=1, right=worst_case_time

Check Middle Time

Can all cars be repaired in mid minutes?

Calculate Capacity

Sum max cars each mechanic can handle

Narrow Range

Move left or right boundary based on feasibility

Code -

solution.c — C

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

int canRepairInTime(int* ranks, int numMechanics, int cars, long long timeLimit) {
    long long totalCars = 0;
    for (int i = 0; i < numMechanics; i++) {
        long long maxCars = (long long)sqrt((double)timeLimit / ranks[i]);
        totalCars += maxCars;
        if (totalCars >= cars) {
            return 1;
        }
    }
    return totalCars >= cars;
}

long long repairCars(int* ranks, int numMechanics, int cars) {
    long long left = 1;
    
    int minRank = ranks[0];
    for (int i = 1; i < numMechanics; i++) {
        if (ranks[i] < minRank) {
            minRank = ranks[i];
        }
    }
    long long right = (long long)minRank * cars * cars;
    
    while (left < right) {
        long long mid = left + (right - left) / 2;
        if (canRepairInTime(ranks, numMechanics, cars, mid)) {
            right = mid;
        } else {
            left = mid + 1;
        }
    }
    
    return left;
}

int main() {
    char line[1000];
    fgets(line, sizeof(line), stdin);
    
    int ranks[100];
    int numMechanics = 0;
    char* token = strtok(line, " ");
    while (token != NULL) {
        ranks[numMechanics++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    int cars;
    scanf("%d", &cars);
    
    printf("%lld\n", repairCars(ranks, numMechanics, cars));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log(max_time))

Binary search takes O(log(max_time)) iterations, each checking n mechanics

⚡ Linearithmic

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.3K Views

Medium Frequency

~25 min Avg. Time

847 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 Answer (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler