Merge branch 'master' into add-graph-knapsack

Author: Matti02co

.github/workflows/sphinx.yml

@@ -34,7 +34,7 @@ jobs:
       - run: uv sync --group=docs
       - uses: actions/configure-pages@v5
       - run: uv run sphinx-build -c docs . docs/_build/html
-      - uses: actions/upload-pages-artifact@v3
+      - uses: actions/upload-pages-artifact@v4
         with:
           path: docs/_build/html
 

.pre-commit-config.yaml

@@ -16,7 +16,7 @@ repos:
       - id: auto-walrus
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: v0.12.8
+    rev: v0.12.10
     hooks:
       - id: ruff-check
       - id: ruff-format
@@ -47,7 +47,7 @@ repos:
       - id: validate-pyproject
 
   - repo: https://github.com/pre-commit/mirrors-mypy
-    rev: v1.15.0
+    rev: v1.17.1
     hooks:
       - id: mypy
         args:

DIRECTORY.md

@@ -12,6 +12,7 @@
   * [Combination Sum](backtracking/combination_sum.py)
   * [Crossword Puzzle Solver](backtracking/crossword_puzzle_solver.py)
   * [Generate Parentheses](backtracking/generate_parentheses.py)
+  * [Generate Parentheses Iterative](backtracking/generate_parentheses_iterative.py)
   * [Hamiltonian Cycle](backtracking/hamiltonian_cycle.py)
   * [Knight Tour](backtracking/knight_tour.py)
   * [Match Word Pattern](backtracking/match_word_pattern.py)
@@ -174,6 +175,7 @@
 
 ## Data Compression
   * [Burrows Wheeler](data_compression/burrows_wheeler.py)
+  * [Coordinate Compression](data_compression/coordinate_compression.py)
   * [Huffman](data_compression/huffman.py)
   * [Lempel Ziv](data_compression/lempel_ziv.py)
   * [Lempel Ziv Decompress](data_compression/lempel_ziv_decompress.py)
@@ -723,6 +725,7 @@
     * [Secant Method](maths/numerical_analysis/secant_method.py)
     * [Simpson Rule](maths/numerical_analysis/simpson_rule.py)
     * [Square Root](maths/numerical_analysis/square_root.py)
+    * [Weierstrass Method](maths/numerical_analysis/weierstrass_method.py)
   * [Odd Sieve](maths/odd_sieve.py)
   * [Perfect Cube](maths/perfect_cube.py)
   * [Perfect Number](maths/perfect_number.py)
@@ -956,6 +959,7 @@
     * [Sol1](project_euler/problem_009/sol1.py)
     * [Sol2](project_euler/problem_009/sol2.py)
     * [Sol3](project_euler/problem_009/sol3.py)
+    * [Sol4](project_euler/problem_009/sol4.py)
   * Problem 010
     * [Sol1](project_euler/problem_010/sol1.py)
     * [Sol2](project_euler/problem_010/sol2.py)
@@ -1266,6 +1270,7 @@
   * [Comb Sort](sorts/comb_sort.py)
   * [Counting Sort](sorts/counting_sort.py)
   * [Cycle Sort](sorts/cycle_sort.py)
+  * [Cyclic Sort](sorts/cyclic_sort.py)
   * [Double Sort](sorts/double_sort.py)
   * [Dutch National Flag Sort](sorts/dutch_national_flag_sort.py)
   * [Exchange Sort](sorts/exchange_sort.py)
@@ -1296,6 +1301,7 @@
   * [Shell Sort](sorts/shell_sort.py)
   * [Shrink Shell Sort](sorts/shrink_shell_sort.py)
   * [Slowsort](sorts/slowsort.py)
+  * [Stalin Sort](sorts/stalin_sort.py)
   * [Stooge Sort](sorts/stooge_sort.py)
   * [Strand Sort](sorts/strand_sort.py)
   * [Tim Sort](sorts/tim_sort.py)

README.md

@@ -4,6 +4,7 @@
     <img src="https://raw.githubusercontent.com/TheAlgorithms/website/1cd824df116b27029f17c2d1b42d81731f28a920/public/logo.svg" height="100">
   </a>
   <h1><a href="https://github.com/TheAlgorithms/">The Algorithms</a> - Python</h1>
+
 <!-- Labels: -->
   <!-- First row: -->
   <a href="https://gitpod.io/#https://github.com/TheAlgorithms/Python">
@@ -19,6 +20,7 @@
   <a href="https://gitter.im/TheAlgorithms/community">
     <img src="https://img.shields.io/badge/Chat-Gitter-ff69b4.svg?label=Chat&logo=gitter&style=flat-square" height="20" alt="Gitter chat">
   </a>
+
   <!-- Second row: -->
   <br>
   <a href="https://github.com/TheAlgorithms/Python/actions">
@@ -27,23 +29,24 @@
   <a href="https://github.com/pre-commit/pre-commit">
     <img src="https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white&style=flat-square" height="20" alt="pre-commit">
   </a>
-  <a href="https://github.com/psf/black">
-    <img src="https://img.shields.io/static/v1?label=code%20style&message=black&color=black&style=flat-square" height="20" alt="code style: black">
+  <a href="https://docs.astral.sh/ruff/formatter/">
+    <img src="https://img.shields.io/static/v1?label=code%20style&message=ruff&color=black&style=flat-square" height="20" alt="code style: black">
   </a>
+
 <!-- Short description: -->
-  <h3>All algorithms implemented in Python - for education</h3>
+  <h3>All algorithms implemented in Python - for education 📚</h3>
 </div>
 
 Implementations are for learning purposes only. They may be less efficient than the implementations in the Python standard library. Use them at your discretion.
 
-## Getting Started
+## 🚀 Getting Started
 
-Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
+📋 Read through our [Contribution Guidelines](CONTRIBUTING.md) before you contribute.
 
-## Community Channels
+## 🌐 Community Channels
 
 We are on [Discord](https://the-algorithms.com/discord) and [Gitter](https://gitter.im/TheAlgorithms/community)! Community channels are a great way for you to ask questions and get help. Please join us!
 
-## List of Algorithms
+## 📜 List of Algorithms
 
 See our [directory](DIRECTORY.md) for easier navigation and a better overview of the project.

backtracking/combination_sum.py

@@ -47,8 +47,18 @@ def combination_sum(candidates: list, target: int) -> list:
     >>> combination_sum([-8, 2.3, 0], 1)
     Traceback (most recent call last):
         ...
-    RecursionError: maximum recursion depth exceeded
+    ValueError: All elements in candidates must be non-negative
+    >>> combination_sum([], 1)
+    Traceback (most recent call last):
+        ...
+    ValueError: Candidates list should not be empty
     """
+    if not candidates:
+        raise ValueError("Candidates list should not be empty")
+
+    if any(x < 0 for x in candidates):
+        raise ValueError("All elements in candidates must be non-negative")
+
     path = []  # type: list[int]
     answer = []  # type: list[int]
     backtrack(candidates, path, answer, target, 0)

backtracking/generate_parentheses_iterative.py

@@ -0,0 +1,62 @@
+def generate_parentheses_iterative(length: int) -> list:
+    """
+    Generate all valid combinations of parentheses (Iterative Approach).
+
+    The algorithm works as follows:
+    1. Initialize an empty list to store the combinations.
+    2. Initialize a stack to keep track of partial combinations.
+    3. Start with empty string and push it onstack along with the counts of '(' and ')'.
+    4. While the stack is not empty:
+        a. Pop a partial combination and its open and close counts from the stack.
+        b. If the combination length is equal to 2*length, add it to the result.
+        c. If open count < length, push new combination with added '(' on stack.
+        d. If close count < open count, push new combination with added ')' on stack.
+    5. Return the result containing all valid combinations.
+
+    Args:
+        length: The desired length of the parentheses combinations
+
+    Returns:
+        A list of strings representing valid combinations of parentheses
+
+    Time Complexity:
+        O(2^(2*length))
+
+    Space Complexity:
+        O(2^(2*length))
+
+    >>> generate_parentheses_iterative(3)
+    ['()()()', '()(())', '(())()', '(()())', '((()))']
+    >>> generate_parentheses_iterative(2)
+    ['()()', '(())']
+    >>> generate_parentheses_iterative(1)
+    ['()']
+    >>> generate_parentheses_iterative(0)
+    ['']
+    """
+    result = []
+    stack = []
+
+    # Each element in stack is a tuple (current_combination, open_count, close_count)
+    stack.append(("", 0, 0))
+
+    while stack:
+        current_combination, open_count, close_count = stack.pop()
+
+        if len(current_combination) == 2 * length:
+            result.append(current_combination)
+
+        if open_count < length:
+            stack.append((current_combination + "(", open_count + 1, close_count))
+
+        if close_count < open_count:
+            stack.append((current_combination + ")", open_count, close_count + 1))
+
+    return result
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()
+    print(generate_parentheses_iterative(3))

bit_manipulation/reverse_bits.py

@@ -1,83 +1,83 @@
 def get_reverse_bit_string(number: int) -> str:
     """
-    return the bit string of an integer
+    Return the reverse bit string of a 32 bit integer
 
     >>> get_reverse_bit_string(9)
     '10010000000000000000000000000000'
     >>> get_reverse_bit_string(43)
     '11010100000000000000000000000000'
     >>> get_reverse_bit_string(2873)
     '10011100110100000000000000000000'
+    >>> get_reverse_bit_string(2550136832)
+    '00000000000000000000000000011001'
     >>> get_reverse_bit_string("this is not a number")
     Traceback (most recent call last):
         ...
-    TypeError: operation can not be conducted on a object of type str
+    TypeError: operation can not be conducted on an object of type str
     """
     if not isinstance(number, int):
         msg = (
-            "operation can not be conducted on a object of type "
+            "operation can not be conducted on an object of type "
             f"{type(number).__name__}"
         )
         raise TypeError(msg)
     bit_string = ""
     for _ in range(32):
         bit_string += str(number % 2)
-        number = number >> 1
+        number >>= 1
     return bit_string
 
 
-def reverse_bit(number: int) -> str:
+def reverse_bit(number: int) -> int:
     """
-    Take in an 32 bit integer, reverse its bits,
-    return a string of reverse bits
-
-    result of a reverse_bit and operation on the integer provided.
+    Take in a 32 bit integer, reverse its bits, return a 32 bit integer result
 
     >>> reverse_bit(25)
-    '00000000000000000000000000011001'
+    2550136832
     >>> reverse_bit(37)
-    '00000000000000000000000000100101'
+    2751463424
     >>> reverse_bit(21)
-    '00000000000000000000000000010101'
+    2818572288
     >>> reverse_bit(58)
-    '00000000000000000000000000111010'
+    1543503872
     >>> reverse_bit(0)
-    '00000000000000000000000000000000'
+    0
     >>> reverse_bit(256)
-    '00000000000000000000000100000000'
+    8388608
+    >>> reverse_bit(2550136832)
+    25
     >>> reverse_bit(-1)
     Traceback (most recent call last):
         ...
-    ValueError: the value of input must be positive
+    ValueError: The value of input must be non-negative
 
     >>> reverse_bit(1.1)
     Traceback (most recent call last):
         ...
-    TypeError: Input value must be a 'int' type
+    TypeError: Input value must be an 'int' type
 
     >>> reverse_bit("0")
     Traceback (most recent call last):
         ...
-    TypeError: '<' not supported between instances of 'str' and 'int'
+    TypeError: Input value must be an 'int' type
     """
+    if not isinstance(number, int):
+        raise TypeError("Input value must be an 'int' type")
     if number < 0:
-        raise ValueError("the value of input must be positive")
-    elif isinstance(number, float):
-        raise TypeError("Input value must be a 'int' type")
-    elif isinstance(number, str):
-        raise TypeError("'<' not supported between instances of 'str' and 'int'")
+        raise ValueError("The value of input must be non-negative")
+
     result = 0
-    # iterator over [1 to 32],since we are dealing with 32 bit integer
-    for _ in range(1, 33):
+    # iterator over [0 to 31], since we are dealing with a 32 bit integer
+    for _ in range(32):
         # left shift the bits by unity
-        result = result << 1
+        result <<= 1
         # get the end bit
-        end_bit = number % 2
+        end_bit = number & 1
         # right shift the bits by unity
-        number = number >> 1
-        # add that bit to our ans
-        result = result | end_bit
-    return get_reverse_bit_string(result)
+        number >>= 1
+        # add that bit to our answer
+        result |= end_bit
+    return result
 
 
 if __name__ == "__main__":

blockchain/README.md

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