Merge branch 'TheAlgorithms:master' into time_period_simple_pendulum

Author: pluto-tofu

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -6,14 +6,14 @@ body:
     attributes:
       value: >
         Before requesting please search [existing issues](https://github.com/TheAlgorithms/Python/labels/enhancement).
+        Do not create issues to implement new algorithms as these will be closed.
         Usage questions such as "How do I...?"  belong on the
         [Discord](https://discord.gg/c7MnfGFGa6) and will be closed.
 
   - type: textarea
     attributes:
       label: "Feature description"
       description: >
-        This could be new algorithms, data structures or improving any existing
-        implementations.
+        This could include new topics or improving any existing implementations.
     validations:
       required: true

.github/pull_request_template.md

@@ -4,6 +4,7 @@
 
 * [ ] Add an algorithm?
 * [ ] Fix a bug or typo in an existing algorithm?
+* [ ] Add or change doctests? -- Note: Please avoid changing both code and tests in a single pull request.
 * [ ] Documentation change?
 
 ### Checklist:

.pre-commit-config.yaml

@@ -16,12 +16,12 @@ repos:
     -   id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.292
+    rev: v0.1.1
     hooks:
       - id: ruff
 
   - repo: https://github.com/psf/black
-    rev: 23.9.1
+    rev: 23.10.0
     hooks:
       - id: black
 
@@ -46,12 +46,12 @@ repos:
         pass_filenames: false
 
   - repo: https://github.com/abravalheri/validate-pyproject
-    rev: v0.14
+    rev: v0.15
     hooks:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.5.1
+    rev: v1.6.1
     hooks:
       - id: mypy
         args:

DIRECTORY.md

@@ -1,15 +1,40 @@
 """
         In this problem, we want to determine all possible combinations of k
         numbers out of 1 ... n. We use backtracking to solve this problem.
-        Time complexity: O(C(n,k)) which is O(n choose k) = O((n!/(k! * (n - k)!)))
+
+        Time complexity: O(C(n,k)) which is O(n choose k) = O((n!/(k! * (n - k)!))),
 """
 from __future__ import annotations
 
+from itertools import combinations
+
+
+def combination_lists(n: int, k: int) -> list[list[int]]:
+    """
+    >>> combination_lists(n=4, k=2)
+    [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
+    """
+    return [list(x) for x in combinations(range(1, n + 1), k)]
+
 
 def generate_all_combinations(n: int, k: int) -> list[list[int]]:
     """
     >>> generate_all_combinations(n=4, k=2)
     [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]
+    >>> generate_all_combinations(n=0, k=0)
+    [[]]
+    >>> generate_all_combinations(n=10, k=-1)
+    Traceback (most recent call last):
+        ...
+    RecursionError: maximum recursion depth exceeded
+    >>> generate_all_combinations(n=-1, k=10)
+    []
+    >>> generate_all_combinations(n=5, k=4)
+    [[1, 2, 3, 4], [1, 2, 3, 5], [1, 2, 4, 5], [1, 3, 4, 5], [2, 3, 4, 5]]
+    >>> from itertools import combinations
+    >>> all(generate_all_combinations(n, k) == combination_lists(n, k)
+    ...     for n in range(1, 6) for k in range(1, 6))
+    True
     """
 
     result: list[list[int]] = []
@@ -34,13 +59,17 @@ def create_all_state(
         current_list.pop()
 
 
-def print_all_state(total_list: list[list[int]]) -> None:
-    for i in total_list:
-        print(*i)
+if __name__ == "__main__":
+    from doctest import testmod
 
+    testmod()
+    print(generate_all_combinations(n=4, k=2))
+    tests = ((n, k) for n in range(1, 5) for k in range(1, 5))
+    for n, k in tests:
+        print(n, k, generate_all_combinations(n, k) == combination_lists(n, k))
 
-if __name__ == "__main__":
-    n = 4
-    k = 2
-    total_list = generate_all_combinations(n, k)
-    print_all_state(total_list)
+    print("Benchmark:")
+    from timeit import timeit
+
+    for func in ("combination_lists", "generate_all_combinations"):
+        print(f"{func:>25}(): {timeit(f'{func}(n=4, k = 2)', globals=globals())}")

arithmetic_analysis/README.md

@@ -16,6 +16,22 @@ def minimax(
     depth: int, node_index: int, is_max: bool, scores: list[int], height: float
 ) -> int:
     """
+    This function implements the minimax algorithm, which helps achieve the optimal
+    score for a player in a two-player game by checking all possible moves.
+    If the player is the maximizer, then the score is maximized.
+    If the player is the minimizer, then the score is minimized.
+
+    Parameters:
+    - depth: Current depth in the game tree.
+    - node_index: Index of the current node in the scores list.
+    - is_max: A boolean indicating whether the current move
+              is for the maximizer (True) or minimizer (False).
+    - scores: A list containing the scores of the leaves of the game tree.
+    - height: The maximum height of the game tree.
+
+    Returns:
+    - An integer representing the optimal score for the current player.
+
     >>> import math
     >>> scores = [90, 23, 6, 33, 21, 65, 123, 34423]
     >>> height = math.log(len(scores), 2)
@@ -37,28 +53,36 @@ def minimax(
 
     if depth < 0:
         raise ValueError("Depth cannot be less than 0")
-
     if len(scores) == 0:
         raise ValueError("Scores cannot be empty")
 
+    # Base case: If the current depth equals the height of the tree,
+    # return the score of the current node.
     if depth == height:
         return scores[node_index]
 
+    # If it's the maximizer's turn, choose the maximum score
+    # between the two possible moves.
     if is_max:
         return max(
             minimax(depth + 1, node_index * 2, False, scores, height),
             minimax(depth + 1, node_index * 2 + 1, False, scores, height),
         )
 
+    # If it's the minimizer's turn, choose the minimum score
+    # between the two possible moves.
     return min(
         minimax(depth + 1, node_index * 2, True, scores, height),
         minimax(depth + 1, node_index * 2 + 1, True, scores, height),
     )
 
 
 def main() -> None:
+    # Sample scores and height calculation
     scores = [90, 23, 6, 33, 21, 65, 123, 34423]
     height = math.log(len(scores), 2)
+
+    # Calculate and print the optimal value using the minimax algorithm
     print("Optimal value : ", end="")
     print(minimax(0, 0, True, scores, height))