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 5dd976c3e759ded617b571b9873e478ef5a65e74 Mon Sep 17 00:00:00 2001 From: Vijay Shanker Sharma Date: Tue, 4 Jun 2024 16:21:14 +0530 Subject: [PATCH 3/3] Added solution for Length of Last Word --- .../0000-0099/0058-length-of-last-word.md | 112 ++++++++++++++++++ 1 file changed, 112 insertions(+) create mode 100644 dsa-solutions/lc-solutions/0000-0099/0058-length-of-last-word.md diff --git a/dsa-solutions/lc-solutions/0000-0099/0058-length-of-last-word.md b/dsa-solutions/lc-solutions/0000-0099/0058-length-of-last-word.md new file mode 100644 index 000000000..6bc463bb5 --- /dev/null +++ b/dsa-solutions/lc-solutions/0000-0099/0058-length-of-last-word.md @@ -0,0 +1,112 @@ +--- +id: length-of-last-word +title: Length of Last Word (LeetCode) +difficulty: Easy +sidebar_label: 0058-LengthOfLastWord +topics: + - String +--- + +## Problem Description + +| Problem Statement | Solution Link | LeetCode Profile | +| :---------------- | :------------ | :--------------- | +| [Merge Two Sorted Lists](https://leetcode.com/problems/length-of-last-word/) | [Merge Two Sorted Lists Solution on LeetCode](https://leetcode.com/problems/length-of-last-word/solutions/) | [VijayShankerSharma](https://leetcode.com/u/darkknight648/) | + + +## Problem Description + +Given a string `s` consisting of words and spaces, return the length of the last word in the string. + +### Examples + +#### Example 1 + +- **Input:** s = "Hello World" +- **Output:** 5 +- **Explanation:** The last word is "World" with length 5. + +#### Example 2 + +- **Input:** s = " fly me to the moon " +- **Output:** 4 +- **Explanation:** The last word is "moon" with length 4. + +#### Example 3 + +- **Input:** s = "luffy is still joyboy" +- **Output:** 6 +- **Explanation:** The last word is "joyboy" with length 6. + +### Constraints + +- `1 <= s.length <= 10^4` +- `s` consists of only English letters and spaces ' '. +- There will be at least one word in `s`. + +### Approach + +To find the length of the last word in the string `s`, we can follow these steps: + +1. Trim any trailing spaces from the string. +2. Initialize a variable `length` to store the length of the last word. +3. Iterate over the string from right to left: + - When encountering a non-space character, increment `length`. + - Break the loop when encountering the first space character after a non-space character. +4. Return `length`. + +### Solution Code + +#### Python + +``` +class Solution(object): + def lengthOfLastWord(self, s): + return len(s.split()[-1]) +``` + +#### C++ + +``` +class Solution { +public: + int lengthOfLastWord(string s) { + int length = 0; + int n = s.length(); + while (n > 0 && s[n - 1] == ' ') { + n--; // Trim trailing spaces + } + for (int i = n - 1; i >= 0; --i) { + if (s[i] != ' ') { + length++; + } else if (length != 0) { + break; + } + } + return length; + } +}; +``` + +#### Java + +``` +class Solution { + public int lengthOfLastWord(String s) { + int length = 0; + s = s.trim(); // Trim trailing spaces + for (int i = s.length() - 1; i >= 0; --i) { + if (s.charAt(i) != ' ') { + length++; + } else if (length != 0) { + break; + } + } + return length; + } +} +``` + +### Conclusion + +The Length of Last Word problem can be efficiently solved by trimming any trailing spaces from the string and iterating over the string from right to left to find the length of the last word. 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