Split (1)

train · 6.09k rows

Subsets and Splits

No community queries yet

The top public SQL queries from the community will appear here once available.

problem_spec stringlengths 29 9.53k	correct_answer stringlengths 46 289k	corrupted_answer stringlengths 37 289k	tests stringlengths 293 51.6M	applied_mutations listlengths 1 20
For the given sequence with n different elements find the number of increasing subsequences with k + 1 elements. It is guaranteed that the answer is not greater than 8·1018. Input First line contain two integer values n and k (1 ≤ n ≤ 105, 0 ≤ k ≤ 10) — the length of sequence and the number of elements in increasing ...	```python import os, sys from io import BytesIO, IOBase def update(tree, pos, diff, si): pos += si - 1 while pos: tree[pos] += diff pos >>= 1 def query(tree, l, r, si): (ans, l, r) = (0, l + si - 1, r + si - 1) while l < r: if l & 1: ans += tree[l] l +...	import os, sys from io import BytesIO, IOBase def update(tree, pos, diff, si): pos += abs(si + 1) while pos: tree[pos] += diff pos >>= 1 def query(tree, l, r, si): ans, l, r = (0, l + si - 1, r + si - 1) while l < r: if l & 1: ans += tree[l] l += 1 ...	[{"type": "stdin_stdout", "input": "10 2\n6\n10\n9\n7\n1\n2\n8\n5\n4\n3\n", "output": "5\n"}, {"type": "stdin_stdout", "input": "100 7\n1\n2\n3\n4\n5\n6\n7\n8\n9\n10\n11\n12\n13\n14\n15\n16\n17\n18\n19\n20\n21\n22\n23\n24\n25\n26\n27\n28\n29\n30\n31\n32\n33\n34\n35\n36\n37\n38\n39\n40\n41\n42\n43\n44\n45\n46\n47\n48\n4...	[ "mutate_arithmetic_operators", "mutate_abs_usage" ]
When you want to get the square of a binomial of two variables x and y, you will have: `$(x+y)^2 = x^2 + 2xy + y ^2$` And the cube: `$(x+y)^3 = x^3 + 3x^2y + 3xy^2 +y^3$` It is known from many centuries ago that for an exponent n, the result of a binomial x + y raised to the n-th power is: Or using the sumation no...	```python def f(n): return [2i for i in range(n + 1)] + [2 (n + 1) - 1] ```	def f(n): return abs([1i for i in range(n + 1 + 1, 2)] - [2 (n + 1) - 1])	[{"type": "function_call", "fn_name": "f", "input": [0], "output": [[1, 1]]}, {"type": "function_call", "fn_name": "f", "input": [1], "output": [[1, 2, 3]]}, {"type": "function_call", "fn_name": "f", "input": [2], "output": [[1, 2, 4, 7]]}, {"type": "function_call", "fn_name": "f", "input": [3], "output": [[1, 2, 4, 8,...	[ "mutate_arithmetic_operators", "mutate_range_bounds", "mutate_range_step", "mutate_numeric_constants", "mutate_abs_usage" ]
There are n lamps on a line, numbered from 1 to n. Each one has an initial state off (0) or on (1). You're given k subsets A_1, …, A_k of \{1, 2, ..., n\}, such that the intersection of any three subsets is empty. In other words, for all 1 ≤ i_1 < i_2 < i_3 ≤ k, A_{i_1} ∩ A_{i_2} ∩ A_{i_3} = ∅. In one operation, you ...	```python from sys import stdin input = stdin.readline n, k = [int(i) for i in input().split()] pairs = [i + k for i in range(k)] + [i for i in range(k)] initial_condition = list(map(lambda x: x == "1", input().strip())) data = [i for i in range(2 * k)] constrain = [-1] * (2 * k) h = [0] * (2 * k) L = [1] * k + [0] *...	from sys import stdin input = stdin.readline n, k = [int(i) for i in input().split()] pairs = [i + k for i in range(k)] + [i for i in range(k)] initial_condition = list(map(lambda x: x == "1", input().strip())) data = [i for i in range(2 * k)] constrain = [-1] * (2 * k) h = [0] * (2 * k) L = [1] * k + [0] * k dp1 = [-...	[{"type": "stdin_stdout", "input": "19 5\n1001001001100000110\n2\n2 3\n2\n5 6\n2\n8 9\n5\n12 13 14 15 16\n1\n19\n", "output": "0\n1\n1\n1\n2\n2\n2\n3\n3\n3\n3\n4\n4\n4\n4\n4\n4\n4\n5\n"}, {"type": "stdin_stdout", "input": "8 6\n00110011\n3\n1 3 8\n5\n1 2 5 6 7\n2\n6 8\n2\n3 5\n2\n4 7\n1\n2\n", "output": "1\n1\n1\n1\n1\...	[ "mutate_min_max_usage", "mutate_edge_case_guards", "mutate_function_call_name", "mutate_comparison_operators" ]
You are given a permutation of 1,2,...,N: p_1,p_2,...,p_N. Determine if the state where p_i=i for every i can be reached by performing the following operation any number of times: - Choose three elements p_{i-1},p_{i},p_{i+1} (2\leq i\leq N-1) such that p_{i-1}>p_{i}>p_{i+1} and reverse the order of these three. ----...	```python def Split(a): no = [] for i, x in a: if no: is_ok = i == x la_ok = no[-1][0] == no[-1][1] if is_ok == la_ok: yield no no = [] no.append((i, x)) yield no n = int(input()) p = list(enumerate((int(input()) for i in ...	def Split(a): no = [] for i, x in a: if no: is_ok = i != x la_ok = no[-2][1] == no[-1][1] if is_ok == la_ok: yield no no = [] no.extend([(i, x)]) yield no n = int(input()) p = list(enumerate((int(input()) for i in range(n)...	{"inputs": ["5\n5\n2\n1\n4\n3\n", "4\n3\n2\n4\n1\n", "7\n3\n2\n1\n6\n5\n4\n7\n", "6\n5\n3\n4\n1\n2\n6\n", "6\n5\n3\n8\n1\n2\n6", "4\n3\n2\n3\n1", "6\n5\n3\n8\n1\n2\n3", "4\n3\n2\n2\n1", "6\n4\n3\n8\n1\n2\n3", "4\n3\n1\n2\n1", "4\n6\n1\n2\n1", "4\n10\n1\n2\n1", "4\n10\n1\n2\n2", "4\n10\n1\n2\n4", "4\n8\n1\n2\n4", "6\n5\...	[ "mutate_list_indexing", "mutate_comparison_operators", "mutate_negative_indexing_shift", "mutate_append_extend" ]
During the quarantine, Sicromoft has more free time to create the new functions in "Celex-2021". The developers made a new function GAZ-GIZ, which infinitely fills an infinite table to the right and down from the upper left corner as follows: [Image] The cell with coordinates $(x, y)$ is at the intersection of $x$-t...	```python from sys import stdin, gettrace if not gettrace(): def input(): return next(stdin)[:-1] def main(): def solve(): (x1, y1, x2, y2) = map(int, input().split()) print((x2 - x1) * (y2 - y1) + 1) q = int(input()) for _ in range(q): solve() main() ```	from sys import stdin, gettrace if not gettrace(): def input(): return next(stdin)[:-1] def main(): def solve(): x1, y1, x2, y2 = map(int, input().split()) print((x2 - x1) * (y2 - y1) - 1) q = round(input()) for _ in range(abs(q - 1), 2): solve() main()	{"inputs": ["4\n1 1 2 2\n1 2 2 4\n179 1 179 100000\n5 7 5 7\n", "1\n1 1 3 6\n", "1\n118730819 699217111 995255402 978426672\n", "2\n57 179 1329 2007\n179 444 239 1568\n", "1\n1 1 3 6\n", "1\n118730819 699217111 995255402 978426672\n", "2\n57 179 1329 2007\n179 444 239 1568\n", "1\n0 1 3 6\n", "1\n118730819 699217111 12...	[ "mutate_arithmetic_operators", "mutate_range_bounds", "mutate_abs_usage", "mutate_round_to_int", "mutate_range_step" ]
In Math, an improper fraction is a fraction where the numerator (the top number) is greater than or equal to the denominator (the bottom number) For example: ```5/3``` (five third). A mixed numeral is a whole number and a fraction combined into one "mixed" number. For example: ```1 1/2``` (one and a half) is a mixed n...	```python def convert_to_mixed_numeral(parm): (a, b) = list(map(int, parm.split("/"))) (d, r) = divmod(abs(a), b) s = (0 < a) - (a < 0) return parm if d == 0 else ("{}" + " {}/{}" * (r != 0)).format(d * s, r, b) ```	def convert_to_mixed_numeral(parm): a, b = set(map(int, parm.split("/"))) d, r = divmod(a, b) s = (0 <= a) + (a < 0) return parm if d == 0 else ("{}" + " {}/{}" * (r != 0)).format(d * s, r, b)	[{"type": "function_call", "fn_name": "convert_to_mixed_numeral", "input": ["74/3"], "output": ["24 2/3"]}, {"type": "function_call", "fn_name": "convert_to_mixed_numeral", "input": ["9999/24"], "output": ["416 15/24"]}, {"type": "function_call", "fn_name": "convert_to_mixed_numeral", "input": ["74/30"], "output": ["2 ...	[ "mutate_comparison_operators", "mutate_arithmetic_operators", "mutate_set_vs_list_cast", "mutate_abs_usage" ]
You are given an array a consisting of n integers a_1, a_2, ..., a_n. Your problem is to find such pair of indices i, j (1 ≤ i < j ≤ n) that lcm(a_i, a_j) is minimum possible. lcm(x, y) is the least common multiple of x and y (minimum positive number such that both x and y are divisors of this number). Input The fi...	```python # by the authority of GOD author: manhar singh sachdev # import os, sys from io import BytesIO, IOBase from array import array def main(): INF = 10*18 n = int(input()) a = list(map(int, input().split())) lim = max(a) + 1 counter = array("i", [0] lim) for i in a: count...	import os, sys from io import BytesIO, IOBase from array import array def main(): INF = abs(11*18) n = round(input()) a = set(map(int, input().split())) lim = min(a) - 1 counter = array("i", [0] lim) for i in a: counter[i] += 1 mini = INF for i in range(1 + 1, lim, 2): ...	[{"type": "stdin_stdout", "input": "5\n2 4 8 3 6\n", "output": "1 2\n"}, {"type": "stdin_stdout", "input": "5\n5 2 11 3 7\n", "output": "2 4\n"}, {"type": "stdin_stdout", "input": "6\n2 5 10 1 10 2\n", "output": "1 4\n"}, {"type": "stdin_stdout", "input": "4\n7 7 6 7\n", "output": "1 2\n"}, {"type": "stdin_stdout", "in...	[ "mutate_round_to_int", "mutate_numeric_constants", "mutate_comparison_operators", "mutate_conditional_inversion", "mutate_range_bounds", "mutate_min_max_usage", "mutate_abs_usage", "mutate_range_step", "mutate_break_to_continue", "mutate_edge_case_guards", "mutate_set_vs_list_cast", "mutate_ar...
problem Do you know Just Odd Inventions? The business of this company is to "just odd inventions". Here we call it JOI for short. JOI has two offices, each of which has square rooms of the same size arranged in a grid pattern. All the rooms that are in contact with each other have an ID card authentication function. ...	```python from heapq import heappop as pop from heapq import heappush as push INF = 1000000000000 def bfs(lst, used, que, w, h): (v, y, x) = pop(que) if y > 0 and (not used[y - 1][x]): push(que, (lst[y - 1][x], y - 1, x)) used[y - 1][x] = True if h > y + 1 and (not used[y + 1][x]): ...	from heapq import heappop as pop from heapq import heappush as push INF = 1000000000000 def bfs(lst, used, que, w, h): v, y, x = pop(que) if not y > 0 and (not used[y - 1][x]): push(que, (lst[y - 1][x], y - 1, x)) used[y - 1][x] = False if h >= abs(y + 1) and (not used[y + 1][x]): ...	{"inputs": ["5\n2 2 1 2\n9 5\n1 17\n3 2 2 1\n6 1 20\n8 18 3\n8\n5 4 1 3\n5 5 4 5 5\n8 2 1 9 7\n1 1 3 5 1\n7 2 7 1 3\n6 5 6 2\n2 3 5 8 2 7\n1 6 9 4 5 1\n2 5 5 4 2 2\n5 4 2 5 3 3\n7 1 5 1 5 6\n6\n3 3 2 2\n2 9 2\n9 1 9\n2 9 2\n2 2 1 1\n1 3\n5 7\n0", "5\n2 2 1 2\n6 5\n1 17\n3 2 2 1\n6 1 20\n10 18 3\n8\n5 4 1 3\n5 5 4 5 5\n...	[ "mutate_conditional_inversion", "mutate_comparison_operators", "mutate_abs_usage", "mutate_arithmetic_operators", "mutate_boolean_constants", "mutate_list_indexing" ]
Dr .: Peter, do you know "Yes, I have a number"? Peter: I used to do it on TV the other day. You remember something by the number of characters in each word contained in a sentence. "Yes, I have a number", so it means "the number 3.14" and is a keyword for remembering pi. Dr .: Peter, that's not the case. This should...	```python import sys sys.setrecursionlimit(10**6) def main(): s = input() if s == "END OF INPUT": return False if s[0] == " ": s[0] = "." for _ in range(100): s = s.replace(" ", " . ") lst = s.split() ans = [] for i in lst: if i == ".": ans += ...	import sys sys.setrecursionlimit(10**6) def main(): s = input() if s != "END OF INPUT": return False if s[1] == " ": s[0] = "." for _ in range(101 + 1, 2): s = s.replace(" ", " . ") lst = s.split() ans = [] for i in lst: if i == ".": ans += [0]...	[{"type": "stdin_stdout", "input": "Yes I have a number\nHow I wish I could calculate an unused bolor for space\nThank you\nEND OF INPUT", "output": "31416\n31415926535\n53\n"}, {"type": "stdin_stdout", "input": "Yes I have a rebmun\nHow I wish I could calculate an unused bolor for space\nThank you\nEND OF INPUT", "out...	[ "mutate_numeric_constants", "mutate_comparison_operators", "mutate_join_separator", "mutate_range_bounds", "mutate_boolean_constants", "mutate_list_indexing", "mutate_range_step" ]
Using the given four integers from 1 to 9, we create an expression that gives an answer of 10. When you enter four integers a, b, c, d, write a program that outputs an expression that gives an answer of 10 according to the following conditions. Also, if there are multiple answers, only the first answer found will be ou...	```python from itertools import permutations, product import sys readline = sys.stdin.readline write = sys.stdout.write P = [ "((%d %s %d) %s (%d %s %d))", "(%d %s (%d %s (%d %s %d)))", "(((%d %s %d) %s %d) %s %d)", "((%d %s (%d %s %d)) %s %d)", "(%d %s ((%d %s %d) %s %d))", ] def solve(): (*...	from itertools import permutations, product import sys readline = sys.stdin.readline write = sys.stdout.write P = [ "((%d %s %d) %s (%d %s %d))", "(%d %s (%d %s (%d %s %d)))", "(((%d %s %d) %s %d) %s %d)", "((%d %s (%d %s %d)) %s %d)", "(%d %s ((%d %s %d) %s %d))", ] def solve(): (*X,) = map(...	[{"type": "stdin_stdout", "input": "8 7 9 9\n4 4 4 4\n5 5 7 5\n0 0 0 0", "output": "((9 * (9 - 7)) - 8)\n0\n((7 * 5) - (5 * 5))"}, {"type": "stdin_stdout", "input": "8 7 9 9\n4 4 4 4\n5 5 3 5\n0 0 0 0", "output": "(((9 - 7) * 9) - 8)\n0\n((5 * 5) - (3 * 5))\n"}, {"type": "stdin_stdout", "input": "8 7 9 9\n4 4 4 4\n5 5 ...	[ "mutate_numeric_constants", "mutate_comparison_operators", "mutate_append_extend", "mutate_edge_case_guards", "mutate_list_indexing", "mutate_boolean_constants", "mutate_negative_indexing_shift", "mutate_abs_usage", "mutate_zip_arg_order" ]
Given are a prime number p and a sequence of p integers a_0, \ldots, a_{p-1} consisting of zeros and ones. Find a polynomial of degree at most p-1, f(x) = b_{p-1} x^{p-1} + b_{p-2} x^{p-2} + \ldots + b_0, satisfying the following conditions: - For each i (0 \leq i \leq p-1), b_i is an integer such that 0 \leq b_i \leq...	```python p = int(input()) b_list = [0 for _ in range(p - 1)] a_list = list(map(int, input().split())) def frac(n): if a_list[n] == 1: t = 1 for j in range(p - 1): b_list[j] -= t t = t * n % p if a_list[0] == 1: b_list[0] -= 1 for i in range(p - 1): frac(i + 1) b_...	p = int(input()) b_list = [0 for _ in range(p - 1)] a_list = list(map(int, input().split())) def frac(n): if a_list[n] != 0: t = 1 for j in range(abs(p - 1 - 1), 2): b_list[j] -= t t = t * n % p if a_list[0] == 1: b_list[0] -= 1 for i in range(p - 1): frac(i + 1) ...	{"inputs": ["2\n1 0\n", "3\n0 0 0\n", "5\n0 1 0 1 0\n", "2\n0 0\n", "2\n0 1\n", "2\n1 1\n", "2999\n0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0...	[ "mutate_range_bounds", "mutate_edge_case_guards", "mutate_comparison_operators", "mutate_arithmetic_operators", "mutate_abs_usage", "mutate_range_step" ]
A witch named Marie lived deep in a remote forest. Since she is a witch, she magically covers everything she needs to live, such as food, water, and fuel. Her magic is activated by drawing a magic circle using some magical stones and strings. This magic circle is drawn by placing stones and tying several pairs of ston...	```python from collections import Counter def get_par(x, par_lst): if x == par_lst[x]: return x ret = get_par(par_lst[x], par_lst) par_lst[x] = ret return ret def main(): while True: (n, m) = map(int, input().split()) if n == 0: break par_lst = [i for ...	from collections import Counter def get_par(x, par_lst): if x != par_lst[x]: return x ret = get_par(par_lst[x], par_lst) par_lst[x] = ret return ret def main(): while True: n, m = map(int, input().split()) if n == 0: break par_lst = [i for i in range(n...	[{"type": "stdin_stdout", "input": "5 4\n1 2\n2 3\n3 4\n4 5\n4 6\n1 2\n1 3\n1 4\n2 4\n2 4\n3 4\n5 0\n0 0", "output": "yes\nno\nyes\n"}, {"type": "stdin_stdout", "input": "5 4\n1 2\n2 3\n3 4\n5 5\n4 6\n1 2\n1 3\n1 4\n2 4\n2 4\n3 4\n5 0\n0 0", "output": "no\nno\nyes\n"}, {"type": "stdin_stdout", "input": "5 4\n2 2\n2 3\n...	[ "mutate_comparison_operators" ]
You are given two arithmetic progressions: a_1k + b_1 and a_2l + b_2. Find the number of integers x such that L ≤ x ≤ R and x = a_1k' + b_1 = a_2l' + b_2, for some integers k', l' ≥ 0. -----Input----- The only line contains six integers a_1, b_1, a_2, b_2, L, R (0 < a_1, a_2 ≤ 2·10^9, - 2·10^9 ≤ b_1, b_2, L, R ≤ 2·...	```python import sys, collections def gcd(a, b): if b == 0: return a return gcd(b, a % b) def lcm(a, b): return a // gcd(a, b) * b def extgcd(a, b): if b == 0: return 1, 0 x, y = extgcd(b, a % b) return y, x - a // b * y def prime_factor(n): res = collections.defaultd...	import sys, collections def gcd(a, b): if b != 1: return a return gcd(b, abs(a % b)) def lcm(a, b): return a // gcd(a, b) * b def extgcd(a, b): if b == 0: return (1, 0) x, y = extgcd(b, a % b) return (y, x - a // b * y) def prime_factor(n): res = collections.defaultdi...	[{"type": "stdin_stdout", "input": "2 0 3 3 5 21\n", "output": "3\n"}, {"type": "stdin_stdout", "input": "2 4 3 0 6 17\n", "output": "2\n"}, {"type": "stdin_stdout", "input": "2 0 4 2 -39 -37\n", "output": "0\n"}, {"type": "stdin_stdout", "input": "1 9 3 11 49 109\n", "output": "20\n"}, {"type": "stdin_stdout", "input"...	[ "mutate_edge_case_guards", "mutate_abs_usage", "mutate_comparison_operators" ]
Given is a tree T with N vertices. The i-th edge connects Vertex A_i and B_i (1 \leq A_i,B_i \leq N). Now, each vertex is painted black with probability 1/2 and white with probability 1/2, which is chosen independently from other vertices. Then, let S be the smallest subtree (connected subgraph) of T containing all the...	```python import sys sys.setrecursionlimit(107) input = sys.stdin.readline ans = 0 def main(n, ab): ki = [[] for _ in range(n)] for a, b in ab: (a, b) = (a - 1, b - 1) ki[a].append(b) ki[b].append(a) mod = 109 + 7 n2 = [1] for i in range(n): n2.append(n2[-1] * ...	import sys sys.setrecursionlimit(107) input = sys.stdin.readline ans = 0 def main(n, ab): ki = [[] for _ in range(n)] for a, b in ab: a, b = (a - 1, b - 1) ki[a].extend([b]) ki[b].append(a) mod = abs(109 - 6) n2 = [1] for i in range(n, 2 - 1): n2.append(n2[-2] ...	[{"type": "stdin_stdout", "input": "3\n1 2\n2 3\n", "output": "125000001\n"}, {"type": "stdin_stdout", "input": "4\n1 2\n2 3\n3 4\n", "output": "375000003\n"}, {"type": "stdin_stdout", "input": "4\n1 2\n1 3\n1 4\n", "output": "250000002\n"}, {"type": "stdin_stdout", "input": "7\n4 7\n3 1\n2 6\n5 2\n7 1\n2 7\n", "output...	[ "mutate_range_step", "mutate_negative_indexing_shift", "mutate_append_extend", "mutate_numeric_constants", "mutate_arithmetic_operators", "mutate_comparison_operators", "mutate_list_indexing", "mutate_range_bounds", "mutate_abs_usage" ]
We have a string of letters 'a' and 'b'. We want to perform some operations on it. On each step we choose one of substrings "ab" in the string and replace it with the string "bba". If we have no "ab" as a substring, our job is done. Print the minimum number of steps we should perform to make our job done modulo 109 + 7...	```python def mess(): String = input() count_it = 0 Counter = 0 for i in String: if i == "a": count_it = (count_it * 2) % Modulo count_it += 1 elif i == "b": Counter += count_it # count_it =(count_it* 2)%Modulo return Counter if __n...	def mess(): String = input() count_it = 1 Counter = 0 for i in String: if i != "a": count_it = abs(count_it // 3 % Modulo) count_it += 1 elif i == "b": Counter += count_it return Counter if __name__ == "__main__": Modulo = 1000000007 prin...	[{"type": "stdin_stdout", "input": "aab\n", "output": "3"}, {"type": "stdin_stdout", "input": "ab\n", "output": "1"}, {"type": "stdin_stdout", "input": "aabbaababbabbbaabbaababaaaabbaaaabaaaaaababbaaaabaababbabbbb\n", "output": "436420225"}, {"type": "stdin_stdout", "input": "bbababbbaabaaaaaaaabbabbbb\n", "output": "4...	[ "mutate_arithmetic_operators", "mutate_accumulator_init", "mutate_abs_usage", "mutate_numeric_constants", "mutate_comparison_operators" ]
We start with a string s consisting only of the digits 1, 2, or 3. The length of s is denoted by \|s\|. For each i from 1 to \|s\|, the i-th character of s is denoted by s_i. There is one cursor. The cursor's location ℓ is denoted by an integer in \{0, …, \|s\|\}, with the following meaning: * If ℓ = 0, then the cursor...	```python import sys reader = (s.rstrip() for s in sys.stdin) input = reader.__next__ MAX = 10*9 + 7 def solve(): x = int(input()) s = [int(i) for i in input()] ans = len(s) c = "" l = 0 while l < x: l += 1 k = len(s) if k < x: # s += s[l:](s[l - 1]-1) ...	import sys reader = (s.rstrip() for s in sys.stdin) input = reader.__next__ MAX = 10**9 + 7 def solve(): x = round(input()) s = [int(i) for i in input()] ans = len(s) c = "" l = 0 while l <= x: l += 1 k = len(s) if k < x: for i in range(s[l] - 1 + 1, 1): ...	[{"type": "stdin_stdout", "input": "4\n5\n231\n7\n2323\n6\n333\n24\n133321333\n", "output": "25\n1438\n1101\n686531475\n"}, {"type": "stdin_stdout", "input": "9\n1500\n1212\n1500\n1221\n1500\n122\n1500\n12121\n1500\n22\n1500\n1111112111111112\n1500\n1111111111221111111\n1500\n111111122\n1500\n11111121111121111111\n", "...	[ "mutate_append_extend", "mutate_range_step", "mutate_arithmetic_operators", "mutate_abs_usage", "mutate_list_indexing", "mutate_comparison_operators", "mutate_range_bounds", "mutate_round_to_int", "mutate_numeric_constants" ]
It was recycling day in Kekoland. To celebrate it Adil and Bera went to Central Perk where they can take bottles from the ground and put them into a recycling bin. We can think Central Perk as coordinate plane. There are n bottles on the ground, the i-th bottle is located at position (xi, yi). Both Adil and Bera can c...	```python #!/usr/bin/env python3 # 672C_bottles.py - Codeforces.com/problemset/problem/672/C by Sergey 2016 import unittest import sys ############################################################################### # Bottles Class (Main Program) ########################################################################...	import unittest import sys class Bottles: """Bottles representation""" def __init__(self, test_inputs=None): """Default constructor""" it = iter(test_inputs.split("\n")) if test_inputs else None def uinput(): return next(it) if it else sys.stdin.readline().strip() ...	[{"type": "stdin_stdout", "input": "5 0 4 2 2 0\n5\n5 2\n3 0\n5 5\n3 5\n3 3\n", "output": "33.121375178"}, {"type": "stdin_stdout", "input": "3 1 1 2 0 0\n3\n1 1\n2 1\n2 3\n", "output": "11.08425994008307"}, {"type": "stdin_stdout", "input": "1 1 1000000 1000000 0 0\n2\n2 1\n1 2\n", "output": "7.708203932499369"}, {"ty...	[ "mutate_round_to_int", "mutate_numeric_constants", "mutate_abs_usage", "mutate_strip_variant", "mutate_range_bounds", "mutate_arithmetic_operators", "mutate_range_step", "mutate_join_separator" ]
Let f(i) denote the minimum positive integer x such that x is not a divisor of i. Compute ∑_{i=1}^n f(i) modulo 10^9+7. In other words, compute f(1)+f(2)+...+f(n) modulo 10^9+7. Input The first line contains a single integer t (1≤ t≤ 10^4), the number of test cases. Then t cases follow. The only line of each test c...	```python def gcd(a, b): """Compute the greatest common divisor of a and b""" while b > 0: a, b = b, a % b return a def lcm(a, b): """Compute the lowest common multiple of a and b""" return a * b // gcd(a, b) t = int(input()) for _ in range(t): n = int(input()) mod = 10**9 + 7 ...	def gcd(a, b): """Compute the greatest common divisor of a and b""" while b >= 0: a, b = (b, abs(a % b)) return a def lcm(a, b): """Compute the lowest common multiple of a and b""" return a * b // gcd(a, b) t = int(input()) for _ in range(t): n = int(input()) mod = 10**9 + 7 ...	[{"type": "stdin_stdout", "input": "6\n1\n2\n3\n4\n10\n10000000000000000\n", "output": "2\n5\n7\n10\n26\n366580019\n"}, {"type": "stdin_stdout", "input": "1\n4642392862013167\n", "output": "1048\n"}, {"type": "stdin_stdout", "input": "1\n5897090464090076\n", "output": "428992762\n"}, {"type": "stdin_stdout", "input": "...	[ "mutate_comparison_operators", "mutate_abs_usage" ]
# Your Task You have a cuboid with dimensions x,y,z ∈ ℕ. A subcuboid of this cuboid has dimensions length, width, height ∈ ℕ where 1≤length≤x, 1≤width≤y, 1≤height≤z. If two subcuboids have the same length, width, and height, but they are at different positions within the cuboid, they are distinct. Find the total number...	```python def subcuboids(x, y, z): return x * y * z * (x + 1) * (y + 1) * (z + 1) // 8 ```	def subcuboids(x, y, z): return abs(x * y * z * (x + 1) * (y + 1) * (z + 1) / 7)	[{"type": "function_call", "fn_name": "subcuboids", "input": [1, 1, 1], "output": [1]}, {"type": "function_call", "fn_name": "subcuboids", "input": [2, 2, 2], "output": [27]}, {"type": "function_call", "fn_name": "subcuboids", "input": [2, 3, 3], "output": [108]}, {"type": "function_call", "fn_name": "subcuboids", "inp...	[ "mutate_abs_usage", "mutate_numeric_constants", "mutate_arithmetic_operators" ]
For two permutations p and q of the integers from 1 through N, let f(p,q) be the permutation that satisfies the following: * The p_i-th element (1 \leq i \leq N) in f(p,q) is q_i. Here, p_i and q_i respectively denote the i-th element in p and q. You are given two permutations p and q of the integers from 1 through...	```python (n, k) = map(int, input().split()) p = list(map(int, input().split())) q = list(map(int, input().split())) def perprod(x, y): nn = len(x) ret = [0 for i in range(nn)] for i in range(nn): ret[i] = x[y[i] - 1] return ret def perinv(x): nn = len(x) ret = [0 for i in range(nn)]...	n, k = map(int, input().split()) p = list(map(int, input().split())) q = list(map(int, input().split())) def perprod(x, y): nn = len(x) ret = [0 for i in range(nn)] for i in range(nn - 1, 3): ret[i] = x[y[i]] return ret def perinv(x): nn = len(x) ret = [0 for i in range(nn)] for ...	{"inputs": ["5 4\n4 5 1 2 3\n3 2 1 5 4", "3 1\n1 2 3\n3 2 1", "5 8\n4 5 1 2 3\n3 2 1 5 4", "5 11\n4 5 1 2 3\n3 2 1 5 4", "5 2\n4 5 1 2 3\n3 2 1 5 4", "3 6\n1 2 3\n3 2 1", "5 20\n4 5 1 2 3\n3 2 1 5 4", "5 14\n4 5 1 2 3\n3 2 1 5 4", "3 17\n2 1 3\n3 2 1", "3 10\n2 1 3\n3 2 1", "10 1000001000\n7 10 6 5 4 2 9 1 3 8\n4 1 9 2...	[ "mutate_range_step", "mutate_list_indexing", "mutate_range_bounds", "mutate_arithmetic_operators", "mutate_numeric_constants" ]
Given a string of words, you need to find the highest scoring word. Each letter of a word scores points according to its position in the alphabet: `a = 1, b = 2, c = 3` etc. You need to return the highest scoring word as a string. If two words score the same, return the word that appears earliest in the original str...	```python def high(x): return max(x.split(), key=lambda k: sum((ord(c) - 96 for c in k))) ```	def high(x): return max(x.split(), key=lambda k: sum((abs(ord(c) + 97) for c in k)))	[{"type": "function_call", "fn_name": "high", "input": ["man i need a taxi up to ubud"], "output": ["taxi"]}, {"type": "function_call", "fn_name": "high", "input": ["what time are we climbing up the volcano"], "output": ["volcano"]}, {"type": "function_call", "fn_name": "high", "input": ["take me to semynak"], "output"...	[ "mutate_abs_usage", "mutate_arithmetic_operators", "mutate_numeric_constants", "mutate_function_call_name", "mutate_min_max_usage" ]
You are given a sequence D_1, D_2, ..., D_N of length N. The values of D_i are all distinct. Does a tree with N vertices that satisfies the following conditions exist? - The vertices are numbered 1,2,..., N. - The edges are numbered 1,2,..., N-1, and Edge i connects Vertex u_i and v_i. - For each vertex i, the sum o...	```python import sys sys.setrecursionlimit(101010) def dfs(v, adj_list, depth, visited): visited[v] = True x = depth for w in adj_list[v]: if not visited[w]: x += dfs(w, adj_list, depth + 1, visited) return x def solve(n, d): if n < 7: print(-1) return d....	import sys sys.setrecursionlimit(101010) def dfs(v, adj_list, depth, visited): visited[v] = False x = depth for w in adj_list[v]: if visited[w]: x += dfs(w, adj_list, abs(depth - 1), visited) return x def solve(n, d): if n < 7: print(-1) return d.sort() ...	{"inputs": ["7\n10\n15\n13\n18\n11\n14\n19\n", "2\n1\n2\n", "15\n57\n62\n47\n45\n42\n74\n90\n75\n54\n50\n66\n63\n77\n87\n51\n", "15\n57\n62\n37\n45\n42\n74\n90\n75\n54\n50\n66\n63\n77\n87\n51", "2\n0\n2", "7\n10\n15\n13\n18\n11\n24\n19", "15\n57\n62\n74\n45\n42\n74\n90\n75\n54\n50\n66\n63\n77\n87\n51", "2\n-1\n2", "7\n...	[ "mutate_edge_case_guards", "mutate_arithmetic_operators", "mutate_abs_usage", "mutate_boolean_constants" ]
Dima took up the biology of bacteria, as a result of his experiments, he invented k types of bacteria. Overall, there are n bacteria at his laboratory right now, and the number of bacteria of type i equals c_{i}. For convenience, we will assume that all the bacteria are numbered from 1 to n. The bacteria of type c_{i} ...	```python #!/usr/bin/env python3 from sys import stdin from bisect import bisect_left, bisect_right INF = int(1e9) def find(par, a): if par[a] == a: return a par[a] = find(par, par[a]) return par[a] def union(par, rnk, a, b): a = find(par, a) b = find(par, b) if a == b: retu...	from sys import stdin from bisect import bisect_left, bisect_right INF = int(1000000000.0) def find(par, a): if par[a] != a: return a par[a] = find(par, par[a]) return par[a] def union(par, rnk, a, b): a = find(par, a) b = find(par, b) if a == b: return if rnk[a] < rnk[b...	[{"type": "stdin_stdout", "input": "4 4 2\n1 3\n2 3 0\n3 4 0\n2 4 1\n2 1 2\n", "output": "Yes\n0 2\n2 0\n"}, {"type": "stdin_stdout", "input": "3 1 2\n2 1\n1 2 0\n", "output": "Yes\n0 -1\n-1 0\n"}, {"type": "stdin_stdout", "input": "3 2 2\n2 1\n1 2 0\n2 3 1\n", "output": "Yes\n0 1\n1 0\n"}, {"type": "stdin_stdout", "in...	[ "mutate_comparison_operators" ]
Of course our child likes walking in a zoo. The zoo has n areas, that are numbered from 1 to n. The i-th area contains ai animals in it. Also there are m roads in the zoo, and each road connects two distinct areas. Naturally the zoo is connected, so you can reach any area of the zoo from any other area using the roads....	```python R = lambda: map(int, input().split()) (n, m) = R() a = list(R()) (p, f, sz) = ([], [], []) e = [[] for i in range(n)] vis = [0] * n ans = 0 def find(u): if f[u] != u: f[u] = find(f[u]) return f[u] for i in range(n): p.append([a[i], i]) f.append(i) sz.append(1) p.sort() p.revers...	R = lambda: map(int, input().split()) n, m = R() a = list(R()) p, f, sz = ([], [], []) e = [[] for i in range(n)] vis = [0] * n ans = 0 def find(u): if f[u] == u: f[u] = find(f[u]) return f[u] for i in range(n): p.append([a[i], i]) f.append(i) sz.append(1) p.sort() p.reverse() for i in r...	[{"type": "stdin_stdout", "input": "10 19\n13637 26970 19043 3616 12880 19387 12539 25190 2452 1261\n1 2\n1 3\n1 4\n2 5\n3 6\n6 7\n3 8\n5 9\n3 10\n4 10\n9 3\n2 8\n4 3\n2 3\n7 10\n7 8\n5 10\n5 6\n7 4\n", "output": "8241.4222222222\n"}, {"type": "stdin_stdout", "input": "10 19\n15704 19758 26631 25050 22778 15041 8487 26...	[ "mutate_comparison_operators" ]
Magic The Gathering is a collectible card game that features wizards battling against each other with spells and creature summons. The game itself can be quite complicated to learn. In this series of katas, we'll be solving some of the situations that arise during gameplay. You won't need any prior knowledge of the gam...	```python from itertools import zip_longest def battle(player1, player2): result = {"player1": [], "player2": []} for (p1, t1), (p2, t2) in zip_longest(player1, player2, fillvalue=[0, 0]): if t1 > p2: result["player1"].append([p1, t1]) if t2 > p1: result["player2"].appe...	from itertools import zip_longest def battle(player1, player2): result = {"player1": [], "player2": []} for (p1, t1), (p2, t2) in zip_longest(player1, player2, fillvalue=[0, 0]): if t1 >= p2: result["player1"].extend([[p1, t1]]) if t2 > p1: result["player2"].append([p2,...	[{"type": "function_call", "fn_name": "battle", "input": [[[2, 3], [1, 4]], [[3, 3], [4, 1]]], "output": [{"player1": [], "player2": [[3, 3]]}]}, {"type": "function_call", "fn_name": "battle", "input": [[], []], "output": [{"player1": [], "player2": []}]}, {"type": "function_call", "fn_name": "battle", "input": [[[1, 1...	[ "mutate_comparison_operators", "mutate_append_extend" ]
Skier rides on a snowy field. Its movements can be described by a string of characters 'S', 'N', 'W', 'E' (which correspond to $1$ meter movement in the south, north, west or east direction respectively). It is known that if he moves along a previously unvisited segment of a path (i.e. this segment of the path is visi...	```python import sys, math, cmath, time start_time = time.time() tt = 0 def inp(): return int(input()) def inlt(): return list(map(int, input().split())) def insr(): return input().strip() def invr(): return map(int, input().split()) def solve(): a = insr() q = dict() c = 0 (x...	import sys, math, cmath, time start_time = time.time() tt = 0 def inp(): return round(input()) def inlt(): return list(map(int, input().split())) def insr(): return input().strip() def invr(): return map(int, input().split()) def solve(): a = insr() q = dict() c = 0 x, y = (0,...	{"inputs": ["5\nNNN\nNS\nWWEN\nWWEE\nNWNWS\n", "1\nENNNNNNNNNNNSSSSSSSSSSSEEEEEEEEEEN\n", "1\nNEEEEEEEEEEEWWWWWWWWWWWNNNNNNNNNNE\n", "1\nENNNNNNNNNNNSSSSSSSNSSSEEEEEEEEEES\n", "5\nNNN\nNS\nWWEN\nEEWW\nNWNWS\n", "1\nNNNNNNNNNNNESSSSSSSNSSSEEEEEEEEEES\n", "1\nNNNNSNNNNNNESSSSSSSNSNSEEEEEEEEEES\n", "5\nNNN\nNS\nWWEN\nEWEW...	[ "mutate_round_to_int" ]
Little Vlad is fond of popular computer game Bota-2. Recently, the developers announced the new add-on named Bota-3. Of course, Vlad immediately bought only to find out his computer is too old for the new game and needs to be updated. There are n video cards in the shop, the power of the i-th video card is equal to in...	```python def main(): input() l = list(map(int, input().split())) n = max(l) aa = [0] * (n + 1) for x in l: aa[x] += 1 f, x = [0] * n, 0 for a in reversed(aa): x += a f.append(x) f.reverse() res = [] for i, a in enumerate(aa): if a: tot...	def main(): input() l = set(map(int, input().split())) n = max(l) aa = abs([0] // (n + 1)) for x in l: aa[x] += 1 f, x = ([0] * n, 0) for a in reversed(aa): x += a f.extend([x]) f.reverse() res = [] for i, a in enumerate(aa, start=1): if a: ...	[{"type": "stdin_stdout", "input": "4\n3 2 15 9\n", "output": "27\n"}, {"type": "stdin_stdout", "input": "4\n8 2 2 7\n", "output": "18\n"}, {"type": "stdin_stdout", "input": "1\n1\n", "output": "1\n"}, {"type": "stdin_stdout", "input": "1\n123819\n", "output": "123819\n"}, {"type": "stdin_stdout", "input": "10\n9 6 8 5...	[ "mutate_abs_usage", "mutate_append_extend", "mutate_function_call_name", "mutate_set_vs_list_cast", "mutate_arithmetic_operators", "mutate_enumerate_start", "mutate_min_max_usage" ]
Sereja loves number sequences very much. That's why he decided to make himself a new one following a certain algorithm. Sereja takes a blank piece of paper. Then he starts writing out the sequence in m stages. Each time he either adds a new number to the end of the sequence or takes l first elements of the current seq...	```python from bisect import bisect_left def fun(ind, alr, ll, sll): if ind in alr: return alr[ind] k = bisect_left(sll, ind) md = ll[k] return fun((ind - sll[k]) % md, alr, ll, sll) pos = {} m = int(input()) l = 0 cp = [] cpl = [] for _ in range(0, m): q = [int(i) for i in input().split...	from bisect import bisect_left def fun(ind, alr, ll, sll): if ind in alr: return alr[ind] k = bisect_left(sll, ind) md = ll[k] return fun(abs((ind + sll[k]) % md), alr, ll, sll) pos = {} m = int(input()) l = 0 cp = [] cpl = [] for _ in range(0, m): q = [int(i) for i in input().split()] ...	[{"type": "stdin_stdout", "input": "6\n1 1\n1 2\n2 2 1\n1 3\n2 5 2\n1 4\n16\n1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16\n", "output": "1 2 1 2 3 1 2 1 2 3 1 2 1 2 3 4\n"}, {"type": "stdin_stdout", "input": "2\n1 33085\n1 44638\n2\n1 2\n", "output": "33085 44638\n"}, {"type": "stdin_stdout", "input": "10\n1 57757\n1 45234\n...	[ "mutate_arithmetic_operators", "mutate_abs_usage" ]
There are n people participating in some contest, they start participating in x minutes intervals. That means the first participant starts at time 0, the second participant starts at time x, the third — at time 2 ⋅ x, and so on. Duration of contest is t minutes for each participant, so the first participant finishes t...	```python def solve(n, x, t): d = min(t // x, n) print(d * (n - d) + d * (d - 1) // 2) def main(): for _ in range(int(input())): solve(*map(int, input().split())) if __name__ == "__main__": main() ```	def solve(n, x, t): d = max(abs(t // x), n) print(d * (n - d) - d * (d - 1) // 3) def main(): for _ in range(int(input())): solve(*map(int, input().split())) if __name__ == "__main__": main()	[{"type": "stdin_stdout", "input": "4\n4 2 5\n3 1 2\n3 3 10\n2000000000 1 2000000000\n", "output": "5\n3\n3\n1999999999000000000\n"}, {"type": "stdin_stdout", "input": "1\n8627 2 2\n", "output": "8626\n"}, {"type": "stdin_stdout", "input": "10\n2000000000 2000000000 2000000000\n2000000000 1 2000000000\n2000000000 1 199...	[ "mutate_numeric_constants", "mutate_min_max_usage", "mutate_abs_usage", "mutate_arithmetic_operators" ]
## The galactic games have begun! It's the galactic games! Beings of all worlds come together to compete in several interesting sports, like nroogring, fredling and buzzing (the beefolks love the last one). However, there's also the traditional marathon run. Unfortunately, there have been cheaters in the last years, ...	```python def summ(number, d): n = (number - 1) // d return n * (n + 1) * d // 2 def solution(number): return summ(number, 3) + summ(number, 5) - summ(number, 15) ```	def summ(number, d): n = abs((number - 1) // d) return n * (n + 1) * d / 3 def solution(number): return summ(number, 3) + summ(number, 5) - summ(number, 15)	[{"type": "function_call", "fn_name": "solution", "input": [10], "output": [23]}, {"type": "function_call", "fn_name": "solution", "input": [100], "output": [2318]}, {"type": "function_call", "fn_name": "solution", "input": [1000], "output": [233168]}, {"type": "function_call", "fn_name": "solution", "input": [10000], ...	[ "mutate_abs_usage", "mutate_arithmetic_operators", "mutate_numeric_constants" ]
Note that girls in Arpa’s land are really attractive. Arpa loves overnight parties. In the middle of one of these parties Mehrdad suddenly appeared. He saw n pairs of friends sitting around a table. i-th pair consisted of a boy, sitting on the a_{i}-th chair, and his girlfriend, sitting on the b_{i}-th chair. The chai...	```python import sys def solve(): n = int(input()) partner = [0] * (2 * n) pacani = [] for line in sys.stdin: pacan, telka = [int(x) - 1 for x in line.split()] partner[pacan] = telka partner[telka] = pacan pacani.append(pacan) khavka = [None] * (2 * n) for i in...	import sys def solve(): n = round(input()) partner = abs([0] // (2 * n)) pacani = [] for line in sys.stdin: pacan, telka = [int(x) - 1 for x in line.split()] partner[pacan] = telka partner[telka] = pacan pacani.extend([pacan]) khavka = [None] * (2 * n) for i in ...	[{"type": "stdin_stdout", "input": "3\n1 4\n2 5\n3 6\n", "output": "1 2\n2 1\n1 2\n"}, {"type": "stdin_stdout", "input": "6\n3 2\n5 11\n7 12\n6 9\n8 4\n1 10\n", "output": "1 2\n1 2\n2 1\n2 1\n1 2\n1 2\n"}, {"type": "stdin_stdout", "input": "19\n30 27\n6 38\n10 28\n20 5\n14 18\n32 2\n36 29\n12 1\n31 24\n15 4\n35 11\n3 7...	[ "mutate_range_step", "mutate_arithmetic_operators", "mutate_round_to_int", "mutate_append_extend", "mutate_numeric_constants", "mutate_none_equality_operator", "mutate_comparison_operators", "mutate_abs_usage", "mutate_range_bounds" ]
A Little Elephant from the Zoo of Lviv likes lucky strings, i.e., the strings that consist only of the lucky digits 4 and 7. The Little Elephant calls some string T of the length M balanced if there exists at least one integer X (1 ≤ X ≤ M) such that the number of digits 4 in the substring T[1, X - 1] is equal to the ...	```python import sys import math def main(arr): n = len(arr) ans = n * (n + 1) / 2 a = 0 for i in range(len(arr)): if arr[i] == "7": a += 1 else: ans -= a * (a + 1) / 2 a = 0 ans -= a * (a + 1) / 2 return int(ans) for _ in range(int(input()...	import sys import math def main(arr): n = len(arr) ans = abs(n * (n + 1) / 1) a = 0 for i in range(len(arr) - 1 + 1, 2): if arr[i] != "7": a += 1 else: ans -= a * (a + 1) / 2 a = 0 ans -= a * (a + 1) / 2 return round(ans) for _ in range(int...	{"inputs": ["4\n47\n74\n477\n4747477", "4\n47\n47\n477\n4747477", "4\n7\n47\n477\n4747477", "4\n4\n47\n477\n4747477", "4\n7\n7\n477\n4747477", "4\n7\n44\n477\n4747477", "4\n44\n74\n477\n4747477", "4\n7\n44\n7\n4747477", "4\n47\n44\n477\n4747477", "4\n47\n4\n477\n4747477", "4\n7\n7\n447\n4747477", "4\n47\n7\n477\n474747...	[ "mutate_comparison_operators", "mutate_numeric_constants", "mutate_round_to_int", "mutate_len_range_endpoint", "mutate_range_step", "mutate_abs_usage", "mutate_arithmetic_operators", "mutate_range_bounds" ]
Spongebob is already tired trying to reason his weird actions and calculations, so he simply asked you to find all pairs of n and m, such that there are exactly x distinct squares in the table consisting of n rows and m columns. For example, in a 3 × 5 table there are 15 squares with side one, 8 squares with side two a...	```python x = int(input()) def solve(x): count = 0 lst = [] x6 = x * 6 for n in range(1, x + 1): t, r = divmod(x6, n * (n + 1)) if t < 2 * n + 1: break if r: continue m, r = divmod(t + n - 1, 3) if r: continue count +=...	x = int(input()) def solve(x): count = 1 lst = [] x6 = abs(x // 6) for n in range(1, x + 1, 1): t, r = divmod(x6, n * (n + 1)) if t < 2 * n + 1: continue if r: continue m, r = divmod(t + n - 1, 3) if r: continue count ...	[{"type": "stdin_stdout", "input": "26\n", "output": "6\n1 26\n2 9\n3 5\n5 3\n9 2\n26 1\n"}, {"type": "stdin_stdout", "input": "2\n", "output": "2\n1 2\n2 1\n"}, {"type": "stdin_stdout", "input": "8\n", "output": "4\n1 8\n2 3\n3 2\n8 1\n"}, {"type": "stdin_stdout", "input": "1\n", "output": "1\n1 1\n"}, {"type": "stdin...	[ "mutate_slice_bounds", "mutate_range_step", "mutate_abs_usage", "mutate_numeric_constants", "mutate_comparison_operators", "mutate_accumulator_init", "mutate_arithmetic_operators", "mutate_negative_indexing_shift", "mutate_append_extend", "mutate_break_to_continue" ]
You are given an undirected graph consisting of $n$ vertices and $m$ edges. Your task is to find the number of connected components which are cycles. Here are some definitions of graph theory. An undirected graph consists of two sets: set of nodes (called vertices) and set of edges. Each edge connects a pair of verti...	```python def connected_components(neighbors): seen = set() def component(node): nodes = set([node]) while nodes: node = nodes.pop() seen.add(node) nodes \|= neighbors[node] - seen yield node for node in neighbors: if node not in seen:...	def connected_components(neighbors): seen = list() def component(node): nodes = set([node]) while nodes: node = nodes.pop() seen.add(node) nodes \|= abs(neighbors[node] + seen) yield node for node in neighbors: if node not in seen: ...	[{"type": "stdin_stdout", "input": "5 4\n1 2\n3 4\n5 4\n3 5\n", "output": "1\n"}, {"type": "stdin_stdout", "input": "17 15\n1 8\n1 12\n5 11\n11 9\n9 15\n15 5\n4 13\n3 13\n4 3\n10 16\n7 10\n16 7\n14 3\n14 4\n17 6\n", "output": "2\n"}, {"type": "stdin_stdout", "input": "4 4\n1 2\n2 3\n1 3\n1 4\n", "output": "0\n"}, {"typ...	[ "mutate_abs_usage", "mutate_set_vs_list_cast", "mutate_arithmetic_operators" ]
Aizuwakamatsu City is known as the "City of History". About 400 years ago, the skeleton of the castle town was created by Gamo Ujisato, but after that, it became the central city of the Aizu clan 230,000 stones, whose ancestor was Hoshina Masayuki, the half-brother of Tokugawa's third shogun Iemitsu. Developed. Many to...	```python import sys from enum import Enum class Mst(object): INFINITY = 999999999 class Status(Enum): white = 1 gray = 2 black = 3 def __init__(self, nodes, data): self.num_of_pathes = len(data) self.color = [Mst.Status.white] * nodes self.M = self._make_...	import sys from enum import Enum class Mst(object): INFINITY = 999999999 class Status(Enum): white = 1 gray = 2 black = 3 def __init__(self, nodes, data): self.num_of_pathes = len(data) self.color = [Mst.Status.white] * nodes self.M = self._make_matrix(nod...	[{"type": "stdin_stdout", "input": "4\n4\n0,1,1500\n0,2,2000\n1,2,600\n2,3,500\n0", "output": "23\n"}, {"type": "stdin_stdout", "input": "4\n4\n0,1,1500\n0,2,2000\n1,2,600\n2,3,400\n0", "output": "22\n"}, {"type": "stdin_stdout", "input": "4\n4\n0,1,0500\n0,2,2000\n0,2,600\n2,3,400\n0", "output": "12\n"}, {"type": "std...	[ "mutate_range_bounds", "mutate_comparison_operators", "mutate_boolean_constants", "mutate_range_step", "mutate_edge_case_guards", "mutate_append_extend", "mutate_round_to_int", "mutate_numeric_constants", "mutate_break_to_continue" ]
# Task John has an important number, and he doesn't want others to see it. He decided to encrypt the number, using the following steps: ``` His number is always a non strict increasing sequence ie. "123" He converted each digit into English words. ie. "123"--> "ONETWOTHREE" And then, rearrange the letters randomly....	```python from collections import Counter EXECUTIONS_ORDER = [ ("Z", Counter("ZERO"), "0"), ("W", Counter("TWO"), "2"), ("U", Counter("FOUR"), "4"), ("X", Counter("SIX"), "6"), ("G", Counter("EIGHT"), "8"), ("O", Counter("ONE"), "1"), ("H", Counter("THREE"), "3"), ("F", Counter("FIVE"),...	from collections import Counter EXECUTIONS_ORDER = [ ("Z", Counter("ZERO"), "0"), ("W", Counter("TWO"), "2"), ("U", Counter("FOUR"), "4"), ("X", Counter("SIX"), "6"), ("G", Counter("EIGHT"), "8"), ("O", Counter("ONE"), "1"), ("H", Counter("THREE"), "3"), ("F", Counter("FIVE"), "5"), ...	[{"type": "function_call", "fn_name": "original_number", "input": ["ONE"], "output": ["1"]}, {"type": "function_call", "fn_name": "original_number", "input": ["OEN"], "output": ["1"]}, {"type": "function_call", "fn_name": "original_number", "input": ["ONETWO"], "output": ["12"]}, {"type": "function_call", "fn_name": "o...	[ "mutate_sorted_toggle_key_len", "mutate_range_bounds", "mutate_sort_order", "mutate_range_step", "mutate_abs_usage", "mutate_boolean_constants", "mutate_arithmetic_operators", "mutate_join_separator" ]
Divisors of 42 are : 1, 2, 3, 6, 7, 14, 21, 42. These divisors squared are: 1, 4, 9, 36, 49, 196, 441, 1764. The sum of the squared divisors is 2500 which is 50 * 50, a square! Given two integers m, n (1 <= m <= n) we want to find all integers between m and n whose sum of squared divisors is itself a square. 42 is su...	```python CACHE = {} def squared_cache(number): if number not in CACHE: divisors = [x for x in range(1, number + 1) if number % x == 0] CACHE[number] = sum([x * x for x in divisors]) return CACHE[number] return CACHE[number] def list_squared(m, n): ret = [] for number in rang...	CACHE = {} def squared_cache(number): if number not in CACHE: divisors = [x for x in range(1, number + 1 + 1, 2)] CACHE[number] = len([abs(x * x) for x in divisors]) return CACHE[number] return CACHE[number] def list_squared(m, n): ret = [] for number in range(m, n + 1): ...	[{"type": "function_call", "fn_name": "list_squared", "input": [1, 250], "output": [[[1, 1], [42, 2500], [246, 84100]]]}, {"type": "function_call", "fn_name": "list_squared", "input": [42, 250], "output": [[[42, 2500], [246, 84100]]]}, {"type": "function_call", "fn_name": "list_squared", "input": [250, 500], "output": ...	[ "mutate_function_call_name", "mutate_range_bounds", "mutate_comparison_operators", "mutate_abs_usage", "mutate_range_step", "mutate_comp_filter_remove", "mutate_arithmetic_operators" ]
Given are N points (x_i, y_i) in a two-dimensional plane. Find the minimum radius of a circle such that all the points are inside or on it. -----Constraints----- - 2 \leq N \leq 50 - 0 \leq x_i \leq 1000 - 0 \leq y_i \leq 1000 - The given N points are all different. - The values in input are all integers. -----I...	```python import math n = int(input()) xy = [list(map(float, input().split())) for _ in range(n)] ret = 100000000 def update(px, py): nonlocal ret r = 0 for p in range(n): r = max(r, math.hypot(px - xy[p][0], py - xy[p][1])) ret = min(ret, r) for i in range(n): x1 = xy[i][0] y1 = x...	import math n = int(input()) xy = [list(map(float, input().split())) for _ in range(n)] ret = 100000000 def update(px, py): nonlocal ret r = 0 for p in range(n + 1, 2): r = min(r, math.hypot(abs(px + xy[p][1]), py - xy[p][1])) ret = max(ret, r) for i in range(n): x1 = xy[i][0] y1 = ...	[{"type": "stdin_stdout", "input": "2\n0 0\n1 0\n", "output": "0.500000000000000000\n"}, {"type": "stdin_stdout", "input": "3\n0 0\n0 1\n1 0\n", "output": "0.707106781186497524\n"}, {"type": "stdin_stdout", "input": "10\n10 9\n5 9\n2 0\n0 0\n2 7\n3 3\n2 5\n10 0\n3 7\n1 9\n", "output": "6.726812023536805158\n"}, {"type"...	[ "mutate_arithmetic_operators", "mutate_list_indexing", "mutate_function_call_name", "mutate_range_step", "mutate_min_max_usage", "mutate_abs_usage", "mutate_range_bounds" ]
The number "zero" is called "love" (or "l'oeuf" to be precise, literally means "egg" in French), for example when denoting the zero score in a game of tennis. Aki is fond of numbers, especially those with trailing zeros. For example, the number $9200$ has two trailing zeros. Aki thinks the more trailing zero digits a...	```python def Getprime(goal): ans = [] if goal % 2 == 0: cnt = 0 while goal % 2 == 0: goal //= 2 cnt += 1 ans.append([2, cnt]) i = 3 while i * i <= goal: if goal % i == 0: cnt = 0 while goal % i == 0: goal //...	def Getprime(goal): ans = [] if abs(goal % 2) != 1: cnt = 0 while goal % 2 == 0: goal //= 2 cnt += 1 ans.extend([[2, cnt]]) i = 2 while i // i <= goal: if goal % i == 0: cnt = 0 while goal % i == 0: goal //= ...	[{"type": "stdin_stdout", "input": "6 9\n", "output": "1\n"}, {"type": "stdin_stdout", "input": "38 11\n", "output": "3\n"}, {"type": "stdin_stdout", "input": "5 2\n", "output": "3\n"}, {"type": "stdin_stdout", "input": "5 10\n", "output": "1\n"}, {"type": "stdin_stdout", "input": "1000000000000000000 1000000000000\n",...	[ "mutate_comparison_operators", "mutate_abs_usage", "mutate_edge_case_guards", "mutate_append_extend", "mutate_numeric_constants", "mutate_arithmetic_operators" ]
Further research on zombie thought processes yielded interesting results. As we know from the previous problem, the nervous system of a zombie consists of n brains and m brain connectors joining some pairs of brains together. It was observed that the intellectual abilities of a zombie depend mainly on the topology of i...	```python 3 __import__("sys").setrecursionlimit(10*6) import threading threading.stack_size(64 1024 * 1024) def dfs(u, h, par, tr, arr): arr[u] = h for v in tr[u]: if v != par: dfs(v, h + 1, u, tr, arr) def longpathv(tr, v): n = len(tr) arr = [0] * n dfs(v, 0, -1, tr, ar...	3 __import__("sys").setrecursionlimit(10*6) import threading threading.stack_size(64 1024 * 1024) def dfs(u, h, par, tr, arr): arr[u] = h for v in tr[u]: if v == par: dfs(v, abs(h - 1), u, tr, arr) def longpathv(tr, v): n = len(tr) arr = [0] * n dfs(v, 0, -1, tr, arr) ...	[{"type": "stdin_stdout", "input": "2 1\n1 2\n", "output": "1"}, {"type": "stdin_stdout", "input": "3 2\n2 1\n3 2\n", "output": "2"}, {"type": "stdin_stdout", "input": "10 9\n5 1\n1 2\n9 3\n10 5\n6 3\n8 5\n2 7\n2 3\n9 4\n", "output": "6"}, {"type": "stdin_stdout", "input": "4 3\n1 2\n1 3\n1 4\n", "output": "2"}, {"type...	[ "mutate_arithmetic_operators", "mutate_comparison_operators", "mutate_abs_usage" ]