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 841cc25bdca7abf8e12238e50d20ff7bc27e94b1 Mon Sep 17 00:00:00 2001 From: Vijay Shanker Sharma Date: Tue, 4 Jun 2024 17:10:39 +0530 Subject: [PATCH 3/3] Added solution for sqrtx --- .../lc-solutions/0000-0099/0069-SqrtX.md | 129 ++++++++++++++++++ 1 file changed, 129 insertions(+) create mode 100644 dsa-solutions/lc-solutions/0000-0099/0069-SqrtX.md diff --git a/dsa-solutions/lc-solutions/0000-0099/0069-SqrtX.md b/dsa-solutions/lc-solutions/0000-0099/0069-SqrtX.md new file mode 100644 index 000000000..778fee4fc --- /dev/null +++ b/dsa-solutions/lc-solutions/0000-0099/0069-SqrtX.md @@ -0,0 +1,129 @@ +--- +id: sqrt-x +title: Sqrt(x) (LeetCode) +difficulty: Easy +sidebar_label: 0069-SqrtX +topics: + - Math + - Binary Search +--- + + +## Problem Description + +| Problem Statement | Solution Link | LeetCode Profile | +| :---------------- | :------------ | :--------------- | +| [Merge Two Sorted Lists](https://leetcode.com/problems/sqrtx/) | [Merge Two Sorted Lists Solution on LeetCode](https://leetcode.com/problems/sqrtx/solutions/) | [VijayShankerSharma](https://leetcode.com/u/darkknight648/) | + +## Problem Description + +Given a non-negative integer `x`, return the square root of `x` rounded down to the nearest integer. The returned integer should be non-negative as well. + +You must not use any built-in exponent function or operator. + +### Examples + +#### Example 1: + +- **Input:** `x = 4` +- **Output:** `2` +- **Explanation:** The square root of 4 is 2, so we return 2. + +#### Example 2: + +- **Input:** `x = 8` +- **Output:** `2` +- **Explanation:** The square root of 8 is approximately 2.82842..., and since we round it down to the nearest integer, 2 is returned. + +### Constraints: + +- `0 <= x <= 2^31 - 1` + +### Approach + +To find the square root of a non-negative integer `x` without using built-in functions, we can use binary search within the range `[0, x]`. + +1. Initialize variables `left` and `right` to represent the search range `[0, x]`. +2. Perform binary search within this range, updating the `mid` value as `(left + right) / 2`. +3. If `mid * mid` is greater than `x`, update `right` to `mid - 1`. +4. If `mid * mid` is less than or equal to `x`, update `left` to `mid + 1`. +5. Repeat steps 2-4 until `left` is greater than `right`. +6. Return the value of `right`, which represents the largest integer whose square is less than or equal to `x`. + +### Solution Code + +#### Python + +``` +class Solution(object): + def mySqrt(self, x): + if x < 2: + return x + left, right = 1, x + while left <= right: + mid = (left + right) // 2 + if mid * mid == x: + return mid + elif mid * mid < x: + left = mid + 1 + else: + right = mid - 1 + return right +``` + +#### C++ + +``` +class Solution { +public: + int mySqrt(int x) { + if (x == 0) { + return 0; + } + + long left = 1, right = x; + while (left <= right) { + long mid = (left + right) / 2; + if (mid * mid == x) { + return mid; + } else if (mid * mid < x) { + left = mid + 1; + } else { + right = mid - 1; + } + } + + return right; + } +}; +``` + +#### Java + +``` +class Solution { + public int mySqrt(int x) { + if (x == 0) { + return 0; + } + + long left = 1, right = x; + while (left <= right) { + long mid = (left + right) / 2; + if (mid * mid == x) { + return (int)mid; + } else if (mid * mid < x) { + left = mid + 1; + } else { + right = mid - 1; + } + } + + return (int)right; + } +} +``` + +### Conclusion + +The "Sqrt(x)" problem can be efficiently solved using binary search within the range `[0, x]`. The provided solution code implements this approach in Python, C++, and Java, providing an optimal solution to the problem. \ No newline at end of file