algonest 0.1.0__tar.gz

algonest-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 dsa-kit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

algonest-0.1.0/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: algonest
+Version: 0.1.0
+Summary: Lightweight DSA utilities for Python
+Author: Varun K S
+License: MIT
+Project-URL: Homepage, https://github.com/your-org/algonest
+Project-URL: Repository, https://github.com/your-org/algonest
+Project-URL: Issues, https://github.com/your-org/algonest/issues
+Keywords: dsa,algorithms,data-structures,python,interview
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries
+Classifier: Topic :: Education
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: flake8>=6.0; extra == "dev"
+Dynamic: license-file
+
+# AlgoNest
+
+algonest is a clean, reusable Python DSA utility package focused on production-ready implementations of core algorithmic patterns.
+
+## Installation
+
+```bash
+pip install algonest
+```
+
+## Included Modules
+
+- `algonest.search.binary_search`: `lower_bound`, `upper_bound`, `binary_search`
+- `algonest.arrays.sliding_window`: `max_sum_subarray_k`, `longest_unique_substring`
+- `algonest.sort.sorting`: classical sorting algorithms
+- `algonest.linked_list`: linked list data structures
+- `algonest.stack_queue`: stack, queue, deque, monotonic stack utilities
+- `algonest.heap`: min heap, max heap, priority queue
+- `algonest.trees`: binary trees, BST/AVL, traversals, segment/fenwick trees
+- `algonest.graphs`: traversal, shortest path, MST, DSU, topological sorting
+- `algonest.dynamic_programming`: knapsack, LCS/LIS, coin change, MCM, edit distance
+- `algonest.strings`: KMP, Rabin-Karp, Z algorithm, trie, anagram utilities
+- `algonest.math`: gcd/lcm, prime utilities, modular arithmetic, bit tricks
+- `algonest.utils`: validators and shared type helper aliases
+
+## Quick Start
+
+```python
+from algonest import (
+	binary_search,
+	longest_unique_substring,
+	lower_bound,
+	max_sum_subarray_k,
+	upper_bound,
+)
+
+idx = lower_bound([1, 2, 2, 4], 2)
+hi = upper_bound([1, 2, 2, 4], 2)
+pos = binary_search([1, 3, 5, 7], 5)
+best = max_sum_subarray_k([2, 1, 5, 1, 3, 2], 3)
+size = longest_unique_substring("abcabcbb")
+```
+
+## Testing
+
+```bash
+python -m pytest -q tests
+```

algonest-0.1.0/README.md

@@ -0,0 +1,48 @@
+# AlgoNest
+
+algonest is a clean, reusable Python DSA utility package focused on production-ready implementations of core algorithmic patterns.
+
+## Installation
+
+```bash
+pip install algonest
+```
+
+## Included Modules
+
+- `algonest.search.binary_search`: `lower_bound`, `upper_bound`, `binary_search`
+- `algonest.arrays.sliding_window`: `max_sum_subarray_k`, `longest_unique_substring`
+- `algonest.sort.sorting`: classical sorting algorithms
+- `algonest.linked_list`: linked list data structures
+- `algonest.stack_queue`: stack, queue, deque, monotonic stack utilities
+- `algonest.heap`: min heap, max heap, priority queue
+- `algonest.trees`: binary trees, BST/AVL, traversals, segment/fenwick trees
+- `algonest.graphs`: traversal, shortest path, MST, DSU, topological sorting
+- `algonest.dynamic_programming`: knapsack, LCS/LIS, coin change, MCM, edit distance
+- `algonest.strings`: KMP, Rabin-Karp, Z algorithm, trie, anagram utilities
+- `algonest.math`: gcd/lcm, prime utilities, modular arithmetic, bit tricks
+- `algonest.utils`: validators and shared type helper aliases
+
+## Quick Start
+
+```python
+from algonest import (
+	binary_search,
+	longest_unique_substring,
+	lower_bound,
+	max_sum_subarray_k,
+	upper_bound,
+)
+
+idx = lower_bound([1, 2, 2, 4], 2)
+hi = upper_bound([1, 2, 2, 4], 2)
+pos = binary_search([1, 3, 5, 7], 5)
+best = max_sum_subarray_k([2, 1, 5, 1, 3, 2], 3)
+size = longest_unique_substring("abcabcbb")
+```
+
+## Testing
+
+```bash
+python -m pytest -q tests
+```

algonest-0.1.0/algonest/__init__.py

@@ -0,0 +1,223 @@
+"""Public API for algonest Phase 5."""
+
+from algonest.arrays import (
+    container_with_water,
+    longest_unique_substring,
+    max_subarray_sum,
+    max_sum_subarray_k,
+    partition_by_pivot,
+    prefix_sum,
+    range_sum,
+    remove_duplicates,
+    sort_three_values,
+    subarray_sum_equals_k,
+    two_sum_sorted,
+)
+from algonest.search import (
+    binary_search,
+    jump_search,
+    linear_search,
+    lower_bound,
+    ternary_search,
+    upper_bound,
+)
+from algonest.heap import MaxHeap, MinHeap, PriorityQueue
+from algonest.linked_list import (
+    CircularLinkedList,
+    DoublyLinkedList,
+    DoublyListNode,
+    ListNode,
+    SinglyLinkedList,
+)
+from algonest.sort import (
+    bubble_sort,
+    counting_sort,
+    heap_sort,
+    insertion_sort,
+    merge_sort,
+    quick_sort,
+    radix_sort,
+    selection_sort,
+)
+from algonest.stack_queue import (
+    DequeDS,
+    Queue,
+    Stack,
+    largest_rectangle_in_histogram,
+    next_greater_element,
+)
+from algonest.dynamic_programming import (
+    coin_change_ways,
+    edit_distance,
+    knapsack_01,
+    lcs_length,
+    lis_length,
+    matrix_chain_order,
+    min_coins,
+    unbounded_knapsack,
+)
+from algonest.graphs import (
+    DSU,
+    bellman_ford,
+    bfs_traversal,
+    connected_components,
+    dfs_topological_sort,
+    dfs_traversal,
+    dijkstra_shortest_paths,
+    floyd_warshall,
+    has_cycle_undirected,
+    kahn_topological_sort,
+    kruskal_mst,
+    prim_mst,
+    shortest_path_unweighted,
+)
+from algonest.trees import (
+    AVLTree,
+    BST,
+    BinaryTree,
+    FenwickTree,
+    SegmentTree,
+    TreeNode,
+    inorder,
+    level_order,
+    postorder,
+    preorder,
+)
+from algonest.strings import (
+    Trie,
+    find_all_anagrams,
+    group_anagrams,
+    is_anagram,
+    kmp_search,
+    rabin_karp_search,
+    z_array,
+    z_search,
+)
+from algonest.math import (
+    chinese_remainder_theorem,
+    clear_bit,
+    count_bits,
+    extended_gcd,
+    fast_power,
+    gcd,
+    is_power_of_two,
+    is_prime,
+    lcm,
+    mod_exp,
+    mod_inverse,
+    prime_factors,
+    set_bit,
+    sieve_of_eratosthenes,
+    xor_trick,
+)
+from algonest.utils import (
+    assert_sorted,
+    build_pytest_command,
+    read_ints_from_text,
+    run_tests,
+    time_function,
+    validate_iterable,
+    write_lines,
+)
+
+__all__ = [
+    "lower_bound",
+    "upper_bound",
+    "binary_search",
+    "linear_search",
+    "ternary_search",
+    "jump_search",
+    "max_sum_subarray_k",
+    "longest_unique_substring",
+    "two_sum_sorted",
+    "remove_duplicates",
+    "container_with_water",
+    "prefix_sum",
+    "range_sum",
+    "subarray_sum_equals_k",
+    "max_subarray_sum",
+    "sort_three_values",
+    "partition_by_pivot",
+    "bubble_sort",
+    "selection_sort",
+    "insertion_sort",
+    "merge_sort",
+    "quick_sort",
+    "heap_sort",
+    "counting_sort",
+    "radix_sort",
+    "ListNode",
+    "DoublyListNode",
+    "SinglyLinkedList",
+    "DoublyLinkedList",
+    "CircularLinkedList",
+    "Stack",
+    "Queue",
+    "DequeDS",
+    "next_greater_element",
+    "largest_rectangle_in_histogram",
+    "MinHeap",
+    "MaxHeap",
+    "PriorityQueue",
+    "TreeNode",
+    "BinaryTree",
+    "BST",
+    "inorder",
+    "preorder",
+    "postorder",
+    "level_order",
+    "AVLTree",
+    "SegmentTree",
+    "FenwickTree",
+    "bfs_traversal",
+    "shortest_path_unweighted",
+    "dfs_traversal",
+    "connected_components",
+    "has_cycle_undirected",
+    "dijkstra_shortest_paths",
+    "bellman_ford",
+    "floyd_warshall",
+    "kahn_topological_sort",
+    "dfs_topological_sort",
+    "kruskal_mst",
+    "prim_mst",
+    "DSU",
+    "knapsack_01",
+    "unbounded_knapsack",
+    "lcs_length",
+    "lis_length",
+    "min_coins",
+    "coin_change_ways",
+    "matrix_chain_order",
+    "edit_distance",
+    "kmp_search",
+    "rabin_karp_search",
+    "z_array",
+    "z_search",
+    "Trie",
+    "group_anagrams",
+    "is_anagram",
+    "find_all_anagrams",
+    "gcd",
+    "lcm",
+    "extended_gcd",
+    "sieve_of_eratosthenes",
+    "is_prime",
+    "prime_factors",
+    "mod_exp",
+    "mod_inverse",
+    "chinese_remainder_theorem",
+    "fast_power",
+    "count_bits",
+    "is_power_of_two",
+    "set_bit",
+    "clear_bit",
+    "xor_trick",
+    "validate_iterable",
+    "read_ints_from_text",
+    "write_lines",
+    "time_function",
+    "assert_sorted",
+    "build_pytest_command",
+    "run_tests",
+]

algonest-0.1.0/algonest/arrays/__init__.py

@@ -0,0 +1,21 @@
+"""Array algorithms package."""
+
+from algonest.arrays.dutch_flag import partition_by_pivot, sort_three_values
+from algonest.arrays.kadane import max_subarray_sum
+from algonest.arrays.prefix_sum import prefix_sum, range_sum, subarray_sum_equals_k
+from algonest.arrays.sliding_window import longest_unique_substring, max_sum_subarray_k
+from algonest.arrays.two_pointers import container_with_water, remove_duplicates, two_sum_sorted
+
+__all__ = [
+	"max_sum_subarray_k",
+	"longest_unique_substring",
+	"two_sum_sorted",
+	"remove_duplicates",
+	"container_with_water",
+	"prefix_sum",
+	"range_sum",
+	"subarray_sum_equals_k",
+	"max_subarray_sum",
+	"sort_three_values",
+	"partition_by_pivot",
+]

algonest-0.1.0/algonest/arrays/dutch_flag.py

@@ -0,0 +1,92 @@
+"""Dutch flag partitioning algorithms."""
+
+from typing import Any, Iterable, List
+
+from algonest.utils import _validate_iterable
+
+
+def sort_three_values(
+    arr: Iterable[Any],
+    low_value: Any,
+    mid_value: Any,
+    high_value: Any,
+) -> List[Any]:
+    """Return values sorted by low/mid/high categories in one pass.
+
+    Args:
+        arr (Iterable[Any]): Iterable containing only three category values.
+        low_value (Any): Category that should appear first.
+        mid_value (Any): Category that should appear second.
+        high_value (Any): Category that should appear third.
+
+    Returns:
+        List[Any]: Newly sorted list by category order.
+
+    Raises:
+        TypeError: If arr is not iterable.
+        ValueError: If arr contains values outside the three categories.
+
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+
+    Example:
+        >>> sort_three_values([2, 0, 1, 2, 1, 0], 0, 1, 2)
+        [0, 0, 1, 1, 2, 2]
+    """
+    values = _validate_iterable(arr)
+    allowed = {low_value, mid_value, high_value}
+    for value in values:
+        if value not in allowed:
+            raise ValueError("arr must contain only the three provided values")
+
+    out = values[:]
+    low = 0
+    mid = 0
+    high = len(out) - 1
+    while mid <= high:
+        if out[mid] == low_value:
+            out[low], out[mid] = out[mid], out[low]
+            low += 1
+            mid += 1
+        elif out[mid] == mid_value:
+            mid += 1
+        else:
+            out[mid], out[high] = out[high], out[mid]
+            high -= 1
+    return out
+
+
+def partition_by_pivot(arr: Iterable[Any], pivot: Any) -> List[Any]:
+    """Return values partitioned into < pivot, == pivot, > pivot.
+
+    Args:
+        arr (Iterable[Any]): Iterable input values.
+        pivot (Any): Pivot for partitioning.
+
+    Returns:
+        List[Any]: Partitioned list.
+
+    Raises:
+        TypeError: If arr is not iterable.
+
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+
+    Example:
+        >>> partition_by_pivot([3, 5, 2, 5, 1], 3)
+        [2, 1, 3, 5, 5]
+    """
+    values = _validate_iterable(arr)
+    lower: List[Any] = []
+    equal: List[Any] = []
+    higher: List[Any] = []
+
+    for value in values:
+        if value < pivot:
+            lower.append(value)
+        elif value == pivot:
+            equal.append(value)
+        else:
+            higher.append(value)
+
+    return lower + equal + higher

algonest-0.1.0/algonest/arrays/kadane.py

@@ -0,0 +1,42 @@
+"""Kadane algorithm for maximum subarray sum."""
+
+from numbers import Real
+from typing import Iterable
+
+from algonest.utils import _validate_iterable
+
+
+def max_subarray_sum(arr: Iterable[Real]) -> Real:
+    """Return the maximum sum among all contiguous subarrays.
+
+    Args:
+        arr (Iterable[Real]): Iterable of numeric values.
+
+    Returns:
+        Real: Maximum contiguous subarray sum.
+
+    Raises:
+        TypeError: If arr is not iterable or contains non-numeric values.
+        ValueError: If input is empty.
+
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+
+    Example:
+        >>> max_subarray_sum([-2, 1, -3, 4, -1, 2, 1, -5, 4])
+        6
+    """
+    values = _validate_iterable(arr)
+    if not values:
+        raise ValueError("arr cannot be empty")
+
+    for value in values:
+        if not isinstance(value, Real) or isinstance(value, bool):
+            raise TypeError("All elements in arr must be numeric")
+
+    current = values[0]
+    best = values[0]
+    for value in values[1:]:
+        current = max(value, current + value)
+        best = max(best, current)
+    return best

algonest-0.1.0/algonest/arrays/prefix_sum.py

@@ -0,0 +1,115 @@
+"""Prefix-sum based array algorithms."""
+
+from numbers import Real
+from typing import Any, Iterable, List
+
+from algonest.utils import _validate_iterable
+
+
+def prefix_sum(arr: Iterable[Real]) -> List[Real]:
+    """Return prefix sums for numeric iterable input.
+
+    Args:
+        arr (Iterable[Real]): Iterable of numeric values.
+
+    Returns:
+        List[Real]: Prefix sums where out[i] = sum(arr[0:i+1]).
+
+    Raises:
+        TypeError: If arr is not iterable or contains non-numeric values.
+
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+
+    Example:
+        >>> prefix_sum([3, 5, 2, 7])
+        [3, 8, 10, 17]
+    """
+    values = _validate_iterable(arr)
+    out: List[Real] = []
+    running: Real = 0
+
+    for value in values:
+        if not isinstance(value, Real) or isinstance(value, bool):
+            raise TypeError("All elements in arr must be numeric")
+        running += value
+        out.append(running)
+    return out
+
+
+def range_sum(prefix: Iterable[Real], left: int, right: int) -> Real:
+    """Return inclusive sum from left to right using prefix sums.
+
+    Args:
+        prefix (Iterable[Real]): Prefix-sum iterable.
+        left (int): Left index, inclusive.
+        right (int): Right index, inclusive.
+
+    Returns:
+        Real: Sum over [left, right].
+
+    Raises:
+        TypeError: If prefix is not iterable or bounds are not integers.
+        ValueError: If prefix is empty or left > right.
+        IndexError: If bounds are out of range.
+
+    Time Complexity: O(1)
+    Space Complexity: O(n)
+
+    Example:
+        >>> p = prefix_sum([3, 5, 2, 7])
+        >>> range_sum(p, 1, 3)
+        14
+    """
+    values = _validate_iterable(prefix)
+    if not values:
+        raise ValueError("prefix cannot be empty")
+    if not isinstance(left, int) or isinstance(left, bool):
+        raise TypeError("left must be an integer")
+    if not isinstance(right, int) or isinstance(right, bool):
+        raise TypeError("right must be an integer")
+    if left > right:
+        raise ValueError("left cannot be greater than right")
+    if left < 0 or right < 0 or left >= len(values) or right >= len(values):
+        raise IndexError("left and right must be valid indices")
+
+    return values[right] if left == 0 else values[right] - values[left - 1]
+
+
+def subarray_sum_equals_k(arr: Iterable[Real], k: Real) -> int:
+    """Return count of contiguous subarrays with sum exactly equal to k.
+
+    Args:
+        arr (Iterable[Real]): Iterable of numeric values.
+        k (Real): Target sum.
+
+    Returns:
+        int: Number of matching subarrays.
+
+    Raises:
+        TypeError: If arr is not iterable or contains non-numeric values.
+        TypeError: If k is not numeric.
+
+    Time Complexity: O(n)
+    Space Complexity: O(n)
+
+    Example:
+        >>> subarray_sum_equals_k([1, 1, 1], 2)
+        2
+    """
+    values = _validate_iterable(arr)
+    if not isinstance(k, Real) or isinstance(k, bool):
+        raise TypeError("k must be numeric")
+
+    for value in values:
+        if not isinstance(value, Real) or isinstance(value, bool):
+            raise TypeError("All elements in arr must be numeric")
+
+    count = 0
+    running: Real = 0
+    seen = {0: 1}
+    for value in values:
+        running += value
+        count += seen.get(running - k, 0)
+        seen[running] = seen.get(running, 0) + 1
+    return count