Merge branch 'update_power_sum.py' of https://github.com/Muhammadummerr/Python into update_power_sum.py

Author: Muhammadummerr

.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
@@ -26,7 +26,7 @@ repos:
       - id: black
 
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.5
+    rev: v2.2.6
     hooks:
       - id: codespell
         additional_dependencies:
@@ -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/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/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()

blockchain/diophantine_equation.py

@@ -1,11 +1,13 @@
 from __future__ import annotations
 
+from maths.greatest_common_divisor import greatest_common_divisor
+
 
 def diophantine(a: int, b: int, c: int) -> tuple[float, float]:
     """
     Diophantine Equation : Given integers a,b,c ( at least one of a and b != 0), the
     diophantine equation a*x + b*y = c has a solution (where x and y are integers)
-    iff gcd(a,b) divides c.
+    iff greatest_common_divisor(a,b) divides c.
 
     GCD ( Greatest Common Divisor ) or HCF ( Highest Common Factor )
 
@@ -22,7 +24,7 @@ def diophantine(a: int, b: int, c: int) -> tuple[float, float]:
 
     assert (
         c % greatest_common_divisor(a, b) == 0
-    )  # greatest_common_divisor(a,b) function implemented below
+    )  # greatest_common_divisor(a,b) is in maths directory
     (d, x, y) = extended_gcd(a, b)  # extended_gcd(a,b) function implemented below
     r = c / d
     return (r * x, r * y)
@@ -69,32 +71,6 @@ def diophantine_all_soln(a: int, b: int, c: int, n: int = 2) -> None:
         print(x, y)
 
 
-def greatest_common_divisor(a: int, b: int) -> int:
-    """
-    Euclid's Lemma :  d divides a and b, if and only if d divides a-b and b
-
-    Euclid's Algorithm
-
-    >>> greatest_common_divisor(7,5)
-    1
-
-    Note : In number theory, two integers a and b are said to be relatively prime,
-           mutually prime, or co-prime if the only positive integer (factor) that
-           divides both of them is 1  i.e., gcd(a,b) = 1.
-
-    >>> greatest_common_divisor(121, 11)
-    11
-
-    """
-    if a < b:
-        a, b = b, a
-
-    while a % b != 0:
-        a, b = b, a % b
-
-    return b
-
-
 def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     """
     Extended Euclid's Algorithm : If d divides a and b and d = a*x + b*y for integers
@@ -107,7 +83,8 @@ def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
     (1, -2, 3)
 
     """
-    assert a >= 0 and b >= 0
+    assert a >= 0
+    assert b >= 0
 
     if b == 0:
         d, x, y = a, 1, 0
@@ -116,7 +93,8 @@ def extended_gcd(a: int, b: int) -> tuple[int, int, int]:
         x = q
         y = p - q * (a // b)
 
-    assert a % d == 0 and b % d == 0
+    assert a % d == 0
+    assert b % d == 0
     assert d == a * x + b * y
 
     return (d, x, y)