Harryxun/testdata huggingface dataset:
Buggy python submission (verdict: Runtime Error):
t = input()

stack = ''
for i in range(len(t)):
    word = t[i]
    if word == '?':
        next_word = t[i+1] if i < len(t)-1 else None
        if len(stack) <= 0 and next_word == 'P':
            word = 'D'
        elif len(stack) <= 0 and (next_word == 'D' or next_word == '?'):
            word = 'P'
        elif stack[-1] == 'D' and (next_word == '?' or next_word == 'D'):
            word = 'P'
        else:
            word = 'D'

    stack += word
print(stack)


Fixed submission:
t = input()

stack = ''
for i in range(len(t)):
    word = t[i]
    if word == '?':
        next_word = t[i+1] if i < len(t)-1 else None
        if next_word is None:
            word = 'D'
        else:
            if len(stack) <= 0 and next_word == 'P':
                word = 'D'
            elif len(stack) <= 0 and (next_word == 'D' or next_word == '?'):
                word = 'P'
            elif stack[-1] == 'D' and (next_word == '?' or next_word == 'D'):
                word = 'P'
            else:
                word = 'D'

    stack += word
print(stack)

Buggy python submission (verdict: Runtime Error):
t = input()

stack = ''
for s in t:
    if s == '?':
        if stack[-1] == 'P':
            s = 'D'
        else:
            s = 'P'

    stack += s
print(stack)


Fixed submission:
t = input()

stack = ''
for i in range(len(t)):
    word = t[i]
    if word == '?':
        next_word = t[i+1] if i < len(t)-1 else None
        if next_word is None:
            word = 'D'
        else:
            if len(stack) <= 0 and next_word == 'P':
                word = 'D'
            elif len(stack) <= 0 and (next_word == 'D' or next_word == '?'):
                word = 'P'
            elif stack[-1] == 'D' and (next_word == '?' or next_word == 'D'):
                word = 'P'
            else:
                word = 'D'

    stack += word
print(stack)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a_list = list(map(int, input().split()))

for i in range(1, n+1):
    print(a_list.count(i))


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

ans_dict = {}
for a in a_list:
    if not(a in ans_dict):
        ans_dict[a] = 0
    ans_dict[a] += 1

for i in range(1, n+1):
    if i in ans_dict:
        print(ans_dict[i])
    else:
        print(0)
Buggy python submission (verdict: Time Limit Exceeded):
from functools import lru_cache


@lru_cache(maxsize=None)
def get_sum(k):
    filtered = map(lambda x: x[1]-1 if x[0]
                   == k else x[1], a_dict.items())
    filtered = map(lambda x: x*(x-1)//2, filtered)
    return sum(filtered)


n = int(input())
a_list = list(map(int, input().split()))

a_dict = {}
for a in a_list:
    if not(a in a_dict):
        a_dict[a] = 0

    a_dict[a] += 1


for i in range(n):
    k = a_list[i]
    print(get_sum(k))


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

a_dict = {}
for a in a_list:
    if not(a in a_dict):
        a_dict[a] = 0
    a_dict[a] += 1
    
ans = sum(map(lambda x: x*(x-1)//2, a_dict.values()))

for i in range(n):
    k = a_list[i]
    before = a_dict[k]*(a_dict[k]-1) // 2
    after = (a_dict[k]-1)*(a_dict[k]-2) // 2
    print(ans - (before - after))

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a_list = list(map(int, input().split()))

a_dict = {}
for a in a_list:
    if not(a in a_dict):
        a_dict[a] = 0

    a_dict[a] += 1

for i in range(n):
    k = a_list[i]
    filtered = map(lambda x: x[1]-1 if x[0]
                   == k else x[1], a_dict.items())
    filtered = map(lambda x: x*(x-1)//2, filtered)
    print(sum(filtered))


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

a_dict = {}
for a in a_list:
    if not(a in a_dict):
        a_dict[a] = 0
    a_dict[a] += 1
    
ans = sum(map(lambda x: x*(x-1)//2, a_dict.values()))

for i in range(n):
    k = a_list[i]
    before = a_dict[k]*(a_dict[k]-1) // 2
    after = (a_dict[k]-1)*(a_dict[k]-2) // 2
    print(ans - (before - after))
Buggy python submission (verdict: Time Limit Exceeded):
n, a, b = map(int, input().split())
a_count = 0
n_count = 0

while n_count < n:
    for i in range(a):
        if n_count >= n:
            break
        a_count += 1
        n_count += 1
    n_count += b

print(a_count)


Fixed submission:
n, a, b = map(int, input().split())
ans = n // (a+b)*a
rem = n % (a+b)
ans += min(rem, a)
print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
p_list = list(map(int, input().split()))

ans = 0
for i in range(n):
    if p_list[i] <= min(p_list[:i+1]):
        ans += 1
print(ans)


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

ans = 0
now_min = p_list[0]
for i in range(n):
    if now_min > p_list[i]:
        now_min = p_list[i]
    if p_list[i] <= now_min:
        ans += 1
print(ans)
Buggy python submission (verdict: Runtime Error):
N, A, B = map(int, input().split())
diff = abs(A - B)

if diff % 2 == 0:
    print(diff // 2)
else:
  prrint(-1)

Fixed submission:
N, A, B = map(int, input().split())
diff = abs(A - B)

if diff % 2 == 0:
    print(diff // 2)

else:
    n = (diff // 2) + 1 + min(N-B, A-1)
    print(n)
Buggy python submission (verdict: Runtime Error):
import math
import sys
sys.setrecursionlimit(100000)

a, b = map(int, input().split())
gcd = math.gcd(a, b)
if gcd <= 0:
    print(0)
else:
    result = int(a*b / gcd)
    print(result)


Fixed submission:
from fractions import gcd
import sys
sys.setrecursionlimit(100000)

a, b = map(int, input().split())
gcd = gcd(a, b)
if gcd <= 0:
    print(0)
else:
    result = int(a*b / gcd)
    print(result)

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

a, b = map(int, input().split())
gcd = math.gcd(a, b)
if gcd == 0:
    print(0)
else:
    result = int(a*b / gcd)
    print(result)


Fixed submission:
from fractions import gcd
import sys
sys.setrecursionlimit(100000)

a, b = map(int, input().split())
gcd = gcd(a, b)
if gcd <= 0:
    print(0)
else:
    result = int(a*b / gcd)
    print(result)

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

a, b = map(int, input().split())
result = int(a*b / math.gcd(a, b))
print(result)


Fixed submission:
from fractions import gcd
import sys
sys.setrecursionlimit(100000)

a, b = map(int, input().split())
gcd = gcd(a, b)
if gcd <= 0:
    print(0)
else:
    result = int(a*b / gcd)
    print(result)
Buggy python submission (verdict: Runtime Error):
n,m = map(int, input().split())
neighbors = {key:[] for key in range(1, n+1)}
answers = {key:0 for key in range(1, n+1)}
answers[1] = 1
for i in range(m):
    a,b = map(int, input().split())
    neighbors[a].append(b)
    neighbors[b].append(a)
hosts = neighbors[1]
now = 1
def register(hs, n):
    for h in hs:
        if answers[h] == 0:
            answers[h] = n
            register(neighbors[h], h)
register(hosts, now)
flag = 0
for key, item in answers.items():
    if item == 0:
        flag = 1
if flag == 0:
    print("Yes")
    for key, item in answers.items():
        if key != 1:
            print(item)
else:
    print("No")

Fixed submission:
n,m = map(int, input().split())
neighbors = {key:[] for key in range(1, n+1)}
answers = {key:0 for key in range(1, n+1)}
answers[1] = 1
for i in range(m):
    a,b = map(int, input().split())
    neighbors[a].append(b)
    neighbors[b].append(a)

def register(hs):
    newhs = []
    for h in hs:
        for i in neighbors[h]:
            if answers[i] == 0:
                answers[i] = h
                newhs.append(i)
    return newhs

hosts = [1]
while True:
    hosts = register(hosts)
    if len(hosts) == 0:
        break

flag = 0
for key, item in answers.items():
    if item == 0:
        flag = 1
if flag == 0:
    print("Yes")
    for key, item in answers.items():
        if key != 1:
            print(item)
else:
    print("No")
Buggy python submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(10**9)

def neighbor(a):
    if a == 0:
        return [0,1]
    if a == 9:
        return [8,9]
    return [a-1,a,a+1]

def make_lunlun(digit, start):
    if digit == 1:
        return [start]
    res = []
    for start_neighbor in neighbor(start):
        b = make_lunlun(digit-1, start_neighbor)
        c = list(map(lambda x:x+(start*(10**(digit-1))), b))
        res.extend(c)
    return res
lunlun = []
for i in range(1,11):
    for j in range(1,10):
        lunlun.extend(make_lunlun(i, j))

k = int(input())
print(lunlun[k-1])


import sys
sys.setrecursionlimit(10**9)

def neighbor(a):
    if a == 0:
        return [0,1]
    if a == 9:
        return [8,9]
    return [a-1,a,a+1]

def make_lunlun(digit, start):
    if digit == 1:
        return [start]
    res = []
    for start_neighbor in neighbor(start):
        b = make_lunlun(digit-1, start_neighbor)
        c = list(map(lambda x:x+(start*(10**(digit-1))), b))
        res.extend(c)
    return res
lunlun = []
for i in range(1,11):
    for j in range(1,10):
        lunlun.extend(make_lunlun(i, j))

k = int(input())
print(lunlun[k-1])


Fixed submission:
import sys
sys.setrecursionlimit(10**9)

def neighbor(a):
    if a == 0:
        return [0,1]
    if a == 9:
        return [8,9]
    return [a-1,a,a+1]

def make_lunlun(digit, start):
    if digit == 1:
        return [start]
    res = []
    for start_neighbor in neighbor(start):
        b = make_lunlun(digit-1, start_neighbor)
        c = list(map(lambda x:x+(start*(10**(digit-1))), b))
        res.extend(c)
    return res
lunlun = []
for i in range(1,11):
    for j in range(1,10):
        lunlun.extend(make_lunlun(i, j))

k = int(input())
print(lunlun[k-1])
Buggy python submission (verdict: Runtime Error):
n = int(input())
ans = []
def dfs(line, mx):
    if len(line) == n:
        ans.append(line)
    else:
        for i in range(mx+1):
            line_copy = line.copy()
            line_copy.append(i)
            dfs(line_copy, mx)
        line_copy = line.copy()
        line_copy.append(mx+1)
        dfs(line_copy, mx+1)

dfs([0], 0)

figures = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

for a in ans:
    for i in a:
        print(figures[i], end="")
    print()


Fixed submission:
n = int(input())
ans = []
def dfs(line, mx):
    if len(line) == n:
        ans.append(line)
    else:
        for i in range(mx+1):
            line_copy = line.copy()
            line_copy.append(i)
            dfs(line_copy, mx)
        line_copy = line.copy()
        line_copy.append(mx+1)
        dfs(line_copy, mx+1)

dfs([0], 0)

figures = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"]

for a in ans:
    for i in a:
        print(figures[i], end="")
    print()
Buggy python submission (verdict: Time Limit Exceeded):
n, p = map(int, input().split())
s = input()

def nC2(n):
    if n == 0:
        return 0
    return n*(n-1)//2

if p != 2 and p != 5:
    u = []
    for i in range(n):
        u.append(int(s[i:])%p)
    onaji = {}
    for i in u:
        if not i in onaji:
            onaji[i] = 1
        else:
            onaji[i] += 1
    ans = 0
    for key, r in onaji.items():
        ans += nC2(r)
        if key == 0:
            ans += r
    print(ans)

elif p == 2:
    ans = 0
    for i in range(n):
        if int(s[i]) in [0,2,4,6,8]:
            ans += i+1
    print(ans)

else:
    ans = 0
    for i in range(n):
        if int(s[i]) in [0,5]:
            ans += i+1
    print(ans)


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

def nC2(n):
    if n == 0:
        return 0
    return n*(n-1)//2

p_joyo = [] # 10^m % p は p_joyo[m]に対応
r = 1
for i in range(n):
    p_joyo.append(r)
    r = r*10 % p

if p != 2 and p != 5:
    u = []
    r = int(s[n-1])%p
    for i in range(1,n):
        u.append(r)
        j = n-i-1
        r = (r + int(s[j])*p_joyo[i])%p
    u.append(r)
    onaji = {}
    for i in u:
        if not i in onaji:
            onaji[i] = 1
        else:
            onaji[i] += 1
    ans = 0
    for key, r in onaji.items():
        ans += nC2(r)
        if key == 0:
            ans += r
    print(ans)

elif p == 2:
    ans = 0
    for i in range(n):
        if int(s[i]) in [0,2,4,6,8]:
            ans += i+1
    print(ans)

else:
    ans = 0
    for i in range(n):
        if int(s[i]) in [0,5]:
            ans += i+1
    print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
mod = 1000000007
def make_bin(i):
    return list(map(int, list(format(i, "060b"))))


a_bin = []
for i in range(n):
    a_bin.append(make_bin(a[i]))

ans = 0
for i in range(60):
    index_i = []
    for j in range(n):
        index_i.append(a_bin[j][i])
    ones = index_i.count(1)
    ans += (ones*(n-ones)*(2**(59-i))) % mod

ans %= mod
print(ans)

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

def wash_b(line, s):
    l = len(line)
    neck = 2**s
    cnt = 0
    for i in range(l):
        if line[i] >= neck:
            line[i] -= neck
            cnt += 1
    return cnt
ans = 0
for i in range(60):
    w = wash_b(a, 59 - i)
    ans += (w*(n-w)*(2**(59-i))) % mod

ans %= mod
print(ans)

Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
a = list(map(int, input().split()))
mod = 1000000007
def make_bin(i):
    return list(map(int, list(format(i, "060b"))))
def power(x, y):
    if y == 0:
        return 1
    elif y == 1:
        return x % mod
    elif y % 2 == 0:
        return power(x, y // 2) ** 2 % mod
    else:
        return power(x, y // 2) ** 2 * x % mod

a_bin = []
for i in range(n):
    a_bin.append(make_bin(a[i]))

ans = 0
for i in range(60):
    index_i = []
    for j in range(n):
        index_i.append(a_bin[j][i])
    ones = index_i.count(1)
    ans += (ones*(n-ones)*(power(2, 59-i))) % mod

ans %= mod
print(ans)

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

def wash_b(line, s):
    l = len(line)
    neck = 2**s
    cnt = 0
    for i in range(l):
        if line[i] >= neck:
            line[i] -= neck
            cnt += 1
    return cnt
ans = 0
for i in range(60):
    w = wash_b(a, 59 - i)
    ans += (w*(n-w)*(2**(59-i))) % mod

ans %= mod
print(ans)
Buggy python submission (verdict: Runtime Error):
n = int(input())
neighbors = [[] for i in range(n+1)]
ab = []
for i in range(n-1):
    line = list(map(int, input().split()))
    neighbors[line[0]].append(line[1])
    neighbors[line[1]].append(line[0])
    ab.append((line[0], line[1]))
maximum = 0
neighbors_max = 0
for i in range(n):
    if maximum < len(neighbors[i]):
        neighbors_max = i
        maximum = len(neighbors[i])
edgecolors = {}
reached = {neighbors_max}
def make_other_colors(c, m):
    res = []
    if c > m:
        res += [i+1 for i in range(m)]
    else:
        res += [i+1 for i in range(c-1)]
        res += [maximum-i for i in range(m-c+1)]
    return res
def coloring(v, c):
    if c == 0:
        reached.add(v)
        for i in range(len(neighbors[v])):
            edgecolors[(v, neighbors[v][i])] = i + 1
            edgecolors[(neighbors[v][i], v)] = i + 1
            reached.add(neighbors[v][i])
            coloring(neighbors[v][i], i+1)
        return
    l = len(neighbors[v])
    if l == 1 and neighbors[v][0] in reached:
        reached.add(v)
        return
    other_colors = make_other_colors(c, l-1)
    i = 0
    j = 0
    while i < l:
        if neighbors[v][i] in reached:
            i += 1
            continue
        edgecolors[(v, neighbors[v][i])] = other_colors[j]
        edgecolors[(neighbors[v][i], v)] = other_colors[j]
        reached.add(neighbors[v][i])
        coloring(neighbors[v][i], other_colors[j])
        i += 1
        j += 1
coloring(neighbors_max, 0)
print(maximum)
for i in ab:
    print(edgecolors[i])


Fixed submission:
import sys
sys.setrecursionlimit(10**9)

n = int(input())
neighbors = [[] for i in range(n+1)]
ab = []
for i in range(n-1):
    line = list(map(int, input().split()))
    neighbors[line[0]].append(line[1])
    neighbors[line[1]].append(line[0])
    ab.append((line[0], line[1]))
maximum = 0
neighbors_max = 0
for i in range(n):
    if maximum < len(neighbors[i]):
        neighbors_max = i
        maximum = len(neighbors[i])
edgecolors = {}
reached = {neighbors_max}
def make_other_colors(c, m):
    res = []
    if c > m:
        res += [i+1 for i in range(m)]
    else:
        res += [i+1 for i in range(c-1)]
        res += [maximum-i for i in range(m-c+1)]
    return res
def coloring(v, c):
    if c == 0:
        reached.add(v)
        for i in range(len(neighbors[v])):
            edgecolors[(v, neighbors[v][i])] = i + 1
            edgecolors[(neighbors[v][i], v)] = i + 1
            reached.add(neighbors[v][i])
            coloring(neighbors[v][i], i+1)
        return
    l = len(neighbors[v])
    if l == 1 and neighbors[v][0] in reached:
        reached.add(v)
        return
    other_colors = make_other_colors(c, l-1)
    i = 0
    j = 0
    while i < l:
        if neighbors[v][i] in reached:
            i += 1
            continue
        edgecolors[(v, neighbors[v][i])] = other_colors[j]
        edgecolors[(neighbors[v][i], v)] = other_colors[j]
        reached.add(neighbors[v][i])
        coloring(neighbors[v][i], other_colors[j])
        i += 1
        j += 1
coloring(neighbors_max, 0)
print(maximum)
for i in ab:
    print(edgecolors[i])
Buggy python submission (verdict: Runtime Error):
mod = 1000000007
import sys
sys.setrecursionlimit(1000000)
x, y = map(int, input().split())
if (x+y) % 3 != 0:
    print(0)
else:
    a = ((2*x-y)//3)%mod
    b = ((2*y-x)//3)%mod
    n = (a + b)%mod
    kaijo = [1, 1]
    for i in range(2, n+1):
        kaijo.append(i*kaijo[i-1]%mod)
    def mul(a, b):
        return ((a % mod) * (b % mod)) % mod
    def power(x, y):
        if y == 0:
            return 1
        elif y == 1:
            return x % mod
        elif y % 2 == 0:
            return power(x, y // 2) ** 2 % mod
        else:
            return power(x, y // 2) ** 2 * x % mod
    def div(a, b):
        return mul(a, power(b, mod - 2))
    n_a = div(kaijo[n], kaijo[a])
    ans = div(n_a, kaijo[n-a])
    print(ans)


Fixed submission:
mod = 1000000007
import sys
sys.setrecursionlimit(1000000)
x, y = map(int, input().split())
a = ((2*x-y)//3)
b = ((2*y-x)//3)
if (x+y) % 3 != 0 or a < 0 or b < 0:
    print(0)
else:
    n = (a + b)%mod
    kaijo = [1, 1]
    for i in range(2, n+1):
        kaijo.append(i*kaijo[i-1]%mod)
    def mul(a, b):
        return ((a % mod) * (b % mod)) % mod
    def power(x, y):
        if y == 0:
            return 1
        elif y == 1:
            return x % mod
        elif y % 2 == 0:
            return power(x, y // 2) ** 2 % mod
        else:
            return power(x, y // 2) ** 2 * x % mod
    def div(a, b):
        return mul(a, power(b, mod - 2))
    n_a = div(kaijo[n], kaijo[a])
    ans = div(n_a, kaijo[n-a])
    print(ans)
Buggy python submission (verdict: Time Limit Exceeded):
n = int(input())
l = sorted(list(map(int, input().split())))
cnt = 0
for i in range(n-1):
    for j in range(i+1,n):
        down = l[j] - l[i]
        up = l[j] + l[i]
        for k in range(j+1,n):
            if down < l[k]:
                if l[k] < up:
                    cnt += 1
                else:
                    break
print(cnt)

Fixed submission:
import bisect
n = int(input())
l = sorted(list(map(int, input().split())))
cnt = 0
for i in range(n-1):
    for j in range(i+1,n):
        up = l[j] + l[i]
        #l[k] = up となるようなkのうち最小のものを見つけろ
        k = bisect.bisect_left(l, up)
        cnt += k - j - 1
print(cnt)
Buggy python submission (verdict: Runtime Error):
c = 0
s.append("U")

for i in range(-(-l//2)):
    d = 2*i
    if s[d] == "L":
        print("No")
        c = 1
        break
    if s[d+1] == "R":
        print("No")
        c = 1
        break
if c == 0:
    print("Yes")

Fixed submission:
S = input()
l = len(S)
s = list(S)
c = 0
s.append("U")

for i in range(-(-l//2)):
    d = 2*i
    if s[d] == "L":
        print("No")
        c = 1
        break
    if s[d+1] == "R":
        print("No")
        c = 1
        break
if c == 0:
    print("Yes")
Buggy python submission (verdict: Time Limit Exceeded):
N, K, Q = map(int,input().split())
A = []
for i in range(Q):
    A.append(int(input())-1)
for i in range(N):
    if A.count(i) >= Q - K + 1:
        print("Yes")
    else:
        print("No")



Fixed submission:
N, K, Q = map(int,input().split())
A = []
for i in range(Q):
    A.append(int(input())-1)
count = [0 for i in range(N)]
for i in A:
    count[i] += 1
for i in range(N):
    if count[i] >= Q - K + 1:
        print("Yes")
    else:
        print("No")
Buggy python submission (verdict: Time Limit Exceeded):
N, M = map(int, input().split())
A = list(map(int, input().split()))
Asorted = sorted(A)
MM = 0
if M+1 >= N:
    MM = N
else:
    MM = M+1
Atop = [Asorted[N-i-1] for i in range(MM)]
for i in range(M):
    Atopmax = Atop.index(max(Atop))
    Atop[Atopmax] = Atop[Atopmax]//2
count = 0
for i in range(N-MM):
    count += Asorted[i]
count += sum(Atop)
print(count)

Fixed submission:
#標準入力
N, M = map(int, input().split())
A = list(map(int, input().split()))
#heapqをimportして、Aの要素をすべてマイナスにしてheapify
import heapq
def minus(n):
    return -n
A = list(map(minus, A))
heapq.heapify(A)
#その最小値を出力して削除し、その半分を追加することをM回やる
for i in range(M):
    heapq.heappush(A, -(-heapq.heappop(A)//2))
#Aの要素を合計してminusして出力する
print(minus(sum(A)))

Buggy python submission (verdict: Time Limit Exceeded):
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(M):
    Amax = A.index(max(A))
    A[Amax] = A[Amax]//2
print(sum(A))

Fixed submission:
#標準入力
N, M = map(int, input().split())
A = list(map(int, input().split()))
#heapqをimportして、Aの要素をすべてマイナスにしてheapify
import heapq
def minus(n):
    return -n
A = list(map(minus, A))
heapq.heapify(A)
#その最小値を出力して削除し、その半分を追加することをM回やる
for i in range(M):
    heapq.heappush(A, -(-heapq.heappop(A)//2))
#Aの要素を合計してminusして出力する
print(minus(sum(A)))

Buggy python submission (verdict: Time Limit Exceeded):
N, M = map(int, input().split())
A = list(map(int, input().split()))
for i in range(M):
    Amax = A.index(max(A))
    A[Amax] = A[Amax]//2
print(sum(A))

Fixed submission:
#標準入力
N, M = map(int, input().split())
A = list(map(int, input().split()))
#heapqをimportして、Aの要素をすべてマイナスにしてheapify
import heapq
def minus(n):
    return -n
A = list(map(minus, A))
heapq.heapify(A)
#その最小値を出力して削除し、その半分を追加することをM回やる
for i in range(M):
    heapq.heappush(A, -(-heapq.heappop(A)//2))
#Aの要素を合計してminusして出力する
print(minus(sum(A)))
Buggy python submission (verdict: Time Limit Exceeded):
# 標準入力
N = int(input())
H = list(map(int, input().split()))
H.append(10**10)
count = [0 for i in range(N)]
# 左からi番目に降り立って(iは0~N-1)
for i in range(N):
# H[i] >= H[i+1] ならcount[i]を一つ増やしてiに足していけ(H[N] = 10**10としよう)
  while H[i] >= H[i+1]:
    count[i] += 1
    i += 1
#max(count)を出力しよう
print(max(count))


Fixed submission:
# 標準入力
N = int(input())
H = list(map(int, input().split()))
H.append(10**10)
count = [0 for i in range(N)]
i = 0
# 左からi番目に降り立って(iは0~N-1)、H[i]>=H[i+1]が続くまでcountを増やす。count[i]=5なら次はi+6から繰り返す
while i <= N-1:
  j = i
  while H[j] >= H[j+1]:
    count[i] += 1
    if j <= N-3:
      j += 1
    else:
      break
  i += count[i]+1
#max(count)を出力しよう
print(max(count))