From 5e3012548480966f64efd39a1bf3e74d42006a33 Mon Sep 17 00:00:00 2001 From: Mukul Bansal Date: Sun, 20 Oct 2024 17:18:43 +0530 Subject: [PATCH 1/7] 121. Best Time to Buy and Sell Stock11' --- .../easy/Best_Time_to_buy_and_sell_stock.js | 92 +++++++++++++++++++ .../Best_Time_to_buy_and_sell_stock_Test.js | 15 +++ README.md | 1 + 3 files changed, 108 insertions(+) create mode 100644 LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js create mode 100644 LeetcodeProblemsTests/Algorithms/easy/Best_Time_to_buy_and_sell_stock_Test.js diff --git a/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js new file mode 100644 index 0000000..3f0d9c8 --- /dev/null +++ b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js @@ -0,0 +1,92 @@ +/* +121. Best Time to Buy and Sell Stock +https://leetcode.com/problems/best-time-to-buy-and-sell-stock/description/ + +Problem: +You are given an array prices where prices[i] is the price of a given stock on the ith day. + +You want to maximize your profit by choosing a single day to buy one stock and choosing a different day in the future to sell that stock. + +Return the maximum profit you can achieve from this transaction. If you cannot achieve any profit, return 0. + + + +Example 1: + +Input: prices = [7,1,5,3,6,4] +Output: 5 +Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. +Note that buying on day 2 and selling on day 1 is not allowed because you must buy before you sell. +Example 2: + +Input: prices = [7,6,4,3,1] +Output: 0 +Explanation: In this case, no transactions are done and the max profit = 0. + +Constraints: + +1 <= prices.length <= 10^5 +0 <= prices[i] <= 10^4 +*/ +/* +Approach: +let use initialize Left and Right pointer to first and second position of array +Here Left is to buy stock and Right is to sell stock + +Then we initialize our max_profit as 0. + +Now we will start our while loop and we will run till our +Right pointer less then length of array +For Example: +prices=[7,1,5,3,6,4] +Note: +prices[left] --> buy stock +prices[right] --> sell stock +now we will check price at right and left pointer + +step 1: + +price[left]=7 price[right]=1 profit=-6 +here price[left] is greater than price[right] so we will move left pointer to the right position and increment our right pointer by 1. We always want our left point to be minimum + +step 2: + +price[left]=1 price[right]=5 profit=4 +here price[left] is less than price[right] which means we will get profit so we will update our max_profit and move our right pointer alone + +step 3: + +price[left]=1 price[right]=3 profit=2 +here price[left] is less than price[right] which means we will get profit so we will check our max_profit previously it + +was 4 now our current profit is 2 so we will check which is maximum and update our max_profit and move our right pointer alone + +step 4: + +price[left]=1 price[right]=6 profit=5 +here price[left] is less than price[right] which means we will get profit so we will check our max_profit previously it was 4 now our current profit is 5 so we will check which is maximum and update our max_profit and move our right pointer alone + +step 5: + +price[left]=1 price[right]=4 profit=3 +same logic as above +*/ + +const maxProfit = (prices) => { + let left = 0; // Buy + let right = 1; // sell + let max_profit = 0; + while (right < prices.length) { + if (prices[left] < prices[right]) { + let profit = prices[right] - prices[left]; // our current profit + + max_profit = Math.max(max_profit, profit); + } else { + left = right; + } + right++; + } + return max_profit; +}; + +module.exports.maxProfit = maxProfit; \ No newline at end of file diff --git a/LeetcodeProblemsTests/Algorithms/easy/Best_Time_to_buy_and_sell_stock_Test.js b/LeetcodeProblemsTests/Algorithms/easy/Best_Time_to_buy_and_sell_stock_Test.js new file mode 100644 index 0000000..db97988 --- /dev/null +++ b/LeetcodeProblemsTests/Algorithms/easy/Best_Time_to_buy_and_sell_stock_Test.js @@ -0,0 +1,15 @@ +const assert = require("assert"); +const maxProfitEqual = require("../../../LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock").maxProfit; + +function test() { + assert.deepEqual( + maxProfit([7,1,5,3,6,4]), + 5 + ); + assert.deepEqual( + maxProfit([7,6,4,3,1]), + 0 + ); +} + +module.exports.test = test; \ No newline at end of file diff --git a/README.md b/README.md index d03fae8..d820f21 100644 --- a/README.md +++ b/README.md @@ -72,6 +72,7 @@ The solutions are located under `/LeetcodeProblems`. Each problem has a test fil | [Gas Station](/LeetcodeProblems/Algorithms/medium/GasStation/index.js) | Medium | https://leetcode.com/problems/gas-station/description/ | | [K Closest Points to Origin](/LeetcodeProblems/Algorithms/medium/K_Closest_Points_to_Origin.js/) | Medium | https://leetcode.com/problems/k-closest-points-to-origin/ | [BestTimeToBuy](LeetcodeProblems/Algorithms/easy/Best_Time_To_Buy_And_Sell_Stock_II.js) | Medium | https://leetcode.com/problems/best-time-to-buy-and-sell-stock-ii | +| [Best Time to Buy and Sell Stock](/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js) | Easy | https://leetcode.com/problems/best-time-to-buy-and-sell-stock/ | [Flood Fill ](/LeetcodeProblems/Algorithms/easy/Flood_Fill.js) | Easy | https://leetcode.com/problems/flood-fill/ | | [Implement stack using queues ](/LeetcodeProblems/Algorithms/easy/Implement_stack_using_queues.js) | Easy | https://leetcode.com/problems/implement-stack-using-queues/ | | [Number of Segments in a String ](/LeetcodeProblems/Algorithms/easy/Number_of_Segments_in_a_String.js) | Easy | https://leetcode.com/problems/number-of-segments-in-a-string/ | From 691ed78c1e588a54c6cf42f8b7324749aff6151d Mon Sep 17 00:00:00 2001 From: Mukul Bansal Date: Sun, 20 Oct 2024 20:58:54 +0530 Subject: [PATCH 2/7] 121. Best Time to Buy and Sell Stock --- .../easy/Best_Time_to_buy_and_sell_stock.js | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js index 3f0d9c8..b5e67e9 100644 --- a/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js +++ b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js @@ -33,7 +33,7 @@ Approach: let use initialize Left and Right pointer to first and second position of array Here Left is to buy stock and Right is to sell stock -Then we initialize our max_profit as 0. +Then we initialize our maxProfitValue as 0. Now we will start our while loop and we will run till our Right pointer less then length of array @@ -52,19 +52,19 @@ here price[left] is greater than price[right] so we will move left pointer to th step 2: price[left]=1 price[right]=5 profit=4 -here price[left] is less than price[right] which means we will get profit so we will update our max_profit and move our right pointer alone +here price[left] is less than price[right] which means we will get profit so we will update our maxProfitValue and move our right pointer alone step 3: price[left]=1 price[right]=3 profit=2 -here price[left] is less than price[right] which means we will get profit so we will check our max_profit previously it +here price[left] is less than price[right] which means we will get profit so we will check our maxProfitValue previously it -was 4 now our current profit is 2 so we will check which is maximum and update our max_profit and move our right pointer alone +was 4 now our current profit is 2 so we will check which is maximum and update our maxProfitValue and move our right pointer alone step 4: price[left]=1 price[right]=6 profit=5 -here price[left] is less than price[right] which means we will get profit so we will check our max_profit previously it was 4 now our current profit is 5 so we will check which is maximum and update our max_profit and move our right pointer alone +here price[left] is less than price[right] which means we will get profit so we will check our maxProfitValue previously it was 4 now our current profit is 5 so we will check which is maximum and update our maxProfitValue and move our right pointer alone step 5: @@ -75,18 +75,18 @@ same logic as above const maxProfit = (prices) => { let left = 0; // Buy let right = 1; // sell - let max_profit = 0; + let maxProfitValue = 0; while (right < prices.length) { if (prices[left] < prices[right]) { let profit = prices[right] - prices[left]; // our current profit - max_profit = Math.max(max_profit, profit); + maxProfitValue = Math.max(maxProfitValue, profit); } else { left = right; } right++; } - return max_profit; + return maxProfitValue; }; module.exports.maxProfit = maxProfit; \ No newline at end of file From c13e3f6974d72c35f5efe063e361ac087b97db87 Mon Sep 17 00:00:00 2001 From: Ignacio Chiazzo Cardarello Date: Sun, 20 Oct 2024 20:33:14 -0300 Subject: [PATCH 3/7] Update Best_Time_to_buy_and_sell_stock.js --- .../easy/Best_Time_to_buy_and_sell_stock.js | 29 ++++++++++--------- 1 file changed, 16 insertions(+), 13 deletions(-) diff --git a/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js index b5e67e9..a94d16b 100644 --- a/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js +++ b/LeetcodeProblems/Algorithms/easy/Best_Time_to_buy_and_sell_stock.js @@ -30,41 +30,44 @@ Constraints: */ /* Approach: -let use initialize Left and Right pointer to first and second position of array -Here Left is to buy stock and Right is to sell stock +We will use a Two pointers strategy (Left and Right pointers). +The first will start pointing to the first element, and the right to the second position of array. +The Left is to buy stock and Right is to sell stock -Then we initialize our maxProfitValue as 0. +We initialize our maxProfitValue as 0. + +Now we will start our while loop, and we will run till our +Right pointer less than the array's length. -Now we will start our while loop and we will run till our -Right pointer less then length of array For Example: prices=[7,1,5,3,6,4] Note: prices[left] --> buy stock prices[right] --> sell stock -now we will check price at right and left pointer +We will check the price at the right and left pointer step 1: price[left]=7 price[right]=1 profit=-6 -here price[left] is greater than price[right] so we will move left pointer to the right position and increment our right pointer by 1. We always want our left point to be minimum +here, price[left] is greater than price[right], so we will move the left pointer to the right position +and increment our right pointer by 1. We always want our left point to be the minimum. step 2: price[left]=1 price[right]=5 profit=4 -here price[left] is less than price[right] which means we will get profit so we will update our maxProfitValue and move our right pointer alone +here, price[left] is less than price[right], which means we will get profit, +so we will update our maxProfitValue and move our right pointer alone step 3: price[left]=1 price[right]=3 profit=2 -here price[left] is less than price[right] which means we will get profit so we will check our maxProfitValue previously it - -was 4 now our current profit is 2 so we will check which is maximum and update our maxProfitValue and move our right pointer alone +here, price[left] is less than price[right], we will get profit, so we will compare the maxProfitValue with the current profit. +We will update our maxProfitValue and move our right pointer alone step 4: price[left]=1 price[right]=6 profit=5 -here price[left] is less than price[right] which means we will get profit so we will check our maxProfitValue previously it was 4 now our current profit is 5 so we will check which is maximum and update our maxProfitValue and move our right pointer alone +same logic as above step 5: @@ -89,4 +92,4 @@ const maxProfit = (prices) => { return maxProfitValue; }; -module.exports.maxProfit = maxProfit; \ No newline at end of file +module.exports.maxProfit = maxProfit; From 693a1059f6195472619e1ea97f0f44773f305afd Mon Sep 17 00:00:00 2001 From: mukul Date: Tue, 22 Oct 2024 20:00:00 +0530 Subject: [PATCH 4/7] 41. First Missing Positive --- .../Algorithms/hard/First_Missing_Positive.js | 51 +++++++++++++++++++ .../hard/First_Missing_Positive_Test.js | 19 +++++++ README.md | 1 + 3 files changed, 71 insertions(+) create mode 100644 LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js create mode 100644 LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js diff --git a/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js new file mode 100644 index 0000000..6a39e8a --- /dev/null +++ b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js @@ -0,0 +1,51 @@ +/* +41. First Missing Positive +https://leetcode.com/problems/first-missing-positive/ +Problem: +Given an unsorted integer array nums. Return the smallest positive integer that is not present in nums. +You must implement an algorithm that runs in O(n) time and uses O(1) auxiliary space. +Example 1: +Input: nums = [1,2,0] +Output: 3 +Explanation: The numbers in the range [1,2] are all in the array. +Example 2: +Input: nums = [3,4,-1,1] +Output: 2 +Explanation: 1 is in the array but 2 is missing. +Example 3: +Input: nums = [7,8,9,11,12] +Output: 1 +Explanation: The smallest positive integer 1 is missing. +Constraints: +1 <= nums.length <= 10^5 +-2^31 <= nums[i] <= 2^31 - 1 +Explanation +Initialize n +const n = nums.length; +This line sets the variable n to the length of the input array nums. It represents the size of the array. +This is the cyclic sort algorithm. It iterates through the array and, in each step, it checks if the current element nums[i] is within the valid range (1 to n) and not in its correct position. If so, it swaps the element with the one at its correct position. +After the cyclic sort, this loop searches for the first element that is out of place. If nums[i] is not equal to i + 1, it means that i + 1 is the smallest missing positive integer, and it is returned. +Return Next Positive Integer if All Elements Are in Place, +If all elements are in their correct positions, the function returns the next positive integer after the maximum element in the array (n + 1). +*/ + + +/** + * @param {number[]} nums + * @return {number} + */ +var firstMissingPositive = function(nums) { + const n = nums.length + + for (let i = 0; i < n; i++) + while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]) + [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]] + + for (let i = 0; i < n; i++) + if (nums[i] !== i + 1) + return i + 1 + + return n + 1 +}; + +module.exports.firstMissingPositive = firstMissingPositive; \ No newline at end of file diff --git a/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js b/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js new file mode 100644 index 0000000..c9b77c7 --- /dev/null +++ b/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js @@ -0,0 +1,19 @@ +const assert = require("assert"); +const bitReverseToMakeNumberEqual = require("../../../LeetcodeProblems/Algorithms/hard/First_Missing_Positive").firstMissingPositive; + +function test() { + assert.deepEqual( + firstMissingPositive([1,2,0]), + 2 + ); + assert.deepEqual( + firstMissingPositive([3,4,-1,1]), + 2 + ); + assert.deepEqual( + firstMissingPositive([7,8,9,11,12]), + 1 +); +} + +module.exports.test = test; \ No newline at end of file diff --git a/README.md b/README.md index d820f21..01307b7 100644 --- a/README.md +++ b/README.md @@ -16,6 +16,7 @@ The solutions are located under `/LeetcodeProblems`. Each problem has a test fil | Name | Level | Link | |----------------------------------------------------------------------------------------------------------------------------------------------------------------|--------|---------------------------------------------------------------------------------------------------------------------| | [Edit Distance ](/LeetcodeProblems/Algorithms/hard/Edit_Distance.js) | Hard | https://leetcode.com/problems/edit-distance/ | +| [First Missing Positive ](/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js) | Hard | https://leetcode.com/problems/first-missing-positive/ | | [Remove Invalid Parentheses ](/LeetcodeProblems/Algorithms/hard/Remove_Invalid_Parentheses.js) | Hard | https://leetcode.com/problems/remove-invalid-parentheses/ | | [Longest Consecutive Sequence ](/LeetcodeProblems/Algorithms/hard/Longest_Consecutive_Sequence.js) | Hard | https://leetcode.com/problems/longest-consecutive-sequence/ | | [Minimum Window Substring ](/LeetcodeProblems/Algorithms/hard/Minimum_Window_Substring.js) | Hard | https://leetcode.com/problems/minimum-window-substring/ | From 8a907b6f2f3be62f21e04cc0f2b4ee6c8849f7fe Mon Sep 17 00:00:00 2001 From: mukul Date: Tue, 22 Oct 2024 20:03:32 +0530 Subject: [PATCH 5/7] 41. First Missing Positive --- .../Algorithms/hard/First_Missing_Positive_Test.js | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js b/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js index c9b77c7..8662c2c 100644 --- a/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js +++ b/LeetcodeProblemsTests/Algorithms/hard/First_Missing_Positive_Test.js @@ -4,7 +4,7 @@ const bitReverseToMakeNumberEqual = require("../../../LeetcodeProblems/Algorithm function test() { assert.deepEqual( firstMissingPositive([1,2,0]), - 2 + 3 ); assert.deepEqual( firstMissingPositive([3,4,-1,1]), From cd335dc02a8555a6469ee432f4d407a3c3b51cb7 Mon Sep 17 00:00:00 2001 From: mukul Date: Tue, 22 Oct 2024 20:04:31 +0530 Subject: [PATCH 6/7] 41. First Missing Positive --- .../Algorithms/hard/First_Missing_Positive.js | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js index 6a39e8a..c85597b 100644 --- a/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js +++ b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js @@ -35,17 +35,17 @@ If all elements are in their correct positions, the function returns the next po * @return {number} */ var firstMissingPositive = function(nums) { - const n = nums.length + const n = nums.length - for (let i = 0; i < n; i++) - while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]) - [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]] + for (let i = 0; i < n; i++) + while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]) + [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]] - for (let i = 0; i < n; i++) - if (nums[i] !== i + 1) - return i + 1 + for (let i = 0; i < n; i++) + if (nums[i] !== i + 1) + return i + 1 - return n + 1 + return n + 1 }; module.exports.firstMissingPositive = firstMissingPositive; \ No newline at end of file From 2c02f96c7183a278d1e0323e8da2a232fe50ed32 Mon Sep 17 00:00:00 2001 From: mukul Date: Tue, 22 Oct 2024 20:28:17 +0530 Subject: [PATCH 7/7] 41. First Missing Positive --- .../Algorithms/hard/First_Missing_Positive.js | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js index c85597b..8bb6ed3 100644 --- a/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js +++ b/LeetcodeProblems/Algorithms/hard/First_Missing_Positive.js @@ -35,17 +35,17 @@ If all elements are in their correct positions, the function returns the next po * @return {number} */ var firstMissingPositive = function(nums) { - const n = nums.length + const n = nums.length; for (let i = 0; i < n; i++) while (nums[i] > 0 && nums[i] <= n && nums[nums[i] - 1] !== nums[i]) - [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]] + [nums[nums[i] - 1], nums[i]] = [nums[i], nums[nums[i] - 1]]; for (let i = 0; i < n; i++) if (nums[i] !== i + 1) - return i + 1 + return i + 1; - return n + 1 + return n + 1; }; module.exports.firstMissingPositive = firstMissingPositive; \ No newline at end of file