Harryxun/GPT-100-sft-dataset huggingface dataset:
Problem p03469 (python)

Fixed submission:
indate = input().split('/')
outdate = ['2018'] + indate[1:3]
print('/'.join(outdate))

Buggy submission (verdict: Runtime Error):
import math

inn = [int(x) for x in input().split()]
aa = []
bb = []
for i in range(inn[0]):
    tmp = [int(x) for x in input().split()]
    aa.append(tmp[0])
    bb.append(tmp[1])

maxaa = max(aa)
ba = [x for x in bb if x > maxaa]
sumba = sum(ba)
lenba = len(ba)
if sumba == inn[1]:
    print(lenba)
    exit()
elif sumba > inn[1]:
    count = lenba
    tot = sumba
    for b in sorted(ba):
        tot -= b
        if tot < inn[1]:
            print(count)
            exit()
        count -= 1
else:
    count = lenba + math.ceil((inn[1]-sumba)/max(aa))
    print(count)
Problem p03470 (python)

Fixed submission:
inn = int(input())
sizes = set()
for i in range(inn):
    sizes.add(int(input()))
ans = len(sizes)
print(ans)

Buggy submission (verdict: Runtime Error):
inn=int(input())
sizes = []
for i in range(inn):
  sizes.append(int(input())

ans = len(set(sizes))
print(ans)
Problem p03340 (python)

Fixed submission:
n = int(input())
xs = list(map(int, input().split()))
 
ans = 0
sums = xs[0]
xors = xs[0]
i, j = 0, 0

while True:
  if xors == sums:
    ans += j - i + 1
    j += 1
    if j >= n: break
    sums += xs[j]
    xors ^= xs[j]
  else:
    sums -= xs[i]
    xors ^= xs[i]
    i += 1
    
print(ans)

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

ans = 0
sums = 0
xors = 0
for i in range(n):
  for j in range(i, n):
    sums += xs[j]
    xors ^= xs[j]
    if sums == xors:
      ans += 1
  sums = 0
  xors = 0
print(ans)
Problem p03354 (python)

Fixed submission:
n, m = map(int, input().split())
ps = [int(p)-1 for p in input().split()]
xys = [tuple(int(x)-1 for x in input().split()) for _ in range(m)]

nodes = range(n)
union = {node:node for node in nodes}

def root(node, previouss=None):
    if not previouss:
        previouss = []

    if union[node] == node:
        for previous in previouss:
            union[previous] = node
        return node
    else:
        previouss.append(node)
        return root(union[node], previouss)

for x, y in xys:
    rx = root(x)
    ry = root(y)
    union[rx] = ry

groups = {node:{node} for node, rootn in union.items() if node==rootn} 
for node in nodes:
    if node in groups:
        continue
    group = groups[root(node)]
    group.add(node)
    groups[node] = group

print(sum(p in groups[i] for i, p in enumerate(ps)))

Buggy submission (verdict: Runtime Error):
n, m = map(int, input().split())
ps = [int(p) for p in input().split()]
xys = [tuple(map(int, input().split())) for _ in range(m)]
 
union = {node:node for node in range(n)}
 
def root(node):
    if union[node] == node:
        return node
    union[node] = root(union[node])
    return union[node]
 
for x, y in xys:
    union[root(x)] = root(y)
 
print(sum(root(i+1) == root(p) for i, p in enumerate(ps)))
Problem p03372 (python)

Fixed submission:
from itertools import accumulate

n, c = map(int, input().split())
xs, vs = zip(*(map(int, input().split()) for _ in range(n)))

xs = (0,) + xs + (c,)
ds = [j - i for i, j in zip(xs, xs[1:])]

clockwise = [0] + [v - d for v, d in zip(accumulate(vs), accumulate(ds))]
clockwise_maxs = list(accumulate(clockwise, func=max))
clock_max = clockwise_maxs[-1]

anticlockwise = [0] + [v - d for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))]
anticlockwise_maxs = list(accumulate(anticlockwise, func=max))
anticlock_max = anticlockwise_maxs[-1]

clockwise2 = [0] + [v - d*2 for v, d in zip(accumulate(vs), accumulate(ds))]
clock_anticlock = [x + y for x, y in zip(clockwise2, reversed(anticlockwise_maxs))]
c_ac_max = max(clock_anticlock)

anticlockwise2 = [0] + [v - d*2 for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))]
anticlock_clock = [x + y for x, y in zip(anticlockwise2, reversed(clockwise_maxs))]
ac_c_max = max(anticlock_clock)

print(max(clock_max, anticlock_max, c_ac_max, ac_c_max))

Buggy submission (verdict: Runtime Error):
from itertools import accumulate, chain
 
n, c = map(int, input().split())
xs, vs = zip(*(map(int, input().split()) for _ in range(n)))
 
ds = [j - i for i, j in zip(chain([0], xs), chain(xs, [c]))]
 
clockwise1      = chain([0], (v - d*2 for v, d in zip(accumulate(vs), accumulate(ds))))
anticlockwise1  = chain([0], (v - d for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))))
clock_anticlock = (x + y for x, y in zip(clockwise1, reversed(list(accumulate(anticlockwise1, func=max)))))
 
anticlockwise2  = chain([0], (v - d*2 for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))))
clockwise2      = chain([0], (v - d for v, d in zip(accumulate(vs), accumulate(ds))))
anticlock_clock = (x + y for x, y in zip(anticlockwise2, reversed(list(accumulate(clockwise2, func=max)))))
 
print(max(chain(anticlock_clock, clock_anticlock)))
from itertools import accumulate, chain

n, c = map(int, input().split())
xs, vs = zip(*(map(int, input().split()) for _ in range(n)))

ds = [j - i for i, j in zip(chain([0], xs), chain(xs, [c]))]

clockwise1      = chain([0], (v - d*2 for v, d in zip(accumulate(vs), accumulate(ds))))
anticlockwise1  = chain([0], (v - d for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))))
clock_anticlock = (x + y for x, y in zip(clockwise1, reversed(list(accumulate(anticlockwise1, func=max)))))

anticlockwise2  = chain([0], (v - d*2 for v, d in zip(accumulate(vs[::-1]), accumulate(ds[::-1]))))
clockwise2      = chain([0], (v - d for v, d in zip(accumulate(vs), accumulate(ds))))
anticlock_clock = (x + y for x, y in zip(anticlockwise2, reversed(list(accumulate(clockwise2, func=max)))))
 
print(max(chain(clock_anticlock, anticlock_clock)))
Problem p03385 (python)

Fixed submission:
print('Yes' if set(input()) == set('abc') else 'No')

Buggy submission (verdict: Runtime Error):
rom itertools import count, takewhile
from math import floor, sqrt
 
n = int(input())
xys = [map(int, input().split()) for _ in range(n)]
 
def mysqrt(n):
    x = floor(sqrt(n))
    for y in takewhile(lambda y: y**2 <= n, count(max(0, x-2))):
        x = y
    return x
 
for x, y in xys:
    xy = x*y
    root = mysqrt(xy-1)
    ans = root*2 - (root**2 + root >= xy) - 1 + (x == y)
    print(ans)

Buggy submission (verdict: Runtime Error):
from itertools import count, takewhile
from math import floor, sqrt

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

def mysqrt(n):
    x = floor(sqrt(n))
    for y in takewhile(lambda y: y**2 <= n, count(x-1)):
        x = y
    return x

for x, y in xys:
    xy = x*y
    root = mysqrt(xy-1)
    ans = root*2 - (root**2 + root >= xy) - 1 + (x == y)
    print(ans)
Problem p03436 (python)

Fixed submission:
from collections import deque

h, w = map(int, input().split())
maze = {(i,j):c for i in range(h) for j, c in enumerate(input())}

blacks = sum(c == '#' for c in maze.values())

def bfs(i, j):
    dq = deque()
    dq.appendleft((1, (i, j)))
    while dq:
        steps, (i, j) = dq.pop()
        if (i, j) == (h-1, w-1):
            return steps
        if maze.get((i, j), '#') == '#':
            continue
        maze[(i, j)] = '#'
        dirs = ((-1, 0), (1, 0), (0, 1), (0, -1))
        dq.extendleft((steps+1, (i+di, j+dj)) for di, dj in dirs)

res = bfs(0, 0)
print(-1 if res is None else h*w - res - blacks)

Buggy submission (verdict: Runtime Error):
from collections import deque

h, w = map(int, input().split())
maze = {(i,j):c for i in range(h) for j, c in enumerate(input())}

blacks = sum(c == '#' for c in maze.values())

def bfs(i, j):
    dq = deque()
    dq.appendleft((1, (i, j)))
    while dq:
        steps, (i, j) = dq.pop()
        if (i, j) == (h-1, w-1):
            return steps
        if maze.get((i, j), '#') == '#':
            continue
        maze[(i, j)] = '#'
        dirs = ((-1, 0), (1, 0), (0, 1), (0, -1))
        dq.extendleft((steps+1, (i+di, j+dj)) for di, dj in dirs)

print(h*w - bfs(0, 0) - blacks)
Problem p03476 (python)

Fixed submission:
from itertools import accumulate, count, islice, takewhile
 
def eratosthenes():
    d = {}
    for q in count(2):
        p = d.pop(q, None)
        if p:
            x = next(x for x in count(q + p, p) if x not in d)
            d[x] = p
        else:
            yield q
            d[q*q] = q

def likes():
    xs = set()
    for p in eratosthenes():
        if p in xs:
            yield p
        xs.add(2*p - 1)

likeset = set(takewhile(lambda n: n <= 100000, likes()))
onehot = (i in likeset for i in range(100001))
likecounts = list(accumulate(onehot))

q = int(input())
lrs = [[int(x) for x in input().split()] for _ in range(q)]

for l, r in lrs:
    print(likecounts[r+1] - likecounts[l-1])

Buggy submission (verdict: Runtime Error):
from itertools import accumulate, count, islice, takewhile
 
def eratosthenes():
    d = {}
    for q in count(2):
        p = d.pop(q, None)
        if p:
            x = next(x for x in count(q + p, p) if x not in d)
            d[x] = p
        else:
            yield q
            d[q*q] = q

def likes():
    xs = set()
    for p in eratosthenes():
        if p in xs:
            yield p
        xs.add(2*p - 1)

likeset = set(takewhile(lambda n: n <= 100000, likes()))
onehot = (i in likeset for i in range(100000))
likecounts = list(accumulate(onehot))

q = int(input())
lrs = [[int(x) for x in input().split()] for _ in range(q)]

for l, r in lrs:
    print(likecounts[r+1] - likecounts[l-1])
Problem p03479 (python)

Fixed submission:
from itertools import count, takewhile

x, y = map(int, input().split())

print(sum(1 for _ in takewhile(lambda z: z <= y, (x*(2**i) for i in count()))))

Buggy submission (verdict: Runtime Error):
from itertools import count, takewhile
 
x, y = map(int, input().split())
 
print(max(takewhile(lambda i: (x*(2**i) <= y,  count())))
Problem p03713 (python)

Fixed submission:
from itertools import chain

h, w = map(int, input().split())

def f(x, h, w):
    h2 = h // 2
    h3 = h - h2
    a,b,c = sorted((x,w*h2,w*h3))
    w2 = w // 2
    w3 = w - w2
    d,e,f = sorted((x,w2*h,w3*h))
    return min(c-a, f-d)

ss = ((w2*h, h, w-w2) for w2 in range(1, (w+3)//2))
ts = ((w*h2, h-h2, w) for h2 in range(1, (h+3)//2))

print(min(f(*xs) for xs in chain(ss, ts)))

Buggy submission (verdict: Runtime Error):
from itertools import chain

h, w = map(int, input().split())

def f(x, h, w):
    h2 = h // 2
    h3 = h - h2
    a,b,c = sorted((x,w*h2,w*h3))
    w2 = w // 2
    w3 = w - w2
    d,e,f = sorted((x,w2*h,w3*h))
    return min(c-a, f-d)

ss = ((w2*h, h, w-w2) for w2 in range(1, (w+1)//2))
ts = ((w*h2, h-h2, w) for h2 in range(1, (h+1)//2))

print(min(f(*xs) for xs in chain(ss, ts)))
Problem p03361 (python)

Fixed submission:
# 行数Hおよび列数Wを入力する
H, W = map(int, input().split())
# マスを初期化する（ワンサイズ大きめに作成する）
s = ["." * (W + 2) for _ in range(H + 2)]
# マスを入力する
for i in range(1, H + 1):
    s[i] = "." + input() + "."
# 判定を初期化する
judge = "Yes"
# 各マスについて、黒く塗れるかを調べる
for i in range(1, H + 1):
    for j in range(1, W + 1):
        # 黒く塗らないマスの場合、以降の処理は行わずに次のマスに移る
        if s[i][j] == ".":
            continue
        # 上下左右に黒く塗るべきマスがない場合、塗り分け不可能
        if s[i - 1][j] + s[i][j - 1] + s[i][j + 1] + s[i + 1][j] == "....":
            # 判定を更新する
            judge = "No"
            # マスの調査を終了する
            break
# 判定を出力する
print(judge)

Buggy submission (verdict: Runtime Error):
# 行数Hおよび列数Wを入力する
H, W = map(int, input().split())
# マスを初期化する（ワンサイズ大きめに作成する）
s = ["." * (W + 2) for _ in range(H + 2)]
# マスを入力する
for i in range(1, H + 1):
    s[i] = input()
# 判定を初期化する
judge = "Yes"
# 各マスについて、黒く塗れるかを調べる
for i in range(1, H + 1):
    for j in range(1, W + 1):
        # 黒く塗らないマスの場合、以降の処理は行わずに次のマスに移る
        if s[i][j] == ".":
            continue
        # 上下左右に黒く塗るべきマスがない場合、塗り分け不可能
        if s[i - 1][j] + s[i][j - 1] + s[i][j + 1] + s[i + 1][j] == "....":
            # 判定を更新する
            judge = "No"
            # マスの調査を終了する
            break
# 判定を出力する
print(judge)
Problem p03425 (python)

Fixed submission:
# 人数を入力する
N = int(input())
# 名前を入力する
S = [input() for _ in range(N)]
# 単語をwordとする
word = "MARCH"
# 単語の文字数をsとする
n = len(word)
# 単語の各文字を頭文字とする人数を格納する辞書を初期化する
dic_initial = dict()
for letter in word:
    dic_initial[letter] = 0
# 単語の各文字を頭文字とする人数を調べる
for i in range(N):
    # 頭文字が単語の各文字のいずれかである場合
    if S[i][0] in dic_initial:
        # dic_initial内の人数を更新する
        dic_initial[S[i][0]] += 1
# 人の選び方の組み合わせの数を初期化する
ans = 0
# 3つの文字の組み合わせ全てについて、人の選び方の組み合わせの数を調べる
for p in range(n - 2):
    # 単語の頭からp番目の文字を頭文字とする人の数をnum_pとする
    num_p = dic_initial[word[p]]
    # num_pが0の場合、以降の処理は行わず、次の繰り返しに移る
    if num_p == 0:
        continue
    for q in range(p + 1, n - 1):
        num_q = dic_initial[word[q]]
        if num_q == 0:
            continue
        for r in range(q + 1, n):
            num_r = dic_initial[word[r]]
            ans += num_p * num_q * num_r
# 出力する
print(ans)

Buggy submission (verdict: Runtime Error):
# 人数を入力する
N = int(input())
# 名前を入力する
S = [input() for _ in range(N)]
# 単語をwordとする
word = "MARCH"
# 単語の文字数をsとする
n = len(word)
# 単語の各文字を頭文字とする人数を格納する辞書を初期化する
dic_initial = dict()
for letter in word:
    dic_initial[letter] = 0
# 単語の各文字を頭文字とする人数を調べる
for i in range(N):
    # 頭文字が単語の各文字のいずれかである場合
    if S[i][0] in dic_initial:
        # dic_initial内の人数を更新する
        dic_initial[S[i][0]] += 1
# 人の選び方の組み合わせの数を初期化する
ans = 0
# 3つの文字の組み合わせ全てについて、人の選び方の組み合わせの数を調べる
for p in range(n - 2):
    # 単語の頭からp番目の文字を頭文字とする人の数をnum_pとする
    num_p = dic_initial[word[p]]
    # num_pが0の場合、以降の処理は行わず、次の繰り返しに移る
    if num_p == 0:
        continue
    for q in range(p + 1, n - 1):
        num_q = dic_initial[word[q]]
        if num_q == 0:
            continue
        for r in range(q + 1, n):
            ans += num_p * num_q *num_r
# 出力する
print(ans)
Problem p03695 (python)

Fixed submission:
import numpy as np
# 参加人数を入力する
N = int(input())
# レートを入力する
a = list(map(int, input().split()))
# ndarray型に変換
arr_a = np.array(a)
# 3200未満のレートを持つ人について、色の種類数を設定する
under3200 = 0
# 色ごとのレートの下限と上限を設定
lower = 1
upper = 399
# 上限が3200未満である限り繰り返す
while upper < 3200:
    # 範囲内のレートを持つ人がいる場合、色の種類数を増やす
    if len(arr_a[(arr_a  >= lower) & (arr_a <= upper)]) != 0:
        under3200 += 1
    # 下限と上限を更新する
    lower = upper + 1
    upper += 400
# 3200を超えるレートを持つ人の数を数える
over3200 = len(arr_a[arr_a >= 3200])

# 色の種類数の最小値について
if under3200 != 0:
    min_color = under3200
else:
    min_color = 1
# 色の種類数の最大値について
max_color = under3200 + over3200
# 結果を出力する
print("{} {}".format(min_color, max_color))

Buggy submission (verdict: Runtime Error):
import numpy as np
# 参加人数を入力する
N = int(input())
# レートを入力する
a = list(map(int, input().split()))
# ndarray型に変換
arr_a = np.array(a)
# 3200未満のレートを持つ人について、色の種類数を設定する
under3200 = 0
# 色ごとのレートの下限と上限を設定
lower = 1
upper = 399
# 上限が3200未満である限り繰り返す
while upper < 3200:
    # 範囲内のレートを持つ人がいる場合、色の種類数を増やす
    if len(arr_a[(arr_a  >= lower) & (arr_a <= upper)]) != 0:
        under3200 += 1
    # 下限と上限を更新する
    lower = upper + 1
    upper += 400
# 3200を超えるレートを持つ人の数を数える
over3200 = len(arr_a[arr_a >= 3200])

# 色の種類数の最小値について
if under3200 != 0:
    under3200
else:
    min_color = 1
# 色の種類数の最大値について
max_color = under3200 + over3200
# 結果を出力する
print("{} {}".format(min_color, max_color))

Buggy submission (verdict: Runtime Error):
import numpy as np
# 参加人数を入力する
N = int(input())
# レートを入力する
a = list(map(int, input().split()))
# ndarray型に変換
arr_a = np.array(a)
# 3200未満のレートを持つ人について、色の種類数を設定する
under3200 = 0
# 色ごとのレートの下限と上限を設定
lower = 1
upper = 399
# 上限が3200未満である限り繰り返す
while upper < 3200:
    # 範囲内のレートを持つ人がいる場合、色の種類数を増やす
    if len(arr_a[(arr_a  >= lower) & (arr_a <= upper)]) != 0:
        under3200 += 1
    # 下限と上限を更新する
    lower = upper + 1
    upper += 400
# 3200を超えるレートを持つ人の数を数える
over3200 = len(arr_a[arr_a >= 3200])

# 色の種類数の最小値について
if under3200 != 0:
    under3200
else:
    min_color = 1
# 色の種類数の最大値について
max_color = under3200 + over3200
# 結果を出力する
print("{} {}".format(min_color, max_color))

Buggy submission (verdict: Runtime Error):
import numpy as np
# 参加人数を入力する
N = int(input())
# レートを入力する
a = list(map(int, input().split()))
# ndarray型に変換
arr_a = np.array(a)
# 3200未満のレートを持つ人について、色の種類数を設定する
under3200 = 0
# 色ごとのレートの下限と上限を設定
lower = 1
upper = 399
# 上限が3200未満である限り繰り返す
while upper < 3200:
    # 範囲内のレートを持つ人がいる場合、色の種類数を増やす
    if len(arr_a[(arr_a  >= lower) & (arr_a <= upper)]) != 0:
        under3200 += 1
    # 下限と上限を更新する
    lower = upper + 1
    upper += 400
# 3200を超えるレートを持つ人の数を数える
over3200 = len(arr_a[arr_a >= 3200])
# 規定の色の数を設定する
color = 8

# 色の種類数の最小値について
if over3200 <= under3200:
    min_color = under3200
elif over3200 < color:
    min_color = overcolor
else:
    min_color = 8
# 色の種類数の最大値について
if under3200 + over3200 < color:
    max_color = under3200 + over3200
else:
    max_color = color
# 結果を出力する
print("{} {}".format(min_color, max_color))
Problem p03309 (python)

Fixed submission:
#ABC102C
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
b=0
ans=0
for i in range(N):
    B[i]=A[i]-(i+1)
B_sorted=sorted(B)
if N%2==0:
    b=(B_sorted[int(N/2)]+B_sorted[int(N/2-1)])//2
else:
    b=(B_sorted[N//2])
for i in range(N):
    ans+=abs(A[i]-(b+i+1))
print(int(ans))

Buggy submission (verdict: Runtime Error):
#ABC102C
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
b=0
ans=0
for i in range(N):
    B[i]=A[i]-(i+1)
B_sorted=sorted(B)
if N%2==0:
    b=(B_sorted[N/2]+B_sorted[N/2-1])//2
else:
    b=(B_sorted[N//2])
for i in range(N):
    ans+=abs(A[i]-(b+i+1))
print(int(ans))

Buggy submission (verdict: Runtime Error):
#ABC102C
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
b=0
ans=0
for i in range(N):
    B[i]=A[i]-(i+1)
B_sorted=sorted(B)
if N%2==0:
    b=(B_sorted[N/2]+B_sorted[N/2-1])//2
else:
    b=(B_sorted[N//2])
for i in range(N):
    ans+=abs(A[i]-(b+i+1))
print(ans)

Buggy submission (verdict: Runtime Error):
#ABC102C
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
b=0
ans=0
for i in range(N):
    B[i]=A[i]-(i+1)
B_sorted=sorted(B)
if N%2==0:
    b=(B[N/2]+B[N/2-1])//2
else:
    b=(B[N//2])
for i in range(N):
    ans+=abs(A[i]-(b+i+1))
print(int(ans))

Buggy submission (verdict: Runtime Error):
#ABC102C
N=int(input())
A=list(map(int, input().split()))
B=[0]*N
b=0
ans=0
for i in range(N):
    B[i]=A[i]-(i+1)
B_sorted=sorted(B)
if N%2==0:
    b=(B[N/2]+B[N/2-1])//2
else:
    b=(B[N//2])
for i in range(N):
    ans+=A[i]-(b+i+1)
print(ans)
Problem p03487 (python)

Fixed submission:
#ABC082C
N=int(input())
a_sorted=sorted(list(map(int,input().split())))
#必要な変数の作成
Allowable_original=0
Allowable_count=0
Delete_count=0
#aが要素1個のみの場合
if N==1:
    if a_sorted[0]==1:
        print(0)
    else:
        print(1)
    exit()
#順番にチェック
for i in range(N):
    #開始処理
    if i==0:
        #許容個数カウントとその元値を作成
        Allowable_original=a_sorted[0]
        Allowable_count=Allowable_original-1
        continue

    #前の数字と同じか否か
    # 同じなら、
    if a_sorted[i]==a_sorted[i-1]:
        #許容個数カウントを一つ減らす
        Allowable_count-=1
    # 違うなら、または末尾なら、
    if a_sorted[i]!=a_sorted[i-1]:
        # 許容個数カウントの現在値が正か0か負かチェック
        # 正なら、
        if Allowable_count>0:
            #カウントしてきた許容個数（許容個数カウントの元値-現在値）を削除対象カウントに追加
            Delete_count+=Allowable_original-Allowable_count
        #0以下なら、
        else:
            # -1をかけた値を削除対象カウントに追加
            Delete_count-=Allowable_count
        # 許容個数カウントとその元値を新規作成
        Allowable_original = a_sorted[i]
        Allowable_count = Allowable_original - 1
    #末尾なら、
    if i==N-1:
        # 許容個数カウントの現在値が正か0か負かチェック
        # 正なら、
        if Allowable_count>0:
            #カウントしてきた許容個数（許容個数カウントの元値-現在値）を削除対象カウントに追加
            Delete_count+=Allowable_original-Allowable_count
        #0以下なら、
        else:
            # -1をかけた値を削除対象カウントに追加
            Delete_count-=Allowable_count
#結果出力
print(Delete_count)

Buggy submission (verdict: Runtime Error):
#ABC083
import math
X, Y=map(int,input().split())
print(int(math.log(Y/X, 2)//1+1))

Buggy submission (verdict: Runtime Error):
#ABC083
import math
X, Y=map(int,input().split())
print(int(math.log(Y//X, 2)+1))

Buggy submission (verdict: Runtime Error):
#ABC083
import math
X, Y=map(int,input().split())
print(int(math.log(Y//X, 2)+1))
Problem p03557 (python)

Fixed submission:
#ABC077C 解説を見て自作
import bisect
N=int(input())
A=sorted(list(map(int,input().split())))
B=sorted(list(map(int,input().split())))
C=sorted(list(map(int,input().split())))
#あるBの下にいくつCが入るか数える
C_under_B=[0]*N     #i番目のBの下に入るCの数
for i in range(N):
    C_under_B[i]=N-bisect.bisect_right(C,B[i])
#あるBの上にいくつAが乗るか数える
A_on_B=[0]*N     #i番目のBの上に乗るAの数
for i in range(N):
    A_on_B[i]=bisect.bisect_left(A,B[i])
#あるBの上下におけるものを数えて出力
ans=0
for i in range(N):
    ans+=C_under_B[i]*A_on_B[i]
print(ans)

Buggy submission (verdict: Runtime Error):
#ABC077C
N=int(input())
#大きい順に# 並べる
A=sorted(list(map(int,input().split())), reverse=True)
B=sorted(list(map(int,input().split())), reverse=True)
C=sorted(list(map(int,input().split())), reverse=True)
#あるBの下にいくつCが入るか数える
C_under_B=[0]*N     #i番目のBの下に入るCの数
for i in range(N):
    if j > 0:
        if B[i] == B[i-1]:
            C_under_B[i]=C_under_B[i-1]
            continue
    for j in range(N):
        if C[j]>B[i]:
            C_under_B[i]+=1
        else:       #C[j+1]>C[j]>B[i]なので検討を中止する
            break
#あるAの下にいくつBが入るか数える
B_under_A=[0]*N     #i番目のBの下に入るCの数
for i in range(N):
    if j > 0:
        if A[i] == A[i-1]:
            B_under_A[i]=B_under_A[i-1]
            continue
    for j in range(N):
        if B[j]>A[i]:
            B_under_A[i]+=1
        else:       #B[j+1]>B[j]>A[i]なので検討を中止する
            break
#あるAのもとに入るBのもとに入るCを数える
C_under_B_under_A=[0]*N
for i in range(N):
    C_under_B_under_A[i]=sum([C_under_B[j] for j in range(B_under_A[i])])
#出力
print(sum(C_under_B_under_A))
Problem p03607 (python)

Fixed submission:
#ABC073C
N=int(input())
A=[int(input()) for i in range(N)]
A_sorted=sorted(A)
count=1
ans=0
for i in range(N-1):
    if A_sorted[i]==A_sorted[i+1]:
        count+=1
    else:
        ans+=count%2
        count=1
ans+=count%2
print(ans)

Buggy submission (verdict: Runtime Error):
#ABC073C
N=int(input())
A=[int(input()) for i in range(N)]
A_sorted=sorted(A)
count=1
ans=0
for i in range(N-1):
    if A_sorted[i]==A_sorted[i+1]:
        count+=1
    else
        ans+=count%2
        count=1
ans+=count%2
print(ans)
Problem p03611 (python)

Fixed submission:
#ABC072C
N=int(input())
A=list(map(int,input().split()))
max_A=max(A)
TGS=[0]*(max_A+1)
ans=0
for i in range(N):
    TGS[A[i]]+=1
for i in range(max_A-1):
    if ans<TGS[i]+TGS[i+1]+TGS[i+2]:
        ans=TGS[i]+TGS[i+1]+TGS[i+2]
if max_A<2:
    ans=N
print(ans)

Buggy submission (verdict: Runtime Error):
#ABC072C
N=int(input())
A=list(map(int,input().split()))
max_A=max(A)
TGS=[0]*(max_A+1)
ans=0
for i in range(N):
    TGS[A[i]]+=1
for i in range(max_A):
    if ans<TGS[i]+TGS[i+1]+TGS[i+2]:
        ans=TGS[i]+TGS[i+1]+TGS[i+2]
print(ans)