Update 2023.08.1 (#103)

Author: shorodilov

.github/workflows/tests.yml renamed to .github/workflows/run_tests.yml

@@ -1,4 +1,4 @@
-name: tests
+name: Run tests, checkers and linters with Tox
 
 on:
   push:
@@ -23,9 +23,9 @@ jobs:
         uses: actions/setup-python@v2
         with:
           python-version: ${{ matrix.python-version }}
-      - name: install dependencies
+      - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
           pip install tox tox-gh-actions
-      - name: Tests
+      - name: Run tox
         run: tox

poetry.lock

@@ -4,7 +4,7 @@ build-backend = "poetry.core.masonry.api"
 
 [tool.poetry]
 name = "problem-sets"
-version = "2023.05.1"
+version = "2023.08.1"
 description = "Challenges and solutions for the Python training course"
 license = "MIT"
 authors = [
@@ -43,9 +43,10 @@ packages = [
     { include = "conv_store", from = "src" },
     { include = "datasets", from = "src" },
     { include = "dynamic", from = "src" },
+    { include = "geom", from = "src" },
+    { include = "primes", from = "src" },
     { include = "sequences", from = "src" },
     { include = "sorting", from = "src" },
-    { include = "primes", from = "src" },
     { include = "wtk", from = "src" },
 ]
 

pyproject.toml

@@ -29,7 +29,7 @@ def withdraw(target: int,
     number of coins/bills. If no exact solution is possible, the algorithm
     returns the largest possible amount that is less than the target amount.
 
-    Usage examples:
+    Usage:
 
     >>> assert withdraw(0) == []
     >>> assert withdraw(135) == [(1, 10), (1, 25), (1, 100)]
@@ -54,9 +54,9 @@ def withdraw(target: int,
         target -= multipliers[idx] * denominations[idx]
 
     # filter zero multipliers
-    filtered = filter(lambda pair: pair[0] > 0, zip(multipliers, denominations))
+    filtered = filter(lambda val: val[0] > 0, zip(multipliers, denominations))
 
-    return sorted(filtered, key=lambda pair: pair[1])
+    return sorted(filtered, key=lambda val: val[1])
 
 
 def withdraw_rev(target: int,
@@ -78,35 +78,35 @@ def withdraw_rev(target: int,
     to use the smallest denominations as many times as it possible (it's
     limited with ``limit`` argument).
 
-    Usage examples:
+    Usage:
 
     >>> assert withdraw_rev(0) == []
     >>> assert withdraw_rev(14) == [(10, 1), (2, 2)]
     >>> assert withdraw_rev(17) == [(9, 1), (4, 2)]
 
     """
 
-    raise NotImplementedError
+    raise NotImplementedError  # TODO:
 
 
-def get_total(pairs: Iterable[Tuple[int, int]]) -> int:
+def get_total(values: Iterable[Tuple[int, int]]) -> int:
     """Calculate the total sum
 
-    :param pairs: pairs of denominations and their multipliers
-    :type pairs: list
+    :param values: pairs of denominations and their multipliers
+    :type values: list
 
     :return: the total sum
     :rtype: int
 
     ``pairs`` is a list of tuples. Each ``pair`` tuple contains multiplier
     at the first position and denomination at the second one.
 
-    Usage examples:
+    Usage:
 
     >>> assert get_total([(1, 50), (1, 500), (2, 2000), (2, 10000)]) == 24500
     >>> assert get_total([(1, 500), (1, 2000), (1, 5000), (1, 10000)]) == 17545
     >>> assert get_total([(1, 2000)]) == 2000
 
     """
 
-    return sum(map(lambda pair: pair[0] * pair[1], pairs))
+    return sum(map(lambda val: val[0] * val[1], values))

src/atm/func.py

@@ -20,10 +20,6 @@ def bisect_right(origin: List[str], search: str = "") -> int:
     """
     Return the most right one index matching the search value
 
-    Current function implements common ``bisect_right`` algorithms.
-    The search value represents prefix the string should starts with,
-    that's why current string is trimmed before comparison operation.
-
     :param origin: a list of strings
     :type origin: list
     :param search: a prefix to search
@@ -34,6 +30,10 @@ def bisect_right(origin: List[str], search: str = "") -> int:
 
     :raise NotFound: if the searched value isn't in the list
 
+    Current function implements common ``bisect_right`` algorithms.
+    The search value represents prefix the string should starts with,
+    that's why current string is trimmed before comparison operation.
+
     Usage:
 
     >>> data = ["apple", "apple", "banana", "banana", "cherry"]
@@ -66,10 +66,6 @@ def bisect_left(origin: List[str], search: str = "") -> int:
     """
     Return the most left one index matching the search value
 
-    Current function implements common ``bisect_left`` algorithms.
-    The search value represents prefix the string should starts with,
-    that's why current string is trimmed before comparison operation.
-
     :param origin: a list of strings
     :type origin: list
     :param search: a prefix to search
@@ -80,6 +76,10 @@ def bisect_left(origin: List[str], search: str = "") -> int:
 
     :raise NotFound: if the searched value isn't in the list
 
+    Current function implements common ``bisect_left`` algorithms.
+    The search value represents prefix the string should starts with,
+    that's why current string is trimmed before comparison operation.
+
     Usage:
 
     >>> data = ["apple", "apple", "banana", "banana", "cherry"]
@@ -112,14 +112,20 @@ def find_all(origin: List[str], search: str = "") -> List[str]:
     """
     Return strings starting with prefix
 
-    :param origin: the list of strings
+    :param origin: the sorted list of strings
     :type origin: list
     :param search: the prefix to search, defaults to empty string
     :type search: str
 
     :return: the list of strings starting with the search prefix
     :rtype: list
 
+    The task is to find **all** values starting with a specified preffix
+    in a **sorted** list of strings. The straightforward (brute force)
+    solution to iterate over the entire list is not effective. Instead,
+    there is a better solution to use "binary search" algorithm, to find
+    the first one and the last one values, that suite the condition.
+
     Usage:
 
     >>> data = ["apple", "apple", "banana", "banana", "cherry"]

src/bisearch/prefix.py

@@ -86,15 +86,15 @@ def get_fibonacci_number_nr(idx: int, /) -> int:
     """
     Return a Fibonacci's sequence number at a specified index
 
-    This function implements the non-recursive algorithm, which is more
-    efficient, since it does not have multiple recursive calls.
-
     :param idx: a Fibonacci sequence index starting from 0
     :type idx: int
 
     :return: a sequence's member
     :rtype: int
 
+    This function implements the non-recursive algorithm, which is more
+    efficient, since it does not have multiple recursive calls.
+
     Usage:
 
     >>> assert get_fibonacci_number(0) == 0
@@ -122,9 +122,6 @@ def get_sum_of_strings(number_1: str, number_2: str, /) -> str:
     """
     Return the sum of two numbers of string type as string
 
-    Valid input is a string of any length containing numeric characters from
-    0 to 9. Empty strings are allowed as well and should be considered as 0.
-
     :param number_1: first number
     :type number_1: str
     :param number_2: second number
@@ -133,6 +130,9 @@ def get_sum_of_strings(number_1: str, number_2: str, /) -> str:
     :return: the sum of two numbers
     :rtype: str
 
+    Valid input is a string of any length containing numeric characters from
+    0 to 9. Empty strings are allowed as well and should be considered as 0.
+
     Usage:
 
     >>> assert get_sum_of_strings("123", "456") == "579"

src/calc/func.py

@@ -10,15 +10,15 @@ class Product:
     """
     Product model implementation
 
-    Instances of this class represent a product available for purchase.
-
     :ivar name: the name of a product
     :type name: str
     :ivar price: the price for a single product unit
     :type price: int
     :ivar unit: the size of a single product unit
     :type unit: int | float
 
+    Instances of this class represent a product available for purchase.
+
     """
 
     def __init__(self,
@@ -78,15 +78,15 @@ def get_total(self, quantity: Optional[Union[int, float]] = None) -> int:
         """
         Return the total price for a specified amount of a product
 
-        If the quantity argument is omitted, unit attribute value should be
-        used instead.
-
         :param quantity: a quantity to purchase, defaults to None
         :type quantity: int | float, optional
 
         :return: total price for a specified amount of a product
         :rtype: int
 
+        If the quantity argument is omitted, unit attribute value should be
+        used instead.
+
         """
 
         quantity = quantity or self.unit
@@ -103,15 +103,15 @@ def get_units(self, quantity: Union[int, float]) -> int:
 class ShoppingCart:
     """Shopping cart model implementation
 
-    In general shopping cart is a container for products. Instances of this
-    class handle product and corresponding quantity for each item inside
-    a shopping cart instance.
-
     :ivar products: product appended to the shopping cart instance
     :type products: list
     :ivar quantities: corresponding quantities for each product in cart
     :type quantities: list
 
+    In general shopping cart is a container for products. Instances of this
+    class handle product and corresponding quantity for each item inside
+    a shopping cart instance.
+
     """
 
     def __init__(self) -> None:
@@ -188,15 +188,15 @@ def add_product(self,
         """
         Add product to the shopping cart
 
-        This method adds a product instance and corresponding quantity value
-        to the cart.
-
         :param product: a product instance to add to cart
         :type product: :class: `Product`
         :param quantity: a quantity of a product to add. Defaults to the
             product unit value.
         :type quantity: int | float, optional
 
+        This method adds a product instance and corresponding quantity value
+        to the cart.
+
         """
 
         quantity = quantity or product.unit
@@ -221,14 +221,14 @@ def sub_product(self,
         """
         Subtract product from the shopping cart
 
-        If quantity value is less or equal to 0 the product is to be
-        removed from the shopping cart
-
         :param product: a product instance to add to cart
         :type product: :class: `Product`
         :param quantity: a quantity of a product to add
         :type quantity: int | float
 
+        If quantity value is less or equal to 0 the product is to be
+        removed from the shopping cart
+
         """
 
         quantity = - abs(quantity)