Maximum Number of Eaten Apples - Practice Coding Problems

Maximum Number of Eaten Apples - Problem

Imagine owning a magical apple tree that grows fresh apples daily for n consecutive days! 🌳🍎

Here's how it works: On day i, your tree produces apples[i] fresh apples, but there's a catch - these apples will rot after exactly days[i] days. This means apples grown on day i must be consumed by day i + days[i] - 1 (inclusive), or they become inedible.

Your goal: Eat the maximum number of apples possible following these rules:
• You can eat at most 1 apple per day (doctor's orders!) 👩‍⚕️
• You can continue eating even after the tree stops producing (beyond day n)
• Some days the tree might not produce any apples (apples[i] = 0 and days[i] = 0)

Strategy is key: Should you eat the freshest apples first, or save the longer-lasting ones for later? The choice determines how many apples you can enjoy before they spoil!

Input & Output

example_1.py — Basic Case

$ Input: apples = [1,2,3,5,2], days = [3,2,1,4,2]

› Output: 7

💡 Note: Day 0: eat 1 apple from day 0 batch (expires day 3). Day 1: eat 1 apple from day 2 batch (expires day 2). Day 2: eat 1 apple from day 1 batch (expires day 3). Day 3: eat 1 apple from day 0 batch (expires day 3). Day 4: eat 1 apple from day 3 batch (expires day 7). Day 5: eat 1 apple from day 4 batch (expires day 6). Day 6: eat 1 apple from day 4 batch (expires day 6). Total: 7 apples.

example_2.py — Single Apple

$ Input: apples = [3,0,0,0,0,2], days = [3,0,0,0,0,2]

› Output: 5

💡 Note: Day 0-2: eat the 3 apples from day 0 (expire day 3). Days 3-4: no apples available. Day 5-6: eat the 2 apples from day 5 (expire day 7). Total: 5 apples.

example_3.py — Edge Case

$ Input: apples = [1,10,17,10,12,6,2,12,3,2,2,5,16,2,9,11,15], days = [8,19,1,1,18,20,9,8,8,7,14,14,15,14,15,3,15]

› Output: 71

💡 Note: This complex case requires careful prioritization of apples by expiration date to maximize consumption before spoilage occurs.

Constraints

n == apples.length == days.length
1 ≤ n ≤ 2 × 10⁴
0 ≤ apples[i] ≤ 2 × 10⁴
0 ≤ days[i] ≤ 2 × 10⁴
If apples[i] == 0, then days[i] == 0

Visualization

Tap to expand

Understanding the Visualization

Receive Daily Delivery

Each morning, receive new apples with specific expiration dates

Organize by Priority

Arrange apples by expiration date - soonest to expire at front

Remove Spoiled Items

Throw away any apples that have already expired

Eat/Sell Most Urgent

Choose one apple from the batch expiring soonest

Update Inventory

Reorganize remaining apples and repeat tomorrow

Key Takeaway

🎯 Key Insight: The greedy approach of always eating apples that expire soonest guarantees maximum consumption because it prevents early spoilage and makes room for future apples.

Asked in

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

The optimal solution uses a greedy strategy with a min-heap. The key insight is to always eat apples that expire soonest to minimize waste. We maintain a priority queue ordered by expiration date, and each day we: add new apples, remove expired ones, and eat from the batch expiring first. Time complexity: O(n log n), Space: O(n).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force Simulation	O(n²)	O(n)	Simulate each day by checking all available apples and picking one
Greedy with Priority Queue (Optimal)	O(n log n)	O(n)	Use min-heap to always eat the apple that expires soonest

Brute Force Simulation — Algorithm Steps

For each day from 0 to potentially very large number
Add new apples (if any) to our available list
Remove all expired apple batches
If any apples remain, eat one and increment counter
Continue until no apples are available

Visualization

Tap to expand

Step-by-Step Walkthrough

Add New Apples

On each day, add newly grown apples to our collection

Remove Expired

Check each apple batch and remove those that have rotted

Eat One Apple

If any apples remain, choose one arbitrarily and eat it

Continue Until Empty

Repeat until no more apples are available

Code -

solution.c — C

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

typedef struct {
    int expiry;
    int count;
} Batch;

int eatenApples(int* apples, int applesSize, int* days, int daysSize) {
    int n = applesSize;
    Batch available[20000];
    int availableSize = 0;
    int result = 0;
    int day = 0;
    
    while (day < n || availableSize > 0) {
        // Add new apples if within bounds
        if (day < n && apples[day] > 0) {
            int expiry = day + days[day];
            available[availableSize++] = (Batch){expiry, apples[day]};
        }
        
        // Remove expired apples
        int newSize = 0;
        for (int i = 0; i < availableSize; i++) {
            if (available[i].expiry > day) {
                available[newSize++] = available[i];
            }
        }
        availableSize = newSize;
        
        // Eat one apple if available
        if (availableSize > 0) {
            for (int i = 0; i < availableSize; i++) {
                if (available[i].count > 0) {
                    available[i].count--;
                    result++;
                    break;
                }
            }
            // Remove empty batches
            newSize = 0;
            for (int i = 0; i < availableSize; i++) {
                if (available[i].count > 0) {
                    available[newSize++] = available[i];
                }
            }
            availableSize = newSize;
        }
        
        day++;
        
        // Prevent infinite loop
        if (day > n + 20000) break;
    }
    
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

For each of potentially O(n) days, we may scan through O(n) apple batches

⚠ Quadratic Growth

Space Complexity

O(n)

Store all apple batches that haven't expired yet

⚡ Linearithmic Space

28.5K Views

Medium-High Frequency

~25 min Avg. Time

980 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

Brute Force Simulation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler