Merge branch 'master' into sorts/make-odd-even-transposition-generic

Author: cclauss

DIRECTORY.md

@@ -671,6 +671,7 @@
   * [Travelling Salesman Problem](graphs/travelling_salesman_problem.py)
 
 ## [Greedy Methods](greedy_methods)
+  * [Activity Selection](greedy_methods/activity_selection.py)
   * [Best Time To Buy And Sell Stock](greedy_methods/best_time_to_buy_and_sell_stock.py)
   * [Fractional Cover Problem](greedy_methods/fractional_cover_problem.py)
   * [Fractional Knapsack](greedy_methods/fractional_knapsack.py)
@@ -885,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)
@@ -1592,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)
@@ -1606,6 +1609,7 @@
   * [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 Is Valid Number](strings/string_is_valid_number.py)
   * [String Switch Case](strings/string_switch_case.py)
   * [Strip](strings/strip.py)
   * [Suffix Automaton](strings/suffix_automaton.py)

greedy_methods/activity_selection.py

@@ -0,0 +1,57 @@
+"""
+The Activity Selection Problem is a classic problem in which a set of activities,
+each with a start and end time, needs to be scheduled in such a way that the
+maximum number of non-overlapping activities is selected.
+This is a greedy algorithm where at each step,
+we choose the activity that finishes the earliest
+and does not conflict with previously selected activities.
+
+Wikipedia: https://en.wikipedia.org/wiki/Activity_selection_problem
+"""
+
+
+def activity_selection(activities: list[tuple[int, int]]) -> list[tuple[int, int]]:
+    """
+    Solve the Activity Selection Problem using a greedy algorithm by selecting
+    the maximum number of non-overlapping activities from a list of activities.
+
+    Parameters:
+    activities: A list of tuples where each tuple contains
+                                        the start and end times of an activity.
+
+    Returns:
+    A list of selected activities that are non-overlapping.
+
+    Example:
+    >>> activity_selection([(1, 3), (2, 5), (3, 9), (6, 8)])
+    [(1, 3), (6, 8)]
+
+    >>> activity_selection([(0, 6), (1, 4), (3, 5), (5, 7), (5, 9), (8, 9)])
+    [(1, 4), (5, 7), (8, 9)]
+
+    >>> activity_selection([(1, 2), (2, 4), (3, 5), (0, 6)])
+    [(1, 2), (2, 4)]
+
+    >>> activity_selection([(5, 9), (1, 2), (3, 4), (0, 6)])
+    [(1, 2), (3, 4), (5, 9)]
+
+    >>> all(activity_selection(x) == [] for x in ([], {}, None, False, 0, 0.0))
+    True
+    """
+    if not activities:
+        return []
+
+    # Step 1: Sort the activities by their end time
+    sorted_activities = sorted(activities, key=lambda activity: activity[1])
+
+    # Step 2: Select the first activity (the one that finishes the earliest)
+    # as the initial activity
+    selected_activities = [sorted_activities[0]]
+
+    # Step 3: Iterate through the sorted activities and select the ones
+    # that do not overlap with the last selected activity
+    for i in range(1, len(sorted_activities)):
+        if sorted_activities[i][0] >= selected_activities[-1][1]:
+            selected_activities.append(sorted_activities[i])
+
+    return selected_activities

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()

sorts/recursive_mergesort_array.py

@@ -1,12 +1,23 @@
-"""A merge sort which accepts an array as input and recursively
-splits an array in half and sorts and combines them.
+"""A merge sort which accepts comparable items and recursively
+splits them in half, then sorts and combines the halves.
+
+https://en.wikipedia.org/wiki/Merge_sort
 """
 
-"""https://en.wikipedia.org/wiki/Merge_sort """
+from collections.abc import Iterable
+from typing import Protocol
+
+
+class Comparable(Protocol):
+    def __lt__(self, other: object, /) -> bool: ...
+
+
+def merge[T: Comparable](collection: Iterable[T]) -> list[T]:
+    """Return a new list of ``collection`` sorted in ascending order.
 
+    The input is copied, so the original iterable is left unchanged.
+    Items must be mutually comparable with ``<``.
 
-def merge(arr: list[int]) -> list[int]:
-    """Return a sorted array.
     >>> merge([10,9,8,7,6,5,4,3,2,1])
     [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     >>> merge([1,2,3,4,5,6,7,8,9,10])
@@ -17,19 +28,30 @@ def merge(arr: list[int]) -> list[int]:
     [100]
     >>> merge([])
     []
+    >>> merge(["c", "a", "b"])
+    ['a', 'b', 'c']
+    >>> merge([2.5, -1, 0.0])
+    [-1, 0.0, 2.5]
+    >>> values = [3, 1, 2]
+    >>> merge(values)
+    [1, 2, 3]
+    >>> values
+    [3, 1, 2]
+    >>> merge(("b", "c", "a"))
+    ['a', 'b', 'c']
+    >>> merge([1, "a"])
+    Traceback (most recent call last):
+        ...
+    TypeError: '<' not supported between instances of 'int' and 'str'
     """
+    arr = list(collection)
     if len(arr) > 1:
         middle_length = len(arr) // 2  # Finds the middle of the array
-        left_array = arr[
-            :middle_length
-        ]  # Creates an array of the elements in the first half.
-        right_array = arr[
-            middle_length:
-        ]  # Creates an array of the elements in the second half.
+        # Sort each half into a new list, then combine those halves in ``arr``.
+        left_array = merge(arr[:middle_length])
+        right_array = merge(arr[middle_length:])
         left_size = len(left_array)
         right_size = len(right_array)
-        merge(left_array)  # Starts sorting the left.
-        merge(right_array)  # Starts sorting the right
         left_index = 0  # Left Counter
         right_index = 0  # Right Counter
         index = 0  # Position Counter

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()