Add letter combinations algorithm

Author: sudheerj

README.md

@@ -197,6 +197,7 @@ List of Programs related to data structures and algorithms
 | 5 |   Verify Common Elements                            | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/5.verifyCommonElements/verifyCommonElements.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/5.verifyCommonElements/verifyCommonElements.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/5.verifyCommonElements/verifyCommonElements.md)                                                                                                                                                                                  | Easy       |    Using Map methods                     |
 |  6  | Longest consequtive sequence |[Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.js) | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.js) | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/6.longestConsecutiveSequence/longestConsecutiveSequence.md) |                                                                     Medium                                                                     | Find sequence using set or hash table |
 | 7 |   Valid Sudoku                           | [Source](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                           | [JavaScript](https://livecodes.io/?console&x=https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.js)                                                                                                                                                                                                               | [Documentation](https://github.com/sudheerj/datastructures-algorithms/blob/master/src/javascript/algorithms/hashtable/7.validSudoku/validSudoku.md)                                                                                                                                                                                  | Medium       |    Using Map and Set methods                     |
+| 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                 |
 
 ## Sorting
 

src/images/calculator.png

@@ -0,0 +1,47 @@
+package java1.algorithms.hashmap.letterCombinations;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+class LetterCombinations {
+
+    private static List<String> letterCombinations(String digits){
+        List<String> combinations = new ArrayList<>();
+        if(digits.isEmpty()) {
+            return combinations;
+        }
+
+        Map<Character, String> digitToChar = new HashMap<>();
+        digitToChar.put('2', "abc");
+        digitToChar.put('3', "def");
+        digitToChar.put('4', "ghi");
+        digitToChar.put('5', "jkl");
+        digitToChar.put('6', "mno");
+        digitToChar.put('7', "pqrs");
+        digitToChar.put('8', "tuv");
+        digitToChar.put('9', "wxyz");
+
+        backtrack(0, "", digits, digitToChar, combinations);
+        return combinations;
+    }
+
+    private static void backtrack(int i, String currStr, String digits, Map<Character, String> digitToChar, List<String> combinations) {
+        if(digits.length() == currStr.length()) {
+            combinations.add(currStr);
+            return;
+        }
+
+        for (char ch : digitToChar.get(digits.charAt(i)).toCharArray()) {
+            backtrack(i+1, currStr+ch, digits, digitToChar, combinations);
+        }
+    }
+    public static void main(String[] args) {
+        String digits1 = "24";
+        String digits2 = "";
+        System.out.println(letterCombinations(digits1));
+        System.out.println(letterCombinations(digits2));
+
+    }
+}

src/images/letter-combinations.png

@@ -0,0 +1,46 @@
+**Problem statement:**
+Given a string `digits` contain digits 2-9 inclusive, and each digit(except 1) is mapped to a set of characters. Return all possible letter combinations that the number could represent. 
+
+**Note:** The output can be written in any order. The mapping of digits to letters is shown below:
+
+![Screenshot](../../../../images/calculator.png)
+
+## Examples:
+Example 1:
+
+Input: digits = "24"
+
+Output: ["ag","ah","ai","bg","bh","bi","cg","ch","ci"]
+
+![Screenshot](../../../../images/letter-combinations.png)
+
+Example 2: 
+
+Input: digits = ""
+
+Output: []
+
+
+**Algorithmic Steps**
+This problem is solved with the help of backtracking recursive solution by generating all possible combinations of letters for respective digits. The mapping between digits(2-9) and letters is taken care by map datastructure. The algorithmic approach can be summarized as follows: 
+
+1. Initialize an empty array `combinations` to store the final letter combinations.
+    
+2. Handle the edge case by returning empty combinations array if the given string `digits` is empty.
+   
+3. Create a digit(2-9) to character mapping using a map called `digitToChar`. 
+
+4. Create a backtracking function to generate letter combinations for given digits string.
+   1. Add a base case to include letter combination for given string. i.e If the length of digits string is equals to current string(`digits`), add that current string to `combinations` and return.
+   2. Iterate over all possible letters of a current digit. For each iteration, recursively call backtracking function with incremented index(`i+1`) and updated current string(`currStr`).
+   3. Continue this process until all possible combinations added.
+   
+5. Invoke the backtracking function with in main function. The function is called with index 0 and empty current string.
+   
+6. Return `combinations` indicating the possible combinations of digits string.
+   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(4^n)`, Where `n` is the number of digits in a given string. This is because the backtrack function needs to generate all possible combinations of letters. For each digit, there are upto 4 possible characters(for example, 7-> "pqrs" and 9->"wxyz"). If there are `n` digits in a given string, the maximum number of possible combinations is `O(4^n)`. Building each combination involves appending character one by one, and each combination takes `O(n)`. Hence, the overall time complexity ois `O(n * 4^n)`.
+
+Here, the maximum possible combinations of letters are `4^n` ,and each combination has a length of `n`. So it takes a space complexity of `O(n * 4^n)`.

src/java1/algorithms/hashmap/letterCombinations/LetterCombinations.java

@@ -0,0 +1,37 @@
+function letterCombinations(digits){
+    let combinations = [];
+    if(digits.length === 0) {
+        return combinations;
+    }
+    let digitToChar = new Map();
+
+    digitToChar.set('2', "abc");
+    digitToChar.set('3', "def");
+    digitToChar.set('4', "ghi");
+    digitToChar.set('5', "jkl");
+    digitToChar.set('6', "mno");
+    digitToChar.set('7', "pqrs");
+    digitToChar.set('8', "tuv");
+    digitToChar.set('9', "wxyz");
+
+    backtrack(0, "", digits, digitToChar, combinations);
+
+    return combinations;
+}
+
+function backtrack(i, currStr, digits, digitToChar, combinations){
+    if(digits.length === currStr.length) {
+        combinations.push(currStr);
+        return;
+    }
+
+    for (const ch of digitToChar.get(digits[i])) {
+        backtrack(i+1, currStr+ch, digits, digitToChar, combinations);
+    }
+}
+
+let digits1 = "24";
+let digits2 = "";
+console.log(letterCombinations(digits1));
+console.log(letterCombinations(digits2));
+

src/java1/algorithms/hashmap/letterCombinations/LetterCombinations.md

@@ -0,0 +1,46 @@
+**Problem statement:**
+Given a string `digits` contain digits 2-9 inclusive, and each digit(except 1) is mapped to a set of characters. Return all possible letter combinations that the number could represent. 
+
+**Note:** The output can be written in any order. The mapping of digits to letters is shown below:
+
+![Screenshot](../../../../images/calculator.png)
+
+## Examples:
+Example 1:
+
+Input: digits = "24"
+
+Output: ["ag","ah","ai","bg","bh","bi","cg","ch","ci"]
+
+![Screenshot](../../../../images/letter-combinations.png)
+
+Example 2: 
+
+Input: digits = ""
+
+Output: []
+
+
+**Algorithmic Steps**
+This problem is solved with the help of backtracking recursive solution by generating all possible combinations of letters for respective digits. The mapping between digits(2-9) and letters is taken care by map datastructure. The algorithmic approach can be summarized as follows: 
+
+1. Initialize an empty array `combinations` to store the final letter combinations.
+    
+2. Handle the edge case by returning empty combinations array if the given string `digits` is empty.
+   
+3. Create a digit(2-9) to character mapping using a map called `digitToChar`. 
+
+4. Create a backtracking function to generate letter combinations for given digits string.
+   1. Add a base case to include letter combination for given string. i.e If the length of digits string is equals to current string(`digits`), add that current string to `combinations` and return.
+   2. Iterate over all possible letters of a current digit. For each iteration, recursively call backtracking function with incremented index(`i+1`) and updated current string(`currStr`).
+   3. Continue this process until all possible combinations added.
+   
+5. Invoke the backtracking function with in main function. The function is called with index 0 and empty current string.
+   
+6. Return `combinations` indicating the possible combinations of digits string.
+   
+
+**Time and Space complexity:**
+This algorithm has a time complexity of `O(4^n)`, Where `n` is the number of digits in a given string. This is because the backtrack function needs to generate all possible combinations of letters. For each digit, there are upto 4 possible characters(for example, 7-> "pqrs" and 9->"wxyz"). If there are `n` digits in a given string, the maximum number of possible combinations is `O(4^n)`. Building each combination involves appending character one by one, and each combination takes `O(n)`. Hence, the overall time complexity ois `O(n * 4^n)`.
+
+Here, the maximum possible combinations of letters are `4^n` ,and each combination has a length of `n`. So it takes a space complexity of `O(n * 4^n)`.