Add valid anagram solution

Author: sudheerj

src/java1/algorithms/strings/ValidAnagram.java

@@ -0,0 +1,72 @@
+package java1.algorithms.strings;
+
+import java.util.HashMap;
+
+public class ValidAnagram {
+    
+    //HashMap:- TC:O(n) SC:O(n)
+    private static boolean validAnagram1(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);
+            hashMap.put(ch, hashMap.getOrDefault(ch, 0) + 1);
+        }
+
+        for(int j=0; j< str2.length(); j++) {
+            char ch = str2.charAt(j);
+            if(hashMap.containsKey(ch)) {
+                if(hashMap.get(ch) == 1) {
+                    hashMap.remove(ch);
+                } else if(hashMap.get(ch) > 1) {
+                    hashMap.put(ch, hashMap.get(ch)-1);
+                }
+            } else {
+                return false;
+            }
+        }
+
+        if(hashMap.size() == 0) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    //Using Array: TC:O(n) SC:O(1)
+
+    private static boolean validAnagram2(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;
+    }
+
+    public static void main(String[] args) {
+        String s1 = "anagram", s2="nagaram";
+        System.out.println(validAnagram1(s1, s2));
+        String t1 = "cat", t2="rat";
+        System.out.println(validAnagram1(t1, t2));
+
+        String a1 = "anagram", a2="nagaram";
+        System.out.println(validAnagram2(a1, a2));
+        String b1 = "cat", b2="rat";
+        System.out.println(validAnagram1(b1, b2));
+    }
+}

src/java1/algorithms/strings/longestRepeatingCharReplacement.java

@@ -1,7 +1,7 @@
 //Sliding window: TC:O(n) SC: O(1)
 package java1.algorithms.strings;
 
-public class longestRepeatingCharReplacement {
+public class LongestRepeatingCharReplacement {
     private static int longestCharReplacement(String str, int target) {
         int[] charCount = new int[26];
         int maxLength = 0;

src/java1/algorithms/strings/longestSubstringWithoutRepeatingChar.java

@@ -3,7 +3,7 @@
 
 import java.util.HashSet;
 
-public class longestSubstringWithoutRepeatingChar {
+public class LongestSubstringWithoutRepeatingChar {
     private static int longestSubstringLengthWithoutRepeatingChar(String str) {
         HashSet<Character> hashset = new HashSet<>();
         int left = 0, max = 0;

src/javascript/algorithms/strings/validAnagram.js

@@ -0,0 +1,60 @@
+// 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) {
+    if(str1.length !== str2.length) return false;
+
+    let chars = 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]--;
+    }
+
+    return chars.every((n) => n === 0);
+}
+
+// Using Map:- TC:O(n) SC: O(n)
+function validAnagram3(str1, str2) {
+    if(str1.length != str2.length) return false;
+
+    let map = new Map();
+
+    for(let ch of str1) {
+        map.set(ch, (map.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);
+        } else {
+            return false;
+        }
+    }
+     
+    if(map.size === 0) return true;
+}
+
+
+let a1="anagram", a2="nagaram";
+console.log(validAnagram1(a1, a2));
+console.log(validAnagram2(a1, a2));
+console.log(validAnagram3(a1, a2));
+let b1="cat", b2="rat";
+console.log(validAnagram1(b1, b2));
+console.log(validAnagram2(b1, b2));
+console.log(validAnagram3(b1, b2));