How Many Apples Can You Put into the Basket

How Many Apples Can You Put into the Basket - Problem

You're helping at a farmers market and have a basket that can carry up to 5000 units of weight. In front of you are several apples, each with different weights, and you want to maximize the number of apples you can fit in your basket.

Given an integer array weight where weight[i] represents the weight of the i-th apple, return the maximum number of apples you can put in the basket without exceeding the weight limit.

Goal: Maximize the count of apples, not the total weight.

Example: If you have apples with weights [100, 200, 150, 1000] and your basket capacity is 5000, you should pick the lighter apples first: [100, 200, 150] gives you 3 apples with total weight 450, which is better than picking the heavy apple [1000] which only gives you 1 apple.

Input & Output

example_1.py — Basic Case

$ Input: [100, 200, 150, 1000]

› Output: 3

💡 Note: We can pick apples with weights 100, 200, and 150. Total weight = 450 ≤ 5000, and we get 3 apples. We cannot include the 1000-weight apple as it would make the total 1450, which is still ≤ 5000, but picking the three lighter apples gives us more apples total.

example_2.py — All Fit

$ Input: [900, 950, 800, 1000, 700, 800]

› Output: 5

💡 Note: Sorted: [700, 800, 800, 900, 950, 1000]. We can pick 700+800+800+900+950 = 4150 ≤ 5000, giving us 5 apples. Adding the last apple (1000) would make it 5150 > 5000.

example_3.py — Single Heavy Apple

$ Input: [4000, 3000, 1500]

› Output: 2

💡 Note: Sorted: [1500, 3000, 4000]. We can pick 1500+3000 = 4500 ≤ 5000, giving us 2 apples. We cannot add the 4000-weight apple as it would exceed the limit.

Constraints

1 ≤ weight.length ≤ 10⁴
1 ≤ weight[i] ≤ 10⁴
Basket capacity is always 5000

Visualization

Tap to expand

Understanding the Visualization

Sort by Weight

Arrange all apples from lightest to heaviest - this ensures we consider the most 'efficient' choices first

Greedy Selection

Pick apples one by one starting from the lightest, as long as they fit in our basket

Stop at Limit

As soon as adding the next apple would exceed our capacity, stop and return the count

Key Takeaway

🎯 Key Insight: For maximizing count with weight constraints, greedy selection of lightest items first is always optimal. The intuition is simple: lighter items leave more room for additional items.

Asked in

a Amazon 45 G Google 32 ⊞ Microsoft 28 Apple 15

The optimal solution uses a greedy approach: sort the apple weights in ascending order, then greedily select the lightest apples first until the basket capacity is reached. This maximizes the number of apples rather than the total weight. Time complexity: O(n log n) for sorting, Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Greedy Approach (Sort + Count)	O(n log n)	O(1)	Sort apples by weight and greedily pick the lightest ones first
Brute Force (Try All Combinations)	O(2^n)	O(n)	Generate all possible combinations and find the one with maximum count

Greedy Approach (Sort + Count) — Algorithm Steps

Sort the apple weights in ascending order
Initialize total weight and count to 0
Iterate through sorted weights from lightest to heaviest
For each apple, check if adding it would exceed the limit
If not, add the apple and increment count
Return the final count

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort by Weight

Arrange apples from lightest to heaviest

Pick Greedily

Add apples one by one starting from the lightest

Check Capacity

Stop when adding the next apple would exceed the limit

Return Count

The number of apples successfully added

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return (*(int*)a - *(int*)b);
}

int numPointsInTarget(int* weight, int n) {
    // Sort weights in ascending order
    qsort(weight, n, sizeof(int), compare);
    
    int totalWeight = 0;
    int count = 0;
    
    // Greedily pick lightest apples first
    for (int i = 0; i < n; i++) {
        if (totalWeight + weight[i] <= 5000) {
            totalWeight += weight[i];
            count++;
        } else {
            break; // Can't add any more apples
        }
    }
    
    return count;
}

int main() {
    int weight[] = {100, 200, 150, 1000};
    int n = 4;
    printf("%d\n", numPointsInTarget(weight, n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n log n)

Sorting takes O(n log n), and the greedy selection takes O(n)

⚡ Linearithmic

Space Complexity

O(1)

Only uses constant extra space (if we sort in-place)

✓ Linear Space

28.5K Views

Medium Frequency

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

Greedy Approach (Sort + Count) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler