D. J.:

- Added the leetcode problem and solution for 215, 295, 373 and 502

Author: nobodyPerfecZ

README.md

@@ -145,6 +145,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [210 Course Schedule](https://leetcode.com/problems/course-schedule-ii/description/)
 - [211 Design Add and Search Words Data Structure](https://leetcode.com/problems/design-add-and-search-words-data-structure/description/)
 - [212 Word Search II](https://leetcode.com/problems/word-search-ii/description/)
+- [215 Kth Largest Element in an Array](https://leetcode.com/problems/kth-largest-element-in-an-array/description/)
 - [219 Contains Duplicates II](https://leetcode.com/problems/contains-duplicate-ii/description/)
 - [221 Maximal Square](https://leetcode.com/problems/maximal-square/description/)
 - [222 Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes/description/)
@@ -159,15 +160,18 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [274 H-Index](https://leetcode.com/problems/h-index/description/)
 - [289 Game of Life](https://leetcode.com/problems/game-of-life/description/)
 - [290 Word Pattern](https://leetcode.com/problems/word-pattern/description/)
+- [295 Find Median from Data Stream](https://leetcode.com/problems/find-median-from-data-stream/description/)
 - [300 Longest Increasing Subsequence](https://leetcode.com/problems/longest-increasing-subsequence/description/)
 - [322 Coin Change](https://leetcode.com/problems/coin-change/description/)
+- [373 Find K Pairs with Smallest Sums](https://leetcode.com/problems/find-k-pairs-with-smallest-sums/description/)
 - [380 Insert Delete GetRandom O(1)](https://leetcode.com/problems/insert-delete-getrandom-o1/description/)
 - [383 Ransom Note](https://leetcode.com/problems/ransom-note/description/)
 - [392 Is Subsequence](https://leetcode.com/problems/is-subsequence/description/)
 - [399 Evaluate Division](https://leetcode.com/problems/evaluate-division/description/)
 - [427 Construct Quad Tree](https://leetcode.com/problems/construct-quad-tree/description/)
 - [433 Minimum Genetic Mutation](https://leetcode.com/problems/minimum-genetic-mutation/description/)
 - [452 Minimum Number of Arrows to Burst Balloons](https://leetcode.com/problems/minimum-number-of-arrows-to-burst-balloons/description/)
+- [502 IPO](https://leetcode.com/problems/ipo/description/)
 - [530 Minimum Absolute Difference in BST](https://leetcode.com/problems/minimum-absolute-difference-in-bst/description/)
 - [637 Average of Levels in Binary Tree](https://leetcode.com/problems/average-of-levels-in-binary-tree/description/)
 - [909 Snakes and Ladders](https://leetcode.com/problems/snakes-and-ladders/description/)

awesome_python_leetcode/_215_kth_largest_element_in_an_array.py

@@ -0,0 +1,22 @@
+from typing import List
+from heapq import heapify, heappop
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findKthLargest(self, nums: List[int], k: int) -> int:
+        """
+        Given an integer array nums and an integer k, return the kth largest element in
+        the array.
+
+        Note that it is the kth largest element in the sorted order, not the kth
+        distinct element.
+
+        Can you solve it without sorting?
+        """
+        nums = [-n for n in nums]
+        heapify(nums)
+        for t in range(k):
+            val = heappop(nums)
+        return -val

awesome_python_leetcode/_295_find_median_from_data_stream.py

@@ -0,0 +1,49 @@
+from heapq import heappush, heappop
+
+
+class MedianFinder:
+    """
+    The median is the middle value in an ordered integer list. If the size of the list
+    is even, there is no middle value, and the median is the mean of the two middle
+    values.
+    - For example, for arr = [2,3,4], the median is 3.
+    - For example, for arr = [2,3], the median is (2 + 3) / 2 = 2.5.
+
+    Implement the MedianFinder class:
+    - MedianFinder() initializes the MedianFinder object.
+    - void addNum(int num) adds the integer num from the data stream to the data
+    structure.
+    - double findMedian() returns the median of all elements so far. Answers within
+    10-5 of the actual answer will be accepted.
+    """
+
+    def __init__(self):
+        self.smallHeap = []
+        self.maxHeap = []
+
+    def addNum(self, num: int) -> None:
+        heappush(self.smallHeap, -num)
+
+        if (
+            self.smallHeap
+            and self.maxHeap
+            and (-1 * self.smallHeap[0]) > self.maxHeap[0]
+        ):
+            val = heappop(self.smallHeap)
+            heappush(self.maxHeap, -val)
+
+        if len(self.smallHeap) > len(self.maxHeap) + 1:
+            val = heappop(self.smallHeap)
+            heappush(self.maxHeap, -val)
+
+        if len(self.maxHeap) > len(self.smallHeap) + 1:
+            val = heappop(self.maxHeap)
+            heappush(self.smallHeap, -val)
+
+    def findMedian(self) -> float:
+        if len(self.smallHeap) == len(self.maxHeap):
+            return 0.5 * (-self.smallHeap[0] + self.maxHeap[0])
+        elif len(self.smallHeap) > len(self.maxHeap):
+            return -self.smallHeap[0]
+        else:
+            return self.maxHeap[0]

awesome_python_leetcode/_373_find_k_pairs_with_smallest_sums.py

@@ -0,0 +1,40 @@
+from typing import List
+from heapq import heappop, heappush
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def kSmallestPairs(
+        self,
+        nums1: List[int],
+        nums2: List[int],
+        k: int,
+    ) -> List[List[int]]:
+        """
+        You are given two integer arrays nums1 and nums2 sorted in non-decreasing order
+        and an integer k.
+
+        Define a pair (u, v) which consists of one element from the first array and one
+        element from the second array.
+
+        Return the k pairs (u1, v1), (u2, v2), ..., (uk, vk) with the smallest sums.
+        """
+        res = []
+        visited = {(0, 0)}
+        heap = []
+        heappush(heap, (nums1[0] + nums2[0], 0, 0))
+
+        while k and heap:
+            _, i, j = heappop(heap)
+            res.append([nums1[i], nums2[j]])
+
+            if i + 1 < len(nums1) and (i + 1, j) not in visited:
+                heappush(heap, (nums1[i + 1] + nums2[j], i + 1, j))
+                visited.add((i + 1, j))
+
+            if j + 1 < len(nums2) and (i, j + 1) not in visited:
+                heappush(heap, (nums1[i] + nums2[j + 1], i, j + 1))
+                visited.add((i, j + 1))
+            k -= 1
+        return res

awesome_python_leetcode/_502_ipo.py

@@ -0,0 +1,47 @@
+from typing import List
+from heapq import heappop, heappush, heapify
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def findMaximizedCapital(
+        self,
+        k: int,
+        w: int,
+        profits: List[int],
+        capital: List[int],
+    ) -> int:
+        """
+        Suppose LeetCode will start its IPO soon. In order to sell a good price of its
+        shares to Venture Capital, LeetCode would like to work on some projects to
+        increase its capital before the IPO. Since it has limited resources, it can
+        only finish at most k distinct projects before the IPO. Help LeetCode design
+        the best way to maximize its total capital after finishing at most k distinct
+        projects.
+
+        You are given n projects where the ith project has a pure profit profits[i] and
+        a minimum capital of capital[i] is needed to start it.
+
+        Initially, you have w capital. When you finish a project, you will obtain its
+        pure profit and the profit will be added to your total capital.
+
+        Pick a list of at most k distinct projects from given projects to maximize your
+        final capital, and return the final maximized capital.
+
+        The answer is guaranteed to fit in a 32-bit signed integer.
+        """
+        maxHeap = []
+        minHeap = [(c, p) for c, p in zip(capital, profits)]
+        heapify(minHeap)
+        for t in range(k):
+
+            while minHeap and minHeap[0][0] <= w:
+                c, p = heappop(minHeap)
+                heappush(maxHeap, -p)
+
+            if not maxHeap:
+                break
+
+            w += -1 * heappop(maxHeap)
+        return w

tests/test_215_kth_largest_element_in_an_array.py

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

tests/test_295_find_median_from_data_stream.py

@@ -0,0 +1,11 @@
+from awesome_python_leetcode._295_find_median_from_data_stream import MedianFinder
+
+
+def test_func():
+    """Tests the solution of a LeetCode problem."""
+    finder = MedianFinder()
+    finder.addNum(1)
+    finder.addNum(2)
+    assert finder.findMedian() == 1.5
+    finder.addNum(3)
+    assert finder.findMedian() == 2

tests/test_373_find_k_pairs_with_smallest_sums.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._373_find_k_pairs_with_smallest_sums import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums1", "nums2", "k", "expected"],
+    argvalues=[
+        ([1, 7, 11], [2, 4, 6], 3, [[1, 2], [1, 4], [1, 6]]),
+        ([1, 1, 2], [1, 2, 3], 2, [[1, 1], [1, 1]]),
+    ],
+)
+def test_func(nums1: List[int], nums2: List[int], k: int, expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    pairs = Solution().kSmallestPairs(nums1, nums2, k)
+    assert pairs == expected

tests/test_502_ipo.py

@@ -0,0 +1,24 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._502_ipo import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["k", "w", "profits", "capital", "expected"],
+    argvalues=[
+        (2, 0, [1, 2, 3], [0, 1, 1], 4),
+        (3, 0, [1, 2, 3], [0, 1, 2], 6),
+    ],
+)
+def test_func(
+    k: int,
+    w: int,
+    profits: List[int],
+    capital: List[int],
+    expected: List[int],
+):
+    """Tests the solution of a LeetCode problem."""
+    maximized_capital = Solution().findMaximizedCapital(k, w, profits, capital)
+    assert maximized_capital == expected