# 1. Introduction

"Group Shifted Strings" is a fascinating problem that involves classifying strings based on their shifting patterns. In this problem, strings are grouped if one can be transformed into another by uniformly shifting each letter. It combines concepts of string manipulation, hashing, and character encoding, making it a popular challenge in algorithm design.

## Problem

Given a string array, the task is to group all strings that belong to the same shifting sequence. A string's shifting sequence means that each letter in the string is shifted by the same number of positions in the alphabet. For instance, "abc" can be shifted to "bcd", "cde", and so on.

# 2. Solution Steps

1. Initialize a dictionary to store groups of shifted strings.

2. For each string in the array, compute its shift pattern.

3. The shift pattern is calculated by finding the difference in ASCII values between each character and the first character.

4. Normalize the shift pattern to handle the wrap-around at 'z' to 'a'.

5. Use the shift pattern as a key in the dictionary and append the current string to the associated list.

6. After processing all strings, return the values from the dictionary as groups of shifted strings.

# 3. Code Program

``````def groupStrings(strings):
groups = {}

for string in strings:
key = tuple((ord(char) - ord(string[0])) % 26 for char in string)
groups.setdefault(key, []).append(string)

return list(groups.values())

# Example Usage
print(groupStrings(["abc", "bcd", "acef", "xyz", "az", "ba", "a", "z"]))
# Output: [['abc', 'bcd', 'xyz'], ['acef'], ['az', 'ba'], ['a', 'z']]
``````

### Output:

```[['abc', 'bcd', 'xyz'], ['acef'], ['az', 'ba'], ['a', 'z']]
```

### Explanation:

1. Shift Pattern Calculation: Determines how each string is shifted relative to its first character.

2. Hashing by Shift Pattern: Uses the shift pattern as a key to group similar strings.

3. Normalization of Shifts: Addresses the wrap-around in the alphabet to group strings like 'az' and 'ba'.

4. Dictionary for Grouping: Efficiently categorizes strings into their respective groups.

5. Time Complexity: Processes each string once, leading to O(n) time complexity, where n is the number of strings.

6. Applicability: This approach can be applied to problems involving cyclic patterns or rotational equivalence in strings.