Feat: Add list-processing algorithms

.gitignore

@@ -1,3 +1,4 @@
 .devenv/
 .venv/
 __pycache__/
+poetry.toml

README.md

@@ -29,15 +29,23 @@ poetry run bosco --starting-size 100 --number-doubles 5 --file bosco/sorting.py
 
 The command uses the following inputs:
 
-- `--starting-size` for the initial list size to start the doubling experiment
+- `--starting-size` for the initial list size to start the doubling experiment.
 - `--number-doubles` for the number of times the input size will be doubled
-  during the doubling experiment
+  during the doubling experiment.
 - `--file` for the path to the file containing the sorting algorithm you want to
-  run the doubling experiment on
+  run the doubling experiment on.
 - `--function-name` for the name of the function containing the sorting
-  algorithm you want to test
+  algorithm you want to test.
 - `--element-type` for the data type to fill the randomly generated containers.
 
+This project supplies an array of Python files with list operations in them:
+
+* `bosco/list_processing/basics.py`: basic list operations
+* `bosco/list_processing/combination.py`: list operations involving combination
+* `bosco/list_processing/search.py`: searching algorithms for lists
+* `bosco/list_processing/sorting.py`: sorting algorithms for lists
+* `bosco/list_processing/other.py`: other uncategorized operations
+
 ## Example of command and output
 
 ### Command

bosco/list_processing/basics.py

@@ -0,0 +1,130 @@
+"""Basic python functions."""
+
+import random
+from typing import List, Any
+
+
+def get_first_item(lst: List[Any]) -> Any:
+    """Returns the first item of the list if it exists, otherwise returns None."""
+    return lst[0] if lst else None
+
+
+def get_last_item(lst: List[Any]) -> Any:
+    """Returns the last item of the list if it exists, otherwise returns None."""
+    return lst[-1] if lst else None
+
+
+def get_list_length(lst: List[Any]) -> int:
+    """Returns the length of the list."""
+    return len(lst)
+
+
+def reverse_list(lst: List[Any]) -> List[Any]:
+    """Returns a new list that is the reverse of the input list."""
+    return lst[::-1]
+
+
+def sort_list(lst: List[Any]) -> List[Any]:
+    """Returns a new list that is the sorted version of the input list."""
+    return sorted(lst)
+
+
+def append_item(lst: List[Any], item: Any) -> List[Any]:
+    """Appends an item to the end of the list and returns the list."""
+    lst.append(item)
+    return lst
+
+
+def remove_item(lst: List[Any], item: Any) -> List[Any]:
+    """Removes an item from the list if it exists and returns the list."""
+    if item in lst:
+        lst.remove(item)
+    return lst
+
+
+def count_item(lst: List[Any], item: Any) -> int:
+    """Returns the count of an item in the list."""
+    return lst.count(item)
+
+
+def clear_list(lst: List[Any]) -> List[Any]:
+    """Clears all items from the list and returns the list."""
+    lst.clear()
+    return lst
+
+
+def insert_item(lst: List[Any], index: int, item: Any) -> List[Any]:
+    """Inserts an item at a specific index in the list and returns the list."""
+    lst.insert(index, item)
+    return lst
+
+
+def delete_random_item(lst: List[Any]) -> List[Any]:
+    """Deletes a random item from the list and returns the list."""
+    if lst:
+        del lst[random.randint(0, len(lst) - 1)]
+    return lst
+
+
+def copy_list(lst: List[Any]) -> List[Any]:
+    """Returns a copy of the input list."""
+    return lst.copy()
+
+
+def list_in(lst: List[Any], item: Any) -> bool:
+    """Returns True if the item is in the list, False otherwise."""
+    return item in lst
+
+
+def extend(lst1: List[Any], lst2: List[Any]) -> List[Any]:
+    """Extends lst1 with the items in lst2 and returns the extended list."""
+    lst1.extend(lst2)
+    return lst1
+
+
+def index(lst: List[Any], item: Any) -> int:
+    """Returns the index of the first occurrence of an item in the list."""
+    return lst.index(item)
+
+
+def pop(lst: List[Any], index: int = -1) -> Any:
+    """Removes and returns the item at the given index from the list."""
+    return lst.pop(index)
+
+
+def minimum(lst: List[Any]) -> Any:
+    """Returns the smallest item in the list."""
+    return min(lst)
+
+
+def maximum(lst: List[Any]) -> Any:
+    """Returns the largest item in the list."""
+    return max(lst)
+
+
+def filter_list(lst: List[Any], condition: callable) -> List[Any]:
+    """Returns a new list containing only the items that satisfy the given condition."""
+    return [item for item in lst if condition(item)]
+
+
+def map_list(lst: List[Any], function: callable) -> List[Any]:
+    """Applies a function to each item in the list and returns a new list with the results."""
+    return [function(item) for item in lst]
+
+
+def reduce_list(lst: List[Any], function: callable, initial: Any) -> Any:
+    """Applies a function of two arguments cumulatively to the items of the list, from left to right, so as to reduce the list to a single output."""
+    result = initial
+    for item in lst:
+        result = function(result, item)
+    return result
+
+
+def zip_lists(lst1: List[Any], lst2: List[Any]) -> List[tuple]:
+    """Returns a list of tuples, where the i-th tuple contains the i-th element from each of the argument lists."""
+    return list(zip(lst1, lst2))
+
+
+def flatten_list(lst: List[List[Any]]) -> List[Any]:
+    """Flattens a list of lists into a single list."""
+    return [item for sublist in lst for item in sublist]

bosco/list_processing/combination.py

@@ -0,0 +1,27 @@
+"""List Combining Algorithms."""
+from typing import List, Any, Tuple
+
+
+def concatenate_lists(*lists: List[Any]) -> List[Any]:
+    """Concatenate any number of list you give it."""
+    result = []
+    for lst in lists:
+        result.extend(lst)
+    return result
+
+
+def zip_lists(*lists: List[Any]) -> Tuple[Any]:
+    """Combine multiple lists into a single list of tuples,
+    where each tuple contains elements from the corresponding positions of the lists."""
+    return list(zip(*lists))
+
+
+def merge_lists(list1: List[Any], list2: List[Any]) -> List[Any]:
+    """Combine two lists in a way that the elements are typically interleaved or merged according to a specific criterion."""
+    result = []
+    for i in range(max(len(list1), len(list2))):
+        if i < len(list1):
+            result.append(list1[i])
+        if i < len(list2):
+            result.append(list2[i])
+    return result

bosco/list_processing/other.py

@@ -0,0 +1,47 @@
+"""Other List Algorithms."""
+
+from typing import List, Any, Union, Tuple
+
+
+def is_subset(first_list: List[Any], second_list: List[Any]) -> bool:
+    """Determine if one set is a subset of another set."""
+    for element_one in first_list:
+        matched = False
+        for element_two in second_list:
+            if element_one == element_two:
+                matched = True
+                break
+        if not matched:
+            return False
+    return True
+
+
+def list_intersection(list1: List[Any], list2: List[Any]) -> List[Any]:
+    """Make a new list containing only the elements that are common to both input lists."""
+    return [x for x in list1 if x in list2]
+
+
+def list_symmetric_difference(list1: List[Any], list2: List[Any]) -> List[Any]:
+    """Make a new list containing elements that are present in only one of the input lists"""
+    return [x for x in list1 + list2 if (x not in list1) or (x not in list2)]
+
+
+def list_concatenation(
+    list1: List[Union[int, float, str]], list2: List[Union[int, float, str]]
+) -> List[Union[int, float, str]]:
+    """Concatenates two lists into a single list."""
+    return list1 + list2
+
+
+def list_elementwise_addition(
+    list1: List[Union[int, float]], list2: List[Union[int, float]]
+) -> List[Union[int, float]]:
+    """Performs element-wise addition of two lists of numbers."""
+    return [x + y for x, y in zip(list1, list2)]
+
+
+def list_pairwise_multiplication(
+    list1: List[Union[int, float]], list2: List[Union[int, float]]
+) -> List[Union[int, float]]:
+    """Performs pairwise multiplication of two lists of numbers."""
+    return [x * y for x, y in zip(list1, list2)]

bosco/list_processing/search.py

@@ -0,0 +1,99 @@
+"""List searching algorithms."""
+
+from typing import List, Optional
+import math
+
+
+def compute_iterative_binary_search(values: List[int], target: int) -> bool:
+    """Search a list using iterative binary search."""
+    end = len(values) - 1
+    start = 0
+    while start <= end:
+        mid = (start + end) // 2
+        if values[mid] == target:
+            return True
+        elif values[mid] < target:
+            start = mid + 1
+        elif values[mid] > target:
+            end = mid - 1
+    return False
+
+
+def compute_recursive_binary_search(
+    values: List[int], target: int, start: int = 0, end: Optional[int] = None
+) -> bool:
+    """Search a list using recursive binary search."""
+    if end is None:
+        end = len(values) - 1
+    if start > end:
+        return False
+    mid = (start + end) // 2
+    if values[mid] == target:
+        return True
+    elif values[mid] < target:
+        return compute_recursive_binary_search(values, target, mid + 1, end)
+    elif values[mid] > target:
+        return compute_recursive_binary_search(values, target, start, mid - 1)
+
+
+def compute_jump_search(search_list: List[int], x: int) -> int:
+    """Search a list using jump search function."""
+    n = len(search_list)
+    step = int(math.floor(math.sqrt(n)))
+    prev = 0
+    while search_list[min(step, n) - 1] < x:
+        prev = step
+        step += int(math.floor(math.sqrt(n)))
+        if prev >= n:
+            return -1
+    while search_list[prev] < x:
+        prev = prev + 1
+        if prev == min(step, n):
+            return -1
+    if search_list[prev] == x:
+        return prev
+    return -1
+
+
+def compute_interpolation_search(search_list: List[int], x: int) -> int:
+    """Find indices of two corners."""
+    lo = 0
+    n = len(search_list)
+    hi = n - 1
+    while lo <= hi and x >= search_list[lo] and x <= search_list[hi]:
+        if lo == hi:
+            if search_list[lo] == x:
+                return lo
+            return -1
+        pos = lo + int(
+            (
+                (float(hi - lo) / (search_list[hi] - search_list[lo]))
+                * (x - search_list[lo])
+            )
+        )
+        if search_list[pos] == x:
+            return pos
+        if list[pos] < x:
+            lo = pos + 1
+        else:
+            hi = pos - 1
+    return -1
+
+
+def compute_linear_search(search_list: List[int], x: int) -> int:
+    """Search a list using linear search function."""
+    for i in range(len(search_list)):
+        if search_list[i] == x:
+            return i
+    return -1
+
+
+def compute_exponential_search(search_list: List[int], x: int) -> int:
+    """Return the position of first occurrence of x in array."""
+    n = len(search_list) - 1
+    if search_list[0] == x:
+        return 0
+    i = 1
+    while i < n and search_list[i] <= x:
+        i = i * 2
+    return compute_recursive_binary_search(search_list, x, i / 2, min(i, n))

bosco/main.py

@@ -16,7 +16,7 @@
 def bosco(
     starting_size: int = typer.Option(100),
     number_doubles: int = typer.Option(5),
-    file: str = typer.Option("./bosco/sorting.py"),
+    file: str = typer.Option("./bosco/list_processing/sorting.py"),
     function_name: str = typer.Option("bubble_sort"),
     element_type: str = typer.Option(
         "int", help="Type of the generated elements (int, float, or str)"