Merge remote-tracking branch 'origin/master' into viterbi

Author: carlos3dx

.pre-commit-config.yaml

@@ -26,7 +26,7 @@ repos:
           - --profile=black
 
   - repo: https://github.com/asottile/pyupgrade
-    rev: v3.0.0
+    rev: v3.1.0
     hooks:
       - id: pyupgrade
         args:
@@ -55,14 +55,14 @@ repos:
         additional_dependencies: [types-requests]
 
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.2.1
+    rev: v2.2.2
     hooks:
       - id: codespell
         args:
           - --ignore-words-list=ans,crate,damon,fo,followings,hist,iff,mater,secant,som,sur,tim,zar
-          - --skip="./.*,./strings/dictionary.txt,./strings/words.txt,./project_euler/problem_022/p022_names.txt"
         exclude: |
           (?x)^(
+              ciphers/prehistoric_men.txt |
               strings/dictionary.txt |
               strings/words.txt |
               project_euler/problem_022/p022_names.txt

DIRECTORY.md

@@ -23,9 +23,11 @@
   * [All Permutations](backtracking/all_permutations.py)
   * [All Subsequences](backtracking/all_subsequences.py)
   * [Coloring](backtracking/coloring.py)
+  * [Combination Sum](backtracking/combination_sum.py)
   * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py)
   * [Knight Tour](backtracking/knight_tour.py)
   * [Minimax](backtracking/minimax.py)
+  * [Minmax](backtracking/minmax.py)
   * [N Queens](backtracking/n_queens.py)
   * [N Queens Math](backtracking/n_queens_math.py)
   * [Rat In Maze](backtracking/rat_in_maze.py)
@@ -156,6 +158,7 @@
     * [Binary Tree Mirror](data_structures/binary_tree/binary_tree_mirror.py)
     * [Binary Tree Node Sum](data_structures/binary_tree/binary_tree_node_sum.py)
     * [Binary Tree Traversals](data_structures/binary_tree/binary_tree_traversals.py)
+    * [Diff Views Of Binary Tree](data_structures/binary_tree/diff_views_of_binary_tree.py)
     * [Fenwick Tree](data_structures/binary_tree/fenwick_tree.py)
     * [Inorder Tree Traversal 2022](data_structures/binary_tree/inorder_tree_traversal_2022.py)
     * [Lazy Segment Tree](data_structures/binary_tree/lazy_segment_tree.py)
@@ -512,6 +515,7 @@
   * [Gamma](maths/gamma.py)
   * [Gamma Recursive](maths/gamma_recursive.py)
   * [Gaussian](maths/gaussian.py)
+  * [Gaussian Error Linear Unit](maths/gaussian_error_linear_unit.py)
   * [Greatest Common Divisor](maths/greatest_common_divisor.py)
   * [Greedy Coin Change](maths/greedy_coin_change.py)
   * [Hamming Numbers](maths/hamming_numbers.py)
@@ -600,6 +604,7 @@
   * [Inverse Of Matrix](matrix/inverse_of_matrix.py)
   * [Matrix Class](matrix/matrix_class.py)
   * [Matrix Operation](matrix/matrix_operation.py)
+  * [Max Area Of Island](matrix/max_area_of_island.py)
   * [Nth Fibonacci Using Matrix Exponentiation](matrix/nth_fibonacci_using_matrix_exponentiation.py)
   * [Rotate Matrix](matrix/rotate_matrix.py)
   * [Searching In Sorted Matrix](matrix/searching_in_sorted_matrix.py)
@@ -642,6 +647,7 @@
   * [Tower Of Hanoi](other/tower_of_hanoi.py)
 
 ## Physics
+  * [Casimir Effect](physics/casimir_effect.py)
   * [Horizontal Projectile Motion](physics/horizontal_projectile_motion.py)
   * [Lorentz Transformation Four Vector](physics/lorentz_transformation_four_vector.py)
   * [N Body Simulation](physics/n_body_simulation.py)
@@ -928,6 +934,7 @@
   * [Deutsch Jozsa](quantum/deutsch_jozsa.py)
   * [Half Adder](quantum/half_adder.py)
   * [Not Gate](quantum/not_gate.py)
+  * [Q Full Adder](quantum/q_full_adder.py)
   * [Quantum Entanglement](quantum/quantum_entanglement.py)
   * [Ripple Adder Classic](quantum/ripple_adder_classic.py)
   * [Single Qubit Measure](quantum/single_qubit_measure.py)

backtracking/combination_sum.py

@@ -0,0 +1,66 @@
+"""
+In the Combination Sum problem, we are given a list consisting of distinct integers.
+We need to find all the combinations whose sum equals to target given.
+We can use an element more than one.
+
+Time complexity(Average Case): O(n!)
+
+Constraints:
+1 <= candidates.length <= 30
+2 <= candidates[i] <= 40
+All elements of candidates are distinct.
+1 <= target <= 40
+"""
+
+
+def backtrack(
+    candidates: list, path: list, answer: list, target: int, previous_index: int
+) -> None:
+    """
+    A recursive function that searches for possible combinations. Backtracks in case
+    of a bigger current combination value than the target value.
+
+    Parameters
+    ----------
+    previous_index: Last index from the previous search
+    target: The value we need to obtain by summing our integers in the path list.
+    answer: A list of possible combinations
+    path: Current combination
+    candidates: A list of integers we can use.
+    """
+    if target == 0:
+        answer.append(path.copy())
+    else:
+        for index in range(previous_index, len(candidates)):
+            if target >= candidates[index]:
+                path.append(candidates[index])
+                backtrack(candidates, path, answer, target - candidates[index], index)
+                path.pop(len(path) - 1)
+
+
+def combination_sum(candidates: list, target: int) -> list:
+    """
+    >>> combination_sum([2, 3, 5], 8)
+    [[2, 2, 2, 2], [2, 3, 3], [3, 5]]
+    >>> combination_sum([2, 3, 6, 7], 7)
+    [[2, 2, 3], [7]]
+    >>> combination_sum([-8, 2.3, 0], 1)
+    Traceback (most recent call last):
+        ...
+    RecursionError: maximum recursion depth exceeded in comparison
+    """
+    path = []  # type: list[int]
+    answer = []  # type: list[int]
+    backtrack(candidates, path, answer, target, 0)
+    return answer
+
+
+def main() -> None:
+    print(combination_sum([-8, 2.3, 0], 1))
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    main()

backtracking/minmax.py

@@ -0,0 +1,69 @@
+"""
+Minimax helps to achieve maximum score in a game by checking all possible moves.
+
+"""
+from __future__ import annotations
+
+import math
+
+
+def minimax(
+    depth: int, node_index: int, is_max: bool, scores: list[int], height: float
+) -> int:
+    """
+    depth is current depth in game tree.
+    node_index is index of current node in scores[].
+    scores[] contains the leaves of game tree.
+    height is maximum height of game tree.
+
+    >>> scores = [90, 23, 6, 33, 21, 65, 123, 34423]
+    >>> height = math.log(len(scores), 2)
+    >>> minimax(0, 0, True, scores, height)
+    65
+    >>> minimax(-1, 0, True, scores, height)
+    Traceback (most recent call last):
+        ...
+    ValueError: Depth cannot be less than 0
+    >>> minimax(0, 0, True, [], 2)
+    Traceback (most recent call last):
+        ...
+    ValueError: Scores cannot be empty
+    >>> scores = [3, 5, 2, 9, 12, 5, 23, 23]
+    >>> height = math.log(len(scores), 2)
+    >>> minimax(0, 0, True, scores, height)
+    12
+    """
+
+    if depth < 0:
+        raise ValueError("Depth cannot be less than 0")
+
+    if not scores:
+        raise ValueError("Scores cannot be empty")
+
+    if depth == height:
+        return scores[node_index]
+
+    return (
+        max(
+            minimax(depth + 1, node_index * 2, False, scores, height),
+            minimax(depth + 1, node_index * 2 + 1, False, scores, height),
+        )
+        if is_max
+        else min(
+            minimax(depth + 1, node_index * 2, True, scores, height),
+            minimax(depth + 1, node_index * 2 + 1, True, scores, height),
+        )
+    )
+
+
+def main() -> None:
+    scores = [90, 23, 6, 33, 21, 65, 123, 34423]
+    height = math.log(len(scores), 2)
+    print(f"Optimal value : {minimax(0, 0, True, scores, height)}")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    main()

boolean_algebra/norgate.py

@@ -1,13 +1,15 @@
-""" 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.
-   Following is the truth table of an NOR Gate:
+"""
+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.
+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      |
+
+Following is the code implementation of the NOR Gate
 """
-"""Following is the code implementation of the NOR Gate"""
 
 
 def nor_gate(input_1: int, input_2: int) -> int:
@@ -30,11 +32,11 @@ def nor_gate(input_1: int, input_2: int) -> int:
 
 def main() -> None:
     print("Truth Table of NOR Gate:")
-    print("| Input 1 |", " Input 2 |", " Output |")
-    print("|      0      |", "     0      |     ", nor_gate(0, 0), "     |")
-    print("|      0      |", "     1      |     ", nor_gate(0, 1), "     |")
-    print("|      1      |", "     0      |     ", nor_gate(1, 0), "     |")
-    print("|      1      |", "     1      |     ", nor_gate(1, 1), "     |")
+    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)}     |")
 
 
 if __name__ == "__main__":

computer_vision/horn_schunck.py

@@ -12,7 +12,7 @@
 from typing import SupportsIndex
 
 import numpy as np
-from scipy.ndimage.filters import convolve
+from scipy.ndimage import convolve
 
 
 def warp(