Hash Divided String - Practice Coding Problems

Hash Divided String - Problem

String Simulation Medium

Imagine you're a cryptographer creating a simple hash function for string data! You're given a string s of length n and an integer k, where n is perfectly divisible by k.

Your mission is to transform the original string into a compressed hash string of length n/k using the following algorithm:

Divide: Split the string s into n/k substrings, each exactly k characters long
Hash: For each substring, calculate a hash value by:
- Converting each character to its alphabet position ('a' → 0, 'b' → 1, ..., 'z' → 25)
- Summing all these position values
- Taking the remainder when divided by 26 (this keeps us within alphabet bounds)
Encode: Convert the hash value back to its corresponding lowercase letter
Append: Add this character to your result string

Goal: Return the final hashed string that represents a compressed version of the original input.

Example: If s = "abcd" and k = 2, we get substrings "ab" and "cd". Hash of "ab" = (0+1) % 26 = 1 → 'b', Hash of "cd" = (2+3) % 26 = 5 → 'f'. Result: "bf"

Input & Output

example_1.py — Basic Case

$ Input: s = "abcd", k = 2

› Output: "bf"

💡 Note: Divide "abcd" into ["ab", "cd"]. For "ab": (0+1) % 26 = 1 → 'b'. For "cd": (2+3) % 26 = 5 → 'f'. Result: "bf"

example_2.py — Larger Substring

$ Input: s = "mxz", k = 3

› Output: "i"

💡 Note: Only one substring "mxz". Hash: (12+23+25) % 26 = 60 % 26 = 8 → 'i'. Result: "i"

example_3.py — Multiple Substrings

$ Input: s = "abcdef", k = 3

› Output: "dm"

💡 Note: Divide into ["abc", "def"]. For "abc": (0+1+2) % 26 = 3 → 'd'. For "def": (3+4+5) % 26 = 12 → 'm'. Result: "dm"

Constraints

1 ≤ k ≤ n ≤ 100
n is a multiple of k
s consists of lowercase English letters only
The result string will have length n/k

Visualization

Tap to expand

Understanding the Visualization

Input Division

Raw string gets cut into equal-sized chunks of length k

Character Encoding

Each character in a chunk gets converted to its alphabet position (a=0, b=1, etc.)

Sum Calculation

All position values in the chunk are added together

Hash Modulation

The sum is reduced using modulo 26 to stay within alphabet bounds

Character Output

The final hash value is converted back to a lowercase letter

Key Takeaway

🎯 Key Insight: Each substring can be processed independently, making this an embarrassingly parallel problem that naturally divides the work into equal chunks.

Asked in

G Google 25 a Amazon 18 ⊞ Microsoft 15 f Meta 12

The optimal solution processes the string in one pass by dividing it into substrings of length k, calculating the hash sum for each substring by summing character positions, applying modulo 26, and converting back to characters. Time complexity is O(n) and space complexity is O(n/k).

Common Approaches

Approach	Time	Space	Notes
✓ Brute Force (Character-by-Character)	O(n)	O(n/k)	Process each substring separately with nested loops

Brute Force (Character-by-Character) — Algorithm Steps

Initialize an empty result string
Loop through the string in chunks of size k
For each chunk, initialize sum to 0
Loop through each character in the chunk
Convert character to alphabet position and add to sum
Calculate sum % 26 and convert back to character
Append the result character to the final string

Visualization

Tap to expand

Step-by-Step Walkthrough

Divide String

Split input string into substrings of length k

Calculate Hash

Sum alphabet positions of characters in each substring

Apply Modulo

Take remainder when divided by 26

Convert to Character

Map result back to alphabet character

Code -

solution.c — C

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

char* stringHash(char* s, int k) {
    int n = strlen(s);
    int resultLen = n / k;
    char* result = (char*)malloc((resultLen + 1) * sizeof(char));
    int resultIndex = 0;
    
    // Process each substring of length k
    for (int i = 0; i < n; i += k) {
        int hashSum = 0;
        
        // Calculate sum of character positions
        for (int j = i; j < i + k; j++) {
            hashSum += s[j] - 'a';
        }
        
        // Get hashed character
        result[resultIndex++] = (hashSum % 26) + 'a';
    }
    
    result[resultIndex] = '\0';
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

We visit each character exactly once, where n is the length of the input string

✓ Linear Growth

Space Complexity

O(n/k)

We store the result string which has length n/k

⚡ Linearithmic Space

28.5K Views

Medium Frequency

~8 min Avg. Time

892 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 (Character-by-Character) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler