Minimum Penalty for a Shop - Practice Coding Problems

Minimum Penalty for a Shop - Problem

You're a shop owner analyzing the optimal closing time to minimize financial penalties. Given a string customers representing hourly customer activity:

'Y' at position i means customers visited during hour i
'N' at position i means no customers came during hour i

If you close at hour j (meaning the shop is closed starting from hour j), you incur penalties:

+1 penalty for each hour you're open with no customers ('N')
+1 penalty for each hour you're closed when customers come ('Y')

Goal: Find the earliest hour to close that results in the minimum total penalty.

Example: For "YYNY", closing at hour 2 means you're open during hours 0,1 (penalty for hour 1's 'N') and closed during hours 2,3 (penalty for hour 3's 'Y'), giving total penalty = 2.

Input & Output

example_1.py — Basic Case

$ Input: customers = "YYNY"

› Output: 2

💡 Note: Closing at hour 2 means: open during hours 0,1 (penalty=1 for 'N' at hour 1), closed during hours 2,3 (penalty=1 for 'Y' at hour 3). Total penalty = 2, which is minimum.

example_2.py — No Customers

$ Input: customers = "NNNNN"

› Output: 0

💡 Note: Since no customers come at any hour, it's best to close immediately at hour 0 to avoid penalties for staying open with no customers. Penalty = 0.

example_3.py — Always Customers

$ Input: customers = "YYYY"

› Output: 4

💡 Note: Since customers come every hour, it's best to stay open all day and close at hour 4. Any earlier closing would incur penalties for missing customers.

Constraints

1 ≤ customers.length ≤ 10⁵
customers consists only of characters 'Y' and 'N'
The shop can close at any hour from 0 to n (inclusive)

Visualization

Tap to expand

Understanding the Visualization

Count missed customers

Start with penalty = total 'Y's (closing immediately)

Serve customers incrementally

For each 'Y' we serve by staying open, penalty decreases

Pay for empty hours

For each 'N' hour we stay open, penalty increases

Find the sweet spot

Return the earliest hour with minimum total penalty

Key Takeaway

🎯 Key Insight: Instead of recalculating penalties from scratch, track how the penalty *changes* as you shift closing time. Each customer served reduces penalty by 1, each empty hour endured increases it by 1.

Asked in

a Amazon 25 G Google 18 ⊞ Microsoft 15 f Meta 12

The optimal solution uses a prefix sum approach in O(n) time. Start with the penalty for closing at hour 0 (missing all customers), then incrementally update the penalty as you consider each later closing time. When moving from hour j to j+1: decrease penalty by 1 if customers[j] == 'Y' (we serve them), increase penalty by 1 if customers[j] == 'N' (we stay open unnecessarily). Track the minimum penalty and return the earliest hour achieving it.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Prefix Sum (Optimal)	O(n)	O(1)	Calculate penalty incrementally using running penalty changes
Brute Force (Try All Closing Times)	O(n²)	O(1)	Calculate penalty for every possible closing time from 0 to n

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Initialize penalty as total count of 'Y's (penalty for closing at hour 0)
For each hour j from 0 to n-1, calculate penalty for closing at hour j
Update penalty for closing at hour j+1: if customers[j] == 'Y', penalty--, else penalty++
Track minimum penalty and corresponding earliest hour
Return the hour with minimum penalty

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize

Start with penalty = count of all Y's (closing at hour 0)

Process each hour

For each hour, update penalty based on customer presence

Track minimum

Keep track of the minimum penalty seen so far

Return result

Return the earliest hour with minimum penalty

Code -

solution.c — C

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

int bestClosingTime(char* customers) {
    int n = strlen(customers);
    
    // Initial penalty: close at hour 0 (miss all customers)
    int penalty = 0;
    for (int i = 0; i < n; i++) {
        if (customers[i] == 'Y') penalty++;
    }
    
    int minPenalty = penalty;
    int bestHour = 0;
    
    // Try closing at each hour from 1 to n
    for (int hour = 0; hour < n; hour++) {
        // Update penalty for closing at hour+1 instead of hour
        if (customers[hour] == 'Y') {
            penalty--; // Serve this customer (reduce penalty)
        } else {
            penalty++; // Stay open for no customers (increase penalty)
        }
        
        // Check if this is better than current best
        if (penalty < minPenalty) {
            minPenalty = penalty;
            bestHour = hour + 1;
        }
    }
    
    return bestHour;
}

int main() {
    char customers[100001];
    scanf("%s", customers);
    
    // Remove quotes if present
    int len = strlen(customers);
    if (customers[0] == '"') {
        for (int i = 1; i < len - 1; i++) {
            customers[i-1] = customers[i];
        }
        customers[len-2] = '\0';
    }
    
    printf("%d\n", bestClosingTime(customers));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass to count initial Y's, then single pass to calculate all penalties

✓ Linear Growth

Space Complexity

O(1)

Only using a few variables to track penalty and result

✓ Linear Space

23.4K Views

Medium Frequency

~15 min Avg. Time

892 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

One-Pass Prefix Sum (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler