Merge pull request #2718 from keon/feature/community-algorithms

Add 15 community-contributed algorithms

Author: keon

README.md

@@ -163,6 +163,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 | Graph | `graph.py` | `Node`, `DirectedEdge`, `DirectedGraph` |
 | Hash Table | `hash_table.py` | `HashTable`, `ResizableHashTable` |
 | Heap | `heap.py` | `BinaryHeap` |
+| KD Tree | `kd_tree.py` | `KDTree` |
 | Linked List | `linked_list.py` | `SinglyLinkedListNode`, `DoublyLinkedListNode` |
 | Priority Queue | `priority_queue.py` | `PriorityQueue` |
 | Queue | `queue.py` | `ArrayQueue`, `LinkedListQueue` |
@@ -213,6 +214,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [permute](algorithms/backtracking/permute.py) — generate all permutations of distinct elements
 - [permute_unique](algorithms/backtracking/permute_unique.py) — generate unique permutations when duplicates exist
 - [subsets](algorithms/backtracking/subsets.py) — generate all subsets (power set)
+- [minimax](algorithms/backtracking/minimax.py) — game-tree search with alpha-beta pruning
 - [subsets_unique](algorithms/backtracking/subsets_unique.py) — generate unique subsets when duplicates exist
 
 ### Bit Manipulation
@@ -226,6 +228,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [find_difference](algorithms/bit_manipulation/find_difference.py) — find the added character between two strings using XOR
 - [find_missing_number](algorithms/bit_manipulation/find_missing_number.py) — find a missing number in a sequence using XOR
 - [flip_bit_longest_sequence](algorithms/bit_manipulation/flip_bit_longest_sequence.py) — longest run of 1s after flipping a single 0
+- [gray_code](algorithms/bit_manipulation/gray_code.py) — generate Gray code sequences and convert between Gray and binary
 - [has_alternative_bit](algorithms/bit_manipulation/has_alternative_bit.py) — check if binary representation has alternating bits
 - [insert_bit](algorithms/bit_manipulation/insert_bit.py) — insert bits at a specific position in an integer
 - [power_of_two](algorithms/bit_manipulation/power_of_two.py) — check if an integer is a power of two
@@ -245,10 +248,12 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 
 ### Dynamic Programming
 
+- [bitmask](algorithms/dynamic_programming/bitmask.py) — travelling salesman problem via bitmask dynamic programming
 - [buy_sell_stock](algorithms/dynamic_programming/buy_sell_stock.py) — maximize profit from a stock price array
 - [climbing_stairs](algorithms/dynamic_programming/climbing_stairs.py) — count ways to climb stairs taking 1 or 2 steps
 - [coin_change](algorithms/dynamic_programming/coin_change.py) — minimum coins to make a given amount
 - [combination_sum](algorithms/dynamic_programming/combination_sum.py) — count combinations that sum to a target (with reuse)
+- [count_paths_dp](algorithms/dynamic_programming/count_paths_dp.py) — count paths in a grid using recursion, memoization, and bottom-up DP
 - [edit_distance](algorithms/dynamic_programming/edit_distance.py) — minimum edits to transform one string into another
 - [egg_drop](algorithms/dynamic_programming/egg_drop.py) — minimize trials to find the critical floor
 - [fibonacci](algorithms/dynamic_programming/fib.py) — compute Fibonacci numbers with memoization
@@ -276,6 +281,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [all_factors](algorithms/graph/all_factors.py) — find all factor combinations of a number
 - [all_pairs_shortest_path](algorithms/graph/all_pairs_shortest_path.py) — Floyd-Warshall all-pairs shortest paths
 - [bellman_ford](algorithms/graph/bellman_ford.py) — single-source shortest path with negative edge weights
+- [blossom](algorithms/graph/blossom.py) — Edmonds' blossom algorithm for maximum matching in general graphs
 - [check_bipartite](algorithms/graph/check_bipartite.py) — determine if a graph is two-colorable
 - [check_digraph_strongly_connected](algorithms/graph/check_digraph_strongly_connected.py) — check if a directed graph is strongly connected
 - [clone_graph](algorithms/graph/clone_graph.py) — deep-copy an undirected graph
@@ -371,7 +377,9 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [hailstone](algorithms/math/hailstone.py) — Collatz conjecture (hailstone) sequence
 - [is_strobogrammatic](algorithms/math/is_strobogrammatic.py) — check if a number looks the same upside-down
 - [krishnamurthy_number](algorithms/math/krishnamurthy_number.py) — check if a number equals the sum of the factorials of its digits
+- [linear_regression](algorithms/math/linear_regression.py) — ordinary least-squares linear regression with R² and RMSE
 - [magic_number](algorithms/math/magic_number.py) — check if a number is a magic number
+- [manhattan_distance](algorithms/math/manhattan_distance.py) — compute Manhattan (L1) distance between two points in any dimension
 - [modular_exponential](algorithms/math/modular_exponential.py) — compute (base^exp) mod m efficiently
 - [modular_inverse](algorithms/math/modular_inverse.py) — compute the modular multiplicative inverse
 - [next_bigger](algorithms/math/next_bigger.py) — next larger number with the same digits
@@ -380,6 +388,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [num_digits](algorithms/math/num_digits.py) — count the number of digits in an integer
 - [num_perfect_squares](algorithms/math/num_perfect_squares.py) — minimum perfect squares that sum to n
 - [polynomial](algorithms/math/polynomial.py) — polynomial and monomial arithmetic operations
+- [polynomial_division](algorithms/math/polynomial_division.py) — polynomial long division returning quotient and remainder
 - [power](algorithms/math/power.py) — compute x^n via binary exponentiation
 - [prime_check](algorithms/math/prime_check.py) — check if a number is prime
 - [primes_sieve_of_eratosthenes](algorithms/math/primes_sieve_of_eratosthenes.py) — generate primes up to n using the Sieve of Eratosthenes
@@ -421,6 +430,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 ### Searching
 
 - [binary_search](algorithms/searching/binary_search.py) — search a sorted array in O(log n)
+- [exponential_search](algorithms/searching/exponential_search.py) — search a sorted array by doubling the range then binary searching
 - [find_min_rotate](algorithms/searching/find_min_rotate.py) — find the minimum in a rotated sorted array
 - [first_occurrence](algorithms/searching/first_occurrence.py) — find the first occurrence of a target value
 - [generalized_binary_search](algorithms/searching/generalized_binary_search.py) — binary search with a custom predicate
@@ -432,6 +442,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [search_insert](algorithms/searching/search_insert.py) — find the insertion position for a target value
 - [search_range](algorithms/searching/search_range.py) — find the first and last positions of a target
 - [search_rotate](algorithms/searching/search_rotate.py) — search in a rotated sorted array
+- [sentinel_search](algorithms/searching/sentinel_search.py) — linear search optimized by placing a sentinel at the end
 - [ternary_search](algorithms/searching/ternary_search.py) — search by dividing the array into three parts
 - [two_sum](algorithms/searching/two_sum.py) — find two numbers that sum to a target
 
@@ -488,6 +499,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 ### String
 
 - [add_binary](algorithms/string/add_binary.py) — add two binary number strings
+- [alphabet_board_path](algorithms/string/alphabet_board_path.py) — navigate a 5×5 alphabet board to spell a target word
 - [atbash_cipher](algorithms/string/atbash_cipher.py) — Atbash substitution cipher (reverse the alphabet)
 - [breaking_bad](algorithms/string/breaking_bad.py) — spell a string using periodic-table element symbols
 - [caesar_cipher](algorithms/string/caesar_cipher.py) — Caesar shift cipher encryption / decryption
@@ -510,6 +522,7 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [longest_common_prefix](algorithms/string/longest_common_prefix.py) — find the longest common prefix among strings
 - [longest_palindromic_substring](algorithms/string/longest_palindromic_substring.py) — find the longest palindromic substring
 - [make_sentence](algorithms/string/make_sentence.py) — break a string into valid dictionary words
+- [manacher](algorithms/string/manacher.py) — find the longest palindromic substring in O(n) time
 - [merge_string_checker](algorithms/string/merge_string_checker.py) — check if a string is a valid merge of two others
 - [min_distance](algorithms/string/min_distance.py) — minimum deletions to make two strings equal
 - [multiply_strings](algorithms/string/multiply_strings.py) — multiply two numbers represented as strings
@@ -524,11 +537,13 @@ All core data structures live in [`algorithms/data_structures/`](algorithms/data
 - [roman_to_int](algorithms/string/roman_to_int.py) — convert a Roman numeral string to an integer
 - [rotate](algorithms/string/rotate.py) — rotate a string by k positions
 - [strip_url_params](algorithms/string/strip_url_params.py) — remove duplicate query parameters from a URL
+- [swap_characters](algorithms/string/swap_characters.py) — check if one character swap can make two strings equal
 - [strong_password](algorithms/string/strong_password.py) — check minimum changes needed for a strong password
 - [text_justification](algorithms/string/text_justification.py) — justify text lines to a specified width
 - [unique_morse](algorithms/string/unique_morse.py) — count unique Morse code representations of words
 - [validate_coordinates](algorithms/string/validate_coordinates.py) — validate geographic latitude/longitude coordinates
 - [word_squares](algorithms/string/word_squares.py) — find all valid word squares from a word list
+- [z_algorithm](algorithms/string/z_algorithm.py) — Z-array computation for linear-time pattern matching
 
 ### Tree
 

algorithms/backtracking/__init__.py

@@ -10,6 +10,7 @@
 from .generate_abbreviations import generate_abbreviations
 from .generate_parenthesis import generate_parenthesis_v1, generate_parenthesis_v2
 from .letter_combination import letter_combinations
+from .minimax import minimax
 from .palindrome_partitioning import (
     palindromic_substrings,
     palindromic_substrings_iter,
@@ -43,4 +44,5 @@
     "subsets",
     "subsets_v2",
     "subsets_unique",
+    "minimax",
 ]

algorithms/backtracking/minimax.py

@@ -0,0 +1,60 @@
+"""Minimax — game-tree search with alpha-beta pruning.
+
+The minimax algorithm finds the optimal move for a two-player zero-sum
+game. Alpha-beta pruning reduces the search space by eliminating branches
+that cannot influence the final decision.
+
+Inspired by PR #860 (DD2480-group16).
+"""
+
+from __future__ import annotations
+
+import math
+
+
+def minimax(
+    depth: int,
+    is_maximizing: bool,
+    scores: list[int],
+    alpha: float = -math.inf,
+    beta: float = math.inf,
+) -> float:
+    """Return the minimax value of a perfect binary game tree.
+
+    *scores* contains the leaf values (length must be a power of 2).
+    *depth* is the current depth (start with log2(len(scores))).
+
+    >>> minimax(2, True, [3, 5, 2, 9])
+    5
+    >>> minimax(3, True, [3, 5, 2, 9, 12, 5, 23, 23])
+    12
+    """
+    if depth == 0:
+        return scores[0]
+    mid = len(scores) // 2
+    if is_maximizing:
+        value = -math.inf
+        value = max(
+            value,
+            minimax(depth - 1, False, scores[:mid], alpha, beta),
+        )
+        alpha = max(alpha, value)
+        if alpha < beta:
+            value = max(
+                value,
+                minimax(depth - 1, False, scores[mid:], alpha, beta),
+            )
+        return value
+    else:
+        value = math.inf
+        value = min(
+            value,
+            minimax(depth - 1, True, scores[:mid], alpha, beta),
+        )
+        beta = min(beta, value)
+        if alpha < beta:
+            value = min(
+                value,
+                minimax(depth - 1, True, scores[mid:], alpha, beta),
+            )
+        return value

algorithms/bit_manipulation/__init__.py

@@ -12,6 +12,7 @@
 from .find_difference import find_difference
 from .find_missing_number import find_missing_number, find_missing_number2
 from .flip_bit_longest_sequence import flip_bit_longest_seq
+from .gray_code import gray_code, gray_to_binary
 from .has_alternative_bit import has_alternative_bit, has_alternative_bit_fast
 from .insert_bit import insert_mult_bits, insert_one_bit
 from .power_of_two import is_power_of_two
@@ -53,4 +54,6 @@
     "subsets",
     "swap_pair",
     "update_bit",
+    "gray_code",
+    "gray_to_binary",
 ]

algorithms/bit_manipulation/gray_code.py

@@ -0,0 +1,32 @@
+"""Gray code — generate n-bit Gray code sequences.
+
+A Gray code is an ordering of binary numbers such that successive values
+differ in exactly one bit. Used in error correction and rotary encoders.
+
+Inspired by PR #932 (Simranstha045).
+"""
+
+from __future__ import annotations
+
+
+def gray_code(n: int) -> list[int]:
+    """Return the n-bit Gray code sequence as a list of integers.
+
+    Uses the reflection (mirror) construction:
+        gray(i) = i ^ (i >> 1)
+
+    >>> gray_code(2)
+    [0, 1, 3, 2]
+    >>> gray_code(3)
+    [0, 1, 3, 2, 6, 7, 5, 4]
+    """
+    return [i ^ (i >> 1) for i in range(1 << n)]
+
+
+def gray_to_binary(gray: int) -> int:
+    """Convert a Gray-coded integer back to standard binary."""
+    mask = gray >> 1
+    while mask:
+        gray ^= mask
+        mask >>= 1
+    return gray

algorithms/data_structures/__init__.py

@@ -15,6 +15,7 @@
 from algorithms.data_structures.hash_table import HashTable, ResizableHashTable
 from algorithms.data_structures.heap import AbstractHeap, BinaryHeap
 from algorithms.data_structures.iterative_segment_tree import SegmentTree
+from algorithms.data_structures.kd_tree import KDTree
 from algorithms.data_structures.linked_list import (
     DoublyLinkedListNode,
     SinglyLinkedListNode,
@@ -71,4 +72,5 @@
     "SegmentTree",
     "SegmentTreeRecursive",
     "Trie",
+    "KDTree",
 ]

algorithms/data_structures/kd_tree.py

@@ -0,0 +1,83 @@
+"""KD-tree — a space-partitioning tree for k-dimensional points.
+
+Supports efficient nearest-neighbour and range queries.
+
+Inspired by PR #915 (gjones1077).
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+
+class KDNode:
+    """A single node in a KD-tree."""
+
+    __slots__ = ("point", "left", "right", "axis")
+
+    def __init__(
+        self,
+        point: tuple[float, ...],
+        left: KDNode | None = None,
+        right: KDNode | None = None,
+        axis: int = 0,
+    ) -> None:
+        self.point = point
+        self.left = left
+        self.right = right
+        self.axis = axis
+
+
+class KDTree:
+    """A k-dimensional tree built from a list of points.
+
+    >>> tree = KDTree([(2, 3), (5, 4), (9, 6), (4, 7), (8, 1), (7, 2)])
+    >>> tree.nearest((9, 2))
+    (8, 1)
+    """
+
+    def __init__(self, points: list[tuple[float, ...]]) -> None:
+        self.k = len(points[0]) if points else 0
+        self.root = self._build(list(points), depth=0)
+
+    def _build(self, points: list[tuple[float, ...]], depth: int) -> KDNode | None:
+        if not points:
+            return None
+        axis = depth % self.k
+        points.sort(key=lambda p: p[axis])
+        mid = len(points) // 2
+        return KDNode(
+            point=points[mid],
+            left=self._build(points[:mid], depth + 1),
+            right=self._build(points[mid + 1 :], depth + 1),
+            axis=axis,
+        )
+
+    def nearest(self, target: tuple[float, ...]) -> tuple[float, ...]:
+        """Return the point closest to *target*."""
+        best: list[Any] = [None, math.inf]
+        self._nearest(self.root, target, best)
+        return best[0]
+
+    def _nearest(
+        self,
+        node: KDNode | None,
+        target: tuple[float, ...],
+        best: list[Any],
+    ) -> None:
+        if node is None:
+            return
+        dist = _sq_dist(node.point, target)
+        if dist < best[1]:
+            best[0], best[1] = node.point, dist
+        axis = node.axis
+        diff = target[axis] - node.point[axis]
+        close, away = (node.left, node.right) if diff <= 0 else (node.right, node.left)
+        self._nearest(close, target, best)
+        if diff * diff < best[1]:
+            self._nearest(away, target, best)
+
+
+def _sq_dist(a: tuple[float, ...], b: tuple[float, ...]) -> float:
+    return sum((x - y) ** 2 for x, y in zip(a, b, strict=False))

algorithms/dynamic_programming/__init__.py

@@ -5,10 +5,12 @@
 """
 
 from . import regex_matching
+from .bitmask import tsp
 from .buy_sell_stock import max_profit_naive, max_profit_optimized
 from .climbing_stairs import climb_stairs, climb_stairs_optimized
 from .coin_change import count
 from .combination_sum import combination_sum_bottom_up, combination_sum_topdown
+from .count_paths_dp import count_paths_dp, count_paths_memo, count_paths_recursive
 from .edit_distance import edit_distance
 from .egg_drop import egg_drop
 from .fib import fib_iter, fib_list, fib_recursive
@@ -96,4 +98,10 @@
     "cut_rod",
     # word_break
     "word_break",
+    # bitmask
+    "tsp",
+    # count_paths_dp
+    "count_paths_dp",
+    "count_paths_memo",
+    "count_paths_recursive",
 ]

algorithms/dynamic_programming/bitmask.py

@@ -0,0 +1,45 @@
+"""Bitmask dynamic programming — Travelling Salesman Problem (TSP).
+
+Uses DP with bitmask to find the minimum-cost Hamiltonian cycle in a
+weighted graph. The state (visited_mask, current_city) encodes which
+cities have been visited and where we are now.
+
+Time: O(2^n * n^2).  Space: O(2^n * n).
+
+Inspired by PR #855 (AmandaStromdahl).
+"""
+
+from __future__ import annotations
+
+import math
+
+
+def tsp(dist: list[list[float]]) -> float:
+    """Return the minimum cost of a Hamiltonian cycle.
+
+    *dist* is an n x n distance matrix.
+
+    >>> tsp([[0, 10, 15, 20],
+    ...      [10, 0, 35, 25],
+    ...      [15, 35, 0, 30],
+    ...      [20, 25, 30, 0]])
+    80
+    """
+    n = len(dist)
+    full_mask = (1 << n) - 1
+    dp: dict[tuple[int, int], float] = {}
+
+    def solve(mask: int, pos: int) -> float:
+        if mask == full_mask:
+            return dist[pos][0]
+        key = (mask, pos)
+        if key in dp:
+            return dp[key]
+        ans = math.inf
+        for city in range(n):
+            if not (mask & (1 << city)):
+                ans = min(ans, dist[pos][city] + solve(mask | (1 << city), city))
+        dp[key] = ans
+        return ans
+
+    return solve(1, 0)