Rabin-Karp String Search - Problem

Implement the Rabin-Karp string matching algorithm using polynomial rolling hash to find all occurrences of a pattern string in a text string.

The Rabin-Karp algorithm uses hashing to find any one of a set of pattern strings in a text. It uses a rolling hash to quickly filter out positions of the text that cannot match the pattern, and then checks for a match at the remaining positions.

For this implementation:

Use a polynomial rolling hash with base 31 and modulus 10^9 + 7
Return a list of all starting indices where the pattern occurs in the text
If no matches are found, return an empty list

Note: The algorithm should handle hash collisions by verifying actual string matches when hashes are equal.

Input & Output

Example 1 — Basic Pattern Match

$ Input: text = "abcabcab", pattern = "abc"

› Output: [0,3]

💡 Note: Pattern 'abc' appears at index 0 ('abc'abcab) and index 3 (abc'abc'ab). The rolling hash quickly identifies these positions.

Example 2 — Single Character Pattern

$ Input: text = "aaaaa", pattern = "a"

› Output: [0,1,2,3,4]

💡 Note: Single character 'a' appears at every position in the text. Rolling hash efficiently processes each position.

Example 3 — No Match Found

$ Input: text = "hello", pattern = "world"

› Output: []

💡 Note: Pattern 'world' does not exist anywhere in text 'hello', so return empty array.

Constraints

1 ≤ text.length ≤ 10⁵
1 ≤ pattern.length ≤ 10³
text and pattern consist of lowercase English letters only

Visualization

Tap to expand

Asked in

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

The Rabin-Karp algorithm uses polynomial rolling hash to efficiently find pattern matches. The key insight is using a rolling hash function to avoid recalculating the hash from scratch for each window position. Best approach: Rolling Hash - Time: O(n+m), Space: O(1).

Common Approaches

✓ Brute Force String Matching

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

For each position in the text, compare the pattern character by character. This approach checks every possible starting position and performs a full string comparison.

Rabin-Karp with Rolling Hash

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

Calculate hash of pattern and use rolling hash technique to compute hash of each text substring efficiently. Only perform string comparison when hashes match.

Brute Force String Matching — Algorithm Steps

Step 1: For each position i in text where pattern could fit
Step 2: Compare pattern with text[i:i+pattern_length] character by character
Step 3: If all characters match, add i to result list

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Compare 'abc' with 'abc' - match found!

Position 1

Compare 'abc' with 'bca' - no match

Continue

Check each position until end of text

Code -

solution.c — C

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

int* solution(char* text, char* pattern, int* returnSize) {
    int n = strlen(text), m = strlen(pattern);
    int* result = (int*)malloc(n * sizeof(int));
    *returnSize = 0;
    
    for (int i = 0; i <= n - m; i++) {
        int match = 1;
        for (int j = 0; j < m; j++) {
            if (text[i + j] != pattern[j]) {
                match = 0;
                break;
            }
        }
        if (match) {
            result[(*returnSize)++] = i;
        }
    }
    
    return result;
}

int main() {
    char text[10000], pattern[1000];
    fgets(text, sizeof(text), stdin);
    fgets(pattern, sizeof(pattern), stdin);
    
    text[strcspn(text, "\n")] = 0;
    pattern[strcspn(pattern, "\n")] = 0;
    
    int returnSize;
    int* result = solution(text, pattern, &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+1)×m)

For each of (n-m+1) positions, we compare up to m characters

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for indices and comparisons

✓ Linear Space

23.5K Views

Medium Frequency

~25 min Avg. Time

890 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

Rabin-Karp String Search - Problem

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Brute Force String Matching — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler