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

Author: Narahari-Sundaragopalan

concepts/Currying.md

@@ -80,4 +80,55 @@ console.log(snowDragons);
 
 ## Conclusion
 
-> A curryable function is a function that takes every argument by itself and returns a new function that expects the next dependency to the function until all dependencies are fulfilled and the final value is returned
+> A curryable function is a function that takes every argument by itself and returns a new function that expects the next dependency to the function until all dependencies are fulfilled and the final value is returned
+
+### Question with Currying, Recursion, Closures
+
+> sum(1)(2)(3)(4)..(n)() | Amazon UI/Frontend Javascript Interview Question
+
+```js
+const sum = function(a) {
+	return function(b) {
+		return function(c) {
+			return function(d) {
+				...
+				...
+				...
+				return a + b + c + d + ... n;
+			}
+		}
+	}
+}
+
+// Recursive way to solve the problem as we see a repeating pattern
+
+const sum = function(a) {
+	return function(b) {
+		if (b) {
+			return sum(a + b);
+		} else {
+			return a;
+		}
+	}
+}
+
+// The above recursive solution, will keep returning a function (the sum function in above case, until arguments are provided)
+// While returning a function each time, the arguments are added and the sum function gets called
+// The sum function returns a function with the value passed in parameter 'a' stored in lexical scope or through the closure concept
+// Once there are no more arguments specified, we simply return the value of 'a' which is the added total result
+
+// In ES6 syntax:
+
+const sum = a => {
+	return b => {
+		if (b) {
+			return sum(a + b);
+		} else {
+			return a;
+		}
+	}
+}
+
+// Simplified to one line
+const sum = a => b => b ? sum(a + b) : a;
+```

exercises/leetcode/google/canJump.js

@@ -1,3 +1,25 @@
+/**
+ * Given an array of non-negative integers, you are initially positioned at the first index of the array.
+
+Each element in the array represents your maximum jump length at that position.
+
+Determine if you are able to reach the last index.
+
+Example 1:
+
+Input: [2,3,1,1,4]
+Output: true
+Explanation: Jump 1 step from index 0 to 1, then 3 steps to the last index.
+Example 2:
+
+Input: [3,2,1,0,4]
+Output: false
+Explanation: You will always arrive at index 3 no matter what. Its maximum
+             jump length is 0, which makes it impossible to reach the last index.
+ */
+
+ // O(n2) : Time Complexity
+ // O(n) : Space Complexity
 const INDEX = {
     'G': 'GOOD',
     'B': 'BAD',
@@ -22,4 +44,18 @@ const canJump = nums => {
     }
 
     return map[0] == INDEX.G;
+}
+
+// Greedy Approach
+
+const canJump = nums => {
+	let lastPos = nums.length - 1;
+
+	for (let i = nums.length - 1; i >= 0; i--) {
+		if (i + nums[i] >= lastPos) {
+			lastPos = i;
+		}
+	}
+
+	return lastPos == 0;
 }

exercises/leetcode/sortColors.js

@@ -0,0 +1,37 @@
+/**
+ * Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent,
+ * with the colors in the order red, white and blue.
+
+Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.
+
+Note: You are not suppose to use the library's sort function for this problem.
+
+Example:
+
+Input: [2,0,2,1,1,0]
+Output: [0,0,1,1,2,2]
+Follow up:
+
+A rather straight forward solution is a two-pass algorithm using counting sort.
+First, iterate the array counting number of 0's, 1's, and 2's, then overwrite array with total number of 0's, then 1's and followed by 2's.
+Could you come up with a one-pass algorithm using only constant space?
+ */
+
+const sortColors = nums => {
+	let p0 = 0;
+	let curr = 0;
+	let p2 = nums.length - 1;
+
+	while (curr <= p2) {
+		if (nums[curr] === 0) {
+			[nums[curr], nums[p0]] = [nums[p0], nums[curr]];
+			curr++;
+			p0++;
+		} else if (nums[curr] === 2) {
+			[nums[curr], nums[p2]] = [nums[p2], nums[curr]];
+			p2--;
+		} else {
+			curr++;
+		}
+	}
+}