Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
"""
0で断絶が生じなければ、一番低い部分は共通で処理できる

Nもhも小さいので、貪欲？にやればもんだいなさそう。
0以外で連続してる部分それぞれについて、実際に水やりを行う。
伸ばすよりはhを短くする方が処理的に楽
"""




N = int(input())
H = list(map(int, input().split()))

ans = 0
l,r = 0,0
while True:
    if l > N-1 or r > N-1:
        l,r = 0,0

    while l < N H[l] == 0:
        l += 1

    if l >= N:
        break

    r = l
    while r < N and H[r] != 0:
        r += 1

    tmp = min(H[l:min(r,N)])
    for i in range(l,min(r,N)):
        H[i] -= tmp
    ans += tmp
    l = r + 1

    

print(ans)

Fixed submission:
N = int(input())
h = list(map(int, input().split()))

ans = 0
current_height = 0
for i in range(N):
  # h[i-1]までの高さにはh[i]も育っているので、その差分だけ水をやる必要がある
  # current_height は一つ手前の花の高さ
  if h[i] > current_height:
    ans += h[i] - current_height
    current_height = h[i]
  else:
    # i-1番目の花の高さのほうがi番目より高いなら、水を新たにやる必要はない（i-1に水をやるときに同時に達成できるので）
    current_height = h[i]



print(ans)

Buggy python submission (verdict: Runtime Error):
"""
0で断絶が生じなければ、一番低い部分は共通で処理できる

Nもhも小さいので、貪欲？にやればもんだいなさそう。
0以外で連続してる部分それぞれについて、実際に水やりを行う。
伸ばすよりはhを短くする方が処理的に楽
"""




N = int(input())
H = list(map(int, input().split()))

ans = 0
l,r = 0,0
while True:
    if l > N-1 or r > N-1:
        l,r = 0,0

    while H[l] == 0:
        l += 1

    if l == N:
        break
    
    r = l
    while r < N and H[r] != 0:
        r += 1

    tmp = min(H[l:min(r,N)])
    for i in range(l,min(r,N)):
        H[i] -= tmp
    ans += tmp
    l = r + 1

    if sum(H) == 0:
        break

print(ans)

Fixed submission:
N = int(input())
h = list(map(int, input().split()))

ans = 0
current_height = 0
for i in range(N):
  # h[i-1]までの高さにはh[i]も育っているので、その差分だけ水をやる必要がある
  # current_height は一つ手前の花の高さ
  if h[i] > current_height:
    ans += h[i] - current_height
    current_height = h[i]
  else:
    # i-1番目の花の高さのほうがi番目より高いなら、水を新たにやる必要はない（i-1に水をやるときに同時に達成できるので）
    current_height = h[i]



print(ans)

Buggy python submission (verdict: Runtime Error):


N = int(input())
H = list(map(int, input().split()))

ans = 0
l,r = 0,0
while True:
    if l > N-1 or r > N-1:
        l,r = 0,0

    while H[l] == 0:
        l += 1
    r = l
    while r < N and H[r] != 0:
        r += 1

    tmp = min(H[l:min(r,N)])
    for i in range(l,min(r,N)):
        H[i] -= tmp
    ans += tmp
    l = r + 1

    if sum(H) == 0:
        break

print(ans)

Fixed submission:
N = int(input())
h = list(map(int, input().split()))

ans = 0
current_height = 0
for i in range(N):
  # h[i-1]までの高さにはh[i]も育っているので、その差分だけ水をやる必要がある
  # current_height は一つ手前の花の高さ
  if h[i] > current_height:
    ans += h[i] - current_height
    current_height = h[i]
  else:
    # i-1番目の花の高さのほうがi番目より高いなら、水を新たにやる必要はない（i-1に水をやるときに同時に達成できるので）
    current_height = h[i]



print(ans)
Buggy python submission (verdict: Runtime Error):
from collections import Counter

n,k = map(int, input().split())

sushis = [[0 for _ in range(2)] for _ in range(n)]
cnt_sushi_type = {}
for i in range(n):
  t,p = map(int, input().split())
  sushis[i][0] = -p #ポイント、大きいものから取り出したいのでマイナスにして入れる
  sushis[i][1] = t #種類

cnt_types = Counter() #寿司の種類覚えておく用のdict

sushis.sort(key=lambda x:x[0])

sushi_set = []
ans = 0
for p, t in sushis[:k]:
  #大きいものからk個選んで得点を計算
  ans += -p
  cnt_types[t] += 1
  sushi_set.append([p,t]) #集合を保存
  
ans += len(cnt_types) ** 2 #ネタ数＊ネタ数を加点

##ここまで貪欲選択

#x種類選んだ時の最大値
max_types = [0] * n
max_types[len(cnt_types)] = ans
for p, t in sushis[k:]: #これまで選んでないものを選択した場合についてみていく
  if t in cnt_types:
    continue #選んでない種類のネタを選びたいので、すでに選んでるネタであれば何もせず飛ばす
  else:
    #選んだ寿司集合にある一番得点の低い寿司を、現在見ている新ネタの寿司と入れ替える
    #実際に入れ替えるとめんどくさい（計算量的にappendとかしんどい）ので、ansとcnt_typesをいじることで調整する

    while sushi_set:
      ps, ts = sushi_set.pop() #小さい順で取り出す
      if cnt_types[ts] >= 2:
        #そのネタが2個以上あるなら一個減らして新セットを作る
        tmp =  max_types[len(cnt_types)] - (-ps) + (-p) + 2*len(cnt_types) + 1
        max_types[len(cnt_types)+1] = tmp
        cnt_types[t] += 1
        cnt_types[ts] -= 1
        break #次のまだ見ぬネタを探しに行く
        
#各種類選んだ最大値から最大のものを選択で終了
print(max(max_types))

Fixed submission:
from collections import Counter

n,k = map(int, input().split())

sushis = [[0 for _ in range(2)] for _ in range(n)]
cnt_sushi_type = {}
for i in range(n):
  t,p = map(int, input().split())
  sushis[i][0] = -p #ポイント、大きいものから取り出したいのでマイナスにして入れる
  sushis[i][1] = t #種類

cnt_types = Counter() #寿司の種類覚えておく用のdict

sushis.sort(key=lambda x:x[0])

sushi_set = []
ans = 0
for p, t in sushis[:k]:
  #大きいものからk個選んで得点を計算
  ans += -p
  cnt_types[t] += 1
  sushi_set.append([p,t]) #集合を保存
  
ans += len(cnt_types) ** 2 #ネタ数＊ネタ数を加点

##ここまで貪欲選択


max_types = []
max_types.append(ans)
#max_types[len(cnt_types)] = ans
for p, t in sushis[k:]: #これまで選んでないものを選択した場合についてみていく
  if t in cnt_types:
    continue #選んでない種類のネタを選びたいので、すでに選んでるネタであれば何もせず飛ばす
  else:
    #選んだ寿司集合にある一番得点の低い寿司を、現在見ている新ネタの寿司と入れ替える
    #実際に入れ替えるとめんどくさい（計算量的にappendとかしんどい）ので、ansとcnt_typesをいじることで調整する

    while sushi_set:
      ps, ts = sushi_set.pop() #小さい順で取り出す
      if cnt_types[ts] >= 2:
        #そのネタが2個以上あるなら一個減らして新セットを作る
        tmp =  max_types[-1]- (-ps) + (-p) + 2*len(cnt_types) + 1
        max_types.append(tmp)
        cnt_types[t] += 1
        cnt_types[ts] -= 1
        break #次のまだ見ぬネタを探しに行く
        
#各種類選んだ最大値から最大のものを選択で終了
print(max(max_types))
Buggy python submission (verdict: Time Limit Exceeded):

N,K = map(int, input().split())

H = list(map(int, input().split()))
INF = float("inf")
dp = [INF] * N
dp[0] = 0
dp[1] = abs(H[0] - H[1])

for i in range(2, N):
    # １マス～Kマス先まで飛ぶ。ｊを１～Kまで動かす
    for j in range(1, K+1):
        if i-j < 0:
            break # スタートより後ろに戻る場合は飛ばす
        dp[i] = min(dp[i], dp[i-j] + abs(H[i] - H[i-j])) 

print(dp[-1])

Fixed submission:
N, K = map(int, input().split())
h = list(map(int, input().split()))
INF = float("inf")

dp = [INF] * N
dp[0] = 0
for i in range(1, N):
    for j in range(K):
        if i - j-1 < 0:
            break # スタート地点より手前になる場合は飛ばす
        dp[i] = min(dp[i], dp[i-j-1] + abs(h[i] - h[i-j-1]))

print(dp[-1])

Buggy python submission (verdict: Time Limit Exceeded):
N, K = map(int, input().split())
h = list(map(int, input().split()))
INF = float("inf")

dp = [INF] * N
dp[0] = 0
for i in range(1, N):
    for j in range(K):
        if i - j-1 < 0:
            break # スタート地点より手前になる場合は飛ばす
        dp[i] = min(dp[i], dp[i-j-1] + abs(h[i] - h[i-j-1]))

print(dp[-1])

Fixed submission:
N, K = map(int, input().split())
h = list(map(int, input().split()))
INF = float("inf")

dp = [INF] * N
dp[0] = 0
for i in range(1, N):
    for j in range(K):
        if i - j-1 < 0:
            break # スタート地点より手前になる場合は飛ばす
        dp[i] = min(dp[i], dp[i-j-1] + abs(h[i] - h[i-j-1]))

print(dp[-1])
Buggy python submission (verdict: Time Limit Exceeded):
N,W = map(int, input().split())

wv = [tuple(map(int, input().split())) for _ in range(N)]

dp = [[0 for _ in range(W+1)] for _ in range(N)]
#dp[i][j]：i番目の品物まで選べる時、重さjまで運べる時の最大価値

for i in range(N):
    for j in range(W+1):
        if j >= wv[i][0]:
            # 前者はi番目の品を選ばないとき、後者は選ぶとき
            dp[i][j] = max(dp[i-1][j], dp[i-1][j - wv[i][0]] + wv[i][1])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[-1][-1])

Fixed submission:
N, W = map(int, input().split())
wv = [tuple(map(int, input().split())) for _ in range(N)]

dp = [[0 for _ in range(W+1)] for _ in range(N)]

for i in range(N):
    for j in range(W+1):
        if j >= wv[i][0]:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-wv[i][0]] + wv[i][1])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[N-1][W])
Buggy python submission (verdict: Time Limit Exceeded):
N,W = map(int, input().split())

wv = [tuple(map(int, input().split())) for _ in range(N)]

#i番目まで選べる時に価値がｊとなる最小の重み
dp = [{} for _ in range(N+1)]
dp[0][0] = 0

for i, (w, v) in enumerate(wv):
    # i番目のアイテムまで選んで作れる価値とその時の最小重さの組を取り出す
    for v0, w0 in dp[i].items():
        # 価値v0になる組み合わせが、i番目までの中から選ぶ中で既に存在しているばあい
        if v0 in dp[i+1]:
            # 軽い方を残す
            dp[i+1][v0] = min(dp[i+1][v0], w0) #同じ価値で重さが違うとか、組み合わせで価値は同じだが重さが違うみたいな場合
        # i番目まで選んだ時に重さw0になる組がない場合
        else:
            # i番目まで使い、i+1番目は使わない
            dp[i+1][v0] = w0
        
        # i番目（重さw）を使って、或る組み合わせの価値＋i番目で重量制限を超えたらアウト
        if w0 + w > W:
            continue
        # 上と同じ感じで、今まで+i番目の価値と同じ価値の組が、既に存在する場合、軽いほうを残す
        if v0 + v in dp[i+1]:
            dp[i+1][v0 + v] = min(dp[i+1][v0 + v], w0 + w)
        else:
            dp[i+1][v0 + v] = w0 + w

#最後まで選べる中で、最も価値が大きいもの（重さがオーバーするものはcontinueで落ちてるから問題ない）
print(max(dp[-1].keys()))
        


Fixed submission:
N, W = map(int, input().split())
wv = [tuple(map(int, input().split())) for _ in range(N)]

# Wの最大が大きすぎて計算間に合わないので最大最小変換を行う
# dp[i+1][j]：i番目までのアイテムをナップザックに入れられるとき、価値がjとなる最小の重み
dp = [{} for i in range(N+1)]
dp[0][0] = 0


for i, (w,v) in enumerate(wv):
    for v0, w0 in dp[i].items(): # dictのキーと値に対してfor、i-1番目までのアイテムについて考える
        if v0 in dp[i+1]: # 
            dp[i+1][v0] = min(dp[i+1][v0], w0) # 同じ価値でさらに軽いものがある場合はそれを最小の重みに指定
        else:
            dp[i+1][v0] = w0 # 価値v0のものが今までのアイテムになければ、それを最小の重みに指定
        
        if w0+w > W: # 或る価値に対する最小重みに、現在のアイテムの重みを足して上限を超える場合は、今の価値についてそのアイテムは選択対象外
            continue # 
        if v0+v in dp[i+1]: # 今までの価値+新しく選んだものの価値 がi番目までのアイテムを選んだ時に既に存在する場合
            dp[i+1][v0+v] = min(dp[i+1][v0+v], w0+w)
        else:
            dp[i+1][v0+v] = w0+w


print(max(dp[-1].keys())) # 全部選んでいいときに価値として起こりうるものの最大

Buggy python submission (verdict: Time Limit Exceeded):
N, W = map(int, input().split())
wv = [tuple(map(int, input().split())) for _ in range(N)]

dp = [[0 for _ in range(W+1)] for _ in range(N)]


for i in range(N):
    for j in range(W+1):
        if j >= wv[i][0]:
            dp[i][j] = max(dp[i-1][j], dp[i-1][j-wv[i][0]] + wv[i][1])
        else:
            dp[i][j] = dp[i-1][j]

print(dp[N-1][W])

Fixed submission:
N, W = map(int, input().split())
wv = [tuple(map(int, input().split())) for _ in range(N)]

# Wの最大が大きすぎて計算間に合わないので最大最小変換を行う
# dp[i+1][j]：i番目までのアイテムをナップザックに入れられるとき、価値がjとなる最小の重み
dp = [{} for i in range(N+1)]
dp[0][0] = 0


for i, (w,v) in enumerate(wv):
    for v0, w0 in dp[i].items(): # dictのキーと値に対してfor、i-1番目までのアイテムについて考える
        if v0 in dp[i+1]: # 
            dp[i+1][v0] = min(dp[i+1][v0], w0) # 同じ価値でさらに軽いものがある場合はそれを最小の重みに指定
        else:
            dp[i+1][v0] = w0 # 価値v0のものが今までのアイテムになければ、それを最小の重みに指定
        
        if w0+w > W: # 或る価値に対する最小重みに、現在のアイテムの重みを足して上限を超える場合は、今の価値についてそのアイテムは選択対象外
            continue # 
        if v0+v in dp[i+1]: # 今までの価値+新しく選んだものの価値 がi番目までのアイテムを選んだ時に既に存在する場合
            dp[i+1][v0+v] = min(dp[i+1][v0+v], w0+w)
        else:
            dp[i+1][v0+v] = w0+w


print(max(dp[-1].keys())) # 全部選んでいいときに価値として起こりうるものの最大
Buggy python submission (verdict: Time Limit Exceeded):
n, m = map(int, input().split())

prefs_list = []
prefs_dict = {}
for i in range(m):
  p, y = map(int, input().split())
  prefs_list.append([p,y])
  if p in prefs_dict:
    prefs_dict[p].append(y)
  else:
    prefs_dict[p] = [y]

for key in prefs_dict:
  prefs_dict[key].sort()

for pref in prefs_list:
  print(str(pref[0]).zfill(6) + str(prefs_dict[pref[0]].index(pref[1])+1).zfill(6))




Fixed submission:
import bisect
n, m = map(int, input().split())

prefs_list = []
prefs_dict = {}
for i in range(m):
  p, y = map(int, input().split())
  prefs_list.append([p,y])
  if p in prefs_dict:
    prefs_dict[p].append(y)
  else:
    prefs_dict[p] = [y]

for key in prefs_dict:
  prefs_dict[key].sort()



for pref in prefs_list:
  print(str(pref[0]).zfill(6) + str(bisect.bisect_left(prefs_dict[pref[0]], pref[1])+1).zfill(6))
Buggy python submission (verdict: Runtime Error):
import fractions

N, M = map(int, input().split())
S = input()
T = input()

lcm = N*M // fractions.gcd(N, M)
ans = lcm

X = [""] * (lcm+10)

for i in range(N):
    X[i*lcm//N] = S[i]

for i in range(M):

    if X[i*lcm//M] != "":
        if X[i*lcm//M] != T[i]:
            ans = -1
            break
    
print(ans)

Fixed submission:
import fractions

N, M = map(int, input().split())
S = input()
T = input()
gcd = fractions.gcd(N, M)
lcm = N*M // gcd
ans = lcm


for i in range(gcd):
    if S[i*N//gcd] != T[i*M//gcd]:
        ans = -1
        break 
    
print(ans)

Buggy python submission (verdict: Runtime Error):
import fractions

N, M = map(int, input().split())
S = input()
T = input()

lcm = N*M // fractions.gcd(N, M)
ans = lcm

X = [""] * lcm

for i in range(N):
    X[i*lcm//N] = S[i]

for i in range(M):

    if X[i*lcm//M] != "":
        if X[i*lcm//M] != T[i]:
            ans = -1
            break
    
print(ans)

Fixed submission:
import fractions

N, M = map(int, input().split())
S = input()
T = input()
gcd = fractions.gcd(N, M)
lcm = N*M // gcd
ans = lcm


for i in range(gcd):
    if S[i*N//gcd] != T[i*M//gcd]:
        ans = -1
        break 
    
print(ans)

Buggy python submission (verdict: Runtime Error):
import fractions

N, M = map(int, input().split())
S = input()
T = input()

lcm = N*M // fractions.gcd(N, M)
ans = lcm

X = [""] * lcm

for i in range(N):
    X[i*lcm//N] = S[i]

for i in range(M):

    if X[i*lcm//M] != "":
        if X[i*lcm//M] != T[i]:
            ans = -1
            break
    
print(ans)

Fixed submission:
import fractions

N, M = map(int, input().split())
S = input()
T = input()
gcd = fractions.gcd(N, M)
lcm = N*M // gcd
ans = lcm


for i in range(gcd):
    if S[i*N//gcd] != T[i*M//gcd]:
        ans = -1
        break 
    
print(ans)
Buggy python submission (verdict: Runtime Error):
N = int(input())

xyh = [tuple(map(int, input().split())) for _ in range(N)]

for cx in range(0, 101):
    for cy in range(0, 101):
        flag = True

        for i, (x,y,h) in enumerate(xyh):
            if h == 0:
                H = h + abs(x - cx) + abs(y - cy)

        for i, (x,y,h) in enumerate(xyh):
            if h == max(H - abs(x - cx) - abs(y - cy), 0):
                continue
            else:
                flag = False
                break
        if flag:
            print(cx, cy, H)
            exit()


Fixed submission:
n = int(input())

datas = [list(map(int, input().split())) for _ in range(n)]

for Cx in range(101):
  for Cy in range(101):
    flag = True
    H = 0
    for data in datas:
      if data[2] != 0:
        #高さをあるデータから適当に決める
        H = data[2] + abs(data[0] - Cx) + abs(data[1] - Cy)
        break
        
    #直前で適当に決めた高さがほかのデータにも適合すればOK
    for data in datas:
      if data[2] != 0:
        if H != data[2] + abs(data[0] - Cx) + abs(data[1] - Cy):
          flag = False
          break
      else:
        #hi = 0ならH-abs(data[0] - Cx)-abs(data[1] - Cy)<= 0であるあず
        if H - abs(data[0] - Cx) - abs(data[1] - Cy) > 0:
          flag = False
          break
          
    if flag:
      print(Cx, Cy, H)
Buggy python submission (verdict: Runtime Error):
s = input()


for i in range(len(s)):
  if s[i] == "1":
    s[i] = "9"
  else:
    s[i] = "1"
    
print(s)

Fixed submission:
s = input()

ans = ""
for i in range(len(s)):
  if s[i] == "1":
    ans  += "9"
  else:
    ans += "1"
    
print(ans)
Buggy python submission (verdict: Runtime Error):
n = int(input())

a = list(map(int, input().split()))


dict_odd = {}
dict_even = {}

for i in range(n):
  #リストの奇数番目、０始まりなのであまりは０
  if i %2 == 0:
    dict_odd[a[i]] = dict_odd.get(a[i], 0) + 1
  else:
    dict_even[a[i]] = dict_even.get(a[i], 0) + 1
    
#print(dict_odd, dict_even)    

v_odd_sorted = sorted(dict_odd.values())
v_even_sorted = sorted(dict_even.values())

odd_sorted = sorted(dict_odd.items(), key=lambda x : x[1])
even_sorted = sorted(dict_even.items(), key=lambda x : x[1])

#print(v_odd_sorted, v_even_sorted)    
ans = 0
#数字が一種類しかない場合は、一方を置き換える必要がある
if len(set(a)) == 1:
  for i in range((n//2)-1):
    ans += odd_sorted[i][1]
  #print(sum(v_odd_sorted))
else:
  #偶数列と奇数列について、書き換えた後が同じ数字なら成立しないので、一方の書き換える先を次に多い数字にする
  if odd_sorted[-1][0] == even_sorted[-1][0]:
    if odd_sorted[-1][1] >= even_sorted[-1][1]:
      #偶数列を変更したほうが少ない場合
      ans = sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-2]) + v_even_sorted[-1]
    else:
      #奇数列を変更したほうが少ない場合
      ans = sum(v_even_sorted[:-1]) + sum(v_odd_sorted[:-2]) + v_odd_sorted[-1]
  else:
    ans = sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-1])
  #print(sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-1]))
print(ans)

Fixed submission:
n = int(input())

a = list(map(int, input().split()))


dict_odd = {}
dict_even = {}

for i in range(n):
  #リストの奇数番目、０始まりなのであまりは０
  if i %2 == 0:
    dict_odd[a[i]] = dict_odd.get(a[i], 0) + 1
  else:
    dict_even[a[i]] = dict_even.get(a[i], 0) + 1
    
#print(dict_odd, dict_even)    

v_odd_sorted = sorted(dict_odd.values())
v_even_sorted = sorted(dict_even.values())

odd_sorted = sorted(dict_odd.items(), key=lambda x : x[1])
even_sorted = sorted(dict_even.items(), key=lambda x : x[1])

#print(v_odd_sorted, v_even_sorted)    
ans = 0
#数字が一種類しかない場合は、一方を置き換える必要がある
if len(set(a)) == 1:
  ans = sum(v_odd_sorted)
  #print(sum(v_odd_sorted))
else:
  #偶数列と奇数列について、書き換えた後が同じ数字なら成立しないので、一方の書き換える先を次に多い数字にする
  if odd_sorted[-1][0] == even_sorted[-1][0]:
    comp1 = ans = sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-2]) + v_even_sorted[-1]
    comp2 = ans = sum(v_even_sorted[:-1]) + sum(v_odd_sorted[:-2]) + v_odd_sorted[-1]
    ans = min([comp1, comp2])
    """
    if odd_sorted[-1][1] >= even_sorted[-1][1]:
      #偶数列を変更したほうが少ない場合
      ans = sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-2]) + v_even_sorted[-1]
    else:
      #奇数列を変更したほうが少ない場合
      ans = sum(v_even_sorted[:-1]) + sum(v_odd_sorted[:-2]) + v_odd_sorted[-1]
      """
  else:
    ans = sum(v_odd_sorted[:-1]) + sum(v_even_sorted[:-1])
print(ans)
Buggy python submission (verdict: Runtime Error):
import math


N,X = map(int, input().split())
A = list(map(int, input().split()))

A.append(X)
A.sort()

diff = []
for a,b in zip(A, A[1:]):
    diff.append(b-a)

ans = diff[0]
for i in range(1,len(diff)):
    ans = math.gcd(ans, diff[i])


print(ans)

Fixed submission:
def gcd(a,b):
  if a < b:
    a, b = b, a
  while b:
    a, b = b, a % b
  return a

N, X = map(int, input().split())

x = list(map(int, input().split()))
x.append(X)
x.sort()


if len(x) == 2:
  tmp = (x[1] - x[0])
else:
  tmp = gcd((x[2] - x[1]), (x[1] - x[0]))
  for i in range(2, N):
    tmp = gcd(x[i+1] - x[i], tmp)

    
print(tmp)
Buggy python submission (verdict: Runtime Error):
n, k  =map(int, input().split())

ans = 0
#ｋで割り切れるn以下の数のリスト
odd = [i for i in range(k, n+1, k)] #kから始まり、nまで、ｋ刻み
ans += len(odd) ** 3 #abcの選び方のため3乗

if k % 2 == 0:
  #k/2から始まり、nまでで、kで割ると余りがk/2になる
  even = [i for i in range(k//2, n+1, k)]
  ans += even
  
print(ans)


Fixed submission:
n, k  =map(int, input().split())

ans = 0
#ｋで割り切れるn以下の数のリスト
odd = [i for i in range(k, n+1, k)] #kから始まり、nまで、ｋ刻み
ans += len(odd) ** 3 #abcの選び方のため3乗

if k % 2 == 0:
  #k/2から始まり、nまでで、kで割ると余りがk/2になる
  even = [i for i in range(k//2, n+1, k)]
  ans += len(even) ** 3
  
print(ans)

Buggy python submission (verdict: Runtime Error):
n, k  =map(int, input().split())

ans = 0
#ｋで割り切れるn以下の数のリスト
odd = [i for i in range(k, n+1, k)] #kから始まり、nまで、ｋ刻み
ans += len(odd) ** 3 #abcの選び方のため3乗

if k % 2 == 0:
  #k/2から始まり、nまでで、kで割ると余りがk/2になる
  even = [i ofr i in range(k//2, n+1, k)]
  ans += even
  
print(ans)


Fixed submission:
n, k  =map(int, input().split())

ans = 0
#ｋで割り切れるn以下の数のリスト
odd = [i for i in range(k, n+1, k)] #kから始まり、nまで、ｋ刻み
ans += len(odd) ** 3 #abcの選び方のため3乗

if k % 2 == 0:
  #k/2から始まり、nまでで、kで割ると余りがk/2になる
  even = [i for i in range(k//2, n+1, k)]
  ans += len(even) ** 3
  
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n,k = map(int, input().split())
a = list(map(int, input().split()))

tmp = [0] * k
ans = float("inf")
for i in range(n-k+1):
  tmp = a[i:i+k]
  if (tmp[0] <= 0 and tmp[-1] <= 0) or (tmp[0] >= 0 and tmp[-1] >= 0):
    cost = max(abs(tmp[0]), abs(tmp[-1])) 
  else:
    cost = min(abs(tmp[0]), abs(tmp[-1]))*2 + max(abs(tmp[0]), abs(tmp[-1]))
    
  if ans > cost:
    ans = cost
    
print(ans)

Fixed submission:
n,k = map(int, input().split())
a = list(map(int, input().split()))


ans = float("inf")
for i in range(n-k+1):
  #tmpの左端と右端の符号が同じなら、端から移動していく
  if (a[i] <= 0 and a[i+k-1] <= 0) or (a[i] >= 0 and a[i+k-1] >= 0):
    cost = max(abs(a[i]), abs(a[i+k-1]))
  #選んだろうそくが正負にまたがる場合、左端と右端の近いほうに移動してから  
  else:
    cost = min(abs(a[i]), abs(a[i+k-1]))*2 + max(abs(a[i]), abs(a[i+k-1]))
    
  if ans > cost:
    ans = cost
    
print(ans)
Buggy python submission (verdict: Runtime Error):
n = input()
k = input()


if len(n) == 1:
  print(n)
else:
  if k == "1":
    print(n[0])
  else:
    for i  in range(max(int(k), len(n))):
      if n[i] != "1":
        print(n[i])
        exit
      else:
        print(1)

Fixed submission:
n = input()
k = int(input())


for i in range(len(n)):
  if i == k-1 or i == len(n)-1:
    print(n[i])
    exit()
  else:
    if n[i] != "1":
      print(n[i])
      exit()

Buggy python submission (verdict: Runtime Error):
n = input()
k = input()


if n[0] == "1":
  print(n[1])
else:
  print(n[0])

Fixed submission:
n = input()
k = int(input())


for i in range(len(n)):
  if i == k-1 or i == len(n)-1:
    print(n[i])
    exit()
  else:
    if n[i] != "1":
      print(n[i])
      exit()
Buggy python submission (verdict: Time Limit Exceeded):
N, M = map(int, input().split())

A = list(map(int, input().split()))
"""
if N == 1:
    if A[0] % M == 0:
        print(1)
        exit()
"""

ans = 0
cum = [0] * N
cum[0] = A[0]
if cum[0] % M == 0:
    ans += 1

for i in range(1,N):
    cum[i] = cum[i-1] + A[i]
    if cum[i] % M == 0:
        ans += 1

for l in range(N-1): 
    for r in range(l+1,N):
        #print(l,r)
        if (cum[r] - cum[l]) % M == 0:
             ans += 1

            

print(ans)


Fixed submission:
N, M = map(int, input().split())

A = list(map(int, input().split()))
"""
if N == 1:
    if A[0] % M == 0:
        print(1)
        exit()
"""

ans = 0
cum = [0] * N
cum[0] = A[0]

from collections import defaultdict
d = defaultdict(int)

d[cum[0] % M] += 1
for i in range(1,N):
    cum[i] = cum[i-1] + A[i]
    d[cum[i] % M] += 1


from operator import mul
from functools import reduce

def cmb(n,r):
    if n < r:
        return 0
    r = min(n-r,r)
    if r == 0: return 1
    # reduceは第一引数で与えた関数を第二引数のiterbleのそれぞれで実行した結果をもどす
    over = reduce(mul, range(n, n - r, -1))
    under = reduce(mul, range(1,r + 1))
    return over // under

ans = 0
d[0] += 1
for i in d.keys():
    #print(i,d[i])
    ans += cmb(d[i], 2)           

print(ans)