From ea6d57626504a799e9b38b010a17697a077e2da2 Mon Sep 17 00:00:00 2001 From: Vijay Shanker Sharma Date: Tue, 4 Jun 2024 13:50:14 +0530 Subject: [PATCH 1/3] Added solution for Search Insert Position --- .../0000-0099/0035-search-insert-position.md | 136 ++++++++++++++++++ 1 file changed, 136 insertions(+) create mode 100644 dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md diff --git a/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md b/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md new file mode 100644 index 000000000..063617c1d --- /dev/null +++ b/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md @@ -0,0 +1,136 @@ +--- +id: search-insert-position +title: Search Insert Position +difficulty: Easy +sidebar_label: 0038-SearchInsertPosition +tags: + - Array + - Binary Search +--- + +## Problem Description + +| Problem Statement | Solution Link | LeetCode Profile | +| :---------------- | :------------ | :--------------- | +| [Merge Two Sorted Lists](https://leetcode.com/problems/search-insert-position/) | [Merge Two Sorted Lists Solution on LeetCode](https://leetcode.com/problems/search-insert-position/solutions/) | [VijayShankerSharma](https://leetcode.com/u/darkknight648/) | + +## Problem Description + +Given a sorted array `nums` of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order. + +You must write an algorithm with O(log n) runtime complexity. + +### Examples + +#### Example 1: + +- **Input:** + - `nums = [1,3,5,6]` + - `target = 5` +- **Output:** `2` + +#### Example 2: + +- **Input:** + - `nums = [1,3,5,6]` + - `target = 2` +- **Output:** `1` + +#### Example 3: + +- **Input:** + - `nums = [1,3,5,6]` + - `target = 7` +- **Output:** `4` + +### Constraints + +- `1 <= `nums.length` <= 10^4` +- `-10^4 <= `nums[i]` <= 10^4` +- `nums` contains distinct values sorted in ascending order. +- `-10^4 <= `target` <= 10^4` + +### Approach + +To solve the problem with O(log n) runtime complexity, we can use binary search to find the insertion position of the target value. + +1. **Binary Search:** + - Start with low = 0 and high = length of `nums` - 1. + - While `low <= high`, compute mid as (low + high) / 2. + - If the target value is equal to the value at index mid, return mid. + - If the target value is less than the value at index mid, set high = mid - 1. + - If the target value is greater than the value at index mid, set low = mid + 1. + - After the loop, if the target value is not found, return low (or high + 1). + +### Solution Code + +#### Python + +``` +class Solution(object): + def searchInsert(self, nums, target): + left, right = 0, len(nums) - 1 + + while left <= right: + mid = left + (right - left) // 2 + if nums[mid] == target: + return mid + elif nums[mid] < target: + left = mid + 1 + else: + right = mid - 1 + + return left + +``` + +#### Java + +``` +class Solution { + public int searchInsert(int[] nums, int target) { + int low = 0, high = nums.length - 1; + + while (low <= high) { + int mid = low + (high - low) / 2; + if (nums[mid] == target) { + return mid; + } else if (nums[mid] < target) { + low = mid + 1; + } else { + high = mid - 1; + } + } + + return low; + } +} +``` + +#### C++ + +``` +class Solution { +public: + int searchInsert(vector& nums, int target) { + int low = 0, high = nums.size() - 1; + + while (low <= high) { + int mid = low + (high - low) / 2; + if (nums[mid] == target) { + return mid; + } else if (nums[mid] < target) { + low = mid + 1; + } else { + high = mid - 1; + } + } + + return low; + } +}; +``` + +### Conclusion + +The above solution efficiently finds the insertion position of a target value in a sorted array using binary search. It achieves a runtime complexity of O(log n), providing an optimal solution to the problem. From 27c14c64e4e7b35196300803c8e28c957c044257 Mon Sep 17 00:00:00 2001 From: Vijay Shanker Sharma Date: Tue, 4 Jun 2024 13:57:32 +0530 Subject: [PATCH 2/3] S --- .../0000-0099/0035-search-insert-position.md | 136 ------------------ 1 file changed, 136 deletions(-) delete mode 100644 dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md diff --git a/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md b/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md deleted file mode 100644 index 063617c1d..000000000 --- a/dsa-solutions/lc-solutions/0000-0099/0035-search-insert-position.md +++ /dev/null @@ -1,136 +0,0 @@ ---- -id: search-insert-position -title: Search Insert Position -difficulty: Easy -sidebar_label: 0038-SearchInsertPosition -tags: - - Array - - Binary Search ---- - -## Problem Description - -| Problem Statement | Solution Link | LeetCode Profile | -| :---------------- | :------------ | :--------------- | -| [Merge Two Sorted Lists](https://leetcode.com/problems/search-insert-position/) | [Merge Two Sorted Lists Solution on LeetCode](https://leetcode.com/problems/search-insert-position/solutions/) | [VijayShankerSharma](https://leetcode.com/u/darkknight648/) | - -## Problem Description - -Given a sorted array `nums` of distinct integers and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order. - -You must write an algorithm with O(log n) runtime complexity. - -### Examples - -#### Example 1: - -- **Input:** - - `nums = [1,3,5,6]` - - `target = 5` -- **Output:** `2` - -#### Example 2: - -- **Input:** - - `nums = [1,3,5,6]` - - `target = 2` -- **Output:** `1` - -#### Example 3: - -- **Input:** - - `nums = [1,3,5,6]` - - `target = 7` -- **Output:** `4` - -### Constraints - -- `1 <= `nums.length` <= 10^4` -- `-10^4 <= `nums[i]` <= 10^4` -- `nums` contains distinct values sorted in ascending order. -- `-10^4 <= `target` <= 10^4` - -### Approach - -To solve the problem with O(log n) runtime complexity, we can use binary search to find the insertion position of the target value. - -1. **Binary Search:** - - Start with low = 0 and high = length of `nums` - 1. - - While `low <= high`, compute mid as (low + high) / 2. - - If the target value is equal to the value at index mid, return mid. - - If the target value is less than the value at index mid, set high = mid - 1. - - If the target value is greater than the value at index mid, set low = mid + 1. - - After the loop, if the target value is not found, return low (or high + 1). - -### Solution Code - -#### Python - -``` -class Solution(object): - def searchInsert(self, nums, target): - left, right = 0, len(nums) - 1 - - while left <= right: - mid = left + (right - left) // 2 - if nums[mid] == target: - return mid - elif nums[mid] < target: - left = mid + 1 - else: - right = mid - 1 - - return left - -``` - -#### Java - -``` -class Solution { - public int searchInsert(int[] nums, int target) { - int low = 0, high = nums.length - 1; - - while (low <= high) { - int mid = low + (high - low) / 2; - if (nums[mid] == target) { - return mid; - } else if (nums[mid] < target) { - low = mid + 1; - } else { - high = mid - 1; - } - } - - return low; - } -} -``` - -#### C++ - -``` -class Solution { -public: - int searchInsert(vector& nums, int target) { - int low = 0, high = nums.size() - 1; - - while (low <= high) { - int mid = low + (high - low) / 2; - if (nums[mid] == target) { - return mid; - } else if (nums[mid] < target) { - low = mid + 1; - } else { - high = mid - 1; - } - } - - return low; - } -}; -``` - -### Conclusion - -The above solution efficiently finds the insertion position of a target value in a sorted array using binary search. It achieves a runtime complexity of O(log n), providing an optimal solution to the problem. From 569642674263b96c319b3676980870727ef5cb86 Mon Sep 17 00:00:00 2001 From: Vijay Shanker Sharma Date: Tue, 4 Jun 2024 15:39:42 +0530 Subject: [PATCH 3/3] Added solution for Maximum Subarray --- .../0000-0099/0053-Maximum-Subarray.md | 118 ++++++++++++++++++ 1 file changed, 118 insertions(+) create mode 100644 dsa-solutions/lc-solutions/0000-0099/0053-Maximum-Subarray.md diff --git a/dsa-solutions/lc-solutions/0000-0099/0053-Maximum-Subarray.md b/dsa-solutions/lc-solutions/0000-0099/0053-Maximum-Subarray.md new file mode 100644 index 000000000..1e2e9d00d --- /dev/null +++ b/dsa-solutions/lc-solutions/0000-0099/0053-Maximum-Subarray.md @@ -0,0 +1,118 @@ +--- +id: maximum-subarray +title: Maximum Subarray (LeetCode) +difficulty: Medium +sidebar_label: 0053-MaximumSubarray +topics: + - Array + - Divide and Conquer +companies: + - "" +description: | + Given an integer array nums, find the subarray with the largest sum, and return its sum. +--- + +## Problem Description + +| Problem Statement | Solution Link | LeetCode Profile | +| :---------------- | :------------ | :--------------- | +| [Merge Two Sorted Lists](https://leetcode.com/problems/maximum-subarray/) | [Merge Two Sorted Lists Solution on LeetCode](https://leetcode.com/problems/maximum-subarray/solutions/) | [VijayShankerSharma](https://leetcode.com/u/darkknight648/) | + +## Problem Description + +Given an integer array `nums`, find the subarray with the largest sum, and return its sum. + +### Examples + +#### Example 1 + +- **Input:** nums = [-2,1,-3,4,-1,2,1,-5,4] +- **Output:** 6 +- **Explanation:** The subarray [4,-1,2,1] has the largest sum 6. + +#### Example 2 + +- **Input:** nums = [1] +- **Output:** 1 +- **Explanation:** The subarray [1] has the largest sum 1. + +#### Example 3 + +- **Input:** nums = [5,4,-1,7,8] +- **Output:** 23 +- **Explanation:** The subarray [5,4,-1,7,8] has the largest sum 23. + +### Constraints + +- `1 <= nums.length <= 10^5` +- `-10^4 <= nums[i] <= 10^4` + +### Approach + +To find the subarray with the largest sum, we can utilize the Kadane's algorithm, which efficiently solves this problem in linear time complexity O(n). + +#### Kadane's Algorithm + +1. Initialize two variables `max_sum` and `current_sum` to store the maximum sum found so far and the current sum of subarray, respectively. +2. Iterate through the array: + - Update `current_sum` by adding the current element to it. + - If `current_sum` becomes negative, reset it to 0 (indicating the start of a new potential subarray). + - Update `max_sum` if `current_sum` is greater than `max_sum`. +3. Finally, return `max_sum`. + +### Solution Code + +#### Python + +``` +class Solution(object): + def maxSubArray(self, nums): + if not nums: + return 0 + max_sum = curr_sum = nums[0] + for num in nums[1:]: + curr_sum = max(num, curr_sum + num) + max_sum = max(max_sum, curr_sum) + return max_sum +``` + +#### C++ + +``` +class Solution { +public: + int maxSubArray(vector& nums) { + int max_sum = nums[0]; + int current_sum = 0; + for (int num : nums) { + current_sum += num; + max_sum = max(max_sum, current_sum); + if (current_sum < 0) + current_sum = 0; + } + return max_sum; + } +}; +``` + +#### Java + +``` +class Solution { + public int maxSubArray(int[] nums) { + int max_sum = nums[0]; + int current_sum = 0; + for (int num : nums) { + current_sum += num; + max_sum = Math.max(max_sum, current_sum); + if (current_sum < 0) + current_sum = 0; + } + return max_sum; + } +} +``` + +### Conclusion + +The Maximum Subarray problem can be efficiently solved using Kadane's algorithm, which finds the subarray with the largest sum in linear time complexity O(n). The provided solution code implements this algorithm in Python, C++, and Java, providing an optimal solution to the problem. \ No newline at end of file