code string | signature string | docstring string | loss_without_docstring float64 | loss_with_docstring float64 | factor float64 |
|---|---|---|---|---|---|
# build structures
n = len(mir)
orien = [None] * (n + 2)
orien[n] = 0 # arbitrary orientations
orien[n + 1] = 0
succ = [[None for direc in range(4)] for i in range(n + 2)]
L = [(mir[i][0], mir[i][1], i) for i in range(n)]
L.append((0, -1, n)) # enter
L.appe... | def laser_mirrors(rows, cols, mir) | Orienting mirrors to allow reachability by laser beam
:param int rows:
:param int cols: rows and cols are the dimension of the grid
:param mir: list of mirror coordinates, except
mir[0]= laser entrance,
mir[-1]= laser exit.
:complexity: :math:`O(2^n)` | 3.324342 | 3.292652 | 1.009624 |
assert orien[i] is not None
j = succ[i][direc]
if j is None: # basic case
return False
if j == len(orien) - 1:
return True
if orien[j] is None: # try both orientations
for x in [0, 1]:
orien[j] = x
if solve(succ, orien, j, reflex[direc]... | def solve(succ, orien, i, direc) | Can a laser leaving mirror i in direction direc reach exit ?
:param i: mirror index
:param direc: direction leaving mirror i
:param orient: orient[i]=orientation of mirror i
:param succ: succ[i][direc]=succ mirror reached
when leaving i in direction direc | 2.814427 | 3.113912 | 0.903824 |
assert len(L) >= 2
L.sort()
valmin, argmin = min((L[i] - L[i - 1], i) for i in range(1, len(L)))
return L[argmin - 1], L[argmin] | def closest_values(L) | Closest values
:param L: list of values
:returns: two values from L with minimal distance
:modifies: the order of L
:complexity: O(n log n), for n=len(L) | 3.085531 | 3.17859 | 0.970723 |
header = Cell(None, None, 0, None) # building the cell structure
col = []
for j in range(size_universe):
col.append(Cell(header, None, 0, None))
for i in range(len(sets)):
row = None
for j in sets[i]:
col[j].S += 1 # one more entry in this column
... | def dancing_links(size_universe, sets) | Exact set cover by the dancing links algorithm
:param size_universe: universe = {0, 1, ..., size_universe - 1}
:param sets: list of sets
:returns: list of set indices partitioning the universe, or None
:complexity: huge | 5.371777 | 5.296935 | 1.014129 |
# -- n is the number of variables
n = max(abs(clause[p]) for p in (0, 1) for clause in formula)
graph = [[] for node in range(2 * n)]
for x, y in formula: # x or y
graph[_vertex(-x)].append(_vertex(y)) # -x => y
graph[... | def two_sat(formula) | Solving a 2-SAT boolean formula
:param formula: list of clauses, a clause is pair of literals
over X1,...,Xn for some n.
a literal is an integer, for example -1 = not X1, 3 = X3
:returns: table with boolean assignment satisfying the formula or None
:complexity: linea... | 4.596848 | 4.406732 | 1.043142 |
# snip}
assert L # majorité n'est pas définie sur ensemble vide
# snip{
count = {}
for word in L:
if word in count:
count[word] += 1
else:
count[word] = 1
valmin, argmin = min((-count[word], word) for word in count)
return argmin | def majority(L) | Majority
:param L: list of elements
:returns: element that appears most in L,
tie breaking with smallest element
:complexity: :math:`O(nk)` in average,
where n = len(L) and k = max(w for w in L)
:math:`O(n^2k)` in worst case due to the use of a dictionary | 6.683589 | 7.317562 | 0.913363 |
global N, N2, N4
if len(G) == 16: # for a 16 x 16 sudoku grid
N, N2, N4 = 4, 16, 256
e = 4 * N4
universe = e + 1
S = [[rc(a), rv(a), cv(a), bv(a)] for a in range(N4 * N2)]
A = [e]
for r in range(N2):
for c in range(N2):
if G[r][c] != 0:
... | def sudoku(G) | Solving Sudoku
:param G: integer matrix with 0 at empty cells
:returns bool: True if grid could be solved
:modifies: G will contain the solution
:complexity: huge, but linear for usual published 9x9 grids | 4.577556 | 4.592597 | 0.996725 |
rows = len(P)
cols = len(P[0])
t = [0] * cols
best = None
for i in range(rows):
for j in range(cols):
if P[i][j] == black:
t[j] += 1
else:
t[j] = 0
(area, left, height, right) = rectangles_from_histogram(t)
alt = (a... | def rectangles_from_grid(P, black=1) | Largest area rectangle in a binary matrix
:param P: matrix
:param black: search for rectangles filled with value black
:returns: area, left, top, right, bottom of optimal rectangle
consisting of all (i,j) with
left <= j < right and top <= i <= bottom
:complexity: linear | 2.957201 | 2.715526 | 1.088998 |
INF = float('inf')
n = len(graph) # compute distances
dist = [[INF] * n]
prec = [[None] * n]
dist[0][start] = 0
for ell in range(1, n + 1):
dist.append([INF] * n)
prec.append([None] * n)
for node in range(n):
for neighbor in graph[node]:
... | def min_mean_cycle(graph, weight, start=0) | Minimum mean cycle by Karp
:param graph: directed graph in listlist or listdict format
:param weight: in matrix format or same listdict graph
:param int start: vertex that should be contained in cycle
:returns: cycle as vertex list, average arc weights
or None if there is no cycle from st... | 3.31807 | 3.293611 | 1.007426 |
V = range(len(weight))
for k in V:
for u in V:
for v in V:
weight[u][v] = min(weight[u][v],
weight[u][k] + weight[k][v])
for v in V:
if weight[v][v] < 0: # negative cycle found
return True
return False | def floyd_warshall(weight) | All pairs shortest paths by Floyd-Warshall
:param weight: edge weight matrix
:modifies: weight matrix to contain distances in graph
:returns: True if there are negative cycles
:complexity: :math:`O(|V|^3)` | 2.432654 | 2.465919 | 0.98651 |
n = len(graph)
dist = [float('inf')] * n
prec = [None] * n
dist[source] = 0
for nb_iterations in range(n):
changed = False
for node in range(n):
for neighbor in graph[node]:
alt = dist[node] + weight[node][neighbor]
if alt < dist[neigh... | def bellman_ford(graph, weight, source=0) | Single source shortest paths by Bellman-Ford
:param graph: directed graph in listlist or listdict format
:param weight: can be negative.
in matrix format or same listdict graph
:returns: distance table, precedence table, bool
:explanation: bool is True if a negative circuit is
... | 2.306648 | 2.328285 | 0.990707 |
val = 0
pos10 = 1000
beg = 0
for pos in range(3, -1, -1):
for digit in range(9,-1,-1):
r = roman[pos][digit]
if s.startswith(r, beg): # footnote 1
beg += len(r)
val += digit * pos10
break
pos10 //= 10
retur... | def roman2int(s) | Decode roman number
:param s: string representing a roman number between 1 and 9999
:returns: the decoded roman number
:complexity: linear (if that makes sense for constant bounded input size) | 4.314249 | 4.65358 | 0.927082 |
s = ''
pos10 = 1000
for pos in range(3, -1, -1):
digit = val // pos10
s += roman[pos][digit]
val %= pos10
pos10 //= 10
return s | def int2roman(val) | Code roman number
:param val: integer between 1 and 9999
:returns: the corresponding roman number
:complexity: linear (if that makes sense for constant bounded input size) | 3.084187 | 3.68873 | 0.836111 |
n = len(graph)
assert all(weight[u][v] >= 0 for u in range(n) for v in graph[u])
prec = [None] * n
black = [False] * n
dist = [float('inf')] * n
dist[source] = 0
heap = [(0, source)]
while heap:
dist_node, node = heappop(heap) # Closest node from source
if not ... | def dijkstra(graph, weight, source=0, target=None) | single source shortest paths by Dijkstra
:param graph: directed graph in listlist or listdict format
:param weight: in matrix format or same listdict graph
:assumes: weights are non-negative
:param source: source vertex
:type source: int
:param target: if given, stops once dis... | 1.959839 | 2.034641 | 0.963236 |
n = len(graph)
assert all(weight[u][v] >= 0 for u in range(n) for v in graph[u])
prec = [None] * n
dist = [float('inf')] * n
dist[source] = 0
heap = OurHeap([(dist[node], node) for node in range(n)])
while heap:
dist_node, node = heap.pop() # Closest node from source
... | def dijkstra_update_heap(graph, weight, source=0, target=None) | single source shortest paths by Dijkstra
with a heap implementing item updates
:param graph: adjacency list or adjacency dictionary of a directed graph
:param weight: matrix or adjacency dictionary
:assumes: weights are non-negatif and weights are infinite for non edges
:param source... | 2.529709 | 2.522342 | 1.002921 |
assert set.isdisjoint({'$', '^', '#'}, s) # Forbidden letters
if s == "":
return (0, 1)
t = "^#" + "#".join(s) + "#$"
c = 1
d = 1
p = [0] * len(t)
for i in range(2, len(t) - 1):
# -- reflect index i with respect to c
mirror = 2 * c - i ... | def manacher(s) | Longest palindrome in a string by Manacher
:param s: string
:requires: s is not empty
:returns: i,j such that s[i:j] is the longest palindrome in s
:complexity: O(len(s)) | 4.119489 | 3.755533 | 1.096912 |
to_visit = deque()
dist = [float('inf')] * len(graph)
prec = [None] * len(graph)
dist[start] = 0
to_visit.appendleft(start)
while to_visit: # an empty queue is considered False
node = to_visit.pop()
for neighbor in graph[node]:
if dist[neighbor] == f... | def bfs(graph, start=0) | Shortest path in unweighted graph by BFS
:param graph: directed graph in listlist or listdict format
:param int start: source vertex
:returns: distance table, precedence table
:complexity: `O(|V|+|E|)` | 2.071559 | 2.111598 | 0.981039 |
if T is None:
T = Trie_Node()
if i == len(w):
T.isWord = True
else:
T.s[w[i]] = add(T.s[w[i]], w, i + 1)
return T | def add(T, w, i=0) | :param T: trie
:param string w: word to be added to T
:returns: new trie consisting of w added into T
:complexity: O(len(w)) | 2.953323 | 2.454844 | 1.203059 |
T = None
for w in S:
T = add(T, w)
return T | def Trie(S) | :param S: set of words
:returns: trie containing all words from S
:complexity: linear in total word sizes from S | 5.006452 | 5.215498 | 0.959918 |
assert T is not None
dist = 0
while True: # Try increasing distances
u = search(T, dist, w)
if u is not None:
return u
dist += 1 | def spell_check(T, w) | Spellchecker
:param T: trie encoding the dictionary
:param w: given word
:returns: a closest word from the dictionary
:complexity: linear if distance was constant | 7.611362 | 8.660924 | 0.878816 |
if i == len(w):
if T is not None and T.isWord and dist == 0:
return ""
else:
return None
if T is None:
return None
f = search(T.s[w[i]], dist, w, i + 1) # matching
if f is not None:
return w[i] + f
if dist == 0:
return None
... | def search(T, dist, w, i=0) | Searches for w[i:] in trie T with distance at most dist | 2.519835 | 2.457038 | 1.025558 |
with open(filename, 'r') as f:
while True:
line = f.readline() # ignore leading comments
if line[0] != '#':
break
nb_nodes, nb_edges = tuple(map(int, line.split()))
graph = [[] for u in range(nb_nodes)]
if weighted:
wei... | def read_graph(filename, directed=False, weighted=False, default_weight=None) | Read a graph from a text file
:param filename: plain text file. All numbers are separated by space.
Starts with a line containing n (#vertices) and m (#edges).
Then m lines follow, for each edge.
Vertices are numbered from 0 to n-1.
Line for unweighted edge u... | 2.365549 | 2.333696 | 1.013649 |
with open(dotfile, 'w') as f:
if directed:
f.write("digraph G{\n")
else:
f.write("graph G{\n")
if comment:
f.write('label="%s";\n' % comment)
V = range(len(graph))
# -- vertices
for u in V:
... | def write_graph(dotfile, graph, directed=False,
node_label=None, arc_label=None, comment="",
node_mark=set(), arc_mark=set()) | Writes a graph to a file in the DOT format
:param dotfile: the filename.
:param graph: directed graph in listlist or listdict format
:param directed: true if graph is directed, false if undirected
:param weight: in matrix format or same listdict graph or None
:param node_label: vertex label table o... | 2.496696 | 2.546763 | 0.980341 |
n = len(prec)
graph = [[prec[u]] for u in range(n)] # add predecessors
graph[root] = []
for u in range(n): # add successors
if u != root:
graph[prec[u]].append(u)
return graph | def tree_prec_to_adj(prec, root=0) | Transforms a tree given as predecessor table into adjacency list form
:param prec: predecessor table representing a tree, prec[u] == v iff u is successor of v,
except for the root where prec[root] == root
:param root: root vertex of the tree
:returns: undirected graph in listlist represent... | 3.926877 | 3.43189 | 1.144231 |
prec = [None] * len(graph)
prec[root] = root # mark to visit root only once
to_visit = [root]
while to_visit: # DFS
node = to_visit.pop()
for neighbor in graph[node]:
if prec[neighbor] is None:
prec[neighbor] = node
... | def tree_adj_to_prec(graph, root=0) | Transforms a tree given as adjacency list into predecessor table form.
if graph is not a tree: will return a DFS spanning tree
:param graph: directed graph in listlist or listdict format
:returns: tree in predecessor table representation
:complexity: linear | 3.732276 | 4.047039 | 0.922224 |
for u in range(len(graph)):
for v in graph[u]:
if u not in graph[v]:
if type(graph[v]) is list:
graph[v].append(u)
if capac:
capac[v][u] = 0
else:
assert type(graph[v]) is dic... | def add_reverse_arcs(graph, capac=None) | Utility function for flow algorithms that need for every arc (u,v),
the existence of an (v,u) arc, by default with zero capacity.
graph can be in adjacency list, possibly with capacity matrix capac.
or graph can be in adjacency dictionary, then capac parameter is ignored.
:param capac: arc capacity mat... | 2.368279 | 2.495054 | 0.949189 |
graph = [[] for _ in range(len(weight))]
for u in range(len(graph)):
for v in range(len(graph)):
if weight[u][v] != None:
graph[u].append(v)
return graph | def matrix_to_listlist(weight) | transforms a squared weight matrix in a adjacency table of type listlist
encoding the directed graph corresponding to the entries of the matrix
different from None
:param weight: squared weight matrix, weight[u][v] != None iff arc (u,v) exists
:complexity: linear
:returns: the unweighted directed g... | 2.225829 | 2.177643 | 1.022128 |
if weight:
return [{v:weight[u][v] for v in graph[u]} for u in range(len(graph))]
else:
return [{v:None for v in graph[u]} for u in range(len(graph))] | def listlist_and_matrix_to_listdict(graph, weight=None) | Transforms the weighted adjacency list representation of a graph
of type listlist + optional weight matrix
into the listdict representation
:param graph: in listlist representation
:param weight: optional weight matrix
:returns: graph in listdict representation
:complexity: linear | 2.338096 | 2.651943 | 0.881654 |
V = range(len(sparse))
graph = [[] for _ in V]
weight = [[None for v in V] for u in V]
for u in V:
for v in sparse[u]:
graph[u].append(v)
weight[u][v] = sparse[u][v]
return graph, weight | def listdict_to_listlist_and_matrix(sparse) | Transforms the adjacency list representation of a graph
of type listdict into the listlist + weight matrix representation
:param sparse: graph in listdict representation
:returns: couple with listlist representation, and weight matrix
:complexity: linear | 2.725251 | 2.69184 | 1.012412 |
n = len(dictgraph) # vertices
node_to_name = [name for name in dictgraph] # bijection indices <-> names
node_to_name.sort() # to make it more readable
name_to_node = {}
for i in range(n):
name_to_node[node_to_name[i]] = i
sparse... | def dictdict_to_listdict(dictgraph) | Transforms a dict-dict graph representation into a
adjacency dictionary representation (list-dict)
:param dictgraph: dictionary mapping vertices to dictionary
such that dictgraph[u][v] is weight of arc (u,v)
:complexity: linear
:returns: tuple with graph (listdict), name_to_node (dict), node... | 3.033109 | 2.735046 | 1.108979 |
L = []
while v is not None:
L.append(v)
v = prec[v]
assert v not in L # prevent infinite loops for a bad formed table prec
return L[::-1] | def extract_path(prec, v) | extracts a path in form of vertex list from source to vertex v
given a precedence table prec leading to the source
:param prec: precedence table of a tree
:param v: vertex on the tree
:returns: path from root to v, in form of a list
:complexity: linear | 8.644954 | 8.796906 | 0.982727 |
V = range(len(graph))
arc_label = [{v:"" for v in graph[u]} for u in V]
for u in V:
for v in graph[u]:
if flow[u][v] >= 0:
arc_label[u][v] = "%s/%s" % (flow[u][v], capac[u][v])
else:
arc_label[u][v] = None # do not show negative flow arc... | def make_flow_labels(graph, flow, capac) | Generate arc labels for a flow in a graph with capacities.
:param graph: adjacency list or adjacency dictionary
:param flow: flow matrix or adjacency dictionary
:param capac: capacity matrix or adjacency dictionary
:returns: listdic graph representation, with the arc label strings | 2.85742 | 2.778512 | 1.0284 |
n = len(graph)
match = max_bipartite_matching(graph) # maximum matching
part = [None] * n # partition into chains
nb_chains = 0
for v in range(n - 1, -1, -1): # in inverse topological order
if part[v] is None: # start of chain
u =... | def dilworth(graph) | Decompose a DAG into a minimum number of chains by Dilworth
:param graph: directed graph in listlist or listdict format
:assumes: graph is acyclic
:returns: table giving for each vertex the number of its chains
:complexity: same as matching | 4.238423 | 4.051129 | 1.046233 |
h = []
for a in freq:
heappush(h, (freq[a], a))
while len(h) > 1:
(fl, l) = heappop(h)
(fr, r) = heappop(h)
heappush(h, (fl + fr, [l, r]))
code = {}
extract(code, h[0][1])
return code | def huffman(freq) | Huffman code
:param freq: dictionary with frequencies for each item
:returns: dictionary with binary code string for each item
:complexity: O(n log n) | 2.603627 | 2.805361 | 0.92809 |
if isinstance(tree, list):
l, r = tree
prefix.append('0')
extract(code, l, prefix)
prefix.pop()
prefix.append('1')
extract(code, r, prefix)
prefix.pop()
else:
code[tree] = ''.join(prefix) | def extract(code, tree, prefix=[]) | Extract Huffman code from a Huffman tree
:param tree: a node of the tree
:param prefix: a list with the 01 characters encoding the path from
the root to the node `tree`
:complexity: O(n) | 2.247418 | 2.692705 | 0.834632 |
n = len(tab)
pivot = None # find pivot
for i in range(n - 1):
if tab[i] < tab[i + 1]:
pivot = i
if pivot is None: # tab is already the last perm.
return False
for i in range(pivot + 1, n): # find the element to swap
... | def next_permutation(tab) | find the next permutation of tab in the lexicographical order
:param tab: table with n elements from an ordered set
:modifies: table to next permutation
:returns: False if permutation is already lexicographical maximal
:complexity: O(n) | 2.402094 | 2.49367 | 0.963277 |
E = [(low, -1) for (low, high) in S]
E += [(high, +1) for (low, high) in S]
nb_open = 0
last = None
retval = []
for x, _dir in sorted(E):
if _dir == -1:
if nb_open == 0:
last = x
nb_open += 1
else:
nb_open -= 1
... | def intervals_union(S) | Union of intervals
:param S: list of pairs (low, high) defining intervals [low, high)
:returns: ordered list of disjoint intervals with the same union as S
:complexity: O(n log n) | 2.937036 | 3.238546 | 0.9069 |
# -- assume w.l.o.g. that v is not higher than u in the tree
if self.level[u] > self.level[v]:
u, v = v, u
# -- put v at the same level as u
depth = len(self.anc)
for k in range(depth-1, -1, -1):
if self.level[u] <= self.level[v] - (1 << k):
... | def query(self, u, v) | :returns: the lowest common ancestor of u and v
:complexity: O(log n) | 2.807122 | 2.668321 | 1.052018 |
lu = self.last[u]
lv = self.last[v]
if lu > lv:
lu, lv = lv, lu
return self.rmq.range_min(lu, lv + 1)[1] | def query(self, u, v) | :returns: the lowest common ancestor of u and v
:complexity: O(log n) | 5.090863 | 5.660057 | 0.899437 |
assert a >= 0 and b >= 0 and q >= 1
p = 0 # only for documentation
p2 = 1 # 2 ** p
ap2 = a % q # a ** (2 ** p)
result = 1
while b > 0:
if p2 & b > 0: # b's binary decomposition contains 2 ** p
b -= p2
result = (result * ap2... | def fast_exponentiation2(a, b, q) | Compute (a pow b) % q
:param int a b: non negative
:param int q: positive
:complexity: O(log b) | 4.311985 | 4.522902 | 0.953367 |
assert a >= 0 and b >= 0 and q >= 1
result = 1
while b:
if b % 2 == 1:
result = (result * a) % q
a = (a * a) % q
b >>= 1
return result | def fast_exponentiation(a, b, q) | Compute (a pow b) % q, alternative shorter implementation
:param int a b: non negative
:param int q: positive
:complexity: O(log b) | 1.796124 | 2.094866 | 0.857393 |
visit[u] = True
if u == target:
return val
for v in graph[u]:
cuv = capacity[u][v]
if not visit[v] and cuv > flow[u][v]: # reachable arc
res = min(val, cuv - flow[u][v])
delta = _augment(graph, capacity, flow, res, v, target, visit)
if delta ... | def _augment(graph, capacity, flow, val, u, target, visit) | Find an augmenting path from u to target with value at most val | 2.660559 | 2.550047 | 1.043337 |
add_reverse_arcs(graph, capacity)
n = len(graph)
flow = [[0] * n for _ in range(n)]
INF = float('inf')
while _augment(graph, capacity, flow, INF, s, t, [False] * n) > 0:
pass # work already done in _augment
return (flow, sum(flow[s])) | def ford_fulkerson(graph, capacity, s, t) | Maximum flow by Ford-Fulkerson
:param graph: directed graph in listlist or listdict format
:param capacity: in matrix format or same listdict graph
:param int s: source vertex
:param int t: target vertex
:returns: flow matrix, flow value
:complexity: `O(|V|*|E|*max_capacity)` | 5.046917 | 5.502668 | 0.917176 |
dist, i, j = 0, 0, 0 # dist = |{x[i], ..., x[j-1]}|
occ = {xi: 0 for xi in x} # number of occurrences in x[i:j]
while j < len(x):
while dist == k: # move start of interval
occ[x[i]] -= 1 # update counters
if occ[x[i]] ... | def windows_k_distinct(x, k) | Find all largest windows containing exactly k distinct elements
:param x: list or string
:param k: positive integer
:yields: largest intervals [i, j) with len(set(x[i:j])) == k
:complexity: `O(|x|)` | 3.239561 | 3.068288 | 1.05582 |
if b == 0:
return (1, 0)
else:
u, v = bezout(b, a % b)
return (v, u - (a // b) * v) | def bezout(a, b) | Bezout coefficients for a and b
:param a,b: non-negative integers
:complexity: O(log a + log b) | 2.372169 | 2.652587 | 0.894285 |
prod = 1
for i in range(k):
prod = (prod * (n - i)) // (i + 1)
return prod | def binom(n, k) | Binomial coefficients for :math:`n \choose k`
:param n,k: non-negative integers
:complexity: O(k) | 2.571579 | 3.503433 | 0.734017 |
prod = 1
for i in range(k):
prod = (prod * (n - i) * inv(i + 1, p)) % p
return prod | def binom_modulo(n, k, p) | Binomial coefficients for :math:`n \choose k`, modulo p
:param n,k: non-negative integers
:complexity: O(k) | 2.834732 | 3.50485 | 0.808802 |
n = len(bigraph) # same domain for U and V
match = [None] * n
for u in range(n):
augment(u, bigraph, [False] * n, match)
return match | def max_bipartite_matching(bigraph) | Bipartie maximum matching
:param bigraph: adjacency list, index = vertex in U,
value = neighbor list in V
:assumption: U = V = {0, 1, 2, ..., n - 1} for n = len(bigraph)
:returns: matching list, match[v] == u iff (u, v) in matching
:complexity: `O(|V|*|E|)` | 7.715509 | 7.183265 | 1.074095 |
nU = len(bigraph)
# the following line works only in Python version ≥ 2.5
# nV = max(max(adjlist, default=-1) for adjlist in bigraph) + 1
nV = 0
for adjlist in bigraph:
for v in adjlist:
if v + 1 > nV:
nV = v + 1
match = [None] * nV
for u in range(nU)... | def max_bipartite_matching2(bigraph) | Bipartie maximum matching
:param bigraph: adjacency list, index = vertex in U,
value = neighbor list in V
:comment: U and V can have different cardinalities
:returns: matching list, match[v] == u iff (u, v) in matching
:complexity: `O(|V|*|E|)` | 3.991101 | 4.062602 | 0.9824 |
freq = {} # freq[p] = total weight of words having prefix p
for word, weight in dic:
prefix = ""
for x in word:
prefix += x
if prefix in freq:
freq[prefix] += weight
else:
freq[prefix] = weight
# prop[s] = prefix to... | def predictive_text(dic) | Predictive text for mobile phones
:param dic: associates weights to words from [a-z]*
:returns: a dictionary associating to words from [2-9]*
a corresponding word from the dictionary with highest weight
:complexity: linear in total word length | 4.809137 | 4.8561 | 0.990329 |
answ = 0
pairs = {}
for j in range(len(S)):
for i in range(j):
px, py = S[i]
qx, qy = S[j]
center = (px + qx, py + qy)
dist = (px - qx) ** 2 + (py - qy) ** 2
sign = (center, dist)
if sign in pairs:
answ += l... | def rectangles_from_points(S) | How many rectangles can be formed from a set of points
:param S: list of points, as coordinate pairs
:returns: the number of rectangles
:complexity: :math:`O(n^2)` | 2.497782 | 2.605762 | 0.958561 |
n = len(graph)
time = 0
num = [None] * n
low = [n] * n
father = [None] * n # father[v] = None if root else father of v
critical_childs = [0] * n # c_c[u] = #childs v s.t. low[v] >= num[u]
times_seen = [-1] * n
for start in range(n):
if times_seen[start] == -1: ... | def cut_nodes_edges(graph) | Bi-connected components
:param graph: undirected graph. in listlist format. Cannot be in listdict format.
:returns: a tuple with the list of cut-nodes and the list of cut-edges
:complexity: `O(|V|+|E|)` | 3.300678 | 3.300629 | 1.000015 |
N = len(graph)
assert N <= 5000
recursionlimit = getrecursionlimit()
setrecursionlimit(max(recursionlimit, N + 42))
edges = set((i, j) for i in range(N) for j in graph[i] if i <= j)
nodes = set()
NOT = -2 # not visited yet; -1 would be buggy `marked[v] != prof - 1`
FIN = -3 # alre... | def cut_nodes_edges2(graph) | Bi-connected components, alternative recursive implementation
:param graph: undirected graph. in listlist format. Cannot be in listdict format.
:assumes: graph has about 5000 vertices at most, otherwise memory limit is reached
:returns: a tuple with the list of cut-nodes and the list of cut-edges
:comp... | 5.276485 | 5.225827 | 1.009694 |
A = 0
for i in range(len(p)):
A += p[i - 1][0] * p[i][1] - p[i][0] * p[i - 1][1]
return A / 2. | def area(p) | Area of a polygone
:param p: list of the points taken in any orientation,
p[0] can differ from p[-1]
:returns: area
:complexity: linear | 1.937161 | 2.004974 | 0.966177 |
n = len(polygon)
order = list(range(n))
order.sort(key=lambda i: polygon[i]) # lexicographic order
rank_to_y = list(set(p[1] for p in polygon))
rank_to_y.sort()
y_to_rank = {y: rank for rank, y in enumerate(rank_to_y)}
S = RangeMinQuery([0] * len(rank_to_y)) # sweep structu... | def is_simple(polygon) | Test if a rectilinear polygon is is_simple
:param polygon: list of points as (x,y) pairs along the closed polygon
:returns: True if the segements do not intersect
:complexity: O(n log n) for n=len(polygon) | 4.173465 | 4.219836 | 0.989011 |
shuffle(S)
assert len(S) >= 2
p = S[0]
q = S[1]
d = dist(p, q)
while d > 0:
r = improve(S, d)
if r:
d, p, q = r
else:
break
return p, q | def closest_points(S) | Closest pair of points
:param S: list of points
:requires: size of S at least 2
:modifies: changes the order in S
:returns: pair of points p,q from S with minimum Euclidean distance
:complexity: expected linear time | 3.126878 | 3.142718 | 0.99496 |
n = len(x)
p = [None] * n
h = [None]
b = [float('-inf')] # - infinity
for i in range(n):
if x[i] > b[-1]:
p[i] = h[-1]
h.append(i)
b.append(x[i])
else:
# -- binary search: b[k - 1] < x[i] <= b[k]
k = bisect_left(b, x... | def longest_increasing_subsequence(x) | Longest increasing subsequence
:param x: sequence
:returns: longest strictly increasing subsequence y
:complexity: `O(|x|*log(|y|))` | 2.641481 | 2.689547 | 0.982129 |
seen[node] = True
for neighbor in graph[node]:
if not seen[neighbor]:
dfs_recursive(graph, neighbor, seen) | def dfs_recursive(graph, node, seen) | DFS, detect connected component, recursive implementation
:param graph: directed graph in listlist or listdict format
:param int node: to start graph exploration
:param boolean-table seen: will be set true for the connected component
containing node.
:complexity: `O(|V|+|E|)` | 1.927156 | 3.227336 | 0.597135 |
seen[start] = True
to_visit = [start]
while to_visit:
node = to_visit.pop()
for neighbor in graph[node]:
if not seen[neighbor]:
seen[neighbor] = True
to_visit.append(neighbor) | def dfs_iterative(graph, start, seen) | DFS, detect connected component, iterative implementation
:param graph: directed graph in listlist or listdict format
:param int node: to start graph exploration
:param boolean-table seen: will be set true for the connected component
containing node.
:complexity: `O(|V|+|E|)` | 1.738724 | 2.347103 | 0.740796 |
to_visit = [start]
prec = [None] * len(graph)
while to_visit: # an empty queue equals False
node = to_visit.pop()
for neighbor in graph[node]:
if prec[neighbor] is None:
prec[neighbor] = node
to_visit.append(neighbor)
return p... | def dfs_tree(graph, start=0) | DFS, build DFS tree in unweighted graph
:param graph: directed graph in listlist or listdict format
:param int start: source vertex
:returns: precedence table
:complexity: `O(|V|+|E|)` | 3.213079 | 3.30424 | 0.972411 |
height = len(grid)
width = len(grid[0])
grid[i][j] = mark # mark path
for ni, nj in [(i + 1, j), (i, j + 1),
(i - 1, j), (i, j - 1)]:
if 0 <= ni < height and 0 <= nj < width:
if grid[ni][nj] == free:
dfs_grid(grid, ni, nj) | def dfs_grid_recursive(grid, i, j, mark='X', free='.') | DFS on a grid, mark connected component, iterative version
:param grid: matrix, 4-neighborhood
:param i,j: cell in this matrix, start of DFS exploration
:param free: symbol for walkable cells
:param mark: symbol to overwrite visited vertices
:complexity: linear | 2.037915 | 2.089715 | 0.975212 |
height = len(grid)
width = len(grid[0])
to_visit = [(i, j)]
grid[i][j] = mark
while to_visit:
i1, j1 = to_visit.pop()
for i2, j2 in [(i1 + 1, j1), (i1, j1 + 1),
(i1 - 1, j1), (i1, j1 - 1)]:
if (0 <= i2 < height and 0 <= j2 < width and
... | def dfs_grid(grid, i, j, mark='X', free='.') | DFS on a grid, mark connected component, iterative version
:param grid: matrix, 4-neighborhood
:param i,j: cell in this matrix, start of DFS exploration
:param free: symbol for walkable cells
:param mark: symbol to overwrite visited vertices
:complexity: linear | 1.640324 | 1.66959 | 0.982471 |
n = len(graph)
prec = [None] * n # ancestor marks for visited vertices
for u in range(n):
if prec[u] is None: # unvisited vertex
S = [u] # start new DFS
prec[u] = u # mark root (not necessary for this algorithm)
while S:
u = S.pop()
... | def find_cycle(graph) | find a cycle in an undirected graph
:param graph: undirected graph in listlist or listdict format
:returns: list of vertices in a cycle or None
:complexity: `O(|V|+|E|)` | 4.766705 | 4.673367 | 1.019972 |
if isinstance(expr, tuple):
(left, op, right) = expr
lval = arithm_expr_eval(cell, left)
rval = arithm_expr_eval(cell, right)
if op == '+':
return lval + rval
if op == '-':
return lval - rval
if op == '*':
return lval * rval
... | def arithm_expr_eval(cell, expr) | Evaluates a given expression
:param expr: expression
:param cell: dictionary variable name -> expression
:returns: numerical value of expression
:complexity: linear | 1.535183 | 1.686752 | 0.910141 |
vals = []
ops = []
for tok in line + [';']:
if tok in priority: # tok is an operator
while (tok != '(' and ops and
priority[ops[-1]] >= priority[tok]):
right = vals.pop()
left = vals.pop()
vals.append((left, ops.pop... | def arithm_expr_parse(line) | Constructs an arithmetic expression tree
:param line: list of token strings containing the expression
:returns: expression tree
:complexity: linear | 3.238914 | 3.163956 | 1.023691 |
sum = 0
while i > 0:
sum += self.s[i]
i -= (i & -i)
return sum | def prefixSum(self, i) | :param int i: non negative
:returns: t[1] + ... + t[i] | 2.810672 | 2.9662 | 0.947567 |
return self.prefixSum(b) - self.prefixSum(a-1) | def intervalSum(self, a, b) | :param int a b: with 1 <= a <= b
:returns: t[a] + ... + t[b] | 5.546747 | 4.140946 | 1.339488 |
assert i > 0
while i < len(self.s):
self.s[i] += val
i += (i & -i) | def add(self, i, val) | :param int i: positive
:modifies: adds val to t[i] | 3.515872 | 3.356416 | 1.047508 |
self.add(a, +val)
self.add(b + 1, -val) | def intervalAdd(self, a, b, val) | Variant, adds val to t[a], to t[a + 1] ... and to t[b]
:param int a b: with 1 <= a <= b | 6.574204 | 7.103208 | 0.925526 |
visitU[u] = True
for v in bigraph[u]:
if not visitV[v]:
visitV[v] = True
assert matchV[v] is not None # otherwise match is not maximum
_alternate(matchV[v], bigraph, visitU, visitV, matchV) | def _alternate(u, bigraph, visitU, visitV, matchV) | extend alternating tree from free vertex u.
visitU, visitV marks all vertices covered by the tree. | 3.090788 | 3.256078 | 0.949237 |
V = range(len(bigraph))
matchV = max_bipartite_matching(bigraph)
matchU = [None for u in V]
for v in V: # -- build the mapping from U to V
if matchV[v] is not None:
matchU[matchV[v]] = v
visitU = [False for u in V] # -- build max alternating forest
... | def bipartite_vertex_cover(bigraph) | Bipartite minimum vertex cover by Koenig's theorem
:param bigraph: adjacency list, index = vertex in U,
value = neighbor list in V
:assumption: U = V = {0, 1, 2, ..., n - 1} for n = len(bigraph)
:returns: boolean table for U, boolean table for V
:comment: selected ve... | 4.811944 | 4.777521 | 1.007205 |
if R == []:
return 0
X = []
Y = []
for j in range(len(R)):
(x1, y1, x2, y2) = R[j]
assert x1 <= x2 and y1 <= y2
X.append(x1)
X.append(x2)
Y.append((y1, +1, j)) # generate events
Y.append((y2, -1, j))
X.sort()
Y.sort()
X2i = {X[i... | def union_rectangles(R) | Area of union of rectangles
:param R: list of rectangles defined by (x1, y1, x2, y2)
where (x1, y1) is top left corner and (x2, y2) bottom right corner
:returns: area
:complexity: :math:`O(n^2)` | 2.827785 | 2.843084 | 0.994619 |
self._change(1, 0, self.N, i, k, delta) | def change(self, i, k, delta) | when delta = +1, adds an interval [i, k], when delta = -1, removes it
:complexity: O(log L) | 8.652453 | 8.289505 | 1.043784 |
formula = []
for line in open(filename, 'r'):
line = line.strip()
if line[0] == "#":
continue
lit = line.split(":-")
if len(lit) == 1:
posvar = lit[0]
negvars = []
else:
assert len(lit) == 2
posvar = lit[0].... | def read(filename) | reads a Horn SAT formula from a text file
:file format:
# comment
A # clause with unique positive literal
:- A # clause with unique negative literal
A :- B, C, D # clause where A is positive and B,C,D negative
# variables are strings without spaces | 2.337332 | 2.094463 | 1.115958 |
# --- construct data structures
CLAUSES = range(len(formula))
score = [0 for c in CLAUSES] # number of negative vars that are not yet in solution
posvar_in_clause = [None for c in CLAUSES] # the unique positive variable of a clause (if any)
clauses_with_negvar = defaultdict(set)... | def horn_sat(formula) | Solving a HORN Sat formula
:param formula: list of couple(posvar, negvars).
negvars is a list of the negative variables and can be empty.
posvar is the positive variable and can be None.
Variables can be any hashable objects, as integers or strings
... | 4.123975 | 3.851963 | 1.070616 |
assert source != target
add_reverse_arcs(graph, capacity)
Q = deque()
total = 0
n = len(graph)
flow = [[0] * n for u in range(n)] # flow initially empty
while True: # repeat while we can increase
Q.appendleft(source)
lev = [None] * n # build ... | def dinic(graph, capacity, source, target) | Maximum flow by Dinic
:param graph: directed graph in listlist or listdict format
:param capacity: in matrix format or same listdict graph
:param int source: vertex
:param int target: vertex
:returns: skew symmetric flow matrix, flow value
:complexity: :math:`O(|V|^2 |E|)` | 4.284496 | 4.309346 | 0.994234 |
if limit <= 0:
return 0
if u == target:
return limit
val = 0
for v in graph[u]:
residual = capacity[u][v] - flow[u][v]
if lev[v] == lev[u] + 1 and residual > 0:
z = min(limit, residual)
aug = _dinic_step(graph, capacity, lev, flow, v, target, ... | def _dinic_step(graph, capacity, lev, flow, u, target, limit) | tenter de pousser le plus de flot de u à target, sans dépasser limit | 2.816087 | 2.878124 | 0.978445 |
assert x not in self.rank
i = len(self.heap)
self.heap.append(x) # add a new leaf
self.rank[x] = i
self.up(i) | def push(self, x) | Insert new element x in the heap.
Assumption: x is not already in the heap | 4.966285 | 4.447943 | 1.116535 |
root = self.heap[1]
del self.rank[root]
x = self.heap.pop() # remove last leaf
if self: # if heap is not empty
self.heap[1] = x # put last leaf to root
self.rank[x] = 1
self.down(1) # maintain heap order
return... | def pop(self) | Remove and return smallest element | 5.026011 | 5.011926 | 1.00281 |
x = self.heap[i]
while i > 1 and x < self.heap[i // 2]:
self.heap[i] = self.heap[i // 2]
self.rank[self.heap[i // 2]] = i
i //= 2
self.heap[i] = x # insertion index found
self.rank[x] = i | def up(self, i) | The value of heap[i] has decreased. Maintain heap invariant. | 2.713619 | 2.351341 | 1.154073 |
x = self.heap[i]
n = len(self.heap)
while True:
left = 2 * i # climb down the tree
right = left + 1
if (right < n and self.heap[right] < x and
self.heap[right] < self.heap[left]):
self.heap[i] = self.heap[righ... | def down(self, i) | the value of heap[i] has increased. Maintain heap invariant. | 2.526685 | 2.389108 | 1.057585 |
i = self.rank[old] # change value at index i
del self.rank[old]
self.heap[i] = new
self.rank[new] = i
if old < new: # maintain heap order
self.down(i)
else:
self.up(i) | def update(self, old, new) | Replace an element in the heap | 4.724 | 4.253144 | 1.110708 |
uf = UnionFind(len(graph))
edges = []
for u in range(len(graph)):
for v in graph[u]:
edges.append((weight[u][v], u, v))
edges.sort()
mst = []
for w, u, v in edges:
if uf.union(u, v):
mst.append((u, v))
return mst | def kruskal(graph, weight) | Minimum spanning tree by Kruskal
:param graph: undirected graph in listlist or listdict format
:param weight: in matrix format or same listdict graph
:returns: list of edges of the tree
:complexity: ``O(|E|log|E|)`` | 1.858301 | 2.147258 | 0.86543 |
if self.up[x] == x:
return x
else:
self.up[x] = self.find(self.up[x])
return self.up[x] | def find(self, x) | :returns: identifier of part containing x
:complexity: O(inverse_ackerman(n)) | 2.309671 | 2.378569 | 0.971034 |
repr_x = self.find(x)
repr_y = self.find(y)
if repr_x == repr_y: # already in the same component
return False
if self.rank[repr_x] == self.rank[repr_y]:
self.rank[repr_x] += 1
self.up[repr_y] = repr_x
elif self.rank[repr_x] > sel... | def union(self, x, y) | Merges part that contain x and part containing y
:returns: False if x, y are already in same part
:complexity: O(inverse_ackerman(n)) | 1.888129 | 1.986948 | 0.950266 |
self.prec = anchor.prec # point to neighbors
self.succ = anchor
self.succ.prec = self # make neighbors point to item
self.prec.succ = self | def insert(self, anchor) | insert list item before anchor | 10.312098 | 9.932246 | 1.038244 |
if not self.items: # was list empty ?
self.items = item # then this is the new head
item.insert(self.items) | def append(self, item) | add item to the end of the item list | 13.069942 | 12.483626 | 1.046967 |
DoubleLinkedListItem.remove(self) # remove from double linked list
if self.succ is self: # list was a singleton
self.theclass.items = None # class is empty
elif self.theclass.items is self: # oups we removed the head
self.theclass.i... | def remove(self) | remove item from its class | 10.895876 | 9.001258 | 1.210484 |
has_split = [] # remember which classes split
for i in pivot:
if 0 <= i < len(self.items): # ignore if outside of domain
x = self.items[i]
c = x.theclass # c = class of x
if not c.split: ... | def refine(self, pivot) | Split every class C in the partition into C intersection pivot and C setminus pivot
complexity: linear in size of pivot | 6.14483 | 5.841888 | 1.051857 |
return [[x.val for x in theclass.items] for theclass in self.classes] | def tolist(self) | produce a list representation of the partition | 13.084668 | 10.987804 | 1.190836 |
return [x.val for theclass in self.classes for x in theclass.items] | def order(self) | Produce a flatten list of the partition, ordered by classes | 18.233137 | 10.259227 | 1.777243 |
P = [True] * n
answ = [2]
for i in range(3, n, 2):
if P[i]:
answ.append(i)
for j in range(2 * i, n, i):
P[j] = False
return answ | def eratosthene(n) | Prime numbers by sieve of Eratosthene
:param n: positive integer
:assumes: n > 2
:returns: list of prime numbers <n
:complexity: O(n loglog n) | 2.652076 | 2.308539 | 1.148811 |
primes = []
factor = [0] * n
for x in range(2, n):
if not factor[x]: # no factor found
factor[x] = x # meaning x is prime
primes.append(x)
for p in primes: # loop over all non primes of the form p * x
if p > factor[x] or p * x >= n:
... | def gries_misra(n) | Prime numbers by the sieve of Gries-Misra
Computes both the list of all prime numbers less than n,
and a table mapping every integer 2 ≤ x < n to its smallest prime factor
:param n: positive integer
:returns: list of prime numbers, and list of prime factors
:complexity: O(n) | 4.260213 | 4.118789 | 1.034336 |
n = len(graph)
A = [0] * n # A[v] = min residual cap. on path source->v
augm_path = [None] * n # None = node was not visited yet
Q = deque() # BFS
Q.append(source)
augm_path[source] = source
A[source] = float('inf')
while Q:
u = Q.popleft()
... | def _augment(graph, capacity, flow, source, target) | find a shortest augmenting path | 3.080327 | 2.977833 | 1.034419 |
add_reverse_arcs(graph, capacity)
V = range(len(graph))
flow = [[0 for v in V] for u in V]
while True:
augm_path, delta = _augment(graph, capacity, flow, source, target)
if delta == 0:
break
v = target # go back to source
while v != sou... | def edmonds_karp(graph, capacity, source, target) | Maximum flow by Edmonds-Karp
:param graph: directed graph in listlist or listdict format
:param capacity: in matrix format or same listdict graph
:param int source: vertex
:param int target: vertex
:returns: flow matrix, flow value
:complexity: :math:`O(|V|*|E|^2)` | 4.018068 | 4.19777 | 0.957191 |
n = len(x)
m = len(b)
assert len(A) == m and len(A[0]) == n
S = [] # put linear system in a single matrix S
for i in range(m):
S.append(A[i][:] + [b[i]])
S.append(list(range(n))) # indices in x
k = diagonalize(S, n, m)
if k < m:
for i in r... | def gauss_jordan(A, x, b) | Linear equation system Ax=b by Gauss-Jordan
:param A: n by m matrix
:param x: table of size n
:param b: table of size m
:modifies: x will contain solution if any
:returns int:
0 if no solution,
1 if solution unique,
2 otherwise
:complexity: :math:`O(n^2m)` | 3.651442 | 3.579134 | 1.020203 |
for d in range(k):
if s[i + d] != t[j + d]:
return False
return True | def matches(s, t, i, j, k) | tests if s[i:i + k] equals t[j:j + k] | 2.574063 | 2.321618 | 1.108737 |
hash_s = 0
hash_t = 0
len_s = len(s)
len_t = len(t)
last_pos = pow(DOMAIN, len_t - 1) % PRIME
if len_s < len_t:
return -1
for i in range(len_t): # preprocessing
hash_s = (DOMAIN * hash_s + ord(s[i])) % PRIME
hash_t = (DOMAIN * hash_t + ord(t[i])) % PRIME
... | def rabin_karp_matching(s, t) | Find a substring by Rabin-Karp
:param s: the haystack string
:param t: the needle string
:returns: index i such that s[i: i + len(t)] == t, or -1
:complexity: O(len(s) + len(t)) in expected time,
and O(len(s) * len(t)) in worst case | 2.345708 | 2.590363 | 0.905552 |
last_pos = pow(DOMAIN, k - 1) % PRIME
pos = {}
assert k > 0
if len(s) < k or len(t) < k:
return None
hash_t = 0
for j in range(k): # store hashing values
hash_t = (DOMAIN * hash_t + ord(t[j])) % PRIME
for j in range(len(t) - k + 1):
if hash_t in pos:
... | def rabin_karp_factor(s, t, k) | Find a common factor by Rabin-Karp
:param string s: haystack
:param string t: needle
:param int k: factor length
:returns: (i, j) such that s[i:i + k] == t[j:j + k] or None.
In case of tie, lexicographical minimum (i, j) is returned
:complexity: O(len(s) + len(t)) in expected time,
... | 2.489112 | 2.599501 | 0.957535 |
best = (float('-inf'), 0, 0, 0)
S = []
H2 = H + [float('-inf')] # extra element to empty the queue
for right in range(len(H2)):
x = H2[right]
left = right
while len(S) > 0 and S[-1][1] >= x:
left, height = S.pop()
# first element is area of candidate... | def rectangles_from_histogram(H) | Largest Rectangular Area in a Histogram
:param H: histogram table
:returns: area, left, height, right, rect. is [0, height] * [left, right)
:complexity: linear | 4.74811 | 4.675136 | 1.015609 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.