Fruit Into Baskets - Practice Coding Problems

Fruit Into Baskets - Problem

Imagine you're visiting a fruit orchard where trees are arranged in a single row from left to right. Each tree produces one type of fruit, represented by an integer in the array fruits where fruits[i] is the fruit type of the i-th tree.

You want to maximize your fruit collection, but there are strict rules:

🧺 You have exactly two baskets
🍎 Each basket can only hold one type of fruit
📦 Each basket has unlimited capacity for its fruit type
➡️ You must start at any tree and move only to the right
🛑 You must stop when you encounter a third fruit type

Goal: Find the maximum number of fruits you can collect following these rules.

Example: For [1,2,1], you can collect all 3 fruits (types 1 and 2 fit in your two baskets).

Input & Output

example_1.py — Basic Case

$ Input: [1,2,1]

› Output: 3

💡 Note: We can collect all fruits: start at index 0, collect fruit type 1, then 2, then 1 again. Both types fit in our two baskets, so we get 3 fruits total.

example_2.py — Multiple Types

$ Input: [0,1,2,2]

› Output: 3

💡 Note: We can start at index 1 and collect [1,2,2]. This gives us 3 fruits with only 2 types (1 and 2). Starting at index 0 would only give us [0,1] = 2 fruits before hitting the third type.

example_3.py — Single Type

$ Input: [1,2,3,2,2]

› Output: 4

💡 Note: The optimal collection is [2,3,2,2] starting from index 1, which gives us 4 fruits with types 2 and 3. Any other starting position gives fewer fruits.

Visualization

Tap to expand

Understanding the Visualization

Start collecting

Begin with empty baskets and start collecting fruits from left to right

Expand collection

Keep collecting fruits as long as you have at most 2 different types

Handle third type

When you encounter a third fruit type, you must abandon some fruits from the left to make room

Track maximum

Throughout the process, remember the largest collection you've achieved

Key Takeaway

🎯 Key Insight: This is essentially finding the longest contiguous subarray with at most 2 distinct elements - a perfect use case for the sliding window technique!

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each element is visited at most twice (once by right pointer, once by left pointer), making it linear time

✓ Linear Growth

Space Complexity

O(1)

HashMap stores at most 3 fruit types (temporarily when contracting window), which is constant space

✓ Linear Space

Constraints

1 ≤ fruits.length ≤ 10⁵
0 ≤ fruits[i] < fruits.length
Follow-up: Can you solve this in O(n) time?

Asked in

a Amazon 42 G Google 38 f Meta 31 ⊞ Microsoft 25

The optimal solution uses a sliding window technique with HashMap to track fruit types and their counts. We maintain a window with at most 2 fruit types by expanding the right boundary and contracting the left boundary when necessary. This achieves O(n) time complexity and is the preferred approach for interviews.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Subarrays)	O(n²)	O(1)	Try every possible starting position and extend as far as possible
Sliding Window with HashMap (Optimal)	O(n)	O(1)	Use sliding window technique to maintain at most 2 fruit types efficiently

Brute Force (Try All Subarrays) — Algorithm Steps

For each starting position i from 0 to n-1
Initialize a set to track fruit types and counter for fruits collected
From position i, move right collecting fruits
Stop when we encounter a third fruit type
Update the maximum fruits collected

Visualization

Tap to expand

Step-by-Step Walkthrough

Start at position 0

Begin collecting fruits from the first tree, tracking fruit types

Extend window

Move right, adding fruits until hitting a third type

Record result

Save the count of fruits collected from this starting position

Next start

Move to next starting position and repeat the process

Code -

solution.c — C

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

int totalFruit(int* fruits, int n) {
    int maxFruits = 0;
    
    // Try every starting position
    for (int start = 0; start < n; start++) {
        int fruitTypes[100001] = {0}; // Assuming fruit types are within reasonable range
        int typeCount = 0;
        int currentFruits = 0;
        
        // Extend from current start position
        for (int end = start; end < n; end++) {
            if (fruitTypes[fruits[end]] == 0) {
                fruitTypes[fruits[end]] = 1;
                typeCount++;
            }
            
            // If we have more than 2 fruit types, stop
            if (typeCount > 2) {
                break;
            }
            
            currentFruits++;
            if (currentFruits > maxFruits) {
                maxFruits = currentFruits;
            }
        }
    }
    
    return maxFruits;
}

int main() {
    int fruits[100000];
    int n = 0;
    char line[1000000];
    fgets(line, sizeof(line), stdin);
    
    char* token = strtok(line, " ");
    while (token != NULL) {
        fruits[n++] = atoi(token);
        token = strtok(NULL, " ");
    }
    
    printf("%d\n", totalFruit(fruits, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of n starting positions, we potentially scan the remaining elements, giving us O(n) × O(n) = O(n²)

⚠ Quadratic Growth

Space Complexity

O(1)

Only using a small set to track fruit types and a few variables for counting

✓ Linear Space

Constraints

1 ≤ fruits.length ≤ 10⁵
0 ≤ fruits[i] < fruits.length
Follow-up: Can you solve this in O(n) time?

34.4K Views

High Frequency

~18 min Avg. Time

1.5K 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 (Try All Subarrays) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler