Find Beautiful Indices in the Given Array I

Find Beautiful Indices in the Given Array I - Problem

You are given a 0-indexed string s, two pattern strings a and b, and an integer k representing the maximum allowed distance.

Your task is to find all "beautiful indices" in the string. An index i is considered beautiful if:

The substring starting at index i matches pattern a exactly
There exists at least one index j where the substring starting at j matches pattern b exactly
The distance between indices i and j is at most k (i.e., |i - j| ≤ k)

Goal: Return all beautiful indices in sorted ascending order.

Example: If s = "isawsquirrelnearmyhouse", a = "saw", b = "house", and k = 15, then index 2 is beautiful because s[2:5] = "saw" matches pattern a, and s[19:24] = "house" matches pattern b, with distance |19 - 2| = 17 ≤ 15 being false, but there might be other valid j positions.

Input & Output

example_1.py — Basic Case

$ Input: s = "isawsquirrelnearmyhouse", a = "saw", b = "house", k = 15

› Output: [2]

💡 Note: Pattern 'saw' is found at index 2. Pattern 'house' is found at index 19. Since |19 - 2| = 17 > 15, this doesn't satisfy the distance constraint. However, if there were other 'house' occurrences within distance 15, index 2 would be beautiful.

example_2.py — Multiple Matches

$ Input: s = "abcd", a = "a", b = "c", k = 4

› Output: [0]

💡 Note: Pattern 'a' is found at index 0. Pattern 'c' is found at index 2. Since |2 - 0| = 2 ≤ 4, index 0 is beautiful.

example_3.py — No Valid Indices

$ Input: s = "a", a = "aa", b = "aaa", k = 1

› Output: []

💡 Note: Neither pattern 'aa' nor pattern 'aaa' can be found in string 's' = 'a', so there are no beautiful indices.

Visualization

Tap to expand

Understanding the Visualization

Scan for Pattern A

Find all positions where pattern 'a' appears in the string

Scan for Pattern B

Find all positions where pattern 'b' appears in the string

Distance Check

For each 'a' position, use binary search to check if any 'b' position is within distance k

Collect Results

Gather all 'a' positions that have a nearby 'b' position

Key Takeaway

🎯 Key Insight: Pre-computing all pattern positions and using binary search for range queries transforms an O(n³) problem into an efficient O(n*m + |A|*log|B|) solution

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to check all pairs of positions, O(n) for substring comparison in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the result array, no additional data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ a.length, b.length ≤ 10
0 ≤ k ≤ s.length
s, a, and b consist only of lowercase English letters

Asked in

G Google 35 a Amazon 28 ⊞ Microsoft 22 f Meta 18

The optimal approach uses a two-pass strategy with binary search. First, we identify all positions where patterns 'a' and 'b' occur in the string. Then, for each 'a' position, we use binary search to efficiently find if any 'b' position exists within the distance constraint k. This reduces the time complexity from O(n³) brute force to O(n*m + |A|*log|B|) where m is the pattern length.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Nested Loops)	O(n³)	O(1)	Find all pattern 'a' matches, then for each one check all possible pattern 'b' matches within distance k
Two-Pass with Binary Search	O(nm + \|A\|log\|B\|)	O(\|A\| + \|B\|)	First find all pattern matches, then use binary search to efficiently check distance constraints

Brute Force (Nested Loops) — Algorithm Steps

Iterate through each position i in string s
Check if substring starting at i matches pattern a
If match found, iterate through each position j in string s
Check if substring starting at j matches pattern b
If both patterns match and |i - j| ≤ k, mark i as beautiful
Return all beautiful indices in sorted order

Visualization

Tap to expand

Step-by-Step Walkthrough

Check Position i

Check if pattern 'a' matches at position i

Search for Pattern B

If 'a' matches, search entire string for pattern 'b'

Distance Check

For each 'b' match, check if distance |i-j| ≤ k

Code -

solution.c — C

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

int* beautifulIndices(char* s, char* a, char* b, int k, int* returnSize) {
    int* beautiful = malloc(1000 * sizeof(int));
    *returnSize = 0;
    int n = strlen(s);
    int lenA = strlen(a), lenB = strlen(b);
    
    // Find all positions where pattern 'a' matches
    for (int i = 0; i <= n - lenA; i++) {
        if (strncmp(s + i, a, lenA) == 0) {
            // For each 'a' match, check if there's a 'b' match within distance k
            int foundB = 0;
            for (int j = 0; j <= n - lenB; j++) {
                if (strncmp(s + j, b, lenB) == 0 && abs(i - j) <= k) {
                    foundB = 1;
                    break;
                }
            }
            if (foundB) {
                beautiful[(*returnSize)++] = i;
            }
        }
    }
    
    return beautiful;
}

Time & Space Complexity

Time Complexity

⏱️

O(n³)

O(n²) to check all pairs of positions, O(n) for substring comparison in worst case

⚠ Quadratic Growth

Space Complexity

O(1)

Only storing the result array, no additional data structures

✓ Linear Space

Constraints

1 ≤ s.length ≤ 10⁵
1 ≤ a.length, b.length ≤ 10
0 ≤ k ≤ s.length
s, a, and b consist only of lowercase English letters

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

Brute Force (Nested Loops) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler