Minimum Penalty for a Shop

Minimum Penalty for a Shop - Problem

You are given the customer visit log of a shop represented by a 0-indexed string customers consisting only of characters 'N' and 'Y':

If the i^th character is 'Y', it means that customers come at the i^th hour
If the i^th character is 'N', it means that no customers come at the i^th hour

If the shop closes at the j^th hour (0 ≤ j ≤ n), the penalty is calculated as follows:

For every hour when the shop is open and no customers come, the penalty increases by 1
For every hour when the shop is closed and customers come, the penalty increases by 1

Return the earliest hour at which the shop must be closed to incur a minimum penalty.

Note: If a shop closes at the j^th hour, it means the shop is closed at the hour j.

Input & Output

Example 1 — Basic Case

$ Input: customers = "YYNY"

› Output: 2

💡 Note: Closing at hour 2 gives penalty of 1: open during hours 0,1 (both Y, no penalty) and closed during hours 2,3 (one Y at hour 3, penalty=1)

Example 2 — All Customers

$ Input: customers = "YYYY"

› Output: 4

💡 Note: Best to stay open all hours (close at hour 4): no penalty for being open with customers, penalty=0

Example 3 — No Customers

$ Input: customers = "NNNN"

› Output: 0

💡 Note: Best to close immediately (hour 0): no penalty for being closed when no customers come, penalty=0

Constraints

1 ≤ customers.length ≤ 10⁵
customers consists only of characters 'Y' and 'N'

Visualization

Tap to expand

Asked in

a Amazon 15 G Google 12 M Microsoft 8

The key insight is that as we move the closing hour from left to right, the penalty changes predictably: -1 for each 'Y' we include in open hours, +1 for each 'N'. The optimal approach uses this to calculate penalties in O(n) time by starting with all hours closed and incrementally opening each hour. Time: O(n), Space: O(1)

Common Approaches

✓ Brute Force

⏱️ Time: O(n²) Space: O(1)

For each possible closing hour j, count penalties from being open during 'N' hours (0 to j-1) and being closed during 'Y' hours (j to n-1). Track the minimum penalty and earliest closing hour.

Prefix Sum Optimization

⏱️ Time: O(n) Space: O(1)

Instead of recalculating penalties for each closing hour, we observe that moving closing time from hour i to i+1 removes one 'N' penalty (if customers[i] = 'N') and adds one 'Y' penalty (if customers[i] = 'Y'). We can calculate the initial penalty and then adjust incrementally.

Brute Force — Algorithm Steps

Step 1: Try each closing hour from 0 to n
Step 2: For each hour, count 'N's before closing and 'Y's after closing
Step 3: Track minimum penalty and return earliest hour with minimum penalty

Visualization

Tap to expand

Step-by-Step Walkthrough

Try Each Hour

Test closing at hour 0, 1, 2, ..., n

Count Penalties

For each hour: count N's before + Y's after

Find Minimum

Return earliest hour with minimum penalty

Code -

solution.c — C

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

int solution(char* customers) {
    int n = strlen(customers);
    int minPenalty = INT_MAX;
    int bestHour = 0;
    
    // Try each closing hour from 0 to n
    for (int closeHour = 0; closeHour <= n; closeHour++) {
        int penalty = 0;
        
        // Count penalty for open hours (0 to closeHour-1)
        for (int i = 0; i < closeHour; i++) {
            if (customers[i] == 'N') {
                penalty++;
            }
        }
        
        // Count penalty for closed hours (closeHour to n-1)
        for (int i = closeHour; i < n; i++) {
            if (customers[i] == 'Y') {
                penalty++;
            }
        }
        
        // Update minimum penalty and best hour
        if (penalty < minPenalty) {
            minPenalty = penalty;
            bestHour = closeHour;
        }
    }
    
    return bestHour;
}

int main() {
    char customers[100001];
    fgets(customers, sizeof(customers), stdin);
    customers[strcspn(customers, "\n")] = 0;
    
    int result = solution(customers);
    printf("%d\n", result);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Outer loop tries n+1 closing hours, inner loop counts penalties in O(n) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra variables for counters and minimum tracking

✓ Linear Space

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

Brute Force — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler