python-examples 0.2.0__py3-none-any.whl

Algorithms/arrays/subsequence_conflict.py

@@ -0,0 +1,35 @@
+from typing import List
+
+def dfs(start, adj_lst, visited, seen):
+    """
+    return: if cycle is detected
+    """
+    if start in seen:
+        return True
+    if start in visited or start not in adj_lst:
+        return False 
+    seen.add(start)
+    for neighbor in adj_lst[start]:
+        if dfs(neighbor, adj_lst, visited, seen):
+            return True
+    seen.remove(start)
+    visited.add(start)
+    return False
+
+def subsequence(input_lsts: List[List[int]]):
+    """
+    input_lsts list of lists
+    """
+    adj_lst = dict()
+
+    for l in input_lsts:
+        for i in range(1, len(l)):
+            adj_lst.setdefault(l[i-1], []).append(l[i])
+
+    visited = set()
+    for node in adj_lst.keys():
+        if node not in visited:
+            is_cycle = dfs(node, adj_lst, visited, set())
+            if is_cycle:
+                return False
+    return True

Algorithms/matrices/utils.py

@@ -0,0 +1,59 @@
+import numpy as np
+from scipy.linalg.blas import dsymm
+import time
+
+
+def slow_update_matrix(C: np.ndarray, A: np.ndarray, B: np.ndarray):
+    n = C.shape[0]
+    for i in range(n):
+        for j in range(n):
+            for k in range(n):
+                C[i, j] += A[k, i] * B[k, j] * A[k, j]
+    return C
+
+
+def update_matrix(C: np.ndarray, A: np.ndarray, B: np.ndarray):
+    """
+    Update matrix C by adding A^T @ B @ A, for symmetric matrix B efficiently
+    and ensure innermost loop uses unit-stride vector operations. Since B is symmetric,
+    it's stored in compact upper triangular form.
+    """
+    assert C.shape == A.shape and C.shape == B.shape, (
+        "Matrices C, A, and B must have the same shape."
+    )
+    assert (B.T == B).all(), "Matrix B must be symmetric."
+    BA = B @ A
+    C += A.T @ BA
+    return C
+
+
+def symm_update(C, A, B):
+    BA = dsymm(1.0, B, A)  # B symmetric
+    C += A.T @ BA
+    return C
+
+
+if __name__ == "__main__":
+    n = 10000  # try larger like 400–1000 for clearer results
+    A = np.random.randn(n, n)
+    B = np.random.randn(n, n)
+    B = (B + B.T) / 2  # symmetrize
+    C1 = np.zeros((n, n))
+    C2 = np.zeros((n, n))
+
+    # Time slow
+    # start = time.time()
+    # slow_update_matrix(C1.copy(), A, B)
+    # print("Slow update time:", time.time() - start)
+
+    # Time fast
+    start = time.time()
+    update_matrix(C2.copy(), A, B)
+    print("Fast update time:", time.time() - start)
+
+    start = time.time()
+    symm_update(C2.copy(), A, B)
+    print("BLAS symm update time:", time.time() - start)
+
+    # Check correctness
+    print("Difference norm:", np.linalg.norm(C1 - C2))

Algorithms/numerical_methods/coin_run.py

@@ -0,0 +1,77 @@
+import numpy as np
+
+from mixins.benchmark import BenchmarkMixin
+from mixins.logging import LoggingMixin
+
+
+def count_max_length_runs(length: int, rng=None):
+    lst = np.random.randint(0, 2, length) if rng is None else rng.integers(0, 2, length)
+    i = 1
+    num_runs = 0
+    curr_max = 0
+    run = 1
+
+    while i < length:
+        if lst[i] == lst[i - 1]:
+            run += 1
+        else:
+            # only update number of runs if run ends
+            if run > curr_max:
+                curr_max = run
+                num_runs = 1
+            elif run == curr_max:
+                num_runs += 1
+            run = 1
+        i += 1
+    if run > curr_max:
+        curr_max = run
+        num_runs = 1
+    elif run == curr_max:
+        num_runs += 1
+    return num_runs
+
+
+def count_num_runs(length: int, rng=None):
+    lst = np.random.randint(0, 2, length) if rng is None else rng.integers(0, 2, length)
+    runs = 1
+    for i in range(1, length):
+        if lst[i] != lst[i - 1]:
+            runs += 1
+    return runs
+
+
+class CoinRunSimulation(BenchmarkMixin, LoggingMixin):
+    def __init__(self, seed=None):
+        self.rng = np.random.default_rng(seed)
+
+    def simulate(self, steps: int, length: int = 100):
+        if steps < 0:
+            raise ValueError("steps must be non-negative")
+        if length < 1:
+            raise ValueError("length must be positive")
+
+        results = []
+        for step in range(steps):
+            result = {
+                "step": step,
+                "max_length_runs": count_max_length_runs(length, self.rng),
+                "num_runs": count_num_runs(length, self.rng),
+            }
+            results.append(result)
+            self.logger.debug("Completed coin-run simulation step %s", step)
+        return results
+
+    def run(self, steps: int, length: int = 100):
+        return self.benchmark(self.simulate, steps, length)
+
+
+def main():
+    simulation = CoinRunSimulation()
+    benchmark = simulation.run(steps=10_000, length=100)
+    results = benchmark["result"]
+    print(sum(result["max_length_runs"] for result in results) / len(results))
+    print(sum(result["num_runs"] for result in results) / len(results))
+
+
+if __name__ == "__main__":
+    main()

Algorithms/numerical_methods/euler/p0.py

@@ -0,0 +1,9 @@
+def sum_squares(n: int):
+    if n < 1:
+        raise ValueError("n must be specified for first n sum squares")
+    s = 0
+    for i in range(1, n + 1):
+        v = i * i
+        if v % 2 != 0:
+            s += v
+    return s

Algorithms/numerical_methods/euler/p1.py

@@ -0,0 +1,8 @@
+def mult_35(n: int):
+    v = 1
+    s = 0
+    while v < n:
+        if v % 3 == 0 or v % 5 == 0:
+            s += v
+        v += 1
+    return s

Algorithms/numerical_methods/euler/p2.py

@@ -0,0 +1,16 @@
+def even_fib(n: int):
+    v1 = 1
+    v2 = 2
+    if n < 1:
+        raise ValueError("n must be at least 1")
+    elif n == 1:
+        return 0
+    else:
+        s = 0
+        while v2 <= n:
+            if v2 % 2 == 0:
+                s += v2
+            temp = v2
+            v2 = v2 + v1
+            v1 = temp
+        return s

Algorithms/numerical_methods/euler/p48.py

@@ -0,0 +1,8 @@
+def self_powers(n: int):
+    if n < 1:
+        raise ValueError("n must be at least 1")
+    res = 0
+    MOD = 10**10
+    for i in range(1, n + 1):
+        res = (res + pow(i, i, MOD)) % MOD
+    return res

Algorithms/numerical_methods/euler/p49.py

@@ -0,0 +1,100 @@
+from collections import defaultdict
+import math
+
+
+def is_prime(n: int):
+    if n < 1:
+        raise ValueError("n must be at least 1")
+    elif n == 1:
+        return False
+    elif n == 2:
+        return True
+    elif n % 2 == 0:
+        return False
+    else:
+        for i in range(3, int(math.sqrt(n)) + 1):
+            if n % i == 0:
+                return False
+        return True
+
+
+def sieve_n_digit_primes(n: int):
+    if n < 1:
+        return []
+
+    low = 10 ** (n - 1)
+    high = 10**n - 1
+
+    if n == 1:
+        low = 2
+
+    limit = math.isqrt(high)
+    is_prime = [True] * (limit + 1)
+    base_primes = []
+
+    # sieve base primes
+    for p in range(2, limit + 1):
+        if is_prime[p]:
+            base_primes.append(p)
+            for i in range(p * p, limit + 1, p):
+                is_prime[i] = False
+
+    # Segment the range [low, high] into cache-friendly block sizes
+    # 32KB to 256KB block size prevents CPU cache thrashing
+    block_size = 500000
+    n_digit_primes = []
+
+    for current_low in range(low, high + 1, block_size):
+        current_high = min(current_low + block_size - 1, high)
+        range_size = current_high - current_low + 1
+
+        segment = [True] * range_size
+
+        for p in base_primes:
+            # Find the first multiple of p >= current_low and >= p^2
+            start_multiple = max(p * p, ((current_low + p - 1) // p) * p)
+
+            for j in range(start_multiple, current_high + 1, p):
+                segment[j - current_low] = False
+
+        for i in range(range_size):
+            if segment[i]:
+                n_digit_primes.append(current_low + i)
+
+    return n_digit_primes
+
+
+def prime_permutations(n: int, perms: int) -> str:
+    """
+    n: number of digits in the prime permutations
+    end in odd
+    perms: number of permutations to consider
+    _ _ _ 1,3,5,7,9
+    """
+    all_primes = sieve_n_digit_primes(n)
+    table = defaultdict(list)
+    for prime in all_primes:
+        key = "".join(sorted(str(prime)))
+        table[key].append(prime)
+
+    res = []
+    for key, nums in table.items():
+        if len(nums) < perms:
+            continue
+        nums_set = set(nums)
+        for start in nums_set:
+            for next_num in nums_set:
+                if next_num <= start:
+                    continue
+                diff = next_num - start
+                seq = [start]
+                curr = start
+                while curr in nums_set and len(seq) < perms:
+                    curr += diff
+                    if curr in nums_set:
+                        seq.append(curr)
+                    else:
+                        break
+                if len(seq) == perms:
+                    res.append("".join([str(v) for v in seq]))
+    return res

Algorithms/numerical_methods/euler/p50.py

@@ -0,0 +1,22 @@
+from typing import Optional
+from Algorithms.numerical_methods.euler import utils
+
+
+def consecutive_prime_sum(n: int) -> Optional[int]:
+    is_prime, primes = utils.sieve(n)
+    longest_sum = 0
+    longest_sum_prime = None
+    pref_sums = [0] * (len(primes) + 1)
+    # go through every prefix sum (pairs of start and end primes), sum should be prime
+    for i in range(1, len(pref_sums)):
+        pref_sums[i] = pref_sums[i - 1] + primes[i - 1]
+
+    for start in range(len(primes)):
+        for end in range(start + longest_sum + 1, len(primes) + 1):
+            s = pref_sums[end] - pref_sums[start]
+            if s >= n:
+                break
+            if is_prime[s]:
+                longest_sum = end - start
+                longest_sum_prime = s
+    return longest_sum_prime

Algorithms/numerical_methods/euler/p51.py

@@ -0,0 +1,45 @@
+from Algorithms.numerical_methods.euler import utils
+from typing import Optional
+from itertools import combinations
+
+
+def prime_digit_replacements(
+    n: int, prime_family: int, start_point: Optional[int] = None
+) -> Optional[int]:
+    """
+    n: int
+    prime_family: int
+    return: Smallest prime that has a prime family of size `prime_family`
+    """
+    is_prime, primes = utils.sieve(n)
+    nums = "0123456789"
+    for p in primes:
+        if start_point is not None and p < start_point:
+            continue
+        s = str(p)
+        for digit in nums:
+            positions = [i for i, c in enumerate(s) if c == digit]
+
+            if not positions:
+                continue
+            for r in range(1, len(positions) + 1):
+                for subset in combinations(positions, r):
+                    if subset[-1] == n - 1:
+                        continue
+                    count = 0
+                    smallest = None
+                    for replacement in nums:
+                        if subset[0] == 0 and replacement == "0":
+                            continue
+                        updated = list(s)
+                        for i in subset:
+                            updated[i] = replacement
+
+                        candidate = int("".join(updated))
+                        if is_prime[candidate]:
+                            count += 1
+                            if smallest is None or candidate < smallest:
+                                smallest = candidate
+                    if count == prime_family:
+                        return smallest
+    return None

Algorithms/numerical_methods/euler/p54.py

@@ -0,0 +1,161 @@
+from collections import defaultdict
+from enum import IntEnum
+from typing import Any, Dict, List
+
+VALUE_MAP = {"T": 10, "J": 11, "Q": 12, "K": 13, "A": 14}
+
+
+class Rank(IntEnum):
+    HIGH_CARD = 0
+    ONE_PAIR = 1
+    TWO_PAIRS = 2
+    THREE_OF_A_KIND = 3
+    STRAIGHT = 4
+    FLUSH = 5
+    FULL_HOUSE = 6
+    FOUR_OF_A_KIND = 7
+    STRAIGHT_FLUSH = 8
+    ROYAL_FLUSH = 9
+
+
+def union_find_longest_consecutive(nums):
+    parent = {}
+    size = {}
+    for x in nums:
+        parent[x] = x
+        size[x] = 1
+
+    def find(x):
+        if parent[x] != x:
+            parent[x] = find(parent[x])
+        return parent[x]
+
+    def union(a, b):
+        ra, rb = find(a), find(b)
+        if ra == rb:
+            return
+        if size[ra] < size[rb]:
+            ra, rb = rb, ra
+        # assume rb is the smaller one
+        parent[rb] = ra
+        size[ra] += size[rb]
+
+    snums = set(nums)
+    for x in snums:
+        if x + 1 in snums:
+            union(x, x + 1)
+    return max(size[find(x)] for x in nums)
+
+
+def gather_hand_information(hand: List[str]) -> Dict[str, Any]:
+    """
+    return:
+    - all_same_suit
+    - value counts
+    - are consecutive
+    """
+    seen = set()
+    all_same = True
+    d = defaultdict(int)
+    vals = []
+    for val, suit in [tuple(card) for card in hand]:
+        if suit not in seen:
+            if not seen:
+                seen.add(suit)
+            else:
+                all_same = False
+        int_val = VALUE_MAP[val] if val in VALUE_MAP else int(val)
+        d[int_val] += 1
+        vals.append(int_val)
+    all_consecutive = union_find_longest_consecutive(vals) == len(hand)
+    return {
+        "all_same_suit": all_same,
+        "value_counts": d,
+        "all_consecutive": all_consecutive,
+    }
+
+
+def determine_rank(player_info: Dict[str, Any]) -> tuple[Rank, tuple]:
+    counts = player_info["value_counts"]
+
+    # values sorted by (count, value)
+    groups = sorted(((cnt, val) for val, cnt in counts.items()), reverse=True)
+
+    values_desc = sorted(counts.keys(), reverse=True)
+
+    is_flush = player_info["all_same_suit"]
+    is_straight = player_info["all_consecutive"]
+
+    # Handle A2345 straight
+    if set(counts.keys()) == {14, 2, 3, 4, 5}:
+        is_straight = True
+        straight_high = 5
+    elif is_straight:
+        straight_high = max(counts)
+    else:
+        straight_high = None
+
+    if is_flush and is_straight:
+        if straight_high == 14 and min(counts) == 10:
+            return Rank.ROYAL_FLUSH, ()
+        return Rank.STRAIGHT_FLUSH, (straight_high,)
+
+    if groups[0][0] == 4:
+        quad = groups[0][1]
+        kicker = groups[1][1]
+        return Rank.FOUR_OF_A_KIND, (quad, kicker)
+
+    if groups[0][0] == 3 and groups[1][0] == 2:
+        return Rank.FULL_HOUSE, (groups[0][1], groups[1][1])
+
+    if is_flush:
+        return Rank.FLUSH, tuple(values_desc)
+
+    if is_straight:
+        return Rank.STRAIGHT, (straight_high,)
+
+    if groups[0][0] == 3:
+        trip = groups[0][1]
+        kickers = sorted(
+            (v for v, c in counts.items() if c == 1),
+            reverse=True,
+        )
+        return Rank.THREE_OF_A_KIND, (trip, *kickers)
+
+    if groups[0][0] == 2 and groups[1][0] == 2:
+        pairs = sorted(
+            (v for v, c in counts.items() if c == 2),
+            reverse=True,
+        )
+        kicker = next(v for v, c in counts.items() if c == 1)
+        return Rank.TWO_PAIRS, (*pairs, kicker)
+
+    if groups[0][0] == 2:
+        pair = groups[0][1]
+        kickers = sorted(
+            (v for v, c in counts.items() if c == 1),
+            reverse=True,
+        )
+        return Rank.ONE_PAIR, (pair, *kickers)
+
+    return Rank.HIGH_CARD, tuple(values_desc)
+
+
+def poker_hands(poker_file: str) -> int:
+    player1_wins = 0
+    with open(poker_file) as f:
+        for row in f.readlines():
+            vals = row.strip().split(" ")
+            player1, player2 = vals[:5], vals[5:]
+            player1_info = gather_hand_information(player1)
+            player2_info = gather_hand_information(player2)
+            rank1 = determine_rank(player1_info)
+            rank2 = determine_rank(player2_info)
+            if rank1 > rank2:
+                player1_wins += 1
+            elif rank1 == rank2:
+                if max(player1_info["value_counts"].keys()) > max(
+                    player2_info["value_counts"].keys()
+                ):
+                    player1_wins += 1
+    return player1_wins

Algorithms/numerical_methods/euler/utils.py

@@ -0,0 +1,16 @@
+# utils.py
+
+
+def sieve(n: int):
+    is_prime = [True] * (n + 1)
+    if n >= 0:
+        is_prime[0] = False
+    if n >= 1:
+        is_prime[1] = False
+    primes = []
+    for p in range(2, n + 1):
+        if is_prime[p]:
+            primes.append(p)
+            for v in range(p * p, n + 1, p):
+                is_prime[v] = False
+    return is_prime, primes

Algorithms/slidingWindow/longestUnique.py

@@ -0,0 +1,37 @@
+from collections import OrderedDict
+from pydantic import BaseModel, Field
+from typing import List
+
+
+class SlidingWindowParam(BaseModel):
+    s: str = Field(..., description="Input string", min_length=1)
+
+
+def lengthOfLongestSubstringTwoDistinct(s: SlidingWindowParam) -> int:
+    seen = OrderedDict()
+    start = 0
+    longest = 0
+    for end in range(len(s)):
+        if s[end] in seen:
+            seen.move_to_end(s[end])
+        seen[s[end]] = end
+        if len(seen) > 2:
+            _, idx = seen.popitem(last=False)
+            start = idx + 1
+        longest = max(longest, end - start + 1)
+    return longest
+
+
+def maximumUniqueSubarray(nums: List[int]) -> int:
+    last_seen = dict()
+    start, curr_sum, max_sum = 0, 0, 0
+    for end in range(len(nums)):
+        if nums[end] in last_seen:
+            last_idx = last_seen[nums[end]]
+            if last_idx >= start:
+                curr_sum -= sum(nums[start : (last_idx + 1)])
+                start = last_idx + 1
+        curr_sum += nums[end]
+        max_sum = max(max_sum, curr_sum)
+        last_seen[nums[end]] = end
+    return max_sum

Algorithms/static_analysis/ast_tree.py

@@ -0,0 +1,76 @@
+from typing import Dict
+
+
+class Node:
+    def __init__(self, node_type, value=None, children=None):
+        self.node_type = node_type
+        self.value = value
+        self.children = children if children is not None else []
+
+    def __repr__(self):
+        if self.value:
+            return f"{self.node_type}({self.value})"
+        return f"{self.node_type}({self.children})"
+
+    def __eq__(self, other):
+        return (
+            self.node_type == other.node_type
+            and self.value == other.value
+            and self.children == other.children
+        )
+
+
+def find_calls(root: Node, function_name: str):
+    """
+    This function takes AST root and function name as input and returns all function calls in the AST.
+    First child node is the name of the function
+    """
+    calls = []
+
+    def gather_calls(root, function_name):
+        if root:
+            if root.node_type == "Call":
+                if (
+                    root.children
+                    and root.children[0].node_type == "Name"
+                    and root.children[0].value == function_name
+                ):
+                    calls.append(root)
+            for child in root.children:
+                gather_calls(child, function_name)
+
+    gather_calls(root, function_name)
+    return calls
+
+
+def match(rule_node: Node, code_node: Node, captures: Dict[str, Node]):
+    """
+    Returns True if code_node matches rule_node.
+
+    captures should be populated with metavariable bindings.
+    """
+    if rule_node is None or code_node is None:
+        return rule_node is code_node
+
+    if rule_node.node_type == "MetaVar":
+        name = rule_node.value
+        if name in captures:
+            return captures[name] == code_node
+        captures[name] = code_node
+        return True
+
+    if rule_node.node_type != code_node.node_type:
+        return False
+
+    if rule_node.value is not None:
+        if code_node.value is None or rule_node.value != code_node.value:
+            return False
+
+    if len(rule_node.children) != len(code_node.children):
+        return False
+
+    for rule_child, code_child in zip(rule_node.children, code_node.children):
+        if not match(rule_child, code_child, captures):
+            return False
+
+    return True