Update group anagrams problem

Author: sudheerj

src/java1/algorithms/strings/groupAnagrams/GroupAnagrams.java

@@ -3,54 +3,55 @@
 import java.util.*;
 
 public class GroupAnagrams {
+
+        //HashMap and char array:- TC:O(n * m) SC:O(n)
+        private static List<List<String>> groupAnagram1(String[] strs) {
+            Map<String, List<String>> groupAnagramMap = new HashMap<>();
+    
+            for(String str: strs) {
+                int[] charsCount = new int[26];
+                
+                for(char ch: str.toCharArray()) {
+                    charsCount[ch - 'a']++;
+                }
+    
+                StringBuilder sb = new StringBuilder();
+                for(int num: charsCount) {
+                    sb.append("*");
+                    sb.append(num);
+                }
+    
+                String key = sb.toString();
+                groupAnagramMap.putIfAbsent(key, new ArrayList<>());
+                groupAnagramMap.get(key).add(str);
+            }
+            return new ArrayList<>(groupAnagramMap.values());
+        }
+        
     //HashMap using sorted strings:- TC:O(n * mlogn) SC:O(n)
-    private static List<List<String>> groupAnagram(String[] strs) {
-        Map<String, List<String>> hashMap = new HashMap<>();
+    private static List<List<String>> groupAnagram2(String[] strs) {
+        Map<String, List<String>> groupAnagramMap = new HashMap<>();
 
         for(String str: strs) {
             char[] chars = str.toCharArray();
             Arrays.sort(chars);
             String sortedStr = new String(chars);
-            if(!hashMap.containsKey(sortedStr)) {
-                hashMap.put(sortedStr, new ArrayList<>());
+            if(!groupAnagramMap.containsKey(sortedStr)) {
+                groupAnagramMap.put(sortedStr, new ArrayList<>());
             }
-            hashMap.get(sortedStr).add(str);
+            groupAnagramMap.get(sortedStr).add(str);
         }
 
-        return new ArrayList<>(hashMap.values());
-    }
-
-    //HashMap and char array:- TC:O(n * m) SC:O(n)
-    private static List<List<String>> groupAnagram1(String[] strs) {
-        Map<String, List<String>> hashMap = new HashMap<>();
-
-        for(String str: strs) {
-            int[] charsCount = new int[26];
-            
-            for(char ch: str.toCharArray()) {
-                charsCount[ch - 'a']++;
-            }
-
-            StringBuilder sb = new StringBuilder();
-            for(int i=0; i< 26; i++) {
-                sb.append("*");
-                sb.append(charsCount[i]);
-            }
-
-            String key = sb.toString();
-            hashMap.putIfAbsent(key, new ArrayList<>());
-            hashMap.get(key).add(str);
-        }
-        return new ArrayList<>(hashMap.values());
+        return new ArrayList<>(groupAnagramMap.values());
     }
 
     public static void main(String[] args) {
         String[] strs1 = {"eat","tea","tan","ate","nat","bat"};    
-        System.out.println(groupAnagram(strs1));   
         System.out.println(groupAnagram1(strs1));   
+        System.out.println(groupAnagram2(strs1));   
 
         String[] strs2 = {"hello"};    
-        System.out.println(groupAnagram(strs2));
         System.out.println(groupAnagram1(strs2));
+        System.out.println(groupAnagram2(strs2));
     }
 }

src/java1/algorithms/strings/groupAnagrams/GroupAnagrams.md

@@ -0,0 +1,41 @@
+**Description:**
+Given an array of strings strs, group the anagrams together. You can return the answer in any order.
+
+**Note:**An Anagram is defined as a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.
+
+### Examples
+Example 1:
+Input: strs = ["eat","tea","tan","ate","nat","bat"]
+Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+Example 2:
+Input: strs = ["hello"]
+Output: [["hello"]]
+
+Example 3:
+Input: strs = [""]
+Output: [[""]]
+
+**Algorithmic Steps**
+This problem is solved with the combination of **frequency counting** approach using an array and store anagrams in a map. The algorithmic approach can be summarized as follows:
+
+1. Initialize an empty object(`groupAnagramMap`) to store list of anagrams.
+
+2. Iterate over the list of given input strings array to find anagrams.
+
+3. Create a character frequency array(`charsCount`) with respect to 26 letters of alphabetics. Each value is assigned with zero by default.
+
+4. Iterate over the each character/letter of a string and update the character frequency.
+
+5. Calculate a unique hash key with the combination of the character frequency and prefix symbol.
+
+6. If the key already exists in the anagram object, append the new anagram to the list. Otherwise create a new anagram array for the given key.
+
+7. Repeat steps 3-6 until there are no strings available.
+
+8. Return group of anagrams in an array format.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(m * n)`, where `m` represents the number of strings and `n` represents length of each string. This is because we are traversing each string in the given list of strings. 
+
+Also, it requires space complexity of `O(m * n)` due to object/map data structure which store list of an arrays.

src/javascript/algorithms/strings/5.groupAnagrams/groupAnagrams.js

@@ -1,42 +1,42 @@
-//Using object and sort:- TC: O(m * n log n) OC: O(m * n)
-function groupAnagram(strs) {
+//Character count:- TC:O(m * n) OC: O(m * n)
+function groupAnagram1(strs) {
     let groupAnagramObj = {};
 
     for(let str of strs) {
-        const sortedString = str.split("").sort().join("");
-        if(groupAnagramObj[sortedString]) {
-            groupAnagramObj[sortedString].push(str);
+        const charFrequency = new Array(26).fill(0);
+        for(let i=0; i<str.length; i++) {
+            const charIndex = str.charCodeAt(i) - 97;
+            charFrequency[charIndex]++;
+        }
+        const key = charFrequency.join("#");
+        if(groupAnagramObj[key]) {
+            groupAnagramObj[key].push(str);
         } else {
-            groupAnagramObj[sortedString] = [str];
+            groupAnagramObj[key] = [str];
         }
     }
     return Object.values(groupAnagramObj);
 }
 
-//Character count:- TC:O(m * n) OC: O(n)
-function groupAnagram1(strs) {
+//Using object and sort:- TC: O(m * n log n) OC: O(m * n)
+function groupAnagram2(strs) {
     let groupAnagramObj = {};
 
     for(let str of strs) {
-        const chars = new Array(26).fill(0);
-        for(let i=0; i<str.length; i++) {
-            const charIndex = str.charCodeAt(i) - 97;
-            chars[charIndex]++;
-        }
-        const key = chars.join("#");
-        if(groupAnagramObj[key]) {
-            groupAnagramObj[key].push(str);
+        const sortedString = str.split("").sort().join("");
+        if(groupAnagramObj[sortedString]) {
+            groupAnagramObj[sortedString].push(str);
         } else {
-            groupAnagramObj[key] = [str];
+            groupAnagramObj[sortedString] = [str];
         }
     }
-    return Array.from(Object.values(groupAnagramObj));
+    return Object.values(groupAnagramObj);
 }
 
 let strs1 = ["eat","tea","tan","ate","nat","bat"];    
-console.log(groupAnagram(strs1));   
 console.log(groupAnagram1(strs1));   
+console.log(groupAnagram2(strs1));   
 
 let strs2 = ["hello"];    
-console.log(groupAnagram(strs2));
-console.log(groupAnagram1(strs2));
+console.log(groupAnagram1(strs2));
+console.log(groupAnagram2(strs2));

src/javascript/algorithms/strings/5.groupAnagrams/groupAnagrams.md

@@ -0,0 +1,41 @@
+**Description:**
+Given an array of strings strs, group the anagrams together. You can return the answer in any order.
+
+**Note:**An Anagram is defined as a word or phrase formed by rearranging the letters of a different word or phrase, using all the original letters exactly once.
+
+### Examples
+Example 1:
+Input: strs = ["eat","tea","tan","ate","nat","bat"]
+Output: [["bat"],["nat","tan"],["ate","eat","tea"]]
+
+Example 2:
+Input: strs = ["hello"]
+Output: [["hello"]]
+
+Example 3:
+Input: strs = [""]
+Output: [[""]]
+
+**Algorithmic Steps**
+This problem is solved with the combination of **frequency counting** approach using an array and store anagrams in an object/map. The algorithmic approach can be summarized as follows:
+
+1. Initialize an empty object(`groupAnagramObj`) to store list of anagrams.
+
+2. Iterate over the list of given input strings array to find anagrams.
+
+3. Create a character frequency array(`charFrequency`) with respect to 26 letters of alphabetics. Each value is assigned with zero.
+
+4. Iterate over the each character/letter of a string and update the character frequency.
+
+5. Calculate a unique hash key based on the character frequency.
+
+6. If the key already exists in the anagram object, append the new anagram to the list. Otherwise create a new anagram array for the given key.
+
+7. Repeat steps 3-6 until there are no strings available.
+
+8. Return group of anagrams in an array format.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(m * n)`, where `m` represents the number of strings and `n` represents length of each string. This is because we are traversing each string in the given list of strings. 
+
+Also, it requires space complexity of `O(m * n)` due to object/map data structure which store list of an arrays.