jugaadcode 0.1.16__tar.gz → 0.1.18__tar.gz

{jugaadcode-0.1.16 → jugaadcode-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jugaadcode
-Version: 0.1.16
+Version: 0.1.18
 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.16 → jugaadcode-0.1.18}/pyproject.toml

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

jugaadcode-0.1.18/src/jugaadcode/anagram.py

@@ -0,0 +1,86 @@
+from collections.abc import Iterable
+
+
+def is_anagram(*args):
+    """Check whether two or more strings are anagrams.
+
+    Supports:
+    - Interactive input
+    - Two individual strings
+    - Multiple strings, compared in pairs
+    - Lists, tuples, sets, and other iterables
+    - Collections containing pairs of strings
+
+    Returns:
+    - bool for one pair
+    - list of bools for multiple pairs
+    """
+
+    def compare_pair(pair):
+        first, second = pair
+
+        if not isinstance(first, str) or not isinstance(second, str):
+            raise TypeError("Both values must be strings.")
+
+        return sorted(first.casefold().replace(" ", "")) == sorted(
+            second.casefold().replace(" ", "")
+        )
+
+    def process_collection(values):
+        values = list(values)
+
+        if len(values) == 2 and all(
+            isinstance(value, str) for value in values
+        ):
+            return compare_pair(values)
+
+        if len(values) % 2 == 0 and all(
+            isinstance(value, str) for value in values
+        ):
+            return [
+                compare_pair(values[i:i + 2])
+                for i in range(0, len(values), 2)
+            ]
+
+        if all(
+            isinstance(pair, (list, tuple)) and len(pair) == 2
+            for pair in values
+        ):
+            results = [compare_pair(pair) for pair in values]
+            return results
+
+        raise ValueError(
+            "Provide two strings, an even number of strings, "
+            "or a collection of string pairs."
+        )
+
+    # No arguments: interactive mode
+    if not args:
+        first = input("Enter the first string: ")
+        second = input("Enter the second string: ")
+        return compare_pair((first, second))
+
+    # Multiple positional arguments
+    if len(args) > 1:
+        if len(args) == 2 and all(isinstance(arg, str) for arg in args):
+            return compare_pair(args)
+
+        return process_collection(args)
+
+    value = args[0]
+
+    # One string: prompt for the second string
+    if isinstance(value, str):
+        second = input("Enter the second string to compare: ")
+        return compare_pair((value, second))
+
+    # Reject non-iterable values
+    if isinstance(value, (bytes, bytearray)) or not isinstance(
+        value, Iterable
+    ):
+        raise TypeError(
+            "Input must be a string or an iterable of strings/pairs."
+        )
+
+    # Process lists, tuples, sets, generators, and other iterables
+    return process_collection(value)

jugaadcode-0.1.18/src/jugaadcode/armstrong.py

@@ -0,0 +1,127 @@
+from collections.abc import Iterable
+
+
+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(n for n in [153, 370, 123])
+        is_armstrong()
+        
+    Returns
+    -------
+    bool
+        For a single integer.
+
+    list[bool]
+        For lists, sets, ranges, generators, and other iterables.
+
+    tuple[bool, ...]
+        For tuples or multiple positional arguments.
+
+    Raises
+    ------
+    TypeError
+        If an input is not an integer or supported iterable.
+
+    ValueError
+        If an input contains a negative integer or no values.
+    """
+
+    # Interactive input when no arguments are provided.
+    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 the input format.
+    if len(args) > 1:
+        # Multiple positional arguments.
+        numbers = list(args)
+        input_type = "tuple"
+
+    else:
+        value = args[0]
+
+        if isinstance(value, bool):
+            numbers = [value]
+            input_type = "single"
+
+        elif isinstance(value, int):
+            numbers = [value]
+            input_type = "single"
+
+        elif isinstance(value, (str, bytes, bytearray)):
+            raise TypeError(
+                "Input must contain integers, not strings or bytes."
+            )
+
+        elif isinstance(value, Iterable):
+            numbers = list(value)
+
+            if isinstance(value, tuple):
+                input_type = "tuple"
+            else:
+                input_type = "list"
+
+        else:
+            raise TypeError(
+                "Input must be an integer or an iterable of integers."
+            )
+
+    # Reject empty collections and generators.
+    if not numbers:
+        raise ValueError("At least one number must be provided.")
+
+    def check_number(n):
+        # Booleans are not accepted as integers.
+        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
+
+    # Calculate results.
+    results = [
+        check_number(n) for n in numbers
+    ]
+
+    # Return the result in the appropriate format.
+    if input_type == "single":
+        return results[0]
+
+    if input_type == "tuple":
+        return tuple(results)
+
+    return results

{jugaadcode-0.1.16 → jugaadcode-0.1.18}/src/jugaadcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jugaadcode
-Version: 0.1.16
+Version: 0.1.18
 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.16/src/jugaadcode/anagram.py

@@ -1,115 +0,0 @@
-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.16/src/jugaadcode/armstrong.py

@@ -1,93 +0,0 @@
-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