Find Substring With Given Hash Value - Practice Coding Problems

Find Substring With Given Hash Value - Problem

Find the substring with a specific hash value in a given string.

You're given a polynomial rolling hash function that computes:
hash(s, p, m) = (val(s[0]) * p⁰ + val(s[1]) * p¹ + ... + val(s[k-1]) * p^k-1) mod m

Where val(s[i]) represents the alphabetical index of character s[i] (a=1, b=2, ..., z=26).

Your task: Given a string s and parameters power, modulo, k, and hashValue, find the first substring of length k whose hash equals hashValue.

Example: If s="leetcode", power=7, modulo=20, k=2, hashValue=0, you need to find the first 2-character substring with hash value 0.

Input & Output

example_1.py — Basic Case

$ Input: s = "leetcode", power = 7, modulo = 20, k = 2, hashValue = 0

› Output: "ee"

💡 Note: The hash of "ee" is (5*7^0 + 5*7^1) mod 20 = (5 + 35) mod 20 = 40 mod 20 = 0. The first substring with this hash is "ee".

example_2.py — Different Parameters

$ Input: s = "fbxzaad", power = 31, modulo = 100, k = 3, hashValue = 32

› Output: "fbx"

💡 Note: The hash of "fbx" is (6*31^0 + 2*31^1 + 24*31^2) mod 100 = (6 + 62 + 23064) mod 100 = 23132 mod 100 = 32.

example_3.py — Edge Case

$ Input: s = "a", power = 2, modulo = 3, k = 1, hashValue = 1

› Output: "a"

💡 Note: Single character case. The hash of "a" is (1*2^0) mod 3 = 1 mod 3 = 1, which matches the target.

Visualization

Tap to expand

Understanding the Visualization

Initial Scan

Start with the last group of suspects and get their combined fingerprint code

Smart Update

Move left: remove the rightmost person, add new leftmost person, update code instantly

Pattern Match

Compare updated code with target - if it matches, you found your suspects!

Efficient Search

Continue rolling left until you find the first matching group

Key Takeaway

🎯 Key Insight: Rolling hash transforms an O(n*k) problem into O(n) by reusing previous calculations with smart modular arithmetic updates.

Time & Space Complexity

Time Complexity

⏱️

O(n)

Single pass through string with O(1) hash updates per position

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for hash calculations

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 2 × 10⁴
1 ≤ power, modulo ≤ 10⁹
0 ≤ hashValue < modulo
s consists of lowercase English letters only
The test cases are generated such that an answer always exists

Asked in

G Google 42 f Meta 38 a Amazon 35 ⊞ Microsoft 28

The optimal solution uses rolling hash technique to find the target substring in O(n) time. The key insight is to work backwards through the string, using modular arithmetic to efficiently update hash values in constant time rather than recalculating from scratch.

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Recalculate Each Hash)	O(n*k)	O(1)	Calculate hash from scratch for every possible substring of length k
Rolling Hash (Optimal)	O(n)	O(1)	Use rolling hash technique to update hash values in O(1) time per position

Brute Force (Recalculate Each Hash) — Algorithm Steps

Iterate through all possible starting positions (0 to n-k)
For each position, calculate hash of k-length substring from scratch
Apply formula: hash = (val[0]*p^0 + val[1]*p^1 + ... + val[k-1]*p^(k-1)) mod m
Compare calculated hash with target hashValue
Return first matching substring

Visualization

Tap to expand

Step-by-Step Walkthrough

Position 0

Calculate hash for first k characters

Position 1

Move to next position, recalculate entire hash

Continue

Repeat until we find matching hash

Code -

solution.c — C

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

char* findSubstring(char* s, int power, int modulo, int k, int hashValue) {
    int n = strlen(s);
    static char result[100001];
    
    // Check each possible substring of length k
    for (int i = 0; i <= n - k; i++) {
        // Calculate hash for substring
        long long currentHash = 0;
        long long powerVal = 1;
        
        for (int j = 0; j < k; j++) {
            int val = s[i + j] - 'a' + 1;
            currentHash = (currentHash + (val * powerVal) % modulo) % modulo;
            powerVal = (powerVal * power) % modulo;
        }
        
        if (currentHash == hashValue) {
            strncpy(result, s + i, k);
            result[k] = '\0';
            return result;
        }
    }
    
    result[0] = '\0';
    return result;
}

int main() {
    char s[100001];
    int power, modulo, k, hashValue;
    scanf("%s %d %d %d %d", s, &power, &modulo, &k, &hashValue);
    
    printf("%s\n", findSubstring(s, power, modulo, k, hashValue));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n*k)

For each of n-k+1 positions, we calculate hash in O(k) time

✓ Linear Growth

Space Complexity

O(1)

Only using constant extra space for calculations

✓ Linear Space

Constraints

1 ≤ k ≤ s.length ≤ 2 × 10⁴
1 ≤ power, modulo ≤ 10⁹
0 ≤ hashValue < modulo
s consists of lowercase English letters only
The test cases are generated such that an answer always exists

38.0K Views

Medium Frequency

~25 min Avg. Time

1.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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

Brute Force (Recalculate Each Hash) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler