Codestin Search App

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
✓ 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)	O(n²)	O(1)	Try every possible starting position and extend as far as possible

Sliding Window with HashMap (Optimal) — Algorithm Steps

Initialize left and right pointers, and a HashMap to count fruit types
Expand window by moving right pointer and adding fruits to HashMap
If we have more than 2 fruit types, contract window from left
Remove fruits from left until we have at most 2 types
Track maximum window size throughout the process

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize window

Set left=0, right=0, and empty HashMap for fruit counts

Expand window

Move right pointer and add fruits to HashMap

Contract if needed

When >2 fruit types, move left pointer and update counts

Track maximum

Record the largest valid window size seen so far

Code -

solution.c — C

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

int totalFruit(int* fruits, int n) {
    if (n == 0) return 0;
    
    int left = 0;
    int maxFruits = 0;
    int fruitCount[100001] = {0}; // Assuming reasonable fruit type range
    int typeCount = 0;
    
    for (int right = 0; right < n; right++) {
        // Add current fruit to window
        if (fruitCount[fruits[right]] == 0) {
            typeCount++;
        }
        fruitCount[fruits[right]]++;
        
        // Contract window if more than 2 fruit types
        while (typeCount > 2) {
            fruitCount[fruits[left]]--;
            if (fruitCount[fruits[left]] == 0) {
                typeCount--;
            }
            left++;
        }
        
        // Update maximum fruits collected
        int currentFruits = right - left + 1;
        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)

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?

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

Sliding Window with HashMap (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler