D. J.:

- Added the leetcode problem and solution for 11, 15 and 167

Author: nobodyPerfecZ

README.md

@@ -28,9 +28,11 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [2 Add Two Numbers](https://leetcode.com/problems/add-two-numbers/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/)
 - [12 Integer to Roman](https://leetcode.com/problems/integer-to-roman/description/)
 - [13 Roman to Integer](https://leetcode.com/problems/roman-to-integer/description/)
 - [14 Longest Common Prefix](https://leetcode.com/problems/longest-common-prefix/description/)
+- [15 3Sum](https://leetcode.com/problems/3sum/description/)
 - [19 Remove Nth Node From End of List](https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
 - [20 Valid Parentheses](https://leetcode.com/problems/valid-parentheses/description/)
 - [21 Merge Two Sorted Lists](https://leetcode.com/problems/merge-two-sorted-lists/description/)
@@ -88,6 +90,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [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/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/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/)
 - [173 Binary Search Tree Iterator](https://leetcode.com/problems/binary-search-tree-iterator/description/)

awesome_python_leetcode/_11_container_with_most_water.py

@@ -0,0 +1,27 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxArea(self, height: List[int]) -> int:
+        """
+        You are given an integer array height of length n. There are n vertical lines
+        drawn such that the two endpoints of the ith line are (i, 0) and (i, height[i]).
+
+        Find two lines that together with the x-axis form a container, such that the
+        container contains the most water.
+
+        Return the maximum amount of water a container can store.
+
+        Notice that you may not slant the container.
+        """
+        maxArea = 0
+        left, right = 0, len(height) - 1
+        while left < right:
+            maxArea = max(maxArea, min(height[left], height[right]) * (right - left))
+            if height[left] < height[right]:
+                left += 1
+            else:
+                right -= 1
+        return maxArea

awesome_python_leetcode/_15_3sum.py

@@ -0,0 +1,35 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def threeSum(self, nums: List[int]) -> List[List[int]]:
+        """
+        Given an integer array nums, return all the triplets
+        [nums[i], nums[j],nums[k]] such that i != j, i != k, and j != k, and
+        nums[i] + nums[j] + nums[k] == 0.
+
+        Notice that the solution set must not contain duplicate triplets.
+        """
+        nums = sorted(nums)
+        threeSums = []
+        i = 0
+        while i < len(nums) - 2:
+            if i > 0 and nums[i] == nums[i - 1]:
+                i += 1
+                continue
+            left, right = i + 1, len(nums) - 1
+            while left < right:
+                threeSum = nums[i] + nums[left] + nums[right]
+                if threeSum > 0:
+                    right -= 1
+                elif threeSum < 0:
+                    left += 1
+                else:
+                    threeSums.append([nums[i], nums[left], nums[right]])
+                    left += 1
+                    while left < right and nums[left] == nums[left - 1]:
+                        left += 1
+            i += 1
+        return threeSums

awesome_python_leetcode/_167_two_sum_II_input_array_is_sorted.py

@@ -0,0 +1,34 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def twoSum(self, numbers: List[int], target: int) -> List[int]:
+        """
+        Given a 1-indexed array of integers numbers that is already sorted in
+        non-decreasing order, find two numbers such that they add up to a specific
+        target number. Let these two numbers be numbers[index1] and numbers[index2]
+        where 1 <= index1 < index2 <= numbers.length.
+
+        Return the indices of the two numbers, index1 and index2, added by one as an
+        integer array [index1, index2] of length 2.
+
+        The tests are generated such that there is exactly one solution. You may not
+        use the same element twice.
+
+        Your solution must use only constant extra space.
+        """
+        if len(numbers) == 2:
+            return [1, 2]
+
+        left, right = 0, len(numbers) - 1
+        while left < right:
+            twosum = numbers[left] + numbers[right]
+            if twosum < target:
+                left += 1
+            elif twosum > target:
+                right -= 1
+            else:
+                return [left + 1, right + 1]
+        return [left + 1, right + 1]

tests/test_11_container_with_most_water.py

@@ -0,0 +1,18 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._11_container_with_most_water import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["height", "expected"],
+    argvalues=[
+        ([1, 8, 6, 2, 5, 4, 8, 3, 7], 49),
+        ([1, 1], 1),
+    ],
+)
+def test_func(height: List[int], expected: int):
+    """Tests the solution of a LeetCode problem."""
+    max_area = Solution().maxArea(height)
+    assert max_area == expected

tests/test_15_3sum.py

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

tests/test_167_two_sum_II_input_array_is_sorted.py

@@ -0,0 +1,19 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._167_two_sum_II_input_array_is_sorted import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["numbers", "target", "expected"],
+    argvalues=[
+        ([2, 7, 11, 15], 9, [1, 2]),
+        ([2, 3, 4], 6, [1, 3]),
+        ([-1, 0], -1, [1, 2]),
+    ],
+)
+def test_func(numbers: List[int], target: int, expected: List[int]):
+    """Tests the solution of a LeetCode problem."""
+    two_sum = Solution().twoSum(numbers, target)
+    assert two_sum == expected