Grumpy Bookstore Owner - Practice Coding Problems

Grumpy Bookstore Owner - Problem

🛍️ The Grumpy Bookstore Owner Problem

You're helping optimize customer satisfaction at a local bookstore! The owner runs their shop for n minutes each day, but has a bit of a grumpiness problem.

Here's the situation:

📊 customers[i] = number of customers entering at minute i
😤 grumpy[i] = 1 means the owner is grumpy at minute i, 0 means they're friendly
😊 Happy owner = satisfied customers
😡 Grumpy owner = unsatisfied customers (they leave upset!)

The secret technique: The owner knows a special meditation method to stay calm for minutes consecutive minutes, but can only use it once per day.

Your goal: Find the maximum number of customers that can be satisfied by strategically timing when to use the meditation technique!

Input & Output

example_1.py — Basic Example

$ Input: customers = [1,0,1,2,1,1,7,5], grumpy = [0,1,0,1,1,1,0,1], minutes = 3

› Output: 16

💡 Note: The bookstore owner keeps themselves not grumpy for minutes = 3. Maximum customers = 1 + 1 + 1 + 1 + 7 + 5 = 16. We use technique on minutes [3,4,5] to satisfy customers: 2+1+1=4 additional.

example_2.py — All Grumpy

$ Input: customers = [4,8,2,6], grumpy = [1,1,1,1], minutes = 2

› Output: 14

💡 Note: Owner is grumpy all day. Best strategy is to use technique on the 2 consecutive minutes with most customers: positions [0,1] with 4+8=12 customers, or [1,2] with 8+2=10, or [2,3] with 2+6=8. Choose [0,1] for total 14.

example_3.py — Never Grumpy

$ Input: customers = [2,3,4,1], grumpy = [0,0,0,0], minutes = 2

› Output: 10

💡 Note: Owner is never grumpy, so all customers are always satisfied regardless of when the technique is used. Total = 2+3+4+1 = 10.

Constraints

1 ≤ customers.length ≤ 2 × 10⁴
0 ≤ customers[i] ≤ 1000
grumpy.length == customers.length
grumpy[i] is either 0 or 1
1 ≤ minutes ≤ customers.length
The technique can only be used once during the day

Visualization

Tap to expand

Understanding the Visualization

Identify Baseline

Count customers already satisfied (when owner isn't grumpy)

Find Optimal Window

Locate the consecutive time period with most grumpy-minute customers

Apply Technique

Use the meditation technique during this optimal window

Calculate Total

Add baseline satisfaction + gained satisfaction from technique

Key Takeaway

🎯 Key Insight: The sliding window technique lets us efficiently find the optimal time period to maximize the conversion of unsatisfied customers to satisfied ones, achieving O(n) time complexity instead of O(n×k) brute force.

Asked in

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

The optimal approach uses a sliding window technique to efficiently find the best consecutive time period to apply the meditation technique. We calculate the baseline satisfaction (when owner isn't grumpy), then find the window that maximizes additional customers that would be satisfied if the owner used the technique during that period. Time complexity: O(n), Space complexity: O(1).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Try All Windows)	O(n×k)	O(1)	Try every possible consecutive window of size 'minutes' to see which gives maximum satisfaction
Sliding Window (Optimal)	O(n)	O(1)	Use sliding window technique to efficiently find the best consecutive minutes to apply the technique

Brute Force (Try All Windows) — Algorithm Steps

Calculate baseline satisfied customers (when owner is not grumpy)
For each possible starting position of the technique window:
- Calculate additional customers that would be satisfied in this window
- Keep track of the maximum additional satisfaction possible
Return baseline + maximum additional satisfaction

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Baseline

Sum customers when owner is not grumpy

Try Window at Position 0

Calculate additional satisfied customers in first window

Try Window at Position 1

Move window right and recalculate

Continue for All Positions

Test every valid window position

Return Best Result

Baseline + maximum additional from any window

Code -

solution.c — C

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

int maxSatisfied(int* customers, int* grumpy, int customersSize, int minutes) {
    int baseline = 0;
    
    // Calculate baseline satisfaction
    for (int i = 0; i < customersSize; i++) {
        if (grumpy[i] == 0) {
            baseline += customers[i];
        }
    }
    
    int maxAdditional = 0;
    
    // Try every possible window position
    for (int start = 0; start <= customersSize - minutes; start++) {
        int additional = 0;
        for (int i = start; i < start + minutes; i++) {
            if (grumpy[i] == 1) {
                additional += customers[i];
            }
        }
        if (additional > maxAdditional) {
            maxAdditional = additional;
        }
    }
    
    return baseline + maxAdditional;
}

int main() {
    // Implementation for input parsing required
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n×k)

We try n-k+1 possible starting positions, and for each position we sum k elements

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track current and maximum satisfaction

✓ Linear Space

52.0K Views

Medium Frequency

~15 min Avg. Time

1.9K 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

🛍️ The Grumpy Bookstore Owner Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force (Try All Windows) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler