Add valid anagram problem

Author: sudheerj

README.md

@@ -86,9 +86,9 @@ List of Programs related to data structures and algorithms
 
    3. Minimum window substring: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/3.minWindowSubstring/minWindowSubstring.md)
 
-   4. Valid anagram: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/validAnagram.js)
+   4. Valid anagram: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/4.validAnagram/validAnagram.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/4.validAnagram/validAnagram.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/4.validAnagram/validAnagram.md)
 
-   5. Group anagrams: [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/groupAnagrams.js)
+   5. Group anagrams: [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/5.groupAnagrams/groupAnagrams.js)  [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/5.groupAnagrams/groupAnagrams.js) [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/strings/5.groupAnagrams/groupAnagrams.md)
 
    6. Valid parentheses: [JavaScript]()
 

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

@@ -1,4 +1,4 @@
-package java1.algorithms.strings;
+package java1.algorithms.strings.groupAnagrams;
 
 import java.util.*;
 

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

@@ -1,24 +1,44 @@
-package java1.algorithms.strings;
+package java1.algorithms.strings.validAnagram;
 
+import java.util.Arrays;
 import java.util.HashMap;
 
 public class ValidAnagram {
 
-    //HashMap:- TC:O(n) SC:O(n)
+    //Using Array: TC:O(n) SC:O(1)
+
     private static boolean validAnagram1(String str1, String str2) {
+        if(str1.length() != str2.length()) return false;
+
+        int[] chars = new int[26];
+
+        for(int i=0; i< str1.length(); i++) {
+            char ch1 = str1.charAt(i);
+            char ch2 = str2.charAt(i);
+            chars[ch1 - 'a']++;
+            chars[ch2 - 'a']--;
+        }
+
+        for(int ch: chars) {
+            if(ch !=0) return false;
+        }
+
+        return true;
+    }
+
+    //HashMap:- TC:O(n) SC:O(n)
+    private static boolean validAnagram2(String str1, String str2) {
         if(str1.length() != str2.length()) {
             return false;
         }
 
         HashMap<Character, Integer> hashMap = new HashMap<>();
 
-        for(int i = 0; i< str1.length(); i++) {
-            char ch = str1.charAt(i);
+        for(char ch: str1.toCharArray()) {
             hashMap.put(ch, hashMap.getOrDefault(ch, 0) + 1);
         }
 
-        for(int j=0; j< str2.length(); j++) {
-            char ch = str2.charAt(j);
+        for(char ch: str2.toCharArray()) {
             if(hashMap.containsKey(ch)) {
                 if(hashMap.get(ch) == 1) {
                     hashMap.remove(ch);
@@ -30,34 +50,38 @@ private static boolean validAnagram1(String str1, String str2) {
             }
         }
 
-        if(hashMap.size() == 0) {
-            return true;
-        } else {
-            return false;
-        }
+        return hashMap.size() == 0;
     }
 
-    //Using Array: TC:O(n) SC:O(1)
+    //Sorting and compare built-in methods:- TC:O(n logn) SC:O(n)
+    private static boolean validAnagram3(String str1, String str2) {
+        if(str1.length() != str2.length()) {
+            return false;
+        }
 
-    private static boolean validAnagram2(String str1, String str2) {
-        if(str1.length() != str2.length()) return false;
+        char[] chars1 = str1.toCharArray();
+        char[] chars2 = str2.toCharArray();
+        
+        Arrays.sort(chars1);
+        Arrays.sort(chars2);
 
-        int[] chars = new int[26];
+        return Arrays.equals(chars1, chars2);
+    }
 
-        for(int i=0; i< str1.length(); i++) {
-            char ch1 = str1.charAt(i);
-            char ch2 = str2.charAt(i);
-            chars[ch1 - 'a']++;
-            chars[ch2 - 'a']--;
+    //Using Sort, split and join methods:- TC:O(n logn) SC:O(n)
+    private static boolean validAnagram4(String str1, String str2) {
+        if(str1.length() != str2.length()) {
+            return false;
         }
 
-        for(int ch: chars) {
-            if(ch !=0) return false;
-        }
+        String[] splitStr1 = str1.split("");
+        String[] splitStr2 = str2.split("");
 
-        return true;
-    }
+        Arrays.sort(splitStr1);
+        Arrays.sort(splitStr2);
 
+        return String.join("", splitStr1).equals(String.join("", splitStr2));
+    }
     public static void main(String[] args) {
         String s1 = "anagram", s2="nagaram";
         System.out.println(validAnagram1(s1, s2));
@@ -67,6 +91,16 @@ public static void main(String[] args) {
         String a1 = "anagram", a2="nagaram";
         System.out.println(validAnagram2(a1, a2));
         String b1 = "cat", b2="rat";
-        System.out.println(validAnagram1(b1, b2));
+        System.out.println(validAnagram2(b1, b2));
+
+        String x1 = "anagram", x2="nagaram";
+        System.out.println(validAnagram3(x1, x2));
+        String y1 = "cat", y2="rat";
+        System.out.println(validAnagram3(y1, y2));
+
+        String c1 = "anagram", c2="nagaram";
+        System.out.println(validAnagram4(c1, c2));
+        String d1 = "cat", d2="rat";
+        System.out.println(validAnagram4(d1, d2));
     }
 }

src/java1/algorithms/strings/ValidAnagram.java src/java1/algorithms/strings/validAnagram/ValidAnagram.java

@@ -0,0 +1,35 @@
+**Description:**
+Given two strings `str1` and `str2`, return `true` if `str2` is an anagram of `str1`, and `false` otherwise.
+
+**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: str1 = "anagram", str2 = "nagaram"
+Output: true
+
+Example 2:
+Input: str1 = "rat", str2 = "cat"
+Output: false
+
+**Algorithmic Steps**
+This problem is solved with the help of **frequency counting** approach using an array. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check whether both string lengths are equal or not. If they are not equal, return `false` because they cannot be anagrams anymore.
+
+2. Create an array named `charcharFrequencyArr` to hold the alphabetic(i.e, a-z) letter frequencies. By default, their count is initialized with 0.
+
+3. Iterate any of the input string to find the unicode of each character.
+
+4. Find the unicode for each index in both the strings.
+
+5. Calculate the index position of frequency array by substring the letter's ASCII value from unicode. Increment the frequency for first string and decrement the frequency for second string to balance the frequencies.
+
+6. Repeat steps 4-5 until there are no more characters in the string.
+
+7. Return `true` if every element's frequency is zero. Otherwise return `false` indicating that those two strings are not anagrams.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(n)`, where `n` represents length of the string. This is because we are traversing the string at most once. 
+
+Also, it requires space complexity of `O(1)`(i.e, `O(26)`) due to no other data structure used except fixed 26 letter array for the character frequencies.

src/java1/algorithms/strings/validAnagram/validAnagram.md

@@ -1,54 +1,53 @@
-// Sort and compare:- TC: O(n logn) SC: O(n)
-function validAnagram1(str1, str2) {
-    if(str1.length !== str2.length) return false;
-
-    return reorderStr(str1) === reorderStr(str2);
-}
-
-const reorderStr = (str) => 
-            str.split("")
-            .sort((a, b) => a.localeCompare(b))
-            .join("");
-
-
 // Using array:- TC:O(n) SC:O(1)
-function validAnagram2(str1, str2) {
+function validAnagram1(str1, str2) {
     if(str1.length !== str2.length) return false;
 
-    let chars = new Array(26).fill(0);
+    let charFrequencyArr = new Array(26).fill(0);
 
     for(let i=0; i< str1.length; i++) {
-        let ch1 = str1.charCodeAt(i);
-        let ch2 = str2.charCodeAt(i);
-        chars[ch1-97]++;
-        chars[ch2-97]--;
+        let charCode1 = str1.charCodeAt(i);
+        let charCode2 = str2.charCodeAt(i);
+        charFrequencyArr[charCode1-97]++;
+        charFrequencyArr[charCode2-97]--;
     }
 
-    return chars.every((n) => n === 0);
+    return charFrequencyArr.every((n) => n === 0);
 }
 
 // Using Map:- TC:O(n) SC: O(n)
-function validAnagram3(str1, str2) {
+function validAnagram2(str1, str2) {
     if(str1.length != str2.length) return false;
 
-    let map = new Map();
+    let charMap = new Map();
 
     for(let ch of str1) {
-        map.set(ch, (map.get(ch) || 0) + 1);
+        charMap.set(ch, (charMap.get(ch) || 0) + 1);
     }
 
     for(let ch of str2) {
-        if(map.has(ch)) {
-            map.set(ch, map.get(ch)-1);
-            if(map.get(ch) === 0) map.delete(ch);
+        if(charMap.has(ch)) {
+            charMap.set(ch, charMap.get(ch)-1);
+            if(charMap.get(ch) === 0) charMap.delete(ch);
         } else {
             return false;
         }
     }
 
-    if(map.size === 0) return true;
+    return charMap.size === 0;
+}
+
+// Sort and compare:- TC: O(n logn) SC: O(n)
+function validAnagram3(str1, str2) {
+    if(str1.length !== str2.length) return false;
+
+    return reorderStr(str1) === reorderStr(str2);
 }
 
+const reorderStr = (str) => 
+            str.split("")
+            .sort((a, b) => a.localeCompare(b))
+            .join("");
+
 
 let a1="anagram", a2="nagaram";
 console.log(validAnagram1(a1, a2));

src/javascript/algorithms/strings/validAnagram.js src/javascript/algorithms/strings/4.validAnagram/validAnagram.js

@@ -0,0 +1,35 @@
+**Description:**
+Given two strings `str1` and `str2`, return `true` if `str2` is an anagram of `str1`, and `false` otherwise.
+
+**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: str1 = "anagram", str2 = "nagaram"
+Output: true
+
+Example 2:
+Input: str1 = "rat", str2 = "cat"
+Output: false
+
+**Algorithmic Steps**
+This problem is solved with the help of **frequency counting** approach using an array. The algorithmic approach can be summarized as follows:
+
+1. Add a preliminary check whether both string lengths are equal or not. If they are not equal, return `false` because they cannot be anagrams anymore.
+
+2. Create an array named `charcharFrequencyArr` to hold the alphabetic(i.e, a-z) letter frequencies. By default, their count is initialized with 0.
+
+3. Iterate any of the input string to find the unicode of each character.
+
+4. Find the unicode for each index in both the strings.
+
+5. Calculate the index position of frequency array by substring the letter's ASCII value from unicode. Increment the frequency for first string and decrement the frequency for second string to balance the frequencies.
+
+6. Repeat steps 4-5 until there are no more characters in the string.
+
+7. Return `true` if every element's frequency is zero. Otherwise return `false` indicating that those two strings are not anagrams.
+
+**Time and Space complexity:**
+This algorithm takes a time complexity of `O(n)`, where `n` represents length of the string. This is because we are traversing the string at most once. 
+
+Also, it requires space complexity of `O(1)`(i.e, `O(26)`) due to no other data structure used except fixed 26 letter array for the character frequencies.