Find All Anagrams in a String - Practice Coding Problems

Find All Anagrams in a String - Problem

Imagine you're a word detective searching for hidden anagrams within a larger string! Given two strings s (the haystack) and p (the needle), your mission is to find all starting positions where anagrams of p appear as substrings in s.

What's an anagram? It's a rearrangement of letters - like "abc" and "bca" are anagrams because they contain the same letters with the same frequency.

Example: If s = "abab" and p = "ab", then positions 0 and 2 contain anagrams of "ab" ("ab" at index 0 and "ab" at index 2).

Return an array of all the starting indices where p's anagrams begin in s. The order of results doesn't matter!

Input & Output

example_1.py — Python

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

› Output: [0, 2]

💡 Note: The substring "ab" at index 0 is an anagram of "ab". The substring "ab" at index 2 is an anagram of "ab".

example_2.py — Python

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

› Output: [1, 6]

💡 Note: The substring "bae" at index 1 is an anagram of "abc" (contains a,b,c). The substring "bac" at index 6 is an anagram of "abc".

example_3.py — Python

$ Input: s = "abacabad", p = "aaab"

› Output: []

💡 Note: No substring of length 4 in s contains exactly 3 'a's and 1 'b', so no anagrams exist.

Visualization

Tap to expand

Understanding the Visualization

Setup Phase

Create frequency map for target pattern and initialize first window

Check Current Window

Compare frequency maps to detect anagram

Slide Window Right

Remove leftmost character and add new rightmost character

Update Frequencies

Efficiently update frequency counts and check for new matches

Key Takeaway

🎯 Key Insight: The sliding window technique transforms an O(n×m×log m) brute force solution into an elegant O(n+m) algorithm by maintaining frequency counts as we slide, rather than recalculating everything from scratch each time.

Time & Space Complexity

Time Complexity

⏱️

O(n + m)

Single pass through string s (n) plus creating frequency map for p (m)

✓ Linear Growth

Space Complexity

O(1)

Hash maps store at most 26 characters (constant space for lowercase English letters)

✓ Linear Space

Constraints

1 ≤ s.length, p.length ≤ 3 × 10⁴
s and p consist of lowercase English letters only
Both strings are non-empty

Asked in

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

The optimal solution uses a sliding window technique with hash maps to track character frequencies. Instead of checking every substring individually, we maintain a window of size p.length() and efficiently slide it across string s, updating frequency counts in O(1) time per slide. This achieves O(n) time complexity with O(1) space (since we store at most 26 characters).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Check Every Substring)	O(n * m * log m)	O(m)	Check every possible substring of length p by sorting and comparing
Sliding Window with Hash Map (Optimal)	O(n + m)	O(1)	Use sliding window technique with character frequency maps

Brute Force (Check Every Substring) — Algorithm Steps

Iterate through each possible starting position in s
Extract substring of length p starting at current position
Sort both the substring and p
If sorted strings match, add starting index to result
Continue until end of string s

Visualization

Tap to expand

Step-by-Step Walkthrough

Extract Substring

Take substring of length p starting at current position

Sort Both Strings

Sort the substring and target string p

Compare

If sorted strings match, we found an anagram

Move to Next Position

Slide to next starting position and repeat

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;
}

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

int main() {
    int returnSize;
    int* result = findAnagrams("abab", "ab", &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 * log m)

n iterations × m length substring × log m for sorting each substring

⚡ Linearithmic

Space Complexity

O(m)

Space for sorting substrings of length m

✓ Linear Space

Constraints

1 ≤ s.length, p.length ≤ 3 × 10⁴
s and p consist of lowercase English letters only
Both strings are non-empty

87.4K Views

High Frequency

~18 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 (Check Every Substring) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler