EsLint and Tests fix

- A lot of files had Linting issues. Used EsLint to fix all the troublesome files. - Fixed the tests that were failing. Node Tests.js should run just fine now!

Author: hot9cups

LeetcodeProblems/Algorithms/2Sum.js

@@ -32,7 +32,7 @@ var twoSum = function (nums, target) {
  let map = {};
  for (let i = 0; i < nums.length; i++) {
  const sum = target - nums[i];
- if (map[parseInt(sum)] != 0) {
+ if (sum in map) {
  return [map[sum], i];
  } else {
  map[nums[i]] = i;
@@ -43,8 +43,8 @@ var twoSum = function (nums, target) {
 //Another method
 var twoSum2 = function (nums, target) {
  for (let i = 0; i < nums.length; i++) {
- for (let j = i + 1; j < nums.length; i++) {
- if (nums[1] + nums[j] === target) {
+ for (let j = i + 1; j < nums.length; j++) {
+ if (nums[i] + nums[j] === target) {
  return [i, j];
  }
  }

LeetcodeProblems/Algorithms/3SumClosest.js

@@ -30,31 +30,31 @@ Constraints:
  * @param {number} target
  * @return {number}
  */
- var threeSumClosest = function(nums, target) {
+var threeSumClosest = function(nums, target) {
  let mid = 1;
  let right = nums.length - 1;
  let currentSum = nums[0] + nums[mid] + nums[right];
  let closest = currentSum;
 
- nums.sort(function(a,b) {return a - b})
+ nums.sort(function(a,b) {return a - b;});
 
  for(var left = 0 ; left < nums.length - 1; left++) {
-  mid = left + 1;
-  right = nums.length - 1;
+ mid = left + 1;
+ right = nums.length - 1;
 
-  while(mid < right) {
-  currentSum = nums[left] + nums[mid] + nums[right];
+ while(mid < right) {
+ currentSum = nums[left] + nums[mid] + nums[right];
 
-  if(Math.abs(target - currentSum) < Math.abs(target - closest)) {
-  closest = currentSum;
-  }
+ if(Math.abs(target - currentSum) < Math.abs(target - closest)) {
+ closest = currentSum;
+ }
 
- if(currentSum > target) {
- right--;
- } else {
- mid++;
- }
+ if(currentSum > target) {
+ right--;
+ } else {
+ mid++;
  }
+ }
  }
 
  return closest;

LeetcodeProblems/Algorithms/Container_With_Most_Water.js

@@ -24,18 +24,18 @@ Output: 1
  * @param {number[]} height
  * @return {number}
  */
- var maxArea = function(height) {
+var maxArea = function(height) {
  let left = 0;
  let right = height.length - 1;
  let maxArea = calculateArea(left, right, height);
 
  while(left < right) {
-  if(height[left] < height[right]) {
-  left++
-  } else {
-  right--;
-  }
-  maxArea = Math.max(maxArea, calculateArea(left, right, height)) 
+ if(height[left] < height[right]) {
+ left++;
+ } else {
+ right--;
+ }
+ maxArea = Math.max(maxArea, calculateArea(left, right, height)); 
  }
  return maxArea;
 };
@@ -44,6 +44,6 @@ var calculateArea = function(x, y, height) {
  let minHeight = height[x] > height[y] ? height[y] : height[x];
  let width = y -x;
  return (width * minHeight);
-}
+};
 
 module.exports.maxArea = maxArea;

LeetcodeProblems/Algorithms/Find_Anagrams.js

@@ -30,51 +30,51 @@ The substring with start index = 2 is "ab", which is an anagram of "ab".
  * @param {string} p
  * @return {number[]}
  */
- var findAnagrams = function(s, p) {
- if(s.length < p.length) { return [] }
+var findAnagrams = function(s, p) {
+ if(s.length < p.length) { return []; }
 
  let start = 0;
  let end = p.length - 1;
  let hashBuild = {};
  let countLeft = p.length;
- let anagrams = []
+ let anagrams = [];
 
  for(let e = 0; e < p.length; e++) {
-  hashBuild[p[e]] = hashBuild[p[e]] !== undefined ? hashBuild[p[e]] + 1 : 1; 
+ hashBuild[p[e]] = hashBuild[p[e]] !== undefined ? hashBuild[p[e]] + 1 : 1; 
  }
 
  for(let i = start; i < end; i++) {
- if(hashBuild[s[i]] !== undefined) {
- hashBuild[s[i]] = hashBuild[s[i]] - 1;
- if(hashBuild[s[i]] >= 0) {
- countLeft--;
- }
+ if(hashBuild[s[i]] !== undefined) {
+ hashBuild[s[i]] = hashBuild[s[i]] - 1;
+ if(hashBuild[s[i]] >= 0) {
+ countLeft--;
  }
+ }
  }
 
  while(end < s.length) {
- // check left
- if(hashBuild[s[end]] !== undefined) {
- hashBuild[s[end]] = hashBuild[s[end]] - 1;
- if(hashBuild[s[end]] >= 0) {
- countLeft--;
- }
- if(countLeft == 0) {
- anagrams.push(start);
- } 
+ // check left
+ if(hashBuild[s[end]] !== undefined) {
+ hashBuild[s[end]] = hashBuild[s[end]] - 1;
+ if(hashBuild[s[end]] >= 0) {
+ countLeft--;
  }
+ if(countLeft == 0) {
+ anagrams.push(start);
+ } 
+ }
 
- // check right
- if(hashBuild[s[start]] !== undefined) {
- hashBuild[s[start]] = hashBuild[s[start]] + 1;
- if(hashBuild[s[start]] >= 1) {
- countLeft++;
- }
+ // check right
+ if(hashBuild[s[start]] !== undefined) {
+ hashBuild[s[start]] = hashBuild[s[start]] + 1;
+ if(hashBuild[s[start]] >= 1) {
+ countLeft++;
  }
+ }
 
-  // slide window
-  end++;
-  start++;
+ // slide window
+ end++;
+ start++;
  }
 
  return anagrams;

LeetcodeProblems/Algorithms/Find_Subarrays_With_Equal_Sum.js

@@ -35,7 +35,7 @@ Note that even though the subarrays have the same content, the two subarrays are
  * @param {number[]} nums
  * @return {boolean}
  */
- var findSubarrays = function (nums) {
+var findSubarrays = function (nums) {
  const sumsSeen = new Set();
 
  for (let i = 0; i < nums.length - 1; i++) {

LeetcodeProblems/Algorithms/Happy_Number.js

@@ -33,17 +33,17 @@ Output: false
  * @return {boolean}
  */
 var isHappy = function(n) {
-  return checkHappyNumber(n);
+ return checkHappyNumber(n);
 };
 
 function checkHappyNumber(n){
-   strNumber = n.toString();
-   splitNumber = strNumber.split("");
-  if(splitNumber.length <= 1){
-  return (n <= 1)? true:false;
-  }
-  const digit = splitNumber.reduce((a,b)=> parseInt(a) + Math.pow(parseInt(b),2),0);
-  return checkHappyNumber(digit)
+ let strNumber = n.toString();
+ let splitNumber = strNumber.split("");
+ if(splitNumber.length <= 1){
+ return (n <= 1)? true:false;
+ }
+ const digit = splitNumber.reduce((a,b)=> parseInt(a) + Math.pow(parseInt(b),2),0);
+ return checkHappyNumber(digit);
 }
 
 module.exports.isHappy = isHappy;

LeetcodeProblems/Algorithms/Longest_Common_Prefix.js

@@ -21,13 +21,13 @@ Explanation: There is no common prefix among the input strings.
  * @param {string[]} strs
  * @return {string}
  */
- var longestCommonPrefix = function(strs) {
+var longestCommonPrefix = function(strs) {
  if(strs.length === 0) return "";
 
  return strs.reduce((result, curr)=>{
-  let i = 0;
-  while(result[i] && curr[i] && result[i] === curr[i]) i++;
-  return result.slice(0, i);
+ let i = 0;
+ while(result[i] && curr[i] && result[i] === curr[i]) i++;
+ return result.slice(0, i);
  });
 };
 

LeetcodeProblems/Algorithms/Longest_Substring.js

@@ -32,8 +32,8 @@ s consists of English letters, digits, symbols and spaces.
  * @param {string} s
  * @return {number}
  */
- var lengthOfLongestSubstring = function(s) {
- if(s.length == 0) { return 0 }
+var lengthOfLongestSubstring = function(s) {
+ if(s.length == 0) { return 0; }
 
  var repeatedChars = new Set();
  var maxLength = 1;
@@ -45,15 +45,15 @@ s consists of English letters, digits, symbols and spaces.
  while(end + 1 < s.length && start < s.length) {
  if(repeatedChars.has(s.charAt(end + 1))) {
  if(repeatedChars.has(s.charAt(start))) {
-  currentMaxLength--;
-  repeatedChars.delete(s.charAt(start))
+ currentMaxLength--;
+ repeatedChars.delete(s.charAt(start));
  }
-  start++;
+ start++;
  } else {
  repeatedChars.add(s.charAt(end + 1));
  currentMaxLength++;
  if(currentMaxLength > maxLength) {
-  maxLength = currentMaxLength;
+ maxLength = currentMaxLength;
  }
  end++;
  }

LeetcodeProblems/Algorithms/Max_Consecutive_Ones_III.js

@@ -24,18 +24,18 @@ var longestOnes = function(nums, k) {
  let end = 0; 
  let maxWindow = 0;
  while(start < nums.length && end < nums.length) {
- if(k > 0 || nums[end] == 1) {
- if(nums[end] == 0) { k--; }
- maxWindow = Math.max(maxWindow, end - start + 1);
- end++;
- } else { // k = 0 and nums[end] == 0
- while(k == 0 && start < nums.length) {
- if(nums[start] == 0) {
- k++;
- }
- start++;
- }
+ if(k > 0 || nums[end] == 1) {
+ if(nums[end] == 0) { k--; }
+ maxWindow = Math.max(maxWindow, end - start + 1);
+ end++;
+ } else { // k = 0 and nums[end] == 0
+ while(k == 0 && start < nums.length) {
+ if(nums[start] == 0) {
+ k++;
+ }
+ start++;
  }
+ }
  }
 
  return maxWindow;

LeetcodeProblems/Algorithms/Maximise_Hour_Glass_Sum.js

@@ -31,18 +31,20 @@ Explanation: There is only one hourglass in the matrix, with the sum: 1 + 2 + 3
  * @param {number[][]} grid
  * @return {number}
  */
- var maxSum = function(grid) {
+var maxSum = function(grid) {
  const m = grid.length;
  const n = grid[0].length;
  if(m<3 || n < 3) {
-  return 0;
+ return 0;
  }
  let max = 0;
  for(let i = 0; i<m-2; i++)
-  for(let j = 0; j<n-2;j++)
-  {
-  let cur = grid[i][j] + grid[i][j+1] + grid[i][j+2] + grid[i+1][j+1] + grid[i+2][j] + grid[i+2][j+1] + grid[i+2][j+2];
-  max = Math.max(cur, max);
-  }
+ for(let j = 0; j<n-2;j++)
+ {
+ let cur = grid[i][j] + grid[i][j+1] + grid[i][j+2] + grid[i+1][j+1] + grid[i+2][j] + grid[i+2][j+1] + grid[i+2][j+2];
+ max = Math.max(cur, max);
+ }
  return max; 
-};
+};
+
+module.exports.maxSum = maxSum;