Find Beautiful Indices in the Given Array II

Find Beautiful Indices in the Given Array II - Problem

You're tasked with finding beautiful indices in a string - a fascinating pattern matching challenge!

Given a string s, two pattern strings a and b, and an integer k, an index i is considered beautiful if:

Pattern Match: The substring starting at index i matches pattern a
Proximity Condition: There exists another index j where pattern b appears, and the distance between i and j is at most k

Your goal is to return all beautiful indices in sorted order.

Example: If s = "isawsquirrelsaw", a = "saw", b = "sq", and k = 6, then index 2 is beautiful because "saw" appears at index 2, "sq" appears at index 5, and |2-5| = 3 ≤ 6.

Input & Output

example_1.py — Basic Case

$ Input: s = "isawsquirrelsaw", a = "saw", b = "sq", k = 6

› Output: [2, 11]

💡 Note: Pattern 'saw' appears at indices 2 and 11. Pattern 'sq' appears at index 5. For index 2: |2-5| = 3 ≤ 6, so it's beautiful. For index 11: |11-5| = 6 ≤ 6, so it's also beautiful.

example_2.py — No Beautiful Indices

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

› Output: [0]

💡 Note: Pattern 'a' appears only at index 0. Since both patterns are the same, the distance is |0-0| = 0 ≤ 4, making index 0 beautiful.

example_3.py — Distance Constraint

$ Input: s = "aba", a = "a", b = "a", k = 1

› Output: [0, 2]

💡 Note: Pattern 'a' appears at indices 0 and 2. For index 0: distance to index 2 is |0-2| = 2 > 1, but distance to itself is 0 ≤ 1. For index 2: distance to index 0 is 2 > 1, but distance to itself is 0 ≤ 1. Both are beautiful.

Visualization

Tap to expand

Understanding the Visualization

Scan for Primary Patterns

Find all occurrences of pattern 'a' in the string - these are potential beautiful indices

Locate Secondary Patterns

Find all occurrences of pattern 'b' - these provide the proximity validation

Check Proximity Constraint

For each pattern 'a' occurrence, verify if any pattern 'b' is within distance k

Collect Beautiful Indices

Indices that satisfy both pattern match and proximity constraints are beautiful

Key Takeaway

🎯 Key Insight: The algorithm transforms a quadratic proximity search into efficient pattern preprocessing plus logarithmic lookups, making it scalable for large inputs while maintaining correctness.

Time & Space Complexity

Time Complexity

⏱️

O(n + m + p)

O(n) pattern finding + O(m + p) two-pointer traversal where m,p are pattern occurrence counts

✓ Linear Growth

Space Complexity

O(m + p)

Space to store pattern occurrences

✓ 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
Pattern lengths are much smaller than string length

Asked in

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

The optimal approach uses pattern preprocessing combined with binary search or two pointers to efficiently find beautiful indices. Key insight: instead of checking every position repeatedly, we first find all pattern occurrences, then use efficient search techniques to check proximity constraints in O(log n) or O(1) time per query.

Common Approaches

Approach	Time	Space	Notes
✓ Two Pointers with Sorted Arrays	O(n + m + p)	O(m + p)	Sort pattern occurrences and use two pointers to efficiently find matches within distance k
Brute Force (Nested Pattern Search)	O(n³)	O(1)	Find all pattern 'a' matches, then for each, scan entire string for nearby pattern 'b' matches
Pattern Preprocessing + Binary Search	O(n + m log m)	O(m)	Preprocess both patterns to find all occurrences, then use binary search for efficient proximity checking

Two Pointers with Sorted Arrays — Algorithm Steps

Find all occurrences of pattern 'a' and pattern 'b'
Sort both occurrence lists (pattern 'a' is naturally sorted)
Initialize two pointers: one for 'a' occurrences, one for 'b' occurrences
For each 'a' occurrence, advance 'b' pointer to find valid matches within distance k
Add 'a' index to result if any valid 'b' match found

Visualization

Tap to expand

Step-by-Step Walkthrough

Initialize Pointers

Set pointer i for pattern 'a' and pointer j for pattern 'b'

Advance Pointer j

Move j to first position where b[j] >= a[i] - k

Check Range

Verify if b[j] <= a[i] + k to confirm it's within distance k

Move to Next

Advance pointer i to next pattern 'a' occurrence

Code -

solution.c — C

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

int* findPatternOccurrences(char* text, char* pattern, int* count) {
    int textLen = strlen(text);
    int patternLen = strlen(pattern);
    int* occurrences = malloc(textLen * sizeof(int));
    *count = 0;
    
    for (int i = 0; i <= textLen - patternLen; i++) {
        if (strncmp(text + i, pattern, patternLen) == 0) {
            occurrences[(*count)++] = i;
        }
    }
    
    return occurrences;
}

int* beautifulIndices(char* s, char* a, char* b, int k, int* returnSize) {
    int aCount, bCount;
    int* aOccurrences = findPatternOccurrences(s, a, &aCount);
    int* bOccurrences = findPatternOccurrences(s, b, &bCount);
    
    if (bCount == 0) {
        *returnSize = 0;
        free(aOccurrences);
        free(bOccurrences);
        return malloc(sizeof(int));  // Return empty array
    }
    
    int* beautiful = malloc(aCount * sizeof(int));
    *returnSize = 0;
    int j = 0;  // pointer for bOccurrences
    
    for (int idx = 0; idx < aCount; idx++) {
        int i = aOccurrences[idx];
        
        // Reset j to find the first valid position for current i
        j = 0;
        while (j < bCount && bOccurrences[j] < i - k) {
            j++;
        }
        
        // Check if any b occurrence is within range [i-k, i+k]
        if (j < bCount && bOccurrences[j] <= i + k) {
            beautiful[(*returnSize)++] = i;
        }
    }
    
    free(aOccurrences);
    free(bOccurrences);
    return beautiful;
}

int main() {
    char s[100001], a[101], b[101];
    int k;
    scanf("%s %s %s %d", s, a, b, &k);
    
    int returnSize;
    int* result = beautifulIndices(s, a, b, k, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(", ");
    }
    printf("]\n");
    
    free(result);
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n + m + p)

O(n) pattern finding + O(m + p) two-pointer traversal where m,p are pattern occurrence counts

✓ Linear Growth

Space Complexity

O(m + p)

Space to store pattern occurrences

✓ 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
Pattern lengths are much smaller than string length

28.4K Views

Medium-High Frequency

~25 min Avg. Time

856 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 Pointers with Sorted Arrays — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler