Apple Redistribution into Boxes

Apple Redistribution into Boxes - Problem

You are given an array apple of size n and an array capacity of size m. There are n packs where the i^th pack contains apple[i] apples. There are m boxes as well, and the i^th box has a capacity of capacity[i] apples.

Return the minimum number of boxes you need to select to redistribute these n packs of apples into boxes. Note that, apples from the same pack can be distributed into different boxes.

Input & Output

Example 1 — Basic Case

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

› Output: 2

💡 Note: We need 1+3+2 = 6 apples total. Using boxes with capacity [5,4] gives us 9 capacity, which is enough. We need minimum 2 boxes.

Example 2 — Single Large Box

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

› Output: 4

💡 Note: Total apples = 15. Even the largest box (7) isn't enough alone. We need all boxes: 2+4+2+7 = 15.

Example 3 — Perfect Fit

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

› Output: 1

💡 Note: Total apples = 5. Single box with capacity 10 is more than enough.

Constraints

1 ≤ n, m ≤ 50
1 ≤ apple[i] ≤ 50
1 ≤ capacity[i] ≤ 50

Visualization

Tap to expand

Asked in

🍎 Apple 15 G Google 12 a Amazon 8

The key insight is to use a greedy approach: sort boxes by capacity in descending order and keep selecting the largest boxes until we have enough total capacity for all apples. Best approach is Greedy Algorithm with Time: O(n + m log m), Space: O(1)

Common Approaches

✓ Brute Force - Try All Combinations

⏱️ Time: O(2^m) Space: O(1)

Try every possible combination of boxes (2^m possibilities) and check if the total capacity is enough for all apples. Return the minimum number of boxes needed.

Greedy - Largest Boxes First

⏱️ Time: O(n + m log m) Space: O(1)

Calculate total apples needed, sort boxes by capacity in descending order, then greedily select the largest boxes first until the total capacity meets or exceeds the required space.

Brute Force - Try All Combinations — Algorithm Steps

Calculate total apples needed
Generate all 2^m subsets of boxes
For each subset, check if capacity >= total apples
Track minimum boxes among valid subsets

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Total

Sum all apples: 1+3+2 = 6

Try Subsets

Test combinations: {4}, {5}, {6}, {4,5}, {4,6}, {5,6}, {4,5,6}

Find Minimum

Smallest valid subset has 2 boxes: {4,5} with capacity 9 >= 6

Code -

solution.c — C

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

int solution(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 2^m subsets 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() {
    char line[1000];
    int apple[50], capacity[50];
    int appleSize = 0, capacitySize = 0;
    
    // Parse apple array
    fgets(line, sizeof(line), stdin);
    char* token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            apple[appleSize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    // Parse capacity array
    fgets(line, sizeof(line), stdin);
    token = strtok(line, "[,]");
    while (token != NULL) {
        if (token[0] >= '0' && token[0] <= '9') {
            capacity[capacitySize++] = atoi(token);
        }
        token = strtok(NULL, "[,]");
    }
    
    int result = solution(apple, appleSize, capacity, capacitySize);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(2^m)

Generate 2^m subsets of capacity array, each taking O(m) time to process

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track minimum and current subset capacity

✓ Linear Space

24.6K Views

Medium Frequency

~15 min Avg. Time

892 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