@RealSaitama

import numpy as np a = 2 b = 3 vs = [2, 2 * a] for i in range(2, 10): vs.append(2 * a * vs[i - 1] + (b - a**2) * vs[i - 2]) print(vs) # def mod_pow(base, exponent, modulus):

VAL = 1.5 cols = "ybrgow" faces = "ulfrbd" pos = { "f0": (1.5, -1, 1), "f1": (1.5, 0, 1), "f2": (1.5, 1, 1), "f3": (1.5, -1, 0), "f4": (1.5, 0, 0),

xs = [[1, 80], [3, 100], [2, 80], [3, 90], [2, 80]] def select(ls): ans = [] ys = sorted(xs, key=lambda x:(-x[0], -x[1])) print(ys) R = -1 for r, a in ys: if r == R: continue ans.append((r, a))

f=lambda n:'\n'.join(' '.join(map(lambda x:str(x).rjust(2,' '),(__import__("math").comb(i,k)for k in range(i+1))))for i in range(n+1)) print(f(7))

from collections import Counter from math import prod primes = (3, 5, 7, 11, 13, 17, 19, 23, 29, 31) def factor(m): n = m f = [] for d in [2, 3, 5]: while n % d == 0:

n = 10 binom = [[1]] for i in range(1, n): r = [1] for j in range(1, i): r.append(binom[i - 1][j] + binom[i - 1][j - 1]) r.append(1) binom.append(r[:]) for line in binom: print(line)

import numpy as np import itertools as it import re from typing import List, Dict, Tuple, Set, AnyStr, Type solution_list: List[Type[np.ndarray]] = [] placements: Dict[str, Dict[int, List[Type[np.ndarray]]]] = {} def compute_blocks(line_len: int,

# https://github.com/gilbertgede/PyIntropt/blob/master/pyintropt/nitro/solver.py import math from typing import Dict, Tuple, Optional, List class SparseMatrix: """Sparse Matrix class Args: data: A dictionary of (i, j) -> value "

import numpy as np from scipy.optimize import linprog # https://github.com/scipy/scipy/blob/main/scipy/optimize/_linprog_ip.py def minimum_transportation_price(suppliers, consumers, costs): costs = np.array(costs) costs_flattened = costs.f

# https://www.quora.com/How-many-numbers-with-set-bit-count-equal-to-k-are-there-between-any-given-positive-numbers-a-and-b from functools import cache from math import comb @cache def T(n, k): if n < k or k < 0: return 0 return 2*

xs = [1, 20, 20 * 18, 20 * 18 * 20, 20 * 18 * 20 * 20, 20 * 18 * 20 * 20] def maya(n): if n == 0: return [0] i = 0 while xs[i + 1] <= n: i += 1 ans = [] while n > 0: q, r = divmod(n, xs[i])

xs = [[1]] for n in range(1, 15): rs = [xs[n - 1][-1]] for i in range(n): rs.append(rs[i] + xs[n - 1][i]) xs.append(rs) print(xs)

class Vecteur: def __init__(self, x, y, z): self.x = x self.y = y self.z = z def __str__(self): return f"Vecteur({self.x}, {self.y}, {self.z})" def __eq__(self, other):

def count_divisible_substrings(s, p): n = len(s) result = [0] * n mod = 2 ** p # Calculate 2^p for divisibility checks for i in range(n): current_mod = 0 # Iterate through substrings starting at index i for

from fractions import Fraction def to_frac(x): [u, v] = [int(x), x % 1] ans = [] i = 0 while v > 0 and i < 10 and u < 1000 : ans.append(u) r = 1 / v u, v = int(r), r % 1

import math EPS = 1E-9 class Pt: def __init__(self, x, y): self.x = x self.y = y def __lt__(self, other):

from functools import cache @cache def solve(n, k): if n <= 0: return [[]] elif n == 1: return [[1]] m = 1 ans = []

def solve(n, k): q, x, ans = n, 1, 0 while q > 0: digit = q % 10 q //= 10 ans += q * x if digit == k: ans += n % x + 1 elif digit > k: ans += x

xs = [' ', '│', '─', '┌', '┐', '┘', '└'] lt = {0:0,1:2,2:1,3:4,4:5,5:6,6:3} rt = {0:0,1:2,2:1,3:6,4:3,5:4,6:5} def rotate_left(xs): n, m = len(xs), len(xs[0]) return [[lt[xs[n - 1 - i][j]] for i in range(n)] for j in range(m)] def rotate_r

xs = [2, 7] import heapq as hq def closure_gen(xs): xs = sorted(set(xs)) # Ensure no duplicates and ascending order seen = set(xs) # Track seen elements to avoid duplicates heap = list(xs) # Initialize the heap with the