Merge branch 'master' into continuous-fractions

Co-authored-by: Caeden Perelli-Harris <caedenperelliharris@gmail.com>

.coveragerc

@@ -1,4 +0,0 @@
-[report]
-sort = Cover
-omit =
-    .env/*

.devcontainer/Dockerfile

@@ -0,0 +1,8 @@
+# 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

.devcontainer/devcontainer.json

@@ -0,0 +1,42 @@
+{
+	"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"
+}

.github/CODEOWNERS

@@ -31,11 +31,11 @@
 
 # /data_structures/  @cclauss  # TODO: Uncomment this line after Hacktoberfest
 
-/digital_image_processing/ @mateuszz0000
+# /digital_image_processing/
 
 # /divide_and_conquer/
 
-/dynamic_programming/ @Kush1101
+# /dynamic_programming/
 
 # /file_transfer/
 
@@ -59,7 +59,7 @@
 
 # /machine_learning/
 
-/maths/ @Kush1101
+# /maths/
 
 # /matrix/
 
@@ -69,7 +69,7 @@
 
 # /other/  @cclauss  # TODO: Uncomment this line after Hacktoberfest
 
-/project_euler/  @dhruvmanila @Kush1101
+/project_euler/  @dhruvmanila
 
 # /quantum/
 
@@ -79,7 +79,7 @@
 
 # /searches/
 
-/sorts/ @mateuszz0000
+# /sorts/
 
 # /strings/  @cclauss  # TODO: Uncomment this line after Hacktoberfest
 

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -17,10 +17,3 @@ body:
         implementations.
     validations:
       required: true
-
-  - type: checkboxes
-    attributes:
-      label: Would you like to work on this feature?
-      options:
-        - label: Yes, I want to work on this feature!
-          required: false

.github/ISSUE_TEMPLATE/other.yml

@@ -0,0 +1,19 @@
+name: Other
+description: Use this for any other issues. PLEASE do not create blank issues
+labels: ["awaiting triage"]
+body:
+  - type: textarea
+    id: issuedescription
+    attributes:
+      label: What would you like to share?
+      description: Provide a clear and concise explanation of your issue.
+    validations:
+      required: true
+
+  - type: textarea
+    id: extrainfo
+    attributes:
+      label: Additional information
+      description: Is there anything else we should know about this issue?
+    validations:
+      required: false

.github/pull_request_template.md

@@ -16,5 +16,5 @@
 * [ ] All functions and variable names follow Python naming conventions.
 * [ ] All function parameters and return values are annotated with Python [type hints](https://docs.python.org/3/library/typing.html).
 * [ ] All functions have [doctests](https://docs.python.org/3/library/doctest.html) that pass the automated testing.
-* [ ] All new algorithms have a URL in its comments that points to Wikipedia or other similar explanation.
-* [ ] If this pull request resolves one or more open issues then the commit message contains `Fixes: #{$ISSUE_NO}`.
+* [ ] All new algorithms include at least one URL that points to Wikipedia or another similar explanation.
+* [ ] If this pull request resolves one or more open issues then the description above includes the issue number(s) with a [closing keyword](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue): "Fixes #ISSUE-NUMBER".

.github/stale.yml

@@ -45,7 +45,7 @@ pulls:
   closeComment: >
     Please reopen this pull request once you commit the changes requested
     or make improvements on the code. If this is not the case and you need
-    some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms)
+    some help, feel free to seek help from our [Gitter](https://gitter.im/TheAlgorithms/community)
     or ping one of the reviewers. Thank you for your contributions!
 
 issues:
@@ -59,5 +59,5 @@ issues:
   closeComment: >
     Please reopen this issue once you add more information and updates here.
     If this is not the case and you need some help, feel free to seek help
-    from our [Gitter](https://gitter.im/TheAlgorithms) or ping one of the
+    from our [Gitter](https://gitter.im/TheAlgorithms/community) or ping one of the
     reviewers. Thank you for your contributions!

.github/workflows/build.yml

@@ -12,7 +12,7 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-python@v4
         with:
-          python-version: 3.x
+          python-version: 3.11
       - uses: actions/cache@v3
         with:
           path: ~/.cache/pip
@@ -22,6 +22,12 @@ jobs:
           python -m pip install --upgrade pip setuptools six wheel
           python -m pip install pytest-cov -r requirements.txt
       - name: Run tests
-        run: pytest --doctest-modules --ignore=project_euler/ --ignore=scripts/validate_solutions.py --cov-report=term-missing:skip-covered --cov=. .
+        # TODO: #8818 Re-enable quantum tests
+        run: pytest
+            --ignore=quantum/q_fourier_transform.py
+            --ignore=project_euler/
+            --ignore=scripts/validate_solutions.py
+            --cov-report=term-missing:skip-covered
+            --cov=. .
       - if: ${{ success() }}
         run: scripts/build_directory_md.py 2>&1 | tee DIRECTORY.md

.github/workflows/pre-commit.yml

@@ -1,28 +0,0 @@
-name: pre-commit
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  pre-commit:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-      - uses: actions/cache@v3
-        with:
-          path: |
-            ~/.cache/pre-commit
-            ~/.cache/pip
-          key: ${{ runner.os }}-pre-commit-${{ hashFiles('.pre-commit-config.yaml') }}
-      - uses: actions/setup-python@v4
-        with:
-          python-version: 3.x
-      # - uses: psf/black@22.6.0
-      - name: Install pre-commit
-        run: |
-          python -m pip install --upgrade pip
-          python -m pip install --upgrade pre-commit
-      - run: pre-commit run --verbose --all-files --show-diff-on-failure

.github/workflows/ruff.yml

@@ -0,0 +1,16 @@
+# https://beta.ruff.rs
+name: ruff
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    branches:
+      - master
+jobs:
+  ruff:
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@v3
+    - run: pip install --user ruff
+    - run: ruff --format=github .

.pre-commit-config.yaml

@@ -1,68 +1,41 @@
 repos:
   - repo: https://github.com/pre-commit/pre-commit-hooks
-    rev: v4.3.0
+    rev: v4.4.0
     hooks:
       - id: check-executables-have-shebangs
+      - id: check-toml
       - id: check-yaml
       - id: end-of-file-fixer
         types: [python]
       - id: trailing-whitespace
-        exclude: |
-          (?x)^(
-            data_structures/heap/binomial_heap.py
-          )$
       - id: requirements-txt-fixer
 
+  - repo: https://github.com/MarcoGorelli/auto-walrus
+    rev: v0.2.2
+    hooks:
+    -   id: auto-walrus
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.0.284
+    hooks:
+      - id: ruff
+
   - repo: https://github.com/psf/black
-    rev: 22.6.0
+    rev: 23.7.0
     hooks:
       - id: black
 
-  - repo: https://github.com/PyCQA/isort
-    rev: 5.10.1
-    hooks:
-      - id: isort
-        args:
-          - --profile=black
-
-  - repo: https://github.com/asottile/pyupgrade
-    rev: v2.37.0
-    hooks:
-      - id: pyupgrade
-        args:
-          - --py310-plus
-
-  - repo: https://gitlab.com/pycqa/flake8
-    rev: 3.9.2
-    hooks:
-      - id: flake8
-        args:
-          - --ignore=E203,W503
-          - --max-complexity=25
-          - --max-line-length=88
-
-  - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v0.961
-    hooks:
-      - id: mypy
-        args:
-          - --ignore-missing-imports
-          - --install-types  # See mirrors-mypy README.md
-          - --non-interactive
-
   - repo: https://github.com/codespell-project/codespell
-    rev: v2.1.0
+    rev: v2.2.5
     hooks:
       - id: codespell
-        args:
-          - --ignore-words-list=ans,crate,fo,followings,hist,iff,mater,secant,som,sur,tim
-          - --skip="./.*,./strings/dictionary.txt,./strings/words.txt,./project_euler/problem_022/p022_names.txt"
-        exclude: |
-          (?x)^(
-              strings/dictionary.txt |
-              strings/words.txt |
-              project_euler/problem_022/p022_names.txt
-          )$
+        additional_dependencies:
+          - tomli
+
+  - repo: https://github.com/tox-dev/pyproject-fmt
+    rev: "0.13.1"
+    hooks:
+      - id: pyproject-fmt
 
   - repo: local
     hooks:
@@ -71,3 +44,18 @@ repos:
         entry: ./scripts/validate_filenames.py
         language: script
         pass_filenames: false
+
+  - repo: https://github.com/abravalheri/validate-pyproject
+    rev: v0.13
+    hooks:
+      - id: validate-pyproject
+
+  - repo: https://github.com/pre-commit/mirrors-mypy
+    rev: v1.5.0
+    hooks:
+      - id: mypy
+        args:
+          - --ignore-missing-imports
+          - --install-types # See mirrors-mypy README.md
+          - --non-interactive
+        additional_dependencies: [types-requests]

.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "githubPullRequests.ignoredPullRequestBranches": [
+        "master"
+    ]
+}

CONTRIBUTING.md

@@ -2,13 +2,13 @@
 
 ## Before contributing
 
-Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before sending your pull requests, make sure that you __read the whole guidelines__. If you have any doubt on the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms).
+Welcome to [TheAlgorithms/Python](https://github.com/TheAlgorithms/Python)! Before sending your pull requests, make sure that you __read the whole guidelines__. If you have any doubt on the contributing guide, please feel free to [state it clearly in an issue](https://github.com/TheAlgorithms/Python/issues/new) or ask the community in [Gitter](https://gitter.im/TheAlgorithms/community).
 
 ## Contributing
 
 ### Contributor
 
-We are very happy that you consider implementing algorithms and data structures for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
+We are very happy that you are considering implementing algorithms and data structures for others! This repository is referenced and used by learners from all over the globe. Being one of our contributors, you agree and confirm that:
 
 - You did your work - no plagiarism allowed
   - Any plagiarized work will not be merged.
@@ -25,7 +25,14 @@ 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.
 
-Please help us keep our issue list small by adding fixes: #{$ISSUE_NO} to the commit message of pull requests that resolve open issues. GitHub will use this tag to auto-close the issue when the PR is merged.
+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:
+```
+Fixes #10
+```
+GitHub will use this tag to [auto-close the issue](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue) if and when the PR is merged.
 
 #### What is an Algorithm?
 
@@ -66,7 +73,7 @@ pre-commit run --all-files --show-diff-on-failure
 
 We want your work to be readable by others; therefore, we encourage you to note the following:
 
-- Please write in Python 3.9+. For instance:  `print()` is a function in Python 3 so `print "Hello"` will *not* work but `print("Hello")` will.
+- Please write in Python 3.11+. For instance:  `print()` is a function in Python 3 so `print "Hello"` will *not* work but `print("Hello")` will.
 - Please focus hard on the naming of functions, classes, and variables.  Help your reader by using __descriptive names__ that can help you to remove redundant comments.
   - Single letter variable names are *old school* so please avoid them unless their life only spans a few lines.
   - Expand acronyms because `gcd()` is hard to understand but `greatest_common_divisor()` is not.
@@ -81,11 +88,11 @@ We want your work to be readable by others; therefore, we encourage you to note
   black .
   ```
 
-- All submissions will need to pass the test `flake8 . --ignore=E203,W503 --max-line-length=88` before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
+- All submissions will need to pass the test `ruff .` before they will be accepted so if possible, try this test locally on your Python file(s) before submitting your pull request.
 
   ```bash
-  python3 -m pip install flake8  # only required the first time
-  flake8 . --ignore=E203,W503  --max-line-length=88 --show-source
+  python3 -m pip install ruff  # only required the first time
+  ruff .
   ```
 
 - Original code submission require docstrings or comments to describe your work.
@@ -176,7 +183,7 @@ We want your work to be readable by others; therefore, we encourage you to note
 
 - Most importantly,
   - __Be consistent in the use of these guidelines when submitting.__
-  - __Join__ [Gitter](https://gitter.im/TheAlgorithms) __now!__
+  - __Join__ us on [Discord](https://discord.com/invite/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms/community) __now!__
   - Happy coding!
 
 Writer [@poyea](https://github.com/poyea), Jun 2019.

DIRECTORY.md

@@ -22,14 +22,18 @@
   * [All Permutations](backtracking/all_permutations.py)
   * [All Subsequences](backtracking/all_subsequences.py)
   * [Coloring](backtracking/coloring.py)
+  * [Combination Sum](backtracking/combination_sum.py)
   * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py)
   * [Knight Tour](backtracking/knight_tour.py)
   * [Minimax](backtracking/minimax.py)
+  * [Minmax](backtracking/minmax.py)
   * [N Queens](backtracking/n_queens.py)
   * [N Queens Math](backtracking/n_queens_math.py)
+  * [Power Sum](backtracking/power_sum.py)
   * [Rat In Maze](backtracking/rat_in_maze.py)
   * [Sudoku](backtracking/sudoku.py)
   * [Sum Of Subsets](backtracking/sum_of_subsets.py)
+  * [Word Search](backtracking/word_search.py)
 
 ## Bit Manipulation
   * [Binary And Operator](bit_manipulation/binary_and_operator.py)
@@ -42,6 +46,11 @@
   * [Count 1S Brian Kernighan Method](bit_manipulation/count_1s_brian_kernighan_method.py)
   * [Count Number Of One Bits](bit_manipulation/count_number_of_one_bits.py)
   * [Gray Code Sequence](bit_manipulation/gray_code_sequence.py)
+  * [Highest Set Bit](bit_manipulation/highest_set_bit.py)
+  * [Index Of Rightmost Set Bit](bit_manipulation/index_of_rightmost_set_bit.py)
+  * [Is Even](bit_manipulation/is_even.py)
+  * [Is Power Of Two](bit_manipulation/is_power_of_two.py)
+  * [Numbers Different Signs](bit_manipulation/numbers_different_signs.py)
   * [Reverse Bits](bit_manipulation/reverse_bits.py)
   * [Single Bit Manipulation Operations](bit_manipulation/single_bit_manipulation_operations.py)
 
@@ -51,18 +60,27 @@
   * [Modular Division](blockchain/modular_division.py)
 
 ## Boolean Algebra
+  * [And Gate](boolean_algebra/and_gate.py)
+  * [Nand Gate](boolean_algebra/nand_gate.py)
+  * [Norgate](boolean_algebra/norgate.py)
+  * [Not Gate](boolean_algebra/not_gate.py)
+  * [Or Gate](boolean_algebra/or_gate.py)
   * [Quine Mc Cluskey](boolean_algebra/quine_mc_cluskey.py)
+  * [Xnor Gate](boolean_algebra/xnor_gate.py)
+  * [Xor Gate](boolean_algebra/xor_gate.py)
 
 ## Cellular Automata
   * [Conways Game Of Life](cellular_automata/conways_game_of_life.py)
   * [Game Of Life](cellular_automata/game_of_life.py)
   * [Nagel Schrekenberg](cellular_automata/nagel_schrekenberg.py)
   * [One Dimensional](cellular_automata/one_dimensional.py)
+  * [Wa Tor](cellular_automata/wa_tor.py)
 
 ## Ciphers
   * [A1Z26](ciphers/a1z26.py)
   * [Affine Cipher](ciphers/affine_cipher.py)
   * [Atbash](ciphers/atbash.py)
+  * [Autokey](ciphers/autokey.py)
   * [Baconian Cipher](ciphers/baconian_cipher.py)
   * [Base16](ciphers/base16.py)
   * [Base32](ciphers/base32.py)
@@ -107,6 +125,7 @@
   * [Huffman](compression/huffman.py)
   * [Lempel Ziv](compression/lempel_ziv.py)
   * [Lempel Ziv Decompress](compression/lempel_ziv_decompress.py)
+  * [Lz77](compression/lz77.py)
   * [Peak Signal To Noise Ratio](compression/peak_signal_to_noise_ratio.py)
   * [Run Length Encoding](compression/run_length_encoding.py)
 
@@ -120,6 +139,7 @@
   * [Pooling Functions](computer_vision/pooling_functions.py)
 
 ## Conversions
+  * [Astronomical Length Scale Conversion](conversions/astronomical_length_scale_conversion.py)
   * [Binary To Decimal](conversions/binary_to_decimal.py)
   * [Binary To Hexadecimal](conversions/binary_to_hexadecimal.py)
   * [Binary To Octal](conversions/binary_to_octal.py)
@@ -128,6 +148,7 @@
   * [Decimal To Binary Recursion](conversions/decimal_to_binary_recursion.py)
   * [Decimal To Hexadecimal](conversions/decimal_to_hexadecimal.py)
   * [Decimal To Octal](conversions/decimal_to_octal.py)
+  * [Energy Conversions](conversions/energy_conversions.py)
   * [Excel Title To Column](conversions/excel_title_to_column.py)
   * [Hex To Bin](conversions/hex_to_bin.py)
   * [Hexadecimal To Decimal](conversions/hexadecimal_to_decimal.py)
@@ -139,19 +160,30 @@
   * [Pressure Conversions](conversions/pressure_conversions.py)
   * [Rgb Hsv Conversion](conversions/rgb_hsv_conversion.py)
   * [Roman Numerals](conversions/roman_numerals.py)
+  * [Speed Conversions](conversions/speed_conversions.py)
   * [Temperature Conversions](conversions/temperature_conversions.py)
   * [Volume Conversions](conversions/volume_conversions.py)
   * [Weight Conversion](conversions/weight_conversion.py)
 
 ## Data Structures
+  * Arrays
+    * [Permutations](data_structures/arrays/permutations.py)
+    * [Prefix Sum](data_structures/arrays/prefix_sum.py)
+    * [Product Sum](data_structures/arrays/product_sum.py)
   * Binary Tree
     * [Avl Tree](data_structures/binary_tree/avl_tree.py)
     * [Basic Binary Tree](data_structures/binary_tree/basic_binary_tree.py)
     * [Binary Search Tree](data_structures/binary_tree/binary_search_tree.py)
     * [Binary Search Tree Recursive](data_structures/binary_tree/binary_search_tree_recursive.py)
     * [Binary Tree Mirror](data_structures/binary_tree/binary_tree_mirror.py)
+    * [Binary Tree Node Sum](data_structures/binary_tree/binary_tree_node_sum.py)
+    * [Binary Tree Path Sum](data_structures/binary_tree/binary_tree_path_sum.py)
     * [Binary Tree Traversals](data_structures/binary_tree/binary_tree_traversals.py)
+    * [Diff Views Of Binary Tree](data_structures/binary_tree/diff_views_of_binary_tree.py)
+    * [Distribute Coins](data_structures/binary_tree/distribute_coins.py)
     * [Fenwick Tree](data_structures/binary_tree/fenwick_tree.py)
+    * [Inorder Tree Traversal 2022](data_structures/binary_tree/inorder_tree_traversal_2022.py)
+    * [Is Bst](data_structures/binary_tree/is_bst.py)
     * [Lazy Segment Tree](data_structures/binary_tree/lazy_segment_tree.py)
     * [Lowest Common Ancestor](data_structures/binary_tree/lowest_common_ancestor.py)
     * [Maximum Fenwick Tree](data_structures/binary_tree/maximum_fenwick_tree.py)
@@ -167,12 +199,16 @@
     * [Alternate Disjoint Set](data_structures/disjoint_set/alternate_disjoint_set.py)
     * [Disjoint Set](data_structures/disjoint_set/disjoint_set.py)
   * Hashing
+    * [Bloom Filter](data_structures/hashing/bloom_filter.py)
     * [Double Hash](data_structures/hashing/double_hash.py)
+    * [Hash Map](data_structures/hashing/hash_map.py)
     * [Hash Table](data_structures/hashing/hash_table.py)
     * [Hash Table With Linked List](data_structures/hashing/hash_table_with_linked_list.py)
     * Number Theory
       * [Prime Numbers](data_structures/hashing/number_theory/prime_numbers.py)
     * [Quadratic Probing](data_structures/hashing/quadratic_probing.py)
+    * Tests
+      * [Test Hash Map](data_structures/hashing/tests/test_hash_map.py)
   * Heap
     * [Binomial Heap](data_structures/heap/binomial_heap.py)
     * [Heap](data_structures/heap/heap.py)
@@ -201,7 +237,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 On List](data_structures/queue/queue_on_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 Pseudo Stack](data_structures/queue/queue_on_pseudo_stack.py)
   * Stacks
     * [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
@@ -217,6 +254,7 @@
     * [Stack With Singly Linked List](data_structures/stacks/stack_with_singly_linked_list.py)
     * [Stock Span Problem](data_structures/stacks/stock_span_problem.py)
   * Trie
+    * [Radix Tree](data_structures/trie/radix_tree.py)
     * [Trie](data_structures/trie/trie.py)
 
 ## Digital Image Processing
@@ -256,7 +294,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 Sum](divide_and_conquer/max_subarray_sum.py)
+  * [Max Subarray](divide_and_conquer/max_subarray.py)
   * [Mergesort](divide_and_conquer/mergesort.py)
   * [Peak](divide_and_conquer/peak.py)
   * [Power](divide_and_conquer/power.py)
@@ -268,38 +306,58 @@
   * [Bitmask](dynamic_programming/bitmask.py)
   * [Catalan Numbers](dynamic_programming/catalan_numbers.py)
   * [Climbing Stairs](dynamic_programming/climbing_stairs.py)
+  * [Combination Sum Iv](dynamic_programming/combination_sum_iv.py)
   * [Edit Distance](dynamic_programming/edit_distance.py)
   * [Factorial](dynamic_programming/factorial.py)
   * [Fast Fibonacci](dynamic_programming/fast_fibonacci.py)
   * [Fibonacci](dynamic_programming/fibonacci.py)
+  * [Fizz Buzz](dynamic_programming/fizz_buzz.py)
   * [Floyd Warshall](dynamic_programming/floyd_warshall.py)
-  * [Fractional Knapsack](dynamic_programming/fractional_knapsack.py)
-  * [Fractional Knapsack 2](dynamic_programming/fractional_knapsack_2.py)
   * [Integer Partition](dynamic_programming/integer_partition.py)
   * [Iterating Through Submasks](dynamic_programming/iterating_through_submasks.py)
+  * [K Means Clustering Tensorflow](dynamic_programming/k_means_clustering_tensorflow.py)
   * [Knapsack](dynamic_programming/knapsack.py)
   * [Longest Common Subsequence](dynamic_programming/longest_common_subsequence.py)
+  * [Longest Common Substring](dynamic_programming/longest_common_substring.py)
   * [Longest Increasing Subsequence](dynamic_programming/longest_increasing_subsequence.py)
   * [Longest Increasing Subsequence O(Nlogn)](dynamic_programming/longest_increasing_subsequence_o(nlogn).py)
   * [Longest Sub Array](dynamic_programming/longest_sub_array.py)
   * [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
   * [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
-  * [Max Sub Array](dynamic_programming/max_sub_array.py)
-  * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.py)
+  * [Max Product Subarray](dynamic_programming/max_product_subarray.py)
+  * [Max Subarray Sum](dynamic_programming/max_subarray_sum.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)
   * [Minimum Partition](dynamic_programming/minimum_partition.py)
+  * [Minimum Size Subarray Sum](dynamic_programming/minimum_size_subarray_sum.py)
+  * [Minimum Squares To Represent A Number](dynamic_programming/minimum_squares_to_represent_a_number.py)
   * [Minimum Steps To One](dynamic_programming/minimum_steps_to_one.py)
+  * [Minimum Tickets Cost](dynamic_programming/minimum_tickets_cost.py)
   * [Optimal Binary Search Tree](dynamic_programming/optimal_binary_search_tree.py)
+  * [Palindrome Partitioning](dynamic_programming/palindrome_partitioning.py)
+  * [Regex Match](dynamic_programming/regex_match.py)
   * [Rod Cutting](dynamic_programming/rod_cutting.py)
   * [Subset Generation](dynamic_programming/subset_generation.py)
   * [Sum Of Subset](dynamic_programming/sum_of_subset.py)
+  * [Tribonacci](dynamic_programming/tribonacci.py)
+  * [Viterbi](dynamic_programming/viterbi.py)
+  * [Word Break](dynamic_programming/word_break.py)
 
 ## Electronics
+  * [Apparent Power](electronics/apparent_power.py)
+  * [Builtin Voltage](electronics/builtin_voltage.py)
   * [Carrier Concentration](electronics/carrier_concentration.py)
+  * [Circular Convolution](electronics/circular_convolution.py)
   * [Coulombs Law](electronics/coulombs_law.py)
+  * [Electric Conductivity](electronics/electric_conductivity.py)
   * [Electric Power](electronics/electric_power.py)
+  * [Electrical Impedance](electronics/electrical_impedance.py)
+  * [Ind Reactance](electronics/ind_reactance.py)
   * [Ohms Law](electronics/ohms_law.py)
+  * [Real And Reactive Power](electronics/real_and_reactive_power.py)
+  * [Resistor Equivalence](electronics/resistor_equivalence.py)
+  * [Resonant Frequency](electronics/resonant_frequency.py)
 
 ## File Transfer
   * [Receive File](file_transfer/receive_file.py)
@@ -310,6 +368,8 @@
 ## Financial
   * [Equated Monthly Installments](financial/equated_monthly_installments.py)
   * [Interest](financial/interest.py)
+  * [Present Value](financial/present_value.py)
+  * [Price Plus Tax](financial/price_plus_tax.py)
 
 ## Fractals
   * [Julia Sets](fractals/julia_sets.py)
@@ -336,14 +396,15 @@
   * [Articulation Points](graphs/articulation_points.py)
   * [Basic Graphs](graphs/basic_graphs.py)
   * [Bellman Ford](graphs/bellman_ford.py)
-  * [Bfs Shortest Path](graphs/bfs_shortest_path.py)
-  * [Bfs Zero One Shortest Path](graphs/bfs_zero_one_shortest_path.py)
+  * [Bi Directional Dijkstra](graphs/bi_directional_dijkstra.py)
   * [Bidirectional A Star](graphs/bidirectional_a_star.py)
   * [Bidirectional Breadth First Search](graphs/bidirectional_breadth_first_search.py)
   * [Boruvka](graphs/boruvka.py)
   * [Breadth First Search](graphs/breadth_first_search.py)
   * [Breadth First Search 2](graphs/breadth_first_search_2.py)
   * [Breadth First Search Shortest Path](graphs/breadth_first_search_shortest_path.py)
+  * [Breadth First Search Shortest Path 2](graphs/breadth_first_search_shortest_path_2.py)
+  * [Breadth First Search Zero One Shortest Path](graphs/breadth_first_search_zero_one_shortest_path.py)
   * [Check Bipartite Graph Bfs](graphs/check_bipartite_graph_bfs.py)
   * [Check Bipartite Graph Dfs](graphs/check_bipartite_graph_dfs.py)
   * [Check Cycle](graphs/check_cycle.py)
@@ -353,6 +414,8 @@
   * [Dijkstra](graphs/dijkstra.py)
   * [Dijkstra 2](graphs/dijkstra_2.py)
   * [Dijkstra Algorithm](graphs/dijkstra_algorithm.py)
+  * [Dijkstra Alternate](graphs/dijkstra_alternate.py)
+  * [Dijkstra Binary Grid](graphs/dijkstra_binary_grid.py)
   * [Dinic](graphs/dinic.py)
   * [Directed And Undirected (Weighted) Graph](graphs/directed_and_undirected_(weighted)_graph.py)
   * [Edmonds Karp Multiple Source And Sink](graphs/edmonds_karp_multiple_source_and_sink.py)
@@ -362,8 +425,9 @@
   * [Frequent Pattern Graph Miner](graphs/frequent_pattern_graph_miner.py)
   * [G Topological Sort](graphs/g_topological_sort.py)
   * [Gale Shapley Bigraph](graphs/gale_shapley_bigraph.py)
+  * [Graph Adjacency List](graphs/graph_adjacency_list.py)
+  * [Graph Adjacency Matrix](graphs/graph_adjacency_matrix.py)
   * [Graph List](graphs/graph_list.py)
-  * [Graph Matrix](graphs/graph_matrix.py)
   * [Graphs Floyd Warshall](graphs/graphs_floyd_warshall.py)
   * [Greedy Best First](graphs/greedy_best_first.py)
   * [Greedy Min Vertex Cover](graphs/greedy_min_vertex_cover.py)
@@ -390,12 +454,16 @@
     * [Test Min Spanning Tree Prim](graphs/tests/test_min_spanning_tree_prim.py)
 
 ## Greedy Methods
+  * [Fractional Knapsack](greedy_methods/fractional_knapsack.py)
+  * [Fractional Knapsack 2](greedy_methods/fractional_knapsack_2.py)
+  * [Minimum Waiting Time](greedy_methods/minimum_waiting_time.py)
   * [Optimal Merge Pattern](greedy_methods/optimal_merge_pattern.py)
 
 ## Hashes
   * [Adler32](hashes/adler32.py)
   * [Chaos Machine](hashes/chaos_machine.py)
   * [Djb2](hashes/djb2.py)
+  * [Elf](hashes/elf.py)
   * [Enigma Machine](hashes/enigma_machine.py)
   * [Hamming Code](hashes/hamming_code.py)
   * [Luhn](hashes/luhn.py)
@@ -407,6 +475,7 @@
 ## Knapsack
   * [Greedy Knapsack](knapsack/greedy_knapsack.py)
   * [Knapsack](knapsack/knapsack.py)
+  * [Recursive Approach Knapsack](knapsack/recursive_approach_knapsack.py)
   * Tests
     * [Test Greedy Knapsack](knapsack/tests/test_greedy_knapsack.py)
     * [Test Knapsack](knapsack/tests/test_knapsack.py)
@@ -417,19 +486,22 @@
     * [Lib](linear_algebra/src/lib.py)
     * [Polynom For Points](linear_algebra/src/polynom_for_points.py)
     * [Power Iteration](linear_algebra/src/power_iteration.py)
+    * [Rank Of Matrix](linear_algebra/src/rank_of_matrix.py)
     * [Rayleigh Quotient](linear_algebra/src/rayleigh_quotient.py)
     * [Schur Complement](linear_algebra/src/schur_complement.py)
     * [Test Linear Algebra](linear_algebra/src/test_linear_algebra.py)
     * [Transformations 2D](linear_algebra/src/transformations_2d.py)
 
+## Linear Programming
+  * [Simplex](linear_programming/simplex.py)
+
 ## Machine Learning
   * [Astar](machine_learning/astar.py)
   * [Data Transformations](machine_learning/data_transformations.py)
   * [Decision Tree](machine_learning/decision_tree.py)
+  * [Dimensionality Reduction](machine_learning/dimensionality_reduction.py)
   * Forecasting
     * [Run](machine_learning/forecasting/run.py)
-  * [Gaussian Naive Bayes](machine_learning/gaussian_naive_bayes.py)
-  * [Gradient Boosting Regressor](machine_learning/gradient_boosting_regressor.py)
   * [Gradient Descent](machine_learning/gradient_descent.py)
   * [K Means Clust](machine_learning/k_means_clust.py)
   * [K Nearest Neighbours](machine_learning/k_nearest_neighbours.py)
@@ -442,26 +514,27 @@
   * Lstm
     * [Lstm Prediction](machine_learning/lstm/lstm_prediction.py)
   * [Multilayer Perceptron Classifier](machine_learning/multilayer_perceptron_classifier.py)
-  * [Polymonial Regression](machine_learning/polymonial_regression.py)
-  * [Random Forest Classifier](machine_learning/random_forest_classifier.py)
-  * [Random Forest Regressor](machine_learning/random_forest_regressor.py)
+  * [Polynomial Regression](machine_learning/polynomial_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)
   * [Similarity Search](machine_learning/similarity_search.py)
   * [Support Vector Machines](machine_learning/support_vector_machines.py)
   * [Word Frequency Functions](machine_learning/word_frequency_functions.py)
+  * [Xgboost Classifier](machine_learning/xgboost_classifier.py)
+  * [Xgboost Regressor](machine_learning/xgboost_regressor.py)
 
 ## Maths
-  * [3N Plus 1](maths/3n_plus_1.py)
   * [Abs](maths/abs.py)
-  * [Abs Max](maths/abs_max.py)
-  * [Abs Min](maths/abs_min.py)
   * [Add](maths/add.py)
+  * [Addition Without Arithmetic](maths/addition_without_arithmetic.py)
   * [Aliquot Sum](maths/aliquot_sum.py)
   * [Allocation Number](maths/allocation_number.py)
+  * [Arc Length](maths/arc_length.py)
   * [Area](maths/area.py)
   * [Area Under Curve](maths/area_under_curve.py)
   * [Armstrong Numbers](maths/armstrong_numbers.py)
+  * [Automorphic Number](maths/automorphic_number.py)
   * [Average Absolute Deviation](maths/average_absolute_deviation.py)
   * [Average Mean](maths/average_mean.py)
   * [Average Median](maths/average_median.py)
@@ -475,6 +548,8 @@
   * [Binomial Coefficient](maths/binomial_coefficient.py)
   * [Binomial Distribution](maths/binomial_distribution.py)
   * [Bisection](maths/bisection.py)
+  * [Carmichael Number](maths/carmichael_number.py)
+  * [Catalan Number](maths/catalan_number.py)
   * [Ceil](maths/ceil.py)
   * [Check Polygon](maths/check_polygon.py)
   * [Chudnovsky Algorithm](maths/chudnovsky_algorithm.py)
@@ -482,8 +557,11 @@
   * [Combinations](maths/combinations.py)
   * [Continued Fraction](maths/continued_fraction.py)
   * [Decimal Isolate](maths/decimal_isolate.py)
+  * [Decimal To Fraction](maths/decimal_to_fraction.py)
+  * [Dodecahedron](maths/dodecahedron.py)
   * [Double Factorial Iterative](maths/double_factorial_iterative.py)
   * [Double Factorial Recursive](maths/double_factorial_recursive.py)
+  * [Dual Number Automatic Differentiation](maths/dual_number_automatic_differentiation.py)
   * [Entropy](maths/entropy.py)
   * [Euclidean Distance](maths/euclidean_distance.py)
   * [Euclidean Gcd](maths/euclidean_gcd.py)
@@ -491,37 +569,41 @@
   * [Euler Modified](maths/euler_modified.py)
   * [Eulers Totient](maths/eulers_totient.py)
   * [Extended Euclidean Algorithm](maths/extended_euclidean_algorithm.py)
-  * [Factorial Iterative](maths/factorial_iterative.py)
-  * [Factorial Recursive](maths/factorial_recursive.py)
+  * [Factorial](maths/factorial.py)
   * [Factors](maths/factors.py)
   * [Fermat Little Theorem](maths/fermat_little_theorem.py)
   * [Fibonacci](maths/fibonacci.py)
   * [Find Max](maths/find_max.py)
-  * [Find Max Recursion](maths/find_max_recursion.py)
   * [Find Min](maths/find_min.py)
-  * [Find Min Recursion](maths/find_min_recursion.py)
   * [Floor](maths/floor.py)
   * [Gamma](maths/gamma.py)
   * [Gamma Recursive](maths/gamma_recursive.py)
   * [Gaussian](maths/gaussian.py)
+  * [Gaussian Error Linear Unit](maths/gaussian_error_linear_unit.py)
+  * [Gcd Of N Numbers](maths/gcd_of_n_numbers.py)
   * [Greatest Common Divisor](maths/greatest_common_divisor.py)
   * [Greedy Coin Change](maths/greedy_coin_change.py)
   * [Hamming Numbers](maths/hamming_numbers.py)
   * [Hardy Ramanujanalgo](maths/hardy_ramanujanalgo.py)
+  * [Hexagonal Number](maths/hexagonal_number.py)
   * [Integration By Simpson Approx](maths/integration_by_simpson_approx.py)
+  * [Interquartile Range](maths/interquartile_range.py)
+  * [Is Int Palindrome](maths/is_int_palindrome.py)
   * [Is Ip V4 Address Valid](maths/is_ip_v4_address_valid.py)
   * [Is Square Free](maths/is_square_free.py)
   * [Jaccard Similarity](maths/jaccard_similarity.py)
-  * [Kadanes](maths/kadanes.py)
+  * [Juggler Sequence](maths/juggler_sequence.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)
   * [Lucas Lehmer Primality Test](maths/lucas_lehmer_primality_test.py)
   * [Lucas Series](maths/lucas_series.py)
+  * [Maclaurin Series](maths/maclaurin_series.py)
+  * [Manhattan Distance](maths/manhattan_distance.py)
   * [Matrix Exponentiation](maths/matrix_exponentiation.py)
   * [Max Sum Sliding Window](maths/max_sum_sliding_window.py)
   * [Median Of Two Arrays](maths/median_of_two_arrays.py)
@@ -534,20 +616,26 @@
   * [Newton Raphson](maths/newton_raphson.py)
   * [Number Of Digits](maths/number_of_digits.py)
   * [Numerical Integration](maths/numerical_integration.py)
+  * [Odd Sieve](maths/odd_sieve.py)
   * [Perfect Cube](maths/perfect_cube.py)
   * [Perfect Number](maths/perfect_number.py)
   * [Perfect Square](maths/perfect_square.py)
   * [Persistence](maths/persistence.py)
+  * [Pi Generator](maths/pi_generator.py)
   * [Pi Monte Carlo Estimation](maths/pi_monte_carlo_estimation.py)
   * [Points Are Collinear 3D](maths/points_are_collinear_3d.py)
   * [Pollard Rho](maths/pollard_rho.py)
   * [Polynomial Evaluation](maths/polynomial_evaluation.py)
+  * Polynomials
+    * [Single Indeterminate Operations](maths/polynomials/single_indeterminate_operations.py)
   * [Power Using Recursion](maths/power_using_recursion.py)
   * [Prime Check](maths/prime_check.py)
   * [Prime Factors](maths/prime_factors.py)
   * [Prime Numbers](maths/prime_numbers.py)
   * [Prime Sieve Eratosthenes](maths/prime_sieve_eratosthenes.py)
   * [Primelib](maths/primelib.py)
+  * [Print Multiplication Table](maths/print_multiplication_table.py)
+  * [Pronic Number](maths/pronic_number.py)
   * [Proth Number](maths/proth_number.py)
   * [Pythagoras](maths/pythagoras.py)
   * [Qr Decomposition](maths/qr_decomposition.py)
@@ -555,6 +643,7 @@
   * [Radians](maths/radians.py)
   * [Radix2 Fft](maths/radix2_fft.py)
   * [Relu](maths/relu.py)
+  * [Remove Digit](maths/remove_digit.py)
   * [Runge Kutta](maths/runge_kutta.py)
   * [Segmented Sieve](maths/segmented_sieve.py)
   * Series
@@ -567,7 +656,10 @@
     * [P Series](maths/series/p_series.py)
   * [Sieve Of Eratosthenes](maths/sieve_of_eratosthenes.py)
   * [Sigmoid](maths/sigmoid.py)
+  * [Sigmoid Linear Unit](maths/sigmoid_linear_unit.py)
+  * [Signum](maths/signum.py)
   * [Simpson Rule](maths/simpson_rule.py)
+  * [Simultaneous Linear Equation Solver](maths/simultaneous_linear_equation_solver.py)
   * [Sin](maths/sin.py)
   * [Sock Merchant](maths/sock_merchant.py)
   * [Softmax](maths/softmax.py)
@@ -575,22 +667,34 @@
   * [Sum Of Arithmetic Series](maths/sum_of_arithmetic_series.py)
   * [Sum Of Digits](maths/sum_of_digits.py)
   * [Sum Of Geometric Progression](maths/sum_of_geometric_progression.py)
+  * [Sum Of Harmonic Series](maths/sum_of_harmonic_series.py)
+  * [Sumset](maths/sumset.py)
   * [Sylvester Sequence](maths/sylvester_sequence.py)
+  * [Tanh](maths/tanh.py)
   * [Test Prime Check](maths/test_prime_check.py)
   * [Trapezoidal Rule](maths/trapezoidal_rule.py)
   * [Triplet Sum](maths/triplet_sum.py)
+  * [Twin Prime](maths/twin_prime.py)
   * [Two Pointer](maths/two_pointer.py)
   * [Two Sum](maths/two_sum.py)
   * [Ugly Numbers](maths/ugly_numbers.py)
   * [Volume](maths/volume.py)
+  * [Weird Number](maths/weird_number.py)
   * [Zellers Congruence](maths/zellers_congruence.py)
 
 ## Matrix
+  * [Binary Search Matrix](matrix/binary_search_matrix.py)
   * [Count Islands In Matrix](matrix/count_islands_in_matrix.py)
+  * [Count Negative Numbers In Sorted Matrix](matrix/count_negative_numbers_in_sorted_matrix.py)
+  * [Count Paths](matrix/count_paths.py)
+  * [Cramers Rule 2X2](matrix/cramers_rule_2x2.py)
   * [Inverse Of Matrix](matrix/inverse_of_matrix.py)
+  * [Largest Square Area In Matrix](matrix/largest_square_area_in_matrix.py)
   * [Matrix Class](matrix/matrix_class.py)
   * [Matrix Operation](matrix/matrix_operation.py)
+  * [Max Area Of Island](matrix/max_area_of_island.py)
   * [Nth Fibonacci Using Matrix Exponentiation](matrix/nth_fibonacci_using_matrix_exponentiation.py)
+  * [Pascal Triangle](matrix/pascal_triangle.py)
   * [Rotate Matrix](matrix/rotate_matrix.py)
   * [Searching In Sorted Matrix](matrix/searching_in_sorted_matrix.py)
   * [Sherman Morrison](matrix/sherman_morrison.py)
@@ -604,14 +708,16 @@
 
 ## Neural Network
   * [2 Hidden Layers Neural Network](neural_network/2_hidden_layers_neural_network.py)
+  * Activation Functions
+    * [Exponential Linear Unit](neural_network/activation_functions/exponential_linear_unit.py)
   * [Back Propagation Neural Network](neural_network/back_propagation_neural_network.py)
   * [Convolution Neural Network](neural_network/convolution_neural_network.py)
   * [Perceptron](neural_network/perceptron.py)
+  * [Simple Neural Network](neural_network/simple_neural_network.py)
 
 ## Other
   * [Activity Selection](other/activity_selection.py)
   * [Alternative List Arrange](other/alternative_list_arrange.py)
-  * [Check Strong Password](other/check_strong_password.py)
   * [Davisb Putnamb Logemannb Loveland](other/davisb_putnamb_logemannb_loveland.py)
   * [Dijkstra Bankers Algorithm](other/dijkstra_bankers_algorithm.py)
   * [Doomsday](other/doomsday.py)
@@ -619,23 +725,42 @@
   * [Gauss Easter](other/gauss_easter.py)
   * [Graham Scan](other/graham_scan.py)
   * [Greedy](other/greedy.py)
+  * [Guess The Number Search](other/guess_the_number_search.py)
+  * [H Index](other/h_index.py)
   * [Least Recently Used](other/least_recently_used.py)
   * [Lfu Cache](other/lfu_cache.py)
   * [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)
-  * [Password Generator](other/password_generator.py)
+  * [Number Container System](other/number_container_system.py)
+  * [Password](other/password.py)
+  * [Quine](other/quine.py)
   * [Scoring Algorithm](other/scoring_algorithm.py)
   * [Sdes](other/sdes.py)
   * [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)
   * [Horizontal Projectile Motion](physics/horizontal_projectile_motion.py)
-  * [Lorenz Transformation Four Vector](physics/lorenz_transformation_four_vector.py)
+  * [Hubble Parameter](physics/hubble_parameter.py)
+  * [Ideal Gas Law](physics/ideal_gas_law.py)
+  * [Kinetic Energy](physics/kinetic_energy.py)
+  * [Lorentz Transformation Four Vector](physics/lorentz_transformation_four_vector.py)
+  * [Malus Law](physics/malus_law.py)
   * [N Body Simulation](physics/n_body_simulation.py)
+  * [Newtons Law Of Gravitation](physics/newtons_law_of_gravitation.py)
   * [Newtons Second Law Of Motion](physics/newtons_second_law_of_motion.py)
+  * [Potential Energy](physics/potential_energy.py)
+  * [Rms Speed Of Molecule](physics/rms_speed_of_molecule.py)
+  * [Shear Stress](physics/shear_stress.py)
+  * [Speed Of Sound](physics/speed_of_sound.py)
 
 ## Project Euler
   * Problem 001
@@ -815,6 +940,8 @@
   * Problem 072
     * [Sol1](project_euler/problem_072/sol1.py)
     * [Sol2](project_euler/problem_072/sol2.py)
+  * Problem 073
+    * [Sol1](project_euler/problem_073/sol1.py)
   * Problem 074
     * [Sol1](project_euler/problem_074/sol1.py)
     * [Sol2](project_euler/problem_074/sol2.py)
@@ -826,10 +953,14 @@
     * [Sol1](project_euler/problem_077/sol1.py)
   * Problem 078
     * [Sol1](project_euler/problem_078/sol1.py)
+  * Problem 079
+    * [Sol1](project_euler/problem_079/sol1.py)
   * Problem 080
     * [Sol1](project_euler/problem_080/sol1.py)
   * Problem 081
     * [Sol1](project_euler/problem_081/sol1.py)
+  * Problem 082
+    * [Sol1](project_euler/problem_082/sol1.py)
   * Problem 085
     * [Sol1](project_euler/problem_085/sol1.py)
   * Problem 086
@@ -842,16 +973,20 @@
     * [Sol1](project_euler/problem_091/sol1.py)
   * Problem 092
     * [Sol1](project_euler/problem_092/sol1.py)
+  * Problem 094
+    * [Sol1](project_euler/problem_094/sol1.py)
   * Problem 097
     * [Sol1](project_euler/problem_097/sol1.py)
   * Problem 099
     * [Sol1](project_euler/problem_099/sol1.py)
+  * Problem 100
+    * [Sol1](project_euler/problem_100/sol1.py)
   * Problem 101
     * [Sol1](project_euler/problem_101/sol1.py)
   * Problem 102
     * [Sol1](project_euler/problem_102/sol1.py)
   * Problem 104
-    * [Sol](project_euler/problem_104/sol.py)
+    * [Sol1](project_euler/problem_104/sol1.py)
   * Problem 107
     * [Sol1](project_euler/problem_107/sol1.py)
   * Problem 109
@@ -866,6 +1001,8 @@
     * [Sol1](project_euler/problem_115/sol1.py)
   * Problem 116
     * [Sol1](project_euler/problem_116/sol1.py)
+  * Problem 117
+    * [Sol1](project_euler/problem_117/sol1.py)
   * Problem 119
     * [Sol1](project_euler/problem_119/sol1.py)
   * Problem 120
@@ -878,6 +1015,8 @@
     * [Sol1](project_euler/problem_125/sol1.py)
   * Problem 129
     * [Sol1](project_euler/problem_129/sol1.py)
+  * Problem 131
+    * [Sol1](project_euler/problem_131/sol1.py)
   * Problem 135
     * [Sol1](project_euler/problem_135/sol1.py)
   * Problem 144
@@ -890,6 +1029,8 @@
     * [Sol1](project_euler/problem_174/sol1.py)
   * Problem 180
     * [Sol1](project_euler/problem_180/sol1.py)
+  * Problem 187
+    * [Sol1](project_euler/problem_187/sol1.py)
   * Problem 188
     * [Sol1](project_euler/problem_188/sol1.py)
   * Problem 191
@@ -914,18 +1055,26 @@
     * [Sol1](project_euler/problem_587/sol1.py)
   * Problem 686
     * [Sol1](project_euler/problem_686/sol1.py)
+  * Problem 800
+    * [Sol1](project_euler/problem_800/sol1.py)
 
 ## Quantum
+  * [Bb84](quantum/bb84.py)
   * [Deutsch Jozsa](quantum/deutsch_jozsa.py)
   * [Half Adder](quantum/half_adder.py)
   * [Not Gate](quantum/not_gate.py)
+  * [Q Fourier Transform](quantum/q_fourier_transform.py)
+  * [Q Full Adder](quantum/q_full_adder.py)
   * [Quantum Entanglement](quantum/quantum_entanglement.py)
+  * [Quantum Teleportation](quantum/quantum_teleportation.py)
   * [Ripple Adder Classic](quantum/ripple_adder_classic.py)
   * [Single Qubit Measure](quantum/single_qubit_measure.py)
+  * [Superdense Coding](quantum/superdense_coding.py)
 
 ## Scheduling
   * [First Come First Served](scheduling/first_come_first_served.py)
   * [Highest Response Ratio Next](scheduling/highest_response_ratio_next.py)
+  * [Job Sequencing With Deadline](scheduling/job_sequencing_with_deadline.py)
   * [Multi Level Feedback Queue](scheduling/multi_level_feedback_queue.py)
   * [Non Preemptive Shortest Job First](scheduling/non_preemptive_shortest_job_first.py)
   * [Round Robin](scheduling/round_robin.py)
@@ -950,6 +1099,7 @@
 
 ## Sorts
   * [Bead Sort](sorts/bead_sort.py)
+  * [Binary Insertion Sort](sorts/binary_insertion_sort.py)
   * [Bitonic Sort](sorts/bitonic_sort.py)
   * [Bogo Sort](sorts/bogo_sort.py)
   * [Bubble Sort](sorts/bubble_sort.py)
@@ -1005,11 +1155,11 @@
   * [Alternative String Arrange](strings/alternative_string_arrange.py)
   * [Anagrams](strings/anagrams.py)
   * [Autocomplete Using Trie](strings/autocomplete_using_trie.py)
+  * [Barcode Validator](strings/barcode_validator.py)
   * [Boyer Moore Search](strings/boyer_moore_search.py)
   * [Can String Be Rearranged As Palindrome](strings/can_string_be_rearranged_as_palindrome.py)
   * [Capitalize](strings/capitalize.py)
   * [Check Anagrams](strings/check_anagrams.py)
-  * [Check Pangram](strings/check_pangram.py)
   * [Credit Card Validator](strings/credit_card_validator.py)
   * [Detecting English Programmatically](strings/detecting_english_programmatically.py)
   * [Dna](strings/dna.py)
@@ -1017,7 +1167,11 @@
   * [Hamming Distance](strings/hamming_distance.py)
   * [Indian Phone Validator](strings/indian_phone_validator.py)
   * [Is Contains Unique Chars](strings/is_contains_unique_chars.py)
-  * [Is Palindrome](strings/is_palindrome.py)
+  * [Is Isogram](strings/is_isogram.py)
+  * [Is Pangram](strings/is_pangram.py)
+  * [Is Spain National Id](strings/is_spain_national_id.py)
+  * [Is Srilankan Phone Number](strings/is_srilankan_phone_number.py)
+  * [Is Valid Email Address](strings/is_valid_email_address.py)
   * [Jaro Winkler](strings/jaro_winkler.py)
   * [Join](strings/join.py)
   * [Knuth Morris Pratt](strings/knuth_morris_pratt.py)
@@ -1034,7 +1188,11 @@
   * [Reverse Letters](strings/reverse_letters.py)
   * [Reverse Long Words](strings/reverse_long_words.py)
   * [Reverse Words](strings/reverse_words.py)
+  * [Snake Case To Camel Pascal Case](strings/snake_case_to_camel_pascal_case.py)
   * [Split](strings/split.py)
+  * [String Switch Case](strings/string_switch_case.py)
+  * [Text Justification](strings/text_justification.py)
+  * [Top K Frequent Words](strings/top_k_frequent_words.py)
   * [Upper](strings/upper.py)
   * [Wave](strings/wave.py)
   * [Wildcard Pattern Matching](strings/wildcard_pattern_matching.py)
@@ -1044,6 +1202,7 @@
 
 ## Web Programming
   * [Co2 Emission](web_programming/co2_emission.py)
+  * [Convert Number To Words](web_programming/convert_number_to_words.py)
   * [Covid Stats Via Xpath](web_programming/covid_stats_via_xpath.py)
   * [Crawl Google Results](web_programming/crawl_google_results.py)
   * [Crawl Google Scholar Citation](web_programming/crawl_google_scholar_citation.py)
@@ -1053,12 +1212,12 @@
   * [Daily Horoscope](web_programming/daily_horoscope.py)
   * [Download Images From Google Query](web_programming/download_images_from_google_query.py)
   * [Emails From Url](web_programming/emails_from_url.py)
-  * [Fetch Anime And Play](web_programming/fetch_anime_and_play.py)
   * [Fetch Bbc News](web_programming/fetch_bbc_news.py)
   * [Fetch Github Info](web_programming/fetch_github_info.py)
   * [Fetch Jobs](web_programming/fetch_jobs.py)
   * [Fetch Quotes](web_programming/fetch_quotes.py)
   * [Fetch Well Rx Price](web_programming/fetch_well_rx_price.py)
+  * [Get Amazon Product Data](web_programming/get_amazon_product_data.py)
   * [Get Imdb Top 250 Movies Csv](web_programming/get_imdb_top_250_movies_csv.py)
   * [Get Imdbtop](web_programming/get_imdbtop.py)
   * [Get Top Hn Posts](web_programming/get_top_hn_posts.py)
@@ -1068,6 +1227,7 @@
   * [Instagram Pic](web_programming/instagram_pic.py)
   * [Instagram Video](web_programming/instagram_video.py)
   * [Nasa Data](web_programming/nasa_data.py)
+  * [Open Google Results](web_programming/open_google_results.py)
   * [Random Anime Character](web_programming/random_anime_character.py)
   * [Recaptcha Verification](web_programming/recaptcha_verification.py)
   * [Reddit](web_programming/reddit.py)

README.md

@@ -13,19 +13,16 @@
     <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://discord.gg/c7MnfGFGa6">
+  <a href="https://the-algorithms.com/discord">
     <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">
+  <a href="https://gitter.im/TheAlgorithms/community">
     <img src="https://img.shields.io/badge/Chat-Gitter-ff69b4.svg?label=Chat&logo=gitter&style=flat-square" height="20" alt="Gitter chat">
   </a>
   <!-- Second row: -->
   <br>
   <a href="https://github.com/TheAlgorithms/Python/actions">
-    <img src="https://img.shields.io/github/workflow/status/TheAlgorithms/Python/build?label=CI&logo=github&style=flat-square" height="20" alt="GitHub Workflow Status">
-  </a>
-  <a href="https://lgtm.com/projects/g/TheAlgorithms/Python/alerts">
-    <img src="https://img.shields.io/lgtm/alerts/github/TheAlgorithms/Python.svg?label=LGTM&logo=LGTM&style=flat-square" height="20" alt="LGTM">
+    <img src="https://img.shields.io/github/actions/workflow/status/TheAlgorithms/Python/build.yml?branch=master&label=CI&logo=github&style=flat-square" height="20" alt="GitHub Workflow Status">
   </a>
   <a href="https://github.com/pre-commit/pre-commit">
     <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" height="20" alt="pre-commit">
@@ -37,7 +34,7 @@
   <h3>All algorithms implemented in Python - for education</h3>
 </div>
 
-Implementations are for learning purposes only. As they may be less efficient than the implementations in the Python standard library, use them at your discretion.
+Implementations are for learning purposes only. They may be less efficient than the implementations in the Python standard library. Use them at your discretion.
 
 ## Getting Started
 
@@ -45,8 +42,8 @@ Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribut
 
 ## Community Channels
 
-We're on [Discord](https://discord.gg/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms)! Community channels are great for you to ask questions and get help. Please join us!
+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!
 
 ## List of Algorithms
 
-See our [directory](DIRECTORY.md) for easier navigation and better overview of the project.
+See our [directory](DIRECTORY.md) for easier navigation and a better overview of the project.

arithmetic_analysis/bisection.py

@@ -8,7 +8,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
     1.0000000149011612
     >>> bisection(lambda x: x ** 3 - 1, 2, 1000)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: could not find root in given interval.
     >>> bisection(lambda x: x ** 2 - 4 * x + 3, 0, 2)
     1.0
@@ -16,7 +16,7 @@ def bisection(function: Callable[[float], float], a: float, b: float) -> float:
     3.0
     >>> bisection(lambda x: x ** 2 - 4 * x + 3, 4, 1000)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: could not find root in given interval.
     """
     start: float = a

arithmetic_analysis/gaussian_elimination.py

@@ -33,11 +33,11 @@ def retroactive_resolution(
 
     x: NDArray[float64] = np.zeros((rows, 1), dtype=float)
     for row in reversed(range(rows)):
-        sum = 0
+        total = 0
         for col in range(row + 1, columns):
-            sum += coefficients[row, col] * x[col]
+            total += coefficients[row, col] * x[col]
 
-        x[row, 0] = (vector[row] - sum) / coefficients[row, row]
+        x[row, 0] = (vector[row] - total) / coefficients[row, row]
 
     return x
 

arithmetic_analysis/intersection.py

@@ -10,7 +10,7 @@ def intersection(function: Callable[[float], float], x0: float, x1: float) -> fl
     0.9999999999954654
     >>> intersection(lambda x: x ** 3 - 1, 5, 5)
     Traceback (most recent call last):
-    ...
+        ...
     ZeroDivisionError: float division by zero, could not find root
     >>> intersection(lambda x: x ** 3 - 1, 100, 200)
     1.0000000000003888
@@ -24,7 +24,7 @@ def intersection(function: Callable[[float], float], x0: float, x1: float) -> fl
     0.0
     >>> intersection(math.cos, -math.pi, math.pi)
     Traceback (most recent call last):
-    ...
+        ...
     ZeroDivisionError: float division by zero, could not find root
     """
     x_n: float = x0

arithmetic_analysis/jacobi_iteration_method.py

@@ -42,16 +42,18 @@ def jacobi_iteration_method(
     >>> iterations = 3
     >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Coefficient matrix dimensions must be nxn but received 2x3
 
     >>> coefficient = np.array([[4, 1, 1], [1, 5, 2], [1, 2, 4]])
     >>> constant = np.array([[2], [-6]])
     >>> init_val = [0.5, -0.5, -0.5]
     >>> iterations = 3
-    >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
+    >>> jacobi_iteration_method(
+    ...     coefficient, constant, init_val, iterations
+    ... )  # doctest: +NORMALIZE_WHITESPACE
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Coefficient and constant matrices dimensions must be nxn and nx1 but
                 received 3x3 and 2x1
 
@@ -59,9 +61,11 @@ def jacobi_iteration_method(
     >>> constant = np.array([[2], [-6], [-4]])
     >>> init_val = [0.5, -0.5]
     >>> iterations = 3
-    >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
+    >>> jacobi_iteration_method(
+    ...     coefficient, constant, init_val, iterations
+    ... )  # doctest: +NORMALIZE_WHITESPACE
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Number of initial values must be equal to number of rows in coefficient
                 matrix but received 2 and 3
 
@@ -71,7 +75,7 @@ def jacobi_iteration_method(
     >>> iterations = 0
     >>> jacobi_iteration_method(coefficient, constant, init_val, iterations)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Iterations must be at least 1
     """
 
@@ -79,24 +83,26 @@ def jacobi_iteration_method(
     rows2, cols2 = constant_matrix.shape
 
     if rows1 != cols1:
-        raise ValueError(
-            f"Coefficient matrix dimensions must be nxn but received {rows1}x{cols1}"
-        )
+        msg = f"Coefficient matrix dimensions must be nxn but received {rows1}x{cols1}"
+        raise ValueError(msg)
 
     if cols2 != 1:
-        raise ValueError(f"Constant matrix must be nx1 but received {rows2}x{cols2}")
+        msg = f"Constant matrix must be nx1 but received {rows2}x{cols2}"
+        raise ValueError(msg)
 
     if rows1 != rows2:
-        raise ValueError(
-            f"""Coefficient and constant matrices dimensions must be nxn and nx1 but
-            received {rows1}x{cols1} and {rows2}x{cols2}"""
+        msg = (
+            "Coefficient and constant matrices dimensions must be nxn and nx1 but "
+            f"received {rows1}x{cols1} and {rows2}x{cols2}"
         )
+        raise ValueError(msg)
 
     if len(init_val) != rows1:
-        raise ValueError(
-            f"""Number of initial values must be equal to number of rows in coefficient
-            matrix but received {len(init_val)} and {rows1}"""
+        msg = (
+            "Number of initial values must be equal to number of rows in coefficient "
+            f"matrix but received {len(init_val)} and {rows1}"
         )
+        raise ValueError(msg)
 
     if iterations <= 0:
         raise ValueError("Iterations must be at least 1")
@@ -110,7 +116,7 @@ def jacobi_iteration_method(
     strictly_diagonally_dominant(table)
 
     # Iterates the whole matrix for given number of times
-    for i in range(iterations):
+    for _ in range(iterations):
         new_val = []
         for row in range(rows):
             temp = 0
@@ -138,7 +144,7 @@ def strictly_diagonally_dominant(table: NDArray[float64]) -> bool:
     >>> table = np.array([[4, 1, 1, 2], [1, 5, 2, -6], [1, 2, 3, -4]])
     >>> strictly_diagonally_dominant(table)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Coefficient matrix is not strictly diagonally dominant
     """
 
@@ -147,14 +153,14 @@ def strictly_diagonally_dominant(table: NDArray[float64]) -> bool:
     is_diagonally_dominant = True
 
     for i in range(0, rows):
-        sum = 0
+        total = 0
         for j in range(0, cols - 1):
             if i == j:
                 continue
             else:
-                sum += table[i][j]
+                total += table[i][j]
 
-        if table[i][i] <= sum:
+        if table[i][i] <= total:
             raise ValueError("Coefficient matrix is not strictly diagonally dominant")
 
     return is_diagonally_dominant

arithmetic_analysis/lu_decomposition.py

@@ -1,62 +1,102 @@
-"""Lower-Upper (LU) Decomposition.
+"""
+Lower–upper (LU) decomposition factors a matrix as a product of a lower
+triangular matrix and an upper triangular matrix. A square matrix has an LU
+decomposition under the following conditions:
+    - If the matrix is invertible, then it has an LU decomposition if and only
+    if all of its leading principal minors are non-zero (see
+    https://en.wikipedia.org/wiki/Minor_(linear_algebra) for an explanation of
+    leading principal minors of a matrix).
+    - If the matrix is singular (i.e., not invertible) and it has a rank of k
+    (i.e., it has k linearly independent columns), then it has an LU
+    decomposition if its first k leading principal minors are non-zero.
 
-Reference:
-- https://en.wikipedia.org/wiki/LU_decomposition
+This algorithm will simply attempt to perform LU decomposition on any square
+matrix and raise an error if no such decomposition exists.
+
+Reference: https://en.wikipedia.org/wiki/LU_decomposition
 """
 from __future__ import annotations
 
 import numpy as np
-import numpy.typing as NDArray
-from numpy import float64
 
 
-def lower_upper_decomposition(
-    table: NDArray[float64],
-) -> tuple[NDArray[float64], NDArray[float64]]:
-    """Lower-Upper (LU) Decomposition
-
-    Example:
-
+def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray]:
+    """
+    Perform LU decomposition on a given matrix and raises an error if the matrix
+    isn't square or if no such decomposition exists
     >>> matrix = np.array([[2, -2, 1], [0, 1, 2], [5, 3, 1]])
-    >>> outcome = lower_upper_decomposition(matrix)
-    >>> outcome[0]
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
     array([[1. , 0. , 0. ],
            [0. , 1. , 0. ],
            [2.5, 8. , 1. ]])
-    >>> outcome[1]
+    >>> upper_mat
     array([[  2. ,  -2. ,   1. ],
            [  0. ,   1. ,   2. ],
            [  0. ,   0. , -17.5]])
 
+    >>> matrix = np.array([[4, 3], [6, 3]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
+    array([[1. , 0. ],
+           [1.5, 1. ]])
+    >>> upper_mat
+    array([[ 4. ,  3. ],
+           [ 0. , -1.5]])
+
+    # Matrix is not square
     >>> matrix = np.array([[2, -2, 1], [0, 1, 2]])
-    >>> lower_upper_decomposition(matrix)
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: 'table' has to be of square shaped array but got a 2x3 array:
     [[ 2 -2  1]
      [ 0  1  2]]
+
+    # Matrix is invertible, but its first leading principal minor is 0
+    >>> matrix = np.array([[0, 1], [1, 0]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    Traceback (most recent call last):
+    ...
+    ArithmeticError: No LU decomposition exists
+
+    # Matrix is singular, but its first leading principal minor is 1
+    >>> matrix = np.array([[1, 0], [1, 0]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    >>> lower_mat
+    array([[1., 0.],
+           [1., 1.]])
+    >>> upper_mat
+    array([[1., 0.],
+           [0., 0.]])
+
+    # Matrix is singular, but its first leading principal minor is 0
+    >>> matrix = np.array([[0, 1], [0, 1]])
+    >>> lower_mat, upper_mat = lower_upper_decomposition(matrix)
+    Traceback (most recent call last):
+    ...
+    ArithmeticError: No LU decomposition exists
     """
-    # Table that contains our data
-    # Table has to be a square array so we need to check first
+    # Ensure that table is a square array
     rows, columns = np.shape(table)
     if rows != columns:
-        raise ValueError(
-            f"'table' has to be of square shaped array but got a {rows}x{columns} "
-            + f"array:\n{table}"
+        msg = (
+            "'table' has to be of square shaped array but got a "
+            f"{rows}x{columns} array:\n{table}"
         )
+        raise ValueError(msg)
+
     lower = np.zeros((rows, columns))
     upper = np.zeros((rows, columns))
     for i in range(columns):
         for j in range(i):
-            total = 0
-            for k in range(j):
-                total += lower[i][k] * upper[k][j]
+            total = sum(lower[i][k] * upper[k][j] for k in range(j))
+            if upper[j][j] == 0:
+                raise ArithmeticError("No LU decomposition exists")
             lower[i][j] = (table[i][j] - total) / upper[j][j]
         lower[i][i] = 1
         for j in range(i, columns):
-            total = 0
-            for k in range(i):
-                total += lower[i][k] * upper[k][j]
+            total = sum(lower[i][k] * upper[k][j] for k in range(j))
             upper[i][j] = table[i][j] - total
     return lower, upper
 

arithmetic_analysis/newton_forward_interpolation.py

@@ -23,7 +23,7 @@ def ucal(u: float, p: int) -> float:
 def main() -> None:
     n = int(input("enter the numbers of values: "))
     y: list[list[float]] = []
-    for i in range(n):
+    for _ in range(n):
         y.append([])
     for i in range(n):
         for j in range(n):

arithmetic_analysis/newton_method.py

@@ -28,7 +28,7 @@ def newton(
     1.5707963267948966
     >>> newton(math.cos, lambda x: -math.sin(x), 0)
     Traceback (most recent call last):
-    ...
+        ...
     ZeroDivisionError: Could not find root
     """
     prev_guess = float(starting_int)

arithmetic_analysis/newton_raphson.py

@@ -5,7 +5,7 @@
 from __future__ import annotations
 
 from decimal import Decimal
-from math import *  # noqa: F401, F403
+from math import *  # noqa: F403
 
 from sympy import diff
 
@@ -25,9 +25,11 @@ def newton_raphson(
     """
     x = a
     while True:
-        x = Decimal(x) - (Decimal(eval(func)) / Decimal(eval(str(diff(func)))))
+        x = Decimal(x) - (
+            Decimal(eval(func)) / Decimal(eval(str(diff(func))))  # noqa: S307
+        )
         # This number dictates the accuracy of the answer
-        if abs(eval(func)) < precision:
+        if abs(eval(func)) < precision:  # noqa: S307
             return float(x)
 
 

arithmetic_analysis/newton_raphson_new.py

@@ -8,7 +8,7 @@
 # Newton's Method - https://en.wikipedia.org/wiki/Newton's_method
 
 from sympy import diff, lambdify, symbols
-from sympy.functions import *  # noqa: F401, F403
+from sympy.functions import *  # noqa: F403
 
 
 def newton_raphson(
@@ -32,7 +32,7 @@ def newton_raphson(
     1.2186556186174883e-10
     >>> newton_raphson('cos(x)', 0)
     Traceback (most recent call last):
-    ...
+        ...
     ZeroDivisionError: Could not find root
     """
 
@@ -59,7 +59,6 @@ def newton_raphson(
 
 # Let's Execute
 if __name__ == "__main__":
-
     # Find root of trigonometric function
     # Find value of pi
     print(f"The root of sin(x) = 0 is {newton_raphson('sin(x)', 2)}")

arithmetic_analysis/secant_method.py

@@ -20,7 +20,7 @@ def secant_method(lower_bound: float, upper_bound: float, repeats: int) -> float
     """
     x0 = lower_bound
     x1 = upper_bound
-    for i in range(0, repeats):
+    for _ in range(0, repeats):
         x0, x1 = x1, x1 - (f(x1) * (x1 - x0)) / (f(x1) - f(x0))
     return x1
 

audio_filters/butterworth_filter.py

@@ -11,7 +11,7 @@ Alternatively you can use scipy.signal.butter, which should yield the same resul
 
 
 def make_lowpass(
-    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)
+    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a low-pass filter
@@ -39,7 +39,7 @@ def make_lowpass(
 
 
 def make_highpass(
-    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)
+    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a high-pass filter
@@ -67,7 +67,7 @@ def make_highpass(
 
 
 def make_bandpass(
-    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)
+    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a band-pass filter
@@ -96,7 +96,7 @@ def make_bandpass(
 
 
 def make_allpass(
-    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)
+    frequency: int, samplerate: int, q_factor: float = 1 / sqrt(2)  # noqa: B008
 ) -> IIRFilter:
     """
     Creates an all-pass filter
@@ -121,7 +121,10 @@ def make_allpass(
 
 
 def make_peak(
-    frequency: int, samplerate: int, gain_db: float, q_factor: float = 1 / sqrt(2)
+    frequency: int,
+    samplerate: int,
+    gain_db: float,
+    q_factor: float = 1 / sqrt(2),  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a peak filter
@@ -150,7 +153,10 @@ def make_peak(
 
 
 def make_lowshelf(
-    frequency: int, samplerate: int, gain_db: float, q_factor: float = 1 / sqrt(2)
+    frequency: int,
+    samplerate: int,
+    gain_db: float,
+    q_factor: float = 1 / sqrt(2),  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a low-shelf filter
@@ -184,7 +190,10 @@ def make_lowshelf(
 
 
 def make_highshelf(
-    frequency: int, samplerate: int, gain_db: float, q_factor: float = 1 / sqrt(2)
+    frequency: int,
+    samplerate: int,
+    gain_db: float,
+    q_factor: float = 1 / sqrt(2),  # noqa: B008
 ) -> IIRFilter:
     """
     Creates a high-shelf filter

audio_filters/equal_loudness_filter.py.broken.txt

@@ -0,0 +1,61 @@
+from json import loads
+from pathlib import Path
+
+import numpy as np
+from yulewalker import yulewalk
+
+from audio_filters.butterworth_filter import make_highpass
+from audio_filters.iir_filter import IIRFilter
+
+data = loads((Path(__file__).resolve().parent / "loudness_curve.json").read_text())
+
+
+class EqualLoudnessFilter:
+    r"""
+    An equal-loudness filter which compensates for the human ear's non-linear response
+     to sound.
+    This filter corrects this by cascading a yulewalk filter and a butterworth filter.
+
+    Designed for use with samplerate of 44.1kHz and above. If you're using a lower
+     samplerate, use with caution.
+
+    Code based on matlab implementation at https://bit.ly/3eqh2HU
+    (url shortened for ruff)
+
+    Target curve: https://i.imgur.com/3g2VfaM.png
+    Yulewalk response: https://i.imgur.com/J9LnJ4C.png
+    Butterworth and overall response: https://i.imgur.com/3g2VfaM.png
+
+    Images and original matlab implementation by David Robinson, 2001
+    """
+
+    def __init__(self, samplerate: int = 44100) -> None:
+        self.yulewalk_filter = IIRFilter(10)
+        self.butterworth_filter = make_highpass(150, samplerate)
+
+        # pad the data to nyquist
+        curve_freqs = np.array(data["frequencies"] + [max(20000.0, samplerate / 2)])
+        curve_gains = np.array(data["gains"] + [140])
+
+        # Convert to angular frequency
+        freqs_normalized = curve_freqs / samplerate * 2
+        # Invert the curve and normalize to 0dB
+        gains_normalized = np.power(10, (np.min(curve_gains) - curve_gains) / 20)
+
+        # Scipy's `yulewalk` function is a stub, so we're using the
+        #  `yulewalker` library instead.
+        # This function computes the coefficients using a least-squares
+        #  fit to the specified curve.
+        ya, yb = yulewalk(10, freqs_normalized, gains_normalized)
+        self.yulewalk_filter.set_coefficients(ya, yb)
+
+    def process(self, sample: float) -> float:
+        """
+        Process a single sample through both filters
+
+        >>> filt = EqualLoudnessFilter()
+        >>> filt.process(0.0)
+        0.0
+        """
+        tmp = self.yulewalk_filter.process(sample)
+        return self.butterworth_filter.process(tmp)

audio_filters/iir_filter.py

@@ -47,19 +47,21 @@ class IIRFilter:
             >>> filt.set_coefficients(a_coeffs, b_coeffs)
         """
         if len(a_coeffs) < self.order:
-            a_coeffs = [1.0] + a_coeffs
+            a_coeffs = [1.0, *a_coeffs]
 
         if len(a_coeffs) != self.order + 1:
-            raise ValueError(
-                f"Expected a_coeffs to have {self.order + 1} elements for {self.order}"
-                f"-order filter, got {len(a_coeffs)}"
+            msg = (
+                f"Expected a_coeffs to have {self.order + 1} elements "
+                f"for {self.order}-order filter, got {len(a_coeffs)}"
             )
+            raise ValueError(msg)
 
         if len(b_coeffs) != self.order + 1:
-            raise ValueError(
-                f"Expected b_coeffs to have {self.order + 1} elements for {self.order}"
-                f"-order filter, got {len(a_coeffs)}"
+            msg = (
+                f"Expected b_coeffs to have {self.order + 1} elements "
+                f"for {self.order}-order filter, got {len(a_coeffs)}"
             )
+            raise ValueError(msg)
 
         self.a_coeffs = a_coeffs
         self.b_coeffs = b_coeffs

audio_filters/loudness_curve.json

@@ -0,0 +1,76 @@
+{
+  "_comment": "The following is a representative average of the Equal Loudness Contours as measured by Robinson and Dadson, 1956",
+  "_doi": "10.1088/0508-3443/7/5/302",
+  "frequencies": [
+    0,
+    20,
+    30,
+    40,
+    50,
+    60,
+    70,
+    80,
+    90,
+    100,
+    200,
+    300,
+    400,
+    500,
+    600,
+    700,
+    800,
+    900,
+    1000,
+    1500,
+    2000,
+    2500,
+    3000,
+    3700,
+    4000,
+    5000,
+    6000,
+    7000,
+    8000,
+    9000,
+    10000,
+    12000,
+    15000,
+    20000
+  ],
+  "gains": [
+    120,
+    113,
+    103,
+    97,
+    93,
+    91,
+    89,
+    87,
+    86,
+    85,
+    78,
+    76,
+    76,
+    76,
+    76,
+    77,
+    78,
+    79.5,
+    80,
+    79,
+    77,
+    74,
+    71.5,
+    70,
+    70.5,
+    74,
+    79,
+    84,
+    86,
+    86,
+    85,
+    95,
+    110,
+    125
+  ]
+}

audio_filters/show_response.py

@@ -34,7 +34,7 @@ def get_bounds(
     return lowest, highest
 
 
-def show_frequency_response(filter: FilterType, samplerate: int) -> None:
+def show_frequency_response(filter_type: FilterType, samplerate: int) -> None:
     """
     Show frequency response of a filter
 
@@ -45,7 +45,7 @@ def show_frequency_response(filter: FilterType, samplerate: int) -> None:
 
     size = 512
     inputs = [1] + [0] * (size - 1)
-    outputs = [filter.process(item) for item in inputs]
+    outputs = [filter_type.process(item) for item in inputs]
 
     filler = [0] * (samplerate - size)  # zero-padding
     outputs += filler
@@ -66,7 +66,7 @@ def show_frequency_response(filter: FilterType, samplerate: int) -> None:
     plt.show()
 
 
-def show_phase_response(filter: FilterType, samplerate: int) -> None:
+def show_phase_response(filter_type: FilterType, samplerate: int) -> None:
     """
     Show phase response of a filter
 
@@ -77,7 +77,7 @@ def show_phase_response(filter: FilterType, samplerate: int) -> None:
 
     size = 512
     inputs = [1] + [0] * (size - 1)
-    outputs = [filter.process(item) for item in inputs]
+    outputs = [filter_type.process(item) for item in inputs]
 
     filler = [0] * (samplerate - size)  # zero-padding
     outputs += filler

backtracking/combination_sum.py

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

backtracking/hamiltonian_cycle.py

@@ -71,7 +71,7 @@ def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int)
     >>> curr_ind = 1
     >>> util_hamilton_cycle(graph, path, curr_ind)
     True
-    >>> print(path)
+    >>> path
     [0, 1, 2, 4, 3, 0]
 
     Case 2: Use exact graph as in previous case, but in the properties taken from
@@ -85,7 +85,7 @@ def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int)
     >>> curr_ind = 3
     >>> util_hamilton_cycle(graph, path, curr_ind)
     True
-    >>> print(path)
+    >>> path
     [0, 1, 2, 4, 3, 0]
     """
 
@@ -95,10 +95,10 @@ def util_hamilton_cycle(graph: list[list[int]], path: list[int], curr_ind: int)
         return graph[path[curr_ind - 1]][path[0]] == 1
 
     # Recursive Step
-    for next in range(0, len(graph)):
-        if valid_connection(graph, next, curr_ind, path):
+    for next_ver in range(0, len(graph)):
+        if valid_connection(graph, next_ver, curr_ind, path):
             # Insert current vertex  into path as next transition
-            path[curr_ind] = next
+            path[curr_ind] = next_ver
             # Validate created path
             if util_hamilton_cycle(graph, path, curr_ind + 1):
                 return True

backtracking/knight_tour.py

@@ -78,7 +78,7 @@ def open_knight_tour(n: int) -> list[list[int]]:
 
     >>> open_knight_tour(2)
     Traceback (most recent call last):
-    ...
+        ...
     ValueError: Open Kight Tour cannot be performed on a board of size 2
     """
 
@@ -91,7 +91,8 @@ def open_knight_tour(n: int) -> list[list[int]]:
                 return board
             board[i][j] = 0
 
-    raise ValueError(f"Open Kight Tour cannot be performed on a board of size {n}")
+    msg = f"Open Kight Tour cannot be performed on a board of size {n}"
+    raise ValueError(msg)
 
 
 if __name__ == "__main__":

backtracking/minmax.py

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

backtracking/n_queens.py

@@ -12,7 +12,7 @@ from __future__ import annotations
 solution = []
 
 
-def isSafe(board: list[list[int]], row: int, column: int) -> bool:
+def is_safe(board: list[list[int]], row: int, column: int) -> bool:
     """
     This function returns a boolean value True if it is safe to place a queen there
     considering the current state of the board.
@@ -63,7 +63,7 @@ def solve(board: list[list[int]], row: int) -> bool:
         If all the combinations for that particular branch are successful the board is
         reinitialized for the next possible combination.
         """
-        if isSafe(board, row, i):
+        if is_safe(board, row, i):
             board[row][i] = 1
             solve(board, row + 1)
             board[row][i] = 0

backtracking/n_queens_math.py

@@ -107,7 +107,6 @@ def depth_first_search(
 
     # We iterate each column in the row to find all possible results in each row
     for col in range(n):
-
         # We apply that we learned previously. First we check that in the current board
         # (possible_board) there are not other same value because if there is it means
         # that there are a collision in vertical. Then we apply the two formulas we
@@ -130,9 +129,9 @@ def depth_first_search(
 
         # If it is False we call dfs function again and we update the inputs
         depth_first_search(
-            possible_board + [col],
-            diagonal_right_collisions + [row - col],
-            diagonal_left_collisions + [row + col],
+            [*possible_board, col],
+            [*diagonal_right_collisions, row - col],
+            [*diagonal_left_collisions, row + col],
             boards,
             n,
         )

backtracking/power_sum.py

@@ -0,0 +1,93 @@
+"""
+Problem source: https://www.hackerrank.com/challenges/the-power-sum/problem
+Find the number of ways that a given integer X, can be expressed as the sum
+of the Nth powers of unique, natural numbers. For example, if X=13 and N=2.
+We have to find all combinations of unique squares adding up to 13.
+The only solution is 2^2+3^2. Constraints: 1<=X<=1000, 2<=N<=10.
+"""
+
+from math import pow
+
+
+def backtrack(
+    needed_sum: int,
+    power: int,
+    current_number: int,
+    current_sum: int,
+    solutions_count: int,
+) -> tuple[int, int]:
+    """
+    >>> backtrack(13, 2, 1, 0, 0)
+    (0, 1)
+    >>> backtrack(100, 2, 1, 0, 0)
+    (0, 3)
+    >>> backtrack(100, 3, 1, 0, 0)
+    (0, 1)
+    >>> backtrack(800, 2, 1, 0, 0)
+    (0, 561)
+    >>> backtrack(1000, 10, 1, 0, 0)
+    (0, 0)
+    >>> backtrack(400, 2, 1, 0, 0)
+    (0, 55)
+    >>> backtrack(50, 1, 1, 0, 0)
+    (0, 3658)
+    """
+    if current_sum == needed_sum:
+        # If the sum of the powers is equal to needed_sum, then we have a solution.
+        solutions_count += 1
+        return current_sum, solutions_count
+
+    i_to_n = int(pow(current_number, power))
+    if current_sum + i_to_n <= needed_sum:
+        # If the sum of the powers is less than needed_sum, then continue adding powers.
+        current_sum += i_to_n
+        current_sum, solutions_count = backtrack(
+            needed_sum, power, current_number + 1, current_sum, solutions_count
+        )
+        current_sum -= i_to_n
+    if i_to_n < needed_sum:
+        # If the power of i is less than needed_sum, then try with the next power.
+        current_sum, solutions_count = backtrack(
+            needed_sum, power, current_number + 1, current_sum, solutions_count
+        )
+    return current_sum, solutions_count
+
+
+def solve(needed_sum: int, power: int) -> int:
+    """
+    >>> solve(13, 2)
+    1
+    >>> solve(100, 2)
+    3
+    >>> solve(100, 3)
+    1
+    >>> solve(800, 2)
+    561
+    >>> solve(1000, 10)
+    0
+    >>> solve(400, 2)
+    55
+    >>> solve(50, 1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid input
+    needed_sum must be between 1 and 1000, power between 2 and 10.
+    >>> solve(-10, 5)
+    Traceback (most recent call last):
+        ...
+    ValueError: Invalid input
+    needed_sum must be between 1 and 1000, power between 2 and 10.
+    """
+    if not (1 <= needed_sum <= 1000 and 2 <= power <= 10):
+        raise ValueError(
+            "Invalid input\n"
+            "needed_sum must be between 1 and 1000, power between 2 and 10."
+        )
+
+    return backtrack(needed_sum, power, 1, 0, 0)[1]  # Return the solutions_count
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

backtracking/rat_in_maze.py

@@ -88,12 +88,12 @@ def run_maze(maze: list[list[int]], i: int, j: int, solutions: list[list[int]])
         solutions[i][j] = 1
         return True
 
-    lower_flag = (not (i < 0)) and (not (j < 0))  # Check lower bounds
+    lower_flag = (not i < 0) and (not j < 0)  # Check lower bounds
     upper_flag = (i < size) and (j < size)  # Check upper bounds
 
     if lower_flag and upper_flag:
         # check for already visited and block points.
-        block_flag = (not (solutions[i][j])) and (not (maze[i][j]))
+        block_flag = (not solutions[i][j]) and (not maze[i][j])
         if block_flag:
             # check visited
             solutions[i][j] = 1

backtracking/sum_of_subsets.py

@@ -39,14 +39,14 @@ def create_state_space_tree(
     if sum(path) == max_sum:
         result.append(path)
         return
-    for num_index in range(num_index, len(nums)):
+    for index in range(num_index, len(nums)):
         create_state_space_tree(
             nums,
             max_sum,
-            num_index + 1,
-            path + [nums[num_index]],
+            index + 1,
+            [*path, nums[index]],
             result,
-            remaining_nums_sum - nums[num_index],
+            remaining_nums_sum - nums[index],
         )
 
 

backtracking/word_search.py

@@ -0,0 +1,168 @@
+"""
+Author  : Alexander Pantyukhin
+Date    : November 24, 2022
+
+Task:
+Given an m x n grid of characters board and a string word,
+return true if word exists in the grid.
+
+The word can be constructed from letters of sequentially adjacent cells,
+where adjacent cells are horizontally or vertically neighboring.
+The same letter cell may not be used more than once.
+
+Example:
+
+Matrix:
+---------
+|A|B|C|E|
+|S|F|C|S|
+|A|D|E|E|
+---------
+
+Word:
+"ABCCED"
+
+Result:
+True
+
+Implementation notes: Use backtracking approach.
+At each point, check all neighbors to try to find the next letter of the word.
+
+leetcode: https://leetcode.com/problems/word-search/
+
+"""
+
+
+def get_point_key(len_board: int, len_board_column: int, row: int, column: int) -> int:
+    """
+    Returns the hash key of matrix indexes.
+
+    >>> get_point_key(10, 20, 1, 0)
+    200
+    """
+
+    return len_board * len_board_column * row + column
+
+
+def exits_word(
+    board: list[list[str]],
+    word: str,
+    row: int,
+    column: int,
+    word_index: int,
+    visited_points_set: set[int],
+) -> bool:
+    """
+    Return True if it's possible to search the word suffix
+    starting from the word_index.
+
+    >>> exits_word([["A"]], "B", 0, 0, 0, set())
+    False
+    """
+
+    if board[row][column] != word[word_index]:
+        return False
+
+    if word_index == len(word) - 1:
+        return True
+
+    traverts_directions = [(0, 1), (0, -1), (-1, 0), (1, 0)]
+    len_board = len(board)
+    len_board_column = len(board[0])
+    for direction in traverts_directions:
+        next_i = row + direction[0]
+        next_j = column + direction[1]
+        if not (0 <= next_i < len_board and 0 <= next_j < len_board_column):
+            continue
+
+        key = get_point_key(len_board, len_board_column, next_i, next_j)
+        if key in visited_points_set:
+            continue
+
+        visited_points_set.add(key)
+        if exits_word(board, word, next_i, next_j, word_index + 1, visited_points_set):
+            return True
+
+        visited_points_set.remove(key)
+
+    return False
+
+
+def word_exists(board: list[list[str]], word: str) -> bool:
+    """
+    >>> word_exists([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "ABCCED")
+    True
+    >>> word_exists([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "SEE")
+    True
+    >>> word_exists([["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], "ABCB")
+    False
+    >>> word_exists([["A"]], "A")
+    True
+    >>> word_exists([["A","A","A","A","A","A"],
+    ...              ["A","A","A","A","A","A"],
+    ...              ["A","A","A","A","A","A"],
+    ...              ["A","A","A","A","A","A"],
+    ...              ["A","A","A","A","A","B"],
+    ...              ["A","A","A","A","B","A"]],
+    ...             "AAAAAAAAAAAAABB")
+    False
+    >>> word_exists([["A"]], 123)
+    Traceback (most recent call last):
+        ...
+    ValueError: The word parameter should be a string of length greater than 0.
+    >>> word_exists([["A"]], "")
+    Traceback (most recent call last):
+        ...
+    ValueError: The word parameter should be a string of length greater than 0.
+    >>> word_exists([[]], "AB")
+    Traceback (most recent call last):
+        ...
+    ValueError: The board should be a non empty matrix of single chars strings.
+    >>> word_exists([], "AB")
+    Traceback (most recent call last):
+        ...
+    ValueError: The board should be a non empty matrix of single chars strings.
+    >>> word_exists([["A"], [21]], "AB")
+    Traceback (most recent call last):
+        ...
+    ValueError: The board should be a non empty matrix of single chars strings.
+    """
+
+    # Validate board
+    board_error_message = (
+        "The board should be a non empty matrix of single chars strings."
+    )
+
+    len_board = len(board)
+    if not isinstance(board, list) or len(board) == 0:
+        raise ValueError(board_error_message)
+
+    for row in board:
+        if not isinstance(row, list) or len(row) == 0:
+            raise ValueError(board_error_message)
+
+        for item in row:
+            if not isinstance(item, str) or len(item) != 1:
+                raise ValueError(board_error_message)
+
+    # Validate word
+    if not isinstance(word, str) or len(word) == 0:
+        raise ValueError(
+            "The word parameter should be a string of length greater than 0."
+        )
+
+    len_board_column = len(board[0])
+    for i in range(len_board):
+        for j in range(len_board_column):
+            if exits_word(
+                board, word, i, j, 0, {get_point_key(len_board, len_board_column, i, j)}
+            ):
+                return True
+
+    return False
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/count_1s_brian_kernighan_method.py

@@ -1,7 +1,7 @@
 def get_1s_count(number: int) -> int:
     """
     Count the number of set bits in a 32 bit integer using Brian Kernighan's way.
-    Ref - http://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
+    Ref - https://graphics.stanford.edu/~seander/bithacks.html#CountBitsSetKernighan
     >>> get_1s_count(25)
     3
     >>> get_1s_count(37)
@@ -17,16 +17,19 @@ def get_1s_count(number: int) -> int:
     >>> get_1s_count(-1)
     Traceback (most recent call last):
         ...
-    ValueError: the value of input must be positive
+    ValueError: Input must be a non-negative integer
     >>> get_1s_count(0.8)
     Traceback (most recent call last):
         ...
-    TypeError: Input value must be an 'int' type
+    ValueError: Input must be a non-negative integer
+    >>> get_1s_count("25")
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
     """
-    if number < 0:
-        raise ValueError("the value of input must be positive")
-    elif isinstance(number, float):
-        raise TypeError("Input value must be an 'int' type")
+    if not isinstance(number, int) or number < 0:
+        raise ValueError("Input must be a non-negative integer")
+
     count = 0
     while number:
         # This way we arrive at next set bit (next 1) instead of looping

bit_manipulation/count_number_of_one_bits.py

@@ -1,34 +1,91 @@
-def get_set_bits_count(number: int) -> int:
+from timeit import timeit
+
+
+def get_set_bits_count_using_brian_kernighans_algorithm(number: int) -> int:
     """
     Count the number of set bits in a 32 bit integer
-    >>> get_set_bits_count(25)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(25)
     3
-    >>> get_set_bits_count(37)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(37)
     3
-    >>> get_set_bits_count(21)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(21)
     3
-    >>> get_set_bits_count(58)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(58)
     4
-    >>> get_set_bits_count(0)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(0)
     0
-    >>> get_set_bits_count(256)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(256)
     1
-    >>> get_set_bits_count(-1)
+    >>> get_set_bits_count_using_brian_kernighans_algorithm(-1)
     Traceback (most recent call last):
         ...
-    ValueError: the value of input must be positive
+    ValueError: the value of input must not be negative
     """
     if number < 0:
-        raise ValueError("the value of input must be positive")
+        raise ValueError("the value of input must not be negative")
+    result = 0
+    while number:
+        number &= number - 1
+        result += 1
+    return result
+
+
+def get_set_bits_count_using_modulo_operator(number: int) -> int:
+    """
+    Count the number of set bits in a 32 bit integer
+    >>> get_set_bits_count_using_modulo_operator(25)
+    3
+    >>> get_set_bits_count_using_modulo_operator(37)
+    3
+    >>> get_set_bits_count_using_modulo_operator(21)
+    3
+    >>> get_set_bits_count_using_modulo_operator(58)
+    4
+    >>> get_set_bits_count_using_modulo_operator(0)
+    0
+    >>> get_set_bits_count_using_modulo_operator(256)
+    1
+    >>> get_set_bits_count_using_modulo_operator(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: the value of input must not be negative
+    """
+    if number < 0:
+        raise ValueError("the value of input must not be negative")
     result = 0
     while number:
         if number % 2 == 1:
             result += 1
-        number = number >> 1
+        number >>= 1
     return result
 
 
+def benchmark() -> None:
+    """
+    Benchmark code for comparing 2 functions, with different length int values.
+    Brian Kernighan's algorithm is consistently faster than using modulo_operator.
+    """
+
+    def do_benchmark(number: int) -> None:
+        setup = "import __main__ as z"
+        print(f"Benchmark when {number = }:")
+        print(f"{get_set_bits_count_using_modulo_operator(number) = }")
+        timing = timeit("z.get_set_bits_count_using_modulo_operator(25)", setup=setup)
+        print(f"timeit() runs in {timing} seconds")
+        print(f"{get_set_bits_count_using_brian_kernighans_algorithm(number) = }")
+        timing = timeit(
+            "z.get_set_bits_count_using_brian_kernighans_algorithm(25)",
+            setup=setup,
+        )
+        print(f"timeit() runs in {timing} seconds")
+
+    for number in (25, 37, 58, 0):
+        do_benchmark(number)
+        print()
+
+
 if __name__ == "__main__":
     import doctest
 
     doctest.testmod()
+    benchmark()

bit_manipulation/highest_set_bit.py

@@ -0,0 +1,34 @@
+def get_highest_set_bit_position(number: int) -> int:
+    """
+    Returns position of the highest set bit of a number.
+    Ref - https://graphics.stanford.edu/~seander/bithacks.html#IntegerLogObvious
+    >>> get_highest_set_bit_position(25)
+    5
+    >>> get_highest_set_bit_position(37)
+    6
+    >>> get_highest_set_bit_position(1)
+    1
+    >>> get_highest_set_bit_position(4)
+    3
+    >>> get_highest_set_bit_position(0)
+    0
+    >>> get_highest_set_bit_position(0.8)
+    Traceback (most recent call last):
+        ...
+    TypeError: Input value must be an 'int' type
+    """
+    if not isinstance(number, int):
+        raise TypeError("Input value must be an 'int' type")
+
+    position = 0
+    while number:
+        position += 1
+        number >>= 1
+
+    return position
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/index_of_rightmost_set_bit.py

@@ -0,0 +1,51 @@
+# Reference: https://www.geeksforgeeks.org/position-of-rightmost-set-bit/
+
+
+def get_index_of_rightmost_set_bit(number: int) -> int:
+    """
+    Take in a positive integer 'number'.
+    Returns the zero-based index of first set bit in that 'number' from right.
+    Returns -1, If no set bit found.
+
+    >>> get_index_of_rightmost_set_bit(0)
+    -1
+    >>> get_index_of_rightmost_set_bit(5)
+    0
+    >>> get_index_of_rightmost_set_bit(36)
+    2
+    >>> get_index_of_rightmost_set_bit(8)
+    3
+    >>> get_index_of_rightmost_set_bit(-18)
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
+    >>> get_index_of_rightmost_set_bit('test')
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
+    >>> get_index_of_rightmost_set_bit(1.25)
+    Traceback (most recent call last):
+        ...
+    ValueError: Input must be a non-negative integer
+    """
+
+    if not isinstance(number, int) or number < 0:
+        raise ValueError("Input must be a non-negative integer")
+
+    intermediate = number & ~(number - 1)
+    index = 0
+    while intermediate:
+        intermediate >>= 1
+        index += 1
+    return index - 1
+
+
+if __name__ == "__main__":
+    """
+    Finding the index of rightmost set bit has some very peculiar use-cases,
+    especially in finding missing or/and repeating numbers in a list of
+    positive integers.
+    """
+    import doctest
+
+    doctest.testmod(verbose=True)

bit_manipulation/is_even.py

@@ -0,0 +1,37 @@
+def is_even(number: int) -> bool:
+    """
+    return true if the input integer is even
+    Explanation: Lets take a look at the following deicmal to binary conversions
+    2 => 10
+    14 => 1110
+    100 => 1100100
+    3 => 11
+    13 => 1101
+    101 => 1100101
+    from the above examples we can observe that
+    for all the odd integers there is always 1 set bit at the end
+    also, 1 in binary can be represented as 001, 00001, or 0000001
+    so for any odd integer n => n&1 is always equals 1 else the integer is even
+
+    >>> is_even(1)
+    False
+    >>> is_even(4)
+    True
+    >>> is_even(9)
+    False
+    >>> is_even(15)
+    False
+    >>> is_even(40)
+    True
+    >>> is_even(100)
+    True
+    >>> is_even(101)
+    False
+    """
+    return number & 1 == 0
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/is_power_of_two.py

@@ -0,0 +1,57 @@
+"""
+Author  : Alexander Pantyukhin
+Date    : November 1, 2022
+
+Task:
+Given a positive int number. Return True if this number is power of 2
+or False otherwise.
+
+Implementation notes: Use bit manipulation.
+For example if the number is the power of two it's bits representation:
+n     = 0..100..00
+n - 1 = 0..011..11
+
+n & (n - 1) - no intersections = 0
+"""
+
+
+def is_power_of_two(number: int) -> bool:
+    """
+    Return True if this number is power of 2 or False otherwise.
+
+    >>> is_power_of_two(0)
+    True
+    >>> is_power_of_two(1)
+    True
+    >>> is_power_of_two(2)
+    True
+    >>> is_power_of_two(4)
+    True
+    >>> is_power_of_two(6)
+    False
+    >>> is_power_of_two(8)
+    True
+    >>> is_power_of_two(17)
+    False
+    >>> is_power_of_two(-1)
+    Traceback (most recent call last):
+        ...
+    ValueError: number must not be negative
+    >>> is_power_of_two(1.2)
+    Traceback (most recent call last):
+        ...
+    TypeError: unsupported operand type(s) for &: 'float' and 'float'
+
+    # Test all powers of 2 from 0 to 10,000
+    >>> all(is_power_of_two(int(2 ** i)) for i in range(10000))
+    True
+    """
+    if number < 0:
+        raise ValueError("number must not be negative")
+    return number & (number - 1) == 0
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/numbers_different_signs.py

@@ -0,0 +1,39 @@
+"""
+Author  : Alexander Pantyukhin
+Date    : November 30, 2022
+
+Task:
+Given two int numbers. Return True these numbers have opposite signs
+or False otherwise.
+
+Implementation notes: Use bit manipulation.
+Use XOR for two numbers.
+"""
+
+
+def different_signs(num1: int, num2: int) -> bool:
+    """
+    Return True if numbers have opposite signs False otherwise.
+
+    >>> different_signs(1, -1)
+    True
+    >>> different_signs(1, 1)
+    False
+    >>> different_signs(1000000000000000000000000000, -1000000000000000000000000000)
+    True
+    >>> different_signs(-1000000000000000000000000000, 1000000000000000000000000000)
+    True
+    >>> different_signs(50, 278)
+    False
+    >>> different_signs(0, 2)
+    False
+    >>> different_signs(2, 0)
+    False
+    """
+    return num1 ^ num2 < 0
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

bit_manipulation/reverse_bits.py

@@ -14,10 +14,11 @@ def get_reverse_bit_string(number: int) -> str:
     TypeError: operation can not be conducted on a object of type str
     """
     if not isinstance(number, int):
-        raise TypeError(
+        msg = (
             "operation can not be conducted on a object of type "
             f"{type(number).__name__}"
         )
+        raise TypeError(msg)
     bit_string = ""
     for _ in range(0, 32):
         bit_string += str(number % 2)

blockchain/README.md

@@ -0,0 +1,45 @@
+# Blockchain
+
+A Blockchain is a type of **distributed ledger** technology (DLT) that consists of growing list of records, called **blocks**, that are securely linked together using **cryptography**.
+
+Let's breakdown the terminologies in the above definition. We find below terminologies,
+
+- Digital Ledger Technology (DLT)
+- Blocks
+- Cryptography
+
+## Digital Ledger Technology
+
+ It is otherwise called as distributed ledger technology. It is simply the opposite of centralized database. Firstly, what is a **ledger**? A ledger is a book or collection of accounts that records account transactions.
+
+ *Why is Blockchain addressed as digital ledger if it can record more than account transactions? What other transaction details and information can it hold?*
+
+Digital Ledger Technology is just a ledger which is shared among multiple nodes. This way there exist no need for central authority to hold the info. Okay, how is it differentiated from central database and what are their benefits?
+
+There is an organization which has 4 branches whose data are stored in a centralized database. So even if one branch needs any data from ledger they need an approval from database in charge. And if one hacks the central database he gets to tamper and control all the data.
+
+Now lets assume every branch has a copy of the ledger and then once anything is added to the ledger by anyone branch it is gonna automatically reflect in all other ledgers available in other branch. This is done using Peer-to-peer network.
+
+So this means even if information is tampered in one branch we can find out. If one branch is hacked we can be alerted ,so we can safeguard other branches. Now, assume these branches as computers or nodes and the ledger is a transaction record or digital receipt. If one ledger is hacked in a node we can detect since there will be a mismatch in comparison with other node information. So this is the concept of Digital Ledger Technology.
+
+*Is it required for all nodes to have access to all information in other nodes? Wouldn't this require enormous storage space in each node?*
+
+## Blocks
+
+In short a block is nothing but collections of records with a labelled header. These are connected cryptographically. Once a new block is added to a chain, the previous block is connected, more precisely said as locked and hence, will remain unaltered. We can understand this concept once we get a clear understanding of working mechanism of blockchain.
+
+## Cryptography
+
+It is the practice and study of secure communication techniques in the midst of adversarial behavior. More broadly, cryptography is the creation and analysis of protocols that prevent third parties or the general public from accessing private messages.
+
+*Which cryptography technology is most widely used in blockchain and why?*
+
+So, in general, blockchain technology is a distributed record holder which records the information about ownership of an asset. To define precisely,
+> Blockchain is a distributed, immutable ledger that makes it easier to record transactions and track assets in a corporate network.
+An asset could be tangible (such as a house, car, cash, or land) or intangible (such as a business) (intellectual property, patents, copyrights, branding). A blockchain network can track and sell almost anything of value, lowering risk and costs for everyone involved.
+
+So this is all about introduction to blockchain technology. To learn more about the topic refer below links....
+* <https://en.wikipedia.org/wiki/Blockchain>
+* <https://en.wikipedia.org/wiki/Chinese_remainder_theorem>
+* <https://en.wikipedia.org/wiki/Diophantine_equation>
+* <https://www.geeksforgeeks.org/modular-division/>

blockchain/chinese_remainder_theorem.py

@@ -53,6 +53,7 @@ def chinese_remainder_theorem(n1: int, r1: int, n2: int, r2: int) -> int:
 
 # ----------SAME SOLUTION USING InvertModulo instead ExtendedEuclid----------------
 
+
 # This function find the inverses of a i.e., a^(-1)
 def invert_modulo(a: int, n: int) -> int:
     """

boolean_algebra/and_gate.py

@@ -0,0 +1,50 @@
+"""
+An AND Gate is a logic gate in boolean algebra which results to 1 (True) if both the
+inputs are 1, and 0 (False) otherwise.
+
+Following is the truth table of an AND Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    0   |
+    |    0    |    1    |    0   |
+    |    1    |    0    |    0   |
+    |    1    |    1    |    1   |
+    ------------------------------
+
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def and_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate AND of the input values
+
+    >>> and_gate(0, 0)
+    0
+    >>> and_gate(0, 1)
+    0
+    >>> and_gate(1, 0)
+    0
+    >>> and_gate(1, 1)
+    1
+    """
+    return int((input_1, input_2).count(0) == 0)
+
+
+def test_and_gate() -> None:
+    """
+    Tests the and_gate function
+    """
+    assert and_gate(0, 0) == 0
+    assert and_gate(0, 1) == 0
+    assert and_gate(1, 0) == 0
+    assert and_gate(1, 1) == 1
+
+
+if __name__ == "__main__":
+    test_and_gate()
+    print(and_gate(1, 0))
+    print(and_gate(0, 0))
+    print(and_gate(0, 1))
+    print(and_gate(1, 1))

boolean_algebra/nand_gate.py

@@ -0,0 +1,47 @@
+"""
+A NAND Gate is a logic gate in boolean algebra which results to 0 (False) if both
+the inputs are 1, and 1 (True) otherwise. It's similar to adding
+a NOT gate along with an AND gate.
+Following is the truth table of a NAND Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    1   |
+    |    0    |    1    |    1   |
+    |    1    |    0    |    1   |
+    |    1    |    1    |    0   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def nand_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate NAND of the input values
+    >>> nand_gate(0, 0)
+    1
+    >>> nand_gate(0, 1)
+    1
+    >>> nand_gate(1, 0)
+    1
+    >>> nand_gate(1, 1)
+    0
+    """
+    return int((input_1, input_2).count(0) != 0)
+
+
+def test_nand_gate() -> None:
+    """
+    Tests the nand_gate function
+    """
+    assert nand_gate(0, 0) == 1
+    assert nand_gate(0, 1) == 1
+    assert nand_gate(1, 0) == 1
+    assert nand_gate(1, 1) == 0
+
+
+if __name__ == "__main__":
+    print(nand_gate(0, 0))
+    print(nand_gate(0, 1))
+    print(nand_gate(1, 0))
+    print(nand_gate(1, 1))

boolean_algebra/norgate.py

@@ -0,0 +1,48 @@
+"""
+A NOR Gate is a logic gate in boolean algebra which results to false(0)
+if any of the input is 1, and True(1) if  both the inputs are 0.
+Following is the truth table of a NOR Gate:
+   | Input 1 | Input 2 |  Output |
+   |      0      |     0      |      1      |
+   |      0      |     1      |      0      |
+   |      1      |     0      |      0      |
+   |      1      |     1      |      0      |
+
+Following is the code implementation of the NOR Gate
+"""
+
+
+def nor_gate(input_1: int, input_2: int) -> int:
+    """
+    >>> nor_gate(0, 0)
+    1
+    >>> nor_gate(0, 1)
+    0
+    >>> nor_gate(1, 0)
+    0
+    >>> nor_gate(1, 1)
+    0
+    >>> nor_gate(0.0, 0.0)
+    1
+    >>> nor_gate(0, -7)
+    0
+    """
+    return int(input_1 == input_2 == 0)
+
+
+def main() -> None:
+    print("Truth Table of NOR Gate:")
+    print("|   Input 1   |  Input 2  | Output |")
+    print(f"|      0      |    0      |  {nor_gate(0, 0)}     |")
+    print(f"|      0      |    1      |  {nor_gate(0, 1)}     |")
+    print(f"|      1      |    0      |  {nor_gate(1, 0)}     |")
+    print(f"|      1      |    1      |  {nor_gate(1, 1)}     |")
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    main()
+"""Code provided by Akshaj Vishwanathan"""
+"""Reference: https://www.geeksforgeeks.org/logic-gates-in-python/"""

boolean_algebra/not_gate.py

@@ -0,0 +1,37 @@
+"""
+A NOT Gate is a logic gate in boolean algebra which results to 0 (False) if the
+input is high, and 1 (True) if the input is low.
+Following is the truth table of a XOR Gate:
+    ------------------------------
+    | Input   |  Output |
+    ------------------------------
+    |    0    |    1    |
+    |    1    |    0    |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def not_gate(input_1: int) -> int:
+    """
+    Calculate NOT of the input values
+    >>> not_gate(0)
+    1
+    >>> not_gate(1)
+    0
+    """
+
+    return 1 if input_1 == 0 else 0
+
+
+def test_not_gate() -> None:
+    """
+    Tests the not_gate function
+    """
+    assert not_gate(0) == 1
+    assert not_gate(1) == 0
+
+
+if __name__ == "__main__":
+    print(not_gate(0))
+    print(not_gate(1))

boolean_algebra/or_gate.py

@@ -0,0 +1,46 @@
+"""
+An OR Gate is a logic gate in boolean algebra which results to 0 (False) if both the
+inputs are 0, and 1 (True) otherwise.
+Following is the truth table of an AND Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    0   |
+    |    0    |    1    |    1   |
+    |    1    |    0    |    1   |
+    |    1    |    1    |    1   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def or_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate OR of the input values
+    >>> or_gate(0, 0)
+    0
+    >>> or_gate(0, 1)
+    1
+    >>> or_gate(1, 0)
+    1
+    >>> or_gate(1, 1)
+    1
+    """
+    return int((input_1, input_2).count(1) != 0)
+
+
+def test_or_gate() -> None:
+    """
+    Tests the or_gate function
+    """
+    assert or_gate(0, 0) == 0
+    assert or_gate(0, 1) == 1
+    assert or_gate(1, 0) == 1
+    assert or_gate(1, 1) == 1
+
+
+if __name__ == "__main__":
+    print(or_gate(0, 1))
+    print(or_gate(1, 0))
+    print(or_gate(0, 0))
+    print(or_gate(1, 1))

boolean_algebra/quine_mc_cluskey.py

@@ -1,15 +1,16 @@
 from __future__ import annotations
 
 from collections.abc import Sequence
+from typing import Literal
 
 
-def compare_string(string1: str, string2: str) -> str:
+def compare_string(string1: str, string2: str) -> str | Literal[False]:
     """
     >>> compare_string('0010','0110')
     '0_10'
 
     >>> compare_string('0110','1101')
-    'X'
+    False
     """
     list1 = list(string1)
     list2 = list(string2)
@@ -19,7 +20,7 @@ def compare_string(string1: str, string2: str) -> str:
             count += 1
             list1[i] = "_"
     if count > 1:
-        return "X"
+        return False
     else:
         return "".join(list1)
 
@@ -36,10 +37,10 @@ def check(binary: list[str]) -> list[str]:
         for i in range(len(binary)):
             for j in range(i + 1, len(binary)):
                 k = compare_string(binary[i], binary[j])
-                if k != "X":
+                if k is False:
                     check1[i] = "*"
                     check1[j] = "*"
-                    temp.append(k)
+                    temp.append("X")
         for i in range(len(binary)):
             if check1[i] == "$":
                 pi.append(binary[i])
@@ -56,7 +57,7 @@ def decimal_to_binary(no_of_variable: int, minterms: Sequence[float]) -> list[st
     temp = []
     for minterm in minterms:
         string = ""
-        for i in range(no_of_variable):
+        for _ in range(no_of_variable):
             string = str(minterm % 2) + string
             minterm //= 2
         temp.append(string)
@@ -73,10 +74,7 @@ def is_for_table(string1: str, string2: str, count: int) -> bool:
     """
     list1 = list(string1)
     list2 = list(string2)
-    count_n = 0
-    for i in range(len(list1)):
-        if list1[i] != list2[i]:
-            count_n += 1
+    count_n = sum(item1 != item2 for item1, item2 in zip(list1, list2))
     return count_n == count
 
 
@@ -91,40 +89,34 @@ def selection(chart: list[list[int]], prime_implicants: list[str]) -> list[str]:
     temp = []
     select = [0] * len(chart)
     for i in range(len(chart[0])):
-        count = 0
-        rem = -1
-        for j in range(len(chart)):
-            if chart[j][i] == 1:
-                count += 1
-                rem = j
+        count = sum(row[i] == 1 for row in chart)
         if count == 1:
+            rem = max(j for j, row in enumerate(chart) if row[i] == 1)
             select[rem] = 1
-    for i in range(len(select)):
-        if select[i] == 1:
-            for j in range(len(chart[0])):
-                if chart[i][j] == 1:
-                    for k in range(len(chart)):
-                        chart[k][j] = 0
-            temp.append(prime_implicants[i])
+    for i, item in enumerate(select):
+        if item != 1:
+            continue
+        for j in range(len(chart[0])):
+            if chart[i][j] != 1:
+                continue
+            for row in chart:
+                row[j] = 0
+        temp.append(prime_implicants[i])
     while True:
-        max_n = 0
-        rem = -1
-        count_n = 0
-        for i in range(len(chart)):
-            count_n = chart[i].count(1)
-            if count_n > max_n:
-                max_n = count_n
-                rem = i
+        counts = [chart[i].count(1) for i in range(len(chart))]
+        max_n = max(counts)
+        rem = counts.index(max_n)
 
         if max_n == 0:
             return temp
 
         temp.append(prime_implicants[rem])
 
-        for i in range(len(chart[0])):
-            if chart[rem][i] == 1:
-                for j in range(len(chart)):
-                    chart[j][i] = 0
+        for j in range(len(chart[0])):
+            if chart[rem][j] != 1:
+                continue
+            for i in range(len(chart)):
+                chart[i][j] = 0
 
 
 def prime_implicant_chart(

boolean_algebra/xnor_gate.py

@@ -0,0 +1,48 @@
+"""
+A XNOR Gate is a logic gate in boolean algebra which results to 0 (False) if both the
+inputs are different, and 1 (True), if the inputs are same.
+It's similar to adding a NOT gate to an XOR gate
+
+Following is the truth table of a XNOR Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    1   |
+    |    0    |    1    |    0   |
+    |    1    |    0    |    0   |
+    |    1    |    1    |    1   |
+    ------------------------------
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def xnor_gate(input_1: int, input_2: int) -> int:
+    """
+    Calculate XOR of the input values
+    >>> xnor_gate(0, 0)
+    1
+    >>> xnor_gate(0, 1)
+    0
+    >>> xnor_gate(1, 0)
+    0
+    >>> xnor_gate(1, 1)
+    1
+    """
+    return 1 if input_1 == input_2 else 0
+
+
+def test_xnor_gate() -> None:
+    """
+    Tests the xnor_gate function
+    """
+    assert xnor_gate(0, 0) == 1
+    assert xnor_gate(0, 1) == 0
+    assert xnor_gate(1, 0) == 0
+    assert xnor_gate(1, 1) == 1
+
+
+if __name__ == "__main__":
+    print(xnor_gate(0, 0))
+    print(xnor_gate(0, 1))
+    print(xnor_gate(1, 0))
+    print(xnor_gate(1, 1))

boolean_algebra/xor_gate.py

@@ -0,0 +1,46 @@
+"""
+A XOR Gate is a logic gate in boolean algebra which results to 1 (True) if only one of
+the two inputs is 1, and 0 (False) if an even number of inputs are 1.
+Following is the truth table of a XOR Gate:
+    ------------------------------
+    | Input 1 | Input 2 | Output |
+    ------------------------------
+    |    0    |    0    |    0   |
+    |    0    |    1    |    1   |
+    |    1    |    0    |    1   |
+    |    1    |    1    |    0   |
+    ------------------------------
+
+Refer - https://www.geeksforgeeks.org/logic-gates-in-python/
+"""
+
+
+def xor_gate(input_1: int, input_2: int) -> int:
+    """
+    calculate xor of the input values
+
+    >>> xor_gate(0, 0)
+    0
+    >>> xor_gate(0, 1)
+    1
+    >>> xor_gate(1, 0)
+    1
+    >>> xor_gate(1, 1)
+    0
+    """
+    return (input_1, input_2).count(0) % 2
+
+
+def test_xor_gate() -> None:
+    """
+    Tests the xor_gate function
+    """
+    assert xor_gate(0, 0) == 0
+    assert xor_gate(0, 1) == 1
+    assert xor_gate(1, 0) == 1
+    assert xor_gate(1, 1) == 0
+
+
+if __name__ == "__main__":
+    print(xor_gate(0, 0))
+    print(xor_gate(0, 1))

cellular_automata/game_of_life.py

@@ -10,7 +10,7 @@ Python:
   - 3.5
 
 Usage:
-  - $python3 game_o_life <canvas_size:int>
+  - $python3 game_of_life <canvas_size:int>
 
 Game-Of-Life Rules:
 
@@ -34,7 +34,7 @@ import numpy as np
 from matplotlib import pyplot as plt
 from matplotlib.colors import ListedColormap
 
-usage_doc = "Usage of script: script_nama <size_of_canvas:int>"
+usage_doc = "Usage of script: script_name <size_of_canvas:int>"
 
 choice = [0] * 100 + [1] * 10
 random.shuffle(choice)
@@ -52,7 +52,8 @@ 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:
     --
@@ -60,21 +61,17 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:
 
     @returns:
     --
-    None
+    canvas of population after one step
     """
     current_canvas = np.array(canvas)
     next_gen_canvas = np.array(create_canvas(current_canvas.shape[0]))
     for r, row in enumerate(current_canvas):
         for c, pt in enumerate(row):
-            # print(r-1,r+2,c-1,c+2)
             next_gen_canvas[r][c] = __judge_point(
                 pt, current_canvas[r - 1 : r + 2, c - 1 : c + 2]
             )
 
-    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
+    return next_gen_canvas.tolist()
 
 
 def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:
@@ -99,7 +96,7 @@ def __judge_point(pt: bool, neighbours: list[list[bool]]) -> bool:
     if pt:
         if alive < 2:
             state = False
-        elif alive == 2 or alive == 3:
+        elif alive in {2, 3}:
             state = True
         elif alive > 3:
             state = False

cellular_automata/nagel_schrekenberg.py

@@ -45,8 +45,7 @@ def construct_highway(
 
     highway = [[-1] * number_of_cells]  # Create a highway without any car
     i = 0
-    if initial_speed < 0:
-        initial_speed = 0
+    initial_speed = max(initial_speed, 0)
     while i < number_of_cells:
         highway[0][i] = (
             randint(0, max_speed) if random_speed else initial_speed

cellular_automata/wa_tor.py

@@ -0,0 +1,550 @@
+"""
+Wa-Tor algorithm (1984)
+
+@ https://en.wikipedia.org/wiki/Wa-Tor
+@ https://beltoforion.de/en/wator/
+@ https://beltoforion.de/en/wator/images/wator_medium.webm
+
+This solution aims to completely remove any systematic approach
+to the Wa-Tor planet, and utilise fully random methods.
+
+The constants are a working set that allows the Wa-Tor planet
+to result in one of the three possible results.
+"""
+
+from collections.abc import Callable
+from random import randint, shuffle
+from time import sleep
+from typing import Literal
+
+WIDTH = 50  # Width of the Wa-Tor planet
+HEIGHT = 50  # Height of the Wa-Tor planet
+
+PREY_INITIAL_COUNT = 30  # The initial number of prey entities
+PREY_REPRODUCTION_TIME = 5  # The chronons before reproducing
+
+PREDATOR_INITIAL_COUNT = 50  # The initial number of predator entities
+# The initial energy value of predator entities
+PREDATOR_INITIAL_ENERGY_VALUE = 15
+# The energy value provided when consuming prey
+PREDATOR_FOOD_VALUE = 5
+PREDATOR_REPRODUCTION_TIME = 20  # The chronons before reproducing
+
+MAX_ENTITIES = 500  # The max number of organisms on the board
+# The number of entities to delete from the unbalanced side
+DELETE_UNBALANCED_ENTITIES = 50
+
+
+class Entity:
+    """
+    Represents an entity (either prey or predator).
+
+    >>> e = Entity(True, coords=(0, 0))
+    >>> e.prey
+    True
+    >>> e.coords
+    (0, 0)
+    >>> e.alive
+    True
+    """
+
+    def __init__(self, prey: bool, coords: tuple[int, int]) -> None:
+        self.prey = prey
+        # The (row, col) pos of the entity
+        self.coords = coords
+
+        self.remaining_reproduction_time = (
+            PREY_REPRODUCTION_TIME if prey else PREDATOR_REPRODUCTION_TIME
+        )
+        self.energy_value = None if prey is True else PREDATOR_INITIAL_ENERGY_VALUE
+        self.alive = True
+
+    def reset_reproduction_time(self) -> None:
+        """
+        >>> e = Entity(True, coords=(0, 0))
+        >>> e.reset_reproduction_time()
+        >>> e.remaining_reproduction_time == PREY_REPRODUCTION_TIME
+        True
+        >>> e = Entity(False, coords=(0, 0))
+        >>> e.reset_reproduction_time()
+        >>> e.remaining_reproduction_time == PREDATOR_REPRODUCTION_TIME
+        True
+        """
+        self.remaining_reproduction_time = (
+            PREY_REPRODUCTION_TIME if self.prey is True else PREDATOR_REPRODUCTION_TIME
+        )
+
+    def __repr__(self) -> str:
+        """
+        >>> Entity(prey=True, coords=(1, 1))
+        Entity(prey=True, coords=(1, 1), remaining_reproduction_time=5)
+        >>> Entity(prey=False, coords=(2, 1))  # doctest: +NORMALIZE_WHITESPACE
+        Entity(prey=False, coords=(2, 1),
+        remaining_reproduction_time=20, energy_value=15)
+        """
+        repr_ = (
+            f"Entity(prey={self.prey}, coords={self.coords}, "
+            f"remaining_reproduction_time={self.remaining_reproduction_time}"
+        )
+        if self.energy_value is not None:
+            repr_ += f", energy_value={self.energy_value}"
+        return f"{repr_})"
+
+
+class WaTor:
+    """
+    Represents the main Wa-Tor algorithm.
+
+    :attr time_passed: A function that is called every time
+        time passes (a chronon) in order to visually display
+        the new Wa-Tor planet. The time_passed function can block
+        using time.sleep to slow the algorithm progression.
+
+    >>> wt = WaTor(10, 15)
+    >>> wt.width
+    10
+    >>> wt.height
+    15
+    >>> len(wt.planet)
+    15
+    >>> len(wt.planet[0])
+    10
+    >>> len(wt.get_entities()) == PREDATOR_INITIAL_COUNT + PREY_INITIAL_COUNT
+    True
+    """
+
+    time_passed: Callable[["WaTor", int], None] | None
+
+    def __init__(self, width: int, height: int) -> None:
+        self.width = width
+        self.height = height
+        self.time_passed = None
+
+        self.planet: list[list[Entity | None]] = [[None] * width for _ in range(height)]
+
+        # Populate planet with predators and prey randomly
+        for _ in range(PREY_INITIAL_COUNT):
+            self.add_entity(prey=True)
+        for _ in range(PREDATOR_INITIAL_COUNT):
+            self.add_entity(prey=False)
+        self.set_planet(self.planet)
+
+    def set_planet(self, planet: list[list[Entity | None]]) -> None:
+        """
+        Ease of access for testing
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> planet = [
+        ... [None, None, None],
+        ... [None, Entity(True, coords=(1, 1)), None]
+        ... ]
+        >>> wt.set_planet(planet)
+        >>> wt.planet == planet
+        True
+        >>> wt.width
+        3
+        >>> wt.height
+        2
+        """
+        self.planet = planet
+        self.width = len(planet[0])
+        self.height = len(planet)
+
+    def add_entity(self, prey: bool) -> None:
+        """
+        Adds an entity, making sure the entity does
+        not override another entity
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([[None, None], [None, None]])
+        >>> wt.add_entity(True)
+        >>> len(wt.get_entities())
+        1
+        >>> wt.add_entity(False)
+        >>> len(wt.get_entities())
+        2
+        """
+        while True:
+            row, col = randint(0, self.height - 1), randint(0, self.width - 1)
+            if self.planet[row][col] is None:
+                self.planet[row][col] = Entity(prey=prey, coords=(row, col))
+                return
+
+    def get_entities(self) -> list[Entity]:
+        """
+        Returns a list of all the entities within the planet.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> len(wt.get_entities()) == PREDATOR_INITIAL_COUNT + PREY_INITIAL_COUNT
+        True
+        """
+        return [entity for column in self.planet for entity in column if entity]
+
+    def balance_predators_and_prey(self) -> None:
+        """
+        Balances predators and preys so that prey
+        can not dominate the predators, blocking up
+        space for them to reproduce.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> for i in range(2000):
+        ...     row, col = i // HEIGHT, i % WIDTH
+        ...     wt.planet[row][col] = Entity(True, coords=(row, col))
+        >>> entities = len(wt.get_entities())
+        >>> wt.balance_predators_and_prey()
+        >>> len(wt.get_entities()) == entities
+        False
+        """
+        entities = self.get_entities()
+        shuffle(entities)
+
+        if len(entities) >= MAX_ENTITIES - MAX_ENTITIES / 10:
+            prey = [entity for entity in entities if entity.prey]
+            predators = [entity for entity in entities if not entity.prey]
+
+            prey_count, predator_count = len(prey), len(predators)
+
+            entities_to_purge = (
+                prey[:DELETE_UNBALANCED_ENTITIES]
+                if prey_count > predator_count
+                else predators[:DELETE_UNBALANCED_ENTITIES]
+            )
+            for entity in entities_to_purge:
+                self.planet[entity.coords[0]][entity.coords[1]] = None
+
+    def get_surrounding_prey(self, entity: Entity) -> list[Entity]:
+        """
+        Returns all the prey entities around (N, S, E, W) a predator entity.
+
+        Subtly different to the try_to_move_to_unoccupied square.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([
+        ... [None, Entity(True, (0, 1)), None],
+        ... [None, Entity(False, (1, 1)), None],
+        ... [None, Entity(True, (2, 1)), None]])
+        >>> wt.get_surrounding_prey(
+        ... Entity(False, (1, 1)))  # doctest: +NORMALIZE_WHITESPACE
+        [Entity(prey=True, coords=(0, 1), remaining_reproduction_time=5),
+        Entity(prey=True, coords=(2, 1), remaining_reproduction_time=5)]
+        >>> wt.set_planet([[Entity(False, (0, 0))]])
+        >>> wt.get_surrounding_prey(Entity(False, (0, 0)))
+        []
+        >>> wt.set_planet([
+        ... [Entity(True, (0, 0)), Entity(False, (1, 0)), Entity(False, (2, 0))],
+        ... [None, Entity(False, (1, 1)), Entity(True, (2, 1))],
+        ... [None, None, None]])
+        >>> wt.get_surrounding_prey(Entity(False, (1, 0)))
+        [Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5)]
+        """
+        row, col = entity.coords
+        adjacent: list[tuple[int, int]] = [
+            (row - 1, col),  # North
+            (row + 1, col),  # South
+            (row, col - 1),  # West
+            (row, col + 1),  # East
+        ]
+
+        return [
+            ent
+            for r, c in adjacent
+            if 0 <= r < self.height
+            and 0 <= c < self.width
+            and (ent := self.planet[r][c]) is not None
+            and ent.prey
+        ]
+
+    def move_and_reproduce(
+        self, entity: Entity, direction_orders: list[Literal["N", "E", "S", "W"]]
+    ) -> None:
+        """
+        Attempts to move to an unoccupied neighbouring square
+        in either of the four directions (North, South, East, West).
+        If the move was successful and the remaining_reproduction time is
+        equal to 0, then a new prey or predator can also be created
+        in the previous square.
+
+        :param direction_orders: Ordered list (like priority queue) depicting
+                            order to attempt to move. Removes any systematic
+                            approach of checking neighbouring squares.
+
+        >>> planet = [
+        ... [None, None, None],
+        ... [None, Entity(True, coords=(1, 1)), None],
+        ... [None, None, None]
+        ... ]
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet(planet)
+        >>> wt.move_and_reproduce(Entity(True, coords=(1, 1)), direction_orders=["N"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[None, Entity(prey=True, coords=(0, 1), remaining_reproduction_time=4), None],
+        [None, None, None],
+        [None, None, None]]
+        >>> wt.planet[0][0] = Entity(True, coords=(0, 0))
+        >>> wt.move_and_reproduce(Entity(True, coords=(0, 1)),
+        ... direction_orders=["N", "W", "E", "S"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5), None,
+        Entity(prey=True, coords=(0, 2), remaining_reproduction_time=4)],
+        [None, None, None],
+        [None, None, None]]
+        >>> wt.planet[0][1] = wt.planet[0][2]
+        >>> wt.planet[0][2] = None
+        >>> wt.move_and_reproduce(Entity(True, coords=(0, 1)),
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5), None, None],
+        [None, Entity(prey=True, coords=(1, 1), remaining_reproduction_time=4), None],
+        [None, None, None]]
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> reproducable_entity = Entity(False, coords=(0, 1))
+        >>> reproducable_entity.remaining_reproduction_time = 0
+        >>> wt.planet = [[None, reproducable_entity]]
+        >>> wt.move_and_reproduce(reproducable_entity,
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=False, coords=(0, 0),
+        remaining_reproduction_time=20, energy_value=15),
+        Entity(prey=False, coords=(0, 1), remaining_reproduction_time=20,
+        energy_value=15)]]
+        """
+        row, col = coords = entity.coords
+
+        adjacent_squares: dict[Literal["N", "E", "S", "W"], tuple[int, int]] = {
+            "N": (row - 1, col),  # North
+            "S": (row + 1, col),  # South
+            "W": (row, col - 1),  # West
+            "E": (row, col + 1),  # East
+        }
+        # Weight adjacent locations
+        adjacent: list[tuple[int, int]] = []
+        for order in direction_orders:
+            adjacent.append(adjacent_squares[order])
+
+        for r, c in adjacent:
+            if (
+                0 <= r < self.height
+                and 0 <= c < self.width
+                and self.planet[r][c] is None
+            ):
+                # Move entity to empty adjacent square
+                self.planet[r][c] = entity
+                self.planet[row][col] = None
+                entity.coords = (r, c)
+                break
+
+        # (2.) See if it possible to reproduce in previous square
+        if coords != entity.coords and entity.remaining_reproduction_time <= 0:
+            # Check if the entities on the planet is less than the max limit
+            if len(self.get_entities()) < MAX_ENTITIES:
+                # Reproduce in previous square
+                self.planet[row][col] = Entity(prey=entity.prey, coords=coords)
+                entity.reset_reproduction_time()
+        else:
+            entity.remaining_reproduction_time -= 1
+
+    def perform_prey_actions(
+        self, entity: Entity, direction_orders: list[Literal["N", "E", "S", "W"]]
+    ) -> None:
+        """
+        Performs the actions for a prey entity
+
+        For prey the rules are:
+          1. At each chronon, a prey moves randomly to one of the adjacent unoccupied
+            squares. If there are no free squares, no movement takes place.
+          2. Once a prey has survived a certain number of chronons it may reproduce.
+            This is done as it moves to a neighbouring square,
+            leaving behind a new prey in its old position.
+            Its reproduction time is also reset to zero.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> reproducable_entity = Entity(True, coords=(0, 1))
+        >>> reproducable_entity.remaining_reproduction_time = 0
+        >>> wt.planet = [[None, reproducable_entity]]
+        >>> wt.perform_prey_actions(reproducable_entity,
+        ... direction_orders=["N", "W", "S", "E"])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=True, coords=(0, 0), remaining_reproduction_time=5),
+        Entity(prey=True, coords=(0, 1), remaining_reproduction_time=5)]]
+        """
+        self.move_and_reproduce(entity, direction_orders)
+
+    def perform_predator_actions(
+        self,
+        entity: Entity,
+        occupied_by_prey_coords: tuple[int, int] | None,
+        direction_orders: list[Literal["N", "E", "S", "W"]],
+    ) -> None:
+        """
+        Performs the actions for a predator entity
+
+        :param occupied_by_prey_coords: Move to this location if there is prey there
+
+        For predators the rules are:
+          1. At each chronon, a predator moves randomly to an adjacent square occupied
+            by a prey. If there is none, the predator moves to a random adjacent
+            unoccupied square. If there are no free squares, no movement takes place.
+          2. At each chronon, each predator is deprived of a unit of energy.
+          3. Upon reaching zero energy, a predator dies.
+          4. If a predator moves to a square occupied by a prey,
+            it eats the prey and earns a certain amount of energy.
+          5. Once a predator has survived a certain number of chronons
+          it may reproduce in exactly the same way as the prey.
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.set_planet([[Entity(True, coords=(0, 0)), Entity(False, coords=(0, 1))]])
+        >>> wt.perform_predator_actions(Entity(False, coords=(0, 1)), (0, 0), [])
+        >>> wt.planet  # doctest: +NORMALIZE_WHITESPACE
+        [[Entity(prey=False, coords=(0, 0),
+        remaining_reproduction_time=20, energy_value=19), None]]
+        """
+        assert entity.energy_value is not None  # [type checking]
+
+        # (3.) If the entity has 0 energy, it will die
+        if entity.energy_value == 0:
+            self.planet[entity.coords[0]][entity.coords[1]] = None
+            return
+
+        # (1.) Move to entity if possible
+        if occupied_by_prey_coords is not None:
+            # Kill the prey
+            prey = self.planet[occupied_by_prey_coords[0]][occupied_by_prey_coords[1]]
+            assert prey is not None
+            prey.alive = False
+
+            # Move onto prey
+            self.planet[occupied_by_prey_coords[0]][occupied_by_prey_coords[1]] = entity
+            self.planet[entity.coords[0]][entity.coords[1]] = None
+
+            entity.coords = occupied_by_prey_coords
+            # (4.) Eats the prey and earns energy
+            entity.energy_value += PREDATOR_FOOD_VALUE
+        else:
+            # (5.) If it has survived the certain number of chronons it will also
+            # reproduce in this function
+            self.move_and_reproduce(entity, direction_orders)
+
+        # (2.) Each chronon, the predator is deprived of a unit of energy
+        entity.energy_value -= 1
+
+    def run(self, *, iteration_count: int) -> None:
+        """
+        Emulate time passing by looping iteration_count times
+
+        >>> wt = WaTor(WIDTH, HEIGHT)
+        >>> wt.run(iteration_count=PREDATOR_INITIAL_ENERGY_VALUE - 1)
+        >>> len(list(filter(lambda entity: entity.prey is False,
+        ... wt.get_entities()))) >= PREDATOR_INITIAL_COUNT
+        True
+        """
+        for iter_num in range(iteration_count):
+            # Generate list of all entities in order to randomly
+            # pop an entity at a time to simulate true randomness
+            # This removes the systematic approach of iterating
+            # through each entity width by height
+            all_entities = self.get_entities()
+
+            for __ in range(len(all_entities)):
+                entity = all_entities.pop(randint(0, len(all_entities) - 1))
+                if entity.alive is False:
+                    continue
+
+                directions: list[Literal["N", "E", "S", "W"]] = ["N", "E", "S", "W"]
+                shuffle(directions)  # Randomly shuffle directions
+
+                if entity.prey:
+                    self.perform_prey_actions(entity, directions)
+                else:
+                    # Create list of surrounding prey
+                    surrounding_prey = self.get_surrounding_prey(entity)
+                    surrounding_prey_coords = None
+
+                    if surrounding_prey:
+                        # Again, randomly shuffle directions
+                        shuffle(surrounding_prey)
+                        surrounding_prey_coords = surrounding_prey[0].coords
+
+                    self.perform_predator_actions(
+                        entity, surrounding_prey_coords, directions
+                    )
+
+            # Balance out the predators and prey
+            self.balance_predators_and_prey()
+
+            if self.time_passed is not None:
+                # Call time_passed function for Wa-Tor planet
+                # visualisation in a terminal or a graph.
+                self.time_passed(self, iter_num)
+
+
+def visualise(wt: WaTor, iter_number: int, *, colour: bool = True) -> None:
+    """
+    Visually displays the Wa-Tor planet using
+    an ascii code in terminal to clear and re-print
+    the Wa-Tor planet at intervals.
+
+    Uses ascii colour codes to colourfully display
+    the predators and prey.
+
+    (0x60f197) Prey = #
+    (0xfffff) Predator = x
+
+    >>> wt = WaTor(30, 30)
+    >>> wt.set_planet([
+    ... [Entity(True, coords=(0, 0)), Entity(False, coords=(0, 1)), None],
+    ... [Entity(False, coords=(1, 0)), None, Entity(False, coords=(1, 2))],
+    ... [None, Entity(True, coords=(2, 1)), None]
+    ... ])
+    >>> visualise(wt, 0, colour=False)  # doctest: +NORMALIZE_WHITESPACE
+    #  x  .
+    x  .  x
+    .  #  .
+    <BLANKLINE>
+    Iteration: 0 | Prey count: 2 | Predator count: 3 |
+    """
+    if colour:
+        __import__("os").system("")
+        print("\x1b[0;0H\x1b[2J\x1b[?25l")
+
+    reprint = "\x1b[0;0H" if colour else ""
+    ansi_colour_end = "\x1b[0m " if colour else " "
+
+    planet = wt.planet
+    output = ""
+
+    # Iterate over every entity in the planet
+    for row in planet:
+        for entity in row:
+            if entity is None:
+                output += " . "
+            else:
+                if colour is True:
+                    output += (
+                        "\x1b[38;2;96;241;151m"
+                        if entity.prey
+                        else "\x1b[38;2;255;255;15m"
+                    )
+                output += f" {'#' if entity.prey else 'x'}{ansi_colour_end}"
+
+        output += "\n"
+
+    entities = wt.get_entities()
+    prey_count = sum(entity.prey for entity in entities)
+
+    print(
+        f"{output}\n Iteration: {iter_number} | Prey count: {prey_count} | "
+        f"Predator count: {len(entities) - prey_count} | {reprint}"
+    )
+    # Block the thread to be able to visualise seeing the algorithm
+    sleep(0.05)
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+
+    wt = WaTor(WIDTH, HEIGHT)
+    wt.time_passed = visualise
+    wt.run(iteration_count=100_000)

ciphers/affine_cipher.py

@@ -9,26 +9,26 @@ SYMBOLS = (
 )
 
 
-def check_keys(keyA: int, keyB: int, mode: str) -> None:
+def check_keys(key_a: int, key_b: int, mode: str) -> None:
     if mode == "encrypt":
-        if keyA == 1:
+        if key_a == 1:
             sys.exit(
                 "The affine cipher becomes weak when key "
                 "A is set to 1. Choose different key"
             )
-        if keyB == 0:
+        if key_b == 0:
             sys.exit(
                 "The affine cipher becomes weak when key "
                 "B is set to 0. Choose different key"
             )
-    if keyA < 0 or keyB < 0 or keyB > len(SYMBOLS) - 1:
+    if key_a < 0 or key_b < 0 or key_b > len(SYMBOLS) - 1:
         sys.exit(
             "Key A must be greater than 0 and key B must "
             f"be between 0 and {len(SYMBOLS) - 1}."
         )
-    if cryptomath.gcd(keyA, len(SYMBOLS)) != 1:
+    if cryptomath.gcd(key_a, len(SYMBOLS)) != 1:
         sys.exit(
-            f"Key A {keyA} and the symbol set size {len(SYMBOLS)} "
+            f"Key A {key_a} and the symbol set size {len(SYMBOLS)} "
             "are not relatively prime. Choose a different key."
         )
 
@@ -39,16 +39,16 @@ def encrypt_message(key: int, message: str) -> str:
     ...                       'substitution cipher.')
     'VL}p MM{I}p~{HL}Gp{vp pFsH}pxMpyxIx JHL O}F{~pvuOvF{FuF{xIp~{HL}Gi'
     """
-    keyA, keyB = divmod(key, len(SYMBOLS))
-    check_keys(keyA, keyB, "encrypt")
-    cipherText = ""
+    key_a, key_b = divmod(key, len(SYMBOLS))
+    check_keys(key_a, key_b, "encrypt")
+    cipher_text = ""
     for symbol in message:
         if symbol in SYMBOLS:
-            symIndex = SYMBOLS.find(symbol)
-            cipherText += SYMBOLS[(symIndex * keyA + keyB) % len(SYMBOLS)]
+            sym_index = SYMBOLS.find(symbol)
+            cipher_text += SYMBOLS[(sym_index * key_a + key_b) % len(SYMBOLS)]
         else:
-            cipherText += symbol
-    return cipherText
+            cipher_text += symbol
+    return cipher_text
 
 
 def decrypt_message(key: int, message: str) -> str:
@@ -57,25 +57,27 @@ def decrypt_message(key: int, message: str) -> str:
     ...                       '{xIp~{HL}Gi')
     'The affine cipher is a type of monoalphabetic substitution cipher.'
     """
-    keyA, keyB = divmod(key, len(SYMBOLS))
-    check_keys(keyA, keyB, "decrypt")
-    plainText = ""
-    modInverseOfkeyA = cryptomath.find_mod_inverse(keyA, len(SYMBOLS))
+    key_a, key_b = divmod(key, len(SYMBOLS))
+    check_keys(key_a, key_b, "decrypt")
+    plain_text = ""
+    mod_inverse_of_key_a = cryptomath.find_mod_inverse(key_a, len(SYMBOLS))
     for symbol in message:
         if symbol in SYMBOLS:
-            symIndex = SYMBOLS.find(symbol)
-            plainText += SYMBOLS[(symIndex - keyB) * modInverseOfkeyA % len(SYMBOLS)]
+            sym_index = SYMBOLS.find(symbol)
+            plain_text += SYMBOLS[
+                (sym_index - key_b) * mod_inverse_of_key_a % len(SYMBOLS)
+            ]
         else:
-            plainText += symbol
-    return plainText
+            plain_text += symbol
+    return plain_text
 
 
 def get_random_key() -> int:
     while True:
-        keyA = random.randint(2, len(SYMBOLS))
-        keyB = random.randint(2, len(SYMBOLS))
-        if cryptomath.gcd(keyA, len(SYMBOLS)) == 1 and keyB % len(SYMBOLS) != 0:
-            return keyA * len(SYMBOLS) + keyB
+        key_b = random.randint(2, len(SYMBOLS))
+        key_b = random.randint(2, len(SYMBOLS))
+        if cryptomath.gcd(key_b, len(SYMBOLS)) == 1 and key_b % len(SYMBOLS) != 0:
+            return key_b * len(SYMBOLS) + key_b
 
 
 def main() -> None:

ciphers/atbash.py

@@ -38,26 +38,13 @@ def atbash(sequence: str) -> str:
 
 
 def benchmark() -> None:
-    """Let's benchmark them side-by-side..."""
+    """Let's benchmark our functions side-by-side..."""
     from timeit import timeit
 
     print("Running performance benchmarks...")
-    print(
-        "> atbash_slow()",
-        timeit(
-            "atbash_slow(printable)",
-            setup="from string import printable ; from __main__ import atbash_slow",
-        ),
-        "seconds",
-    )
-    print(
-        ">      atbash()",
-        timeit(
-            "atbash(printable)",
-            setup="from string import printable ; from __main__ import atbash",
-        ),
-        "seconds",
-    )
+    setup = "from string import printable ; from __main__ import atbash, atbash_slow"
+    print(f"> atbash_slow(): {timeit('atbash_slow(printable)', setup=setup)} seconds")
+    print(f">      atbash(): {timeit('atbash(printable)', setup=setup)} seconds")
 
 
 if __name__ == "__main__":

ciphers/autokey.py

@@ -0,0 +1,131 @@
+"""
+https://en.wikipedia.org/wiki/Autokey_cipher
+An autokey cipher (also known as the autoclave cipher) is a cipher that
+incorporates the message (the plaintext) into the key.
+The key is generated from the message in some automated fashion,
+sometimes by selecting certain letters from the text or, more commonly,
+by adding a short primer key to the front of the message.
+"""
+
+
+def encrypt(plaintext: str, key: str) -> str:
+    """
+    Encrypt a given plaintext (string) and key (string), returning the
+    encrypted ciphertext.
+    >>> encrypt("hello world", "coffee")
+    'jsqqs avvwo'
+    >>> encrypt("coffee is good as python", "TheAlgorithms")
+    'vvjfpk wj ohvp su ddylsv'
+    >>> encrypt("coffee is good as python", 2)
+    Traceback (most recent call last):
+        ...
+    TypeError: key must be a string
+    >>> encrypt("", "TheAlgorithms")
+    Traceback (most recent call last):
+        ...
+    ValueError: plaintext is empty
+    """
+    if not isinstance(plaintext, str):
+        raise TypeError("plaintext must be a string")
+    if not isinstance(key, str):
+        raise TypeError("key must be a string")
+
+    if not plaintext:
+        raise ValueError("plaintext is empty")
+    if not key:
+        raise ValueError("key is empty")
+
+    key += plaintext
+    plaintext = plaintext.lower()
+    key = key.lower()
+    plaintext_iterator = 0
+    key_iterator = 0
+    ciphertext = ""
+    while plaintext_iterator < len(plaintext):
+        if (
+            ord(plaintext[plaintext_iterator]) < 97
+            or ord(plaintext[plaintext_iterator]) > 122
+        ):
+            ciphertext += plaintext[plaintext_iterator]
+            plaintext_iterator += 1
+        elif ord(key[key_iterator]) < 97 or ord(key[key_iterator]) > 122:
+            key_iterator += 1
+        else:
+            ciphertext += chr(
+                (
+                    (ord(plaintext[plaintext_iterator]) - 97 + ord(key[key_iterator]))
+                    - 97
+                )
+                % 26
+                + 97
+            )
+            key_iterator += 1
+            plaintext_iterator += 1
+    return ciphertext
+
+
+def decrypt(ciphertext: str, key: str) -> str:
+    """
+    Decrypt a given ciphertext (string) and key (string), returning the decrypted
+    ciphertext.
+    >>> decrypt("jsqqs avvwo", "coffee")
+    'hello world'
+    >>> decrypt("vvjfpk wj ohvp su ddylsv", "TheAlgorithms")
+    'coffee is good as python'
+    >>> decrypt("vvjfpk wj ohvp su ddylsv", "")
+    Traceback (most recent call last):
+        ...
+    ValueError: key is empty
+    >>> decrypt(527.26, "TheAlgorithms")
+    Traceback (most recent call last):
+        ...
+    TypeError: ciphertext must be a string
+    """
+    if not isinstance(ciphertext, str):
+        raise TypeError("ciphertext must be a string")
+    if not isinstance(key, str):
+        raise TypeError("key must be a string")
+
+    if not ciphertext:
+        raise ValueError("ciphertext is empty")
+    if not key:
+        raise ValueError("key is empty")
+
+    key = key.lower()
+    ciphertext_iterator = 0
+    key_iterator = 0
+    plaintext = ""
+    while ciphertext_iterator < len(ciphertext):
+        if (
+            ord(ciphertext[ciphertext_iterator]) < 97
+            or ord(ciphertext[ciphertext_iterator]) > 122
+        ):
+            plaintext += ciphertext[ciphertext_iterator]
+        else:
+            plaintext += chr(
+                (ord(ciphertext[ciphertext_iterator]) - ord(key[key_iterator])) % 26
+                + 97
+            )
+            key += chr(
+                (ord(ciphertext[ciphertext_iterator]) - ord(key[key_iterator])) % 26
+                + 97
+            )
+            key_iterator += 1
+        ciphertext_iterator += 1
+    return plaintext
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    operation = int(input("Type 1 to encrypt or 2 to decrypt:"))
+    if operation == 1:
+        plaintext = input("Typeplaintext to be encrypted:\n")
+        key = input("Type the key:\n")
+        print(encrypt(plaintext, key))
+    elif operation == 2:
+        ciphertext = input("Type the ciphertext to be decrypted:\n")
+        key = input("Type the key:\n")
+        print(decrypt(ciphertext, key))
+    decrypt("jsqqs avvwo", "coffee")

ciphers/base16.py

@@ -1,34 +1,63 @@
-import base64
-
-
-def base16_encode(inp: str) -> bytes:
+def base16_encode(data: bytes) -> str:
     """
-    Encodes a given utf-8 string into base-16.
+    Encodes the given bytes into base16.
 
-    >>> base16_encode('Hello World!')
-    b'48656C6C6F20576F726C6421'
-    >>> base16_encode('HELLO WORLD!')
-    b'48454C4C4F20574F524C4421'
-    >>> base16_encode('')
-    b''
-    """
-    # encode the input into a bytes-like object and then encode b16encode that
-    return base64.b16encode(inp.encode("utf-8"))
-
-
-def base16_decode(b16encoded: bytes) -> str:
-    """
-    Decodes from base-16 to a utf-8 string.
-
-    >>> base16_decode(b'48656C6C6F20576F726C6421')
-    'Hello World!'
-    >>> base16_decode(b'48454C4C4F20574F524C4421')
-    'HELLO WORLD!'
-    >>> base16_decode(b'')
+    >>> base16_encode(b'Hello World!')
+    '48656C6C6F20576F726C6421'
+    >>> base16_encode(b'HELLO WORLD!')
+    '48454C4C4F20574F524C4421'
+    >>> base16_encode(b'')
     ''
     """
-    # b16decode the input into bytes and decode that into a human readable string
-    return base64.b16decode(b16encoded).decode("utf-8")
+    # Turn the data into a list of integers (where each integer is a byte),
+    # Then turn each byte into its hexadecimal representation, make sure
+    # it is uppercase, and then join everything together and return it.
+    return "".join([hex(byte)[2:].zfill(2).upper() for byte in list(data)])
+
+
+def base16_decode(data: str) -> bytes:
+    """
+    Decodes the given base16 encoded data into bytes.
+
+    >>> base16_decode('48656C6C6F20576F726C6421')
+    b'Hello World!'
+    >>> base16_decode('48454C4C4F20574F524C4421')
+    b'HELLO WORLD!'
+    >>> base16_decode('')
+    b''
+    >>> base16_decode('486')
+    Traceback (most recent call last):
+      ...
+    ValueError: Base16 encoded data is invalid:
+    Data does not have an even number of hex digits.
+    >>> base16_decode('48656c6c6f20576f726c6421')
+    Traceback (most recent call last):
+      ...
+    ValueError: Base16 encoded data is invalid:
+    Data is not uppercase hex or it contains invalid characters.
+    >>> base16_decode('This is not base64 encoded data.')
+    Traceback (most recent call last):
+      ...
+    ValueError: Base16 encoded data is invalid:
+    Data is not uppercase hex or it contains invalid characters.
+    """
+    # Check data validity, following RFC3548
+    # https://www.ietf.org/rfc/rfc3548.txt
+    if (len(data) % 2) != 0:
+        raise ValueError(
+            """Base16 encoded data is invalid:
+Data does not have an even number of hex digits."""
+        )
+    # Check the character set - the standard base16 alphabet
+    # is uppercase according to RFC3548 section 6
+    if not set(data) <= set("0123456789ABCDEF"):
+        raise ValueError(
+            """Base16 encoded data is invalid:
+Data is not uppercase hex or it contains invalid characters."""
+        )
+    # For every two hexadecimal digits (= a byte), turn it into an integer.
+    # Then, string the result together into bytes, and return it.
+    return bytes(int(data[i] + data[i + 1], 16) for i in range(0, len(data), 2))
 
 
 if __name__ == "__main__":

ciphers/base64.py

@@ -34,9 +34,8 @@ def base64_encode(data: bytes) -> bytes:
     """
     # Make sure the supplied data is a bytes-like object
     if not isinstance(data, bytes):
-        raise TypeError(
-            f"a bytes-like object is required, not '{data.__class__.__name__}'"
-        )
+        msg = f"a bytes-like object is required, not '{data.__class__.__name__}'"
+        raise TypeError(msg)
 
     binary_stream = "".join(bin(byte)[2:].zfill(8) for byte in data)
 
@@ -88,10 +87,11 @@ def base64_decode(encoded_data: str) -> bytes:
     """
     # Make sure encoded_data is either a string or a bytes-like object
     if not isinstance(encoded_data, bytes) and not isinstance(encoded_data, str):
-        raise TypeError(
-            "argument should be a bytes-like object or ASCII string, not "
-            f"'{encoded_data.__class__.__name__}'"
+        msg = (
+            "argument should be a bytes-like object or ASCII string, "
+            f"not '{encoded_data.__class__.__name__}'"
         )
+        raise TypeError(msg)
 
     # In case encoded_data is a bytes-like object, make sure it contains only
     # ASCII characters so we convert it to a string object

ciphers/beaufort_cipher.py

@@ -5,7 +5,7 @@ Author: Mohit Radadiya
 from string import ascii_uppercase
 
 dict1 = {char: i for i, char in enumerate(ascii_uppercase)}
-dict2 = {i: char for i, char in enumerate(ascii_uppercase)}
+dict2 = dict(enumerate(ascii_uppercase))
 
 
 # This function generates the key in

ciphers/bifid.py

@@ -9,16 +9,17 @@ https://www.braingle.com/brainteasers/codes/bifid.php
 
 import numpy as np
 
+SQUARE = [
+    ["a", "b", "c", "d", "e"],
+    ["f", "g", "h", "i", "k"],
+    ["l", "m", "n", "o", "p"],
+    ["q", "r", "s", "t", "u"],
+    ["v", "w", "x", "y", "z"],
+]
+
 
 class BifidCipher:
     def __init__(self) -> None:
-        SQUARE = [
-            ["a", "b", "c", "d", "e"],
-            ["f", "g", "h", "i", "k"],
-            ["l", "m", "n", "o", "p"],
-            ["q", "r", "s", "t", "u"],
-            ["v", "w", "x", "y", "z"],
-        ]
         self.SQUARE = np.array(SQUARE)
 
     def letter_to_numbers(self, letter: str) -> np.ndarray:
@@ -32,7 +33,7 @@ class BifidCipher:
         >>> np.array_equal(BifidCipher().letter_to_numbers('u'), [4,5])
         True
         """
-        index1, index2 = np.where(self.SQUARE == letter)
+        index1, index2 = np.where(letter == self.SQUARE)
         indexes = np.concatenate([index1 + 1, index2 + 1])
         return indexes
 

ciphers/brute_force_caesar_cipher.py

@@ -1,3 +1,6 @@
+import string
+
+
 def decrypt(message: str) -> None:
     """
     >>> decrypt('TMDETUX PMDVU')
@@ -28,16 +31,15 @@ def decrypt(message: str) -> None:
     Decryption using Key #24: VOFGVWZ ROFXW
     Decryption using Key #25: UNEFUVY QNEWV
     """
-    LETTERS = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-    for key in range(len(LETTERS)):
+    for key in range(len(string.ascii_uppercase)):
         translated = ""
         for symbol in message:
-            if symbol in LETTERS:
-                num = LETTERS.find(symbol)
+            if symbol in string.ascii_uppercase:
+                num = string.ascii_uppercase.find(symbol)
                 num = num - key
                 if num < 0:
-                    num = num + len(LETTERS)
-                translated = translated + LETTERS[num]
+                    num = num + len(string.ascii_uppercase)
+                translated = translated + string.ascii_uppercase[num]
             else:
                 translated = translated + symbol
         print(f"Decryption using Key #{key}: {translated}")

ciphers/caesar_cipher.py

@@ -27,7 +27,7 @@ def encrypt(input_string: str, key: int, alphabet: str | None = None) -> str:
     =========================
     The caesar cipher is named after Julius Caesar who used it when sending
     secret military messages to his troops. This is a simple substitution cipher
-    where very character in the plain-text is shifted by a certain number known
+    where every character in the plain-text is shifted by a certain number known
     as the "key" or "shift".
 
     Example:

ciphers/cryptomath_module.py

@@ -6,7 +6,8 @@ def gcd(a: int, b: int) -> int:
 
 def find_mod_inverse(a: int, m: int) -> int:
     if gcd(a, m) != 1:
-        raise ValueError(f"mod inverse of {a!r} and {m!r} does not exist")
+        msg = f"mod inverse of {a!r} and {m!r} does not exist"
+        raise ValueError(msg)
     u1, u2, u3 = 1, 0, a
     v1, v2, v3 = 0, 1, m
     while v3 != 0:

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,
@@ -228,10 +228,10 @@ class DiffieHellman:
 
     def is_valid_public_key(self, key: int) -> bool:
         # check if the other public key is valid based on NIST SP800-56
-        if 2 <= key and key <= self.prime - 2:
-            if pow(key, (self.prime - 1) // 2, self.prime) == 1:
-                return True
-        return False
+        return (
+            2 <= key <= self.prime - 2
+            and pow(key, (self.prime - 1) // 2, self.prime) == 1
+        )
 
     def generate_shared_key(self, other_key_str: str) -> str:
         other_key = int(other_key_str, base=16)
@@ -243,10 +243,10 @@ class DiffieHellman:
     @staticmethod
     def is_valid_public_key_static(remote_public_key_str: int, prime: int) -> bool:
         # check if the other public key is valid based on NIST SP800-56
-        if 2 <= remote_public_key_str and remote_public_key_str <= prime - 2:
-            if pow(remote_public_key_str, (prime - 1) // 2, prime) == 1:
-                return True
-        return False
+        return (
+            2 <= remote_public_key_str <= prime - 2
+            and pow(remote_public_key_str, (prime - 1) // 2, prime) == 1
+        )
 
     @staticmethod
     def generate_shared_key_static(

ciphers/elgamal_key_generator.py

@@ -26,7 +26,7 @@ def primitive_root(p_val: int) -> int:
 
 def generate_key(key_size: int) -> tuple[tuple[int, int, int, int], tuple[int, int]]:
     print("Generating prime p...")
-    p = rabin_miller.generateLargePrime(key_size)  # select large prime number.
+    p = rabin_miller.generate_large_prime(key_size)  # select large prime number.
     e_1 = primitive_root(p)  # one primitive root on modulo p.
     d = random.randrange(3, p)  # private_key -> have to be greater than 2 for safety.
     e_2 = cryptomath.find_mod_inverse(pow(e_1, d, p), p)
@@ -37,26 +37,23 @@ def generate_key(key_size: int) -> tuple[tuple[int, int, int, int], tuple[int, i
     return public_key, private_key
 
 
-def make_key_files(name: str, keySize: int) -> None:
+def make_key_files(name: str, key_size: int) -> None:
     if os.path.exists(f"{name}_pubkey.txt") or os.path.exists(f"{name}_privkey.txt"):
         print("\nWARNING:")
         print(
-            '"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n'
+            f'"{name}_pubkey.txt" or "{name}_privkey.txt" already exists. \n'
             "Use a different name or delete these files and re-run this program."
-            % (name, name)
         )
         sys.exit()
 
-    publicKey, privateKey = generate_key(keySize)
+    public_key, private_key = generate_key(key_size)
     print(f"\nWriting public key to file {name}_pubkey.txt...")
     with open(f"{name}_pubkey.txt", "w") as fo:
-        fo.write(
-            "%d,%d,%d,%d" % (publicKey[0], publicKey[1], publicKey[2], publicKey[3])
-        )
+        fo.write(f"{public_key[0]},{public_key[1]},{public_key[2]},{public_key[3]}")
 
     print(f"Writing private key to file {name}_privkey.txt...")
     with open(f"{name}_privkey.txt", "w") as fo:
-        fo.write("%d,%d" % (privateKey[0], privateKey[1]))
+        fo.write(f"{private_key[0]},{private_key[1]}")
 
 
 def main() -> None:

ciphers/enigma_machine2.py

@@ -86,24 +86,21 @@ def _validator(
     """
     # Checks if there are 3 unique rotors
 
-    unique_rotsel = len(set(rotsel))
-    if unique_rotsel < 3:
-        raise Exception(f"Please use 3 unique rotors (not {unique_rotsel})")
+    if (unique_rotsel := len(set(rotsel))) < 3:
+        msg = f"Please use 3 unique rotors (not {unique_rotsel})"
+        raise Exception(msg)
 
     # Checks if rotor positions are valid
     rotorpos1, rotorpos2, rotorpos3 = rotpos
     if not 0 < rotorpos1 <= len(abc):
-        raise ValueError(
-            "First rotor position is not within range of 1..26 (" f"{rotorpos1}"
-        )
+        msg = f"First rotor position is not within range of 1..26 ({rotorpos1}"
+        raise ValueError(msg)
     if not 0 < rotorpos2 <= len(abc):
-        raise ValueError(
-            "Second rotor position is not within range of 1..26 (" f"{rotorpos2})"
-        )
+        msg = f"Second rotor position is not within range of 1..26 ({rotorpos2})"
+        raise ValueError(msg)
     if not 0 < rotorpos3 <= len(abc):
-        raise ValueError(
-            "Third rotor position is not within range of 1..26 (" f"{rotorpos3})"
-        )
+        msg = f"Third rotor position is not within range of 1..26 ({rotorpos3})"
+        raise ValueError(msg)
 
     # Validates string and returns dict
     pbdict = _plugboard(pb)
@@ -131,9 +128,11 @@ def _plugboard(pbstring: str) -> dict[str, str]:
     # a) is type string
     # b) has even length (so pairs can be made)
     if not isinstance(pbstring, str):
-        raise TypeError(f"Plugboard setting isn't type string ({type(pbstring)})")
+        msg = f"Plugboard setting isn't type string ({type(pbstring)})"
+        raise TypeError(msg)
     elif len(pbstring) % 2 != 0:
-        raise Exception(f"Odd number of symbols ({len(pbstring)})")
+        msg = f"Odd number of symbols ({len(pbstring)})"
+        raise Exception(msg)
     elif pbstring == "":
         return {}
 
@@ -143,9 +142,11 @@ def _plugboard(pbstring: str) -> dict[str, str]:
     tmppbl = set()
     for i in pbstring:
         if i not in abc:
-            raise Exception(f"'{i}' not in list of symbols")
+            msg = f"'{i}' not in list of symbols"
+            raise Exception(msg)
         elif i in tmppbl:
-            raise Exception(f"Duplicate symbol ({i})")
+            msg = f"Duplicate symbol ({i})"
+            raise Exception(msg)
         else:
             tmppbl.add(i)
     del tmppbl
@@ -231,7 +232,6 @@ def enigma(
     # encryption/decryption process --------------------------
     for symbol in text:
         if symbol in abc:
-
             # 1st plugboard --------------------------
             if symbol in plugboard:
                 symbol = plugboard[symbol]

ciphers/hill_cipher.py

@@ -104,10 +104,11 @@ class HillCipher:
 
         req_l = len(self.key_string)
         if greatest_common_divisor(det, len(self.key_string)) != 1:
-            raise ValueError(
-                f"determinant modular {req_l} of encryption key({det}) is not co prime "
-                f"w.r.t {req_l}.\nTry another key."
+            msg = (
+                f"determinant modular {req_l} of encryption key({det}) "
+                f"is not co prime w.r.t {req_l}.\nTry another key."
             )
+            raise ValueError(msg)
 
     def process_text(self, text: str) -> str:
         """
@@ -201,11 +202,11 @@ class HillCipher:
 
 
 def main() -> None:
-    N = int(input("Enter the order of the encryption key: "))
+    n = int(input("Enter the order of the encryption key: "))
     hill_matrix = []
 
     print("Enter each row of the encryption key with space separated integers")
-    for _ in range(N):
+    for _ in range(n):
         row = [int(x) for x in input().split()]
         hill_matrix.append(row)
 

ciphers/mixed_keyword_cypher.py

@@ -1,7 +1,11 @@
-def mixed_keyword(key: str = "college", pt: str = "UNIVERSITY") -> str:
-    """
+from string import ascii_uppercase
 
-    For key:hello
+
+def mixed_keyword(
+    keyword: str, plaintext: str, verbose: bool = False, alphabet: str = ascii_uppercase
+) -> str:
+    """
+    For keyword: hello
 
     H E L O
     A B C D
@@ -12,57 +16,60 @@ def mixed_keyword(key: str = "college", pt: str = "UNIVERSITY") -> str:
     Y Z
     and map vertically
 
-    >>> mixed_keyword("college", "UNIVERSITY")  # doctest: +NORMALIZE_WHITESPACE
+    >>> mixed_keyword("college", "UNIVERSITY", True)  # doctest: +NORMALIZE_WHITESPACE
     {'A': 'C', 'B': 'A', 'C': 'I', 'D': 'P', 'E': 'U', 'F': 'Z', 'G': 'O', 'H': 'B',
      'I': 'J', 'J': 'Q', 'K': 'V', 'L': 'L', 'M': 'D', 'N': 'K', 'O': 'R', 'P': 'W',
      'Q': 'E', 'R': 'F', 'S': 'M', 'T': 'S', 'U': 'X', 'V': 'G', 'W': 'H', 'X': 'N',
      'Y': 'T', 'Z': 'Y'}
     'XKJGUFMJST'
+
+    >>> mixed_keyword("college", "UNIVERSITY", False)  # doctest: +NORMALIZE_WHITESPACE
+    'XKJGUFMJST'
     """
-    key = key.upper()
-    pt = pt.upper()
-    temp = []
-    for i in key:
-        if i not in temp:
-            temp.append(i)
-    len_temp = len(temp)
-    # print(temp)
-    alpha = []
-    modalpha = []
-    for j in range(65, 91):
-        t = chr(j)
-        alpha.append(t)
-        if t not in temp:
-            temp.append(t)
-    # print(temp)
-    r = int(26 / 4)
-    # print(r)
-    k = 0
-    for _ in range(r):
-        s = []
-        for j in range(len_temp):
-            s.append(temp[k])
-            if not (k < 25):
+    keyword = keyword.upper()
+    plaintext = plaintext.upper()
+    alphabet_set = set(alphabet)
+
+    # create a list of unique characters in the keyword - their order matters
+    # it determines how we will map plaintext characters to the ciphertext
+    unique_chars = []
+    for char in keyword:
+        if char in alphabet_set and char not in unique_chars:
+            unique_chars.append(char)
+    # the number of those unique characters will determine the number of rows
+    num_unique_chars_in_keyword = len(unique_chars)
+
+    # create a shifted version of the alphabet
+    shifted_alphabet = unique_chars + [
+        char for char in alphabet if char not in unique_chars
+    ]
+
+    # create a modified alphabet by splitting the shifted alphabet into rows
+    modified_alphabet = [
+        shifted_alphabet[k : k + num_unique_chars_in_keyword]
+        for k in range(0, 26, num_unique_chars_in_keyword)
+    ]
+
+    # map the alphabet characters to the modified alphabet characters
+    # going 'vertically' through the modified alphabet - consider columns first
+    mapping = {}
+    letter_index = 0
+    for column in range(num_unique_chars_in_keyword):
+        for row in modified_alphabet:
+            # if current row (the last one) is too short, break out of loop
+            if len(row) <= column:
                 break
-            k += 1
-        modalpha.append(s)
-    # print(modalpha)
-    d = {}
-    j = 0
-    k = 0
-    for j in range(len_temp):
-        for m in modalpha:
-            if not (len(m) - 1 >= j):
-                break
-            d[alpha[k]] = m[j]
-            if not k < 25:
-                break
-            k += 1
-    print(d)
-    cypher = ""
-    for i in pt:
-        cypher += d[i]
-    return cypher
+
+            # map current letter to letter in modified alphabet
+            mapping[alphabet[letter_index]] = row[column]
+            letter_index += 1
+
+    if verbose:
+        print(mapping)
+    # create the encrypted text by mapping the plaintext to the modified alphabet
+    return "".join(mapping[char] if char in mapping else char for char in plaintext)
 
 
-print(mixed_keyword("college", "UNIVERSITY"))
+if __name__ == "__main__":
+    # example use
+    print(mixed_keyword("college", "UNIVERSITY"))

ciphers/onepad_cipher.py

@@ -22,7 +22,7 @@ class Onepad:
         for i in range(len(key)):
             p = int((cipher[i] - (key[i]) ** 2) / key[i])
             plain.append(chr(p))
-        return "".join([i for i in plain])
+        return "".join(plain)
 
 
 if __name__ == "__main__":

ciphers/playfair_cipher.py

@@ -39,7 +39,6 @@ def prepare_input(dirty: str) -> str:
 
 
 def generate_table(key: str) -> list[str]:
-
     # I and J are used interchangeably to allow
     # us to use a 5x5 table (25 letters)
     alphabet = "ABCDEFGHIKLMNOPQRSTUVWXYZ"

ciphers/polybius.py

@@ -8,16 +8,17 @@ https://www.braingle.com/brainteasers/codes/polybius.php
 
 import numpy as np
 
+SQUARE = [
+    ["a", "b", "c", "d", "e"],
+    ["f", "g", "h", "i", "k"],
+    ["l", "m", "n", "o", "p"],
+    ["q", "r", "s", "t", "u"],
+    ["v", "w", "x", "y", "z"],
+]
+
 
 class PolybiusCipher:
     def __init__(self) -> None:
-        SQUARE = [
-            ["a", "b", "c", "d", "e"],
-            ["f", "g", "h", "i", "k"],
-            ["l", "m", "n", "o", "p"],
-            ["q", "r", "s", "t", "u"],
-            ["v", "w", "x", "y", "z"],
-        ]
         self.SQUARE = np.array(SQUARE)
 
     def letter_to_numbers(self, letter: str) -> np.ndarray:
@@ -30,7 +31,7 @@ class PolybiusCipher:
         >>> np.array_equal(PolybiusCipher().letter_to_numbers('u'), [4,5])
         True
         """
-        index1, index2 = np.where(self.SQUARE == letter)
+        index1, index2 = np.where(letter == self.SQUARE)
         indexes = np.concatenate([index1 + 1, index2 + 1])
         return indexes
 

ciphers/rabin_miller.py

@@ -3,7 +3,7 @@
 import random
 
 
-def rabinMiller(num: int) -> bool:
+def rabin_miller(num: int) -> bool:
     s = num - 1
     t = 0
 
@@ -11,7 +11,7 @@ def rabinMiller(num: int) -> bool:
         s = s // 2
         t += 1
 
-    for trials in range(5):
+    for _ in range(5):
         a = random.randrange(2, num - 1)
         v = pow(a, s, num)
         if v != 1:
@@ -29,7 +29,7 @@ def is_prime_low_num(num: int) -> bool:
     if num < 2:
         return False
 
-    lowPrimes = [
+    low_primes = [
         2,
         3,
         5,
@@ -200,17 +200,17 @@ def is_prime_low_num(num: int) -> bool:
         997,
     ]
 
-    if num in lowPrimes:
+    if num in low_primes:
         return True
 
-    for prime in lowPrimes:
+    for prime in low_primes:
         if (num % prime) == 0:
             return False
 
-    return rabinMiller(num)
+    return rabin_miller(num)
 
 
-def generateLargePrime(keysize: int = 1024) -> int:
+def generate_large_prime(keysize: int = 1024) -> int:
     while True:
         num = random.randrange(2 ** (keysize - 1), 2 ** (keysize))
         if is_prime_low_num(num):
@@ -218,6 +218,6 @@ def generateLargePrime(keysize: int = 1024) -> int:
 
 
 if __name__ == "__main__":
-    num = generateLargePrime()
+    num = generate_large_prime()
     print(("Prime number:", num))
     print(("is_prime_low_num:", is_prime_low_num(num)))

ciphers/rail_fence_cipher.py

@@ -72,7 +72,7 @@ def decrypt(input_string: str, key: int) -> str:
     counter = 0
     for row in temp_grid:  # fills in the characters
         splice = input_string[counter : counter + len(row)]
-        grid.append([character for character in splice])
+        grid.append(list(splice))
         counter += len(row)
 
     output_string = ""  # reads as zigzag

ciphers/rsa_cipher.py

@@ -37,12 +37,12 @@ def get_text_from_blocks(
 
 
 def encrypt_message(
-    message: str, key: tuple[int, int], blockSize: int = DEFAULT_BLOCK_SIZE
+    message: str, key: tuple[int, int], block_size: int = DEFAULT_BLOCK_SIZE
 ) -> list[int]:
     encrypted_blocks = []
     n, e = key
 
-    for block in get_blocks_from_text(message, blockSize):
+    for block in get_blocks_from_text(message, block_size):
         encrypted_blocks.append(pow(block, e, n))
     return encrypted_blocks
 
@@ -63,8 +63,8 @@ def decrypt_message(
 def read_key_file(key_filename: str) -> tuple[int, int, int]:
     with open(key_filename) as fo:
         content = fo.read()
-    key_size, n, EorD = content.split(",")
-    return (int(key_size), int(n), int(EorD))
+    key_size, n, eor_d = content.split(",")
+    return (int(key_size), int(n), int(eor_d))
 
 
 def encrypt_and_write_to_file(
@@ -76,10 +76,11 @@ def encrypt_and_write_to_file(
     key_size, n, e = read_key_file(key_filename)
     if key_size < block_size * 8:
         sys.exit(
-            "ERROR: Block size is %s bits and key size is %s bits. The RSA cipher "
+            "ERROR: Block size is {} bits and key size is {} bits. The RSA cipher "
             "requires the block size to be equal to or greater than the key size. "
-            "Either decrease the block size or use different keys."
-            % (block_size * 8, key_size)
+            "Either decrease the block size or use different keys.".format(
+                block_size * 8, key_size
+            )
         )
 
     encrypted_blocks = [str(i) for i in encrypt_message(message, (n, e), block_size)]
@@ -101,10 +102,11 @@ def read_from_file_and_decrypt(message_filename: str, key_filename: str) -> str:
 
     if key_size < block_size * 8:
         sys.exit(
-            "ERROR: Block size is %s bits and key size is %s bits. The RSA cipher "
+            "ERROR: Block size is {} bits and key size is {} bits. The RSA cipher "
             "requires the block size to be equal to or greater than the key size. "
-            "Did you specify the correct key file and encrypted file?"
-            % (block_size * 8, key_size)
+            "Did you specify the correct key file and encrypted file?".format(
+                block_size * 8, key_size
+            )
         )
 
     encrypted_blocks = []
@@ -125,15 +127,15 @@ def main() -> None:
 
     if mode == "encrypt":
         if not os.path.exists("rsa_pubkey.txt"):
-            rkg.makeKeyFiles("rsa", 1024)
+            rkg.make_key_files("rsa", 1024)
 
         message = input("\nEnter message: ")
         pubkey_filename = "rsa_pubkey.txt"
         print(f"Encrypting and writing to {filename}...")
-        encryptedText = encrypt_and_write_to_file(filename, pubkey_filename, message)
+        encrypted_text = encrypt_and_write_to_file(filename, pubkey_filename, message)
 
         print("\nEncrypted text:")
-        print(encryptedText)
+        print(encrypted_text)
 
     elif mode == "decrypt":
         privkey_filename = "rsa_privkey.txt"

ciphers/rsa_factorization.py

@@ -13,7 +13,7 @@ import math
 import random
 
 
-def rsafactor(d: int, e: int, N: int) -> list[int]:
+def rsafactor(d: int, e: int, n: int) -> list[int]:
     """
     This function returns the factors of N, where p*q=N
       Return: [p, q]
@@ -35,16 +35,16 @@ def rsafactor(d: int, e: int, N: int) -> list[int]:
     p = 0
     q = 0
     while p == 0:
-        g = random.randint(2, N - 1)
+        g = random.randint(2, n - 1)
         t = k
         while True:
             if t % 2 == 0:
                 t = t // 2
-                x = (g**t) % N
-                y = math.gcd(x - 1, N)
+                x = (g**t) % n
+                y = math.gcd(x - 1, n)
                 if x > 1 and y > 1:
                     p = y
-                    q = N // y
+                    q = n // y
                     break  # find the correct factors
             else:
                 break  # t is not divisible by 2, break and choose another g

ciphers/rsa_key_generator.py

@@ -2,55 +2,59 @@ import os
 import random
 import sys
 
-from . import cryptomath_module as cryptoMath
-from . import rabin_miller as rabinMiller
+from . import cryptomath_module, rabin_miller
 
 
 def main() -> None:
     print("Making key files...")
-    makeKeyFiles("rsa", 1024)
+    make_key_files("rsa", 1024)
     print("Key files generation successful.")
 
 
-def generateKey(keySize: int) -> tuple[tuple[int, int], tuple[int, int]]:
-    print("Generating prime p...")
-    p = rabinMiller.generateLargePrime(keySize)
-    print("Generating prime q...")
-    q = rabinMiller.generateLargePrime(keySize)
+def generate_key(key_size: int) -> tuple[tuple[int, int], tuple[int, int]]:
+    """
+    >>> random.seed(0) # for repeatability
+    >>> public_key, private_key = generate_key(8)
+    >>> public_key
+    (26569, 239)
+    >>> private_key
+    (26569, 2855)
+    """
+    p = rabin_miller.generate_large_prime(key_size)
+    q = rabin_miller.generate_large_prime(key_size)
     n = p * q
 
-    print("Generating e that is relatively prime to (p - 1) * (q - 1)...")
+    # Generate e that is relatively prime to (p - 1) * (q - 1)
     while True:
-        e = random.randrange(2 ** (keySize - 1), 2 ** (keySize))
-        if cryptoMath.gcd(e, (p - 1) * (q - 1)) == 1:
+        e = random.randrange(2 ** (key_size - 1), 2 ** (key_size))
+        if cryptomath_module.gcd(e, (p - 1) * (q - 1)) == 1:
             break
 
-    print("Calculating d that is mod inverse of e...")
-    d = cryptoMath.find_mod_inverse(e, (p - 1) * (q - 1))
+    # Calculate d that is mod inverse of e
+    d = cryptomath_module.find_mod_inverse(e, (p - 1) * (q - 1))
 
-    publicKey = (n, e)
-    privateKey = (n, d)
-    return (publicKey, privateKey)
+    public_key = (n, e)
+    private_key = (n, d)
+    return (public_key, private_key)
 
 
-def makeKeyFiles(name: str, keySize: int) -> None:
+def make_key_files(name: str, key_size: int) -> None:
     if os.path.exists(f"{name}_pubkey.txt") or os.path.exists(f"{name}_privkey.txt"):
         print("\nWARNING:")
         print(
-            '"%s_pubkey.txt" or "%s_privkey.txt" already exists. \n'
+            f'"{name}_pubkey.txt" or "{name}_privkey.txt" already exists. \n'
             "Use a different name or delete these files and re-run this program."
-            % (name, name)
         )
         sys.exit()
 
-    publicKey, privateKey = generateKey(keySize)
+    public_key, private_key = generate_key(key_size)
     print(f"\nWriting public key to file {name}_pubkey.txt...")
     with open(f"{name}_pubkey.txt", "w") as out_file:
-        out_file.write(f"{keySize},{publicKey[0]},{publicKey[1]}")
+        out_file.write(f"{key_size},{public_key[0]},{public_key[1]}")
 
     print(f"Writing private key to file {name}_privkey.txt...")
     with open(f"{name}_privkey.txt", "w") as out_file:
-        out_file.write(f"{keySize},{privateKey[0]},{privateKey[1]}")
+        out_file.write(f"{key_size},{private_key[0]},{private_key[1]}")
 
 
 if __name__ == "__main__":

ciphers/shuffled_shift_cipher.py

@@ -42,7 +42,7 @@ class ShuffledShiftCipher:
         """
         :return: passcode of the cipher object
         """
-        return "Passcode is: " + "".join(self.__passcode)
+        return "".join(self.__passcode)
 
     def __neg_pos(self, iterlist: list[int]) -> list[int]:
         """

ciphers/simple_keyword_cypher.py

@@ -21,7 +21,7 @@ def create_cipher_map(key: str) -> dict[str, str]:
     :param key: keyword to use
     :return: dictionary cipher map
     """
-    # Create alphabet list
+    # Create a list of the letters in the alphabet
     alphabet = [chr(i + 65) for i in range(26)]
     # Remove duplicate characters from key
     key = remove_duplicates(key.upper())

ciphers/simple_substitution_cipher.py

@@ -9,66 +9,66 @@ def main() -> None:
     key = "LFWOAYUISVKMNXPBDCRJTQEGHZ"
     resp = input("Encrypt/Decrypt [e/d]: ")
 
-    checkValidKey(key)
+    check_valid_key(key)
 
     if resp.lower().startswith("e"):
         mode = "encrypt"
-        translated = encryptMessage(key, message)
+        translated = encrypt_message(key, message)
     elif resp.lower().startswith("d"):
         mode = "decrypt"
-        translated = decryptMessage(key, message)
+        translated = decrypt_message(key, message)
 
     print(f"\n{mode.title()}ion: \n{translated}")
 
 
-def checkValidKey(key: str) -> None:
-    keyList = list(key)
-    lettersList = list(LETTERS)
-    keyList.sort()
-    lettersList.sort()
+def check_valid_key(key: str) -> None:
+    key_list = list(key)
+    letters_list = list(LETTERS)
+    key_list.sort()
+    letters_list.sort()
 
-    if keyList != lettersList:
+    if key_list != letters_list:
         sys.exit("Error in the key or symbol set.")
 
 
-def encryptMessage(key: str, message: str) -> str:
+def encrypt_message(key: str, message: str) -> str:
     """
-    >>> encryptMessage('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Harshil Darji')
+    >>> encrypt_message('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Harshil Darji')
     'Ilcrism Olcvs'
     """
-    return translateMessage(key, message, "encrypt")
+    return translate_message(key, message, "encrypt")
 
 
-def decryptMessage(key: str, message: str) -> str:
+def decrypt_message(key: str, message: str) -> str:
     """
-    >>> decryptMessage('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Ilcrism Olcvs')
+    >>> decrypt_message('LFWOAYUISVKMNXPBDCRJTQEGHZ', 'Ilcrism Olcvs')
     'Harshil Darji'
     """
-    return translateMessage(key, message, "decrypt")
+    return translate_message(key, message, "decrypt")
 
 
-def translateMessage(key: str, message: str, mode: str) -> str:
+def translate_message(key: str, message: str, mode: str) -> str:
     translated = ""
-    charsA = LETTERS
-    charsB = key
+    chars_a = LETTERS
+    chars_b = key
 
     if mode == "decrypt":
-        charsA, charsB = charsB, charsA
+        chars_a, chars_b = chars_b, chars_a
 
     for symbol in message:
-        if symbol.upper() in charsA:
-            symIndex = charsA.find(symbol.upper())
+        if symbol.upper() in chars_a:
+            sym_index = chars_a.find(symbol.upper())
             if symbol.isupper():
-                translated += charsB[symIndex].upper()
+                translated += chars_b[sym_index].upper()
             else:
-                translated += charsB[symIndex].lower()
+                translated += chars_b[sym_index].lower()
         else:
             translated += symbol
 
     return translated
 
 
-def getRandomKey() -> str:
+def get_random_key() -> str:
     key = list(LETTERS)
     random.shuffle(key)
     return "".join(key)

ciphers/trafid_cipher.py

@@ -2,12 +2,12 @@
 from __future__ import annotations
 
 
-def __encryptPart(messagePart: str, character2Number: dict[str, str]) -> str:
+def __encrypt_part(message_part: str, character_to_number: dict[str, str]) -> str:
     one, two, three = "", "", ""
     tmp = []
 
-    for character in messagePart:
-        tmp.append(character2Number[character])
+    for character in message_part:
+        tmp.append(character_to_number[character])
 
     for each in tmp:
         one += each[0]
@@ -17,18 +17,18 @@ def __encryptPart(messagePart: str, character2Number: dict[str, str]) -> str:
     return one + two + three
 
 
-def __decryptPart(
-    messagePart: str, character2Number: dict[str, str]
+def __decrypt_part(
+    message_part: str, character_to_number: dict[str, str]
 ) -> tuple[str, str, str]:
-    tmp, thisPart = "", ""
+    tmp, this_part = "", ""
     result = []
 
-    for character in messagePart:
-        thisPart += character2Number[character]
+    for character in message_part:
+        this_part += character_to_number[character]
 
-    for digit in thisPart:
+    for digit in this_part:
         tmp += digit
-        if len(tmp) == len(messagePart):
+        if len(tmp) == len(message_part):
             result.append(tmp)
             tmp = ""
 
@@ -79,51 +79,57 @@ def __prepare(
         "332",
         "333",
     )
-    character2Number = {}
-    number2Character = {}
+    character_to_number = {}
+    number_to_character = {}
     for letter, number in zip(alphabet, numbers):
-        character2Number[letter] = number
-        number2Character[number] = letter
+        character_to_number[letter] = number
+        number_to_character[number] = letter
 
-    return message, alphabet, character2Number, number2Character
+    return message, alphabet, character_to_number, number_to_character
 
 
-def encryptMessage(
+def encrypt_message(
     message: str, alphabet: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period: int = 5
 ) -> str:
-    message, alphabet, character2Number, number2Character = __prepare(message, alphabet)
+    message, alphabet, character_to_number, number_to_character = __prepare(
+        message, alphabet
+    )
     encrypted, encrypted_numeric = "", ""
 
     for i in range(0, len(message) + 1, period):
-        encrypted_numeric += __encryptPart(message[i : i + period], character2Number)
+        encrypted_numeric += __encrypt_part(
+            message[i : i + period], character_to_number
+        )
 
     for i in range(0, len(encrypted_numeric), 3):
-        encrypted += number2Character[encrypted_numeric[i : i + 3]]
+        encrypted += number_to_character[encrypted_numeric[i : i + 3]]
 
     return encrypted
 
 
-def decryptMessage(
+def decrypt_message(
     message: str, alphabet: str = "ABCDEFGHIJKLMNOPQRSTUVWXYZ.", period: int = 5
 ) -> str:
-    message, alphabet, character2Number, number2Character = __prepare(message, alphabet)
+    message, alphabet, character_to_number, number_to_character = __prepare(
+        message, alphabet
+    )
     decrypted_numeric = []
     decrypted = ""
 
     for i in range(0, len(message) + 1, period):
-        a, b, c = __decryptPart(message[i : i + period], character2Number)
+        a, b, c = __decrypt_part(message[i : i + period], character_to_number)
 
         for j in range(0, len(a)):
             decrypted_numeric.append(a[j] + b[j] + c[j])
 
     for each in decrypted_numeric:
-        decrypted += number2Character[each]
+        decrypted += number_to_character[each]
 
     return decrypted
 
 
 if __name__ == "__main__":
     msg = "DEFEND THE EAST WALL OF THE CASTLE."
-    encrypted = encryptMessage(msg, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
-    decrypted = decryptMessage(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
+    encrypted = encrypt_message(msg, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
+    decrypted = decrypt_message(encrypted, "EPSDUCVWYM.ZLKXNBTFGORIJHAQ")
     print(f"Encrypted: {encrypted}\nDecrypted: {decrypted}")

ciphers/transposition_cipher.py

@@ -14,53 +14,53 @@ def main() -> None:
     mode = input("Encryption/Decryption [e/d]: ")
 
     if mode.lower().startswith("e"):
-        text = encryptMessage(key, message)
+        text = encrypt_message(key, message)
     elif mode.lower().startswith("d"):
-        text = decryptMessage(key, message)
+        text = decrypt_message(key, message)
 
     # Append pipe symbol (vertical bar) to identify spaces at the end.
     print(f"Output:\n{text + '|'}")
 
 
-def encryptMessage(key: int, message: str) -> str:
+def encrypt_message(key: int, message: str) -> str:
     """
-    >>> encryptMessage(6, 'Harshil Darji')
+    >>> encrypt_message(6, 'Harshil Darji')
     'Hlia rDsahrij'
     """
-    cipherText = [""] * key
+    cipher_text = [""] * key
     for col in range(key):
         pointer = col
         while pointer < len(message):
-            cipherText[col] += message[pointer]
+            cipher_text[col] += message[pointer]
             pointer += key
-    return "".join(cipherText)
+    return "".join(cipher_text)
 
 
-def decryptMessage(key: int, message: str) -> str:
+def decrypt_message(key: int, message: str) -> str:
     """
-    >>> decryptMessage(6, 'Hlia rDsahrij')
+    >>> decrypt_message(6, 'Hlia rDsahrij')
     'Harshil Darji'
     """
-    numCols = math.ceil(len(message) / key)
-    numRows = key
-    numShadedBoxes = (numCols * numRows) - len(message)
-    plainText = [""] * numCols
+    num_cols = math.ceil(len(message) / key)
+    num_rows = key
+    num_shaded_boxes = (num_cols * num_rows) - len(message)
+    plain_text = [""] * num_cols
     col = 0
     row = 0
 
     for symbol in message:
-        plainText[col] += symbol
+        plain_text[col] += symbol
         col += 1
 
         if (
-            (col == numCols)
-            or (col == numCols - 1)
-            and (row >= numRows - numShadedBoxes)
+            (col == num_cols)
+            or (col == num_cols - 1)
+            and (row >= num_rows - num_shaded_boxes)
         ):
             col = 0
             row += 1
 
-    return "".join(plainText)
+    return "".join(plain_text)
 
 
 if __name__ == "__main__":

ciphers/transposition_cipher_encrypt_decrypt_file.py

@@ -2,39 +2,39 @@ import os
 import sys
 import time
 
-from . import transposition_cipher as transCipher
+from . import transposition_cipher as trans_cipher
 
 
 def main() -> None:
-    inputFile = "Prehistoric Men.txt"
-    outputFile = "Output.txt"
+    input_file = "Prehistoric Men.txt"
+    output_file = "Output.txt"
     key = int(input("Enter key: "))
     mode = input("Encrypt/Decrypt [e/d]: ")
 
-    if not os.path.exists(inputFile):
-        print(f"File {inputFile} does not exist. Quitting...")
+    if not os.path.exists(input_file):
+        print(f"File {input_file} does not exist. Quitting...")
         sys.exit()
-    if os.path.exists(outputFile):
-        print(f"Overwrite {outputFile}? [y/n]")
+    if os.path.exists(output_file):
+        print(f"Overwrite {output_file}? [y/n]")
         response = input("> ")
         if not response.lower().startswith("y"):
             sys.exit()
 
-    startTime = time.time()
+    start_time = time.time()
     if mode.lower().startswith("e"):
-        with open(inputFile) as f:
+        with open(input_file) as f:
             content = f.read()
-        translated = transCipher.encryptMessage(key, content)
+        translated = trans_cipher.encrypt_message(key, content)
     elif mode.lower().startswith("d"):
-        with open(outputFile) as f:
+        with open(output_file) as f:
             content = f.read()
-        translated = transCipher.decryptMessage(key, content)
+        translated = trans_cipher.decrypt_message(key, content)
 
-    with open(outputFile, "w") as outputObj:
-        outputObj.write(translated)
+    with open(output_file, "w") as output_obj:
+        output_obj.write(translated)
 
-    totalTime = round(time.time() - startTime, 2)
-    print(("Done (", totalTime, "seconds )"))
+    total_time = round(time.time() - start_time, 2)
+    print(("Done (", total_time, "seconds )"))
 
 
 if __name__ == "__main__":

ciphers/vigenere_cipher.py

@@ -8,43 +8,43 @@ def main() -> None:
 
     if mode.lower().startswith("e"):
         mode = "encrypt"
-        translated = encryptMessage(key, message)
+        translated = encrypt_message(key, message)
     elif mode.lower().startswith("d"):
         mode = "decrypt"
-        translated = decryptMessage(key, message)
+        translated = decrypt_message(key, message)
 
     print(f"\n{mode.title()}ed message:")
     print(translated)
 
 
-def encryptMessage(key: str, message: str) -> str:
+def encrypt_message(key: str, message: str) -> str:
     """
-    >>> encryptMessage('HDarji', 'This is Harshil Darji from Dharmaj.')
+    >>> encrypt_message('HDarji', 'This is Harshil Darji from Dharmaj.')
     'Akij ra Odrjqqs Gaisq muod Mphumrs.'
     """
-    return translateMessage(key, message, "encrypt")
+    return translate_message(key, message, "encrypt")
 
 
-def decryptMessage(key: str, message: str) -> str:
+def decrypt_message(key: str, message: str) -> str:
     """
-    >>> decryptMessage('HDarji', 'Akij ra Odrjqqs Gaisq muod Mphumrs.')
+    >>> decrypt_message('HDarji', 'Akij ra Odrjqqs Gaisq muod Mphumrs.')
     'This is Harshil Darji from Dharmaj.'
     """
-    return translateMessage(key, message, "decrypt")
+    return translate_message(key, message, "decrypt")
 
 
-def translateMessage(key: str, message: str, mode: str) -> str:
+def translate_message(key: str, message: str, mode: str) -> str:
     translated = []
-    keyIndex = 0
+    key_index = 0
     key = key.upper()
 
     for symbol in message:
         num = LETTERS.find(symbol.upper())
         if num != -1:
             if mode == "encrypt":
-                num += LETTERS.find(key[keyIndex])
+                num += LETTERS.find(key[key_index])
             elif mode == "decrypt":
-                num -= LETTERS.find(key[keyIndex])
+                num -= LETTERS.find(key[key_index])
 
             num %= len(LETTERS)
 
@@ -53,9 +53,9 @@ def translateMessage(key: str, message: str, mode: str) -> str:
             elif symbol.islower():
                 translated.append(LETTERS[num].lower())
 
-            keyIndex += 1
-            if keyIndex == len(key):
-                keyIndex = 0
+            key_index += 1
+            if key_index == len(key):
+                key_index = 0
         else:
             translated.append(symbol)
     return "".join(translated)

ciphers/xor_cipher.py

@@ -128,12 +128,10 @@ class XORCipher:
         assert isinstance(file, str) and isinstance(key, int)
 
         try:
-            with open(file) as fin:
-                with open("encrypt.out", "w+") as fout:
-
-                    # actual encrypt-process
-                    for line in fin:
-                        fout.write(self.encrypt_string(line, key))
+            with open(file) as fin, open("encrypt.out", "w+") as fout:
+                # actual encrypt-process
+                for line in fin:
+                    fout.write(self.encrypt_string(line, key))
 
         except OSError:
             return False
@@ -153,12 +151,10 @@ class XORCipher:
         assert isinstance(file, str) and isinstance(key, int)
 
         try:
-            with open(file) as fin:
-                with open("decrypt.out", "w+") as fout:
-
-                    # actual encrypt-process
-                    for line in fin:
-                        fout.write(self.decrypt_string(line, key))
+            with open(file) as fin, open("decrypt.out", "w+") as fout:
+                # actual encrypt-process
+                for line in fin:
+                    fout.write(self.decrypt_string(line, key))
 
         except OSError:
             return False

compression/burrows_wheeler.py

@@ -150,11 +150,11 @@ 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)
-    for x in range(len(bwt_string)):
+    for _ in range(len(bwt_string)):
         for i in range(len(bwt_string)):
             ordered_rotations[i] = bwt_string[i] + ordered_rotations[i]
         ordered_rotations.sort()

compression/huffman.py

@@ -31,8 +31,8 @@ def parse_file(file_path: str) -> list[Letter]:
             c = f.read(1)
             if not c:
                 break
-            chars[c] = chars[c] + 1 if c in chars.keys() else 1
-    return sorted((Letter(c, f) for c, f in chars.items()), key=lambda l: l.freq)
+            chars[c] = chars[c] + 1 if c in chars else 1
+    return sorted((Letter(c, f) for c, f in chars.items()), key=lambda x: x.freq)
 
 
 def build_tree(letters: list[Letter]) -> Letter | TreeNode:
@@ -47,7 +47,7 @@ def build_tree(letters: list[Letter]) -> Letter | TreeNode:
         total_freq = left.freq + right.freq
         node = TreeNode(total_freq, left, right)
         response.append(node)
-        response.sort(key=lambda l: l.freq)
+        response.sort(key=lambda x: x.freq)
     return response[0]
 
 
@@ -56,7 +56,7 @@ def traverse_tree(root: Letter | TreeNode, bitstring: str) -> list[Letter]:
     Recursively traverse the Huffman Tree to set each
     Letter's bitstring dictionary, and return the list of Letters
     """
-    if type(root) is Letter:
+    if isinstance(root, Letter):
         root.bitstring[root.letter] = bitstring
         return [root]
     treenode: TreeNode = root  # type: ignore

compression/lempel_ziv_decompress.py

@@ -43,10 +43,10 @@ def decompress_data(data_bits: str) -> str:
         lexicon[curr_string] = last_match_id + "0"
 
         if math.log2(index).is_integer():
-            newLex = {}
+            new_lex = {}
             for curr_key in list(lexicon):
-                newLex["0" + curr_key] = lexicon.pop(curr_key)
-            lexicon = newLex
+                new_lex["0" + curr_key] = lexicon.pop(curr_key)
+            lexicon = new_lex
 
         lexicon[bin(index)[2:]] = last_match_id + "1"
         index += 1

compression/lz77.py

@@ -0,0 +1,226 @@
+"""
+LZ77 compression algorithm
+- lossless data compression published in papers by Abraham Lempel and Jacob Ziv in 1977
+- also known as LZ1 or sliding-window compression
+- form the basis for many variations including LZW, LZSS, LZMA and others
+
+It uses a “sliding window” method. Within the sliding window we have:
+  - search buffer
+  - look ahead buffer
+len(sliding_window) = len(search_buffer) + len(look_ahead_buffer)
+
+LZ77 manages a dictionary that uses triples composed of:
+    - Offset into search buffer, it's the distance between the start of a phrase and
+      the beginning of a file.
+    - Length of the match, it's the number of characters that make up a phrase.
+    - The indicator is represented by a character that is going to be encoded next.
+
+As a file is parsed, the dictionary is dynamically updated to reflect the compressed
+data contents and size.
+
+Examples:
+"cabracadabrarrarrad" <-> [(0, 0, 'c'), (0, 0, 'a'), (0, 0, 'b'), (0, 0, 'r'),
+                           (3, 1, 'c'), (2, 1, 'd'), (7, 4, 'r'), (3, 5, 'd')]
+"ababcbababaa" <-> [(0, 0, 'a'), (0, 0, 'b'), (2, 2, 'c'), (4, 3, 'a'), (2, 2, 'a')]
+"aacaacabcabaaac" <-> [(0, 0, 'a'), (1, 1, 'c'), (3, 4, 'b'), (3, 3, 'a'), (1, 2, 'c')]
+
+Sources:
+en.wikipedia.org/wiki/LZ77_and_LZ78
+"""
+
+
+from dataclasses import dataclass
+
+__version__ = "0.1"
+__author__ = "Lucia Harcekova"
+
+
+@dataclass
+class Token:
+    """
+    Dataclass representing triplet called token consisting of length, offset
+    and indicator. This triplet is used during LZ77 compression.
+    """
+
+    offset: int
+    length: int
+    indicator: str
+
+    def __repr__(self) -> str:
+        """
+        >>> token = Token(1, 2, "c")
+        >>> repr(token)
+        '(1, 2, c)'
+        >>> str(token)
+        '(1, 2, c)'
+        """
+        return f"({self.offset}, {self.length}, {self.indicator})"
+
+
+class LZ77Compressor:
+    """
+    Class containing compress and decompress methods using LZ77 compression algorithm.
+    """
+
+    def __init__(self, window_size: int = 13, lookahead_buffer_size: int = 6) -> None:
+        self.window_size = window_size
+        self.lookahead_buffer_size = lookahead_buffer_size
+        self.search_buffer_size = self.window_size - self.lookahead_buffer_size
+
+    def compress(self, text: str) -> list[Token]:
+        """
+        Compress the given string text using LZ77 compression algorithm.
+
+        Args:
+            text: string to be compressed
+
+        Returns:
+            output: the compressed text as a list of Tokens
+
+        >>> lz77_compressor = LZ77Compressor()
+        >>> str(lz77_compressor.compress("ababcbababaa"))
+        '[(0, 0, a), (0, 0, b), (2, 2, c), (4, 3, a), (2, 2, a)]'
+        >>> str(lz77_compressor.compress("aacaacabcabaaac"))
+        '[(0, 0, a), (1, 1, c), (3, 4, b), (3, 3, a), (1, 2, c)]'
+        """
+
+        output = []
+        search_buffer = ""
+
+        # while there are still characters in text to compress
+        while text:
+            # find the next encoding phrase
+            # - triplet with offset, length, indicator (the next encoding character)
+            token = self._find_encoding_token(text, search_buffer)
+
+            # update the search buffer:
+            # - add new characters from text into it
+            # - check if size exceed the max search buffer size, if so, drop the
+            #   oldest elements
+            search_buffer += text[: token.length + 1]
+            if len(search_buffer) > self.search_buffer_size:
+                search_buffer = search_buffer[-self.search_buffer_size :]
+
+            # update the text
+            text = text[token.length + 1 :]
+
+            # append the token to output
+            output.append(token)
+
+        return output
+
+    def decompress(self, tokens: list[Token]) -> str:
+        """
+        Convert the list of tokens into an output string.
+
+        Args:
+            tokens: list containing triplets (offset, length, char)
+
+        Returns:
+            output: decompressed text
+
+        Tests:
+            >>> lz77_compressor = LZ77Compressor()
+            >>> lz77_compressor.decompress([Token(0, 0, 'c'), Token(0, 0, 'a'),
+            ... Token(0, 0, 'b'), Token(0, 0, 'r'), Token(3, 1, 'c'),
+            ... Token(2, 1, 'd'), Token(7, 4, 'r'), Token(3, 5, 'd')])
+            'cabracadabrarrarrad'
+            >>> lz77_compressor.decompress([Token(0, 0, 'a'), Token(0, 0, 'b'),
+            ... Token(2, 2, 'c'), Token(4, 3, 'a'), Token(2, 2, 'a')])
+            'ababcbababaa'
+            >>> lz77_compressor.decompress([Token(0, 0, 'a'), Token(1, 1, 'c'),
+            ... Token(3, 4, 'b'), Token(3, 3, 'a'), Token(1, 2, 'c')])
+            'aacaacabcabaaac'
+        """
+
+        output = ""
+
+        for token in tokens:
+            for _ in range(token.length):
+                output += output[-token.offset]
+            output += token.indicator
+
+        return output
+
+    def _find_encoding_token(self, text: str, search_buffer: str) -> Token:
+        """Finds the encoding token for the first character in the text.
+
+        Tests:
+            >>> lz77_compressor = LZ77Compressor()
+            >>> lz77_compressor._find_encoding_token("abrarrarrad", "abracad").offset
+            7
+            >>> lz77_compressor._find_encoding_token("adabrarrarrad", "cabrac").length
+            1
+            >>> lz77_compressor._find_encoding_token("abc", "xyz").offset
+            0
+            >>> lz77_compressor._find_encoding_token("", "xyz").offset
+            Traceback (most recent call last):
+                ...
+            ValueError: We need some text to work with.
+            >>> lz77_compressor._find_encoding_token("abc", "").offset
+            0
+        """
+
+        if not text:
+            raise ValueError("We need some text to work with.")
+
+        # Initialise result parameters to default values
+        length, offset = 0, 0
+
+        if not search_buffer:
+            return Token(offset, length, text[length])
+
+        for i, character in enumerate(search_buffer):
+            found_offset = len(search_buffer) - i
+            if character == text[0]:
+                found_length = self._match_length_from_index(text, search_buffer, 0, i)
+                # if the found length is bigger than the current or if it's equal,
+                # which means it's offset is smaller: update offset and length
+                if found_length >= length:
+                    offset, length = found_offset, found_length
+
+        return Token(offset, length, text[length])
+
+    def _match_length_from_index(
+        self, text: str, window: str, text_index: int, window_index: int
+    ) -> int:
+        """Calculate the longest possible match of text and window characters from
+        text_index in text and window_index in window.
+
+        Args:
+            text: _description_
+            window: sliding window
+            text_index: index of character in text
+            window_index: index of character in sliding window
+
+        Returns:
+            The maximum match between text and window, from given indexes.
+
+        Tests:
+            >>> lz77_compressor = LZ77Compressor(13, 6)
+            >>> lz77_compressor._match_length_from_index("rarrad", "adabrar", 0, 4)
+            5
+            >>> lz77_compressor._match_length_from_index("adabrarrarrad",
+            ...     "cabrac", 0, 1)
+            1
+        """
+        if not text or text[text_index] != window[window_index]:
+            return 0
+        return 1 + self._match_length_from_index(
+            text, window + text[text_index], text_index + 1, window_index + 1
+        )
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+    # Initialize compressor class
+    lz77_compressor = LZ77Compressor(window_size=13, lookahead_buffer_size=6)
+
+    # Example
+    TEXT = "cabracadabrarrarrad"
+    compressed_text = lz77_compressor.compress(TEXT)
+    print(lz77_compressor.compress("ababcbababaa"))
+    decompressed_text = lz77_compressor.decompress(compressed_text)
+    assert decompressed_text == TEXT, "The LZ77 algorithm returned the invalid result."

compression/peak_signal_to_noise_ratio.py

@@ -11,14 +11,15 @@ import os
 import cv2
 import numpy as np
 
+PIXEL_MAX = 255.0
 
-def psnr(original: float, contrast: float) -> float:
+
+def peak_signal_to_noise_ratio(original: float, contrast: float) -> float:
     mse = np.mean((original - contrast) ** 2)
     if mse == 0:
         return 100
-    PIXEL_MAX = 255.0
-    PSNR = 20 * math.log10(PIXEL_MAX / math.sqrt(mse))
-    return PSNR
+
+    return 20 * math.log10(PIXEL_MAX / math.sqrt(mse))
 
 
 def main() -> None:
@@ -34,11 +35,11 @@ def main() -> None:
 
     # Value expected: 29.73dB
     print("-- First Test --")
-    print(f"PSNR value is {psnr(original, contrast)} dB")
+    print(f"PSNR value is {peak_signal_to_noise_ratio(original, contrast)} dB")
 
     # # Value expected: 31.53dB (Wikipedia Example)
     print("\n-- Second Test --")
-    print(f"PSNR value is {psnr(original2, contrast2)} dB")
+    print(f"PSNR value is {peak_signal_to_noise_ratio(original2, contrast2)} dB")
 
 
 if __name__ == "__main__":

computer_vision/cnn_classification.py

@@ -28,11 +28,13 @@ import tensorflow as tf
 from tensorflow.keras import layers, models
 
 if __name__ == "__main__":
-
     # Initialising the CNN
+    # (Sequential- Building the model layer by layer)
     classifier = models.Sequential()
 
     # Step 1 - Convolution
+    # Here 64,64 is the length & breadth of dataset images and 3 is for the RGB channel
+    # (3,3) is the kernel size (filter matrix)
     classifier.add(
         layers.Conv2D(32, (3, 3), input_shape=(64, 64, 3), activation="relu")
     )
@@ -91,7 +93,7 @@ if __name__ == "__main__":
     test_image = tf.keras.preprocessing.image.img_to_array(test_image)
     test_image = np.expand_dims(test_image, axis=0)
     result = classifier.predict(test_image)
-    training_set.class_indices
+    # training_set.class_indices
     if result[0][0] == 0:
         prediction = "Normal"
     if result[0][0] == 1:

computer_vision/flip_augmentation.py

@@ -22,7 +22,6 @@ def main() -> None:
     Get images list and annotations list from input dir.
     Update new images and annotations.
     Save images and annotations in output dir.
-    >>> pass  # A doctest is not possible for this function.
     """
     img_paths, annos = get_dataset(LABEL_DIR, IMAGE_DIR)
     print("Processing...")
@@ -33,13 +32,13 @@ def main() -> None:
         letter_code = random_chars(32)
         file_name = paths[index].split(os.sep)[-1].rsplit(".", 1)[0]
         file_root = f"{OUTPUT_DIR}/{file_name}_FLIP_{letter_code}"
-        cv2.imwrite(f"/{file_root}.jpg", image, [cv2.IMWRITE_JPEG_QUALITY, 85])
+        cv2.imwrite(f"{file_root}.jpg", image, [cv2.IMWRITE_JPEG_QUALITY, 85])
         print(f"Success {index+1}/{len(new_images)} with {file_name}")
         annos_list = []
         for anno in new_annos[index]:
             obj = f"{anno[0]} {anno[1]} {anno[2]} {anno[3]} {anno[4]}"
             annos_list.append(obj)
-        with open(f"/{file_root}.txt", "w") as outfile:
+        with open(f"{file_root}.txt", "w") as outfile:
             outfile.write("\n".join(line for line in annos_list))
 
 
@@ -48,7 +47,6 @@ def get_dataset(label_dir: str, img_dir: str) -> tuple[list, list]:
     - label_dir <type: str>: Path to label include annotation of images
     - img_dir <type: str>: Path to folder contain images
     Return <type: list>: List of images path and labels
-    >>> pass  # A doctest is not possible for this function.
     """
     img_paths = []
     labels = []
@@ -88,7 +86,6 @@ def update_image_and_anno(
         - new_imgs_list <type: narray>: image after resize
         - new_annos_lists <type: list>: list of new annotation after scale
         - path_list <type: list>: list the name of image file
-    >>> pass  # A doctest is not possible for this function.
     """
     new_annos_lists = []
     path_list = []