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

Fixed submission:
from collections import deque


class Dinic:
    def __init__(self, n):
        self.n = n
        self.links = [[] for _ in range(n)]
        self.depth = None
        self.progress = None

    def add_link(self, _from, to, cap):
        self.links[_from].append([cap, to, len(self.links[to])])
        self.links[to].append([0, _from, len(self.links[_from]) - 1])

    def bfs(self, s):
        depth = [-1] * self.n
        depth[s] = 0
        q = deque([s])
        while q:
            v = q.popleft()
            for cap, to, rev in self.links[v]:
                if cap > 0 and depth[to] < 0:
                    depth[to] = depth[v] + 1
                    q.append(to)
        self.depth = depth

    def dfs(self, v, t, flow):
        if v == t:
            return flow
        for i, link in enumerate(self.links[v]):
            if i < self.progress[v]:
                continue
            self.progress[v] = i
            cap, to, rev = link
            if cap == 0 or self.depth[v] >= self.depth[to]:
                continue
            d = self.dfs(to, t, min(flow, cap))
            if d == 0:
                continue
            link[0] -= d
            self.links[to][rev][0] += d
            return d
        return 0

    def max_flow(self, s, t):
        flow = 0
        while True:
            self.bfs(s)
            if self.depth[t] < 0:
                return flow
            self.progress = [0] * self.n
            current_flow = self.dfs(s, t, float('inf'))
            while current_flow > 0:
                flow += current_flow
                current_flow = self.dfs(s, t, float('inf'))


n = int(input())
an = list(map(int, input().split()))
mf = Dinic(n + 2)
max_value = 0
for i, a in enumerate(an):
    i += 1
    if a > 0:
        max_value += a
        mf.add_link(i, n + 1, a)
    else:
        mf.add_link(0, i, -a)
    for j in range(2 * i, n + 1, i):
        mf.add_link(i, j, float('inf'))
print(max_value - mf.max_flow(0, n + 1))

Buggy submission (verdict: Runtime Error):
def check(iter, broken):
    iter_ans=0
    for j in iter:
        tmp_sum=0
        tmp_broken=set()
        for t in range(j, n, j+1):
            if t not in broken:
                tmp_sum+=aa[t]
                tmp_broken.add(t)
        # print(ans, j, tmp_broken, broken)
        if tmp_sum < 0:
            iter_ans -= tmp_sum
            broken.update(tmp_broken)
    return iter_ans


n=int(input())
aa=list(map(int,input().split()))
ans=sum(aa)
i=n//2
broken=set()
for j in range(i,n):
    if aa[j] < 0:
        ans -= aa[j]
        broken.add(j)
ccc=0
import random
for _ in range(100):
    c=check(random.shuffle(aa[i]), broken.copy())
    ccc=max(ccc,c)
print(ans+ccc)
Problem p03561 (python)

Fixed submission:
def solve(k, n):
    if k & 1 == 0:
        return [k // 2] + [k] * (n - 1)
    ans = [k // 2 + 1] * n
    l = n
    for i in range((n - 2) // 2 + 1):
        if ans[-1] == 1:
            ans.pop()
            l -= 1
        else:
            ans[-1] -= 1
            if l < n:
                ans += [k] * (n - l)
                l = n
    return ans


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

print(*solve(k, n))

Buggy submission (verdict: Runtime Error):
def solve(k, n):
    if k & 1 == 0:
        return [k // 2] + [k] * (n - 1)
    xs = [((k ** i - 1) // (k - 1)) for i in range(1, -1)]
    xs = [((k ** i - 1) // (k - 1)) for i in range(n + 1, 1, -1)]
    tgt = xs[0] // 2 - 1
    mk1 = k // 2
    mk2 = mk1 + 1
    l = xs[1] * mk1
    ans = []
    for i in range(1, n - 1):
        if l == tgt:
            return ans
        nxt = l + xs[i + 1] * mk1 + 1
        if nxt > tgt:
            ans.append(mk1)
            l = nxt - xs[i + 1]
        else:
            ans.append(mk2)
            l = nxt
    if l == tgt:
        return ans
    return ans + [tgt - l]


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

print(*solve(k, n))

Buggy submission (verdict: Runtime Error):
def solve(k, n):
    if k & 1 == 0:
        return [k // 2] + [k] * (n - 1)
    xs = [((k ** i - 1) // (k - 1)) for i in range(n + 1, 1, -1)]
    tgt = xs[0] // 2 - 1
    mk = k // 2 + 1
    l = xs[1] * (k // 2)
    for i in range(1, n - 1):
        if l == tgt:
            return [mk] * i
        if l > tgt:
            return [mk] * i + [mk - 1] * (n - i)
        l += xs[i + 1] * (k // 2) + 1
    if l == tgt:
        return [mk] * (n - 1)
    return [mk] * (n - 1) + [tgt - l]


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

print(*solve(k, n))
Problem p03570 (python)

Fixed submission:
from string import ascii_lowercase

cd = {c: 1 << i for i, c in enumerate(ascii_lowercase)}
bt = set(cd.values())
bt.add(0)


def solve(s):
    a, b = [], 0
    for c in s:
        b ^= cd[c]
        a.append(b)
    if a[-1] == 0:
        return 1

    dp = {0: 0}
    for b1 in a:
        for b2 in bt:
            b3 = b1 ^ b2
            if b3 not in dp:
                continue
            if b1 in dp:
                dp[b1] = min(dp[b1], dp[b3] + 1)
            else:
                dp[b1] = dp[b3] + 1
    return dp[a[-1]]


print(solve(input()))

Buggy submission (verdict: Runtime Error):
from string import ascii_lowercase
import heapq

cd = {c: 1 << i for i, c in enumerate(ascii_lowercase)}


def solve(s):
    queue = [(0, s)]
    while queue:
        n, s = heapq.heappop(queue)
        if not s:
            return n
        b = 0
        for i, c in enumerate(s):
            b ^= cd[c]
            if bin(b).count('1') <= 1:
                heapq.heappush(queue, (n + 1, s[i + 1:]))


print(solve(input()))
Problem p03588 (python)

Fixed submission:
from operator import add

n = int(input())
print(min(add(*map(int, input().split())) for _ in range(n)))

Buggy submission (verdict: Runtime Error):
from operator import add
n=int(input())
print(min(map(add, map(int, input().split())) for _ in range(n)))
Problem p03602 (python)

Fixed submission:
def solve(n, tbl):
    ans = 0
    for i, row_i in enumerate(tbl):
        for j in range(i + 1, n):
            row_j = tbl[j]
            ij = row_i[j]
            mind = min((ik + kj for ik, kj in zip(row_i, row_j) if ik and kj), default=float('inf'))
            if ij > mind:
                return -1
            if ij < mind:
                ans += ij
    return ans


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

Buggy submission (verdict: Runtime Error):
def solve(n, tbl):
    ans = 0
    for i, row_i in enumerate(tbl):
        for j in range(i + 1, n):
            row_j = tbl[j]
            ij = row_i[j]
            mind = min(ik + kj for ik, kj in zip(row_i, row_j) if ik and kj)
            if ij > mind:
                return -1
            if ij < mind:
                ans += ij
    return ans


n = int(input())
tbl = [list(map(int, input().split())) for _ in range(n)]
print(solve(n, tbl))
Problem p03615 (python)

Fixed submission:
from collections import Counter
from fractions import gcd

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

excludes = 0
for i, (x1, y1) in enumerate(xys):
    slopes = []
    for x2, y2 in xys[i + 1:]:
        dx, dy = x2 - x1, y2 - y1
        if dx == 0:
            slopes.append(1j)
        elif dy == 0:
            slopes.append(1)
        else:
            m = gcd(dx, dy)
            slopes.append(dx // m + dy // m * 1j)
    for c in Counter(slopes).values():
        if c > 1:
            excludes += 2 ** c - c - 1
    excludes %= MOD

print((pow(2, n, MOD) - excludes - (n * (n - 1) // 2) - n - 1) % MOD)

Buggy submission (verdict: Runtime Error):
from collections import Counter
from math import gcd

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

excludes = 0
for i, (x1, y1) in enumerate(xys):
    slopes = []
    for x2, y2 in xys[i + 1:]:
        dx, dy = x2 - x1, y2 - y1
        if dx == 0:
            slopes.append(1j)
        elif dy == 0:
            slopes.append(1)
        else:
            m = gcd(dx, dy)
            slopes.append(dx // m + dy // m * 1j)
    for c in Counter(slopes).values():
        if c > 1:
            excludes += 2 ** c - c - 1
    excludes %= MOD

print((pow(2, n, MOD) - excludes - (n * (n - 1) // 2) - n - 1) % MOD)
Problem p03689 (python)

Fixed submission:
def get_1d(H, h):
    ret = [0] * (H + 1)
    for s in range(h):
        for x, i in enumerate(range(s, H, h)):
            ret[i] = -x
    for x, i in enumerate(range(H, 0, -h)):
        ret[i] = x + 1
    return [x1 - x0 for x0, x1 in zip(ret, ret[1:])]


def solve(H, W, h, w):
    if H % h == 0 and W % w == 0:
        return False
    ans = []
    if H % h > 0:
        col = get_1d(H, h)
        ans.extend([x] * W for x in col)
    else:
        row = get_1d(W, w)
        ans.extend([row] * H)
    return ans


H, W, h, w = map(int, input().split())
ans = solve(H, W, h, w)
if ans == False:
    print('No')
else:
    print('Yes')
    for row in ans:
        print(*row)

Buggy submission (verdict: Runtime Error):
def solve(H, W, h, w):
    if H == 1:
        if W <= 2:
            print('No')
        else:
            kari = (W - 2) // 2 + 1
            if kari >= w - 1:
                print('No')
            else:
                print('Yes')
                print(kari, *([-1] * (W - 2)), kari)
        return
    if W == 1:
        if H <= 2:
            print('No')
        else:
            kari = (H - 2) // 2 + 1
            if kari >= h - 1:
                print('No')
            else:
                print('Yes')
                print(kari)
                for _ in range(H - 2):
                    print(-1)
                print(kari)
        return
    kari = (H * W - 4) // 4 + 1
    if kari >= h * w - 1:
        print('No')
    else:
        print('Yes')
        print(kari, *([-1] * (W - 2)), kari)
        for _ in range(H - 2):
            print(*([-1] * W))
        print(kari, *([-1] * (W - 2)), kari)


H, W, h, w = map(int, input().split())
solve(H, W, h, w)

Buggy submission (verdict: Runtime Error):
def solve(H, W, h, w):
    if H == 1:
        if W <= 2:
            print('No')
        else:
            kari = (W - 2) // 2 + 1
            if kari >= w - 1:
                print('No')
            else:
                print('Yes')
                print(kari, *([-1] * (W - 2)), kari)
        return
    if W == 1:
        if H <= 2:
            print('No')
        else:
            kari = (H - 2) // 2 + 1
            if kari >= h - 1:
                print('No')
            else:
                print('Yes')
                print(kari)
                for _ in range(H - 2):
                    print(-1)
                print(kari)
        return
    kari = (H * W - 4) // 4 + 1
    if kari >= h * w - 1:
        print('No')
    else:
        print('Yes')
        print(kari, *([-1] * (W - 2)), kari)
        for _ in range(H - 2):
            print(*([-1] * W))
        print(kari, *([-1] * (W - 2)), kari)


solve(*map(int, input().split()))
Problem p03691 (python)

Fixed submission:
def get_survivors(n, pairs):
    survivors = {v: {v} for v in range(n)}
    for x, y in reversed(pairs):
        for v, srv in survivors.copy().items():
            if x in srv:
                if y in srv:
                    del survivors[v]
                else:
                    srv.add(y)
            elif y in srv:
                srv.add(x)
    return survivors


def solve(n, pairs):
    survivors = get_survivors(n, pairs)
    ans = 0
    for u, su in survivors.items():
        for v, sv in survivors.items():
            if u >= v:
                continue
            if su.isdisjoint(sv):
                ans += 1
    return ans


n, m = map(int, input().split())
pairs = []
for _ in range(m):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    pairs.append((x, y))
print(solve(n, pairs))

Buggy submission (verdict: Runtime Error):
import sys

from itertools import combinations

n, m = map(int, input().split())
survivors = {v: {v + 1} for v in range(n)}
for x, y in reversed(map(int, line.split()) for line in sys.stdin.readlines()):
    for v, srv in survivors.copy().items():
        if x in srv:
            if y in srv:
                del survivors[v]
            else:
                srv.add(y)
        elif y in srv:
            srv.add(x)
print(sum(su.isdisjoint(sv) for su, sv in combinations(survivors.values(), 2)))

Buggy submission (verdict: Runtime Error):
def get_survivors(n, pairs):
    survivors = {v: {v} for v in range(n)}
    for x, y in reversed(pairs):
        for v, srv in survivors.copy().items():
            if x in srv:
                if y in srv:
                    del survivors[v]
                else:
                    srv.add(y)
            elif y in srv:
                srv.add(x)
    return survivors.values()


def solve(n, pairs):
    survivors = get_survivors(n, pairs)
    ans = 0

    for i, su in enumerate(survivors[:-1]):
        for sv in survivors[i + 1:]:
            if su.isdisjoint(sv):
                ans += 1
    return ans


n, m = map(int, input().split())
pairs = []
for _ in range(m):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    pairs.append((x, y))
print(solve(n, pairs))

Buggy submission (verdict: Runtime Error):
def get_survivors(n, pairs):
    survivors = {v: {v} for v in range(n)}
    for x, y in reversed(pairs):
        for v, srv in survivors.copy().items():
            if x in srv:
                if y in srv:
                    del survivors[v]
                else:
                    srv.add(y)
            elif y in srv:
                srv.add(x)
    return survivors.values()


def solve(n, pairs):
    survivors = get_survivors(n, pairs)
    ans = 0

    for i, su in enumerate(survivors):
        for sv in survivors[i + 1:]:
            if su.isdisjoint(sv):
                ans += 1
    return ans


n, m = map(int, input().split())
pairs = []
for _ in range(m):
    x, y = map(int, input().split())
    x -= 1
    y -= 1
    pairs.append((x, y))
print(solve(n, pairs))
Problem p03703 (python)

Fixed submission:
import sys

import numpy as np


class Bit:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n + 1)

    def sum(self, i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):
        while i <= self.size:
            self.tree[i] += x
            i += i & -i


n, k = map(int, input().split())
aaa = np.fromiter(sys.stdin, dtype=np.int64)
aaa = np.insert(aaa, 0, 0)
acc = np.add.accumulate(aaa) - np.arange(0, k * n + 1, k)
dct = {v: i for i, v in enumerate(np.unique(acc), start=1)}
bit = Bit(len(dct))
ans = 0
for d in acc:
    i = dct[d]
    ans += bit.sum(i)
    bit.add(i, 1)
print(ans)

Buggy submission (verdict: Runtime Error):
import sys

import numpy as np


class Bit:
    def __init__(self, n):
        self.size = n
        self.tree = [0] * (n + 1)

    def sum(self, i):
        s = 0
        while i > 0:
            s += self.tree[i]
            i -= i & -i
        return s

    def add(self, i, x):
        while i <= self.size:
            self.tree[i] += x
            i += i & -i


n, k = map(int, input().split())
aaa = np.fromiter(sys.stdin, dtype=np.int64)
aaa = np.insert(aaa, 0, 0)
acc = np.add.accumulate(aaa) - np.arange(0, k * n + 1, k)
dct = {v: i for i, v in enumerate(np.unique(acc), start=1)}
bit = Bit(n)
ans = 0
for d in acc:
    i = dct[d]
    ans += bit.sum(i)
    bit.add(i, 1)
print(ans)
Problem p03939 (python)

Fixed submission:
def solve(n, d, x):
    ans = 0
    while n:
        ans += d + (2 * n - 1) * x / 2
        d = ((n + 1) * d + 5 * x / 2) / n
        x *= (n + 2) / n
        n -= 1
    return ans


print('{:.10f}'.format(solve(*map(float, input().split()))))

Buggy submission (verdict: Runtime Error):
import sys

sys.setrecursionlimit(200000)


def solve(n, d, x):
    if not n:
        return 0
    return d + (2 * n - 1) * x / 2 + solve(n - 1, ((n + 1) * d + 5 * x / 2) / n, (n + 2) * x / n)


print(solve(*map(int, input().split())))
Problem p03949 (python)

Fixed submission:
import sys

sys.setrecursionlimit(10 ** 7)


def dfs(v, parent, odd):
    hi = INF
    lo = -INF
    if fixed[v] != INF:
        if odd_even[v] != odd:
            print('No')
            exit()
        hi = lo = fixed[v]
    for u in links[v]:
        if u == parent:
            continue
        chi, clo = dfs(u, v, odd ^ 1)
        if hi < clo or chi < lo:
            print('No')
            exit()
        hi = min(hi, chi)
        lo = max(lo, clo)
    upper[v] = hi
    lower[v] = lo
    return hi + 1, lo - 1


def fill(v, parent, pp):
    if pp + 1 > upper[v]:
        assert pp - 1 >= lower[v]
        vp = fixed[v] = pp - 1
    else:
        vp = fixed[v] = pp + 1
    for u in links[v]:
        if u == parent:
            continue
        fill(u, v, vp)


inp = list(map(int, sys.stdin.buffer.read().split()))
n = inp[0]
links = [set() for _ in range(n)]
for a, b in zip(inp[1:2 * n - 1:2], inp[2:2 * n - 1:2]):
    a -= 1
    b -= 1
    links[a].add(b)
    links[b].add(a)
INF = 10 ** 9
k = inp[2 * n - 1]
fixed = [INF] * n
odd_even = {}
fixed_v = 0
for v, p in zip(inp[2 * n::2], inp[2 * n + 1::2]):
    v -= 1
    fixed[v] = p
    odd_even[v] = p % 2
    fixed_v = v

lower = [-INF] * n
upper = [INF] * n
dfs(fixed_v, -1, odd_even[fixed_v])
fill(fixed_v, -1, fixed[fixed_v] + 1)
print('Yes')
print('\n'.join(map(str, fixed)))

Buggy submission (verdict: Runtime Error):
import sys


def dfs(v, parent, odd):
    hi = INF
    lo = -INF
    if fixed[v] != INF:
        if odd_even[v] != odd:
            print('No')
            exit()
        hi = lo = fixed[v]
    for u in links[v]:
        if u == parent:
            continue
        chi, clo = dfs(u, v, odd ^ 1)
        if hi < clo or chi < lo:
            print('No')
            exit()
        hi = min(hi, chi)
        lo = max(lo, clo)
    upper[v] = hi
    lower[v] = lo
    return hi + 1, lo - 1


def fill(v, parent, pp):
    if pp + 1 > upper[v]:
        assert pp - 1 >= lower[v]
        vp = fixed[v] = pp - 1
    else:
        vp = fixed[v] = pp + 1
    for u in links[v]:
        if u == parent:
            continue
        fill(u, v, vp)


inp = list(map(int, sys.stdin.buffer.read().split()))
n = inp[0]
links = [set() for _ in range(n)]
for a, b in zip(inp[1:2 * n - 1:2], inp[2:2 * n - 1:2]):
    a -= 1
    b -= 1
    links[a].add(b)
    links[b].add(a)
INF = 10 ** 9
k = inp[2 * n - 1]
fixed = [INF] * n
odd_even = {}
fixed_v = 0
for v, p in zip(inp[2 * n::2], inp[2 * n + 1::2]):
    v -= 1
    fixed[v] = p
    odd_even[v] = p % 2
    fixed_v = v

lower = [-INF] * n
upper = [INF] * n
dfs(fixed_v, -1, odd_even[fixed_v])
fill(fixed_v, -1, fixed[fixed_v] + 1)
print('Yes')
print('\n'.join(map(str, fixed)))
Problem p03962 (python)

Fixed submission:
print(len(set(input().split())))

Buggy submission (verdict: Runtime Error):
print(len({input().split()}))
Problem p04003 (python)

Fixed submission:
import sys
from collections import deque, defaultdict


def bfs01(s, t, links):
    q = deque([(0, s, -1)])  # cost, station, last-company
    visited = set()
    while q:
        d, v, e = q.popleft()
        if v == t:
            return d
        if (v, e) in visited:
            continue
        visited.add((v, e))
        if e == 0:
            for c in links[v]:
                for u in links[v][c]:
                    if (u, c) in visited:
                        continue
                    q.append((d + 1, u, c))
        else:
            for u in links[v][e]:
                if (u, e) in visited:
                    continue
                q.appendleft((d, u, e))
            if (v, 0) not in visited:
                q.appendleft((d, v, 0))

    return -1


readline = sys.stdin.buffer.readline
read = sys.stdin.buffer.read

n, m = map(int, readline().split())
links = [defaultdict(set) for _ in range(n)]
pqc = list(map(int, read().split()))
for p, q, c in zip(pqc[0::3], pqc[1::3], pqc[2::3]):
    p -= 1
    q -= 1
    links[p][c].add(q)
    links[q][c].add(p)

print(bfs01(0, n - 1, links))

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


def bfs01(s, t, links):
    q = deque([(0, s, -1)])  # cost, station, last-company
    visited = set()
    while q:
        d, v, e = q.popleft()
        if v == t:
            return d
        if (v, e) in visited:
            continue
        visited.add((v, e))
        if e == 0:
            for c, us in links[v]:
                for u in us:
                    if (u, c) in visited:
                        continue
                    q.append((d + 1, u, c))
        else:
            for u in links[v][e]:
                if (u, e) in visited:
                    continue
                q.appendleft((d, u, e))
            if (v, 0) not in visited:
                q.appendleft((d, v, 0))

    return -1


readline = sys.stdin.buffer.readline
read = sys.stdin.buffer.read

n, m = map(int, readline().split())
links = [defaultdict(set) for _ in range(n)]
pqc = list(map(int, read().split()))
for p, q, c in zip(pqc[0::3], pqc[1::3], pqc[2::3]):
    p -= 1
    q -= 1
    links[p][c].add(q)
    links[q][c].add(p)

print(bfs01(0, n - 1, links))
Problem p04017 (python)

Fixed submission:
import sys
from bisect import bisect

n = int(input())
xxx = list(map(int, input().split()))
l = int(input())

reachable = [[bisect(xxx, x + l) - 1 for x in xxx]]
while reachable[-1][0] < n - 1:
    rp = reachable[-1]
    reachable.append(list(map(rp.__getitem__, rp)))

q = int(input())
buf = []
for line in sys.stdin:
    a, b = map(int, line.split())
    a -= 1
    b -= 1
    if a > b:
        a, b = b, a
    ans = 0
    for i in range(len(reachable) - 1, -1, -1):
        ria = reachable[i][a]
        if ria >= b:
            continue
        ans += 1 << i
        a = ria
    if a != b:
        ans += 1
    buf.append(ans)

print('\n'.join(map(str, buf)))

Buggy submission (verdict: Runtime Error):
import sys
from bisect import bisect_left, bisect_right
from functools import lru_cache

sys.setrecursionlimit(10 ** 5 + 1)


@lru_cache(maxsize=None)
def solve(l, r):
    if l >= r:
        return 0
    return solve(rightmost[l], r) + 1


n = int(input())
xxx = list(map(int, input().split()))
l = int(input())

rightmost = []
for x in xxx:
    rightmost.append(bisect_right(xxx, x + l) - 1)

buf = []
q = int(input())
for line in sys.stdin:
    a, b = map(int, line.split())
    a -= 1
    b -= 1
    if a > b:
        a, b = b, a
    buf.append(solve(a, b))
print('\n'.join(map(str, buf)))

Buggy submission (verdict: Runtime Error):
import sys
from bisect import bisect_left, bisect_right
from functools import lru_cache


@lru_cache(maxsize=None)
def solve(l, r):
    if l >= r:
        return 0
    return solve(rightmost[l], r) + 1


n = int(input())
xxx = list(map(int, input().split()))
l = int(input())

rightmost = []
for x in xxx:
    rightmost.append(bisect_right(xxx, x + l) - 1)

buf = []
q = int(input())
for line in sys.stdin:
    a, b = map(int, line.split())
    a -= 1
    b -= 1
    if a > b:
        a, b = b, a
    buf.append(solve(a, b))
print('\n'.join(map(str, buf)))
Problem p02576 (python)

Fixed submission:
n, x, t = map(int, input().split())
a = n//x
if n%x != 0:
  a += 1
print(t*a)

Buggy submission (verdict: Runtime Error):
s = input()
ans = 0
for x in s:
  ans += int(x)
if ans%9 == 0:
  print("Yes")
else:
  print("No")
Problem p02607 (python)

Fixed submission:
n = int(input())
arr = [int(j) for j in input().split()]
count = 0
for i in range(1, n+1):
  if i%2 == 1 and arr[i-1]%2 == 1:
    count += 1
print(count)

Buggy submission (verdict: Runtime Error):
n = int(input())
arr = [int(j) for j in input().split()]
count = 0
for i in range(1, n+1):
  if i%2 == 1 && arr[i-1]%2 == 1:
    count += 1
print(count)
Problem p02783 (python)

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

x = h/a

if x%1 == 0:
	print(int(x))
else:
	print(int(x)+1)

Buggy submission (verdict: Runtime Error):
from math import ceil
a, b = map(int, input().split()
           print(ceil(a/b))