updated canJump

Author: Narahari-Sundaragopalan

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++;
+		}
+	}
+}