From d610df1cb1ca986027d8f6d7730ff5cf221bb967 Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:19:28 +0300
Subject: [PATCH 1/8] Fix sphinx/build_docs warnings for dynamic_programming

---
 dynamic_programming/all_construct.py          |  7 +-
 dynamic_programming/combination_sum_iv.py     | 23 ++---
 dynamic_programming/fizz_buzz.py              | 11 ++-
 dynamic_programming/knapsack.py               | 39 ++++----
 .../longest_common_substring.py               | 14 ++-
 .../longest_increasing_subsequence.py         | 13 ++-
 .../matrix_chain_multiplication.py            | 92 ++++++++++---------
 dynamic_programming/max_product_subarray.py   |  3 +-
 .../minimum_squares_to_represent_a_number.py  |  1 +
 dynamic_programming/regex_match.py            | 18 ++--
 dynamic_programming/rod_cutting.py            | 83 +++++++++--------
 dynamic_programming/subset_generation.py      | 63 +++++++------
 dynamic_programming/viterbi.py                | 32 +------
 13 files changed, 203 insertions(+), 196 deletions(-)

diff --git a/dynamic_programming/all_construct.py b/dynamic_programming/all_construct.py
index 5d585fc7fcec..ca00f2beb06a 100644
--- a/dynamic_programming/all_construct.py
+++ b/dynamic_programming/all_construct.py
@@ -8,9 +8,10 @@
 
 def all_construct(target: str, word_bank: list[str] | None = None) -> list[list[str]]:
     """
-        returns the list containing all the possible
-        combinations a string(target) can be constructed from
-        the given list of substrings(word_bank)
+    returns the list containing all the possible
+    combinations a string(`target`) can be constructed from
+    the given list of substrings(`word_bank`)
+
     >>> all_construct("hello", ["he", "l", "o"])
     [['he', 'l', 'l', 'o']]
     >>> all_construct("purple",["purp","p","ur","le","purpl"])
diff --git a/dynamic_programming/combination_sum_iv.py b/dynamic_programming/combination_sum_iv.py
index 113c06a27a9e..ed8dcd88e6fd 100644
--- a/dynamic_programming/combination_sum_iv.py
+++ b/dynamic_programming/combination_sum_iv.py
@@ -1,24 +1,25 @@
 """
 Question:
-You are given an array of distinct integers and you have to tell how many
-different ways of selecting the elements from the array are there such that
-the sum of chosen elements is equal to the target number tar.
+    You are given an array of distinct integers and you have to tell how many
+    different ways of selecting the elements from the array are there such that
+    the sum of chosen elements is equal to the target number tar.
 
 Example
 
 Input:
-N = 3
-target = 5
-array = [1, 2, 5]
+    * N = 3
+    * target = 5
+    * array = [1, 2, 5]
 
 Output:
-9
+    9
 
 Approach:
-The basic idea is to go over recursively to find the way such that the sum
-of chosen elements is “tar”. For every element, we have two choices
-    1. Include the element in our set of chosen elements.
-    2. Don't include the element in our set of chosen elements.
+    The basic idea is to go over recursively to find the way such that the sum
+    of chosen elements is `target`. For every element, we have two choices
+
+        1. Include the element in our set of chosen elements.
+        2. Don't include the element in our set of chosen elements.
 """
 
 
diff --git a/dynamic_programming/fizz_buzz.py b/dynamic_programming/fizz_buzz.py
index e29116437a93..0cb48897875b 100644
--- a/dynamic_programming/fizz_buzz.py
+++ b/dynamic_programming/fizz_buzz.py
@@ -3,11 +3,12 @@
 
 def fizz_buzz(number: int, iterations: int) -> str:
     """
-    Plays FizzBuzz.
-    Prints Fizz if number is a multiple of 3.
-    Prints Buzz if its a multiple of 5.
-    Prints FizzBuzz if its a multiple of both 3 and 5 or 15.
-    Else Prints The Number Itself.
+    | Plays FizzBuzz.
+    | Prints Fizz if number is a multiple of ``3``.
+    | Prints Buzz if its a multiple of ``5``.
+    | Prints FizzBuzz if its a multiple of both ``3`` and ``5`` or ``15``.
+    | Else Prints The Number Itself.
+
     >>> fizz_buzz(1,7)
     '1 2 Fizz 4 Buzz Fizz 7 '
     >>> fizz_buzz(1,0)
diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py
index 489b5ada450a..5945ab470564 100644
--- a/dynamic_programming/knapsack.py
+++ b/dynamic_programming/knapsack.py
@@ -11,7 +11,7 @@ def mf_knapsack(i, wt, val, j):
     """
     This code involves the concept of memory functions. Here we solve the subproblems
     which are needed unlike the below example
-    F is a 2D array with -1s filled up
+    F is a 2D array with ``-1`` s filled up
     """
     global f  # a global dp table for knapsack
     if f[i][j] < 0:
@@ -45,22 +45,24 @@ def knapsack_with_example_solution(w: int, wt: list, val: list):
     the several possible optimal subsets.
 
     Parameters
-    ---------
+    ----------
 
-    W: int, the total maximum weight for the given knapsack problem.
-    wt: list, the vector of weights for all items where wt[i] is the weight
-    of the i-th item.
-    val: list, the vector of values for all items where val[i] is the value
-    of the i-th item
+    * `w`: int, the total maximum weight for the given knapsack problem.
+    * `wt`: list, the vector of weights for all items where ``wt[i]`` is the weight
+       of the ``i``-th item.
+    * `val`: list, the vector of values for all items where ``val[i]`` is the value
+      of the ``i``-th item
 
     Returns
     -------
-    optimal_val: float, the optimal value for the given knapsack problem
-    example_optional_set: set, the indices of one of the optimal subsets
-    which gave rise to the optimal value.
+
+    * `optimal_val`: float, the optimal value for the given knapsack problem
+    * `example_optional_set`: set, the indices of one of the optimal subsets
+      which gave rise to the optimal value.
 
     Examples
-    -------
+    --------
+
     >>> knapsack_with_example_solution(10, [1, 3, 5, 2], [10, 20, 100, 22])
     (142, {2, 3, 4})
     >>> knapsack_with_example_solution(6, [4, 3, 2, 3], [3, 2, 4, 4])
@@ -104,19 +106,18 @@ def _construct_solution(dp: list, wt: list, i: int, j: int, optimal_set: set):
     a filled DP table and the vector of weights
 
     Parameters
-    ---------
-
-    dp: list of list, the table of a solved integer weight dynamic programming problem
+    ----------
 
-    wt: list or tuple, the vector of weights of the items
-    i: int, the index of the item under consideration
-    j: int, the current possible maximum weight
-    optimal_set: set, the optimal subset so far. This gets modified by the function.
+    * `dp`: list of list, the table of a solved integer weight dynamic programming problem
+    * `wt`: list or tuple, the vector of weights of the items
+    * `i`: int, the index of the item under consideration
+    * `j`: int, the current possible maximum weight
+    * `optimal_set`: set, the optimal subset so far. This gets modified by the function.
 
     Returns
     -------
-    None
 
+    ``None``
     """
     # for the current item i at a maximum weight j to be part of an optimal subset,
     # the optimal value at (i, j) must be greater than the optimal value at (i-1, j).
diff --git a/dynamic_programming/longest_common_substring.py b/dynamic_programming/longest_common_substring.py
index e2f944a5e336..ea5233eb2d17 100644
--- a/dynamic_programming/longest_common_substring.py
+++ b/dynamic_programming/longest_common_substring.py
@@ -1,15 +1,19 @@
 """
-Longest Common Substring Problem Statement: Given two sequences, find the
-longest common substring present in both of them. A substring is
-necessarily continuous.
-Example: "abcdef" and "xabded" have two longest common substrings, "ab" or "de".
-Therefore, algorithm should return any one of them.
+Longest Common Substring Problem Statement:
+    Given two sequences, find the
+    longest common substring present in both of them. A substring is
+    necessarily continuous.
+
+Example:
+    ``abcdef`` and ``xabded`` have two longest common substrings, ``ab`` or ``de``.
+    Therefore, algorithm should return any one of them.
 """
 
 
 def longest_common_substring(text1: str, text2: str) -> str:
     """
     Finds the longest common substring between two strings.
+
     >>> longest_common_substring("", "")
     ''
     >>> longest_common_substring("a","")
diff --git a/dynamic_programming/longest_increasing_subsequence.py b/dynamic_programming/longest_increasing_subsequence.py
index 2a78e2e7ad1d..d839757f6da5 100644
--- a/dynamic_programming/longest_increasing_subsequence.py
+++ b/dynamic_programming/longest_increasing_subsequence.py
@@ -4,11 +4,13 @@
 This is a pure Python implementation of Dynamic Programming solution to the longest
 increasing subsequence of a given sequence.
 
-The problem is  :
-Given an array, to find the longest and increasing sub-array in that given array and
-return it.
-Example: [10, 22, 9, 33, 21, 50, 41, 60, 80] as input will return
-         [10, 22, 33, 41, 60, 80] as output
+The problem is:
+    Given an array, to find the longest and increasing sub-array in that given array and
+    return it.
+
+Example:
+    ``[10, 22, 9, 33, 21, 50, 41, 60, 80]`` as input will return
+    ``[10, 22, 33, 41, 60, 80]`` as output
 """
 
 from __future__ import annotations
@@ -17,6 +19,7 @@
 def longest_subsequence(array: list[int]) -> list[int]:  # This function is recursive
     """
     Some examples
+
     >>> longest_subsequence([10, 22, 9, 33, 21, 50, 41, 60, 80])
     [10, 22, 33, 41, 60, 80]
     >>> longest_subsequence([4, 8, 7, 5, 1, 12, 2, 3, 9])
diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index da6e525ce816..1d5f559d91f0 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -1,42 +1,47 @@
 """
-Find the minimum number of multiplications needed to multiply chain of matrices.
-Reference: https://www.geeksforgeeks.org/matrix-chain-multiplication-dp-8/
-
-The algorithm has interesting real-world applications. Example:
-1. Image transformations in Computer Graphics as images are composed of matrix.
-2. Solve complex polynomial equations in the field of algebra using least processing
-   power.
-3. Calculate overall impact of macroeconomic decisions as economic equations involve a
-   number of variables.
-4. Self-driving car navigation can be made more accurate as matrix multiplication can
-   accurately determine position and orientation of obstacles in short time.
-
-Python doctests can be run with the following command:
-python -m doctest -v matrix_chain_multiply.py
-
-Given a sequence arr[] that represents chain of 2D matrices such that the dimension of
-the ith matrix is arr[i-1]*arr[i].
-So suppose arr = [40, 20, 30, 10, 30] means we have 4 matrices of dimensions
-40*20, 20*30, 30*10 and 10*30.
-
-matrix_chain_multiply() returns an integer denoting minimum number of multiplications to
+| Find the minimum number of multiplications needed to multiply chain of matrices.
+| Reference: https://www.geeksforgeeks.org/matrix-chain-multiplication-dp-8/
+
+The algorithm has interesting real-world applications.
+
+Example:
+  1. Image transformations in Computer Graphics as images are composed of matrix.
+  2. Solve complex polynomial equations in the field of algebra using least processing
+     power.
+  3. Calculate overall impact of macroeconomic decisions as economic equations involve a
+     number of variables.
+  4. Self-driving car navigation can be made more accurate as matrix multiplication can
+     accurately determine position and orientation of obstacles in short time.
+
+Python doctests can be run with the following command::
+
+  python -m doctest -v matrix_chain_multiply.py
+
+Given a sequence ``arr[]`` that represents chain of 2D matrices such that the dimension of
+the ``i`` th matrix is ``arr[i-1]*arr[i]``.
+So suppose ``arr = [40, 20, 30, 10, 30]`` means we have ``4`` matrices of dimensions
+``40*20``, ``20*30``, ``30*10`` and ``10*30``.
+
+``matrix_chain_multiply()`` returns an integer denoting minimum number of multiplications to
 multiply the chain.
 
 We do not need to perform actual multiplication here.
 We only need to decide the order in which to perform the multiplication.
 
 Hints:
-1. Number of multiplications (ie cost) to multiply 2 matrices
-of size m*p and p*n is m*p*n.
-2. Cost of matrix multiplication is associative ie (M1*M2)*M3 != M1*(M2*M3)
-3. Matrix multiplication is not commutative. So, M1*M2 does not mean M2*M1 can be done.
-4. To determine the required order, we can try different combinations.
+  1. Number of multiplications (ie cost) to multiply ``2`` matrices
+     of size ``m*p`` and ``p*n`` is ``m*p*n``.
+  2. Cost of matrix multiplication is not associative ie ``(M1*M2)*M3 != M1*(M2*M3)``
+  3. Matrix multiplication is not commutative. So, ``M1*M2`` does not mean ``M2*M1`` can be done.
+  4. To determine the required order, we can try different combinations.
+
 So, this problem has overlapping sub-problems and can be solved using recursion.
 We use Dynamic Programming for optimal time complexity.
 
 Example input:
-arr = [40, 20, 30, 10, 30]
-output: 26000
+    ``arr = [40, 20, 30, 10, 30]``
+output:
+    ``26000``
 """
 
 from collections.abc import Iterator
@@ -50,25 +55,25 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     Find the minimum number of multiplcations required to multiply the chain of matrices
 
     Args:
-        arr: The input array of integers.
+        `arr`: The input array of integers.
 
     Returns:
         Minimum number of multiplications needed to multiply the chain
 
     Examples:
-        >>> matrix_chain_multiply([1, 2, 3, 4, 3])
-        30
-        >>> matrix_chain_multiply([10])
-        0
-        >>> matrix_chain_multiply([10, 20])
-        0
-        >>> matrix_chain_multiply([19, 2, 19])
-        722
-        >>> matrix_chain_multiply(list(range(1, 100)))
-        323398
-
-        # >>> matrix_chain_multiply(list(range(1, 251)))
-        # 2626798
+
+    >>> matrix_chain_multiply([1, 2, 3, 4, 3])
+    30
+    >>> matrix_chain_multiply([10])
+    0
+    >>> matrix_chain_multiply([10, 20])
+    0
+    >>> matrix_chain_multiply([19, 2, 19])
+    722
+    >>> matrix_chain_multiply(list(range(1, 100)))
+    323398
+    # >>> matrix_chain_multiply(list(range(1, 251)))
+    # 2626798
     """
     if len(arr) < 2:
         return 0
@@ -93,8 +98,10 @@ def matrix_chain_multiply(arr: list[int]) -> int:
 def matrix_chain_order(dims: list[int]) -> int:
     """
     Source: https://en.wikipedia.org/wiki/Matrix_chain_multiplication
+
     The dynamic programming solution is faster than cached the recursive solution and
     can handle larger inputs.
+
     >>> matrix_chain_order([1, 2, 3, 4, 3])
     30
     >>> matrix_chain_order([10])
@@ -105,7 +112,6 @@ def matrix_chain_order(dims: list[int]) -> int:
     722
     >>> matrix_chain_order(list(range(1, 100)))
     323398
-
     # >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
     # 2626798
     """
diff --git a/dynamic_programming/max_product_subarray.py b/dynamic_programming/max_product_subarray.py
index 425859bc03e3..6f4f38e38942 100644
--- a/dynamic_programming/max_product_subarray.py
+++ b/dynamic_programming/max_product_subarray.py
@@ -1,9 +1,10 @@
 def max_product_subarray(numbers: list[int]) -> int:
     """
     Returns the maximum product that can be obtained by multiplying a
-    contiguous subarray of the given integer list `nums`.
+    contiguous subarray of the given integer list `numbers`.
 
     Example:
+
     >>> max_product_subarray([2, 3, -2, 4])
     6
     >>> max_product_subarray((-2, 0, -1))
diff --git a/dynamic_programming/minimum_squares_to_represent_a_number.py b/dynamic_programming/minimum_squares_to_represent_a_number.py
index bf5849f5bcb3..98c0602fa831 100644
--- a/dynamic_programming/minimum_squares_to_represent_a_number.py
+++ b/dynamic_programming/minimum_squares_to_represent_a_number.py
@@ -5,6 +5,7 @@
 def minimum_squares_to_represent_a_number(number: int) -> int:
     """
     Count the number of minimum squares to represent a number
+
     >>> minimum_squares_to_represent_a_number(25)
     1
     >>> minimum_squares_to_represent_a_number(37)
diff --git a/dynamic_programming/regex_match.py b/dynamic_programming/regex_match.py
index 200a882831c0..67fb1db9480e 100644
--- a/dynamic_programming/regex_match.py
+++ b/dynamic_programming/regex_match.py
@@ -1,8 +1,10 @@
 """
 Regex matching check if a text matches pattern or not.
 Pattern:
-    '.' Matches any single character.
-    '*' Matches zero or more of the preceding element.
+
+    1. ``.`` Matches any single character.
+    2. ``*`` Matches zero or more of the preceding element.
+
 More info:
     https://medium.com/trick-the-interviwer/regular-expression-matching-9972eb74c03
 """
@@ -12,12 +14,12 @@ def recursive_match(text: str, pattern: str) -> bool:
     """
     Recursive matching algorithm.
 
-    Time complexity: O(2 ^ (|text| + |pattern|))
-    Space complexity: Recursion depth is O(|text| + |pattern|).
+    | Time complexity: O(2^(\|text\| + \|pattern\|))
+    | Space complexity: Recursion depth is O(\|text\| + \|pattern\|).
 
     :param text: Text to match.
     :param pattern: Pattern to match.
-    :return: True if text matches pattern, False otherwise.
+    :return: ``True`` if `text` matches `pattern`, ``False`` otherwise.
 
     >>> recursive_match('abc', 'a.c')
     True
@@ -51,12 +53,12 @@ def dp_match(text: str, pattern: str) -> bool:
     """
     Dynamic programming matching algorithm.
 
-    Time complexity: O(|text| * |pattern|)
-    Space complexity: O(|text| * |pattern|)
+    | Time complexity: O(\|text\| * \|pattern\|)
+    | Space complexity: O(\|text\| * \|pattern\|)
 
     :param text: Text to match.
     :param pattern: Pattern to match.
-    :return: True if text matches pattern, False otherwise.
+    :return: ``True`` if `text` matches `pattern`, ``False`` otherwise.
 
     >>> dp_match('abc', 'a.c')
     True
diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index f80fa440ae86..7f90ccbd6a52 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -1,7 +1,7 @@
 """
 This module provides two implementations for the rod-cutting problem:
-1. A naive recursive implementation which has an exponential runtime
-2. Two dynamic programming implementations which have quadratic runtime
+  1. A naive recursive implementation which has an exponential runtime
+  2. Two dynamic programming implementations which have quadratic runtime
 
 The rod-cutting problem is the problem of finding the maximum possible revenue
 obtainable from a rod of length ``n`` given a list of prices for each integral piece
@@ -20,18 +20,21 @@ def naive_cut_rod_recursive(n: int, prices: list):
     Runtime: O(2^n)
 
     Arguments
-    -------
-    n: int, the length of the rod
-    prices: list, the prices for each piece of rod. ``p[i-i]`` is the
-    price for a rod of length ``i``
+    ---------
+
+    * `n`: int, the length of the rod
+    * `prices`: list, the prices for each piece of rod. ``p[i-i]`` is the
+      price for a rod of length ``i``
 
     Returns
     -------
-    The maximum revenue obtainable for a rod of length n given the list of prices
+
+    The maximum revenue obtainable for a rod of length `n` given the list of prices
     for each piece.
 
     Examples
     --------
+
     >>> naive_cut_rod_recursive(4, [1, 5, 8, 9])
     10
     >>> naive_cut_rod_recursive(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
@@ -54,28 +57,30 @@ def top_down_cut_rod(n: int, prices: list):
     """
     Constructs a top-down dynamic programming solution for the rod-cutting
     problem via memoization. This function serves as a wrapper for
-    _top_down_cut_rod_recursive
+    ``_top_down_cut_rod_recursive``
 
     Runtime: O(n^2)
 
     Arguments
-    --------
-    n: int, the length of the rod
-    prices: list, the prices for each piece of rod. ``p[i-i]`` is the
-    price for a rod of length ``i``
+    ---------
 
-    Note
-    ----
-    For convenience and because Python's lists using 0-indexing, length(max_rev) =
-    n + 1, to accommodate for the revenue obtainable from a rod of length 0.
+    * `n`: int, the length of the rod
+    * `prices`: list, the prices for each piece of rod. ``p[i-i]`` is the
+      price for a rod of length ``i``
+
+    .. note::
+      For convenience and because Python's lists using ``0``-indexing, ``length(max_rev) =
+      n + 1``, to accommodate for the revenue obtainable from a rod of length ``0```.
 
     Returns
     -------
-    The maximum revenue obtainable for a rod of length n given the list of prices
+
+    The maximum revenue obtainable for a rod of length `n` given the list of prices
     for each piece.
 
     Examples
-    -------
+    --------
+
     >>> top_down_cut_rod(4, [1, 5, 8, 9])
     10
     >>> top_down_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
@@ -94,16 +99,18 @@ def _top_down_cut_rod_recursive(n: int, prices: list, max_rev: list):
     Runtime: O(n^2)
 
     Arguments
-    --------
-    n: int, the length of the rod
-    prices: list, the prices for each piece of rod. ``p[i-i]`` is the
-    price for a rod of length ``i``
-    max_rev: list, the computed maximum revenue for a piece of rod.
-    ``max_rev[i]`` is the maximum revenue obtainable for a rod of length ``i``
+    ---------
+
+    * `n`: int, the length of the rod
+    * `prices`: list, the prices for each piece of rod. ``p[i-i]`` is the
+      price for a rod of length ``i``
+    * `max_rev`: list, the computed maximum revenue for a piece of rod.
+      ``max_rev[i]`` is the maximum revenue obtainable for a rod of length ``i``
 
     Returns
     -------
-    The maximum revenue obtainable for a rod of length n given the list of prices
+
+    The maximum revenue obtainable for a rod of length `n` given the list of prices
     for each piece.
     """
     if max_rev[n] >= 0:
@@ -130,18 +137,21 @@ def bottom_up_cut_rod(n: int, prices: list):
     Runtime: O(n^2)
 
     Arguments
-    ----------
-    n: int, the maximum length of the rod.
-    prices: list, the prices for each piece of rod. ``p[i-i]`` is the
-    price for a rod of length ``i``
+    ---------
+
+    * `n`: int, the maximum length of the rod.
+    * `prices`: list, the prices for each piece of rod. ``p[i-i]`` is the
+      price for a rod of length ``i``
 
     Returns
     -------
-    The maximum revenue obtainable from cutting a rod of length n given
+
+    The maximum revenue obtainable from cutting a rod of length `n` given
     the prices for each piece of rod p.
 
     Examples
-    -------
+    --------
+
     >>> bottom_up_cut_rod(4, [1, 5, 8, 9])
     10
     >>> bottom_up_cut_rod(10, [1, 5, 8, 9, 10, 17, 17, 20, 24, 30])
@@ -168,13 +178,12 @@ def _enforce_args(n: int, prices: list):
     """
     Basic checks on the arguments to the rod-cutting algorithms
 
-    n: int, the length of the rod
-    prices: list, the price list for each piece of rod.
-
-    Throws ValueError:
+    * `n`: int, the length of the rod
+    * `prices`: list, the price list for each piece of rod.
 
-    if n is negative or there are fewer items in the price list than the length of
-    the rod
+    Throws ``ValueError``:
+        if `n` is negative or there are fewer items in the price list than the length of
+        the rod
     """
     if n < 0:
         msg = f"n must be greater than or equal to 0. Got n = {n}"
diff --git a/dynamic_programming/subset_generation.py b/dynamic_programming/subset_generation.py
index d490bca737ba..08daaac6f88a 100644
--- a/dynamic_programming/subset_generation.py
+++ b/dynamic_programming/subset_generation.py
@@ -1,38 +1,41 @@
 def subset_combinations(elements: list[int], n: int) -> list:
     """
     Compute n-element combinations from a given list using dynamic programming.
+
     Args:
-        elements: The list of elements from which combinations will be generated.
-        n: The number of elements in each combination.
+        * `elements`: The list of elements from which combinations will be generated.
+        * `n`: The number of elements in each combination.
+
     Returns:
-        A list of tuples, each representing a combination of n elements.
-        >>> subset_combinations(elements=[10, 20, 30, 40], n=2)
-        [(10, 20), (10, 30), (10, 40), (20, 30), (20, 40), (30, 40)]
-        >>> subset_combinations(elements=[1, 2, 3], n=1)
-        [(1,), (2,), (3,)]
-        >>> subset_combinations(elements=[1, 2, 3], n=3)
-        [(1, 2, 3)]
-        >>> subset_combinations(elements=[42], n=1)
-        [(42,)]
-        >>> subset_combinations(elements=[6, 7, 8, 9], n=4)
-        [(6, 7, 8, 9)]
-        >>> subset_combinations(elements=[10, 20, 30, 40, 50], n=0)
-        [()]
-        >>> subset_combinations(elements=[1, 2, 3, 4], n=2)
-        [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
-        >>> subset_combinations(elements=[1, 'apple', 3.14], n=2)
-        [(1, 'apple'), (1, 3.14), ('apple', 3.14)]
-        >>> subset_combinations(elements=['single'], n=0)
-        [()]
-        >>> subset_combinations(elements=[], n=9)
-        []
-        >>> from itertools import combinations
-        >>> all(subset_combinations(items, n) == list(combinations(items, n))
-        ...     for items, n in (
-        ...         ([10, 20, 30, 40], 2), ([1, 2, 3], 1), ([1, 2, 3], 3), ([42], 1),
-        ...         ([6, 7, 8, 9], 4), ([10, 20, 30, 40, 50], 1), ([1, 2, 3, 4], 2),
-        ...         ([1, 'apple', 3.14], 2), (['single'], 0), ([], 9)))
-        True
+        A list of tuples, each representing a combination of `n` elements.
+
+    >>> subset_combinations(elements=[10, 20, 30, 40], n=2)
+    [(10, 20), (10, 30), (10, 40), (20, 30), (20, 40), (30, 40)]
+    >>> subset_combinations(elements=[1, 2, 3], n=1)
+    [(1,), (2,), (3,)]
+    >>> subset_combinations(elements=[1, 2, 3], n=3)
+    [(1, 2, 3)]
+    >>> subset_combinations(elements=[42], n=1)
+    [(42,)]
+    >>> subset_combinations(elements=[6, 7, 8, 9], n=4)
+    [(6, 7, 8, 9)]
+    >>> subset_combinations(elements=[10, 20, 30, 40, 50], n=0)
+    [()]
+    >>> subset_combinations(elements=[1, 2, 3, 4], n=2)
+    [(1, 2), (1, 3), (1, 4), (2, 3), (2, 4), (3, 4)]
+    >>> subset_combinations(elements=[1, 'apple', 3.14], n=2)
+    [(1, 'apple'), (1, 3.14), ('apple', 3.14)]
+    >>> subset_combinations(elements=['single'], n=0)
+    [()]
+    >>> subset_combinations(elements=[], n=9)
+    []
+    >>> from itertools import combinations
+    >>> all(subset_combinations(items, n) == list(combinations(items, n))
+    ...     for items, n in (
+    ...         ([10, 20, 30, 40], 2), ([1, 2, 3], 1), ([1, 2, 3], 3), ([42], 1),
+    ...         ([6, 7, 8, 9], 4), ([10, 20, 30, 40, 50], 1), ([1, 2, 3, 4], 2),
+    ...         ([1, 'apple', 3.14], 2), (['single'], 0), ([], 9)))
+    True
     """
     r = len(elements)
     if n > r:
diff --git a/dynamic_programming/viterbi.py b/dynamic_programming/viterbi.py
index 764d45dc2c05..dc4274ca2a51 100644
--- a/dynamic_programming/viterbi.py
+++ b/dynamic_programming/viterbi.py
@@ -11,9 +11,11 @@ def viterbi(
     """
         Viterbi Algorithm, to find the most likely path of
         states from the start and the expected output.
+
         https://en.wikipedia.org/wiki/Viterbi_algorithm
-    sdafads
+
         Wikipedia example
+
         >>> observations = ["normal", "cold", "dizzy"]
         >>> states = ["Healthy", "Fever"]
         >>> start_p = {"Healthy": 0.6, "Fever": 0.4}
@@ -27,97 +29,78 @@ def viterbi(
         ... }
         >>> viterbi(observations, states, start_p, trans_p, emit_p)
         ['Healthy', 'Healthy', 'Fever']
-
         >>> viterbi((), states, start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: There's an empty parameter
-
         >>> viterbi(observations, (), start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: There's an empty parameter
-
         >>> viterbi(observations, states, {}, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: There's an empty parameter
-
         >>> viterbi(observations, states, start_p, {}, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: There's an empty parameter
-
         >>> viterbi(observations, states, start_p, trans_p, {})
         Traceback (most recent call last):
             ...
         ValueError: There's an empty parameter
-
         >>> viterbi("invalid", states, start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: observations_space must be a list
-
         >>> viterbi(["valid", 123], states, start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: observations_space must be a list of strings
-
         >>> viterbi(observations, "invalid", start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: states_space must be a list
-
         >>> viterbi(observations, ["valid", 123], start_p, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: states_space must be a list of strings
-
         >>> viterbi(observations, states, "invalid", trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: initial_probabilities must be a dict
-
         >>> viterbi(observations, states, {2:2}, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: initial_probabilities all keys must be strings
-
         >>> viterbi(observations, states, {"a":2}, trans_p, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: initial_probabilities all values must be float
-
         >>> viterbi(observations, states, start_p, "invalid", emit_p)
         Traceback (most recent call last):
             ...
         ValueError: transition_probabilities must be a dict
-
         >>> viterbi(observations, states, start_p, {"a":2}, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: transition_probabilities all values must be dict
-
         >>> viterbi(observations, states, start_p, {2:{2:2}}, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: transition_probabilities all keys must be strings
-
         >>> viterbi(observations, states, start_p, {"a":{2:2}}, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: transition_probabilities all keys must be strings
-
         >>> viterbi(observations, states, start_p, {"a":{"b":2}}, emit_p)
         Traceback (most recent call last):
             ...
         ValueError: transition_probabilities nested dictionary all values must be float
-
         >>> viterbi(observations, states, start_p, trans_p, "invalid")
         Traceback (most recent call last):
             ...
         ValueError: emission_probabilities must be a dict
-
         >>> viterbi(observations, states, start_p, trans_p, None)
         Traceback (most recent call last):
             ...
@@ -213,7 +196,6 @@ def _validation(
     ...     "Fever": {"normal": 0.1, "cold": 0.3, "dizzy": 0.6},
     ... }
     >>> _validation(observations, states, start_p, trans_p, emit_p)
-
     >>> _validation([], states, start_p, trans_p, emit_p)
     Traceback (most recent call last):
             ...
@@ -242,7 +224,6 @@ def _validate_not_empty(
     """
     >>> _validate_not_empty(["a"], ["b"], {"c":0.5},
     ... {"d": {"e": 0.6}}, {"f": {"g": 0.7}})
-
     >>> _validate_not_empty(["a"], ["b"], {"c":0.5}, {}, {"f": {"g": 0.7}})
     Traceback (most recent call last):
             ...
@@ -267,12 +248,10 @@ def _validate_not_empty(
 def _validate_lists(observations_space: Any, states_space: Any) -> None:
     """
     >>> _validate_lists(["a"], ["b"])
-
     >>> _validate_lists(1234, ["b"])
     Traceback (most recent call last):
             ...
     ValueError: observations_space must be a list
-
     >>> _validate_lists(["a"], [3])
     Traceback (most recent call last):
             ...
@@ -285,7 +264,6 @@ def _validate_lists(observations_space: Any, states_space: Any) -> None:
 def _validate_list(_object: Any, var_name: str) -> None:
     """
     >>> _validate_list(["a"], "mock_name")
-
     >>> _validate_list("a", "mock_name")
     Traceback (most recent call last):
             ...
@@ -294,7 +272,6 @@ def _validate_list(_object: Any, var_name: str) -> None:
     Traceback (most recent call last):
             ...
     ValueError: mock_name must be a list of strings
-
     """
     if not isinstance(_object, list):
         msg = f"{var_name} must be a list"
@@ -313,7 +290,6 @@ def _validate_dicts(
 ) -> None:
     """
     >>> _validate_dicts({"c":0.5}, {"d": {"e": 0.6}}, {"f": {"g": 0.7}})
-
     >>> _validate_dicts("invalid", {"d": {"e": 0.6}}, {"f": {"g": 0.7}})
     Traceback (most recent call last):
             ...
@@ -339,7 +315,6 @@ def _validate_dicts(
 def _validate_nested_dict(_object: Any, var_name: str) -> None:
     """
     >>> _validate_nested_dict({"a":{"b": 0.5}}, "mock_name")
-
     >>> _validate_nested_dict("invalid", "mock_name")
     Traceback (most recent call last):
             ...
@@ -367,7 +342,6 @@ def _validate_dict(
 ) -> None:
     """
     >>> _validate_dict({"b": 0.5}, "mock_name", float)
-
     >>> _validate_dict("invalid", "mock_name", float)
     Traceback (most recent call last):
             ...

From 3c2ccb96e4c87f705d578678f6fdf520e8543457 Mon Sep 17 00:00:00 2001
From: "pre-commit-ci[bot]"
 <66853113+pre-commit-ci[bot]@users.noreply.github.com>
Date: Sun, 29 Dec 2024 23:20:25 +0000
Subject: [PATCH 2/8] [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci
---
 dynamic_programming/viterbi.py | 186 ++++++++++++++++-----------------
 1 file changed, 93 insertions(+), 93 deletions(-)

diff --git a/dynamic_programming/viterbi.py b/dynamic_programming/viterbi.py
index dc4274ca2a51..5b78fa9e46d0 100644
--- a/dynamic_programming/viterbi.py
+++ b/dynamic_programming/viterbi.py
@@ -9,102 +9,102 @@ def viterbi(
     emission_probabilities: dict,
 ) -> list:
     """
-        Viterbi Algorithm, to find the most likely path of
-        states from the start and the expected output.
+    Viterbi Algorithm, to find the most likely path of
+    states from the start and the expected output.
 
-        https://en.wikipedia.org/wiki/Viterbi_algorithm
+    https://en.wikipedia.org/wiki/Viterbi_algorithm
 
-        Wikipedia example
+    Wikipedia example
 
-        >>> observations = ["normal", "cold", "dizzy"]
-        >>> states = ["Healthy", "Fever"]
-        >>> start_p = {"Healthy": 0.6, "Fever": 0.4}
-        >>> trans_p = {
-        ...     "Healthy": {"Healthy": 0.7, "Fever": 0.3},
-        ...     "Fever": {"Healthy": 0.4, "Fever": 0.6},
-        ... }
-        >>> emit_p = {
-        ...     "Healthy": {"normal": 0.5, "cold": 0.4, "dizzy": 0.1},
-        ...     "Fever": {"normal": 0.1, "cold": 0.3, "dizzy": 0.6},
-        ... }
-        >>> viterbi(observations, states, start_p, trans_p, emit_p)
-        ['Healthy', 'Healthy', 'Fever']
-        >>> viterbi((), states, start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
-        >>> viterbi(observations, (), start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
-        >>> viterbi(observations, states, {}, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
-        >>> viterbi(observations, states, start_p, {}, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
-        >>> viterbi(observations, states, start_p, trans_p, {})
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
-        >>> viterbi("invalid", states, start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: observations_space must be a list
-        >>> viterbi(["valid", 123], states, start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: observations_space must be a list of strings
-        >>> viterbi(observations, "invalid", start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: states_space must be a list
-        >>> viterbi(observations, ["valid", 123], start_p, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: states_space must be a list of strings
-        >>> viterbi(observations, states, "invalid", trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: initial_probabilities must be a dict
-        >>> viterbi(observations, states, {2:2}, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: initial_probabilities all keys must be strings
-        >>> viterbi(observations, states, {"a":2}, trans_p, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: initial_probabilities all values must be float
-        >>> viterbi(observations, states, start_p, "invalid", emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: transition_probabilities must be a dict
-        >>> viterbi(observations, states, start_p, {"a":2}, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: transition_probabilities all values must be dict
-        >>> viterbi(observations, states, start_p, {2:{2:2}}, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: transition_probabilities all keys must be strings
-        >>> viterbi(observations, states, start_p, {"a":{2:2}}, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: transition_probabilities all keys must be strings
-        >>> viterbi(observations, states, start_p, {"a":{"b":2}}, emit_p)
-        Traceback (most recent call last):
-            ...
-        ValueError: transition_probabilities nested dictionary all values must be float
-        >>> viterbi(observations, states, start_p, trans_p, "invalid")
-        Traceback (most recent call last):
-            ...
-        ValueError: emission_probabilities must be a dict
-        >>> viterbi(observations, states, start_p, trans_p, None)
-        Traceback (most recent call last):
-            ...
-        ValueError: There's an empty parameter
+    >>> observations = ["normal", "cold", "dizzy"]
+    >>> states = ["Healthy", "Fever"]
+    >>> start_p = {"Healthy": 0.6, "Fever": 0.4}
+    >>> trans_p = {
+    ...     "Healthy": {"Healthy": 0.7, "Fever": 0.3},
+    ...     "Fever": {"Healthy": 0.4, "Fever": 0.6},
+    ... }
+    >>> emit_p = {
+    ...     "Healthy": {"normal": 0.5, "cold": 0.4, "dizzy": 0.1},
+    ...     "Fever": {"normal": 0.1, "cold": 0.3, "dizzy": 0.6},
+    ... }
+    >>> viterbi(observations, states, start_p, trans_p, emit_p)
+    ['Healthy', 'Healthy', 'Fever']
+    >>> viterbi((), states, start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
+    >>> viterbi(observations, (), start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
+    >>> viterbi(observations, states, {}, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
+    >>> viterbi(observations, states, start_p, {}, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
+    >>> viterbi(observations, states, start_p, trans_p, {})
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
+    >>> viterbi("invalid", states, start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: observations_space must be a list
+    >>> viterbi(["valid", 123], states, start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: observations_space must be a list of strings
+    >>> viterbi(observations, "invalid", start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: states_space must be a list
+    >>> viterbi(observations, ["valid", 123], start_p, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: states_space must be a list of strings
+    >>> viterbi(observations, states, "invalid", trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: initial_probabilities must be a dict
+    >>> viterbi(observations, states, {2:2}, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: initial_probabilities all keys must be strings
+    >>> viterbi(observations, states, {"a":2}, trans_p, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: initial_probabilities all values must be float
+    >>> viterbi(observations, states, start_p, "invalid", emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: transition_probabilities must be a dict
+    >>> viterbi(observations, states, start_p, {"a":2}, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: transition_probabilities all values must be dict
+    >>> viterbi(observations, states, start_p, {2:{2:2}}, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: transition_probabilities all keys must be strings
+    >>> viterbi(observations, states, start_p, {"a":{2:2}}, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: transition_probabilities all keys must be strings
+    >>> viterbi(observations, states, start_p, {"a":{"b":2}}, emit_p)
+    Traceback (most recent call last):
+        ...
+    ValueError: transition_probabilities nested dictionary all values must be float
+    >>> viterbi(observations, states, start_p, trans_p, "invalid")
+    Traceback (most recent call last):
+        ...
+    ValueError: emission_probabilities must be a dict
+    >>> viterbi(observations, states, start_p, trans_p, None)
+    Traceback (most recent call last):
+        ...
+    ValueError: There's an empty parameter
 
     """
     _validation(

From dc96be7a7e795f0165d158f776b1d670a358c19b Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:27:37 +0300
Subject: [PATCH 3/8] Fix

---
 dynamic_programming/knapsack.py                    |  3 ++-
 dynamic_programming/matrix_chain_multiplication.py | 11 ++++++-----
 dynamic_programming/regex_match.py                 |  4 ++--
 dynamic_programming/rod_cutting.py                 |  4 ++--
 4 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py
index 5945ab470564..28c5b19dbe36 100644
--- a/dynamic_programming/knapsack.py
+++ b/dynamic_programming/knapsack.py
@@ -108,7 +108,8 @@ def _construct_solution(dp: list, wt: list, i: int, j: int, optimal_set: set):
     Parameters
     ----------
 
-    * `dp`: list of list, the table of a solved integer weight dynamic programming problem
+    * `dp`: list of list, the table of a solved integer weight dynamic programming
+      problem
     * `wt`: list or tuple, the vector of weights of the items
     * `i`: int, the index of the item under consideration
     * `j`: int, the current possible maximum weight
diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index 1d5f559d91f0..9adabbd6286f 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -17,13 +17,13 @@
 
   python -m doctest -v matrix_chain_multiply.py
 
-Given a sequence ``arr[]`` that represents chain of 2D matrices such that the dimension of
-the ``i`` th matrix is ``arr[i-1]*arr[i]``.
+Given a sequence ``arr[]`` that represents chain of 2D matrices such that the dimension
+of the ``i`` th matrix is ``arr[i-1]*arr[i]``.
 So suppose ``arr = [40, 20, 30, 10, 30]`` means we have ``4`` matrices of dimensions
 ``40*20``, ``20*30``, ``30*10`` and ``10*30``.
 
-``matrix_chain_multiply()`` returns an integer denoting minimum number of multiplications to
-multiply the chain.
+``matrix_chain_multiply()`` returns an integer denoting minimum number of
+multiplications to multiply the chain.
 
 We do not need to perform actual multiplication here.
 We only need to decide the order in which to perform the multiplication.
@@ -32,7 +32,8 @@
   1. Number of multiplications (ie cost) to multiply ``2`` matrices
      of size ``m*p`` and ``p*n`` is ``m*p*n``.
   2. Cost of matrix multiplication is not associative ie ``(M1*M2)*M3 != M1*(M2*M3)``
-  3. Matrix multiplication is not commutative. So, ``M1*M2`` does not mean ``M2*M1`` can be done.
+  3. Matrix multiplication is not commutative. So, ``M1*M2`` does not mean ``M2*M1``
+     can be done.
   4. To determine the required order, we can try different combinations.
 
 So, this problem has overlapping sub-problems and can be solved using recursion.
diff --git a/dynamic_programming/regex_match.py b/dynamic_programming/regex_match.py
index 67fb1db9480e..e94d82093c8b 100644
--- a/dynamic_programming/regex_match.py
+++ b/dynamic_programming/regex_match.py
@@ -11,7 +11,7 @@
 
 
 def recursive_match(text: str, pattern: str) -> bool:
-    """
+    r"""
     Recursive matching algorithm.
 
     | Time complexity: O(2^(\|text\| + \|pattern\|))
@@ -50,7 +50,7 @@ def recursive_match(text: str, pattern: str) -> bool:
 
 
 def dp_match(text: str, pattern: str) -> bool:
-    """
+    r"""
     Dynamic programming matching algorithm.
 
     | Time complexity: O(\|text\| * \|pattern\|)
diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index 7f90ccbd6a52..d12c759dc928 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -69,8 +69,8 @@ def top_down_cut_rod(n: int, prices: list):
       price for a rod of length ``i``
 
     .. note::
-      For convenience and because Python's lists using ``0``-indexing, ``length(max_rev) =
-      n + 1``, to accommodate for the revenue obtainable from a rod of length ``0```.
+      For convenience and because Python's lists using ``0``-indexing, ``length(max_rev)
+      = n + 1``, to accommodate for the revenue obtainable from a rod of length ``0``.
 
     Returns
     -------

From c73c93e373a14a2470f659dcc5363b458d712d78 Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:31:39 +0300
Subject: [PATCH 4/8] Fix

---
 dynamic_programming/matrix_chain_multiplication.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index 9adabbd6286f..91ca04458b61 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -73,8 +73,8 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     722
     >>> matrix_chain_multiply(list(range(1, 100)))
     323398
-    # >>> matrix_chain_multiply(list(range(1, 251)))
-    # 2626798
+    >>> matrix_chain_multiply(list(range(1, 251)))
+    2626798
     """
     if len(arr) < 2:
         return 0
@@ -113,8 +113,8 @@ def matrix_chain_order(dims: list[int]) -> int:
     722
     >>> matrix_chain_order(list(range(1, 100)))
     323398
-    # >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
-    # 2626798
+    >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
+    2626798
     """
 
     @cache

From 624a79d625b4f1a7e155ef1e6af99a31b85ddcf5 Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:36:26 +0300
Subject: [PATCH 5/8] Fix

---
 dynamic_programming/matrix_chain_multiplication.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index 91ca04458b61..da7dc9ccdfcc 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -74,7 +74,7 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     >>> matrix_chain_multiply(list(range(1, 100)))
     323398
     >>> matrix_chain_multiply(list(range(1, 251)))
-    2626798
+    5208248
     """
     if len(arr) < 2:
         return 0
@@ -114,7 +114,7 @@ def matrix_chain_order(dims: list[int]) -> int:
     >>> matrix_chain_order(list(range(1, 100)))
     323398
     >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
-    2626798
+    5208248
     """
 
     @cache

From aa9a6e651326d94c0125e7f22a37c151e7cf8dcc Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:39:48 +0300
Subject: [PATCH 6/8] Fix

---
 dynamic_programming/matrix_chain_multiplication.py | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index da7dc9ccdfcc..9adabbd6286f 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -73,8 +73,8 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     722
     >>> matrix_chain_multiply(list(range(1, 100)))
     323398
-    >>> matrix_chain_multiply(list(range(1, 251)))
-    5208248
+    # >>> matrix_chain_multiply(list(range(1, 251)))
+    # 2626798
     """
     if len(arr) < 2:
         return 0
@@ -113,8 +113,8 @@ def matrix_chain_order(dims: list[int]) -> int:
     722
     >>> matrix_chain_order(list(range(1, 100)))
     323398
-    >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
-    5208248
+    # >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
+    # 2626798
     """
 
     @cache

From 720feb361ebc470998163c318dff2f5578b9cc97 Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:42:00 +0300
Subject: [PATCH 7/8] Fix

---
 dynamic_programming/matrix_chain_multiplication.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index 9adabbd6286f..1fb484504fe3 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -73,6 +73,7 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     722
     >>> matrix_chain_multiply(list(range(1, 100)))
     323398
+
     # >>> matrix_chain_multiply(list(range(1, 251)))
     # 2626798
     """
@@ -113,6 +114,7 @@ def matrix_chain_order(dims: list[int]) -> int:
     722
     >>> matrix_chain_order(list(range(1, 100)))
     323398
+
     # >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
     # 2626798
     """

From bba79c952388efec483440a855fb0eaabf9620f1 Mon Sep 17 00:00:00 2001
From: MaximSmolskiy <mithridatus@mail.ru>
Date: Mon, 30 Dec 2024 02:44:06 +0300
Subject: [PATCH 8/8] Fix

---
 dynamic_programming/matrix_chain_multiplication.py | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/dynamic_programming/matrix_chain_multiplication.py b/dynamic_programming/matrix_chain_multiplication.py
index 1fb484504fe3..10e136b9f0db 100644
--- a/dynamic_programming/matrix_chain_multiplication.py
+++ b/dynamic_programming/matrix_chain_multiplication.py
@@ -73,8 +73,7 @@ def matrix_chain_multiply(arr: list[int]) -> int:
     722
     >>> matrix_chain_multiply(list(range(1, 100)))
     323398
-
-    # >>> matrix_chain_multiply(list(range(1, 251)))
+    >>> # matrix_chain_multiply(list(range(1, 251)))
     # 2626798
     """
     if len(arr) < 2:
@@ -114,8 +113,7 @@ def matrix_chain_order(dims: list[int]) -> int:
     722
     >>> matrix_chain_order(list(range(1, 100)))
     323398
-
-    # >>> matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
+    >>> # matrix_chain_order(list(range(1, 251)))  # Max before RecursionError is raised
     # 2626798
     """