Merge branch 'TheAlgorithms:master' into master

Author: tianyizheng02

DIRECTORY.md

@@ -937,6 +937,8 @@
     * [Sol1](project_euler/problem_091/sol1.py)
   * Problem 092
     * [Sol1](project_euler/problem_092/sol1.py)
+  * Problem 094
+    * [Sol1](project_euler/problem_094/sol1.py)
   * Problem 097
     * [Sol1](project_euler/problem_097/sol1.py)
   * Problem 099
@@ -1017,6 +1019,8 @@
     * [Sol1](project_euler/problem_587/sol1.py)
   * Problem 686
     * [Sol1](project_euler/problem_686/sol1.py)
+  * Problem 800
+    * [Sol1](project_euler/problem_800/sol1.py)
 
 ## Quantum
   * [Bb84](quantum/bb84.py)

data_structures/linked_list/doubly_linked_list.py

@@ -81,7 +81,9 @@ def insert_at_nth(self, index: int, data):
             ....
         IndexError: list index out of range
         """
-        if not 0 <= index <= len(self):
+        length = len(self)
+
+        if not 0 <= index <= length:
             raise IndexError("list index out of range")
         new_node = Node(data)
         if self.head is None:
@@ -90,7 +92,7 @@ def insert_at_nth(self, index: int, data):
             self.head.previous = new_node
             new_node.next = self.head
             self.head = new_node
-        elif index == len(self):
+        elif index == length:
             self.tail.next = new_node
             new_node.previous = self.tail
             self.tail = new_node
@@ -131,15 +133,17 @@ def delete_at_nth(self, index: int):
             ....
         IndexError: list index out of range
         """
-        if not 0 <= index <= len(self) - 1:
+        length = len(self)
+
+        if not 0 <= index <= length - 1:
             raise IndexError("list index out of range")
         delete_node = self.head  # default first node
-        if len(self) == 1:
+        if length == 1:
             self.head = self.tail = None
         elif index == 0:
             self.head = self.head.next
             self.head.previous = None
-        elif index == len(self) - 1:
+        elif index == length - 1:
             delete_node = self.tail
             self.tail = self.tail.previous
             self.tail.next = None

digital_image_processing/edge_detection/canny.py

@@ -18,105 +18,126 @@ def gen_gaussian_kernel(k_size, sigma):
     return g
 
 
-def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
-    image_row, image_col = image.shape[0], image.shape[1]
-    # gaussian_filter
-    gaussian_out = img_convolve(image, gen_gaussian_kernel(9, sigma=1.4))
-    # get the gradient and degree by sobel_filter
-    sobel_grad, sobel_theta = sobel_filter(gaussian_out)
-    gradient_direction = np.rad2deg(sobel_theta)
-    gradient_direction += PI
-
-    dst = np.zeros((image_row, image_col))
-
+def suppress_non_maximum(image_shape, gradient_direction, sobel_grad):
     """
     Non-maximum suppression. If the edge strength of the current pixel is the largest
     compared to the other pixels in the mask with the same direction, the value will be
     preserved. Otherwise, the value will be suppressed.
     """
-    for row in range(1, image_row - 1):
-        for col in range(1, image_col - 1):
+    destination = np.zeros(image_shape)
+
+    for row in range(1, image_shape[0] - 1):
+        for col in range(1, image_shape[1] - 1):
             direction = gradient_direction[row, col]
 
             if (
-                0 <= direction < 22.5
+                0 <= direction < PI / 8
                 or 15 * PI / 8 <= direction <= 2 * PI
                 or 7 * PI / 8 <= direction <= 9 * PI / 8
             ):
                 w = sobel_grad[row, col - 1]
                 e = sobel_grad[row, col + 1]
                 if sobel_grad[row, col] >= w and sobel_grad[row, col] >= e:
-                    dst[row, col] = sobel_grad[row, col]
+                    destination[row, col] = sobel_grad[row, col]
 
-            elif (PI / 8 <= direction < 3 * PI / 8) or (
-                9 * PI / 8 <= direction < 11 * PI / 8
+            elif (
+                PI / 8 <= direction < 3 * PI / 8
+                or 9 * PI / 8 <= direction < 11 * PI / 8
             ):
                 sw = sobel_grad[row + 1, col - 1]
                 ne = sobel_grad[row - 1, col + 1]
                 if sobel_grad[row, col] >= sw and sobel_grad[row, col] >= ne:
-                    dst[row, col] = sobel_grad[row, col]
+                    destination[row, col] = sobel_grad[row, col]
 
-            elif (3 * PI / 8 <= direction < 5 * PI / 8) or (
-                11 * PI / 8 <= direction < 13 * PI / 8
+            elif (
+                3 * PI / 8 <= direction < 5 * PI / 8
+                or 11 * PI / 8 <= direction < 13 * PI / 8
             ):
                 n = sobel_grad[row - 1, col]
                 s = sobel_grad[row + 1, col]
                 if sobel_grad[row, col] >= n and sobel_grad[row, col] >= s:
-                    dst[row, col] = sobel_grad[row, col]
+                    destination[row, col] = sobel_grad[row, col]
 
-            elif (5 * PI / 8 <= direction < 7 * PI / 8) or (
-                13 * PI / 8 <= direction < 15 * PI / 8
+            elif (
+                5 * PI / 8 <= direction < 7 * PI / 8
+                or 13 * PI / 8 <= direction < 15 * PI / 8
             ):
                 nw = sobel_grad[row - 1, col - 1]
                 se = sobel_grad[row + 1, col + 1]
                 if sobel_grad[row, col] >= nw and sobel_grad[row, col] >= se:
-                    dst[row, col] = sobel_grad[row, col]
-
-            """
-            High-Low threshold detection. If an edge pixel’s gradient value is higher
-            than the high threshold value, it is marked as a strong edge pixel. If an
-            edge pixel’s gradient value is smaller than the high threshold value and
-            larger than the low threshold value, it is marked as a weak edge pixel. If
-            an edge pixel's value is smaller than the low threshold value, it will be
-            suppressed.
-            """
-            if dst[row, col] >= threshold_high:
-                dst[row, col] = strong
-            elif dst[row, col] <= threshold_low:
-                dst[row, col] = 0
+                    destination[row, col] = sobel_grad[row, col]
+
+    return destination
+
+
+def detect_high_low_threshold(
+    image_shape, destination, threshold_low, threshold_high, weak, strong
+):
+    """
+    High-Low threshold detection. If an edge pixel’s gradient value is higher
+    than the high threshold value, it is marked as a strong edge pixel. If an
+    edge pixel’s gradient value is smaller than the high threshold value and
+    larger than the low threshold value, it is marked as a weak edge pixel. If
+    an edge pixel's value is smaller than the low threshold value, it will be
+    suppressed.
+    """
+    for row in range(1, image_shape[0] - 1):
+        for col in range(1, image_shape[1] - 1):
+            if destination[row, col] >= threshold_high:
+                destination[row, col] = strong
+            elif destination[row, col] <= threshold_low:
+                destination[row, col] = 0
             else:
-                dst[row, col] = weak
+                destination[row, col] = weak
 
+
+def track_edge(image_shape, destination, weak, strong):
     """
     Edge tracking. Usually a weak edge pixel caused from true edges will be connected
     to a strong edge pixel while noise responses are unconnected. As long as there is
     one strong edge pixel that is involved in its 8-connected neighborhood, that weak
     edge point can be identified as one that should be preserved.
     """
-    for row in range(1, image_row):
-        for col in range(1, image_col):
-            if dst[row, col] == weak:
+    for row in range(1, image_shape[0]):
+        for col in range(1, image_shape[1]):
+            if destination[row, col] == weak:
                 if 255 in (
-                    dst[row, col + 1],
-                    dst[row, col - 1],
-                    dst[row - 1, col],
-                    dst[row + 1, col],
-                    dst[row - 1, col - 1],
-                    dst[row + 1, col - 1],
-                    dst[row - 1, col + 1],
-                    dst[row + 1, col + 1],
+                    destination[row, col + 1],
+                    destination[row, col - 1],
+                    destination[row - 1, col],
+                    destination[row + 1, col],
+                    destination[row - 1, col - 1],
+                    destination[row + 1, col - 1],
+                    destination[row - 1, col + 1],
+                    destination[row + 1, col + 1],
                 ):
-                    dst[row, col] = strong
+                    destination[row, col] = strong
                 else:
-                    dst[row, col] = 0
+                    destination[row, col] = 0
+
+
+def canny(image, threshold_low=15, threshold_high=30, weak=128, strong=255):
+    # gaussian_filter
+    gaussian_out = img_convolve(image, gen_gaussian_kernel(9, sigma=1.4))
+    # get the gradient and degree by sobel_filter
+    sobel_grad, sobel_theta = sobel_filter(gaussian_out)
+    gradient_direction = PI + np.rad2deg(sobel_theta)
+
+    destination = suppress_non_maximum(image.shape, gradient_direction, sobel_grad)
+
+    detect_high_low_threshold(
+        image.shape, destination, threshold_low, threshold_high, weak, strong
+    )
+
+    track_edge(image.shape, destination, weak, strong)
 
-    return dst
+    return destination
 
 
 if __name__ == "__main__":
     # read original image in gray mode
     lena = cv2.imread(r"../image_data/lena.jpg", 0)
     # canny edge detection
-    canny_dst = canny(lena)
-    cv2.imshow("canny", canny_dst)
+    canny_destination = canny(lena)
+    cv2.imshow("canny", canny_destination)
     cv2.waitKey(0)

digital_image_processing/morphological_operations/dilation_operation.py

@@ -1,41 +1,43 @@
+from pathlib import Path
+
 import numpy as np
 from PIL import Image
 
 
-def rgb2gray(rgb: np.array) -> np.array:
+def rgb_to_gray(rgb: np.ndarray) -> np.ndarray:
     """
     Return gray image from rgb image
-    >>> rgb2gray(np.array([[[127, 255, 0]]]))
+    >>> rgb_to_gray(np.array([[[127, 255, 0]]]))
     array([[187.6453]])
-    >>> rgb2gray(np.array([[[0, 0, 0]]]))
+    >>> rgb_to_gray(np.array([[[0, 0, 0]]]))
     array([[0.]])
-    >>> rgb2gray(np.array([[[2, 4, 1]]]))
+    >>> rgb_to_gray(np.array([[[2, 4, 1]]]))
     array([[3.0598]])
-    >>> rgb2gray(np.array([[[26, 255, 14], [5, 147, 20], [1, 200, 0]]]))
+    >>> rgb_to_gray(np.array([[[26, 255, 14], [5, 147, 20], [1, 200, 0]]]))
     array([[159.0524,  90.0635, 117.6989]])
     """
     r, g, b = rgb[:, :, 0], rgb[:, :, 1], rgb[:, :, 2]
     return 0.2989 * r + 0.5870 * g + 0.1140 * b
 
 
-def gray2binary(gray: np.array) -> np.array:
+def gray_to_binary(gray: np.ndarray) -> np.ndarray:
     """
     Return binary image from gray image
-    >>> gray2binary(np.array([[127, 255, 0]]))
+    >>> gray_to_binary(np.array([[127, 255, 0]]))
     array([[False,  True, False]])
-    >>> gray2binary(np.array([[0]]))
+    >>> gray_to_binary(np.array([[0]]))
     array([[False]])
-    >>> gray2binary(np.array([[26.2409, 4.9315, 1.4729]]))
+    >>> gray_to_binary(np.array([[26.2409, 4.9315, 1.4729]]))
     array([[False, False, False]])
-    >>> gray2binary(np.array([[26, 255, 14], [5, 147, 20], [1, 200, 0]]))
+    >>> gray_to_binary(np.array([[26, 255, 14], [5, 147, 20], [1, 200, 0]]))
     array([[False,  True, False],
            [False,  True, False],
            [False,  True, False]])
     """
     return (gray > 127) & (gray <= 255)
 
 
-def dilation(image: np.array, kernel: np.array) -> np.array:
+def dilation(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:
     """
     Return dilated image
     >>> dilation(np.array([[True, False, True]]), np.array([[0, 1, 0]]))
@@ -61,14 +63,13 @@ def dilation(image: np.array, kernel: np.array) -> np.array:
     return output
 
 
-# kernel to be applied
-structuring_element = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
-
-
 if __name__ == "__main__":
     # read original image
-    image = np.array(Image.open(r"..\image_data\lena.jpg"))
-    output = dilation(gray2binary(rgb2gray(image)), structuring_element)
+    lena_path = Path(__file__).resolve().parent / "image_data" / "lena.jpg"
+    lena = np.array(Image.open(lena_path))
+    # kernel to be applied
+    structuring_element = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 0]])
+    output = dilation(gray_to_binary(rgb_to_gray(lena)), structuring_element)
     # Save the output image
     pil_img = Image.fromarray(output).convert("RGB")
     pil_img.save("result_dilation.png")

physics/grahams_law.py

@@ -0,0 +1,208 @@
+"""
+Title: Graham's Law of Effusion
+
+Description: Graham's law of effusion states that the rate of effusion of a gas is
+inversely proportional to the square root of the molar mass of its particles:
+
+r1/r2 = sqrt(m2/m1)
+
+r1 = Rate of effusion for the first gas.
+r2 = Rate of effusion for the second gas.
+m1 = Molar mass of the first gas.
+m2 = Molar mass of the second gas.
+
+(Description adapted from https://en.wikipedia.org/wiki/Graham%27s_law)
+"""
+
+from math import pow, sqrt
+
+
+def validate(*values: float) -> bool:
+    """
+    Input Parameters:
+    -----------------
+    effusion_rate_1: Effustion rate of first gas (m^2/s, mm^2/s, etc.)
+    effusion_rate_2: Effustion rate of second gas (m^2/s, mm^2/s, etc.)
+    molar_mass_1: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    molar_mass_2: Molar mass of the second gas (g/mol, kg/kmol, etc.)
+
+    Returns:
+    --------
+    >>> validate(2.016, 4.002)
+    True
+    >>> validate(-2.016, 4.002)
+    False
+    >>> validate()
+    False
+    """
+    result = len(values) > 0 and all(value > 0.0 for value in values)
+    return result
+
+
+def effusion_ratio(molar_mass_1: float, molar_mass_2: float) -> float | ValueError:
+    """
+    Input Parameters:
+    -----------------
+    molar_mass_1: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    molar_mass_2: Molar mass of the second gas (g/mol, kg/kmol, etc.)
+
+    Returns:
+    --------
+    >>> effusion_ratio(2.016, 4.002)
+    1.408943
+    >>> effusion_ratio(-2.016, 4.002)
+    ValueError('Input Error: Molar mass values must greater than 0.')
+    >>> effusion_ratio(2.016)
+    Traceback (most recent call last):
+      ...
+    TypeError: effusion_ratio() missing 1 required positional argument: 'molar_mass_2'
+    """
+    return (
+        round(sqrt(molar_mass_2 / molar_mass_1), 6)
+        if validate(molar_mass_1, molar_mass_2)
+        else ValueError("Input Error: Molar mass values must greater than 0.")
+    )
+
+
+def first_effusion_rate(
+    effusion_rate: float, molar_mass_1: float, molar_mass_2: float
+) -> float | ValueError:
+    """
+    Input Parameters:
+    -----------------
+    effusion_rate: Effustion rate of second gas (m^2/s, mm^2/s, etc.)
+    molar_mass_1: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    molar_mass_2: Molar mass of the second gas (g/mol, kg/kmol, etc.)
+
+    Returns:
+    --------
+    >>> first_effusion_rate(1, 2.016, 4.002)
+    1.408943
+    >>> first_effusion_rate(-1, 2.016, 4.002)
+    ValueError('Input Error: Molar mass and effusion rate values must greater than 0.')
+    >>> first_effusion_rate(1)
+    Traceback (most recent call last):
+      ...
+    TypeError: first_effusion_rate() missing 2 required positional arguments: \
+'molar_mass_1' and 'molar_mass_2'
+    >>> first_effusion_rate(1, 2.016)
+    Traceback (most recent call last):
+      ...
+    TypeError: first_effusion_rate() missing 1 required positional argument: \
+'molar_mass_2'
+    """
+    return (
+        round(effusion_rate * sqrt(molar_mass_2 / molar_mass_1), 6)
+        if validate(effusion_rate, molar_mass_1, molar_mass_2)
+        else ValueError(
+            "Input Error: Molar mass and effusion rate values must greater than 0."
+        )
+    )
+
+
+def second_effusion_rate(
+    effusion_rate: float, molar_mass_1: float, molar_mass_2: float
+) -> float | ValueError:
+    """
+    Input Parameters:
+    -----------------
+    effusion_rate: Effustion rate of second gas (m^2/s, mm^2/s, etc.)
+    molar_mass_1: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    molar_mass_2: Molar mass of the second gas (g/mol, kg/kmol, etc.)
+
+    Returns:
+    --------
+    >>> second_effusion_rate(1, 2.016, 4.002)
+    0.709752
+    >>> second_effusion_rate(-1, 2.016, 4.002)
+    ValueError('Input Error: Molar mass and effusion rate values must greater than 0.')
+    >>> second_effusion_rate(1)
+    Traceback (most recent call last):
+      ...
+    TypeError: second_effusion_rate() missing 2 required positional arguments: \
+'molar_mass_1' and 'molar_mass_2'
+    >>> second_effusion_rate(1, 2.016)
+    Traceback (most recent call last):
+      ...
+    TypeError: second_effusion_rate() missing 1 required positional argument: \
+'molar_mass_2'
+    """
+    return (
+        round(effusion_rate / sqrt(molar_mass_2 / molar_mass_1), 6)
+        if validate(effusion_rate, molar_mass_1, molar_mass_2)
+        else ValueError(
+            "Input Error: Molar mass and effusion rate values must greater than 0."
+        )
+    )
+
+
+def first_molar_mass(
+    molar_mass: float, effusion_rate_1: float, effusion_rate_2: float
+) -> float | ValueError:
+    """
+    Input Parameters:
+    -----------------
+    molar_mass: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    effusion_rate_1: Effustion rate of first gas (m^2/s, mm^2/s, etc.)
+    effusion_rate_2: Effustion rate of second gas (m^2/s, mm^2/s, etc.)
+
+    Returns:
+    --------
+    >>> first_molar_mass(2, 1.408943, 0.709752)
+    0.507524
+    >>> first_molar_mass(-1, 2.016, 4.002)
+    ValueError('Input Error: Molar mass and effusion rate values must greater than 0.')
+    >>> first_molar_mass(1)
+    Traceback (most recent call last):
+      ...
+    TypeError: first_molar_mass() missing 2 required positional arguments: \
+'effusion_rate_1' and 'effusion_rate_2'
+    >>> first_molar_mass(1, 2.016)
+    Traceback (most recent call last):
+      ...
+    TypeError: first_molar_mass() missing 1 required positional argument: \
+'effusion_rate_2'
+    """
+    return (
+        round(molar_mass / pow(effusion_rate_1 / effusion_rate_2, 2), 6)
+        if validate(molar_mass, effusion_rate_1, effusion_rate_2)
+        else ValueError(
+            "Input Error: Molar mass and effusion rate values must greater than 0."
+        )
+    )
+
+
+def second_molar_mass(
+    molar_mass: float, effusion_rate_1: float, effusion_rate_2: float
+) -> float | ValueError:
+    """
+    Input Parameters:
+    -----------------
+    molar_mass: Molar mass of the first gas (g/mol, kg/kmol, etc.)
+    effusion_rate_1: Effustion rate of first gas (m^2/s, mm^2/s, etc.)
+    effusion_rate_2: Effustion rate of second gas (m^2/s, mm^2/s, etc.)
+
+    Returns:
+    --------
+    >>> second_molar_mass(2, 1.408943, 0.709752)
+    1.970351
+    >>> second_molar_mass(-2, 1.408943, 0.709752)
+    ValueError('Input Error: Molar mass and effusion rate values must greater than 0.')
+    >>> second_molar_mass(1)
+    Traceback (most recent call last):
+      ...
+    TypeError: second_molar_mass() missing 2 required positional arguments: \
+'effusion_rate_1' and 'effusion_rate_2'
+    >>> second_molar_mass(1, 2.016)
+    Traceback (most recent call last):
+      ...
+    TypeError: second_molar_mass() missing 1 required positional argument: \
+'effusion_rate_2'
+    """
+    return (
+        round(pow(effusion_rate_1 / effusion_rate_2, 2) / molar_mass, 6)
+        if validate(molar_mass, effusion_rate_1, effusion_rate_2)
+        else ValueError(
+            "Input Error: Molar mass and effusion rate values must greater than 0."
+        )
+    )

project_euler/problem_094/__init__.py

@@ -0,0 +1,44 @@
+"""
+Project Euler Problem 94: https://projecteuler.net/problem=94
+
+It is easily proved that no equilateral triangle exists with integral length sides and
+integral area. However, the almost equilateral triangle 5-5-6 has an area of 12 square
+units.
+
+We shall define an almost equilateral triangle to be a triangle for which two sides are
+equal and the third differs by no more than one unit.
+
+Find the sum of the perimeters of all almost equilateral triangles with integral side
+lengths and area and whose perimeters do not exceed one billion (1,000,000,000).
+"""
+
+
+def solution(max_perimeter: int = 10**9) -> int:
+    """
+    Returns the sum of the perimeters of all almost equilateral triangles with integral
+    side lengths and area and whose perimeters do not exceed max_perimeter
+
+    >>> solution(20)
+    16
+    """
+
+    prev_value = 1
+    value = 2
+
+    perimeters_sum = 0
+    i = 0
+    perimeter = 0
+    while perimeter <= max_perimeter:
+        perimeters_sum += perimeter
+
+        prev_value += 2 * value
+        value += prev_value
+
+        perimeter = 2 * value + 2 if i % 2 == 0 else 2 * value - 2
+        i += 1
+
+    return perimeters_sum
+
+
+if __name__ == "__main__":
+    print(f"{solution() = }")

project_euler/problem_094/sol1.py

@@ -0,0 +1,65 @@
+"""
+Project Euler Problem 800: https://projecteuler.net/problem=800
+
+An integer of the form p^q q^p with prime numbers p != q is called a hybrid-integer.
+For example, 800 = 2^5 5^2 is a hybrid-integer.
+
+We define C(n) to be the number of hybrid-integers less than or equal to n.
+You are given C(800) = 2 and C(800^800) = 10790
+
+Find C(800800^800800)
+"""
+
+from math import isqrt, log2
+
+
+def calculate_prime_numbers(max_number: int) -> list[int]:
+    """
+    Returns prime numbers below max_number
+
+    >>> calculate_prime_numbers(10)
+    [2, 3, 5, 7]
+    """
+
+    is_prime = [True] * max_number
+    for i in range(2, isqrt(max_number - 1) + 1):
+        if is_prime[i]:
+            for j in range(i**2, max_number, i):
+                is_prime[j] = False
+
+    return [i for i in range(2, max_number) if is_prime[i]]
+
+
+def solution(base: int = 800800, degree: int = 800800) -> int:
+    """
+    Returns the number of hybrid-integers less than or equal to base^degree
+
+    >>> solution(800, 1)
+    2
+
+    >>> solution(800, 800)
+    10790
+    """
+
+    upper_bound = degree * log2(base)
+    max_prime = int(upper_bound)
+    prime_numbers = calculate_prime_numbers(max_prime)
+
+    hybrid_integers_count = 0
+    left = 0
+    right = len(prime_numbers) - 1
+    while left < right:
+        while (
+            prime_numbers[right] * log2(prime_numbers[left])
+            + prime_numbers[left] * log2(prime_numbers[right])
+            > upper_bound
+        ):
+            right -= 1
+        hybrid_integers_count += right - left
+        left += 1
+
+    return hybrid_integers_count
+
+
+if __name__ == "__main__":
+    print(f"{solution() = }")