Merge branch 'TheAlgorithms:master' into master

Author: MaximSmolskiy

Diff for: DIRECTORY.md

@@ -990,6 +990,8 @@
     * [Sol1](project_euler/problem_174/sol1.py)
   * Problem 180
     * [Sol1](project_euler/problem_180/sol1.py)
+  * Problem 187
+    * [Sol1](project_euler/problem_187/sol1.py)
   * Problem 188
     * [Sol1](project_euler/problem_188/sol1.py)
   * Problem 191

Diff for: arithmetic_analysis/lu_decomposition.py

@@ -1,62 +1,101 @@
-"""Lower-Upper (LU) Decomposition.
+"""
+Lower–upper (LU) decomposition factors a matrix as a product of a lower
+triangular matrix and an upper triangular matrix. A square matrix has an LU
+decomposition under the following conditions:
+    - If the matrix is invertible, then it has an LU decomposition if and only
+    if all of its leading principal minors are non-zero (see
+    https://en.wikipedia.org/wiki/Minor_(linear_algebra) for an explanation of
+    leading principal minors of a matrix).
+    - If the matrix is singular (i.e., not invertible) and it has a rank of k
+    (i.e., it has k linearly independent columns), then it has an LU
+    decomposition if its first k leading principal minors are non-zero.
+
+This algorithm will simply attempt to perform LU decomposition on any square
+matrix and raise an error if no such decomposition exists.
 
-Reference:
-- https://en.wikipedia.org/wiki/LU_decomposition
+Reference: https://en.wikipedia.org/wiki/LU_decomposition
 """
 from __future__ import annotations
 
 import numpy as np
-from numpy import float64
-from numpy.typing import ArrayLike
-
 
-def lower_upper_decomposition(
-    table: ArrayLike[float64],
-) -> tuple[ArrayLike[float64], ArrayLike[float64]]:
-    """Lower-Upper (LU) Decomposition
-
-    Example:
 
+def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Perform LU decomposition on a given matrix and raises an error if the matrix
+    isn't square or if no such decomposition exists
     >>> matrix = np.array([[2, -2, 1], [0, 1, 2], [5, 3, 1]])
-    >>> outcome = lower_upper_decomposition(matrix)
-    >>> outcome[0]
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
     array([[1. , 0. , 0. ],
            [0. , 1. , 0. ],
            [2.5, 8. , 1. ]])
-    >>> outcome[1]
+    >>> upper_mat
     array([[  2. ,  -2. ,   1. ],
            [  0. ,   1. ,   2. ],
            [  0. ,   0. , -17.5]])
 
+    >>> matrix = np.array([[4, 3], [6, 3]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
+    array([[1. , 0. ],
+           [1.5, 1. ]])
+    >>> upper_mat
+    array([[ 4. ,  3. ],
+           [ 0. , -1.5]])
+
+    # Matrix is not square
     >>> matrix = np.array([[2, -2, 1], [0, 1, 2]])
-    >>> lower_upper_decomposition(matrix)
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
     Traceback (most recent call last):
         ...
     ValueError: 'table' has to be of square shaped array but got a 2x3 array:
     [[ 2 -2  1]
      [ 0  1  2]]
+
+    # Matrix is invertible, but its first leading principal minor is 0
+    >>> matrix = np.array([[0, 1], [1, 0]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    Traceback (most recent call last):
+    ...
+    ArithmeticError: No LU decomposition exists
+
+    # Matrix is singular, but its first leading principal minor is 1
+    >>> matrix = np.array([[1, 0], [1, 0]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
+    array([[1., 0.],
+           [1., 1.]])
+    >>> upper_mat
+    array([[1., 0.],
+           [0., 0.]])
+
+    # Matrix is singular, but its first leading principal minor is 0
+    >>> matrix = np.array([[0, 1], [0, 1]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    Traceback (most recent call last):
+    ...
+    ArithmeticError: No LU decomposition exists
     """
-    # Table that contains our data
-    # Table has to be a square array so we need to check first
+    # Ensure that table is a square array
     rows, columns = np.shape(table)
     if rows != columns:
         raise ValueError(
-            f"'table' has to be of square shaped array but got a {rows}x{columns} "
-            + f"array:\n{table}"
+            f"'table' has to be of square shaped array but got a "
+            f"{rows}x{columns} array:\n{table}"
         )
+
     lower = np.zeros((rows, columns))
     upper = np.zeros((rows, columns))
     for i in range(columns):
         for j in range(i):
-            total = 0
-            for k in range(j):
-                total += lower[i][k] * upper[k][j]
+            total = sum(lower[i][k] * upper[k][j] for k in range(j))
+            if upper[j][j] == 0:
+                raise ArithmeticError("No LU decomposition exists")
             lower[i][j] = (table[i][j] - total) / upper[j][j]
         lower[i][i] = 1
         for j in range(i, columns):
-            total = 0
-            for k in range(i):
-                total += lower[i][k] * upper[k][j]
+            total = sum(lower[i][k] * upper[k][j] for k in range(j))
             upper[i][j] = table[i][j] - total
     return lower, upper
 

Diff for: computer_vision/cnn_classification.py

@@ -93,7 +93,7 @@
     test_image = tf.keras.preprocessing.image.img_to_array(test_image)
     test_image = np.expand_dims(test_image, axis=0)
     result = classifier.predict(test_image)
-    training_set.class_indices
+    # training_set.class_indices
     if result[0][0] == 0:
         prediction = "Normal"
     if result[0][0] == 1:

Diff for: data_structures/linked_list/circular_linked_list.py

@@ -24,7 +24,7 @@ def __iter__(self) -> Iterator[Any]:
                 break
 
     def __len__(self) -> int:
-        return len(tuple(iter(self)))
+        return sum(1 for _ in self)
 
     def __repr__(self):
         return "->".join(str(item) for item in iter(self))

Diff for: data_structures/linked_list/doubly_linked_list.py

@@ -51,7 +51,7 @@ def __len__(self):
         >>> len(linked_list) == 5
         True
         """
-        return len(tuple(iter(self)))
+        return sum(1 for _ in self)
 
     def insert_at_head(self, data):
         self.insert_at_nth(0, data)

Diff for: data_structures/linked_list/merge_two_lists.py

@@ -44,7 +44,7 @@ def __len__(self) -> int:
         >>> len(SortedLinkedList(test_data_odd))
         8
         """
-        return len(tuple(iter(self)))
+        return sum(1 for _ in self)
 
     def __str__(self) -> str:
         """

Diff for: data_structures/linked_list/singly_linked_list.py

@@ -72,7 +72,7 @@ def __len__(self) -> int:
         >>> len(linked_list)
         0
         """
-        return len(tuple(iter(self)))
+        return sum(1 for _ in self)
 
     def __repr__(self) -> str:
         """

Diff for: dynamic_programming/max_product_subarray.py

@@ -0,0 +1,53 @@
+def max_product_subarray(numbers: list[int]) -> int:
+    """
+    Returns the maximum product that can be obtained by multiplying a
+    contiguous subarray of the given integer list `nums`.
+
+    Example:
+    >>> max_product_subarray([2, 3, -2, 4])
+    6
+    >>> max_product_subarray((-2, 0, -1))
+    0
+    >>> max_product_subarray([2, 3, -2, 4, -1])
+    48
+    >>> max_product_subarray([-1])
+    -1
+    >>> max_product_subarray([0])
+    0
+    >>> max_product_subarray([])
+    0
+    >>> max_product_subarray("")
+    0
+    >>> max_product_subarray(None)
+    0
+    >>> max_product_subarray([2, 3, -2, 4.5, -1])
+    Traceback (most recent call last):
+        ...
+    ValueError: numbers must be an iterable of integers
+    >>> max_product_subarray("ABC")
+    Traceback (most recent call last):
+        ...
+    ValueError: numbers must be an iterable of integers
+    """
+    if not numbers:
+        return 0
+
+    if not isinstance(numbers, (list, tuple)) or not all(
+        isinstance(number, int) for number in numbers
+    ):
+        raise ValueError("numbers must be an iterable of integers")
+
+    max_till_now = min_till_now = max_prod = numbers[0]
+
+    for i in range(1, len(numbers)):
+        # update the maximum and minimum subarray products
+        number = numbers[i]
+        if number < 0:
+            max_till_now, min_till_now = min_till_now, max_till_now
+        max_till_now = max(number, max_till_now * number)
+        min_till_now = min(number, min_till_now * number)
+
+        # update the maximum product found till now
+        max_prod = max(max_prod, max_till_now)
+
+    return max_prod

Diff for: file_transfer/receive_file.py

@@ -1,8 +1,9 @@
-if __name__ == "__main__":
-    import socket  # Import socket module
+import socket
+
 
-    sock = socket.socket()  # Create a socket object
-    host = socket.gethostname()  # Get local machine name
+def main():
+    sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    host = socket.gethostname()
     port = 12312
 
     sock.connect((host, port))
@@ -13,11 +14,14 @@
         print("Receiving data...")
         while True:
             data = sock.recv(1024)
-            print(f"{data = }")
             if not data:
                 break
-            out_file.write(data)  # Write data to a file
+            out_file.write(data)
 
-    print("Successfully got the file")
+    print("Successfully received the file")
     sock.close()
     print("Connection closed")
+
+
+if __name__ == "__main__":
+    main()

Diff for: project_euler/problem_187/__init__.py

@@ -0,0 +1,58 @@
+"""
+Project Euler Problem 187: https://projecteuler.net/problem=187
+
+A composite is a number containing at least two prime factors.
+For example, 15 = 3 x 5; 9 = 3 x 3; 12 = 2 x 2 x 3.
+
+There are ten composites below thirty containing precisely two,
+not necessarily distinct, prime factors: 4, 6, 9, 10, 14, 15, 21, 22, 25, 26.
+
+How many composite integers, n < 10^8, have precisely two,
+not necessarily distinct, prime factors?
+"""
+
+from math import isqrt
+
+
+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(max_number: int = 10**8) -> int:
+    """
+    Returns the number of composite integers below max_number have precisely two,
+    not necessarily distinct, prime factors
+
+    >>> solution(30)
+    10
+    """
+
+    prime_numbers = calculate_prime_numbers(max_number // 2)
+
+    semiprimes_count = 0
+    left = 0
+    right = len(prime_numbers) - 1
+    while left <= right:
+        while prime_numbers[left] * prime_numbers[right] >= max_number:
+            right -= 1
+        semiprimes_count += right - left + 1
+        left += 1
+
+    return semiprimes_count
+
+
+if __name__ == "__main__":
+    print(f"{solution() = }")