Merge branch 'TheAlgorithms:master' into master

Author: haxkd

Diff for: CONTRIBUTING.md

@@ -25,8 +25,12 @@ We appreciate any contribution, from fixing a grammar mistake in a comment to im
 
 Your contribution will be tested by our [automated testing on GitHub Actions](https://github.com/TheAlgorithms/Python/actions) to save time and mental energy.  After you have submitted your pull request, you should see the GitHub Actions tests start to run at the bottom of your submission page.  If those tests fail, then click on the ___details___ button try to read through the GitHub Actions output to understand the failure.  If you do not understand, please leave a comment on your submission page and a community member will try to help.
 
+#### Issues
+
 If you are interested in resolving an [open issue](https://github.com/TheAlgorithms/Python/issues), simply make a pull request with your proposed fix. __We do not assign issues in this repo__ so please do not ask for permission to work on an issue.
 
+__Do not__ create an issue to contribute an algorithm. Please submit a pull request instead.
+
 Please help us keep our issue list small by adding `Fixes #{$ISSUE_NUMBER}` to the description of pull requests that resolve open issues.
 For example, if your pull request fixes issue #10, then please add the following to its description:
 ```

Diff for: DIRECTORY.md

@@ -170,6 +170,7 @@
 
 ## Data Structures
   * Arrays
+    * [Median Two Array](data_structures/arrays/median_two_array.py)
     * [Permutations](data_structures/arrays/permutations.py)
     * [Prefix Sum](data_structures/arrays/prefix_sum.py)
     * [Product Sum](data_structures/arrays/product_sum.py)
@@ -185,6 +186,7 @@
     * [Diff Views Of Binary Tree](data_structures/binary_tree/diff_views_of_binary_tree.py)
     * [Distribute Coins](data_structures/binary_tree/distribute_coins.py)
     * [Fenwick Tree](data_structures/binary_tree/fenwick_tree.py)
+    * [Flatten Binarytree To Linkedlist](data_structures/binary_tree/flatten_binarytree_to_linkedlist.py)
     * [Inorder Tree Traversal 2022](data_structures/binary_tree/inorder_tree_traversal_2022.py)
     * [Is Bst](data_structures/binary_tree/is_bst.py)
     * [Lazy Segment Tree](data_structures/binary_tree/lazy_segment_tree.py)
@@ -324,6 +326,7 @@
   * [Longest Common Substring](dynamic_programming/longest_common_substring.py)
   * [Longest Increasing Subsequence](dynamic_programming/longest_increasing_subsequence.py)
   * [Longest Increasing Subsequence O(Nlogn)](dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
+  * [Longest Palindromic Subsequence](dynamic_programming/longest_palindromic_subsequence.py)
   * [Longest Sub Array](dynamic_programming/longest_sub_array.py)
   * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
   * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
@@ -466,6 +469,7 @@
   * [Djb2](hashes/djb2.py)
   * [Elf](hashes/elf.py)
   * [Enigma Machine](hashes/enigma_machine.py)
+  * [Fletcher16](hashes/fletcher16.py)
   * [Hamming Code](hashes/hamming_code.py)
   * [Luhn](hashes/luhn.py)
   * [Md5](hashes/md5.py)
@@ -539,6 +543,7 @@
   * [Average Mode](maths/average_mode.py)
   * [Bailey Borwein Plouffe](maths/bailey_borwein_plouffe.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 3](maths/binary_exponentiation_3.py)
@@ -690,6 +695,7 @@
   * [Matrix Class](matrix/matrix_class.py)
   * [Matrix Operation](matrix/matrix_operation.py)
   * [Max Area Of Island](matrix/max_area_of_island.py)
+  * [Median Matrix](matrix/median_matrix.py)
   * [Nth Fibonacci Using Matrix Exponentiation](matrix/nth_fibonacci_using_matrix_exponentiation.py)
   * [Pascal Triangle](matrix/pascal_triangle.py)
   * [Rotate Matrix](matrix/rotate_matrix.py)
@@ -708,8 +714,8 @@
   * Activation Functions
     * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
     * [Leaky Rectified Linear Unit](neural_network/activation_functions/leaky_rectified_linear_unit.py)
-    * [Scaled Exponential Linear Unit](neural_network/activation_functions/scaled_exponential_linear_unit.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)
   * [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)
@@ -756,9 +762,11 @@
   * [Kinetic Energy](physics/kinetic_energy.py)
   * [Lorentz Transformation Four Vector](physics/lorentz_transformation_four_vector.py)
   * [Malus Law](physics/malus_law.py)
+  * [Mirror Formulae](physics/mirror_formulae.py)
   * [N Body Simulation](physics/n_body_simulation.py)
   * [Newtons Law Of Gravitation](physics/newtons_law_of_gravitation.py)
   * [Newtons Second Law Of Motion](physics/newtons_second_law_of_motion.py)
+  * [Photoelectric Effect](physics/photoelectric_effect.py)
   * [Potential Energy](physics/potential_energy.py)
   * [Rms Speed Of Molecule](physics/rms_speed_of_molecule.py)
   * [Shear Stress](physics/shear_stress.py)

Diff for: bit_manipulation/largest_pow_of_two_le_num.py

@@ -0,0 +1,60 @@
+"""
+Author  : Naman Sharma
+Date    : October 2, 2023
+
+Task:
+To Find the largest power of 2 less than or equal to a given number.
+
+Implementation notes: Use bit manipulation.
+We start from 1 & left shift the set bit to check if (res<<1)<=number.
+Each left bit shift represents a pow of 2.
+
+For example:
+number: 15
+res:    1   0b1
+        2   0b10
+        4   0b100
+        8   0b1000
+        16  0b10000 (Exit)
+"""
+
+
+def largest_pow_of_two_le_num(number: int) -> int:
+    """
+    Return the largest power of two less than or equal to a number.
+
+    >>> largest_pow_of_two_le_num(0)
+    0
+    >>> largest_pow_of_two_le_num(1)
+    1
+    >>> largest_pow_of_two_le_num(-1)
+    0
+    >>> largest_pow_of_two_le_num(3)
+    2
+    >>> largest_pow_of_two_le_num(15)
+    8
+    >>> largest_pow_of_two_le_num(99)
+    64
+    >>> largest_pow_of_two_le_num(178)
+    128
+    >>> largest_pow_of_two_le_num(999999)
+    524288
+    >>> largest_pow_of_two_le_num(99.9)
+    Traceback (most recent call last):
+        ...
+    TypeError: Input value must be a 'int' type
+    """
+    if isinstance(number, float):
+        raise TypeError("Input value must be a 'int' type")
+    if number <= 0:
+        return 0
+    res = 1
+    while (res << 1) <= number:
+        res <<= 1
+    return res
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: hashes/fletcher16.py

@@ -0,0 +1,36 @@
+"""
+The Fletcher checksum is an algorithm for computing a position-dependent
+checksum devised by John G. Fletcher (1934–2012) at Lawrence Livermore Labs
+in the late 1970s.[1] The objective of the Fletcher checksum was to
+provide error-detection properties approaching those of a cyclic
+redundancy check but with the lower computational effort associated
+with summation techniques.
+
+Source: https://en.wikipedia.org/wiki/Fletcher%27s_checksum
+"""
+
+
+def fletcher16(text: str) -> int:
+    """
+    Loop through every character in the data and add to two sums.
+
+    >>> fletcher16('hello world')
+    6752
+    >>> fletcher16('onethousandfourhundredthirtyfour')
+    28347
+    >>> fletcher16('The quick brown fox jumps over the lazy dog.')
+    5655
+    """
+    data = bytes(text, "ascii")
+    sum1 = 0
+    sum2 = 0
+    for character in data:
+        sum1 = (sum1 + character) % 255
+        sum2 = (sum1 + sum2) % 255
+    return (sum2 << 8) | sum1
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: maths/fermat_little_theorem.py

@@ -5,7 +5,7 @@
 # Wikipedia reference: https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
 
 
-def binary_exponentiation(a, n, mod):
+def binary_exponentiation(a: int, n: float, mod: int) -> int:
     if n == 0:
         return 1
 

Diff for: physics/mirror_formulae.py

@@ -0,0 +1,127 @@
+"""
+This module contains the functions to calculate the focal length, object distance
+and image distance of a mirror.
+
+The mirror formula is an equation that relates the object distance (u),
+image distance (v), and focal length (f) of a spherical mirror.
+It is commonly used in optics to determine the position and characteristics
+of an image formed by a mirror. It is expressed using the formulae :
+
+-------------------
+| 1/f = 1/v + 1/u |
+-------------------
+
+Where,
+f = Focal length of the spherical mirror (metre)
+v = Image distance from the mirror (metre)
+u = Object distance from the mirror (metre)
+
+
+The signs of the distances are taken with respect to the sign convention.
+The sign convention is as follows:
+    1) Object is always placed to the left of mirror
+    2) Distances measured in the direction of the incident ray are positive
+    and the distances measured in the direction opposite to that of the incident
+    rays are negative.
+    3) All distances are measured from the pole of the mirror.
+
+
+There are a few assumptions that are made while using the mirror formulae.
+They are as follows:
+    1) Thin Mirror: The mirror is assumed to be thin, meaning its thickness is
+    negligible compared to its radius of curvature. This assumption allows
+    us to treat the mirror as a two-dimensional surface.
+    2) Spherical Mirror: The mirror is assumed to have a spherical shape. While this
+    assumption may not hold exactly for all mirrors, it is a reasonable approximation
+    for most practical purposes.
+    3) Small Angles: The angles involved in the derivation are assumed to be small.
+    This assumption allows us to use the small-angle approximation, where the tangent
+    of a small angle is approximately equal to the angle itself. It simplifies the
+    calculations and makes the derivation more manageable.
+    4) Paraxial Rays: The mirror formula is derived using paraxial rays, which are
+    rays that are close to the principal axis and make small angles with it. This
+    assumption ensures that the rays are close enough to the principal axis, making the
+    calculations more accurate.
+    5) Reflection and Refraction Laws: The derivation assumes that the laws of
+    reflection and refraction hold.
+    These laws state that the angle of incidence is equal to the angle of reflection
+    for reflection, and the incident and refracted rays lie in the same plane and
+    obey Snell's law for refraction.
+
+(Description and Assumptions adapted from
+https://www.collegesearch.in/articles/mirror-formula-derivation)
+
+(Sign Convention adapted from
+https://www.toppr.com/ask/content/concept/sign-convention-for-mirrors-210189/)
+
+
+"""
+
+
+def focal_length(distance_of_object: float, distance_of_image: float) -> float:
+    """
+    >>> from math import isclose
+    >>> isclose(focal_length(10, 20), 6.66666666666666)
+    True
+    >>> from math import isclose
+    >>> isclose(focal_length(9.5, 6.7), 3.929012346)
+    True
+    >>> focal_length(0, 20)  # doctest: +NORMALIZE_WHITESPACE
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid inputs. Enter non zero values with respect
+    to the sign convention.
+    """
+
+    if distance_of_object == 0 or distance_of_image == 0:
+        raise ValueError(
+            "Invalid inputs. Enter non zero values with respect to the sign convention."
+        )
+    focal_length = 1 / ((1 / distance_of_object) + (1 / distance_of_image))
+    return focal_length
+
+
+def object_distance(focal_length: float, distance_of_image: float) -> float:
+    """
+    >>> from math import isclose
+    >>> isclose(object_distance(30, 20), -60.0)
+    True
+    >>> from math import isclose
+    >>> isclose(object_distance(10.5, 11.7), 102.375)
+    True
+    >>> object_distance(90, 0)  # doctest: +NORMALIZE_WHITESPACE
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid inputs. Enter non zero values with respect
+    to the sign convention.
+    """
+
+    if distance_of_image == 0 or focal_length == 0:
+        raise ValueError(
+            "Invalid inputs. Enter non zero values with respect to the sign convention."
+        )
+    object_distance = 1 / ((1 / focal_length) - (1 / distance_of_image))
+    return object_distance
+
+
+def image_distance(focal_length: float, distance_of_object: float) -> float:
+    """
+    >>> from math import isclose
+    >>> isclose(image_distance(10, 40), 13.33333333)
+    True
+    >>> from math import isclose
+    >>> isclose(image_distance(1.5, 6.7), 1.932692308)
+    True
+    >>> image_distance(0, 0)  # doctest: +NORMALIZE_WHITESPACE
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid inputs. Enter non zero values with respect
+    to the sign convention.
+    """
+
+    if distance_of_object == 0 or focal_length == 0:
+        raise ValueError(
+            "Invalid inputs. Enter non zero values with respect to the sign convention."
+        )
+    image_distance = 1 / ((1 / focal_length) - (1 / distance_of_object))
+    return image_distance

Diff for: strings/pig_latin.py

@@ -0,0 +1,44 @@
+def pig_latin(word: str) -> str:
+    """Compute the piglatin of a given string.
+
+    https://en.wikipedia.org/wiki/Pig_Latin
+
+    Usage examples:
+    >>> pig_latin("pig")
+    'igpay'
+    >>> pig_latin("latin")
+    'atinlay'
+    >>> pig_latin("banana")
+    'ananabay'
+    >>> pig_latin("friends")
+    'iendsfray'
+    >>> pig_latin("smile")
+    'ilesmay'
+    >>> pig_latin("string")
+    'ingstray'
+    >>> pig_latin("eat")
+    'eatway'
+    >>> pig_latin("omelet")
+    'omeletway'
+    >>> pig_latin("are")
+    'areway'
+    >>> pig_latin(" ")
+    ''
+    >>> pig_latin(None)
+    ''
+    """
+    if not (word or "").strip():
+        return ""
+    word = word.lower()
+    if word[0] in "aeiou":
+        return f"{word}way"
+    for i, char in enumerate(word):  # noqa: B007
+        if char in "aeiou":
+            break
+    return f"{word[i:]}{word[:i]}ay"
+
+
+if __name__ == "__main__":
+    print(f"{pig_latin('friends') = }")
+    word = input("Enter a word: ")
+    print(f"{pig_latin(word) = }")