2025-02-25 10:28:39 +00:00
55 changed files with 616 additions and 1092 deletions
--- a/.devcontainer/Dockerfile
+++ b/.devcontainer/Dockerfile
@ -1,8 +0,0 @@
-# https://github.com/microsoft/vscode-dev-containers/blob/main/containers/python-3/README.md
-ARG VARIANT=3.11-bookworm
-FROM mcr.microsoft.com/vscode/devcontainers/python:${VARIANT}
-COPY requirements.txt /tmp/pip-tmp/
-RUN python3 -m pip install --upgrade pip \
-  && python3 -m pip install --no-cache-dir install -r /tmp/pip-tmp/requirements.txt \
-  && pipx install pre-commit ruff \
-  && pre-commit install
--- a/.devcontainer/devcontainer.json
+++ b/.devcontainer/devcontainer.json
@ -1,42 +0,0 @@
-{
-	"name": "Python 3",
-	"build": {
-		"dockerfile": "Dockerfile",
-		"context": "..",
-		"args": {
-			// Update 'VARIANT' to pick a Python version: 3, 3.10, 3.9, 3.8, 3.7, 3.6
-			// Append -bullseye or -buster to pin to an OS version.
-			// Use -bullseye variants on local on arm64/Apple Silicon.
-			"VARIANT": "3.11-bookworm",
-		}
-	},
-
-	// Configure tool-specific properties.
-	"customizations": {
-		// Configure properties specific to VS Code.
-		"vscode": {
-			// Set *default* container specific settings.json values on container create.
-			"settings": {
-				"python.defaultInterpreterPath": "/usr/local/bin/python",
-				"python.linting.enabled": true,
-				"python.formatting.blackPath": "/usr/local/py-utils/bin/black",
-				"python.linting.mypyPath": "/usr/local/py-utils/bin/mypy"
-			},
-
-			// Add the IDs of extensions you want installed when the container is created.
-			"extensions": [
-				"ms-python.python",
-				"ms-python.vscode-pylance"
-			]
-		}
-	},
-
-	// Use 'forwardPorts' to make a list of ports inside the container available locally.
-	// "forwardPorts": [],
-
-	// Use 'postCreateCommand' to run commands after the container is created.
-	// "postCreateCommand": "pip3 install --user -r requirements.txt",
-
-	// Comment out to connect as root instead. More info: https://aka.ms/vscode-remote/containers/non-root.
-	"remoteUser": "vscode"
-}
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@ -16,12 +16,12 @@ repos:
    -   id: auto-walrus

  - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.0.281
+    rev: v0.0.275
    hooks:
      - id: ruff

  - repo: https://github.com/psf/black
-    rev: 23.7.0
+    rev: 23.3.0
    hooks:
      - id: black

@ -33,7 +33,7 @@ repos:
          - tomli

  - repo: https://github.com/tox-dev/pyproject-fmt
-    rev: "0.13.0"
+    rev: "0.12.1"
    hooks:
      - id: pyproject-fmt

--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@ -25,8 +25,6 @@ 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.

-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.
-
 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:
 ```
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@ -236,8 +236,8 @@
    * [Double Ended Queue](data_structures/queue/double_ended_queue.py)
    * [Linked Queue](data_structures/queue/linked_queue.py)
    * [Priority Queue Using List](data_structures/queue/priority_queue_using_list.py)
-    * [Queue By List](data_structures/queue/queue_by_list.py)
    * [Queue By Two Stacks](data_structures/queue/queue_by_two_stacks.py)
+    * [Queue On List](data_structures/queue/queue_on_list.py)
    * [Queue On Pseudo Stack](data_structures/queue/queue_on_pseudo_stack.py)
  * Stacks
    * [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
@ -293,7 +293,7 @@
  * [Inversions](divide_and_conquer/inversions.py)
  * [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
  * [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
-  * [Max Subarray](divide_and_conquer/max_subarray.py)
+  * [Max Subarray Sum](divide_and_conquer/max_subarray_sum.py)
  * [Mergesort](divide_and_conquer/mergesort.py)
  * [Peak](divide_and_conquer/peak.py)
  * [Power](divide_and_conquer/power.py)
@ -324,7 +324,8 @@
  * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
  * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
-  * [Max Subarray Sum](dynamic_programming/max_subarray_sum.py)
+  * [Max Sub Array](dynamic_programming/max_sub_array.py)
+  * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
  * [Min Distance Up Bottom](dynamic_programming/min_distance_up_bottom.py)
  * [Minimum Coin Change](dynamic_programming/minimum_coin_change.py)
  * [Minimum Cost Path](dynamic_programming/minimum_cost_path.py)
@ -511,7 +512,7 @@
  * Lstm
    * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
  * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
-  * [Polynomial Regression](machine_learning/polynomial_regression.py)
+  * [Polymonial Regression](machine_learning/polymonial_regression.py)
  * [Scoring Functions](machine_learning/scoring_functions.py)
  * [Self Organizing Map](machine_learning/self_organizing_map.py)
  * [Sequential Minimum Optimization](machine_learning/sequential_minimum_optimization.py)
@ -590,10 +591,12 @@
  * [Is Square Free](maths/is_square_free.py)
  * [Jaccard Similarity](maths/jaccard_similarity.py)
  * [Juggler Sequence](maths/juggler_sequence.py)
+  * [Kadanes](maths/kadanes.py)
  * [Karatsuba](maths/karatsuba.py)
  * [Krishnamurthy Number](maths/krishnamurthy_number.py)
  * [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
  * [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
+  * [Largest Subarray Sum](maths/largest_subarray_sum.py)
  * [Least Common Multiple](maths/least_common_multiple.py)
  * [Line Length](maths/line_length.py)
  * [Liouville Lambda](maths/liouville_lambda.py)
@ -730,6 +733,7 @@
  * [Linear Congruential Generator](other/linear_congruential_generator.py)
  * [Lru Cache](other/lru_cache.py)
  * [Magicdiamondpattern](other/magicdiamondpattern.py)
+  * [Maximum Subarray](other/maximum_subarray.py)
  * [Maximum Subsequence](other/maximum_subsequence.py)
  * [Nested Brackets](other/nested_brackets.py)
  * [Number Container System](other/number_container_system.py)
@ -740,9 +744,7 @@
  * [Tower Of Hanoi](other/tower_of_hanoi.py)

 ## Physics
-  * [Altitude Pressure](physics/altitude_pressure.py)
  * [Archimedes Principle](physics/archimedes_principle.py)
-  * [Basic Orbital Capture](physics/basic_orbital_capture.py)
  * [Casimir Effect](physics/casimir_effect.py)
  * [Centripetal Force](physics/centripetal_force.py)
  * [Grahams Law](physics/grahams_law.py)
@ -1064,6 +1066,7 @@
  * [Q Fourier Transform](quantum/q_fourier_transform.py)
  * [Q Full Adder](quantum/q_full_adder.py)
  * [Quantum Entanglement](quantum/quantum_entanglement.py)
+  * [Quantum Random](quantum/quantum_random.py)
  * [Quantum Teleportation](quantum/quantum_teleportation.py)
  * [Ripple Adder Classic](quantum/ripple_adder_classic.py)
  * [Single Qubit Measure](quantum/single_qubit_measure.py)
--- a/README.md
+++ b/README.md
@ -13,7 +13,7 @@
    <img src="https://img.shields.io/static/v1.svg?label=Contributions&message=Welcome&color=0059b3&style=flat-square" height="20" alt="Contributions Welcome">
  </a>
  <img src="https://img.shields.io/github/repo-size/TheAlgorithms/Python.svg?label=Repo%20size&style=flat-square" height="20">
-  <a href="https://the-algorithms.com/discord">
+  <a href="https://discord.gg/c7MnfGFGa6">
    <img src="https://img.shields.io/discord/808045925556682782.svg?logo=discord&colorB=7289DA&style=flat-square" height="20" alt="Discord chat">
  </a>
  <a href="https://gitter.im/TheAlgorithms/community">
@ -42,7 +42,7 @@ Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribut

 ## Community Channels

-We are on [Discord](https://the-algorithms.com/discord) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!
+We are on [Discord](https://discord.gg/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!

 ## List of Algorithms

--- a/arithmetic_analysis/newton_raphson.py
+++ b/arithmetic_analysis/newton_raphson.py
@ -25,11 +25,9 @@ def newton_raphson(
    """
    x = a
    while True:
-        x = Decimal(x) - (
-            Decimal(eval(func)) / Decimal(eval(str(diff(func))))  # noqa: S307
-        )
+        x = Decimal(x) - (Decimal(eval(func)) / Decimal(eval(str(diff(func)))))
        # This number dictates the accuracy of the answer
-        if abs(eval(func)) < precision:  # noqa: S307
+        if abs(eval(func)) < precision:
            return float(x)


--- a/cellular_automata/game_of_life.py
+++ b/cellular_automata/game_of_life.py
@ -10,7 +10,7 @@ Python:
  - 3.5

 Usage:
-  - $python3 game_of_life <canvas_size:int>
+  - $python3 game_o_life <canvas_size:int>

 Game-Of-Life Rules:

@ -52,8 +52,7 @@ def seed(canvas: list[list[bool]]) -> None:


 def run(canvas: list[list[bool]]) -> list[list[bool]]:
-    """
-    This function runs the rules of game through all points, and changes their
+    """This  function runs the rules of game through all points, and changes their
    status accordingly.(in the same canvas)
    @Args:
    --
@ -61,7 +60,7 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:

    @returns:
    --
-    canvas of population after one step
+    None
    """
    current_canvas = np.array(canvas)
    next_gen_canvas = np.array(create_canvas(current_canvas.shape[0]))
@ -71,7 +70,10 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:
                pt, current_canvas[r - 1 : r + 2, c - 1 : c + 2]
            )

-    return next_gen_canvas.tolist()
+    current_canvas = next_gen_canvas
+    del next_gen_canvas  # cleaning memory as we move on.
+    return_canvas: list[list[bool]] = current_canvas.tolist()
+    return return_canvas


 def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:
@ -96,7 +98,7 @@ def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:
    if pt:
        if alive < 2:
            state = False
-        elif alive in {2, 3}:
+        elif alive == 2 or alive == 3:
            state = True
        elif alive > 3:
            state = False
--- a/ciphers/diffie_hellman.py
+++ b/ciphers/diffie_hellman.py
@ -10,13 +10,13 @@ primes = {
    5: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
+            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
@ -25,16 +25,16 @@ primes = {
    14: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
+            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            + "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
@ -43,21 +43,21 @@ primes = {
    15: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
+            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            + "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
@ -66,27 +66,27 @@ primes = {
    16: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
-            "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
-            "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
-            "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
-            "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
-            "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
-            "FFFFFFFFFFFFFFFF",
+            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+            + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+            + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+            + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+            + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+            + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
+            + "FFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
@ -95,33 +95,33 @@ primes = {
    17: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
-            "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
-            "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
-            "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
-            "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
-            "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
-            "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
-            "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
-            "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
-            "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
-            "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
-            "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
-            "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
-            "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
-            "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
-            "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
-            "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
-            "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
-            "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
-            "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
-            "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
-            "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
-            "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
-            "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
-            "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
-            "6DCC4024FFFFFFFFFFFFFFFF",
+            + "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
+            + "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
+            + "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
+            + "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
+            + "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
+            + "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
+            + "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
+            + "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
+            + "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
+            + "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
+            + "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
+            + "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
+            + "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
+            + "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
+            + "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+            + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
+            + "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
+            + "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
+            + "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
+            + "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
+            + "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+            + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
+            + "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
+            + "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
+            + "6DCC4024FFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
@ -130,48 +130,48 @@ primes = {
    18: {
        "prime": int(
            "FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
-            "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
-            "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
-            "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
-            "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
-            "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
-            "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
-            "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
-            "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
-            "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
-            "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
-            "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
-            "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
-            "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
-            "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
-            "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
-            "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
-            "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
-            "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
-            "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
-            "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
-            "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
-            "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
-            "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
-            "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
-            "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
-            "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
-            "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
-            "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
-            "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
-            "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
-            "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
-            "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
-            "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
-            "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
-            "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
-            "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
-            "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
-            "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
-            "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
-            "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
-            "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
-            "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
+            + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+            + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+            + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+            + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+            + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+            + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+            + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+            + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+            + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+            + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+            + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+            + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+            + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+            + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+            + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+            + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+            + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+            + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+            + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+            + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+            + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
+            + "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
+            + "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
+            + "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
+            + "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
+            + "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
+            + "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+            + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
+            + "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
+            + "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
+            + "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
+            + "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
+            + "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
+            + "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
+            + "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
+            + "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
+            + "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
+            + "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
+            + "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
+            + "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
+            + "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
+            + "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
            base=16,
        ),
        "generator": 2,
--- a/compression/burrows_wheeler.py
+++ b/compression/burrows_wheeler.py
@ -150,7 +150,7 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
        raise ValueError("The parameter idx_original_string must not be lower than 0.")
    if idx_original_string >= len(bwt_string):
        raise ValueError(
-            "The parameter idx_original_string must be lower than len(bwt_string)."
+            "The parameter idx_original_string must be lower than" " len(bwt_string)."
        )

    ordered_rotations = [""] * len(bwt_string)
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@ -58,19 +58,6 @@ def inorder(root: Node | None) -> list[int]:
    return [*inorder(root.left), root.data, *inorder(root.right)] if root else []


-def reverse_inorder(root: Node | None) -> list[int]:
-    """
-    Reverse in-order traversal visits right subtree, root node, left subtree.
-    >>> reverse_inorder(make_tree())
-    [3, 1, 5, 2, 4]
-    """
-    return (
-        [*reverse_inorder(root.right), root.data, *reverse_inorder(root.left)]
-        if root
-        else []
-    )
-
-
 def height(root: Node | None) -> int:
    """
    Recursive function for calculating the height of the binary tree.
@ -174,12 +161,15 @@ def zigzag(root: Node | None) -> Sequence[Node | None] | list[Any]:


 def main() -> None:  # Main function for testing.
-    # Create binary tree.
+    """
+    Create binary tree.
+    """
    root = make_tree()
+    """
+    All Traversals of the binary are as follows:
+    """

-    # All Traversals of the binary are as follows:
    print(f"In-order Traversal: {inorder(root)}")
-    print(f"Reverse In-order Traversal: {reverse_inorder(root)}")
    print(f"Pre-order Traversal: {preorder(root)}")
    print(f"Post-order Traversal: {postorder(root)}", "\n")

--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@ -152,7 +152,7 @@ class RedBlackTree:
                    self.grandparent.color = 1
                    self.grandparent._insert_repair()

-    def remove(self, label: int) -> RedBlackTree:  # noqa: PLR0912
+    def remove(self, label: int) -> RedBlackTree:
        """Remove label from this tree."""
        if self.label == label:
            if self.left and self.right:
--- a/data_structures/binary_tree/segment_tree.py
+++ b/data_structures/binary_tree/segment_tree.py
@ -7,7 +7,6 @@ class SegmentTree:
        self.st = [0] * (
            4 * self.N
        )  # approximate the overall size of segment tree with array N
-        if self.N:
        self.build(1, 0, self.N - 1)

    def left(self, idx):
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@ -54,7 +54,7 @@ class Deque:
            the current node of the iteration.
        """

-        __slots__ = ("_cur",)
+        __slots__ = "_cur"

        def __init__(self, cur: Deque._Node | None) -> None:
            self._cur = cur
--- a/data_structures/queue/queue_by_list.py
+++ b/data_structures/queue/queue_by_list.py
@ -1,141 +0,0 @@
-"""Queue represented by a Python list"""
-
-from collections.abc import Iterable
-from typing import Generic, TypeVar
-
-_T = TypeVar("_T")
-
-
-class QueueByList(Generic[_T]):
-    def __init__(self, iterable: Iterable[_T] | None = None) -> None:
-        """
-        >>> QueueByList()
-        Queue(())
-        >>> QueueByList([10, 20, 30])
-        Queue((10, 20, 30))
-        >>> QueueByList((i**2 for i in range(1, 4)))
-        Queue((1, 4, 9))
-        """
-        self.entries: list[_T] = list(iterable or [])
-
-    def __len__(self) -> int:
-        """
-        >>> len(QueueByList())
-        0
-        >>> from string import ascii_lowercase
-        >>> len(QueueByList(ascii_lowercase))
-        26
-        >>> queue = QueueByList()
-        >>> for i in range(1, 11):
-        ...     queue.put(i)
-        >>> len(queue)
-        10
-        >>> for i in range(2):
-        ...   queue.get()
-        1
-        2
-        >>> len(queue)
-        8
-        """
-
-        return len(self.entries)
-
-    def __repr__(self) -> str:
-        """
-        >>> queue = QueueByList()
-        >>> queue
-        Queue(())
-        >>> str(queue)
-        'Queue(())'
-        >>> queue.put(10)
-        >>> queue
-        Queue((10,))
-        >>> queue.put(20)
-        >>> queue.put(30)
-        >>> queue
-        Queue((10, 20, 30))
-        """
-
-        return f"Queue({tuple(self.entries)})"
-
-    def put(self, item: _T) -> None:
-        """Put `item` to the Queue
-
-        >>> queue = QueueByList()
-        >>> queue.put(10)
-        >>> queue.put(20)
-        >>> len(queue)
-        2
-        >>> queue
-        Queue((10, 20))
-        """
-
-        self.entries.append(item)
-
-    def get(self) -> _T:
-        """
-        Get `item` from the Queue
-
-        >>> queue = QueueByList((10, 20, 30))
-        >>> queue.get()
-        10
-        >>> queue.put(40)
-        >>> queue.get()
-        20
-        >>> queue.get()
-        30
-        >>> len(queue)
-        1
-        >>> queue.get()
-        40
-        >>> queue.get()
-        Traceback (most recent call last):
-            ...
-        IndexError: Queue is empty
-        """
-
-        if not self.entries:
-            raise IndexError("Queue is empty")
-        return self.entries.pop(0)
-
-    def rotate(self, rotation: int) -> None:
-        """Rotate the items of the Queue `rotation` times
-
-        >>> queue = QueueByList([10, 20, 30, 40])
-        >>> queue
-        Queue((10, 20, 30, 40))
-        >>> queue.rotate(1)
-        >>> queue
-        Queue((20, 30, 40, 10))
-        >>> queue.rotate(2)
-        >>> queue
-        Queue((40, 10, 20, 30))
-        """
-
-        put = self.entries.append
-        get = self.entries.pop
-
-        for _ in range(rotation):
-            put(get(0))
-
-    def get_front(self) -> _T:
-        """Get the front item from the Queue
-
-        >>> queue = QueueByList((10, 20, 30))
-        >>> queue.get_front()
-        10
-        >>> queue
-        Queue((10, 20, 30))
-        >>> queue.get()
-        10
-        >>> queue.get_front()
-        20
-        """
-
-        return self.entries[0]
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-
-    testmod()
--- a/data_structures/queue/queue_on_list.py
+++ b/data_structures/queue/queue_on_list.py
@ -0,0 +1,52 @@
+"""Queue represented by a Python list"""
+
+
+class Queue:
+    def __init__(self):
+        self.entries = []
+        self.length = 0
+        self.front = 0
+
+    def __str__(self):
+        printed = "<" + str(self.entries)[1:-1] + ">"
+        return printed
+
+    """Enqueues {@code item}
+    @param item
+        item to enqueue"""
+
+    def put(self, item):
+        self.entries.append(item)
+        self.length = self.length + 1
+
+    """Dequeues {@code item}
+    @requirement: |self.length| > 0
+    @return dequeued
+        item that was dequeued"""
+
+    def get(self):
+        self.length = self.length - 1
+        dequeued = self.entries[self.front]
+        # self.front-=1
+        # self.entries = self.entries[self.front:]
+        self.entries = self.entries[1:]
+        return dequeued
+
+    """Rotates the queue {@code rotation} times
+    @param rotation
+        number of times to rotate queue"""
+
+    def rotate(self, rotation):
+        for _ in range(rotation):
+            self.put(self.get())
+
+    """Enqueues {@code item}
+    @return item at front of self.entries"""
+
+    def get_front(self):
+        return self.entries[0]
+
+    """Returns the length of this.entries"""
+
+    def size(self):
+        return self.length
--- a/data_structures/stacks/infix_to_postfix_conversion.py
+++ b/data_structures/stacks/infix_to_postfix_conversion.py
@ -4,26 +4,9 @@ https://en.wikipedia.org/wiki/Reverse_Polish_notation
 https://en.wikipedia.org/wiki/Shunting-yard_algorithm
 """

-from typing import Literal
-
 from .balanced_parentheses import balanced_parentheses
 from .stack import Stack

-PRECEDENCES: dict[str, int] = {
-    "+": 1,
-    "-": 1,
-    "*": 2,
-    "/": 2,
-    "^": 3,
-}
-ASSOCIATIVITIES: dict[str, Literal["LR", "RL"]] = {
-    "+": "LR",
-    "-": "LR",
-    "*": "LR",
-    "/": "LR",
-    "^": "RL",
-}
-

 def precedence(char: str) -> int:
    """
@ -31,15 +14,7 @@ def precedence(char: str) -> int:
    order of operation.
    https://en.wikipedia.org/wiki/Order_of_operations
    """
-    return PRECEDENCES.get(char, -1)
-
-
-def associativity(char: str) -> Literal["LR", "RL"]:
-    """
-    Return the associativity of the operator `char`.
-    https://en.wikipedia.org/wiki/Operator_associativity
-    """
-    return ASSOCIATIVITIES[char]
+    return {"+": 1, "-": 1, "*": 2, "/": 2, "^": 3}.get(char, -1)


 def infix_to_postfix(expression_str: str) -> str:
@ -60,8 +35,6 @@ def infix_to_postfix(expression_str: str) -> str:
    'a b c * + d e * f + g * +'
    >>> infix_to_postfix("x^y/(5*z)+2")
    'x y ^ 5 z * / 2 +'
-    >>> infix_to_postfix("2^3^2")
-    '2 3 2 ^ ^'
    """
    if not balanced_parentheses(expression_str):
        raise ValueError("Mismatched parentheses")
@ -77,26 +50,9 @@ def infix_to_postfix(expression_str: str) -> str:
                postfix.append(stack.pop())
            stack.pop()
        else:
-            while True:
-                if stack.is_empty():
-                    stack.push(char)
-                    break
-
-                char_precedence = precedence(char)
-                tos_precedence = precedence(stack.peek())
-
-                if char_precedence > tos_precedence:
-                    stack.push(char)
-                    break
-                if char_precedence < tos_precedence:
+            while not stack.is_empty() and precedence(char) <= precedence(stack.peek()):
                postfix.append(stack.pop())
-                    continue
-                # Precedences are equal
-                if associativity(char) == "RL":
            stack.push(char)
-                    break
-                postfix.append(stack.pop())
-
    while not stack.is_empty():
        postfix.append(stack.pop())
    return " ".join(postfix)
--- a/data_structures/trie/radix_tree.py
+++ b/data_structures/trie/radix_tree.py
@ -54,17 +54,10 @@ class RadixNode:
            word (str): word to insert

        >>> RadixNode("myprefix").insert("mystring")
-
-        >>> root = RadixNode()
-        >>> root.insert_many(['myprefix', 'myprefixA', 'myprefixAA'])
-        >>> root.print_tree()
-        - myprefix   (leaf)
-        -- A   (leaf)
-        --- A   (leaf)
        """
        # Case 1: If the word is the prefix of the node
        # Solution: We set the current node as leaf
-        if self.prefix == word and not self.is_leaf:
+        if self.prefix == word:
            self.is_leaf = True

        # Case 2: The node has no edges that have a prefix to the word
@ -163,7 +156,7 @@ class RadixNode:
                        del self.nodes[word[0]]
                        # We merge the current node with its only child
                        if len(self.nodes) == 1 and not self.is_leaf:
-                            merging_node = next(iter(self.nodes.values()))
+                            merging_node = list(self.nodes.values())[0]
                            self.is_leaf = merging_node.is_leaf
                            self.prefix += merging_node.prefix
                            self.nodes = merging_node.nodes
@ -172,7 +165,7 @@ class RadixNode:
                        incoming_node.is_leaf = False
                    # If there is 1 edge, we merge it with its child
                    else:
-                        merging_node = next(iter(incoming_node.nodes.values()))
+                        merging_node = list(incoming_node.nodes.values())[0]
                        incoming_node.is_leaf = merging_node.is_leaf
                        incoming_node.prefix += merging_node.prefix
                        incoming_node.nodes = merging_node.nodes
--- a/digital_image_processing/dithering/burkes.py
+++ b/digital_image_processing/dithering/burkes.py
@ -39,18 +39,9 @@ class Burkes:
    def get_greyscale(cls, blue: int, green: int, red: int) -> float:
        """
        >>> Burkes.get_greyscale(3, 4, 5)
-        4.185
-        >>> Burkes.get_greyscale(0, 0, 0)
-        0.0
-        >>> Burkes.get_greyscale(255, 255, 255)
-        255.0
+        3.753
        """
-        """
-        Formula from https://en.wikipedia.org/wiki/HSL_and_HSV
-        cf Lightness section, and Fig 13c.
-        We use the first of four possible.
-        """
-        return 0.114 * blue + 0.587 * green + 0.299 * red
+        return 0.114 * blue + 0.587 * green + 0.2126 * red

    def process(self) -> None:
        for y in range(self.height):
@ -58,10 +49,10 @@ class Burkes:
                greyscale = int(self.get_greyscale(*self.input_img[y][x]))
                if self.threshold > greyscale + self.error_table[y][x]:
                    self.output_img[y][x] = (0, 0, 0)
-                    current_error = greyscale + self.error_table[y][x]
+                    current_error = greyscale + self.error_table[x][y]
                else:
                    self.output_img[y][x] = (255, 255, 255)
-                    current_error = greyscale + self.error_table[y][x] - 255
+                    current_error = greyscale + self.error_table[x][y] - 255
                """
                Burkes error propagation (`*` is current pixel):

--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@ -266,7 +266,7 @@ def convex_hull_bf(points: list[Point]) -> list[Point]:
            points_left_of_ij = points_right_of_ij = False
            ij_part_of_convex_hull = True
            for k in range(n):
-                if k not in {i, j}:
+                if k != i and k != j:
                    det_k = _det(points[i], points[j], points[k])

                    if det_k > 0:
--- a/divide_and_conquer/max_subarray.py
+++ b/divide_and_conquer/max_subarray.py
@ -1,112 +0,0 @@
-"""
-The maximum subarray problem is the task of finding the continuous subarray that has the
-maximum sum within a given array of numbers. For example, given the array
-[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
-[4, -1, 2, 1], which has a sum of 6.
-
-This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
-"""
-from __future__ import annotations
-
-import time
-from collections.abc import Sequence
-from random import randint
-
-from matplotlib import pyplot as plt
-
-
-def max_subarray(
-    arr: Sequence[float], low: int, high: int
-) -> tuple[int | None, int | None, float]:
-    """
-    Solves the maximum subarray problem using divide and conquer.
-    :param arr:     the given array of numbers
-    :param low:     the start index
-    :param high:    the end index
-    :return:        the start index of the maximum subarray, the end index of the
-                    maximum subarray, and the maximum subarray sum
-
-    >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
-    >>> max_subarray(nums, 0, len(nums) - 1)
-    (3, 6, 6)
-    >>> nums = [2, 8, 9]
-    >>> max_subarray(nums, 0, len(nums) - 1)
-    (0, 2, 19)
-    >>> nums = [0, 0]
-    >>> max_subarray(nums, 0, len(nums) - 1)
-    (0, 0, 0)
-    >>> nums = [-1.0, 0.0, 1.0]
-    >>> max_subarray(nums, 0, len(nums) - 1)
-    (2, 2, 1.0)
-    >>> nums = [-2, -3, -1, -4, -6]
-    >>> max_subarray(nums, 0, len(nums) - 1)
-    (2, 2, -1)
-    >>> max_subarray([], 0, 0)
-    (None, None, 0)
-    """
-    if not arr:
-        return None, None, 0
-    if low == high:
-        return low, high, arr[low]
-
-    mid = (low + high) // 2
-    left_low, left_high, left_sum = max_subarray(arr, low, mid)
-    right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
-    cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
-    if left_sum >= right_sum and left_sum >= cross_sum:
-        return left_low, left_high, left_sum
-    elif right_sum >= left_sum and right_sum >= cross_sum:
-        return right_low, right_high, right_sum
-    return cross_left, cross_right, cross_sum
-
-
-def max_cross_sum(
-    arr: Sequence[float], low: int, mid: int, high: int
-) -> tuple[int, int, float]:
-    left_sum, max_left = float("-inf"), -1
-    right_sum, max_right = float("-inf"), -1
-
-    summ: int | float = 0
-    for i in range(mid, low - 1, -1):
-        summ += arr[i]
-        if summ > left_sum:
-            left_sum = summ
-            max_left = i
-
-    summ = 0
-    for i in range(mid + 1, high + 1):
-        summ += arr[i]
-        if summ > right_sum:
-            right_sum = summ
-            max_right = i
-
-    return max_left, max_right, (left_sum + right_sum)
-
-
-def time_max_subarray(input_size: int) -> float:
-    arr = [randint(1, input_size) for _ in range(input_size)]
-    start = time.time()
-    max_subarray(arr, 0, input_size - 1)
-    end = time.time()
-    return end - start
-
-
-def plot_runtimes() -> None:
-    input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
-    runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
-    print("No of Inputs\t\tTime Taken")
-    for input_size, runtime in zip(input_sizes, runtimes):
-        print(input_size, "\t\t", runtime)
-    plt.plot(input_sizes, runtimes)
-    plt.xlabel("Number of Inputs")
-    plt.ylabel("Time taken in seconds")
-    plt.show()
-
-
-if __name__ == "__main__":
-    """
-    A random simulation of this algorithm.
-    """
-    from doctest import testmod
-
-    testmod()
--- a/divide_and_conquer/max_subarray_sum.py
+++ b/divide_and_conquer/max_subarray_sum.py
@ -0,0 +1,78 @@
+"""
+Given a array of length n, max_subarray_sum() finds
+the maximum of sum of contiguous sub-array using divide and conquer method.
+
+Time complexity : O(n log n)
+
+Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION
+(section : 4, sub-section : 4.1, page : 70)
+
+"""
+
+
+def max_sum_from_start(array):
+    """This function finds the maximum contiguous sum of array from 0 index
+
+    Parameters :
+    array (list[int]) : given array
+
+    Returns :
+    max_sum (int) : maximum contiguous sum of array from 0 index
+
+    """
+    array_sum = 0
+    max_sum = float("-inf")
+    for num in array:
+        array_sum += num
+        if array_sum > max_sum:
+            max_sum = array_sum
+    return max_sum
+
+
+def max_cross_array_sum(array, left, mid, right):
+    """This function finds the maximum contiguous sum of left and right arrays
+
+    Parameters :
+    array, left, mid, right (list[int], int, int, int)
+
+    Returns :
+    (int) :  maximum of sum of contiguous sum of left and right arrays
+
+    """
+
+    max_sum_of_left = max_sum_from_start(array[left : mid + 1][::-1])
+    max_sum_of_right = max_sum_from_start(array[mid + 1 : right + 1])
+    return max_sum_of_left + max_sum_of_right
+
+
+def max_subarray_sum(array, left, right):
+    """Maximum contiguous sub-array sum, using divide and conquer method
+
+    Parameters :
+    array, left, right (list[int], int, int) :
+    given array, current left index and current right index
+
+    Returns :
+    int :  maximum of sum of contiguous sub-array
+
+    """
+
+    # base case: array has only one element
+    if left == right:
+        return array[right]
+
+    # Recursion
+    mid = (left + right) // 2
+    left_half_sum = max_subarray_sum(array, left, mid)
+    right_half_sum = max_subarray_sum(array, mid + 1, right)
+    cross_sum = max_cross_array_sum(array, left, mid, right)
+    return max(left_half_sum, right_half_sum, cross_sum)
+
+
+if __name__ == "__main__":
+    array = [-2, -5, 6, -2, -3, 1, 5, -6]
+    array_length = len(array)
+    print(
+        "Maximum sum of contiguous subarray:",
+        max_subarray_sum(array, 0, array_length - 1),
+    )
--- a/dynamic_programming/max_sub_array.py
+++ b/dynamic_programming/max_sub_array.py
@ -0,0 +1,93 @@
+"""
+author : Mayank Kumar Jha (mk9440)
+"""
+from __future__ import annotations
+
+
+def find_max_sub_array(a, low, high):
+    if low == high:
+        return low, high, a[low]
+    else:
+        mid = (low + high) // 2
+        left_low, left_high, left_sum = find_max_sub_array(a, low, mid)
+        right_low, right_high, right_sum = find_max_sub_array(a, mid + 1, high)
+        cross_left, cross_right, cross_sum = find_max_cross_sum(a, low, mid, high)
+        if left_sum >= right_sum and left_sum >= cross_sum:
+            return left_low, left_high, left_sum
+        elif right_sum >= left_sum and right_sum >= cross_sum:
+            return right_low, right_high, right_sum
+        else:
+            return cross_left, cross_right, cross_sum
+
+
+def find_max_cross_sum(a, low, mid, high):
+    left_sum, max_left = -999999999, -1
+    right_sum, max_right = -999999999, -1
+    summ = 0
+    for i in range(mid, low - 1, -1):
+        summ += a[i]
+        if summ > left_sum:
+            left_sum = summ
+            max_left = i
+    summ = 0
+    for i in range(mid + 1, high + 1):
+        summ += a[i]
+        if summ > right_sum:
+            right_sum = summ
+            max_right = i
+    return max_left, max_right, (left_sum + right_sum)
+
+
+def max_sub_array(nums: list[int]) -> int:
+    """
+    Finds the contiguous subarray which has the largest sum and return its sum.
+
+    >>> max_sub_array([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+    6
+
+    An empty (sub)array has sum 0.
+    >>> max_sub_array([])
+    0
+
+    If all elements are negative, the largest subarray would be the empty array,
+    having the sum 0.
+    >>> max_sub_array([-1, -2, -3])
+    0
+    >>> max_sub_array([5, -2, -3])
+    5
+    >>> max_sub_array([31, -41, 59, 26, -53, 58, 97, -93, -23, 84])
+    187
+    """
+    best = 0
+    current = 0
+    for i in nums:
+        current += i
+        current = max(current, 0)
+        best = max(best, current)
+    return best
+
+
+if __name__ == "__main__":
+    """
+    A random simulation of this algorithm.
+    """
+    import time
+    from random import randint
+
+    from matplotlib import pyplot as plt
+
+    inputs = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+    tim = []
+    for i in inputs:
+        li = [randint(1, i) for j in range(i)]
+        strt = time.time()
+        (find_max_sub_array(li, 0, len(li) - 1))
+        end = time.time()
+        tim.append(end - strt)
+    print("No of Inputs       Time Taken")
+    for i in range(len(inputs)):
+        print(inputs[i], "\t\t", tim[i])
+    plt.plot(inputs, tim)
+    plt.xlabel("Number of Inputs")
+    plt.ylabel("Time taken in seconds ")
+    plt.show()
--- a/dynamic_programming/max_subarray_sum.py
+++ b/dynamic_programming/max_subarray_sum.py
@ -1,60 +0,0 @@
-"""
-The maximum subarray sum problem is the task of finding the maximum sum that can be
-obtained from a contiguous subarray within a given array of numbers. For example, given
-the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
-is [4, -1, 2, 1], so the maximum subarray sum is 6.
-
-Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
-subarray sum problem in O(n) time and O(1) space.
-
-Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
-"""
-from collections.abc import Sequence
-
-
-def max_subarray_sum(
-    arr: Sequence[float], allow_empty_subarrays: bool = False
-) -> float:
-    """
-    Solves the maximum subarray sum problem using Kadane's algorithm.
-    :param arr: the given array of numbers
-    :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
-
-    >>> max_subarray_sum([2, 8, 9])
-    19
-    >>> max_subarray_sum([0, 0])
-    0
-    >>> max_subarray_sum([-1.0, 0.0, 1.0])
-    1.0
-    >>> max_subarray_sum([1, 2, 3, 4, -2])
-    10
-    >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
-    6
-    >>> max_subarray_sum([2, 3, -9, 8, -2])
-    8
-    >>> max_subarray_sum([-2, -3, -1, -4, -6])
-    -1
-    >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
-    0
-    >>> max_subarray_sum([])
-    0
-    """
-    if not arr:
-        return 0
-
-    max_sum = 0 if allow_empty_subarrays else float("-inf")
-    curr_sum = 0.0
-    for num in arr:
-        curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
-        max_sum = max(max_sum, curr_sum)
-
-    return max_sum
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-
-    testmod()
-
-    nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
-    print(f"{max_subarray_sum(nums) = }")
--- a/dynamic_programming/max_sum_contiguous_subsequence.py
+++ b/dynamic_programming/max_sum_contiguous_subsequence.py
@ -0,0 +1,20 @@
+def max_subarray_sum(nums: list) -> int:
+    """
+    >>> max_subarray_sum([6 , 9, -1, 3, -7, -5, 10])
+    17
+    """
+    if not nums:
+        return 0
+    n = len(nums)
+
+    res, s, s_pre = nums[0], nums[0], nums[0]
+    for i in range(1, n):
+        s = max(nums[i], s_pre + nums[i])
+        s_pre = s
+        res = max(res, s)
+    return res
+
+
+if __name__ == "__main__":
+    nums = [6, 9, -1, 3, -7, -5, 10]
+    print(max_subarray_sum(nums))
--- a/fractals/sierpinski_triangle.py
+++ b/fractals/sierpinski_triangle.py
@ -82,4 +82,3 @@ if __name__ == "__main__":

    vertices = [(-175, -125), (0, 175), (175, -125)]  # vertices of triangle
    triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))
-    turtle.Screen().exitonclick()
--- a/graphs/directed_and_undirected_(weighted)_graph.py
+++ b/graphs/directed_and_undirected_(weighted)_graph.py
@ -39,7 +39,7 @@ class DirectedGraph:
        stack = []
        visited = []
        if s == -2:
-            s = next(iter(self.graph))
+            s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        ss = s
@ -87,7 +87,7 @@ class DirectedGraph:
        d = deque()
        visited = []
        if s == -2:
-            s = next(iter(self.graph))
+            s = list(self.graph)[0]
        d.append(s)
        visited.append(s)
        while d:
@ -114,7 +114,7 @@ class DirectedGraph:
        stack = []
        visited = []
        if s == -2:
-            s = next(iter(self.graph))
+            s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        ss = s
@ -146,7 +146,7 @@ class DirectedGraph:
    def cycle_nodes(self):
        stack = []
        visited = []
-        s = next(iter(self.graph))
+        s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        parent = -2
@ -199,7 +199,7 @@ class DirectedGraph:
    def has_cycle(self):
        stack = []
        visited = []
-        s = next(iter(self.graph))
+        s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        parent = -2
@ -305,7 +305,7 @@ class Graph:
        stack = []
        visited = []
        if s == -2:
-            s = next(iter(self.graph))
+            s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        ss = s
@ -353,7 +353,7 @@ class Graph:
        d = deque()
        visited = []
        if s == -2:
-            s = next(iter(self.graph))
+            s = list(self.graph)[0]
        d.append(s)
        visited.append(s)
        while d:
@ -371,7 +371,7 @@ class Graph:
    def cycle_nodes(self):
        stack = []
        visited = []
-        s = next(iter(self.graph))
+        s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        parent = -2
@ -424,7 +424,7 @@ class Graph:
    def has_cycle(self):
        stack = []
        visited = []
-        s = next(iter(self.graph))
+        s = list(self.graph)[0]
        stack.append(s)
        visited.append(s)
        parent = -2
--- a/graphs/edmonds_karp_multiple_source_and_sink.py
+++ b/graphs/edmonds_karp_multiple_source_and_sink.py
@ -113,7 +113,7 @@ class PushRelabelExecutor(MaximumFlowAlgorithmExecutor):
        vertices_list = [
            i
            for i in range(self.verticies_count)
-            if i not in {self.source_index, self.sink_index}
+            if i != self.source_index and i != self.sink_index
        ]

        # move through list
--- a/graphs/eulerian_path_and_circuit_for_undirected_graph.py
+++ b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
@ -20,7 +20,7 @@ def check_circuit_or_path(graph, max_node):
    odd_degree_nodes = 0
    odd_node = -1
    for i in range(max_node):
-        if i not in graph:
+        if i not in graph.keys():
            continue
        if len(graph[i]) % 2 == 1:
            odd_degree_nodes += 1
--- a/machine_learning/polymonial_regression.py
+++ b/machine_learning/polymonial_regression.py
@ -0,0 +1,44 @@
+import pandas as pd
+from matplotlib import pyplot as plt
+from sklearn.linear_model import LinearRegression
+
+# Splitting the dataset into the Training set and Test set
+from sklearn.model_selection import train_test_split
+
+# Fitting Polynomial Regression to the dataset
+from sklearn.preprocessing import PolynomialFeatures
+
+# Importing the dataset
+dataset = pd.read_csv(
+    "https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/"
+    "position_salaries.csv"
+)
+X = dataset.iloc[:, 1:2].values
+y = dataset.iloc[:, 2].values
+
+
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
+
+
+poly_reg = PolynomialFeatures(degree=4)
+X_poly = poly_reg.fit_transform(X)
+pol_reg = LinearRegression()
+pol_reg.fit(X_poly, y)
+
+
+# Visualizing the Polymonial Regression results
+def viz_polymonial():
+    plt.scatter(X, y, color="red")
+    plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color="blue")
+    plt.title("Truth or Bluff (Linear Regression)")
+    plt.xlabel("Position level")
+    plt.ylabel("Salary")
+    plt.show()
+
+
+if __name__ == "__main__":
+    viz_polymonial()
+
+    # Predicting a new result with Polymonial Regression
+    pol_reg.predict(poly_reg.fit_transform([[5.5]]))
+    # output should be 132148.43750003
--- a/machine_learning/polynomial_regression.py
+++ b/machine_learning/polynomial_regression.py
@ -1,213 +0,0 @@
-"""
-Polynomial regression is a type of regression analysis that models the relationship
-between a predictor x and the response y as an mth-degree polynomial:
-
-y = β₀ + β₁x + β₂x² + ... + βₘxᵐ + ε
-
-By treating x, x², ..., xᵐ as distinct variables, we see that polynomial regression is a
-special case of multiple linear regression. Therefore, we can use ordinary least squares
-(OLS) estimation to estimate the vector of model parameters β = (β₀, β₁, β₂, ..., βₘ)
-for polynomial regression:
-
-β = (XᵀX)⁻¹Xᵀy = X⁺y
-
-where X is the design matrix, y is the response vector, and X⁺ denotes the Moore–Penrose
-pseudoinverse of X. In the case of polynomial regression, the design matrix is
-
-    |1  x₁  x₁² ⋯ x₁ᵐ|
-X = |1  x₂  x₂² ⋯ x₂ᵐ|
-    |⋮  ⋮   ⋮   ⋱ ⋮  |
-    |1  xₙ  xₙ² ⋯  xₙᵐ|
-
-In OLS estimation, inverting XᵀX to compute X⁺ can be very numerically unstable. This
-implementation sidesteps this need to invert XᵀX by computing X⁺ using singular value
-decomposition (SVD):
-
-β = VΣ⁺Uᵀy
-
-where UΣVᵀ is an SVD of X.
-
-References:
-    - https://en.wikipedia.org/wiki/Polynomial_regression
-    - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
-    - https://en.wikipedia.org/wiki/Numerical_methods_for_linear_least_squares
-    - https://en.wikipedia.org/wiki/Singular_value_decomposition
-"""
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-
-class PolynomialRegression:
-    __slots__ = "degree", "params"
-
-    def __init__(self, degree: int) -> None:
-        """
-        @raises ValueError: if the polynomial degree is negative
-        """
-        if degree < 0:
-            raise ValueError("Polynomial degree must be non-negative")
-
-        self.degree = degree
-        self.params = None
-
-    @staticmethod
-    def _design_matrix(data: np.ndarray, degree: int) -> np.ndarray:
-        """
-        Constructs a polynomial regression design matrix for the given input data. For
-        input data x = (x₁, x₂, ..., xₙ) and polynomial degree m, the design matrix is
-        the Vandermonde matrix
-
-            |1  x₁  x₁² ⋯ x₁ᵐ|
-        X = |1  x₂  x₂² ⋯ x₂ᵐ|
-            |⋮  ⋮   ⋮   ⋱ ⋮  |
-            |1  xₙ  xₙ² ⋯  xₙᵐ|
-
-        Reference: https://en.wikipedia.org/wiki/Vandermonde_matrix
-
-        @param data:    the input predictor values x, either for model fitting or for
-                        prediction
-        @param degree:  the polynomial degree m
-        @returns:       the Vandermonde matrix X (see above)
-        @raises ValueError: if input data is not N x 1
-
-        >>> x = np.array([0, 1, 2])
-        >>> PolynomialRegression._design_matrix(x, degree=0)
-        array([[1],
-               [1],
-               [1]])
-        >>> PolynomialRegression._design_matrix(x, degree=1)
-        array([[1, 0],
-               [1, 1],
-               [1, 2]])
-        >>> PolynomialRegression._design_matrix(x, degree=2)
-        array([[1, 0, 0],
-               [1, 1, 1],
-               [1, 2, 4]])
-        >>> PolynomialRegression._design_matrix(x, degree=3)
-        array([[1, 0, 0, 0],
-               [1, 1, 1, 1],
-               [1, 2, 4, 8]])
-        >>> PolynomialRegression._design_matrix(np.array([[0, 0], [0 , 0]]), degree=3)
-        Traceback (most recent call last):
-        ...
-        ValueError: Data must have dimensions N x 1
-        """
-        rows, *remaining = data.shape
-        if remaining:
-            raise ValueError("Data must have dimensions N x 1")
-
-        return np.vander(data, N=degree + 1, increasing=True)
-
-    def fit(self, x_train: np.ndarray, y_train: np.ndarray) -> None:
-        """
-        Computes the polynomial regression model parameters using ordinary least squares
-        (OLS) estimation:
-
-        β = (XᵀX)⁻¹Xᵀy = X⁺y
-
-        where X⁺ denotes the Moore–Penrose pseudoinverse of the design matrix X. This
-        function computes X⁺ using singular value decomposition (SVD).
-
-        References:
-            - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
-            - https://en.wikipedia.org/wiki/Singular_value_decomposition
-            - https://en.wikipedia.org/wiki/Multicollinearity
-
-        @param x_train: the predictor values x for model fitting
-        @param y_train: the response values y for model fitting
-        @raises ArithmeticError:    if X isn't full rank, then XᵀX is singular and β
-                                    doesn't exist
-
-        >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
-        >>> y = x**3 - 2 * x**2 + 3 * x - 5
-        >>> poly_reg = PolynomialRegression(degree=3)
-        >>> poly_reg.fit(x, y)
-        >>> poly_reg.params
-        array([-5.,  3., -2.,  1.])
-        >>> poly_reg = PolynomialRegression(degree=20)
-        >>> poly_reg.fit(x, y)
-        Traceback (most recent call last):
-        ...
-        ArithmeticError: Design matrix is not full rank, can't compute coefficients
-
-        Make sure errors don't grow too large:
-        >>> coefs = np.array([-250, 50, -2, 36, 20, -12, 10, 2, -1, -15, 1])
-        >>> y = PolynomialRegression._design_matrix(x, len(coefs) - 1) @ coefs
-        >>> poly_reg = PolynomialRegression(degree=len(coefs) - 1)
-        >>> poly_reg.fit(x, y)
-        >>> np.allclose(poly_reg.params, coefs, atol=10e-3)
-        True
-        """
-        X = PolynomialRegression._design_matrix(x_train, self.degree)  # noqa: N806
-        _, cols = X.shape
-        if np.linalg.matrix_rank(X) < cols:
-            raise ArithmeticError(
-                "Design matrix is not full rank, can't compute coefficients"
-            )
-
-        # np.linalg.pinv() computes the Moore–Penrose pseudoinverse using SVD
-        self.params = np.linalg.pinv(X) @ y_train
-
-    def predict(self, data: np.ndarray) -> np.ndarray:
-        """
-        Computes the predicted response values y for the given input data by
-        constructing the design matrix X and evaluating y = Xβ.
-
-        @param data:    the predictor values x for prediction
-        @returns:       the predicted response values y = Xβ
-        @raises ArithmeticError:    if this function is called before the model
-                                    parameters are fit
-
-        >>> x = np.array([0, 1, 2, 3, 4])
-        >>> y = x**3 - 2 * x**2 + 3 * x - 5
-        >>> poly_reg = PolynomialRegression(degree=3)
-        >>> poly_reg.fit(x, y)
-        >>> poly_reg.predict(np.array([-1]))
-        array([-11.])
-        >>> poly_reg.predict(np.array([-2]))
-        array([-27.])
-        >>> poly_reg.predict(np.array([6]))
-        array([157.])
-        >>> PolynomialRegression(degree=3).predict(x)
-        Traceback (most recent call last):
-        ...
-        ArithmeticError: Predictor hasn't been fit yet
-        """
-        if self.params is None:
-            raise ArithmeticError("Predictor hasn't been fit yet")
-
-        return PolynomialRegression._design_matrix(data, self.degree) @ self.params
-
-
-def main() -> None:
-    """
-    Fit a polynomial regression model to predict fuel efficiency using seaborn's mpg
-    dataset
-
-    >>> pass    # Placeholder, function is only for demo purposes
-    """
-    import seaborn as sns
-
-    mpg_data = sns.load_dataset("mpg")
-
-    poly_reg = PolynomialRegression(degree=2)
-    poly_reg.fit(mpg_data.weight, mpg_data.mpg)
-
-    weight_sorted = np.sort(mpg_data.weight)
-    predictions = poly_reg.predict(weight_sorted)
-
-    plt.scatter(mpg_data.weight, mpg_data.mpg, color="gray", alpha=0.5)
-    plt.plot(weight_sorted, predictions, color="red", linewidth=3)
-    plt.title("Predicting Fuel Efficiency Using Polynomial Regression")
-    plt.xlabel("Weight (lbs)")
-    plt.ylabel("Fuel Efficiency (mpg)")
-    plt.show()
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
-
-    main()
--- a/maths/collatz_sequence.py
+++ b/maths/collatz_sequence.py
@ -57,7 +57,7 @@ def collatz_sequence(n: int) -> Generator[int, None, None]:


 def main():
-    n = int(input("Your number: "))
+    n = 43
    sequence = tuple(collatz_sequence(n))
    print(sequence)
    print(f"Collatz sequence from {n} took {len(sequence)} steps.")
--- a/maths/factorial.py
+++ b/maths/factorial.py
@ -55,7 +55,7 @@ def factorial_recursive(n: int) -> int:
        raise ValueError("factorial() only accepts integral values")
    if n < 0:
        raise ValueError("factorial() not defined for negative values")
-    return 1 if n in {0, 1} else n * factorial(n - 1)
+    return 1 if n == 0 or n == 1 else n * factorial(n - 1)


 if __name__ == "__main__":
--- a/maths/inter_quartile_range.py
+++ b/maths/inter_quartile_range.py
@ -30,23 +30,22 @@ def find_median(x: np.array) -> float:
    return float((x[length // 2] + x[(length // 2) - 1]) / 2)


-def interquartile_range(x: np.array) -> float:
+def inter_quartile_range(x: np.array) -> float:
    """
    This is the implementation of inter_quartile
    range for a list of numeric.
    :param x: The list of data point
    :return: Inter_quartile range

-    >>> interquartile_range(x=np.array([4,1,2,3,2]))
+    >>> inter_quartile_range(x=np.array([4,1,2,3,2]))
    2.0

-
-    >>> interquartile_range(x=np.array([25,32,49,21,37,43,27,45,31]))
+    >>> inter_quartile_range(x=np.array([25,32,49,21,37,43,27,45,31]))
    18.0
    """
    length = len(x)
    if length == 0:
-        raise ValueError("The list is empty. Provide a non-empty list.")
+        raise ValueError
    x.sort()
    q1 = find_median(x[0 : length // 2])
    half_length = (length // 2) + 1 if length % 2 else length // 2
--- a/maths/kadanes.py
+++ b/maths/kadanes.py
@ -0,0 +1,63 @@
+"""
+Kadane's algorithm to get maximum subarray sum
+https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d
+https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+test_data: tuple = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], [])
+
+
+def negative_exist(arr: list) -> int:
+    """
+    >>> negative_exist([-2,-8,-9])
+    -2
+    >>> [negative_exist(arr) for arr in test_data]
+    [-2, 0, 0, 0, 0]
+    """
+    arr = arr or [0]
+    max_number = arr[0]
+    for i in arr:
+        if i >= 0:
+            return 0
+        elif max_number <= i:
+            max_number = i
+    return max_number
+
+
+def kadanes(arr: list) -> int:
+    """
+    If negative_exist() returns 0 than this function will execute
+    else it will return the value return by negative_exist function
+
+    For example: arr = [2, 3, -9, 8, -2]
+        Initially we set value of max_sum to 0 and max_till_element to 0 than when
+        max_sum is less than max_till particular element it will assign that value to
+        max_sum and when value of max_till_sum is less than 0 it will assign 0 to i
+        and after that whole process, return the max_sum
+    So the output for above arr is 8
+
+    >>> kadanes([2, 3, -9, 8, -2])
+    8
+    >>> [kadanes(arr) for arr in test_data]
+    [-2, 19, 1, 0, 0]
+    """
+    max_sum = negative_exist(arr)
+    if max_sum < 0:
+        return max_sum
+
+    max_sum = 0
+    max_till_element = 0
+
+    for i in arr:
+        max_till_element += i
+        max_sum = max(max_sum, max_till_element)
+        max_till_element = max(max_till_element, 0)
+    return max_sum
+
+
+if __name__ == "__main__":
+    try:
+        print("Enter integer values sepatated by spaces")
+        arr = [int(x) for x in input().split()]
+        print(f"Maximum subarray sum of {arr} is {kadanes(arr)}")
+    except ValueError:
+        print("Please enter integer values.")
--- a/maths/largest_subarray_sum.py
+++ b/maths/largest_subarray_sum.py
@ -0,0 +1,21 @@
+from sys import maxsize
+
+
+def max_sub_array_sum(a: list, size: int = 0):
+    """
+    >>> max_sub_array_sum([-13, -3, -25, -20, -3, -16, -23, -12, -5, -22, -15, -4, -7])
+    -3
+    """
+    size = size or len(a)
+    max_so_far = -maxsize - 1
+    max_ending_here = 0
+    for i in range(0, size):
+        max_ending_here = max_ending_here + a[i]
+        max_so_far = max(max_so_far, max_ending_here)
+        max_ending_here = max(max_ending_here, 0)
+    return max_so_far
+
+
+if __name__ == "__main__":
+    a = [-13, -3, -25, -20, 1, -16, -23, -12, -5, -22, -15, -4, -7]
+    print(("Maximum contiguous sum is", max_sub_array_sum(a, len(a))))
--- a/maths/primelib.py
+++ b/maths/primelib.py
@ -154,7 +154,7 @@ def prime_factorization(number):

    quotient = number

-    if number in {0, 1}:
+    if number == 0 or number == 1:
        ans.append(number)

    # if 'number' not prime then builds the prime factorization of 'number'
--- a/neural_network/input_data.py
+++ b/neural_network/input_data.py
@ -263,7 +263,9 @@ def _maybe_download(filename, work_directory, source_url):
    return filepath


-@deprecated(None, "Please use alternatives such as: tensorflow_datasets.load('mnist')")
+@deprecated(
+    None, "Please use alternatives such as:" " tensorflow_datasets.load('mnist')"
+)
 def read_data_sets(
    train_dir,
    fake_data=False,
--- a/other/davisb_putnamb_logemannb_loveland.py
+++ b/other/davisb_putnamb_logemannb_loveland.py
@ -253,7 +253,7 @@ def find_unit_clauses(
    unit_symbols = []
    for clause in clauses:
        if len(clause) == 1:
-            unit_symbols.append(next(iter(clause.literals.keys())))
+            unit_symbols.append(list(clause.literals.keys())[0])
        else:
            f_count, n_count = 0, 0
            for literal, value in clause.literals.items():
--- a/other/maximum_subarray.py
+++ b/other/maximum_subarray.py
@ -0,0 +1,32 @@
+from collections.abc import Sequence
+
+
+def max_subarray_sum(nums: Sequence[int]) -> int:
+    """Return the maximum possible sum amongst all non - empty subarrays.
+
+    Raises:
+      ValueError: when nums is empty.
+
+    >>> max_subarray_sum([1,2,3,4,-2])
+    10
+    >>> max_subarray_sum([-2,1,-3,4,-1,2,1,-5,4])
+    6
+    """
+    if not nums:
+        raise ValueError("Input sequence should not be empty")
+
+    curr_max = ans = nums[0]
+    nums_len = len(nums)
+
+    for i in range(1, nums_len):
+        num = nums[i]
+        curr_max = max(curr_max + num, num)
+        ans = max(curr_max, ans)
+
+    return ans
+
+
+if __name__ == "__main__":
+    n = int(input("Enter number of elements : ").strip())
+    array = list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
+    print(max_subarray_sum(array))
--- a/other/number_container_system.py
+++ b/other/number_container_system.py
@ -1,6 +1,6 @@
 """
 A number container system that uses binary search to delete and insert values into
-arrays with O(log n) write times and O(1) read times.
+arrays with O(n logn) write times and O(1) read times.

 This container system holds integers at indexes.

--- a/physics/altitude_pressure.py
+++ b/physics/altitude_pressure.py
@ -1,52 +0,0 @@
-"""
-Title : Calculate altitude using Pressure
-
-Description :
-    The below algorithm approximates the altitude using Barometric formula
-
-
-"""
-
-
-def get_altitude_at_pressure(pressure: float) -> float:
-    """
-    This method calculates the altitude from Pressure wrt to
-    Sea level pressure as reference .Pressure is in Pascals
-    https://en.wikipedia.org/wiki/Pressure_altitude
-    https://community.bosch-sensortec.com/t5/Question-and-answers/How-to-calculate-the-altitude-from-the-pressure-sensor-data/qaq-p/5702
-
-    H = 44330 * [1 - (P/p0)^(1/5.255) ]
-
-    Where :
-    H = altitude (m)
-    P = measured pressure
-    p0 = reference pressure at sea level 101325 Pa
-
-    Examples:
-    >>> get_altitude_at_pressure(pressure=100_000)
-    105.47836610778828
-    >>> get_altitude_at_pressure(pressure=101_325)
-    0.0
-    >>> get_altitude_at_pressure(pressure=80_000)
-    1855.873388064995
-    >>> get_altitude_at_pressure(pressure=201_325)
-    Traceback (most recent call last):
-      ...
-    ValueError: Value Higher than Pressure at Sea Level !
-    >>> get_altitude_at_pressure(pressure=-80_000)
-    Traceback (most recent call last):
-      ...
-    ValueError: Atmospheric Pressure can not be negative !
-    """
-
-    if pressure > 101325:
-        raise ValueError("Value Higher than Pressure at Sea Level !")
-    if pressure < 0:
-        raise ValueError("Atmospheric Pressure can not be negative !")
-    return 44_330 * (1 - (pressure / 101_325) ** (1 / 5.5255))
-
-
-if __name__ == "__main__":
-    import doctest
-
-    doctest.testmod()
--- a/physics/basic_orbital_capture.py
+++ b/physics/basic_orbital_capture.py
@ -1,178 +0,0 @@
-from math import pow, sqrt
-
-from scipy.constants import G, c, pi
-
-"""
-These two functions will return the radii of impact for a target object
-of mass M and radius R as well as it's effective cross sectional area σ(sigma).
-That is to say any projectile with velocity v passing within σ, will impact the
-target object with mass M. The derivation of which is given at the bottom
-of this file.
-
-The derivation shows that a projectile does not need to aim directly at the target
-body in order to hit it, as  R_capture>R_target. Astronomers refer to the effective
-cross section for capture as σ=π*R_capture**2.
-
-This algorithm does not account for an N-body problem.
-
-"""
-
-
-def capture_radii(
-    target_body_radius: float, target_body_mass: float, projectile_velocity: float
-) -> float:
-    """
-    Input Params:
-    -------------
-    target_body_radius: Radius of the central body SI units: meters | m
-    target_body_mass: Mass of the central body SI units: kilograms | kg
-    projectile_velocity: Velocity of object moving toward central body
-        SI units: meters/second | m/s
-    Returns:
-    --------
-    >>> capture_radii(6.957e8, 1.99e30, 25000.0)
-    17209590691.0
-    >>> capture_radii(-6.957e8, 1.99e30, 25000.0)
-    Traceback (most recent call last):
-        ...
-    ValueError: Radius cannot be less than 0
-    >>> capture_radii(6.957e8, -1.99e30, 25000.0)
-    Traceback (most recent call last):
-        ...
-    ValueError: Mass cannot be less than 0
-    >>> capture_radii(6.957e8, 1.99e30, c+1)
-    Traceback (most recent call last):
-        ...
-    ValueError: Cannot go beyond speed of light
-
-    Returned SI units:
-    ------------------
-    meters | m
-    """
-
-    if target_body_mass < 0:
-        raise ValueError("Mass cannot be less than 0")
-    if target_body_radius < 0:
-        raise ValueError("Radius cannot be less than 0")
-    if projectile_velocity > c:
-        raise ValueError("Cannot go beyond speed of light")
-
-    escape_velocity_squared = (2 * G * target_body_mass) / target_body_radius
-    capture_radius = target_body_radius * sqrt(
-        1 + escape_velocity_squared / pow(projectile_velocity, 2)
-    )
-    return round(capture_radius, 0)
-
-
-def capture_area(capture_radius: float) -> float:
-    """
-    Input Param:
-    ------------
-    capture_radius: The radius of orbital capture and impact for a central body of
-    mass M and a projectile moving towards it with velocity v
-        SI units: meters | m
-    Returns:
-    --------
-    >>> capture_area(17209590691)
-    9.304455331329126e+20
-    >>> capture_area(-1)
-    Traceback (most recent call last):
-        ...
-    ValueError: Cannot have a capture radius less than 0
-
-    Returned SI units:
-    ------------------
-    meters*meters | m**2
-    """
-
-    if capture_radius < 0:
-        raise ValueError("Cannot have a capture radius less than 0")
-    sigma = pi * pow(capture_radius, 2)
-    return round(sigma, 0)
-
-
-if __name__ == "__main__":
-    from doctest import testmod
-
-    testmod()
-
-"""
-Derivation:
-
-Let: Mt=target mass, Rt=target radius, v=projectile_velocity,
-     r_0=radius of projectile at instant 0 to CM of target
-     v_p=v at closest approach,
-     r_p=radius from projectile to target CM at closest approach,
-     R_capture= radius of impact for projectile with velocity v
-
-(1)At time=0  the projectile's energy falling from infinity| E=K+U=0.5*m*(v**2)+0
-
-    E_initial=0.5*m*(v**2)
-
-(2)at time=0 the angular momentum of the projectile relative to CM target|
-    L_initial=m*r_0*v*sin(Θ)->m*r_0*v*(R_capture/r_0)->m*v*R_capture
-
-    L_i=m*v*R_capture
-
-(3)The energy of the projectile at closest approach will be its kinetic energy
-   at closest approach plus gravitational potential energy(-(GMm)/R)|
-    E_p=K_p+U_p->E_p=0.5*m*(v_p**2)-(G*Mt*m)/r_p
-
-    E_p=0.0.5*m*(v_p**2)-(G*Mt*m)/r_p
-
-(4)The angular momentum of the projectile relative to the target at closest
-   approach will be L_p=m*r_p*v_p*sin(Θ), however relative to the target Θ=90°
-   sin(90°)=1|
-
-    L_p=m*r_p*v_p
-(5)Using conservation of angular momentum and energy, we can write a quadratic
-   equation that solves for r_p|
-
-   (a)
-    Ei=Ep-> 0.5*m*(v**2)=0.5*m*(v_p**2)-(G*Mt*m)/r_p-> v**2=v_p**2-(2*G*Mt)/r_p
-
-   (b)
-    Li=Lp-> m*v*R_capture=m*r_p*v_p-> v*R_capture=r_p*v_p-> v_p=(v*R_capture)/r_p
-
-   (c) b plugs int a|
-    v**2=((v*R_capture)/r_p)**2-(2*G*Mt)/r_p->
-
-    v**2-(v**2)*(R_c**2)/(r_p**2)+(2*G*Mt)/r_p=0->
-
-    (v**2)*(r_p**2)+2*G*Mt*r_p-(v**2)*(R_c**2)=0
-
-   (d) Using the quadratic formula, we'll solve for r_p then rearrange to solve to
-       R_capture
-
-    r_p=(-2*G*Mt ± sqrt(4*G^2*Mt^2+ 4(v^4*R_c^2)))/(2*v^2)->
-
-    r_p=(-G*Mt ± sqrt(G^2*Mt+v^4*R_c^2))/v^2->
-
-    r_p<0 is something we can ignore, as it has no physical meaning for our purposes.->
-
-    r_p=(-G*Mt)/v^2 + sqrt(G^2*Mt^2/v^4 + R_c^2)
-
-   (e)We are trying to solve for R_c. We are looking for impact, so we want r_p=Rt
-
-    Rt + G*Mt/v^2 = sqrt(G^2*Mt^2/v^4 + R_c^2)->
-
-    (Rt + G*Mt/v^2)^2 = G^2*Mt^2/v^4 + R_c^2->
-
-    Rt^2 + 2*G*Mt*Rt/v^2 + G^2*Mt^2/v^4 = G^2*Mt^2/v^4 + R_c^2->
-
-    Rt**2 + 2*G*Mt*Rt/v**2 = R_c**2->
-
-    Rt**2 * (1 + 2*G*Mt/Rt *1/v**2) = R_c**2->
-
-    escape velocity = sqrt(2GM/R)= v_escape**2=2GM/R->
-
-    Rt**2 * (1 + v_esc**2/v**2) = R_c**2->
-
-(6)
-    R_capture = Rt * sqrt(1 + v_esc**2/v**2)
-
-Source: Problem Set 3 #8 c.Fall_2017|Honors Astronomy|Professor Rachel Bezanson
-
-Source #2: http://www.nssc.ac.cn/wxzygx/weixin/201607/P020160718380095698873.pdf
-           8.8 Planetary Rendezvous: Pg.368
-"""
--- a/physics/newtons_second_law_of_motion.py
+++ b/physics/newtons_second_law_of_motion.py
@ -60,7 +60,7 @@ def newtons_second_law_of_motion(mass: float, acceleration: float) -> float:
    >>> newtons_second_law_of_motion(2.0, 1)
    2.0
    """
-    force = 0.0
+    force = float()
    try:
        force = mass * acceleration
    except Exception:
--- a/project_euler/problem_009/sol3.py
+++ b/project_euler/problem_009/sol3.py
@ -28,16 +28,12 @@ def solution() -> int:
    31875000
    """

-    return next(
-        iter(
-            [
+    return [
        a * b * (1000 - a - b)
        for a in range(1, 999)
        for b in range(a, 999)
        if (a * a + b * b == (1000 - a - b) ** 2)
-            ]
-        )
-    )
+    ][0]


 if __name__ == "__main__":
--- a/pyproject.toml
+++ b/pyproject.toml
@ -49,7 +49,6 @@ select = [  # https://beta.ruff.rs/docs/rules
  "ICN",    # flake8-import-conventions
  "INP",    # flake8-no-pep420
  "INT",    # flake8-gettext
-  "ISC",  # flake8-implicit-str-concat
  "N",      # pep8-naming
  "NPY",    # NumPy-specific rules
  "PGH",    # pygrep-hooks
@ -73,6 +72,7 @@ select = [  # https://beta.ruff.rs/docs/rules
  # "DJ",   # flake8-django
  # "ERA",  # eradicate -- DO NOT FIX
  # "FBT",  # flake8-boolean-trap  # FIX ME
+  # "ISC",  # flake8-implicit-str-concat  # FIX ME
  # "PD",   # pandas-vet
  # "PT",   # flake8-pytest-style
  # "PTH",  # flake8-use-pathlib  # FIX ME
--- a/quantum/quantum_random.py.DISABLED.txt
+++ b/quantum/quantum_random.py.DISABLED.txt
--- a/quantum/ripple_adder_classic.py
+++ b/quantum/ripple_adder_classic.py
@ -107,7 +107,7 @@ def ripple_adder(
    res = qiskit.execute(circuit, backend, shots=1).result()

    # The result is in binary. Convert it back to int
-    return int(next(iter(res.get_counts())), 2)
+    return int(list(res.get_counts())[0], 2)


 if __name__ == "__main__":
--- a/requirements.txt
+++ b/requirements.txt
@ -9,7 +9,6 @@ pandas
 pillow
 projectq
 qiskit
-qiskit-aer
 requests
 rich
 scikit-fuzzy
--- a/searches/linear_search.py
+++ b/searches/linear_search.py
@ -15,7 +15,7 @@ def linear_search(sequence: list, target: int) -> int:
    :param sequence: a collection with comparable items (as sorted items not required
        in Linear Search)
    :param target: item value to search
-    :return: index of found item or -1 if item is not found
+    :return: index of found item or None if item is not found

    Examples:
    >>> linear_search([0, 5, 7, 10, 15], 0)
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@ -1,7 +1,4 @@
-from typing import Any
-
-
-def bubble_sort(collection: list[Any]) -> list[Any]:
+def bubble_sort(collection):
    """Pure implementation of bubble sort algorithm in Python

    :param collection: some mutable ordered collection with heterogeneous
@ -31,9 +28,9 @@ def bubble_sort(collection: list[Any]) -> list[Any]:
    True
    """
    length = len(collection)
-    for i in reversed(range(length)):
+    for i in range(length - 1):
        swapped = False
-        for j in range(i):
+        for j in range(length - 1 - i):
            if collection[j] > collection[j + 1]:
                swapped = True
                collection[j], collection[j + 1] = collection[j + 1], collection[j]
--- a/strings/is_srilankan_phone_number.py
+++ b/strings/is_srilankan_phone_number.py
@ -22,7 +22,9 @@ def is_sri_lankan_phone_number(phone: str) -> bool:
    False
    """

-    pattern = re.compile(r"^(?:0|94|\+94|0{2}94)7(0|1|2|4|5|6|7|8)(-| |)\d{7}$")
+    pattern = re.compile(
+        r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"
+    )

    return bool(re.search(pattern, phone))

--- a/strings/min_cost_string_conversion.py
+++ b/strings/min_cost_string_conversion.py
@ -61,7 +61,7 @@ def assemble_transformation(ops: list[list[str]], i: int, j: int) -> list[str]:
    if i == 0 and j == 0:
        return []
    else:
-        if ops[i][j][0] in {"C", "R"}:
+        if ops[i][j][0] == "C" or ops[i][j][0] == "R":
            seq = assemble_transformation(ops, i - 1, j - 1)
            seq.append(ops[i][j])
            return seq
--- a/web_programming/convert_number_to_words.py
+++ b/web_programming/convert_number_to_words.py
@ -90,7 +90,9 @@ def convert(number: int) -> str:
                else:
                    addition = ""
                    if counter in placevalue:
-                        if current != 0 and ((temp_num % 100) // 10) != 0:
+                        if current == 0 and ((temp_num % 100) // 10) == 0:
+                            addition = ""
+                        else:
                            addition = placevalue[counter]
                    if ((temp_num % 100) // 10) == 1:
                        words = teens[current] + addition + words
--- a/web_programming/world_covid19_stats.py
+++ b/web_programming/world_covid19_stats.py
@ -22,5 +22,6 @@ def world_covid19_stats(url: str = "https://www.worldometers.info/coronavirus")


 if __name__ == "__main__":
-    print("\033[1m COVID-19 Status of the World \033[0m\n")
-    print("\n".join(f"{key}\n{value}" for key, value in world_covid19_stats().items()))
+    print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
+    for key, value in world_covid19_stats().items():
+        print(f"{key}\n{value}\n")