Find All Anagrams in a String

Find All Anagrams in a String - Problem

Given two strings s and p, return an array of all the start indices of p's anagrams in s. You may return the answer in any order.

An anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.

Input & Output

Example 1 — Basic Case

$ Input: s = "cbaebabacd", p = "ab"

› Output: [1,4,5,6]

💡 Note: The anagrams of "ab" in "cbaebabacd" start at indices 1 ("ba"), 4 ("ba"), 5 ("ab"), and 6 ("ba"). All of these substrings are anagrams of "ab".

Example 2 — Multiple Matches

$ Input: s = "abab", p = "ab"

› Output: [0,1,2]

💡 Note: Anagrams start at indices 0 ("ab"), 1 ("ba"), and 2 ("ab"). All substrings of length 2 form anagrams of "ab".

Example 3 — No Matches

$ Input: s = "xyz", p = "ab"

› Output: []

💡 Note: No substring of length 2 in "xyz" can form an anagram of "ab" since the characters don't match.

Constraints

1 ≤ s.length, p.length ≤ 3 × 10⁴
s and p consist of lowercase English letters only

Visualization

Tap to expand

Asked in

f Facebook 35 a Amazon 28 G Google 22 M Microsoft 18

The key insight is that anagrams have identical character frequencies. The optimal sliding window approach maintains frequency counts while sliding through the string, achieving O(n) time complexity. Time: O(n), Space: O(1).

Common Approaches

✓ Brute Force with Sorting

⏱️ Time: O(n × m × log m) Space: O(m)

For each position in string s, extract a substring of length p and check if it's an anagram by sorting both strings and comparing them.

Frequency Count Comparison

⏱️ Time: O(n × m) Space: O(m)

Build frequency maps for the pattern and each substring of the same length, then compare the frequency counts to determine if they form anagrams.

Sliding Window with Frequency Count

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

Use a sliding window of size equal to pattern length. Maintain frequency counts and slide the window by adding the new character and removing the old character, checking for anagram matches.

Brute Force with Sorting — Algorithm Steps

Step 1: Sort pattern string p
Step 2: For each position i in s, extract substring of length p
Step 3: Sort the substring and compare with sorted p
Step 4: If they match, add index i to result

Visualization

Tap to expand

Step-by-Step Walkthrough

Sort Pattern

Sort characters in pattern string

Check Substrings

For each position, sort substring and compare

Collect Matches

Add matching positions to result

Code -

solution.c — C

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

int compare(const void *a, const void *b) {
    return *(char*)a - *(char*)b;
}

void solution(char* s, char* p, int* result, int* returnSize) {
    int sLen = strlen(s);
    int pLen = strlen(p);
    char pSorted[pLen + 1];
    strcpy(pSorted, p);
    qsort(pSorted, pLen, sizeof(char), compare);
    
    *returnSize = 0;
    
    for (int i = 0; i <= sLen - pLen; i++) {
        char substring[pLen + 1];
        strncpy(substring, s + i, pLen);
        substring[pLen] = '\0';
        qsort(substring, pLen, sizeof(char), compare);
        
        if (strcmp(substring, pSorted) == 0) {
            result[(*returnSize)++] = i;
        }
    }
}

int main() {
    char s[30001], p[21];
    fgets(s, sizeof(s), stdin);
    fgets(p, sizeof(p), stdin);
    s[strcspn(s, "\n")] = 0;
    p[strcspn(p, "\n")] = 0;
    
    int result[30000];
    int returnSize;
    solution(s, p, result, &returnSize);
    
    printf("[");
    for (int i = 0; i < returnSize; i++) {
        printf("%d", result[i]);
        if (i < returnSize - 1) printf(",");
    }
    printf("]\n");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m × log m)

n positions × m characters per substring × log m for sorting

✓ Linear Growth

Space Complexity

O(m)

Space for temporary strings during sorting

✓ Linear Space

487.2K Views

High Frequency

~25 min Avg. Time

8.5K 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 with Sorting — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler