Merge branch 'TheAlgorithms:master' into master

Author: PoojanSmart

DIRECTORY.md

@@ -174,6 +174,7 @@
   * [Roman Numerals](conversions/roman_numerals.py)
   * [Speed Conversions](conversions/speed_conversions.py)
   * [Temperature Conversions](conversions/temperature_conversions.py)
+  * [Time Conversions](conversions/time_conversions.py)
   * [Volume Conversions](conversions/volume_conversions.py)
   * [Weight Conversion](conversions/weight_conversion.py)
 
@@ -438,8 +439,7 @@
   * [Breadth First Search Shortest Path](graphs/breadth_first_search_shortest_path.py)
   * [Breadth First Search Shortest Path 2](graphs/breadth_first_search_shortest_path_2.py)
   * [Breadth First Search Zero One Shortest Path](graphs/breadth_first_search_zero_one_shortest_path.py)
-  * [Check Bipartite Graph Bfs](graphs/check_bipartite_graph_bfs.py)
-  * [Check Bipartite Graph Dfs](graphs/check_bipartite_graph_dfs.py)
+  * [Check Bipatrite](graphs/check_bipatrite.py)
   * [Check Cycle](graphs/check_cycle.py)
   * [Connected Components](graphs/connected_components.py)
   * [Deep Clone Graph](graphs/deep_clone_graph.py)
@@ -542,6 +542,7 @@
   * [Dimensionality Reduction](machine_learning/dimensionality_reduction.py)
   * Forecasting
     * [Run](machine_learning/forecasting/run.py)
+  * [Frequent Pattern Growth](machine_learning/frequent_pattern_growth.py)
   * [Gradient Descent](machine_learning/gradient_descent.py)
   * [K Means Clust](machine_learning/k_means_clust.py)
   * [K Nearest Neighbours](machine_learning/k_nearest_neighbours.py)
@@ -550,13 +551,7 @@
   * Local Weighted Learning
     * [Local Weighted Learning](machine_learning/local_weighted_learning/local_weighted_learning.py)
   * [Logistic Regression](machine_learning/logistic_regression.py)
-  * Loss Functions
-    * [Binary Cross Entropy](machine_learning/loss_functions/binary_cross_entropy.py)
-    * [Categorical Cross Entropy](machine_learning/loss_functions/categorical_cross_entropy.py)
-    * [Hinge Loss](machine_learning/loss_functions/hinge_loss.py)
-    * [Huber Loss](machine_learning/loss_functions/huber_loss.py)
-    * [Mean Squared Error](machine_learning/loss_functions/mean_squared_error.py)
-    * [Mean Squared Logarithmic Error](machine_learning/loss_functions/mean_squared_logarithmic_error.py)
+  * [Loss Functions](machine_learning/loss_functions.py)
   * [Mfcc](machine_learning/mfcc.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
   * [Polynomial Regression](machine_learning/polynomial_regression.py)
@@ -577,25 +572,18 @@
   * [Arc Length](maths/arc_length.py)
   * [Area](maths/area.py)
   * [Area Under Curve](maths/area_under_curve.py)
-  * [Armstrong Numbers](maths/armstrong_numbers.py)
-  * [Automorphic Number](maths/automorphic_number.py)
   * [Average Absolute Deviation](maths/average_absolute_deviation.py)
   * [Average Mean](maths/average_mean.py)
   * [Average Median](maths/average_median.py)
   * [Average Mode](maths/average_mode.py)
   * [Bailey Borwein Plouffe](maths/bailey_borwein_plouffe.py)
   * [Base Neg2 Conversion](maths/base_neg2_conversion.py)
   * [Basic Maths](maths/basic_maths.py)
-  * [Bell Numbers](maths/bell_numbers.py)
-  * [Binary Exp Mod](maths/binary_exp_mod.py)
   * [Binary Exponentiation](maths/binary_exponentiation.py)
-  * [Binary Exponentiation 2](maths/binary_exponentiation_2.py)
   * [Binary Multiplication](maths/binary_multiplication.py)
   * [Binomial Coefficient](maths/binomial_coefficient.py)
   * [Binomial Distribution](maths/binomial_distribution.py)
   * [Bisection](maths/bisection.py)
-  * [Carmichael Number](maths/carmichael_number.py)
-  * [Catalan Number](maths/catalan_number.py)
   * [Ceil](maths/ceil.py)
   * [Chebyshev Distance](maths/chebyshev_distance.py)
   * [Check Polygon](maths/check_polygon.py)
@@ -628,10 +616,7 @@
   * [Gcd Of N Numbers](maths/gcd_of_n_numbers.py)
   * [Germain Primes](maths/germain_primes.py)
   * [Greatest Common Divisor](maths/greatest_common_divisor.py)
-  * [Hamming Numbers](maths/hamming_numbers.py)
   * [Hardy Ramanujanalgo](maths/hardy_ramanujanalgo.py)
-  * [Harshad Numbers](maths/harshad_numbers.py)
-  * [Hexagonal Number](maths/hexagonal_number.py)
   * [Integration By Simpson Approx](maths/integration_by_simpson_approx.py)
   * [Interquartile Range](maths/interquartile_range.py)
   * [Is Int Palindrome](maths/is_int_palindrome.py)
@@ -641,7 +626,6 @@
   * [Joint Probability Distribution](maths/joint_probability_distribution.py)
   * [Juggler Sequence](maths/juggler_sequence.py)
   * [Karatsuba](maths/karatsuba.py)
-  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
   * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
   * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
   * [Least Common Multiple](maths/least_common_multiple.py)
@@ -673,7 +657,6 @@
   * [Pi Monte Carlo Estimation](maths/pi_monte_carlo_estimation.py)
   * [Points Are Collinear 3D](maths/points_are_collinear_3d.py)
   * [Pollard Rho](maths/pollard_rho.py)
-  * [Polygonal Numbers](maths/polygonal_numbers.py)
   * [Polynomial Evaluation](maths/polynomial_evaluation.py)
   * Polynomials
     * [Single Indeterminate Operations](maths/polynomials/single_indeterminate_operations.py)
@@ -684,8 +667,6 @@
   * [Prime Sieve Eratosthenes](maths/prime_sieve_eratosthenes.py)
   * [Primelib](maths/primelib.py)
   * [Print Multiplication Table](maths/print_multiplication_table.py)
-  * [Pronic Number](maths/pronic_number.py)
-  * [Proth Number](maths/proth_number.py)
   * [Pythagoras](maths/pythagoras.py)
   * [Qr Decomposition](maths/qr_decomposition.py)
   * [Quadratic Equations Complex Numbers](maths/quadratic_equations_complex_numbers.py)
@@ -712,6 +693,22 @@
   * [Sock Merchant](maths/sock_merchant.py)
   * [Softmax](maths/softmax.py)
   * [Solovay Strassen Primality Test](maths/solovay_strassen_primality_test.py)
+  * Special Numbers
+    * [Armstrong Numbers](maths/special_numbers/armstrong_numbers.py)
+    * [Automorphic Number](maths/special_numbers/automorphic_number.py)
+    * [Bell Numbers](maths/special_numbers/bell_numbers.py)
+    * [Carmichael Number](maths/special_numbers/carmichael_number.py)
+    * [Catalan Number](maths/special_numbers/catalan_number.py)
+    * [Hamming Numbers](maths/special_numbers/hamming_numbers.py)
+    * [Harshad Numbers](maths/special_numbers/harshad_numbers.py)
+    * [Hexagonal Number](maths/special_numbers/hexagonal_number.py)
+    * [Krishnamurthy Number](maths/special_numbers/krishnamurthy_number.py)
+    * [Perfect Number](maths/special_numbers/perfect_number.py)
+    * [Polygonal Numbers](maths/special_numbers/polygonal_numbers.py)
+    * [Pronic Number](maths/special_numbers/pronic_number.py)
+    * [Proth Number](maths/special_numbers/proth_number.py)
+    * [Ugly Numbers](maths/special_numbers/ugly_numbers.py)
+    * [Weird Number](maths/special_numbers/weird_number.py)
   * [Square Root](maths/square_root.py)
   * [Sum Of Arithmetic Series](maths/sum_of_arithmetic_series.py)
   * [Sum Of Digits](maths/sum_of_digits.py)
@@ -727,9 +724,7 @@
   * [Twin Prime](maths/twin_prime.py)
   * [Two Pointer](maths/two_pointer.py)
   * [Two Sum](maths/two_sum.py)
-  * [Ugly Numbers](maths/ugly_numbers.py)
   * [Volume](maths/volume.py)
-  * [Weird Number](maths/weird_number.py)
   * [Zellers Congruence](maths/zellers_congruence.py)
 
 ## Matrix
@@ -774,13 +769,12 @@
     * [Swish](neural_network/activation_functions/swish.py)
   * [Back Propagation Neural Network](neural_network/back_propagation_neural_network.py)
   * [Convolution Neural Network](neural_network/convolution_neural_network.py)
-  * [Perceptron](neural_network/perceptron.py)
   * [Simple Neural Network](neural_network/simple_neural_network.py)
 
 ## Other
   * [Activity Selection](other/activity_selection.py)
   * [Alternative List Arrange](other/alternative_list_arrange.py)
-  * [Davisb Putnamb Logemannb Loveland](other/davisb_putnamb_logemannb_loveland.py)
+  * [Davis Putnam Logemann Loveland](other/davis_putnam_logemann_loveland.py)
   * [Dijkstra Bankers Algorithm](other/dijkstra_bankers_algorithm.py)
   * [Doomsday](other/doomsday.py)
   * [Fischer Yates Shuffle](other/fischer_yates_shuffle.py)
@@ -810,8 +804,10 @@
   * [Archimedes Principle Of Buoyant Force](physics/archimedes_principle_of_buoyant_force.py)
   * [Basic Orbital Capture](physics/basic_orbital_capture.py)
   * [Casimir Effect](physics/casimir_effect.py)
+  * [Center Of Mass](physics/center_of_mass.py)
   * [Centripetal Force](physics/centripetal_force.py)
   * [Coulombs Law](physics/coulombs_law.py)
+  * [Doppler Frequency](physics/doppler_frequency.py)
   * [Grahams Law](physics/grahams_law.py)
   * [Horizontal Projectile Motion](physics/horizontal_projectile_motion.py)
   * [Hubble Parameter](physics/hubble_parameter.py)

backtracking/n_queens.py

@@ -17,50 +17,49 @@ def is_safe(board: list[list[int]], row: int, column: int) -> bool:
     This function returns a boolean value True if it is safe to place a queen there
     considering the current state of the board.
 
-    Parameters :
-    board(2D matrix) : board
-    row ,column : coordinates of the cell on a board
+    Parameters:
+    board (2D matrix): The chessboard
+    row, column: Coordinates of the cell on the board
 
-    Returns :
+    Returns:
     Boolean Value
 
     """
-    for i in range(len(board)):
-        if board[row][i] == 1:
-            return False
-    for i in range(len(board)):
-        if board[i][column] == 1:
-            return False
-    for i, j in zip(range(row, -1, -1), range(column, -1, -1)):
-        if board[i][j] == 1:
-            return False
-    for i, j in zip(range(row, -1, -1), range(column, len(board))):
-        if board[i][j] == 1:
-            return False
-    return True
+
+    n = len(board)  # Size of the board
+
+    # Check if there is any queen in the same row, column,
+    # left upper diagonal, and right upper diagonal
+    return (
+        all(board[i][j] != 1 for i, j in zip(range(row, -1, -1), range(column, n)))
+        and all(
+            board[i][j] != 1 for i, j in zip(range(row, -1, -1), range(column, -1, -1))
+        )
+        and all(board[i][j] != 1 for i, j in zip(range(row, n), range(column, n)))
+        and all(board[i][j] != 1 for i, j in zip(range(row, n), range(column, -1, -1)))
+    )
 
 
 def solve(board: list[list[int]], row: int) -> bool:
     """
-    It creates a state space tree and calls the safe function until it receives a
-    False Boolean and terminates that branch and backtracks to the next
+    This function creates a state space tree and calls the safe function until it
+    receives a False Boolean and terminates that branch and backtracks to the next
     possible solution branch.
     """
     if row >= len(board):
         """
-        If the row number exceeds N we have board with a successful combination
+        If the row number exceeds N, we have a board with a successful combination
         and that combination is appended to the solution list and the board is printed.
-
         """
         solution.append(board)
         printboard(board)
         print()
         return True
     for i in range(len(board)):
         """
-        For every row it iterates through each column to check if it is feasible to
+        For every row, it iterates through each column to check if it is feasible to
         place a queen there.
-        If all the combinations for that particular branch are successful the board is
+        If all the combinations for that particular branch are successful, the board is
         reinitialized for the next possible combination.
         """
         if is_safe(board, row, i):
@@ -77,14 +76,14 @@ def printboard(board: list[list[int]]) -> None:
     for i in range(len(board)):
         for j in range(len(board)):
             if board[i][j] == 1:
-                print("Q", end=" ")
+                print("Q", end=" ")  # Queen is present
             else:
-                print(".", end=" ")
+                print(".", end=" ")  # Empty cell
         print()
 
 
-# n=int(input("The no. of queens"))
+# Number of queens (e.g., n=8 for an 8x8 board)
 n = 8
 board = [[0 for i in range(n)] for j in range(n)]
 solve(board, 0)
-print("The total no. of solutions are :", len(solution))
+print("The total number of solutions are:", len(solution))

boolean_algebra/nor_gate.py

@@ -1,15 +1,18 @@
 """
-A NOR Gate is a logic gate in boolean algebra which results to false(0)
-if any of the input is 1, and True(1) if  both the inputs are 0.
+A NOR Gate is a logic gate in boolean algebra which results in false(0) if any of the
+inputs is 1, and True(1) if all inputs are 0.
 Following is the truth table of a NOR Gate:
-   | Input 1 | Input 2 |  Output |
-   |      0      |     0      |      1      |
-   |      0      |     1      |      0      |
-   |      1      |     0      |      0      |
-   |      1      |     1      |      0      |
+    Truth Table of NOR Gate:
+    | Input 1  | Input 2  |  Output  |
+    |    0     |    0     |    1     |
+    |    0     |    1     |    0     |
+    |    1     |    0     |    0     |
+    |    1     |    1     |    0     |
 
-Following is the code implementation of the NOR Gate
+    Code provided by Akshaj Vishwanathan
+https://www.geeksforgeeks.org/logic-gates-in-python
 """
+from collections.abc import Callable
 
 
 def nor_gate(input_1: int, input_2: int) -> int:
@@ -30,19 +33,35 @@ def nor_gate(input_1: int, input_2: int) -> int:
     return int(input_1 == input_2 == 0)
 
 
-def main() -> None:
-    print("Truth Table of NOR Gate:")
-    print("|   Input 1   |  Input 2  | Output |")
-    print(f"|      0      |    0      |  {nor_gate(0, 0)}     |")
-    print(f"|      0      |    1      |  {nor_gate(0, 1)}     |")
-    print(f"|      1      |    0      |  {nor_gate(1, 0)}     |")
-    print(f"|      1      |    1      |  {nor_gate(1, 1)}     |")
+def truth_table(func: Callable) -> str:
+    """
+    >>> print(truth_table(nor_gate))
+    Truth Table of NOR Gate:
+    | Input 1  | Input 2  |  Output  |
+    |    0     |    0     |    1     |
+    |    0     |    1     |    0     |
+    |    1     |    0     |    0     |
+    |    1     |    1     |    0     |
+    """
+
+    def make_table_row(items: list | tuple) -> str:
+        """
+        >>> make_table_row(("One", "Two", "Three"))
+        '|   One    |   Two    |  Three   |'
+        """
+        return f"| {' | '.join(f'{item:^8}' for item in items)} |"
+
+    return "\n".join(
+        (
+            "Truth Table of NOR Gate:",
+            make_table_row(("Input 1", "Input 2", "Output")),
+            *[make_table_row((i, j, func(i, j))) for i in (0, 1) for j in (0, 1)],
+        )
+    )
 
 
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod()
-    main()
-"""Code provided by Akshaj Vishwanathan"""
-"""Reference: https://www.geeksforgeeks.org/logic-gates-in-python/"""
+    print(truth_table(nor_gate))

ciphers/onepad_cipher.py

@@ -4,7 +4,27 @@
 class Onepad:
     @staticmethod
     def encrypt(text: str) -> tuple[list[int], list[int]]:
-        """Function to encrypt text using pseudo-random numbers"""
+        """
+        Function to encrypt text using pseudo-random numbers
+        >>> Onepad().encrypt("")
+        ([], [])
+        >>> Onepad().encrypt([])
+        ([], [])
+        >>> random.seed(1)
+        >>> Onepad().encrypt(" ")
+        ([6969], [69])
+        >>> random.seed(1)
+        >>> Onepad().encrypt("Hello")
+        ([9729, 114756, 4653, 31309, 10492], [69, 292, 33, 131, 61])
+        >>> Onepad().encrypt(1)
+        Traceback (most recent call last):
+        ...
+        TypeError: 'int' object is not iterable
+        >>> Onepad().encrypt(1.1)
+        Traceback (most recent call last):
+        ...
+        TypeError: 'float' object is not iterable
+        """
         plain = [ord(i) for i in text]
         key = []
         cipher = []
@@ -17,7 +37,20 @@ def encrypt(text: str) -> tuple[list[int], list[int]]:
 
     @staticmethod
     def decrypt(cipher: list[int], key: list[int]) -> str:
-        """Function to decrypt text using pseudo-random numbers."""
+        """
+        Function to decrypt text using pseudo-random numbers.
+        >>> Onepad().decrypt([], [])
+        ''
+        >>> Onepad().decrypt([35], [])
+        ''
+        >>> Onepad().decrypt([], [35])
+        Traceback (most recent call last):
+        ...
+        IndexError: list index out of range
+        >>> random.seed(1)
+        >>> Onepad().decrypt([9729, 114756, 4653, 31309, 10492], [69, 292, 33, 131, 61])
+        'Hello'
+        """
         plain = []
         for i in range(len(key)):
             p = int((cipher[i] - (key[i]) ** 2) / key[i])