Apple Redistribution into Boxes - Practice Coding Problems

Apple Redistribution into Boxes - Problem

Apple Redistribution into Boxes

Imagine you're a warehouse manager who needs to pack apples into shipping boxes efficiently! 📦🍎

You have n packs of apples, where the i-th pack contains apple[i] apples. You also have m boxes available, where the i-th box can hold up to capacity[i] apples.

Your goal is to find the minimum number of boxes needed to store all the apples. The good news is that you can split apples from the same pack across different boxes if needed!

Example: If you have packs with [1, 3, 2] apples and boxes with capacities [4, 3, 1, 5, 2], you'd want to use the largest boxes first (capacity 5 and 4) to minimize the total number of boxes used.

Return the minimum number of boxes required to redistribute all apples.

Input & Output

example_1.py — Basic Case

$ Input: apple = [1,3,2], capacity = [4,3,1,5,2]

› Output: 2

💡 Note: We need 6 apples total. Sort boxes: [5,4,3,2,1]. Take box with capacity 5 (need 1 more), then box with capacity 4 (total 9 ≥ 6). Answer: 2 boxes.

example_2.py — Single Large Box

$ Input: apple = [5,5,5], capacity = [2,4,2,7]

› Output: 4

💡 Note: We need 15 apples total. Sort boxes: [7,4,2,2]. Take all: 7+4+2+2=15 exactly. Answer: 4 boxes.

example_3.py — Minimum Case

$ Input: apple = [1], capacity = [100]

› Output: 1

💡 Note: We need 1 apple total. One box with capacity 100 is more than enough. Answer: 1 box.

Constraints

1 ≤ n ≤ 50 (number of apple packs)
1 ≤ m ≤ 50 (number of boxes)
1 ≤ apple[i] ≤ 50 (apples in each pack)
1 ≤ capacity[i] ≤ 50 (capacity of each box)
The sum of all capacities will always be ≥ sum of all apples

Visualization

Tap to expand

Understanding the Visualization

Count All Apples

First, calculate the total volume of apples that need to be packed

Sort Boxes by Size

Arrange all available boxes from largest to smallest capacity

Fill Largest First

Start filling the largest boxes first - this minimizes waste and total box count

Stop When Full

Continue until the total capacity meets or exceeds the apple count

Key Takeaway

🎯 Key Insight: The greedy approach works because taking larger boxes first never hurts - it either uses the same number or fewer boxes than any other strategy.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 f Meta 15

The optimal solution uses a greedy approach: sort boxes by capacity in descending order, then select the largest boxes first until all apples fit. This works because using larger capacity boxes always minimizes the total count needed. Time: O(m log m), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Combinations)	O(2^m)	O(m)	Try all possible subsets of boxes to find minimum count that can hold all apples
Greedy with Sorting (Optimal)	O(m log m)	O(1)	Sort boxes by capacity descending, then greedily fill largest boxes first

Brute Force (Try All Combinations) — Algorithm Steps

Calculate total apples needed
Generate all possible subsets of boxes
For each subset, check if total capacity >= total apples
Keep track of minimum subset size that works
Return the minimum count

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total

Sum all apples: 1+3+2 = 6 apples total

Try Combinations

Test subsets: {5}, {4,3}, {5,4}, etc.

Check Capacity

Does this combination hold ≥6 apples?

Track Minimum

Keep the smallest working combination

Code -

solution.c — C

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

int minimumBoxes(int* apple, int appleSize, int* capacity, int capacitySize) {
    int totalApples = 0;
    for (int i = 0; i < appleSize; i++) {
        totalApples += apple[i];
    }
    
    int minBoxes = INT_MAX;
    
    // Try all possible combinations of boxes
    for (int mask = 1; mask < (1 << capacitySize); mask++) {
        int boxesUsed = 0;
        int totalCapacity = 0;
        
        for (int i = 0; i < capacitySize; i++) {
            if (mask & (1 << i)) {
                boxesUsed++;
                totalCapacity += capacity[i];
            }
        }
        
        if (totalCapacity >= totalApples) {
            if (boxesUsed < minBoxes) {
                minBoxes = boxesUsed;
            }
        }
    }
    
    return minBoxes;
}

int main() {
    int apple[] = {1, 3, 2};
    int capacity[] = {4, 3, 1, 5, 2};
    printf("%d\n", minimumBoxes(apple, 3, capacity, 5));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

We need to check all 2^m possible combinations of boxes

✓ Linear Growth

Space Complexity

O(m)

Space for recursion stack and storing current combination

✓ Linear Space

42.3K Views

Medium Frequency

~12 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 Combinations) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler