D. J.:

- Added the leetcode problem and solution for 9, 50, 66, 69, 149 and 172

Author: nobodyPerfecZ

README.md

@@ -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/)
 - [6 Zigzag Conversion](https://leetcode.com/problems/zigzag-conversion/description/)
+- [9 Palindrome Number](https://leetcode.com/problems/palindrome-number/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/)
@@ -40,13 +41,16 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [42 Trapping Rain Water](https://leetcode.com/problems/trapping-rain-water/description/)
 - [45 Jump Game II](https://leetcode.com/problems/jump-game-ii/description/)
 - [49 Group Anagrams](https://leetcode.com/problems/group-anagrams/description/)
+- [50 Pow(x_n)](https://leetcode.com/problems/powx-n/description/)
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
 - [58 Length of Last Word](https://leetcode.com/problems/length-of-last-word/description/)
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
 - [57 Insert Interval](https://leetcode.com/problems/insert-interval/description/)
 - [61 Rotate List](https://leetcode.com/problems/rotate-list/description/)
+- [66 Plus One](https://leetcode.com/problems/plus-one/description)
 - [67 Add Binary](https://leetcode.com/problems/add-binary/description/)
 - [68 Text Justification](https://leetcode.com/problems/text-justification/description/)
+- [69 Sqrt(x)](https://leetcode.com/problems/sqrtx/description/)
 - [71 Simplify Path](https://leetcode.com/problems/simplify-path/description/)
 - [80 Remove Duplicates from Sorted Array II](https://leetcode.com/problems/remove-duplicates-from-sorted-array-ii/description/)
 - [82 Remove Duplicates from Sorted List II](https://leetcode.com/problems/remove-duplicates-from-sorted-list-ii/description/)
@@ -80,10 +84,12 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [138 Copy List with Random Pointer](https://leetcode.com/problems/copy-list-with-random-pointer/description/)
 - [141 Linked List Cycle](https://leetcode.com/problems/linked-list-cycle/description/)
 - [146 LRU Cache](https://leetcode.com/problems/lru-cache/description/)
+- [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/)
 - [155 Min Stack](https://leetcode.com/problems/min-stack/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/)
 - [189 Rotate Array](https://leetcode.com/problems/rotate-array/description/)
 - [190 Reverse Bits](https://leetcode.com/problems/reverse-bits/description/)

awesome_python_leetcode/_149_max_points_on_a_line.py

@@ -0,0 +1,26 @@
+import collections
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def maxPoints(self, points: List[List[int]]) -> int:
+        """
+        Given an array of points where points[i] = [xi, yi] represents a point on the
+        X-Y plane, return the maximum number of points that lie on the same straight
+        line.
+        """
+        max_points = 1
+        for i in range(len(points)):
+            p1 = points[i]
+            count = collections.defaultdict(int)
+            for j in range(i + 1, len(points)):
+                p2 = points[j]
+                if p2[0] == p1[0]:
+                    slope = float("inf")
+                else:
+                    slope = (p2[1] - p1[1]) / (p2[0] - p1[0])
+                count[slope] += 1
+                max_points = max(max_points, count[slope] + 1)
+        return max_points

awesome_python_leetcode/_172_factorial_trailing_zeros.py

@@ -0,0 +1,9 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def trailingZeroes(self, n: int) -> int:
+        zeros = 0
+        while n != 0:
+            n = n // 5
+            zeros += n
+        return zeros

awesome_python_leetcode/_50_pow_x_n.py

@@ -0,0 +1,22 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def myPow(self, x: float, n: int) -> float:
+        """
+        Implement pow(x, n), which calculates x raised to the power n (i.e., xn).
+        """
+
+        def power(x: float, n: int):
+            if n == 0:
+                return 1
+            elif n == 1:
+                return x
+            elif n % 2 != 0:
+                x_n = self.myPow(x, n // 2)
+                return x * x_n * x_n
+            else:
+                x_n = self.myPow(x, n // 2)
+                return x_n * x_n
+
+        res = power(x, abs(n))
+        return res if n >= 0 else 1 / res

awesome_python_leetcode/_66_plus_one.py

@@ -0,0 +1,25 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def plusOne(self, digits: List[int]) -> List[int]:
+        """
+        You are given a large integer represented as an integer array digits, where each
+        digits[i] is the ith digit of the integer. The digits are ordered from most
+        significant to least significant in left-to-right order. The large integer does
+        not contain any leading 0's.
+
+        Increment the large integer by one and return the resulting array of digits.
+        """
+        leftover = 1
+        for i in range(len(digits) - 1, -1, -1):
+            if leftover == 0:
+                break
+            val = digits[i] + leftover
+            digits[i] = val % 10
+            leftover = val // 10
+        if leftover == 1:
+            digits.insert(0, leftover)
+        return digits

awesome_python_leetcode/_69_sqrt_x.py

@@ -0,0 +1,23 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def mySqrt(self, x: int) -> int:
+        """
+        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.
+        - For example, do not use pow(x, 0.5) in c++ or x ** 0.5 in python.
+        """
+        left, right = 0, x
+        res = 0
+        while left <= right:
+            mid = left + ((right - left) // 2)
+            if mid**2 > x:
+                right = mid - 1
+            elif mid**2 < x:
+                left = mid + 1
+                res = mid
+            else:
+                return mid
+        return res

awesome_python_leetcode/_9_palindrome_number.py

@@ -0,0 +1,31 @@
+from typing import List
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def digits(self, x: int) -> List[int]:
+        x = abs(x)
+        digits = []
+        while x != 0:
+            digits.insert(0, x % 10)
+            x = x // 10
+        return digits
+
+    def isPalindrome(self, x: int) -> bool:
+        """
+        Given an integer x, return true if x is a palindrome, and false otherwise.
+
+        An integer is a palindrome when it reads the same forward and backward.
+        """
+        if x < 0:
+            return False
+
+        digits = self.digits(x)
+        i, j = 0, len(digits) - 1
+        while i < j:
+            if digits[i] != digits[j]:
+                return False
+            i += 1
+            j -= 1
+        return True

requirements.txt

@@ -0,0 +1 @@
+numpy>=2.2.4

tests/test_149_max_points_on_a_line.py

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

tests/test_172_factorial_trailing_zeroes.py

@@ -0,0 +1,18 @@
+import pytest
+
+from awesome_python_leetcode._172_factorial_trailing_zeros import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (3, 0),
+        (5, 1),
+        (0, 0),
+        (7, 1),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    trailing_zeroes = Solution().trailingZeroes(n)
+    assert trailing_zeroes == expected