jugaadcode 0.1.15__tar.gz → 0.1.17__tar.gz

{jugaadcode-0.1.15 → jugaadcode-0.1.17}/PKG-INFO

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

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

jugaadcode-0.1.17/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.17/src/jugaadcode/trailing_zeros.py

@@ -0,0 +1,64 @@
+from collections.abc import Iterable
+
+
+def trailing_zeros(*args):
+    """
+    Count trailing zeros in the factorial of non-negative integers.
+
+    Examples:
+        trailing_zeros(5)           -> 1
+        trailing_zeros(10)          -> 2
+        trailing_zeros([5, 10, 25]) -> [1, 2, 6]
+        trailing_zeros((5, 10, 25)) -> (1, 2, 6)
+        trailing_zeros(5, 10, 25)   -> (1, 2, 6)
+    """
+
+    def calculate(n):
+        if isinstance(n, bool) or not isinstance(n, int):
+            raise TypeError("Input must be an integer.")
+
+        if n < 0:
+            raise ValueError("Number must be non-negative.")
+
+        count = 0
+
+        while n > 0:
+            n //= 5
+            count += n
+
+        return count
+
+    # Interactive input
+    if not args:
+        n = int(input("Enter a non-negative integer: "))
+        return calculate(n)
+
+    # Multiple positional arguments
+    if len(args) > 1:
+        return tuple(calculate(n) for n in args)
+
+    value = args[0]
+
+    # Single integer
+    if isinstance(value, int) and not isinstance(value, bool):
+        return calculate(value)
+
+    # Reject strings and bytes
+    if isinstance(value, (str, bytes, bytearray)):
+        raise TypeError(
+            "Input must be an integer or an iterable of integers."
+        )
+
+    # Lists, tuples, and other iterables
+    if isinstance(value, Iterable):
+        numbers = list(value)
+        results = [calculate(n) for n in numbers]
+
+        if isinstance(value, tuple):
+            return tuple(results)
+
+        return results
+
+    raise TypeError(
+        "Input must be an integer or an iterable of integers."
+    )

{jugaadcode-0.1.15 → jugaadcode-0.1.17}/src/jugaadcode.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: jugaadcode
-Version: 0.1.15
+Version: 0.1.17
 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.15/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.15/src/jugaadcode/trailing_zeros.py

@@ -1,16 +0,0 @@
-from collections.abc import Iterable
-
-def trailing_zeros(*args):
-    if n is None:
-        n = int(input("Enter a number: "))
-
-    if n < 0:
-        raise ValueError("Number must be non-negative")
-
-    count = 0
-
-    while n > 0:
-        n //= 5
-        count += n
-
-    return count