Add isomorphic strings

Author: sudheerj

README.md

@@ -206,6 +206,7 @@ List of Programs related to data structures and algorithms
 | 8 |   Letter combinations                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/8.letterCombinations/letterCombinations.md)                                                                                                                                                                                  | Medium       |    Backtracking with hash table mapping                 |
 | 9 |   LRU Cache                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/9.lruCache/lruCache.md)                                                                                                                                                                                  | Medium       |    Combination of Hash Table and doubly linked list                 |
 | 10 |   Maximum number of balloons                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/10.maximumBalloons/maximumBalloons.md)                                                                                                                                                                                  | Easy       |    Hash map on characters                 |
+| 11 |   Isomorphic Strings                          | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/11.isomorphicStrings/isomorphicStrings.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/11.isomorphicStrings/isomorphicStrings.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/11.isomorphicStrings/isomorphicStrings.md)                                                                                                                                                                                  | Easy       |    mapping characters using Hash maps                |
 
 ## Sorting
 

src/java1/algorithms/hashmap/isomorphicStrings/IsomorphicStrings.java

@@ -0,0 +1,44 @@
+package java1.algorithms.hashmap.isomorphicStrings;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class IsomorphicStrings {
+    private static boolean isIsomorphic(String s, String t){
+        if(s.length() != t.length()) {
+            return false;
+        }
+
+        Map<Character, Character> sMap = new HashMap<>();
+        Map<Character, Character> tMap = new HashMap<>();
+
+        for(int i=0; i<s.length(); i++) {
+            char charS = s.charAt(i);
+            char charT = t.charAt(i);
+            if(sMap.containsKey(charS)) {
+                if(sMap.get(charS) != charT) {
+                    return false;
+                }
+            } else {
+                sMap.put(charS, charT);
+            }
+
+            if(tMap.containsKey(charT)) {
+                if(tMap.get(charT) != charS) {
+                    return false;
+                }
+            } else {
+                tMap.put(charT, charS);
+            }
+        }
+
+        return true;
+    }
+
+    public static void main(String[] args) {
+        String s1 = "dad", t1 = "mom";
+        String s2 = "zoo", t2 = "cat";
+        System.out.println(isIsomorphic(s1, t1));
+        System.out.println(isIsomorphic(s2, t2));    
+    }
+}

src/java1/algorithms/hashmap/isomorphicStrings/IsomorphicStrings.md

@@ -0,0 +1,38 @@
+**Problem statement:**
+Given two strings `s` and `t`, determine if they are isomorphic or not.
+
+**Note:** Two strings can be called as isomorphic if the characters in one word can be replaced to get another word. You need to make sure that all occurrences of a character must be replaced with another character while preserving the order of characters. Also, no two unique characters map to the same character, but a character map to itself.
+
+## Examples:
+Example 1:
+
+Input: s = "dad", t="mom"
+
+Output: true
+
+
+Example 2: 
+
+Input: s = "zoo", t="cat"
+
+Output: false
+
+
+**Algorithmic Steps**
+This problem is solved with the help of maps to verify one-to-one mapping between every character of the first string to the second string. 
+
+1. Add a base case check by returning false when two strings lengths are not equal.
+    
+2. Define two hash maps(i.e, `sMap`, `tMap`) to track mappings between two strings.
+   
+3. Iterate over characters of given string(either string `s` or `t`).
+   1. If the current character of first string already exists in `sMap`, and if the current character in the first string has been mapped to a conflict character in the second string, return `false`indicating that given strings are not isomorphic. Otherwise(when there is no conflict mapping), add the character mapping in `sMap`. 
+   
+   2. If the current character of second string already exists in `tMap`, and if the current character in the second string has been mapped to a conflict character in the first string, return `false`indicating that given strings are not isomorphic. Otherwise(when there is no conflict mapping), add the character mapping in `tMap`. 
+   
+4. If the above iteration is complete without any conflicts, those two strings are considered as isomorphic. i.e, Return `true` indicating the given strings as isomorphic strings.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, Where `n` is the length of the input strings. This is because we traverse the string once and perform constant time operations for hash map lookups and insertions.
+
+Here, it takes time complexity of `O(n)`. This is because of the space required by two hash maps(i.e, `sMap`,`tMap`).

src/javascript/algorithms/hashtable/11.isomorphicStrings/isomorphicStrings.js

@@ -0,0 +1,30 @@
+function isIsomorphic(s, t) {
+    if(s.length !== t.length){
+        return false;
+    }
+    let sMap = new Map();
+    let tMap = new Map();
+
+    for (let i = 0; i < s.length; i++) {
+        if(sMap.has(s[i])) {
+            if(t[i] !== sMap.get(s[i])) {
+                return false;
+            }
+        } else {
+            sMap.set(s[i], t[i]);
+        }
+        if(tMap.has(t[i])) {
+            if(s[i] !== tMap.get(t[i])) {
+                return false;
+            }
+        } else {
+        tMap.set(t[i], s[i]);
+        }
+    }
+    return true;
+}
+
+const s1 = "dad", t1 = "mom";
+const s2 = "zoo", t2 = "cat";
+console.log(isIsomorphic(s1, t1));
+console.log(isIsomorphic(s2, t2));

src/javascript/algorithms/hashtable/11.isomorphicStrings/isomorphicStrings.md

@@ -0,0 +1,38 @@
+**Problem statement:**
+Given two strings `s` and `t`, determine if they are isomorphic or not.
+
+**Note:** Two strings can be called as isomorphic if the characters in one word can be replaced to get another word. You need to make sure that all occurrences of a character must be replaced with another character while preserving the order of characters. Also, no two unique characters map to the same character, but a character map to itself.
+
+## Examples:
+Example 1:
+
+Input: s = "dad", t="mom"
+
+Output: true
+
+
+Example 2: 
+
+Input: s = "zoo", t="cat"
+
+Output: false
+
+
+**Algorithmic Steps**
+This problem is solved with the help of maps to verify one-to-one mapping between every character of the first string to the second string. 
+
+1. Add a base case check by returning false when two strings lengths are not equal.
+    
+2. Define two hash maps(i.e, `sMap`, `tMap`) to track mappings between two strings.
+   
+3. Iterate over characters of given string(either string `s` or `t`).
+   1. If the current character of first string already exists in `sMap`, and if the current character in the first string has been mapped to a conflict character in the second string, return `false`indicating that given strings are not isomorphic. Otherwise(when there is no conflict mapping), add the character mapping in `sMap`. 
+   
+   2. If the current character of second string already exists in `tMap`, and if the current character in the second string has been mapped to a conflict character in the first string, return `false`indicating that given strings are not isomorphic. Otherwise(when there is no conflict mapping), add the character mapping in `tMap`. 
+   
+4. If the above iteration is complete without any conflicts, those two strings are considered as isomorphic. i.e, Return `true` indicating the given strings as isomorphic strings.
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(n)`, Where `n` is the length of the input strings. This is because we traverse the string once and perform constant time operations for hash map lookups and insertions.
+
+Here, it takes time complexity of `O(n)`. This is because of the space required by two hash maps(i.e, `sMap`,`tMap`).