diff --git a/.devcontainer/Dockerfile b/.devcontainer/Dockerfile
new file mode 100644
index 000000000..b5a5347c6
--- /dev/null
+++ b/.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
diff --git a/.devcontainer/devcontainer.json b/.devcontainer/devcontainer.json
new file mode 100644
index 000000000..c5a855b25
--- /dev/null
+++ b/.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"
+}
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
index b3ba8baf9..1f9797fae 100644
--- a/.github/pull_request_template.md
+++ b/.github/pull_request_template.md
@@ -17,4 +17,4 @@
* [ ] 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 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 commit message contains `Fixes: #{$ISSUE_NO}`.
+* [ ] 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".
diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 6b9cc890b..fc8cb6369 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -22,11 +22,9 @@ jobs:
python -m pip install --upgrade pip setuptools six wheel
python -m pip install pytest-cov -r requirements.txt
- name: Run tests
- # See: #6591 for re-enabling tests on Python v3.11
+ # TODO: #8818 Re-enable quantum tests
run: pytest
- --ignore=computer_vision/cnn_classification.py
- --ignore=machine_learning/lstm/lstm_prediction.py
- --ignore=quantum/
+ --ignore=quantum/q_fourier_transform.py
--ignore=project_euler/
--ignore=scripts/validate_solutions.py
--cov-report=term-missing:skip-covered
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 288473ca3..e158bd8d6 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -15,25 +15,25 @@ repos:
hooks:
- id: auto-walrus
- - repo: https://github.com/charliermarsh/ruff-pre-commit
- rev: v0.0.262
+ - repo: https://github.com/astral-sh/ruff-pre-commit
+ rev: v0.0.281
hooks:
- id: ruff
- repo: https://github.com/psf/black
- rev: 23.3.0
+ rev: 23.7.0
hooks:
- id: black
- repo: https://github.com/codespell-project/codespell
- rev: v2.2.4
+ rev: v2.2.5
hooks:
- id: codespell
additional_dependencies:
- tomli
- repo: https://github.com/tox-dev/pyproject-fmt
- rev: "0.10.0"
+ rev: "0.13.0"
hooks:
- id: pyproject-fmt
@@ -46,12 +46,12 @@ repos:
pass_filenames: false
- repo: https://github.com/abravalheri/validate-pyproject
- rev: v0.12.2
+ rev: v0.13
hooks:
- id: validate-pyproject
- repo: https://github.com/pre-commit/mirrors-mypy
- rev: v1.2.0
+ rev: v1.4.1
hooks:
- id: mypy
args:
diff --git a/.vscode/settings.json b/.vscode/settings.json
new file mode 100644
index 000000000..ef16fa1aa
--- /dev/null
+++ b/.vscode/settings.json
@@ -0,0 +1,5 @@
+{
+ "githubPullRequests.ignoredPullRequestBranches": [
+ "master"
+ ]
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 2bb0c2e39..4a1bb6527 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -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?
diff --git a/DIRECTORY.md b/DIRECTORY.md
index 8e67c85c6..fdcf0ceed 100644
--- a/DIRECTORY.md
+++ b/DIRECTORY.md
@@ -29,6 +29,7 @@
* [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)
@@ -146,6 +147,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)
@@ -166,6 +168,7 @@
* 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)
@@ -233,8 +236,8 @@
* [Double Ended Queue](data_structures/queue/double_ended_queue.py)
* [Linked Queue](data_structures/queue/linked_queue.py)
* [Priority Queue Using List](data_structures/queue/priority_queue_using_list.py)
+ * [Queue By List](data_structures/queue/queue_by_list.py)
* [Queue By Two Stacks](data_structures/queue/queue_by_two_stacks.py)
- * [Queue On List](data_structures/queue/queue_on_list.py)
* [Queue On Pseudo Stack](data_structures/queue/queue_on_pseudo_stack.py)
* Stacks
* [Balanced Parentheses](data_structures/stacks/balanced_parentheses.py)
@@ -290,7 +293,7 @@
* [Inversions](divide_and_conquer/inversions.py)
* [Kth Order Statistic](divide_and_conquer/kth_order_statistic.py)
* [Max Difference Pair](divide_and_conquer/max_difference_pair.py)
- * [Max Subarray 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)
@@ -321,8 +324,7 @@
* [Matrix Chain Order](dynamic_programming/matrix_chain_order.py)
* [Max Non Adjacent Sum](dynamic_programming/max_non_adjacent_sum.py)
* [Max Product Subarray](dynamic_programming/max_product_subarray.py)
- * [Max Sub Array](dynamic_programming/max_sub_array.py)
- * [Max Sum Contiguous Subsequence](dynamic_programming/max_sum_contiguous_subsequence.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)
@@ -363,6 +365,7 @@
## 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
@@ -409,6 +412,7 @@
* [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)
@@ -418,8 +422,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)
@@ -448,6 +453,7 @@
## 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
@@ -477,11 +483,15 @@
* [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)
@@ -501,7 +511,7 @@
* 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)
+ * [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)
@@ -512,7 +522,6 @@
* [Xgboost Regressor](machine_learning/xgboost_regressor.py)
## Maths
- * [3N Plus 1](maths/3n_plus_1.py)
* [Abs](maths/abs.py)
* [Add](maths/add.py)
* [Addition Without Arithmetic](maths/addition_without_arithmetic.py)
@@ -548,6 +557,7 @@
* [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)
@@ -575,16 +585,15 @@
* [Hardy Ramanujanalgo](maths/hardy_ramanujanalgo.py)
* [Hexagonal Number](maths/hexagonal_number.py)
* [Integration By Simpson Approx](maths/integration_by_simpson_approx.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)
* [Juggler Sequence](maths/juggler_sequence.py)
- * [Kadanes](maths/kadanes.py)
* [Karatsuba](maths/karatsuba.py)
* [Krishnamurthy Number](maths/krishnamurthy_number.py)
* [Kth Lexicographic Permutation](maths/kth_lexicographic_permutation.py)
* [Largest Of Very Large Numbers](maths/largest_of_very_large_numbers.py)
- * [Largest Subarray Sum](maths/largest_subarray_sum.py)
* [Least Common Multiple](maths/least_common_multiple.py)
* [Line Length](maths/line_length.py)
* [Liouville Lambda](maths/liouville_lambda.py)
@@ -604,6 +613,7 @@
* [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)
@@ -630,6 +640,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
@@ -645,6 +656,7 @@
* [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)
@@ -655,6 +667,7 @@
* [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)
@@ -669,6 +682,7 @@
## 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)
@@ -691,6 +705,8 @@
## 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)
* [Input Data](neural_network/input_data.py)
@@ -707,13 +723,16 @@
* [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)
+ * [Number Container System](other/number_container_system.py)
* [Password](other/password.py)
* [Quine](other/quine.py)
* [Scoring Algorithm](other/scoring_algorithm.py)
@@ -721,7 +740,9 @@
* [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)
@@ -737,6 +758,7 @@
* [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
@@ -1042,7 +1064,6 @@
* [Q Fourier Transform](quantum/q_fourier_transform.py)
* [Q Full Adder](quantum/q_full_adder.py)
* [Quantum Entanglement](quantum/quantum_entanglement.py)
- * [Quantum Random](quantum/quantum_random.py)
* [Quantum Teleportation](quantum/quantum_teleportation.py)
* [Ripple Adder Classic](quantum/ripple_adder_classic.py)
* [Single Qubit Measure](quantum/single_qubit_measure.py)
@@ -1076,6 +1097,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)
@@ -1144,7 +1166,6 @@
* [Indian Phone Validator](strings/indian_phone_validator.py)
* [Is Contains Unique Chars](strings/is_contains_unique_chars.py)
* [Is Isogram](strings/is_isogram.py)
- * [Is Palindrome](strings/is_palindrome.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)
@@ -1166,7 +1187,9 @@
* [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)
@@ -1186,7 +1209,6 @@
* [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)
diff --git a/README.md b/README.md
index bf6e0ed3c..d8eba4e01 100644
--- a/README.md
+++ b/README.md
@@ -13,7 +13,7 @@
-
+
@@ -42,7 +42,7 @@ Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribut
## Community Channels
-We are on [Discord](https://discord.gg/c7MnfGFGa6) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!
+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
diff --git a/arithmetic_analysis/jacobi_iteration_method.py b/arithmetic_analysis/jacobi_iteration_method.py
index fe506a94a..17edf4bf4 100644
--- a/arithmetic_analysis/jacobi_iteration_method.py
+++ b/arithmetic_analysis/jacobi_iteration_method.py
@@ -49,7 +49,9 @@ def jacobi_iteration_method(
>>> 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
@@ -59,7 +61,9 @@ 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
@@ -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")
diff --git a/arithmetic_analysis/lu_decomposition.py b/arithmetic_analysis/lu_decomposition.py
index 941c1dadf..eaabce544 100644
--- a/arithmetic_analysis/lu_decomposition.py
+++ b/arithmetic_analysis/lu_decomposition.py
@@ -80,10 +80,11 @@ def lower_upper_decomposition(table: np.ndarray) -> tuple[np.ndarray, np.ndarray
# 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 "
+ 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))
diff --git a/arithmetic_analysis/newton_raphson.py b/arithmetic_analysis/newton_raphson.py
index aee2f07e5..1b90ad417 100644
--- a/arithmetic_analysis/newton_raphson.py
+++ b/arithmetic_analysis/newton_raphson.py
@@ -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)
diff --git a/audio_filters/iir_filter.py b/audio_filters/iir_filter.py
index bd448175f..f3c1ad43b 100644
--- a/audio_filters/iir_filter.py
+++ b/audio_filters/iir_filter.py
@@ -50,16 +50,18 @@ class IIRFilter:
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
diff --git a/backtracking/knight_tour.py b/backtracking/knight_tour.py
index bb650ece3..cc88307b7 100644
--- a/backtracking/knight_tour.py
+++ b/backtracking/knight_tour.py
@@ -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__":
diff --git a/backtracking/power_sum.py b/backtracking/power_sum.py
new file mode 100644
index 000000000..fcf1429f8
--- /dev/null
+++ b/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()
diff --git a/bit_manipulation/reverse_bits.py b/bit_manipulation/reverse_bits.py
index 55608ae12..a8c77c11b 100644
--- a/bit_manipulation/reverse_bits.py
+++ b/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)
diff --git a/boolean_algebra/and_gate.py b/boolean_algebra/and_gate.py
index cbbcfde79..834116772 100644
--- a/boolean_algebra/and_gate.py
+++ b/boolean_algebra/and_gate.py
@@ -43,6 +43,8 @@ def test_and_gate() -> None:
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))
diff --git a/cellular_automata/game_of_life.py b/cellular_automata/game_of_life.py
index 8e5470251..d691a2b73 100644
--- a/cellular_automata/game_of_life.py
+++ b/cellular_automata/game_of_life.py
@@ -10,7 +10,7 @@ Python:
- 3.5
Usage:
- - $python3 game_o_life
+ - $python3 game_of_life
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 "
+usage_doc = "Usage of script: script_name "
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,7 +61,7 @@ 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]))
@@ -70,10 +71,7 @@ def run(canvas: list[list[bool]]) -> list[list[bool]]:
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:
@@ -98,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
diff --git a/ciphers/base64.py b/ciphers/base64.py
index 38a952acc..2b950b1be 100644
--- a/ciphers/base64.py
+++ b/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
diff --git a/ciphers/beaufort_cipher.py b/ciphers/beaufort_cipher.py
index 8eae847a7..788fc72b8 100644
--- a/ciphers/beaufort_cipher.py
+++ b/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
diff --git a/ciphers/cryptomath_module.py b/ciphers/cryptomath_module.py
index be8764ff3..6f15f7b73 100644
--- a/ciphers/cryptomath_module.py
+++ b/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:
diff --git a/ciphers/diffie_hellman.py b/ciphers/diffie_hellman.py
index cd40a6b9c..aec7fb3ea 100644
--- a/ciphers/diffie_hellman.py
+++ b/ciphers/diffie_hellman.py
@@ -10,13 +10,13 @@ primes = {
5: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
- + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
- + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
- + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
- + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
- + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
- + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+ "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+ "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA237327FFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
@@ -25,16 +25,16 @@ primes = {
14: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
- + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
- + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
- + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
- + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
- + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
- + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
- + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
- + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
- + "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+ "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+ "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+ "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+ "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+ "15728E5A8AACAA68FFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
@@ -43,21 +43,21 @@ primes = {
15: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
- + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
- + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
- + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
- + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
- + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
- + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
- + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
- + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
- + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
- + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
- + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
- + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
- + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
- + "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+ "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+ "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+ "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+ "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+ "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+ "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+ "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+ "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+ "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+ "43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
@@ -66,27 +66,27 @@ primes = {
16: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
- + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
- + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
- + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
- + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
- + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
- + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
- + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
- + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
- + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
- + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
- + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
- + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
- + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
- + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
- + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
- + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
- + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
- + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
- + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
- + "FFFFFFFFFFFFFFFF",
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+ "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+ "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+ "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+ "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+ "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+ "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+ "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+ "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+ "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+ "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+ "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+ "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+ "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+ "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+ "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934063199"
+ "FFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
@@ -95,33 +95,33 @@ primes = {
17: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E08"
- + "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
- + "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
- + "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
- + "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
- + "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
- + "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
- + "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
- + "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
- + "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
- + "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
- + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
- + "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
- + "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
- + "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
- + "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
- + "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
- + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
- + "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
- + "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
- + "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
- + "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
- + "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
- + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
- + "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
- + "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
- + "6DCC4024FFFFFFFFFFFFFFFF",
+ "8A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B"
+ "302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9"
+ "A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE6"
+ "49286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8"
+ "FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C"
+ "180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF695581718"
+ "3995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D"
+ "04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7D"
+ "B3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D226"
+ "1AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+ "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFC"
+ "E0FD108E4B82D120A92108011A723C12A787E6D788719A10BDBA5B26"
+ "99C327186AF4E23C1A946834B6150BDA2583E9CA2AD44CE8DBBBC2DB"
+ "04DE8EF92E8EFC141FBECAA6287C59474E6BC05D99B2964FA090C3A2"
+ "233BA186515BE7ED1F612970CEE2D7AFB81BDD762170481CD0069127"
+ "D5B05AA993B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+ "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BDF8FF9406"
+ "AD9E530EE5DB382F413001AEB06A53ED9027D831179727B0865A8918"
+ "DA3EDBEBCF9B14ED44CE6CBACED4BB1BDB7F1447E6CC254B33205151"
+ "2BD7AF426FB8F401378CD2BF5983CA01C64B92ECF032EA15D1721D03"
+ "F482D7CE6E74FEF6D55E702F46980C82B5A84031900B1C9E59E7C97F"
+ "BEC7E8F323A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+ "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE32806A1D58B"
+ "B7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55CDA56C9EC2EF29632"
+ "387FE8D76E3C0468043E8F663F4860EE12BF2D5B0B7474D6E694F91E"
+ "6DCC4024FFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
@@ -130,48 +130,48 @@ primes = {
18: {
"prime": int(
"FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1"
- + "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
- + "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
- + "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
- + "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
- + "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
- + "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
- + "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
- + "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
- + "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
- + "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
- + "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
- + "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
- + "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
- + "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
- + "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
- + "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
- + "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
- + "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
- + "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
- + "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
- + "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
- + "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
- + "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
- + "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
- + "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
- + "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
- + "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
- + "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
- + "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
- + "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
- + "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
- + "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
- + "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
- + "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
- + "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
- + "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
- + "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
- + "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
- + "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
- + "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
- + "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
- + "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
+ "29024E088A67CC74020BBEA63B139B22514A08798E3404DD"
+ "EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245"
+ "E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED"
+ "EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D"
+ "C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F"
+ "83655D23DCA3AD961C62F356208552BB9ED529077096966D"
+ "670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B"
+ "E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9"
+ "DE2BCBF6955817183995497CEA956AE515D2261898FA0510"
+ "15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64"
+ "ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7"
+ "ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B"
+ "F12FFA06D98A0864D87602733EC86A64521F2B18177B200C"
+ "BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31"
+ "43DB5BFCE0FD108E4B82D120A92108011A723C12A787E6D7"
+ "88719A10BDBA5B2699C327186AF4E23C1A946834B6150BDA"
+ "2583E9CA2AD44CE8DBBBC2DB04DE8EF92E8EFC141FBECAA6"
+ "287C59474E6BC05D99B2964FA090C3A2233BA186515BE7ED"
+ "1F612970CEE2D7AFB81BDD762170481CD0069127D5B05AA9"
+ "93B4EA988D8FDDC186FFB7DC90A6C08F4DF435C934028492"
+ "36C3FAB4D27C7026C1D4DCB2602646DEC9751E763DBA37BD"
+ "F8FF9406AD9E530EE5DB382F413001AEB06A53ED9027D831"
+ "179727B0865A8918DA3EDBEBCF9B14ED44CE6CBACED4BB1B"
+ "DB7F1447E6CC254B332051512BD7AF426FB8F401378CD2BF"
+ "5983CA01C64B92ECF032EA15D1721D03F482D7CE6E74FEF6"
+ "D55E702F46980C82B5A84031900B1C9E59E7C97FBEC7E8F3"
+ "23A97A7E36CC88BE0F1D45B7FF585AC54BD407B22B4154AA"
+ "CC8F6D7EBF48E1D814CC5ED20F8037E0A79715EEF29BE328"
+ "06A1D58BB7C5DA76F550AA3D8A1FBFF0EB19CCB1A313D55C"
+ "DA56C9EC2EF29632387FE8D76E3C0468043E8F663F4860EE"
+ "12BF2D5B0B7474D6E694F91E6DBE115974A3926F12FEE5E4"
+ "38777CB6A932DF8CD8BEC4D073B931BA3BC832B68D9DD300"
+ "741FA7BF8AFC47ED2576F6936BA424663AAB639C5AE4F568"
+ "3423B4742BF1C978238F16CBE39D652DE3FDB8BEFC848AD9"
+ "22222E04A4037C0713EB57A81A23F0C73473FC646CEA306B"
+ "4BCBC8862F8385DDFA9D4B7FA2C087E879683303ED5BDD3A"
+ "062B3CF5B3A278A66D2A13F83F44F82DDF310EE074AB6A36"
+ "4597E899A0255DC164F31CC50846851DF9AB48195DED7EA1"
+ "B1D510BD7EE74D73FAF36BC31ECFA268359046F4EB879F92"
+ "4009438B481C6CD7889A002ED5EE382BC9190DA6FC026E47"
+ "9558E4475677E9AA9E3050E2765694DFC81F56E880B96E71"
+ "60C980DD98EDD3DFFFFFFFFFFFFFFFFF",
base=16,
),
"generator": 2,
diff --git a/ciphers/enigma_machine2.py b/ciphers/enigma_machine2.py
index 07d21893f..ec0d44e4a 100644
--- a/ciphers/enigma_machine2.py
+++ b/ciphers/enigma_machine2.py
@@ -87,22 +87,20 @@ def _validator(
# Checks if there are 3 unique rotors
if (unique_rotsel := len(set(rotsel))) < 3:
- raise Exception(f"Please use 3 unique rotors (not {unique_rotsel})")
+ 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)
@@ -130,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 {}
@@ -142,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
diff --git a/ciphers/hill_cipher.py b/ciphers/hill_cipher.py
index f646d567b..b4424e822 100644
--- a/ciphers/hill_cipher.py
+++ b/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:
"""
diff --git a/ciphers/mixed_keyword_cypher.py b/ciphers/mixed_keyword_cypher.py
index 806004faa..b984808fc 100644
--- a/ciphers/mixed_keyword_cypher.py
+++ b/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 _ in range(len_temp):
- s.append(temp[k])
- if 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"))
diff --git a/compression/burrows_wheeler.py b/compression/burrows_wheeler.py
index 0916b8a65..52bb045d9 100644
--- a/compression/burrows_wheeler.py
+++ b/compression/burrows_wheeler.py
@@ -150,7 +150,7 @@ def reverse_bwt(bwt_string: str, idx_original_string: int) -> str:
raise ValueError("The parameter idx_original_string must not be lower than 0.")
if idx_original_string >= len(bwt_string):
raise ValueError(
- "The parameter idx_original_string must be lower than" " len(bwt_string)."
+ "The parameter idx_original_string must be lower than len(bwt_string)."
)
ordered_rotations = [""] * len(bwt_string)
diff --git a/conversions/astronomical_length_scale_conversion.py b/conversions/astronomical_length_scale_conversion.py
index 804d82487..0f4136449 100644
--- a/conversions/astronomical_length_scale_conversion.py
+++ b/conversions/astronomical_length_scale_conversion.py
@@ -77,15 +77,17 @@ def length_conversion(value: float, from_type: str, to_type: str) -> float:
to_sanitized = UNIT_SYMBOL.get(to_sanitized, to_sanitized)
if from_sanitized not in METRIC_CONVERSION:
- raise ValueError(
+ msg = (
f"Invalid 'from_type' value: {from_type!r}.\n"
f"Conversion abbreviations are: {', '.join(METRIC_CONVERSION)}"
)
+ raise ValueError(msg)
if to_sanitized not in METRIC_CONVERSION:
- raise ValueError(
+ msg = (
f"Invalid 'to_type' value: {to_type!r}.\n"
f"Conversion abbreviations are: {', '.join(METRIC_CONVERSION)}"
)
+ raise ValueError(msg)
from_exponent = METRIC_CONVERSION[from_sanitized]
to_exponent = METRIC_CONVERSION[to_sanitized]
exponent = 1
diff --git a/conversions/energy_conversions.py b/conversions/energy_conversions.py
new file mode 100644
index 000000000..51de6b313
--- /dev/null
+++ b/conversions/energy_conversions.py
@@ -0,0 +1,114 @@
+"""
+Conversion of energy units.
+
+Available units: joule, kilojoule, megajoule, gigajoule,\
+ wattsecond, watthour, kilowatthour, newtonmeter, calorie_nutr,\
+ kilocalorie_nutr, electronvolt, britishthermalunit_it, footpound
+
+USAGE :
+-> Import this file into their respective project.
+-> Use the function energy_conversion() for conversion of energy units.
+-> Parameters :
+ -> from_type : From which type you want to convert
+ -> to_type : To which type you want to convert
+ -> value : the value which you want to convert
+
+REFERENCES :
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Units_of_energy
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Joule
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Kilowatt-hour
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Newton-metre
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Calorie
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Electronvolt
+-> Wikipedia reference: https://en.wikipedia.org/wiki/British_thermal_unit
+-> Wikipedia reference: https://en.wikipedia.org/wiki/Foot-pound_(energy)
+-> Unit converter reference: https://www.unitconverters.net/energy-converter.html
+"""
+
+ENERGY_CONVERSION: dict[str, float] = {
+ "joule": 1.0,
+ "kilojoule": 1_000,
+ "megajoule": 1_000_000,
+ "gigajoule": 1_000_000_000,
+ "wattsecond": 1.0,
+ "watthour": 3_600,
+ "kilowatthour": 3_600_000,
+ "newtonmeter": 1.0,
+ "calorie_nutr": 4_186.8,
+ "kilocalorie_nutr": 4_186_800.00,
+ "electronvolt": 1.602_176_634e-19,
+ "britishthermalunit_it": 1_055.055_85,
+ "footpound": 1.355_818,
+}
+
+
+def energy_conversion(from_type: str, to_type: str, value: float) -> float:
+ """
+ Conversion of energy units.
+ >>> energy_conversion("joule", "joule", 1)
+ 1.0
+ >>> energy_conversion("joule", "kilojoule", 1)
+ 0.001
+ >>> energy_conversion("joule", "megajoule", 1)
+ 1e-06
+ >>> energy_conversion("joule", "gigajoule", 1)
+ 1e-09
+ >>> energy_conversion("joule", "wattsecond", 1)
+ 1.0
+ >>> energy_conversion("joule", "watthour", 1)
+ 0.0002777777777777778
+ >>> energy_conversion("joule", "kilowatthour", 1)
+ 2.7777777777777776e-07
+ >>> energy_conversion("joule", "newtonmeter", 1)
+ 1.0
+ >>> energy_conversion("joule", "calorie_nutr", 1)
+ 0.00023884589662749592
+ >>> energy_conversion("joule", "kilocalorie_nutr", 1)
+ 2.388458966274959e-07
+ >>> energy_conversion("joule", "electronvolt", 1)
+ 6.241509074460763e+18
+ >>> energy_conversion("joule", "britishthermalunit_it", 1)
+ 0.0009478171226670134
+ >>> energy_conversion("joule", "footpound", 1)
+ 0.7375621211696556
+ >>> energy_conversion("joule", "megajoule", 1000)
+ 0.001
+ >>> energy_conversion("calorie_nutr", "kilocalorie_nutr", 1000)
+ 1.0
+ >>> energy_conversion("kilowatthour", "joule", 10)
+ 36000000.0
+ >>> energy_conversion("britishthermalunit_it", "footpound", 1)
+ 778.1692306784539
+ >>> energy_conversion("watthour", "joule", "a") # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ TypeError: unsupported operand type(s) for /: 'str' and 'float'
+ >>> energy_conversion("wrongunit", "joule", 1) # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ ValueError: Incorrect 'from_type' or 'to_type' value: 'wrongunit', 'joule'
+ Valid values are: joule, ... footpound
+ >>> energy_conversion("joule", "wrongunit", 1) # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ ValueError: Incorrect 'from_type' or 'to_type' value: 'joule', 'wrongunit'
+ Valid values are: joule, ... footpound
+ >>> energy_conversion("123", "abc", 1) # doctest: +ELLIPSIS
+ Traceback (most recent call last):
+ ...
+ ValueError: Incorrect 'from_type' or 'to_type' value: '123', 'abc'
+ Valid values are: joule, ... footpound
+ """
+ if to_type not in ENERGY_CONVERSION or from_type not in ENERGY_CONVERSION:
+ msg = (
+ f"Incorrect 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"
+ f"Valid values are: {', '.join(ENERGY_CONVERSION)}"
+ )
+ raise ValueError(msg)
+ return value * ENERGY_CONVERSION[from_type] / ENERGY_CONVERSION[to_type]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/conversions/length_conversion.py b/conversions/length_conversion.py
index 790d9c116..d8f395152 100644
--- a/conversions/length_conversion.py
+++ b/conversions/length_conversion.py
@@ -104,15 +104,17 @@ def length_conversion(value: float, from_type: str, to_type: str) -> float:
new_to = to_type.lower().rstrip("s")
new_to = TYPE_CONVERSION.get(new_to, new_to)
if new_from not in METRIC_CONVERSION:
- raise ValueError(
+ msg = (
f"Invalid 'from_type' value: {from_type!r}.\n"
f"Conversion abbreviations are: {', '.join(METRIC_CONVERSION)}"
)
+ raise ValueError(msg)
if new_to not in METRIC_CONVERSION:
- raise ValueError(
+ msg = (
f"Invalid 'to_type' value: {to_type!r}.\n"
f"Conversion abbreviations are: {', '.join(METRIC_CONVERSION)}"
)
+ raise ValueError(msg)
return value * METRIC_CONVERSION[new_from].from_ * METRIC_CONVERSION[new_to].to
diff --git a/conversions/prefix_conversions_string.py b/conversions/prefix_conversions_string.py
index 3851d7c8b..9344c9672 100644
--- a/conversions/prefix_conversions_string.py
+++ b/conversions/prefix_conversions_string.py
@@ -96,7 +96,7 @@ def add_si_prefix(value: float) -> str:
for name_prefix, value_prefix in prefixes.items():
numerical_part = value / (10**value_prefix)
if numerical_part > 1:
- return f"{str(numerical_part)} {name_prefix}"
+ return f"{numerical_part!s} {name_prefix}"
return str(value)
@@ -111,7 +111,7 @@ def add_binary_prefix(value: float) -> str:
for prefix in BinaryUnit:
numerical_part = value / (2**prefix.value)
if numerical_part > 1:
- return f"{str(numerical_part)} {prefix.name}"
+ return f"{numerical_part!s} {prefix.name}"
return str(value)
diff --git a/conversions/rgb_hsv_conversion.py b/conversions/rgb_hsv_conversion.py
index 081cfe1d7..74b3d33e4 100644
--- a/conversions/rgb_hsv_conversion.py
+++ b/conversions/rgb_hsv_conversion.py
@@ -121,8 +121,8 @@ def rgb_to_hsv(red: int, green: int, blue: int) -> list[float]:
float_red = red / 255
float_green = green / 255
float_blue = blue / 255
- value = max(max(float_red, float_green), float_blue)
- chroma = value - min(min(float_red, float_green), float_blue)
+ value = max(float_red, float_green, float_blue)
+ chroma = value - min(float_red, float_green, float_blue)
saturation = 0 if value == 0 else chroma / value
if chroma == 0:
diff --git a/conversions/speed_conversions.py b/conversions/speed_conversions.py
index 62da9e137..ba497119d 100644
--- a/conversions/speed_conversions.py
+++ b/conversions/speed_conversions.py
@@ -57,10 +57,11 @@ def convert_speed(speed: float, unit_from: str, unit_to: str) -> float:
115.078
"""
if unit_to not in speed_chart or unit_from not in speed_chart_inverse:
- raise ValueError(
+ msg = (
f"Incorrect 'from_type' or 'to_type' value: {unit_from!r}, {unit_to!r}\n"
f"Valid values are: {', '.join(speed_chart_inverse)}"
)
+ raise ValueError(msg)
return round(speed * speed_chart[unit_from] * speed_chart_inverse[unit_to], 3)
diff --git a/conversions/weight_conversion.py b/conversions/weight_conversion.py
index 5c032a497..e8326e0b6 100644
--- a/conversions/weight_conversion.py
+++ b/conversions/weight_conversion.py
@@ -299,10 +299,11 @@ def weight_conversion(from_type: str, to_type: str, value: float) -> float:
1.999999998903455
"""
if to_type not in KILOGRAM_CHART or from_type not in WEIGHT_TYPE_CHART:
- raise ValueError(
+ msg = (
f"Invalid 'from_type' or 'to_type' value: {from_type!r}, {to_type!r}\n"
f"Supported values are: {', '.join(WEIGHT_TYPE_CHART)}"
)
+ raise ValueError(msg)
return value * KILOGRAM_CHART[to_type] * WEIGHT_TYPE_CHART[from_type]
diff --git a/data_structures/arrays/permutations.py b/data_structures/arrays/permutations.py
index eb3f26517..4558bd8d4 100644
--- a/data_structures/arrays/permutations.py
+++ b/data_structures/arrays/permutations.py
@@ -1,7 +1,6 @@
def permute(nums: list[int]) -> list[list[int]]:
"""
Return all permutations.
-
>>> from itertools import permutations
>>> numbers= [1,2,3]
>>> all(list(nums) in permute(numbers) for nums in permutations(numbers))
@@ -20,7 +19,32 @@ def permute(nums: list[int]) -> list[list[int]]:
return result
+def permute2(nums):
+ """
+ Return all permutations of the given list.
+
+ >>> permute2([1, 2, 3])
+ [[1, 2, 3], [1, 3, 2], [2, 1, 3], [2, 3, 1], [3, 2, 1], [3, 1, 2]]
+ """
+
+ def backtrack(start):
+ if start == len(nums) - 1:
+ output.append(nums[:])
+ else:
+ for i in range(start, len(nums)):
+ nums[start], nums[i] = nums[i], nums[start]
+ backtrack(start + 1)
+ nums[start], nums[i] = nums[i], nums[start] # backtrack
+
+ output = []
+ backtrack(0)
+ return output
+
+
if __name__ == "__main__":
import doctest
+ # use res to print the data in permute2 function
+ res = permute2([1, 2, 3])
+ print(res)
doctest.testmod()
diff --git a/data_structures/arrays/product_sum.py b/data_structures/arrays/product_sum.py
new file mode 100644
index 000000000..4fb906f36
--- /dev/null
+++ b/data_structures/arrays/product_sum.py
@@ -0,0 +1,98 @@
+"""
+Calculate the Product Sum from a Special Array.
+reference: https://dev.to/sfrasica/algorithms-product-sum-from-an-array-dc6
+
+Python doctests can be run with the following command:
+python -m doctest -v product_sum.py
+
+Calculate the product sum of a "special" array which can contain integers or nested
+arrays. The product sum is obtained by adding all elements and multiplying by their
+respective depths.
+
+For example, in the array [x, y], the product sum is (x + y). In the array [x, [y, z]],
+the product sum is x + 2 * (y + z). In the array [x, [y, [z]]],
+the product sum is x + 2 * (y + 3z).
+
+Example Input:
+[5, 2, [-7, 1], 3, [6, [-13, 8], 4]]
+Output: 12
+
+"""
+
+
+def product_sum(arr: list[int | list], depth: int) -> int:
+ """
+ Recursively calculates the product sum of an array.
+
+ The product sum of an array is defined as the sum of its elements multiplied by
+ their respective depths. If an element is a list, its product sum is calculated
+ recursively by multiplying the sum of its elements with its depth plus one.
+
+ Args:
+ arr: The array of integers and nested lists.
+ depth: The current depth level.
+
+ Returns:
+ int: The product sum of the array.
+
+ Examples:
+ >>> product_sum([1, 2, 3], 1)
+ 6
+ >>> product_sum([-1, 2, [-3, 4]], 2)
+ 8
+ >>> product_sum([1, 2, 3], -1)
+ -6
+ >>> product_sum([1, 2, 3], 0)
+ 0
+ >>> product_sum([1, 2, 3], 7)
+ 42
+ >>> product_sum((1, 2, 3), 7)
+ 42
+ >>> product_sum({1, 2, 3}, 7)
+ 42
+ >>> product_sum([1, -1], 1)
+ 0
+ >>> product_sum([1, -2], 1)
+ -1
+ >>> product_sum([-3.5, [1, [0.5]]], 1)
+ 1.5
+
+ """
+ total_sum = 0
+ for ele in arr:
+ total_sum += product_sum(ele, depth + 1) if isinstance(ele, list) else ele
+ return total_sum * depth
+
+
+def product_sum_array(array: list[int | list]) -> int:
+ """
+ Calculates the product sum of an array.
+
+ Args:
+ array (List[Union[int, List]]): The array of integers and nested lists.
+
+ Returns:
+ int: The product sum of the array.
+
+ Examples:
+ >>> product_sum_array([1, 2, 3])
+ 6
+ >>> product_sum_array([1, [2, 3]])
+ 11
+ >>> product_sum_array([1, [2, [3, 4]]])
+ 47
+ >>> product_sum_array([0])
+ 0
+ >>> product_sum_array([-3.5, [1, [0.5]]])
+ 1.5
+ >>> product_sum_array([1, -2])
+ -1
+
+ """
+ return product_sum(array, 1)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/data_structures/binary_tree/binary_search_tree.py b/data_structures/binary_tree/binary_search_tree.py
index cd88cc10e..c72195424 100644
--- a/data_structures/binary_tree/binary_search_tree.py
+++ b/data_structures/binary_tree/binary_search_tree.py
@@ -40,7 +40,7 @@ class BinarySearchTree:
else:
node.parent.left = new_children
else:
- self.root = None
+ self.root = new_children
def is_right(self, node: Node) -> bool:
if node.parent and node.parent.right:
diff --git a/data_structures/binary_tree/binary_search_tree_recursive.py b/data_structures/binary_tree/binary_search_tree_recursive.py
index 97eb8e25b..b5b983b9b 100644
--- a/data_structures/binary_tree/binary_search_tree_recursive.py
+++ b/data_structures/binary_tree/binary_search_tree_recursive.py
@@ -77,7 +77,8 @@ class BinarySearchTree:
elif label > node.label:
node.right = self._put(node.right, label, node)
else:
- raise Exception(f"Node with label {label} already exists")
+ msg = f"Node with label {label} already exists"
+ raise Exception(msg)
return node
@@ -100,7 +101,8 @@ class BinarySearchTree:
def _search(self, node: Node | None, label: int) -> Node:
if node is None:
- raise Exception(f"Node with label {label} does not exist")
+ msg = f"Node with label {label} does not exist"
+ raise Exception(msg)
else:
if label < node.label:
node = self._search(node.left, label)
diff --git a/data_structures/binary_tree/binary_tree_mirror.py b/data_structures/binary_tree/binary_tree_mirror.py
index 1ef950ad6..b8548f4ec 100644
--- a/data_structures/binary_tree/binary_tree_mirror.py
+++ b/data_structures/binary_tree/binary_tree_mirror.py
@@ -31,7 +31,8 @@ def binary_tree_mirror(binary_tree: dict, root: int = 1) -> dict:
if not binary_tree:
raise ValueError("binary tree cannot be empty")
if root not in binary_tree:
- raise ValueError(f"root {root} is not present in the binary_tree")
+ msg = f"root {root} is not present in the binary_tree"
+ raise ValueError(msg)
binary_tree_mirror_dictionary = dict(binary_tree)
binary_tree_mirror_dict(binary_tree_mirror_dictionary, root)
return binary_tree_mirror_dictionary
diff --git a/data_structures/binary_tree/binary_tree_traversals.py b/data_structures/binary_tree/binary_tree_traversals.py
index 71a895e76..2afb7604f 100644
--- a/data_structures/binary_tree/binary_tree_traversals.py
+++ b/data_structures/binary_tree/binary_tree_traversals.py
@@ -58,6 +58,19 @@ def inorder(root: Node | None) -> list[int]:
return [*inorder(root.left), root.data, *inorder(root.right)] if root else []
+def reverse_inorder(root: Node | None) -> list[int]:
+ """
+ Reverse in-order traversal visits right subtree, root node, left subtree.
+ >>> reverse_inorder(make_tree())
+ [3, 1, 5, 2, 4]
+ """
+ return (
+ [*reverse_inorder(root.right), root.data, *reverse_inorder(root.left)]
+ if root
+ else []
+ )
+
+
def height(root: Node | None) -> int:
"""
Recursive function for calculating the height of the binary tree.
@@ -161,15 +174,12 @@ def zigzag(root: Node | None) -> Sequence[Node | None] | list[Any]:
def main() -> None: # Main function for testing.
- """
- Create binary tree.
- """
+ # Create binary tree.
root = make_tree()
- """
- All Traversals of the binary are as follows:
- """
+ # All Traversals of the binary are as follows:
print(f"In-order Traversal: {inorder(root)}")
+ print(f"Reverse In-order Traversal: {reverse_inorder(root)}")
print(f"Pre-order Traversal: {preorder(root)}")
print(f"Post-order Traversal: {postorder(root)}", "\n")
diff --git a/data_structures/binary_tree/red_black_tree.py b/data_structures/binary_tree/red_black_tree.py
index 3ebc8d639..4ebe0e927 100644
--- a/data_structures/binary_tree/red_black_tree.py
+++ b/data_structures/binary_tree/red_black_tree.py
@@ -152,7 +152,7 @@ class RedBlackTree:
self.grandparent.color = 1
self.grandparent._insert_repair()
- def remove(self, label: int) -> RedBlackTree:
+ def remove(self, label: int) -> RedBlackTree: # noqa: PLR0912
"""Remove label from this tree."""
if self.label == label:
if self.left and self.right:
diff --git a/data_structures/binary_tree/segment_tree.py b/data_structures/binary_tree/segment_tree.py
index b05803869..5f822407d 100644
--- a/data_structures/binary_tree/segment_tree.py
+++ b/data_structures/binary_tree/segment_tree.py
@@ -7,7 +7,8 @@ class SegmentTree:
self.st = [0] * (
4 * self.N
) # approximate the overall size of segment tree with array N
- self.build(1, 0, self.N - 1)
+ if self.N:
+ self.build(1, 0, self.N - 1)
def left(self, idx):
return idx * 2
diff --git a/data_structures/disjoint_set/disjoint_set.py b/data_structures/disjoint_set/disjoint_set.py
index f8500bf2c..12dafb2d9 100644
--- a/data_structures/disjoint_set/disjoint_set.py
+++ b/data_structures/disjoint_set/disjoint_set.py
@@ -56,7 +56,8 @@ def find_python_set(node: Node) -> set:
for s in sets:
if node.data in s:
return s
- raise ValueError(f"{node.data} is not in {sets}")
+ msg = f"{node.data} is not in {sets}"
+ raise ValueError(msg)
def test_disjoint_set() -> None:
diff --git a/data_structures/heap/heap.py b/data_structures/heap/heap.py
index b14c55d9d..c1004f349 100644
--- a/data_structures/heap/heap.py
+++ b/data_structures/heap/heap.py
@@ -1,9 +1,28 @@
from __future__ import annotations
+from abc import abstractmethod
from collections.abc import Iterable
+from typing import Generic, Protocol, TypeVar
-class Heap:
+class Comparable(Protocol):
+ @abstractmethod
+ def __lt__(self: T, other: T) -> bool:
+ pass
+
+ @abstractmethod
+ def __gt__(self: T, other: T) -> bool:
+ pass
+
+ @abstractmethod
+ def __eq__(self: T, other: object) -> bool:
+ pass
+
+
+T = TypeVar("T", bound=Comparable)
+
+
+class Heap(Generic[T]):
"""A Max Heap Implementation
>>> unsorted = [103, 9, 1, 7, 11, 15, 25, 201, 209, 107, 5]
@@ -27,7 +46,7 @@ class Heap:
"""
def __init__(self) -> None:
- self.h: list[float] = []
+ self.h: list[T] = []
self.heap_size: int = 0
def __repr__(self) -> str:
@@ -79,7 +98,7 @@ class Heap:
# fix the subsequent violation recursively if any
self.max_heapify(violation)
- def build_max_heap(self, collection: Iterable[float]) -> None:
+ def build_max_heap(self, collection: Iterable[T]) -> None:
"""build max heap from an unsorted array"""
self.h = list(collection)
self.heap_size = len(self.h)
@@ -88,7 +107,7 @@ class Heap:
for i in range(self.heap_size // 2 - 1, -1, -1):
self.max_heapify(i)
- def extract_max(self) -> float:
+ def extract_max(self) -> T:
"""get and remove max from heap"""
if self.heap_size >= 2:
me = self.h[0]
@@ -102,7 +121,7 @@ class Heap:
else:
raise Exception("Empty heap")
- def insert(self, value: float) -> None:
+ def insert(self, value: T) -> None:
"""insert a new value into the max heap"""
self.h.append(value)
idx = (self.heap_size - 1) // 2
@@ -144,7 +163,7 @@ if __name__ == "__main__":
]:
print(f"unsorted array: {unsorted}")
- heap = Heap()
+ heap: Heap[int] = Heap()
heap.build_max_heap(unsorted)
print(f"after build heap: {heap}")
diff --git a/data_structures/linked_list/circular_linked_list.py b/data_structures/linked_list/circular_linked_list.py
index 9092fb29e..325d91026 100644
--- a/data_structures/linked_list/circular_linked_list.py
+++ b/data_structures/linked_list/circular_linked_list.py
@@ -94,25 +94,25 @@ def test_circular_linked_list() -> None:
try:
circular_linked_list.delete_front()
- raise AssertionError() # This should not happen
+ raise AssertionError # This should not happen
except IndexError:
assert True # This should happen
try:
circular_linked_list.delete_tail()
- raise AssertionError() # This should not happen
+ raise AssertionError # This should not happen
except IndexError:
assert True # This should happen
try:
circular_linked_list.delete_nth(-1)
- raise AssertionError()
+ raise AssertionError
except IndexError:
assert True
try:
circular_linked_list.delete_nth(0)
- raise AssertionError()
+ raise AssertionError
except IndexError:
assert True
diff --git a/data_structures/linked_list/doubly_linked_list.py b/data_structures/linked_list/doubly_linked_list.py
index 69763d12d..1a6c48191 100644
--- a/data_structures/linked_list/doubly_linked_list.py
+++ b/data_structures/linked_list/doubly_linked_list.py
@@ -198,13 +198,13 @@ def test_doubly_linked_list() -> None:
try:
linked_list.delete_head()
- raise AssertionError() # This should not happen.
+ raise AssertionError # This should not happen.
except IndexError:
assert True # This should happen.
try:
linked_list.delete_tail()
- raise AssertionError() # This should not happen.
+ raise AssertionError # This should not happen.
except IndexError:
assert True # This should happen.
diff --git a/data_structures/linked_list/singly_linked_list.py b/data_structures/linked_list/singly_linked_list.py
index a8f9e8ebb..890e21c9b 100644
--- a/data_structures/linked_list/singly_linked_list.py
+++ b/data_structures/linked_list/singly_linked_list.py
@@ -353,13 +353,13 @@ def test_singly_linked_list() -> None:
try:
linked_list.delete_head()
- raise AssertionError() # This should not happen.
+ raise AssertionError # This should not happen.
except IndexError:
assert True # This should happen.
try:
linked_list.delete_tail()
- raise AssertionError() # This should not happen.
+ raise AssertionError # This should not happen.
except IndexError:
assert True # This should happen.
diff --git a/data_structures/queue/double_ended_queue.py b/data_structures/queue/double_ended_queue.py
index 637b7f62f..44dc863b9 100644
--- a/data_structures/queue/double_ended_queue.py
+++ b/data_structures/queue/double_ended_queue.py
@@ -32,7 +32,7 @@ class Deque:
the number of nodes
"""
- __slots__ = ["_front", "_back", "_len"]
+ __slots__ = ("_front", "_back", "_len")
@dataclass
class _Node:
@@ -54,7 +54,7 @@ class Deque:
the current node of the iteration.
"""
- __slots__ = ["_cur"]
+ __slots__ = ("_cur",)
def __init__(self, cur: Deque._Node | None) -> None:
self._cur = cur
diff --git a/data_structures/queue/queue_by_list.py b/data_structures/queue/queue_by_list.py
new file mode 100644
index 000000000..4b05be9fd
--- /dev/null
+++ b/data_structures/queue/queue_by_list.py
@@ -0,0 +1,141 @@
+"""Queue represented by a Python list"""
+
+from collections.abc import Iterable
+from typing import Generic, TypeVar
+
+_T = TypeVar("_T")
+
+
+class QueueByList(Generic[_T]):
+ def __init__(self, iterable: Iterable[_T] | None = None) -> None:
+ """
+ >>> QueueByList()
+ Queue(())
+ >>> QueueByList([10, 20, 30])
+ Queue((10, 20, 30))
+ >>> QueueByList((i**2 for i in range(1, 4)))
+ Queue((1, 4, 9))
+ """
+ self.entries: list[_T] = list(iterable or [])
+
+ def __len__(self) -> int:
+ """
+ >>> len(QueueByList())
+ 0
+ >>> from string import ascii_lowercase
+ >>> len(QueueByList(ascii_lowercase))
+ 26
+ >>> queue = QueueByList()
+ >>> for i in range(1, 11):
+ ... queue.put(i)
+ >>> len(queue)
+ 10
+ >>> for i in range(2):
+ ... queue.get()
+ 1
+ 2
+ >>> len(queue)
+ 8
+ """
+
+ return len(self.entries)
+
+ def __repr__(self) -> str:
+ """
+ >>> queue = QueueByList()
+ >>> queue
+ Queue(())
+ >>> str(queue)
+ 'Queue(())'
+ >>> queue.put(10)
+ >>> queue
+ Queue((10,))
+ >>> queue.put(20)
+ >>> queue.put(30)
+ >>> queue
+ Queue((10, 20, 30))
+ """
+
+ return f"Queue({tuple(self.entries)})"
+
+ def put(self, item: _T) -> None:
+ """Put `item` to the Queue
+
+ >>> queue = QueueByList()
+ >>> queue.put(10)
+ >>> queue.put(20)
+ >>> len(queue)
+ 2
+ >>> queue
+ Queue((10, 20))
+ """
+
+ self.entries.append(item)
+
+ def get(self) -> _T:
+ """
+ Get `item` from the Queue
+
+ >>> queue = QueueByList((10, 20, 30))
+ >>> queue.get()
+ 10
+ >>> queue.put(40)
+ >>> queue.get()
+ 20
+ >>> queue.get()
+ 30
+ >>> len(queue)
+ 1
+ >>> queue.get()
+ 40
+ >>> queue.get()
+ Traceback (most recent call last):
+ ...
+ IndexError: Queue is empty
+ """
+
+ if not self.entries:
+ raise IndexError("Queue is empty")
+ return self.entries.pop(0)
+
+ def rotate(self, rotation: int) -> None:
+ """Rotate the items of the Queue `rotation` times
+
+ >>> queue = QueueByList([10, 20, 30, 40])
+ >>> queue
+ Queue((10, 20, 30, 40))
+ >>> queue.rotate(1)
+ >>> queue
+ Queue((20, 30, 40, 10))
+ >>> queue.rotate(2)
+ >>> queue
+ Queue((40, 10, 20, 30))
+ """
+
+ put = self.entries.append
+ get = self.entries.pop
+
+ for _ in range(rotation):
+ put(get(0))
+
+ def get_front(self) -> _T:
+ """Get the front item from the Queue
+
+ >>> queue = QueueByList((10, 20, 30))
+ >>> queue.get_front()
+ 10
+ >>> queue
+ Queue((10, 20, 30))
+ >>> queue.get()
+ 10
+ >>> queue.get_front()
+ 20
+ """
+
+ return self.entries[0]
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
diff --git a/data_structures/queue/queue_on_list.py b/data_structures/queue/queue_on_list.py
deleted file mode 100644
index 71fca6b2f..000000000
--- a/data_structures/queue/queue_on_list.py
+++ /dev/null
@@ -1,52 +0,0 @@
-"""Queue represented by a Python list"""
-
-
-class Queue:
- def __init__(self):
- self.entries = []
- self.length = 0
- self.front = 0
-
- def __str__(self):
- printed = "<" + str(self.entries)[1:-1] + ">"
- return printed
-
- """Enqueues {@code item}
- @param item
- item to enqueue"""
-
- def put(self, item):
- self.entries.append(item)
- self.length = self.length + 1
-
- """Dequeues {@code item}
- @requirement: |self.length| > 0
- @return dequeued
- item that was dequeued"""
-
- def get(self):
- self.length = self.length - 1
- dequeued = self.entries[self.front]
- # self.front-=1
- # self.entries = self.entries[self.front:]
- self.entries = self.entries[1:]
- return dequeued
-
- """Rotates the queue {@code rotation} times
- @param rotation
- number of times to rotate queue"""
-
- def rotate(self, rotation):
- for _ in range(rotation):
- self.put(self.get())
-
- """Enqueues {@code item}
- @return item at front of self.entries"""
-
- def get_front(self):
- return self.entries[0]
-
- """Returns the length of this.entries"""
-
- def size(self):
- return self.length
diff --git a/data_structures/stacks/stack.py b/data_structures/stacks/stack.py
index 55d424d50..a14f4648a 100644
--- a/data_structures/stacks/stack.py
+++ b/data_structures/stacks/stack.py
@@ -92,13 +92,13 @@ def test_stack() -> None:
try:
_ = stack.pop()
- raise AssertionError() # This should not happen
+ raise AssertionError # This should not happen
except StackUnderflowError:
assert True # This should happen
try:
_ = stack.peek()
- raise AssertionError() # This should not happen
+ raise AssertionError # This should not happen
except StackUnderflowError:
assert True # This should happen
@@ -118,7 +118,7 @@ def test_stack() -> None:
try:
stack.push(200)
- raise AssertionError() # This should not happen
+ raise AssertionError # This should not happen
except StackOverflowError:
assert True # This should happen
diff --git a/data_structures/trie/radix_tree.py b/data_structures/trie/radix_tree.py
index 66890346e..fadc50cb4 100644
--- a/data_structures/trie/radix_tree.py
+++ b/data_structures/trie/radix_tree.py
@@ -54,10 +54,17 @@ class RadixNode:
word (str): word to insert
>>> RadixNode("myprefix").insert("mystring")
+
+ >>> root = RadixNode()
+ >>> root.insert_many(['myprefix', 'myprefixA', 'myprefixAA'])
+ >>> root.print_tree()
+ - myprefix (leaf)
+ -- A (leaf)
+ --- A (leaf)
"""
# Case 1: If the word is the prefix of the node
# Solution: We set the current node as leaf
- if self.prefix == word:
+ if self.prefix == word and not self.is_leaf:
self.is_leaf = True
# Case 2: The node has no edges that have a prefix to the word
@@ -156,7 +163,7 @@ class RadixNode:
del self.nodes[word[0]]
# We merge the current node with its only child
if len(self.nodes) == 1 and not self.is_leaf:
- merging_node = list(self.nodes.values())[0]
+ merging_node = next(iter(self.nodes.values()))
self.is_leaf = merging_node.is_leaf
self.prefix += merging_node.prefix
self.nodes = merging_node.nodes
@@ -165,7 +172,7 @@ class RadixNode:
incoming_node.is_leaf = False
# If there is 1 edge, we merge it with its child
else:
- merging_node = list(incoming_node.nodes.values())[0]
+ merging_node = next(iter(incoming_node.nodes.values()))
incoming_node.is_leaf = merging_node.is_leaf
incoming_node.prefix += merging_node.prefix
incoming_node.nodes = merging_node.nodes
diff --git a/digital_image_processing/dithering/burkes.py b/digital_image_processing/dithering/burkes.py
index 2bf0bbe03..35aedc16d 100644
--- a/digital_image_processing/dithering/burkes.py
+++ b/digital_image_processing/dithering/burkes.py
@@ -21,7 +21,8 @@ class Burkes:
self.max_threshold = int(self.get_greyscale(255, 255, 255))
if not self.min_threshold < threshold < self.max_threshold:
- raise ValueError(f"Factor value should be from 0 to {self.max_threshold}")
+ msg = f"Factor value should be from 0 to {self.max_threshold}"
+ raise ValueError(msg)
self.input_img = input_img
self.threshold = threshold
@@ -38,9 +39,18 @@ class Burkes:
def get_greyscale(cls, blue: int, green: int, red: int) -> float:
"""
>>> Burkes.get_greyscale(3, 4, 5)
- 3.753
+ 4.185
+ >>> Burkes.get_greyscale(0, 0, 0)
+ 0.0
+ >>> Burkes.get_greyscale(255, 255, 255)
+ 255.0
"""
- return 0.114 * blue + 0.587 * green + 0.2126 * red
+ """
+ Formula from https://en.wikipedia.org/wiki/HSL_and_HSV
+ cf Lightness section, and Fig 13c.
+ We use the first of four possible.
+ """
+ return 0.114 * blue + 0.587 * green + 0.299 * red
def process(self) -> None:
for y in range(self.height):
@@ -48,10 +58,10 @@ class Burkes:
greyscale = int(self.get_greyscale(*self.input_img[y][x]))
if self.threshold > greyscale + self.error_table[y][x]:
self.output_img[y][x] = (0, 0, 0)
- current_error = greyscale + self.error_table[x][y]
+ current_error = greyscale + self.error_table[y][x]
else:
self.output_img[y][x] = (255, 255, 255)
- current_error = greyscale + self.error_table[x][y] - 255
+ current_error = greyscale + self.error_table[y][x] - 255
"""
Burkes error propagation (`*` is current pixel):
diff --git a/digital_image_processing/test_digital_image_processing.py b/digital_image_processing/test_digital_image_processing.py
index c999464ce..fee7ab247 100644
--- a/digital_image_processing/test_digital_image_processing.py
+++ b/digital_image_processing/test_digital_image_processing.py
@@ -96,7 +96,7 @@ def test_nearest_neighbour(
def test_local_binary_pattern():
- file_path: str = "digital_image_processing/image_data/lena.jpg"
+ file_path = "digital_image_processing/image_data/lena.jpg"
# Reading the image and converting it to grayscale.
image = imread(file_path, 0)
diff --git a/divide_and_conquer/convex_hull.py b/divide_and_conquer/convex_hull.py
index 39e78be04..1d1bf301d 100644
--- a/divide_and_conquer/convex_hull.py
+++ b/divide_and_conquer/convex_hull.py
@@ -174,12 +174,12 @@ def _validate_input(points: list[Point] | list[list[float]]) -> list[Point]:
"""
if not hasattr(points, "__iter__"):
- raise ValueError(
- f"Expecting an iterable object but got an non-iterable type {points}"
- )
+ msg = f"Expecting an iterable object but got an non-iterable type {points}"
+ raise ValueError(msg)
if not points:
- raise ValueError(f"Expecting a list of points but got {points}")
+ msg = f"Expecting a list of points but got {points}"
+ raise ValueError(msg)
return _construct_points(points)
@@ -266,7 +266,7 @@ def convex_hull_bf(points: list[Point]) -> list[Point]:
points_left_of_ij = points_right_of_ij = False
ij_part_of_convex_hull = True
for k in range(n):
- if k != i and k != j:
+ if k not in {i, j}:
det_k = _det(points[i], points[j], points[k])
if det_k > 0:
diff --git a/divide_and_conquer/max_subarray.py b/divide_and_conquer/max_subarray.py
new file mode 100644
index 000000000..851ef621a
--- /dev/null
+++ b/divide_and_conquer/max_subarray.py
@@ -0,0 +1,112 @@
+"""
+The maximum subarray problem is the task of finding the continuous subarray that has the
+maximum sum within a given array of numbers. For example, given the array
+[-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum is
+[4, -1, 2, 1], which has a sum of 6.
+
+This divide-and-conquer algorithm finds the maximum subarray in O(n log n) time.
+"""
+from __future__ import annotations
+
+import time
+from collections.abc import Sequence
+from random import randint
+
+from matplotlib import pyplot as plt
+
+
+def max_subarray(
+ arr: Sequence[float], low: int, high: int
+) -> tuple[int | None, int | None, float]:
+ """
+ Solves the maximum subarray problem using divide and conquer.
+ :param arr: the given array of numbers
+ :param low: the start index
+ :param high: the end index
+ :return: the start index of the maximum subarray, the end index of the
+ maximum subarray, and the maximum subarray sum
+
+ >>> nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (3, 6, 6)
+ >>> nums = [2, 8, 9]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 2, 19)
+ >>> nums = [0, 0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (0, 0, 0)
+ >>> nums = [-1.0, 0.0, 1.0]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, 1.0)
+ >>> nums = [-2, -3, -1, -4, -6]
+ >>> max_subarray(nums, 0, len(nums) - 1)
+ (2, 2, -1)
+ >>> max_subarray([], 0, 0)
+ (None, None, 0)
+ """
+ if not arr:
+ return None, None, 0
+ if low == high:
+ return low, high, arr[low]
+
+ mid = (low + high) // 2
+ left_low, left_high, left_sum = max_subarray(arr, low, mid)
+ right_low, right_high, right_sum = max_subarray(arr, mid + 1, high)
+ cross_left, cross_right, cross_sum = max_cross_sum(arr, low, mid, high)
+ if left_sum >= right_sum and left_sum >= cross_sum:
+ return left_low, left_high, left_sum
+ elif right_sum >= left_sum and right_sum >= cross_sum:
+ return right_low, right_high, right_sum
+ return cross_left, cross_right, cross_sum
+
+
+def max_cross_sum(
+ arr: Sequence[float], low: int, mid: int, high: int
+) -> tuple[int, int, float]:
+ left_sum, max_left = float("-inf"), -1
+ right_sum, max_right = float("-inf"), -1
+
+ summ: int | float = 0
+ for i in range(mid, low - 1, -1):
+ summ += arr[i]
+ if summ > left_sum:
+ left_sum = summ
+ max_left = i
+
+ summ = 0
+ for i in range(mid + 1, high + 1):
+ summ += arr[i]
+ if summ > right_sum:
+ right_sum = summ
+ max_right = i
+
+ return max_left, max_right, (left_sum + right_sum)
+
+
+def time_max_subarray(input_size: int) -> float:
+ arr = [randint(1, input_size) for _ in range(input_size)]
+ start = time.time()
+ max_subarray(arr, 0, input_size - 1)
+ end = time.time()
+ return end - start
+
+
+def plot_runtimes() -> None:
+ input_sizes = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
+ runtimes = [time_max_subarray(input_size) for input_size in input_sizes]
+ print("No of Inputs\t\tTime Taken")
+ for input_size, runtime in zip(input_sizes, runtimes):
+ print(input_size, "\t\t", runtime)
+ plt.plot(input_sizes, runtimes)
+ plt.xlabel("Number of Inputs")
+ plt.ylabel("Time taken in seconds")
+ plt.show()
+
+
+if __name__ == "__main__":
+ """
+ A random simulation of this algorithm.
+ """
+ from doctest import testmod
+
+ testmod()
diff --git a/divide_and_conquer/max_subarray_sum.py b/divide_and_conquer/max_subarray_sum.py
deleted file mode 100644
index f23e81719..000000000
--- a/divide_and_conquer/max_subarray_sum.py
+++ /dev/null
@@ -1,78 +0,0 @@
-"""
-Given a array of length n, max_subarray_sum() finds
-the maximum of sum of contiguous sub-array using divide and conquer method.
-
-Time complexity : O(n log n)
-
-Ref : INTRODUCTION TO ALGORITHMS THIRD EDITION
-(section : 4, sub-section : 4.1, page : 70)
-
-"""
-
-
-def max_sum_from_start(array):
- """This function finds the maximum contiguous sum of array from 0 index
-
- Parameters :
- array (list[int]) : given array
-
- Returns :
- max_sum (int) : maximum contiguous sum of array from 0 index
-
- """
- array_sum = 0
- max_sum = float("-inf")
- for num in array:
- array_sum += num
- if array_sum > max_sum:
- max_sum = array_sum
- return max_sum
-
-
-def max_cross_array_sum(array, left, mid, right):
- """This function finds the maximum contiguous sum of left and right arrays
-
- Parameters :
- array, left, mid, right (list[int], int, int, int)
-
- Returns :
- (int) : maximum of sum of contiguous sum of left and right arrays
-
- """
-
- max_sum_of_left = max_sum_from_start(array[left : mid + 1][::-1])
- max_sum_of_right = max_sum_from_start(array[mid + 1 : right + 1])
- return max_sum_of_left + max_sum_of_right
-
-
-def max_subarray_sum(array, left, right):
- """Maximum contiguous sub-array sum, using divide and conquer method
-
- Parameters :
- array, left, right (list[int], int, int) :
- given array, current left index and current right index
-
- Returns :
- int : maximum of sum of contiguous sub-array
-
- """
-
- # base case: array has only one element
- if left == right:
- return array[right]
-
- # Recursion
- mid = (left + right) // 2
- left_half_sum = max_subarray_sum(array, left, mid)
- right_half_sum = max_subarray_sum(array, mid + 1, right)
- cross_sum = max_cross_array_sum(array, left, mid, right)
- return max(left_half_sum, right_half_sum, cross_sum)
-
-
-if __name__ == "__main__":
- array = [-2, -5, 6, -2, -3, 1, 5, -6]
- array_length = len(array)
- print(
- "Maximum sum of contiguous subarray:",
- max_subarray_sum(array, 0, array_length - 1),
- )
diff --git a/divide_and_conquer/strassen_matrix_multiplication.py b/divide_and_conquer/strassen_matrix_multiplication.py
index 371605d6d..cbfc7e565 100644
--- a/divide_and_conquer/strassen_matrix_multiplication.py
+++ b/divide_and_conquer/strassen_matrix_multiplication.py
@@ -112,17 +112,19 @@ def strassen(matrix1: list, matrix2: list) -> list:
[[139, 163], [121, 134], [100, 121]]
"""
if matrix_dimensions(matrix1)[1] != matrix_dimensions(matrix2)[0]:
- raise Exception(
- "Unable to multiply these matrices, please check the dimensions. \n"
- f"Matrix A:{matrix1} \nMatrix B:{matrix2}"
+ msg = (
+ "Unable to multiply these matrices, please check the dimensions.\n"
+ f"Matrix A: {matrix1}\n"
+ f"Matrix B: {matrix2}"
)
+ raise Exception(msg)
dimension1 = matrix_dimensions(matrix1)
dimension2 = matrix_dimensions(matrix2)
if dimension1[0] == dimension1[1] and dimension2[0] == dimension2[1]:
return [matrix1, matrix2]
- maximum = max(max(dimension1), max(dimension2))
+ maximum = max(*dimension1, *dimension2)
maxim = int(math.pow(2, math.ceil(math.log2(maximum))))
new_matrix1 = matrix1
new_matrix2 = matrix2
diff --git a/dynamic_programming/fibonacci.py b/dynamic_programming/fibonacci.py
index 7ec5993ef..c102493aa 100644
--- a/dynamic_programming/fibonacci.py
+++ b/dynamic_programming/fibonacci.py
@@ -24,7 +24,7 @@ class Fibonacci:
return self.sequence[:index]
-def main():
+def main() -> None:
print(
"Fibonacci Series Using Dynamic Programming\n",
"Enter the index of the Fibonacci number you want to calculate ",
diff --git a/dynamic_programming/knapsack.py b/dynamic_programming/knapsack.py
index b12d30313..489b5ada4 100644
--- a/dynamic_programming/knapsack.py
+++ b/dynamic_programming/knapsack.py
@@ -78,17 +78,18 @@ def knapsack_with_example_solution(w: int, wt: list, val: list):
num_items = len(wt)
if num_items != len(val):
- raise ValueError(
- "The number of weights must be the "
- "same as the number of values.\nBut "
- f"got {num_items} weights and {len(val)} values"
+ msg = (
+ "The number of weights must be the same as the number of values.\n"
+ f"But got {num_items} weights and {len(val)} values"
)
+ raise ValueError(msg)
for i in range(num_items):
if not isinstance(wt[i], int):
- raise TypeError(
- "All weights must be integers but "
- f"got weight of type {type(wt[i])} at index {i}"
+ msg = (
+ "All weights must be integers but got weight of "
+ f"type {type(wt[i])} at index {i}"
)
+ raise TypeError(msg)
optimal_val, dp_table = knapsack(w, wt, val, num_items)
example_optional_set: set = set()
diff --git a/dynamic_programming/max_sub_array.py b/dynamic_programming/max_sub_array.py
deleted file mode 100644
index 07717fba4..000000000
--- a/dynamic_programming/max_sub_array.py
+++ /dev/null
@@ -1,93 +0,0 @@
-"""
-author : Mayank Kumar Jha (mk9440)
-"""
-from __future__ import annotations
-
-
-def find_max_sub_array(a, low, high):
- if low == high:
- return low, high, a[low]
- else:
- mid = (low + high) // 2
- left_low, left_high, left_sum = find_max_sub_array(a, low, mid)
- right_low, right_high, right_sum = find_max_sub_array(a, mid + 1, high)
- cross_left, cross_right, cross_sum = find_max_cross_sum(a, low, mid, high)
- if left_sum >= right_sum and left_sum >= cross_sum:
- return left_low, left_high, left_sum
- elif right_sum >= left_sum and right_sum >= cross_sum:
- return right_low, right_high, right_sum
- else:
- return cross_left, cross_right, cross_sum
-
-
-def find_max_cross_sum(a, low, mid, high):
- left_sum, max_left = -999999999, -1
- right_sum, max_right = -999999999, -1
- summ = 0
- for i in range(mid, low - 1, -1):
- summ += a[i]
- if summ > left_sum:
- left_sum = summ
- max_left = i
- summ = 0
- for i in range(mid + 1, high + 1):
- summ += a[i]
- if summ > right_sum:
- right_sum = summ
- max_right = i
- return max_left, max_right, (left_sum + right_sum)
-
-
-def max_sub_array(nums: list[int]) -> int:
- """
- Finds the contiguous subarray which has the largest sum and return its sum.
-
- >>> max_sub_array([-2, 1, -3, 4, -1, 2, 1, -5, 4])
- 6
-
- An empty (sub)array has sum 0.
- >>> max_sub_array([])
- 0
-
- If all elements are negative, the largest subarray would be the empty array,
- having the sum 0.
- >>> max_sub_array([-1, -2, -3])
- 0
- >>> max_sub_array([5, -2, -3])
- 5
- >>> max_sub_array([31, -41, 59, 26, -53, 58, 97, -93, -23, 84])
- 187
- """
- best = 0
- current = 0
- for i in nums:
- current += i
- current = max(current, 0)
- best = max(best, current)
- return best
-
-
-if __name__ == "__main__":
- """
- A random simulation of this algorithm.
- """
- import time
- from random import randint
-
- from matplotlib import pyplot as plt
-
- inputs = [10, 100, 1000, 10000, 50000, 100000, 200000, 300000, 400000, 500000]
- tim = []
- for i in inputs:
- li = [randint(1, i) for j in range(i)]
- strt = time.time()
- (find_max_sub_array(li, 0, len(li) - 1))
- end = time.time()
- tim.append(end - strt)
- print("No of Inputs Time Taken")
- for i in range(len(inputs)):
- print(inputs[i], "\t\t", tim[i])
- plt.plot(inputs, tim)
- plt.xlabel("Number of Inputs")
- plt.ylabel("Time taken in seconds ")
- plt.show()
diff --git a/dynamic_programming/max_subarray_sum.py b/dynamic_programming/max_subarray_sum.py
new file mode 100644
index 000000000..c76943472
--- /dev/null
+++ b/dynamic_programming/max_subarray_sum.py
@@ -0,0 +1,60 @@
+"""
+The maximum subarray sum problem is the task of finding the maximum sum that can be
+obtained from a contiguous subarray within a given array of numbers. For example, given
+the array [-2, 1, -3, 4, -1, 2, 1, -5, 4], the contiguous subarray with the maximum sum
+is [4, -1, 2, 1], so the maximum subarray sum is 6.
+
+Kadane's algorithm is a simple dynamic programming algorithm that solves the maximum
+subarray sum problem in O(n) time and O(1) space.
+
+Reference: https://en.wikipedia.org/wiki/Maximum_subarray_problem
+"""
+from collections.abc import Sequence
+
+
+def max_subarray_sum(
+ arr: Sequence[float], allow_empty_subarrays: bool = False
+) -> float:
+ """
+ Solves the maximum subarray sum problem using Kadane's algorithm.
+ :param arr: the given array of numbers
+ :param allow_empty_subarrays: if True, then the algorithm considers empty subarrays
+
+ >>> max_subarray_sum([2, 8, 9])
+ 19
+ >>> max_subarray_sum([0, 0])
+ 0
+ >>> max_subarray_sum([-1.0, 0.0, 1.0])
+ 1.0
+ >>> max_subarray_sum([1, 2, 3, 4, -2])
+ 10
+ >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+ 6
+ >>> max_subarray_sum([2, 3, -9, 8, -2])
+ 8
+ >>> max_subarray_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subarray_sum([-2, -3, -1, -4, -6], allow_empty_subarrays=True)
+ 0
+ >>> max_subarray_sum([])
+ 0
+ """
+ if not arr:
+ return 0
+
+ max_sum = 0 if allow_empty_subarrays else float("-inf")
+ curr_sum = 0.0
+ for num in arr:
+ curr_sum = max(0 if allow_empty_subarrays else num, curr_sum + num)
+ max_sum = max(max_sum, curr_sum)
+
+ return max_sum
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+ nums = [-2, 1, -3, 4, -1, 2, 1, -5, 4]
+ print(f"{max_subarray_sum(nums) = }")
diff --git a/dynamic_programming/max_sum_contiguous_subsequence.py b/dynamic_programming/max_sum_contiguous_subsequence.py
deleted file mode 100644
index bac592370..000000000
--- a/dynamic_programming/max_sum_contiguous_subsequence.py
+++ /dev/null
@@ -1,20 +0,0 @@
-def max_subarray_sum(nums: list) -> int:
- """
- >>> max_subarray_sum([6 , 9, -1, 3, -7, -5, 10])
- 17
- """
- if not nums:
- return 0
- n = len(nums)
-
- res, s, s_pre = nums[0], nums[0], nums[0]
- for i in range(1, n):
- s = max(nums[i], s_pre + nums[i])
- s_pre = s
- res = max(res, s)
- return res
-
-
-if __name__ == "__main__":
- nums = [6, 9, -1, 3, -7, -5, 10]
- print(max_subarray_sum(nums))
diff --git a/dynamic_programming/minimum_steps_to_one.py b/dynamic_programming/minimum_steps_to_one.py
index f4eb7033d..8785027fb 100644
--- a/dynamic_programming/minimum_steps_to_one.py
+++ b/dynamic_programming/minimum_steps_to_one.py
@@ -42,7 +42,8 @@ def min_steps_to_one(number: int) -> int:
"""
if number <= 0:
- raise ValueError(f"n must be greater than 0. Got n = {number}")
+ msg = f"n must be greater than 0. Got n = {number}"
+ raise ValueError(msg)
table = [number + 1] * (number + 1)
diff --git a/dynamic_programming/rod_cutting.py b/dynamic_programming/rod_cutting.py
index 79104d8f4..f80fa440a 100644
--- a/dynamic_programming/rod_cutting.py
+++ b/dynamic_programming/rod_cutting.py
@@ -177,13 +177,15 @@ def _enforce_args(n: int, prices: list):
the rod
"""
if n < 0:
- raise ValueError(f"n must be greater than or equal to 0. Got n = {n}")
+ msg = f"n must be greater than or equal to 0. Got n = {n}"
+ raise ValueError(msg)
if n > len(prices):
- raise ValueError(
- "Each integral piece of rod must have a corresponding "
- f"price. Got n = {n} but length of prices = {len(prices)}"
+ msg = (
+ "Each integral piece of rod must have a corresponding price. "
+ f"Got n = {n} but length of prices = {len(prices)}"
)
+ raise ValueError(msg)
def main():
diff --git a/dynamic_programming/viterbi.py b/dynamic_programming/viterbi.py
index 93ab845e2..764d45dc2 100644
--- a/dynamic_programming/viterbi.py
+++ b/dynamic_programming/viterbi.py
@@ -297,11 +297,13 @@ def _validate_list(_object: Any, var_name: str) -> None:
"""
if not isinstance(_object, list):
- raise ValueError(f"{var_name} must be a list")
+ msg = f"{var_name} must be a list"
+ raise ValueError(msg)
else:
for x in _object:
if not isinstance(x, str):
- raise ValueError(f"{var_name} must be a list of strings")
+ msg = f"{var_name} must be a list of strings"
+ raise ValueError(msg)
def _validate_dicts(
@@ -384,14 +386,15 @@ def _validate_dict(
ValueError: mock_name nested dictionary all values must be float
"""
if not isinstance(_object, dict):
- raise ValueError(f"{var_name} must be a dict")
+ msg = f"{var_name} must be a dict"
+ raise ValueError(msg)
if not all(isinstance(x, str) for x in _object):
- raise ValueError(f"{var_name} all keys must be strings")
+ msg = f"{var_name} all keys must be strings"
+ raise ValueError(msg)
if not all(isinstance(x, value_type) for x in _object.values()):
nested_text = "nested dictionary " if nested else ""
- raise ValueError(
- f"{var_name} {nested_text}all values must be {value_type.__name__}"
- )
+ msg = f"{var_name} {nested_text}all values must be {value_type.__name__}"
+ raise ValueError(msg)
if __name__ == "__main__":
diff --git a/electronics/resistor_equivalence.py b/electronics/resistor_equivalence.py
index 7142f838a..55e7f2d6b 100644
--- a/electronics/resistor_equivalence.py
+++ b/electronics/resistor_equivalence.py
@@ -23,7 +23,8 @@ def resistor_parallel(resistors: list[float]) -> float:
index = 0
for resistor in resistors:
if resistor <= 0:
- raise ValueError(f"Resistor at index {index} has a negative or zero value!")
+ msg = f"Resistor at index {index} has a negative or zero value!"
+ raise ValueError(msg)
first_sum += 1 / float(resistor)
index += 1
return 1 / first_sum
@@ -47,7 +48,8 @@ def resistor_series(resistors: list[float]) -> float:
for resistor in resistors:
sum_r += resistor
if resistor < 0:
- raise ValueError(f"Resistor at index {index} has a negative value!")
+ msg = f"Resistor at index {index} has a negative value!"
+ raise ValueError(msg)
index += 1
return sum_r
diff --git a/financial/interest.py b/financial/interest.py
index c69c73045..33d02e27c 100644
--- a/financial/interest.py
+++ b/financial/interest.py
@@ -4,7 +4,7 @@ from __future__ import annotations
def simple_interest(
- principal: float, daily_interest_rate: float, days_between_payments: int
+ principal: float, daily_interest_rate: float, days_between_payments: float
) -> float:
"""
>>> simple_interest(18000.0, 0.06, 3)
@@ -42,7 +42,7 @@ def simple_interest(
def compound_interest(
principal: float,
nominal_annual_interest_rate_percentage: float,
- number_of_compounding_periods: int,
+ number_of_compounding_periods: float,
) -> float:
"""
>>> compound_interest(10000.0, 0.05, 3)
@@ -77,6 +77,43 @@ def compound_interest(
)
+def apr_interest(
+ principal: float,
+ nominal_annual_percentage_rate: float,
+ number_of_years: float,
+) -> float:
+ """
+ >>> apr_interest(10000.0, 0.05, 3)
+ 1618.223072263547
+ >>> apr_interest(10000.0, 0.05, 1)
+ 512.6749646744732
+ >>> apr_interest(0.5, 0.05, 3)
+ 0.08091115361317736
+ >>> apr_interest(10000.0, 0.06, -4)
+ Traceback (most recent call last):
+ ...
+ ValueError: number_of_years must be > 0
+ >>> apr_interest(10000.0, -3.5, 3.0)
+ Traceback (most recent call last):
+ ...
+ ValueError: nominal_annual_percentage_rate must be >= 0
+ >>> apr_interest(-5500.0, 0.01, 5)
+ Traceback (most recent call last):
+ ...
+ ValueError: principal must be > 0
+ """
+ if number_of_years <= 0:
+ raise ValueError("number_of_years must be > 0")
+ if nominal_annual_percentage_rate < 0:
+ raise ValueError("nominal_annual_percentage_rate must be >= 0")
+ if principal <= 0:
+ raise ValueError("principal must be > 0")
+
+ return compound_interest(
+ principal, nominal_annual_percentage_rate / 365, number_of_years * 365
+ )
+
+
if __name__ == "__main__":
import doctest
diff --git a/financial/present_value.py b/financial/present_value.py
new file mode 100644
index 000000000..f74612b92
--- /dev/null
+++ b/financial/present_value.py
@@ -0,0 +1,42 @@
+"""
+Reference: https://www.investopedia.com/terms/p/presentvalue.asp
+
+An algorithm that calculates the present value of a stream of yearly cash flows given...
+1. The discount rate (as a decimal, not a percent)
+2. An array of cash flows, with the index of the cash flow being the associated year
+
+Note: This algorithm assumes that cash flows are paid at the end of the specified year
+"""
+
+
+def present_value(discount_rate: float, cash_flows: list[float]) -> float:
+ """
+ >>> present_value(0.13, [10, 20.70, -293, 297])
+ 4.69
+ >>> present_value(0.07, [-109129.39, 30923.23, 15098.93, 29734,39])
+ -42739.63
+ >>> present_value(0.07, [109129.39, 30923.23, 15098.93, 29734,39])
+ 175519.15
+ >>> present_value(-1, [109129.39, 30923.23, 15098.93, 29734,39])
+ Traceback (most recent call last):
+ ...
+ ValueError: Discount rate cannot be negative
+ >>> present_value(0.03, [])
+ Traceback (most recent call last):
+ ...
+ ValueError: Cash flows list cannot be empty
+ """
+ if discount_rate < 0:
+ raise ValueError("Discount rate cannot be negative")
+ if not cash_flows:
+ raise ValueError("Cash flows list cannot be empty")
+ present_value = sum(
+ cash_flow / ((1 + discount_rate) ** i) for i, cash_flow in enumerate(cash_flows)
+ )
+ return round(present_value, ndigits=2)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/fractals/sierpinski_triangle.py b/fractals/sierpinski_triangle.py
index c28ec00b2..45f7ab84c 100644
--- a/fractals/sierpinski_triangle.py
+++ b/fractals/sierpinski_triangle.py
@@ -82,3 +82,4 @@ if __name__ == "__main__":
vertices = [(-175, -125), (0, 175), (175, -125)] # vertices of triangle
triangle(vertices[0], vertices[1], vertices[2], int(sys.argv[1]))
+ turtle.Screen().exitonclick()
diff --git a/genetic_algorithm/basic_string.py b/genetic_algorithm/basic_string.py
index 45b8be651..089c5c99a 100644
--- a/genetic_algorithm/basic_string.py
+++ b/genetic_algorithm/basic_string.py
@@ -21,6 +21,54 @@ MUTATION_PROBABILITY = 0.4
random.seed(random.randint(0, 1000))
+def evaluate(item: str, main_target: str) -> tuple[str, float]:
+ """
+ Evaluate how similar the item is with the target by just
+ counting each char in the right position
+ >>> evaluate("Helxo Worlx", "Hello World")
+ ('Helxo Worlx', 9.0)
+ """
+ score = len([g for position, g in enumerate(item) if g == main_target[position]])
+ return (item, float(score))
+
+
+def crossover(parent_1: str, parent_2: str) -> tuple[str, str]:
+ """Slice and combine two string at a random point."""
+ random_slice = random.randint(0, len(parent_1) - 1)
+ child_1 = parent_1[:random_slice] + parent_2[random_slice:]
+ child_2 = parent_2[:random_slice] + parent_1[random_slice:]
+ return (child_1, child_2)
+
+
+def mutate(child: str, genes: list[str]) -> str:
+ """Mutate a random gene of a child with another one from the list."""
+ child_list = list(child)
+ if random.uniform(0, 1) < MUTATION_PROBABILITY:
+ child_list[random.randint(0, len(child)) - 1] = random.choice(genes)
+ return "".join(child_list)
+
+
+# Select, crossover and mutate a new population.
+def select(
+ parent_1: tuple[str, float],
+ population_score: list[tuple[str, float]],
+ genes: list[str],
+) -> list[str]:
+ """Select the second parent and generate new population"""
+ pop = []
+ # Generate more children proportionally to the fitness score.
+ child_n = int(parent_1[1] * 100) + 1
+ child_n = 10 if child_n >= 10 else child_n
+ for _ in range(child_n):
+ parent_2 = population_score[random.randint(0, N_SELECTED)][0]
+
+ child_1, child_2 = crossover(parent_1[0], parent_2)
+ # Append new string to the population list.
+ pop.append(mutate(child_1, genes))
+ pop.append(mutate(child_2, genes))
+ return pop
+
+
def basic(target: str, genes: list[str], debug: bool = True) -> tuple[int, int, str]:
"""
Verify that the target contains no genes besides the ones inside genes variable.
@@ -48,13 +96,13 @@ def basic(target: str, genes: list[str], debug: bool = True) -> tuple[int, int,
# Verify if N_POPULATION is bigger than N_SELECTED
if N_POPULATION < N_SELECTED:
- raise ValueError(f"{N_POPULATION} must be bigger than {N_SELECTED}")
+ msg = f"{N_POPULATION} must be bigger than {N_SELECTED}"
+ raise ValueError(msg)
# Verify that the target contains no genes besides the ones inside genes variable.
not_in_genes_list = sorted({c for c in target if c not in genes})
if not_in_genes_list:
- raise ValueError(
- f"{not_in_genes_list} is not in genes list, evolution cannot converge"
- )
+ msg = f"{not_in_genes_list} is not in genes list, evolution cannot converge"
+ raise ValueError(msg)
# Generate random starting population.
population = []
@@ -70,17 +118,6 @@ def basic(target: str, genes: list[str], debug: bool = True) -> tuple[int, int,
total_population += len(population)
# Random population created. Now it's time to evaluate.
- def evaluate(item: str, main_target: str = target) -> tuple[str, float]:
- """
- Evaluate how similar the item is with the target by just
- counting each char in the right position
- >>> evaluate("Helxo Worlx", Hello World)
- ["Helxo Worlx", 9]
- """
- score = len(
- [g for position, g in enumerate(item) if g == main_target[position]]
- )
- return (item, float(score))
# Adding a bit of concurrency can make everything faster,
#
@@ -94,7 +131,7 @@ def basic(target: str, genes: list[str], debug: bool = True) -> tuple[int, int,
#
# but with a simple algorithm like this, it will probably be slower.
# We just need to call evaluate for every item inside the population.
- population_score = [evaluate(item) for item in population]
+ population_score = [evaluate(item, target) for item in population]
# Check if there is a matching evolution.
population_score = sorted(population_score, key=lambda x: x[1], reverse=True)
@@ -121,41 +158,9 @@ def basic(target: str, genes: list[str], debug: bool = True) -> tuple[int, int,
(item, score / len(target)) for item, score in population_score
]
- # Select, crossover and mutate a new population.
- def select(parent_1: tuple[str, float]) -> list[str]:
- """Select the second parent and generate new population"""
- pop = []
- # Generate more children proportionally to the fitness score.
- child_n = int(parent_1[1] * 100) + 1
- child_n = 10 if child_n >= 10 else child_n
- for _ in range(child_n):
- parent_2 = population_score[ # noqa: B023
- random.randint(0, N_SELECTED)
- ][0]
-
- child_1, child_2 = crossover(parent_1[0], parent_2)
- # Append new string to the population list.
- pop.append(mutate(child_1))
- pop.append(mutate(child_2))
- return pop
-
- def crossover(parent_1: str, parent_2: str) -> tuple[str, str]:
- """Slice and combine two string at a random point."""
- random_slice = random.randint(0, len(parent_1) - 1)
- child_1 = parent_1[:random_slice] + parent_2[random_slice:]
- child_2 = parent_2[:random_slice] + parent_1[random_slice:]
- return (child_1, child_2)
-
- def mutate(child: str) -> str:
- """Mutate a random gene of a child with another one from the list."""
- child_list = list(child)
- if random.uniform(0, 1) < MUTATION_PROBABILITY:
- child_list[random.randint(0, len(child)) - 1] = random.choice(genes)
- return "".join(child_list)
-
# This is selection
for i in range(N_SELECTED):
- population.extend(select(population_score[int(i)]))
+ population.extend(select(population_score[int(i)], population_score, genes))
# Check if the population has already reached the maximum value and if so,
# break the cycle. If this check is disabled, the algorithm will take
# forever to compute large strings, but will also calculate small strings in
diff --git a/graphics/vector3_for_2d_rendering.py b/graphics/vector3_for_2d_rendering.py
index dfa22262a..a332206e6 100644
--- a/graphics/vector3_for_2d_rendering.py
+++ b/graphics/vector3_for_2d_rendering.py
@@ -28,9 +28,8 @@ def convert_to_2d(
TypeError: Input values must either be float or int: ['1', 2, 3, 10, 10]
"""
if not all(isinstance(val, (float, int)) for val in locals().values()):
- raise TypeError(
- "Input values must either be float or int: " f"{list(locals().values())}"
- )
+ msg = f"Input values must either be float or int: {list(locals().values())}"
+ raise TypeError(msg)
projected_x = ((x * distance) / (z + distance)) * scale
projected_y = ((y * distance) / (z + distance)) * scale
return projected_x, projected_y
@@ -71,10 +70,11 @@ def rotate(
input_variables = locals()
del input_variables["axis"]
if not all(isinstance(val, (float, int)) for val in input_variables.values()):
- raise TypeError(
+ msg = (
"Input values except axis must either be float or int: "
f"{list(input_variables.values())}"
)
+ raise TypeError(msg)
angle = (angle % 360) / 450 * 180 / math.pi
if axis == "z":
new_x = x * math.cos(angle) - y * math.sin(angle)
diff --git a/graphs/breadth_first_search_shortest_path.py b/graphs/breadth_first_search_shortest_path.py
index cb21076f9..d489b110b 100644
--- a/graphs/breadth_first_search_shortest_path.py
+++ b/graphs/breadth_first_search_shortest_path.py
@@ -73,9 +73,10 @@ class Graph:
target_vertex_parent = self.parent.get(target_vertex)
if target_vertex_parent is None:
- raise ValueError(
+ msg = (
f"No path from vertex: {self.source_vertex} to vertex: {target_vertex}"
)
+ raise ValueError(msg)
return self.shortest_path(target_vertex_parent) + f"->{target_vertex}"
diff --git a/graphs/dijkstra_binary_grid.py b/graphs/dijkstra_binary_grid.py
new file mode 100644
index 000000000..c23d82343
--- /dev/null
+++ b/graphs/dijkstra_binary_grid.py
@@ -0,0 +1,89 @@
+"""
+This script implements the Dijkstra algorithm on a binary grid.
+The grid consists of 0s and 1s, where 1 represents
+a walkable node and 0 represents an obstacle.
+The algorithm finds the shortest path from a start node to a destination node.
+Diagonal movement can be allowed or disallowed.
+"""
+
+from heapq import heappop, heappush
+
+import numpy as np
+
+
+def dijkstra(
+ grid: np.ndarray,
+ source: tuple[int, int],
+ destination: tuple[int, int],
+ allow_diagonal: bool,
+) -> tuple[float | int, list[tuple[int, int]]]:
+ """
+ Implements Dijkstra's algorithm on a binary grid.
+
+ Args:
+ grid (np.ndarray): A 2D numpy array representing the grid.
+ 1 represents a walkable node and 0 represents an obstacle.
+ source (Tuple[int, int]): A tuple representing the start node.
+ destination (Tuple[int, int]): A tuple representing the
+ destination node.
+ allow_diagonal (bool): A boolean determining whether
+ diagonal movements are allowed.
+
+ Returns:
+ Tuple[Union[float, int], List[Tuple[int, int]]]:
+ The shortest distance from the start node to the destination node
+ and the shortest path as a list of nodes.
+
+ >>> dijkstra(np.array([[1, 1, 1], [0, 1, 0], [0, 1, 1]]), (0, 0), (2, 2), False)
+ (4.0, [(0, 0), (0, 1), (1, 1), (2, 1), (2, 2)])
+
+ >>> dijkstra(np.array([[1, 1, 1], [0, 1, 0], [0, 1, 1]]), (0, 0), (2, 2), True)
+ (2.0, [(0, 0), (1, 1), (2, 2)])
+
+ >>> dijkstra(np.array([[1, 1, 1], [0, 0, 1], [0, 1, 1]]), (0, 0), (2, 2), False)
+ (4.0, [(0, 0), (0, 1), (0, 2), (1, 2), (2, 2)])
+ """
+ rows, cols = grid.shape
+ dx = [-1, 1, 0, 0]
+ dy = [0, 0, -1, 1]
+ if allow_diagonal:
+ dx += [-1, -1, 1, 1]
+ dy += [-1, 1, -1, 1]
+
+ queue, visited = [(0, source)], set()
+ matrix = np.full((rows, cols), np.inf)
+ matrix[source] = 0
+ predecessors = np.empty((rows, cols), dtype=object)
+ predecessors[source] = None
+
+ while queue:
+ (dist, (x, y)) = heappop(queue)
+ if (x, y) in visited:
+ continue
+ visited.add((x, y))
+
+ if (x, y) == destination:
+ path = []
+ while (x, y) != source:
+ path.append((x, y))
+ x, y = predecessors[x, y]
+ path.append(source) # add the source manually
+ path.reverse()
+ return matrix[destination], path
+
+ for i in range(len(dx)):
+ nx, ny = x + dx[i], y + dy[i]
+ if 0 <= nx < rows and 0 <= ny < cols:
+ next_node = grid[nx][ny]
+ if next_node == 1 and matrix[nx, ny] > dist + 1:
+ heappush(queue, (dist + 1, (nx, ny)))
+ matrix[nx, ny] = dist + 1
+ predecessors[nx, ny] = (x, y)
+
+ return np.inf, []
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/graphs/directed_and_undirected_(weighted)_graph.py b/graphs/directed_and_undirected_(weighted)_graph.py
index b29485031..8ca645fda 100644
--- a/graphs/directed_and_undirected_(weighted)_graph.py
+++ b/graphs/directed_and_undirected_(weighted)_graph.py
@@ -39,7 +39,7 @@ class DirectedGraph:
stack = []
visited = []
if s == -2:
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
ss = s
@@ -87,7 +87,7 @@ class DirectedGraph:
d = deque()
visited = []
if s == -2:
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
d.append(s)
visited.append(s)
while d:
@@ -114,7 +114,7 @@ class DirectedGraph:
stack = []
visited = []
if s == -2:
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
ss = s
@@ -146,7 +146,7 @@ class DirectedGraph:
def cycle_nodes(self):
stack = []
visited = []
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
parent = -2
@@ -199,7 +199,7 @@ class DirectedGraph:
def has_cycle(self):
stack = []
visited = []
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
parent = -2
@@ -305,7 +305,7 @@ class Graph:
stack = []
visited = []
if s == -2:
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
ss = s
@@ -353,7 +353,7 @@ class Graph:
d = deque()
visited = []
if s == -2:
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
d.append(s)
visited.append(s)
while d:
@@ -371,7 +371,7 @@ class Graph:
def cycle_nodes(self):
stack = []
visited = []
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
parent = -2
@@ -424,7 +424,7 @@ class Graph:
def has_cycle(self):
stack = []
visited = []
- s = list(self.graph)[0]
+ s = next(iter(self.graph))
stack.append(s)
visited.append(s)
parent = -2
diff --git a/graphs/edmonds_karp_multiple_source_and_sink.py b/graphs/edmonds_karp_multiple_source_and_sink.py
index d06108041..5c774f4b8 100644
--- a/graphs/edmonds_karp_multiple_source_and_sink.py
+++ b/graphs/edmonds_karp_multiple_source_and_sink.py
@@ -113,7 +113,7 @@ class PushRelabelExecutor(MaximumFlowAlgorithmExecutor):
vertices_list = [
i
for i in range(self.verticies_count)
- if i != self.source_index and i != self.sink_index
+ if i not in {self.source_index, self.sink_index}
]
# move through list
diff --git a/graphs/eulerian_path_and_circuit_for_undirected_graph.py b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
index 6c43c5d3e..6b4ea8e21 100644
--- a/graphs/eulerian_path_and_circuit_for_undirected_graph.py
+++ b/graphs/eulerian_path_and_circuit_for_undirected_graph.py
@@ -20,7 +20,7 @@ def check_circuit_or_path(graph, max_node):
odd_degree_nodes = 0
odd_node = -1
for i in range(max_node):
- if i not in graph.keys():
+ if i not in graph:
continue
if len(graph[i]) % 2 == 1:
odd_degree_nodes += 1
diff --git a/graphs/graph_adjacency_list.py b/graphs/graph_adjacency_list.py
new file mode 100644
index 000000000..76f34f845
--- /dev/null
+++ b/graphs/graph_adjacency_list.py
@@ -0,0 +1,589 @@
+#!/usr/bin/env python3
+"""
+Author: Vikram Nithyanandam
+
+Description:
+The following implementation is a robust unweighted Graph data structure
+implemented using an adjacency list. This vertices and edges of this graph can be
+effectively initialized and modified while storing your chosen generic
+value in each vertex.
+
+Adjacency List: https://en.wikipedia.org/wiki/Adjacency_list
+
+Potential Future Ideas:
+- Add a flag to set edge weights on and set edge weights
+- Make edge weights and vertex values customizable to store whatever the client wants
+- Support multigraph functionality if the client wants it
+"""
+from __future__ import annotations
+
+import random
+import unittest
+from pprint import pformat
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class GraphAdjacencyList(Generic[T]):
+ def __init__(
+ self, vertices: list[T], edges: list[list[T]], directed: bool = True
+ ) -> None:
+ """
+ Parameters:
+ - vertices: (list[T]) The list of vertex names the client wants to
+ pass in. Default is empty.
+ - edges: (list[list[T]]) The list of edges the client wants to
+ pass in. Each edge is a 2-element list. Default is empty.
+ - directed: (bool) Indicates if graph is directed or undirected.
+ Default is True.
+ """
+ self.adj_list: dict[T, list[T]] = {} # dictionary of lists of T
+ self.directed = directed
+
+ # Falsey checks
+ edges = edges or []
+ vertices = vertices or []
+
+ for vertex in vertices:
+ self.add_vertex(vertex)
+
+ for edge in edges:
+ if len(edge) != 2:
+ msg = f"Invalid input: {edge} is the wrong length."
+ raise ValueError(msg)
+ self.add_edge(edge[0], edge[1])
+
+ def add_vertex(self, vertex: T) -> None:
+ """
+ Adds a vertex to the graph. If the given vertex already exists,
+ a ValueError will be thrown.
+ """
+ if self.contains_vertex(vertex):
+ msg = f"Incorrect input: {vertex} is already in the graph."
+ raise ValueError(msg)
+ self.adj_list[vertex] = []
+
+ def add_edge(self, source_vertex: T, destination_vertex: T) -> None:
+ """
+ Creates an edge from source vertex to destination vertex. If any
+ given vertex doesn't exist or the edge already exists, a ValueError
+ will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} or "
+ f"{destination_vertex} does not exist"
+ )
+ raise ValueError(msg)
+ if self.contains_edge(source_vertex, destination_vertex):
+ msg = (
+ "Incorrect input: The edge already exists between "
+ f"{source_vertex} and {destination_vertex}"
+ )
+ raise ValueError(msg)
+
+ # add the destination vertex to the list associated with the source vertex
+ # and vice versa if not directed
+ self.adj_list[source_vertex].append(destination_vertex)
+ if not self.directed:
+ self.adj_list[destination_vertex].append(source_vertex)
+
+ def remove_vertex(self, vertex: T) -> None:
+ """
+ Removes the given vertex from the graph and deletes all incoming and
+ outgoing edges from the given vertex as well. If the given vertex
+ does not exist, a ValueError will be thrown.
+ """
+ if not self.contains_vertex(vertex):
+ msg = f"Incorrect input: {vertex} does not exist in this graph."
+ raise ValueError(msg)
+
+ if not self.directed:
+ # If not directed, find all neighboring vertices and delete all references
+ # of edges connecting to the given vertex
+ for neighbor in self.adj_list[vertex]:
+ self.adj_list[neighbor].remove(vertex)
+ else:
+ # If directed, search all neighbors of all vertices and delete all
+ # references of edges connecting to the given vertex
+ for edge_list in self.adj_list.values():
+ if vertex in edge_list:
+ edge_list.remove(vertex)
+
+ # Finally, delete the given vertex and all of its outgoing edge references
+ self.adj_list.pop(vertex)
+
+ def remove_edge(self, source_vertex: T, destination_vertex: T) -> None:
+ """
+ Removes the edge between the two vertices. If any given vertex
+ doesn't exist or the edge does not exist, a ValueError will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} or "
+ f"{destination_vertex} does not exist"
+ )
+ raise ValueError(msg)
+ if not self.contains_edge(source_vertex, destination_vertex):
+ msg = (
+ "Incorrect input: The edge does NOT exist between "
+ f"{source_vertex} and {destination_vertex}"
+ )
+ raise ValueError(msg)
+
+ # remove the destination vertex from the list associated with the source
+ # vertex and vice versa if not directed
+ self.adj_list[source_vertex].remove(destination_vertex)
+ if not self.directed:
+ self.adj_list[destination_vertex].remove(source_vertex)
+
+ def contains_vertex(self, vertex: T) -> bool:
+ """
+ Returns True if the graph contains the vertex, False otherwise.
+ """
+ return vertex in self.adj_list
+
+ def contains_edge(self, source_vertex: T, destination_vertex: T) -> bool:
+ """
+ Returns True if the graph contains the edge from the source_vertex to the
+ destination_vertex, False otherwise. If any given vertex doesn't exist, a
+ ValueError will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} "
+ f"or {destination_vertex} does not exist."
+ )
+ raise ValueError(msg)
+
+ return destination_vertex in self.adj_list[source_vertex]
+
+ def clear_graph(self) -> None:
+ """
+ Clears all vertices and edges.
+ """
+ self.adj_list = {}
+
+ def __repr__(self) -> str:
+ return pformat(self.adj_list)
+
+
+class TestGraphAdjacencyList(unittest.TestCase):
+ def __assert_graph_edge_exists_check(
+ self,
+ undirected_graph: GraphAdjacencyList,
+ directed_graph: GraphAdjacencyList,
+ edge: list[int],
+ ) -> None:
+ self.assertTrue(undirected_graph.contains_edge(edge[0], edge[1]))
+ self.assertTrue(undirected_graph.contains_edge(edge[1], edge[0]))
+ self.assertTrue(directed_graph.contains_edge(edge[0], edge[1]))
+
+ def __assert_graph_edge_does_not_exist_check(
+ self,
+ undirected_graph: GraphAdjacencyList,
+ directed_graph: GraphAdjacencyList,
+ edge: list[int],
+ ) -> None:
+ self.assertFalse(undirected_graph.contains_edge(edge[0], edge[1]))
+ self.assertFalse(undirected_graph.contains_edge(edge[1], edge[0]))
+ self.assertFalse(directed_graph.contains_edge(edge[0], edge[1]))
+
+ def __assert_graph_vertex_exists_check(
+ self,
+ undirected_graph: GraphAdjacencyList,
+ directed_graph: GraphAdjacencyList,
+ vertex: int,
+ ) -> None:
+ self.assertTrue(undirected_graph.contains_vertex(vertex))
+ self.assertTrue(directed_graph.contains_vertex(vertex))
+
+ def __assert_graph_vertex_does_not_exist_check(
+ self,
+ undirected_graph: GraphAdjacencyList,
+ directed_graph: GraphAdjacencyList,
+ vertex: int,
+ ) -> None:
+ self.assertFalse(undirected_graph.contains_vertex(vertex))
+ self.assertFalse(directed_graph.contains_vertex(vertex))
+
+ def __generate_random_edges(
+ self, vertices: list[int], edge_pick_count: int
+ ) -> list[list[int]]:
+ self.assertTrue(edge_pick_count <= len(vertices))
+
+ random_source_vertices: list[int] = random.sample(
+ vertices[0 : int(len(vertices) / 2)], edge_pick_count
+ )
+ random_destination_vertices: list[int] = random.sample(
+ vertices[int(len(vertices) / 2) :], edge_pick_count
+ )
+ random_edges: list[list[int]] = []
+
+ for source in random_source_vertices:
+ for dest in random_destination_vertices:
+ random_edges.append([source, dest])
+
+ return random_edges
+
+ def __generate_graphs(
+ self, vertex_count: int, min_val: int, max_val: int, edge_pick_count: int
+ ) -> tuple[GraphAdjacencyList, GraphAdjacencyList, list[int], list[list[int]]]:
+ if max_val - min_val + 1 < vertex_count:
+ raise ValueError(
+ "Will result in duplicate vertices. Either increase range "
+ "between min_val and max_val or decrease vertex count."
+ )
+
+ # generate graph input
+ random_vertices: list[int] = random.sample(
+ range(min_val, max_val + 1), vertex_count
+ )
+ random_edges: list[list[int]] = self.__generate_random_edges(
+ random_vertices, edge_pick_count
+ )
+
+ # build graphs
+ undirected_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=random_edges, directed=False
+ )
+ directed_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=random_edges, directed=True
+ )
+
+ return undirected_graph, directed_graph, random_vertices, random_edges
+
+ def test_init_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # test graph initialization with vertices and edges
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ for edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+ self.assertFalse(undirected_graph.directed)
+ self.assertTrue(directed_graph.directed)
+
+ def test_contains_vertex(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # Build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # Test contains_vertex
+ for num in range(101):
+ self.assertEqual(
+ num in random_vertices, undirected_graph.contains_vertex(num)
+ )
+ self.assertEqual(
+ num in random_vertices, directed_graph.contains_vertex(num)
+ )
+
+ def test_add_vertices(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # build empty graphs
+ undirected_graph: GraphAdjacencyList = GraphAdjacencyList(
+ vertices=[], edges=[], directed=False
+ )
+ directed_graph: GraphAdjacencyList = GraphAdjacencyList(
+ vertices=[], edges=[], directed=True
+ )
+
+ # run add_vertex
+ for num in random_vertices:
+ undirected_graph.add_vertex(num)
+
+ for num in random_vertices:
+ directed_graph.add_vertex(num)
+
+ # test add_vertex worked
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ def test_remove_vertices(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # test remove_vertex worked
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ undirected_graph.remove_vertex(num)
+ directed_graph.remove_vertex(num)
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, num
+ )
+
+ def test_add_and_remove_vertices_repeatedly(self) -> None:
+ random_vertices1: list[int] = random.sample(range(51), 20)
+ random_vertices2: list[int] = random.sample(range(51, 101), 20)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyList(
+ vertices=random_vertices1, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyList(
+ vertices=random_vertices1, edges=[], directed=True
+ )
+
+ # test adding and removing vertices
+ for i, _ in enumerate(random_vertices1):
+ undirected_graph.add_vertex(random_vertices2[i])
+ directed_graph.add_vertex(random_vertices2[i])
+
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, random_vertices2[i]
+ )
+
+ undirected_graph.remove_vertex(random_vertices1[i])
+ directed_graph.remove_vertex(random_vertices1[i])
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, random_vertices1[i]
+ )
+
+ # remove all vertices
+ for i, _ in enumerate(random_vertices1):
+ undirected_graph.remove_vertex(random_vertices2[i])
+ directed_graph.remove_vertex(random_vertices2[i])
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, random_vertices2[i]
+ )
+
+ def test_contains_edge(self) -> None:
+ # generate graphs and graph input
+ vertex_count = 20
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(vertex_count, 0, 100, 4)
+
+ # generate all possible edges for testing
+ all_possible_edges: list[list[int]] = []
+ for i in range(vertex_count - 1):
+ for j in range(i + 1, vertex_count):
+ all_possible_edges.append([random_vertices[i], random_vertices[j]])
+ all_possible_edges.append([random_vertices[j], random_vertices[i]])
+
+ # test contains_edge function
+ for edge in all_possible_edges:
+ if edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+ elif [edge[1], edge[0]] in random_edges:
+ # since this edge exists for undirected but the reverse
+ # may not exist for directed
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, [edge[1], edge[0]]
+ )
+ else:
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_add_edge(self) -> None:
+ # generate graph input
+ random_vertices: list[int] = random.sample(range(101), 15)
+ random_edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyList(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # run and test add_edge
+ for edge in random_edges:
+ undirected_graph.add_edge(edge[0], edge[1])
+ directed_graph.add_edge(edge[0], edge[1])
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_remove_edge(self) -> None:
+ # generate graph input and graphs
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # run and test remove_edge
+ for edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+ undirected_graph.remove_edge(edge[0], edge[1])
+ directed_graph.remove_edge(edge[0], edge[1])
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_add_and_remove_edges_repeatedly(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # make some more edge options!
+ more_random_edges: list[list[int]] = []
+
+ while len(more_random_edges) != len(random_edges):
+ edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+ for edge in edges:
+ if len(more_random_edges) == len(random_edges):
+ break
+ elif edge not in more_random_edges and edge not in random_edges:
+ more_random_edges.append(edge)
+
+ for i, _ in enumerate(random_edges):
+ undirected_graph.add_edge(more_random_edges[i][0], more_random_edges[i][1])
+ directed_graph.add_edge(more_random_edges[i][0], more_random_edges[i][1])
+
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, more_random_edges[i]
+ )
+
+ undirected_graph.remove_edge(random_edges[i][0], random_edges[i][1])
+ directed_graph.remove_edge(random_edges[i][0], random_edges[i][1])
+
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, random_edges[i]
+ )
+
+ def test_add_vertex_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for vertex in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.add_vertex(vertex)
+ with self.assertRaises(ValueError):
+ directed_graph.add_vertex(vertex)
+
+ def test_remove_vertex_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for i in range(101):
+ if i not in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.remove_vertex(i)
+ with self.assertRaises(ValueError):
+ directed_graph.remove_vertex(i)
+
+ def test_add_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for edge in random_edges:
+ with self.assertRaises(ValueError):
+ undirected_graph.add_edge(edge[0], edge[1])
+ with self.assertRaises(ValueError):
+ directed_graph.add_edge(edge[0], edge[1])
+
+ def test_remove_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ more_random_edges: list[list[int]] = []
+
+ while len(more_random_edges) != len(random_edges):
+ edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+ for edge in edges:
+ if len(more_random_edges) == len(random_edges):
+ break
+ elif edge not in more_random_edges and edge not in random_edges:
+ more_random_edges.append(edge)
+
+ for edge in more_random_edges:
+ with self.assertRaises(ValueError):
+ undirected_graph.remove_edge(edge[0], edge[1])
+ with self.assertRaises(ValueError):
+ directed_graph.remove_edge(edge[0], edge[1])
+
+ def test_contains_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for vertex in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.contains_edge(vertex, 102)
+ with self.assertRaises(ValueError):
+ directed_graph.contains_edge(vertex, 102)
+
+ with self.assertRaises(ValueError):
+ undirected_graph.contains_edge(103, 102)
+ with self.assertRaises(ValueError):
+ directed_graph.contains_edge(103, 102)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/graphs/graph_adjacency_matrix.py b/graphs/graph_adjacency_matrix.py
new file mode 100644
index 000000000..4d2e02f73
--- /dev/null
+++ b/graphs/graph_adjacency_matrix.py
@@ -0,0 +1,608 @@
+#!/usr/bin/env python3
+"""
+Author: Vikram Nithyanandam
+
+Description:
+The following implementation is a robust unweighted Graph data structure
+implemented using an adjacency matrix. This vertices and edges of this graph can be
+effectively initialized and modified while storing your chosen generic
+value in each vertex.
+
+Adjacency Matrix: https://mathworld.wolfram.com/AdjacencyMatrix.html
+
+Potential Future Ideas:
+- Add a flag to set edge weights on and set edge weights
+- Make edge weights and vertex values customizable to store whatever the client wants
+- Support multigraph functionality if the client wants it
+"""
+from __future__ import annotations
+
+import random
+import unittest
+from pprint import pformat
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+
+
+class GraphAdjacencyMatrix(Generic[T]):
+ def __init__(
+ self, vertices: list[T], edges: list[list[T]], directed: bool = True
+ ) -> None:
+ """
+ Parameters:
+ - vertices: (list[T]) The list of vertex names the client wants to
+ pass in. Default is empty.
+ - edges: (list[list[T]]) The list of edges the client wants to
+ pass in. Each edge is a 2-element list. Default is empty.
+ - directed: (bool) Indicates if graph is directed or undirected.
+ Default is True.
+ """
+ self.directed = directed
+ self.vertex_to_index: dict[T, int] = {}
+ self.adj_matrix: list[list[int]] = []
+
+ # Falsey checks
+ edges = edges or []
+ vertices = vertices or []
+
+ for vertex in vertices:
+ self.add_vertex(vertex)
+
+ for edge in edges:
+ if len(edge) != 2:
+ msg = f"Invalid input: {edge} must have length 2."
+ raise ValueError(msg)
+ self.add_edge(edge[0], edge[1])
+
+ def add_edge(self, source_vertex: T, destination_vertex: T) -> None:
+ """
+ Creates an edge from source vertex to destination vertex. If any
+ given vertex doesn't exist or the edge already exists, a ValueError
+ will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} or "
+ f"{destination_vertex} does not exist"
+ )
+ raise ValueError(msg)
+ if self.contains_edge(source_vertex, destination_vertex):
+ msg = (
+ "Incorrect input: The edge already exists between "
+ f"{source_vertex} and {destination_vertex}"
+ )
+ raise ValueError(msg)
+
+ # Get the indices of the corresponding vertices and set their edge value to 1.
+ u: int = self.vertex_to_index[source_vertex]
+ v: int = self.vertex_to_index[destination_vertex]
+ self.adj_matrix[u][v] = 1
+ if not self.directed:
+ self.adj_matrix[v][u] = 1
+
+ def remove_edge(self, source_vertex: T, destination_vertex: T) -> None:
+ """
+ Removes the edge between the two vertices. If any given vertex
+ doesn't exist or the edge does not exist, a ValueError will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} or "
+ f"{destination_vertex} does not exist"
+ )
+ raise ValueError(msg)
+ if not self.contains_edge(source_vertex, destination_vertex):
+ msg = (
+ "Incorrect input: The edge does NOT exist between "
+ f"{source_vertex} and {destination_vertex}"
+ )
+ raise ValueError(msg)
+
+ # Get the indices of the corresponding vertices and set their edge value to 0.
+ u: int = self.vertex_to_index[source_vertex]
+ v: int = self.vertex_to_index[destination_vertex]
+ self.adj_matrix[u][v] = 0
+ if not self.directed:
+ self.adj_matrix[v][u] = 0
+
+ def add_vertex(self, vertex: T) -> None:
+ """
+ Adds a vertex to the graph. If the given vertex already exists,
+ a ValueError will be thrown.
+ """
+ if self.contains_vertex(vertex):
+ msg = f"Incorrect input: {vertex} already exists in this graph."
+ raise ValueError(msg)
+
+ # build column for vertex
+ for row in self.adj_matrix:
+ row.append(0)
+
+ # build row for vertex and update other data structures
+ self.adj_matrix.append([0] * (len(self.adj_matrix) + 1))
+ self.vertex_to_index[vertex] = len(self.adj_matrix) - 1
+
+ def remove_vertex(self, vertex: T) -> None:
+ """
+ Removes the given vertex from the graph and deletes all incoming and
+ outgoing edges from the given vertex as well. If the given vertex
+ does not exist, a ValueError will be thrown.
+ """
+ if not self.contains_vertex(vertex):
+ msg = f"Incorrect input: {vertex} does not exist in this graph."
+ raise ValueError(msg)
+
+ # first slide up the rows by deleting the row corresponding to
+ # the vertex being deleted.
+ start_index = self.vertex_to_index[vertex]
+ self.adj_matrix.pop(start_index)
+
+ # next, slide the columns to the left by deleting the values in
+ # the column corresponding to the vertex being deleted
+ for lst in self.adj_matrix:
+ lst.pop(start_index)
+
+ # final clean up
+ self.vertex_to_index.pop(vertex)
+
+ # decrement indices for vertices shifted by the deleted vertex in the adj matrix
+ for vertex in self.vertex_to_index:
+ if self.vertex_to_index[vertex] >= start_index:
+ self.vertex_to_index[vertex] = self.vertex_to_index[vertex] - 1
+
+ def contains_vertex(self, vertex: T) -> bool:
+ """
+ Returns True if the graph contains the vertex, False otherwise.
+ """
+ return vertex in self.vertex_to_index
+
+ def contains_edge(self, source_vertex: T, destination_vertex: T) -> bool:
+ """
+ Returns True if the graph contains the edge from the source_vertex to the
+ destination_vertex, False otherwise. If any given vertex doesn't exist, a
+ ValueError will be thrown.
+ """
+ if not (
+ self.contains_vertex(source_vertex)
+ and self.contains_vertex(destination_vertex)
+ ):
+ msg = (
+ f"Incorrect input: Either {source_vertex} "
+ f"or {destination_vertex} does not exist."
+ )
+ raise ValueError(msg)
+
+ u = self.vertex_to_index[source_vertex]
+ v = self.vertex_to_index[destination_vertex]
+ return self.adj_matrix[u][v] == 1
+
+ def clear_graph(self) -> None:
+ """
+ Clears all vertices and edges.
+ """
+ self.vertex_to_index = {}
+ self.adj_matrix = []
+
+ def __repr__(self) -> str:
+ first = "Adj Matrix:\n" + pformat(self.adj_matrix)
+ second = "\nVertex to index mapping:\n" + pformat(self.vertex_to_index)
+ return first + second
+
+
+class TestGraphMatrix(unittest.TestCase):
+ def __assert_graph_edge_exists_check(
+ self,
+ undirected_graph: GraphAdjacencyMatrix,
+ directed_graph: GraphAdjacencyMatrix,
+ edge: list[int],
+ ) -> None:
+ self.assertTrue(undirected_graph.contains_edge(edge[0], edge[1]))
+ self.assertTrue(undirected_graph.contains_edge(edge[1], edge[0]))
+ self.assertTrue(directed_graph.contains_edge(edge[0], edge[1]))
+
+ def __assert_graph_edge_does_not_exist_check(
+ self,
+ undirected_graph: GraphAdjacencyMatrix,
+ directed_graph: GraphAdjacencyMatrix,
+ edge: list[int],
+ ) -> None:
+ self.assertFalse(undirected_graph.contains_edge(edge[0], edge[1]))
+ self.assertFalse(undirected_graph.contains_edge(edge[1], edge[0]))
+ self.assertFalse(directed_graph.contains_edge(edge[0], edge[1]))
+
+ def __assert_graph_vertex_exists_check(
+ self,
+ undirected_graph: GraphAdjacencyMatrix,
+ directed_graph: GraphAdjacencyMatrix,
+ vertex: int,
+ ) -> None:
+ self.assertTrue(undirected_graph.contains_vertex(vertex))
+ self.assertTrue(directed_graph.contains_vertex(vertex))
+
+ def __assert_graph_vertex_does_not_exist_check(
+ self,
+ undirected_graph: GraphAdjacencyMatrix,
+ directed_graph: GraphAdjacencyMatrix,
+ vertex: int,
+ ) -> None:
+ self.assertFalse(undirected_graph.contains_vertex(vertex))
+ self.assertFalse(directed_graph.contains_vertex(vertex))
+
+ def __generate_random_edges(
+ self, vertices: list[int], edge_pick_count: int
+ ) -> list[list[int]]:
+ self.assertTrue(edge_pick_count <= len(vertices))
+
+ random_source_vertices: list[int] = random.sample(
+ vertices[0 : int(len(vertices) / 2)], edge_pick_count
+ )
+ random_destination_vertices: list[int] = random.sample(
+ vertices[int(len(vertices) / 2) :], edge_pick_count
+ )
+ random_edges: list[list[int]] = []
+
+ for source in random_source_vertices:
+ for dest in random_destination_vertices:
+ random_edges.append([source, dest])
+
+ return random_edges
+
+ def __generate_graphs(
+ self, vertex_count: int, min_val: int, max_val: int, edge_pick_count: int
+ ) -> tuple[GraphAdjacencyMatrix, GraphAdjacencyMatrix, list[int], list[list[int]]]:
+ if max_val - min_val + 1 < vertex_count:
+ raise ValueError(
+ "Will result in duplicate vertices. Either increase "
+ "range between min_val and max_val or decrease vertex count"
+ )
+
+ # generate graph input
+ random_vertices: list[int] = random.sample(
+ range(min_val, max_val + 1), vertex_count
+ )
+ random_edges: list[list[int]] = self.__generate_random_edges(
+ random_vertices, edge_pick_count
+ )
+
+ # build graphs
+ undirected_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=random_edges, directed=False
+ )
+ directed_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=random_edges, directed=True
+ )
+
+ return undirected_graph, directed_graph, random_vertices, random_edges
+
+ def test_init_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # test graph initialization with vertices and edges
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ for edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ self.assertFalse(undirected_graph.directed)
+ self.assertTrue(directed_graph.directed)
+
+ def test_contains_vertex(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # Build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # Test contains_vertex
+ for num in range(101):
+ self.assertEqual(
+ num in random_vertices, undirected_graph.contains_vertex(num)
+ )
+ self.assertEqual(
+ num in random_vertices, directed_graph.contains_vertex(num)
+ )
+
+ def test_add_vertices(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # build empty graphs
+ undirected_graph: GraphAdjacencyMatrix = GraphAdjacencyMatrix(
+ vertices=[], edges=[], directed=False
+ )
+ directed_graph: GraphAdjacencyMatrix = GraphAdjacencyMatrix(
+ vertices=[], edges=[], directed=True
+ )
+
+ # run add_vertex
+ for num in random_vertices:
+ undirected_graph.add_vertex(num)
+
+ for num in random_vertices:
+ directed_graph.add_vertex(num)
+
+ # test add_vertex worked
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ def test_remove_vertices(self) -> None:
+ random_vertices: list[int] = random.sample(range(101), 20)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # test remove_vertex worked
+ for num in random_vertices:
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, num
+ )
+
+ undirected_graph.remove_vertex(num)
+ directed_graph.remove_vertex(num)
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, num
+ )
+
+ def test_add_and_remove_vertices_repeatedly(self) -> None:
+ random_vertices1: list[int] = random.sample(range(51), 20)
+ random_vertices2: list[int] = random.sample(range(51, 101), 20)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices1, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices1, edges=[], directed=True
+ )
+
+ # test adding and removing vertices
+ for i, _ in enumerate(random_vertices1):
+ undirected_graph.add_vertex(random_vertices2[i])
+ directed_graph.add_vertex(random_vertices2[i])
+
+ self.__assert_graph_vertex_exists_check(
+ undirected_graph, directed_graph, random_vertices2[i]
+ )
+
+ undirected_graph.remove_vertex(random_vertices1[i])
+ directed_graph.remove_vertex(random_vertices1[i])
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, random_vertices1[i]
+ )
+
+ # remove all vertices
+ for i, _ in enumerate(random_vertices1):
+ undirected_graph.remove_vertex(random_vertices2[i])
+ directed_graph.remove_vertex(random_vertices2[i])
+
+ self.__assert_graph_vertex_does_not_exist_check(
+ undirected_graph, directed_graph, random_vertices2[i]
+ )
+
+ def test_contains_edge(self) -> None:
+ # generate graphs and graph input
+ vertex_count = 20
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(vertex_count, 0, 100, 4)
+
+ # generate all possible edges for testing
+ all_possible_edges: list[list[int]] = []
+ for i in range(vertex_count - 1):
+ for j in range(i + 1, vertex_count):
+ all_possible_edges.append([random_vertices[i], random_vertices[j]])
+ all_possible_edges.append([random_vertices[j], random_vertices[i]])
+
+ # test contains_edge function
+ for edge in all_possible_edges:
+ if edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+ elif [edge[1], edge[0]] in random_edges:
+ # since this edge exists for undirected but the reverse may
+ # not exist for directed
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, [edge[1], edge[0]]
+ )
+ else:
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_add_edge(self) -> None:
+ # generate graph input
+ random_vertices: list[int] = random.sample(range(101), 15)
+ random_edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+
+ # build graphs WITHOUT edges
+ undirected_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=False
+ )
+ directed_graph = GraphAdjacencyMatrix(
+ vertices=random_vertices, edges=[], directed=True
+ )
+
+ # run and test add_edge
+ for edge in random_edges:
+ undirected_graph.add_edge(edge[0], edge[1])
+ directed_graph.add_edge(edge[0], edge[1])
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_remove_edge(self) -> None:
+ # generate graph input and graphs
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # run and test remove_edge
+ for edge in random_edges:
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, edge
+ )
+ undirected_graph.remove_edge(edge[0], edge[1])
+ directed_graph.remove_edge(edge[0], edge[1])
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, edge
+ )
+
+ def test_add_and_remove_edges_repeatedly(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ # make some more edge options!
+ more_random_edges: list[list[int]] = []
+
+ while len(more_random_edges) != len(random_edges):
+ edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+ for edge in edges:
+ if len(more_random_edges) == len(random_edges):
+ break
+ elif edge not in more_random_edges and edge not in random_edges:
+ more_random_edges.append(edge)
+
+ for i, _ in enumerate(random_edges):
+ undirected_graph.add_edge(more_random_edges[i][0], more_random_edges[i][1])
+ directed_graph.add_edge(more_random_edges[i][0], more_random_edges[i][1])
+
+ self.__assert_graph_edge_exists_check(
+ undirected_graph, directed_graph, more_random_edges[i]
+ )
+
+ undirected_graph.remove_edge(random_edges[i][0], random_edges[i][1])
+ directed_graph.remove_edge(random_edges[i][0], random_edges[i][1])
+
+ self.__assert_graph_edge_does_not_exist_check(
+ undirected_graph, directed_graph, random_edges[i]
+ )
+
+ def test_add_vertex_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for vertex in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.add_vertex(vertex)
+ with self.assertRaises(ValueError):
+ directed_graph.add_vertex(vertex)
+
+ def test_remove_vertex_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for i in range(101):
+ if i not in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.remove_vertex(i)
+ with self.assertRaises(ValueError):
+ directed_graph.remove_vertex(i)
+
+ def test_add_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for edge in random_edges:
+ with self.assertRaises(ValueError):
+ undirected_graph.add_edge(edge[0], edge[1])
+ with self.assertRaises(ValueError):
+ directed_graph.add_edge(edge[0], edge[1])
+
+ def test_remove_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ more_random_edges: list[list[int]] = []
+
+ while len(more_random_edges) != len(random_edges):
+ edges: list[list[int]] = self.__generate_random_edges(random_vertices, 4)
+ for edge in edges:
+ if len(more_random_edges) == len(random_edges):
+ break
+ elif edge not in more_random_edges and edge not in random_edges:
+ more_random_edges.append(edge)
+
+ for edge in more_random_edges:
+ with self.assertRaises(ValueError):
+ undirected_graph.remove_edge(edge[0], edge[1])
+ with self.assertRaises(ValueError):
+ directed_graph.remove_edge(edge[0], edge[1])
+
+ def test_contains_edge_exception_check(self) -> None:
+ (
+ undirected_graph,
+ directed_graph,
+ random_vertices,
+ random_edges,
+ ) = self.__generate_graphs(20, 0, 100, 4)
+
+ for vertex in random_vertices:
+ with self.assertRaises(ValueError):
+ undirected_graph.contains_edge(vertex, 102)
+ with self.assertRaises(ValueError):
+ directed_graph.contains_edge(vertex, 102)
+
+ with self.assertRaises(ValueError):
+ undirected_graph.contains_edge(103, 102)
+ with self.assertRaises(ValueError):
+ directed_graph.contains_edge(103, 102)
+
+
+if __name__ == "__main__":
+ unittest.main()
diff --git a/graphs/graph_matrix.py b/graphs/graph_matrix.py
deleted file mode 100644
index 4adc6c0bb..000000000
--- a/graphs/graph_matrix.py
+++ /dev/null
@@ -1,24 +0,0 @@
-class Graph:
- def __init__(self, vertex):
- self.vertex = vertex
- self.graph = [[0] * vertex for i in range(vertex)]
-
- def add_edge(self, u, v):
- self.graph[u - 1][v - 1] = 1
- self.graph[v - 1][u - 1] = 1
-
- def show(self):
- for i in self.graph:
- for j in i:
- print(j, end=" ")
- print(" ")
-
-
-g = Graph(100)
-
-g.add_edge(1, 4)
-g.add_edge(4, 2)
-g.add_edge(4, 5)
-g.add_edge(2, 5)
-g.add_edge(5, 3)
-g.show()
diff --git a/graphs/greedy_best_first.py b/graphs/greedy_best_first.py
index d49e65b9d..35f7ca9fe 100644
--- a/graphs/greedy_best_first.py
+++ b/graphs/greedy_best_first.py
@@ -58,8 +58,8 @@ class Node:
The heuristic here is the Manhattan Distance
Could elaborate to offer more than one choice
"""
- dy = abs(self.pos_x - self.goal_x)
- dx = abs(self.pos_y - self.goal_y)
+ dx = abs(self.pos_x - self.goal_x)
+ dy = abs(self.pos_y - self.goal_y)
return dx + dy
def __lt__(self, other) -> bool:
diff --git a/graphs/tests/__init__.py b/graphs/tests/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/greedy_methods/minimum_waiting_time.py b/greedy_methods/minimum_waiting_time.py
new file mode 100644
index 000000000..aaae8cf8f
--- /dev/null
+++ b/greedy_methods/minimum_waiting_time.py
@@ -0,0 +1,48 @@
+"""
+Calculate the minimum waiting time using a greedy algorithm.
+reference: https://www.youtube.com/watch?v=Sf3eiO12eJs
+
+For doctests run following command:
+python -m doctest -v minimum_waiting_time.py
+
+The minimum_waiting_time function uses a greedy algorithm to calculate the minimum
+time for queries to complete. It sorts the list in non-decreasing order, calculates
+the waiting time for each query by multiplying its position in the list with the
+sum of all remaining query times, and returns the total waiting time. A doctest
+ensures that the function produces the correct output.
+"""
+
+
+def minimum_waiting_time(queries: list[int]) -> int:
+ """
+ This function takes a list of query times and returns the minimum waiting time
+ for all queries to be completed.
+
+ Args:
+ queries: A list of queries measured in picoseconds
+
+ Returns:
+ total_waiting_time: Minimum waiting time measured in picoseconds
+
+ Examples:
+ >>> minimum_waiting_time([3, 2, 1, 2, 6])
+ 17
+ >>> minimum_waiting_time([3, 2, 1])
+ 4
+ >>> minimum_waiting_time([1, 2, 3, 4])
+ 10
+ >>> minimum_waiting_time([5, 5, 5, 5])
+ 30
+ >>> minimum_waiting_time([])
+ 0
+ """
+ n = len(queries)
+ if n in (0, 1):
+ return 0
+ return sum(query * (n - i - 1) for i, query in enumerate(sorted(queries)))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/linear_algebra/src/rank_of_matrix.py b/linear_algebra/src/rank_of_matrix.py
new file mode 100644
index 000000000..7ff3c1699
--- /dev/null
+++ b/linear_algebra/src/rank_of_matrix.py
@@ -0,0 +1,89 @@
+"""
+Calculate the rank of a matrix.
+
+See: https://en.wikipedia.org/wiki/Rank_(linear_algebra)
+"""
+
+
+def rank_of_matrix(matrix: list[list[int | float]]) -> int:
+ """
+ Finds the rank of a matrix.
+ Args:
+ matrix: The matrix as a list of lists.
+ Returns:
+ The rank of the matrix.
+ Example:
+ >>> matrix1 = [[1, 2, 3],
+ ... [4, 5, 6],
+ ... [7, 8, 9]]
+ >>> rank_of_matrix(matrix1)
+ 2
+ >>> matrix2 = [[1, 0, 0],
+ ... [0, 1, 0],
+ ... [0, 0, 0]]
+ >>> rank_of_matrix(matrix2)
+ 2
+ >>> matrix3 = [[1, 2, 3, 4],
+ ... [5, 6, 7, 8],
+ ... [9, 10, 11, 12]]
+ >>> rank_of_matrix(matrix3)
+ 2
+ >>> rank_of_matrix([[2,3,-1,-1],
+ ... [1,-1,-2,4],
+ ... [3,1,3,-2],
+ ... [6,3,0,-7]])
+ 4
+ >>> rank_of_matrix([[2,1,-3,-6],
+ ... [3,-3,1,2],
+ ... [1,1,1,2]])
+ 3
+ >>> rank_of_matrix([[2,-1,0],
+ ... [1,3,4],
+ ... [4,1,-3]])
+ 3
+ >>> rank_of_matrix([[3,2,1],
+ ... [-6,-4,-2]])
+ 1
+ >>> rank_of_matrix([[],[]])
+ 0
+ >>> rank_of_matrix([[1]])
+ 1
+ >>> rank_of_matrix([[]])
+ 0
+ """
+
+ rows = len(matrix)
+ columns = len(matrix[0])
+ rank = min(rows, columns)
+
+ for row in range(rank):
+ # Check if diagonal element is not zero
+ if matrix[row][row] != 0:
+ # Eliminate all the elements below the diagonal
+ for col in range(row + 1, rows):
+ multiplier = matrix[col][row] / matrix[row][row]
+ for i in range(row, columns):
+ matrix[col][i] -= multiplier * matrix[row][i]
+ else:
+ # Find a non-zero diagonal element to swap rows
+ reduce = True
+ for i in range(row + 1, rows):
+ if matrix[i][row] != 0:
+ matrix[row], matrix[i] = matrix[i], matrix[row]
+ reduce = False
+ break
+ if reduce:
+ rank -= 1
+ for i in range(rows):
+ matrix[i][row] = matrix[i][rank]
+
+ # Reduce the row pointer by one to stay on the same row
+ row -= 1
+
+ return rank
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/linear_algebra/src/schur_complement.py b/linear_algebra/src/schur_complement.py
index 3a5f4443a..750f4de5e 100644
--- a/linear_algebra/src/schur_complement.py
+++ b/linear_algebra/src/schur_complement.py
@@ -31,16 +31,18 @@ def schur_complement(
shape_c = np.shape(mat_c)
if shape_a[0] != shape_b[0]:
- raise ValueError(
- f"Expected the same number of rows for A and B. \
- Instead found A of size {shape_a} and B of size {shape_b}"
+ msg = (
+ "Expected the same number of rows for A and B. "
+ f"Instead found A of size {shape_a} and B of size {shape_b}"
)
+ raise ValueError(msg)
if shape_b[1] != shape_c[1]:
- raise ValueError(
- f"Expected the same number of columns for B and C. \
- Instead found B of size {shape_b} and C of size {shape_c}"
+ msg = (
+ "Expected the same number of columns for B and C. "
+ f"Instead found B of size {shape_b} and C of size {shape_c}"
)
+ raise ValueError(msg)
a_inv = pseudo_inv
if a_inv is None:
diff --git a/linear_programming/simplex.py b/linear_programming/simplex.py
new file mode 100644
index 000000000..ba64add40
--- /dev/null
+++ b/linear_programming/simplex.py
@@ -0,0 +1,311 @@
+"""
+Python implementation of the simplex algorithm for solving linear programs in
+tabular form with
+- `>=`, `<=`, and `=` constraints and
+- each variable `x1, x2, ...>= 0`.
+
+See https://gist.github.com/imengus/f9619a568f7da5bc74eaf20169a24d98 for how to
+convert linear programs to simplex tableaus, and the steps taken in the simplex
+algorithm.
+
+Resources:
+https://en.wikipedia.org/wiki/Simplex_algorithm
+https://tinyurl.com/simplex4beginners
+"""
+from typing import Any
+
+import numpy as np
+
+
+class Tableau:
+ """Operate on simplex tableaus
+
+ >>> t = Tableau(np.array([[-1,-1,0,0,-1],[1,3,1,0,4],[3,1,0,1,4.]]), 2)
+ Traceback (most recent call last):
+ ...
+ ValueError: RHS must be > 0
+ """
+
+ def __init__(self, tableau: np.ndarray, n_vars: int) -> None:
+ # Check if RHS is negative
+ if np.any(tableau[:, -1], where=tableau[:, -1] < 0):
+ raise ValueError("RHS must be > 0")
+
+ self.tableau = tableau
+ self.n_rows, _ = tableau.shape
+
+ # Number of decision variables x1, x2, x3...
+ self.n_vars = n_vars
+
+ # Number of artificial variables to be minimised
+ self.n_art_vars = len(np.where(tableau[self.n_vars : -1] == -1)[0])
+
+ # 2 if there are >= or == constraints (nonstandard), 1 otherwise (std)
+ self.n_stages = (self.n_art_vars > 0) + 1
+
+ # Number of slack variables added to make inequalities into equalities
+ self.n_slack = self.n_rows - self.n_stages
+
+ # Objectives for each stage
+ self.objectives = ["max"]
+
+ # In two stage simplex, first minimise then maximise
+ if self.n_art_vars:
+ self.objectives.append("min")
+
+ self.col_titles = [""]
+
+ # Index of current pivot row and column
+ self.row_idx = None
+ self.col_idx = None
+
+ # Does objective row only contain (non)-negative values?
+ self.stop_iter = False
+
+ @staticmethod
+ def generate_col_titles(*args: int) -> list[str]:
+ """Generate column titles for tableau of specific dimensions
+
+ >>> Tableau.generate_col_titles(2, 3, 1)
+ ['x1', 'x2', 's1', 's2', 's3', 'a1', 'RHS']
+
+ >>> Tableau.generate_col_titles()
+ Traceback (most recent call last):
+ ...
+ ValueError: Must provide n_vars, n_slack, and n_art_vars
+ >>> Tableau.generate_col_titles(-2, 3, 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: All arguments must be non-negative integers
+ """
+ if len(args) != 3:
+ raise ValueError("Must provide n_vars, n_slack, and n_art_vars")
+
+ if not all(x >= 0 and isinstance(x, int) for x in args):
+ raise ValueError("All arguments must be non-negative integers")
+
+ # decision | slack | artificial
+ string_starts = ["x", "s", "a"]
+ titles = []
+ for i in range(3):
+ for j in range(args[i]):
+ titles.append(string_starts[i] + str(j + 1))
+ titles.append("RHS")
+ return titles
+
+ def find_pivot(self, tableau: np.ndarray) -> tuple[Any, Any]:
+ """Finds the pivot row and column.
+ >>> t = Tableau(np.array([[-2,1,0,0,0], [3,1,1,0,6], [1,2,0,1,7.]]), 2)
+ >>> t.find_pivot(t.tableau)
+ (1, 0)
+ """
+ objective = self.objectives[-1]
+
+ # Find entries of highest magnitude in objective rows
+ sign = (objective == "min") - (objective == "max")
+ col_idx = np.argmax(sign * tableau[0, : self.n_vars])
+
+ # Choice is only valid if below 0 for maximise, and above for minimise
+ if sign * self.tableau[0, col_idx] <= 0:
+ self.stop_iter = True
+ return 0, 0
+
+ # Pivot row is chosen as having the lowest quotient when elements of
+ # the pivot column divide the right-hand side
+
+ # Slice excluding the objective rows
+ s = slice(self.n_stages, self.n_rows)
+
+ # RHS
+ dividend = tableau[s, -1]
+
+ # Elements of pivot column within slice
+ divisor = tableau[s, col_idx]
+
+ # Array filled with nans
+ nans = np.full(self.n_rows - self.n_stages, np.nan)
+
+ # If element in pivot column is greater than zeron_stages, return
+ # quotient or nan otherwise
+ quotients = np.divide(dividend, divisor, out=nans, where=divisor > 0)
+
+ # Arg of minimum quotient excluding the nan values. n_stages is added
+ # to compensate for earlier exclusion of objective columns
+ row_idx = np.nanargmin(quotients) + self.n_stages
+ return row_idx, col_idx
+
+ def pivot(self, tableau: np.ndarray, row_idx: int, col_idx: int) -> np.ndarray:
+ """Pivots on value on the intersection of pivot row and column.
+
+ >>> t = Tableau(np.array([[-2,-3,0,0,0],[1,3,1,0,4],[3,1,0,1,4.]]), 2)
+ >>> t.pivot(t.tableau, 1, 0).tolist()
+ ... # doctest: +NORMALIZE_WHITESPACE
+ [[0.0, 3.0, 2.0, 0.0, 8.0],
+ [1.0, 3.0, 1.0, 0.0, 4.0],
+ [0.0, -8.0, -3.0, 1.0, -8.0]]
+ """
+ # Avoid changes to original tableau
+ piv_row = tableau[row_idx].copy()
+
+ piv_val = piv_row[col_idx]
+
+ # Entry becomes 1
+ piv_row *= 1 / piv_val
+
+ # Variable in pivot column becomes basic, ie the only non-zero entry
+ for idx, coeff in enumerate(tableau[:, col_idx]):
+ tableau[idx] += -coeff * piv_row
+ tableau[row_idx] = piv_row
+ return tableau
+
+ def change_stage(self, tableau: np.ndarray) -> np.ndarray:
+ """Exits first phase of the two-stage method by deleting artificial
+ rows and columns, or completes the algorithm if exiting the standard
+ case.
+
+ >>> t = Tableau(np.array([
+ ... [3, 3, -1, -1, 0, 0, 4],
+ ... [2, 1, 0, 0, 0, 0, 0.],
+ ... [1, 2, -1, 0, 1, 0, 2],
+ ... [2, 1, 0, -1, 0, 1, 2]
+ ... ]), 2)
+ >>> t.change_stage(t.tableau).tolist()
+ ... # doctest: +NORMALIZE_WHITESPACE
+ [[2.0, 1.0, 0.0, 0.0, 0.0, 0.0],
+ [1.0, 2.0, -1.0, 0.0, 1.0, 2.0],
+ [2.0, 1.0, 0.0, -1.0, 0.0, 2.0]]
+ """
+ # Objective of original objective row remains
+ self.objectives.pop()
+
+ if not self.objectives:
+ return tableau
+
+ # Slice containing ids for artificial columns
+ s = slice(-self.n_art_vars - 1, -1)
+
+ # Delete the artificial variable columns
+ tableau = np.delete(tableau, s, axis=1)
+
+ # Delete the objective row of the first stage
+ tableau = np.delete(tableau, 0, axis=0)
+
+ self.n_stages = 1
+ self.n_rows -= 1
+ self.n_art_vars = 0
+ self.stop_iter = False
+ return tableau
+
+ def run_simplex(self) -> dict[Any, Any]:
+ """Operate on tableau until objective function cannot be
+ improved further.
+
+ # Standard linear program:
+ Max: x1 + x2
+ ST: x1 + 3x2 <= 4
+ 3x1 + x2 <= 4
+ >>> Tableau(np.array([[-1,-1,0,0,0],[1,3,1,0,4],[3,1,0,1,4.]]),
+ ... 2).run_simplex()
+ {'P': 2.0, 'x1': 1.0, 'x2': 1.0}
+
+ # Optimal tableau input:
+ >>> Tableau(np.array([
+ ... [0, 0, 0.25, 0.25, 2],
+ ... [0, 1, 0.375, -0.125, 1],
+ ... [1, 0, -0.125, 0.375, 1]
+ ... ]), 2).run_simplex()
+ {'P': 2.0, 'x1': 1.0, 'x2': 1.0}
+
+ # Non-standard: >= constraints
+ Max: 2x1 + 3x2 + x3
+ ST: x1 + x2 + x3 <= 40
+ 2x1 + x2 - x3 >= 10
+ - x2 + x3 >= 10
+ >>> Tableau(np.array([
+ ... [2, 0, 0, 0, -1, -1, 0, 0, 20],
+ ... [-2, -3, -1, 0, 0, 0, 0, 0, 0],
+ ... [1, 1, 1, 1, 0, 0, 0, 0, 40],
+ ... [2, 1, -1, 0, -1, 0, 1, 0, 10],
+ ... [0, -1, 1, 0, 0, -1, 0, 1, 10.]
+ ... ]), 3).run_simplex()
+ {'P': 70.0, 'x1': 10.0, 'x2': 10.0, 'x3': 20.0}
+
+ # Non standard: minimisation and equalities
+ Min: x1 + x2
+ ST: 2x1 + x2 = 12
+ 6x1 + 5x2 = 40
+ >>> Tableau(np.array([
+ ... [8, 6, 0, -1, 0, -1, 0, 0, 52],
+ ... [1, 1, 0, 0, 0, 0, 0, 0, 0],
+ ... [2, 1, 1, 0, 0, 0, 0, 0, 12],
+ ... [2, 1, 0, -1, 0, 0, 1, 0, 12],
+ ... [6, 5, 0, 0, 1, 0, 0, 0, 40],
+ ... [6, 5, 0, 0, 0, -1, 0, 1, 40.]
+ ... ]), 2).run_simplex()
+ {'P': 7.0, 'x1': 5.0, 'x2': 2.0}
+ """
+ # Stop simplex algorithm from cycling.
+ for _ in range(100):
+ # Completion of each stage removes an objective. If both stages
+ # are complete, then no objectives are left
+ if not self.objectives:
+ self.col_titles = self.generate_col_titles(
+ self.n_vars, self.n_slack, self.n_art_vars
+ )
+
+ # Find the values of each variable at optimal solution
+ return self.interpret_tableau(self.tableau, self.col_titles)
+
+ row_idx, col_idx = self.find_pivot(self.tableau)
+
+ # If there are no more negative values in objective row
+ if self.stop_iter:
+ # Delete artificial variable columns and rows. Update attributes
+ self.tableau = self.change_stage(self.tableau)
+ else:
+ self.tableau = self.pivot(self.tableau, row_idx, col_idx)
+ return {}
+
+ def interpret_tableau(
+ self, tableau: np.ndarray, col_titles: list[str]
+ ) -> dict[str, float]:
+ """Given the final tableau, add the corresponding values of the basic
+ decision variables to the `output_dict`
+ >>> tableau = np.array([
+ ... [0,0,0.875,0.375,5],
+ ... [0,1,0.375,-0.125,1],
+ ... [1,0,-0.125,0.375,1]
+ ... ])
+ >>> t = Tableau(tableau, 2)
+ >>> t.interpret_tableau(tableau, ["x1", "x2", "s1", "s2", "RHS"])
+ {'P': 5.0, 'x1': 1.0, 'x2': 1.0}
+ """
+ # P = RHS of final tableau
+ output_dict = {"P": abs(tableau[0, -1])}
+
+ for i in range(self.n_vars):
+ # Gives ids of nonzero entries in the ith column
+ nonzero = np.nonzero(tableau[:, i])
+ n_nonzero = len(nonzero[0])
+
+ # First entry in the nonzero ids
+ nonzero_rowidx = nonzero[0][0]
+ nonzero_val = tableau[nonzero_rowidx, i]
+
+ # If there is only one nonzero value in column, which is one
+ if n_nonzero == nonzero_val == 1:
+ rhs_val = tableau[nonzero_rowidx, -1]
+ output_dict[col_titles[i]] = rhs_val
+
+ # Check for basic variables
+ for title in col_titles:
+ # Don't add RHS or slack variables to output dict
+ if title[0] not in "R-s-a":
+ output_dict.setdefault(title, 0)
+ return output_dict
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/machine_learning/linear_discriminant_analysis.py b/machine_learning/linear_discriminant_analysis.py
index c0a477be1..88c047157 100644
--- a/machine_learning/linear_discriminant_analysis.py
+++ b/machine_learning/linear_discriminant_analysis.py
@@ -399,7 +399,7 @@ def main():
if input("Press any key to restart or 'q' for quit: ").strip().lower() == "q":
print("\n" + "GoodBye!".center(100, "-") + "\n")
break
- system("clear" if name == "posix" else "cls") # noqa: S605
+ system("cls" if name == "nt" else "clear") # noqa: S605
if __name__ == "__main__":
diff --git a/machine_learning/local_weighted_learning/local_weighted_learning.py b/machine_learning/local_weighted_learning/local_weighted_learning.py
index 6260e9ac6..8dd0e55d4 100644
--- a/machine_learning/local_weighted_learning/local_weighted_learning.py
+++ b/machine_learning/local_weighted_learning/local_weighted_learning.py
@@ -1,14 +1,55 @@
+"""
+Locally weighted linear regression, also called local regression, is a type of
+non-parametric linear regression that prioritizes data closest to a given
+prediction point. The algorithm estimates the vector of model coefficients β
+using weighted least squares regression:
+
+β = (XᵀWX)⁻¹(XᵀWy),
+
+where X is the design matrix, y is the response vector, and W is the diagonal
+weight matrix.
+
+This implementation calculates wᵢ, the weight of the ith training sample, using
+the Gaussian weight:
+
+wᵢ = exp(-‖xᵢ - x‖²/(2τ²)),
+
+where xᵢ is the ith training sample, x is the prediction point, τ is the
+"bandwidth", and ‖x‖ is the Euclidean norm (also called the 2-norm or the L²
+norm). The bandwidth τ controls how quickly the weight of a training sample
+decreases as its distance from the prediction point increases. One can think of
+the Gaussian weight as a bell curve centered around the prediction point: a
+training sample is weighted lower if it's farther from the center, and τ
+controls the spread of the bell curve.
+
+Other types of locally weighted regression such as locally estimated scatterplot
+smoothing (LOESS) typically use different weight functions.
+
+References:
+ - https://en.wikipedia.org/wiki/Local_regression
+ - https://en.wikipedia.org/wiki/Weighted_least_squares
+ - https://cs229.stanford.edu/notes2022fall/main_notes.pdf
+"""
+
import matplotlib.pyplot as plt
import numpy as np
-def weighted_matrix(
- point: np.array, training_data_x: np.array, bandwidth: float
-) -> np.array:
+def weight_matrix(point: np.ndarray, x_train: np.ndarray, tau: float) -> np.ndarray:
"""
- Calculate the weight for every point in the data set.
- point --> the x value at which we want to make predictions
- >>> weighted_matrix(
+ Calculate the weight of every point in the training data around a given
+ prediction point
+
+ Args:
+ point: x-value at which the prediction is being made
+ x_train: ndarray of x-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+
+ Returns:
+ m x m weight matrix around the prediction point, where m is the size of
+ the training set
+ >>> weight_matrix(
... np.array([1., 1.]),
... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
... 0.6
@@ -17,25 +58,30 @@ def weighted_matrix(
[0.00000000e+000, 0.00000000e+000, 0.00000000e+000],
[0.00000000e+000, 0.00000000e+000, 0.00000000e+000]])
"""
- m, _ = np.shape(training_data_x) # m is the number of training samples
- weights = np.eye(m) # Initializing weights as identity matrix
-
- # calculating weights for all training examples [x(i)'s]
+ m = len(x_train) # Number of training samples
+ weights = np.eye(m) # Initialize weights as identity matrix
for j in range(m):
- diff = point - training_data_x[j]
- weights[j, j] = np.exp(diff @ diff.T / (-2.0 * bandwidth**2))
+ diff = point - x_train[j]
+ weights[j, j] = np.exp(diff @ diff.T / (-2.0 * tau**2))
+
return weights
def local_weight(
- point: np.array,
- training_data_x: np.array,
- training_data_y: np.array,
- bandwidth: float,
-) -> np.array:
+ point: np.ndarray, x_train: np.ndarray, y_train: np.ndarray, tau: float
+) -> np.ndarray:
"""
- Calculate the local weights using the weight_matrix function on training data.
- Return the weighted matrix.
+ Calculate the local weights at a given prediction point using the weight
+ matrix for that point
+
+ Args:
+ point: x-value at which the prediction is being made
+ x_train: ndarray of x-values for training
+ y_train: ndarray of y-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+ Returns:
+ ndarray of local weights
>>> local_weight(
... np.array([1., 1.]),
... np.array([[16.99, 10.34], [21.01,23.68], [24.59,25.69]]),
@@ -45,19 +91,28 @@ def local_weight(
array([[0.00873174],
[0.08272556]])
"""
- weight = weighted_matrix(point, training_data_x, bandwidth)
- w = np.linalg.inv(training_data_x.T @ (weight @ training_data_x)) @ (
- training_data_x.T @ weight @ training_data_y.T
+ weight_mat = weight_matrix(point, x_train, tau)
+ weight = np.linalg.inv(x_train.T @ weight_mat @ x_train) @ (
+ x_train.T @ weight_mat @ y_train.T
)
- return w
+ return weight
def local_weight_regression(
- training_data_x: np.array, training_data_y: np.array, bandwidth: float
-) -> np.array:
+ x_train: np.ndarray, y_train: np.ndarray, tau: float
+) -> np.ndarray:
"""
- Calculate predictions for each data point on axis
+ Calculate predictions for each point in the training data
+
+ Args:
+ x_train: ndarray of x-values for training
+ y_train: ndarray of y-values for training
+ tau: bandwidth value, controls how quickly the weight of training values
+ decreases as the distance from the prediction point increases
+
+ Returns:
+ ndarray of predictions
>>> local_weight_regression(
... np.array([[16.99, 10.34], [21.01, 23.68], [24.59, 25.69]]),
... np.array([[1.01, 1.66, 3.5]]),
@@ -65,77 +120,57 @@ def local_weight_regression(
... )
array([1.07173261, 1.65970737, 3.50160179])
"""
- m, _ = np.shape(training_data_x)
- ypred = np.zeros(m)
+ y_pred = np.zeros(len(x_train)) # Initialize array of predictions
+ for i, item in enumerate(x_train):
+ y_pred[i] = item @ local_weight(item, x_train, y_train, tau)
- for i, item in enumerate(training_data_x):
- ypred[i] = item @ local_weight(
- item, training_data_x, training_data_y, bandwidth
- )
-
- return ypred
+ return y_pred
def load_data(
- dataset_name: str, cola_name: str, colb_name: str
-) -> tuple[np.array, np.array, np.array, np.array]:
+ dataset_name: str, x_name: str, y_name: str
+) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
"""
Load data from seaborn and split it into x and y points
+ >>> pass # No doctests, function is for demo purposes only
"""
import seaborn as sns
data = sns.load_dataset(dataset_name)
- col_a = np.array(data[cola_name]) # total_bill
- col_b = np.array(data[colb_name]) # tip
+ x_data = np.array(data[x_name])
+ y_data = np.array(data[y_name])
- mcol_a = col_a.copy()
- mcol_b = col_b.copy()
+ one = np.ones(len(y_data))
- one = np.ones(np.shape(mcol_b)[0], dtype=int)
+ # pairing elements of one and x_data
+ x_train = np.column_stack((one, x_data))
- # pairing elements of one and mcol_a
- training_data_x = np.column_stack((one, mcol_a))
-
- return training_data_x, mcol_b, col_a, col_b
-
-
-def get_preds(training_data_x: np.array, mcol_b: np.array, tau: float) -> np.array:
- """
- Get predictions with minimum error for each training data
- >>> get_preds(
- ... np.array([[16.99, 10.34], [21.01, 23.68], [24.59, 25.69]]),
- ... np.array([[1.01, 1.66, 3.5]]),
- ... 0.6
- ... )
- array([1.07173261, 1.65970737, 3.50160179])
- """
- ypred = local_weight_regression(training_data_x, mcol_b, tau)
- return ypred
+ return x_train, x_data, y_data
def plot_preds(
- training_data_x: np.array,
- predictions: np.array,
- col_x: np.array,
- col_y: np.array,
- cola_name: str,
- colb_name: str,
-) -> plt.plot:
+ x_train: np.ndarray,
+ preds: np.ndarray,
+ x_data: np.ndarray,
+ y_data: np.ndarray,
+ x_name: str,
+ y_name: str,
+) -> None:
"""
Plot predictions and display the graph
+ >>> pass # No doctests, function is for demo purposes only
"""
- xsort = training_data_x.copy()
- xsort.sort(axis=0)
- plt.scatter(col_x, col_y, color="blue")
+ x_train_sorted = np.sort(x_train, axis=0)
+ plt.scatter(x_data, y_data, color="blue")
plt.plot(
- xsort[:, 1],
- predictions[training_data_x[:, 1].argsort(0)],
+ x_train_sorted[:, 1],
+ preds[x_train[:, 1].argsort(0)],
color="yellow",
linewidth=5,
)
plt.title("Local Weighted Regression")
- plt.xlabel(cola_name)
- plt.ylabel(colb_name)
+ plt.xlabel(x_name)
+ plt.ylabel(y_name)
plt.show()
@@ -144,6 +179,7 @@ if __name__ == "__main__":
doctest.testmod()
- training_data_x, mcol_b, col_a, col_b = load_data("tips", "total_bill", "tip")
- predictions = get_preds(training_data_x, mcol_b, 0.5)
- plot_preds(training_data_x, predictions, col_a, col_b, "total_bill", "tip")
+ # Demo with a dataset from the seaborn module
+ training_data_x, total_bill, tip = load_data("tips", "total_bill", "tip")
+ predictions = local_weight_regression(training_data_x, tip, 5)
+ plot_preds(training_data_x, predictions, total_bill, tip, "total_bill", "tip")
diff --git a/machine_learning/polymonial_regression.py b/machine_learning/polymonial_regression.py
deleted file mode 100644
index 487fb8145..000000000
--- a/machine_learning/polymonial_regression.py
+++ /dev/null
@@ -1,44 +0,0 @@
-import pandas as pd
-from matplotlib import pyplot as plt
-from sklearn.linear_model import LinearRegression
-
-# Splitting the dataset into the Training set and Test set
-from sklearn.model_selection import train_test_split
-
-# Fitting Polynomial Regression to the dataset
-from sklearn.preprocessing import PolynomialFeatures
-
-# Importing the dataset
-dataset = pd.read_csv(
- "https://s3.us-west-2.amazonaws.com/public.gamelab.fun/dataset/"
- "position_salaries.csv"
-)
-X = dataset.iloc[:, 1:2].values
-y = dataset.iloc[:, 2].values
-
-
-X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=0)
-
-
-poly_reg = PolynomialFeatures(degree=4)
-X_poly = poly_reg.fit_transform(X)
-pol_reg = LinearRegression()
-pol_reg.fit(X_poly, y)
-
-
-# Visualizing the Polymonial Regression results
-def viz_polymonial():
- plt.scatter(X, y, color="red")
- plt.plot(X, pol_reg.predict(poly_reg.fit_transform(X)), color="blue")
- plt.title("Truth or Bluff (Linear Regression)")
- plt.xlabel("Position level")
- plt.ylabel("Salary")
- plt.show()
-
-
-if __name__ == "__main__":
- viz_polymonial()
-
- # Predicting a new result with Polymonial Regression
- pol_reg.predict(poly_reg.fit_transform([[5.5]]))
- # output should be 132148.43750003
diff --git a/machine_learning/polynomial_regression.py b/machine_learning/polynomial_regression.py
new file mode 100644
index 000000000..5bafea96f
--- /dev/null
+++ b/machine_learning/polynomial_regression.py
@@ -0,0 +1,213 @@
+"""
+Polynomial regression is a type of regression analysis that models the relationship
+between a predictor x and the response y as an mth-degree polynomial:
+
+y = β₀ + β₁x + β₂x² + ... + βₘxᵐ + ε
+
+By treating x, x², ..., xᵐ as distinct variables, we see that polynomial regression is a
+special case of multiple linear regression. Therefore, we can use ordinary least squares
+(OLS) estimation to estimate the vector of model parameters β = (β₀, β₁, β₂, ..., βₘ)
+for polynomial regression:
+
+β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+where X is the design matrix, y is the response vector, and X⁺ denotes the Moore–Penrose
+pseudoinverse of X. In the case of polynomial regression, the design matrix is
+
+ |1 x₁ x₁² ⋯ x₁ᵐ|
+X = |1 x₂ x₂² ⋯ x₂ᵐ|
+ |⋮ ⋮ ⋮ ⋱ ⋮ |
+ |1 xₙ xₙ² ⋯ xₙᵐ|
+
+In OLS estimation, inverting XᵀX to compute X⁺ can be very numerically unstable. This
+implementation sidesteps this need to invert XᵀX by computing X⁺ using singular value
+decomposition (SVD):
+
+β = VΣ⁺Uᵀy
+
+where UΣVᵀ is an SVD of X.
+
+References:
+ - https://en.wikipedia.org/wiki/Polynomial_regression
+ - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+ - https://en.wikipedia.org/wiki/Numerical_methods_for_linear_least_squares
+ - https://en.wikipedia.org/wiki/Singular_value_decomposition
+"""
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class PolynomialRegression:
+ __slots__ = "degree", "params"
+
+ def __init__(self, degree: int) -> None:
+ """
+ @raises ValueError: if the polynomial degree is negative
+ """
+ if degree < 0:
+ raise ValueError("Polynomial degree must be non-negative")
+
+ self.degree = degree
+ self.params = None
+
+ @staticmethod
+ def _design_matrix(data: np.ndarray, degree: int) -> np.ndarray:
+ """
+ Constructs a polynomial regression design matrix for the given input data. For
+ input data x = (x₁, x₂, ..., xₙ) and polynomial degree m, the design matrix is
+ the Vandermonde matrix
+
+ |1 x₁ x₁² ⋯ x₁ᵐ|
+ X = |1 x₂ x₂² ⋯ x₂ᵐ|
+ |⋮ ⋮ ⋮ ⋱ ⋮ |
+ |1 xₙ xₙ² ⋯ xₙᵐ|
+
+ Reference: https://en.wikipedia.org/wiki/Vandermonde_matrix
+
+ @param data: the input predictor values x, either for model fitting or for
+ prediction
+ @param degree: the polynomial degree m
+ @returns: the Vandermonde matrix X (see above)
+ @raises ValueError: if input data is not N x 1
+
+ >>> x = np.array([0, 1, 2])
+ >>> PolynomialRegression._design_matrix(x, degree=0)
+ array([[1],
+ [1],
+ [1]])
+ >>> PolynomialRegression._design_matrix(x, degree=1)
+ array([[1, 0],
+ [1, 1],
+ [1, 2]])
+ >>> PolynomialRegression._design_matrix(x, degree=2)
+ array([[1, 0, 0],
+ [1, 1, 1],
+ [1, 2, 4]])
+ >>> PolynomialRegression._design_matrix(x, degree=3)
+ array([[1, 0, 0, 0],
+ [1, 1, 1, 1],
+ [1, 2, 4, 8]])
+ >>> PolynomialRegression._design_matrix(np.array([[0, 0], [0 , 0]]), degree=3)
+ Traceback (most recent call last):
+ ...
+ ValueError: Data must have dimensions N x 1
+ """
+ rows, *remaining = data.shape
+ if remaining:
+ raise ValueError("Data must have dimensions N x 1")
+
+ return np.vander(data, N=degree + 1, increasing=True)
+
+ def fit(self, x_train: np.ndarray, y_train: np.ndarray) -> None:
+ """
+ Computes the polynomial regression model parameters using ordinary least squares
+ (OLS) estimation:
+
+ β = (XᵀX)⁻¹Xᵀy = X⁺y
+
+ where X⁺ denotes the Moore–Penrose pseudoinverse of the design matrix X. This
+ function computes X⁺ using singular value decomposition (SVD).
+
+ References:
+ - https://en.wikipedia.org/wiki/Moore%E2%80%93Penrose_inverse
+ - https://en.wikipedia.org/wiki/Singular_value_decomposition
+ - https://en.wikipedia.org/wiki/Multicollinearity
+
+ @param x_train: the predictor values x for model fitting
+ @param y_train: the response values y for model fitting
+ @raises ArithmeticError: if X isn't full rank, then XᵀX is singular and β
+ doesn't exist
+
+ >>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
+ >>> y = x**3 - 2 * x**2 + 3 * x - 5
+ >>> poly_reg = PolynomialRegression(degree=3)
+ >>> poly_reg.fit(x, y)
+ >>> poly_reg.params
+ array([-5., 3., -2., 1.])
+ >>> poly_reg = PolynomialRegression(degree=20)
+ >>> poly_reg.fit(x, y)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: Design matrix is not full rank, can't compute coefficients
+
+ Make sure errors don't grow too large:
+ >>> coefs = np.array([-250, 50, -2, 36, 20, -12, 10, 2, -1, -15, 1])
+ >>> y = PolynomialRegression._design_matrix(x, len(coefs) - 1) @ coefs
+ >>> poly_reg = PolynomialRegression(degree=len(coefs) - 1)
+ >>> poly_reg.fit(x, y)
+ >>> np.allclose(poly_reg.params, coefs, atol=10e-3)
+ True
+ """
+ X = PolynomialRegression._design_matrix(x_train, self.degree) # noqa: N806
+ _, cols = X.shape
+ if np.linalg.matrix_rank(X) < cols:
+ raise ArithmeticError(
+ "Design matrix is not full rank, can't compute coefficients"
+ )
+
+ # np.linalg.pinv() computes the Moore–Penrose pseudoinverse using SVD
+ self.params = np.linalg.pinv(X) @ y_train
+
+ def predict(self, data: np.ndarray) -> np.ndarray:
+ """
+ Computes the predicted response values y for the given input data by
+ constructing the design matrix X and evaluating y = Xβ.
+
+ @param data: the predictor values x for prediction
+ @returns: the predicted response values y = Xβ
+ @raises ArithmeticError: if this function is called before the model
+ parameters are fit
+
+ >>> x = np.array([0, 1, 2, 3, 4])
+ >>> y = x**3 - 2 * x**2 + 3 * x - 5
+ >>> poly_reg = PolynomialRegression(degree=3)
+ >>> poly_reg.fit(x, y)
+ >>> poly_reg.predict(np.array([-1]))
+ array([-11.])
+ >>> poly_reg.predict(np.array([-2]))
+ array([-27.])
+ >>> poly_reg.predict(np.array([6]))
+ array([157.])
+ >>> PolynomialRegression(degree=3).predict(x)
+ Traceback (most recent call last):
+ ...
+ ArithmeticError: Predictor hasn't been fit yet
+ """
+ if self.params is None:
+ raise ArithmeticError("Predictor hasn't been fit yet")
+
+ return PolynomialRegression._design_matrix(data, self.degree) @ self.params
+
+
+def main() -> None:
+ """
+ Fit a polynomial regression model to predict fuel efficiency using seaborn's mpg
+ dataset
+
+ >>> pass # Placeholder, function is only for demo purposes
+ """
+ import seaborn as sns
+
+ mpg_data = sns.load_dataset("mpg")
+
+ poly_reg = PolynomialRegression(degree=2)
+ poly_reg.fit(mpg_data.weight, mpg_data.mpg)
+
+ weight_sorted = np.sort(mpg_data.weight)
+ predictions = poly_reg.predict(weight_sorted)
+
+ plt.scatter(mpg_data.weight, mpg_data.mpg, color="gray", alpha=0.5)
+ plt.plot(weight_sorted, predictions, color="red", linewidth=3)
+ plt.title("Predicting Fuel Efficiency Using Polynomial Regression")
+ plt.xlabel("Weight (lbs)")
+ plt.ylabel("Fuel Efficiency (mpg)")
+ plt.show()
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ main()
diff --git a/machine_learning/similarity_search.py b/machine_learning/similarity_search.py
index 72979181f..7a23ec463 100644
--- a/machine_learning/similarity_search.py
+++ b/machine_learning/similarity_search.py
@@ -97,26 +97,29 @@ def similarity_search(
"""
if dataset.ndim != value_array.ndim:
- raise ValueError(
- f"Wrong input data's dimensions... dataset : {dataset.ndim}, "
- f"value_array : {value_array.ndim}"
+ msg = (
+ "Wrong input data's dimensions... "
+ f"dataset : {dataset.ndim}, value_array : {value_array.ndim}"
)
+ raise ValueError(msg)
try:
if dataset.shape[1] != value_array.shape[1]:
- raise ValueError(
- f"Wrong input data's shape... dataset : {dataset.shape[1]}, "
- f"value_array : {value_array.shape[1]}"
+ msg = (
+ "Wrong input data's shape... "
+ f"dataset : {dataset.shape[1]}, value_array : {value_array.shape[1]}"
)
+ raise ValueError(msg)
except IndexError:
if dataset.ndim != value_array.ndim:
raise TypeError("Wrong shape")
if dataset.dtype != value_array.dtype:
- raise TypeError(
- f"Input data have different datatype... dataset : {dataset.dtype}, "
- f"value_array : {value_array.dtype}"
+ msg = (
+ "Input data have different datatype... "
+ f"dataset : {dataset.dtype}, value_array : {value_array.dtype}"
)
+ raise TypeError(msg)
answer = []
diff --git a/machine_learning/support_vector_machines.py b/machine_learning/support_vector_machines.py
index df854cc85..24046115e 100644
--- a/machine_learning/support_vector_machines.py
+++ b/machine_learning/support_vector_machines.py
@@ -74,7 +74,8 @@ class SVC:
# sklear: def_gamma = 1/(n_features * X.var()) (wiki)
# previously it was 1/(n_features)
else:
- raise ValueError(f"Unknown kernel: {kernel}")
+ msg = f"Unknown kernel: {kernel}"
+ raise ValueError(msg)
# kernels
def __linear(self, vector1: ndarray, vector2: ndarray) -> float:
diff --git a/maths/3n_plus_1.py b/maths/3n_plus_1.py
deleted file mode 100644
index 59fdec48e..000000000
--- a/maths/3n_plus_1.py
+++ /dev/null
@@ -1,149 +0,0 @@
-from __future__ import annotations
-
-
-def n31(a: int) -> tuple[list[int], int]:
- """
- Returns the Collatz sequence and its length of any positive integer.
- >>> n31(4)
- ([4, 2, 1], 3)
- """
-
- if not isinstance(a, int):
- raise TypeError(f"Must be int, not {type(a).__name__}")
- if a < 1:
- raise ValueError(f"Given integer must be positive, not {a}")
-
- path = [a]
- while a != 1:
- if a % 2 == 0:
- a //= 2
- else:
- a = 3 * a + 1
- path.append(a)
- return path, len(path)
-
-
-def test_n31():
- """
- >>> test_n31()
- """
- assert n31(4) == ([4, 2, 1], 3)
- assert n31(11) == ([11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1], 15)
- assert n31(31) == (
- [
- 31,
- 94,
- 47,
- 142,
- 71,
- 214,
- 107,
- 322,
- 161,
- 484,
- 242,
- 121,
- 364,
- 182,
- 91,
- 274,
- 137,
- 412,
- 206,
- 103,
- 310,
- 155,
- 466,
- 233,
- 700,
- 350,
- 175,
- 526,
- 263,
- 790,
- 395,
- 1186,
- 593,
- 1780,
- 890,
- 445,
- 1336,
- 668,
- 334,
- 167,
- 502,
- 251,
- 754,
- 377,
- 1132,
- 566,
- 283,
- 850,
- 425,
- 1276,
- 638,
- 319,
- 958,
- 479,
- 1438,
- 719,
- 2158,
- 1079,
- 3238,
- 1619,
- 4858,
- 2429,
- 7288,
- 3644,
- 1822,
- 911,
- 2734,
- 1367,
- 4102,
- 2051,
- 6154,
- 3077,
- 9232,
- 4616,
- 2308,
- 1154,
- 577,
- 1732,
- 866,
- 433,
- 1300,
- 650,
- 325,
- 976,
- 488,
- 244,
- 122,
- 61,
- 184,
- 92,
- 46,
- 23,
- 70,
- 35,
- 106,
- 53,
- 160,
- 80,
- 40,
- 20,
- 10,
- 5,
- 16,
- 8,
- 4,
- 2,
- 1,
- ],
- 107,
- )
-
-
-if __name__ == "__main__":
- num = 4
- path, length = n31(num)
- print(f"The Collatz sequence of {num} took {length} steps. \nPath: {path}")
diff --git a/maths/automorphic_number.py b/maths/automorphic_number.py
index 103fc7301..8ed937563 100644
--- a/maths/automorphic_number.py
+++ b/maths/automorphic_number.py
@@ -40,7 +40,8 @@ def is_automorphic_number(number: int) -> bool:
TypeError: Input value of [number=5.0] must be an integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 0:
return False
number_square = number * number
diff --git a/maths/catalan_number.py b/maths/catalan_number.py
index 85607dc1e..20c2cfb17 100644
--- a/maths/catalan_number.py
+++ b/maths/catalan_number.py
@@ -31,10 +31,12 @@ def catalan(number: int) -> int:
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 1:
- raise ValueError(f"Input value of [number={number}] must be > 0")
+ msg = f"Input value of [number={number}] must be > 0"
+ raise ValueError(msg)
current_number = 1
diff --git a/maths/collatz_sequence.py b/maths/collatz_sequence.py
index 7b3636de6..b47017146 100644
--- a/maths/collatz_sequence.py
+++ b/maths/collatz_sequence.py
@@ -1,43 +1,66 @@
+"""
+The Collatz conjecture is a famous unsolved problem in mathematics. Given a starting
+positive integer, define the following sequence:
+- If the current term n is even, then the next term is n/2.
+- If the current term n is odd, then the next term is 3n + 1.
+The conjecture claims that this sequence will always reach 1 for any starting number.
+
+Other names for this problem include the 3n + 1 problem, the Ulam conjecture, Kakutani's
+problem, the Thwaites conjecture, Hasse's algorithm, the Syracuse problem, and the
+hailstone sequence.
+
+Reference: https://en.wikipedia.org/wiki/Collatz_conjecture
+"""
+
from __future__ import annotations
+from collections.abc import Generator
-def collatz_sequence(n: int) -> list[int]:
+
+def collatz_sequence(n: int) -> Generator[int, None, None]:
"""
- Collatz conjecture: start with any positive integer n. The next term is
- obtained as follows:
- If n term is even, the next term is: n / 2 .
- If n is odd, the next term is: 3 * n + 1.
-
- The conjecture states the sequence will always reach 1 for any starting value n.
- Example:
- >>> collatz_sequence(2.1)
+ Generate the Collatz sequence starting at n.
+ >>> tuple(collatz_sequence(2.1))
Traceback (most recent call last):
...
- Exception: Sequence only defined for natural numbers
- >>> collatz_sequence(0)
+ Exception: Sequence only defined for positive integers
+ >>> tuple(collatz_sequence(0))
Traceback (most recent call last):
...
- Exception: Sequence only defined for natural numbers
- >>> collatz_sequence(43) # doctest: +NORMALIZE_WHITESPACE
- [43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7,
- 22, 11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1]
+ Exception: Sequence only defined for positive integers
+ >>> tuple(collatz_sequence(4))
+ (4, 2, 1)
+ >>> tuple(collatz_sequence(11))
+ (11, 34, 17, 52, 26, 13, 40, 20, 10, 5, 16, 8, 4, 2, 1)
+ >>> tuple(collatz_sequence(31)) # doctest: +NORMALIZE_WHITESPACE
+ (31, 94, 47, 142, 71, 214, 107, 322, 161, 484, 242, 121, 364, 182, 91, 274, 137,
+ 412, 206, 103, 310, 155, 466, 233, 700, 350, 175, 526, 263, 790, 395, 1186, 593,
+ 1780, 890, 445, 1336, 668, 334, 167, 502, 251, 754, 377, 1132, 566, 283, 850, 425,
+ 1276, 638, 319, 958, 479, 1438, 719, 2158, 1079, 3238, 1619, 4858, 2429, 7288, 3644,
+ 1822, 911, 2734, 1367, 4102, 2051, 6154, 3077, 9232, 4616, 2308, 1154, 577, 1732,
+ 866, 433, 1300, 650, 325, 976, 488, 244, 122, 61, 184, 92, 46, 23, 70, 35, 106, 53,
+ 160, 80, 40, 20, 10, 5, 16, 8, 4, 2, 1)
+ >>> tuple(collatz_sequence(43)) # doctest: +NORMALIZE_WHITESPACE
+ (43, 130, 65, 196, 98, 49, 148, 74, 37, 112, 56, 28, 14, 7, 22, 11, 34, 17, 52, 26,
+ 13, 40, 20, 10, 5, 16, 8, 4, 2, 1)
"""
-
if not isinstance(n, int) or n < 1:
- raise Exception("Sequence only defined for natural numbers")
+ raise Exception("Sequence only defined for positive integers")
- sequence = [n]
+ yield n
while n != 1:
- n = 3 * n + 1 if n & 1 else n // 2
- sequence.append(n)
- return sequence
+ if n % 2 == 0:
+ n //= 2
+ else:
+ n = 3 * n + 1
+ yield n
def main():
- n = 43
- sequence = collatz_sequence(n)
+ n = int(input("Your number: "))
+ sequence = tuple(collatz_sequence(n))
print(sequence)
- print(f"collatz sequence from {n} took {len(sequence)} steps.")
+ print(f"Collatz sequence from {n} took {len(sequence)} steps.")
if __name__ == "__main__":
diff --git a/maths/dual_number_automatic_differentiation.py b/maths/dual_number_automatic_differentiation.py
new file mode 100644
index 000000000..f98997c8b
--- /dev/null
+++ b/maths/dual_number_automatic_differentiation.py
@@ -0,0 +1,141 @@
+from math import factorial
+
+"""
+https://en.wikipedia.org/wiki/Automatic_differentiation#Automatic_differentiation_using_dual_numbers
+https://blog.jliszka.org/2013/10/24/exact-numeric-nth-derivatives.html
+
+Note this only works for basic functions, f(x) where the power of x is positive.
+"""
+
+
+class Dual:
+ def __init__(self, real, rank):
+ self.real = real
+ if isinstance(rank, int):
+ self.duals = [1] * rank
+ else:
+ self.duals = rank
+
+ def __repr__(self):
+ return (
+ f"{self.real}+"
+ f"{'+'.join(str(dual)+'E'+str(n+1)for n,dual in enumerate(self.duals))}"
+ )
+
+ def reduce(self):
+ cur = self.duals.copy()
+ while cur[-1] == 0:
+ cur.pop(-1)
+ return Dual(self.real, cur)
+
+ def __add__(self, other):
+ if not isinstance(other, Dual):
+ return Dual(self.real + other, self.duals)
+ s_dual = self.duals.copy()
+ o_dual = other.duals.copy()
+ if len(s_dual) > len(o_dual):
+ o_dual.extend([1] * (len(s_dual) - len(o_dual)))
+ elif len(s_dual) < len(o_dual):
+ s_dual.extend([1] * (len(o_dual) - len(s_dual)))
+ new_duals = []
+ for i in range(len(s_dual)):
+ new_duals.append(s_dual[i] + o_dual[i])
+ return Dual(self.real + other.real, new_duals)
+
+ __radd__ = __add__
+
+ def __sub__(self, other):
+ return self + other * -1
+
+ def __mul__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i * other)
+ return Dual(self.real * other, new_duals)
+ new_duals = [0] * (len(self.duals) + len(other.duals) + 1)
+ for i, item in enumerate(self.duals):
+ for j, jtem in enumerate(other.duals):
+ new_duals[i + j + 1] += item * jtem
+ for k in range(len(self.duals)):
+ new_duals[k] += self.duals[k] * other.real
+ for index in range(len(other.duals)):
+ new_duals[index] += other.duals[index] * self.real
+ return Dual(self.real * other.real, new_duals)
+
+ __rmul__ = __mul__
+
+ def __truediv__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i / other)
+ return Dual(self.real / other, new_duals)
+ raise ValueError
+
+ def __floordiv__(self, other):
+ if not isinstance(other, Dual):
+ new_duals = []
+ for i in self.duals:
+ new_duals.append(i // other)
+ return Dual(self.real // other, new_duals)
+ raise ValueError
+
+ def __pow__(self, n):
+ if n < 0 or isinstance(n, float):
+ raise ValueError("power must be a positive integer")
+ if n == 0:
+ return 1
+ if n == 1:
+ return self
+ x = self
+ for _ in range(n - 1):
+ x *= self
+ return x
+
+
+def differentiate(func, position, order):
+ """
+ >>> differentiate(lambda x: x**2, 2, 2)
+ 2
+ >>> differentiate(lambda x: x**2 * x**4, 9, 2)
+ 196830
+ >>> differentiate(lambda y: 0.5 * (y + 3) ** 6, 3.5, 4)
+ 7605.0
+ >>> differentiate(lambda y: y ** 2, 4, 3)
+ 0
+ >>> differentiate(8, 8, 8)
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires a function as input for func
+ >>> differentiate(lambda x: x **2, "", 1)
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires a float as input for position
+ >>> differentiate(lambda x: x**2, 3, "")
+ Traceback (most recent call last):
+ ...
+ ValueError: differentiate() requires an int as input for order
+ """
+ if not callable(func):
+ raise ValueError("differentiate() requires a function as input for func")
+ if not isinstance(position, (float, int)):
+ raise ValueError("differentiate() requires a float as input for position")
+ if not isinstance(order, int):
+ raise ValueError("differentiate() requires an int as input for order")
+ d = Dual(position, 1)
+ result = func(d)
+ if order == 0:
+ return result.real
+ return result.duals[order - 1] * factorial(order)
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ def f(y):
+ return y**2 * y**4
+
+ print(differentiate(f, 9, 2))
diff --git a/maths/euclidean_distance.py b/maths/euclidean_distance.py
index 22012e92c..9b29b37b0 100644
--- a/maths/euclidean_distance.py
+++ b/maths/euclidean_distance.py
@@ -1,12 +1,12 @@
from __future__ import annotations
+import typing
from collections.abc import Iterable
-from typing import Union
import numpy as np
-Vector = Union[Iterable[float], Iterable[int], np.ndarray]
-VectorOut = Union[np.float64, int, float]
+Vector = typing.Union[Iterable[float], Iterable[int], np.ndarray] # noqa: UP007
+VectorOut = typing.Union[np.float64, int, float] # noqa: UP007
def euclidean_distance(vector_1: Vector, vector_2: Vector) -> VectorOut:
diff --git a/maths/factorial.py b/maths/factorial.py
index bbf0efc01..18cacdef9 100644
--- a/maths/factorial.py
+++ b/maths/factorial.py
@@ -55,7 +55,7 @@ def factorial_recursive(n: int) -> int:
raise ValueError("factorial() only accepts integral values")
if n < 0:
raise ValueError("factorial() not defined for negative values")
- return 1 if n == 0 or n == 1 else n * factorial(n - 1)
+ return 1 if n in {0, 1} else n * factorial(n - 1)
if __name__ == "__main__":
diff --git a/maths/hexagonal_number.py b/maths/hexagonal_number.py
index 28735c638..3677ab95e 100644
--- a/maths/hexagonal_number.py
+++ b/maths/hexagonal_number.py
@@ -36,7 +36,8 @@ def hexagonal(number: int) -> int:
TypeError: Input value of [number=11.0] must be an integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 1:
raise ValueError("Input must be a positive integer")
return number * (2 * number - 1)
diff --git a/maths/is_int_palindrome.py b/maths/is_int_palindrome.py
new file mode 100644
index 000000000..63dc9e213
--- /dev/null
+++ b/maths/is_int_palindrome.py
@@ -0,0 +1,34 @@
+def is_int_palindrome(num: int) -> bool:
+ """
+ Returns whether `num` is a palindrome or not
+ (see for reference https://en.wikipedia.org/wiki/Palindromic_number).
+
+ >>> is_int_palindrome(-121)
+ False
+ >>> is_int_palindrome(0)
+ True
+ >>> is_int_palindrome(10)
+ False
+ >>> is_int_palindrome(11)
+ True
+ >>> is_int_palindrome(101)
+ True
+ >>> is_int_palindrome(120)
+ False
+ """
+ if num < 0:
+ return False
+
+ num_copy: int = num
+ rev_num: int = 0
+ while num > 0:
+ rev_num = rev_num * 10 + (num % 10)
+ num //= 10
+
+ return num_copy == rev_num
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/juggler_sequence.py b/maths/juggler_sequence.py
index 9daba8bc0..7f65d1dff 100644
--- a/maths/juggler_sequence.py
+++ b/maths/juggler_sequence.py
@@ -40,9 +40,11 @@ def juggler_sequence(number: int) -> list[int]:
ValueError: Input value of [number=-1] must be a positive integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 1:
- raise ValueError(f"Input value of [number={number}] must be a positive integer")
+ msg = f"Input value of [number={number}] must be a positive integer"
+ raise ValueError(msg)
sequence = [number]
while number != 1:
if number % 2 == 0:
diff --git a/maths/kadanes.py b/maths/kadanes.py
deleted file mode 100644
index c2ea53a6c..000000000
--- a/maths/kadanes.py
+++ /dev/null
@@ -1,63 +0,0 @@
-"""
-Kadane's algorithm to get maximum subarray sum
-https://medium.com/@rsinghal757/kadanes-algorithm-dynamic-programming-how-and-why-does-it-work-3fd8849ed73d
-https://en.wikipedia.org/wiki/Maximum_subarray_problem
-"""
-test_data: tuple = ([-2, -8, -9], [2, 8, 9], [-1, 0, 1], [0, 0], [])
-
-
-def negative_exist(arr: list) -> int:
- """
- >>> negative_exist([-2,-8,-9])
- -2
- >>> [negative_exist(arr) for arr in test_data]
- [-2, 0, 0, 0, 0]
- """
- arr = arr or [0]
- max_number = arr[0]
- for i in arr:
- if i >= 0:
- return 0
- elif max_number <= i:
- max_number = i
- return max_number
-
-
-def kadanes(arr: list) -> int:
- """
- If negative_exist() returns 0 than this function will execute
- else it will return the value return by negative_exist function
-
- For example: arr = [2, 3, -9, 8, -2]
- Initially we set value of max_sum to 0 and max_till_element to 0 than when
- max_sum is less than max_till particular element it will assign that value to
- max_sum and when value of max_till_sum is less than 0 it will assign 0 to i
- and after that whole process, return the max_sum
- So the output for above arr is 8
-
- >>> kadanes([2, 3, -9, 8, -2])
- 8
- >>> [kadanes(arr) for arr in test_data]
- [-2, 19, 1, 0, 0]
- """
- max_sum = negative_exist(arr)
- if max_sum < 0:
- return max_sum
-
- max_sum = 0
- max_till_element = 0
-
- for i in arr:
- max_till_element += i
- max_sum = max(max_sum, max_till_element)
- max_till_element = max(max_till_element, 0)
- return max_sum
-
-
-if __name__ == "__main__":
- try:
- print("Enter integer values sepatated by spaces")
- arr = [int(x) for x in input().split()]
- print(f"Maximum subarray sum of {arr} is {kadanes(arr)}")
- except ValueError:
- print("Please enter integer values.")
diff --git a/maths/largest_subarray_sum.py b/maths/largest_subarray_sum.py
deleted file mode 100644
index 90f92c712..000000000
--- a/maths/largest_subarray_sum.py
+++ /dev/null
@@ -1,21 +0,0 @@
-from sys import maxsize
-
-
-def max_sub_array_sum(a: list, size: int = 0):
- """
- >>> max_sub_array_sum([-13, -3, -25, -20, -3, -16, -23, -12, -5, -22, -15, -4, -7])
- -3
- """
- size = size or len(a)
- max_so_far = -maxsize - 1
- max_ending_here = 0
- for i in range(0, size):
- max_ending_here = max_ending_here + a[i]
- max_so_far = max(max_so_far, max_ending_here)
- max_ending_here = max(max_ending_here, 0)
- return max_so_far
-
-
-if __name__ == "__main__":
- a = [-13, -3, -25, -20, 1, -16, -23, -12, -5, -22, -15, -4, -7]
- print(("Maximum contiguous sum is", max_sub_array_sum(a, len(a))))
diff --git a/maths/least_common_multiple.py b/maths/least_common_multiple.py
index 621d93720..10cc63ac7 100644
--- a/maths/least_common_multiple.py
+++ b/maths/least_common_multiple.py
@@ -67,7 +67,7 @@ def benchmark():
class TestLeastCommonMultiple(unittest.TestCase):
- test_inputs = [
+ test_inputs = (
(10, 20),
(13, 15),
(4, 31),
@@ -77,8 +77,8 @@ class TestLeastCommonMultiple(unittest.TestCase):
(12, 25),
(10, 25),
(6, 9),
- ]
- expected_results = [20, 195, 124, 210, 1462, 60, 300, 50, 18]
+ )
+ expected_results = (20, 195, 124, 210, 1462, 60, 300, 50, 18)
def test_lcm_function(self):
for i, (first_num, second_num) in enumerate(self.test_inputs):
diff --git a/maths/liouville_lambda.py b/maths/liouville_lambda.py
index 5993efa42..1ed228dd5 100644
--- a/maths/liouville_lambda.py
+++ b/maths/liouville_lambda.py
@@ -33,7 +33,8 @@ def liouville_lambda(number: int) -> int:
TypeError: Input value of [number=11.0] must be an integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 1:
raise ValueError("Input must be a positive integer")
return -1 if len(prime_factors(number)) % 2 else 1
diff --git a/maths/manhattan_distance.py b/maths/manhattan_distance.py
index 2711d4c8c..413991468 100644
--- a/maths/manhattan_distance.py
+++ b/maths/manhattan_distance.py
@@ -15,15 +15,15 @@ def manhattan_distance(point_a: list, point_b: list) -> float:
9.0
>>> manhattan_distance([1,1], None)
Traceback (most recent call last):
- ...
+ ...
ValueError: Missing an input
>>> manhattan_distance([1,1], [2, 2, 2])
Traceback (most recent call last):
- ...
+ ...
ValueError: Both points must be in the same n-dimensional space
>>> manhattan_distance([1,"one"], [2, 2, 2])
Traceback (most recent call last):
- ...
+ ...
TypeError: Expected a list of numbers as input, found str
>>> manhattan_distance(1, [2, 2, 2])
Traceback (most recent call last):
@@ -66,14 +66,14 @@ def _validate_point(point: list[float]) -> None:
if isinstance(point, list):
for item in point:
if not isinstance(item, (int, float)):
- raise TypeError(
- f"Expected a list of numbers as input, "
- f"found {type(item).__name__}"
+ msg = (
+ "Expected a list of numbers as input, found "
+ f"{type(item).__name__}"
)
+ raise TypeError(msg)
else:
- raise TypeError(
- f"Expected a list of numbers as input, found {type(point).__name__}"
- )
+ msg = f"Expected a list of numbers as input, found {type(point).__name__}"
+ raise TypeError(msg)
else:
raise ValueError("Missing an input")
diff --git a/maths/odd_sieve.py b/maths/odd_sieve.py
new file mode 100644
index 000000000..60e92921a
--- /dev/null
+++ b/maths/odd_sieve.py
@@ -0,0 +1,42 @@
+from itertools import compress, repeat
+from math import ceil, sqrt
+
+
+def odd_sieve(num: int) -> list[int]:
+ """
+ Returns the prime numbers < `num`. The prime numbers are calculated using an
+ odd sieve implementation of the Sieve of Eratosthenes algorithm
+ (see for reference https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes).
+
+ >>> odd_sieve(2)
+ []
+ >>> odd_sieve(3)
+ [2]
+ >>> odd_sieve(10)
+ [2, 3, 5, 7]
+ >>> odd_sieve(20)
+ [2, 3, 5, 7, 11, 13, 17, 19]
+ """
+
+ if num <= 2:
+ return []
+ if num == 3:
+ return [2]
+
+ # Odd sieve for numbers in range [3, num - 1]
+ sieve = bytearray(b"\x01") * ((num >> 1) - 1)
+
+ for i in range(3, int(sqrt(num)) + 1, 2):
+ if sieve[(i >> 1) - 1]:
+ i_squared = i**2
+ sieve[(i_squared >> 1) - 1 :: i] = repeat(
+ 0, ceil((num - i_squared) / (i << 1))
+ )
+
+ return [2] + list(compress(range(3, num, 2), sieve))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/primelib.py b/maths/primelib.py
index 81d573706..28b5aee9d 100644
--- a/maths/primelib.py
+++ b/maths/primelib.py
@@ -154,7 +154,7 @@ def prime_factorization(number):
quotient = number
- if number == 0 or number == 1:
+ if number in {0, 1}:
ans.append(number)
# if 'number' not prime then builds the prime factorization of 'number'
diff --git a/maths/pronic_number.py b/maths/pronic_number.py
index 8b554dbbd..cf4d3d2eb 100644
--- a/maths/pronic_number.py
+++ b/maths/pronic_number.py
@@ -41,7 +41,8 @@ def is_pronic(number: int) -> bool:
TypeError: Input value of [number=6.0] must be an integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 0 or number % 2 == 1:
return False
number_sqrt = int(number**0.5)
diff --git a/maths/proth_number.py b/maths/proth_number.py
index ce911473a..47747ed26 100644
--- a/maths/proth_number.py
+++ b/maths/proth_number.py
@@ -29,10 +29,12 @@ def proth(number: int) -> int:
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if number < 1:
- raise ValueError(f"Input value of [number={number}] must be > 0")
+ msg = f"Input value of [number={number}] must be > 0"
+ raise ValueError(msg)
elif number == 1:
return 3
elif number == 2:
diff --git a/maths/radix2_fft.py b/maths/radix2_fft.py
index af98f24f9..2c5cdc004 100644
--- a/maths/radix2_fft.py
+++ b/maths/radix2_fft.py
@@ -167,7 +167,7 @@ class FFT:
f"{coef}*x^{i}" for coef, i in enumerate(self.product)
)
- return "\n".join((a, b, c))
+ return f"{a}\n{b}\n{c}"
# Unit tests
diff --git a/maths/remove_digit.py b/maths/remove_digit.py
new file mode 100644
index 000000000..db14ac902
--- /dev/null
+++ b/maths/remove_digit.py
@@ -0,0 +1,37 @@
+def remove_digit(num: int) -> int:
+ """
+
+ returns the biggest possible result
+ that can be achieved by removing
+ one digit from the given number
+
+ >>> remove_digit(152)
+ 52
+ >>> remove_digit(6385)
+ 685
+ >>> remove_digit(-11)
+ 1
+ >>> remove_digit(2222222)
+ 222222
+ >>> remove_digit("2222222")
+ Traceback (most recent call last):
+ TypeError: only integers accepted as input
+ >>> remove_digit("string input")
+ Traceback (most recent call last):
+ TypeError: only integers accepted as input
+ """
+
+ if not isinstance(num, int):
+ raise TypeError("only integers accepted as input")
+ else:
+ num_str = str(abs(num))
+ num_transpositions = [list(num_str) for char in range(len(num_str))]
+ for index in range(len(num_str)):
+ num_transpositions[index].pop(index)
+ return max(
+ int("".join(list(transposition))) for transposition in num_transpositions
+ )
+
+
+if __name__ == "__main__":
+ __import__("doctest").testmod()
diff --git a/maths/sieve_of_eratosthenes.py b/maths/sieve_of_eratosthenes.py
index 3cd6ce0b4..a0520aa5c 100644
--- a/maths/sieve_of_eratosthenes.py
+++ b/maths/sieve_of_eratosthenes.py
@@ -34,7 +34,8 @@ def prime_sieve(num: int) -> list[int]:
"""
if num <= 0:
- raise ValueError(f"{num}: Invalid input, please enter a positive integer.")
+ msg = f"{num}: Invalid input, please enter a positive integer."
+ raise ValueError(msg)
sieve = [True] * (num + 1)
prime = []
diff --git a/maths/sigmoid_linear_unit.py b/maths/sigmoid_linear_unit.py
index a8ada10dd..0ee09bf82 100644
--- a/maths/sigmoid_linear_unit.py
+++ b/maths/sigmoid_linear_unit.py
@@ -17,7 +17,7 @@ This script is inspired by a corresponding research paper.
import numpy as np
-def sigmoid(vector: np.array) -> np.array:
+def sigmoid(vector: np.ndarray) -> np.ndarray:
"""
Mathematical function sigmoid takes a vector x of K real numbers as input and
returns 1/ (1 + e^-x).
@@ -29,17 +29,15 @@ def sigmoid(vector: np.array) -> np.array:
return 1 / (1 + np.exp(-vector))
-def sigmoid_linear_unit(vector: np.array) -> np.array:
+def sigmoid_linear_unit(vector: np.ndarray) -> np.ndarray:
"""
Implements the Sigmoid Linear Unit (SiLU) or swish function
Parameters:
- vector (np.array): A numpy array consisting of real
- values.
+ vector (np.ndarray): A numpy array consisting of real values
Returns:
- swish_vec (np.array): The input numpy array, after applying
- swish.
+ swish_vec (np.ndarray): The input numpy array, after applying swish
Examples:
>>> sigmoid_linear_unit(np.array([-1.0, 1.0, 2.0]))
diff --git a/maths/simultaneous_linear_equation_solver.py b/maths/simultaneous_linear_equation_solver.py
new file mode 100644
index 000000000..1287b2002
--- /dev/null
+++ b/maths/simultaneous_linear_equation_solver.py
@@ -0,0 +1,142 @@
+"""
+https://en.wikipedia.org/wiki/Augmented_matrix
+
+This algorithm solves simultaneous linear equations of the form
+λa + λb + λc + λd + ... = γ as [λ, λ, λ, λ, ..., γ]
+Where λ & γ are individual coefficients, the no. of equations = no. of coefficients - 1
+
+Note in order to work there must exist 1 equation where all instances of λ and γ != 0
+"""
+
+
+def simplify(current_set: list[list]) -> list[list]:
+ """
+ >>> simplify([[1, 2, 3], [4, 5, 6]])
+ [[1.0, 2.0, 3.0], [0.0, 0.75, 1.5]]
+ >>> simplify([[5, 2, 5], [5, 1, 10]])
+ [[1.0, 0.4, 1.0], [0.0, 0.2, -1.0]]
+ """
+ # Divide each row by magnitude of first term --> creates 'unit' matrix
+ duplicate_set = current_set.copy()
+ for row_index, row in enumerate(duplicate_set):
+ magnitude = row[0]
+ for column_index, column in enumerate(row):
+ if magnitude == 0:
+ current_set[row_index][column_index] = column
+ continue
+ current_set[row_index][column_index] = column / magnitude
+ # Subtract to cancel term
+ first_row = current_set[0]
+ final_set = [first_row]
+ current_set = current_set[1::]
+ for row in current_set:
+ temp_row = []
+ # If first term is 0, it is already in form we want, so we preserve it
+ if row[0] == 0:
+ final_set.append(row)
+ continue
+ for column_index in range(len(row)):
+ temp_row.append(first_row[column_index] - row[column_index])
+ final_set.append(temp_row)
+ # Create next recursion iteration set
+ if len(final_set[0]) != 3:
+ current_first_row = final_set[0]
+ current_first_column = []
+ next_iteration = []
+ for row in final_set[1::]:
+ current_first_column.append(row[0])
+ next_iteration.append(row[1::])
+ resultant = simplify(next_iteration)
+ for i in range(len(resultant)):
+ resultant[i].insert(0, current_first_column[i])
+ resultant.insert(0, current_first_row)
+ final_set = resultant
+ return final_set
+
+
+def solve_simultaneous(equations: list[list]) -> list:
+ """
+ >>> solve_simultaneous([[1, 2, 3],[4, 5, 6]])
+ [-1.0, 2.0]
+ >>> solve_simultaneous([[0, -3, 1, 7],[3, 2, -1, 11],[5, 1, -2, 12]])
+ [6.4, 1.2, 10.6]
+ >>> solve_simultaneous([])
+ Traceback (most recent call last):
+ ...
+ IndexError: solve_simultaneous() requires n lists of length n+1
+ >>> solve_simultaneous([[1, 2, 3],[1, 2]])
+ Traceback (most recent call last):
+ ...
+ IndexError: solve_simultaneous() requires n lists of length n+1
+ >>> solve_simultaneous([[1, 2, 3],["a", 7, 8]])
+ Traceback (most recent call last):
+ ...
+ ValueError: solve_simultaneous() requires lists of integers
+ >>> solve_simultaneous([[0, 2, 3],[4, 0, 6]])
+ Traceback (most recent call last):
+ ...
+ ValueError: solve_simultaneous() requires at least 1 full equation
+ """
+ if len(equations) == 0:
+ raise IndexError("solve_simultaneous() requires n lists of length n+1")
+ _length = len(equations) + 1
+ if any(len(item) != _length for item in equations):
+ raise IndexError("solve_simultaneous() requires n lists of length n+1")
+ for row in equations:
+ if any(not isinstance(column, (int, float)) for column in row):
+ raise ValueError("solve_simultaneous() requires lists of integers")
+ if len(equations) == 1:
+ return [equations[0][-1] / equations[0][0]]
+ data_set = equations.copy()
+ if any(0 in row for row in data_set):
+ temp_data = data_set.copy()
+ full_row = []
+ for row_index, row in enumerate(temp_data):
+ if 0 not in row:
+ full_row = data_set.pop(row_index)
+ break
+ if not full_row:
+ raise ValueError("solve_simultaneous() requires at least 1 full equation")
+ data_set.insert(0, full_row)
+ useable_form = data_set.copy()
+ simplified = simplify(useable_form)
+ simplified = simplified[::-1]
+ solutions: list = []
+ for row in simplified:
+ current_solution = row[-1]
+ if not solutions:
+ if row[-2] == 0:
+ solutions.append(0)
+ continue
+ solutions.append(current_solution / row[-2])
+ continue
+ temp_row = row.copy()[: len(row) - 1 :]
+ while temp_row[0] == 0:
+ temp_row.pop(0)
+ if len(temp_row) == 0:
+ solutions.append(0)
+ continue
+ temp_row = temp_row[1::]
+ temp_row = temp_row[::-1]
+ for column_index, column in enumerate(temp_row):
+ current_solution -= column * solutions[column_index]
+ solutions.append(current_solution)
+ final = []
+ for item in solutions:
+ final.append(float(round(item, 5)))
+ return final[::-1]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ eq = [
+ [2, 1, 1, 1, 1, 4],
+ [1, 2, 1, 1, 1, 5],
+ [1, 1, 2, 1, 1, 6],
+ [1, 1, 1, 2, 1, 7],
+ [1, 1, 1, 1, 2, 8],
+ ]
+ print(solve_simultaneous(eq))
+ print(solve_simultaneous([[4, 2]]))
diff --git a/maths/sylvester_sequence.py b/maths/sylvester_sequence.py
index 114c9dd58..607424c6a 100644
--- a/maths/sylvester_sequence.py
+++ b/maths/sylvester_sequence.py
@@ -31,7 +31,8 @@ def sylvester(number: int) -> int:
if number == 1:
return 2
elif number < 1:
- raise ValueError(f"The input value of [n={number}] has to be > 0")
+ msg = f"The input value of [n={number}] has to be > 0"
+ raise ValueError(msg)
else:
num = sylvester(number - 1)
lower = num - 1
diff --git a/maths/tanh.py b/maths/tanh.py
new file mode 100644
index 000000000..ddab3e1ab
--- /dev/null
+++ b/maths/tanh.py
@@ -0,0 +1,42 @@
+"""
+This script demonstrates the implementation of the tangent hyperbolic
+or tanh function.
+
+The function takes a vector of K real numbers as input and
+then (e^x - e^(-x))/(e^x + e^(-x)). After through tanh, the
+element of the vector mostly -1 between 1.
+
+Script inspired from its corresponding Wikipedia article
+https://en.wikipedia.org/wiki/Activation_function
+"""
+import numpy as np
+
+
+def tangent_hyperbolic(vector: np.array) -> np.array:
+ """
+ Implements the tanh function
+
+ Parameters:
+ vector: np.array
+
+ Returns:
+ tanh (np.array): The input numpy array after applying tanh.
+
+ mathematically (e^x - e^(-x))/(e^x + e^(-x)) can be written as (2/(1+e^(-2x))-1
+
+ Examples:
+ >>> tangent_hyperbolic(np.array([1,5,6,-0.67]))
+ array([ 0.76159416, 0.9999092 , 0.99998771, -0.58497988])
+
+ >>> tangent_hyperbolic(np.array([8,10,2,-0.98,13]))
+ array([ 0.99999977, 1. , 0.96402758, -0.7530659 , 1. ])
+
+ """
+
+ return (2 / (1 + np.exp(-2 * vector))) - 1
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/maths/twin_prime.py b/maths/twin_prime.py
index e6ac0cc78..912b10b36 100644
--- a/maths/twin_prime.py
+++ b/maths/twin_prime.py
@@ -32,7 +32,8 @@ def twin_prime(number: int) -> int:
TypeError: Input value of [number=6.0] must be an integer
"""
if not isinstance(number, int):
- raise TypeError(f"Input value of [number={number}] must be an integer")
+ msg = f"Input value of [number={number}] must be an integer"
+ raise TypeError(msg)
if is_prime(number) and is_prime(number + 2):
return number + 2
else:
diff --git a/matrix/count_negative_numbers_in_sorted_matrix.py b/matrix/count_negative_numbers_in_sorted_matrix.py
new file mode 100644
index 000000000..2799ff3b4
--- /dev/null
+++ b/matrix/count_negative_numbers_in_sorted_matrix.py
@@ -0,0 +1,151 @@
+"""
+Given an matrix of numbers in which all rows and all columns are sorted in decreasing
+order, return the number of negative numbers in grid.
+
+Reference: https://leetcode.com/problems/count-negative-numbers-in-a-sorted-matrix
+"""
+
+
+def generate_large_matrix() -> list[list[int]]:
+ """
+ >>> generate_large_matrix() # doctest: +ELLIPSIS
+ [[1000, ..., -999], [999, ..., -1001], ..., [2, ..., -1998]]
+ """
+ return [list(range(1000 - i, -1000 - i, -1)) for i in range(1000)]
+
+
+grid = generate_large_matrix()
+test_grids = (
+ [[4, 3, 2, -1], [3, 2, 1, -1], [1, 1, -1, -2], [-1, -1, -2, -3]],
+ [[3, 2], [1, 0]],
+ [[7, 7, 6]],
+ [[7, 7, 6], [-1, -2, -3]],
+ grid,
+)
+
+
+def validate_grid(grid: list[list[int]]) -> None:
+ """
+ Validate that the rows and columns of the grid is sorted in decreasing order.
+ >>> for grid in test_grids:
+ ... validate_grid(grid)
+ """
+ assert all(row == sorted(row, reverse=True) for row in grid)
+ assert all(list(col) == sorted(col, reverse=True) for col in zip(*grid))
+
+
+def find_negative_index(array: list[int]) -> int:
+ """
+ Find the smallest negative index
+
+ >>> find_negative_index([0,0,0,0])
+ 4
+ >>> find_negative_index([4,3,2,-1])
+ 3
+ >>> find_negative_index([1,0,-1,-10])
+ 2
+ >>> find_negative_index([0,0,0,-1])
+ 3
+ >>> find_negative_index([11,8,7,-3,-5,-9])
+ 3
+ >>> find_negative_index([-1,-1,-2,-3])
+ 0
+ >>> find_negative_index([5,1,0])
+ 3
+ >>> find_negative_index([-5,-5,-5])
+ 0
+ >>> find_negative_index([0])
+ 1
+ >>> find_negative_index([])
+ 0
+ """
+ left = 0
+ right = len(array) - 1
+
+ # Edge cases such as no values or all numbers are negative.
+ if not array or array[0] < 0:
+ return 0
+
+ while right + 1 > left:
+ mid = (left + right) // 2
+ num = array[mid]
+
+ # Num must be negative and the index must be greater than or equal to 0.
+ if num < 0 and array[mid - 1] >= 0:
+ return mid
+
+ if num >= 0:
+ left = mid + 1
+ else:
+ right = mid - 1
+ # No negative numbers so return the last index of the array + 1 which is the length.
+ return len(array)
+
+
+def count_negatives_binary_search(grid: list[list[int]]) -> int:
+ """
+ An O(m logn) solution that uses binary search in order to find the boundary between
+ positive and negative numbers
+
+ >>> [count_negatives_binary_search(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ total = 0
+ bound = len(grid[0])
+
+ for i in range(len(grid)):
+ bound = find_negative_index(grid[i][:bound])
+ total += bound
+ return (len(grid) * len(grid[0])) - total
+
+
+def count_negatives_brute_force(grid: list[list[int]]) -> int:
+ """
+ This solution is O(n^2) because it iterates through every column and row.
+
+ >>> [count_negatives_brute_force(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ return len([number for row in grid for number in row if number < 0])
+
+
+def count_negatives_brute_force_with_break(grid: list[list[int]]) -> int:
+ """
+ Similar to the brute force solution above but uses break in order to reduce the
+ number of iterations.
+
+ >>> [count_negatives_brute_force_with_break(grid) for grid in test_grids]
+ [8, 0, 0, 3, 1498500]
+ """
+ total = 0
+ for row in grid:
+ for i, number in enumerate(row):
+ if number < 0:
+ total += len(row) - i
+ break
+ return total
+
+
+def benchmark() -> None:
+ """Benchmark our functions next to each other"""
+ from timeit import timeit
+
+ print("Running benchmarks")
+ setup = (
+ "from __main__ import count_negatives_binary_search, "
+ "count_negatives_brute_force, count_negatives_brute_force_with_break, grid"
+ )
+ for func in (
+ "count_negatives_binary_search", # took 0.7727 seconds
+ "count_negatives_brute_force_with_break", # took 4.6505 seconds
+ "count_negatives_brute_force", # took 12.8160 seconds
+ ):
+ time = timeit(f"{func}(grid=grid)", setup=setup, number=500)
+ print(f"{func}() took {time:0.4f} seconds")
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+ benchmark()
diff --git a/matrix/matrix_operation.py b/matrix/matrix_operation.py
index 576094902..f189f1898 100644
--- a/matrix/matrix_operation.py
+++ b/matrix/matrix_operation.py
@@ -70,10 +70,11 @@ def multiply(matrix_a: list[list[int]], matrix_b: list[list[int]]) -> list[list[
rows, cols = _verify_matrix_sizes(matrix_a, matrix_b)
if cols[0] != rows[1]:
- raise ValueError(
- f"Cannot multiply matrix of dimensions ({rows[0]},{cols[0]}) "
- f"and ({rows[1]},{cols[1]})"
+ msg = (
+ "Cannot multiply matrix of dimensions "
+ f"({rows[0]},{cols[0]}) and ({rows[1]},{cols[1]})"
)
+ raise ValueError(msg)
return [
[sum(m * n for m, n in zip(i, j)) for j in zip(*matrix_b)] for i in matrix_a
]
@@ -174,10 +175,11 @@ def _verify_matrix_sizes(
) -> tuple[tuple[int, int], tuple[int, int]]:
shape = _shape(matrix_a) + _shape(matrix_b)
if shape[0] != shape[3] or shape[1] != shape[2]:
- raise ValueError(
- f"operands could not be broadcast together with shape "
+ msg = (
+ "operands could not be broadcast together with shape "
f"({shape[0], shape[1]}), ({shape[2], shape[3]})"
)
+ raise ValueError(msg)
return (shape[0], shape[2]), (shape[1], shape[3])
diff --git a/matrix/sherman_morrison.py b/matrix/sherman_morrison.py
index 39eddfed8..256271e8a 100644
--- a/matrix/sherman_morrison.py
+++ b/matrix/sherman_morrison.py
@@ -173,7 +173,8 @@ class Matrix:
result[r, c] += self[r, i] * another[i, c]
return result
else:
- raise TypeError(f"Unsupported type given for another ({type(another)})")
+ msg = f"Unsupported type given for another ({type(another)})"
+ raise TypeError(msg)
def transpose(self) -> Matrix:
"""
diff --git a/neural_network/activation_functions/exponential_linear_unit.py b/neural_network/activation_functions/exponential_linear_unit.py
new file mode 100644
index 000000000..7a3cf1d84
--- /dev/null
+++ b/neural_network/activation_functions/exponential_linear_unit.py
@@ -0,0 +1,40 @@
+"""
+Implements the Exponential Linear Unit or ELU function.
+
+The function takes a vector of K real numbers and a real number alpha as
+input and then applies the ELU function to each element of the vector.
+
+Script inspired from its corresponding Wikipedia article
+https://en.wikipedia.org/wiki/Rectifier_(neural_networks)
+"""
+
+import numpy as np
+
+
+def exponential_linear_unit(vector: np.ndarray, alpha: float) -> np.ndarray:
+ """
+ Implements the ELU activation function.
+ Parameters:
+ vector: the array containing input of elu activation
+ alpha: hyper-parameter
+ return:
+ elu (np.array): The input numpy array after applying elu.
+
+ Mathematically, f(x) = x, x>0 else (alpha * (e^x -1)), x<=0, alpha >=0
+
+ Examples:
+ >>> exponential_linear_unit(vector=np.array([2.3,0.6,-2,-3.8]), alpha=0.3)
+ array([ 2.3 , 0.6 , -0.25939942, -0.29328877])
+
+ >>> exponential_linear_unit(vector=np.array([-9.2,-0.3,0.45,-4.56]), alpha=0.067)
+ array([-0.06699323, -0.01736518, 0.45 , -0.06629904])
+
+
+ """
+ return np.where(vector > 0, vector, (alpha * (np.exp(vector) - 1)))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/neural_network/input_data.py b/neural_network/input_data.py
index 2a32f0b82..a58e64907 100644
--- a/neural_network/input_data.py
+++ b/neural_network/input_data.py
@@ -198,10 +198,7 @@ class _DataSet:
"""Return the next `batch_size` examples from this data set."""
if fake_data:
fake_image = [1] * 784
- if self.one_hot:
- fake_label = [1] + [0] * 9
- else:
- fake_label = 0
+ fake_label = [1] + [0] * 9 if self.one_hot else 0
return (
[fake_image for _ in range(batch_size)],
[fake_label for _ in range(batch_size)],
@@ -266,9 +263,7 @@ def _maybe_download(filename, work_directory, source_url):
return filepath
-@deprecated(
- None, "Please use alternatives such as:" " tensorflow_datasets.load('mnist')"
-)
+@deprecated(None, "Please use alternatives such as: tensorflow_datasets.load('mnist')")
def read_data_sets(
train_dir,
fake_data=False,
@@ -324,10 +319,11 @@ def read_data_sets(
test_labels = _extract_labels(f, one_hot=one_hot)
if not 0 <= validation_size <= len(train_images):
- raise ValueError(
- f"Validation size should be between 0 and {len(train_images)}. "
- f"Received: {validation_size}."
+ msg = (
+ "Validation size should be between 0 and "
+ f"{len(train_images)}. Received: {validation_size}."
)
+ raise ValueError(msg)
validation_images = train_images[:validation_size]
validation_labels = train_labels[:validation_size]
diff --git a/other/davisb_putnamb_logemannb_loveland.py b/other/davisb_putnamb_logemannb_loveland.py
index a1bea5b39..f5fb103ba 100644
--- a/other/davisb_putnamb_logemannb_loveland.py
+++ b/other/davisb_putnamb_logemannb_loveland.py
@@ -253,7 +253,7 @@ def find_unit_clauses(
unit_symbols = []
for clause in clauses:
if len(clause) == 1:
- unit_symbols.append(list(clause.literals.keys())[0])
+ unit_symbols.append(next(iter(clause.literals.keys())))
else:
f_count, n_count = 0, 0
for literal, value in clause.literals.items():
diff --git a/other/guess_the_number_search.py b/other/guess_the_number_search.py
new file mode 100644
index 000000000..01e8898bb
--- /dev/null
+++ b/other/guess_the_number_search.py
@@ -0,0 +1,165 @@
+"""
+guess the number using lower,higher and the value to find or guess
+
+solution works by dividing lower and higher of number guessed
+
+suppose lower is 0, higher is 1000 and the number to guess is 355
+
+>>> guess_the_number(10, 1000, 17)
+started...
+guess the number : 17
+details : [505, 257, 133, 71, 40, 25, 17]
+
+"""
+
+
+def temp_input_value(
+ min_val: int = 10, max_val: int = 1000, option: bool = True
+) -> int:
+ """
+ Temporary input values for tests
+
+ >>> temp_input_value(option=True)
+ 10
+
+ >>> temp_input_value(option=False)
+ 1000
+
+ >>> temp_input_value(min_val=100, option=True)
+ 100
+
+ >>> temp_input_value(min_val=100, max_val=50)
+ Traceback (most recent call last):
+ ...
+ ValueError: Invalid value for min_val or max_val (min_value < max_value)
+
+ >>> temp_input_value("ten","fifty",1)
+ Traceback (most recent call last):
+ ...
+ AssertionError: Invalid type of value(s) specified to function!
+
+ >>> temp_input_value(min_val=-100, max_val=500)
+ -100
+
+ >>> temp_input_value(min_val=-5100, max_val=-100)
+ -5100
+ """
+ assert (
+ isinstance(min_val, int)
+ and isinstance(max_val, int)
+ and isinstance(option, bool)
+ ), "Invalid type of value(s) specified to function!"
+
+ if min_val > max_val:
+ raise ValueError("Invalid value for min_val or max_val (min_value < max_value)")
+ return min_val if option else max_val
+
+
+def get_avg(number_1: int, number_2: int) -> int:
+ """
+ Return the mid-number(whole) of two integers a and b
+
+ >>> get_avg(10, 15)
+ 12
+
+ >>> get_avg(20, 300)
+ 160
+
+ >>> get_avg("abcd", 300)
+ Traceback (most recent call last):
+ ...
+ TypeError: can only concatenate str (not "int") to str
+
+ >>> get_avg(10.5,50.25)
+ 30
+ """
+ return int((number_1 + number_2) / 2)
+
+
+def guess_the_number(lower: int, higher: int, to_guess: int) -> None:
+ """
+ The `guess_the_number` function that guess the number by some operations
+ and using inner functions
+
+ >>> guess_the_number(10, 1000, 17)
+ started...
+ guess the number : 17
+ details : [505, 257, 133, 71, 40, 25, 17]
+
+ >>> guess_the_number(-10000, 10000, 7)
+ started...
+ guess the number : 7
+ details : [0, 5000, 2500, 1250, 625, 312, 156, 78, 39, 19, 9, 4, 6, 7]
+
+ >>> guess_the_number(10, 1000, "a")
+ Traceback (most recent call last):
+ ...
+ AssertionError: argument values must be type of "int"
+
+ >>> guess_the_number(10, 1000, 5)
+ Traceback (most recent call last):
+ ...
+ ValueError: guess value must be within the range of lower and higher value
+
+ >>> guess_the_number(10000, 100, 5)
+ Traceback (most recent call last):
+ ...
+ ValueError: argument value for lower and higher must be(lower > higher)
+ """
+ assert (
+ isinstance(lower, int) and isinstance(higher, int) and isinstance(to_guess, int)
+ ), 'argument values must be type of "int"'
+
+ if lower > higher:
+ raise ValueError("argument value for lower and higher must be(lower > higher)")
+
+ if not lower < to_guess < higher:
+ raise ValueError(
+ "guess value must be within the range of lower and higher value"
+ )
+
+ def answer(number: int) -> str:
+ """
+ Returns value by comparing with entered `to_guess` number
+ """
+ if number > to_guess:
+ return "high"
+ elif number < to_guess:
+ return "low"
+ else:
+ return "same"
+
+ print("started...")
+
+ last_lowest = lower
+ last_highest = higher
+
+ last_numbers = []
+
+ while True:
+ number = get_avg(last_lowest, last_highest)
+ last_numbers.append(number)
+
+ if answer(number) == "low":
+ last_lowest = number
+ elif answer(number) == "high":
+ last_highest = number
+ else:
+ break
+
+ print(f"guess the number : {last_numbers[-1]}")
+ print(f"details : {last_numbers!s}")
+
+
+def main() -> None:
+ """
+ starting point or function of script
+ """
+ lower = int(input("Enter lower value : ").strip())
+ higher = int(input("Enter high value : ").strip())
+ guess = int(input("Enter value to guess : ").strip())
+ guess_the_number(lower, higher, guess)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/other/h_index.py b/other/h_index.py
new file mode 100644
index 000000000..e91389675
--- /dev/null
+++ b/other/h_index.py
@@ -0,0 +1,71 @@
+"""
+Task:
+Given an array of integers citations where citations[i] is the number of
+citations a researcher received for their ith paper, return compute the
+researcher's h-index.
+
+According to the definition of h-index on Wikipedia: A scientist has an
+index h if h of their n papers have at least h citations each, and the other
+n - h papers have no more than h citations each.
+
+If there are several possible values for h, the maximum one is taken as the
+h-index.
+
+H-Index link: https://en.wikipedia.org/wiki/H-index
+
+Implementation notes:
+Use sorting of array
+
+Leetcode link: https://leetcode.com/problems/h-index/description/
+
+n = len(citations)
+Runtime Complexity: O(n * log(n))
+Space Complexity: O(1)
+
+"""
+
+
+def h_index(citations: list[int]) -> int:
+ """
+ Return H-index of citations
+
+ >>> h_index([3, 0, 6, 1, 5])
+ 3
+ >>> h_index([1, 3, 1])
+ 1
+ >>> h_index([1, 2, 3])
+ 2
+ >>> h_index('test')
+ Traceback (most recent call last):
+ ...
+ ValueError: The citations should be a list of non negative integers.
+ >>> h_index([1,2,'3'])
+ Traceback (most recent call last):
+ ...
+ ValueError: The citations should be a list of non negative integers.
+ >>> h_index([1,2,-3])
+ Traceback (most recent call last):
+ ...
+ ValueError: The citations should be a list of non negative integers.
+ """
+
+ # validate:
+ if not isinstance(citations, list) or not all(
+ isinstance(item, int) and item >= 0 for item in citations
+ ):
+ raise ValueError("The citations should be a list of non negative integers.")
+
+ citations.sort()
+ len_citations = len(citations)
+
+ for i in range(len_citations):
+ if citations[len_citations - 1 - i] <= i:
+ return i
+
+ return len_citations
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/other/maximum_subarray.py b/other/maximum_subarray.py
deleted file mode 100644
index 1c8c8cabc..000000000
--- a/other/maximum_subarray.py
+++ /dev/null
@@ -1,32 +0,0 @@
-from collections.abc import Sequence
-
-
-def max_subarray_sum(nums: Sequence[int]) -> int:
- """Return the maximum possible sum amongst all non - empty subarrays.
-
- Raises:
- ValueError: when nums is empty.
-
- >>> max_subarray_sum([1,2,3,4,-2])
- 10
- >>> max_subarray_sum([-2,1,-3,4,-1,2,1,-5,4])
- 6
- """
- if not nums:
- raise ValueError("Input sequence should not be empty")
-
- curr_max = ans = nums[0]
- nums_len = len(nums)
-
- for i in range(1, nums_len):
- num = nums[i]
- curr_max = max(curr_max + num, num)
- ans = max(curr_max, ans)
-
- return ans
-
-
-if __name__ == "__main__":
- n = int(input("Enter number of elements : ").strip())
- array = list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
- print(max_subarray_sum(array))
diff --git a/other/maximum_subsequence.py b/other/maximum_subsequence.py
new file mode 100644
index 000000000..f81717596
--- /dev/null
+++ b/other/maximum_subsequence.py
@@ -0,0 +1,42 @@
+from collections.abc import Sequence
+
+
+def max_subsequence_sum(nums: Sequence[int] | None = None) -> int:
+ """Return the maximum possible sum amongst all non - empty subsequences.
+
+ Raises:
+ ValueError: when nums is empty.
+
+ >>> max_subsequence_sum([1,2,3,4,-2])
+ 10
+ >>> max_subsequence_sum([-2, -3, -1, -4, -6])
+ -1
+ >>> max_subsequence_sum([])
+ Traceback (most recent call last):
+ . . .
+ ValueError: Input sequence should not be empty
+ >>> max_subsequence_sum()
+ Traceback (most recent call last):
+ . . .
+ ValueError: Input sequence should not be empty
+ """
+ if nums is None or not nums:
+ raise ValueError("Input sequence should not be empty")
+
+ ans = nums[0]
+ for i in range(1, len(nums)):
+ num = nums[i]
+ ans = max(ans, ans + num, num)
+
+ return ans
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
+
+ # Try on a sample input from the user
+ n = int(input("Enter number of elements : ").strip())
+ array = list(map(int, input("\nEnter the numbers : ").strip().split()))[:n]
+ print(max_subsequence_sum(array))
diff --git a/other/nested_brackets.py b/other/nested_brackets.py
index ea48c0a5f..19c6dd53c 100644
--- a/other/nested_brackets.py
+++ b/other/nested_brackets.py
@@ -18,7 +18,7 @@ def is_balanced(s):
stack = []
open_brackets = set({"(", "[", "{"})
closed_brackets = set({")", "]", "}"})
- open_to_closed = dict({"{": "}", "[": "]", "(": ")"})
+ open_to_closed = {"{": "}", "[": "]", "(": ")"}
for i in range(len(s)):
if s[i] in open_brackets:
diff --git a/other/number_container_system.py b/other/number_container_system.py
new file mode 100644
index 000000000..6c95dd0a3
--- /dev/null
+++ b/other/number_container_system.py
@@ -0,0 +1,180 @@
+"""
+A number container system that uses binary search to delete and insert values into
+arrays with O(log n) write times and O(1) read times.
+
+This container system holds integers at indexes.
+
+Further explained in this leetcode problem
+> https://leetcode.com/problems/minimum-cost-tree-from-leaf-values
+"""
+
+
+class NumberContainer:
+ def __init__(self) -> None:
+ # numbermap keys are the number and its values are lists of indexes sorted
+ # in ascending order
+ self.numbermap: dict[int, list[int]] = {}
+ # indexmap keys are an index and it's values are the number at that index
+ self.indexmap: dict[int, int] = {}
+
+ def binary_search_delete(self, array: list | str | range, item: int) -> list[int]:
+ """
+ Removes the item from the sorted array and returns
+ the new array.
+
+ >>> NumberContainer().binary_search_delete([1,2,3], 2)
+ [1, 3]
+ >>> NumberContainer().binary_search_delete([0, 0, 0], 0)
+ [0, 0]
+ >>> NumberContainer().binary_search_delete([-1, -1, -1], -1)
+ [-1, -1]
+ >>> NumberContainer().binary_search_delete([-1, 0], 0)
+ [-1]
+ >>> NumberContainer().binary_search_delete([-1, 0], -1)
+ [0]
+ >>> NumberContainer().binary_search_delete(range(7), 3)
+ [0, 1, 2, 4, 5, 6]
+ >>> NumberContainer().binary_search_delete([1.1, 2.2, 3.3], 2.2)
+ [1.1, 3.3]
+ >>> NumberContainer().binary_search_delete("abcde", "c")
+ ['a', 'b', 'd', 'e']
+ >>> NumberContainer().binary_search_delete([0, -1, 2, 4], 0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Either the item is not in the array or the array was unsorted
+ >>> NumberContainer().binary_search_delete([2, 0, 4, -1, 11], -1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Either the item is not in the array or the array was unsorted
+ >>> NumberContainer().binary_search_delete(125, 1)
+ Traceback (most recent call last):
+ ...
+ TypeError: binary_search_delete() only accepts either a list, range or str
+ """
+ if isinstance(array, (range, str)):
+ array = list(array)
+ elif not isinstance(array, list):
+ raise TypeError(
+ "binary_search_delete() only accepts either a list, range or str"
+ )
+
+ low = 0
+ high = len(array) - 1
+
+ while low <= high:
+ mid = (low + high) // 2
+ if array[mid] == item:
+ array.pop(mid)
+ return array
+ elif array[mid] < item:
+ low = mid + 1
+ else:
+ high = mid - 1
+ raise ValueError(
+ "Either the item is not in the array or the array was unsorted"
+ )
+
+ def binary_search_insert(self, array: list | str | range, index: int) -> list[int]:
+ """
+ Inserts the index into the sorted array
+ at the correct position.
+
+ >>> NumberContainer().binary_search_insert([1,2,3], 2)
+ [1, 2, 2, 3]
+ >>> NumberContainer().binary_search_insert([0,1,3], 2)
+ [0, 1, 2, 3]
+ >>> NumberContainer().binary_search_insert([-5, -3, 0, 0, 11, 103], 51)
+ [-5, -3, 0, 0, 11, 51, 103]
+ >>> NumberContainer().binary_search_insert([-5, -3, 0, 0, 11, 100, 103], 101)
+ [-5, -3, 0, 0, 11, 100, 101, 103]
+ >>> NumberContainer().binary_search_insert(range(10), 4)
+ [0, 1, 2, 3, 4, 4, 5, 6, 7, 8, 9]
+ >>> NumberContainer().binary_search_insert("abd", "c")
+ ['a', 'b', 'c', 'd']
+ >>> NumberContainer().binary_search_insert(131, 23)
+ Traceback (most recent call last):
+ ...
+ TypeError: binary_search_insert() only accepts either a list, range or str
+ """
+ if isinstance(array, (range, str)):
+ array = list(array)
+ elif not isinstance(array, list):
+ raise TypeError(
+ "binary_search_insert() only accepts either a list, range or str"
+ )
+
+ low = 0
+ high = len(array) - 1
+
+ while low <= high:
+ mid = (low + high) // 2
+ if array[mid] == index:
+ # If the item already exists in the array,
+ # insert it after the existing item
+ array.insert(mid + 1, index)
+ return array
+ elif array[mid] < index:
+ low = mid + 1
+ else:
+ high = mid - 1
+
+ # If the item doesn't exist in the array, insert it at the appropriate position
+ array.insert(low, index)
+ return array
+
+ def change(self, index: int, number: int) -> None:
+ """
+ Changes (sets) the index as number
+
+ >>> cont = NumberContainer()
+ >>> cont.change(0, 10)
+ >>> cont.change(0, 20)
+ >>> cont.change(-13, 20)
+ >>> cont.change(-100030, 20032903290)
+ """
+ # Remove previous index
+ if index in self.indexmap:
+ n = self.indexmap[index]
+ if len(self.numbermap[n]) == 1:
+ del self.numbermap[n]
+ else:
+ self.numbermap[n] = self.binary_search_delete(self.numbermap[n], index)
+
+ # Set new index
+ self.indexmap[index] = number
+
+ # Number not seen before or empty so insert number value
+ if number not in self.numbermap:
+ self.numbermap[number] = [index]
+
+ # Here we need to perform a binary search insertion in order to insert
+ # The item in the correct place
+ else:
+ self.numbermap[number] = self.binary_search_insert(
+ self.numbermap[number], index
+ )
+
+ def find(self, number: int) -> int:
+ """
+ Returns the smallest index where the number is.
+
+ >>> cont = NumberContainer()
+ >>> cont.find(10)
+ -1
+ >>> cont.change(0, 10)
+ >>> cont.find(10)
+ 0
+ >>> cont.change(0, 20)
+ >>> cont.find(10)
+ -1
+ >>> cont.find(20)
+ 0
+ """
+ # Simply return the 0th index (smallest) of the indexes found (or -1)
+ return self.numbermap.get(number, [-1])[0]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/other/scoring_algorithm.py b/other/scoring_algorithm.py
index 8e04a8f30..af04f432e 100644
--- a/other/scoring_algorithm.py
+++ b/other/scoring_algorithm.py
@@ -68,7 +68,8 @@ def calculate_each_score(
# weight not 0 or 1
else:
- raise ValueError(f"Invalid weight of {weight:f} provided")
+ msg = f"Invalid weight of {weight:f} provided"
+ raise ValueError(msg)
score_lists.append(score)
diff --git a/physics/altitude_pressure.py b/physics/altitude_pressure.py
new file mode 100644
index 000000000..65307d223
--- /dev/null
+++ b/physics/altitude_pressure.py
@@ -0,0 +1,52 @@
+"""
+Title : Calculate altitude using Pressure
+
+Description :
+ The below algorithm approximates the altitude using Barometric formula
+
+
+"""
+
+
+def get_altitude_at_pressure(pressure: float) -> float:
+ """
+ This method calculates the altitude from Pressure wrt to
+ Sea level pressure as reference .Pressure is in Pascals
+ https://en.wikipedia.org/wiki/Pressure_altitude
+ https://community.bosch-sensortec.com/t5/Question-and-answers/How-to-calculate-the-altitude-from-the-pressure-sensor-data/qaq-p/5702
+
+ H = 44330 * [1 - (P/p0)^(1/5.255) ]
+
+ Where :
+ H = altitude (m)
+ P = measured pressure
+ p0 = reference pressure at sea level 101325 Pa
+
+ Examples:
+ >>> get_altitude_at_pressure(pressure=100_000)
+ 105.47836610778828
+ >>> get_altitude_at_pressure(pressure=101_325)
+ 0.0
+ >>> get_altitude_at_pressure(pressure=80_000)
+ 1855.873388064995
+ >>> get_altitude_at_pressure(pressure=201_325)
+ Traceback (most recent call last):
+ ...
+ ValueError: Value Higher than Pressure at Sea Level !
+ >>> get_altitude_at_pressure(pressure=-80_000)
+ Traceback (most recent call last):
+ ...
+ ValueError: Atmospheric Pressure can not be negative !
+ """
+
+ if pressure > 101325:
+ raise ValueError("Value Higher than Pressure at Sea Level !")
+ if pressure < 0:
+ raise ValueError("Atmospheric Pressure can not be negative !")
+ return 44_330 * (1 - (pressure / 101_325) ** (1 / 5.5255))
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/physics/basic_orbital_capture.py b/physics/basic_orbital_capture.py
new file mode 100644
index 000000000..eeb45e602
--- /dev/null
+++ b/physics/basic_orbital_capture.py
@@ -0,0 +1,178 @@
+from math import pow, sqrt
+
+from scipy.constants import G, c, pi
+
+"""
+These two functions will return the radii of impact for a target object
+of mass M and radius R as well as it's effective cross sectional area σ(sigma).
+That is to say any projectile with velocity v passing within σ, will impact the
+target object with mass M. The derivation of which is given at the bottom
+of this file.
+
+The derivation shows that a projectile does not need to aim directly at the target
+body in order to hit it, as R_capture>R_target. Astronomers refer to the effective
+cross section for capture as σ=π*R_capture**2.
+
+This algorithm does not account for an N-body problem.
+
+"""
+
+
+def capture_radii(
+ target_body_radius: float, target_body_mass: float, projectile_velocity: float
+) -> float:
+ """
+ Input Params:
+ -------------
+ target_body_radius: Radius of the central body SI units: meters | m
+ target_body_mass: Mass of the central body SI units: kilograms | kg
+ projectile_velocity: Velocity of object moving toward central body
+ SI units: meters/second | m/s
+ Returns:
+ --------
+ >>> capture_radii(6.957e8, 1.99e30, 25000.0)
+ 17209590691.0
+ >>> capture_radii(-6.957e8, 1.99e30, 25000.0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Radius cannot be less than 0
+ >>> capture_radii(6.957e8, -1.99e30, 25000.0)
+ Traceback (most recent call last):
+ ...
+ ValueError: Mass cannot be less than 0
+ >>> capture_radii(6.957e8, 1.99e30, c+1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Cannot go beyond speed of light
+
+ Returned SI units:
+ ------------------
+ meters | m
+ """
+
+ if target_body_mass < 0:
+ raise ValueError("Mass cannot be less than 0")
+ if target_body_radius < 0:
+ raise ValueError("Radius cannot be less than 0")
+ if projectile_velocity > c:
+ raise ValueError("Cannot go beyond speed of light")
+
+ escape_velocity_squared = (2 * G * target_body_mass) / target_body_radius
+ capture_radius = target_body_radius * sqrt(
+ 1 + escape_velocity_squared / pow(projectile_velocity, 2)
+ )
+ return round(capture_radius, 0)
+
+
+def capture_area(capture_radius: float) -> float:
+ """
+ Input Param:
+ ------------
+ capture_radius: The radius of orbital capture and impact for a central body of
+ mass M and a projectile moving towards it with velocity v
+ SI units: meters | m
+ Returns:
+ --------
+ >>> capture_area(17209590691)
+ 9.304455331329126e+20
+ >>> capture_area(-1)
+ Traceback (most recent call last):
+ ...
+ ValueError: Cannot have a capture radius less than 0
+
+ Returned SI units:
+ ------------------
+ meters*meters | m**2
+ """
+
+ if capture_radius < 0:
+ raise ValueError("Cannot have a capture radius less than 0")
+ sigma = pi * pow(capture_radius, 2)
+ return round(sigma, 0)
+
+
+if __name__ == "__main__":
+ from doctest import testmod
+
+ testmod()
+
+"""
+Derivation:
+
+Let: Mt=target mass, Rt=target radius, v=projectile_velocity,
+ r_0=radius of projectile at instant 0 to CM of target
+ v_p=v at closest approach,
+ r_p=radius from projectile to target CM at closest approach,
+ R_capture= radius of impact for projectile with velocity v
+
+(1)At time=0 the projectile's energy falling from infinity| E=K+U=0.5*m*(v**2)+0
+
+ E_initial=0.5*m*(v**2)
+
+(2)at time=0 the angular momentum of the projectile relative to CM target|
+ L_initial=m*r_0*v*sin(Θ)->m*r_0*v*(R_capture/r_0)->m*v*R_capture
+
+ L_i=m*v*R_capture
+
+(3)The energy of the projectile at closest approach will be its kinetic energy
+ at closest approach plus gravitational potential energy(-(GMm)/R)|
+ E_p=K_p+U_p->E_p=0.5*m*(v_p**2)-(G*Mt*m)/r_p
+
+ E_p=0.0.5*m*(v_p**2)-(G*Mt*m)/r_p
+
+(4)The angular momentum of the projectile relative to the target at closest
+ approach will be L_p=m*r_p*v_p*sin(Θ), however relative to the target Θ=90°
+ sin(90°)=1|
+
+ L_p=m*r_p*v_p
+(5)Using conservation of angular momentum and energy, we can write a quadratic
+ equation that solves for r_p|
+
+ (a)
+ Ei=Ep-> 0.5*m*(v**2)=0.5*m*(v_p**2)-(G*Mt*m)/r_p-> v**2=v_p**2-(2*G*Mt)/r_p
+
+ (b)
+ Li=Lp-> m*v*R_capture=m*r_p*v_p-> v*R_capture=r_p*v_p-> v_p=(v*R_capture)/r_p
+
+ (c) b plugs int a|
+ v**2=((v*R_capture)/r_p)**2-(2*G*Mt)/r_p->
+
+ v**2-(v**2)*(R_c**2)/(r_p**2)+(2*G*Mt)/r_p=0->
+
+ (v**2)*(r_p**2)+2*G*Mt*r_p-(v**2)*(R_c**2)=0
+
+ (d) Using the quadratic formula, we'll solve for r_p then rearrange to solve to
+ R_capture
+
+ r_p=(-2*G*Mt ± sqrt(4*G^2*Mt^2+ 4(v^4*R_c^2)))/(2*v^2)->
+
+ r_p=(-G*Mt ± sqrt(G^2*Mt+v^4*R_c^2))/v^2->
+
+ r_p<0 is something we can ignore, as it has no physical meaning for our purposes.->
+
+ r_p=(-G*Mt)/v^2 + sqrt(G^2*Mt^2/v^4 + R_c^2)
+
+ (e)We are trying to solve for R_c. We are looking for impact, so we want r_p=Rt
+
+ Rt + G*Mt/v^2 = sqrt(G^2*Mt^2/v^4 + R_c^2)->
+
+ (Rt + G*Mt/v^2)^2 = G^2*Mt^2/v^4 + R_c^2->
+
+ Rt^2 + 2*G*Mt*Rt/v^2 + G^2*Mt^2/v^4 = G^2*Mt^2/v^4 + R_c^2->
+
+ Rt**2 + 2*G*Mt*Rt/v**2 = R_c**2->
+
+ Rt**2 * (1 + 2*G*Mt/Rt *1/v**2) = R_c**2->
+
+ escape velocity = sqrt(2GM/R)= v_escape**2=2GM/R->
+
+ Rt**2 * (1 + v_esc**2/v**2) = R_c**2->
+
+(6)
+ R_capture = Rt * sqrt(1 + v_esc**2/v**2)
+
+Source: Problem Set 3 #8 c.Fall_2017|Honors Astronomy|Professor Rachel Bezanson
+
+Source #2: http://www.nssc.ac.cn/wxzygx/weixin/201607/P020160718380095698873.pdf
+ 8.8 Planetary Rendezvous: Pg.368
+"""
diff --git a/physics/horizontal_projectile_motion.py b/physics/horizontal_projectile_motion.py
index dbde3660f..80f85a1b7 100644
--- a/physics/horizontal_projectile_motion.py
+++ b/physics/horizontal_projectile_motion.py
@@ -147,6 +147,6 @@ if __name__ == "__main__":
# Print results
print()
print("Results: ")
- print(f"Horizontal Distance: {str(horizontal_distance(init_vel, angle))} [m]")
- print(f"Maximum Height: {str(max_height(init_vel, angle))} [m]")
- print(f"Total Time: {str(total_time(init_vel, angle))} [s]")
+ print(f"Horizontal Distance: {horizontal_distance(init_vel, angle)!s} [m]")
+ print(f"Maximum Height: {max_height(init_vel, angle)!s} [m]")
+ print(f"Total Time: {total_time(init_vel, angle)!s} [s]")
diff --git a/physics/newtons_second_law_of_motion.py b/physics/newtons_second_law_of_motion.py
index cb53f8f65..53fab6ce7 100644
--- a/physics/newtons_second_law_of_motion.py
+++ b/physics/newtons_second_law_of_motion.py
@@ -60,7 +60,7 @@ def newtons_second_law_of_motion(mass: float, acceleration: float) -> float:
>>> newtons_second_law_of_motion(2.0, 1)
2.0
"""
- force = float()
+ force = 0.0
try:
force = mass * acceleration
except Exception:
diff --git a/physics/speed_of_sound.py b/physics/speed_of_sound.py
new file mode 100644
index 000000000..a4658366a
--- /dev/null
+++ b/physics/speed_of_sound.py
@@ -0,0 +1,52 @@
+"""
+Title : Calculating the speed of sound
+
+Description :
+ The speed of sound (c) is the speed that a sound wave travels
+ per unit time (m/s). During propagation, the sound wave propagates
+ through an elastic medium. Its SI unit is meter per second (m/s).
+
+ Only longitudinal waves can propagate in liquids and gas other then
+ solid where they also travel in transverse wave. The following Algo-
+ rithem calculates the speed of sound in fluid depanding on the bulk
+ module and the density of the fluid.
+
+ Equation for calculating speed od sound in fluid:
+ c_fluid = (K_s*p)**0.5
+
+ c_fluid: speed of sound in fluid
+ K_s: isentropic bulk modulus
+ p: density of fluid
+
+
+
+Source : https://en.wikipedia.org/wiki/Speed_of_sound
+"""
+
+
+def speed_of_sound_in_a_fluid(density: float, bulk_modulus: float) -> float:
+ """
+ This method calculates the speed of sound in fluid -
+ This is calculated from the other two provided values
+ Examples:
+ Example 1 --> Water 20°C: bulk_moduls= 2.15MPa, density=998kg/m³
+ Example 2 --> Murcery 20°: bulk_moduls= 28.5MPa, density=13600kg/m³
+
+ >>> speed_of_sound_in_a_fluid(bulk_modulus=2.15*10**9, density=998)
+ 1467.7563207952705
+ >>> speed_of_sound_in_a_fluid(bulk_modulus=28.5*10**9, density=13600)
+ 1447.614670861731
+ """
+
+ if density <= 0:
+ raise ValueError("Impossible fluid density")
+ if bulk_modulus <= 0:
+ raise ValueError("Impossible bulk modulus")
+
+ return (bulk_modulus / density) ** 0.5
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/project_euler/problem_009/sol3.py b/project_euler/problem_009/sol3.py
index d299f821d..37340d306 100644
--- a/project_euler/problem_009/sol3.py
+++ b/project_euler/problem_009/sol3.py
@@ -28,12 +28,16 @@ def solution() -> int:
31875000
"""
- return [
- a * b * (1000 - a - b)
- for a in range(1, 999)
- for b in range(a, 999)
- if (a * a + b * b == (1000 - a - b) ** 2)
- ][0]
+ return next(
+ iter(
+ [
+ a * b * (1000 - a - b)
+ for a in range(1, 999)
+ for b in range(a, 999)
+ if (a * a + b * b == (1000 - a - b) ** 2)
+ ]
+ )
+ )
if __name__ == "__main__":
diff --git a/project_euler/problem_054/sol1.py b/project_euler/problem_054/sol1.py
index 9af7aef5a..86dfa5edd 100644
--- a/project_euler/problem_054/sol1.py
+++ b/project_euler/problem_054/sol1.py
@@ -47,18 +47,18 @@ import os
class PokerHand:
"""Create an object representing a Poker Hand based on an input of a
- string which represents the best 5 card combination from the player's hand
+ string which represents the best 5-card combination from the player's hand
and board cards.
Attributes: (read-only)
- hand: string representing the hand consisting of five cards
+ hand: a string representing the hand consisting of five cards
Methods:
compare_with(opponent): takes in player's hand (self) and
opponent's hand (opponent) and compares both hands according to
the rules of Texas Hold'em.
Returns one of 3 strings (Win, Loss, Tie) based on whether
- player's hand is better than opponent's hand.
+ player's hand is better than the opponent's hand.
hand_name(): Returns a string made up of two parts: hand name
and high card.
@@ -66,11 +66,11 @@ class PokerHand:
Supported operators:
Rich comparison operators: <, >, <=, >=, ==, !=
- Supported builtin methods and functions:
+ Supported built-in methods and functions:
list.sort(), sorted()
"""
- _HAND_NAME = [
+ _HAND_NAME = (
"High card",
"One pair",
"Two pairs",
@@ -81,10 +81,10 @@ class PokerHand:
"Four of a kind",
"Straight flush",
"Royal flush",
- ]
+ )
- _CARD_NAME = [
- "", # placeholder as lists are zero indexed
+ _CARD_NAME = (
+ "", # placeholder as tuples are zero-indexed
"One",
"Two",
"Three",
@@ -99,7 +99,7 @@ class PokerHand:
"Queen",
"King",
"Ace",
- ]
+ )
def __init__(self, hand: str) -> None:
"""
@@ -119,10 +119,12 @@ class PokerHand:
For example: "6S 4C KC AS TH"
"""
if not isinstance(hand, str):
- raise TypeError(f"Hand should be of type 'str': {hand!r}")
+ msg = f"Hand should be of type 'str': {hand!r}"
+ raise TypeError(msg)
# split removes duplicate whitespaces so no need of strip
if len(hand.split(" ")) != 5:
- raise ValueError(f"Hand should contain only 5 cards: {hand!r}")
+ msg = f"Hand should contain only 5 cards: {hand!r}"
+ raise ValueError(msg)
self._hand = hand
self._first_pair = 0
self._second_pair = 0
diff --git a/project_euler/problem_068/sol1.py b/project_euler/problem_068/sol1.py
index 772be359f..cf814b001 100644
--- a/project_euler/problem_068/sol1.py
+++ b/project_euler/problem_068/sol1.py
@@ -73,7 +73,8 @@ def solution(gon_side: int = 5) -> int:
if is_magic_gon(numbers):
return int("".join(str(n) for n in numbers))
- raise ValueError(f"Magic {gon_side}-gon ring is impossible")
+ msg = f"Magic {gon_side}-gon ring is impossible"
+ raise ValueError(msg)
def generate_gon_ring(gon_side: int, perm: list[int]) -> list[int]:
diff --git a/project_euler/problem_131/sol1.py b/project_euler/problem_131/sol1.py
index f5302aac8..be3ea9c81 100644
--- a/project_euler/problem_131/sol1.py
+++ b/project_euler/problem_131/sol1.py
@@ -26,10 +26,7 @@ def is_prime(number: int) -> bool:
False
"""
- for divisor in range(2, isqrt(number) + 1):
- if number % divisor == 0:
- return False
- return True
+ return all(number % divisor != 0 for divisor in range(2, isqrt(number) + 1))
def solution(max_prime: int = 10**6) -> int:
diff --git a/pyproject.toml b/pyproject.toml
index 48c3fbd40..f9091fb85 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,3 +1,120 @@
+[tool.ruff]
+ignore = [ # `ruff rule S101` for a description of that rule
+ "ARG001", # Unused function argument `amount` -- FIX ME?
+ "B904", # Within an `except` clause, raise exceptions with `raise ... from err` -- FIX ME
+ "B905", # `zip()` without an explicit `strict=` parameter -- FIX ME
+ "DTZ001", # The use of `datetime.datetime()` without `tzinfo` argument is not allowed -- FIX ME
+ "DTZ005", # The use of `datetime.datetime.now()` without `tzinfo` argument is not allowed -- FIX ME
+ "E741", # Ambiguous variable name 'l' -- FIX ME
+ "EM101", # Exception must not use a string literal, assign to variable first
+ "EXE001", # Shebang is present but file is not executable" -- FIX ME
+ "G004", # Logging statement uses f-string
+ "ICN001", # `matplotlib.pyplot` should be imported as `plt` -- FIX ME
+ "INP001", # File `x/y/z.py` is part of an implicit namespace package. Add an `__init__.py`. -- FIX ME
+ "N999", # Invalid module name -- FIX ME
+ "NPY002", # Replace legacy `np.random.choice` call with `np.random.Generator` -- FIX ME
+ "PGH003", # Use specific rule codes when ignoring type issues -- FIX ME
+ "PLC1901", # `{}` can be simplified to `{}` as an empty string is falsey
+ "PLR5501", # Consider using `elif` instead of `else` -- FIX ME
+ "PLW0120", # `else` clause on loop without a `break` statement -- FIX ME
+ "PLW060", # Using global for `{name}` but no assignment is done -- DO NOT FIX
+ "PLW2901", # PLW2901: Redefined loop variable -- FIX ME
+ "RUF00", # Ambiguous unicode character and other rules
+ "RUF100", # Unused `noqa` directive -- FIX ME
+ "S101", # Use of `assert` detected -- DO NOT FIX
+ "S105", # Possible hardcoded password: 'password'
+ "S113", # Probable use of requests call without timeout -- FIX ME
+ "S311", # Standard pseudo-random generators are not suitable for cryptographic purposes -- FIX ME
+ "SIM102", # Use a single `if` statement instead of nested `if` statements -- FIX ME
+ "SLF001", # Private member accessed: `_Iterator` -- FIX ME
+ "UP038", # Use `X | Y` in `{}` call instead of `(X, Y)` -- DO NOT FIX
+]
+select = [ # https://beta.ruff.rs/docs/rules
+ "A", # flake8-builtins
+ "ARG", # flake8-unused-arguments
+ "ASYNC", # flake8-async
+ "B", # flake8-bugbear
+ "BLE", # flake8-blind-except
+ "C4", # flake8-comprehensions
+ "C90", # McCabe cyclomatic complexity
+ "DTZ", # flake8-datetimez
+ "E", # pycodestyle
+ "EM", # flake8-errmsg
+ "EXE", # flake8-executable
+ "F", # Pyflakes
+ "FA", # flake8-future-annotations
+ "FLY", # flynt
+ "G", # flake8-logging-format
+ "I", # isort
+ "ICN", # flake8-import-conventions
+ "INP", # flake8-no-pep420
+ "INT", # flake8-gettext
+ "ISC", # flake8-implicit-str-concat
+ "N", # pep8-naming
+ "NPY", # NumPy-specific rules
+ "PGH", # pygrep-hooks
+ "PIE", # flake8-pie
+ "PL", # Pylint
+ "PYI", # flake8-pyi
+ "RSE", # flake8-raise
+ "RUF", # Ruff-specific rules
+ "S", # flake8-bandit
+ "SIM", # flake8-simplify
+ "SLF", # flake8-self
+ "T10", # flake8-debugger
+ "TD", # flake8-todos
+ "TID", # flake8-tidy-imports
+ "UP", # pyupgrade
+ "W", # pycodestyle
+ "YTT", # flake8-2020
+ # "ANN", # flake8-annotations # FIX ME?
+ # "COM", # flake8-commas
+ # "D", # pydocstyle -- FIX ME?
+ # "DJ", # flake8-django
+ # "ERA", # eradicate -- DO NOT FIX
+ # "FBT", # flake8-boolean-trap # FIX ME
+ # "PD", # pandas-vet
+ # "PT", # flake8-pytest-style
+ # "PTH", # flake8-use-pathlib # FIX ME
+ # "Q", # flake8-quotes
+ # "RET", # flake8-return # FIX ME?
+ # "T20", # flake8-print
+ # "TCH", # flake8-type-checking
+ # "TRY", # tryceratops
+]
+show-source = true
+target-version = "py311"
+
+[tool.ruff.mccabe] # DO NOT INCREASE THIS VALUE
+max-complexity = 17 # default: 10
+
+[tool.ruff.per-file-ignores]
+"arithmetic_analysis/newton_raphson.py" = ["PGH001"]
+"audio_filters/show_response.py" = ["ARG002"]
+"data_structures/binary_tree/binary_search_tree_recursive.py" = ["BLE001"]
+"data_structures/binary_tree/treap.py" = ["SIM114"]
+"data_structures/hashing/hash_table.py" = ["ARG002"]
+"data_structures/hashing/quadratic_probing.py" = ["ARG002"]
+"data_structures/hashing/tests/test_hash_map.py" = ["BLE001"]
+"data_structures/heap/max_heap.py" = ["SIM114"]
+"graphs/minimum_spanning_tree_prims.py" = ["SIM114"]
+"hashes/enigma_machine.py" = ["BLE001"]
+"machine_learning/decision_tree.py" = ["SIM114"]
+"machine_learning/linear_discriminant_analysis.py" = ["ARG005"]
+"machine_learning/sequential_minimum_optimization.py" = ["SIM115"]
+"matrix/sherman_morrison.py" = ["SIM103", "SIM114"]
+"other/l*u_cache.py" = ["RUF012"]
+"physics/newtons_second_law_of_motion.py" = ["BLE001"]
+"project_euler/problem_099/sol1.py" = ["SIM115"]
+"sorts/external_sort.py" = ["SIM115"]
+
+[tool.ruff.pylint] # DO NOT INCREASE THESE VALUES
+allow-magic-value-types = ["float", "int", "str"]
+max-args = 10 # default: 5
+max-branches = 20 # default: 12
+max-returns = 8 # default: 6
+max-statements = 88 # default: 50
+
[tool.pytest.ini_options]
markers = [
"mat_ops: mark a test as utilizing matrix operations.",
@@ -15,56 +132,3 @@ sort = "Cover"
[tool.codespell]
ignore-words-list = "3rt,ans,crate,damon,fo,followings,hist,iff,kwanza,mater,secant,som,sur,tim,zar"
skip = "./.*,*.json,ciphers/prehistoric_men.txt,project_euler/problem_022/p022_names.txt,pyproject.toml,strings/dictionary.txt,strings/words.txt"
-
-[tool.ruff]
-ignore = [ # `ruff rule S101` for a description of that rule
- "B904", # B904: Within an `except` clause, raise exceptions with `raise ... from err`
- "B905", # B905: `zip()` without an explicit `strict=` parameter
- "E741", # E741: Ambiguous variable name 'l'
- "G004", # G004 Logging statement uses f-string
- "N999", # N999: Invalid module name
- "PLC1901", # PLC1901: `{}` can be simplified to `{}` as an empty string is falsey
- "PLR2004", # PLR2004: Magic value used in comparison
- "PLR5501", # PLR5501: Consider using `elif` instead of `else`
- "PLW0120", # PLW0120: `else` clause on loop without a `break` statement
- "PLW060", # PLW060: Using global for `{name}` but no assignment is done -- DO NOT FIX
- "PLW2901", # PLW2901: Redefined loop variable
- "RUF00", # RUF00: Ambiguous unicode character -- DO NOT FIX
- "RUF100", # RUF100: Unused `noqa` directive
- "S101", # S101: Use of `assert` detected -- DO NOT FIX
- "S105", # S105: Possible hardcoded password: 'password'
- "S113", # S113: Probable use of requests call without timeout
- "S311", # S311: Standard pseudo-random generators are not suitable for cryptographic purposes
- "UP038", # UP038: Use `X | Y` in `{}` call instead of `(X, Y)` -- DO NOT FIX
-]
-select = [ # https://beta.ruff.rs/docs/rules
- "A", # A: builtins
- "B", # B: bugbear
- "C40", # C40: comprehensions
- "C90", # C90: mccabe code complexity
- "E", # E: pycodestyle errors
- "F", # F: pyflakes
- "G", # G: logging format
- "I", # I: isort
- "N", # N: pep8 naming
- "PL", # PL: pylint
- "PIE", # PIE: pie
- "PYI", # PYI: type hinting stub files
- "RUF", # RUF: ruff
- "S", # S: bandit
- "TID", # TID: tidy imports
- "UP", # UP: pyupgrade
- "W", # W: pycodestyle warnings
- "YTT", # YTT: year 2020
-]
-show-source = true
-target-version = "py311"
-
-[tool.ruff.mccabe] # DO NOT INCREASE THIS VALUE
-max-complexity = 17 # default: 10
-
-[tool.ruff.pylint] # DO NOT INCREASE THESE VALUES
-max-args = 10 # default: 5
-max-branches = 20 # default: 12
-max-returns = 8 # default: 6
-max-statements = 88 # default: 50
diff --git a/quantum/bb84.py b/quantum/bb84.py
index 60d64371f..e90a11c2a 100644
--- a/quantum/bb84.py
+++ b/quantum/bb84.py
@@ -64,10 +64,10 @@ def bb84(key_len: int = 8, seed: int | None = None) -> str:
key: The key generated using BB84 protocol.
>>> bb84(16, seed=0)
- '1101101100010000'
+ '0111110111010010'
>>> bb84(8, seed=0)
- '01011011'
+ '10110001'
"""
# Set up the random number generator.
rng = np.random.default_rng(seed=seed)
diff --git a/quantum/quantum_random.py b/quantum/quantum_random.py.DISABLED.txt
similarity index 100%
rename from quantum/quantum_random.py
rename to quantum/quantum_random.py.DISABLED.txt
diff --git a/quantum/ripple_adder_classic.py b/quantum/ripple_adder_classic.py
index b604395bc..2284141cc 100644
--- a/quantum/ripple_adder_classic.py
+++ b/quantum/ripple_adder_classic.py
@@ -107,7 +107,7 @@ def ripple_adder(
res = qiskit.execute(circuit, backend, shots=1).result()
# The result is in binary. Convert it back to int
- return int(list(res.get_counts())[0], 2)
+ return int(next(iter(res.get_counts())), 2)
if __name__ == "__main__":
diff --git a/requirements.txt b/requirements.txt
index acfbc823e..2702523d5 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -9,6 +9,7 @@ pandas
pillow
projectq
qiskit
+qiskit-aer
requests
rich
scikit-fuzzy
diff --git a/scripts/build_directory_md.py b/scripts/build_directory_md.py
index b95be9ebc..24bc00cd0 100755
--- a/scripts/build_directory_md.py
+++ b/scripts/build_directory_md.py
@@ -33,7 +33,7 @@ def print_directory_md(top_dir: str = ".") -> None:
if filepath != old_path:
old_path = print_path(old_path, filepath)
indent = (filepath.count(os.sep) + 1) if filepath else 0
- url = "/".join((filepath, filename)).replace(" ", "%20")
+ url = f"{filepath}/{filename}".replace(" ", "%20")
filename = os.path.splitext(filename.replace("_", " ").title())[0]
print(f"{md_prefix(indent)} [{filename}]({url})")
diff --git a/searches/binary_tree_traversal.py b/searches/binary_tree_traversal.py
index 76e80df25..6fb841af4 100644
--- a/searches/binary_tree_traversal.py
+++ b/searches/binary_tree_traversal.py
@@ -13,11 +13,9 @@ class TreeNode:
self.left = None
-def build_tree():
+def build_tree() -> TreeNode:
print("\n********Press N to stop entering at any point of time********\n")
- check = input("Enter the value of the root node: ").strip().lower() or "n"
- if check == "n":
- return None
+ check = input("Enter the value of the root node: ").strip().lower()
q: queue.Queue = queue.Queue()
tree_node = TreeNode(int(check))
q.put(tree_node)
@@ -37,7 +35,7 @@ def build_tree():
right_node = TreeNode(int(check))
node_found.right = right_node
q.put(right_node)
- return None
+ raise
def pre_order(node: TreeNode) -> None:
@@ -272,7 +270,7 @@ if __name__ == "__main__":
doctest.testmod()
print(prompt("Binary Tree Traversals"))
- node = build_tree()
+ node: TreeNode = build_tree()
print(prompt("Pre Order Traversal"))
pre_order(node)
print(prompt() + "\n")
diff --git a/searches/linear_search.py b/searches/linear_search.py
index 777080d14..ba6e81d6b 100644
--- a/searches/linear_search.py
+++ b/searches/linear_search.py
@@ -15,7 +15,7 @@ def linear_search(sequence: list, target: int) -> int:
:param sequence: a collection with comparable items (as sorted items not required
in Linear Search)
:param target: item value to search
- :return: index of found item or None if item is not found
+ :return: index of found item or -1 if item is not found
Examples:
>>> linear_search([0, 5, 7, 10, 15], 0)
diff --git a/sorts/binary_insertion_sort.py b/sorts/binary_insertion_sort.py
new file mode 100644
index 000000000..8d4102558
--- /dev/null
+++ b/sorts/binary_insertion_sort.py
@@ -0,0 +1,61 @@
+"""
+This is a pure Python implementation of the binary insertion sort algorithm
+
+For doctests run following command:
+python -m doctest -v binary_insertion_sort.py
+or
+python3 -m doctest -v binary_insertion_sort.py
+
+For manual testing run:
+python binary_insertion_sort.py
+"""
+
+
+def binary_insertion_sort(collection: list) -> list:
+ """Pure implementation of the binary insertion sort algorithm in Python
+ :param collection: some mutable ordered collection with heterogeneous
+ comparable items inside
+ :return: the same collection ordered by ascending
+
+ Examples:
+ >>> binary_insertion_sort([0, 4, 1234, 4, 1])
+ [0, 1, 4, 4, 1234]
+ >>> binary_insertion_sort([]) == sorted([])
+ True
+ >>> binary_insertion_sort([-1, -2, -3]) == sorted([-1, -2, -3])
+ True
+ >>> lst = ['d', 'a', 'b', 'e', 'c']
+ >>> binary_insertion_sort(lst) == sorted(lst)
+ True
+ >>> import random
+ >>> collection = random.sample(range(-50, 50), 100)
+ >>> binary_insertion_sort(collection) == sorted(collection)
+ True
+ >>> import string
+ >>> collection = random.choices(string.ascii_letters + string.digits, k=100)
+ >>> binary_insertion_sort(collection) == sorted(collection)
+ True
+ """
+
+ n = len(collection)
+ for i in range(1, n):
+ val = collection[i]
+ low = 0
+ high = i - 1
+
+ while low <= high:
+ mid = (low + high) // 2
+ if val < collection[mid]:
+ high = mid - 1
+ else:
+ low = mid + 1
+ for j in range(i, low, -1):
+ collection[j] = collection[j - 1]
+ collection[low] = val
+ return collection
+
+
+if __name__ == "__main__":
+ user_input = input("Enter numbers separated by a comma:\n").strip()
+ unsorted = [int(item) for item in user_input.split(",")]
+ print(binary_insertion_sort(unsorted))
diff --git a/sorts/bubble_sort.py b/sorts/bubble_sort.py
index aef2da272..7da4362a5 100644
--- a/sorts/bubble_sort.py
+++ b/sorts/bubble_sort.py
@@ -1,4 +1,7 @@
-def bubble_sort(collection):
+from typing import Any
+
+
+def bubble_sort(collection: list[Any]) -> list[Any]:
"""Pure implementation of bubble sort algorithm in Python
:param collection: some mutable ordered collection with heterogeneous
@@ -28,9 +31,9 @@ def bubble_sort(collection):
True
"""
length = len(collection)
- for i in range(length - 1):
+ for i in reversed(range(length)):
swapped = False
- for j in range(length - 1 - i):
+ for j in range(i):
if collection[j] > collection[j + 1]:
swapped = True
collection[j], collection[j + 1] = collection[j + 1], collection[j]
diff --git a/sorts/dutch_national_flag_sort.py b/sorts/dutch_national_flag_sort.py
index 79afefa73..758e3a887 100644
--- a/sorts/dutch_national_flag_sort.py
+++ b/sorts/dutch_national_flag_sort.py
@@ -84,9 +84,8 @@ def dutch_national_flag_sort(sequence: list) -> list:
sequence[mid], sequence[high] = sequence[high], sequence[mid]
high -= 1
else:
- raise ValueError(
- f"The elements inside the sequence must contains only {colors} values"
- )
+ msg = f"The elements inside the sequence must contains only {colors} values"
+ raise ValueError(msg)
return sequence
diff --git a/strings/barcode_validator.py b/strings/barcode_validator.py
index e050cd337..b4f3864e2 100644
--- a/strings/barcode_validator.py
+++ b/strings/barcode_validator.py
@@ -65,7 +65,8 @@ def get_barcode(barcode: str) -> int:
ValueError: Barcode 'dwefgiweuf' has alphabetic characters.
"""
if str(barcode).isalpha():
- raise ValueError(f"Barcode '{barcode}' has alphabetic characters.")
+ msg = f"Barcode '{barcode}' has alphabetic characters."
+ raise ValueError(msg)
elif int(barcode) < 0:
raise ValueError("The entered barcode has a negative value. Try again.")
else:
diff --git a/strings/capitalize.py b/strings/capitalize.py
index 63603aa07..e7e97c2be 100644
--- a/strings/capitalize.py
+++ b/strings/capitalize.py
@@ -17,7 +17,7 @@ def capitalize(sentence: str) -> str:
"""
if not sentence:
return ""
- lower_to_upper = {lc: uc for lc, uc in zip(ascii_lowercase, ascii_uppercase)}
+ lower_to_upper = dict(zip(ascii_lowercase, ascii_uppercase))
return lower_to_upper.get(sentence[0], sentence[0]) + sentence[1:]
diff --git a/strings/is_palindrome.py b/strings/is_palindrome.py
deleted file mode 100644
index 406aa2e8d..000000000
--- a/strings/is_palindrome.py
+++ /dev/null
@@ -1,41 +0,0 @@
-def is_palindrome(s: str) -> bool:
- """
- Determine if the string s is a palindrome.
-
- >>> is_palindrome("A man, A plan, A canal -- Panama!")
- True
- >>> is_palindrome("Hello")
- False
- >>> is_palindrome("Able was I ere I saw Elba")
- True
- >>> is_palindrome("racecar")
- True
- >>> is_palindrome("Mr. Owl ate my metal worm?")
- True
- """
- # Since punctuation, capitalization, and spaces are often ignored while checking
- # palindromes, we first remove them from our string.
- s = "".join(character for character in s.lower() if character.isalnum())
- # return s == s[::-1] the slicing method
- # uses extra spaces we can
- # better with iteration method.
-
- end = len(s) // 2
- n = len(s)
-
- # We need to traverse till half of the length of string
- # as we can get access of the i'th last element from
- # i'th index.
- # eg: [0,1,2,3,4,5] => 4th index can be accessed
- # with the help of 1st index (i==n-i-1)
- # where n is length of string
-
- return all(s[i] == s[n - i - 1] for i in range(end))
-
-
-if __name__ == "__main__":
- s = input("Please enter a string to see if it is a palindrome: ")
- if is_palindrome(s):
- print(f"'{s}' is a palindrome.")
- else:
- print(f"'{s}' is not a palindrome.")
diff --git a/strings/is_spain_national_id.py b/strings/is_spain_national_id.py
index 67f49755f..60d06e123 100644
--- a/strings/is_spain_national_id.py
+++ b/strings/is_spain_national_id.py
@@ -48,7 +48,8 @@ def is_spain_national_id(spanish_id: str) -> bool:
"""
if not isinstance(spanish_id, str):
- raise TypeError(f"Expected string as input, found {type(spanish_id).__name__}")
+ msg = f"Expected string as input, found {type(spanish_id).__name__}"
+ raise TypeError(msg)
spanish_id_clean = spanish_id.replace("-", "").upper()
if len(spanish_id_clean) != 9:
diff --git a/strings/is_srilankan_phone_number.py b/strings/is_srilankan_phone_number.py
index 7bded93f7..6456f85e1 100644
--- a/strings/is_srilankan_phone_number.py
+++ b/strings/is_srilankan_phone_number.py
@@ -22,9 +22,7 @@ def is_sri_lankan_phone_number(phone: str) -> bool:
False
"""
- pattern = re.compile(
- r"^(?:0|94|\+94|0{2}94)" r"7(0|1|2|4|5|6|7|8)" r"(-| |)" r"\d{7}$"
- )
+ pattern = re.compile(r"^(?:0|94|\+94|0{2}94)7(0|1|2|4|5|6|7|8)(-| |)\d{7}$")
return bool(re.search(pattern, phone))
diff --git a/strings/min_cost_string_conversion.py b/strings/min_cost_string_conversion.py
index 089c2532f..0fad0b88c 100644
--- a/strings/min_cost_string_conversion.py
+++ b/strings/min_cost_string_conversion.py
@@ -61,7 +61,7 @@ def assemble_transformation(ops: list[list[str]], i: int, j: int) -> list[str]:
if i == 0 and j == 0:
return []
else:
- if ops[i][j][0] == "C" or ops[i][j][0] == "R":
+ if ops[i][j][0] in {"C", "R"}:
seq = assemble_transformation(ops, i - 1, j - 1)
seq.append(ops[i][j])
return seq
diff --git a/strings/palindrome.py b/strings/palindrome.py
index dd1fe316f..bfdb3ddcf 100644
--- a/strings/palindrome.py
+++ b/strings/palindrome.py
@@ -1,5 +1,7 @@
# Algorithms to determine if a string is palindrome
+from timeit import timeit
+
test_data = {
"MALAYALAM": True,
"String": False,
@@ -33,6 +35,25 @@ def is_palindrome(s: str) -> bool:
return True
+def is_palindrome_traversal(s: str) -> bool:
+ """
+ Return True if s is a palindrome otherwise return False.
+
+ >>> all(is_palindrome_traversal(key) is value for key, value in test_data.items())
+ True
+ """
+ end = len(s) // 2
+ n = len(s)
+
+ # We need to traverse till half of the length of string
+ # as we can get access of the i'th last element from
+ # i'th index.
+ # eg: [0,1,2,3,4,5] => 4th index can be accessed
+ # with the help of 1st index (i==n-i-1)
+ # where n is length of string
+ return all(s[i] == s[n - i - 1] for i in range(end))
+
+
def is_palindrome_recursive(s: str) -> bool:
"""
Return True if s is a palindrome otherwise return False.
@@ -40,7 +61,7 @@ def is_palindrome_recursive(s: str) -> bool:
>>> all(is_palindrome_recursive(key) is value for key, value in test_data.items())
True
"""
- if len(s) <= 1:
+ if len(s) <= 2:
return True
if s[0] == s[len(s) - 1]:
return is_palindrome_recursive(s[1:-1])
@@ -58,9 +79,26 @@ def is_palindrome_slice(s: str) -> bool:
return s == s[::-1]
+def benchmark_function(name: str) -> None:
+ stmt = f"all({name}(key) is value for key, value in test_data.items())"
+ setup = f"from __main__ import test_data, {name}"
+ number = 500000
+ result = timeit(stmt=stmt, setup=setup, number=number)
+ print(f"{name:<35} finished {number:,} runs in {result:.5f} seconds")
+
+
if __name__ == "__main__":
for key, value in test_data.items():
assert is_palindrome(key) is is_palindrome_recursive(key)
assert is_palindrome(key) is is_palindrome_slice(key)
print(f"{key:21} {value}")
print("a man a plan a canal panama")
+
+ # finished 500,000 runs in 0.46793 seconds
+ benchmark_function("is_palindrome_slice")
+ # finished 500,000 runs in 0.85234 seconds
+ benchmark_function("is_palindrome")
+ # finished 500,000 runs in 1.32028 seconds
+ benchmark_function("is_palindrome_recursive")
+ # finished 500,000 runs in 2.08679 seconds
+ benchmark_function("is_palindrome_traversal")
diff --git a/strings/snake_case_to_camel_pascal_case.py b/strings/snake_case_to_camel_pascal_case.py
index 28a28b517..8219337a6 100644
--- a/strings/snake_case_to_camel_pascal_case.py
+++ b/strings/snake_case_to_camel_pascal_case.py
@@ -27,11 +27,11 @@ def snake_to_camel_case(input_str: str, use_pascal: bool = False) -> str:
"""
if not isinstance(input_str, str):
- raise ValueError(f"Expected string as input, found {type(input_str)}")
+ msg = f"Expected string as input, found {type(input_str)}"
+ raise ValueError(msg)
if not isinstance(use_pascal, bool):
- raise ValueError(
- f"Expected boolean as use_pascal parameter, found {type(use_pascal)}"
- )
+ msg = f"Expected boolean as use_pascal parameter, found {type(use_pascal)}"
+ raise ValueError(msg)
words = input_str.split("_")
diff --git a/strings/string_switch_case.py b/strings/string_switch_case.py
new file mode 100644
index 000000000..9a07472df
--- /dev/null
+++ b/strings/string_switch_case.py
@@ -0,0 +1,108 @@
+import re
+
+"""
+general info:
+https://en.wikipedia.org/wiki/Naming_convention_(programming)#Python_and_Ruby
+
+pascal case [ an upper Camel Case ]: https://en.wikipedia.org/wiki/Camel_case
+
+camel case: https://en.wikipedia.org/wiki/Camel_case
+
+kebab case [ can be found in general info ]:
+https://en.wikipedia.org/wiki/Naming_convention_(programming)#Python_and_Ruby
+
+snake case: https://en.wikipedia.org/wiki/Snake_case
+"""
+
+
+# assistant functions
+def split_input(str_: str) -> list:
+ """
+ >>> split_input("one two 31235three4four")
+ [['one', 'two', '31235three4four']]
+ """
+ return [char.split() for char in re.split(r"[^ a-z A-Z 0-9 \s]", str_)]
+
+
+def to_simple_case(str_: str) -> str:
+ """
+ >>> to_simple_case("one two 31235three4four")
+ 'OneTwo31235three4four'
+ """
+ string_split = split_input(str_)
+ return "".join(
+ ["".join([char.capitalize() for char in sub_str]) for sub_str in string_split]
+ )
+
+
+def to_complex_case(text: str, upper: bool, separator: str) -> str:
+ """
+ >>> to_complex_case("one two 31235three4four", True, "_")
+ 'ONE_TWO_31235THREE4FOUR'
+ >>> to_complex_case("one two 31235three4four", False, "-")
+ 'one-two-31235three4four'
+ """
+ try:
+ string_split = split_input(text)
+ if upper:
+ res_str = "".join(
+ [
+ separator.join([char.upper() for char in sub_str])
+ for sub_str in string_split
+ ]
+ )
+ else:
+ res_str = "".join(
+ [
+ separator.join([char.lower() for char in sub_str])
+ for sub_str in string_split
+ ]
+ )
+ return res_str
+ except IndexError:
+ return "not valid string"
+
+
+# main content
+def to_pascal_case(text: str) -> str:
+ """
+ >>> to_pascal_case("one two 31235three4four")
+ 'OneTwo31235three4four'
+ """
+ return to_simple_case(text)
+
+
+def to_camel_case(text: str) -> str:
+ """
+ >>> to_camel_case("one two 31235three4four")
+ 'oneTwo31235three4four'
+ """
+ try:
+ res_str = to_simple_case(text)
+ return res_str[0].lower() + res_str[1:]
+ except IndexError:
+ return "not valid string"
+
+
+def to_snake_case(text: str, upper: bool) -> str:
+ """
+ >>> to_snake_case("one two 31235three4four", True)
+ 'ONE_TWO_31235THREE4FOUR'
+ >>> to_snake_case("one two 31235three4four", False)
+ 'one_two_31235three4four'
+ """
+ return to_complex_case(text, upper, "_")
+
+
+def to_kebab_case(text: str, upper: bool) -> str:
+ """
+ >>> to_kebab_case("one two 31235three4four", True)
+ 'ONE-TWO-31235THREE4FOUR'
+ >>> to_kebab_case("one two 31235three4four", False)
+ 'one-two-31235three4four'
+ """
+ return to_complex_case(text, upper, "-")
+
+
+if __name__ == "__main__":
+ __import__("doctest").testmod()
diff --git a/strings/top_k_frequent_words.py b/strings/top_k_frequent_words.py
new file mode 100644
index 000000000..f3d1e0cd5
--- /dev/null
+++ b/strings/top_k_frequent_words.py
@@ -0,0 +1,101 @@
+"""
+Finds the top K most frequent words from the provided word list.
+
+This implementation aims to show how to solve the problem using the Heap class
+already present in this repository.
+Computing order statistics is, in fact, a typical usage of heaps.
+
+This is mostly shown for educational purposes, since the problem can be solved
+in a few lines using collections.Counter from the Python standard library:
+
+from collections import Counter
+def top_k_frequent_words(words, k_value):
+ return [x[0] for x in Counter(words).most_common(k_value)]
+"""
+
+
+from collections import Counter
+from functools import total_ordering
+
+from data_structures.heap.heap import Heap
+
+
+@total_ordering
+class WordCount:
+ def __init__(self, word: str, count: int) -> None:
+ self.word = word
+ self.count = count
+
+ def __eq__(self, other: object) -> bool:
+ """
+ >>> WordCount('a', 1).__eq__(WordCount('b', 1))
+ True
+ >>> WordCount('a', 1).__eq__(WordCount('a', 1))
+ True
+ >>> WordCount('a', 1).__eq__(WordCount('a', 2))
+ False
+ >>> WordCount('a', 1).__eq__(WordCount('b', 2))
+ False
+ >>> WordCount('a', 1).__eq__(1)
+ NotImplemented
+ """
+ if not isinstance(other, WordCount):
+ return NotImplemented
+ return self.count == other.count
+
+ def __lt__(self, other: object) -> bool:
+ """
+ >>> WordCount('a', 1).__lt__(WordCount('b', 1))
+ False
+ >>> WordCount('a', 1).__lt__(WordCount('a', 1))
+ False
+ >>> WordCount('a', 1).__lt__(WordCount('a', 2))
+ True
+ >>> WordCount('a', 1).__lt__(WordCount('b', 2))
+ True
+ >>> WordCount('a', 2).__lt__(WordCount('a', 1))
+ False
+ >>> WordCount('a', 2).__lt__(WordCount('b', 1))
+ False
+ >>> WordCount('a', 1).__lt__(1)
+ NotImplemented
+ """
+ if not isinstance(other, WordCount):
+ return NotImplemented
+ return self.count < other.count
+
+
+def top_k_frequent_words(words: list[str], k_value: int) -> list[str]:
+ """
+ Returns the `k_value` most frequently occurring words,
+ in non-increasing order of occurrence.
+ In this context, a word is defined as an element in the provided list.
+
+ In case `k_value` is greater than the number of distinct words, a value of k equal
+ to the number of distinct words will be considered, instead.
+
+ >>> top_k_frequent_words(['a', 'b', 'c', 'a', 'c', 'c'], 3)
+ ['c', 'a', 'b']
+ >>> top_k_frequent_words(['a', 'b', 'c', 'a', 'c', 'c'], 2)
+ ['c', 'a']
+ >>> top_k_frequent_words(['a', 'b', 'c', 'a', 'c', 'c'], 1)
+ ['c']
+ >>> top_k_frequent_words(['a', 'b', 'c', 'a', 'c', 'c'], 0)
+ []
+ >>> top_k_frequent_words([], 1)
+ []
+ >>> top_k_frequent_words(['a', 'a'], 2)
+ ['a']
+ """
+ heap: Heap[WordCount] = Heap()
+ count_by_word = Counter(words)
+ heap.build_max_heap(
+ [WordCount(word, count) for word, count in count_by_word.items()]
+ )
+ return [heap.extract_max().word for _ in range(min(k_value, len(count_by_word)))]
+
+
+if __name__ == "__main__":
+ import doctest
+
+ doctest.testmod()
diff --git a/web_programming/convert_number_to_words.py b/web_programming/convert_number_to_words.py
index 1e293df96..dac9e3e38 100644
--- a/web_programming/convert_number_to_words.py
+++ b/web_programming/convert_number_to_words.py
@@ -90,9 +90,7 @@ def convert(number: int) -> str:
else:
addition = ""
if counter in placevalue:
- if current == 0 and ((temp_num % 100) // 10) == 0:
- addition = ""
- else:
+ if current != 0 and ((temp_num % 100) // 10) != 0:
addition = placevalue[counter]
if ((temp_num % 100) // 10) == 1:
words = teens[current] + addition + words
diff --git a/web_programming/currency_converter.py b/web_programming/currency_converter.py
index 69f2a2c4d..3bbcafa8f 100644
--- a/web_programming/currency_converter.py
+++ b/web_programming/currency_converter.py
@@ -8,13 +8,7 @@ import os
import requests
URL_BASE = "https://www.amdoren.com/api/currency.php"
-TESTING = os.getenv("CI", "")
-API_KEY = os.getenv("AMDOREN_API_KEY", "")
-if not API_KEY and not TESTING:
- raise KeyError(
- "API key must be provided in the 'AMDOREN_API_KEY' environment variable."
- )
# Currency and their description
list_of_currencies = """
@@ -175,20 +169,31 @@ ZMW Zambian Kwacha
def convert_currency(
- from_: str = "USD", to: str = "INR", amount: float = 1.0, api_key: str = API_KEY
+ from_: str = "USD", to: str = "INR", amount: float = 1.0, api_key: str = ""
) -> str:
"""https://www.amdoren.com/currency-api/"""
+ # Instead of manually generating parameters
params = locals()
+ # from is a reserved keyword
params["from"] = params.pop("from_")
res = requests.get(URL_BASE, params=params).json()
return str(res["amount"]) if res["error"] == 0 else res["error_message"]
if __name__ == "__main__":
+ TESTING = os.getenv("CI", "")
+ API_KEY = os.getenv("AMDOREN_API_KEY", "")
+
+ if not API_KEY and not TESTING:
+ raise KeyError(
+ "API key must be provided in the 'AMDOREN_API_KEY' environment variable."
+ )
+
print(
convert_currency(
input("Enter from currency: ").strip(),
input("Enter to currency: ").strip(),
float(input("Enter the amount: ").strip()),
+ API_KEY,
)
)
diff --git a/web_programming/fetch_anime_and_play.py b/web_programming/fetch_anime_and_play.py.BROKEN
similarity index 100%
rename from web_programming/fetch_anime_and_play.py
rename to web_programming/fetch_anime_and_play.py.BROKEN
diff --git a/web_programming/reddit.py b/web_programming/reddit.py
index 6a31c81c3..5ca5f828c 100644
--- a/web_programming/reddit.py
+++ b/web_programming/reddit.py
@@ -26,7 +26,8 @@ def get_subreddit_data(
"""
wanted_data = wanted_data or []
if invalid_search_terms := ", ".join(sorted(set(wanted_data) - valid_terms)):
- raise ValueError(f"Invalid search term: {invalid_search_terms}")
+ msg = f"Invalid search term: {invalid_search_terms}"
+ raise ValueError(msg)
response = requests.get(
f"https://reddit.com/r/{subreddit}/{age}.json?limit={limit}",
headers={"User-agent": "A random string"},
diff --git a/web_programming/search_books_by_isbn.py b/web_programming/search_books_by_isbn.py
index abac3c70b..d5d4cfe92 100644
--- a/web_programming/search_books_by_isbn.py
+++ b/web_programming/search_books_by_isbn.py
@@ -22,7 +22,8 @@ def get_openlibrary_data(olid: str = "isbn/0140328726") -> dict:
"""
new_olid = olid.strip().strip("/") # Remove leading/trailing whitespace & slashes
if new_olid.count("/") != 1:
- raise ValueError(f"{olid} is not a valid Open Library olid")
+ msg = f"{olid} is not a valid Open Library olid"
+ raise ValueError(msg)
return requests.get(f"https://openlibrary.org/{new_olid}.json").json()
diff --git a/web_programming/slack_message.py b/web_programming/slack_message.py
index f35aa3ca5..5e97d6b64 100644
--- a/web_programming/slack_message.py
+++ b/web_programming/slack_message.py
@@ -7,10 +7,11 @@ def send_slack_message(message_body: str, slack_url: str) -> None:
headers = {"Content-Type": "application/json"}
response = requests.post(slack_url, json={"text": message_body}, headers=headers)
if response.status_code != 200:
- raise ValueError(
- f"Request to slack returned an error {response.status_code}, "
- f"the response is:\n{response.text}"
+ msg = (
+ "Request to slack returned an error "
+ f"{response.status_code}, the response is:\n{response.text}"
)
+ raise ValueError(msg)
if __name__ == "__main__":
diff --git a/web_programming/world_covid19_stats.py b/web_programming/world_covid19_stats.py
index 1dd1ff6d1..ca81abdc4 100644
--- a/web_programming/world_covid19_stats.py
+++ b/web_programming/world_covid19_stats.py
@@ -22,6 +22,5 @@ def world_covid19_stats(url: str = "https://www.worldometers.info/coronavirus")
if __name__ == "__main__":
- print("\033[1m" + "COVID-19 Status of the World" + "\033[0m\n")
- for key, value in world_covid19_stats().items():
- print(f"{key}\n{value}\n")
+ print("\033[1m COVID-19 Status of the World \033[0m\n")
+ print("\n".join(f"{key}\n{value}" for key, value in world_covid19_stats().items()))