Find Good Days to Rob the Bank - Practice Coding Problems

Find Good Days to Rob the Bank - Problem

You and your gang are planning to rob a bank! 🏦 To ensure a successful heist, you need to carefully analyze the security patterns over time.

You're given an array security where security[i] represents the number of guards on duty on day i. You also have a parameter time that defines your observation window.

A day is considered "good" for robbing if:

There are at least time days before AND after this day (so you have enough data)
For the time days leading up to this day, security is non-increasing (guards are getting lazy or leaving)
For the time days after this day, security is non-decreasing (guards are ramping back up)

In other words, you want to rob when security is at a local minimum with consistent patterns on both sides!

Goal: Return all the good days to rob the bank (0-indexed). The order doesn't matter.

Input & Output

example_1.py — Basic Valley Pattern

$ Input: security = [5,3,3,3,5,6,2], time = 2

› Output: [2, 3]

💡 Note: Day 2: Security goes 5→3→3→3→5→6 (decreasing then increasing). Day 3: Security goes 3→3→3→3→5→6 (non-increasing then non-decreasing). Both satisfy the 2-day time window requirement.

example_2.py — No Valid Days

$ Input: security = [1,1,1,1,1], time = 0

› Output: [0, 1, 2, 3, 4]

💡 Note: With time=0, we only need to check the day itself. Since all days have equal security (satisfying both non-increasing and non-decreasing with length 0), all days are valid.

example_3.py — Insufficient Length

$ Input: security = [1,2,3,4,5,6], time = 2

› Output: []

💡 Note: The array is strictly increasing, so no day has a non-increasing period before it (except the edges, but they don't have enough buffer days). No valid robbery days exist.

Constraints

1 ≤ security.length ≤ 10⁵
0 ≤ security[i], time ≤ 10⁵
The array represents guard counts per day
Days are 0-indexed

Visualization

Tap to expand

Understanding the Visualization

Map the Terrain

Security levels form peaks and valleys over time

Find Downward Slopes

Count consecutive decreasing security days

Find Upward Slopes

Count consecutive increasing security days

Identify Valley Floors

Days where both slopes meet the time requirement

Key Takeaway

🎯 Key Insight: Instead of checking each day's neighborhood repeatedly, build a map of all slope directions first, then quickly identify where stable valleys occur!

Asked in

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

The optimal approach uses two-pass precomputation to build streak information efficiently. Instead of checking each day's neighborhood repeatedly (O(n×time)), we precompute decreasing and increasing streak lengths in O(n) time. This transforms the problem from repeated neighborhood scanning to simple array lookups, achieving optimal linear time complexity.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Precomputation (Dynamic Programming)	O(n)	O(n)	Precompute decreasing/increasing streak lengths, then find valid intersections
Brute Force (Check Every Day)	O(n * time)	O(1)	For each day, check if the time-window before is non-increasing and after is non-decreasing

Two-Pass Precomputation (Dynamic Programming) — Algorithm Steps

First pass: For each day, count consecutive non-increasing days ending here
Second pass: For each day, count consecutive non-decreasing days starting here
Final pass: Check if both counts >= time for each valid day position
Collect all days that satisfy both conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

Pass 1: Decreasing Streaks

Count consecutive non-increasing days ending at each position

Pass 2: Increasing Streaks

Count consecutive non-decreasing days starting from each position

Find Intersections

Identify days where both streak lengths >= time

Code -

solution.c — C

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

int* goodDaysToRobBank(int* security, int securitySize, int time, int* returnSize) {
    *returnSize = 0;
    if (securitySize < 2 * time + 1) {
        return NULL;
    }
    
    // First pass: count non-increasing streaks ending at each position
    int* decreasing = (int*)calloc(securitySize, sizeof(int));
    for (int i = 1; i < securitySize; i++) {
        if (security[i] <= security[i-1]) {
            decreasing[i] = decreasing[i-1] + 1;
        }
    }
    
    // Second pass: count non-decreasing streaks starting from each position
    int* increasing = (int*)calloc(securitySize, sizeof(int));
    for (int i = securitySize-2; i >= 0; i--) {
        if (security[i] <= security[i+1]) {
            increasing[i] = increasing[i+1] + 1;
        }
    }
    
    // Find valid days
    int* result = (int*)malloc(securitySize * sizeof(int));
    for (int i = time; i < securitySize - time; i++) {
        if (decreasing[i] >= time && increasing[i] >= time) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(decreasing);
    free(increasing);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three linear passes: one for decreasing streaks, one for increasing streaks, one to find results

✓ Linear Growth

Space Complexity

O(n)

Two arrays to store the precomputed streak lengths

⚡ Linearithmic Space

48.0K Views

Medium Frequency

~18 min Avg. Time

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

Two-Pass Precomputation (Dynamic Programming) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler