Find Substring With Given Hash Value

Find Substring With Given Hash Value - Problem

The hash of a 0-indexed string s of length k, given integers p and m, is computed using the following function:

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 index of s[i] in the alphabet from val('a') = 1 to val('z') = 26.

You are given a string s and the integers power, modulo, k, and hashValue. Return sub, the first substring of s of length k such that hash(sub, power, modulo) == hashValue.

The test cases will be generated such that an answer always exists.

A substring is a contiguous non-empty sequence of characters within a string.

Input & Output

Example 1 — Basic Case

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

› Output: ee

💡 Note: Hash of "ee" = (5*1 + 5*7) % 20 = 40 % 20 = 0, which matches hashValue

Example 2 — Single Character

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

› Output: fbx

💡 Note: Hash of "fbx" = (6*1 + 2*31 + 24*31²) % 100 = (6 + 62 + 23064) % 100 = 32, which matches hashValue

Example 3 — Edge Case

$ Input: s = "xmmhdakfursinye", power = 96, modulo = 45, k = 15, hashValue = 21

› Output: xmmhdakfursinye

💡 Note: The entire string has length 15, equal to k, so only one possible substring

Constraints

1 ≤ k ≤ s.length ≤ 2 × 10⁴
1 ≤ power, modulo ≤ 10⁹
0 ≤ hashValue < modulo
s consists of lowercase English letters only
The answer is guaranteed to exist

Visualization

Tap to expand

Asked in

G Google 25 M Microsoft 18 A Amazon 15 f Meta 12

The key insight is using rolling hash to avoid recomputing hash values from scratch. The optimal approach uses reverse sliding window to eliminate modular division issues, achieving O(n) time complexity with O(1) space.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Brute Force

⏱️ Time: O(n*k) Space: O(1)

For each possible starting position, extract the substring of length k and compute its hash value from scratch using the given formula. Compare with the target hash value and return the first match.

Rolling Hash (Reverse Sliding Window)

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

Instead of recomputing hash from scratch, use rolling hash to update the hash value in O(1) time as we slide the window. Process from right to left to avoid modular division issues.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

// Function to compute modular inverse using extended Euclidean algorithm
long long modInverse(long long a, long long m) {
    long long m0 = m, x0 = 0, x1 = 1;
    if (m == 1) return 0;
    while (a > 1) {
        long long q = a / m;
        long long t = m;
        m = a % m;
        a = t;
        t = x0;
        x0 = x1 - q * x0;
        x1 = t;
    }
    if (x1 < 0) x1 += m0;
    return x1;
}

// Function to compute power using iterative method (avoiding math.h)
long long power_mod(long long base, long long exp, long long mod) {
    long long result = 1;
    base = base % mod;
    while (exp > 0) {
        if (exp % 2 == 1) {
            result = (result * base) % mod;
        }
        exp = exp >> 1;
        base = (base * base) % mod;
    }
    return result;
}

char* subStrHash(char* s, int power, int modulo, int k, int hashValue) {
    int n = strlen(s);
    
    // We'll process from right to left to make rolling hash easier
    // Calculate hash of the rightmost substring first
    long long currentHash = 0;
    long long powerK = 1; // This will be power^k
    
    // Calculate the hash of the last k characters
    for (int i = n - k; i < n; i++) {
        int val = s[i] - 'a' + 1;
        currentHash = (currentHash + ((long long)val * powerK) % modulo) % modulo;
        if (i < n - 1) {
            powerK = (powerK * power) % modulo;
        }
    }
    
    // Check if this matches
    if (currentHash == hashValue) {
        char* result = (char*)malloc((k + 1) * sizeof(char));
        strncpy(result, s + n - k, k);
        result[k] = '\0';
        return result;
    }
    
    // Calculate modular inverse of power for rolling hash
    long long powerInv = modInverse(power, modulo);
    
    // Roll the hash from right to left
    for (int i = n - k - 1; i >= 0; i--) {
        // Remove the rightmost character
        int rightVal = s[i + k] - 'a' + 1;
        currentHash = (currentHash - ((long long)rightVal * powerK) % modulo + modulo) % modulo;
        
        // Divide by power (multiply by inverse)
        currentHash = (currentHash * powerInv) % modulo;
        
        // Add the new leftmost character
        int leftVal = s[i] - 'a' + 1;
        currentHash = (currentHash + leftVal) % modulo;
        
        // Check if this matches
        if (currentHash == hashValue) {
            char* result = (char*)malloc((k + 1) * sizeof(char));
            strncpy(result, s + i, k);
            result[k] = '\0';
            return result;
        }
    }
    
    return NULL; // Should never reach here according to problem statement
}

int main() {
    char s[20001];
    int power, modulo, k, hashValue;
    
    // Read input
    fgets(s, sizeof(s), stdin);
    // Remove newline if present
    int len = strlen(s);
    if (len > 0 && s[len-1] == '\n') {
        s[len-1] = '\0';
    }
    
    scanf("%d", &power);
    scanf("%d", &modulo);
    scanf("%d", &k);
    scanf("%d", &hashValue);
    
    char* result = subStrHash(s, power, modulo, k, hashValue);
    if (result) {
        printf("%s\n", result);
        free(result);
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

✓ Linear Space

28.5K Views

Medium Frequency

~35 min Avg. Time

589 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