from test_framework import generic_test
from sortedcontainers import SortedSet
from math import sqrt
def generate_first_k_a_b_sqrt2(k):
result = []
q = sqrt(2)
tree = SortedSet([(0.0, 0, 0)])
while len(result) < k:
smallest = tree.pop(0)
result.append(smallest[0])
a = smallest[1]
b = smallest[2]
tree.add(((a + 1) + b * q, a + 1, b))
tree.add((a + (b + 1) * q, a, b + 1))
return result
if __name__ == '__main__':
exit(
generic_test.generic_test_main("a_b_sqrt2.py", 'a_b_sqrt2.tsv',
generate_first_k_a_b_sqrt2))
from test_framework import generic_test
def find_element_appears_once(A):
# TODO - you fill in here.
return 0
if __name__ == '__main__':
exit(
generic_test.generic_test_main("element_appearing_once.py",
'element_appearing_once.tsv',
find_element_appears_once))
if t.d == -1: # Unvisited vertex.
t.d = q[0].d + 1
q.append(t)
elif t.d == q[0].d:
return False
del q[0]
return True
return all(bfs(v) for v in graph if v.d == -1)
@enable_executor_hook
def is_any_placement_feasible_wrapper(executor, k, edges):
if k <= 0:
raise RuntimeError('Invalid k value')
graph = [GraphVertex() for _ in range(k)]
for (fr, to) in edges:
if fr < 0 or fr >= k or to < 0 or to >= k:
raise RuntimeError('Invalid vertex index')
graph[fr].edges.append(graph[to])
return executor.run(functools.partial(is_any_placement_feasible, graph))
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_circuit_wirable.py",
'is_circuit_wirable.tsv',
is_any_placement_feasible_wrapper))
from test_framework import generic_test
# Assumes L has at least k nodes, deletes the k-th last node in L.
def remove_kth_last(L, k):
# TODO - you fill in here.
return None
if __name__ == '__main__':
exit(
generic_test.generic_test_main("delete_kth_last_from_list.py",
'delete_kth_last_from_list.tsv',
remove_kth_last))
from test_framework import generic_test
def multiply(x, y):
def add(a, b):
while b:
carry = a & b
a, b = a ^ b, carry << 1
return a
running_sum = 0
while x: # Examines each bit of x.
if x & 1:
running_sum = add(running_sum, y)
x, y = x >> 1, y << 1
return running_sum
if __name__ == '__main__':
exit(
generic_test.generic_test_main("primitive_multiply.py",
'primitive_multiply.tsv', multiply))
from test_framework import generic_test
cache = {}
def fibonacci(n):
if n <= 1:
return n
elif n not in cache:
cache[n] = fibonacci(n - 1) + fibonacci(n - 2)
return cache[n]
if __name__ == '__main__':
exit(
generic_test.generic_test_main("fibonacci.py", 'fibonacci.tsv',
fibonacci))
from test_framework import generic_test
# Given n, return all primes up to and including n.
def generate_primes(n):
if n < 2:
return []
size = (n - 3) // 2 + 1
primes = [2] # Stores the primes from 1 to n.
# is_prime[i] represents (2i + 3) is prime or not.
# Initially set each to true. Then use sieving to eliminate nonprimes.
is_prime = [True] * size
for i in range(size):
if is_prime[i]:
p = i * 2 + 3
primes.append(p)
# Sieving from p^2, where p^2 = (4i^2 + 12i + 9). The index in is_prime
# is (2i^2 + 6i + 3) because is_prime[i] represents 2i + 3.
#
# Note that we need to use long for j because p^2 might overflow.
for j in range(2 * i**2 + 6 * i + 3, size, p):
is_prime[j] = False
return primes
if __name__ == '__main__':
exit(
generic_test.generic_test_main("prime_sieve.py", "prime_sieve.tsv",
generate_primes))
def smallest_nonconstructible_value(A):
max_constructible_value = 0
for a in sorted(A):
if a > max_constructible_value + 1:
break
max_constructible_value += a
return max_constructible_value + 1
import functools
from sys import exit
from test_framework import generic_test, test_utils
def smallest_nonconstructible_value_pythonic(A):
return functools.reduce(
lambda max_val, a: max_val +
(0 if a > max_val + 1 else a), sorted(A), 0) + 1
if __name__ == '__main__':
exit(
generic_test.generic_test_main('smallest_nonconstructible_value.tsv',
smallest_nonconstructible_value))
# Adds the first k elements into min_heap. Stop if there are fewer than k
# elements.
for x in itertools.islice(sequence, k):
heapq.heappush(min_heap, x)
result = []
# For every new element, add it to min_heap and extract the smallest.
for x in sequence:
smallest = heapq.heappushpop(min_heap, x)
result.append(smallest)
# sequence is exhausted, iteratively extracts the remaining elements.
# while min_heap:
# smallest = heapq.heappop(min_heap)
# result.append(smallest)
# The above while loop can be replaced by following faster substitute
result.extend(heapq.nsmallest(k, min_heap))
return result
def sort_approximately_sorted_array_wrapper(sequence, k):
return sort_approximately_sorted_array(iter(sequence), k)
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
'sort_almost_sorted_array.py', 'sort_almost_sorted_array.tsv',
sort_approximately_sorted_array_wrapper))
from test_framework import generic_test
def swap_bits(x, i, j):
# TODO - you fill in here.
i_bit = x >> i & 1
j_bit = x >> j & 1
if i_bit != j_bit:
bit_mask = (1 << i) | (1 << j)
x = x ^ bit_mask
return x
if __name__ == '__main__':
exit(
generic_test.generic_test_main("swap_bits.py", 'swap_bits.tsv',
swap_bits))
from test_framework import generic_test, test_utils
def generate_power_set(S):
# TODO - you fill in here.
subsets = []
for i in range(1 << len(S)):
subset = []
for j in range(len(S)):
if i & (1 << j):
subset.append(S[j])
subsets.append(subset)
return subsets
if __name__ == '__main__':
exit(
generic_test.generic_test_main("power_set.py", 'power_set.tsv',
generate_power_set,
test_utils.unordered_compare))
def convert_base(num_as_string, b1, b2):
# Implement this placeholder.
return ''
from sys import exit
from test_framework import generic_test, test_utils
if __name__ == '__main__':
exit(generic_test.generic_test_main("convert_base.tsv", convert_base))
# Input nodes are nonempty and the key at s is less than or equal to that at b.
def find_LCA(tree, s, b):
# TODO - you fill in here.
search_node = tree
while search_node:
if s.data <= search_node.data and b.data >= search_node.data:
return search_node
elif b.data < search_node.data:
search_node = search_node.left
else:
search_node = search_node.right
return None
@enable_executor_hook
def lca_wrapper(executor, tree, s, b):
result = executor.run(
functools.partial(find_LCA, tree, must_find_node(tree, s),
must_find_node(tree, b)))
if result is None:
raise TestFailure("Result can't be None")
return result.data
if __name__ == '__main__':
exit(
generic_test.generic_test_main("lowest_common_ancestor_in_bst.py",
'lowest_common_ancestor_in_bst.tsv',
lca_wrapper))
return min(min_weights)
"""
def minimum_path_weight(triangle):
# TODO - you fill in here.
cache = {}
def rec_top_down(i,j):
if i == len(triangle) - 1:
return triangle[i][j]
if (i, j) not in cache:
cache[(i, j)] = min(rec_top_down(i+1, j), rec_top_down(i+1, j+1)) + triangle[i][j]
return cache[(i, j)]
if not triangle:
return 0
min_to_row = [0]
for row in triangle:
min_to_row = [min(min_to_row[max(i-1, 0)], min_to_row[min(i, len(min_to_row)-1)]) + row[i] for i in range(len(row))]
return min(min_to_row)
# return rec_top_down(0, 0)
"""
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"minimum_weight_path_in_a_triangle.py",
'minimum_weight_path_in_a_triangle.tsv', minimum_path_weight))
from test_framework import generic_test
def number_of_ways_to_top(top, maximum_step):
def compute_number_of_ways_to_h(h):
if h <= 1:
return 1
if number_of_ways_to_h[h] == 0:
number_of_ways_to_h[h] = sum(
compute_number_of_ways_to_h(h - i)
for i in range(1,
min(maximum_step, h) + 1))
return number_of_ways_to_h[h]
number_of_ways_to_h = [0] * (top + 1)
return compute_number_of_ways_to_h(top)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("number_of_traversals_staircase.py",
"number_of_traversals_staircase.tsv",
number_of_ways_to_top))
from test_framework import generic_test
def gcd(x: int, y: int) -> int:
return x if y == 0 else gcd(y, x % y)
if __name__ == "__main__":
exit(generic_test.generic_test_main("euclidean_gcd.py", "gcd.tsv", gcd))
from test_framework import generic_test
def find_longest_subarray_less_equal_k(A, k):
# TODO - you fill in here.
return 0
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"longest_subarray_with_sum_constraint.py",
'longest_subarray_with_sum_constraint.tsv',
find_longest_subarray_less_equal_k))
import collections
from test_framework import generic_test, test_utils
def find_anagrams(dictionary):
anagrams = collections.defaultdict(list)
for s in dictionary:
anagrams[''.join(sorted(s))].append(s)
groups = []
for group in anagrams.values():
if len(group) >= 2:
groups.append(group)
return groups
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"anagrams.py",
"anagrams.tsv",
find_anagrams,
comparator=test_utils.unordered_compare))
prev, result = None, []
while tree:
if prev is tree.parent:
# We came down to tree from prev.
if tree.left: # Keep going left.
next = tree.left
else:
result.append(tree.data)
# Done with left, so go right if right is not empty. Otherwise,
# go up.
next = tree.right or tree.parent
elif tree.left is prev:
# We came up to tree from its left child.
result.append(tree.data)
# Done with left, so go right if right is not empty. Otherwise, go
# up.
next = tree.right or tree.parent
else: # Done with both children, so move up.
next = tree.parent
prev, tree = tree, next
return result
if __name__ == '__main__':
exit(
generic_test.generic_test_main("tree_with_parent_inorder.py",
'tree_with_parent_inorder.tsv',
inorder_traversal))
from test_framework import generic_test
def look_and_say(n):
# TODO - you fill in here.
return ''
if __name__ == '__main__':
exit(
generic_test.generic_test_main("look_and_say.py", "look_and_say.tsv",
look_and_say))
from list_node import ListNode
from test_framework import generic_test
def add_two_numbers(L1, L2):
place_iter = dummy_head = ListNode()
carry = 0
while L1 or L2 or carry:
val = carry + (L1.data if L1 else 0) + (L2.data if L2 else 0)
L1 = L1.next if L1 else None
L2 = L2.next if L2 else None
place_iter.next = ListNode(val % 10)
carry, place_iter = val // 10, place_iter.next
return dummy_head.next
if __name__ == '__main__':
exit(
generic_test.generic_test_main("int_as_list_add.py",
'int_as_list_add.tsv', add_two_numbers))
def dutch_flag_partition_wrapper(executor, A, pivot_idx):
count = [0, 0, 0]
for x in A:
count[x] += 1
pivot = A[pivot_idx]
executor.run(functools.partial(dutch_flag_partition, pivot_idx, A))
i = 0
while i < len(A) and A[i] < pivot:
count[A[i]] -= 1
i += 1
while i < len(A) and A[i] == pivot:
count[A[i]] -= 1
i += 1
while i < len(A) and A[i] > pivot:
count[A[i]] -= 1
i += 1
if i != len(A):
raise TestFailure('Not partitioned after {}th element'.format(i))
elif any(count):
raise TestFailure("Some elements are missing from original array")
if __name__ == '__main__':
exit(
generic_test.generic_test_main("dutch_national_flag.py",
'dutch_national_flag.tsv',
dutch_flag_partition_wrapper))
def add_interval(disjoint_intervals, new_interval):
# TODO - you fill in here.
return []
@enable_executor_hook
def add_interval_wrapper(executor, disjoint_intervals, new_interval):
disjoint_intervals = [Interval(*x) for x in disjoint_intervals]
return executor.run(
functools.partial(add_interval, disjoint_intervals,
Interval(*new_interval)))
def res_printer(prop, value):
def fmt(x):
return [[e[0], e[1]] for e in x] if x else None
if prop in (PropertyName.EXPECTED, PropertyName.RESULT):
return fmt(value)
else:
return value
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"interval_add.py",
'interval_add.tsv',
add_interval_wrapper,
res_printer=res_printer))
def list_pivoting_wrapper(executor, l, x):
original = linked_to_list(l)
l = executor.run(functools.partial(list_pivoting, l, x))
pivoted = linked_to_list(l)
mode = -1
for i in pivoted:
if mode == -1:
if i == x:
mode = 0
elif i > x:
mode = 1
elif mode == 0:
if i < x:
raise TestFailure('List is not pivoted')
elif i > x:
mode = 1
else:
if i <= x:
raise TestFailure('List is not pivoted')
if sorted(original) != sorted(pivoted):
raise TestFailure('Result list contains different values')
if __name__ == '__main__':
exit(
generic_test.generic_test_main('pivot_list.py', 'pivot_list.tsv',
list_pivoting_wrapper))
'{} > {}'.format(A[i - 1], A[i]))
if i + 1 < len(A):
if A[i] < A[i + 1]:
raise TestFailure().with_property(
PropertyName.RESULT, A).with_mismatch_info(
i, 'A[{}] >= A[{}]'.format(i, i + 1),
'{} < {}'.format(A[i], A[i + 1]))
else:
if i > 0:
if A[i - 1] < A[i]:
raise TestFailure().with_property(
PropertyName.RESULT, A).with_mismatch_info(
i, 'A[{}] >= A[{}]'.format(i - 1, i),
'{} < {}'.format(A[i - 1], A[i]))
if i + 1 < len(A):
if A[i + 1] < A[i]:
raise TestFailure().with_property(
PropertyName.RESULT, A).with_mismatch_info(
i, 'A[{}] <= A[{}]'.format(i, i + 1),
'{} > {}'.format(A[i], A[i + 1]))
executor.run(functools.partial(rearrange, A))
check_answer(A)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("alternating_array.py",
'alternating_array.tsv',
rearrange_wrapper))
from test_framework import generic_test
def inorder_traversal(tree):
result = []
while tree and tree.left:
tree = tree.left
while tree:
result.append(tree.data)
if tree.right:
tree = tree.right
while tree.left:
tree = tree.left
else:
while tree.parent and tree.parent.right is tree:
tree = tree.parent
tree = tree.parent
return result
if __name__ == '__main__':
exit(
generic_test.generic_test_main("tree_with_parent_inorder.py",
'tree_with_parent_inorder.tsv',
inorder_traversal))
import collections
from test_framework import generic_test, test_utils
def find_anagrams(dictionary):
sorted_string_to_anagrams = collections.defaultdict(list)
for s in dictionary:
# Sorts the string, uses it as a key, and then appends the original
# string as another value into hash table.
sorted_string_to_anagrams[''.join(sorted(s))].append(s)
return [
group for group in sorted_string_to_anagrams.values()
if len(group) >= 2
]
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"anagrams.py",
"anagrams.tsv",
find_anagrams,
comparator=test_utils.unordered_compare))
elif left_size == k - 1: # k-th is iter itself.
return tree
else: # k-th node must be in left subtree of iter.
tree = tree.left
return None # If k is between 1 and the tree size, this is unreachable.
@enable_executor_hook
def find_kth_node_binary_tree_wrapper(executor, tree, k):
def init_size(node):
if not node:
return 0
node.size = 1 + init_size(node.left) + init_size(node.right)
return node.size
init_size(tree)
result = executor.run(
functools.partial(find_kth_node_binary_tree, tree, k))
if not result:
raise TestFailure("Result can't be None")
return result.data
if __name__ == '__main__':
exit(
generic_test.generic_test_main("kth_node_in_tree.py",
"kth_node_in_tree.tsv",
find_kth_node_binary_tree_wrapper))
if k < 0:
# No items can be chosen.
return 0
if V[k][available_capacity] == -1:
without_curr_item = optimum_subject_to_item_and_capacity(
k - 1, available_capacity)
with_curr_item = (0 if available_capacity < items[k].weight else (
items[k].value + optimum_subject_to_item_and_capacity(
k - 1, available_capacity - items[k].weight)))
V[k][available_capacity] = max(without_curr_item, with_curr_item)
return V[k][available_capacity]
# V[i][j] holds the optimum value when we choose from items[:i + 1] and have
# a capacity of j.
V = [[-1] * (capacity + 1) for _ in items]
return optimum_subject_to_item_and_capacity(len(items) - 1, capacity)
@enable_executor_hook
def optimum_subject_to_capacity_wrapper(executor, items, capacity):
items = [Item(*i) for i in items]
return executor.run(
functools.partial(optimum_subject_to_capacity, items, capacity))
if __name__ == '__main__':
exit(
generic_test.generic_test_main("knapsack.py", "knapsack.tsv",
optimum_subject_to_capacity_wrapper))
def optimum_subject_to_capacity(items, capacity):
memo = [[-1 for _ in range(capacity + 1)] for _ in range(len(items))]
def fill(item_idx, remaining_cap):
if item_idx == len(items):
return 0
if memo[item_idx][remaining_cap] == -1:
w, v = items[item_idx] #weight, value
memo[item_idx][remaining_cap] = max(
fill(item_idx + 1,
remaining_cap), 0 if remaining_cap < w else v +
fill(item_idx + 1, remaining_cap - w))
return memo[item_idx][remaining_cap]
fill(0, capacity)
return memo[0][capacity]
@enable_executor_hook
def optimum_subject_to_capacity_wrapper(executor, items, capacity):
items = [Item(*i) for i in items]
return executor.run(
functools.partial(optimum_subject_to_capacity, items, capacity))
if __name__ == '__main__':
exit(
generic_test.generic_test_main("knapsack.py", "knapsack.tsv",
optimum_subject_to_capacity_wrapper))
from test_framework import generic_test
def find_first_greater_than_k(tree, k):
# TODO - you fill in here.
return None
def find_first_greater_than_k_wrapper(tree, k):
result = find_first_greater_than_k(tree, k)
return result.data if result else -1
if __name__ == '__main__':
exit(
generic_test.generic_test_main("search_first_greater_value_in_bst.py",
'search_first_greater_value_in_bst.tsv',
find_first_greater_than_k_wrapper))
write_idx += 1
if s[i] == 'a':
a_count += 1
# Backward iteration: replace 'a's with 'dd's starting from the end.
cur_idx = write_idx - 1
write_idx += a_count - 1
final_size = write_idx + 1
while cur_idx >= 0:
if s[cur_idx] == 'a':
s[write_idx - 1:write_idx + 1] = 'dd'
write_idx -= 2
else:
s[write_idx] = s[cur_idx]
write_idx -= 1
cur_idx -= 1
return final_size
@enable_executor_hook
def replace_and_remove_wrapper(executor, size, s):
res_size = executor.run(functools.partial(replace_and_remove, size, s))
return s[:res_size]
if __name__ == '__main__':
exit(
generic_test.generic_test_main('replace_and_remove.py',
'replace_and_remove.tsv',
replace_and_remove_wrapper))
begin, end = begin + 1, end - 1
reverse(0, len(A) - 1)
reverse(0, rotate_amount - 1)
reverse(rotate_amount, len(A) - 1)
# Although the following function is very natural way to rotate an array,
# its use of sublists leads to copy from original list, and therefore
# linear space complexity.
def rotate_array_naive(rotate_amount, A):
rotate_amount %= len(A)
A[:] = A[::-1] # reverse whole list
A[:rotate_amount] = A[:rotate_amount][::
-1] # reverse A[:rotate_amount] part
A[rotate_amount:] = A[rotate_amount:][::
-1] # reverse A[rotate_amount:] part
@enable_executor_hook
def rotate_array_wrapper(executor, A, rotate_amount):
a_copy = A[:]
executor.run(functools.partial(rotate_array, rotate_amount, a_copy))
return a_copy
if __name__ == '__main__':
exit(
generic_test.generic_test_main("rotate_array.py", 'rotate_array.tsv',
rotate_array_wrapper))
from test_framework import generic_test
def roman_to_integer(s: str) -> int:
values = {
'I': 1,
'V': 5,
'X': 10,
'L': 50,
'C': 100,
'D': 500,
'M': 1000,
}
result = values[s[-1]]
for i, c in enumerate(s[:-1]):
result += -values[c] if values[c] < values[s[i + 1]] else values[c]
return result
if __name__ == '__main__':
exit(
generic_test.generic_test_main('roman_to_integer.py',
'roman_to_integer.tsv',
roman_to_integer))
from reverse_linked_list_iterative import reverse_linked_list
from test_framework import generic_test
def is_linked_list_a_palindrome(L):
# Finds the second half of L.
slow = fast = L
while fast and fast.next:
fast, slow = fast.next.next, slow.next
# Compares the first half and the reversed second half lists.
first_half_iter, second_half_iter = L, reverse_linked_list(slow)
while second_half_iter and first_half_iter:
if second_half_iter.data != first_half_iter.data:
return False
second_half_iter, first_half_iter = (second_half_iter.next,
first_half_iter.next)
return True
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_list_palindromic.py",
'is_list_palindromic.tsv',
is_linked_list_a_palindrome))
# Avg runtime 284 us; Median runtime 40 us
def author_solution(preorder_sequence):
def rebuild_bst_from_preorder_on_value_range(lower_bound, upper_bound):
if root_idx[0] == len(preorder_sequence):
return None
root = preorder_sequence[root_idx[0]]
if not lower_bound <= root <= upper_bound:
return None
root_idx[0] += 1
# Note that rebuild_bst_from_preorder_on_value_range updates root_idx[0]
# So the order of following two calls are critical
left_subtree = rebuild_bst_from_preorder_on_value_range(
lower_bound, root)
right_subtree = rebuild_bst_from_preorder_on_value_range(
root, upper_bound)
return BstNode(root, left_subtree, right_subtree)
root_idx = [0] # Tracks current subtree
return rebuild_bst_from_preorder_on_value_range(float('-inf'),
float('inf'))
if __name__ == '__main__':
exit(
generic_test.generic_test_main("bst_from_preorder.py",
'bst_from_preorder.tsv',
rebuild_bst_from_preorder))
from test_framework import generic_test
def get_height(cases, drops):
def get_height_helper(cases, drops):
if cases == 0 or drops == 0:
return 0
elif cases == 1:
return drops
if F[cases][drops] == -1:
F[cases][drops] = (get_height_helper(cases, drops - 1) +
get_height_helper(cases - 1, drops - 1) + 1)
return F[cases][drops]
F = [[-1] * (drops + 1) for i in range(cases + 1)]
return get_height_helper(cases, drops)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("max_safe_height.py",
'max_safe_height.tsv', get_height))
if result[index]!= 0:
break
del result[index]
result[0] = result[0] * sign
return result
"""
def multiply2(num1, num2):
# TODO - you fill in here.
results = [[] * ]
max_len = 0
for i in range(len(num2)):
result = [0] * i
[0] * i
for j in reversed(range(len(num1))):
result = [num2[i] * num1[j]] + result
max_len = max(len(result), max_len)
results.append(result)
for i in reversed(range(max_len)):
for result in results:
if i < len(result)
return []
"""
if __name__ == '__main__':
exit(
generic_test.generic_test_main("int_as_array_multiply.py",
'int_as_array_multiply.tsv', multiply))
new_pivot_idx = left
A[pivot_idx], A[right] = A[right], A[pivot_idx]
for i in range(left, right):
if comp(A[i], pivot_value):
A[i], A[new_pivot_idx] = A[new_pivot_idx], A[i]
new_pivot_idx += 1
A[right], A[new_pivot_idx] = A[new_pivot_idx], A[right]
return new_pivot_idx
left, right = 0, len(A) - 1
while left <= right:
# Generates a random integer in [left, right].
pivot_idx = random.randint(left, right)
new_pivot_idx = partition_around_pivot(left, right, pivot_idx)
if new_pivot_idx == k - 1:
return A[new_pivot_idx]
elif new_pivot_idx > k - 1:
right = new_pivot_idx - 1
else: # new_pivot_idx < k - 1.
left = new_pivot_idx + 1
raise IndexError('no k-th node in array A')
return find_kth(operator.lt)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("kth_largest_in_array.py",
'kth_largest_in_array.tsv',
find_kth_largest))
from typing import List
from test_framework import generic_test
def get_max_trapped_water(heights: List[int]) -> int:
left, right = 0, len(heights) - 1
max_water = 0
while left < right:
water = (right - left) * min(heights[left], heights[right])
max_water = max(max_water, water)
if heights[left] < heights[right]:
left += 1
else:
right -= 1
return max_water
if __name__ == '__main__':
exit(
generic_test.generic_test_main('max_trapped_water.py',
'max_trapped_water.tsv',
get_max_trapped_water))
# one in it. We will discard those k items by one for each.
if len(table) == k:
for it in table:
table[it] -= 1
table = +table # remove all zero values
# Resets table for the following counting.
for it in table:
table[it] = 0
# Resets the stream and read it again.
stream = stream_copy
# Counts the occurrence of each candidate word.
for buf in stream:
if buf in table:
table[buf] += 1
# Selects the word which occurs > n / k times.
return [it for it, value in table.items() if value > n / k]
def search_frequent_items_wrapper(k, stream):
return search_frequent_items(k, iter(stream))
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"search_frequent_items.py", "search_frequent_items.tsv",
search_frequent_items_wrapper, test_utils.unordered_compare))
from test_framework import generic_test
def is_binary_tree_bst(tree, low_range=float('-inf'), high_range=float('inf')):
# TODO - you fill in here.
return True
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_tree_a_bst.py", 'is_tree_a_bst.tsv',
is_binary_tree_bst))
def decompose_into_dictionary_words(domain, dictionary):
# TODO - you fill in here.
return []
@enable_executor_hook
def decompose_into_dictionary_words_wrapper(executor, domain, dictionary,
decomposable):
result = executor.run(
functools.partial(decompose_into_dictionary_words, domain, dictionary))
if not decomposable:
if result:
raise TestFailure('domain is not decomposable')
return
if any(s not in dictionary for s in result):
raise TestFailure('Result uses words not in dictionary')
if ''.join(result) != domain:
raise TestFailure('Result is not composed into domain')
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"is_string_decomposable_into_words.py",
'is_string_decomposable_into_words.tsv',
decompose_into_dictionary_words_wrapper))
from typing import List
from binary_tree_node import BinaryTreeNode
from test_framework import generic_test
def postorder_traversal(tree: BinaryTreeNode) -> List[int]:
# TODO - you fill in here.
return []
if __name__ == '__main__':
exit(
generic_test.generic_test_main('tree_postorder.py',
'tree_postorder.tsv',
postorder_traversal))
from test_framework import generic_test
def sort_k_increasing_decreasing_array(A):
# TODO - you fill in here.
return []
if __name__ == '__main__':
exit(
generic_test.generic_test_main("sort_increasing_decreasing_array.py",
'sort_increasing_decreasing_array.tsv',
sort_k_increasing_decreasing_array))
from test_framework import generic_test
def add_two_numbers(L1, L2):
# TODO - you fill in here.
return None
if __name__ == '__main__':
exit(
generic_test.generic_test_main("int_as_list_add.py",
'int_as_list_add.tsv', add_two_numbers))
from test_framework import generic_test
from two_sum import has_two_sum
def has_three_sum(A, t):
A.sort()
# Finds if the sum of two numbers in A equals to t - a.
return any(has_two_sum(A, t - a) for a in A)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("three_sum.py", "three_sum.tsv",
has_three_sum))
from test_framework import generic_test
def change_making(cents: int) -> int:
coins = [100, 50, 25, 10, 5, 1]
count = 0
for coin in coins:
count += cents // coin
cents %= coin
return count
if __name__ == '__main__':
exit(
generic_test.generic_test_main('making_change.py', 'making_change.tsv',
change_making))
result.append(valid_prefix)
return result
return directed_generate_balanced_parentheses(num_pairs, num_pairs, '')
def generate_balanced_parentheses_pythonic(num_pairs, num_left_open=0):
if not num_pairs:
return [')' * num_left_open]
if not num_left_open:
return [
'(' + p for p in generate_balanced_parentheses_pythonic(
num_pairs - 1, num_left_open + 1)
]
else:
return ([
'(' + p for p in generate_balanced_parentheses_pythonic(
num_pairs - 1, num_left_open + 1)
] + [
')' + p for p in generate_balanced_parentheses_pythonic(
num_pairs - 1, num_left_open - 1)
])
if __name__ == '__main__':
exit(
generic_test.generic_test_main("enumerate_balanced_parentheses.py",
'enumerate_balanced_parentheses.tsv',
generate_balanced_parentheses,
test_utils.unordered_compare))
from test_framework import generic_test
def reverse_bits(x: int) -> int:
y = 0
pos = 63
while x:
next_bit = x & 1
y += next_bit << pos
x >>= 1
pos -= 1
return y
if __name__ == '__main__':
exit(
generic_test.generic_test_main('reverse_bits.py', 'reverse_bits.tsv',
reverse_bits))
char_frequency_for_letter = collections.Counter(letter_text)
# Checks if characters in magazine_text can cover characters in
# char_frequency_for_letter.
for c in magazine_text:
if c in char_frequency_for_letter:
char_frequency_for_letter[c] -= 1
if char_frequency_for_letter[c] == 0:
del char_frequency_for_letter[c]
if not char_frequency_for_letter:
# All characters for letter_text are matched.
return True
# Empty char_frequency_for_letter means every char in letter_text can be
# covered by a character in magazine_text.
return not char_frequency_for_letter
# Pythonic solution that exploits collections.Counter. Note that the
# subtraction only keeps keys with positive counts.
def is_letter_constructible_from_magazine_pythonic(letter_text, magazine_text):
return (not collections.Counter(letter_text) -
collections.Counter(magazine_text))
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_anonymous_letter_constructible.py",
'is_anonymous_letter_constructible.tsv',
is_letter_constructible_from_magazine))
from typing import List
from test_framework import generic_test
def calculate_bonus(productivity: List[int]) -> int:
# TODO - you fill in here.
return 0
if __name__ == '__main__':
exit(
generic_test.generic_test_main('bonus.py', 'bonus.tsv',
calculate_bonus))
Player = collections.namedtuple('Player', ('height'))
def __init__(self, height):
self._players = [Team.Player(h) for h in height]
# Checks if team0 can be placed in front of team1.
@staticmethod
def valid_placement_exists(team0, team1):
# TODO - you fill in here.
return True
@enable_executor_hook
def valid_placement_exists_wrapper(executor, team0, team1, expected_01,
expected_10):
t0, t1 = Team(team0), Team(team1)
result_01 = executor.run(
functools.partial(Team.valid_placement_exists, t0, t1))
result_10 = executor.run(
functools.partial(Team.valid_placement_exists, t1, t0))
if result_01 != expected_01 or result_10 != expected_10:
raise TestFailure("")
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_array_dominated.py",
'is_array_dominated.tsv',
valid_placement_exists_wrapper))
from typing import List
from test_framework import generic_test, test_utils
MAPPING = ('0', '1', 'ABC', 'DEF', 'GHI', 'JKL', 'MNO', 'PQRS', 'TUV', 'WXYZ')
def phone_mnemonic(phone_number: str) -> List[str]:
nums = []
def attach(cur, rem):
if rem == '':
nums.append(cur)
return
for c in MAPPING[int(rem[0])]:
attach(cur + c, rem[1:])
attach('', phone_number)
return nums
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
'phone_number_mnemonic.py',
'phone_number_mnemonic.tsv',
phone_mnemonic,
comparator=test_utils.unordered_compare))
from test_framework import generic_test
def find_maximum_subarray(A):
# TODO - you fill in here.
return -1
if __name__ == '__main__':
exit(
generic_test.generic_test_main("max_sum_subarray.py",
'max_sum_subarray.tsv',
find_maximum_subarray))
from test_framework import generic_test
class solution():
def __init__(self):
self.result = None
def helper(self, s):
print(s)
def is_well_formed(s):
# TODO - you fill in here.
r = solution()
r.helper(s)
return True
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_valid_parenthesization.py",
'is_valid_parenthesization.tsv',
is_well_formed))
from list_node import ListNode
from test_framework import generic_test
def even_odd_merge(L):
if not L:
return L
even_dummy_head, odd_dummy_head = ListNode(0), ListNode(0)
tails, turn = [even_dummy_head, odd_dummy_head], 0
while L:
tails[turn].next = L
L = L.next
tails[turn] = tails[turn].next
turn ^= 1 # Alternate between even and odd.
tails[1].next = None
tails[0].next = odd_dummy_head.next
return even_dummy_head.next
if __name__ == '__main__':
exit(
generic_test.generic_test_main("even_odd_list_merge.py",
'even_odd_list_merge.tsv',
even_odd_merge))
def get_valid_ip_address(s):
def is_valid_part(s):
# '00', '000', '01', etc. are not valid, but '0' is valid.
return len(s) == 1 or (s[0] != '0' and int(s) <= 255)
result, parts = [], [None] * 4
for i in range(1, min(4, len(s))):
parts[0] = s[:i]
if is_valid_part(parts[0]):
for j in range(1, min(len(s) - i, 4)):
parts[1] = s[i:i + j]
if is_valid_part(parts[1]):
for k in range(1, min(len(s) - i - j, 4)):
parts[2], parts[3] = s[i + j:i + j + k], s[i + j + k:]
if is_valid_part(parts[2]) and is_valid_part(parts[3]):
result.append('.'.join(parts))
return result
def comp(a, b):
return sorted(a) == sorted(b)
if __name__ == '__main__':
exit(
generic_test.generic_test_main(
"valid_ip_addresses.py",
'valid_ip_addresses.tsv',
get_valid_ip_address,
comparator=comp))
from test_framework import generic_test
def calculate_largest_rectangle(heights):
pillar_indices, max_rectangle_area = [], 0
# By appending [0] to heights, we can uniformly handle the computation for
# rectangle area here.
for i, h in enumerate(heights + [0]):
while pillar_indices and heights[pillar_indices[-1]] >= h:
height = heights[pillar_indices.pop()]
width = i if not pillar_indices else i - pillar_indices[-1] - 1
max_rectangle_area = max(max_rectangle_area, height * width)
pillar_indices.append(i)
return max_rectangle_area
if __name__ == '__main__':
exit(
generic_test.generic_test_main("largest_rectangle_under_skyline.py",
'largest_rectangle_under_skyline.tsv',
calculate_largest_rectangle))
result = executor.run(functools.partial(has_cycle, head))
if cycle_idx == -1:
if result is not None:
raise TestFailure("Found a non-existing cycle")
else:
if result is None:
raise TestFailure("Existing cycle was not found")
cursor = result
while True:
cursor = cursor.next
cycle_length -= 1
if cursor is None or cycle_length < 0:
raise TestFailure(
"Returned node does not belong to the cycle or is not the closest node to the head"
)
if cursor is result:
break
if cycle_length != 0:
raise TestFailure(
"Returned node does not belong to the cycle or is not the closest node to the head"
)
if __name__ == '__main__':
exit(
generic_test.generic_test_main("is_list_cyclic.py",
'is_list_cyclic.tsv',
has_cycle_wrapper))
