Merge branch 'master' into add/longest-common-prefix

Author: ignacio-chiazzo

LeetcodeProblems/Algorithms/2Sum.js

@@ -0,0 +1,43 @@
+/**
+2 Sum
+https://leetcode.com/problems/two-sum/
+
+Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+Example 1:
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Explanation: Because nums[0] + nums[1] == 9, we return [0, 1].
+
+Example 2:
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+
+Example 3:
+Input: nums = [3,3], target = 6
+Output: [0,1]
+
+*/
+
+/**
+ * @param {number[]} nums
+ * @param {number} target
+ * @return {number[]}
+ */
+ 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){
+          return [map[sum], i];
+      } else{
+          map[nums[i]] = i;
+      }
+  }
+};
+
+module.exports.twoSum = twoSum;

LeetcodeProblems/Algorithms/Find_Subarrays_With_Equal_Sum.js

@@ -0,0 +1,51 @@
+/*
+Find Subarrays With Equal Sum
+https://leetcode.com/problems/find-subarrays-with-equal-sum/description/
+
+Given a 0-indexed integer array nums, determine whether there exist two subarrays of length 2 with equal sum. Note that the two subarrays must begin at different indices.
+
+Return true if these subarrays exist, and false otherwise.
+
+A subarray is a contiguous non-empty sequence of elements within an array.
+
+
+
+Example 1:
+
+Input: nums = [4,2,4]
+Output: true
+Explanation: The subarrays with elements [4,2] and [2,4] have the same sum of 6.
+
+
+Example 2:
+
+Input: nums = [1,2,3,4,5]
+Output: false
+Explanation: No two subarrays of size 2 have the same sum.
+
+Example 3:
+
+Input: nums = [0,0,0]
+Output: true
+Explanation: The subarrays [nums[0],nums[1]] and [nums[1],nums[2]] have the same sum of 0. 
+Note that even though the subarrays have the same content, the two subarrays are considered different because they are in different positions in the original array.
+*/
+
+/**
+ * @param {number[]} nums
+ * @return {boolean}
+ */
+ var findSubarrays = function (nums) {
+  const sumsSeen = new Set();
+
+  for (let i = 0; i < nums.length - 1; i++) {
+    if (sumsSeen.has(nums[i] + nums[i + 1])) {
+      return true;
+    }
+    sumsSeen.add(nums[i] + nums[i + 1]);
+  }
+
+  return false;
+};
+
+module.exports.findSubarrays = findSubarrays;

LeetcodeProblems/Algorithms/Reverse_Integer.js

@@ -0,0 +1,46 @@
+/**
+Reverse Integer
+https://leetcode.com/problems/reverse-integer/
+
+Given a signed 32-bit integer x, return x with its digits reversed. If reversing x causes the value to go outside the signed 32-bit integer range [-231, 231 - 1], then return 0.
+
+Assume the environment does not allow you to store 64-bit integers (signed or unsigned).
+
+Example 1:
+Input: x = 123
+Output: 321
+
+Example 2:
+Input: x = -123
+Output: -321
+
+Example 3:
+Input: x = 120
+Output: 21
+
+ */
+
+/**
+ * @param {number} x
+ * @return {number}
+ */
+var reverseInteger = function(x) {
+  const sign = x >= 0 ? 1 : -1;
+  
+  let baseNum = sign * x;
+  let builder = 0;
+  
+  while (baseNum > 0) {
+    const digit = baseNum % 10;
+    builder = builder * 10 + digit;
+    baseNum = (baseNum / 10) | 0;
+  }
+  
+  builder *= sign;
+  
+  const isWithinRange = (builder >= -Math.pow(2, 31) && builder <= Math.pow(2, 31) - 1);
+  
+  return isWithinRange ? builder : 0;
+};
+
+module.exports.reverseInteger = reverseInteger;

LeetcodeProblems/Algorithms/Time_Needed_Rearrange_Binary_String.js

@@ -0,0 +1,47 @@
+/*
+You are given a binary string s. In one second, all occurrences of "01" are simultaneously replaced with "10". This process repeats until no occurrences of "01" exist.
+
+Return the number of seconds needed to complete this process.
+
+ 
+
+Example 1:
+
+Input: s = "0110101"
+Output: 4
+Explanation: 
+After one second, s becomes "1011010".
+After another second, s becomes "1101100".
+After the third second, s becomes "1110100".
+After the fourth second, s becomes "1111000".
+No occurrence of "01" exists any longer, and the process needed 4 seconds to complete,
+so we return 4.
+Example 2:
+
+Input: s = "11100"
+Output: 0
+Explanation:
+No occurrence of "01" exists in s, and the processes needed 0 seconds to complete,
+so we return 0.
+ 
+
+Constraints:
+
+1 <= s.length <= 1000
+s[i] is either '0' or '1'.
+*/
+
+
+/**
+ * @param {string} s
+ * @return {number}
+ */
+ var secondsToRemoveOccurrences = function(s) {
+  let result = 0;
+  while (true) {
+    const replaced = s.replaceAll('01', '10');
+    if (s === replaced) return result;
+    s = replaced;
+    result += 1;
+  }
+};

LeetcodeProblemsTests/Algorithms/2Sum_Test.js

@@ -0,0 +1,11 @@
+const assert = require('assert');
+const twoSum = require('../../LeetcodeProblems/Algorithms/2Sum').twoSum;
+
+var test = function () {
+  assert.deepEqual([0,1], twoSum([2,7,11,15], 9));
+  assert.deepEqual([1,2], twoSum([3,2,4], 6));
+  assert.deepEqual([0,1], twoSum([3,3], 6));
+}
+
+module.exports.test = test;
+

LeetcodeProblemsTests/Algorithms/Find_Subarrays_With_Equal_Sum_Test.js

@@ -0,0 +1,10 @@
+const assert = require('assert');
+const findSubarrays = require('../../LeetcodeProblems/Algorithms/Find_Subarrays_With_Equal_Sum').findSubarrays;
+
+var test = function () {
+  assert.equal(findSubarrays([4,2,4]), true);
+  assert.equal(findSubarrays([1,2,3,4,5]), false);
+  assert.equal(findSubarrays([0,0,0]), true);
+}
+
+module.exports.test = test;

LeetcodeProblemsTests/Algorithms/Maximise_Hour_Glass_Sum.js

@@ -2,8 +2,8 @@ const assert = require('assert');
 const maxSum = require('../../LeetcodeProblems/Algorithms/Maximise_Hour_Glass_Sum').maxSum;
 
 function test() {
-  assert.equal(maxSum([[6,2,1,3],[4,2,1,5],[9,2,8,7],[4,1,2,9]]));
-  assert.equal(maxSum([[1,2,3],[4,5,6],[7,8,9]]));
+  assert.equal(maxSum([[6,2,1,3],[4,2,1,5],[9,2,8,7],[4,1,2,9]]), 30);
+  assert.equal(maxSum([[1,2,3],[4,5,6],[7,8,9]]), 35);
 }
 
 module.exports.test = test

LeetcodeProblemsTests/Algorithms/Reverse_Integer_Test.js

@@ -0,0 +1,11 @@
+const assert = require('assert');
+const reverseInteger = require('../../LeetcodeProblems/Algorithms/Reverse_Integer').reverseInteger;
+
+var test = function() {
+  assert.equal(reverseInteger(123), 321);
+  assert.equal(reverseInteger(-123), -321);
+  assert.equal(reverseInteger(120), 21);
+}
+
+
+module.exports.test = test;

LeetcodeProblemsTests/Algorithms/Time_Needed_Rearrange_Binary_String_Test.js

@@ -0,0 +1,9 @@
+const assert = require('assert');
+const secondsToRemoveOccurrences = require('../../LeetcodeProblems/Algorithms/Time_Needed_Rearrange_Binary_String').secondsToRemoveOccurrences;
+
+function test() {
+  assert.equal(secondsToRemoveOccurrences("0110101"), 4);
+  assert.equal(secondsToRemoveOccurrences("11100"), 0)
+};
+
+module.exports.test = test

README.md

@@ -62,6 +62,9 @@ To run a specific problem in your console run  `node <problem_file_path>` (e.g.
 | [Construct Binary Tree from Preorder and Inorder Traversal ](/LeetcodeProblems/Algorithms/Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal.js)   | Medium | https://leetcode.com/problems/construct-binary-tree-from-preorder-and-inorder-traversal/ | 
 | [Lowest Common Ancestor of a Binary Tree ](/LeetcodeProblems/Algorithms/Lowest_Common_Ancestor_of_a_Binary_Tree.js) | Medium | https://leetcode.com/problems/lowest-common-ancestor-of-a-binary-tree/ |
 | [Maximum Sum of an Hourglass](/LeetcodeProblems/Algorithms/Maximise_Hour_Glass_Sum.js)                          | Medium | https://leetcode.com/problems/maximum-sum-of-an-hourglass/ |
+| [Reverse Integer](/LeetcodeProblems/Algorithms/Reverse_Integer.js)                                              | Medium | https://leetcode.com/problems/reverse-integer/ |
+| [Time Needed to Rearrange a Binary String](/LeetcodeProblems/Algorithms/Time_Needed_Rearrange_Binary_String.js) | Medium | https://leetcode.com/problems/time-needed-to-rearrange-a-binary-string/ |
+| [Find Subarrays With Equal Sum ](/LeetcodeProblems/Algorithms/Find_Subarrays_With_Equal_Sums.js)                | Medium | https://leetcode.com/problems/find-subarrays-with-equal-sum/ | 
 | [Flood Fill ](/LeetcodeProblems/Algorithms/Flood_Fill.js)                                                       | Easy   | https://leetcode.com/problems/flood-fill/ |
 | [Implement stack using queues ](/LeetcodeProblems/Algorithms/Implement_stack_using_queues.js)                   | Easy   | https://leetcode.com/problems/implement-stack-using-queues/ |
 | [Number of Segments in a String ](/LeetcodeProblems/Algorithms/Number_of_Segments_in_a_String.js)               | Easy   | https://leetcode.com/problems/number-of-segments-in-a-string/ |
@@ -77,6 +80,7 @@ To run a specific problem in your console run  `node <problem_file_path>` (e.g.
 | [Binary Gap ](/LeetcodeProblems/Algorithms/Binary_Gap.js)                                                       | Easy   | https://leetcode.com/problems/binary-gap/ |
 | [Majority Element](/LeetcodeProblems/Algorithms/Majority_Element.js)                                            | Easy   | https://leetcode.com/problems/majority-element/ |
 | [Longest Common Prefix](/LeetcodeProblems/Algorithms/Longest_Common_Prefix.js)                                  | Easy   | https://leetcode.com/problems/longest-common-prefix/ |
+| [Two Sum](/LeetcodeProblems/Algorithms/2Sum.js)                                                                 | Easy   | https://leetcode.com/problems/two-sum/ |
 | [Tic Tac Toe ](/LeetcodeProblems/Algorithms/Tic_Tac_Toe.js)                                                     |        | |
 | [Permutations With Duplicates ](/LeetcodeProblems/Algorithms/Permutations_With_Duplicates.js)                   |        | |
 | [Deletion Distance](/LeetcodeProblems/Algorithms/Deletion_Distance.js)                                          |        | |