def count_locations(N, SX, SY, Xprefix, Yprefix): S = create_points(N, SX, SY, Xprefix, Yprefix) # print("len: {} ==> {}".format(S.size(), S)) if S.size() < 3: return 0 possible_points = Points() for p1 in range(len(S.points_list) - 1): # print(p1) for p2 in range(p1 + 1, len(S.points_list)): find_square(S, possible_points, S.points_list[p1], S.points_list[p2]) return possible_points.size() def run_line(match): N = int(match.group(1)) SX = int(match.group(2)) SY = int(match.group(3)) Xprefix = get_ints(match.group(4)) Yprefix = get_ints(match.group(5)) expected = int(match.group(6)) actual = count_locations(N, SX, SY, Xprefix, Yprefix) assert_equals(actual, expected) test_solution(__file__, '(\\d+), (\\d+), (\\d+), {(.*)}, {(.*)}\\s+(\\d+)', run_line)
def find_all(): palindromes = [] for digits in range(1, 15): palindromes.extend(find_by_digits(digits)) return palindromes def get_min(x): global all if len(all) == 0: all = find_all() for p in all: if p % x == 0: y = p / x if y > 1e9: return -1 return p / x return -1 def run_line(match): x = int(match.group(1)) expected = int(match.group(2)) actual = get_min(x) assert_equals(actual, expected) test_solution(__file__, '(\\S+)\\s+(\\S+)', run_line)
def get_primes(sums_input): global sums sums = sums_input find_primes_numbers() find_primes_digits() index_primes() possible_first = [i for i in range(len(primes_digits))] possible_second = [i for i in range(len(primes_digits))] possible_third = [i for i in range(len(primes_digits))] result = recursive_find(0, possible_first, possible_second, possible_third) print(result) if result is None: return [] result = [primes_numbers[result[0][0]], primes_numbers[result[1][0]], primes_numbers[result[2][0]]] print(result) return result def run_line(match): sums = get_ints(match.group(1)) expected = get_ints(match.group(2)) actual = get_primes(sums) assert_equals(len(actual), len(expected)) test_solution(__file__, '{(.*)}\\s+{(.*)}', run_line)
cost = remove_one(lists, x, y, z) if cost is None: break # print(cost) total_cost += cost result = { 'min_sum': sum(lists[0]) + sum(lists[1]) + sum(lists[2]), 'cost': total_cost } # print(result) return result def run_line(match): a = int(match.group(1)) b = int(match.group(2)) c = int(match.group(3)) x = int(match.group(4)) y = int(match.group(5)) z = int(match.group(6)) min_sum = int(match.group(7)) cost = int(match.group(8)) actual = do_delete(a, b, c, x, y, z) assert_equals(actual['min_sum'], min_sum) assert_equals(actual['cost'], cost) test_solution(__file__, '(\\d+), (\\d+), (\\d+), (\\d+), (\\d+), (\\d+)\\s+{(\\d+), (\\d+)}', run_line)
updated = lamp.integrate(self.solvers[j]) if updated: any_updated = True print("update lamp {} related {}".format( lamp.lamp, lamp.related)) if lamp.is_finite(): self.guess_alternatives -= 1 return any_updated def learn_from_experiments(self): for lamp in range(self.n): lamp_solver = LampSolver(self, lamp) lamp_solver.check_lamp() self.solvers.append(lamp_solver) def the_min(switches, lamps): s = Solver(switches, lamps) return s.solve() def run_line(match): switches = get_strings(match.group(1)) lamps = get_strings(match.group(2)) expected = int(match.group(3)) actual = the_min(switches, lamps) assert_equals(actual, expected) test_solution(__file__, '{(.*)}, {(.*)}\\s+(\\S+)', run_line)
print(self) def __repr__(self): return "{},{},{} = {:,}".format( self.product1, self.product2, "Parallel" if self.parallel else "Serial", self.value) def construct(nanoOhms): print("{:,}".format(nanoOhms)) products.append(Product(-1, -1, False)) products.append(Product(-1, -1, False)) while (products[-1].value != nanoOhms): if len(products) > 1000: raise Exception("Failed!") if products[-1].value < nanoOhms: last = len(products) - 1 products.append(Product(last, last - 1, False)) else: last = len(products) - 1 products.append(Product(last, last - 1, True)) def run_line(match): nanoOhms = int(match.group(1)) construct(nanoOhms) test_solution(__file__, '(\\d+)', run_line)
def find_number_of_swaps(p, a0, x, y, n, k): s = generate(p, a0, n, x, y) score = 0 for i in range(k): part = "" while i < len(s): part += s[i] i += k score += replace_count(part) return score def run_line(match): p = match.group(1) a0 = int(match.group(2)) x = int(match.group(3)) y = int(match.group(4)) n = int(match.group(5)) k = int(match.group(6)) expected = int(match.group(7)) actual = find_number_of_swaps(p, a0, x, y, n, k) assert_equals(actual, expected) test_solution(__file__, '"(.*)", (\\d+), (\\d+), (\\d+), (\\d+), (\\d+)\\s+(\\d+)', run_line)
from python.test_utils import test_solution, assert_equals, get_ints def possible(candy, bag_size, bags): add = list(map(lambda x: x // bags, candy)) return sum(add) >= bag_size def make_bags(candy, bag_size): low = 0 high = pow(10, 19) while low + 1 < high: mid = (low + high) // 2 if possible(candy, bag_size, mid): low = mid else: high = mid return low def run_line(match): candy = get_ints(match.group(1)) bag_size = int(match.group(2)) expected = int(match.group(3)) actual = make_bags(candy, bag_size) assert_equals(actual, expected) test_solution(__file__, '{(.*)}, (\\d+)\\s+(\\d+)', run_line)
c['z'] = reduce_multiple(c['z']) print("after reduce multiple z: " + periodic_string(c)) truncate_zeros(c) print("after zeros truncate: " + periodic_string(c)) pattern_reduce(c) print("after pattern reduce: " + periodic_string(c)) return periodic_string(c) def periodic_string(c): y = c['y'] if y == 0: y = '' return '{}.{}({})'.format(c['x'], y, c['z']) def run_line(match): a = match.group(1) b = match.group(2) expected = match.group(3) actual = add(a, b) assert_equals(actual, expected) test_solution(__file__, '"(.*)", "(.*)"\\s+"(.*)"', run_line)
a = match.group(1) b = match.group(2) c = match.group(3) valid = [] for i in range(10): a_num = replace_digit(a, i) b_num = replace_digit(b, i) c_num = replace_digit(c, i) if a_num is None or b_num is None or c_num is None: continue if a_num * b_num == c_num: valid.append(i) if len(valid) != 1: return -1 return valid[0] def run_line(match): equation = match.group(1) expected = int(match.group(2)) actual = find_digit(equation) assert_equals(actual, expected) test_solution(__file__, '"(.*)"\\s+(-?\\d+)', run_line)
else: indexes[distance] = [position] def find_value(default_value, query): if query == 0: return 0 indexes = {} last = 0 position = 0 while query not in indexes: position += 1 distance = find_distance(last, indexes, default_value) last = distance add_location(distance, indexes, position) if position > 10000000: return -1 return indexes[query][0] def run_line(match): default_value = int(match.group(1)) query = int(match.group(2)) expected = int(match.group(3)) actual = find_value(default_value, query) assert_equals(actual, expected) test_solution(__file__, '(\\d+), (\\d+)\\s+(-?\\d+)', run_line)
return s, e def maximize(n, e): p = generate_prime_alphabet() final_len = n - e if n > 17000: s = ['z'] * final_len else: s = p[0:n] start = 0 while e > 0: s, e = lexical_delete(start, s, e) start += 1 return ''.join(s) def run_line(match): n = int(match.group(1)) e = int(match.group(2)) expected = match.group(3) actual = maximize(n, e) assert_equals(actual, expected) test_solution(__file__, '(\\d+), (\\d+)\\s+\"(.*)\"', run_line)
if blocks[try_height] > 0: blocks[try_height] -= 1 if recurse_possible(0, land_width - 1, blocks, 0, current_height + 1): return True blocks[try_height] += 1 else: return True def is_it_even_possible(water_width, land_width, block_height, depth): blocks = [0] * 202 for h in block_height: blocks[h] += 1 if recurse_possible(water_width, land_width, blocks, depth, 0): return "POSSIBLE" return "IMPOSSIBLE" def run_line(match): water_width = int(match.group(1)) land_width = int(match.group(2)) block_height = get_ints(match.group(3)) depth = int(match.group(4)) expected = match.group(5) actual = is_it_even_possible(water_width, land_width, block_height, depth) assert_equals(actual, expected) test_solution(__file__, '(\\d+), (\\d+), {(.*)}, (\\d+)\\s+"(.*)"', run_line)