Find All Good Indices - Practice Coding Problems

Find All Good Indices - Problem

Imagine you're analyzing a financial time series where you need to find stable pivot points - moments where the trend was declining before and rising after.

Given a 0-indexed integer array nums of size n and a positive integer k, your task is to find all "good indices" that represent these stable points.

An index i is considered good if k ≤ i < n - k and both conditions are met:

The k elements immediately before index i are in non-increasing order (declining or stable)
The k elements immediately after index i are in non-decreasing order (rising or stable)

Goal: Return an array of all good indices sorted in increasing order.

Example: For nums = [2,1,1,1,3,4,1], k = 2, index 3 is good because the 2 elements before it [1,1] are non-increasing and the 2 elements after it [3,4] are non-decreasing.

Input & Output

example_1.py — Basic Case

$ Input: nums = [2,1,1,1,3,4,1], k = 2

› Output: [3]

💡 Note: Index 3 is the only good index. The 2 elements before it [1,1] are non-increasing, and the 2 elements after it [3,4] are non-decreasing.

example_2.py — Multiple Good Indices

$ Input: nums = [2,1,1,2], k = 2

› Output: []

💡 Note: No valid indices exist. The only potential candidate would be at index 2, but we need k=2 elements before and after, which requires array length ≥ 2*2+1 = 5.

example_3.py — Edge Case Small k

$ Input: nums = [1,1,1,1,1], k = 1

› Output: [1,2,3]

💡 Note: Indices 1, 2, and 3 are all good. For each: 1 element before is non-increasing (≤), and 1 element after is non-decreasing (≥).

Visualization

Tap to expand

Track Descents: Count consecutive non-increasing elements ending at each position2. Track Ascents: Count consecutive non-decreasing elements starting at each position3. Find Valleys: Identify positions where both counts ≥ k

Understanding the Visualization

Identify Pattern

Look for valley-like patterns where descent transitions to ascent

Precompute Descents

For each position, track how long the descent has been continuing

Precompute Ascents

For each position, track how long the ascent will continue

Find Intersections

Good indices are where both descent and ascent lengths meet the k requirement

Key Takeaway

🎯 Key Insight: Instead of checking k elements repeatedly, precompute sequence lengths to find valley patterns efficiently in linear time

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three linear passes through the array

✓ Linear Growth

Space Complexity

O(n)

Two additional arrays to store precomputed lengths

⚡ Linearithmic Space

Constraints

n == nums.length
3 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ n / 2
Valid range: k ≤ i < n - k must be non-empty

Asked in

G Google 45 a Amazon 38 f Meta 22 ⊞ Microsoft 31

The optimal approach uses two-pass precomputation to efficiently identify good indices. First, compute the length of non-increasing sequences ending at each position. Second, compute the length of non-decreasing sequences starting at each position. Finally, find indices where both conditions are satisfied with length ≥ k. This achieves O(n) time complexity and O(n) space complexity, much better than the O(n*k) brute force approach.

Common Approaches

Approach	Time	Space	Notes
✓ Two-Pass Precomputation	O(n)	O(n)	Precompute non-increasing and non-decreasing lengths, then find intersections
Brute Force (Check Each Index)	O(n*k)	O(1)	For each potential good index, check k elements before and after

Two-Pass Precomputation — Algorithm Steps

First pass: For each index, calculate length of non-increasing sequence ending there
Second pass: For each index, calculate length of non-decreasing sequence starting there
Third pass: Check each valid index i where both sequences have length ≥ k
Collect all indices that satisfy both conditions

Visualization

Tap to expand

Step-by-Step Walkthrough

First Pass

Calculate non-increasing sequence lengths ending at each position

Second Pass

Calculate non-decreasing sequence lengths starting at each position

Find Intersections

Identify positions where both conditions are satisfied

Code -

solution.c — C

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

int* goodIndices(int* nums, int numsSize, int k, int* returnSize) {
    *returnSize = 0;
    if (numsSize < 2 * k + 1) {
        return NULL;
    }
    
    int* nonIncreasing = (int*)malloc(numsSize * sizeof(int));
    int* nonDecreasing = (int*)malloc(numsSize * sizeof(int));
    int* result = (int*)malloc(numsSize * sizeof(int));
    
    // Initialize arrays
    for (int i = 0; i < numsSize; i++) {
        nonIncreasing[i] = 1;
        nonDecreasing[i] = 1;
    }
    
    // Precompute non-increasing lengths
    for (int i = 1; i < numsSize; i++) {
        if (nums[i] <= nums[i-1]) {
            nonIncreasing[i] = nonIncreasing[i-1] + 1;
        }
    }
    
    // Precompute non-decreasing lengths
    for (int i = numsSize-2; i >= 0; i--) {
        if (nums[i] <= nums[i+1]) {
            nonDecreasing[i] = nonDecreasing[i+1] + 1;
        }
    }
    
    // Find good indices
    for (int i = k; i < numsSize - k; i++) {
        if (nonIncreasing[i-1] >= k && nonDecreasing[i+1] >= k) {
            result[(*returnSize)++] = i;
        }
    }
    
    free(nonIncreasing);
    free(nonDecreasing);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Three linear passes through the array

✓ Linear Growth

Space Complexity

O(n)

Two additional arrays to store precomputed lengths

⚡ Linearithmic Space

Constraints

n == nums.length
3 ≤ n ≤ 10⁵
1 ≤ nums[i] ≤ 10⁶
1 ≤ k ≤ n / 2
Valid range: k ≤ i < n - k must be non-empty

89.2K Views

Medium Frequency

~25 min Avg. Time

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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Two-Pass Precomputation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler