jugaadcode 0.1.10__tar.gz → 0.1.11__tar.gz

{jugaadcode-0.1.10 → jugaadcode-0.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jugaadcode
-Version: 0.1.10
+Version: 0.1.11
 Summary: A Python library for common programming logic and algorithms
 Author: Mohamed Faraazman Bin Farooq S, Surya Deepta
 Requires-Python: >=3.9

{jugaadcode-0.1.10 → jugaadcode-0.1.11}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "jugaadcode"
-version = "0.1.10"
+version = "0.1.11"
 description = "A Python library for common programming logic and algorithms"
 readme = "README.md"
 requires-python = ">=3.9"

jugaadcode-0.1.11/src/jugaadcode/anagram.py

@@ -0,0 +1,115 @@
+from collections import Counter
+
+
+def is_anagram(*args):
+    """
+    Check whether two or more strings form anagrams.
+
+    Supports:
+        is_anagram("listen", "silent")
+        is_anagram(["listen", "silent"])
+        is_anagram(("listen", "silent"))
+        is_anagram(("listen", "silent"), ("hello", "world"))
+        is_anagram("listen", "silent", "hello", "world")
+
+    Spaces and letter case are ignored.
+
+    Parameters
+    ----------
+    *args : str or collections of strings
+        Two strings for a single comparison, or multiple pairs
+        supplied as separate arguments or collections.
+
+    Returns
+    -------
+    bool or list[bool]
+        A boolean for one comparison, or a list of booleans
+        for multiple comparisons.
+
+    Raises
+    ------
+    TypeError
+        If an input is not a string or a supported collection.
+    ValueError
+        If a comparison does not contain exactly two strings,
+        or either string is empty after removing whitespace.
+    """
+
+    if not args:
+        first = input("Enter first string: ")
+        second = input("Enter second string: ")
+        args = (first, second)
+
+    def normalize(text):
+        if not isinstance(text, str):
+            raise TypeError("Every string must be of type str.")
+
+        normalized = "".join(text.split()).casefold()
+
+        if not normalized:
+            raise ValueError(
+                "Strings must contain at least one non-whitespace character."
+            )
+
+        return Counter(normalized)
+
+    def compare_pair(pair):
+        if len(pair) != 2:
+            raise ValueError(
+                "Each anagram comparison must contain exactly two strings."
+            )
+
+        first, second = pair
+        return normalize(first) == normalize(second)
+
+    # Two strings represent one comparison.
+    if len(args) == 2 and all(isinstance(arg, str) for arg in args):
+        return compare_pair(args)
+
+    # Multiple strings represent consecutive pairs.
+    if all(isinstance(arg, str) for arg in args):
+        if len(args) % 2 != 0:
+            raise ValueError(
+                "Multiple strings must be supplied in pairs."
+            )
+
+        return [
+            compare_pair(args[index:index + 2])
+            for index in range(0, len(args), 2)
+        ]
+
+    # A single collection may contain a pair of strings
+    # or multiple pairs of strings.
+    if len(args) == 1:
+        collection = args[0]
+
+        if isinstance(collection, (list, tuple)):
+            if len(collection) == 2 and all(
+                isinstance(item, str) for item in collection
+            ):
+                return compare_pair(collection)
+
+            results = []
+
+            for pair in collection:
+                if not isinstance(pair, (list, tuple)):
+                    raise TypeError(
+                        "Multiple comparisons must be supplied as pairs."
+                    )
+
+                results.append(compare_pair(pair))
+
+            return results
+
+    # Multiple pairs passed as separate arguments.
+    results = []
+
+    for pair in args:
+        if not isinstance(pair, (list, tuple)):
+            raise TypeError(
+                "Supply strings in pairs or provide collections of string pairs."
+            )
+
+        results.append(compare_pair(pair))
+
+    return results

jugaadcode-0.1.11/src/jugaadcode/armstrong.py

@@ -0,0 +1,93 @@
+def is_armstrong(*args):
+    """
+    Check whether one or more integers are Armstrong numbers.
+
+    Supports:
+        is_armstrong(153)
+        is_armstrong(153, 370, 123)
+        is_armstrong([153, 370, 123])
+        is_armstrong((153, 370, 123))
+        is_armstrong({153, 370, 123})
+        is_armstrong(range(100, 200))
+        is_armstrong()
+
+    Returns
+    -------
+    bool
+        For a single integer.
+    list[bool] or tuple[bool, ...] or set[bool]
+        For multiple integers, according to the input format.
+
+    Raises
+    ------
+    TypeError
+        If an input is not an integer or supported collection.
+    ValueError
+        If an input contains a negative integer or no values.
+    """
+
+    if not args:
+        value = input(
+            "Enter number(s) to check, separated by commas: "
+        ).strip()
+
+        if not value:
+            raise ValueError("Input cannot be empty.")
+
+        try:
+            args = tuple(int(item.strip()) for item in value.split(","))
+        except ValueError as exc:
+            raise ValueError(
+                "Enter valid integers separated by commas."
+            ) from exc
+
+    # Determine whether the caller supplied a collection or
+    # multiple individual arguments.
+    if len(args) == 1:
+        value = args[0]
+
+        if isinstance(value, (list, tuple, set, range)):
+            numbers = list(value)
+            input_type = type(value)
+        else:
+            numbers = [value]
+            input_type = None
+    else:
+        numbers = list(args)
+        input_type = tuple
+
+    if not numbers:
+        raise ValueError("At least one number must be provided.")
+
+    def check_number(n):
+        if isinstance(n, bool) or not isinstance(n, int):
+            raise TypeError("Every value must be an integer.")
+
+        if n < 0:
+            raise ValueError(
+                "Armstrong number checking requires non-negative integers."
+            )
+
+        digits = str(n)
+        power = len(digits)
+
+        total = sum(int(digit) ** power for digit in digits)
+
+        return total == n
+
+    results = [check_number(n) for n in numbers]
+
+    # Preserve a single result for a single integer.
+    if input_type is None:
+        return results[0]
+
+    if input_type is list or input_type is range:
+        return results
+
+    if input_type is tuple:
+        return tuple(results)
+
+    if input_type is set:
+        return set(results)
+
+    return results

jugaadcode-0.1.11/src/jugaadcode/binary_search.py

@@ -0,0 +1,119 @@
+from collections.abc import Iterable
+
+
+def binary_search(numbers=None, target=None, *additional_targets):
+    """
+    Search for one or more targets in a sorted sequence using binary search.
+
+    Supports:
+        binary_search([1, 3, 5, 7], 5)
+        binary_search((1, 3, 5, 7), 5)
+        binary_search([1, 3, 5, 7], [3, 7, 9])
+        binary_search([1, 3, 5, 7], 3, 7, 9)
+
+    If the sequence or target is omitted, prompts the user.
+
+    Parameters
+    ----------
+    numbers : iterable of int, optional
+        Sorted sequence to search.
+    target : int or iterable of int, optional
+        Target value or values to find.
+    *additional_targets : int
+        Additional targets to search for.
+
+    Returns
+    -------
+    int
+        Index of the target when a single target is provided.
+        Returns -1 if the target is not found.
+    list[int]
+        Indices for multiple targets, using -1 for missing values.
+
+    Raises
+    ------
+    TypeError
+        If the sequence or target contains unsupported values.
+    ValueError
+        If the sequence is not sorted in ascending order.
+    """
+
+    if numbers is None:
+        raw = input(
+            "Enter sorted numbers separated by spaces: "
+        ).strip()
+
+        if not raw:
+            raise ValueError("The numbers sequence cannot be empty.")
+
+        try:
+            numbers = list(map(int, raw.split()))
+        except ValueError as exc:
+            raise ValueError("Enter valid integers.") from exc
+
+    if isinstance(numbers, (str, bytes)):
+        raise TypeError("numbers must be a sequence of numeric values.")
+
+    if not isinstance(numbers, Iterable):
+        raise TypeError("numbers must be an iterable of integers.")
+
+    numbers = list(numbers)
+
+    if any(
+        isinstance(number, bool) or not isinstance(number, int)
+        for number in numbers
+    ):
+        raise TypeError("Every element in numbers must be an integer.")
+
+    if any(numbers[i] > numbers[i + 1] for i in range(len(numbers) - 1)):
+        raise ValueError("numbers must be sorted in ascending order.")
+
+    if target is None:
+        raw = input("Enter target (or targets separated by spaces): ").strip()
+
+        if not raw:
+            raise ValueError("At least one target must be provided.")
+
+        try:
+            parsed = list(map(int, raw.split()))
+        except ValueError as exc:
+            raise ValueError("Targets must be valid integers.") from exc
+
+        if len(parsed) == 1:
+            target = parsed[0]
+        else:
+            target = parsed
+
+    def search_one(value):
+        if isinstance(value, bool) or not isinstance(value, int):
+            raise TypeError("Every target must be an integer.")
+
+        left, right = 0, len(numbers) - 1
+
+        while left <= right:
+            middle = (left + right) // 2
+
+            if numbers[middle] == value:
+                return middle
+
+            if numbers[middle] < value:
+                left = middle + 1
+            else:
+                right = middle - 1
+
+        return -1
+
+    # Collect targets while preserving the original single-target behaviour.
+    if additional_targets:
+        targets = [target, *additional_targets]
+        multiple = True
+    elif isinstance(target, (list, tuple, set, range)):
+        targets = list(target)
+        multiple = True
+    else:
+        targets = [target]
+        multiple = False
+
+    results = [search_one(value) for value in targets]
+
+    return results if multiple else results[0]

jugaadcode-0.1.11/src/jugaadcode/bubble_sort.py

@@ -0,0 +1,94 @@
+from collections.abc import Iterable
+
+
+def bubble_sort(*args):
+    """
+    Sort numbers in ascending order using the Bubble Sort algorithm.
+
+    Supports:
+        bubble_sort([5, 2, 8, 1])
+        bubble_sort((5, 2, 8, 1))
+        bubble_sort(range(5, 0, -1))
+        bubble_sort(5, 2, 8, 1)
+        bubble_sort()
+
+    Parameters
+    ----------
+    *args
+        A collection of numbers, multiple numeric arguments,
+        or no arguments to enable interactive input.
+
+    Returns
+    -------
+    list
+        A new list containing the sorted numbers.
+
+    Raises
+    ------
+    TypeError
+        If the input is not a supported collection of comparable numbers.
+    ValueError
+        If interactive input is empty or contains invalid numbers.
+
+    Examples
+    --------
+    >>> bubble_sort([5, 2, 8, 1])
+    [1, 2, 5, 8]
+
+    >>> bubble_sort(5, 2, 8, 1)
+    [1, 2, 5, 8]
+    """
+
+    if not args:
+        raw = input("Enter numbers separated by spaces: ").strip()
+
+        if not raw:
+            raise ValueError("At least one number must be provided.")
+
+        try:
+            args = ([
+                float(value) if "." in value else int(value)
+                for value in raw.split()
+            ],)
+        except ValueError as exc:
+            raise ValueError("Enter valid numeric values.") from exc
+
+    # Accept a collection as the first argument or multiple arguments.
+    if len(args) == 1:
+        values = args[0]
+
+        if isinstance(values, (str, bytes)):
+            raise TypeError("Input must contain numbers, not a string.")
+
+        if isinstance(values, Iterable):
+            numbers = list(values)
+        else:
+            numbers = [values]
+    else:
+        numbers = list(args)
+
+    # Validate elements.
+    for number in numbers:
+        if isinstance(number, bool) or not isinstance(number, (int, float)):
+            raise TypeError("All elements must be integers or floats.")
+
+        if isinstance(number, float) and not __import__("math").isfinite(number):
+            raise ValueError("NaN and infinity are not supported.")
+
+    # Bubble Sort.
+    numbers = numbers.copy()
+    n = len(numbers)
+
+    for i in range(n):
+        swapped = False
+
+        for j in range(n - i - 1):
+            if numbers[j] > numbers[j + 1]:
+                numbers[j], numbers[j + 1] = numbers[j + 1], numbers[j]
+                swapped = True
+
+        # Stop early if the list is already sorted.
+        if not swapped:
+            break
+
+    return numbers

jugaadcode-0.1.11/src/jugaadcode/capitalize_words.py

@@ -0,0 +1,77 @@
+from collections.abc import Iterable
+
+
+def capitalize_words(*args):
+    """
+    Capitalize the first character of each word in one or more strings.
+
+    Supports:
+        capitalize_words("hello world")
+        capitalize_words("hello world", "python programming")
+        capitalize_words(["hello world", "python programming"])
+        capitalize_words(("hello world", "python programming"))
+        capitalize_words()
+
+    Parameters
+    ----------
+    *args : str or iterable of str
+        One string, multiple strings, or a collection of strings.
+        If no arguments are supplied, prompts for interactive input.
+
+    Returns
+    -------
+    str or list[str] or tuple[str, ...]
+        A capitalized string for a single string.
+        A list or tuple for multiple strings, matching the input style.
+
+    Raises
+    ------
+    TypeError
+        If an input is not a string or supported collection of strings.
+
+    Examples
+    --------
+    >>> capitalize_words("hello world")
+    'Hello World'
+
+    >>> capitalize_words(["hello world", "python programming"])
+    ['Hello World', 'Python Programming']
+    """
+
+    if not args:
+        text = input("Enter a sentence to capitalize words in: ")
+        return text.title()
+
+    # Handle multiple positional strings.
+    if all(isinstance(arg, str) for arg in args):
+        if len(args) == 1:
+            return args[0].title()
+
+        return tuple(text.title() for text in args)
+
+    # Handle a single collection of strings.
+    if len(args) == 1:
+        values = args[0]
+
+        if isinstance(values, str):
+            return values.title()
+
+        if isinstance(values, Iterable):
+            if isinstance(values, (bytes, bytearray)):
+                raise TypeError("Input must contain strings, not bytes.")
+
+            texts = list(values)
+
+            if not all(isinstance(text, str) for text in texts):
+                raise TypeError("Every element must be a string.")
+
+            results = [text.title() for text in texts]
+
+            if isinstance(values, tuple):
+                return tuple(results)
+
+            return results
+
+    raise TypeError(
+        "Provide a string, multiple strings, or a collection of strings."
+    )

jugaadcode-0.1.11/src/jugaadcode/character_frequency.py

@@ -0,0 +1,85 @@
+from collections.abc import Iterable
+from collections import Counter
+
+
+def character_frequency(*args):
+    """
+    Count the frequency of each character in one or more strings.
+
+    Spaces are ignored. Other whitespace characters, such as tabs
+    and newlines, are counted.
+
+    Supports:
+        character_frequency("hello")
+        character_frequency("hello", "world")
+        character_frequency(["hello", "world"])
+        character_frequency(("hello", "world"))
+        character_frequency()
+
+    Parameters
+    ----------
+    *args : str or iterable of str
+        A string, multiple strings, or a collection of strings.
+        If no arguments are supplied, prompts for interactive input.
+
+    Returns
+    -------
+    dict[str, int] or list[dict[str, int]] or tuple[dict[str, int], ...]
+        A frequency dictionary for one string.
+        A collection of frequency dictionaries for multiple strings.
+
+    Raises
+    ------
+    TypeError
+        If an input is not a string or a supported collection of strings.
+
+    Examples
+    --------
+    >>> character_frequency("hello")
+    {'h': 1, 'e': 1, 'l': 2, 'o': 1}
+
+    >>> character_frequency(["hello", "world"])
+    [{'h': 1, 'e': 1, 'l': 2, 'o': 1},
+     {'w': 1, 'o': 1, 'r': 1, 'l': 1, 'd': 1}]
+    """
+
+    if not args:
+        text = input("Enter a string to analyze character frequency: ")
+        args = (text,)
+
+    def count_characters(text):
+        if not isinstance(text, str):
+            raise TypeError("Every input must be a string.")
+
+        return dict(Counter(character for character in text if character != " "))
+
+    # A single string produces one frequency dictionary.
+    if len(args) == 1 and isinstance(args[0], str):
+        return count_characters(args[0])
+
+    # Multiple positional strings produce multiple dictionaries.
+    if all(isinstance(arg, str) for arg in args):
+        return tuple(count_characters(text) for text in args)
+
+    # A collection of strings produces one dictionary per string.
+    if len(args) == 1 and isinstance(args[0], Iterable):
+        values = args[0]
+
+        if isinstance(values, (bytes, bytearray)):
+            raise TypeError("Input must contain strings, not bytes.")
+
+        texts = list(values)
+
+        if not all(isinstance(text, str) for text in texts):
+            raise TypeError("Every element in the collection must be a string.")
+
+        results = [count_characters(text) for text in texts]
+
+        if isinstance(values, tuple):
+            return tuple(results)
+
+        return results
+
+    raise TypeError(
+        "Provide a string, multiple strings, or a collection of strings."
+    )

jugaadcode-0.1.11/src/jugaadcode/climbing_stairs.py

@@ -0,0 +1,104 @@
+from collections.abc import Iterable
+
+
+def climbing_stairs(*args):
+    """
+    Calculate the number of distinct ways to climb stairs,
+    taking either 1 or 2 steps at a time.
+
+    Supports:
+        climbing_stairs(5)
+        climbing_stairs(3, 5, 7)
+        climbing_stairs([3, 5, 7])
+        climbing_stairs((3, 5, 7))
+        climbing_stairs(range(1, 6))
+        climbing_stairs()
+
+    Parameters
+    ----------
+    *args : int or iterable of int
+        One stair count, multiple stair counts, or a collection
+        of stair counts. If omitted, prompts for interactive input.
+
+    Returns
+    -------
+    int or list[int] or tuple[int, ...]
+        The number of ways for one input or multiple inputs.
+        For n = 0, returns 1 because there is one way to climb
+        zero stairs: take no steps.
+
+    Raises
+    ------
+    TypeError
+        If an input is not an integer or supported collection.
+    ValueError
+        If any stair count is negative.
+
+    Examples
+    --------
+    >>> climbing_stairs(2)
+    2
+    >>> climbing_stairs(5)
+    8
+    >>> climbing_stairs([2, 3, 5])
+    [2, 3, 8]
+    """
+
+    if not args:
+        raw = input("Enter number(s) of stairs, separated by spaces: ").strip()
+
+        if not raw:
+            raise ValueError("At least one stair count must be provided.")
+
+        try:
+            args = tuple(int(value) for value in raw.split())
+        except ValueError as exc:
+            raise ValueError("Stair counts must be integers.") from exc
+
+    # Determine whether input is a single value, collection,
+    # or multiple positional values.
+    if len(args) == 1:
+        value = args[0]
+
+        if isinstance(value, (list, tuple, range)):
+            numbers = list(value)
+            input_type = type(value)
+        else:
+            numbers = [value]
+            input_type = None
+    else:
+        numbers = list(args)
+        input_type = tuple
+
+    if not numbers:
+        raise ValueError("At least one stair count must be provided.")
+
+    def count_ways(n):
+        if isinstance(n, bool) or not isinstance(n, int):
+            raise TypeError("Every stair count must be an integer.")
+
+        if n < 0:
+            raise ValueError("The number of stairs cannot be negative.")
+
+        if n == 0:
+            return 1
+
+        if n <= 2:
+            return n
+
+        first, second = 1, 2
+
+        for _ in range(3, n + 1):
+            first, second = second, first + second
+
+        return second
+
+    results = [count_ways(n) for n in numbers]
+
+    if input_type is None:
+        return results[0]
+
+    if input_type is tuple:
+        return tuple(results)
+
+    return results