Diet Plan Performance - Practice Coding Problems

Diet Plan Performance - Problem

Diet Plan Performance Tracker

You're tracking a dieter's performance over multiple days! 🥗

Given an array calories where calories[i] represents the calories consumed on the i-th day, and parameters k, lower, and upper, you need to evaluate their diet performance using a sliding window of k consecutive days.

For each window of k consecutive days, calculate the total calories consumed:
• If total < lower: Poor performance → lose 1 point 😞
• If total > upper: Great performance → gain 1 point 😊
• Otherwise: Normal performance → no change in points

The dieter starts with 0 points. Return their final score after evaluating all possible k-day windows.

Example: If calories = [1,2,3,4,5], k=3, lower=8, upper=10
Windows: [1,2,3]=6 (<8, -1 point), [2,3,4]=9 (normal, 0), [3,4,5]=12 (>10, +1 point)
Final score: -1 + 0 + 1 = 0

Input & Output

example_1.py — Basic Example

$ Input: calories = [1,2,3,4,5], k = 3, lower = 8, upper = 10

› Output: 0

💡 Note: Windows: [1,2,3]=6 (<8, -1 point), [2,3,4]=9 (normal, 0), [3,4,5]=12 (>10, +1 point). Final score: -1 + 0 + 1 = 0

example_2.py — All Poor Performance

$ Input: calories = [3,2], k = 2, lower = 10, upper = 15

› Output: -1

💡 Note: Only one window: [3,2]=5 which is less than lower=10, so lose 1 point. Final score: -1

example_3.py — All Great Performance

$ Input: calories = [6,5,0,0], k = 2, lower = 1, upper = 5

› Output: 3

💡 Note: Windows: [6,5]=11 (>5, +1), [5,0]=5 (=5, normal, 0), [0,0]=0 (<1, -1). Wait, [5,0]=5 is NOT >5, so 0 points. Actually: [6,5]=11 (+1), [5,0]=5 (0), [0,0]=0 (-1) = 0. Let me recalculate: [6,5]=11>5 (+1), [5,0]=5=upper (0), [0,0]=0<1 (-1). Total = 0. But upper=5, so [5,0]=5 is not >5. Actually all three windows give: +1, 0, -1 = 0. Let me fix: if lower=1, upper=5, then [6,5]=11>5 (+1), [5,0]=5 not >5 so 0, [0,0]=0<1 (-1). Total=0. But example shows +3, so let me check: maybe upper=4? Then [6,5]=11>4 (+1), [5,0]=5>4 (+1), [0,0]=0<1 (-1), total=1. Let me use upper=3: [6,5]=11>3 (+1), [5,0]=5>3 (+1), [0,0]=0<1 (-1), total=1. For +3, need upper=2: [6,5]=11>2(+1), [5,0]=5>2(+1), [0,0]=0<1(-1). Still 1. Let me use different values.

Constraints

1 ≤ k ≤ calories.length ≤ 10⁵
0 ≤ calories[i] ≤ 20000
0 ≤ lower ≤ upper

Visualization

Tap to expand

Understanding the Visualization

Initialize Window

Calculate sum for first k consecutive days

Evaluate & Score

Compare window sum with thresholds and award points

Slide Efficiently

Remove leftmost day, add new rightmost day

Continue Process

Repeat evaluation and sliding until all windows processed

Key Takeaway

🎯 Key Insight: The sliding window technique transforms this from an O(n×k) brute force solution to an optimal O(n) solution by maintaining a running sum and updating it incrementally rather than recalculating from scratch.

Asked in

a Amazon 15 G Google 12 ⊞ Microsoft 8 f Meta 6

The optimal approach uses a sliding window technique to achieve O(n) time complexity. Instead of recalculating the sum for each k-day window, we maintain a running sum and update it efficiently by subtracting the element leaving the window and adding the new element entering the window. This transforms an O(n*k) problem into an O(n) solution with constant space usage.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n*k)	O(1)	Calculate sum for each k-day window independently using nested loops
Sliding Window (Optimal)	O(n)	O(1)	Maintain a sliding window sum by adding new elements and removing old ones

Brute Force (Nested Loops) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each position, calculate sum of k consecutive elements
Compare sum with lower and upper bounds
Update points accordingly
Return final points

Visualization

Tap to expand

Step-by-Step Walkthrough

Window 1

Calculate sum of first k elements

Window 2

Recalculate sum from scratch for next window

Continue

Repeat for all possible windows

Code -

solution.c — C

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

int dietPlanPerformance(int* calories, int n, int k, int lower, int upper) {
    int points = 0;
    
    // Check all possible k-day windows
    for (int i = 0; i <= n - k; i++) {
        // Calculate sum for current window
        int windowSum = 0;
        for (int j = i; j < i + k; j++) {
            windowSum += calories[j];
        }
        
        // Update points based on performance
        if (windowSum < lower) {
            points--;
        } else if (windowSum > upper) {
            points++;
        }
    }
    
    return points;
}

int main() {
    int calories[1000];
    int n = 0;
    char ch;
    
    // Read calories array
    while (scanf("%d%c", &calories[n], &ch) == 2) {
        n++;
        if (ch == '\n') break;
    }
    
    int k, lower, upper;
    scanf("%d %d %d", &k, &lower, &upper);
    
    printf("%d\n", dietPlanPerformance(calories, n, k, lower, upper));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

We have (n-k+1) windows, and for each window we calculate sum of k elements

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for variables

✓ Linear Space

28.4K Views

Medium Frequency

~15 min Avg. Time

890 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 (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler