Minimum Time to Eat All Grains - Practice Coding Problems

Minimum Time to Eat All Grains - Problem

The Great Grain Hunt Challenge

Imagine a farm where n hens are scattered along a straight line, and m grains are also positioned at various points on the same line. Your mission is to help these hungry hens eat all the grains in the minimum possible time!

Here's how it works:
• Each hen can move left or right by 1 unit per second
• Multiple hens can move simultaneously and independently
• A hen eats a grain instantly when they occupy the same position
• One hen can eat multiple grains
• All grains must be consumed

The question is: What's the minimum time needed if all hens act optimally?

This is a classic assignment optimization problem where we need to smartly assign grains to hens to minimize the maximum time any hen takes.

Input & Output

example_1.py — Basic Example

$ Input: hens = [3, 6, 7], grains = [2, 4, 7, 9]

› Output: 2

💡 Note: Hen at position 3 can eat grains at positions 2 and 4 (takes 2 seconds: go to 2, then to 4). Hen at position 6 can eat grain at position 7 (takes 1 second). Hen at position 7 can eat grain at position 9 (takes 2 seconds). Maximum time is 2 seconds.

example_2.py — Single Hen

$ Input: hens = [4], grains = [1, 3, 6, 8]

› Output: 7

💡 Note: Single hen at position 4 must eat all grains. Optimal strategy: go to position 1 first (3 seconds), then traverse to position 8 (7 more seconds), total 7 seconds to cover range [1,8].

example_3.py — Edge Case

$ Input: hens = [0, 10], grains = [5]

› Output: 5

💡 Note: Two hens at positions 0 and 10, one grain at position 5. Either hen can eat it in 5 seconds. Optimal assignment gives minimum time of 5.

Constraints

1 ≤ hens.length, grains.length ≤ 2 × 10⁴
-10⁹ ≤ hens[i], grains[i] ≤ 10⁹
All positions are distinct within their respective arrays
At least one hen and one grain are always present

Visualization

Tap to expand

Sort: Arrange hens and grains by position2. Binary Search: Search minimum feasible time3. Greedy Validation: Check if assignment possible4. Result: Each hen takes consecutive grains optimallyTime Complexity: O((n+m) × log(max_distance)) | Space: O(1)

Understanding the Visualization

Sort Positions

Arrange all hens and grains in order along the line

Binary Search

Search for the minimum possible maximum time

Greedy Check

For each time limit, check if feasible assignment exists

Optimal Solution

Find the minimum time where all grains can be collected

Key Takeaway

🎯 Key Insight: Binary search on the answer combined with greedy validation gives us the optimal O((n+m) × log(max_distance)) solution for this assignment optimization problem.

Asked in

G Google 42 a Amazon 38 f Meta 31 ⊞ Microsoft 28

The optimal solution uses binary search on the answer combined with a greedy validation approach. We binary search for the minimum time needed and for each candidate time, greedily check if it's possible to assign grains to hens such that each hen can collect their assigned grains within the time limit. The key insight is that each hen should take consecutive grains to minimize travel time, and we can validate assignments in O(n+m) time.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Assignments)	O(n^m)	O(m)	Try all possible ways to assign grains to hens
Binary Search + Greedy (Optimal)	O((n+m) * log(max_distance))	O(1)	Binary search on answer with greedy validation

Brute Force (Try All Assignments) — Algorithm Steps

Sort both hens and grains by position
Generate all possible ways to assign grains to hens
For each assignment, calculate the time each hen needs
Track the minimum of all maximum times across assignments

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort positions

Sort both hens and grains by position

Generate assignments

Try every way to assign grains to hens

Calculate times

For each assignment, calculate maximum time needed

Find minimum

Track the minimum of all maximum times

Code -

solution.c — C

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

int minTime = INT_MAX;

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int abs_val(int x) {
    return x < 0 ? -x : x;
}

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

int max(int a, int b) {
    return a > b ? a : b;
}

void backtrack(int grainIdx, int* hens, int hensSize, int* grains, int grainsSize, int** assignment, int* assignmentSizes) {
    if (grainIdx == grainsSize) {
        int maxTime = 0;
        for (int henIdx = 0; henIdx < hensSize; henIdx++) {
            if (assignmentSizes[henIdx] > 0) {
                int henPos = hens[henIdx];
                int leftmost = grains[assignment[henIdx][0]];
                int rightmost = grains[assignment[henIdx][assignmentSizes[henIdx]-1]];
                int timeNeeded = min(
                    abs_val(henPos - leftmost) + rightmost - leftmost,
                    abs_val(henPos - rightmost) + rightmost - leftmost
                );
                maxTime = max(maxTime, timeNeeded);
            }
        }
        minTime = min(minTime, maxTime);
        return;
    }
    
    for (int henIdx = 0; henIdx < hensSize; henIdx++) {
        assignment[henIdx][assignmentSizes[henIdx]] = grainIdx;
        assignmentSizes[henIdx]++;
        backtrack(grainIdx + 1, hens, hensSize, grains, grainsSize, assignment, assignmentSizes);
        assignmentSizes[henIdx]--;
    }
}

int minimumTimeToEatGrains(int* hens, int hensSize, int* grains, int grainsSize) {
    qsort(hens, hensSize, sizeof(int), compare);
    qsort(grains, grainsSize, sizeof(int), compare);
    
    int** assignment = malloc(hensSize * sizeof(int*));
    int* assignmentSizes = calloc(hensSize, sizeof(int));
    for (int i = 0; i < hensSize; i++) {
        assignment[i] = malloc(grainsSize * sizeof(int));
    }
    
    backtrack(0, hens, hensSize, grains, grainsSize, assignment, assignmentSizes);
    
    for (int i = 0; i < hensSize; i++) {
        free(assignment[i]);
    }
    free(assignment);
    free(assignmentSizes);
    
    return minTime;
}

int main() {
    int hens[] = {3, 6, 7};
    int grains[] = {2, 4, 7, 9};
    printf("%d\n", minimumTimeToEatGrains(hens, 3, grains, 4));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n^m)

We try all ways to assign m grains to n hens, leading to exponential combinations

✓ Linear Growth

Space Complexity

O(m)

Space for storing current assignment and calculating times

✓ Linear Space

48.2K Views

High 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

Brute Force (Try All Assignments) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler