Merge remote-tracking branch 'origin/master'

Author: Suyashd999

Diff for: DIRECTORY.md

@@ -34,6 +34,7 @@
   * [Bitwise Addition Recursive](bit_manipulation/bitwise_addition_recursive.py)
   * [Count 1S Brian Kernighan Method](bit_manipulation/count_1s_brian_kernighan_method.py)
   * [Count Number Of One Bits](bit_manipulation/count_number_of_one_bits.py)
+  * [Excess 3 Code](bit_manipulation/excess_3_code.py)
   * [Gray Code Sequence](bit_manipulation/gray_code_sequence.py)
   * [Highest Set Bit](bit_manipulation/highest_set_bit.py)
   * [Index Of Rightmost Set Bit](bit_manipulation/index_of_rightmost_set_bit.py)
@@ -170,7 +171,10 @@
   * Arrays
     * [Equilibrium Index In Array](data_structures/arrays/equilibrium_index_in_array.py)
     * [Find Triplets With 0 Sum](data_structures/arrays/find_triplets_with_0_sum.py)
+    * [Index 2D Array In 1D](data_structures/arrays/index_2d_array_in_1d.py)
+    * [Kth Largest Element](data_structures/arrays/kth_largest_element.py)
     * [Median Two Array](data_structures/arrays/median_two_array.py)
+    * [Monotonic Array](data_structures/arrays/monotonic_array.py)
     * [Pairs With Given Sum](data_structures/arrays/pairs_with_given_sum.py)
     * [Permutations](data_structures/arrays/permutations.py)
     * [Prefix Sum](data_structures/arrays/prefix_sum.py)
@@ -368,6 +372,7 @@
 ## Electronics
   * [Apparent Power](electronics/apparent_power.py)
   * [Builtin Voltage](electronics/builtin_voltage.py)
+  * [Capacitor Equivalence](electronics/capacitor_equivalence.py)
   * [Carrier Concentration](electronics/carrier_concentration.py)
   * [Charging Capacitor](electronics/charging_capacitor.py)
   * [Charging Inductor](electronics/charging_inductor.py)
@@ -531,12 +536,14 @@
 ## Machine Learning
   * [Apriori Algorithm](machine_learning/apriori_algorithm.py)
   * [Astar](machine_learning/astar.py)
+  * [Automatic Differentiation](machine_learning/automatic_differentiation.py)
   * [Data Transformations](machine_learning/data_transformations.py)
   * [Decision Tree](machine_learning/decision_tree.py)
   * [Dimensionality Reduction](machine_learning/dimensionality_reduction.py)
   * Forecasting
     * [Run](machine_learning/forecasting/run.py)
   * [Frequent Pattern Growth](machine_learning/frequent_pattern_growth.py)
+  * [Gradient Boosting Classifier](machine_learning/gradient_boosting_classifier.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)
@@ -598,6 +605,7 @@
   * [Extended Euclidean Algorithm](maths/extended_euclidean_algorithm.py)
   * [Factorial](maths/factorial.py)
   * [Factors](maths/factors.py)
+  * [Fast Inverse Sqrt](maths/fast_inverse_sqrt.py)
   * [Fermat Little Theorem](maths/fermat_little_theorem.py)
   * [Fibonacci](maths/fibonacci.py)
   * [Find Max](maths/find_max.py)
@@ -648,6 +656,7 @@
     * [Numerical Integration](maths/numerical_analysis/numerical_integration.py)
     * [Runge Kutta](maths/numerical_analysis/runge_kutta.py)
     * [Runge Kutta Fehlberg 45](maths/numerical_analysis/runge_kutta_fehlberg_45.py)
+    * [Runge Kutta Gills](maths/numerical_analysis/runge_kutta_gills.py)
     * [Secant Method](maths/numerical_analysis/secant_method.py)
     * [Simpson Rule](maths/numerical_analysis/simpson_rule.py)
     * [Square Root](maths/numerical_analysis/square_root.py)
@@ -814,6 +823,7 @@
   * [Ideal Gas Law](physics/ideal_gas_law.py)
   * [In Static Equilibrium](physics/in_static_equilibrium.py)
   * [Kinetic Energy](physics/kinetic_energy.py)
+  * [Lens Formulae](physics/lens_formulae.py)
   * [Lorentz Transformation Four Vector](physics/lorentz_transformation_four_vector.py)
   * [Malus Law](physics/malus_law.py)
   * [Mass Energy Equivalence](physics/mass_energy_equivalence.py)

Diff for: backtracking/generate_parentheses.py

@@ -0,0 +1,77 @@
+"""
+author: Aayush Soni
+Given n pairs of parentheses, write a function to generate all
+combinations of well-formed parentheses.
+Input: n = 2
+Output: ["(())","()()"]
+Leetcode link: https://leetcode.com/problems/generate-parentheses/description/
+"""
+
+
+def backtrack(
+    partial: str, open_count: int, close_count: int, n: int, result: list[str]
+) -> None:
+    """
+    Generate valid combinations of balanced parentheses using recursion.
+
+    :param partial: A string representing the current combination.
+    :param open_count: An integer representing the count of open parentheses.
+    :param close_count: An integer representing the count of close parentheses.
+    :param n: An integer representing the total number of pairs.
+    :param result: A list to store valid combinations.
+    :return: None
+
+    This function uses recursion to explore all possible combinations,
+    ensuring that at each step, the parentheses remain balanced.
+
+    Example:
+    >>> result = []
+    >>> backtrack("", 0, 0, 2, result)
+    >>> result
+    ['(())', '()()']
+    """
+    if len(partial) == 2 * n:
+        # When the combination is complete, add it to the result.
+        result.append(partial)
+        return
+
+    if open_count < n:
+        # If we can add an open parenthesis, do so, and recurse.
+        backtrack(partial + "(", open_count + 1, close_count, n, result)
+
+    if close_count < open_count:
+        # If we can add a close parenthesis (it won't make the combination invalid),
+        # do so, and recurse.
+        backtrack(partial + ")", open_count, close_count + 1, n, result)
+
+
+def generate_parenthesis(n: int) -> list[str]:
+    """
+    Generate valid combinations of balanced parentheses for a given n.
+
+    :param n: An integer representing the number of pairs of parentheses.
+    :return: A list of strings with valid combinations.
+
+    This function uses a recursive approach to generate the combinations.
+
+    Time Complexity: O(2^(2n)) - In the worst case, we have 2^(2n) combinations.
+    Space Complexity: O(n) - where 'n' is the number of pairs.
+
+    Example 1:
+    >>> generate_parenthesis(3)
+    ['((()))', '(()())', '(())()', '()(())', '()()()']
+
+    Example 2:
+    >>> generate_parenthesis(1)
+    ['()']
+    """
+
+    result: list[str] = []
+    backtrack("", 0, 0, n, result)
+    return result
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: bit_manipulation/find_previous_power_of_two.py

@@ -0,0 +1,30 @@
+def find_previous_power_of_two(number: int) -> int:
+    """
+    Find the largest power of two that is less than or equal to a given integer.
+    https://stackoverflow.com/questions/1322510
+
+    >>> [find_previous_power_of_two(i) for i in range(18)]
+    [0, 1, 2, 2, 4, 4, 4, 4, 8, 8, 8, 8, 8, 8, 8, 8, 16, 16]
+    >>> find_previous_power_of_two(-5)
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
+    >>> find_previous_power_of_two(10.5)
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
+    """
+    if not isinstance(number, int) or number < 0:
+        raise ValueError("Input must be a non-negative integer")
+    if number == 0:
+        return 0
+    power = 1
+    while power <= number:
+        power <<= 1  # Equivalent to multiplying by 2
+    return power >> 1 if number > 1 else 1
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: bit_manipulation/missing_number.py

@@ -11,6 +11,12 @@ def find_missing_number(nums: list[int]) -> int:
     Example:
         >>> find_missing_number([0, 1, 3, 4])
         2
+        >>> find_missing_number([4, 3, 1, 0])
+        2
+        >>> find_missing_number([-4, -3, -1, 0])
+        -2
+        >>> find_missing_number([-2, 2, 1, 3, 0])
+        -1
         >>> find_missing_number([1, 3, 4, 5, 6])
         2
         >>> find_missing_number([6, 5, 4, 2, 1])
@@ -26,3 +32,9 @@ def find_missing_number(nums: list[int]) -> int:
         missing_number ^= i ^ nums[i - low]
 
     return missing_number
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: boolean_algebra/karnaugh_map_simplification.py

@@ -0,0 +1,55 @@
+"""
+https://en.wikipedia.org/wiki/Karnaugh_map
+https://www.allaboutcircuits.com/technical-articles/karnaugh-map-boolean-algebraic-simplification-technique
+"""
+
+
+def simplify_kmap(kmap: list[list[int]]) -> str:
+    """
+    Simplify the Karnaugh map.
+    >>> simplify_kmap(kmap=[[0, 1], [1, 1]])
+    "A'B + AB' + AB"
+    >>> simplify_kmap(kmap=[[0, 0], [0, 0]])
+    ''
+    >>> simplify_kmap(kmap=[[0, 1], [1, -1]])
+    "A'B + AB' + AB"
+    >>> simplify_kmap(kmap=[[0, 1], [1, 2]])
+    "A'B + AB' + AB"
+    >>> simplify_kmap(kmap=[[0, 1], [1, 1.1]])
+    "A'B + AB' + AB"
+    >>> simplify_kmap(kmap=[[0, 1], [1, 'a']])
+    "A'B + AB' + AB"
+    """
+    simplified_f = []
+    for a, row in enumerate(kmap):
+        for b, item in enumerate(row):
+            if item:
+                term = ("A" if a else "A'") + ("B" if b else "B'")
+                simplified_f.append(term)
+    return " + ".join(simplified_f)
+
+
+def main() -> None:
+    """
+    Main function to create and simplify a K-Map.
+
+    >>> main()
+    [0, 1]
+    [1, 1]
+    Simplified Expression:
+    A'B + AB' + AB
+    """
+    kmap = [[0, 1], [1, 1]]
+
+    # Manually generate the product of [0, 1] and [0, 1]
+
+    for row in kmap:
+        print(row)
+
+    print("Simplified Expression:")
+    print(simplify_kmap(kmap))
+
+
+if __name__ == "__main__":
+    main()
+    print(f"{simplify_kmap(kmap=[[0, 1], [1, 1]]) = }")

Diff for: boolean_algebra/multiplexer.py

@@ -0,0 +1,42 @@
+def mux(input0: int, input1: int, select: int) -> int:
+    """
+    Implement a 2-to-1 Multiplexer.
+
+    :param input0: The first input value (0 or 1).
+    :param input1: The second input value (0 or 1).
+    :param select: The select signal (0 or 1) to choose between input0 and input1.
+    :return: The output based on the select signal.  input1 if select else input0.
+
+    https://www.electrically4u.com/solved-problems-on-multiplexer
+    https://en.wikipedia.org/wiki/Multiplexer
+
+    >>> mux(0, 1, 0)
+    0
+    >>> mux(0, 1, 1)
+    1
+    >>> mux(1, 0, 0)
+    1
+    >>> mux(1, 0, 1)
+    0
+    >>> mux(2, 1, 0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Inputs and select signal must be 0 or 1
+    >>> mux(0, -1, 0)
+    Traceback (most recent call last):
+        ...
+    ValueError: Inputs and select signal must be 0 or 1
+    >>> mux(0, 1, 1.1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Inputs and select signal must be 0 or 1
+    """
+    if all(i in (0, 1) for i in (input0, input1, select)):
+        return input1 if select else input0
+    raise ValueError("Inputs and select signal must be 0 or 1")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

Diff for: ciphers/running_key_cipher.py

@@ -0,0 +1,75 @@
+"""
+https://en.wikipedia.org/wiki/Running_key_cipher
+"""
+
+
+def running_key_encrypt(key: str, plaintext: str) -> str:
+    """
+    Encrypts the plaintext using the Running Key Cipher.
+
+    :param key: The running key (long piece of text).
+    :param plaintext: The plaintext to be encrypted.
+    :return: The ciphertext.
+    """
+    plaintext = plaintext.replace(" ", "").upper()
+    key = key.replace(" ", "").upper()
+    key_length = len(key)
+    ciphertext = []
+    ord_a = ord("A")
+
+    for i, char in enumerate(plaintext):
+        p = ord(char) - ord_a
+        k = ord(key[i % key_length]) - ord_a
+        c = (p + k) % 26
+        ciphertext.append(chr(c + ord_a))
+
+    return "".join(ciphertext)
+
+
+def running_key_decrypt(key: str, ciphertext: str) -> str:
+    """
+    Decrypts the ciphertext using the Running Key Cipher.
+
+    :param key: The running key (long piece of text).
+    :param ciphertext: The ciphertext to be decrypted.
+    :return: The plaintext.
+    """
+    ciphertext = ciphertext.replace(" ", "").upper()
+    key = key.replace(" ", "").upper()
+    key_length = len(key)
+    plaintext = []
+    ord_a = ord("A")
+
+    for i, char in enumerate(ciphertext):
+        c = ord(char) - ord_a
+        k = ord(key[i % key_length]) - ord_a
+        p = (c - k) % 26
+        plaintext.append(chr(p + ord_a))
+
+    return "".join(plaintext)
+
+
+def test_running_key_encrypt() -> None:
+    """
+    >>> key = "How does the duck know that? said Victor"
+    >>> ciphertext = running_key_encrypt(key, "DEFEND THIS")
+    >>> running_key_decrypt(key, ciphertext) == "DEFENDTHIS"
+    True
+    """
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    test_running_key_encrypt()
+
+    plaintext = input("Enter the plaintext: ").upper()
+    print(f"\n{plaintext = }")
+
+    key = "How does the duck know that? said Victor"
+    encrypted_text = running_key_encrypt(key, plaintext)
+    print(f"{encrypted_text = }")
+
+    decrypted_text = running_key_decrypt(key, encrypted_text)
+    print(f"{decrypted_text = }")