Diet Plan Performance

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: 3

💡 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. Total = +3

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

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
✓ Sliding Window	O(n)	O(1)	Efficiently maintain window sum by sliding one element at a time
Brute Force	O(n×k)	O(1)	Calculate sum for each k-day window separately

Sliding Window — Algorithm Steps

Calculate sum of first k elements
For each new position, remove left element and add right element
Compare updated sum with bounds and update points

Visualization

Tap to expand

Step-by-Step Walkthrough

Initial Window

Calculate first k-day window sum

Slide Window

Remove left element, add right element

Update Score

Compare updated sum and adjust 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;
    
    // Calculate sum of first window
    int windowSum = 0;
    for (int i = 0; i < k; i++) {
        windowSum += calories[i];
    }
    
    // Check first window
    if (windowSum < lower) {
        points--;
    } else if (windowSum > upper) {
        points++;
    }
    
    // Slide the window
    for (int i = k; i < caloriesSize; i++) {
        // Remove leftmost element, add new rightmost element
        windowSum = windowSum - calories[i - k] + calories[i];
        
        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)

Single pass through array, each element added and removed once

✓ 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

Sliding Window — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler