D. J.:

- Add the LeetCode problems and solution for 67, 136, 137, 190, 191 and 201

Author: nobodyPerfecZ

README.md

@@ -33,6 +33,7 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [55 Jump Game](https://leetcode.com/problems/jump-game/description/)
 - [56 Merge Intervals](https://leetcode.com/problems/merge-intervals/description/)
 - [57 Insert Interval](https://leetcode.com/problems/insert-interval/description/)
+- [67 Add Binary](https://leetcode.com/problems/add-binary/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/)
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
@@ -55,6 +56,9 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [169 Majority Element](https://leetcode.com/problems/majority-element/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/)
+- [191 Number of 1 Bits](https://leetcode.com/problems/number-of-1-bits/description/)
+- [201 Bitwise AND of Numbers Range](https://leetcode.com/problems/bitwise-and-of-numbers-range/description/)
 - [202 Happy Number](https://leetcode.com/problems/happy-number/description/)
 - [205 Isomorphic Strings](https://leetcode.com/problems/isomorphic-strings/description/)
 - [219 Contains Duplicates II](https://leetcode.com/problems/contains-duplicate-ii/description/)

awesome_python_leetcode/_136_single_number.py

@@ -0,0 +1,16 @@
+from typing import List
+
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        """
+        Given a non-empty array of integers nums, every element appears twice except for
+        one. Find that single one.
+
+        You must implement a solution with a linear runtime complexity and use only
+        constant extra space.
+        """
+        res = 0
+        for n in nums:
+            res = res ^ n
+        return res

awesome_python_leetcode/_137_single_number_II.py

@@ -0,0 +1,17 @@
+from typing import List
+
+
+class Solution:
+    def singleNumber(self, nums: List[int]) -> int:
+        """
+        Given an integer array nums where every element appears three times except for
+        one, which appears exactly once. Find the single element and return it.
+
+        You must implement a solution with a linear runtime complexity and use only
+        constant extra space.
+        """
+        ones, twos = 0, 0
+        for n in nums:
+            ones = (ones ^ n) & ~twos
+            twos = (twos ^ n) & ~ones
+        return ones

awesome_python_leetcode/_190_reverse_bits.py

@@ -0,0 +1,8 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        """Reverse bits of a given 32 bits unsigned integer."""
+        res = 0
+        for i in range(32):
+            bit = (n >> i) & 1
+            res = res | (bit << (31 - i))
+        return res

awesome_python_leetcode/_191_number_of_1_bits.py

@@ -0,0 +1,11 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        """
+        Given a positive integer n, write a function that returns the number of set bits
+        in its binary representation (also known as the Hamming weight).
+        """
+        count = 0
+        for i in range(32):
+            if (n >> i) & 1:
+                count += 1
+        return count

awesome_python_leetcode/_201_bitwise_and_of_numbers_range.py

@@ -0,0 +1,12 @@
+class Solution:
+    def rangeBitwiseAnd(self, left: int, right: int) -> int:
+        """
+        Given two integers left and right that represent the range [left, right],
+        return the bitwise AND of all numbers in this range, inclusive.
+        """
+        i = 0
+        while left != right:
+            left = left >> 1
+            right = right >> 1
+            i += 1
+        return left << i

awesome_python_leetcode/_67_add_binary.py

@@ -0,0 +1,33 @@
+class Solution:
+    def addBinary(self, a: str, b: str) -> str:
+        """Given two binary strings a and b, return their sum as a binary string."""
+        result, overhead = "", "0"
+        max_length = max(len(a), len(b))
+        a = ("0" * (max_length - len(a))) + a
+        b = ("0" * (max_length - len(b))) + b
+        for a_, b_ in zip(reversed(a), reversed(b)):
+            if a_ == "0" and b_ == "0" and overhead == "0":
+                result = "0" + result
+                overhead = "0"
+            elif a_ == "0" and b_ == "0" and overhead == "1":
+                result = "1" + result
+                overhead = "0"
+            elif a_ == "0" and b_ == "1" and overhead == "0":
+                result = "1" + result
+                overhead = "0"
+            elif a_ == "0" and b_ == "1" and overhead == "1":
+                result = "0" + result
+                overhead = "1"
+            elif a_ == "1" and b_ == "0" and overhead == "0":
+                result = "1" + result
+                overhead = "0"
+            elif a_ == "1" and b_ == "0" and overhead == "1":
+                result = "0" + result
+                overhead = "1"
+            elif a_ == "1" and b_ == "1" and overhead == "0":
+                result = "0" + result
+                overhead = "1"
+            elif a_ == "1" and b_ == "1" and overhead == "1":
+                result = "1" + result
+                overhead = "1"
+        return overhead + result if overhead == "1" else result

tests/test_136_single_number.py

@@ -0,0 +1,17 @@
+from typing import List
+import pytest
+
+from awesome_python_leetcode._136_single_number import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([2, 2, 1], 1),
+        ([4, 1, 2, 1, 2], 4),
+        ([1], 1),
+    ],
+)
+def test_func(nums: List[int], expected: int):
+    num = Solution().singleNumber(nums)
+    assert num == expected

tests/test_137_single_number.py

@@ -0,0 +1,16 @@
+from typing import List
+import pytest
+
+from awesome_python_leetcode._137_single_number_II import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["nums", "expected"],
+    argvalues=[
+        ([2, 2, 3, 2], 3),
+        ([0, 1, 0, 1, 0, 1, 99], 99),
+    ],
+)
+def test_func(nums: List[int], expected: str):
+    num = Solution().singleNumber(nums)
+    assert num == expected

tests/test_190_reverse_bits.py

@@ -0,0 +1,15 @@
+import pytest
+
+from awesome_python_leetcode._190_reverse_bits import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (0b00000010100101000001111010011100, 0b00111001011110000010100101000000),
+        (0b11111111111111111111111111111101, 0b10111111111111111111111111111111),
+    ],
+)
+def test_func(n: int, expected: int):
+    n_reversed = Solution().reverseBits(n)
+    assert n_reversed == expected