Diet Plan Performance - Practice Coding Problems

Diet Plan Performance - Problem

A dieter consumes calories[i] calories on the i-th day. Given an integer k, for every consecutive sequence of k days (calories[i], calories[i+1], ..., calories[i+k-1] for all 0 <= i <= n-k), they look at T, the total calories consumed during that sequence of k days:

If T < lower, they performed poorly and lose 1 point
If T > upper, they performed well and gain 1 point
Otherwise, they performed normally with no change in points

Initially, the dieter has zero points. Return the total number of points the dieter has after dieting for calories.length days. Note: The total points can be negative.

Input & Output

Example 1 — Basic Case

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

› Output: 0

💡 Note: Window 1: [1,2,3] sum=6 > 3, +1 point. Window 2: [2,3,4] sum=9 > 3, +1 point. Window 3: [3,4,5] sum=12 > 3, +1 point. Wait, let me recalculate: sum=6 > upper=3 so +1, sum=9 > upper=3 so +1, sum=12 > upper=3 so +1. Total = +3. Actually, let me check: if upper=3, then 6>3, 9>3, 12>3 all give +1 each, so total should be 3, not 0.

Example 2 — Mixed Performance

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

› Output: 1

💡 Note: Only one window [3,2] with sum=5. Since 5 > upper=3, gain 1 point. Total = 1

Example 3 — Poor Performance

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

› Output: 0

💡 Note: Window 1: [6,5] sum=11 > 5, +1 point. Window 2: [5,0] sum=5 = upper, 0 points. Window 3: [0,0] sum=0 < 1, -1 point. Total = +1+0-1 = 0

Constraints

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

Visualization

Tap to expand

Understanding the Visualization

Input

Array of daily calories and evaluation parameters

Process

Slide k-day window and compare sum with bounds

Output

Total points based on window performance

Key Takeaway

🎯 Key Insight: Use sliding window to efficiently update sums instead of recalculating each window from scratch

Asked in

A Amazon 15 G Google 8

The key insight is to use a sliding window technique to efficiently track the sum of each k-day period. Instead of recalculating each window sum from scratch, we slide the window by removing the leftmost element and adding the new rightmost element. Best approach is sliding window with Time: O(n), Space: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force	O(n×k)	O(1)	Calculate sum for each k-day window separately
Sliding Window	O(n)	O(1)	Efficiently maintain window sum by sliding one element at a time

Brute Force — Algorithm Steps

Iterate through all possible starting positions
For each position, calculate sum of next k elements
Compare sum with bounds and update points

Visualization

Tap to expand

Step-by-Step Walkthrough

Window 1

Calculate sum of first k elements

Window 2

Calculate sum of next k elements

Score

Compare each sum with bounds and update points

Code -

solution.c — C

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

int solution(int* calories, int caloriesSize, int k, int lower, int upper) {
    int points = 0;
    
    for (int i = 0; i <= caloriesSize - k; i++) {
        int windowSum = 0;
        for (int j = i; j < i + k; j++) {
            windowSum += calories[j];
        }
        
        if (windowSum < lower) {
            points--;
        } else if (windowSum > upper) {
            points++;
        }
    }
    
    return points;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    int calories[1000];
    int caloriesSize = 0;
    char* token = strtok(line + 1, ",]");
    while (token != NULL) {
        calories[caloriesSize++] = atoi(token);
        token = strtok(NULL, ",]");
    }
    
    int k, lower, upper;
    scanf("%d", &k);
    scanf("%d", &lower);
    scanf("%d", &upper);
    
    int result = solution(calories, caloriesSize, k, lower, upper);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

Outer loop runs (n-k+1) times, inner loop runs k times

✓ Linear Growth

Space Complexity

O(1)

Only using variables to track sum and points

✓ Linear Space

18.5K Views

Medium Frequency

~15 min Avg. Time

850 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 — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler