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

Fixed submission:
import os, sys, re, math


def get_exp_value(number):
    if number == 0:
        return 0
    a = (number + 1) / number
    exp = a * (number // 2)
    if number % 2 != 0:
        exp += a / 2

    return exp


(N, K) = [int(n) for n in input().split()]
P = [int(n) for n in input().split()]

exps = [get_exp_value(i) for i in range(200001)]

s = sum(P[0:K])
max_sum = 0
max_pos = 0
for i in range(K, N):
    s = s - P[i - K] + P[i]
    if s > max_sum:
        max_sum = s
        max_pos = i

answer = 0
for i in range(max_pos - K, max_pos):
    answer += exps[P[i + 1]]

print(answer)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math


def get_exp_value(number):
    if number == 0:
        return 0
    a = (number + 1) / number
    exp = a * (number // 2)
    if number % 2 != 0:
        exp += a / 2

    return exp


(N, K) = [int(n) for n in input().split()]
P = [int(n) for n in input().split()]

exps = [get_exp_value(i) for i in range(100)]

s = sum(P[0:K])
max_sum = 0
max_pos = 0
for i in range(K, N):
    s = s - P[i - K] + P[i]
    if s > max_sum:
        max_sum = s
        max_pos = i

answer = 0
for i in range(max_pos - K, max_pos):
    answer += exps[P[i + 1]]

print(answer)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]
P = [int(n) for n in input().split()]

def get_exp_value(number):
    if number == 0:
        return 0
    a = (number + 1) / number
    exp = a * (number // 2)
    if number % 2 != 0:
        exp += a / 2

    return exp

exps = [get_exp_value(i) for i in range(200001)]

max_sum = sum(P[0:K])
max_pos = 0
for i in range(K, N):
    s = max_sum - P[i - K] + P[i]
    if s > max_sum:
        max_sum = s
        max_pos = i - K

answer = 0
for i in range(max_pos, max_pos + K):
    answer += get_exp_value(P[i + 1])
    #answer += exps[P[i + 1]]

print(answer)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]
P = [int(n) for n in input().split()]

def get_exp_value(number):
    if number == 0:
        return 0
    a = (number + 1) / number
    exp = a * (number // 2)
    if number % 2 != 0:
        exp += a / 2

    return exp

exps = [get_exp_value(i) for i in range(200001)]

max_sum = sum(P[0:K])
max_pos = 0
for i in range(K, N):
    s = max_sum - P[i - K] + P[i]
    if s > max_sum:
        max_sum = s
        max_pos = i - K

answer = 0
for i in range(max_pos, max_pos + K):
    #answer += get_exp_value(P[i + 1])
    answer += exps[P[i + 1]]

print(answer)
Problem p02995 (python)

Fixed submission:
import os, sys, re, math

def gcd(a, b):
    while b:
        a, b = b, a % b
    return a

def lcm(x, y):
    return (x * y) // gcd(x, y)

(A, B, C, D) = [int(n) for n in input().split()]

minC = (A + (C - 1)) // C
maxC = B // C

minD = (A + (D - 1)) // D
maxD = B // D

CD = lcm(C, D)
minCD = (A + (CD - 1)) // CD
maxCD = B // CD

countC = maxC - minC + 1
countD = maxD - minD + 1
countCD = maxCD - minCD + 1

print(B - A - (countC + countD - countCD) + 1)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

def lcm(x, y):
    return (x * y) // math.gcd(x, y)

(A, B, C, D) = [int(n) for n in input().split()]

minC = (A + (C - 1)) // C
maxC = B // C

minD = (A + (D - 1)) // D
maxD = B // D

CD = lcm(C, D)
minCD = (A + (CD - 1)) // CD
maxCD = B // CD

countC = maxC - minC + 1
countD = maxD - minD + 1
countCD = maxCD - minCD + 1

print(B - A - (countC + countD - countCD) + 1)
Problem p03043 (python)

Fixed submission:
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]

if K == 1:
    print(1)
else:
    lk = math.log2(K - 1)
    p = 0
    for i in range(1, N + 1):
        if i >= K:
            p += 1.0
        else:
            p += (0.5 ** (int(lk - math.log2(i) + 1)))
    print(p / N)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]

lk = math.log2(K - 1)

p = 0
for i in range(1, N + 1):
    if i >= K:
        p += 1.0
    else:
        p += (0.5 ** (int(lk - math.log2(i) + 1)))

print(p / N)

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

(N, K) = [int(n) for n in input().split()]

lk = math.log2(K - 1)

p = 0
for i in range(1, N + 1):
    if i >= K:
        p += 1.0
    else:
        p += (0.5 ** (int(lk - math.log2(i) + 1)))
    print(int(lk - math.log2(i) + 1))

print(p / N)
Problem p03294 (python)

Fixed submission:
import os, sys, re, math

from functools import reduce
from fractions import gcd
def lcm(vals):
    return reduce((lambda x, y: (x * y) // gcd(x, y)), vals, 1)

lines = sys.stdin.readlines()

n = int(lines[0])
a = [int(k) for k in lines[1].split()]

m = lcm(a) - 1
print (sum([m % k for k in a]))

Buggy submission (verdict: Runtime Error):
import os, sys, re, math

from functools import reduce
def lcm(vals):
    return reduce((lambda x, y: (x * y) // math.gcd(x, y)), vals, 1)

lines = sys.stdin.readlines()

n = int(lines[0])
a = [int(k) for k in lines[1].split()]

m = lcm(a) - 1
print (sum([m % k for k in a]))
Problem p02775 (python)

Fixed submission:
n = input()
lenn = len(n)

dp = [0, 10000]
for d in reversed(n):
    d = int(d)
    dp = [min(d + dp[0], d + 1 + dp[1]), min(10 - d + dp[0], 9 - d + dp[1])]

print(min(dp[0], 1 + dp[1]))

Buggy submission (verdict: Runtime Error):
import functools
import sys

sys.setrecursionlimit(10000000)
n = input()
memo = {}
lenn = len(n)
@functools.lru_cache(None)
def dp(index, carry):
    if index >= lenn:
        return 99999999999999999999 if carry else 0
    v = int(n[index])
    if carry:
        # ぴったり払う
        temp = 10 - v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 9 - v + dp(index+1, 1))
    else:
        # ぴったり払う
        temp = v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 1 + v + dp(index+1, 1))
    return temp

print(min(dp(0, 0), 1 + dp(0, 1)))

Buggy submission (verdict: Runtime Error):
import functools
import sys

sys.setrecursionlimit(1000000000)
n = input()
memo = {}

@functools.lru_cache(None)
def dp(index, carry):
    if index >= len(n):
        return 99999999999999999999 if carry else 0
    v = int(n[index])
    if carry:
        # ぴったり払う
        temp = 10 - v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 9 - v + dp(index+1, 1))
    else:
        # ぴったり払う
        temp = v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 1 + v + dp(index+1, 1))
    return temp

print(min(dp(0, 0), 1 + dp(0, 1)))

Buggy submission (verdict: Runtime Error):
import functools
import sys

sys.setrecursionlimit(10000000)
n = input()
memo = {}

@functools.lru_cache(None)
def dp(index, carry):
    if index >= len(n):
        return 99999999999999999999 if carry else 0
    v = int(n[index])
    if carry:
        # ぴったり払う
        temp = 10 - v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 9 - v + dp(index+1, 1))
    else:
        # ぴったり払う
        temp = v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 1 + v + dp(index+1, 1))
    return temp

print(min(dp(0, 0), 1 + dp(0, 1)))

Buggy submission (verdict: Runtime Error):
import functools
n = input()
memo = {}

@functools.lru_cache(None)
def dp(index, carry):
    if index >= len(n):
        return 99999999999999999999 if carry else 0
    v = int(n[index])
    if carry:
        # ぴったり払う
        temp = 10 - v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 9 - v + dp(index+1, 1))
    else:
        # ぴったり払う
        temp = v + dp(index+1, 0)
        # お釣りありで払う
        temp = min(temp, 1 + v + dp(index+1, 1))
    return temp

print(min(dp(0, 0), 1 + dp(0, 1)))

Buggy submission (verdict: Runtime Error):
s = input()
ans = 0
index = 0
rev = {'0': '9',
       '1': '8',
       '2': '7',
       '3': '6',
       '4': '5',
       '5': '4',
       '6': '3',
       '7': '2',
       '8': '1',
       '9': '0'}
def f(n):
    global ans, index

    lenn = len(n)
    while index < lenn and (n[index] < '5' or (n[index] == '5' and (index == lenn - 1 or n[index+1] <= '4'))):
        ans += int(n[index])
        index += 1
    if index < lenn:
        ans += 1
        f(''.join([rev[t] for t in n if t]))
f(s)
print(ans)
Problem p02850 (python)

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

# 昔同じ問題を atcoder で見た？
n = int(input())
edges = []
paths = {}
for i in range(n-1):
    a, b = list(map(int, input().split(' ')))
    edges.append((a, b))
    paths[a] = paths.get(a, []) + [b]
    paths[b] = paths.get(b, []) + [a]
# print(edges)
# print(paths)
colors = {}  # (a->b) 1 とか
current = 1
biggest = 1
def f(current, prev, prev_color):
    global biggest
    color = 0
    for vertex in paths[current]:
        if vertex == prev:
            continue
        color += 1
        if color == prev_color:
            color += 1
        biggest = max(biggest, color)
        colors[(current, vertex)] = color
        f(vertex, current, color)
f(1, None, None)

print(biggest)
for a, b in edges:
    print(colors[(a, b)])
# pypy3

Buggy submission (verdict: Runtime Error):
# 昔同じ問題を atcoder で見た？
n = int(input())
edges = []
paths = {}
for i in range(n-1):
    a, b = list(map(int, input().split(' ')))
    edges.append((a, b))
    paths[a] = paths.get(a, []) + [b]
    paths[b] = paths.get(b, []) + [a]
# print(edges)
# print(paths)
colors = {}  # (a->b) 1 とか
current = 1
biggest = 1
def f(current, prev, prev_color):
    global biggest
    color = 0
    for vertex in paths[current]:
        if vertex == prev:
            continue
        color += 1
        if color == prev_color:
            color += 1
        biggest = max(biggest, color)
        colors[(current, vertex)] = color
        f(vertex, current, color)
f(1, None, None)

print(biggest)
for a, b in edges:
    print(colors[(a, b)])
Problem p02865 (python)

Fixed submission:
n = int(input())
ans = 0
for i in range(1, (n+1)//2):
  ans += 1
print(ans)

Buggy submission (verdict: Runtime Error):
n = int(input())
ans = 0
for i in range(n//2):
  ans += 1
printt(ans)
Problem p02866 (python)

Fixed submission:
n = int(input())
ls = list(map(int, input().split(' ')))
m = max(set(ls))
d = {}
for l in ls:
    d[l] = d.get(l, 0) + 1
ans = 0 if (ls[0] != 0 or d.get(0) >= 2) else 1
for i in range(1, m+1):
    if i not in d:
        ans = 0
    ans = (ans * (d.get(i-1, 0) ** d.get(i, 0))) % 998244353 
print(ans)

Buggy submission (verdict: Runtime Error):
n = int(input())
ls = list(map(int, input().split(' ')))
ans = 1
m = max(set(ls))
d = {}
for l in ls:
    d[l] = d.get(l, 0) + 1
if ans != 0:
    for i in range(1, m+1):
        if d.get(i, 0) == 0:
            ans = 0
            break
        ans = (ans * (d[i-1] ** d[i])) % 998244353
print(ans)

Buggy submission (verdict: Runtime Error):
n = int(input())
ls = list(map(int, input().split(' ')))
ans = 1
if ls[0] != 0:
    ans = 0
m = max(set(ls))
if m > n:
    ans = 0
# d = {i: ls.count(i) for i in range(m+1)}
d = {}
for l in ls:
    d[l] = d.get(l, 0) + 1
if ans != 0:
    for i in range(1, m+1):
        ans = (ans * (d[i-1] ** d[i]) % 998244353) % 998244353
print(ans)
Problem p02909 (python)

Fixed submission:
d = dict(
    Sunny='Cloudy',
    Cloudy='Rainy',
    Rainy='Sunny'
)
print(d[input()])

Buggy submission (verdict: Runtime Error):
import bisect
N, M = list(map(int, input().split(' ')))
As = list(map(int, input().split(' ')))
# osoi
As = sorted([-a for a in As])
while M:
    hoge = -As.pop(0) // 2
    M -= 1
    while M and As and hoge < As[1]:
        hoge = hoge // 2
        M -= 1
    bisect.insort(As, -hoge)
print(-sum(As))
Problem p02936 (python)

Fixed submission:
from collections import deque

n, k = list(map(int,input().split(' ')))
path = []
for i in range(n+1):
    path.append([])
for i in range(n-1):
    a, b = list(map(int,input().split(' ')))
    path[a].append(b)
    path[b].append(a)
val = [0] * (n+1)
for i in range(k):
    v, pt = list(map(int,input().split(' ')))
    val[v] += pt

used = {}
q = deque([1])
used[1] = True
while q:
    v = q.pop()
    for next_v in path[v]:
        if next_v not in used:
            used[next_v] = True
            val[next_v] += val[v]
            q.append(next_v)

print(' '.join([str(pt) for pt in val[1:]]))

Buggy submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(100001)

n, k = list(map(int,input().split(' ')))
path = []
for i in range(n+1):
    path.append([])
for i in range(n-1):
    a, b = list(map(int,input().split(' ')))
    path[a].append(b)
val = [0] * (n+1)
for i in range(k):
    v, pt = list(map(int,input().split(' ')))
    val[v] += pt
# DFS
def f(current):
    for next_v in path[current]:
        val[next_v] += val[current]
        if path[next_v]:
            f(next_v)

f(1)

print(' '.join([str(pt) for pt in val[1:]]))

Buggy submission (verdict: Runtime Error):
import sys
sys.setrecursionlimit(100000)

n, k = list(map(int,input().split(' ')))
path = []
for i in range(n+1):
    path.append([])
for i in range(n-1):
    a, b = list(map(int,input().split(' ')))
    path[a].append(b)
val = [0] * (n+1)
for i in range(k):
    v, pt = list(map(int,input().split(' ')))
    val[v] += pt
# BFS
# q = [1]
# while q:
#     v = q.pop(0)
#     for next_v in path[v]:
#         val[next_v] += val[v]
#         q.append(next_v)

# DFS
def f(current):
    for next_v in path[current]:
        val[next_v] += val[current]
        f(next_v)

f(1)

print(' '.join([str(pt) for pt in val[1:]]))
Problem p02957 (python)

Fixed submission:
a, b = map(int, raw_input().split(' '))
print (a + b) / 2 if (a + b) % 2 == 0 else 'IMPOSSIBLE'

Buggy submission (verdict: Runtime Error):
a, b = list(map(int, input().split(' ')))
print((a+b) // 2 if a + b % 2 == 0 else 'IMPOSSIBLE)
Problem p03000 (python)

Fixed submission:
k, n = list(map(int, input().split(' ')))
l = list(map(int, input().split(' ')))
ct = 0
ans = 1
i = 0
while ct <= n and i < len(l):
  ct += l[i]
  ans += (ct <= n)
  i += 1
print(ans)

Buggy submission (verdict: Runtime Error):
k, n = list(map(int, input().split(' ')))
l = list(map(int, input().split(' ')))
ct = 0
ans = 1
i = 0
while ct <= n:
  ct += l[i]
  ans += (ct <= n)
  i += 1
print(ans)
Problem p03001 (python)

Fixed submission:
w, h, x, y = list(map(int, input().split(' ')))
hoge = w / 2 == x
fuga = h / 2 == y
print('%.6f %s' % ((w*h) / 2, int(hoge and fuga)))

Buggy submission (verdict: Runtime Error):
w, h, x, y = list(map(int, input().split(' ')))
hoge = abs(y/x) == 1
print('%.6f %s' % ((w*h) / 2, int(hoge)))
Problem p03128 (python)

Fixed submission:
n, m = list(map(int, input().split(' ')))
l = list(map(int, input().split(' ')))
d = {}
# 1 = 2 = 0.5
d[2] = [1]
# 7 = 3 = 2.3 
d[3] = [7]
# 4 = 4 = 1
d[4] = [4]
# 5 = 5 = 1
# 3 = 5 = .6
# 2 = 5 = .4
d[5] = [5, 3, 2]
# 9 = 6 = 1.5
# 6 = 6 = 1
d[6] = [9, 6]
# 8 = 7 = 1.1...
d[7] = [8]
enable = [False] * 10
for a in l:
  enable[a] = True
memo = {}
def f(nokori, current):
#  print(nokori, current)
  k = (nokori, current)  # 順不同
  if k in memo:
    return memo[k]
  if nokori == 0:
    return current
  if nokori < 0:
    return -1
  temps = []
  for key, nums in list(d.items())[::-1]:
    # print(key, nums, type(nums))
    for num in nums:
      if enable[num]:
        if nokori-key != 0 and current % 10 != 0 and current % 10 < num:
          continue
        temps.append(f(nokori-key, current*10+num))
        break
  memo[k] = max(temps)
  return memo[k]

# pre
hoge = False
for key, nums in list(d.items()):
    # print(key, nums, type(nums))
    for num in nums:
      if enable[num]:
        hoge = True
        break
    if hoge:
      break
cs = []
while n > 50:  #
  n -= key
  cs.append(str(num))
num_ans = str(f(n, 0))
print(''.join(sorted(list(num_ans) + cs)[::-1]))

Buggy submission (verdict: Runtime Error):
l = list(map(int, input().split(' ')))
d = {}  # key=match, val=num
d[2] = [1]
d[3] = [7]
d[4] = [4]
d[5] = [5, 3, 2]
d[6] = [9, 6]
d[7] = [8]
enable = [False] * 10
for a in l:
  enable[a] = True
memo = {}
# マッチをk(=2..7)本使う場合の一番大きい値を総当たり
def f(nokori, current):
  k = (nokori, current)
  if k in memo:
    return memo[k]
  if nokori <= 0:
    return current if nokori == 0 else -1
  temps = []
  for key, nums in list(d.items())[::-1]:
    for num in nums:
      if enable[num]:
        temps.append(f(nokori-key, current*10+num))
        break
  memo[k] = max(temps)
  return memo[k]
 
# 余裕があるうちは一番マッチの本数が少ないモノをヤケクソで詰めまくる
hoge = False
for key, nums in list(d.items()):
    for num in nums:
      if enable[num]:
        hoge = True
        break
    if hoge:
      break
cs = []
while n > 50:
  n -= key
  cs.append(str(num))

# ヤケクソで詰めたやつと総当たりで調べたマックスを並び替えて辞書順で大きくする
ans = str(f(n, 0))
print(''.join(sorted(list(ans) + cs)[::-1]))
Problem p03290 (python)

Fixed submission:
import sys
sys.setrecursionlimit(10000)
D, G = list(map(int, input().split(' ')))
left = {}
bonus = {}
for i in range(1, D+1):
    left[i], bonus[i] = list(map(int, input().split(' ')))
 
big = 9999999
 
probably_ans = big
memo = {}
def hogehoge(depth, index, pt, left, bonus, probably_ans):
    key = (depth, index, pt, str(left))
    if key in memo:
        return memo[key]
    if pt >= G:
        return depth
    if depth >= probably_ans or index > D:  # 遅いかも
        return big
    
    # 一つも引かない
    probably_ans = min(probably_ans, hogehoge(depth, index + 1, pt, left, bonus, probably_ans))
    
    # 全部引いて index reset
    for k in range(0, D - index + 1):
        if left[index + k]:
            temp = left[index + k]
            left[index + k] = 0
            probably_ans = min(probably_ans, hogehoge(depth+temp, 1, pt + (index + k) * 100 * temp + bonus[index + k], left, bonus, probably_ans))
            left[index + k] = temp

    # 歯抜け状態から行けそうならクリア
    if left[index]:
        if pt + index * 100 * left[index] + bonus[index] >= G:
            for i in range(1, left[index] + 1):
                left[index] = left[index] - i
                new_pt = pt + index * 100 * i + bonus[index] * (left[index] == 0)
                if (new_pt >= G):
                    probably_ans = min(probably_ans, hogehoge(depth+i, index+1, new_pt, left, bonus, probably_ans))
                left[index] = left[index] + i
    memo[key] = probably_ans
    return probably_ans
    
print(hogehoge(0, 1, 0, left, bonus, probably_ans))

Buggy submission (verdict: Runtime Error):
D, G = list(map(int, input().split(' ')))
left = {}
bonus = {}
for i in range(1, D+1):
    left[i], bonus[i] = list(map(int, input().split(' ')))

big = 9999999

probably_ans = big
def hogehoge(depth, index, pt, left, bonus, probably_ans):
    if depth >= probably_ans:  # 遅いかも
        return big
    if pt >= G:
        return depth
    for i in range(index, D+1):
        if left[i] == 0:
            continue
        left[i] = left[i] - 1
        probably_ans = min(probably_ans, hogehoge(depth+1, i, pt + i * 100 + bonus[i] * (left[i] == 0), left, bonus, probably_ans))
        left[i] = left[i] + 1
    return probably_ans
    
print(hogehoge(0, 1, 0, left, bonus, probably_ans))
Problem p03292 (python)

Fixed submission:
nums = sorted(list(map(int, input().split(' '))))
print(sum([abs(nums[i+1] - nums[i]) for i in range(len(nums) - 1)]))

Buggy submission (verdict: Runtime Error):
N, M = list(map(int, input().split(' ')))
edges = []
for i in range(M):
    a, b = list(map(int, input().split(' ')))
    edges.append([v for v in range(a, b)])

ans = 0
while any(edges):
    hit_index = 0
    max_hit = 0
    edge = []
    for i in range(len(edges)):
        if edges[i]:
            edge = edges[i]
            break
    for v in edge[::-1]:
        hit = 0
        for i in range(M):
            if edges[i] and v in edges[i]:
                hit += 1
            if hit > max_hit:
                max_hit = hit
                hit_index = v
    # print('max_hit')
    # print(max_hit)
    # print('cut here')
    # print(hit_index)
    for i in range(len(edges)):
        if edges[i] and hit_index in edges[i]:
            edges[i] = False
    ans += 1
    # print('cutted')
    # print(edges)
print(ans)
Problem p03323 (python)

Fixed submission:
a, b = map(int, raw_input().split(' '))
print 'Yay!' if a <= 8 and b <= 8 else ':('

Buggy submission (verdict: Runtime Error):
a, b = raw_input()
return 'Yay!' if a <= 8 and b <= 8 else ':('
Problem p02782 (python)

Fixed submission:
r1, c1, r2, c2 = map(int, input().split())

mod = 1000000007

def pow(x, n):
    ret = 1
    while n > 0:
        if (n & 1) == 1:
            ret = (ret * x) % mod
        x = (x * x) % mod
        n //= 2
    return ret

def fac(n):
    ret = 1
    for i in range(1, n + 1):
        ret = (ret * i) % mod
    return ret

def facinv(n):
    return pow(fac(n), mod - 2)

def cmb(n, k):
    if k < 0 or k > n:
        return 0
    return ((fac(n) * facinv(k)) % mod * facinv(n - k)) % mod

def rect(r, c):
    return cmb(r + c, c)

ret = (rect(r2 + 1, c2 + 1) - rect(r1, c2 + 1) - rect(r2 + 1, c1) + rect(r1, c1) + mod + mod) % mod
print(ret)

Buggy submission (verdict: Runtime Error):
r1, c1, r2, c2 = map(int, input().split())

n = 200004
mod = 1000000007

def pow(x, n):
    ret = 1
    while n > 0:
        if (n & 1) == 1:
            ret = (ret * x) % mod
        x = (x * x) % mod
        n //= 2
    return ret

fac = [1]
inv = [1]
for i in range(1, n + 1):
    fac.append((fac[-1] * i) % mod)
    inv.append(pow(fac[i], mod - 2))

def cmb(n, k):
    if k < 0 or k > n:
        return 0
    return ((fac[n] * inv[k]) % mod * inv[n - k]) % mod

def rect(r, c):
    return cmb(r + c, c)

ret = (rect(r2 + 1, c2 + 1) - rect(r1, c2 + 1) - rect(r2 + 1, c1) + rect(r1, c1) + mod + mod) % mod
print(ret)

Buggy submission (verdict: Runtime Error):
r1, c1, r2, c2 = map(int, input().split())

n = 200004
mod = 1000000007

def pow(x, n):
    ret = 1
    while n > 0:
        if (n & 1) == 1:
            ret = (ret * x) % mod
        x = (x * x) % mod
        n //= 2
    return ret

fac = [1]
inv = [1]
for i in range(1, n + 1):
    fac.append((fac[-1] * i) % mod)
    inv.append(pow(fac[i], mod - 2))

def cmb(n, k):
    if k < 0 or k > n:
        return 0
    return ((fac[n] * inv[k]) % mod * inv[n - k]) % mod

def rect(r, c):
    return cmb(r + c, c)

ret = (rect(r2 + 1, c2 + 1) - rect(r1, c2 + 1) - rect(r2 + 1, c1) + rect(r1, c1) + mod + mod) % mod
print(ret)
Problem p02803 (python)

Fixed submission:
h, w = map(int, input().split())
s = [input() for _ in range(h)]

def bfs(x, y):
    q = []
    dp = {}
    def qpush(x, y, t):
        if 0 <= x < w and 0 <= y < h and s[y][x] != '#' and (x, y) not in dp:
            q.append((x, y))
            dp[(x, y)] = t

    qpush(x, y, 0)
    while len(q) > 0:
        (x, y) = q.pop(0)
        qpush(x + 1, y, dp[(x, y)] + 1)
        qpush(x, y - 1, dp[(x, y)] + 1)
        qpush(x - 1, y, dp[(x, y)] + 1)
        qpush(x, y + 1, dp[(x, y)] + 1)
    return dp.get((x, y), 0)

t = 0
for y in range(h):
    for x in range(w):
        t = max(t, bfs(x, y))
print(t)

Buggy submission (verdict: Runtime Error):
h, w = map(int, input().split())
s = [input() for _ in range(h)]

def bfs(x, y):
    q = []
    dp = {}
    def qpush(x, y, t):
        if 0 <= x < w and 0 <= y < h and s[y][x] != '#' and (x, y) not in dp:
            q.append((x, y))
            dp[(x, y)] = t

    qpush(x, y, 0)
    while len(q) > 0:
        (x, y) = q.pop(0)
        qpush(x + 1, y, dp[(x, y)] + 1)
        qpush(x, y - 1, dp[(x, y)] + 1)
        qpush(x - 1, y, dp[(x, y)] + 1)
        qpush(x, y + 1, dp[(x, y)] + 1)
    return (dp[(x, y)], x, y)

(t, x, y) = bfs(0, 0)
(t, x, y) = bfs(x, y)
print(t)