Group Anagrams

You're given a list of words and need to group them based on whether they are anagrams of each other. Anagrams are words that contain the same characters with the same frequencies, just in a different order. This is a fundamental problem in string manipulation and has applications in areas like dictionary building, text analysis, and search algorithms.

Problem Description

The goal is to take a list of strings (words) and organize them into groups where each group contains words that are anagrams of each other.

Requirements:

• You should iterate through the input list of strings.
• For each string, determine if it's an anagram of any strings already processed and assigned to a group.
• If it is, add it to that group.
• If it's not an anagram of any existing group, create a new group for it.
• The order of the output groups does not matter.
• The order of strings within each output group does not matter.

Expected Behavior: The function should return a list of lists, where each inner list represents a group of anagrams.

Edge Cases to Consider:

• Empty input list.
• List containing empty strings.
• List containing strings with different cases (e.g., "Eat" and "eat"). For this problem, assume case-insensitivity for anagrams (treat 'A' and 'a' as the same character).
• List containing strings with non-alphabetic characters. For this problem, consider only alphabetic characters for anagram comparison and ignore all other characters.

Examples

Example 1:

Input: ["eat", "tea", "tan", "ate", "nat", "bat"]
Output: [["eat", "tea", "ate"], ["tan", "nat"], ["bat"]]
Explanation:
"eat", "tea", and "ate" are anagrams because they all contain one 'a', one 'e', and one 't'.
"tan" and "nat" are anagrams because they both contain one 'a', one 'n', and one 't'.
"bat" is not an anagram of any other word.

Example 2:

Input: [""]
Output: [[""]]
Explanation: An empty string is an anagram of itself.

Example 3:

Input: ["a"]
Output: [["a"]]
Explanation: A single character string forms its own group.

Example 4: (Case-insensitivity and non-alphabetic characters)

Input: ["Cat", "act", "tac!", "Dog", "god", " "]
Output: [["Cat", "act", "tac!"], ["Dog", "god"]]
Explanation:
"Cat", "act", and "tac!" are grouped because, after converting to lowercase and removing non-alphabetic characters, they all become "act".
"Dog" and "god" are grouped because they both become "dgo".
The empty string and strings with only non-alphabetic characters are ignored for grouping if they don't form anagrams with valid words.

Constraints

• The input list will contain between 0 and 10^4 strings.
• Each string will contain between 0 and 100 characters.
• Strings will consist of English letters, spaces, and potentially other characters.
• The solution should aim for an efficient time complexity, ideally better than O(NMlogM) where N is the number of strings and M is the maximum length of a string.

Notes

• Think about how you can uniquely represent an anagram regardless of the order of its characters.
• A common approach involves sorting the characters of a string or counting the frequency of each character.
• Consider how to handle case-insensitivity and non-alphabetic characters as specified in the edge cases.