Group Anagrams

                                            
class Solution {
public:
    vector<vector<string>> groupAnagrams(vector<string>& strs) {
        unordered_map<string, vector<string>> mp;
        for (string s : strs) {
            string sortedStr = s;
            sort(sortedStr.begin(), sortedStr.end());
            mp[sortedStr].push_back(s);
        }
        
        vector<vector<string>> result;
        for (auto it = mp.begin(); it != mp.end(); it++) {
            result.push_back(it->second);
        }
        
        return result;
    }
};

                                            
class Solution {
    public List<List<String>> groupAnagrams(String[] strs) {
        Map<String, List<String>> map = new HashMap<>();
        for (String str : strs) {
            char[] charArray = str.toCharArray();
            Arrays.sort(charArray);
            String sortedStr = String.valueOf(charArray);
            List<String> anagramList = map.getOrDefault(sortedStr, new ArrayList<>());
            anagramList.add(str);
            map.put(sortedStr, anagramList);
        }
        return new ArrayList<>(map.values());
    }
}

                                            
class Solution(object):
    def groupAnagrams(self, strs):
        """
        :type strs: List[str]
        :rtype: List[List[str]]
        """
        anagrams = collections.defaultdict(list)
        for word in strs:
            sorted_word = ''.join(sorted(word))
            anagrams[sorted_word].append(word)
        return list(anagrams.values())

                                            
#define MAX_CHAR 26

// Function to sort a string
void sortString(char* str) {
    int count[MAX_CHAR] = {0};

    // Count frequency of characters
    for (int i = 0; i < strlen(str); i++) {
        count[str[i] - 'a']++;
    }

    // Update the string with sorted characters
    int index = 0;
    for (int i = 0; i < MAX_CHAR; i++) {
        while (count[i] > 0) {
            str[index++] = i + 'a';
            count[i]--;
        }
    }
}

char*** groupAnagrams(char** strs, int strsSize, int* returnSize, int** returnColumnSizes) {
    *returnSize = 0;
    *returnColumnSizes = (int*)malloc(strsSize * sizeof(int));
    char*** result = (char***)malloc(strsSize * sizeof(char**));

    // Create a hash map to store groups of anagrams
    // Key -> sorted string, Value -> list of anagrams
    struct hash_table {
        char* key;
        int index;
    };

    struct hash_table* hashMap = (struct hash_table*)malloc(strsSize * sizeof(struct hash_table));

    for (int i = 0; i < strsSize; i++) {
        // Sort current string
        char* sortedStr = strdup(strs[i]);
        sortString(sortedStr);

        // Check if the sorted string is already in the hash map
        int found = 0;
        for (int j = 0; j < *returnSize; j++) {
            if (strcmp(hashMap[j].key, sortedStr) == 0) {
                found = 1;
                int idx = hashMap[j].index;
                result[idx] = (char**)realloc(result[idx], ((*returnColumnSizes)[idx] + 1) * sizeof(char*));
                result[idx][(*returnColumnSizes)[idx]] = strdup(strs[i]);
                (*returnColumnSizes)[idx]++;
                break;
            }
        }

        // If sorted string not found, add it to hashmap
        if (!found) {
            int idx = *returnSize;
            hashMap[idx].key = sortedStr;
            hashMap[idx].index = idx;
            result[idx] = (char**)malloc(sizeof(char*));
            result[idx][0] = strdup(strs[i]);
            (*returnColumnSizes)[idx] = 1;
            (*returnSize)++;
        }
    }

    // Free memory
    free(hashMap);

    return result;
}

                                            
public class Solution {
    public IList<IList<string>> GroupAnagrams(string[] strs) {
        Dictionary<string, List<string>> map = new Dictionary<string, List<string>>();
        
        foreach(var str in strs){
            char[] arr = str.ToCharArray();
            Array.Sort(arr);
            string key = new string(arr);
            
            if(!map.ContainsKey(key)){
                map[key] = new List<string>();
            }
            
            map[key].Add(str);
        }
        
        IList<IList<string>> result = new List<IList<string>>();
        
        foreach(var list in map.Values){
            result.Add(list);
        }
        
        return result;
    }
}

                                            
/**
 * @param {string[]} strs
 * @return {string[][]}
 */
var groupAnagrams = function(strs) {
    const map = {};
    for (let str of strs) {
        const key = str.split('').sort().join('');
        if (!map[key]) {
            map[key] = [str];
        } else {
            map[key].push(str);
        }
    }
    return Object.values(map);
};

                                            
function groupAnagrams(strs: string[]): string[][] {
    const map: Map<string, string[]> = new Map();
    
    for (const str of strs) {
        const sortedStr = str.split("").sort().join("");
        if (map.has(sortedStr)) {
            map.get(sortedStr)?.push(str);
        } else {
            map.set(sortedStr, [str]);
        }
    }
    
    return Array.from(map.values());
};

                                            
class Solution {
    /**
     * @param String[] $strs
     * @return String[][]
     */
    function groupAnagrams($strs) {
        $map = [];
        foreach ($strs as $str) {
            $key = str_split($str);
            sort($key);
            $key = implode('', $key);
            $map[$key][] = $str;
        }
        
        return array_values($map);
    }
}

                                            
class Solution {
    func groupAnagrams(_ strs: [String]) -> [[String]] {
        var anagramDict: [String: [String]] = [:]
        
        for str in strs {
            let sortedStr = String(str.sorted())
            
            if var anagrams = anagramDict[sortedStr] {
                anagrams.append(str)
                anagramDict[sortedStr] = anagrams
            } else {
                anagramDict[sortedStr] = [str]
            }
        }
        
        return Array(anagramDict.values)
    }
}

                                            
import java.util.*

class Solution {
    fun groupAnagrams(strs: Array<String>): List<List<String>> {
        val map = HashMap<String, MutableList<String>>()
        for (str in strs) {
            val charArray = str.toCharArray()
            charArray.sort()
            val key = String(charArray)
            
            if (!map.containsKey(key)) {
                map[key] = mutableListOf()
            }
            map[key]?.add(str)
        }
        
        return ArrayList(map.values)
    }
}

                                            
class Solution {
  List<List<String>> groupAnagrams(List<String> strs) {
    Map<String, List<String>> map = {};

    for (String str in strs) {
      List<int> count = List.filled(26, 0);
      for (int i = 0; i < str.length; i++) {
        count[str.codeUnitAt(i) - 'a'.codeUnitAt(0)]++;
      }
      String key = count.join('#');
      map[key] = map[key] ?? [];
      map[key]!.add(str);
    }

    return map.values.toList();
  }
}

                                            
func groupAnagrams(strs []string) [][]string {
    groups := make(map[string][]string)
    
    for _, str := range strs {
        key := sortString(str)
        groups[key] = append(groups[key], str)
    }
    
    result := make([][]string, 0, len(groups))
    for _, group := range groups {
        result = append(result, group)
    }
    
    return result
}

func sortString(s string) string {
    r := []rune(s)
    sort.Slice(r, func(i, j int) bool {
        return r[i] < r[j]
    })
    return string(r)
}

                                            
# @param {String[]} strs
# @return {String[][]}
def group_anagrams(strs)
    hash = {}
    strs.each do |str|
        key = str.chars.sort.join
        if hash[key]
            hash[key] << str
        else
            hash[key] = [str]
        end
    end
    hash.values
end

                                            
import scala.collection.mutable.ListBuffer

object Solution {
    def groupAnagrams(strs: Array[String]): List[List[String]] = {
        val map = scala.collection.mutable.Map[String, ListBuffer[String]]()
        
        for (str <- strs) {
            val key = str.sorted
            if (!map.contains(key)) {
                map(key) = ListBuffer[String]()
            }
            map(key) += str
        }
        
        map.values.toList.map(_.toList)
    }
}

                                            
impl Solution {
    pub fn group_anagrams(strs: Vec<String>) -> Vec<Vec<String>> {
        use std::collections::HashMap;
        
        let mut map: HashMap<Vec<u8>, Vec<String>> = HashMap::new();
        
        for word in strs {
            let mut sorted_word = word.as_bytes().to_vec();
            sorted_word.sort();
            
            map.entry(sorted_word).or_insert(Vec::new()).push(word);
        }
        
        map.into_iter().map(|(_, v)| v).collect()
    }
}

                                            
defmodule Solution do
  @spec group_anagrams(strs :: [String.t]) :: [[String.t]]
  def group_anagrams(strs) do
    Enum.group_by(strs, &sort_chars/1)
    |> Map.values()
  end

  defp sort_chars(str) do
    str
    |> String.split("", trim: true)
    |> Enum.sort()
    |> Enum.join("")
  end
end

To solve this coding challenge, the goal is to group anagrams within a given list of strings. An anagram is defined as a word or phrase formed by rearranging the letters of another, using all original letters exactly once. For example:

The words "eat" and "tea" are anagrams because both can be rearranged into each other.
The strings "nat" and "tan" are also anagrams for the same reason.

# Explanation

A solution to this problem involves leveraging the property that anagrams, when sorted alphabetically, will result in the same string. For example, sorting both "ate" and "eat" will result in "aet". By using this property, we can group all anagrams together by using a hashmap (dictionary). Each key of the dictionary will be the sorted version of the word, and the value will be a list of words (anagrams) that correspond to that sorted key.

Here is a more detailed explanation of the steps involved:

Initialize the Data Structure: Use a hashmap to store lists of anagrams, where the key will be the sorted string, and the value will be a list of strings that are anagrams.
Iterate through Each Word: For each word in the given list of strings:

Sort the word alphabetically.
Use the sorted word as a key in the hashmap and append the original word to the list corresponding to this key.

Return the Result: Transform the values of the hashmap into the desired list format and return it.

Detailed Steps in Pseudocode

                                            
# Initialize a dictionary to store anagram groups
anagramGroups = {}

# Iterate over each word in the list of strings
for each word in list_of_strings:
    # Sort the characters of the word to form the key
    sorted_word = sort_characters_of(word) 
    
    # Check if the sorted word is already a key in the dictionary
    if sorted_word not in anagramGroups:
        # If not, create a new entry with this sorted word
        anagramGroups[sorted_word] = []
    
    # Append the original word to the list corresponding to this key
    anagramGroups[sorted_word].append(word)

# Convert the dictionary values to a list to get the desired output format
return list(anagramGroups.values())

Explanation of Pseudocode Steps with Detailed Comments

                                            
# Initialize a dictionary to store anagram groups
# The keys will be sorted words, and the values will be lists of anagrams
anagramGroups = {}

# Iterate over each word in the given list of strings
for each word in list_of_strings:
    # Sort the characters of the word 
    # This step will help in identifying anagrams as they will have the same sorted characters
    sorted_word = sort_characters_of(word) 
    
    # Check if the sorted word is already present as a key in the dictionary
    # If the sorted word is not in the dictionary, create a new entry with an empty list
    if sorted_word not in anagramGroups:
        anagramGroups[sorted_word] = []
    
    # Append the original word to the list corresponding to the sorted key
    # This helps in grouping all anagrams together under their sorted key
    anagramGroups[sorted_word].append(word)

# Convert the dictionary's values to a list
# The values will be lists of anagrams grouped together
return list(anagramGroups.values())

By following these steps in the pseudocode, we've established a clear method to solve the problem of grouping anagrams. Each part of the pseudocode is explained with comments that aid in understanding the process and logic behind the grouping of anagrams. This detailed explanation should provide a thorough understanding of the methodology required to solve the challenge.