Datasets:

---

rootacess

/

pie-perf

like 0

[ "-", "-", "-def parity_of_nCk(n, k):", "- return (n & k) == k", "-", "-", "-ans = 0", "-for i, a in enumerate(A):", "- if a & r:", "- if parity_of_nCk(N - 1, i):", "- ans ^= 1", "-print((ans * r))", "+print((sum([1 if A[i] & r and (N - 1 & i) == i else 0 for i in range(N)]) % 2 * r))" ]

[ "s830400854", "s067979056" ]

[ "-a = [\"A\", \"G\", \"C\", \"T\"]", "-l = [", "- \"GACA\",", "- \"GACC\",", "- \"GACT\",", "- \"AGGC\",", "- \"AGCA\",", "- \"AGCG\",", "- \"AGCC\",", "- \"AGCT\",", "- \"AGTC\",", "- \"ACGA\",", "- \"ACGG\",", "- \"ACGC\",", "- \"ACGT\",", "- \"ATGC\",", "-]", "-dict1_y = {}", "-dict1_n = {}", "-dict2_y = {}", "-dict2_n = {}", "-t = 3", "-p = 10**9 + 7", "-for i in a:", "- for j in a:", "- for k in a:", "- s = i + j + k", "- dict1_y[s] = 0", "- dict1_n[s] = 0", "- dict2_y[s] = 0", "- dict2_n[s] = 0", "-for i in a:", "- for j in a:", "- for k in a:", "- s = i + j + k", "- if \"AGC\" in s:", "- dict1_y[s] += 1", "- else:", "- tem1 = s[0]", "- tem2 = s[1]", "- new_s = tem2 + tem1 + s[2]", "- if \"AGC\" in new_s:", "- dict1_y[s] += 1", "- else:", "- tem1 = s[1]", "- tem2 = s[2]", "- new_s = s[0] + tem2 + tem1", "- if \"AGC\" in new_s:", "- dict1_y[s] += 1", "- else:", "- dict1_n[s] += 1", "-while t != n:", "- for k, v in list(dict1_y.items()):", "- for m in a:", "- key = m + k[0] + k[1]", "- dict2_y[key] += v", "- for k, v in list(dict1_n.items()):", "- for m in a:", "- new_s = m + k", "- key = m + k[0] + k[1]", "- if new_s in l:", "- dict2_y[key] += v", "- else:", "- dict2_n[key] += v", "- for i in a:", "- for j in a:", "- for k in a:", "- s = i + j + k", "- dict1_y[s] = dict2_y[s] % p", "- dict1_n[s] = dict2_n[s] % p", "- dict2_y[s] = 0", "- dict2_n[s] = 0", "- t += 1", "-ans = 0", "-for v in list(dict1_y.values()):", "- ans += v % p", "-print(((4**n - ans) % p))", "+dict = {", "+ 3: 61,", "+ 4: 230,", "+ 5: 865,", "+ 6: 3247,", "+ 7: 12185,", "+ 8: 45719,", "+ 9: 171531,", "+ 10: 643550,", "+ 11: 2414454,", "+ 12: 9058467,", "+ 13: 33985227,", "+ 14: 127504505,", "+ 15: 478366600,", "+ 16: 794717734,", "+ 17: 733354121,", "+ 18: 261943303,", "+ 19: 776803305,", "+ 20: 580025381,", "+ 21: 51688048,", "+ 22: 44657419,", "+ 23: 737209731,", "+ 24: 604119499,", "+ 25: 159693437,", "+ 26: 858533109,", "+ 27: 639056669,", "+ 28: 549054109,", "+ 29: 996291083,", "+ 30: 531294469,", "+ 31: 23314687,", "+ 32: 783022045,", "+ 33: 855462856,", "+ 34: 649970414,", "+ 35: 68697295,", "+ 36: 409213624,", "+ 37: 604356692,", "+ 38: 88638656,", "+ 39: 978442997,", "+ 40: 534833116,", "+ 41: 763737161,", "+ 42: 785892908,", "+ 43: 123883652,", "+ 44: 639213333,", "+ 45: 181836645,", "+ 46: 998121103,", "+ 47: 124885216,", "+ 48: 501575626,", "+ 49: 39816123,", "+ 50: 113468411,", "+ 51: 799008836,", "+ 52: 775465589,", "+ 53: 256852905,", "+ 54: 664630886,", "+ 55: 971550783,", "+ 56: 751629411,", "+ 57: 51018086,", "+ 58: 702530485,", "+ 59: 725438992,", "+ 60: 696683714,", "+ 61: 792638194,", "+ 62: 221791721,", "+ 63: 149602322,", "+ 64: 414054379,", "+ 65: 986519078,", "+ 66: 981760191,", "+ 67: 305799096,", "+ 68: 515140586,", "+ 69: 406959393,", "+ 70: 975058685,", "+ 71: 245601370,", "+ 72: 324759692,", "+ 73: 673385295,", "+ 74: 191483611,", "+ 75: 570246669,", "+ 76: 427196161,", "+ 77: 781042769,", "+ 78: 569725155,", "+ 79: 842176273,", "+ 80: 25328739,", "+ 81: 847501730,", "+ 82: 206282374,", "+ 83: 353770801,", "+ 84: 323137024,", "+ 85: 371653459,", "+ 86: 940737264,", "+ 87: 123820509,", "+ 88: 915711339,", "+ 89: 847205021,", "+ 90: 252858375,", "+ 91: 718889563,", "+ 92: 866398347,", "+ 93: 738390145,", "+ 94: 133009077,", "+ 95: 333099663,", "+ 96: 170591295,", "+ 97: 329869205,", "+ 98: 616680192,", "+ 99: 597534442,", "+ 100: 388130742,", "+}", "+print((dict[n]))" ]

[ "s759242843", "s776229921" ]

[ "- if l[a] != l[b] and l[b] != l[c] and l[c] != l[a]:", "+ if l[a] != l[b] and l[b] != l[c] and l[a] != l[c]:" ]

[ "s892005895", "s406171060" ]

[ "- if S[mid] == i:", "+ if A[mid] == key:", "- elif i < S[mid]:", "+ elif key < A[mid]:" ]

[ "s597131514", "s496070384" ]

[ "+import sys", "+", "+input = sys.stdin.readline" ]

[ "s584508610", "s193169199" ]

[ "+A.insert(0, 0)", "+A.append(0)", "-for i in range(1, N):", "- D += abs(A[i] - A[i - 1])", "-D += abs(A[0] - 0)", "-D += abs(A[N - 1] - 0)", "-ans = []", "-for i in range(N):", "- if i == 0:", "- a = abs(A[i + 1] - A[i]) + abs(A[i] - 0)", "- b = abs(A[i + 1] - 0)", "- elif i == N - 1:", "- a = abs(0 - A[i]) + abs(A[i] - A[i - 1])", "- b = abs(0 - A[i - 1])", "- else:", "- a = abs(A[i + 1] - A[i]) + abs(A[i] - A[i - 1])", "- b = abs(A[i + 1] - A[i - 1])", "- ans.append(D - a + b)", "-for x in ans:", "- print(x)", "+for i in range(N + 1):", "+ D += abs(A[i + 1] - A[i])", "+for i in range(1, N + 1):", "+ dist = D - (abs(A[i - 1] - A[i]) + abs(A[i] - A[i + 1])) + abs(A[i - 1] - A[i + 1])", "+ print(dist)" ]

[ "s183558933", "s807396513" ]

[ "-x = int(input())", "-LIST2 = [1]", "-LIST2X = [-2]", "-N = 1", "-for i in range(1, 30):", "- N = N + 4**i", "- LIST2.append(N)", "-N = -2", "-for i in range(1, 30):", "- N = N - 2 * 4**i", "- LIST2X.append(N)", "-LIST = [0] * 60", "-", "-", "-def nex(N):", "- if N > 0:", "- for i in range(30):", "- if N <= LIST2[i]:", "- break", "- LIST[i * 2] += 1", "- return N - (-2) ** (i * 2)", "- if N < 0:", "- for i in range(30):", "- if N >= LIST2X[i]:", "- break", "- LIST[i * 2 + 1] += 1", "- return N - (-2) ** (i * 2 + 1)", "-", "-", "-while x != 0:", "- x = nex(x)", "- # print(x)", "-for i in range(59, -1, -1):", "- if LIST[i] == 1:", "- break", "-for j in range(i, -1, -1):", "- print(LIST[j], end=\"\")", "+N = int(eval(input()))", "+if N == 0:", "+ print((0))", "+s = \"\"", "+while N:", "+ if N % 2 == 1:", "+ s = \"1\" + s", "+ N -= 1", "+ else:", "+ s = \"0\" + s", "+ N = -N // 2", "+print(s)" ]

[ "s260778276", "s346885265" ]

[ "-N = int(eval(input()))", "-a = list(map(int, input().split()))", "-dp = [0] + [10**10] * N", "-for i, h in enumerate(a):", "- for j in range(i + 1, min(i + 3, N)):", "- dp[j] = min(dp[j], dp[i] + abs(h - a[j]))", "- # print(dp)", "-print((dp[N - 1]))", "+n = int(eval(input()))", "+dp = [0] + [float(\"INF\")] * (n)", "+h = list(map(int, input().split()))", "+for i in range(n):", "+ dp[i] = min(", "+ dp[i], dp[i - 2] + abs(h[i] - h[i - 2]), dp[i - 1] + abs(h[i] - h[i - 1])", "+ )", "+print((dp[n - 1]))" ]

[ "s148305259", "s876305741" ]

[ "-a = [int(s) - 1 for s in input().split()]", "+t = 1", "-for i in range(N):", "- if a[i] != (i - result):", "+for a in map(int, input().split()):", "+ if a == t:", "+ t += 1", "+ else:" ]

[ "s522204363", "s637315102" ]

[ "+import heapq", "+", "-ABC = []", "-for xi in range(X):", "- if xi + 1 > K:", "- break", "- for yi in range(Y):", "- if (xi + 1) * (yi + 1) > K:", "- break", "- for zi in range(Z):", "- if (xi + 1) * (yi + 1) * (zi + 1) > K:", "- break", "- ABC.append(A[xi] + B[yi] + C[zi])", "-ABC.sort(reverse=True)", "-for i in range(K):", "- print((ABC[i]))", "+q = [(-(A[0] + B[0] + C[0]), 0, 0, 0)]", "+s = set()", "+for n in range(K):", "+ p, a, b, c = heapq.heappop(q)", "+ print((-p))", "+ if a + 1 < X and ((a + 1, b, c) not in s):", "+ s.add((a + 1, b, c))", "+ heapq.heappush(q, (-(A[a + 1] + B[b] + C[c]), a + 1, b, c))", "+ if b + 1 < Y and ((a, b + 1, c) not in s):", "+ s.add((a, b + 1, c))", "+ heapq.heappush(q, (-(A[a] + B[b + 1] + C[c]), a, b + 1, c))", "+ if c + 1 < Z and ((a, b, c + 1) not in s):", "+ s.add((a, b, c + 1))", "+ heapq.heappush(q, (-(A[a] + B[b] + C[c + 1]), a, b, c + 1))" ]

[ "s862523527", "s836403731" ]

[ "-V = [int(i) for i in input().split()]", "-E, O = [], []", "-E_cnt2, O_cnt2 = 0, 0", "-for i in range(n):", "- if i % 2:", "- E.append(V[i])", "+v = [int(i) for i in input().split()]", "+kisu = []", "+gusu = []", "+kisu = v[::2]", "+gusu = v[1::2]", "+kisu_cnt = collections.Counter(kisu)", "+gusu_cnt = collections.Counter(gusu)", "+kisu_cnt = kisu_cnt.most_common(2) # 引数にnを用意すると，出現回数の多い順にn子だけ呼び出せる", "+gusu_cnt = gusu_cnt.most_common(2)", "+kisu_most = 0", "+gusu_most = 0", "+if kisu_cnt[0][0] != gusu_cnt[0][0]:", "+ print((n - kisu_cnt[0][1] - gusu_cnt[0][1]))", "+ exit()", "+else:", "+ if len(kisu_cnt) == 1 or len(gusu_cnt) == 1:", "+ print((n // 2))", "+ exit()", "- O.append(V[i])", "-e = collections.Counter(E)", "-tmp = e.most_common()", "-E_mode, E_cnt = tmp[0][0], tmp[0][1]", "-if len(tmp) >= 2:", "- E_cnt2 = tmp[1][1]", "-o = collections.Counter(O)", "-tmp = o.most_common()", "-O_mode, O_cnt = tmp[0][0], tmp[0][1]", "-if len(tmp) >= 2:", "- O_cnt2 = tmp[1][1]", "-if E_mode != O_mode:", "- print((len(E) - E_cnt + len(O) - O_cnt))", "-else:", "- print((min((len(E) - E_cnt + len(O) - O_cnt2), len(E) - E_cnt2 + len(O) - O_cnt)))", "+ print(", "+ (n - max(kisu_cnt[0][1] + gusu_cnt[1][1], kisu_cnt[1][1] + gusu_cnt[0][1]))", "+ )" ]

[ "s515221895", "s179242213" ]

[ "-for t in range(n):", "- cnt = 0", "- for i in range(n):", "- a = 1", "- if i > t:", "- a = -1", "- cnt += a * w[i]", "- ans = min(ans, abs(cnt))", "+now = sum(w)", "+for i in range(n):", "+ now -= 2 * w[i]", "+ ans = min(ans, abs(now))" ]

[ "s413649475", "s830588196" ]

[ "-import math", "+#!/usr/bin/env python3", "+import sys", "-n = int(eval(input()))", "-a = list(map(int, input().split()))", "-maxlog = int(math.log2(max(a)))", "-answer = 0", "-for _ in range(maxlog):", "- a = [aa / 2 for aa in a if aa % 2 == 0]", "- answer += len(a)", "- if not a:", "- break", "-print(answer)", "+", "+def solve(N: int, a: \"List[int]\"):", "+ answer = 0", "+ for i in range(N):", "+ while a[i] % 2 == 0:", "+ answer += 1", "+ a[i] //= 2", "+ print(answer)", "+ return", "+", "+", "+def main():", "+ def iterate_tokens():", "+ for line in sys.stdin:", "+ for word in line.split():", "+ yield word", "+", "+ tokens = iterate_tokens()", "+ N = int(next(tokens)) # type: int", "+ a = [int(next(tokens)) for _ in range(N)] # type: \"List[int]\"", "+ solve(N, a)", "+", "+", "+if __name__ == \"__main__\":", "+ main()" ]

[ "s677096233", "s395855875" ]

[ "-prime_flag_list[0] = prime_flag_list[1] = False", "+prime_flag_list[0] = False", "+prime_flag_list[1] = False" ]

[ "s065052510", "s276124209" ]

[ "-b = [-1] * n", "+b = bisect", "+c = [-1] * n", "- b[bisect(b, a - 1) - 1] = a", "-print((n - b.count(-1)))", "+ c[b(c, a - 1) - 1] = a", "+print((n - b(c, -1)))" ]

[ "s557785138", "s180237993" ]

[ "+import random", "+random.shuffle(A)", "- for p, n in fast_factorization(a).items():", "- if cnt[p] != 0:", "- flg = 0", "- cnt[p] += n", "+ if flg:", "+ for p, n in fast_factorization(a).items():", "+ if cnt[p] != 0:", "+ flg = 0", "+ cnt[p] += n" ]

[ "s755148356", "s667619941" ]

[ "-N, K = list(map(int, input().split()))", "+n, k = list(map(int, input().split()))", "-for i in range(1, N + 1):", "- tmp = 1 / N", "+for i in range(1, n + 1):", "- while i < K:", "- i *= 2", "+ while i * (2**cnt) < k:", "- tmp *= (0.5) ** cnt", "+ tmp = (1 / n) * (0.5**cnt)" ]

[ "s381791962", "s443168801" ]

[ "-import sys", "-input = sys.stdin.readline", "-", "-", "-def solve():", "- H, W = list(map(int, input().split()))", "- Ch, Cw = list(map(int, input().split()))", "- Dh, Dw = list(map(int, input().split()))", "- l = [[1 if i == \"#\" else 0 for i in eval(input())] for _ in range(H)]", "- q = deque([(0, (Ch - 1, Cw - 1))])", "- INF = 10**12", "- costs = [[INF] * W for _ in range(H)]", "- costs[Ch - 1][Cw - 1] = 0", "- while q:", "- cost, pos = q.popleft()", "- h, w = pos", "- for dh in range(-2, 3):", "- for dw in range(-2, 3):", "- if dh == 0 and dw == 0:", "- continue", "- hh, ww = h + dh, w + dw", "- if not (0 <= hh < H and 0 <= ww < W):", "- continue", "- if l[hh][ww]:", "- continue", "- if ((abs(dh) == 1 and dw == 0) or (dh == 0 and abs(dw) == 1)) and costs[", "- hh", "- ][ww] > costs[h][w]:", "- costs[hh][ww] = costs[h][w]", "- q.appendleft((cost, (hh, ww)))", "- elif costs[hh][ww] > costs[h][w] + 1:", "- costs[hh][ww] = costs[h][w] + 1", "- q.append((cost + 1, (hh, ww)))", "- ans = costs[Dh - 1][Dw - 1]", "- print((ans if ans != INF else -1))", "-", "-", "-solve()", "+H, W = list(map(int, input().split()))", "+Ch, Cw = list(map(int, input().split()))", "+Dh, Dw = list(map(int, input().split()))", "+l = [[1 if i == \"#\" else 0 for i in eval(input())] for _ in range(H)]", "+q = deque([(0, (Ch - 1, Cw - 1))])", "+INF = 10**12", "+costs = [[INF] * W for _ in range(H)]", "+costs[Ch - 1][Cw - 1] = 0", "+while q:", "+ cost, pos = q.popleft()", "+ h, w = pos", "+ for dh in range(-2, 3):", "+ for dw in range(-2, 3):", "+ if dh == 0 and dw == 0:", "+ continue", "+ hh, ww = h + dh, w + dw", "+ if not (0 <= hh < H and 0 <= ww < W):", "+ continue", "+ if l[hh][ww]:", "+ continue", "+ if ((abs(dh) == 1 and dw == 0) or (dh == 0 and abs(dw) == 1)) and costs[hh][", "+ ww", "+ ] > costs[h][w]:", "+ costs[hh][ww] = costs[h][w]", "+ q.appendleft((cost, (hh, ww)))", "+ elif costs[hh][ww] > costs[h][w] + 1:", "+ costs[hh][ww] = costs[h][w] + 1", "+ q.append((cost + 1, (hh, ww)))", "+ans = costs[Dh - 1][Dw - 1]", "+print((ans if ans != INF else -1))" ]

[ "s296718503", "s471311948" ]

[ "-ans = 0", "- pass", "+ continue" ]

[ "s509306552", "s457451417" ]

[ "-s = list(eval(input()))", "-if \"A\" not in s or \"B\" not in s:", "+s = eval(input())", "+if s[0] != s[1] or s[1] != s[2]:", "+ print(\"Yes\")", "+else:", "-else:", "- print(\"Yes\")" ]

[ "s930542870", "s757569326" ]

[ "-while 4:", "- n = int(eval(input()))", "- if n == 0:", "+from sys import stdin", "+", "+for i in stdin:", "+ if i == \"0\\n\":", "- print((oct(n)[2:].translate(str.maketrans(\"4567\", \"5789\"))))", "+ print((oct(int(i))[2:].translate(str.maketrans(\"4567\", \"5789\"))))" ]

[ "s061195750", "s256567778" ]

[ "- v = str(v)", "- v0 = int(v[-1])", "+ v0 = v % 10", "- cands += [int(v + \"0\"), int(v + \"1\")]", "+ cands += [v * 10, v * 10 + 1]", "- cands += [int(v + \"8\"), int(v + \"9\")]", "+ cands += [v * 10 + 8, v * 10 + 9]", "- cands += [int(v + str(v0 - 1)), int(v + str(v0)), int(v + str(v0 + 1))]", "+ cands += [v * 10 + v0 - 1, v * 10 + v0, v * 10 + v0 + 1]" ]

[ "s471773280", "s750139843" ]

[ "- T = T.translate(str.maketrans(\"rsp\", \"012\"))", "- T = list(map(int, T))", "+ T = list(map(int, T.translate(str.maketrans(\"rsp\", \"012\"))))", "+ hand = [0] * N", "- for i in range(K):", "- vec = T[i::K]", "- M = len(vec)", "- dp = [[0] * 3 for _ in range(M + 1)]", "- for j in range(M):", "- for k in range(3):", "- dp[j + 1][k] = max(dp[j][(k + 1) % 3], dp[j][(k + 2) % 3])", "- if (k + 1) % 3 == vec[j]:", "- dp[j + 1][k] += point[k]", "- ans += max(dp[M])", "+ for i, h in enumerate(T):", "+ win = (h - 1) % 3", "+ if i >= K and win == hand[i - K]:", "+ hand[i] = -1", "+ else:", "+ hand[i] = win", "+ ans += point[win]" ]

[ "s140431552", "s449532912" ]

[ "-print((\"YNEOS\"[sum(map(int, open(0).read().split())) != 15 :: 2]))", "+print((\"NYOE S\"[sum(map(int, open(0).read().split())) % 2 :: 2]))" ]

[ "s001303554", "s112915209" ]

[ "+import sys", "+", "+input = sys.stdin.readline", "+ri = lambda: int(eval(input()))", "+rs = lambda: input().rstrip()", "+ril = lambda: list(map(int, input().split()))", "+rsl = lambda: input().rstrip().split()", "+ris = lambda n: [ri() for _ in range(n)]", "+rss = lambda n: [rs() for _ in range(n)]", "+rils = lambda n: [ril() for _ in range(n)]", "+rsls = lambda n: [rsl() for _ in range(n)]", "+", "+", "- self.parents = list(range(n + 1))", "- self.ranks = [0 for _ in range(n + 1)]", "+ self.parents = list(range(n))", "+ self.ranks = [0 for _ in range(n)]", "-n, m = list(map(int, input().split()))", "+n, m = ril()", "- x, y, z = list(map(int, input().split()))", "+ x, y, z = ril()" ]

[ "s683070897", "s235932698" ]

[ "-from fractions import gcd", "+from math import gcd", "+", "+", "+def count_indivs(N):", "+ return N - (N // C + N // D - N // L)", "+", "-LCM = C * D // gcd(C, D)", "-print(", "- (", "- B", "- - A", "- + 1", "- - B // C", "- + (A - 1) // C", "- - B // D", "- + (A - 1) // D", "- + B // LCM", "- - (A - 1) // LCM", "- )", "-)", "+L = C * D // gcd(C, D)", "+print((count_indivs(B) - count_indivs(A - 1)))" ]

[ "s314280394", "s912616195" ]

[ "-S = eval(input())", "-G = groupby(S)", "-print((len(list(G)) - 1))", "+S = groupby(eval(input()))", "+cnt = sum([1 for k, v in S])", "+print((cnt - 1))" ]

[ "s654949993", "s055755394" ]

[ "-print((\"YES\" if A <= X and X <= A + B else \"NO\"))", "+print((\"YES\" if A <= X <= A + B else \"NO\"))" ]

[ "s492416803", "s192540877" ]

[ "+from scipy.sparse.csgraph import floyd_warshall", "-", "-def resolve():", "- n, m, L = list(map(int, input().split()))", "- A = [[INF] * n for _ in range(n)]", "- for _ in range(m):", "- a, b, c = list(map(int, input().split()))", "- a -= 1", "- b -= 1", "- A[a][b] = A[b][a] = c", "- from itertools import product", "-", "- for k, i, j in product(list(range(n)), repeat=3):", "- A[i][j] = min(A[i][j], A[i][k] + A[k][j])", "- B = [[INF] * n for _ in range(n)]", "- for i, j in product(list(range(n)), repeat=2):", "+n, m, L = list(map(int, input().split()))", "+A = [[INF] * n for _ in range(n)]", "+for _ in range(m):", "+ a, b, c = list(map(int, input().split()))", "+ a -= 1", "+ b -= 1", "+ A[a][b] = A[b][a] = c", "+A = floyd_warshall(A)", "+B = [[INF] * n for _ in range(n)]", "+for i in range(n):", "+ for j in range(n):", "- for k, i, j in product(list(range(n)), repeat=3):", "- B[i][j] = min(B[i][j], B[i][k] + B[k][j])", "- Q = int(eval(input()))", "- for _ in range(Q):", "- s, t = list(map(int, input().split()))", "- s -= 1", "- t -= 1", "- print((B[s][t] - 1 if (B[s][t] != INF) else -1))", "-", "-", "-resolve()", "+B = floyd_warshall(B)", "+Q = int(eval(input()))", "+for _ in range(Q):", "+ s, t = list(map(int, input().split()))", "+ s -= 1", "+ t -= 1", "+ print((int(B[s][t]) - 1 if (B[s][t] != INF) else -1))" ]

[ "s370296042", "s095950755" ]

[ "+ elif time % ls[j][2] == 0:", "+ time += ls[j][0]", "- additional_time = ls[j][2]", "- while time % additional_time != 0:", "- time += 1", "- time += ls[j][0]", "+ time += ls[j][0] + ls[j][2] - time % ls[j][2]" ]

[ "s951689167", "s847437140" ]

[ "-from heapq import heappop, heappush", "+from collections import deque", "- st = [start]", "+ st = deque([start])", "- sx = heappop(st)", "+ sx = st.popleft()", "- heappush(st, x)", "+ st.append(x)" ]

[ "s977262527", "s964709830" ]

[ "-class modint:", "- def __init__(self, value):", "- self.value = value % MOD", "+def main():", "+ N = int(eval(input()))", "+ G = [[] for _ in range(N)]", "+ for _ in range(N - 1):", "+ a, b = (int(i) for i in input().split())", "+ G[a - 1].append(b - 1)", "+ G[b - 1].append(a - 1)", "+ dp_w = [0] * N", "+ dp_b = [0] * N", "- def __int__(self):", "- return int(self.value)", "+ def dfs(s):", "+ seen = [False] * N", "+ par = [-1] * N", "+ stack = [s]", "+ seen[s] = True", "+ while stack:", "+ v = stack.pop()", "+ if v >= 0:", "+ stack.append(~v)", "+ for u in G[v]:", "+ if seen[u]:", "+ continue", "+ stack.append(u)", "+ seen[u] = True", "+ par[u] = v", "+ else:", "+ # 帰りがけ順", "+ # ~v = -v-1", "+ v = ~v", "+ w = 1", "+ b = 1", "+ for u in G[v]:", "+ if u == par[v]:", "+ continue", "+ w *= dp_w[u] + dp_b[u]", "+ b *= dp_w[u]", "+ w %= MOD", "+ b %= MOD", "+ dp_w[v] += w", "+ dp_b[v] += b", "+ dp_w[v] %= MOD", "+ dp_b[v] %= MOD", "- def __float__(self):", "- return float(self.value)", "-", "- def __str__(self):", "- return str(self.value)", "-", "- def __repr__(self):", "- return str(self.value)", "-", "- def __add__(self, other):", "- return (", "- modint(self.value + other.value)", "- if isinstance(other, modint)", "- else modint(self.value + other)", "- )", "-", "- def __sub__(self, other):", "- return (", "- modint(self.value - other.value)", "- if isinstance(other, modint)", "- else modint(self.value - other)", "- )", "-", "- def __mul__(self, other):", "- return (", "- modint(self.value * other.value)", "- if isinstance(other, modint)", "- else modint(self.value * other)", "- )", "-", "- def __truediv__(self, other):", "- return (", "- modint(self.value * pow(other.value, MOD - 2, MOD))", "- if isinstance(other, modint)", "- else modint(self.value * pow(other, MOD - 2, MOD))", "- )", "-", "- def __pow__(self, other):", "- return (", "- modint(pow(self.value, other.value, MOD))", "- if isinstance(other, modint)", "- else modint(pow(self.value, other, MOD))", "- )", "-", "- def __eq__(self, other):", "- return (", "- self.value == other.value", "- if isinstance(other, modint)", "- else self.value == (other % MOD)", "- )", "-", "- def __ne__(self, other):", "- return (", "- self.value == other.value", "- if isinstance(other, modint)", "- else self.value == (other % MOD)", "- )", "-", "- def __radd__(self, other):", "- return (", "- modint(other.value + self.value)", "- if isinstance(other, modint)", "- else modint(other + self.value)", "- )", "-", "- def __rsub__(self, other):", "- return (", "- modint(other.value - self.value)", "- if isinstance(other, modint)", "- else modint(other - self.value)", "- )", "-", "- def __rmul__(self, other):", "- return (", "- modint(other.value * self.value)", "- if isinstance(other, modint)", "- else modint(other * self.value)", "- )", "-", "- def __rtruediv__(self, other):", "- return (", "- modint(other.value * pow(self.value, MOD - 2, MOD))", "- if isinstance(other, modint)", "- else modint(other * pow(self.value, MOD - 2, MOD))", "- )", "-", "- def __rpow__(self, other):", "- return (", "- modint(pow(other.value, self.value, MOD))", "- if isinstance(other, modint)", "- else modint(pow(other, self.value, MOD))", "- )", "-", "- def modinv(self):", "- return modint(pow(self.value, MOD - 2, MOD))", "-", "-", "-def main():", "- from heapq import heappush, heappop", "- import sys", "-", "- readline = sys.stdin.buffer.readline", "- N = int(readline())", "- edge = [[] for _ in range(N)]", "- for i in range(N - 1):", "- a, b = (int(i) for i in readline().split())", "- edge[a - 1].append(b - 1)", "- edge[b - 1].append(a - 1)", "- dp = [[modint(1)] * 2 for _ in range(N)]", "- from collections import deque", "-", "- G_color = [\"WHITE\" for _ in range(N)]", "- G_distance = [float(\"inf\") for _ in range(N)]", "- G_parent = [\"NIL\" for _ in range(N)]", "-", "- def bfs(G, s):", "- leaves = []", "- G_color[s] = \"GRAY\"", "- G_distance[s] = 0", "- Q = deque()", "- Q.append(s)", "- while Q:", "- u = Q.popleft()", "- has_child = False", "- for v in G[u]:", "- if G_color[v] == \"WHITE\":", "- G_color[v] = \"GRAY\"", "- G_distance[v] = G_distance[u] + 1", "- G_parent[v] = u", "- has_child = True", "- Q.append(v)", "- G_color[u] = \"BLACK\"", "- if not (has_child):", "- heappush(leaves, (-G_distance[u], u))", "- return leaves", "-", "- leaves = bfs(edge, 0)", "- seen = [False] * N", "- while leaves:", "- _, leaf = heappop(leaves)", "- par = G_parent[leaf]", "- if par == \"NIL\":", "- continue", "- dp[par][0] *= dp[leaf][1]", "- dp[par][1] *= dp[leaf][0] + dp[leaf][1]", "- if seen[par]:", "- continue", "- heappush(leaves, (-G_distance[par], par))", "- seen[par] = True", "- print((dp[0][0] + dp[0][1]))", "+ dfs(0)", "+ print(((dp_w[0] + dp_b[0]) % MOD))" ]

[ "s606117185", "s505725653" ]

[ "-def make_divisors(n):", "- divisors = []", "- for i in range(1, int(n**0.5) + 1):", "- if n % i == 0:", "- divisors.append(i)", "- if i != n // i:", "- divisors.append(n // i)", "- return divisors", "+def prime_factorize(n):", "+ a = []", "+ while n % 2 == 0:", "+ a.append(2)", "+ n //= 2", "+ f = 3", "+ while f * f <= n:", "+ if n % f == 0:", "+ a.append(f)", "+ n //= f", "+ else:", "+ f += 2", "+ if n != 1:", "+ a.append(n)", "+ return a", "-gcd = gcd(max(A, B), min(A, B))", "-divisors = sorted(make_divisors(gcd))", "-divisors.pop(0)", "-ans = [1]", "-while divisors:", "- i = divisors.pop(0)", "- for j in range(len(divisors) - 1, -1, -1):", "- if divisors[j] % i == 0:", "- divisors.pop(j)", "- ans.append(i)", "-print((len(ans)))", "+gcd = gcd(A, B)", "+p = set(prime_factorize(gcd))", "+print((len(p) + 1))" ]

[ "s377038638", "s212699565" ]

[ "-def new_color(s, i, rgb):", "- for color in rgb:", "- if color != s[i] and color != s[i + 1]:", "- break", "+def new_color(s, i, color):", "+ rgb = \"rgb\"", "+ another = {", "+ (\"r\", \"g\"): \"b\",", "+ (\"g\", \"r\"): \"b\",", "+ (\"r\", \"b\"): \"g\",", "+ (\"b\", \"r\"): \"g\",", "+ (\"g\", \"b\"): \"r\",", "+ (\"b\", \"g\"): \"r\",", "+ }", "- rgb = \"rgb\"", "- new = new_color(colors, i - 1, rgb)", "+ new = new_color(colors, i - 1, another[(ci, temp)])" ]

[ "s805703709", "s682218195" ]

[ "+from math import sqrt", "+", "-ab = a + b", "-for i in range(int(a + b)):", "- if int(a + b) == i**2:", "- print(\"Yes\")", "- exit()", "-print(\"No\")", "+ab = int(a + b)", "+print(([\"No\", \"Yes\"][int(sqrt(ab)) ** 2 == ab]))" ]

[ "s507781684", "s094425109" ]

[ "+def input():", "+ return sys.stdin.readline().rstrip()", "+", "+", "+def rand_N(ran1, ran2):", "+ return random.randint(ran1, ran2)", "+", "+", "+def rand_List(ran1, ran2, rantime):", "+ return [random.randint(ran1, ran2) for i in range(rantime)]", "+", "+", "+def rand_ints_nodup(ran1, ran2, rantime):", "+ ns = []", "+ while len(ns) < rantime:", "+ n = random.randint(ran1, ran2)", "+ if not n in ns:", "+ ns.append(n)", "+ return sorted(ns)", "+", "+", "+def rand_query(ran1, ran2, rantime):", "+ r_query = []", "+ while len(r_query) < rantime:", "+ n_q = rand_ints_nodup(ran1, ran2, 2)", "+ if not n_q in r_query:", "+ r_query.append(n_q)", "+ return sorted(r_query)", "+", "+", "+from decimal import *", "+from fractions import gcd", "+import random", "+import string", "+from itertools import combinations, permutations, product", "+from operator import mul", "+from functools import reduce", "+mod = 10**9 + 7", "+#############", "+# Main Code #", "+#############", "-nums = [int(e) for e in input().split()]", "-nums.sort()", "-checker = nums[0]", "-count = 1", "-for i in range(1, N):", "- if checker != nums[i]:", "- count += 1", "- checker = nums[i]", "-if (N - count) % 2 == 0:", "- print(count)", "+A = getList()", "+A = Counter(A)", "+one = 0", "+two = 0", "+for i in list(A.items()):", "+ a, b = i", "+ if b % 2 == 0:", "+ two += 1", "+ else:", "+ one += 1", "+ans = 0", "+if two % 2 == 0:", "+ print((one + two))", "- print((count - 1))", "+ print((one + two - 1))" ]

[ "s013179665", "s588082930" ]

[ "-n = int(input())", "+n = int(eval(input()))", "-a = np.array(a)", "-for x in b:", "- print(x + 1, end=\" \")", "-print()", "+print((*(b + 1)))" ]

[ "s693742725", "s558592022" ]

[ "-TOWNS = list(map(int, input().split()))", "-dists = [TOWNS[i + 1] - TOWNS[i] for i in range(N - 1)]", "-sum = 0", "-for dist in dists:", "- sum += min(dist * A, B)", "-print(sum)", "+X = list(map(int, input().split()))", "+ans = 0", "+now = X[0]", "+for x in X[1:]:", "+ d = x - now", "+ if d * A < B:", "+ ans += d * A", "+ else:", "+ ans += B", "+ now = x", "+print(ans)" ]

[ "s733099448", "s226387470" ]

[ "- for e in self._graph[cur_vertex][", "- self._iter[cur_vertex] : len(self._graph[cur_vertex])", "- ]:", "+ while self._iter[cur_vertex] < len(self._graph[cur_vertex]):", "+ e = self._graph[cur_vertex][self._iter[cur_vertex]]", "+ self._iter[cur_vertex] += 1" ]

[ "s330088455", "s461384434" ]

[ "-n = eval(input())", "-print((\"YNeos\"[\"7\" not in n :: 2]))", "+print((\"YNeos\"[\"7\" not in eval(input()) :: 2]))" ]

[ "s871987556", "s232111472" ]

[ "-ans = [1 for x in r(k + 1) for y in r(k + 1) if x + y <= s and s - x - y <= k]", "-print((sum(ans)))", "+print((sum(1 for x in r(k + 1) for y in r(k + 1) if x + y <= s and s - x - y <= k)))" ]

[ "s253872537", "s008964064" ]

[ "- # e = math.gcd(a,b)", "- e = fractions.gcd(a, b)", "+ e = math.gcd(a, b)", "+ # e = fractions.gcd(a,b)", "- # d = math.gcd(e,c)", "- d = fractions.gcd(e, c)", "+ d = math.gcd(e, c)", "+ # d = fractions.gcd(e,c)" ]

[ "s469996599", "s488326146" ]

[ "-a = [1, n]", "+# (1,1)から一番長く移動しないといけないのは(1,n)の時", "+ans = n - 1", "- j = n // i", "- if n % i == 0 and a[0] + a[1] > i + j:", "- a = [i, j]", "-print((a[0] - 1 + a[1] - 1))", "+ if n % i == 0:", "+ ans = min(ans, i + int(n / i) - 2)", "+print(ans)" ]

[ "s668422704", "s289799104" ]

[ "-from statistics import median", "-", "+# from statistics import median", "-from fractions import gcd", "-from itertools import combinations # (string,3) 3回", "-from collections import deque", "+# from fractions import gcd", "+# from itertools import combinations # (string,3) 3回", "+# from collections import deque", "-import bisect", "+# import bisect", "-ma = A[-1]", "-mi = A[0]", "-for i in range(n - 1):", "- if abs(A[i] - ma / 2) <= abs(mi - ma / 2):", "- mi = A[i]", "-print((ma, mi))", "+MAX = A[-1]", "+MIN = A[0]", "+for i in range(1, n - 1):", "+ if abs(MAX / 2 - A[i]) <= abs(MAX / 2 - MIN):", "+ MIN = A[i]", "+print((MAX, MIN))" ]

[ "s033426817", "s786421819" ]

[ "+import numba as nb", "+import numpy as np", "-def main():", "- N, K = list(map(int, input().split()))", "- h = list(map(int, input().split()))", "[email protected]", "+def solve(N, K, h):", "- ans = dp[-1]", "+ return dp[-1]", "+", "+", "+def main():", "+ N, K = list(map(int, input().split()))", "+ h = np.array(input().split(), dtype=np.int64)", "+ ans = solve(N, K, h)" ]

[ "s506182287", "s053525925" ]

[ "-p = [-1] * -~n", "-f = [[] for _ in p]", "+p, f = [-1] * -~n, [-1] * -~n", "- f[a] += (b,)", "- f[b] += (a,)", "-a = [~len(f[i]) - p[r(i)] for i in range(n + 1)]", "+ f[a] -= 1", "+ f[b] -= 1", "+a = [f[i] - p[r(i)] for i in range(n + 1)]" ]

[ "s554606517", "s355518725" ]

[ "-b = 0", "-print((sum((b := max(c := int(a), b)) - c for a in [*open(0)][1].split())))", "+b = s = 0", "+for a in [*open(0)][1].split():", "+ a = int(a)", "+ b = max(b, a)", "+ s += b - a", "+print(s)" ]

[ "s878821937", "s320955947" ]

[ "+from collections import defaultdict", "+", "-cnt = [0] * 26", "-for i in range(N):", "- cnt[ord(S[i]) - ord(\"a\")] += 1", "+count_dict = defaultdict(int)", "+for s in S:", "+ count_dict[s] += 1", "-for i in range(26):", "- ans *= cnt[i] + 1", "+for v in list(count_dict.values()):", "+ ans *= v + 1" ]

[ "s597947504", "s557313951" ]

[ "- indices[c].add(i)", "+ indices[c].add(2 * i)", "- (i + j) % 2 == 0 and (i + j) // 2 in indices[c3]", "- for i in indices[c1]", "- for j in indices[c2]", "+ (i + j) // 2 in indices[c3] for i in indices[c1] for j in indices[c2]" ]

[ "s381605928", "s490219458" ]

[ "-r, g, b, n = list(map(int, input().split()))", "-s_rgb = sorted([r, g, b], reverse=True)", "-count = 0", "-for i in range(int(n / s_rgb[0]) + 1)[::-1]:", "- for j in range(int((n - s_rgb[0] * i) / s_rgb[1]) + 1)[::-1]:", "- tmp = n - s_rgb[0] * i - s_rgb[1] * j", "- if tmp >= 0 and tmp % s_rgb[2] == 0:", "- count += 1", "-print(count)", "+R, G, B, N = [int(i) for i in input().split()]", "+dp = [0] * (N + 1)", "+dp[0] = 1", "+for c in (R, G, B):", "+ for i in range(N + 1 - c):", "+ dp[i + c] += dp[i]", "+print((dp[N]))" ]

[ "s639798432", "s596642034" ]

[ "-import numpy as np", "-", "-j = b.index(min(b))", "-print((m, a[j]))", "+print((m, a[b.index(min(b))]))" ]

[ "s208912944", "s849333054" ]

[ "-A, B, C, X = [int(eval(input())) for _ in range(4)]", "-m = 0", "-for a in range(A + 1):", "- for b in range(B + 1):", "- for c in range(C + 1):", "- if (500 * a) + (100 * b) + (50 * c) == X:", "- m += 1", "-print(m)", "+Li = [int(eval(input())) for _ in range(4)]", "+a, b, c, x = Li[0], Li[1], Li[2], Li[3]", "+ans = 0", "+for i in range(min(x // 500, a) + 1):", "+ for j in range(min((x - 500 * i) // 100, b) + 1):", "+ ans += 1 if (x - 500 * i - 100 * j) // 50 <= c else 0", "+print(ans)" ]

[ "s109432358", "s761956735" ]

[ "+# Here your code !", "+import sys", "+from collections import deque", "+", "+", "- sum_process_time = 0", "- sum_process_time += in_time[0]", "- if sum_process_time > self.quantum:", "- remain_time = sum_process_time - self.quantum", "+ if in_time[0] > self.quantum:", "+ remain_time = in_time[0] - self.quantum", "- sum_process_time = self.quantum", "- in_process.pop(0)", "- in_time.pop(0)", "+ in_process.popleft()", "+ in_time.popleft()", "-processes = []", "-times = []", "+processes = deque()", "+times = deque()" ]

[ "s756346637", "s504438887" ]

[ "-dp = [[int(0) for i in range(W + 1)] for i in range(N + 1)]", "+dp = [[0] * (W + 1) for _ in range(N + 1)]" ]

[ "s697946168", "s899488055" ]

[ "- for y in range(k + 1):", "+ for y in range(min(k + 1, s + 1 - x)):" ]

[ "s033686793", "s928348748" ]

[ "-rs = s[::-1]", "-inds = 0", "-indrs = 0", "-for i in range(len(s)):", "- if s[i] == \"A\":", "- inds = i", "- break", "-for j in range(len(rs)):", "- if rs[j] == \"Z\":", "- indrs = j", "- break", "-indrs = len(s) - indrs", "-print((abs(indrs - inds)))", "+left = s.find(\"A\")", "+right = s.rfind(\"Z\")", "+print((right - left + 1))" ]

[ "s204492397", "s672199772" ]

[ "-# スライド最小値を計算", "-slide_min = deque([])", "-MIN = []", "-for k in range(N):", "- while slide_min and P[slide_min[-1]] >= P[k]:", "- slide_min.pop()", "- slide_min.append(k)", "- if k < K - 1:", "- continue", "- if slide_min[0] + K <= k:", "- slide_min.popleft()", "- MIN.append(P[slide_min[0]])", "-# スライド最大値を計算", "-slide_max = deque([])", "-MAX = []", "-for k in range(N):", "- while slide_max and P[slide_max[-1]] <= P[k]:", "- slide_max.pop()", "- slide_max.append(k)", "- if k < K - 1:", "- continue", "- if slide_max[0] + K <= k:", "- slide_max.popleft()", "- MAX.append(P[slide_max[0]])", "+", "+", "+def slide_min(A, K):", "+ deq, ret = deque([]), []", "+ for k in range(len(A)):", "+ while deq and A[deq[-1]] >= A[k]:", "+ deq.pop()", "+ deq.append(k)", "+ if k < K - 1:", "+ continue", "+ if deq[0] + K <= k:", "+ deq.popleft()", "+ ret.append(A[deq[0]])", "+ return ret", "+", "+", "+# スライド最小値・最大値を計算", "+MIN = slide_min(P, K)", "+MAX = list([-x for x in slide_min(list([-x for x in P]), K)])" ]

[ "s513921034", "s233057422" ]

[ "+import sys", "+", "-lst = [int(eval(input())) for _ in range(n)]", "+lst = [int(i) for i in sys.stdin]" ]

[ "s658852053", "s055287665" ]

[ "-f = lambda x: int(x) - 1", "-p = list(map(f, input().split()))", "-par = [j for j in range(n)]", "+p = list(map(int, input().split()))", "+par = [i for i in range(n)]", "- if x == par[x]:", "- return x", "+ if par[x] == x:", "+ return par[x]", "-def union(a, b):", "- ra = find(a)", "- rb = find(b)", "- if ra != rb:", "- par[ra] = par[rb]", "+def union(x, y):", "+ fx = find(x)", "+ fy = find(y)", "+ if fx != fy:", "+ par[fx] = fy", "-for i in range(m):", "- v, w = list(map(f, input().split()))", "- union(v, w)", "+f = lambda x: int(x) - 1", "+for mm in range(m):", "+ x, y = list(map(f, input().split()))", "+ union(x, y)", "-for j in range(n):", "- if find(j) == find(p[j]):", "+for i in range(n):", "+ if find(p[i] - 1) == find(i):" ]

[ "s577432993", "s110394275" ]

[ "-# 左に<がいくつ連続しているか", "-dai = [None] * N", "-dai[0] = 0", "+A = [0] * N", "- dai[i + 1] = c", "-# 右に>がいくつ連続しているかを実装を簡単にするためにSをひっくり返して調べる", "-S = S[::-1]", "-sho = [None] * N", "-sho[0] = 0 #", "+ A[i + 1] = c", "-for i, si in enumerate(S):", "- if si == \">\":", "+for i in range(len(S) - 1, -1, -1):", "+ if S[i] == \">\":", "- sho[i + 1] = c", "-sho = sho[::-1] # 元に戻す", "-# print(dai)", "-# print(sho)", "-a = [None] * (N)", "-for i in range(N):", "- a[i] = max(dai[i], sho[i])", "-# print(a)", "-ans = sum(a)", "-print(ans)", "+ A[i] = max(A[i], c)", "+# print(A)", "+print((sum(A)))" ]

[ "s512334538", "s215428434" ]

[ "-a, b, c = list(map(int, input().split()))", "+l = list(map(int, input().split()))", "-print((a + b + c - max(a, b, c) + max(a, b, c) * (2**k)))", "+L = l.sort()", "+print((int(l[0]) + int(l[1]) + int(l[2]) * (2**k)))" ]

[ "s853070437", "s259281427" ]

[ "-memo = [[[-1] * 201 for j in range(201)] for i in range(201)]", "-", "-", "- if memo[a][b][c] == -1:", "- if dup == 1:", "- ans = gcd([gcd([a, b]), c])", "- elif dup == 2:", "- ans = gcd([gcd([a, b]), c]) * 3", "- else:", "- ans = gcd([gcd([a, b]), c]) * 6", "- memo[a][b][c] = ans", "- gcd_sum += memo[a][b][c]", "+ if dup == 1:", "+ gcd_sum += gcd([gcd([a, b]), c])", "+ elif dup == 2:", "+ gcd_sum += gcd([gcd([a, b]), c]) * 3", "+ else:", "+ gcd_sum += gcd([gcd([a, b]), c]) * 6" ]

[ "s974760543", "s228118435" ]

[ "- for i in range(l, r):", "- for j in range(i + 1, r + 1):", "+ for i in range(l % 2019, r % 2019):", "+ for j in range(i + 1, r % 2019 + 1):" ]

[ "s037251882", "s877528230" ]

[ "-a = int(eval(input()))", "-b = int(eval(input()))", "-c = int(eval(input()))", "-d = int(eval(input()))", "-e = int(eval(input()))", "-li = [a, b, c, d, e]", "-for i in range(len(li)):", "- if li[i] % 10 != 0:", "- if li[i] % 10 == min([x % 10 if x % 10 != 0 else 10 for x in li]):", "- N = i + 0", "- break", "-else:", "- N = 0", "-for j in range(len(li)):", "- if j == N:", "- continue", "- elif li[j] % 10 != 0:", "- li[j] += 10 - li[j] % 10", "-print((sum(li)))", "+a = [int(eval(input())) for _ in range(5)]", "+m = 0 # 1の位が0以外で一番小さいもの(10との差が一番大きいもの)", "+sum_a = 0 # 10倍数にしたものの合計", "+for x in a:", "+ if x % 10 != 0:", "+ t = 10 - x % 10 # 10倍数との差", "+ else:", "+ t = 0", "+ sum_a += x + t", "+ m = max(m, t)", "+print((sum_a - m))" ]

[ "s018138464", "s196857737" ]

[ "-if B <= A + 2 or K <= A - 1:", "- ans = 1 + K", "+if B - A <= 2:", "+ print((1 + K))", "- cnt = A - 1", "- ans = A", "- while cnt <= K:", "- k = min(ans // A, (K - cnt) // 2)", "- if k >= 1:", "- cnt += 2 * k", "- ans = ans - k * A + k * B", "+ if K <= A - 1:", "+ print((1 + K))", "+ else:", "+ d = K - (A - 1)", "+ if d == 1:", "+ print((A + 1))", "+ elif d % 2 == 0:", "+ print((B + ((d - 2) // 2) * (B - A)))", "- ans += K - cnt", "- break", "-print(ans)", "+ print((B + ((d - 3) // 2) * (B - A) + 1))" ]

[ "s813205160", "s687352334" ]

[ "-n = int(eval(input()))", "+_ = eval(input())", "-dmax = 0", "-for i in range(n - 1):", "- for j in range(i + 1, n):", "- dmax = max(dmax, abs(A[i] - A[j]))", "-print(dmax)", "+print((abs(max(A) - min(A))))" ]

[ "s836613091", "s223306796" ]

[ "-# 2019/08/27", "+# 写経", "-ln = len(str(n))", "-sft = \"7530\"", "-cnt = 0", "-def dfs(ln, s):", "- global cnt", "- if ln == 0:", "- if \"7\" in s and \"5\" in s and \"3\" in s:", "- if \"0\" in str(int(s)):", "- return", "- if n >= int(s):", "- cnt += 1", "- return", "- for e in sft:", "- dfs(ln - 1, s + e)", "+def dfs(s):", "+ if int(s) > n:", "+ return 0", "+ ret = 1 if all(s.count(c) > 0 for c in \"753\") else 0", "+ for c in \"753\":", "+ ret += dfs(s + c)", "+ return ret", "-dfs(ln, \"\")", "-print(cnt)", "+print((dfs(\"0\")))" ]

[ "s642353876", "s527159106" ]

[ "- ans = [0] * N", "- for x in range(1, 101):", "- for y in range(1, 101):", "- for z in range(1, 101):", "+ ans = [0] * (N + 1)", "+ for x in range(1, 100):", "+ for y in range(1, 100):", "+ for z in range(1, 100):", "- ans[left - 1] += 1", "- return ans", "+ ans[left] += 1", "+ return ans[1:]" ]

[ "s995417728", "s945301077" ]

[ "-n = int(eval(input()))", "-s = input().rstrip()", "+import itertools", "+import sys", "-", "-def rle(s):", "- import itertools", "-", "- return list([(x[0], len(list(x[1]))) for x in itertools.groupby(s)])", "-", "-", "-print((len(rle(s))))", "+input = sys.stdin.readline", "+ri = lambda: int(eval(input()))", "+rs = lambda: input().rstrip()", "+ril = lambda: list(map(int, input().split()))", "+rsl = lambda: input().rstrip().split()", "+ris = lambda n: [ri() for _ in range(n)]", "+rss = lambda n: [rs() for _ in range(n)]", "+rils = lambda n: [ril() for _ in range(n)]", "+rsls = lambda n: [rsl() for _ in range(n)]", "+n = ri()", "+s = rs()", "+print((len(list(itertools.groupby(s)))))" ]

[ "s757119048", "s618432006" ]