Fruits Into Baskets III

Fruits Into Baskets III - Problem

You are given two arrays of integers, fruits and baskets, each of length n, where fruits[i] represents the quantity of the i-th type of fruit, and baskets[j] represents the capacity of the j-th basket.

From left to right, place the fruits according to these rules:

Each fruit type must be placed in the leftmost available basket with a capacity greater than or equal to the quantity of that fruit type.
Each basket can hold only one type of fruit.
If a fruit type cannot be placed in any basket, it remains unplaced.

Return the number of fruit types that remain unplaced after all possible allocations are made.

Input & Output

Example 1 — Basic Case

$ Input: fruits = [4,2,1], baskets = [5,1,3]

› Output: 0

💡 Note: Fruit 4 goes to basket 5 (index 0), fruit 2 goes to basket 3 (index 2), fruit 1 goes to basket 1 (index 1). All fruits are placed.

Example 2 — Some Unplaced

$ Input: fruits = [3,3,3], baskets = [3,1,1]

› Output: 2

💡 Note: First fruit 3 goes to basket 3 (index 0). Second and third fruits cannot be placed as remaining baskets have capacity 1 < 3.

Example 3 — All Unplaced

$ Input: fruits = [5,5], baskets = [1,2]

› Output: 2

💡 Note: No basket has sufficient capacity (5) for any fruit, so both remain unplaced.

Constraints

1 ≤ n ≤ 10⁵
1 ≤ fruits[i], baskets[i] ≤ 10⁹

Visualization

Tap to expand

Asked in

G Google 45 A Amazon 38 M Microsoft 32

The key insight is to efficiently find the leftmost available basket with sufficient capacity for each fruit. The brute force approach scans all baskets for each fruit in O(n²). An optimized approach can use binary search after sorting baskets, though we still need to find the leftmost among candidates. Best approach: Time O(n²), Space O(n).

Common Approaches

✓ Brute Force - Linear Search

⏱️ Time: O(n²) Space: O(n)

Iterate through each fruit type and for each one, scan through all baskets from left to right to find the first available basket with sufficient capacity. Mark used baskets to avoid reuse.

Optimized with Sorted Baskets

⏱️ Time: O(n² log n) Space: O(n)

Create pairs of (capacity, original_index) and sort by capacity. For each fruit, use binary search to find the smallest available basket that can hold it, then mark as used.

Brute Force - Linear Search — Algorithm Steps

Iterate through each fruit type
For each fruit, scan baskets from left to right
Find first available basket with capacity >= fruit quantity
Mark basket as used or count as unplaced

Visualization

Tap to expand

Step-by-Step Walkthrough

Process Fruit 1

Scan baskets left to right for first fit

Process Fruit 2

Scan remaining baskets for next fruit

Count Unplaced

Return number of fruits that couldn't be placed

Code -

solution.c — C

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

int parseArray(char* line, int* arr) {
    int size = 0;
    int i = 0;
    int len = strlen(line);
    
    while (i < len) {
        // Skip non-digit characters except minus sign
        while (i < len && !isdigit(line[i]) && line[i] != '-') {
            i++;
        }
        
        if (i < len) {
            int num = 0;
            int sign = 1;
            
            if (line[i] == '-') {
                sign = -1;
                i++;
            }
            
            while (i < len && isdigit(line[i])) {
                num = num * 10 + (line[i] - '0');
                i++;
            }
            
            arr[size++] = sign * num;
        }
    }
    
    return size;
}

int solution(int* fruits, int fruitsSize, int* baskets, int basketsSize) {
    // Track which baskets are used (1 = used, 0 = available)
    int used[1000] = {0};
    int unplaced = 0;
    
    // For each fruit type (from left to right)
    for (int i = 0; i < fruitsSize; i++) {
        int fruitQuantity = fruits[i];
        int placed = 0;
        
        // Find leftmost available basket with sufficient capacity
        for (int j = 0; j < basketsSize; j++) {
            if (!used[j] && baskets[j] >= fruitQuantity) {
                used[j] = 1;  // Mark basket as used
                placed = 1;
                break;
            }
        }
        
        if (!placed) {
            unplaced++;
        }
    }
    
    return unplaced;
}

int main() {
    char line1[10000], line2[10000];
    fgets(line1, sizeof(line1), stdin);
    fgets(line2, sizeof(line2), stdin);
    
    int fruits[1000], baskets[1000];
    int fruitsSize = 0, basketsSize = 0;
    
    // Parse fruits array
    fruitsSize = parseArray(line1, fruits);
    
    // Parse baskets array
    basketsSize = parseArray(line2, baskets);
    
    printf("%d\n", solution(fruits, fruitsSize, baskets, basketsSize));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n fruits, we potentially scan through all n baskets

⚠ Quadratic Growth

Space Complexity

O(n)

Boolean array to track which baskets are used

⚡ Linearithmic Space

23.0K Views

Medium Frequency

~25 min Avg. Time

890 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 - Linear Search — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler