Merge pull request #1153 from aakhtar3/greedy

refactor: js - greedy

Author: aakhtar3

javascript/134-Gas-Station.js

@@ -10,9 +10,7 @@ var canCompleteCircuit = function (gas, cost) {
     let res = 0;
 
     //Checks if theres enough gas to complete a cycle
-    if (gas.reduce((a, b) => a + b) - cost.reduce((a, b) => a + b) < 0) {
-        return -1;
-    }
+    if (gas.reduce((a, b) => a + b) - cost.reduce((a, b) => a + b) < 0) return -1;
 
     // Finds the first appearence of a positive netDistance, if the cycle can't
     // be completed (netDistance < 0), starts cycle again @ the next positive netDistance value.
@@ -24,5 +22,27 @@ var canCompleteCircuit = function (gas, cost) {
             res = i + 1;
         }
     }
+    
     return res;
 };
+
+/**
+ * @param {number[]} gas
+ * @param {number[]} cost
+ * @return {number}
+ */
+ var canCompleteCircuit = function(gas, cost) {
+    let [ totalTank, currTank, startingStation ] = [ 0, 0, 0 ]
+
+    for (let i = 0; i < gas.length; i++) {
+        totalTank += gas[i] - cost[i];
+        currTank += gas[i] - cost[i];
+        
+        const isEmpty = currTank < 0;
+        if (isEmpty) { startingStation = (i + 1); currTank = 0; }
+    }
+    
+    return 0 <= totalTank
+        ? startingStation 
+        : -1;
+}

javascript/1899-Merge-Triplets-to-Form-Target-Triplet.js

@@ -25,3 +25,46 @@ var mergeTriplets = function (triplets, target) {
 
     return good.size === 3;
 };
+
+/**
+ * https://leetcode.com/problems/merge-triplets-to-form-target-triplet/
+ * Time O(N) | Space O(1)
+ * @param {number[][]} triplets
+ * @param {number[]} target
+ * @return {boolean}
+ */
+ var mergeTriplets = function(triplets, target, res = new Array(3).fill(0)) { 
+    for (const [ a, b, c ] of triplets) {          /* Time O(N) */
+        const [ _a, _b, _c ] = target;
+
+        const isTargetGreater = (a <= _a) && (b <= _b) && (c <= _c);
+        if (!isTargetGreater) continue;
+
+        const [ __a, __b, __c ] = res;
+        res = [ Math.max(__a, a), Math.max(__b, b), Math.max(__c, c) ];
+    }
+        
+    return res.every((val, i) => val === target[i])/* Time O(N) */
+};
+
+/**
+ * https://leetcode.com/problems/merge-triplets-to-form-target-triplet/
+ * Time O(N) | Space O(1)
+ * @param {number[][]} triplets
+ * @param {number[]} target
+ * @return {boolean}
+ */
+var mergeTriplets = function(triplets, target, res = new Array(3).fill(false)) { 
+    for (const [ a, b, c ] of triplets) {/* Time O(N) */
+        const [ _a, _b, _c ] = target;
+        
+        const isTargetGreater = (a <= _a) && (b <= _b) && (c <= _c);
+        if (!isTargetGreater) continue;
+        
+        res[0] |= (a === _a);
+        res[1] |= (b === _b);
+        res[2] |= (c === _c);
+    }
+    
+    return res[0] && res[1] && res[2];
+}

javascript/45-Jump-Game-II.js

@@ -1,27 +1,47 @@
 /**
  * https://leetcode.com/problems/jump-game-ii/
- * Time: O(n)
+ * Time O(N) | Space O(1)
  * @param {number[]} nums
  * @return {number}
  */
 var jump = function (nums) {
-    //Start at index 0
-    let left = 0;
-    let right = 0;
-    let jumps = 0;
+    let [ left, right, jumps ] = [ 0, 0, 0 ];
 
-    //Once right >= last index, the last jump can be made
     while (right < nums.length - 1) {
-        let maxReach = 0;
-
-        //Use maxReach of previous jump to find the maxReach of the current jump
-        for (var i = left; i < right + 1; i++) {
-            maxReach = Math.max(maxReach, nums[i] + i);
-        }
+        const maxReach = getMaxReach(nums, left, right);
 
         left = right + 1;
         right = maxReach;
         jumps += 1;
     }
+
     return jumps;
 };
+
+const getMaxReach = (nums, left, right, maxReach = 0) => {
+    for (let i = left; i < right + 1; i++) {
+        const reach = nums[i] + i;
+        maxReach = Math.max(maxReach, reach);
+    }
+
+    return maxReach;
+}
+
+/**
+ * https://leetcode.com/problems/jump-game-ii/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+ var jump = function(nums) {
+    let [ jumps, currentJumpEnd, farthest ] = [ 0, 0, 0];
+    
+    for (let i = 0; i < nums.length - 1; i++) {
+        farthest = Math.max(farthest, (i + nums[i]));
+
+        const canJump = i === currentJumpEnd
+        if (canJump) { jumps++; currentJumpEnd = farthest; }
+    }
+
+    return jumps;
+}

javascript/53-Maximum-Subarray.js

@@ -1,14 +1,76 @@
 /**
+ * https://leetcode.com/problems/maximum-subarray/
+ * Time O(N^2) | Space O(1)
  * @param {number[]} nums
  * @return {number}
  */
-var maxSubArray = function (nums) {
-    let curr = nums[0];
-    let max = nums[0];
+ var maxSubArray = function(nums, maxSum = -Infinity) {
+    for (let i = 0, sum = 0; i < nums.length; i++) {
+        for (let j = i; j < nums.length; j++) {
+            sum += nums[j];
+            maxSum = Math.max(maxSum, sum);
+        }
+    }
+
+    return maxSum;
+}
+
+/**
+ * https://leetcode.com/problems/maximum-subarray/
+ * Time O(N * log(N)) | Space O(log(N))
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums, left = 0, right = nums.length - 1) {
+    const isBaseCase = (right < left)
+    if (isBaseCase) return -Infinity;
+
+    const mid = (left + right) >> 1;
+    const guess = nums[mid];
+    const leftSum = getLeftSumFromMid(nums, mid, left)
+    const rightSum = getRightSumFromMid(nums, mid, right)
+    const sum = guess + leftSum + rightSum;
+    
+    const leftHalf = maxSubArray(nums, left, (mid - 1));
+    const rightHalf = maxSubArray(nums, (mid + 1), right);
+
+    return Math.max(sum, leftHalf, rightHalf);
+}
 
+const getLeftSumFromMid = (nums, mid, left, sum = 0, maxSum = 0) => {
+    for (let i = (mid - 1); left <= i; i--) {
+        sum += nums[i];
+        maxSum = Math.max(maxSum, sum);
+    }
+    
+    return maxSum;
+}
+
+const getRightSumFromMid = (nums, mid, right, sum = 0, maxSum = 0) => {
+    for (let i = (mid + 1); i <= right; i++) {
+        sum += nums[i];
+        maxSum = Math.max(maxSum, sum);
+    }
+    
+    return maxSum;
+}
+
+/**
+ * https://leetcode.com/problems/maximum-subarray/
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {number}
+ */
+var maxSubArray = function(nums) {
+    let [ runningSum, maxSum ] = [ nums[0], nums[0] ]
+    
     for (let i = 1; i < nums.length; i++) {
-        curr = Math.max(curr + nums[i], nums[i]);
-        max = Math.max(max, curr);
+        const num = nums[i]
+        const sum = runningSum + num
+        
+        runningSum = Math.max(num, sum)
+        maxSum = Math.max(maxSum, runningSum)
     }
-    return max;
-};
+    
+    return maxSum
+};

javascript/55-Jump-Game.js

@@ -1,15 +1,98 @@
 /**
+ * Time O(2^N) | Space O(N)
  * @param {number[]} nums
  * @return {boolean}
  */
-var canJump = function (nums) {
-    let goal = nums.length - 1;
+ var canJump = (nums, index = 0) => {
+    const isBaseCase = index === nums.length - 1;
+    if (isBaseCase) return true;
 
-    for (let i = nums.length - 2; i >= 0; i--) {
-        if (i + nums[i] >= goal) {
-            goal = i;
+    const furthestJump = Math.min(index + nums[index], (nums.length - 1));
+    for (let nextIndex = (index + 1); nextIndex <= furthestJump; nextIndex++) {
+        if (canJump(nums, nextIndex)) return true;
+    }
+
+    return false;
+}
+
+/**
+ * Time O(N^2) | Space O(N)
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = (nums) => {
+    const memo = new Array(nums.length).fill(0);
+    memo[memo.length - 1] = 1;
+    
+    return canJumpFromIndex(nums, memo);
+}
+
+const canJumpFromIndex = (nums, memo, index = 0) => {
+    if (memo[index] !== 0) return memo[index] === 1;
+
+    const furthestJump = Math.min(index + nums[index], nums.length - 1);
+    for (let nextIndex = (index + 1); nextIndex <= furthestJump; nextIndex++) {
+        if (!canJumpFromIndex(nums, memo, nextIndex)) continue
+
+        memo[index] = 1;
+        return true;
+    }
+
+    memo[index] = -1;
+    return false;
+}
+
+/**
+ * Time O(N^2) | Space O(N)
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = (nums) => {
+    const memo = new Array(nums.length).fill(0)
+    memo[memo.length - 1] = 1;
+
+    for (let i = (nums.length - 2); 0 <= i; i--) {
+        const furthestJump = Math.min(i + nums[i], nums.length - 1);
+        for (let j = (i + 1); j <= furthestJump; j++) {
+            const isGood = memo[j] === 1
+            if (isGood) { memo[i] = 1; break; }
         }
     }
-    if (goal === 0) return true;
-    else return false;
-};
+
+    return memo[0] === 1;
+}
+
+/**
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = (nums, max = 0, index = 0) => {
+    while (index < nums.length) {
+        const num = nums[index]
+        const jumps = num + index
+        
+        const canNotReachEnd = max < index
+        if (canNotReachEnd) return false
+        
+        max = Math.max(max, jumps)
+        index++
+    }
+
+    return true
+}
+
+/**
+ * Time O(N) | Space O(1)
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+var canJump = (nums, right = nums.length - 1) => {
+    for (let i = right; 0 <= i; i--) {
+        const isJumpable = right <= (i + nums[i])
+        if (isJumpable) right = i;
+    }
+
+    return right === 0;
+}
+