Group Shifted Strings - Practice Coding Problems

Group Shifted Strings - Problem

Imagine having a secret decoder ring that can shift letters in the alphabet! In this problem, you'll work with shifting sequences of strings.

Shifting Rules:

Right shift: Each letter becomes the next letter in the alphabet (a→b, b→c, ..., z→a)
Left shift: Each letter becomes the previous letter in the alphabet (z→y, y→x, ..., a→z)

For example, the string "abc" can be shifted to form an endless sequence:
... ↔ "xyz" ↔ "yza" ↔ "zab" ↔ "abc" ↔ "bcd" ↔ "cde" ↔ ...

Your task: Given an array of strings, group together all strings that belong to the same shifting sequence. Two strings belong to the same group if one can be obtained from the other by applying shift operations.

Input: An array of strings strings
Output: A list of groups, where each group contains strings from the same shifting sequence

Input & Output

example_1.py — Basic Grouping

$ Input: ["abc", "bcd", "acef", "xyz", "az", "ba", "a", "z"]

› Output: [["acef"], ["a", "z"], ["abc", "bcd", "xyz"], ["az", "ba"]]

💡 Note: "abc", "bcd", "xyz" form one group (each differs by +1 shift). "az" and "ba" form another group (both have single +25 shift). "acef" is alone (unique pattern). "a" and "z" are single characters (grouped together).

example_2.py — Single Group

$ Input: ["abc", "bcd", "xyz"]

› Output: [["abc", "bcd", "xyz"]]

💡 Note: All three strings belong to the same shifting sequence. "abc" → "bcd" (shift +1), "bcd" → "xyz" (shift +22, which is equivalent to +22 mod 26).

example_3.py — Edge Cases

$ Input: ["a", "aa", "aaa"]

› Output: [["a"], ["aa"], ["aaa"]]

💡 Note: Strings of different lengths cannot belong to the same shifting sequence, so each forms its own group.

Constraints

1 ≤ strings.length ≤ 300
0 ≤ strings[i].length ≤ 50
strings[i] consists of lowercase English letters only
No two strings are identical

Visualization

Tap to expand

Understanding the Visualization

Identify Pattern

Calculate the 'intervals' (differences) between consecutive characters

Create Signature

Form a unique fingerprint from these intervals

Group by Signature

Strings with identical signatures belong to the same shifting sequence

Return Groups

Each group contains strings that can be shifted to match each other

Key Takeaway

🎯 Key Insight: Strings belong to the same shifting sequence if and only if they have the same pattern of character differences between consecutive positions!

Asked in

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

The optimal solution uses a hash table with signature-based grouping. The key insight is that strings belonging to the same shifting sequence have identical patterns of character differences. We compute a signature for each string based on consecutive character differences, then group strings with the same signature in O(n×m) time.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Table (Optimal)	O(n × m)	O(n × m)	Create a signature for each string based on character differences and group them in a single pass
Brute Force (Compare All Pairs)	O(n² × m)	O(n × m)	Compare each string with every other string to check if they belong to the same shifting sequence

One-Pass Hash Table (Optimal) — Algorithm Steps

For each string, calculate differences between consecutive characters
Create a signature tuple from these differences
Use the signature as a hash key to group strings
Add each string to its corresponding group in the hash map
Return all groups from the hash map

Visualization

Tap to expand

Step-by-Step Walkthrough

Calculate Differences

For each string, compute differences between consecutive characters

Create Signature

Form a unique signature tuple from the differences

Hash & Group

Use signature as key to group strings in hash map

Return Groups

Extract all groups from the hash map

Code -

solution.c — C

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

#define MAX_GROUPS 1000
#define MAX_SIGNATURE 100

typedef struct {
    char signature[MAX_SIGNATURE];
    char** strings;
    int count;
    int capacity;
} Group;

void getSignature(char* s, char* signature) {
    int len = strlen(s);
    sprintf(signature, "%d:", len);
    
    int pos = strlen(signature);
    for (int i = 1; i < len; i++) {
        int diff = (s[i] - s[i-1] + 26) % 26;
        pos += sprintf(signature + pos, "%d,", diff);
    }
}

char*** groupStrings(char** strings, int stringsSize, int* returnSize, int** returnColumnSizes) {
    Group* groups = (Group*)malloc(MAX_GROUPS * sizeof(Group));
    int groupCount = 0;
    
    for (int i = 0; i < stringsSize; i++) {
        char signature[MAX_SIGNATURE];
        getSignature(strings[i], signature);
        
        // Find existing group or create new one
        int groupIndex = -1;
        for (int j = 0; j < groupCount; j++) {
            if (strcmp(groups[j].signature, signature) == 0) {
                groupIndex = j;
                break;
            }
        }
        
        if (groupIndex == -1) {
            groupIndex = groupCount++;
            strcpy(groups[groupIndex].signature, signature);
            groups[groupIndex].strings = (char**)malloc(stringsSize * sizeof(char*));
            groups[groupIndex].count = 0;
            groups[groupIndex].capacity = stringsSize;
        }
        
        groups[groupIndex].strings[groups[groupIndex].count++] = strings[i];
    }
    
    char*** result = (char***)malloc(groupCount * sizeof(char**));
    *returnColumnSizes = (int*)malloc(groupCount * sizeof(int));
    
    for (int i = 0; i < groupCount; i++) {
        result[i] = groups[i].strings;
        (*returnColumnSizes)[i] = groups[i].count;
    }
    
    *returnSize = groupCount;
    free(groups);
    return result;
}

Time & Space Complexity

Time Complexity

⏱️

O(n × m)

One pass through n strings, each taking O(m) time to compute signature

✓ Linear Growth

Space Complexity

O(n × m)

Hash map storing all strings plus their signatures

⚡ Linearithmic Space

42.0K Views

Medium-High Frequency

~15 min Avg. Time

1.9K 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

One-Pass Hash Table (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler