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

Author: Narahari-Sundaragopalan

exercises/leetcode/increasingTriplet.js

@@ -0,0 +1,38 @@
+/**
+ * Given an unsorted array return whether an increasing subsequence of length 3 exists or not in the array.
+
+Formally the function should:
+
+Return true if there exists i, j, k
+such that arr[i] < arr[j] < arr[k] given 0 ≤ i < j < k ≤ n-1 else return false.
+Note: Your algorithm should run in O(n) time complexity and O(1) space complexity.
+
+Example 1:
+
+Input: [1,2,3,4,5]
+Output: true
+Example 2:
+
+Input: [5,4,3,2,1]
+Output: false
+ */
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+const increasingTriplet = nums => {
+	let first = Number.MAX_SAFE_INTEGER;
+	let second = Number.MAX_SAFE_INTEGER;
+
+	for (let num of nums) {
+		if (num <= first) {
+			first = num;
+		} else if (num <=second) {
+			second = num;
+		} else {
+			return true;
+		}
+	}
+
+	return false;
+}

exercises/leetcode/jumpGame.js

@@ -0,0 +1,61 @@
+/**
+ * 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.
+
+Your goal is to reach the last index in the minimum number of jumps.
+
+Example:
+
+Input: [2,3,1,1,4]
+Output: 2
+Explanation: The minimum number of jumps to reach the last index is 2.
+    Jump 1 step from index 0 to 1, then 3 steps to the last index.
+Note:
+
+You can assume that you can always reach the last index.
+ */
+
+const minJump = nums => {
+	const jumpsArray = [0];
+
+	for (let i = 1; i < nums.length; i++) {
+		jumpsArray[i] = Number.MAX_SAFE_INTEGER;
+	}
+	for (let i = 1; i < nums.length; i++) {
+		for (let j = 0; j < i; j++) {
+			if (i <= j + nums[j]) {
+				jumpsArray[i] = Math.min(jumpsArray[i], jumpsArray[j] + 1);
+			}
+		}
+	}
+
+	return jumpsArray[jumpsArray.length - 1];
+}
+
+// Optimal Solution
+
+const jump = nums => {
+	if (nums.length < 2) {
+		return 0;
+	}
+
+	let i = 0;
+	let jumps = 0;
+
+	while (i + nums[i] < nums.length - 1) {
+		let maxVal = 0;
+		let maxValIndex = 0;
+
+		for (let j = 1; j <= nums[i]; j++) {
+			if (nums [i + j] + j > maxVal) {
+				maxVal = nums[i + j] + j;
+				maxValIndex = i + j;
+			}
+		}
+		i = maxValIndex;
+		jumps++;
+	}
+
+	return jumps + 1;
+}

exercises/leetcode/missingRanges.js

@@ -0,0 +1,32 @@
+/**
+ * Given a sorted integer array nums, where the range of elements are in the inclusive range [lower, upper], return its missing ranges.
+
+Example:
+
+Input: nums = [0, 1, 3, 50, 75], lower = 0 and upper = 99,
+Output: ["2", "4->49", "51->74", "76->99"]
+ */
+
+/**
+ * @param {number[]} nums
+ * @param {number} lower
+ * @param {number} upper
+ * @return {string[]}
+ */
+const missingRanges = (nums, lower, upper) => {
+	nums = [lower - 1, ...nums, upper + 1];
+
+	const results = [];
+
+	for (let i = 1; i < nums.length; i++) {
+		if (nums[i] !== nums[i - 1] && nums[i] - 1 !== nums[i -1]) {
+			let num1 = nums[i - 1] + 1;
+			let num2 = nums[i] - 1;
+			results.push(
+				num1 + (num2 === num1 ? "" : "->" + num2)
+			);
+		}
+	}
+
+	return results;
+}