Fruits Into Baskets III - Practice Coding Problems

Fruits Into Baskets III - Problem

You are a warehouse manager organizing fruits into baskets with limited capacities. You have n different types of fruits and n baskets, each with specific capacity constraints.

Problem: Given two arrays fruits and baskets, where:

fruits[i] represents the quantity of the i-th type of fruit
baskets[j] represents the capacity of the j-th basket

Rules for placement:

Process fruits from left to right (index 0 to n-1)
Each fruit type must be placed in the leftmost available basket with sufficient capacity
Each basket can hold only one type of fruit
If no suitable basket exists, the fruit type remains unplaced

Goal: Return the number of fruit types that cannot be placed in any basket.

Example: If fruits = [3, 1, 4] and baskets = [2, 5, 1], then fruit type 0 (quantity 3) goes to basket 1 (capacity 5), fruit type 1 (quantity 1) goes to basket 2 (capacity 1), and fruit type 2 (quantity 4) cannot fit anywhere, so the answer is 1.

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Fruit 0 (qty 3) goes to basket 1 (capacity 5). Fruit 1 (qty 1) goes to basket 2 (capacity 1). Fruit 2 (qty 4) cannot fit in remaining basket 0 (capacity 2), so 1 fruit type remains unplaced.

example_2.py — All Fit

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

› Output: 0

💡 Note: Fruit 0 (qty 1) goes to basket 0 (capacity 3). Fruit 1 (qty 2) goes to basket 1 (capacity 2). Fruit 2 (qty 3) cannot fit in basket 2, but all fruits are placed, so 0 unplaced.

example_3.py — None Fit

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

› Output: 3

💡 Note: No fruit can fit in any basket since all fruit quantities exceed all basket capacities. All 3 fruit types remain unplaced.

Constraints

1 ≤ fruits.length ≤ 10⁵
baskets.length == fruits.length
1 ≤ fruits[i], baskets[i] ≤ 10⁹
Each basket can hold at most one type of fruit
Fruits must be processed in left-to-right order

Visualization

Tap to expand

Understanding the Visualization

Boxes Arrive

Fruits arrive on conveyor belt in order, each with a specific quantity

Find Leftmost Bin

For each box, find the leftmost available bin with sufficient capacity

Assign or Reject

If suitable bin found, assign box; otherwise, box remains unplaced

Key Takeaway

🎯 Key Insight: The challenge is efficiently finding the leftmost available basket with sufficient capacity. Advanced data structures like segment trees reduce this from O(n) per fruit to O(log n).

Asked in

G Google 45 a Amazon 38 ⊞ Microsoft 32 f Meta 25

This problem requires greedy assignment with leftmost preference. The brute force O(n²) approach works for small inputs, but the optimal solution uses segment trees or ordered sets to achieve O(n log n) complexity by efficiently finding the leftmost available basket with sufficient capacity.

Common Approaches

Approach	Time	Space	Notes
✓ Segment Tree / Ordered Set Optimization	O(n log n)	O(n)	Use advanced data structures to efficiently find leftmost available basket with sufficient capacity
Brute Force (Nested Loops)	O(n²)	O(n)	For each fruit, scan all baskets from left to right to find the first available one

Segment Tree / Ordered Set Optimization — Algorithm Steps

Create a segment tree or ordered set with basket indices sorted by capacity then by index
For each fruit, query the data structure to find leftmost available basket with sufficient capacity
Remove the selected basket from the data structure
If no suitable basket found, increment unplaced counter

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Data Structure

Create ordered set or segment tree with available baskets

Query Structure

For each fruit, query for leftmost suitable basket in O(log n)

Update Structure

Remove selected basket from data structure efficiently

Code -

solution.c — C

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

typedef struct {
    int capacity;
    int index;
} Basket;

int unplacedFruits(int* fruits, int* baskets, int n) {
    Basket* available = (Basket*)malloc(n * sizeof(Basket));
    int availableCount = n;
    
    for (int i = 0; i < n; i++) {
        available[i].capacity = baskets[i];
        available[i].index = i;
    }
    
    int unplaced = 0;
    
    for (int i = 0; i < n; i++) {
        int fruitQty = fruits[i];
        int foundIdx = -1;
        int leftmostIndex = n;
        
        for (int j = 0; j < availableCount; j++) {
            if (available[j].capacity >= fruitQty && available[j].index < leftmostIndex) {
                foundIdx = j;
                leftmostIndex = available[j].index;
            }
        }
        
        if (foundIdx == -1) {
            unplaced++;
        } else {
            // Remove basket by shifting array
            for (int k = foundIdx; k < availableCount - 1; k++) {
                available[k] = available[k + 1];
            }
            availableCount--;
        }
    }
    
    free(available);
    return unplaced;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Each fruit requires O(log n) time to find and remove suitable basket

⚡ Linearithmic

Space Complexity

O(n)

Space for the segment tree or ordered set structure

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~25 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

Segment Tree / Ordered Set Optimization — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler