Merge branch 'TheAlgorithms:master' into master

Author: dhruvtrigotra

.pre-commit-config.yaml

@@ -1,6 +1,6 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.4.0
+    rev: v4.5.0
     hooks:
       - id: check-executables-have-shebangs
       - id: check-toml
@@ -51,7 +51,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.5.1
+    rev: v1.6.0
     hooks:
       - id: mypy
         args:

DIRECTORY.md

@@ -54,13 +54,12 @@
   * [Largest Pow Of Two Le Num](bit_manipulation/largest_pow_of_two_le_num.py)
   * [Missing Number](bit_manipulation/missing_number.py)
   * [Numbers Different Signs](bit_manipulation/numbers_different_signs.py)
+  * [Power Of 4](bit_manipulation/power_of_4.py)
   * [Reverse Bits](bit_manipulation/reverse_bits.py)
   * [Single Bit Manipulation Operations](bit_manipulation/single_bit_manipulation_operations.py)
 
 ## Blockchain
-  * [Chinese Remainder Theorem](blockchain/chinese_remainder_theorem.py)
   * [Diophantine Equation](blockchain/diophantine_equation.py)
-  * [Modular Division](blockchain/modular_division.py)
 
 ## Boolean Algebra
   * [And Gate](boolean_algebra/and_gate.py)
@@ -101,11 +100,13 @@
   * [Diffie Hellman](ciphers/diffie_hellman.py)
   * [Elgamal Key Generator](ciphers/elgamal_key_generator.py)
   * [Enigma Machine2](ciphers/enigma_machine2.py)
+  * [Fractionated Morse Cipher](ciphers/fractionated_morse_cipher.py)
   * [Hill Cipher](ciphers/hill_cipher.py)
   * [Mixed Keyword Cypher](ciphers/mixed_keyword_cypher.py)
   * [Mono Alphabetic Ciphers](ciphers/mono_alphabetic_ciphers.py)
   * [Morse Code](ciphers/morse_code.py)
   * [Onepad Cipher](ciphers/onepad_cipher.py)
+  * [Permutation Cipher](ciphers/permutation_cipher.py)
   * [Playfair Cipher](ciphers/playfair_cipher.py)
   * [Polybius](ciphers/polybius.py)
   * [Porta Cipher](ciphers/porta_cipher.py)
@@ -172,6 +173,7 @@
 
 ## Data Structures
   * Arrays
+    * [Equilibrium Index In Array](data_structures/arrays/equilibrium_index_in_array.py)
     * [Median Two Array](data_structures/arrays/median_two_array.py)
     * [Permutations](data_structures/arrays/permutations.py)
     * [Prefix Sum](data_structures/arrays/prefix_sum.py)
@@ -352,6 +354,7 @@
   * [Smith Waterman](dynamic_programming/smith_waterman.py)
   * [Subset Generation](dynamic_programming/subset_generation.py)
   * [Sum Of Subset](dynamic_programming/sum_of_subset.py)
+  * [Trapped Water](dynamic_programming/trapped_water.py)
   * [Tribonacci](dynamic_programming/tribonacci.py)
   * [Viterbi](dynamic_programming/viterbi.py)
   * [Word Break](dynamic_programming/word_break.py)
@@ -360,6 +363,7 @@
   * [Apparent Power](electronics/apparent_power.py)
   * [Builtin Voltage](electronics/builtin_voltage.py)
   * [Carrier Concentration](electronics/carrier_concentration.py)
+  * [Charging Capacitor](electronics/charging_capacitor.py)
   * [Circular Convolution](electronics/circular_convolution.py)
   * [Coulombs Law](electronics/coulombs_law.py)
   * [Electric Conductivity](electronics/electric_conductivity.py)
@@ -466,6 +470,8 @@
     * [Test Min Spanning Tree Prim](graphs/tests/test_min_spanning_tree_prim.py)
 
 ## Greedy Methods
+  * [Best Time To Buy And Sell Stock](greedy_methods/best_time_to_buy_and_sell_stock.py)
+  * [Fractional Cover Problem](greedy_methods/fractional_cover_problem.py)
   * [Fractional Knapsack](greedy_methods/fractional_knapsack.py)
   * [Fractional Knapsack 2](greedy_methods/fractional_knapsack_2.py)
   * [Gas Station](greedy_methods/gas_station.py)
@@ -524,6 +530,11 @@
   * 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)
+    * [Huber Loss](machine_learning/loss_functions/huber_loss.py)
+    * [Mean Squared Error](machine_learning/loss_functions/mean_squared_error.py)
   * [Mfcc](machine_learning/mfcc.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
   * [Polynomial Regression](machine_learning/polynomial_regression.py)
@@ -556,15 +567,17 @@
   * [Bell Numbers](maths/bell_numbers.py)
   * [Binary Exp Mod](maths/binary_exp_mod.py)
   * [Binary Exponentiation](maths/binary_exponentiation.py)
-  * [Binary Exponentiation 3](maths/binary_exponentiation_3.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)
+  * [Chinese Remainder Theorem](maths/chinese_remainder_theorem.py)
   * [Chudnovsky Algorithm](maths/chudnovsky_algorithm.py)
   * [Collatz Sequence](maths/collatz_sequence.py)
   * [Combinations](maths/combinations.py)
@@ -588,10 +601,10 @@
   * [Find Min](maths/find_min.py)
   * [Floor](maths/floor.py)
   * [Gamma](maths/gamma.py)
-  * [Gamma Recursive](maths/gamma_recursive.py)
   * [Gaussian](maths/gaussian.py)
   * [Gaussian Error Linear Unit](maths/gaussian_error_linear_unit.py)
   * [Gcd Of N Numbers](maths/gcd_of_n_numbers.py)
+  * [Germain Primes](maths/germain_primes.py)
   * [Greatest Common Divisor](maths/greatest_common_divisor.py)
   * [Greedy Coin Change](maths/greedy_coin_change.py)
   * [Hamming Numbers](maths/hamming_numbers.py)
@@ -619,7 +632,9 @@
   * [Matrix Exponentiation](maths/matrix_exponentiation.py)
   * [Max Sum Sliding Window](maths/max_sum_sliding_window.py)
   * [Median Of Two Arrays](maths/median_of_two_arrays.py)
+  * [Minkowski Distance](maths/minkowski_distance.py)
   * [Mobius Function](maths/mobius_function.py)
+  * [Modular Division](maths/modular_division.py)
   * [Modular Exponential](maths/modular_exponential.py)
   * [Monte Carlo](maths/monte_carlo.py)
   * [Monte Carlo Dice](maths/monte_carlo_dice.py)
@@ -721,11 +736,16 @@
 ## Neural Network
   * [2 Hidden Layers Neural Network](neural_network/2_hidden_layers_neural_network.py)
   * Activation Functions
+    * [Binary Step](neural_network/activation_functions/binary_step.py)
     * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
     * [Leaky Rectified Linear Unit](neural_network/activation_functions/leaky_rectified_linear_unit.py)
+    * [Mish](neural_network/activation_functions/mish.py)
     * [Rectified Linear Unit](neural_network/activation_functions/rectified_linear_unit.py)
     * [Scaled Exponential Linear Unit](neural_network/activation_functions/scaled_exponential_linear_unit.py)
     * [Sigmoid Linear Unit](neural_network/activation_functions/sigmoid_linear_unit.py)
+    * [Soboleva Modified Hyperbolic Tangent](neural_network/activation_functions/soboleva_modified_hyperbolic_tangent.py)
+    * [Softplus](neural_network/activation_functions/softplus.py)
+    * [Squareplus](neural_network/activation_functions/squareplus.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)
@@ -748,6 +768,7 @@
   * [Linear Congruential Generator](other/linear_congruential_generator.py)
   * [Lru Cache](other/lru_cache.py)
   * [Magicdiamondpattern](other/magicdiamondpattern.py)
+  * [Majority Vote Algorithm](other/majority_vote_algorithm.py)
   * [Maximum Subsequence](other/maximum_subsequence.py)
   * [Nested Brackets](other/nested_brackets.py)
   * [Number Container System](other/number_container_system.py)
@@ -778,6 +799,7 @@
   * [Newtons Second Law Of Motion](physics/newtons_second_law_of_motion.py)
   * [Photoelectric Effect](physics/photoelectric_effect.py)
   * [Potential Energy](physics/potential_energy.py)
+  * [Reynolds Number](physics/reynolds_number.py)
   * [Rms Speed Of Molecule](physics/rms_speed_of_molecule.py)
   * [Shear Stress](physics/shear_stress.py)
   * [Speed Of Sound](physics/speed_of_sound.py)
@@ -1100,6 +1122,7 @@
   * [Interpolation Search](searches/interpolation_search.py)
   * [Jump Search](searches/jump_search.py)
   * [Linear Search](searches/linear_search.py)
+  * [Median Of Medians](searches/median_of_medians.py)
   * [Quick Select](searches/quick_select.py)
   * [Sentinel Linear Search](searches/sentinel_linear_search.py)
   * [Simple Binary Search](searches/simple_binary_search.py)
@@ -1196,11 +1219,11 @@
   * [Rabin Karp](strings/rabin_karp.py)
   * [Remove Duplicate](strings/remove_duplicate.py)
   * [Reverse Letters](strings/reverse_letters.py)
-  * [Reverse Long Words](strings/reverse_long_words.py)
   * [Reverse Words](strings/reverse_words.py)
   * [Snake Case To Camel Pascal Case](strings/snake_case_to_camel_pascal_case.py)
   * [Split](strings/split.py)
   * [String Switch Case](strings/string_switch_case.py)
+  * [Strip](strings/strip.py)
   * [Text Justification](strings/text_justification.py)
   * [Top K Frequent Words](strings/top_k_frequent_words.py)
   * [Upper](strings/upper.py)

arithmetic_analysis/gaussian_elimination.py

@@ -34,7 +34,7 @@ def retroactive_resolution(
     x: NDArray[float64] = np.zeros((rows, 1), dtype=float)
     for row in reversed(range(rows)):
         total = np.dot(coefficients[row, row + 1 :], x[row + 1 :])
-        x[row, 0] = (vector[row] - total) / coefficients[row, row]
+        x[row, 0] = (vector[row][0] - total[0]) / coefficients[row, row]
 
     return x
 

backtracking/power_sum.py

@@ -6,8 +6,6 @@
 The only solution is 2^2+3^2. Constraints: 1<=X<=1000, 2<=N<=10.
 """
 
-from math import pow
-
 
 def backtrack(
     needed_sum: int,
@@ -19,25 +17,25 @@ def backtrack(
     """
     >>> backtrack(13, 2, 1, 0, 0)
     (0, 1)
-    >>> backtrack(100, 2, 1, 0, 0)
-    (0, 3)
-    >>> backtrack(100, 3, 1, 0, 0)
+    >>> backtrack(10, 2, 1, 0, 0)
+    (0, 1)
+    >>> backtrack(10, 3, 1, 0, 0)
+    (0, 0)
+    >>> backtrack(20, 2, 1, 0, 0)
     (0, 1)
-    >>> backtrack(800, 2, 1, 0, 0)
-    (0, 561)
-    >>> backtrack(1000, 10, 1, 0, 0)
+    >>> backtrack(15, 10, 1, 0, 0)
     (0, 0)
-    >>> backtrack(400, 2, 1, 0, 0)
-    (0, 55)
-    >>> backtrack(50, 1, 1, 0, 0)
-    (0, 3658)
+    >>> backtrack(16, 2, 1, 0, 0)
+    (0, 1)
+    >>> backtrack(20, 1, 1, 0, 0)
+    (0, 64)
     """
     if current_sum == needed_sum:
         # If the sum of the powers is equal to needed_sum, then we have a solution.
         solutions_count += 1
         return current_sum, solutions_count
 
-    i_to_n = int(pow(current_number, power))
+    i_to_n = current_number**power
     if current_sum + i_to_n <= needed_sum:
         # If the sum of the powers is less than needed_sum, then continue adding powers.
         current_sum += i_to_n
@@ -57,17 +55,17 @@ def solve(needed_sum: int, power: int) -> int:
     """
     >>> solve(13, 2)
     1
-    >>> solve(100, 2)
-    3
-    >>> solve(100, 3)
+    >>> solve(10, 2)
     1
-    >>> solve(800, 2)
-    561
-    >>> solve(1000, 10)
+    >>> solve(10, 3)
     0
-    >>> solve(400, 2)
-    55
-    >>> solve(50, 1)
+    >>> solve(20, 2)
+    1
+    >>> solve(15, 10)
+    0
+    >>> solve(16, 2)
+    1
+    >>> solve(20, 1)
     Traceback (most recent call last):
         ...
     ValueError: Invalid input

backtracking/word_search.py

@@ -98,13 +98,7 @@ def word_exists(board: list[list[str]], word: str) -> bool:
     False
     >>> word_exists([["A"]], "A")
     True
-    >>> word_exists([["A","A","A","A","A","A"],
-    ...              ["A","A","A","A","A","A"],
-    ...              ["A","A","A","A","A","A"],
-    ...              ["A","A","A","A","A","A"],
-    ...              ["A","A","A","A","A","B"],
-    ...              ["A","A","A","A","B","A"]],
-    ...             "AAAAAAAAAAAAABB")
+    >>> word_exists([["B", "A", "A"], ["A", "A", "A"], ["A", "B", "A"]], "ABB")
     False
     >>> word_exists([["A"]], 123)
     Traceback (most recent call last):

bit_manipulation/missing_number.py

@@ -11,11 +11,18 @@ def find_missing_number(nums: list[int]) -> int:
     Example:
         >>> find_missing_number([0, 1, 3, 4])
         2
+        >>> find_missing_number([1, 3, 4, 5, 6])
+        2
+        >>> find_missing_number([6, 5, 4, 2, 1])
+        3
+        >>> find_missing_number([6, 1, 5, 3, 4])
+        2
     """
-    n = len(nums)
-    missing_number = n
+    low = min(nums)
+    high = max(nums)
+    missing_number = high
 
-    for i in range(n):
-        missing_number ^= i ^ nums[i]
+    for i in range(low, high):
+        missing_number ^= i ^ nums[i - low]
 
     return missing_number

bit_manipulation/power_of_4.py

@@ -0,0 +1,67 @@
+"""
+
+Task:
+Given a positive int number. Return True if this number is power of 4
+or False otherwise.
+
+Implementation notes: Use bit manipulation.
+For example if the number is the power of 2 it's bits representation:
+n     = 0..100..00
+n - 1 = 0..011..11
+
+n & (n - 1) - no intersections = 0
+If the number is a power of 4 then it should be a power of 2
+and the set bit should be at an odd position.
+"""
+
+
+def power_of_4(number: int) -> bool:
+    """
+    Return True if this number is power of 4 or False otherwise.
+
+    >>> power_of_4(0)
+    Traceback (most recent call last):
+        ...
+    ValueError: number must be positive
+    >>> power_of_4(1)
+    True
+    >>> power_of_4(2)
+    False
+    >>> power_of_4(4)
+    True
+    >>> power_of_4(6)
+    False
+    >>> power_of_4(8)
+    False
+    >>> power_of_4(17)
+    False
+    >>> power_of_4(64)
+    True
+    >>> power_of_4(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: number must be positive
+    >>> power_of_4(1.2)
+    Traceback (most recent call last):
+        ...
+    TypeError: number must be an integer
+
+    """
+    if not isinstance(number, int):
+        raise TypeError("number must be an integer")
+    if number <= 0:
+        raise ValueError("number must be positive")
+    if number & (number - 1) == 0:
+        c = 0
+        while number:
+            c += 1
+            number >>= 1
+        return c % 2 == 1
+    else:
+        return False
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()