D. J.:

- Added the leetcode problem and solution for 4, 33, 34, 153 and 162

Author: nobodyPerfecZ

README.md

@@ -15,7 +15,7 @@
             <img src="https://img.shields.io/badge/tests-passed-brightgreen">
         </a>
         <a>
-            <img src="https://img.shields.io/badge/coverage-98%25-brightgreen">
+            <img src="https://img.shields.io/badge/coverage-97%25-brightgreen">
         </a>
     </h1>
 </div>
@@ -27,6 +27,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [1 Two Sum](https://leetcode.com/problems/two-sum/description/)
 - [2 Add Two Numbers](https://leetcode.com/problems/add-two-numbers/description/)
 - [3 Longest Substring Without Repeating Characters](https://leetcode.com/problems/longest-substring-without-repeating-characters/description/)
+- [4 Median of Two Sorted Arrays](https://leetcode.com/problems/median-of-two-sorted-arrays/description/)
 - [6 Zigzag Conversion](https://leetcode.com/problems/zigzag-conversion/description/)
 - [9 Palindrome Number](https://leetcode.com/problems/palindrome-number/description/)
 - [11 Container With Most Water](https://leetcode.com/problems/container-with-most-water/description/)
@@ -45,6 +46,8 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [27 Remove Element](https://leetcode.com/problems/remove-element/description/)
 - [28 Find the Index of the First Occurrence in a String](https://leetcode.com/problems/find-the-index-of-the-first-occurrence-in-a-string/description/)
 - [30 Substring with Concatenation of All Words](https://leetcode.com/problems/substring-with-concatenation-of-all-words/description/)
+- [33 Search in Rotated Sorted Array](https://leetcode.com/problems/search-in-rotated-sorted-array/description/)
+- [34 Find First and Last Position of Element in Sorted Array](https://leetcode.com/problems/find-first-and-last-position-of-element-in-sorted-array/description/)
 - [35 Search Insert Position](https://leetcode.com/problems/search-insert-position/description/)
 - [36 Valid Sudoku](https://leetcode.com/problems/valid-sudoku/description/)
 - [39 Combination Sum](https://leetcode.com/problems/combination-sum/description/)
@@ -110,7 +113,9 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [149 Max Points on a Line](https://leetcode.com/problems/max-points-on-a-line/description/)
 - [150 Evaluate Reverse Polish Notation](https://leetcode.com/problems/evaluate-reverse-polish-notation/description/)
 - [151 Reverse Words in a String](https://leetcode.com/problems/reverse-words-in-a-string/description/)
+- [153 Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/description/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/description/)
+- [162 Find Peak Element](https://leetcode.com/problems/find-peak-element/description/)
 - [167 Two Sum II - Input Array Is Sorted](https://leetcode.com/problems/two-sum-ii-input-array-is-sorted/description/)
 - [169 Majority Element](https://leetcode.com/problems/majority-element/description/)
 - [172 Factorial Trailing Zeroes](https://leetcode.com/problems/factorial-trailing-zeroes/description/)

awesome_python_leetcode/_153_find_minimum_in_rotated_sorted_array.py

@@ -0,0 +1,40 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findMin(self, nums: List[int]) -> int:
+        """
+        Suppose an array of length n sorted in ascending order is rotated between 1 and
+        n times. For example, the array nums = [0,1,2,4,5,6,7] might become:
+        - [4,5,6,7,0,1,2] if it was rotated 4 times.
+        - [0,1,2,4,5,6,7] if it was rotated 7 times.
+
+        Notice that rotating an array [a[0], a[1], a[2], ..., a[n-1]] 1 time results in
+        the array [a[n-1], a[0], a[1], a[2], ..., a[n-2]].
+
+        Given the sorted rotated array nums of unique elements, return the minimum
+        element of this array.
+
+        You must write an algorithm that runs in O(log n) time.
+        """
+        left, right = 0, len(nums) - 1
+        minVal = float("inf")
+
+        while left <= right:
+            if nums[left] < nums[right]:
+                # sorted portion
+                if nums[left] < minVal:
+                    minVal = nums[left]
+                break
+            mid = (left + right) // 2
+            if nums[mid] < minVal:
+                minVal = nums[mid]
+            if nums[left] <= nums[mid]:
+                # left sorted portion
+                left = mid + 1
+            else:
+                # right sorted portion
+                right = mid - 1
+        return minVal

awesome_python_leetcode/_162_find_peak_element.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findPeakElement(self, nums: List[int]) -> int:
+        """
+        A peak element is an element that is strictly greater than its neighbors.
+
+        Given a 0-indexed integer array nums, find a peak element, and return its index.
+        If the array contains multiple peaks, return the index to any of the peaks.
+
+        You may imagine that nums[-1] = nums[n] = -∞. In other words, an element is
+        always considered to be strictly greater than a neighbor that is outside the
+        array.
+
+        You must write an algorithm that runs in O(log n) time.
+        """
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            midVal = nums[mid]
+            leftVal = -float("inf") if mid == 0 else nums[mid - 1]
+            rightVal = -float("inf") if mid == len(nums) - 1 else nums[mid + 1]
+
+            if leftVal < midVal and rightVal < midVal:
+                return mid
+            elif rightVal > midVal:
+                left = mid + 1
+            elif leftVal > midVal:
+                right = mid - 1
+
+        return -1

awesome_python_leetcode/_33_search_in_rotated_sorted_array.py

@@ -0,0 +1,41 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def search(self, nums: List[int], target: int) -> int:
+        """
+        There is an integer array nums sorted in ascending order (with distinct values).
+
+        Prior to being passed to your function, nums is possibly rotated at an unknown
+        pivot index k (1 <= k < nums.length) such that the resulting array is
+        [nums[k], nums[k+1], ..., nums[n-1], nums[0], nums[1], ..., nums[k-1]]
+        (0-indexed). For example, [0,1,2,4,5,6,7] might be rotated at pivot index 3 and
+        become [4,5,6,7,0,1,2].
+
+        Given the array nums after the possible rotation and an integer target, return
+        the index of target if it is in nums, or -1 if it is not in nums.
+
+        You must write an algorithm with O(log n) runtime complexity.
+        """
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+
+            if target == nums[mid]:
+                return mid
+
+            # left sorted portion
+            if nums[left] <= nums[mid]:
+                if target > nums[mid] or target < nums[left]:
+                    left = mid + 1
+                else:
+                    right = mid - 1
+            else:
+                # right sorted portion
+                if target < nums[mid] or target > nums[right]:
+                    right = mid - 1
+                else:
+                    left = mid + 1
+        return -1

awesome_python_leetcode/_34_find_first_and_last_position_of_element_in_sorted_array.py

@@ -0,0 +1,43 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def searchRange(self, nums: List[int], target: int) -> List[int]:
+        """
+        Given an array of integers nums sorted in non-decreasing order, find the
+        starting and ending position of a given target value.
+
+        If target is not found in the array, return [-1, -1].
+
+        You must write an algorithm with O(log n) runtime complexity.
+        """
+        # start position
+        found = False
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] == target:
+                found = True
+                right = mid - 1
+            elif nums[mid] > target:
+                right = mid - 1
+            else:
+                left = mid + 1
+        start = left
+
+        if not found:
+            return [-1, -1]
+
+        # end position
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            if nums[mid] <= target:
+                left = mid + 1
+            else:
+                right = mid - 1
+        end = right
+
+        return [start, end]

awesome_python_leetcode/_4_median_of_two_sorted_arrays.py

@@ -0,0 +1,39 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findMedianSortedArrays(self, nums1: List[int], nums2: List[int]) -> float:
+        """
+        Given two sorted arrays nums1 and nums2 of size m and n respectively, return
+        the median of the two sorted arrays.
+
+        The overall run time complexity should be O(log (m+n)).
+        """
+        total = len(nums1) + len(nums2)
+        half = total // 2
+        if len(nums2) < len(nums1):
+            big, small = nums1, nums2
+        else:
+            big, small = nums2, nums1
+
+        left, right = 0, len(small) - 1
+        while True:
+            i = (left + right) // 2
+            j = half - i - 2
+
+            leftSmall = small[i] if i >= 0 else -float("inf")
+            rightSmall = small[i + 1] if (i + 1) < len(small) else float("inf")
+            leftBig = big[j] if j >= 0 else -float("inf")
+            rightBig = big[j + 1] if (j + 1) < len(big) else float("inf")
+
+            if leftSmall <= rightBig and leftBig <= rightSmall:
+                if total % 2:
+                    return min(rightSmall, rightBig)
+                else:
+                    return (max(leftSmall, leftBig) + min(rightSmall, rightBig)) / 2
+            elif leftSmall > rightBig:
+                right = i - 1
+            else:
+                left = i + 1

tests/test_153_find_minimum_in_rotated_sorted_array.py

@@ -0,0 +1,20 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._153_find_minimum_in_rotated_sorted_array import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([3, 4, 5, 1, 2], 1),
+        ([4, 5, 6, 7, 0, 1, 2], 0),
+        ([11, 13, 15, 17], 11),
+        ([5, 1, 2, 3, 4], 1),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    min_val = Solution().findMin(nums)
+    assert min_val == expected

tests/test_162_find_peak_element.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._162_find_peak_element import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([1, 2, 3, 1], 2),
+        ([1, 2, 1, 3, 5, 6, 4], 5),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    peak_idx = Solution().findPeakElement(nums)
+    assert peak_idx == expected

tests/test_33_search_in_rotated_sorted_array.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._33_search_in_rotated_sorted_array import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "target", "expected"],
+    argvalues=[
+        ([4, 5, 6, 7, 0, 1, 2], 0, 4),
+        ([4, 5, 6, 7, 0, 1, 2], 3, -1),
+        ([1], 0, -1),
+    ],
+)
+def test_func(nums: List[int], target: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    idx = Solution().search(nums, target)
+    assert idx == expected

tests/test_34_find_first_and_last_position_of_element_in_sorted_array.py

@@ -0,0 +1,22 @@
+# flake8: noqa
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._34_find_first_and_last_position_of_element_in_sorted_array import (
+    Solution,
+)
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "target", "expected"],
+    argvalues=[
+        ([5, 7, 7, 8, 8, 10], 8, [3, 4]),
+        ([5, 7, 7, 8, 8, 10], 6, [-1, -1]),
+        ([], 0, [-1, -1]),
+    ],
+)
+def test_func(nums: List[int], target: int, expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    ranges = Solution().searchRange(nums, target)
+    assert ranges == expected