Merge branch 'master' of https://github.com/Narahari-Sundaragopalan/vanillaJSProjects

Author: Narahari-Sundaragopalan

concepts/Promises.md

@@ -60,11 +60,11 @@ const delay = () => {
     });
 }
 
-delay().then(sayHello);
-
 const sayHello = (value) => {
     console.log('Hello');
 }
+
+delay().then(sayHello);
 ```
 
 > This challenge we'll chain promises together using ".then" Create two variables: firstPromise and secondPromise Set secondPromise to be a promise that resolves to "Second!" Set firstPromise to be a promise that resolves to secondPromise Call the firstPromise with a ".then", which will return the secondPromise> promise. Then print the contents of the promise after it has been resolved by passing console.log to .then

exercises/leetcode/letterCombinations.js

@@ -0,0 +1,49 @@
+/**
+ * Given a string containing digits from 2-9 inclusive, return all possible letter combinations that the number could represent.
+
+A mapping of digit to letters (just like on the telephone buttons) is given below. Note that 1 does not map to any letters
+
+Example:
+
+Input: "23"
+Output: ["ad", "ae", "af", "bd", "be", "bf", "cd", "ce", "cf"].
+ */
+
+let output = [];
+const phoneNumberMap = new Map();
+phoneNumberMap.set("2", "abc");
+phoneNumberMap.set("3", "def");
+phoneNumberMap.set("4", "ghi");
+phoneNumberMap.set("5", "jkl");
+phoneNumberMap.set("6", "mno");
+phoneNumberMap.set("7", "pqrs");
+phoneNumberMap.set("8", "tuv");
+phoneNumberMap.set("9", "wxyz");
+
+const backtrack = (combination, nextDigits) => {
+	if (nextDigits.length === 0) {
+		output.push(combination);
+	} else {
+		let digit = nextDigits.substring(0, 1);
+		let letters = phoneNumberMap.get(digit);
+
+		for (let i = 0; i < letters.length; i++) {
+			let letter = phoneNumberMap.get(digit).substring(i, i+1);
+			backtrack(combination + letter, nextDigits.substring(1));
+		}
+	}
+}
+
+const letterCombinations = digits => {
+	output = [];
+	if (digits.length !== 0) {
+		backtrack("", digits);
+	}
+
+	return output;
+}
+
+/**
+ * Time Complexity: 3 ^ N x 4 ^ M
+ * Space Complexity: 3 ^ N x 4 ^ M
+ */

exercises/leetcode/populateNextRightPointer-II.js

@@ -62,4 +62,9 @@ const connect = root => {
 		}
 	}
 	return root;
-}
+}
+
+/**
+ * Time Complexity: O(N)
+ * Space Complexity: O(1)
+ */

exercises/leetcode/populateNextRightPointer.js

@@ -0,0 +1,65 @@
+/**
+ * You are given a perfect binary tree where all leaves are on the same level, and every parent has two children. 
+ * The binary tree has the following definition:
+
+struct Node {
+  int val;
+  Node *left;
+  Node *right;
+  Node *next;
+}
+Populate each next pointer to point to its next right node. If there is no next right node, the next pointer should be set to NULL.
+
+Initially, all next pointers are set to NULL.
+ */
+
+class Queue {
+	constructor() {
+		this.data = [];
+	}
+	add(val) {
+		this.data.push(val);
+	}
+	remove() {
+		return this.data.shift();
+	}
+	peek() {
+		return this.data[0];
+	}
+	size() {
+		this.data.length;
+	}
+}
+
+const connect = root => {
+	if (root === null) {
+		return root;
+	}
+
+	// create a queue to push nodes from each level
+	const queue = new Queue();
+
+	queue.add(root);
+	while (queue.size() > 0) {
+		// we want to do BFS so we take the size of each level
+		let size = queue.size();
+
+		for (let i = 0; i < size; i++) {
+			let node = queue.remove();
+
+			if (i < size - 1) {
+				node.next = queue.peek();
+			}
+
+			if (node.left !== null) {
+				queue.add(node.left);
+			}
+
+			if (node.right !== null) {
+				queue.add(node.right);
+			}
+		}
+	}
+
+	return root;
+}