Merge branch 'master' into activity_selection_new_algo2

Author: cclauss

DIRECTORY.md

@@ -886,6 +886,7 @@
     * [Nevilles Method](maths/numerical_analysis/nevilles_method.py)
     * [Newton Forward Interpolation](maths/numerical_analysis/newton_forward_interpolation.py)
     * [Newton Raphson](maths/numerical_analysis/newton_raphson.py)
+    * [Nth Root](maths/numerical_analysis/nth_root.py)
     * [Numerical Integration](maths/numerical_analysis/numerical_integration.py)
     * [Proper Fractions](maths/numerical_analysis/proper_fractions.py)
     * [Runge Kutta](maths/numerical_analysis/runge_kutta.py)
@@ -1593,6 +1594,7 @@
   * [Knuth Morris Pratt](strings/knuth_morris_pratt.py)
   * [Largest Smallest Words](strings/largest_smallest_words.py)
   * [Levenshtein Distance](strings/levenshtein_distance.py)
+  * [Longest Word In Sentence](strings/longest_word_in_sentence.py)
   * [Lower](strings/lower.py)
   * [Manacher](strings/manacher.py)
   * [Min Cost String Conversion](strings/min_cost_string_conversion.py)

maths/fermat_little_theorem.py

@@ -5,15 +5,25 @@
 # Wikipedia reference: https://en.wikipedia.org/wiki/Fermat%27s_little_theorem
 
 
-def binary_exponentiation(a: int, n: float, mod: int) -> int:
+def binary_exponentiation(a: int, n: int, mod: int) -> int:
+    """
+    Calculate (a ** n) % mod using binary exponentiation, which runs in O(log n) time.
+
+    >>> binary_exponentiation(2, 10, 17)
+    4
+    >>> binary_exponentiation(3, 0, 5)
+    1
+    >>> binary_exponentiation(5, 3, 13)
+    8
+    """
     if n == 0:
         return 1
 
     elif n % 2 == 1:
         return (binary_exponentiation(a, n - 1, mod) * a) % mod
 
     else:
-        b = binary_exponentiation(a, n / 2, mod)
+        b = binary_exponentiation(a, n // 2, mod)
         return (b * b) % mod
 
 

maths/numerical_analysis/nth_root.py

@@ -0,0 +1,155 @@
+"""
+Approximate the nth root of a real number using Newton's Method.
+
+The nth root of a real number R can be computed with Newton's method,
+which starts with an initial guess x_0 and then iterates using the
+recurrence relation:
+
+x_{k + 1} = x_k - ((x_k)**n - R)/(n*(x_k)**(n-1))
+
+The recurrence relation can be rewritten for computational efficiency:
+
+x_{k + 1} = (n-1)/n*x_k + R/(n*(x_k)**(n-1))
+
+Given a tolerance TOL, a stopping criterion can be set as:
+
+abs(x_{k + 1} - x_k) < TOL
+
+References:
+- https://en.wikipedia.org/wiki/Nth_root#Using_Newton's_method
+- Sauer, T. (2011): Numerical analysis.
+    USA. Addison-Wesley Publishing Company.
+"""
+
+from math import pow  # noqa: A004
+
+
+def nth_root(radicand: float, index: int, tolerance: float = 0.0001) -> float:
+    """
+    Approximate the nth root of the radicand for the given index
+
+    Args:
+        radicand: number from which the root is taken
+        index: positive integer which is the degree of the root
+        tolerance: positive real number that establishes the stopping criterion
+
+    Returns:
+        new_approximation: approximation of the nth root of the radicand for the
+        given index
+
+    Raises:
+        TypeError: radicand is not a real number
+        TypeError: index is not an integer
+        ValueError: index is not a positive integer
+        TypeError: tolerance is not a real number
+        ValueError: tolerance is not a positive real number
+        ValueError: math domain error
+
+    >>> round(nth_root(9, 2),1)
+    3.0
+
+    >>> int(round(nth_root(-8, 3, 0.001)))
+    -2
+
+    >>> int(round(nth_root(256, 4, 0.001)))
+    4
+
+    >>> round(nth_root(2, 2), 5)
+    1.41421
+
+    >>> round(nth_root(0.25, 2, 0.00000001), 1)
+    0.5
+
+    >>> round(nth_root(-8/27, 3, 0.0000001), 5)
+    -0.66667
+
+    >>> nth_root(0, 2, 0.1)
+    0.0
+
+    >>> nth_root(0.0, 5)
+    0.0
+
+    >>> all(abs(nth_root(k, k, 0.00000001) - k**(1/k)) <= 1e-10 for k in range(1,10))
+    True
+
+    >>> nth_root('invalid input', 3, 0.0001)
+    Traceback (most recent call last):
+        ...
+    TypeError: radicand must be a real number, not a str
+
+    >>> nth_root(4, 0.5, 0.0001)
+    Traceback (most recent call last):
+        ...
+    TypeError: index must be an integer, not a float
+
+    >>> nth_root(16, -4, 0.001)
+    Traceback (most recent call last):
+        ...
+    ValueError: index must be a positive integer, -4 <= 0
+
+    >>> nth_root(4, 2, '0.000001')
+    Traceback (most recent call last):
+        ...
+    TypeError: tolerance must be a real number, not str
+
+    >>> nth_root(9, 2, -0.01)
+    Traceback (most recent call last):
+        ...
+    ValueError: tolerance must be a positive real number, -0.01 <= 0
+
+    >>> nth_root(-256, 4, 0.0001)
+    Traceback (most recent call last):
+        ...
+    ValueError: math domain error, radicand must be nonnegative for even index
+    """
+    if not isinstance(radicand, (int, float)):
+        error_message = (
+            f"radicand must be a real number, not a {type(radicand).__name__}"
+        )
+        raise TypeError(error_message)
+
+    if not isinstance(index, int):
+        error_message = f"index must be an integer, not a {type(index).__name__}"
+        raise TypeError(error_message)
+
+    if index <= 0:
+        error_message = f"index must be a positive integer, {index} <= 0"
+        raise ValueError(error_message)
+
+    if not isinstance(tolerance, (int, float)):
+        error_message = (
+            f"tolerance must be a real number, not {type(tolerance).__name__}"
+        )
+        raise TypeError(error_message)
+
+    if tolerance <= 0:
+        error_message = f"tolerance must be a positive real number, {tolerance} <= 0"
+        raise ValueError(error_message)
+
+    if radicand < 0 and index % 2 == 0:
+        error_message = "math domain error, radicand must be nonnegative for even index"
+        raise ValueError(error_message)
+
+    if radicand == 0.0:
+        return 0.0
+
+    # Set initial guess
+    new_approximation = radicand
+    # Set old_approximation to enter the loop
+    old_approximation = new_approximation + tolerance + 0.1
+
+    # Iterate as long as the stop criterion is not satisfied
+    while tolerance <= abs(old_approximation - new_approximation):
+        old_approximation = new_approximation
+        # Compute new_approximation with the recurrence relation described above
+        first_summand = (index - 1) / index * old_approximation
+        second_summand = radicand / (index * pow(old_approximation, index - 1))
+        new_approximation = first_summand + second_summand
+
+    return new_approximation
+
+
+if __name__ == "__main__":
+    import doctest
+
+    doctest.testmod()

pyproject.toml

@@ -22,7 +22,6 @@ dependencies = [
   "numpy>=2.1.3",
   "pandas>=2.3.3",
   "pillow>=11.3",
-  "polars>=1.44.2",
   "rich>=13.9.4",
   "scikit-learn>=1.9.1",
   "scipy>=1.18.1",

sorts/reversort.py

@@ -17,10 +17,14 @@
 python reversort.py
 """
 
-from typing import Any
+from typing import Any, Protocol
 
 
-def reversort(collection: list[Any]) -> list[Any]:
+class Comparable(Protocol):
+    def __lt__(self, other: Any, /) -> bool: ...
+
+
+def reversort[T: Comparable](collection: list[T]) -> list[T]:
     """
     Sort a list using the Reversort algorithm.
 
@@ -78,6 +82,10 @@ def reversort(collection: list[Any]) -> list[Any]:
     >>> collection_arg = random.choices(string.ascii_letters + string.digits, k=100)
     >>> reversort(collection_arg) == sorted(collection_arg)
     True
+    >>> reversort([1, "a"])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
     """
     arr = collection[:]  # Create a copy to avoid modifying the original
     n = len(arr)
@@ -96,7 +104,7 @@ def reversort(collection: list[Any]) -> list[Any]:
     return arr
 
 
-def reversort_cost(collection: list[Any]) -> int:
+def reversort_cost[T: Comparable](collection: list[T]) -> int:
     """
     Calculate the cost of sorting using Reversort.
 
@@ -119,6 +127,10 @@ def reversort_cost(collection: list[Any]) -> int:
     0
     >>> reversort_cost([])
     0
+    >>> reversort_cost([1, "a"])  # doctest: +IGNORE_EXCEPTION_DETAIL
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'str' and 'int'
     """
     arr = collection[:]  # Create a copy to avoid modifying the original
     n = len(arr)

strings/longest_word_in_sentence.py

@@ -0,0 +1,30 @@
+def longest_word(sentence: str) -> str:
+    """
+    Finds the longest word in a sentence.
+    >>> longest_word("The quick brown fox jumped over the lazy dog")
+    'jumped'
+    >>> longest_word("Python is amazing")
+    'amazing'
+    >>> longest_word("")
+    ''
+    >>> longest_word("a")
+    'a'
+    >>> longest_word("A journey of a thousand miles begins with a single step")
+    'thousand'
+    >>> longest_word("To be or not to be that is the question")
+    'question'
+    >>> longest_word("Beauty is in the eye of the beholder")
+    'beholder'
+    >>> longest_word("A picture is worth a thousand words")
+    'thousand'
+    >>> longest_word("All that glitters is not gold")
+    'glitters'
+    """
+    words = sentence.split()
+    return max(words, key=len) if words else ""
+
+
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()

tests/test_sorts.py

@@ -41,6 +41,7 @@
 from sorts.patience_sort import patience_sort
 from sorts.quick_sort import quick_sort
 from sorts.recursive_insertion_sort import rec_insertion_sort
+from sorts.reversort import reversort
 from sorts.selection_sort import selection_sort
 from sorts.shell_sort import shell_sort
 from sorts.shrink_shell_sort import shell_sort as shrink_shell_sort
@@ -74,6 +75,7 @@ def test_heap_sort() -> None:
     pancake_sort,
     patience_sort,
     quick_sort,
+    reversort,
     selection_sort,
     shell_sort,
     shrink_shell_sort,
@@ -141,6 +143,7 @@ def test_rec_insertion_sort(case) -> None:
         merge_sort,
         odd_even_sort,
         pancake_sort,
+        reversort,
         selection_sort,
         shrink_shell_sort,
         strand_sort,