Fruits Into Baskets II - Practice Coding Problems

Fruits Into Baskets II - Problem

Array Binary Search Segment Tree Simulation Ordered Set Easy

Fruits Into Baskets II

🍎🧺 Welcome to the fruit packing challenge! You're managing a fruit warehouse where you need to efficiently pack different types of fruits into baskets.

You have n different types of fruits and n baskets available. Each fruit type has a specific quantity that needs to be stored, and each basket has a specific capacity.

Packing Rules:
• Process fruits from left to right (index 0 to n-1)
• Each fruit type must go into the leftmost available basket that can hold it
• A basket can hold a fruit type only if: basket_capacity >= fruit_quantity
• Each basket can hold exactly one type of fruit
• Once a basket is used, it's no longer available

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

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

Input & Output

example_1.py — Basic Case

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

› Output: 1

💡 Note: Fruit 0 (qty=3) → Basket 0 (cap=5) ✓. Fruit 1 (qty=2) → Basket 2 (cap=3) ✓. Fruit 2 (qty=4) → No suitable basket ✗. Result: 1 unplaced fruit.

example_2.py — Perfect Match

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

› Output: 0

💡 Note: Fruit 0 (qty=1) → Basket 0 (cap=3) ✓. Fruit 1 (qty=2) → Basket 1 (cap=2) ✓. Fruit 2 (qty=3) → No baskets left ✗. Wait... Fruit 0 goes to leftmost suitable (Basket 0), Fruit 1 goes to leftmost remaining suitable (Basket 1), Fruit 2 has no options. Actually result is 1, not 0.

example_3.py — All Unplaced

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

› Output: 3

💡 Note: No fruit can fit in any basket since all fruits have quantities larger than any basket capacity. All 3 fruits remain unplaced.

Visualization

Tap to expand

Understanding the Visualization

Guest Arrival

Guests arrive in order and must be assigned to the first available suitable room

Room Search

For each guest group, find the leftmost room that can accommodate them

Assignment

Assign the group to the room and mark it as occupied

Final Count

Count how many guest groups couldn't be accommodated

Key Takeaway

🎯 Key Insight: The challenge is efficiently finding the leftmost available room (basket) that can accommodate each guest group (fruit), which requires smart data structures for optimal performance.

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n fruits, we potentially check all n baskets in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Only need boolean array to track used baskets

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ fruits[i] ≤ 10⁹
0 ≤ baskets[i] ≤ 10⁹
fruits.length == baskets.length

Asked in

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

The optimal approach uses sorting with binary search to efficiently find the leftmost suitable basket for each fruit. Sort baskets by capacity while preserving indices, then for each fruit use binary search to find suitable baskets and select the one with the smallest original index. Time complexity: O(n log n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n²)	O(n)	For each fruit, linearly search through all baskets to find the first available one
Sorting + Binary Search (Optimal)	O(n log n)	O(n)	Sort baskets with indices, use binary search to find leftmost suitable basket

Brute Force (Nested Loops) — Algorithm Steps

Create a boolean array to track which baskets are used
For each fruit type from left to right
Search through baskets from left to right
Find first unused basket with capacity >= fruit quantity
Mark that basket as used and move to next fruit
Count fruits that couldn't be placed

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with all baskets available

Process Fruit 0

Search baskets 0,1,2... until suitable one found

Mark Used

Mark the selected basket as used

Repeat

Continue for remaining fruits

Code -

solution.c — C

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

int solution(int* fruits, int* baskets, int n) {
    bool* used = (bool*)calloc(n, sizeof(bool));
    int unplaced = 0;
    
    for (int i = 0; i < n; i++) {
        bool placed = false;
        for (int j = 0; j < n; j++) {
            if (!used[j] && baskets[j] >= fruits[i]) {
                used[j] = true;
                placed = true;
                break;
            }
        }
        if (!placed) {
            unplaced++;
        }
    }
    
    free(used);
    return unplaced;
}

int main() {
    // Parse input and call solution
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n fruits, we potentially check all n baskets in worst case

⚠ Quadratic Growth

Space Complexity

O(n)

Only need boolean array to track used baskets

⚡ Linearithmic Space

Constraints

1 ≤ n ≤ 10⁵
0 ≤ fruits[i] ≤ 10⁹
0 ≤ baskets[i] ≤ 10⁹
fruits.length == baskets.length

28.4K Views

Medium Frequency

~18 min Avg. Time

856 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler