Merge branch 'TheAlgorithms:master' into time_period_simple_pendulum

Author: pluto-tofu

.github/CODEOWNERS

@@ -7,7 +7,7 @@
 
 # Order is important. The last matching pattern has the most precedence.
 
-/.*  @cclauss @dhruvmanila
+/.*  @cclauss
 
 # /arithmetic_analysis/
 

greedy_methods/fractional_knapsack.py

@@ -6,6 +6,30 @@ def frac_knapsack(vl, wt, w, n):
     """
     >>> frac_knapsack([60, 100, 120], [10, 20, 30], 50, 3)
     240.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 10, 4)
+    105.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 8, 4)
+    95.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6], 8, 4)
+    60.0
+    >>> frac_knapsack([10, 40, 30], [5, 4, 6, 3], 8, 4)
+    60.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 0, 4)
+    0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 8, 0)
+    95.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], -8, 4)
+    0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 8, -4)
+    95.0
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 800, 4)
+    130
+    >>> frac_knapsack([10, 40, 30, 50], [5, 4, 6, 3], 8, 400)
+    95.0
+    >>> frac_knapsack("ABCD", [5, 4, 6, 3], 8, 400)
+    Traceback (most recent call last):
+        ...
+    TypeError: unsupported operand type(s) for /: 'str' and 'int'
     """
 
     r = sorted(zip(vl, wt), key=lambda x: x[0] / x[1], reverse=True)

maths/binomial_coefficient.py

@@ -1,10 +1,48 @@
 def binomial_coefficient(n: int, r: int) -> int:
     """
-    Find binomial coefficient using pascals triangle.
+    Find binomial coefficient using Pascal's triangle.
+
+    Calculate C(n, r) using Pascal's triangle.
+
+    :param n: The total number of items.
+    :param r: The number of items to choose.
+    :return: The binomial coefficient C(n, r).
 
     >>> binomial_coefficient(10, 5)
     252
+    >>> binomial_coefficient(10, 0)
+    1
+    >>> binomial_coefficient(0, 10)
+    1
+    >>> binomial_coefficient(10, 10)
+    1
+    >>> binomial_coefficient(5, 2)
+    10
+    >>> binomial_coefficient(5, 6)
+    0
+    >>> binomial_coefficient(3, 5)
+    0
+    >>> binomial_coefficient(-2, 3)
+    Traceback (most recent call last):
+        ...
+    ValueError: n and r must be non-negative integers
+    >>> binomial_coefficient(5, -1)
+    Traceback (most recent call last):
+        ...
+    ValueError: n and r must be non-negative integers
+    >>> binomial_coefficient(10.1, 5)
+    Traceback (most recent call last):
+        ...
+    TypeError: 'float' object cannot be interpreted as an integer
+    >>> binomial_coefficient(10, 5.1)
+    Traceback (most recent call last):
+        ...
+    TypeError: 'float' object cannot be interpreted as an integer
     """
+    if n < 0 or r < 0:
+        raise ValueError("n and r must be non-negative integers")
+    if 0 in (n, r):
+        return 1
     c = [0 for i in range(r + 1)]
     # nc0 = 1
     c[0] = 1
@@ -17,4 +55,8 @@ def binomial_coefficient(n: int, r: int) -> int:
     return c[r]
 
 
-print(binomial_coefficient(n=10, r=5))
+if __name__ == "__main__":
+    from doctest import testmod
+
+    testmod()
+    print(binomial_coefficient(n=10, r=5))

networking_flow/ford_fulkerson.py

@@ -1,39 +1,95 @@
-# Ford-Fulkerson Algorithm for Maximum Flow Problem
 """
+Ford-Fulkerson Algorithm for Maximum Flow Problem
+* https://en.wikipedia.org/wiki/Ford%E2%80%93Fulkerson_algorithm
+
 Description:
-    (1) Start with initial flow as 0;
-    (2) Choose augmenting path from source to sink and add path to flow;
+    (1) Start with initial flow as 0
+    (2) Choose the augmenting path from source to sink and add the path to flow
 """
+graph = [
+    [0, 16, 13, 0, 0, 0],
+    [0, 0, 10, 12, 0, 0],
+    [0, 4, 0, 0, 14, 0],
+    [0, 0, 9, 0, 0, 20],
+    [0, 0, 0, 7, 0, 4],
+    [0, 0, 0, 0, 0, 0],
+]
+
+
+def breadth_first_search(graph: list, source: int, sink: int, parents: list) -> bool:
+    """
+    This function returns True if there is a node that has not iterated.
+
+    Args:
+        graph: Adjacency matrix of graph
+        source: Source
+        sink: Sink
+        parents: Parent list
+
+    Returns:
+        True if there is a node that has not iterated.
 
+    >>> breadth_first_search(graph, 0, 5, [-1, -1, -1, -1, -1, -1])
+    True
+    >>> breadth_first_search(graph, 0, 6, [-1, -1, -1, -1, -1, -1])
+    Traceback (most recent call last):
+        ...
+    IndexError: list index out of range
+    """
+    visited = [False] * len(graph)  # Mark all nodes as not visited
+    queue = []  # breadth-first search queue
 
-def bfs(graph, s, t, parent):
-    # Return True if there is node that has not iterated.
-    visited = [False] * len(graph)
-    queue = []
-    queue.append(s)
-    visited[s] = True
+    # Source node
+    queue.append(source)
+    visited[source] = True
 
     while queue:
-        u = queue.pop(0)
-        for ind in range(len(graph[u])):
-            if visited[ind] is False and graph[u][ind] > 0:
+        u = queue.pop(0)  # Pop the front node
+        # Traverse all adjacent nodes of u
+        for ind, node in enumerate(graph[u]):
+            if visited[ind] is False and node > 0:
                 queue.append(ind)
                 visited[ind] = True
-                parent[ind] = u
+                parents[ind] = u
+    return visited[sink]
 
-    return visited[t]
 
+def ford_fulkerson(graph: list, source: int, sink: int) -> int:
+    """
+    This function returns the maximum flow from source to sink in the given graph.
 
-def ford_fulkerson(graph, source, sink):
-    # This array is filled by BFS and to store path
+    CAUTION: This function changes the given graph.
+
+    Args:
+        graph: Adjacency matrix of graph
+        source: Source
+        sink: Sink
+
+    Returns:
+        Maximum flow
+
+    >>> test_graph = [
+    ...     [0, 16, 13, 0, 0, 0],
+    ...     [0, 0, 10, 12, 0, 0],
+    ...     [0, 4, 0, 0, 14, 0],
+    ...     [0, 0, 9, 0, 0, 20],
+    ...     [0, 0, 0, 7, 0, 4],
+    ...     [0, 0, 0, 0, 0, 0],
+    ... ]
+    >>> ford_fulkerson(test_graph, 0, 5)
+    23
+    """
+    # This array is filled by breadth-first search and to store path
     parent = [-1] * (len(graph))
     max_flow = 0
-    while bfs(graph, source, sink, parent):
-        path_flow = float("Inf")
+
+    # While there is a path from source to sink
+    while breadth_first_search(graph, source, sink, parent):
+        path_flow = int(1e9)  # Infinite value
         s = sink
 
         while s != source:
-            # Find the minimum value in select path
+            # Find the minimum value in the selected path
             path_flow = min(path_flow, graph[parent[s]][s])
             s = parent[s]
 
@@ -45,17 +101,12 @@ def ford_fulkerson(graph, source, sink):
             graph[u][v] -= path_flow
             graph[v][u] += path_flow
             v = parent[v]
+
     return max_flow
 
 
-graph = [
-    [0, 16, 13, 0, 0, 0],
-    [0, 0, 10, 12, 0, 0],
-    [0, 4, 0, 0, 14, 0],
-    [0, 0, 9, 0, 0, 20],
-    [0, 0, 0, 7, 0, 4],
-    [0, 0, 0, 0, 0, 0],
-]
+if __name__ == "__main__":
+    from doctest import testmod
 
-source, sink = 0, 5
-print(ford_fulkerson(graph, source, sink))
+    testmod()
+    print(f"{ford_fulkerson(graph, source=0, sink=5) = }")

sorts/binary_insertion_sort.py

@@ -12,10 +12,11 @@
 
 
 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
+    """
+    Sorts a list using the binary insertion sort algorithm.
+
+    :param collection: A mutable ordered collection with comparable items.
+    :return: The same collection ordered in ascending order.
 
     Examples:
     >>> binary_insertion_sort([0, 4, 1234, 4, 1])
@@ -39,23 +40,27 @@ def binary_insertion_sort(collection: list) -> list:
 
     n = len(collection)
     for i in range(1, n):
-        val = collection[i]
+        value_to_insert = collection[i]
         low = 0
         high = i - 1
 
         while low <= high:
             mid = (low + high) // 2
-            if val < collection[mid]:
+            if value_to_insert < collection[mid]:
                 high = mid - 1
             else:
                 low = mid + 1
         for j in range(i, low, -1):
             collection[j] = collection[j - 1]
-        collection[low] = val
+        collection[low] = value_to_insert
     return collection
 
 
-if __name__ == "__main__":
+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))
+    try:
+        unsorted = [int(item) for item in user_input.split(",")]
+    except ValueError:
+        print("Invalid input. Please enter valid integers separated by commas.")
+        raise
+    print(f"{binary_insertion_sort(unsorted) = }")

strings/frequency_finder.py

@@ -49,6 +49,15 @@ def get_item_at_index_zero(x: tuple) -> str:
 
 
 def get_frequency_order(message: str) -> str:
+    """
+    Get the frequency order of the letters in the given string
+    >>> get_frequency_order('Hello World')
+    'LOWDRHEZQXJKVBPYGFMUCSNIAT'
+    >>> get_frequency_order('Hello@')
+    'LHOEZQXJKVBPYGFWMUCDRSNIAT'
+    >>> get_frequency_order('h')
+    'HZQXJKVBPYGFWMUCLDRSNIOATE'
+    """
     letter_to_freq = get_letter_count(message)
     freq_to_letter: dict[int, list[str]] = {
         freq: [] for letter, freq in letter_to_freq.items()

web_programming/current_weather.py

@@ -1,30 +1,50 @@
 import requests
 
-APPID = ""  # <-- Put your OpenWeatherMap appid here!
-URL_BASE = "https://api.openweathermap.org/data/2.5/"
-
-
-def current_weather(q: str = "Chicago", appid: str = APPID) -> dict:
-    """https://openweathermap.org/api"""
-    return requests.get(URL_BASE + "weather", params=locals()).json()
-
-
-def weather_forecast(q: str = "Kolkata, India", appid: str = APPID) -> dict:
-    """https://openweathermap.org/forecast5"""
-    return requests.get(URL_BASE + "forecast", params=locals()).json()
-
-
-def weather_onecall(lat: float = 55.68, lon: float = 12.57, appid: str = APPID) -> dict:
-    """https://openweathermap.org/api/one-call-api"""
-    return requests.get(URL_BASE + "onecall", params=locals()).json()
+# Put your API key(s) here
+OPENWEATHERMAP_API_KEY = ""
+WEATHERSTACK_API_KEY = ""
+
+# Define the URL for the APIs with placeholders
+OPENWEATHERMAP_URL_BASE = "https://api.openweathermap.org/data/2.5/weather"
+WEATHERSTACK_URL_BASE = "http://api.weatherstack.com/current"
+
+
+def current_weather(location: str) -> list[dict]:
+    """
+    >>> current_weather("location")
+    Traceback (most recent call last):
+        ...
+    ValueError: No API keys provided or no valid data returned.
+    """
+    weather_data = []
+    if OPENWEATHERMAP_API_KEY:
+        params_openweathermap = {"q": location, "appid": OPENWEATHERMAP_API_KEY}
+        response_openweathermap = requests.get(
+            OPENWEATHERMAP_URL_BASE, params=params_openweathermap
+        )
+        weather_data.append({"OpenWeatherMap": response_openweathermap.json()})
+    if WEATHERSTACK_API_KEY:
+        params_weatherstack = {"query": location, "access_key": WEATHERSTACK_API_KEY}
+        response_weatherstack = requests.get(
+            WEATHERSTACK_URL_BASE, params=params_weatherstack
+        )
+        weather_data.append({"Weatherstack": response_weatherstack.json()})
+    if not weather_data:
+        raise ValueError("No API keys provided or no valid data returned.")
+    return weather_data
 
 
 if __name__ == "__main__":
     from pprint import pprint
 
-    while True:
-        location = input("Enter a location:").strip()
+    location = "to be determined..."
+    while location:
+        location = input("Enter a location (city name or latitude,longitude): ").strip()
         if location:
-            pprint(current_weather(location))
-        else:
-            break
+            try:
+                weather_data = current_weather(location)
+                for forecast in weather_data:
+                    pprint(forecast)
+            except ValueError as e:
+                print(repr(e))
+                location = ""