user_id
stringlengths 10
10
| problem_id
stringlengths 6
6
| language
stringclasses 1
value | submission_id_v0
stringlengths 10
10
| submission_id_v1
stringlengths 10
10
| cpu_time_v0
int64 10
38.3k
| cpu_time_v1
int64 0
24.7k
| memory_v0
int64 2.57k
1.02M
| memory_v1
int64 2.57k
869k
| status_v0
stringclasses 1
value | status_v1
stringclasses 1
value | improvement_frac
float64 7.51
100
| input
stringlengths 20
4.55k
| target
stringlengths 17
3.34k
| code_v0_loc
int64 1
148
| code_v1_loc
int64 1
184
| code_v0_num_chars
int64 13
4.55k
| code_v1_num_chars
int64 14
3.34k
| code_v0_no_empty_lines
stringlengths 21
6.88k
| code_v1_no_empty_lines
stringlengths 20
4.93k
| code_same
bool 1
class | relative_loc_diff_percent
float64 0
79.8
| diff
sequence | diff_only_import_comment
bool 1
class | measured_runtime_v0
float64 0.01
4.45
| measured_runtime_v1
float64 0.01
4.31
| runtime_lift
float64 0
359
| key
sequence |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u376754170 | p04025 | python | s535174645 | s946408947 | 30 | 27 | 9,192 | 9,108 | Accepted | Accepted | 10 | n = int(eval(input()))
ps = list(map(int, input().split()))
p_min = min(ps)
p_max = max(ps)
a = 999999999999999999999
for i in range(p_min, p_max+1):
b = sum([abs(p-i)**2 for p in ps])
a = min(a, b)
print(a) | n = int(eval(input()))
ps = list(map(int, input().split()))
p_avg = round(sum(ps)/len(ps))
print((sum([abs(p-p_avg)**2 for p in ps]))) | 13 | 6 | 225 | 135 | n = int(eval(input()))
ps = list(map(int, input().split()))
p_min = min(ps)
p_max = max(ps)
a = 999999999999999999999
for i in range(p_min, p_max + 1):
b = sum([abs(p - i) ** 2 for p in ps])
a = min(a, b)
print(a)
| n = int(eval(input()))
ps = list(map(int, input().split()))
p_avg = round(sum(ps) / len(ps))
print((sum([abs(p - p_avg) ** 2 for p in ps])))
| false | 53.846154 | [
"-p_min = min(ps)",
"-p_max = max(ps)",
"-a = 999999999999999999999",
"-for i in range(p_min, p_max + 1):",
"- b = sum([abs(p - i) ** 2 for p in ps])",
"- a = min(a, b)",
"-print(a)",
"+p_avg = round(sum(ps) / len(ps))",
"+print((sum([abs(p - p_avg) ** 2 for p in ps])))"
] | false | 0.040948 | 0.037645 | 1.087736 | [
"s535174645",
"s946408947"
] |
u742505495 | p02257 | python | s945022348 | s530114088 | 370 | 330 | 6,120 | 6,008 | Accepted | Accepted | 10.81 | import math
def Eratos(n):
primes = [2]
num = [2*i+1 for i in range(1,n//2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1,len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(20000)
for i in range(n):
a = int(eval(input()))
if a<10000:
if primes.count(a)!=0:
cont += 1
else:
for j in range(len(primes)):
if a%primes[j]==0:
break
else:
if math.sqrt(a)<primes[j]:
cont += 1
break
print(cont)
| import math
def Eratos(n):
primes = [2]
num = [2*i+1 for i in range(1,n//2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1,len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(15000)
for i in range(n):
a = int(eval(input()))
if a<10000:
if primes.count(a)!=0:
cont += 1
else:
for j in range(len(primes)):
if a%primes[j]==0:
break
else:
if math.sqrt(a)<primes[j]:
cont += 1
break
print(cont)
| 37 | 37 | 652 | 652 | import math
def Eratos(n):
primes = [2]
num = [2 * i + 1 for i in range(1, n // 2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1, len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(20000)
for i in range(n):
a = int(eval(input()))
if a < 10000:
if primes.count(a) != 0:
cont += 1
else:
for j in range(len(primes)):
if a % primes[j] == 0:
break
else:
if math.sqrt(a) < primes[j]:
cont += 1
break
print(cont)
| import math
def Eratos(n):
primes = [2]
num = [2 * i + 1 for i in range(1, n // 2)]
tmp = []
top = 1
while top < math.sqrt(n):
top = num[0]
for i in range(1, len(num)):
if num[i] % top != 0:
tmp.append(num[i])
num = tmp
tmp = []
primes.append(top)
for i in range(len(num)):
primes.append(num[i])
return primes
n = int(eval(input()))
cont = 0
primes = Eratos(15000)
for i in range(n):
a = int(eval(input()))
if a < 10000:
if primes.count(a) != 0:
cont += 1
else:
for j in range(len(primes)):
if a % primes[j] == 0:
break
else:
if math.sqrt(a) < primes[j]:
cont += 1
break
print(cont)
| false | 0 | [
"-primes = Eratos(20000)",
"+primes = Eratos(15000)"
] | false | 0.077509 | 0.049788 | 1.556784 | [
"s945022348",
"s530114088"
] |
u239342230 | p02707 | python | s180417909 | s133203026 | 200 | 179 | 33,812 | 34,180 | Accepted | Accepted | 10.5 | N=int(eval(input()))
A=list(map(int,input().split()))
import collections
c = collections.Counter(A)
for i in range(1,N+1):
print((c[i])) | from collections import Counter
N=int(eval(input()))
A=Counter(list(map(int,input().split())))
for i in range(1,N+1):
print((A[i])) | 10 | 5 | 145 | 131 | N = int(eval(input()))
A = list(map(int, input().split()))
import collections
c = collections.Counter(A)
for i in range(1, N + 1):
print((c[i]))
| from collections import Counter
N = int(eval(input()))
A = Counter(list(map(int, input().split())))
for i in range(1, N + 1):
print((A[i]))
| false | 50 | [
"+from collections import Counter",
"+",
"-A = list(map(int, input().split()))",
"-import collections",
"-",
"-c = collections.Counter(A)",
"+A = Counter(list(map(int, input().split())))",
"- print((c[i]))",
"+ print((A[i]))"
] | false | 0.046987 | 0.047701 | 0.985039 | [
"s180417909",
"s133203026"
] |
u348805958 | p02831 | python | s336261520 | s141521031 | 33 | 17 | 2,940 | 3,188 | Accepted | Accepted | 48.48 | #!python3
def resolve():
A, B = list(map(int, input().rstrip().split(" ")))
a = b = 2
X = A
Y = B
while True:
if X == Y:
break
elif X < Y:
X += A
else:
Y += B
print(X)
if __name__ == "__main__":
resolve()
| #!python3
def factor(n):
ans = []
i = 0
while n & 1 == 0:
n >>= 1
i += 1
if i > 0:
ans.append((2, i))
for i in range(3, int(n**.5) +1, 2):
x, y = divmod(n, i)
if y == 0:
j = 1
x1 = x
while True:
x1, y = divmod(x, i)
if y == 0:
x = x1
j += 1
else:
ans.append((i, j))
break
n = x
if n > 1:
ans.append((n, 1))
return ans
def resolve():
A, B = list(map(int, input().rstrip().split(" ")))
fa = dict(factor(A))
fb = dict(factor(B))
a = A
for k, v in list(fa.items()):
if k in fb:
v2 = fb[k]
if v < v2:
a *= k ** (v2 - v)
del fb[k]
for k, v in list(fb.items()):
a *= k ** v
print(a)
if __name__ == "__main__":
resolve()
| 20 | 54 | 310 | 1,012 | #!python3
def resolve():
A, B = list(map(int, input().rstrip().split(" ")))
a = b = 2
X = A
Y = B
while True:
if X == Y:
break
elif X < Y:
X += A
else:
Y += B
print(X)
if __name__ == "__main__":
resolve()
| #!python3
def factor(n):
ans = []
i = 0
while n & 1 == 0:
n >>= 1
i += 1
if i > 0:
ans.append((2, i))
for i in range(3, int(n**0.5) + 1, 2):
x, y = divmod(n, i)
if y == 0:
j = 1
x1 = x
while True:
x1, y = divmod(x, i)
if y == 0:
x = x1
j += 1
else:
ans.append((i, j))
break
n = x
if n > 1:
ans.append((n, 1))
return ans
def resolve():
A, B = list(map(int, input().rstrip().split(" ")))
fa = dict(factor(A))
fb = dict(factor(B))
a = A
for k, v in list(fa.items()):
if k in fb:
v2 = fb[k]
if v < v2:
a *= k ** (v2 - v)
del fb[k]
for k, v in list(fb.items()):
a *= k**v
print(a)
if __name__ == "__main__":
resolve()
| false | 62.962963 | [
"+def factor(n):",
"+ ans = []",
"+ i = 0",
"+ while n & 1 == 0:",
"+ n >>= 1",
"+ i += 1",
"+ if i > 0:",
"+ ans.append((2, i))",
"+ for i in range(3, int(n**0.5) + 1, 2):",
"+ x, y = divmod(n, i)",
"+ if y == 0:",
"+ j = 1",
"+ x1 = x",
"+ while True:",
"+ x1, y = divmod(x, i)",
"+ if y == 0:",
"+ x = x1",
"+ j += 1",
"+ else:",
"+ ans.append((i, j))",
"+ break",
"+ n = x",
"+ if n > 1:",
"+ ans.append((n, 1))",
"+ return ans",
"+",
"+",
"- a = b = 2",
"- X = A",
"- Y = B",
"- while True:",
"- if X == Y:",
"- break",
"- elif X < Y:",
"- X += A",
"- else:",
"- Y += B",
"- print(X)",
"+ fa = dict(factor(A))",
"+ fb = dict(factor(B))",
"+ a = A",
"+ for k, v in list(fa.items()):",
"+ if k in fb:",
"+ v2 = fb[k]",
"+ if v < v2:",
"+ a *= k ** (v2 - v)",
"+ del fb[k]",
"+ for k, v in list(fb.items()):",
"+ a *= k**v",
"+ print(a)"
] | false | 0.044087 | 0.038244 | 1.152778 | [
"s336261520",
"s141521031"
] |
u609061751 | p02771 | python | s164021108 | s774385682 | 199 | 166 | 38,384 | 38,512 | Accepted | Accepted | 16.58 | import sys
input = sys.stdin.readline
A = [int(x) for x in input().split()]
from collections import Counter
c = Counter(A)
for i in list(c.values()):
if i == 2:
print("Yes")
sys.exit()
print("No")
| A = [int(x) for x in input().split()]
from collections import Counter
import sys
c = Counter(A)
for i in list(c.values()):
if i == 2:
print("Yes")
sys.exit()
print("No") | 14 | 11 | 228 | 185 | import sys
input = sys.stdin.readline
A = [int(x) for x in input().split()]
from collections import Counter
c = Counter(A)
for i in list(c.values()):
if i == 2:
print("Yes")
sys.exit()
print("No")
| A = [int(x) for x in input().split()]
from collections import Counter
import sys
c = Counter(A)
for i in list(c.values()):
if i == 2:
print("Yes")
sys.exit()
print("No")
| false | 21.428571 | [
"-import sys",
"-",
"-input = sys.stdin.readline",
"+import sys"
] | false | 0.04816 | 0.147463 | 0.326594 | [
"s164021108",
"s774385682"
] |
u255943004 | p02936 | python | s766198628 | s436435342 | 1,981 | 1,512 | 132,940 | 130,196 | Accepted | Accepted | 23.67 | N,Q = list(map(int,input().split()))
AB = [[] for _ in range(N-1)]
for n in range(N-1):
AB[n] = list(map(int,input().split()))
PX = [[] for _ in range(Q)]
for q in range(Q):
PX[q] = list(map(int,input().split()))
graph = [[] for _ in range(N+1)]
for ab in AB:
graph[ab[0]].append(ab[1])
graph[ab[1]].append(ab[0])
val = [0] * (N+1)
for px in PX:
val[px[0]] += px[1]
parent = [0] * (N+1)
Q = [1]
while Q:
q = Q.pop()
for c in graph[q]:
if c == parent[q]:
continue
parent[c] = q
Q.append(c)
val[c] += val[q]
print((*val[1:]))
| import sys
input = sys.stdin.readline
N,Q = list(map(int,input().split()))
AB = [[] for _ in range(N-1)]
for n in range(N-1):
AB[n] = list(map(int,input().split()))
PX = [[] for _ in range(Q)]
for q in range(Q):
PX[q] = list(map(int,input().split()))
graph = [[] for _ in range(N+1)]
for ab in AB:
graph[ab[0]].append(ab[1])
graph[ab[1]].append(ab[0])
val = [0] * (N+1)
for px in PX:
val[px[0]] += px[1]
parent = [0] * (N+1)
Q = [1]
while Q:
q = Q.pop()
for c in graph[q]:
if c == parent[q]:
continue
parent[c] = q
Q.append(c)
val[c] += val[q]
print((*val[1:]))
| 25 | 27 | 613 | 653 | N, Q = list(map(int, input().split()))
AB = [[] for _ in range(N - 1)]
for n in range(N - 1):
AB[n] = list(map(int, input().split()))
PX = [[] for _ in range(Q)]
for q in range(Q):
PX[q] = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for ab in AB:
graph[ab[0]].append(ab[1])
graph[ab[1]].append(ab[0])
val = [0] * (N + 1)
for px in PX:
val[px[0]] += px[1]
parent = [0] * (N + 1)
Q = [1]
while Q:
q = Q.pop()
for c in graph[q]:
if c == parent[q]:
continue
parent[c] = q
Q.append(c)
val[c] += val[q]
print((*val[1:]))
| import sys
input = sys.stdin.readline
N, Q = list(map(int, input().split()))
AB = [[] for _ in range(N - 1)]
for n in range(N - 1):
AB[n] = list(map(int, input().split()))
PX = [[] for _ in range(Q)]
for q in range(Q):
PX[q] = list(map(int, input().split()))
graph = [[] for _ in range(N + 1)]
for ab in AB:
graph[ab[0]].append(ab[1])
graph[ab[1]].append(ab[0])
val = [0] * (N + 1)
for px in PX:
val[px[0]] += px[1]
parent = [0] * (N + 1)
Q = [1]
while Q:
q = Q.pop()
for c in graph[q]:
if c == parent[q]:
continue
parent[c] = q
Q.append(c)
val[c] += val[q]
print((*val[1:]))
| false | 7.407407 | [
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.063919 | 0.075718 | 0.844165 | [
"s766198628",
"s436435342"
] |
u729133443 | p03643 | python | s021952057 | s165443942 | 170 | 17 | 38,256 | 2,940 | Accepted | Accepted | 90 | print(('ABC'+eval(input()))) | print((eval(input('ABC')))) | 1 | 1 | 20 | 19 | print(("ABC" + eval(input())))
| print((eval(input("ABC"))))
| false | 0 | [
"-print((\"ABC\" + eval(input())))",
"+print((eval(input(\"ABC\"))))"
] | false | 0.042748 | 0.04622 | 0.924892 | [
"s021952057",
"s165443942"
] |
u089230684 | p03449 | python | s102256575 | s077123067 | 22 | 19 | 3,064 | 3,064 | Accepted | Accepted | 13.64 | length = int(eval(input()))
first = input().split(" ")
second = input().split(" ")
i = 0
sweet = 0
sugars = 0
while i < length:
j = i
k = 0
while k<=i:
sweet = sweet + int(first[k])
k = k + 1
while j < length:
sweet = sweet + int(second[j])
j = j + 1
if sweet > sugars:
sugars = sweet
sweet = 0
i = i + 1
print(sugars)
| n = int(eval(input()))
l = []
temp = []
for i in range(0,2):
temp = [int(x) for x in input().split()]
l.append(temp)
cost=[]
for i in range(0,n): # i = length
price=0
for j in range(0,i+1):
price+=l[0][j]
for k in range(i,n):
price+=l[1][k]
cost.append(price)
print((max(cost))) | 20 | 19 | 400 | 333 | length = int(eval(input()))
first = input().split(" ")
second = input().split(" ")
i = 0
sweet = 0
sugars = 0
while i < length:
j = i
k = 0
while k <= i:
sweet = sweet + int(first[k])
k = k + 1
while j < length:
sweet = sweet + int(second[j])
j = j + 1
if sweet > sugars:
sugars = sweet
sweet = 0
i = i + 1
print(sugars)
| n = int(eval(input()))
l = []
temp = []
for i in range(0, 2):
temp = [int(x) for x in input().split()]
l.append(temp)
cost = []
for i in range(0, n): # i = length
price = 0
for j in range(0, i + 1):
price += l[0][j]
for k in range(i, n):
price += l[1][k]
cost.append(price)
print((max(cost)))
| false | 5 | [
"-length = int(eval(input()))",
"-first = input().split(\" \")",
"-second = input().split(\" \")",
"-i = 0",
"-sweet = 0",
"-sugars = 0",
"-while i < length:",
"- j = i",
"- k = 0",
"- while k <= i:",
"- sweet = sweet + int(first[k])",
"- k = k + 1",
"- while j < length:",
"- sweet = sweet + int(second[j])",
"- j = j + 1",
"- if sweet > sugars:",
"- sugars = sweet",
"- sweet = 0",
"- i = i + 1",
"-print(sugars)",
"+n = int(eval(input()))",
"+l = []",
"+temp = []",
"+for i in range(0, 2):",
"+ temp = [int(x) for x in input().split()]",
"+ l.append(temp)",
"+cost = []",
"+for i in range(0, n): # i = length",
"+ price = 0",
"+ for j in range(0, i + 1):",
"+ price += l[0][j]",
"+ for k in range(i, n):",
"+ price += l[1][k]",
"+ cost.append(price)",
"+print((max(cost)))"
] | false | 0.038803 | 0.044189 | 0.878123 | [
"s102256575",
"s077123067"
] |
u179169725 | p03945 | python | s799657383 | s117021358 | 98 | 81 | 84,368 | 88,780 | Accepted | Accepted | 17.35 | # https://atcoder.jp/contests/abc047/tasks/arc063_a
# 連長圧縮すれば簡単
# 圧縮後の文字列長-1となる
# def run_length_encoding(s):
# '''連長圧縮を行う
# s ... iterable object e.g. list, str
# return
# ----------
# s_composed,s_num,s_idx
# それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
# s_composed, s_sum = [], []
# s_idx = [0]
# pre = s[0]
# cnt = 1
# for i, ss in enumerate(s[1:], start=1):
# if pre == ss:
# cnt += 1
# else:
# s_sum.append(cnt)
# s_composed.append(pre)
# s_idx.append(i)
# cnt = 1
# pre = ss
# s_sum.append(cnt)
# s_composed.append(pre)
# # assert len(s_sum) == len(s_composed)
# return s_composed, s_sum, s_idx
def run_length_encoding(s):
'''連長圧縮を行う
s ... iterable object e.g. list, str
return
----------
s_composed,s_num,s_idx
それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
from itertools import groupby
s_composed, s_sum = [], []
s_idx = [0]
for k, v in groupby(s):
s_composed.append(k)
n = len(list(v))
s_sum.append(n)
s_idx.append(s_idx[-1] + n)
# assert len(s_sum) == len(s_composed)
return s_composed, s_sum, s_idx
S_composed, _, _ = run_length_encoding(eval(input()))
print((len(S_composed) - 1))
| # https://atcoder.jp/contests/abc047/tasks/arc063_a
# 連長圧縮すれば簡単
# 圧縮後の文字列長-1となる
def run_length_encoding(s):
'''連長圧縮を行う
s ... iterable object e.g. list, str
return
----------
s_composed,s_num,s_idx
それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
s_composed, s_sum = [], []
s_idx = [0]
pre = s[0]
cnt = 1
for i, ss in enumerate(s[1:], start=1):
if pre == ss:
cnt += 1
else:
s_sum.append(cnt)
s_composed.append(pre)
s_idx.append(i)
cnt = 1
pre = ss
s_sum.append(cnt)
s_composed.append(pre)
# assert len(s_sum) == len(s_composed)
return s_composed, s_sum, s_idx
# def run_length_encoding(s):
# '''連長圧縮を行う
# s ... iterable object e.g. list, str
# return
# ----------
# s_composed,s_num,s_idx
# それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
# from itertools import groupby
# s_composed, s_sum = [], []
# s_idx = [0]
# for k, v in groupby(s):
# s_composed.append(k)
# n = len(list(v))
# s_sum.append(n)
# s_idx.append(s_idx[-1] + n)
# # assert len(s_sum) == len(s_composed)
# return s_composed, s_sum, s_idx
S_composed, _, _ = run_length_encoding(eval(input()))
print((len(S_composed) - 1))
| 53 | 53 | 1,351 | 1,337 | # https://atcoder.jp/contests/abc047/tasks/arc063_a
# 連長圧縮すれば簡単
# 圧縮後の文字列長-1となる
# def run_length_encoding(s):
# '''連長圧縮を行う
# s ... iterable object e.g. list, str
# return
# ----------
# s_composed,s_num,s_idx
# それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
# s_composed, s_sum = [], []
# s_idx = [0]
# pre = s[0]
# cnt = 1
# for i, ss in enumerate(s[1:], start=1):
# if pre == ss:
# cnt += 1
# else:
# s_sum.append(cnt)
# s_composed.append(pre)
# s_idx.append(i)
# cnt = 1
# pre = ss
# s_sum.append(cnt)
# s_composed.append(pre)
# # assert len(s_sum) == len(s_composed)
# return s_composed, s_sum, s_idx
def run_length_encoding(s):
"""連長圧縮を行う
s ... iterable object e.g. list, str
return
----------
s_composed,s_num,s_idx
それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx"""
from itertools import groupby
s_composed, s_sum = [], []
s_idx = [0]
for k, v in groupby(s):
s_composed.append(k)
n = len(list(v))
s_sum.append(n)
s_idx.append(s_idx[-1] + n)
# assert len(s_sum) == len(s_composed)
return s_composed, s_sum, s_idx
S_composed, _, _ = run_length_encoding(eval(input()))
print((len(S_composed) - 1))
| # https://atcoder.jp/contests/abc047/tasks/arc063_a
# 連長圧縮すれば簡単
# 圧縮後の文字列長-1となる
def run_length_encoding(s):
"""連長圧縮を行う
s ... iterable object e.g. list, str
return
----------
s_composed,s_num,s_idx
それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx"""
s_composed, s_sum = [], []
s_idx = [0]
pre = s[0]
cnt = 1
for i, ss in enumerate(s[1:], start=1):
if pre == ss:
cnt += 1
else:
s_sum.append(cnt)
s_composed.append(pre)
s_idx.append(i)
cnt = 1
pre = ss
s_sum.append(cnt)
s_composed.append(pre)
# assert len(s_sum) == len(s_composed)
return s_composed, s_sum, s_idx
# def run_length_encoding(s):
# '''連長圧縮を行う
# s ... iterable object e.g. list, str
# return
# ----------
# s_composed,s_num,s_idx
# それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx'''
# from itertools import groupby
# s_composed, s_sum = [], []
# s_idx = [0]
# for k, v in groupby(s):
# s_composed.append(k)
# n = len(list(v))
# s_sum.append(n)
# s_idx.append(s_idx[-1] + n)
# # assert len(s_sum) == len(s_composed)
# return s_composed, s_sum, s_idx
S_composed, _, _ = run_length_encoding(eval(input()))
print((len(S_composed) - 1))
| false | 0 | [
"+def run_length_encoding(s):",
"+ \"\"\"連長圧縮を行う",
"+ s ... iterable object e.g. list, str",
"+ return",
"+ s_composed,s_num,s_idx",
"+ それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx\"\"\"",
"+ s_composed, s_sum = [], []",
"+ s_idx = [0]",
"+ pre = s[0]",
"+ cnt = 1",
"+ for i, ss in enumerate(s[1:], start=1):",
"+ if pre == ss:",
"+ cnt += 1",
"+ else:",
"+ s_sum.append(cnt)",
"+ s_composed.append(pre)",
"+ s_idx.append(i)",
"+ cnt = 1",
"+ pre = ss",
"+ s_sum.append(cnt)",
"+ s_composed.append(pre)",
"+ # assert len(s_sum) == len(s_composed)",
"+ return s_composed, s_sum, s_idx",
"+",
"+",
"+# from itertools import groupby",
"-# pre = s[0]",
"-# cnt = 1",
"-# for i, ss in enumerate(s[1:], start=1):",
"-# if pre == ss:",
"-# cnt += 1",
"-# else:",
"-# s_sum.append(cnt)",
"-# s_composed.append(pre)",
"-# s_idx.append(i)",
"-# cnt = 1",
"-# pre = ss",
"-# s_sum.append(cnt)",
"-# s_composed.append(pre)",
"+# for k, v in groupby(s):",
"+# s_composed.append(k)",
"+# n = len(list(v))",
"+# s_sum.append(n)",
"+# s_idx.append(s_idx[-1] + n)",
"-def run_length_encoding(s):",
"- \"\"\"連長圧縮を行う",
"- s ... iterable object e.g. list, str",
"- return",
"- s_composed,s_num,s_idx",
"- それぞれ、圧縮後の文字列、その文字数、その文字が始まるidx\"\"\"",
"- from itertools import groupby",
"-",
"- s_composed, s_sum = [], []",
"- s_idx = [0]",
"- for k, v in groupby(s):",
"- s_composed.append(k)",
"- n = len(list(v))",
"- s_sum.append(n)",
"- s_idx.append(s_idx[-1] + n)",
"- # assert len(s_sum) == len(s_composed)",
"- return s_composed, s_sum, s_idx",
"-",
"-"
] | false | 0.108537 | 0.043219 | 2.511321 | [
"s799657383",
"s117021358"
] |
u818349438 | p03296 | python | s318426836 | s995407023 | 173 | 18 | 38,384 | 3,060 | Accepted | Accepted | 89.6 | n = int(eval(input()))
a = list(map(int,input().split()))
neighbor = 1
nei = []
for i in range(1,n):
if a[i] == a[i-1]:
neighbor+=1
else:
if neighbor >1:
nei.append(neighbor)
neighbor = 1
if neighbor >1:
nei.append(neighbor)
ans = 0
for x in nei:
ans += x//2
print(ans) | n = int(eval(input()))
ans = 0
a = list(map(int,input().split()))
now = a[0]
cnt = 1
p = []
for i in range(n-1):
if now == a[i+1]:cnt+=1
else:
p.append(cnt)
now = a[i+1]
cnt = 1
p.append(cnt)
for x in p:
ans+=x//2
print(ans)
| 18 | 18 | 342 | 278 | n = int(eval(input()))
a = list(map(int, input().split()))
neighbor = 1
nei = []
for i in range(1, n):
if a[i] == a[i - 1]:
neighbor += 1
else:
if neighbor > 1:
nei.append(neighbor)
neighbor = 1
if neighbor > 1:
nei.append(neighbor)
ans = 0
for x in nei:
ans += x // 2
print(ans)
| n = int(eval(input()))
ans = 0
a = list(map(int, input().split()))
now = a[0]
cnt = 1
p = []
for i in range(n - 1):
if now == a[i + 1]:
cnt += 1
else:
p.append(cnt)
now = a[i + 1]
cnt = 1
p.append(cnt)
for x in p:
ans += x // 2
print(ans)
| false | 0 | [
"+ans = 0",
"-neighbor = 1",
"-nei = []",
"-for i in range(1, n):",
"- if a[i] == a[i - 1]:",
"- neighbor += 1",
"+now = a[0]",
"+cnt = 1",
"+p = []",
"+for i in range(n - 1):",
"+ if now == a[i + 1]:",
"+ cnt += 1",
"- if neighbor > 1:",
"- nei.append(neighbor)",
"- neighbor = 1",
"-if neighbor > 1:",
"- nei.append(neighbor)",
"-ans = 0",
"-for x in nei:",
"+ p.append(cnt)",
"+ now = a[i + 1]",
"+ cnt = 1",
"+p.append(cnt)",
"+for x in p:"
] | false | 0.047731 | 0.038861 | 1.228251 | [
"s318426836",
"s995407023"
] |
u374802266 | p03767 | python | s905080711 | s280786690 | 210 | 135 | 40,900 | 42,732 | Accepted | Accepted | 35.71 | n=int(eval(input()))
print((sum(sorted(list(map(int,input().split())))[-2:n-1:-2]))) | n=int(eval(input()))
a=list(map(int,input().split()))
a=sorted(a,reverse=1)
print((sum(a[1:n*2:2]))) | 2 | 4 | 77 | 95 | n = int(eval(input()))
print((sum(sorted(list(map(int, input().split())))[-2 : n - 1 : -2])))
| n = int(eval(input()))
a = list(map(int, input().split()))
a = sorted(a, reverse=1)
print((sum(a[1 : n * 2 : 2])))
| false | 50 | [
"-print((sum(sorted(list(map(int, input().split())))[-2 : n - 1 : -2])))",
"+a = list(map(int, input().split()))",
"+a = sorted(a, reverse=1)",
"+print((sum(a[1 : n * 2 : 2])))"
] | false | 0.059633 | 0.037402 | 1.59438 | [
"s905080711",
"s280786690"
] |
u784022244 | p03319 | python | s624237561 | s153093004 | 48 | 40 | 13,812 | 13,812 | Accepted | Accepted | 16.67 | from math import ceil
N,K=list(map(int, input().split()))
A=list(map(int, input().split()))
left=0
right=0
for i in range(N):
if A[i]==1:
left=i
right=N-(i+1)
ans=ceil((left+right)/(K-1))
print(ans)
| from math import ceil
N,K=list(map(int, input().split()))
A=list(map(int, input().split()))
if K==N:
print((1))
exit()
print((ceil((N-1)/(K-1)))) | 14 | 8 | 219 | 151 | from math import ceil
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
left = 0
right = 0
for i in range(N):
if A[i] == 1:
left = i
right = N - (i + 1)
ans = ceil((left + right) / (K - 1))
print(ans)
| from math import ceil
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
if K == N:
print((1))
exit()
print((ceil((N - 1) / (K - 1))))
| false | 42.857143 | [
"-left = 0",
"-right = 0",
"-for i in range(N):",
"- if A[i] == 1:",
"- left = i",
"- right = N - (i + 1)",
"-ans = ceil((left + right) / (K - 1))",
"-print(ans)",
"+if K == N:",
"+ print((1))",
"+ exit()",
"+print((ceil((N - 1) / (K - 1))))"
] | false | 0.045876 | 0.049025 | 0.935759 | [
"s624237561",
"s153093004"
] |
u380524497 | p03045 | python | s056083815 | s824223498 | 396 | 344 | 5,936 | 5,936 | Accepted | Accepted | 13.13 | import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def in_same_group(self, node1, node2):
root1 = self.get_root(node1)
root2 = self.get_root(node2)
return root1 == root2
def unite(self, node1, node2):
if self.in_same_group(node1, node2):
return
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def unite(self, node1, node2):
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if main_root == sub_root:
return
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| 47 | 42 | 1,256 | 1,092 | import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def in_same_group(self, node1, node2):
root1 = self.get_root(node1)
root2 = self.get_root(node2)
return root1 == root2
def unite(self, node1, node2):
if self.in_same_group(node1, node2):
return
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, size):
self.parent = [-1] * size
self.rank = [1] * size
self.groups = size
def get_root(self, node):
parent = self.parent[node]
if parent == -1:
root = node
else:
root = self.get_root(parent)
self.parent[node] = root # 同じnodeへの2回目以降のget_rootを高速にするために、直接rootに繋いでおく
return root
def unite(self, node1, node2):
main_root = self.get_root(node1)
sub_root = self.get_root(node2)
if main_root == sub_root:
return
if self.rank[main_root] < self.rank[sub_root]: # rankの大きい方をmain_rootにする
main_root, sub_root = sub_root, main_root
self.parent[sub_root] = main_root
self.rank[main_root] += self.rank[sub_root]
self.groups -= 1
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for i in range(m):
x, y, z = list(map(int, input().split()))
x -= 1
y -= 1
uf.unite(x, y)
print((uf.groups))
| false | 10.638298 | [
"- def in_same_group(self, node1, node2):",
"- root1 = self.get_root(node1)",
"- root2 = self.get_root(node2)",
"- return root1 == root2",
"-",
"- if self.in_same_group(node1, node2):",
"- return",
"+ if main_root == sub_root:",
"+ return"
] | false | 0.067858 | 0.047298 | 1.434701 | [
"s056083815",
"s824223498"
] |
u172111219 | p03426 | python | s390984180 | s346239728 | 1,125 | 418 | 72,156 | 70,492 | Accepted | Accepted | 62.84 | from collections import defaultdict
def main():
# init
h,w,d = list(map(int,input().split()))
dic = defaultdict(list)
for i in range(h):
nums = [int(x) for x in input().split()]
for j,num in enumerate(nums):
dic[int(num)] = [i,j]
# memo
ls = [0 for i in range(w*h+1)]
for i in range(d+1,w*h+1):
before,after = dic[i-d],dic[i]
diff = abs(after[0]-before[0]) + abs(after[1]-before[1])
ls[i] = ls[i-d]+ diff
# ans
q = int(eval(input()))
for i in range(q):
l,r = list(map(int,input().split()))
print((ls[r]-ls[l]))
if __name__ == "__main__":
main() | from collections import defaultdict
import sys
input = sys.stdin.readline
def main():
# init
input = sys.stdin.readline
h,w,d = list(map(int,input().split()))
dic = defaultdict(list)
for i in range(h):
nums = [int(x) for x in input().split()]
for j,num in enumerate(nums):
dic[int(num)] = [i,j]
# memo
ls = [0 for i in range(w*h+1)]
for i in range(d+1,w*h+1):
before,after = dic[i-d],dic[i]
diff = abs(after[0]-before[0]) + abs(after[1]-before[1])
ls[i] = ls[i-d]+ diff
# ans
q = int(eval(input()))
for i in range(q):
l,r = list(map(int,input().split()))
print((ls[r]-ls[l]))
if __name__ == "__main__":
main() | 23 | 26 | 659 | 731 | from collections import defaultdict
def main():
# init
h, w, d = list(map(int, input().split()))
dic = defaultdict(list)
for i in range(h):
nums = [int(x) for x in input().split()]
for j, num in enumerate(nums):
dic[int(num)] = [i, j]
# memo
ls = [0 for i in range(w * h + 1)]
for i in range(d + 1, w * h + 1):
before, after = dic[i - d], dic[i]
diff = abs(after[0] - before[0]) + abs(after[1] - before[1])
ls[i] = ls[i - d] + diff
# ans
q = int(eval(input()))
for i in range(q):
l, r = list(map(int, input().split()))
print((ls[r] - ls[l]))
if __name__ == "__main__":
main()
| from collections import defaultdict
import sys
input = sys.stdin.readline
def main():
# init
input = sys.stdin.readline
h, w, d = list(map(int, input().split()))
dic = defaultdict(list)
for i in range(h):
nums = [int(x) for x in input().split()]
for j, num in enumerate(nums):
dic[int(num)] = [i, j]
# memo
ls = [0 for i in range(w * h + 1)]
for i in range(d + 1, w * h + 1):
before, after = dic[i - d], dic[i]
diff = abs(after[0] - before[0]) + abs(after[1] - before[1])
ls[i] = ls[i - d] + diff
# ans
q = int(eval(input()))
for i in range(q):
l, r = list(map(int, input().split()))
print((ls[r] - ls[l]))
if __name__ == "__main__":
main()
| false | 11.538462 | [
"+import sys",
"+",
"+input = sys.stdin.readline",
"+ input = sys.stdin.readline"
] | false | 0.035709 | 0.057941 | 0.616302 | [
"s390984180",
"s346239728"
] |
u191874006 | p03060 | python | s872789912 | s117585466 | 176 | 87 | 38,384 | 65,404 | Accepted | Accepted | 50.57 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
v = LI()
c = LI()
lst = [v[i]-c[i] for i in range(n)]
ans = 0
for i in range(n):
if lst[i] >= 0:
ans += lst[i]
print(ans) | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
n = I()
v = LI()
c = LI()
ans = 0
for i in range(n):
if v[i] > c[i]:
ans += v[i] - c[i]
print(ans) | 28 | 27 | 709 | 677 | #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
n = I()
v = LI()
c = LI()
lst = [v[i] - c[i] for i in range(n)]
ans = 0
for i in range(n):
if lst[i] >= 0:
ans += lst[i]
print(ans)
| #!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop, heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float("inf")
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
n = I()
v = LI()
c = LI()
ans = 0
for i in range(n):
if v[i] > c[i]:
ans += v[i] - c[i]
print(ans)
| false | 3.571429 | [
"-lst = [v[i] - c[i] for i in range(n)]",
"- if lst[i] >= 0:",
"- ans += lst[i]",
"+ if v[i] > c[i]:",
"+ ans += v[i] - c[i]"
] | false | 0.046906 | 0.048343 | 0.970272 | [
"s872789912",
"s117585466"
] |
u629540524 | p03001 | python | s638792644 | s583262354 | 30 | 27 | 9,088 | 9,040 | Accepted | Accepted | 10 | w, h, x, y = list(map(int, input().split()))
if w==2*x and h ==2*y:
print((w*h/2, 1))
else:
print((w*h/2, 0)) | w, h, x, y = list(map(int, input().split()))
print((w*h/2, int(w==2*x and h ==2*y))) | 5 | 2 | 111 | 77 | w, h, x, y = list(map(int, input().split()))
if w == 2 * x and h == 2 * y:
print((w * h / 2, 1))
else:
print((w * h / 2, 0))
| w, h, x, y = list(map(int, input().split()))
print((w * h / 2, int(w == 2 * x and h == 2 * y)))
| false | 60 | [
"-if w == 2 * x and h == 2 * y:",
"- print((w * h / 2, 1))",
"-else:",
"- print((w * h / 2, 0))",
"+print((w * h / 2, int(w == 2 * x and h == 2 * y)))"
] | false | 0.041412 | 0.040593 | 1.020185 | [
"s638792644",
"s583262354"
] |
u888092736 | p03165 | python | s451073973 | s359065181 | 539 | 420 | 113,244 | 91,592 | Accepted | Accepted | 22.08 | s = eval(input())
t = eval(input())
dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
for i in range(len(s)):
for j in range(len(t)):
if s[i] == t[j]:
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + 1)
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j + 1])
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i + 1][j])
i, j = len(s), len(t)
ans = ''
while i > 0 and j > 0:
if dp[i][j] == dp[i - 1][j]:
i -= 1
elif dp[i][j] == dp[i][j - 1]:
j -= 1
else:
ans += s[i - 1]
i -= 1
j -= 1
print((ans[::-1])) | import numpy as np
s = np.array(list(eval(input())))
t = np.array(list(eval(input())))
dp = np.zeros((len(s) + 1, len(t) + 1), dtype=int)
is_eq = s[:, None] == t[None,]
for i in range(len(s)):
dp[i + 1, 1:] = np.maximum(dp[i, :-1] + is_eq[i], dp[i, 1:])
dp[i + 1] = np.maximum.accumulate(dp[i + 1])
i, j = len(s), len(t)
ans = ''
while i > 0 and j > 0:
if dp[i, j] == dp[i - 1, j]:
i -= 1
elif dp[i, j] == dp[i, j - 1]:
j -= 1
else:
ans += s[i - 1]
i -= 1
j -= 1
print((ans[::-1]))
| 23 | 23 | 603 | 553 | s = eval(input())
t = eval(input())
dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]
for i in range(len(s)):
for j in range(len(t)):
if s[i] == t[j]:
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + 1)
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j + 1])
dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i + 1][j])
i, j = len(s), len(t)
ans = ""
while i > 0 and j > 0:
if dp[i][j] == dp[i - 1][j]:
i -= 1
elif dp[i][j] == dp[i][j - 1]:
j -= 1
else:
ans += s[i - 1]
i -= 1
j -= 1
print((ans[::-1]))
| import numpy as np
s = np.array(list(eval(input())))
t = np.array(list(eval(input())))
dp = np.zeros((len(s) + 1, len(t) + 1), dtype=int)
is_eq = (
s[:, None]
== t[
None,
]
)
for i in range(len(s)):
dp[i + 1, 1:] = np.maximum(dp[i, :-1] + is_eq[i], dp[i, 1:])
dp[i + 1] = np.maximum.accumulate(dp[i + 1])
i, j = len(s), len(t)
ans = ""
while i > 0 and j > 0:
if dp[i, j] == dp[i - 1, j]:
i -= 1
elif dp[i, j] == dp[i, j - 1]:
j -= 1
else:
ans += s[i - 1]
i -= 1
j -= 1
print((ans[::-1]))
| false | 0 | [
"-s = eval(input())",
"-t = eval(input())",
"-dp = [[0] * (len(t) + 1) for _ in range(len(s) + 1)]",
"+import numpy as np",
"+",
"+s = np.array(list(eval(input())))",
"+t = np.array(list(eval(input())))",
"+dp = np.zeros((len(s) + 1, len(t) + 1), dtype=int)",
"+is_eq = (",
"+ s[:, None]",
"+ == t[",
"+ None,",
"+ ]",
"+)",
"- for j in range(len(t)):",
"- if s[i] == t[j]:",
"- dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j] + 1)",
"- dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i][j + 1])",
"- dp[i + 1][j + 1] = max(dp[i + 1][j + 1], dp[i + 1][j])",
"+ dp[i + 1, 1:] = np.maximum(dp[i, :-1] + is_eq[i], dp[i, 1:])",
"+ dp[i + 1] = np.maximum.accumulate(dp[i + 1])",
"- if dp[i][j] == dp[i - 1][j]:",
"+ if dp[i, j] == dp[i - 1, j]:",
"- elif dp[i][j] == dp[i][j - 1]:",
"+ elif dp[i, j] == dp[i, j - 1]:"
] | false | 0.035132 | 0.212548 | 0.165291 | [
"s451073973",
"s359065181"
] |
u814986259 | p02780 | python | s847744889 | s274215786 | 262 | 192 | 24,804 | 25,060 | Accepted | Accepted | 26.72 | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
s = [0]*N
for i in range(N):
s[i] = (p[i]+1) / 2
ss = [0]*(N+1)
for i in range(N):
ss[i+1] = ss[i] + s[i]
ans = 0
for i in range(N - K + 1):
ans = max(ans, ss[i+K] - ss[i])
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
P = [(1+p[i])/2 for i in range(N)]
ans = sum(P[:K])
tmp = ans
for i in range(N-K):
tmp = tmp - P[i]+P[i+K]
ans = max(ans, tmp)
print(ans)
| 16 | 12 | 284 | 229 | N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
s = [0] * N
for i in range(N):
s[i] = (p[i] + 1) / 2
ss = [0] * (N + 1)
for i in range(N):
ss[i + 1] = ss[i] + s[i]
ans = 0
for i in range(N - K + 1):
ans = max(ans, ss[i + K] - ss[i])
print(ans)
| N, K = list(map(int, input().split()))
p = list(map(int, input().split()))
P = [(1 + p[i]) / 2 for i in range(N)]
ans = sum(P[:K])
tmp = ans
for i in range(N - K):
tmp = tmp - P[i] + P[i + K]
ans = max(ans, tmp)
print(ans)
| false | 25 | [
"-s = [0] * N",
"-for i in range(N):",
"- s[i] = (p[i] + 1) / 2",
"-ss = [0] * (N + 1)",
"-for i in range(N):",
"- ss[i + 1] = ss[i] + s[i]",
"-ans = 0",
"-for i in range(N - K + 1):",
"- ans = max(ans, ss[i + K] - ss[i])",
"+P = [(1 + p[i]) / 2 for i in range(N)]",
"+ans = sum(P[:K])",
"+tmp = ans",
"+for i in range(N - K):",
"+ tmp = tmp - P[i] + P[i + K]",
"+ ans = max(ans, tmp)"
] | false | 0.068158 | 0.084568 | 0.805961 | [
"s847744889",
"s274215786"
] |
u498487134 | p02947 | python | s313153135 | s271132059 | 1,704 | 298 | 83,104 | 102,084 | Accepted | Accepted | 82.51 | import collections
N=int(eval(input()))
s=[[] for _ in range(N)]
for i in range(N):
s[i]=eval(input())
p=101
ha=[0]*N
for i in range(N):
for j in range(len(s[i])):
ha[i]+=pow(p,(ord(s[i][j])-ord("a")))
c=collections.Counter(ha)
ans=0
for n in list(c.values()):
ans+=(n*(n-1))//2
print(ans) |
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N=I()
from collections import defaultdict
dd = defaultdict(int)
for _ in range(N):
s=list(eval(input()))
s.sort()
s=''.join(map(str, s))
dd[s]+=1
ans=0
for k,v in list(dd.items()):
ans+=(v*(v-1))//2
print(ans)
main()
| 19 | 25 | 313 | 477 | import collections
N = int(eval(input()))
s = [[] for _ in range(N)]
for i in range(N):
s[i] = eval(input())
p = 101
ha = [0] * N
for i in range(N):
for j in range(len(s[i])):
ha[i] += pow(p, (ord(s[i][j]) - ord("a")))
c = collections.Counter(ha)
ans = 0
for n in list(c.values()):
ans += (n * (n - 1)) // 2
print(ans)
| def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
mod = 10**9 + 7
N = I()
from collections import defaultdict
dd = defaultdict(int)
for _ in range(N):
s = list(eval(input()))
s.sort()
s = "".join(map(str, s))
dd[s] += 1
ans = 0
for k, v in list(dd.items()):
ans += (v * (v - 1)) // 2
print(ans)
main()
| false | 24 | [
"-import collections",
"+def I():",
"+ return int(eval(input()))",
"-N = int(eval(input()))",
"-s = [[] for _ in range(N)]",
"-for i in range(N):",
"- s[i] = eval(input())",
"-p = 101",
"-ha = [0] * N",
"-for i in range(N):",
"- for j in range(len(s[i])):",
"- ha[i] += pow(p, (ord(s[i][j]) - ord(\"a\")))",
"-c = collections.Counter(ha)",
"-ans = 0",
"-for n in list(c.values()):",
"- ans += (n * (n - 1)) // 2",
"-print(ans)",
"+",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def main():",
"+ mod = 10**9 + 7",
"+ N = I()",
"+ from collections import defaultdict",
"+",
"+ dd = defaultdict(int)",
"+ for _ in range(N):",
"+ s = list(eval(input()))",
"+ s.sort()",
"+ s = \"\".join(map(str, s))",
"+ dd[s] += 1",
"+ ans = 0",
"+ for k, v in list(dd.items()):",
"+ ans += (v * (v - 1)) // 2",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.085958 | 0.035672 | 2.409667 | [
"s313153135",
"s271132059"
] |
u562935282 | p03722 | python | s798407351 | s461358821 | 1,625 | 591 | 3,316 | 3,512 | Accepted | Accepted | 63.63 | inf = float('inf')
n, m = list(map(int, input().split()))
e = []
for _ in range(m):
s, t, c = list(map(int, input().split()))
s -= 1
t -= 1
c *= -1
e.append((s, t, c))
dist = [inf] * n
dist[0] = 0
ans = None
for cnt in range(n * 2):
for s, t, c in e:
if dist[s] != inf and dist[t] > dist[s] + c:
dist[t] = dist[s] + c
update = True
if cnt == n - 1:
ans = -dist[n - 1]
if ans != -dist[n - 1]:
print('inf')
else:
print(ans)
# 「ベルマンフォード法」の pythonのコード
# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)
#
# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである．
#
# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される．
# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので，
# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する．
# (http://www.prefield.com/algorithm/graph/bellman_ford.html)
#
# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、
# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを
# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」
# と判定すればいい。この場合、ループは 2N 回程度回せば確実。
# (http://drken1215.hatenablog.com/entry/2019/02/16/075900)
| def Bellman_Ford(s, g, inf=1 << 60):
# https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html
N = len(g)
dist = [inf] * N
dist[s] = 0
for _ in range(N):
not_updated = True
for v in range(N):
for u, c in g[v]:
if (dist[v] == inf) or (dist[v] + c >= dist[u]): continue
dist[u] = dist[v] + c
not_updated = False
if not_updated: break
else:
# 負閉路が存在する
ret = dist[N - 1]
for v in range(N):
for u, c in g[v]:
if (dist[v] == inf) or (dist[v] + c >= dist[u]): continue
dist[u] = dist[v] + c
if ret == dist[N - 1]:
return -ret
else:
return 'inf'
return -dist[N - 1]
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N))
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
g[a].add((b, -c))
ans = Bellman_Ford(s=0, g=g)
print(ans)
if __name__ == '__main__':
main()
| 42 | 52 | 1,321 | 1,236 | inf = float("inf")
n, m = list(map(int, input().split()))
e = []
for _ in range(m):
s, t, c = list(map(int, input().split()))
s -= 1
t -= 1
c *= -1
e.append((s, t, c))
dist = [inf] * n
dist[0] = 0
ans = None
for cnt in range(n * 2):
for s, t, c in e:
if dist[s] != inf and dist[t] > dist[s] + c:
dist[t] = dist[s] + c
update = True
if cnt == n - 1:
ans = -dist[n - 1]
if ans != -dist[n - 1]:
print("inf")
else:
print(ans)
# 「ベルマンフォード法」の pythonのコード
# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)
#
# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである．
#
# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される．
# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので，
# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する．
# (http://www.prefield.com/algorithm/graph/bellman_ford.html)
#
# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、
# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを
# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」
# と判定すればいい。この場合、ループは 2N 回程度回せば確実。
# (http://drken1215.hatenablog.com/entry/2019/02/16/075900)
| def Bellman_Ford(s, g, inf=1 << 60):
# https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html
N = len(g)
dist = [inf] * N
dist[s] = 0
for _ in range(N):
not_updated = True
for v in range(N):
for u, c in g[v]:
if (dist[v] == inf) or (dist[v] + c >= dist[u]):
continue
dist[u] = dist[v] + c
not_updated = False
if not_updated:
break
else:
# 負閉路が存在する
ret = dist[N - 1]
for v in range(N):
for u, c in g[v]:
if (dist[v] == inf) or (dist[v] + c >= dist[u]):
continue
dist[u] = dist[v] + c
if ret == dist[N - 1]:
return -ret
else:
return "inf"
return -dist[N - 1]
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
N, M = list(map(int, input().split()))
g = tuple(set() for _ in range(N))
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
g[a].add((b, -c))
ans = Bellman_Ford(s=0, g=g)
print(ans)
if __name__ == "__main__":
main()
| false | 19.230769 | [
"-inf = float(\"inf\")",
"-n, m = list(map(int, input().split()))",
"-e = []",
"-for _ in range(m):",
"- s, t, c = list(map(int, input().split()))",
"- s -= 1",
"- t -= 1",
"- c *= -1",
"- e.append((s, t, c))",
"-dist = [inf] * n",
"-dist[0] = 0",
"-ans = None",
"-for cnt in range(n * 2):",
"- for s, t, c in e:",
"- if dist[s] != inf and dist[t] > dist[s] + c:",
"- dist[t] = dist[s] + c",
"- update = True",
"- if cnt == n - 1:",
"- ans = -dist[n - 1]",
"-if ans != -dist[n - 1]:",
"- print(\"inf\")",
"-else:",
"+def Bellman_Ford(s, g, inf=1 << 60):",
"+ # https://tjkendev.github.io/procon-library/python/graph/bellman-ford.html",
"+ N = len(g)",
"+ dist = [inf] * N",
"+ dist[s] = 0",
"+ for _ in range(N):",
"+ not_updated = True",
"+ for v in range(N):",
"+ for u, c in g[v]:",
"+ if (dist[v] == inf) or (dist[v] + c >= dist[u]):",
"+ continue",
"+ dist[u] = dist[v] + c",
"+ not_updated = False",
"+ if not_updated:",
"+ break",
"+ else:",
"+ # 負閉路が存在する",
"+ ret = dist[N - 1]",
"+ for v in range(N):",
"+ for u, c in g[v]:",
"+ if (dist[v] == inf) or (dist[v] + c >= dist[u]):",
"+ continue",
"+ dist[u] = dist[v] + c",
"+ if ret == dist[N - 1]:",
"+ return -ret",
"+ else:",
"+ return \"inf\"",
"+ return -dist[N - 1]",
"+",
"+",
"+def main():",
"+ import sys",
"+",
"+ input = sys.stdin.readline",
"+ sys.setrecursionlimit(10**7)",
"+ N, M = list(map(int, input().split()))",
"+ g = tuple(set() for _ in range(N))",
"+ for _ in range(M):",
"+ a, b, c = list(map(int, input().split()))",
"+ a -= 1",
"+ b -= 1",
"+ g[a].add((b, -c))",
"+ ans = Bellman_Ford(s=0, g=g)",
"-# 「ベルマンフォード法」の pythonのコード",
"-# (https://juppy.hatenablog.com/entry/2018/10/30/%E6%9C%80%E7%9F%AD%E7%B5%8C%E8%B7%AF%E9%96%A2%E9%80%A3_python_%E7%AB%B6%E6%8A%80%E3%83%97%E3%83%AD%E3%82%B0%E3%83%A9%E3%83%9F%E3%83%B3%E3%82%B0)",
"-#",
"-# Bellman Fordは負辺があってもかまわない場合の単一始点全点間最短距離を求め，同時に負閉路の存在を検出するアルゴリズムである．",
"-#",
"-# これは動的計画法に基づくアルゴリズムで，k 回目の更新によって始点から k ステップ以下で進む場合の最短距離が計算される．",
"-# もし n 回目にもまだ更新があるのならば，経路はどこかに負の閉路を含んでいるので，",
"-# その頂点への経路には負閉路が存在するとして距離を負の無限大に設定する．",
"-# (http://www.prefield.com/algorithm/graph/bellman_ford.html)",
"-#",
"-# 通常の Bellman-Ford 法における負閉路検出は、後者の負閉路に対して「負閉路あり」と判定してしまうことに注意。それを防ぐためには、",
"-# 本来 Bellman-Ford は N-1 回のイテレーションで終わるので N 回目以降にも更新が行われたら負閉路ありとしていたところを",
"-# N 回目以降にも頂点 N への最短路が更新されたら、「1 から N までの間に負閉路あり」",
"-# と判定すればいい。この場合、ループは 2N 回程度回せば確実。",
"-# (http://drken1215.hatenablog.com/entry/2019/02/16/075900)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.038419 | 0.091311 | 0.420755 | [
"s798407351",
"s461358821"
] |
u021019433 | p02773 | python | s778599934 | s828435530 | 679 | 611 | 31,940 | 32,476 | Accepted | Accepted | 10.01 | from itertools import groupby
from operator import itemgetter
a = groupby(sorted(eval(input()) for _ in range(int(eval(input())))))
a = [(len(tuple(g)), s) for s, g in a]
m = max(a, key=itemgetter(0))[0]
for k, s in a:
if k == m:
print(s)
| from collections import Counter
c = Counter(eval(input()) for _ in range(int(eval(input()))))
m = max(c.values())
for s in sorted(s for s, k in list(c.items()) if k == m):
print(s)
| 9 | 7 | 242 | 175 | from itertools import groupby
from operator import itemgetter
a = groupby(sorted(eval(input()) for _ in range(int(eval(input())))))
a = [(len(tuple(g)), s) for s, g in a]
m = max(a, key=itemgetter(0))[0]
for k, s in a:
if k == m:
print(s)
| from collections import Counter
c = Counter(eval(input()) for _ in range(int(eval(input()))))
m = max(c.values())
for s in sorted(s for s, k in list(c.items()) if k == m):
print(s)
| false | 22.222222 | [
"-from itertools import groupby",
"-from operator import itemgetter",
"+from collections import Counter",
"-a = groupby(sorted(eval(input()) for _ in range(int(eval(input())))))",
"-a = [(len(tuple(g)), s) for s, g in a]",
"-m = max(a, key=itemgetter(0))[0]",
"-for k, s in a:",
"- if k == m:",
"- print(s)",
"+c = Counter(eval(input()) for _ in range(int(eval(input()))))",
"+m = max(c.values())",
"+for s in sorted(s for s, k in list(c.items()) if k == m):",
"+ print(s)"
] | false | 0.077502 | 0.103806 | 0.746601 | [
"s778599934",
"s828435530"
] |
u747602774 | p02659 | python | s938327205 | s051489736 | 61 | 25 | 61,812 | 9,940 | Accepted | Accepted | 59.02 | A,B = input().split()
A = int(A)
B = B.replace('.','')
B = int(B)
print((A*B//100))
| A,B = input().split()
from decimal import Decimal,ROUND_DOWN
A = Decimal(A)
B = Decimal(B)
N = A*B
print((N.quantize(Decimal('1'),rounding=ROUND_DOWN)))
| 7 | 6 | 90 | 156 | A, B = input().split()
A = int(A)
B = B.replace(".", "")
B = int(B)
print((A * B // 100))
| A, B = input().split()
from decimal import Decimal, ROUND_DOWN
A = Decimal(A)
B = Decimal(B)
N = A * B
print((N.quantize(Decimal("1"), rounding=ROUND_DOWN)))
| false | 14.285714 | [
"-A = int(A)",
"-B = B.replace(\".\", \"\")",
"-B = int(B)",
"-print((A * B // 100))",
"+from decimal import Decimal, ROUND_DOWN",
"+",
"+A = Decimal(A)",
"+B = Decimal(B)",
"+N = A * B",
"+print((N.quantize(Decimal(\"1\"), rounding=ROUND_DOWN)))"
] | false | 0.047642 | 0.050711 | 0.939473 | [
"s938327205",
"s051489736"
] |
u325492232 | p02844 | python | s974830919 | s473058968 | 1,210 | 789 | 9,212 | 8,996 | Accepted | Accepted | 34.79 | def sumitrust2019_d():
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1000):
# 確認するpinの数字の組み合わせと桁の初期化
# pin = list(str(i).zfill(3))
current_digit = 0
pin = f'{i:0>3}'
search_num = pin[current_digit]
for num in s:
# 見つけると桁を右に一つずらす
# 毎回リストにアクセスするより変数に取り出しておくほうがいいかも。
# if num == pin[current_digit]:
if num == pin[current_digit]:
current_digit += 1
# indexが3(桁が3→2→1→0)になったときはそのPINは作れる
if current_digit == 3:
ans += 1
break
# 見つけ終わるまではチェックする数字を置き換え。
elif current_digit < 3:
search_num = pin[current_digit]
print(ans)
if __name__ == '__main__':
sumitrust2019_d() | def sumitrust2019_d():
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1000):
# 確認するpinの数字の組み合わせと桁の初期化
# pin = list(str(i).zfill(3))
current_digit = 0
pin = f'{i:0>3}'
search_num = pin[current_digit]
for num in s:
# 見つけると桁を右に一つずらす
# 毎回リストにアクセスするより変数に取り出しておくほうがいいかも。
# if num == pin[current_digit]:
if num == search_num:
current_digit += 1
# indexが3(桁が3→2→1→0)になったときはそのPINは作れる
if current_digit == 3:
ans += 1
break
# 見つけ終わるまではチェックする数字を置き換え。
elif current_digit < 3:
search_num = pin[current_digit]
print(ans)
if __name__ == '__main__':
sumitrust2019_d() | 32 | 32 | 860 | 852 | def sumitrust2019_d():
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1000):
# 確認するpinの数字の組み合わせと桁の初期化
# pin = list(str(i).zfill(3))
current_digit = 0
pin = f"{i:0>3}"
search_num = pin[current_digit]
for num in s:
# 見つけると桁を右に一つずらす
# 毎回リストにアクセスするより変数に取り出しておくほうがいいかも。
# if num == pin[current_digit]:
if num == pin[current_digit]:
current_digit += 1
# indexが3(桁が3→2→1→0)になったときはそのPINは作れる
if current_digit == 3:
ans += 1
break
# 見つけ終わるまではチェックする数字を置き換え。
elif current_digit < 3:
search_num = pin[current_digit]
print(ans)
if __name__ == "__main__":
sumitrust2019_d()
| def sumitrust2019_d():
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(1000):
# 確認するpinの数字の組み合わせと桁の初期化
# pin = list(str(i).zfill(3))
current_digit = 0
pin = f"{i:0>3}"
search_num = pin[current_digit]
for num in s:
# 見つけると桁を右に一つずらす
# 毎回リストにアクセスするより変数に取り出しておくほうがいいかも。
# if num == pin[current_digit]:
if num == search_num:
current_digit += 1
# indexが3(桁が3→2→1→0)になったときはそのPINは作れる
if current_digit == 3:
ans += 1
break
# 見つけ終わるまではチェックする数字を置き換え。
elif current_digit < 3:
search_num = pin[current_digit]
print(ans)
if __name__ == "__main__":
sumitrust2019_d()
| false | 0 | [
"- if num == pin[current_digit]:",
"+ if num == search_num:"
] | false | 0.097701 | 0.043848 | 2.228182 | [
"s974830919",
"s473058968"
] |
u197955752 | p03073 | python | s322448560 | s025034781 | 130 | 50 | 3,316 | 3,188 | Accepted | Accepted | 61.54 | S = eval(input())
N = len(S) # タイルの数
a = sum((1 << i) for i in range(0, N, 2)) # 0b ...0101
a_flip = bin(a ^ int(S, base = 2))[2:].count('1')
print((min(a_flip, N - a_flip)))
| S = eval(input())
N = len(S) # タイルの数
flip = sum( 1 ^ int(S[i]) for i in range(0, N, 2))
flip += sum( 0 ^ int(S[i]) for i in range(1, N, 2))
print((min(flip, N - flip)))
| 7 | 7 | 175 | 169 | S = eval(input())
N = len(S) # タイルの数
a = sum((1 << i) for i in range(0, N, 2)) # 0b ...0101
a_flip = bin(a ^ int(S, base=2))[2:].count("1")
print((min(a_flip, N - a_flip)))
| S = eval(input())
N = len(S) # タイルの数
flip = sum(1 ^ int(S[i]) for i in range(0, N, 2))
flip += sum(0 ^ int(S[i]) for i in range(1, N, 2))
print((min(flip, N - flip)))
| false | 0 | [
"-a = sum((1 << i) for i in range(0, N, 2)) # 0b ...0101",
"-a_flip = bin(a ^ int(S, base=2))[2:].count(\"1\")",
"-print((min(a_flip, N - a_flip)))",
"+flip = sum(1 ^ int(S[i]) for i in range(0, N, 2))",
"+flip += sum(0 ^ int(S[i]) for i in range(1, N, 2))",
"+print((min(flip, N - flip)))"
] | false | 0.057109 | 0.047118 | 1.212041 | [
"s322448560",
"s025034781"
] |
u145950990 | p03127 | python | s153024042 | s827881763 | 334 | 130 | 88,428 | 14,252 | Accepted | Accepted | 61.08 | import fractions
n = int(eval(input()))
a = list(map(int,input().split()))
ans = a[0]
for i in a[1:]:
ans = fractions.gcd(ans,i)
print(ans) | n = int(eval(input()))
a = sorted(list(map(int,input().split())))
from fractions import gcd
g = a[0]
for i in a[1:]:
g = gcd(g,i)
print(g) | 7 | 7 | 143 | 142 | import fractions
n = int(eval(input()))
a = list(map(int, input().split()))
ans = a[0]
for i in a[1:]:
ans = fractions.gcd(ans, i)
print(ans)
| n = int(eval(input()))
a = sorted(list(map(int, input().split())))
from fractions import gcd
g = a[0]
for i in a[1:]:
g = gcd(g, i)
print(g)
| false | 0 | [
"-import fractions",
"+n = int(eval(input()))",
"+a = sorted(list(map(int, input().split())))",
"+from fractions import gcd",
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-ans = a[0]",
"+g = a[0]",
"- ans = fractions.gcd(ans, i)",
"-print(ans)",
"+ g = gcd(g, i)",
"+print(g)"
] | false | 0.050865 | 0.149983 | 0.339138 | [
"s153024042",
"s827881763"
] |
u952708174 | p02676 | python | s759287983 | s147666204 | 25 | 22 | 9,164 | 9,108 | Accepted | Accepted | 12 | K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[:K] + '...')) | K = int(eval(input()))
S = eval(input())
print((S if len(S) <= K else S[:K] + '...')) | 7 | 3 | 95 | 73 | K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
print((S[:K] + "..."))
| K = int(eval(input()))
S = eval(input())
print((S if len(S) <= K else S[:K] + "..."))
| false | 57.142857 | [
"-if len(S) <= K:",
"- print(S)",
"-else:",
"- print((S[:K] + \"...\"))",
"+print((S if len(S) <= K else S[:K] + \"...\"))"
] | false | 0.049833 | 0.103369 | 0.482092 | [
"s759287983",
"s147666204"
] |
u088552457 | p03319 | python | s059891362 | s594213316 | 88 | 81 | 84,068 | 82,760 | Accepted | Accepted | 7.95 | # import sys
# input = sys.stdin.readline
import collections
import itertools
def main():
n, k = input_list()
a = input_list()
if (n - 1) % (k - 1) == 0:
print(((n-1) // (k-1)))
else:
v = (n-1) // (k-1)
print((v + 1))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| # import sys
# input = sys.stdin.readline
import collections
import itertools
def main():
n, k = input_list()
a = input_list()
b = n - 1
x = k - 1
ans = b // x
if b % x == 0:
print(ans)
else:
print((ans + 1))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| 25 | 26 | 449 | 446 | # import sys
# input = sys.stdin.readline
import collections
import itertools
def main():
n, k = input_list()
a = input_list()
if (n - 1) % (k - 1) == 0:
print(((n - 1) // (k - 1)))
else:
v = (n - 1) // (k - 1)
print((v + 1))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| # import sys
# input = sys.stdin.readline
import collections
import itertools
def main():
n, k = input_list()
a = input_list()
b = n - 1
x = k - 1
ans = b // x
if b % x == 0:
print(ans)
else:
print((ans + 1))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
if __name__ == "__main__":
main()
| false | 3.846154 | [
"- if (n - 1) % (k - 1) == 0:",
"- print(((n - 1) // (k - 1)))",
"+ b = n - 1",
"+ x = k - 1",
"+ ans = b // x",
"+ if b % x == 0:",
"+ print(ans)",
"- v = (n - 1) // (k - 1)",
"- print((v + 1))",
"+ print((ans + 1))"
] | false | 0.044527 | 0.044637 | 0.997541 | [
"s059891362",
"s594213316"
] |
u263830634 | p03295 | python | s386211593 | s172413937 | 478 | 422 | 29,140 | 18,232 | Accepted | Accepted | 11.72 | N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
AB.sort(key = lambda x: x[0])
MAX = 10 ** 9
count = 1
min_ = MAX
for a, b in AB:
if a < min_:
min_ = min(min_, b)
else:
count += 1
min_ = b
print (count)
| N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(M)]
AB.sort(key = lambda x: x[0])
count = 1
B = 10 ** 9
for a, b in AB:
if a < B:
B = min(B, b)
else:
count += 1
B = b
print (count)
| 18 | 15 | 298 | 269 | N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for _ in range(M)]
AB.sort(key=lambda x: x[0])
MAX = 10**9
count = 1
min_ = MAX
for a, b in AB:
if a < min_:
min_ = min(min_, b)
else:
count += 1
min_ = b
print(count)
| N, M = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for _ in range(M)]
AB.sort(key=lambda x: x[0])
count = 1
B = 10**9
for a, b in AB:
if a < B:
B = min(B, b)
else:
count += 1
B = b
print(count)
| false | 16.666667 | [
"-AB = [list(map(int, input().split())) for _ in range(M)]",
"+AB = [tuple(map(int, input().split())) for _ in range(M)]",
"-MAX = 10**9",
"-min_ = MAX",
"+B = 10**9",
"- if a < min_:",
"- min_ = min(min_, b)",
"+ if a < B:",
"+ B = min(B, b)",
"- min_ = b",
"+ B = b"
] | false | 0.051634 | 0.043641 | 1.183147 | [
"s386211593",
"s172413937"
] |
u046187684 | p03448 | python | s929802436 | s330741031 | 44 | 18 | 3,060 | 2,940 | Accepted | Accepted | 59.09 | def solve(string):
a, b, c, x = list(map(int, string.split()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
ans += 1
return str(ans)
if __name__ == '__main__':
n = 4
print((solve('\n'.join([eval(input()) for _ in range(n)]))))
| def solve(string):
a, b, c, x = list(map(int, string.split()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
if 0 <= x - 500 * i - 100 * j <= 50 * c:
ans += 1
return str(ans)
if __name__ == '__main__':
n = 4
print((solve('\n'.join([eval(input()) for _ in range(n)]))))
| 14 | 13 | 376 | 337 | def solve(string):
a, b, c, x = list(map(int, string.split()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
for k in range(c + 1):
if 500 * i + 100 * j + 50 * k == x:
ans += 1
return str(ans)
if __name__ == "__main__":
n = 4
print((solve("\n".join([eval(input()) for _ in range(n)]))))
| def solve(string):
a, b, c, x = list(map(int, string.split()))
ans = 0
for i in range(a + 1):
for j in range(b + 1):
if 0 <= x - 500 * i - 100 * j <= 50 * c:
ans += 1
return str(ans)
if __name__ == "__main__":
n = 4
print((solve("\n".join([eval(input()) for _ in range(n)]))))
| false | 7.142857 | [
"- for k in range(c + 1):",
"- if 500 * i + 100 * j + 50 * k == x:",
"- ans += 1",
"+ if 0 <= x - 500 * i - 100 * j <= 50 * c:",
"+ ans += 1"
] | false | 0.036188 | 0.035441 | 1.021086 | [
"s929802436",
"s330741031"
] |
u506689504 | p03186 | python | s836942176 | s802204956 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | a,b,c = list(map(int, input().split()))
print((min(a+b+1, c)+b)) | a,b,c = list(map(int, input().split()))
if a+b>=c-1:
print((b+c))
else:
print((a+b+1+b))
| 2 | 5 | 57 | 85 | a, b, c = list(map(int, input().split()))
print((min(a + b + 1, c) + b))
| a, b, c = list(map(int, input().split()))
if a + b >= c - 1:
print((b + c))
else:
print((a + b + 1 + b))
| false | 60 | [
"-print((min(a + b + 1, c) + b))",
"+if a + b >= c - 1:",
"+ print((b + c))",
"+else:",
"+ print((a + b + 1 + b))"
] | false | 0.046208 | 0.045903 | 1.006652 | [
"s836942176",
"s802204956"
] |
u316233444 | p02911 | python | s191045683 | s139376508 | 417 | 270 | 21,632 | 11,776 | Accepted | Accepted | 35.25 | import numpy as np
def python_list_sub(in1, in2):
wrk = np.array(in1) + np.array(in2)
return wrk.tolist()
n, k, q = list(map(int,input().split()))
#A = []
Po = []
De = [1 for i in range(n)]
A = [int(eval(input())) for i in range(q)]
#print(A)
# はじめからポイント減らしておく
for i in range(n):
Po.append(int(k-q))
#print(Po)
# 入力はOK
#計算
for j in A:
#print(j,A[j])
Po[j-1] += 1
#print(Po)
for i in range(n):
if Po[i] >0:
print('Yes')
else: print('No') | #2019/09/15 300点，ぎり間に合わず 悔しい
'''
import numpy as np
def python_list_sub(in1, in2):
wrk = np.array(in1) + np.array(in2)
return wrk.tolist()
'''
n, k, q = list(map(int,input().split()))
Po = []
#De = [1 for i in range(n)]
A = [int(eval(input())) for i in range(q)]
#print(A)
# はじめからポイント減らしておく:ここが味噌
for i in range(n):
Po.append(int(k-q))
#print(Po)
# 入力OK
#計算，正解者だけ足していく
for j in A:
#print(j,A[j])
Po[j-1] += 1
#print(Po)
for i in range(n):
if Po[i] >0:
print('Yes')
else: print('No') | 30 | 33 | 495 | 545 | import numpy as np
def python_list_sub(in1, in2):
wrk = np.array(in1) + np.array(in2)
return wrk.tolist()
n, k, q = list(map(int, input().split()))
# A = []
Po = []
De = [1 for i in range(n)]
A = [int(eval(input())) for i in range(q)]
# print(A)
# はじめからポイント減らしておく
for i in range(n):
Po.append(int(k - q))
# print(Po)
# 入力はOK
# 計算
for j in A:
# print(j,A[j])
Po[j - 1] += 1
# print(Po)
for i in range(n):
if Po[i] > 0:
print("Yes")
else:
print("No")
| # 2019/09/15 300点，ぎり間に合わず 悔しい
"""
import numpy as np
def python_list_sub(in1, in2):
wrk = np.array(in1) + np.array(in2)
return wrk.tolist()
"""
n, k, q = list(map(int, input().split()))
Po = []
# De = [1 for i in range(n)]
A = [int(eval(input())) for i in range(q)]
# print(A)
# はじめからポイント減らしておく:ここが味噌
for i in range(n):
Po.append(int(k - q))
# print(Po)
# 入力OK
# 計算，正解者だけ足していく
for j in A:
# print(j,A[j])
Po[j - 1] += 1
# print(Po)
for i in range(n):
if Po[i] > 0:
print("Yes")
else:
print("No")
| false | 9.090909 | [
"+# 2019/09/15 300点，ぎり間に合わず 悔しい",
"+\"\"\"",
"-",
"-",
"-",
"-",
"+\"\"\"",
"-# A = []",
"-De = [1 for i in range(n)]",
"+# De = [1 for i in range(n)]",
"-# はじめからポイント減らしておく",
"+# はじめからポイント減らしておく:ここが味噌",
"-# 入力はOK",
"-# 計算",
"+# 入力OK",
"+# 計算，正解者だけ足していく"
] | false | 0.425819 | 0.040924 | 10.405212 | [
"s191045683",
"s139376508"
] |
u729133443 | p02610 | python | s727610800 | s518448938 | 1,236 | 981 | 40,044 | 39,924 | Accepted | Accepted | 20.63 | from heapq import*
i=input
for _ in'_'*int(i()):
n,s,x,*y=int(i()),0,[]
for _ in'_'*n:
k,l,r=list(map(int,i().split()))
if l>r:x+=(k,l,r),
else:y+=(n-k,r,l),
for x in x,y:
x.sort();n,*h=len(x),
while n:
n-=1
while x and x[-1][0]>n:k,l,r=x.pop();heappush(h,(r-l,l,r))
if h:s+=heappop(h)[1]
for*_,r in x+h:s+=r
print(s) | from heapq import*
i=input
for _ in'_'*int(i()):
n,s,x,*y=int(i()),0,[]
for _ in'_'*n:k,l,r=list(map(int,i().split()));x+=[(k,l,r)]*(l>r);y+=[(n-k,r,l)]*(l<=r)
for x in x,y:
x.sort();n,*h=len(x),
while n:
n-=1
while x and x[-1][0]>n:k,l,r=x.pop();heappush(h,(r-l,l,r))
if h:s+=heappop(h)[1]
for*_,r in x+h:s+=r
print(s) | 16 | 13 | 351 | 344 | from heapq import *
i = input
for _ in "_" * int(i()):
n, s, x, *y = int(i()), 0, []
for _ in "_" * n:
k, l, r = list(map(int, i().split()))
if l > r:
x += ((k, l, r),)
else:
y += ((n - k, r, l),)
for x in x, y:
x.sort()
n, *h = (len(x),)
while n:
n -= 1
while x and x[-1][0] > n:
k, l, r = x.pop()
heappush(h, (r - l, l, r))
if h:
s += heappop(h)[1]
for *_, r in x + h:
s += r
print(s)
| from heapq import *
i = input
for _ in "_" * int(i()):
n, s, x, *y = int(i()), 0, []
for _ in "_" * n:
k, l, r = list(map(int, i().split()))
x += [(k, l, r)] * (l > r)
y += [(n - k, r, l)] * (l <= r)
for x in x, y:
x.sort()
n, *h = (len(x),)
while n:
n -= 1
while x and x[-1][0] > n:
k, l, r = x.pop()
heappush(h, (r - l, l, r))
if h:
s += heappop(h)[1]
for *_, r in x + h:
s += r
print(s)
| false | 18.75 | [
"- if l > r:",
"- x += ((k, l, r),)",
"- else:",
"- y += ((n - k, r, l),)",
"+ x += [(k, l, r)] * (l > r)",
"+ y += [(n - k, r, l)] * (l <= r)"
] | false | 0.074123 | 0.149316 | 0.496416 | [
"s727610800",
"s518448938"
] |
u525065967 | p02607 | python | s324706382 | s310912321 | 26 | 23 | 8,940 | 9,088 | Accepted | Accepted | 11.54 | n = int(eval(input()))
A = [*list(map(int, input().split()))]
c = 0
for i in range(1, n+1):
if i%2 and A[i-1]%2: c += 1
print(c)
| n = int(eval(input()))
c = i = 0
for a in map(int, input().split()):
i += 1
if i%2 and a%2: c += 1
print(c)
| 7 | 7 | 128 | 117 | n = int(eval(input()))
A = [*list(map(int, input().split()))]
c = 0
for i in range(1, n + 1):
if i % 2 and A[i - 1] % 2:
c += 1
print(c)
| n = int(eval(input()))
c = i = 0
for a in map(int, input().split()):
i += 1
if i % 2 and a % 2:
c += 1
print(c)
| false | 0 | [
"-A = [*list(map(int, input().split()))]",
"-c = 0",
"-for i in range(1, n + 1):",
"- if i % 2 and A[i - 1] % 2:",
"+c = i = 0",
"+for a in map(int, input().split()):",
"+ i += 1",
"+ if i % 2 and a % 2:"
] | false | 0.042559 | 0.042025 | 1.012702 | [
"s324706382",
"s310912321"
] |
u102461423 | p03953 | python | s730701169 | s078605369 | 347 | 173 | 42,800 | 40,184 | Accepted | Accepted | 50.14 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
"""
・対象のうさぎの期待値だけ分かれば、次時点での期待値が分かる
・期待値の差分Yを持つ。操作は、Y[i-1]とY[i]の交換
"""
N = int(readline())
X = np.zeros(N+1,np.int64)
X[1:] = readline().split()
M,K = list(map(int,readline().split()))
A = list(map(int,read().split()))
Y = np.diff(X)
# newY[i] = Y[P[i]]
P = list(range(N))
for a in A:
P[a],P[a-1] = P[a-1],P[a]
P = np.array(P)
def mult_perm(P,Q):
return P[Q]
def power_perm(P,N):
if N == 0:
return np.arange(len(P))
Q = power_perm(P,N//2)
Q = mult_perm(Q,Q)
return mult_perm(P,Q) if N & 1 else Q
Q = power_perm(P,K)
newY = Y[Q]
newX = np.cumsum(newY)
print(('\n'.join(newX.astype(str)))) | import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main(N, M, K, X, A):
def compute_perm(A):
P = np.arange(N - 1)
for i in A:
P[i - 2], P[i - 1] = P[i - 1], P[i - 2]
return P
def power(P, K):
Q = P.copy()
x = np.arange(len(P), dtype=np.int32)
while K:
if K & 1:
x = x[Q]
Q = Q[Q]
K >>= 1
return x
P = compute_perm(A)
P = power(P, K)
D = X[1:] - X[:-1]
D = D[P]
ret = np.zeros(N, np.int64)
ret[0] = X[0]
ret[1:] = np.cumsum(D) + X[0]
return ret
signature = '(i8,i8,i8,i8[:],i4[:])'
if sys.argv[-1] == 'ONLINE_JUDGE':
from numba.pycc import CC
cc = CC('my_module')
cc.export('main', signature)(main)
cc.compile()
from my_module import main
N = int(readline())
X = np.array(readline().split(), np.int64)
M, K = list(map(int, readline().split()))
A = np.array(readline().split(), np.int32)
x = main(N, M, K, X, A)
print(('\n'.join(map(str, x.tolist())))) | 42 | 49 | 796 | 1,162 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
"""
・対象のうさぎの期待値だけ分かれば、次時点での期待値が分かる
・期待値の差分Yを持つ。操作は、Y[i-1]とY[i]の交換
"""
N = int(readline())
X = np.zeros(N + 1, np.int64)
X[1:] = readline().split()
M, K = list(map(int, readline().split()))
A = list(map(int, read().split()))
Y = np.diff(X)
# newY[i] = Y[P[i]]
P = list(range(N))
for a in A:
P[a], P[a - 1] = P[a - 1], P[a]
P = np.array(P)
def mult_perm(P, Q):
return P[Q]
def power_perm(P, N):
if N == 0:
return np.arange(len(P))
Q = power_perm(P, N // 2)
Q = mult_perm(Q, Q)
return mult_perm(P, Q) if N & 1 else Q
Q = power_perm(P, K)
newY = Y[Q]
newX = np.cumsum(newY)
print(("\n".join(newX.astype(str))))
| import sys
import numpy as np
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def main(N, M, K, X, A):
def compute_perm(A):
P = np.arange(N - 1)
for i in A:
P[i - 2], P[i - 1] = P[i - 1], P[i - 2]
return P
def power(P, K):
Q = P.copy()
x = np.arange(len(P), dtype=np.int32)
while K:
if K & 1:
x = x[Q]
Q = Q[Q]
K >>= 1
return x
P = compute_perm(A)
P = power(P, K)
D = X[1:] - X[:-1]
D = D[P]
ret = np.zeros(N, np.int64)
ret[0] = X[0]
ret[1:] = np.cumsum(D) + X[0]
return ret
signature = "(i8,i8,i8,i8[:],i4[:])"
if sys.argv[-1] == "ONLINE_JUDGE":
from numba.pycc import CC
cc = CC("my_module")
cc.export("main", signature)(main)
cc.compile()
from my_module import main
N = int(readline())
X = np.array(readline().split(), np.int64)
M, K = list(map(int, readline().split()))
A = np.array(readline().split(), np.int32)
x = main(N, M, K, X, A)
print(("\n".join(map(str, x.tolist()))))
| false | 14.285714 | [
"+import numpy as np",
"-import numpy as np",
"-",
"-\"\"\"",
"-・対象のうさぎの期待値だけ分かれば、次時点での期待値が分かる",
"-・期待値の差分Yを持つ。操作は、Y[i-1]とY[i]の交換",
"-\"\"\"",
"-N = int(readline())",
"-X = np.zeros(N + 1, np.int64)",
"-X[1:] = readline().split()",
"-M, K = list(map(int, readline().split()))",
"-A = list(map(int, read().split()))",
"-Y = np.diff(X)",
"-# newY[i] = Y[P[i]]",
"-P = list(range(N))",
"-for a in A:",
"- P[a], P[a - 1] = P[a - 1], P[a]",
"-P = np.array(P)",
"-def mult_perm(P, Q):",
"- return P[Q]",
"+def main(N, M, K, X, A):",
"+ def compute_perm(A):",
"+ P = np.arange(N - 1)",
"+ for i in A:",
"+ P[i - 2], P[i - 1] = P[i - 1], P[i - 2]",
"+ return P",
"+",
"+ def power(P, K):",
"+ Q = P.copy()",
"+ x = np.arange(len(P), dtype=np.int32)",
"+ while K:",
"+ if K & 1:",
"+ x = x[Q]",
"+ Q = Q[Q]",
"+ K >>= 1",
"+ return x",
"+",
"+ P = compute_perm(A)",
"+ P = power(P, K)",
"+ D = X[1:] - X[:-1]",
"+ D = D[P]",
"+ ret = np.zeros(N, np.int64)",
"+ ret[0] = X[0]",
"+ ret[1:] = np.cumsum(D) + X[0]",
"+ return ret",
"-def power_perm(P, N):",
"- if N == 0:",
"- return np.arange(len(P))",
"- Q = power_perm(P, N // 2)",
"- Q = mult_perm(Q, Q)",
"- return mult_perm(P, Q) if N & 1 else Q",
"+signature = \"(i8,i8,i8,i8[:],i4[:])\"",
"+if sys.argv[-1] == \"ONLINE_JUDGE\":",
"+ from numba.pycc import CC",
"+ cc = CC(\"my_module\")",
"+ cc.export(\"main\", signature)(main)",
"+ cc.compile()",
"+from my_module import main",
"-Q = power_perm(P, K)",
"-newY = Y[Q]",
"-newX = np.cumsum(newY)",
"-print((\"\\n\".join(newX.astype(str))))",
"+N = int(readline())",
"+X = np.array(readline().split(), np.int64)",
"+M, K = list(map(int, readline().split()))",
"+A = np.array(readline().split(), np.int32)",
"+x = main(N, M, K, X, A)",
"+print((\"\\n\".join(map(str, x.tolist()))))"
] | false | 0.230631 | 0.421711 | 0.546893 | [
"s730701169",
"s078605369"
] |
u464205401 | p02629 | python | s104082569 | s540333062 | 33 | 28 | 9,184 | 9,168 | Accepted | Accepted | 15.15 | n=int(eval(input()))
ans=""
for l in range(1,15):
if n<=26**l:
n-=1
for j in range(l):
ans+=chr(ord('a')+n%26)
n//=26
break
else:
n-=26**l
print((ans[::-1]))
| n=int(eval(input()))
tmp=0
for ll in range(1,20):
tmp+=26**ll
if n<=tmp:
break
s=chr((n-1)%26+ord("a")) ##一文字目
for i in range(1,ll):
n-=26**i
s+=chr((n-1)//(26**i)%26+ord("a"))
print((s[::-1]))
| 14 | 14 | 204 | 215 | n = int(eval(input()))
ans = ""
for l in range(1, 15):
if n <= 26**l:
n -= 1
for j in range(l):
ans += chr(ord("a") + n % 26)
n //= 26
break
else:
n -= 26**l
print((ans[::-1]))
| n = int(eval(input()))
tmp = 0
for ll in range(1, 20):
tmp += 26**ll
if n <= tmp:
break
s = chr((n - 1) % 26 + ord("a")) ##一文字目
for i in range(1, ll):
n -= 26**i
s += chr((n - 1) // (26**i) % 26 + ord("a"))
print((s[::-1]))
| false | 0 | [
"-ans = \"\"",
"-for l in range(1, 15):",
"- if n <= 26**l:",
"- n -= 1",
"- for j in range(l):",
"- ans += chr(ord(\"a\") + n % 26)",
"- n //= 26",
"+tmp = 0",
"+for ll in range(1, 20):",
"+ tmp += 26**ll",
"+ if n <= tmp:",
"- else:",
"- n -= 26**l",
"-print((ans[::-1]))",
"+s = chr((n - 1) % 26 + ord(\"a\")) ##一文字目",
"+for i in range(1, ll):",
"+ n -= 26**i",
"+ s += chr((n - 1) // (26**i) % 26 + ord(\"a\"))",
"+print((s[::-1]))"
] | false | 0.034076 | 0.048056 | 0.709096 | [
"s104082569",
"s540333062"
] |
u044220565 | p02587 | python | s564172204 | s074746971 | 394 | 38 | 9,760 | 9,368 | Accepted | Accepted | 90.36 | # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
def search_next(l, r, SC):
ll, lc = l
rr, rc = r
nexts = []
if len(ll) > len(rr):
part = ll[::-1]
for s,c in SC:
if s[-len(part):] == part:
r_n = (s[:-len(ll)], rc + c)
l_n = ('', lc)
nexts.append((rc+c+lc, (l_n, r_n)))
elif s == part[-len(s):]:
l_n =(ll[len(s):], lc)
r_n = ('', rc + c)
nexts.append((rc + c + lc, (l_n, r_n)))
else:
part = rr[::-1]
for s, c in SC:
if s[:len(part)] == part:
l_n = (s[len(rr):], lc + c)
r_n = ('', rc)
nexts.append((lc+rc+c, (l_n, r_n)))
elif s == part[:len(s)]:
r_n = (rr[:-len(s)], rc)
l_n = ('', lc + c)
nexts.append((lc + rc + c, (l_n, r_n)))
return nexts
def palindrome(l, r):
if l + r == (l+r)[::-1]:
return True
else:
return False
def run():
totalL = 0
N = int(sysread())
SC = []
for i in range(N):
s,c = input().split()
c = int(c)
SC.append((s,c))
totalL += len(s)
min_val = INF
for s,c in SC:
queue = []
left = (s, c)
right = ('', 0)
heappush(queue, (c, (left, right)))
done = False
count = 0
while queue:
count += 1
if count > 200000:break
#print(queue)
cost, (l, r) = heappop(queue)
if palindrome(l[0], r[0]):
done = True
#print(l, r)
break
nexts = search_next(l, r, SC)
for n in nexts:
heappush(queue, n)
if done:
min_val = min(min_val, cost)
if min_val == INF:
print((-1))
else:
print(min_val)
if __name__ == "__main__":
run() | # coding: utf-8
import sys
#from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
#from collections import defaultdict
sys.setrecursionlimit(10**7)
#import math
#from itertools import product, accumulate, combinations, product
#import bisect
#import numpy as np
#from copy import deepcopy
#from collections import deque
#from decimal import Decimal
#from numba import jit
INF = 1 << 50
def search_next(l, r, SC):
ll, lc = l
rr, rc = r
nexts = []
if len(ll) > len(rr):
part = ll[::-1]
for s,c in SC:
if s[-len(part):] == part:
r_n = (s[:-len(ll)], rc + c)
l_n = ('', lc)
nexts.append((rc+c+lc, (l_n, r_n)))
elif s == part[-len(s):]:
l_n =(ll[len(s):], lc)
r_n = ('', rc + c)
nexts.append((rc + c + lc, (l_n, r_n)))
else:
part = rr[::-1]
for s, c in SC:
if s[:len(part)] == part:
l_n = (s[len(rr):], lc + c)
r_n = ('', rc)
nexts.append((lc+rc+c, (l_n, r_n)))
elif s == part[:len(s)]:
r_n = (rr[:-len(s)], rc)
l_n = ('', lc + c)
nexts.append((lc + rc + c, (l_n, r_n)))
return nexts
def palindrome(l, r):
if l + r == (l+r)[::-1]:
return True
else:
return False
def run():
totalL = 0
N = int(sysread())
SC = []
for i in range(N):
s,c = input().split()
c = int(c)
SC.append((s,c))
totalL += len(s)
min_val = INF
cache = set()
for s,c in SC:
queue = []
left = (s, c)
right = ('', 0)
heappush(queue, (c, (left, right)))
done = False
while queue:
#print(queue)
cost, (l, r) = heappop(queue)
if (l[0], r[0]) in cache: continue
cache.add((l[0], r[0]))
if palindrome(l[0], r[0]):
done = True
#print(l, r)
cache.remove((l[0], r[0]))
break
nexts = search_next(l, r, SC)
for n in nexts:
heappush(queue, n)
if done:
min_val = min(min_val, cost)
if min_val == INF:
print((-1))
else:
print(min_val)
if __name__ == "__main__":
run() | 94 | 96 | 2,464 | 2,534 | # coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
# from collections import defaultdict
sys.setrecursionlimit(10**7)
# import math
# from itertools import product, accumulate, combinations, product
# import bisect
# import numpy as np
# from copy import deepcopy
# from collections import deque
# from decimal import Decimal
# from numba import jit
INF = 1 << 50
def search_next(l, r, SC):
ll, lc = l
rr, rc = r
nexts = []
if len(ll) > len(rr):
part = ll[::-1]
for s, c in SC:
if s[-len(part) :] == part:
r_n = (s[: -len(ll)], rc + c)
l_n = ("", lc)
nexts.append((rc + c + lc, (l_n, r_n)))
elif s == part[-len(s) :]:
l_n = (ll[len(s) :], lc)
r_n = ("", rc + c)
nexts.append((rc + c + lc, (l_n, r_n)))
else:
part = rr[::-1]
for s, c in SC:
if s[: len(part)] == part:
l_n = (s[len(rr) :], lc + c)
r_n = ("", rc)
nexts.append((lc + rc + c, (l_n, r_n)))
elif s == part[: len(s)]:
r_n = (rr[: -len(s)], rc)
l_n = ("", lc + c)
nexts.append((lc + rc + c, (l_n, r_n)))
return nexts
def palindrome(l, r):
if l + r == (l + r)[::-1]:
return True
else:
return False
def run():
totalL = 0
N = int(sysread())
SC = []
for i in range(N):
s, c = input().split()
c = int(c)
SC.append((s, c))
totalL += len(s)
min_val = INF
for s, c in SC:
queue = []
left = (s, c)
right = ("", 0)
heappush(queue, (c, (left, right)))
done = False
count = 0
while queue:
count += 1
if count > 200000:
break
# print(queue)
cost, (l, r) = heappop(queue)
if palindrome(l[0], r[0]):
done = True
# print(l, r)
break
nexts = search_next(l, r, SC)
for n in nexts:
heappush(queue, n)
if done:
min_val = min(min_val, cost)
if min_val == INF:
print((-1))
else:
print(min_val)
if __name__ == "__main__":
run()
| # coding: utf-8
import sys
# from operator import itemgetter
sysread = sys.stdin.buffer.readline
read = sys.stdin.buffer.read
from heapq import heappop, heappush
# from collections import defaultdict
sys.setrecursionlimit(10**7)
# import math
# from itertools import product, accumulate, combinations, product
# import bisect
# import numpy as np
# from copy import deepcopy
# from collections import deque
# from decimal import Decimal
# from numba import jit
INF = 1 << 50
def search_next(l, r, SC):
ll, lc = l
rr, rc = r
nexts = []
if len(ll) > len(rr):
part = ll[::-1]
for s, c in SC:
if s[-len(part) :] == part:
r_n = (s[: -len(ll)], rc + c)
l_n = ("", lc)
nexts.append((rc + c + lc, (l_n, r_n)))
elif s == part[-len(s) :]:
l_n = (ll[len(s) :], lc)
r_n = ("", rc + c)
nexts.append((rc + c + lc, (l_n, r_n)))
else:
part = rr[::-1]
for s, c in SC:
if s[: len(part)] == part:
l_n = (s[len(rr) :], lc + c)
r_n = ("", rc)
nexts.append((lc + rc + c, (l_n, r_n)))
elif s == part[: len(s)]:
r_n = (rr[: -len(s)], rc)
l_n = ("", lc + c)
nexts.append((lc + rc + c, (l_n, r_n)))
return nexts
def palindrome(l, r):
if l + r == (l + r)[::-1]:
return True
else:
return False
def run():
totalL = 0
N = int(sysread())
SC = []
for i in range(N):
s, c = input().split()
c = int(c)
SC.append((s, c))
totalL += len(s)
min_val = INF
cache = set()
for s, c in SC:
queue = []
left = (s, c)
right = ("", 0)
heappush(queue, (c, (left, right)))
done = False
while queue:
# print(queue)
cost, (l, r) = heappop(queue)
if (l[0], r[0]) in cache:
continue
cache.add((l[0], r[0]))
if palindrome(l[0], r[0]):
done = True
# print(l, r)
cache.remove((l[0], r[0]))
break
nexts = search_next(l, r, SC)
for n in nexts:
heappush(queue, n)
if done:
min_val = min(min_val, cost)
if min_val == INF:
print((-1))
else:
print(min_val)
if __name__ == "__main__":
run()
| false | 2.083333 | [
"+ cache = set()",
"- count = 0",
"- count += 1",
"- if count > 200000:",
"- break",
"+ if (l[0], r[0]) in cache:",
"+ continue",
"+ cache.add((l[0], r[0]))",
"+ cache.remove((l[0], r[0]))"
] | false | 0.049062 | 0.107655 | 0.455737 | [
"s564172204",
"s074746971"
] |
u476604182 | p03440 | python | s732746988 | s950802379 | 416 | 381 | 30,896 | 37,220 | Accepted | Accepted | 8.41 | import sys
input = sys.stdin.buffer.readline
from collections import defaultdict
import heapq
def main():
N,M = list(map(int,input().split()))
a = list(map(int,input().split()))
d = defaultdict(list)
I = [i for i in range(N)]
rank = [1 for _ in range(N)]
def root(a):
if I[a] == a:
return a
else:
I[a] = root(I[a])
return I[a]
def unite(a,b):
pa,pb = root(a),root(b)
ra,rb = rank[a],rank[b]
if ra > rb:
I[pb] = pa
else:
I[pa] = pb
if ra == rb:
rank[pb] += 1
for _ in range(M):
x,y = list(map(int,input().split()))
unite(x,y)
parent = root(x)
for i,num in enumerate(I):
parent = root(num)
heapq.heappush(d[parent],a[i])
if M == N-1:
print((0))
exit()
elif N < 2*(N-M-1):
print("Impossible")
exit()
l = len(list(d.keys()))
ans = 0
rest = []
for use in list(d.values()):
ans += heapq.heappop(use)
rest.extend(use)
remain = 2*(N-M-1)-l
rest.sort()
ans += sum(rest[:remain])
print(ans)
if __name__ == "__main__":
main()
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0]*n
def find(self, x):
if self.par[x]==x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x==y:
return
elif self.rank[x]<self.rank[y]:
self.par[x] = y
elif self.rank[y]<self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x)==self.find(y)
from collections import defaultdict
N,M,*L = list(map(int, open(0).read().split()))
A = L[:N]
U = UnionFind(N)
for x,y in zip(*[iter(L[N:])]*2):
U.unit(x,y)
ans = 0
rest = []
dic = defaultdict(list)
for i in range(N):
dic[U.find(i)].append(A[i])
for k in list(dic.keys()):
dic[k].sort()
ans += dic[k][0]
rest.extend(dic[k][1:])
if N-1==M:
print((0))
exit()
if N<2*(N-M-1):
print('Impossible')
exit()
rest.sort()
remain = 2*(N-M-1)-len(list(dic.keys()))
ans += sum(rest[:remain])
print(ans)
| 60 | 52 | 1,306 | 1,112 | import sys
input = sys.stdin.buffer.readline
from collections import defaultdict
import heapq
def main():
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
d = defaultdict(list)
I = [i for i in range(N)]
rank = [1 for _ in range(N)]
def root(a):
if I[a] == a:
return a
else:
I[a] = root(I[a])
return I[a]
def unite(a, b):
pa, pb = root(a), root(b)
ra, rb = rank[a], rank[b]
if ra > rb:
I[pb] = pa
else:
I[pa] = pb
if ra == rb:
rank[pb] += 1
for _ in range(M):
x, y = list(map(int, input().split()))
unite(x, y)
parent = root(x)
for i, num in enumerate(I):
parent = root(num)
heapq.heappush(d[parent], a[i])
if M == N - 1:
print((0))
exit()
elif N < 2 * (N - M - 1):
print("Impossible")
exit()
l = len(list(d.keys()))
ans = 0
rest = []
for use in list(d.values()):
ans += heapq.heappop(use)
rest.extend(use)
remain = 2 * (N - M - 1) - l
rest.sort()
ans += sum(rest[:remain])
print(ans)
if __name__ == "__main__":
main()
| class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n)]
self.rank = [0] * n
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unit(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
elif self.rank[x] < self.rank[y]:
self.par[x] = y
elif self.rank[y] < self.rank[x]:
self.par[y] = x
else:
self.par[y] = x
self.rank[x] += 1
def same(self, x, y):
return self.find(x) == self.find(y)
from collections import defaultdict
N, M, *L = list(map(int, open(0).read().split()))
A = L[:N]
U = UnionFind(N)
for x, y in zip(*[iter(L[N:])] * 2):
U.unit(x, y)
ans = 0
rest = []
dic = defaultdict(list)
for i in range(N):
dic[U.find(i)].append(A[i])
for k in list(dic.keys()):
dic[k].sort()
ans += dic[k][0]
rest.extend(dic[k][1:])
if N - 1 == M:
print((0))
exit()
if N < 2 * (N - M - 1):
print("Impossible")
exit()
rest.sort()
remain = 2 * (N - M - 1) - len(list(dic.keys()))
ans += sum(rest[:remain])
print(ans)
| false | 13.333333 | [
"-import sys",
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.par = [i for i in range(n)]",
"+ self.rank = [0] * n",
"-input = sys.stdin.buffer.readline",
"-from collections import defaultdict",
"-import heapq",
"+ def find(self, x):",
"+ if self.par[x] == x:",
"+ return x",
"+ else:",
"+ self.par[x] = self.find(self.par[x])",
"+ return self.par[x]",
"+",
"+ def unit(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ elif self.rank[x] < self.rank[y]:",
"+ self.par[x] = y",
"+ elif self.rank[y] < self.rank[x]:",
"+ self.par[y] = x",
"+ else:",
"+ self.par[y] = x",
"+ self.rank[x] += 1",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"-def main():",
"- N, M = list(map(int, input().split()))",
"- a = list(map(int, input().split()))",
"- d = defaultdict(list)",
"- I = [i for i in range(N)]",
"- rank = [1 for _ in range(N)]",
"+from collections import defaultdict",
"- def root(a):",
"- if I[a] == a:",
"- return a",
"- else:",
"- I[a] = root(I[a])",
"- return I[a]",
"-",
"- def unite(a, b):",
"- pa, pb = root(a), root(b)",
"- ra, rb = rank[a], rank[b]",
"- if ra > rb:",
"- I[pb] = pa",
"- else:",
"- I[pa] = pb",
"- if ra == rb:",
"- rank[pb] += 1",
"-",
"- for _ in range(M):",
"- x, y = list(map(int, input().split()))",
"- unite(x, y)",
"- parent = root(x)",
"- for i, num in enumerate(I):",
"- parent = root(num)",
"- heapq.heappush(d[parent], a[i])",
"- if M == N - 1:",
"- print((0))",
"- exit()",
"- elif N < 2 * (N - M - 1):",
"- print(\"Impossible\")",
"- exit()",
"- l = len(list(d.keys()))",
"- ans = 0",
"- rest = []",
"- for use in list(d.values()):",
"- ans += heapq.heappop(use)",
"- rest.extend(use)",
"- remain = 2 * (N - M - 1) - l",
"- rest.sort()",
"- ans += sum(rest[:remain])",
"- print(ans)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+N, M, *L = list(map(int, open(0).read().split()))",
"+A = L[:N]",
"+U = UnionFind(N)",
"+for x, y in zip(*[iter(L[N:])] * 2):",
"+ U.unit(x, y)",
"+ans = 0",
"+rest = []",
"+dic = defaultdict(list)",
"+for i in range(N):",
"+ dic[U.find(i)].append(A[i])",
"+for k in list(dic.keys()):",
"+ dic[k].sort()",
"+ ans += dic[k][0]",
"+ rest.extend(dic[k][1:])",
"+if N - 1 == M:",
"+ print((0))",
"+ exit()",
"+if N < 2 * (N - M - 1):",
"+ print(\"Impossible\")",
"+ exit()",
"+rest.sort()",
"+remain = 2 * (N - M - 1) - len(list(dic.keys()))",
"+ans += sum(rest[:remain])",
"+print(ans)"
] | false | 0.036483 | 0.037329 | 0.977323 | [
"s732746988",
"s950802379"
] |
u855985627 | p03241 | python | s975118174 | s507995414 | 1,732 | 649 | 3,444 | 3,444 | Accepted | Accepted | 62.53 | import random
def is_prime(q,k=50):
if q == 2: return True
if q < 2 or q&1 == 0: return False
d = (q-1)>>1
while d&1 == 0:
d >>= 1
for i in range(k):
a = random.randint(1,q-1)
t = d
y = pow(a,t,q)
while t != q-1 and y != 1 and y != q-1:
y = pow(y,2,q)
t <<= 1
if y != q-1 and t&1 == 0:
return False
return True
n,m=(int(i) for i in input().split(' '))
for i in range(1,n):
if m%i==0 and (is_prime(i) or i==1) and is_prime(m//i) and (i==1 or m//i<n):
print('1')
exit()
for i in range(n,m+1):
if i==m:
print((1))
break
if m%i==0:
print((m//i))
break
if m-i-n>0 and m%(m-i-n)==0 and m//(m-i-n)>n:
print((m-i-n))
break
| import random
def is_prime(q,k=50):
if q == 2: return True
if q < 2 or q&1 == 0: return False
d = (q-1)>>1
while d&1 == 0:
d >>= 1
for i in range(k):
a = random.randint(1,q-1)
t = d
y = pow(a,t,q)
while t != q-1 and y != 1 and y != q-1:
y = pow(y,2,q)
t <<= 1
if y != q-1 and t&1 == 0:
return False
return True
n,m=(int(i) for i in input().split(' '))
for i in range(1,n):
if m%i==0 and (is_prime(i) or i==1) and is_prime(m//i) and (i==1 or m//i<n):
print('1')
exit()
for i in range(n,m+1):
if i==m:
print((1))
break
if m%i==0:
print((m//i))
break | 34 | 31 | 793 | 714 | import random
def is_prime(q, k=50):
if q == 2:
return True
if q < 2 or q & 1 == 0:
return False
d = (q - 1) >> 1
while d & 1 == 0:
d >>= 1
for i in range(k):
a = random.randint(1, q - 1)
t = d
y = pow(a, t, q)
while t != q - 1 and y != 1 and y != q - 1:
y = pow(y, 2, q)
t <<= 1
if y != q - 1 and t & 1 == 0:
return False
return True
n, m = (int(i) for i in input().split(" "))
for i in range(1, n):
if (
m % i == 0
and (is_prime(i) or i == 1)
and is_prime(m // i)
and (i == 1 or m // i < n)
):
print("1")
exit()
for i in range(n, m + 1):
if i == m:
print((1))
break
if m % i == 0:
print((m // i))
break
if m - i - n > 0 and m % (m - i - n) == 0 and m // (m - i - n) > n:
print((m - i - n))
break
| import random
def is_prime(q, k=50):
if q == 2:
return True
if q < 2 or q & 1 == 0:
return False
d = (q - 1) >> 1
while d & 1 == 0:
d >>= 1
for i in range(k):
a = random.randint(1, q - 1)
t = d
y = pow(a, t, q)
while t != q - 1 and y != 1 and y != q - 1:
y = pow(y, 2, q)
t <<= 1
if y != q - 1 and t & 1 == 0:
return False
return True
n, m = (int(i) for i in input().split(" "))
for i in range(1, n):
if (
m % i == 0
and (is_prime(i) or i == 1)
and is_prime(m // i)
and (i == 1 or m // i < n)
):
print("1")
exit()
for i in range(n, m + 1):
if i == m:
print((1))
break
if m % i == 0:
print((m // i))
break
| false | 8.823529 | [
"- if m - i - n > 0 and m % (m - i - n) == 0 and m // (m - i - n) > n:",
"- print((m - i - n))",
"- break"
] | false | 0.053706 | 0.141811 | 0.378714 | [
"s975118174",
"s507995414"
] |
u189023301 | p03042 | python | s787036967 | s992387500 | 26 | 24 | 8,972 | 9,100 | Accepted | Accepted | 7.69 | s = int(eval(input()))
a, b = s // 100, s % 100
x = "YY" if a == 0 or a > 12 else "MM"
y = "YY" if b == 0 or b > 12 else "MM"
print((x + y if x != y else "NA" if x == "YY" else "AMBIGUOUS"))
| a, b = divmod(int(eval(input())), 100)
x = "MM" if 0 < a < 13 else "YY"
y = "MM" if 0 < b < 13 else "YY"
print((x + y if x != y else "NA" if x == "YY" else "AMBIGUOUS"))
| 5 | 4 | 187 | 165 | s = int(eval(input()))
a, b = s // 100, s % 100
x = "YY" if a == 0 or a > 12 else "MM"
y = "YY" if b == 0 or b > 12 else "MM"
print((x + y if x != y else "NA" if x == "YY" else "AMBIGUOUS"))
| a, b = divmod(int(eval(input())), 100)
x = "MM" if 0 < a < 13 else "YY"
y = "MM" if 0 < b < 13 else "YY"
print((x + y if x != y else "NA" if x == "YY" else "AMBIGUOUS"))
| false | 20 | [
"-s = int(eval(input()))",
"-a, b = s // 100, s % 100",
"-x = \"YY\" if a == 0 or a > 12 else \"MM\"",
"-y = \"YY\" if b == 0 or b > 12 else \"MM\"",
"+a, b = divmod(int(eval(input())), 100)",
"+x = \"MM\" if 0 < a < 13 else \"YY\"",
"+y = \"MM\" if 0 < b < 13 else \"YY\""
] | false | 0.008104 | 0.065646 | 0.123445 | [
"s787036967",
"s992387500"
] |
u720065198 | p02959 | python | s701113427 | s024007373 | 203 | 159 | 18,624 | 18,476 | Accepted | Accepted | 21.67 | N = int(eval(input()))
m = list(map(int, input().split()))
b = list(map(int, input().split()))
s = 0
for i in range(N):
l = min(m[i],b[i])
s += l
m[i] -= l
b[i] -= l
r = min(m[i+1],b[i])
s += r
m[i+1] -= r
print(s) | n = int(eval(input()))
a = list(map(int,input().split()))
b = list(map(int,input().split()))
c = 0
for i in range(n):
if a[i]>=b[i]:
c+=int(b[i])
else:
if (a[i]+a[i+1])>=b[i]:
c+=int(b[i])
a[i+1]=a[i]+a[i+1]-b[i]
else:
c+=int(a[i]+a[i+1])
a[i+1]=0
print(c) | 14 | 15 | 238 | 304 | N = int(eval(input()))
m = list(map(int, input().split()))
b = list(map(int, input().split()))
s = 0
for i in range(N):
l = min(m[i], b[i])
s += l
m[i] -= l
b[i] -= l
r = min(m[i + 1], b[i])
s += r
m[i + 1] -= r
print(s)
| n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = 0
for i in range(n):
if a[i] >= b[i]:
c += int(b[i])
else:
if (a[i] + a[i + 1]) >= b[i]:
c += int(b[i])
a[i + 1] = a[i] + a[i + 1] - b[i]
else:
c += int(a[i] + a[i + 1])
a[i + 1] = 0
print(c)
| false | 6.666667 | [
"-N = int(eval(input()))",
"-m = list(map(int, input().split()))",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"-s = 0",
"-for i in range(N):",
"- l = min(m[i], b[i])",
"- s += l",
"- m[i] -= l",
"- b[i] -= l",
"- r = min(m[i + 1], b[i])",
"- s += r",
"- m[i + 1] -= r",
"-print(s)",
"+c = 0",
"+for i in range(n):",
"+ if a[i] >= b[i]:",
"+ c += int(b[i])",
"+ else:",
"+ if (a[i] + a[i + 1]) >= b[i]:",
"+ c += int(b[i])",
"+ a[i + 1] = a[i] + a[i + 1] - b[i]",
"+ else:",
"+ c += int(a[i] + a[i + 1])",
"+ a[i + 1] = 0",
"+print(c)"
] | false | 0.048159 | 0.111256 | 0.432863 | [
"s701113427",
"s024007373"
] |
u094191970 | p03151 | python | s794641484 | s419131466 | 132 | 115 | 19,068 | 24,256 | Accepted | Accepted | 12.88 | from itertools import accumulate
n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
if sum(a)<sum(b):
print((-1))
exit()
c=[]
lack=0
cnt=0
for i,j in zip(a,b):
t=i-j
if i-j>=0:
c.append(t)
else:
lack+=abs(t)
cnt+=1
if cnt==0:
print((0))
exit()
c=sorted(c,reverse=True)
ru=list(accumulate(c))
for i in range(len(ru)):
if ru[i]>=lack:
cnt+=i+1
break
print(cnt) | from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n=int(eval(input()))
a=lnii()
b=lnii()
plus=[]
minus=0
ans=0
for i in range(n):
if a[i]<b[i]:
minus+=b[i]-a[i]
ans+=1
else:
plus.append(a[i]-b[i])
if minus==0:
print((0))
exit()
plus.sort(reverse=True)
for i in range(len(plus)):
minus-=plus[i]
ans+=1
if minus<=0:
print(ans)
exit()
print((-1)) | 33 | 31 | 456 | 471 | from itertools import accumulate
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
if sum(a) < sum(b):
print((-1))
exit()
c = []
lack = 0
cnt = 0
for i, j in zip(a, b):
t = i - j
if i - j >= 0:
c.append(t)
else:
lack += abs(t)
cnt += 1
if cnt == 0:
print((0))
exit()
c = sorted(c, reverse=True)
ru = list(accumulate(c))
for i in range(len(ru)):
if ru[i] >= lack:
cnt += i + 1
break
print(cnt)
| from sys import stdin
nii = lambda: list(map(int, stdin.readline().split()))
lnii = lambda: list(map(int, stdin.readline().split()))
n = int(eval(input()))
a = lnii()
b = lnii()
plus = []
minus = 0
ans = 0
for i in range(n):
if a[i] < b[i]:
minus += b[i] - a[i]
ans += 1
else:
plus.append(a[i] - b[i])
if minus == 0:
print((0))
exit()
plus.sort(reverse=True)
for i in range(len(plus)):
minus -= plus[i]
ans += 1
if minus <= 0:
print(ans)
exit()
print((-1))
| false | 6.060606 | [
"-from itertools import accumulate",
"+from sys import stdin",
"+nii = lambda: list(map(int, stdin.readline().split()))",
"+lnii = lambda: list(map(int, stdin.readline().split()))",
"-a = list(map(int, input().split()))",
"-b = list(map(int, input().split()))",
"-if sum(a) < sum(b):",
"- print((-1))",
"- exit()",
"-c = []",
"-lack = 0",
"-cnt = 0",
"-for i, j in zip(a, b):",
"- t = i - j",
"- if i - j >= 0:",
"- c.append(t)",
"+a = lnii()",
"+b = lnii()",
"+plus = []",
"+minus = 0",
"+ans = 0",
"+for i in range(n):",
"+ if a[i] < b[i]:",
"+ minus += b[i] - a[i]",
"+ ans += 1",
"- lack += abs(t)",
"- cnt += 1",
"-if cnt == 0:",
"+ plus.append(a[i] - b[i])",
"+if minus == 0:",
"-c = sorted(c, reverse=True)",
"-ru = list(accumulate(c))",
"-for i in range(len(ru)):",
"- if ru[i] >= lack:",
"- cnt += i + 1",
"- break",
"-print(cnt)",
"+plus.sort(reverse=True)",
"+for i in range(len(plus)):",
"+ minus -= plus[i]",
"+ ans += 1",
"+ if minus <= 0:",
"+ print(ans)",
"+ exit()",
"+print((-1))"
] | false | 0.038419 | 0.039996 | 0.960547 | [
"s794641484",
"s419131466"
] |
u232852711 | p03310 | python | s142406782 | s672657659 | 1,431 | 819 | 24,180 | 25,068 | Accepted | Accepted | 42.77 | from itertools import accumulate
from bisect import bisect_left, bisect_right
n = int(eval(input()))
a = list(map(int, input().split()))
ts = list(accumulate(a))+[0]
r = 0
def calc(st, ed):
t0 = ts[ed-1] - ts[st-1]
i1 = bisect_left(ts, (ts[ed-1]+ts[st-1])/2, st+1, ed-1)
t11 = ts[i1-1] - ts[st-1]
t12 = t0 - t11
t21 = ts[i1] - ts[st-1]
t22 = t0 - t21
if abs(t22-t21) > abs(t12-t11):
return t11, t12
else:
return t21, t22
ans = 10**18
for i in range(2, n-1):
r1, r2 = calc(0, i)
r3, r4 = calc(i, n)
# print(r1, r2, r3, r4)
diff = max([r1, r2, r3, r4]) - min([r1, r2, r3, r4])
ans = min(ans, diff)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
from itertools import accumulate
accum = list(accumulate(a))
i_left = 0
i_right = 2
ans = 10**18
for i in range(1, n-2):
while True:
p = accum[i_left]
q = accum[i] - p
p_new = accum[i_left+1]
q_new = accum[i] - p_new
if abs(p_new - q_new) < abs(p - q):
i_left += 1
else:
break
while True:
r = accum[i_right] - accum[i]
s = accum[-1] - accum[i_right]
r_new = accum[i_right+1] - accum[i]
s_new = accum[-1] - accum[i_right+1]
if abs(r_new - s_new) < abs(r - s):
i_right += 1
else:
break
# print(p, q, r, s)
diff = max([p, q, r, s]) - min([p, q, r, s])
ans = min(ans, diff)
print(ans)
| 32 | 34 | 711 | 835 | from itertools import accumulate
from bisect import bisect_left, bisect_right
n = int(eval(input()))
a = list(map(int, input().split()))
ts = list(accumulate(a)) + [0]
r = 0
def calc(st, ed):
t0 = ts[ed - 1] - ts[st - 1]
i1 = bisect_left(ts, (ts[ed - 1] + ts[st - 1]) / 2, st + 1, ed - 1)
t11 = ts[i1 - 1] - ts[st - 1]
t12 = t0 - t11
t21 = ts[i1] - ts[st - 1]
t22 = t0 - t21
if abs(t22 - t21) > abs(t12 - t11):
return t11, t12
else:
return t21, t22
ans = 10**18
for i in range(2, n - 1):
r1, r2 = calc(0, i)
r3, r4 = calc(i, n)
# print(r1, r2, r3, r4)
diff = max([r1, r2, r3, r4]) - min([r1, r2, r3, r4])
ans = min(ans, diff)
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
from itertools import accumulate
accum = list(accumulate(a))
i_left = 0
i_right = 2
ans = 10**18
for i in range(1, n - 2):
while True:
p = accum[i_left]
q = accum[i] - p
p_new = accum[i_left + 1]
q_new = accum[i] - p_new
if abs(p_new - q_new) < abs(p - q):
i_left += 1
else:
break
while True:
r = accum[i_right] - accum[i]
s = accum[-1] - accum[i_right]
r_new = accum[i_right + 1] - accum[i]
s_new = accum[-1] - accum[i_right + 1]
if abs(r_new - s_new) < abs(r - s):
i_right += 1
else:
break
# print(p, q, r, s)
diff = max([p, q, r, s]) - min([p, q, r, s])
ans = min(ans, diff)
print(ans)
| false | 5.882353 | [
"-from itertools import accumulate",
"-from bisect import bisect_left, bisect_right",
"-",
"-ts = list(accumulate(a)) + [0]",
"-r = 0",
"+from itertools import accumulate",
"-",
"-def calc(st, ed):",
"- t0 = ts[ed - 1] - ts[st - 1]",
"- i1 = bisect_left(ts, (ts[ed - 1] + ts[st - 1]) / 2, st + 1, ed - 1)",
"- t11 = ts[i1 - 1] - ts[st - 1]",
"- t12 = t0 - t11",
"- t21 = ts[i1] - ts[st - 1]",
"- t22 = t0 - t21",
"- if abs(t22 - t21) > abs(t12 - t11):",
"- return t11, t12",
"- else:",
"- return t21, t22",
"-",
"-",
"+accum = list(accumulate(a))",
"+i_left = 0",
"+i_right = 2",
"-for i in range(2, n - 1):",
"- r1, r2 = calc(0, i)",
"- r3, r4 = calc(i, n)",
"- # print(r1, r2, r3, r4)",
"- diff = max([r1, r2, r3, r4]) - min([r1, r2, r3, r4])",
"+for i in range(1, n - 2):",
"+ while True:",
"+ p = accum[i_left]",
"+ q = accum[i] - p",
"+ p_new = accum[i_left + 1]",
"+ q_new = accum[i] - p_new",
"+ if abs(p_new - q_new) < abs(p - q):",
"+ i_left += 1",
"+ else:",
"+ break",
"+ while True:",
"+ r = accum[i_right] - accum[i]",
"+ s = accum[-1] - accum[i_right]",
"+ r_new = accum[i_right + 1] - accum[i]",
"+ s_new = accum[-1] - accum[i_right + 1]",
"+ if abs(r_new - s_new) < abs(r - s):",
"+ i_right += 1",
"+ else:",
"+ break",
"+ # print(p, q, r, s)",
"+ diff = max([p, q, r, s]) - min([p, q, r, s])"
] | false | 0.11236 | 0.111287 | 1.009637 | [
"s142406782",
"s672657659"
] |
u596536048 | p03573 | python | s750355651 | s850518561 | 30 | 27 | 9,040 | 9,124 | Accepted | Accepted | 10 | A, B, C = list(map(int, input().split()))
print((A if B == C else B if A == C else C)) | integer1, integer2, integer3 = list(map(int, input().split()))
if integer2 == integer3:
print(integer1)
elif integer1 == integer3:
print(integer2)
else:
print(integer3) | 2 | 7 | 79 | 180 | A, B, C = list(map(int, input().split()))
print((A if B == C else B if A == C else C))
| integer1, integer2, integer3 = list(map(int, input().split()))
if integer2 == integer3:
print(integer1)
elif integer1 == integer3:
print(integer2)
else:
print(integer3)
| false | 71.428571 | [
"-A, B, C = list(map(int, input().split()))",
"-print((A if B == C else B if A == C else C))",
"+integer1, integer2, integer3 = list(map(int, input().split()))",
"+if integer2 == integer3:",
"+ print(integer1)",
"+elif integer1 == integer3:",
"+ print(integer2)",
"+else:",
"+ print(integer3)"
] | false | 0.040521 | 0.04061 | 0.997806 | [
"s750355651",
"s850518561"
] |
u827202523 | p03808 | python | s945598198 | s662321063 | 248 | 102 | 58,864 | 87,156 | Accepted | Accepted | 58.87 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def getN():
return int(eval(input()))
def getList():
return list(map(int, input().split()))
import math
n = getN()
nums = getList()
if sum(nums) % ((n * (n+1)) // 2) != 0:
print("NO")
sys.exit()
n_operate = sum(nums) // ((n * (n+1)) // 2)
v_valid = n_operate
v_sign = n
for i, j in zip(nums, nums[1:] + [nums[0]]):
diff = j - i
if diff > v_valid:
print("NO")
sys.exit()
if (v_valid - diff) % v_sign != 0:
print("NO")
sys.exit()
n_operate -= (v_valid - diff) // v_sign
# print(n_operate)
if n_operate == 0:
print("YES")
else:
print("NO")
# print("YES") | import sys
# from collections import defaultdict, deque
# import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 1000000007
def solve():
n = getN()
nums = getList()
bulk = n*(n+1)//2
ope = sum(nums) // bulk
if sum(nums) % bulk != 0:
print("NO")
return
nums = nums + [nums[0]]
tmp = 0
for i, j in zip(nums, nums[1:]):
if j - i > ope:
print("NO")
return
else:
expected = i + ope
if (expected - j) % n != 0:
print("NO")
return
tmp += (expected - j) // n
# print(tmp)
if tmp == ope:
print("YES")
else:
print("NO")
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve()
| 35 | 56 | 727 | 1,170 | import sys
input = sys.stdin.readline
sys.setrecursionlimit(100000)
def getN():
return int(eval(input()))
def getList():
return list(map(int, input().split()))
import math
n = getN()
nums = getList()
if sum(nums) % ((n * (n + 1)) // 2) != 0:
print("NO")
sys.exit()
n_operate = sum(nums) // ((n * (n + 1)) // 2)
v_valid = n_operate
v_sign = n
for i, j in zip(nums, nums[1:] + [nums[0]]):
diff = j - i
if diff > v_valid:
print("NO")
sys.exit()
if (v_valid - diff) % v_sign != 0:
print("NO")
sys.exit()
n_operate -= (v_valid - diff) // v_sign
# print(n_operate)
if n_operate == 0:
print("YES")
else:
print("NO")
# print("YES")
| import sys
# from collections import defaultdict, deque
# import math
# import copy
from bisect import bisect_left, bisect_right
# import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(eval(input()))
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10**20
MOD = 1000000007
def solve():
n = getN()
nums = getList()
bulk = n * (n + 1) // 2
ope = sum(nums) // bulk
if sum(nums) % bulk != 0:
print("NO")
return
nums = nums + [nums[0]]
tmp = 0
for i, j in zip(nums, nums[1:]):
if j - i > ope:
print("NO")
return
else:
expected = i + ope
if (expected - j) % n != 0:
print("NO")
return
tmp += (expected - j) // n
# print(tmp)
if tmp == ope:
print("YES")
else:
print("NO")
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve()
| false | 37.5 | [
"+# from collections import defaultdict, deque",
"+# import math",
"+# import copy",
"+from bisect import bisect_left, bisect_right",
"+",
"+# import heapq",
"+# sys.setrecursionlimit(1000000)",
"+# input aliases",
"-sys.setrecursionlimit(100000)",
"+getS = lambda: input().strip()",
"+getN = lambda: int(eval(input()))",
"+getList = lambda: list(map(int, input().split()))",
"+getZList = lambda: [int(x) - 1 for x in input().split()]",
"+INF = 10**20",
"+MOD = 1000000007",
"-def getN():",
"- return int(eval(input()))",
"+def solve():",
"+ n = getN()",
"+ nums = getList()",
"+ bulk = n * (n + 1) // 2",
"+ ope = sum(nums) // bulk",
"+ if sum(nums) % bulk != 0:",
"+ print(\"NO\")",
"+ return",
"+ nums = nums + [nums[0]]",
"+ tmp = 0",
"+ for i, j in zip(nums, nums[1:]):",
"+ if j - i > ope:",
"+ print(\"NO\")",
"+ return",
"+ else:",
"+ expected = i + ope",
"+ if (expected - j) % n != 0:",
"+ print(\"NO\")",
"+ return",
"+ tmp += (expected - j) // n",
"+ # print(tmp)",
"+ if tmp == ope:",
"+ print(\"YES\")",
"+ else:",
"+ print(\"NO\")",
"-def getList():",
"- return list(map(int, input().split()))",
"+def main():",
"+ n = getN()",
"+ for _ in range(n):",
"+ solve()",
"-import math",
"-",
"-n = getN()",
"-nums = getList()",
"-if sum(nums) % ((n * (n + 1)) // 2) != 0:",
"- print(\"NO\")",
"- sys.exit()",
"-n_operate = sum(nums) // ((n * (n + 1)) // 2)",
"-v_valid = n_operate",
"-v_sign = n",
"-for i, j in zip(nums, nums[1:] + [nums[0]]):",
"- diff = j - i",
"- if diff > v_valid:",
"- print(\"NO\")",
"- sys.exit()",
"- if (v_valid - diff) % v_sign != 0:",
"- print(\"NO\")",
"- sys.exit()",
"- n_operate -= (v_valid - diff) // v_sign",
"- # print(n_operate)",
"-if n_operate == 0:",
"- print(\"YES\")",
"-else:",
"- print(\"NO\")",
"-# print(\"YES\")",
"+if __name__ == \"__main__\":",
"+ # main()",
"+ solve()"
] | false | 0.038321 | 0.042564 | 0.900318 | [
"s945598198",
"s662321063"
] |
u729133443 | p02960 | python | s242214479 | s011020615 | 1,466 | 695 | 44,100 | 42,604 | Accepted | Accepted | 52.59 | d=[1]+[0]*12
for i,c in enumerate(eval(input())):
p=[0]*13
for j in range(13):
for k in range(10):p[(j*10+k)%13]+=d[j]*(c>'9'or k==int(c))
d=[t%(10**9+7)for t in p]
print((d[5])) | d=[1]+[0]*12
for c in eval(input()):
e=[0]*13
for k in(list(range(10))if c>'>'else[int(c)]):
for j in range(13):t=(j*10+k)%13;e[t]+=d[j];e[t]%=10**9+7
d=e
print((d[5])) | 7 | 7 | 181 | 165 | d = [1] + [0] * 12
for i, c in enumerate(eval(input())):
p = [0] * 13
for j in range(13):
for k in range(10):
p[(j * 10 + k) % 13] += d[j] * (c > "9" or k == int(c))
d = [t % (10**9 + 7) for t in p]
print((d[5]))
| d = [1] + [0] * 12
for c in eval(input()):
e = [0] * 13
for k in list(range(10)) if c > ">" else [int(c)]:
for j in range(13):
t = (j * 10 + k) % 13
e[t] += d[j]
e[t] %= 10**9 + 7
d = e
print((d[5]))
| false | 0 | [
"-for i, c in enumerate(eval(input())):",
"- p = [0] * 13",
"- for j in range(13):",
"- for k in range(10):",
"- p[(j * 10 + k) % 13] += d[j] * (c > \"9\" or k == int(c))",
"- d = [t % (10**9 + 7) for t in p]",
"+for c in eval(input()):",
"+ e = [0] * 13",
"+ for k in list(range(10)) if c > \">\" else [int(c)]:",
"+ for j in range(13):",
"+ t = (j * 10 + k) % 13",
"+ e[t] += d[j]",
"+ e[t] %= 10**9 + 7",
"+ d = e"
] | false | 0.130315 | 0.075712 | 1.721201 | [
"s242214479",
"s011020615"
] |
u059436995 | p04002 | python | s580961199 | s875076879 | 1,519 | 1,328 | 155,020 | 155,636 | Accepted | Accepted | 12.57 | h, w, n = list(map(int,input().split()))
from collections import defaultdict
m3x3 =defaultdict(list)
for _ in range(n):
a, b = list(map(int,input().split()))
for i in range(max(0, a - 3),min(h - 2, a)):
for j in range(max(0, b - 3),min(w - 2, b)):
if (i,j) in m3x3:
m3x3[(i,j)] +=1
else:
m3x3[(i,j)] =1
v = list(m3x3.values())
k = list(m3x3.keys())
print(((w-2)*(h-2)-len(k)))
for j in range(1,10):
print((v.count(j)))
| from collections import defaultdict
import sys
h, w, n = list(map(int,sys.stdin.readline().rstrip().split()))
m3x3 =defaultdict(list)
for _ in range(n):
a, b = list(map(int,sys.stdin.readline().rstrip().split()))
for i in range(max(0, a - 3),min(h - 2, a)):
for j in range(max(0, b - 3),min(w - 2, b)):
if (i,j) in m3x3:
m3x3[(i,j)] +=1
else:
m3x3[(i,j)] =1
v = list(m3x3.values())
k = list(m3x3.keys())
print(((w-2)*(h-2)-len(k)))
for j in range(1,10):
print((v.count(j)))
| 16 | 18 | 489 | 547 | h, w, n = list(map(int, input().split()))
from collections import defaultdict
m3x3 = defaultdict(list)
for _ in range(n):
a, b = list(map(int, input().split()))
for i in range(max(0, a - 3), min(h - 2, a)):
for j in range(max(0, b - 3), min(w - 2, b)):
if (i, j) in m3x3:
m3x3[(i, j)] += 1
else:
m3x3[(i, j)] = 1
v = list(m3x3.values())
k = list(m3x3.keys())
print(((w - 2) * (h - 2) - len(k)))
for j in range(1, 10):
print((v.count(j)))
| from collections import defaultdict
import sys
h, w, n = list(map(int, sys.stdin.readline().rstrip().split()))
m3x3 = defaultdict(list)
for _ in range(n):
a, b = list(map(int, sys.stdin.readline().rstrip().split()))
for i in range(max(0, a - 3), min(h - 2, a)):
for j in range(max(0, b - 3), min(w - 2, b)):
if (i, j) in m3x3:
m3x3[(i, j)] += 1
else:
m3x3[(i, j)] = 1
v = list(m3x3.values())
k = list(m3x3.keys())
print(((w - 2) * (h - 2) - len(k)))
for j in range(1, 10):
print((v.count(j)))
| false | 11.111111 | [
"-h, w, n = list(map(int, input().split()))",
"+import sys",
"+h, w, n = list(map(int, sys.stdin.readline().rstrip().split()))",
"- a, b = list(map(int, input().split()))",
"+ a, b = list(map(int, sys.stdin.readline().rstrip().split()))"
] | false | 0.114597 | 0.046636 | 2.45725 | [
"s580961199",
"s875076879"
] |
u811169796 | p03424 | python | s602284575 | s038211382 | 19 | 17 | 3,060 | 2,940 | Accepted | Accepted | 10.53 | n = int(eval(input()))
flag = False
s = input().split(" ")
for c in s:
if(c == "Y"):
flag = True
if(flag):
print("Four")
else:
print("Three") | n = int(eval(input()))
s = input().split()
for i in s:
if(i == 'Y'):
print('Four')
exit()
print('Three')
| 11 | 8 | 156 | 117 | n = int(eval(input()))
flag = False
s = input().split(" ")
for c in s:
if c == "Y":
flag = True
if flag:
print("Four")
else:
print("Three")
| n = int(eval(input()))
s = input().split()
for i in s:
if i == "Y":
print("Four")
exit()
print("Three")
| false | 27.272727 | [
"-flag = False",
"-s = input().split(\" \")",
"-for c in s:",
"- if c == \"Y\":",
"- flag = True",
"-if flag:",
"- print(\"Four\")",
"-else:",
"- print(\"Three\")",
"+s = input().split()",
"+for i in s:",
"+ if i == \"Y\":",
"+ print(\"Four\")",
"+ exit()",
"+print(\"Three\")"
] | false | 0.047086 | 0.043465 | 1.083302 | [
"s602284575",
"s038211382"
] |
u644907318 | p03738 | python | s006762761 | s306657834 | 176 | 71 | 38,384 | 61,964 | Accepted | Accepted | 59.66 | A = int(eval(input()))
B = int(eval(input()))
if A>B:
print("GREATER")
elif A<B:
print("LESS")
else:
print("EQUAL") | A = input().strip()
B = input().strip()
if len(A)>len(B):
print("GREATER")
elif len(A)<len(B):
print("LESS")
else:
if A<B:
print("LESS")
elif A>B:
print("GREATER")
else:
print("EQUAL") | 8 | 13 | 122 | 240 | A = int(eval(input()))
B = int(eval(input()))
if A > B:
print("GREATER")
elif A < B:
print("LESS")
else:
print("EQUAL")
| A = input().strip()
B = input().strip()
if len(A) > len(B):
print("GREATER")
elif len(A) < len(B):
print("LESS")
else:
if A < B:
print("LESS")
elif A > B:
print("GREATER")
else:
print("EQUAL")
| false | 38.461538 | [
"-A = int(eval(input()))",
"-B = int(eval(input()))",
"-if A > B:",
"+A = input().strip()",
"+B = input().strip()",
"+if len(A) > len(B):",
"-elif A < B:",
"+elif len(A) < len(B):",
"- print(\"EQUAL\")",
"+ if A < B:",
"+ print(\"LESS\")",
"+ elif A > B:",
"+ print(\"GREATER\")",
"+ else:",
"+ print(\"EQUAL\")"
] | false | 0.042673 | 0.042951 | 0.993518 | [
"s006762761",
"s306657834"
] |
u043048943 | p03329 | python | s940455841 | s190535067 | 107 | 87 | 82,920 | 74,060 | Accepted | Accepted | 18.69 | from collections import deque
def main():
N = int(eval(input()))
divs = [59049, 46656, 7776, 6561, 1296, 729, 216, 81, 36, 9, 6, 1]
dp = [0]*(10**6+1)
def f(x):
if x == 0:
return 0
if x < 0:
return 10**6
if dp[x]:
return dp[x]
else:
res = 10**6
for d in divs:
res = min(res,f(x-d)+1)
dp[x] = res
return res
print((f(N)))
main() | def main():
N = int(eval(input()))
amounts = [1]
lim = 10**6
mul6 = 6
while mul6 < lim:
amounts.append(mul6)
mul6 *= 6
mul9 = 9
while mul9 < lim:
amounts.append(mul9)
mul9 *= 9
dp = [lim] * (N+1)
dp[0] = 0
for i in range(N):
for a in amounts:
if i+a <= N:
dp[i+a] = min(dp[i+a],dp[i]+1)
print((dp[N]))
main() | 22 | 26 | 506 | 451 | from collections import deque
def main():
N = int(eval(input()))
divs = [59049, 46656, 7776, 6561, 1296, 729, 216, 81, 36, 9, 6, 1]
dp = [0] * (10**6 + 1)
def f(x):
if x == 0:
return 0
if x < 0:
return 10**6
if dp[x]:
return dp[x]
else:
res = 10**6
for d in divs:
res = min(res, f(x - d) + 1)
dp[x] = res
return res
print((f(N)))
main()
| def main():
N = int(eval(input()))
amounts = [1]
lim = 10**6
mul6 = 6
while mul6 < lim:
amounts.append(mul6)
mul6 *= 6
mul9 = 9
while mul9 < lim:
amounts.append(mul9)
mul9 *= 9
dp = [lim] * (N + 1)
dp[0] = 0
for i in range(N):
for a in amounts:
if i + a <= N:
dp[i + a] = min(dp[i + a], dp[i] + 1)
print((dp[N]))
main()
| false | 15.384615 | [
"-from collections import deque",
"-",
"-",
"- divs = [59049, 46656, 7776, 6561, 1296, 729, 216, 81, 36, 9, 6, 1]",
"- dp = [0] * (10**6 + 1)",
"-",
"- def f(x):",
"- if x == 0:",
"- return 0",
"- if x < 0:",
"- return 10**6",
"- if dp[x]:",
"- return dp[x]",
"- else:",
"- res = 10**6",
"- for d in divs:",
"- res = min(res, f(x - d) + 1)",
"- dp[x] = res",
"- return res",
"-",
"- print((f(N)))",
"+ amounts = [1]",
"+ lim = 10**6",
"+ mul6 = 6",
"+ while mul6 < lim:",
"+ amounts.append(mul6)",
"+ mul6 *= 6",
"+ mul9 = 9",
"+ while mul9 < lim:",
"+ amounts.append(mul9)",
"+ mul9 *= 9",
"+ dp = [lim] * (N + 1)",
"+ dp[0] = 0",
"+ for i in range(N):",
"+ for a in amounts:",
"+ if i + a <= N:",
"+ dp[i + a] = min(dp[i + a], dp[i] + 1)",
"+ print((dp[N]))"
] | false | 0.135067 | 0.101354 | 1.332633 | [
"s940455841",
"s190535067"
] |
u327466606 | p03312 | python | s529721192 | s693056390 | 1,602 | 1,430 | 25,972 | 25,972 | Accepted | Accepted | 10.74 | from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
def h(i,j):
ci,cj = C[i],C[j]
k = bisect(C, (ci+cj)//2, lo=i+1,hi=j)
_,a,b = min((abs(ci+cj-2*c),cj-c,c-ci) for c in (C[k-1],C[k]))
return a,b
def solve(x):
L = h(0,x)+h(x,N)
return max(L)-min(L)
print((min(solve(i) for i in range(2,N-1)))) | from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0]+list(accumulate(list(map(int,input().split()))))
S = C[N]
def solve(x):
cx = C[x]
k = bisect(C, cx//2, lo=1,hi=x)
_,a,b = min((abs(cx-2*c),cx-c,c) for c in (C[k-1],C[k]))
k = bisect(C, (S+cx)//2, lo=x+1,hi=N)
_,c,d = min((abs(cx+S-2*c),S-c,c-cx) for c in (C[k-1],C[k]))
L = (a,b,c,d)
return max(L)-min(L)
print((min(solve(i) for i in range(2,N-1)))) | 17 | 17 | 397 | 458 | from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0] + list(accumulate(list(map(int, input().split()))))
def h(i, j):
ci, cj = C[i], C[j]
k = bisect(C, (ci + cj) // 2, lo=i + 1, hi=j)
_, a, b = min((abs(ci + cj - 2 * c), cj - c, c - ci) for c in (C[k - 1], C[k]))
return a, b
def solve(x):
L = h(0, x) + h(x, N)
return max(L) - min(L)
print((min(solve(i) for i in range(2, N - 1))))
| from itertools import accumulate
from bisect import bisect
N = int(eval(input()))
C = [0] + list(accumulate(list(map(int, input().split()))))
S = C[N]
def solve(x):
cx = C[x]
k = bisect(C, cx // 2, lo=1, hi=x)
_, a, b = min((abs(cx - 2 * c), cx - c, c) for c in (C[k - 1], C[k]))
k = bisect(C, (S + cx) // 2, lo=x + 1, hi=N)
_, c, d = min((abs(cx + S - 2 * c), S - c, c - cx) for c in (C[k - 1], C[k]))
L = (a, b, c, d)
return max(L) - min(L)
print((min(solve(i) for i in range(2, N - 1))))
| false | 0 | [
"-",
"-",
"-def h(i, j):",
"- ci, cj = C[i], C[j]",
"- k = bisect(C, (ci + cj) // 2, lo=i + 1, hi=j)",
"- _, a, b = min((abs(ci + cj - 2 * c), cj - c, c - ci) for c in (C[k - 1], C[k]))",
"- return a, b",
"+S = C[N]",
"- L = h(0, x) + h(x, N)",
"+ cx = C[x]",
"+ k = bisect(C, cx // 2, lo=1, hi=x)",
"+ _, a, b = min((abs(cx - 2 * c), cx - c, c) for c in (C[k - 1], C[k]))",
"+ k = bisect(C, (S + cx) // 2, lo=x + 1, hi=N)",
"+ _, c, d = min((abs(cx + S - 2 * c), S - c, c - cx) for c in (C[k - 1], C[k]))",
"+ L = (a, b, c, d)"
] | false | 0.143442 | 0.046961 | 3.054514 | [
"s529721192",
"s693056390"
] |
u624475441 | p03252 | python | s538743669 | s626836487 | 205 | 119 | 37,996 | 4,016 | Accepted | Accepted | 41.95 | from collections import defaultdict
S = eval(input())
T = eval(input())
ds = defaultdict(set)
for k, c in enumerate(S):
ds[c] |= {k}
dt = defaultdict(set)
for k, c in enumerate(T):
dt[c] |= {k}
dss = set(tuple(x) for x in list(ds.values()))
dts = set(tuple(x) for x in list(dt.values()))
print(('Yes' if dss ^ dts == set() else 'No')) | from collections import defaultdict
start = defaultdict(lambda: -1)
goal = defaultdict(lambda: -1)
for s, t in zip(eval(input()), eval(input())):
if start[s] != -1 or goal[t] != -1:
if start[s] != t or goal[t] != s:
print('No')
exit()
start[s], goal[t] = t, s
print('Yes') | 16 | 10 | 335 | 309 | from collections import defaultdict
S = eval(input())
T = eval(input())
ds = defaultdict(set)
for k, c in enumerate(S):
ds[c] |= {k}
dt = defaultdict(set)
for k, c in enumerate(T):
dt[c] |= {k}
dss = set(tuple(x) for x in list(ds.values()))
dts = set(tuple(x) for x in list(dt.values()))
print(("Yes" if dss ^ dts == set() else "No"))
| from collections import defaultdict
start = defaultdict(lambda: -1)
goal = defaultdict(lambda: -1)
for s, t in zip(eval(input()), eval(input())):
if start[s] != -1 or goal[t] != -1:
if start[s] != t or goal[t] != s:
print("No")
exit()
start[s], goal[t] = t, s
print("Yes")
| false | 37.5 | [
"-S = eval(input())",
"-T = eval(input())",
"-ds = defaultdict(set)",
"-for k, c in enumerate(S):",
"- ds[c] |= {k}",
"-dt = defaultdict(set)",
"-for k, c in enumerate(T):",
"- dt[c] |= {k}",
"-dss = set(tuple(x) for x in list(ds.values()))",
"-dts = set(tuple(x) for x in list(dt.values()))",
"-print((\"Yes\" if dss ^ dts == set() else \"No\"))",
"+start = defaultdict(lambda: -1)",
"+goal = defaultdict(lambda: -1)",
"+for s, t in zip(eval(input()), eval(input())):",
"+ if start[s] != -1 or goal[t] != -1:",
"+ if start[s] != t or goal[t] != s:",
"+ print(\"No\")",
"+ exit()",
"+ start[s], goal[t] = t, s",
"+print(\"Yes\")"
] | false | 0.037025 | 0.043187 | 0.857299 | [
"s538743669",
"s626836487"
] |
u883048396 | p03255 | python | s973676162 | s832265050 | 794 | 728 | 25,860 | 25,836 | Accepted | Accepted | 8.31 |
iN ,iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0]*(iN)
aCum[0] = aX[0]
for i in range(1,iN):
aCum[i]=aCum[i-1]+aX[i]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = 5 * aCum[-1]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[-1 * i * iK -1]
# i = 2
# while i*iK < iN :
# iCost += 2 * aCum[-1 * i * iK -1]
# i += 1
iCost += (iK +iN)*iX
return iCost
iTotalCost = fCalcCost(iN,iX,aCum,1)
for iK in range(2,iN//2 + 2):
iTotalCost = min(iTotalCost,fCalcCost(iN,iX,aCum,iK))
print(iTotalCost)
| iN ,iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0]*(iN)
aCum[0] = aX[0]
for i in range(1,iN):
aCum[i]=aCum[i-1]+aX[i]
def fCeil(iT,iR):
return -1 * iT // iR * -1
def fCalcCost(iN,iX,aCum,iK):
iCost = 5 * aCum[-1]
for i in range(2,fCeil(iN,iK) ):
iCost += 2 * aCum[-1 * i * iK -1]
iCost += (iK +iN)*iX
return iCost
iTotalCost = fCalcCost(iN,iX,aCum,1)
for iK in range(2,fCeil(iN,2) + 1):
iTotalCost = min(iTotalCost,fCalcCost(iN,iX,aCum,iK))
print(iTotalCost)
| 28 | 22 | 656 | 563 | iN, iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0] * (iN)
aCum[0] = aX[0]
for i in range(1, iN):
aCum[i] = aCum[i - 1] + aX[i]
def fCeil(iT, iR):
return -1 * iT // iR * -1
def fCalcCost(iN, iX, aCum, iK):
iCost = 5 * aCum[-1]
for i in range(2, fCeil(iN, iK)):
iCost += 2 * aCum[-1 * i * iK - 1]
# i = 2
# while i*iK < iN :
# iCost += 2 * aCum[-1 * i * iK -1]
# i += 1
iCost += (iK + iN) * iX
return iCost
iTotalCost = fCalcCost(iN, iX, aCum, 1)
for iK in range(2, iN // 2 + 2):
iTotalCost = min(iTotalCost, fCalcCost(iN, iX, aCum, iK))
print(iTotalCost)
| iN, iX = [int(x) for x in input().split()]
aX = [int(x) for x in input().split()]
aCum = [0] * (iN)
aCum[0] = aX[0]
for i in range(1, iN):
aCum[i] = aCum[i - 1] + aX[i]
def fCeil(iT, iR):
return -1 * iT // iR * -1
def fCalcCost(iN, iX, aCum, iK):
iCost = 5 * aCum[-1]
for i in range(2, fCeil(iN, iK)):
iCost += 2 * aCum[-1 * i * iK - 1]
iCost += (iK + iN) * iX
return iCost
iTotalCost = fCalcCost(iN, iX, aCum, 1)
for iK in range(2, fCeil(iN, 2) + 1):
iTotalCost = min(iTotalCost, fCalcCost(iN, iX, aCum, iK))
print(iTotalCost)
| false | 21.428571 | [
"- # i = 2",
"- # while i*iK < iN :",
"- # iCost += 2 * aCum[-1 * i * iK -1]",
"- # i += 1",
"-for iK in range(2, iN // 2 + 2):",
"+for iK in range(2, fCeil(iN, 2) + 1):"
] | false | 0.038297 | 0.036596 | 1.046489 | [
"s973676162",
"s832265050"
] |
u807772568 | p03200 | python | s177287033 | s687209945 | 122 | 71 | 4,840 | 4,840 | Accepted | Accepted | 41.8 | a = list(eval(input()))
su = 0
dd = 0
co = 0
for i in range(len(a)-1,-1,-1):
if a[i] == 'W':
co += 1
if co >= 1:
if a[i] == 'B':
su += (len(a)-1 - i) - dd
if a[i] == 'B':
dd += 1
print(su)
| a = list(eval(input()))
su = 0
dd = 0
co = 0
for i in range(len(a)):
if a[i] == 'W':
su += i - dd
dd += 1
print(su)
| 15 | 12 | 211 | 132 | a = list(eval(input()))
su = 0
dd = 0
co = 0
for i in range(len(a) - 1, -1, -1):
if a[i] == "W":
co += 1
if co >= 1:
if a[i] == "B":
su += (len(a) - 1 - i) - dd
if a[i] == "B":
dd += 1
print(su)
| a = list(eval(input()))
su = 0
dd = 0
co = 0
for i in range(len(a)):
if a[i] == "W":
su += i - dd
dd += 1
print(su)
| false | 20 | [
"-for i in range(len(a) - 1, -1, -1):",
"+for i in range(len(a)):",
"- co += 1",
"- if co >= 1:",
"- if a[i] == \"B\":",
"- su += (len(a) - 1 - i) - dd",
"- if a[i] == \"B\":",
"+ su += i - dd"
] | false | 0.04597 | 0.038738 | 1.186694 | [
"s177287033",
"s687209945"
] |
u080364835 | p03087 | python | s214449116 | s512235947 | 539 | 473 | 30,640 | 11,444 | Accepted | Accepted | 12.24 | n, q = list(map(int, input().split()))
s = eval(input())
ll = list(list(map(int, input().split())) for _ in range(q))
acl = [0] * n
cnt = 0
for i in range(1, n):
if s[i-1:i+1] == 'AC':
cnt += 1
acl[i] = cnt
for i in range(q):
l = ll[i][0]
r = ll[i][1]
print((acl[r-1] - acl[l-1]))
| n, q = list(map(int, input().split()))
s = eval(input())
sl = [0]
for i in range(1, n):
if s[i-1:i+1] == 'AC':
sl.append(sl[i-1]+1)
else:
sl.append(sl[i-1])
for _ in range(q):
l, r = list(map(int, input().split()))
print((sl[r-1]-sl[l-1]))
| 15 | 12 | 311 | 264 | n, q = list(map(int, input().split()))
s = eval(input())
ll = list(list(map(int, input().split())) for _ in range(q))
acl = [0] * n
cnt = 0
for i in range(1, n):
if s[i - 1 : i + 1] == "AC":
cnt += 1
acl[i] = cnt
for i in range(q):
l = ll[i][0]
r = ll[i][1]
print((acl[r - 1] - acl[l - 1]))
| n, q = list(map(int, input().split()))
s = eval(input())
sl = [0]
for i in range(1, n):
if s[i - 1 : i + 1] == "AC":
sl.append(sl[i - 1] + 1)
else:
sl.append(sl[i - 1])
for _ in range(q):
l, r = list(map(int, input().split()))
print((sl[r - 1] - sl[l - 1]))
| false | 20 | [
"-ll = list(list(map(int, input().split())) for _ in range(q))",
"-acl = [0] * n",
"-cnt = 0",
"+sl = [0]",
"- cnt += 1",
"- acl[i] = cnt",
"-for i in range(q):",
"- l = ll[i][0]",
"- r = ll[i][1]",
"- print((acl[r - 1] - acl[l - 1]))",
"+ sl.append(sl[i - 1] + 1)",
"+ else:",
"+ sl.append(sl[i - 1])",
"+for _ in range(q):",
"+ l, r = list(map(int, input().split()))",
"+ print((sl[r - 1] - sl[l - 1]))"
] | false | 0.074576 | 0.036771 | 2.028098 | [
"s214449116",
"s512235947"
] |
u125269142 | p02687 | python | s014234698 | s406305384 | 22 | 20 | 8,888 | 9,052 | Accepted | Accepted | 9.09 | S = eval(input())
dict = {'ABC': 'ARC', 'ARC':'ABC'}
print((dict[S])) | dict = {'ABC':'ARC', 'ARC':'ABC'}
print((dict[eval(input())])) | 4 | 3 | 65 | 57 | S = eval(input())
dict = {"ABC": "ARC", "ARC": "ABC"}
print((dict[S]))
| dict = {"ABC": "ARC", "ARC": "ABC"}
print((dict[eval(input())]))
| false | 25 | [
"-S = eval(input())",
"-print((dict[S]))",
"+print((dict[eval(input())]))"
] | false | 0.041238 | 0.080374 | 0.513084 | [
"s014234698",
"s406305384"
] |
u092301301 | p03161 | python | s290828794 | s199543678 | 451 | 392 | 52,448 | 52,448 | Accepted | Accepted | 13.08 | import math
n,k=list(map(int,input().split()))
a=[int(i) for i in input().split()]
b=[0]*n
b[n-2]=abs(a[n-1]-a[n-2])
for i in range(n-3,-1,-1):
c=[]
for j in range(i+1,min(n,i+k+1)):
c.append(abs(a[j]-a[i])+b[j])
b[i]=min(c)
print((b[0])) | n,k=list(map(int,input().split()))
a=[int(i) for i in input().split()]
b=[0]*n
b[n-2]=abs(a[n-1]-a[n-2])
for i in range(n-3,-1,-1):
mini=1000000000000000
for j in range(i+1,min(n,i+k+1)):
x=abs(a[j]-a[i])+b[j]
mini=min(mini,x)
b[i]=mini
print((b[0])) | 11 | 11 | 260 | 280 | import math
n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [0] * n
b[n - 2] = abs(a[n - 1] - a[n - 2])
for i in range(n - 3, -1, -1):
c = []
for j in range(i + 1, min(n, i + k + 1)):
c.append(abs(a[j] - a[i]) + b[j])
b[i] = min(c)
print((b[0]))
| n, k = list(map(int, input().split()))
a = [int(i) for i in input().split()]
b = [0] * n
b[n - 2] = abs(a[n - 1] - a[n - 2])
for i in range(n - 3, -1, -1):
mini = 1000000000000000
for j in range(i + 1, min(n, i + k + 1)):
x = abs(a[j] - a[i]) + b[j]
mini = min(mini, x)
b[i] = mini
print((b[0]))
| false | 0 | [
"-import math",
"-",
"- c = []",
"+ mini = 1000000000000000",
"- c.append(abs(a[j] - a[i]) + b[j])",
"- b[i] = min(c)",
"+ x = abs(a[j] - a[i]) + b[j]",
"+ mini = min(mini, x)",
"+ b[i] = mini"
] | false | 0.044069 | 0.04388 | 1.004289 | [
"s290828794",
"s199543678"
] |
u572122511 | p02659 | python | s507814554 | s264585524 | 23 | 21 | 9,044 | 9,160 | Accepted | Accepted | 8.7 | AB = list(input().split())
A = int(AB[0])
B = int(AB[1][:1] + AB[1][2:])
print((A * B // 100)) | AB = list(input().split())
A = int(AB[0])
B = int(float(AB[1]) * 100 + 0.1)
print((A * B // 100)) | 5 | 4 | 97 | 98 | AB = list(input().split())
A = int(AB[0])
B = int(AB[1][:1] + AB[1][2:])
print((A * B // 100))
| AB = list(input().split())
A = int(AB[0])
B = int(float(AB[1]) * 100 + 0.1)
print((A * B // 100))
| false | 20 | [
"-B = int(AB[1][:1] + AB[1][2:])",
"+B = int(float(AB[1]) * 100 + 0.1)"
] | false | 0.059145 | 0.102113 | 0.57921 | [
"s507814554",
"s264585524"
] |
u815878613 | p02995 | python | s062421887 | s978500214 | 346 | 29 | 22,332 | 9,212 | Accepted | Accepted | 91.62 | import sys
import fractions
import numpy as np
def hoge(A,B,g):
min_r = A//g
if A%g != 0:
min_r += 1
max_r = B//g
return max_r - min_r + 1
if __name__ == '__main__' :
A, B, C, D = list(map(int, input().split()))
num_c = hoge(A,B,C)
num_d = hoge(A,B,D)
E = (C*D)//fractions.gcd(C,D)
num_e = hoge(A,B,E)
print((1+B-A-(num_c + num_d - num_e)))
| import math
A, B, C, D = list(map(int, input().split()))
cd = (C * D) // math.gcd(C, D)
pac, qac = divmod(A, C)
pad, qad = divmod(A, D)
pacd, qacd = divmod(A, cd)
pbc, qbc = divmod(B, C)
pbd, qbd = divmod(B, D)
pbcd, qbcd = divmod(B, cd)
pac = pac - 1 if qac == 0 else pac
pad = pad - 1 if qad != 0 else pad
pacd = pacd - 1 if qacd != 0 else pacd
ans = (pbc + pbd - pbcd) - (pac + pad - pacd)
print((B - A - ans + 1))
| 22 | 21 | 418 | 437 | import sys
import fractions
import numpy as np
def hoge(A, B, g):
min_r = A // g
if A % g != 0:
min_r += 1
max_r = B // g
return max_r - min_r + 1
if __name__ == "__main__":
A, B, C, D = list(map(int, input().split()))
num_c = hoge(A, B, C)
num_d = hoge(A, B, D)
E = (C * D) // fractions.gcd(C, D)
num_e = hoge(A, B, E)
print((1 + B - A - (num_c + num_d - num_e)))
| import math
A, B, C, D = list(map(int, input().split()))
cd = (C * D) // math.gcd(C, D)
pac, qac = divmod(A, C)
pad, qad = divmod(A, D)
pacd, qacd = divmod(A, cd)
pbc, qbc = divmod(B, C)
pbd, qbd = divmod(B, D)
pbcd, qbcd = divmod(B, cd)
pac = pac - 1 if qac == 0 else pac
pad = pad - 1 if qad != 0 else pad
pacd = pacd - 1 if qacd != 0 else pacd
ans = (pbc + pbd - pbcd) - (pac + pad - pacd)
print((B - A - ans + 1))
| false | 4.545455 | [
"-import sys",
"-import fractions",
"-import numpy as np",
"+import math",
"-",
"-def hoge(A, B, g):",
"- min_r = A // g",
"- if A % g != 0:",
"- min_r += 1",
"- max_r = B // g",
"- return max_r - min_r + 1",
"-",
"-",
"-if __name__ == \"__main__\":",
"- A, B, C, D = list(map(int, input().split()))",
"- num_c = hoge(A, B, C)",
"- num_d = hoge(A, B, D)",
"- E = (C * D) // fractions.gcd(C, D)",
"- num_e = hoge(A, B, E)",
"- print((1 + B - A - (num_c + num_d - num_e)))",
"+A, B, C, D = list(map(int, input().split()))",
"+cd = (C * D) // math.gcd(C, D)",
"+pac, qac = divmod(A, C)",
"+pad, qad = divmod(A, D)",
"+pacd, qacd = divmod(A, cd)",
"+pbc, qbc = divmod(B, C)",
"+pbd, qbd = divmod(B, D)",
"+pbcd, qbcd = divmod(B, cd)",
"+pac = pac - 1 if qac == 0 else pac",
"+pad = pad - 1 if qad != 0 else pad",
"+pacd = pacd - 1 if qacd != 0 else pacd",
"+ans = (pbc + pbd - pbcd) - (pac + pad - pacd)",
"+print((B - A - ans + 1))"
] | false | 0.076754 | 0.03602 | 2.130898 | [
"s062421887",
"s978500214"
] |
u197955752 | p03108 | python | s229997408 | s928104595 | 1,249 | 960 | 109,912 | 78,580 | Accepted | Accepted | 23.14 | # Union-Find木（サイズ付き）
class UnionFind():
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.root_of(self.parent[x]) # 経路圧縮して親が変わる
return self.parent[x]
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i]))
| # Union-Find木（サイズ付き）
class UnionFind():
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
children = [x]
while self.parent[x] != x:
x = self.parent[x]
children.append(x)
for ch in children: # 根の子供として張りなおす
self.parent[ch] = x
return x
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i])) | 69 | 73 | 1,972 | 2,015 | # Union-Find木（サイズ付き）
class UnionFind:
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
if self.parent[x] == x:
return x
else:
self.parent[x] = self.root_of(self.parent[x]) # 経路圧縮して親が変わる
return self.parent[x]
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i]))
| # Union-Find木（サイズ付き）
class UnionFind:
def __init__(self, n): # n要素で初期化 初めは全ての頂点が別々の木の根
self.parent = [None] * n # 親
self.rank = [None] * n # 木の深さ
self._size = [1] * n # 要素が属する集合の大きさ（根の要素のみ参照すること）
for i in range(n):
self.parent[i] = i
self.rank[i] = 0
# 木の根を求める
def root_of(self, x):
children = [x]
while self.parent[x] != x:
x = self.parent[x]
children.append(x)
for ch in children: # 根の子供として張りなおす
self.parent[ch] = x
return x
# xとyの属する集合を併合
def unite(self, x, y):
rx = self.root_of(x)
ry = self.root_of(y)
if rx == ry:
return
if self.rank[rx] < self.rank[ry]: # ランクの小さい木から大きい木の根に辺を張る
self.parent[rx] = ry # rxをryの子とする
self._size[ry] += self._size[rx]
elif self.rank[rx] == self.rank[ry]:
self.parent[ry] = rx
self.rank[rx] += 1
self._size[rx] += self._size[ry]
else:
self.parent[ry] = rx
self._size[rx] += self._size[ry]
# 同じ集合に属するかどうか
def is_same(self, x, y):
return self.root_of(x) == self.root_of(y)
# 頂点xが属する集合のサイズ
def size(self, x):
return self._size[self.root_of(x)]
# 入力
N, M = [int(x) for x in input().split()]
A = [None] * M
B = [None] * M
for i in range(M):
A[i], B[i] = [int(x) - 1 for x in input().split()]
# 島同士が全く繋がっていない状態からスタート
# M-1番目, M-2番目, ..., , 2番目, 1番目の橋の順に橋をかけていく
inconv = [-1] * (M - 1) + [N * (N - 1) // 2] # 不便さ
uf = UnionFind(N)
for i in range(M - 1, 0, -1):
# i番目の橋をかける
if not uf.is_same(A[i], B[i]):
size_a = uf.size(A[i]) # A[i]が属する集合の大きさ
size_b = uf.size(B[i]) # B[i]が属する集合の大きさ
inconv[i - 1] = inconv[i] - size_a * size_b
uf.unite(A[i], B[i])
else:
inconv[i - 1] = inconv[i]
for i in range(M):
print((inconv[i]))
| false | 5.479452 | [
"- if self.parent[x] == x:",
"- return x",
"- else:",
"- self.parent[x] = self.root_of(self.parent[x]) # 経路圧縮して親が変わる",
"- return self.parent[x]",
"+ children = [x]",
"+ while self.parent[x] != x:",
"+ x = self.parent[x]",
"+ children.append(x)",
"+ for ch in children: # 根の子供として張りなおす",
"+ self.parent[ch] = x",
"+ return x"
] | false | 0.046224 | 0.043594 | 1.060351 | [
"s229997408",
"s928104595"
] |
u606045429 | p03778 | python | s178559740 | s321717944 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | W, a, b = [int(i) for i in input().split()]
if b > a + W:
print((max(0, b - a - W)))
else:
print((max(0, a - b - W))) | W, a, b = [int(i) for i in input().split()]
print((max(0, abs(a - b) - W))) | 5 | 2 | 125 | 74 | W, a, b = [int(i) for i in input().split()]
if b > a + W:
print((max(0, b - a - W)))
else:
print((max(0, a - b - W)))
| W, a, b = [int(i) for i in input().split()]
print((max(0, abs(a - b) - W)))
| false | 60 | [
"-if b > a + W:",
"- print((max(0, b - a - W)))",
"-else:",
"- print((max(0, a - b - W)))",
"+print((max(0, abs(a - b) - W)))"
] | false | 0.046886 | 0.089614 | 0.523202 | [
"s178559740",
"s321717944"
] |
u620084012 | p02767 | python | s219672970 | s710334657 | 166 | 80 | 38,720 | 62,928 | Accepted | Accepted | 51.81 | N = int(eval(input()))
X = sorted(list(map(int,input().split())))
ans = float("inf")
for e in range(min(X),max(X)+1):
temp = 0
for f in X:
temp += (f-e)**2
ans = min(ans,temp)
print(ans)
| N = int(eval(input()))
X = list(map(int,input().split()))
ans = 10**9
for k in range(min(X),max(X)+1):
temp = 0
for e in X:
temp += (k-e)**2
ans = min(temp,ans)
print(ans)
| 9 | 9 | 209 | 194 | N = int(eval(input()))
X = sorted(list(map(int, input().split())))
ans = float("inf")
for e in range(min(X), max(X) + 1):
temp = 0
for f in X:
temp += (f - e) ** 2
ans = min(ans, temp)
print(ans)
| N = int(eval(input()))
X = list(map(int, input().split()))
ans = 10**9
for k in range(min(X), max(X) + 1):
temp = 0
for e in X:
temp += (k - e) ** 2
ans = min(temp, ans)
print(ans)
| false | 0 | [
"-X = sorted(list(map(int, input().split())))",
"-ans = float(\"inf\")",
"-for e in range(min(X), max(X) + 1):",
"+X = list(map(int, input().split()))",
"+ans = 10**9",
"+for k in range(min(X), max(X) + 1):",
"- for f in X:",
"- temp += (f - e) ** 2",
"- ans = min(ans, temp)",
"+ for e in X:",
"+ temp += (k - e) ** 2",
"+ ans = min(temp, ans)"
] | false | 0.076747 | 0.037519 | 2.045578 | [
"s219672970",
"s710334657"
] |
u296150111 | p02734 | python | s341886509 | s115305629 | 1,331 | 649 | 249,096 | 115,676 | Accepted | Accepted | 51.24 | mod=998244353
n,s=list(map(int,input().split()))
a=list(map(int,input().split()))
dp0=[[0]*(s+1) for _ in range(n+1)]
dp1=[[0]*(s+1) for _ in range(n+1)]
dp2=[[0]*(s+1) for _ in range(n+1)]
dp0[0][0]=1
for i in range(n):
for j in range(s+1):
dp0[i+1][j]+=dp0[i][j]
dp1[i+1][j]+=dp0[i][j]+dp1[i][j]
dp2[i+1][j]+=dp0[i][j]+dp1[i][j]+dp2[i][j]
dp0[i+1][j]%=mod;dp1[i+1][j]%=mod;dp2[i+1][j]%=mod
if j+a[i]<=s:
dp1[i+1][j+a[i]]+=dp1[i][j]+dp0[i][j]
dp2[i+1][j+a[i]]+=dp1[i][j]+dp0[i][j]
dp1[i+1][j+a[i]]%=mod;dp2[i+1][j+a[i]]%=mod
print((dp2[n][s]))
| mod=998244353
n,s=list(map(int,input().split()))
a=list(map(int,input().split()))
dp=[[0]*(s+1) for _ in range(n+1)]
dp[0][0]=1;ans=0
for i in range(n):
for j in range(s+1):
dp[i+1][j]+=dp[i][j]
dp[i+1][j]%=mod
if j+a[i]<=s:
if j==0:
dp[i+1][a[i]]+=i+1
else:
dp[i+1][j+a[i]]+=dp[i][j]
dp[i+1][j+a[i]]%=mod
if j+a[i]==s:
ans+=dp[i+1][j+a[i]]*(n-i)
ans%=mod
print(ans)
| 18 | 19 | 574 | 412 | mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
dp0 = [[0] * (s + 1) for _ in range(n + 1)]
dp1 = [[0] * (s + 1) for _ in range(n + 1)]
dp2 = [[0] * (s + 1) for _ in range(n + 1)]
dp0[0][0] = 1
for i in range(n):
for j in range(s + 1):
dp0[i + 1][j] += dp0[i][j]
dp1[i + 1][j] += dp0[i][j] + dp1[i][j]
dp2[i + 1][j] += dp0[i][j] + dp1[i][j] + dp2[i][j]
dp0[i + 1][j] %= mod
dp1[i + 1][j] %= mod
dp2[i + 1][j] %= mod
if j + a[i] <= s:
dp1[i + 1][j + a[i]] += dp1[i][j] + dp0[i][j]
dp2[i + 1][j + a[i]] += dp1[i][j] + dp0[i][j]
dp1[i + 1][j + a[i]] %= mod
dp2[i + 1][j + a[i]] %= mod
print((dp2[n][s]))
| mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0] * (s + 1) for _ in range(n + 1)]
dp[0][0] = 1
ans = 0
for i in range(n):
for j in range(s + 1):
dp[i + 1][j] += dp[i][j]
dp[i + 1][j] %= mod
if j + a[i] <= s:
if j == 0:
dp[i + 1][a[i]] += i + 1
else:
dp[i + 1][j + a[i]] += dp[i][j]
dp[i + 1][j + a[i]] %= mod
if j + a[i] == s:
ans += dp[i + 1][j + a[i]] * (n - i)
ans %= mod
print(ans)
| false | 5.263158 | [
"-dp0 = [[0] * (s + 1) for _ in range(n + 1)]",
"-dp1 = [[0] * (s + 1) for _ in range(n + 1)]",
"-dp2 = [[0] * (s + 1) for _ in range(n + 1)]",
"-dp0[0][0] = 1",
"+dp = [[0] * (s + 1) for _ in range(n + 1)]",
"+dp[0][0] = 1",
"+ans = 0",
"- dp0[i + 1][j] += dp0[i][j]",
"- dp1[i + 1][j] += dp0[i][j] + dp1[i][j]",
"- dp2[i + 1][j] += dp0[i][j] + dp1[i][j] + dp2[i][j]",
"- dp0[i + 1][j] %= mod",
"- dp1[i + 1][j] %= mod",
"- dp2[i + 1][j] %= mod",
"+ dp[i + 1][j] += dp[i][j]",
"+ dp[i + 1][j] %= mod",
"- dp1[i + 1][j + a[i]] += dp1[i][j] + dp0[i][j]",
"- dp2[i + 1][j + a[i]] += dp1[i][j] + dp0[i][j]",
"- dp1[i + 1][j + a[i]] %= mod",
"- dp2[i + 1][j + a[i]] %= mod",
"-print((dp2[n][s]))",
"+ if j == 0:",
"+ dp[i + 1][a[i]] += i + 1",
"+ else:",
"+ dp[i + 1][j + a[i]] += dp[i][j]",
"+ dp[i + 1][j + a[i]] %= mod",
"+ if j + a[i] == s:",
"+ ans += dp[i + 1][j + a[i]] * (n - i)",
"+ ans %= mod",
"+print(ans)"
] | false | 0.0341 | 0.035405 | 0.963141 | [
"s341886509",
"s115305629"
] |
u489762173 | p02720 | python | s988620878 | s809715950 | 175 | 120 | 10,200 | 7,956 | Accepted | Accepted | 31.43 | from collections import deque
K = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
ansq = deque([1,2,3,4,5,6,7,8,9])
while len(ansq)<=K:
num = d.popleft()
if str(num)[-1] == "0":
d.append(num*10)
d.append(num*10+1)
ansq.append(num*10)
ansq.append(num*10+1)
continue
if str(num)[-1] == "9":
d.append(num*10+8)
d.append(num*10+9)
ansq.append(num*10+8)
ansq.append(num*10+9)
continue
d.append(num*10+int(str(num)[-1])-1)
d.append(num*10+int(str(num)[-1]))
d.append(num*10+int(str(num)[-1])+1)
ansq.append(num*10+int(str(num)[-1])-1)
ansq.append(num*10+int(str(num)[-1]))
ansq.append(num*10+int(str(num)[-1])+1)
print((ansq[K-1])) | from collections import deque
K = int(eval(input()))
d = deque([1,2,3,4,5,6,7,8,9])
ansq = deque([1,2,3,4,5,6,7,8,9])
while len(ansq)<=K:
num = d.popleft()
if str(num)[-1] == "0":
da = num*10
db = num*10+1
d.append(da)
d.append(db)
ansq.append(da)
ansq.append(db)
continue
if str(num)[-1] == "9":
da = num*10+8
db = num*10+9
d.append(da)
d.append(db)
ansq.append(da)
ansq.append(db)
continue
da = num*10+int(str(num)[-1])-1
db = num*10+int(str(num)[-1])
dc = num*10+int(str(num)[-1])+1
d.append(da)
d.append(db)
d.append(dc)
ansq.append(da)
ansq.append(db)
ansq.append(dc)
print((ansq[K-1])) | 31 | 39 | 775 | 788 | from collections import deque
K = int(eval(input()))
d = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
ansq = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
while len(ansq) <= K:
num = d.popleft()
if str(num)[-1] == "0":
d.append(num * 10)
d.append(num * 10 + 1)
ansq.append(num * 10)
ansq.append(num * 10 + 1)
continue
if str(num)[-1] == "9":
d.append(num * 10 + 8)
d.append(num * 10 + 9)
ansq.append(num * 10 + 8)
ansq.append(num * 10 + 9)
continue
d.append(num * 10 + int(str(num)[-1]) - 1)
d.append(num * 10 + int(str(num)[-1]))
d.append(num * 10 + int(str(num)[-1]) + 1)
ansq.append(num * 10 + int(str(num)[-1]) - 1)
ansq.append(num * 10 + int(str(num)[-1]))
ansq.append(num * 10 + int(str(num)[-1]) + 1)
print((ansq[K - 1]))
| from collections import deque
K = int(eval(input()))
d = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
ansq = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
while len(ansq) <= K:
num = d.popleft()
if str(num)[-1] == "0":
da = num * 10
db = num * 10 + 1
d.append(da)
d.append(db)
ansq.append(da)
ansq.append(db)
continue
if str(num)[-1] == "9":
da = num * 10 + 8
db = num * 10 + 9
d.append(da)
d.append(db)
ansq.append(da)
ansq.append(db)
continue
da = num * 10 + int(str(num)[-1]) - 1
db = num * 10 + int(str(num)[-1])
dc = num * 10 + int(str(num)[-1]) + 1
d.append(da)
d.append(db)
d.append(dc)
ansq.append(da)
ansq.append(db)
ansq.append(dc)
print((ansq[K - 1]))
| false | 20.512821 | [
"- d.append(num * 10)",
"- d.append(num * 10 + 1)",
"- ansq.append(num * 10)",
"- ansq.append(num * 10 + 1)",
"+ da = num * 10",
"+ db = num * 10 + 1",
"+ d.append(da)",
"+ d.append(db)",
"+ ansq.append(da)",
"+ ansq.append(db)",
"- d.append(num * 10 + 8)",
"- d.append(num * 10 + 9)",
"- ansq.append(num * 10 + 8)",
"- ansq.append(num * 10 + 9)",
"+ da = num * 10 + 8",
"+ db = num * 10 + 9",
"+ d.append(da)",
"+ d.append(db)",
"+ ansq.append(da)",
"+ ansq.append(db)",
"- d.append(num * 10 + int(str(num)[-1]) - 1)",
"- d.append(num * 10 + int(str(num)[-1]))",
"- d.append(num * 10 + int(str(num)[-1]) + 1)",
"- ansq.append(num * 10 + int(str(num)[-1]) - 1)",
"- ansq.append(num * 10 + int(str(num)[-1]))",
"- ansq.append(num * 10 + int(str(num)[-1]) + 1)",
"+ da = num * 10 + int(str(num)[-1]) - 1",
"+ db = num * 10 + int(str(num)[-1])",
"+ dc = num * 10 + int(str(num)[-1]) + 1",
"+ d.append(da)",
"+ d.append(db)",
"+ d.append(dc)",
"+ ansq.append(da)",
"+ ansq.append(db)",
"+ ansq.append(dc)"
] | false | 0.100619 | 0.050392 | 1.996732 | [
"s988620878",
"s809715950"
] |
u714642969 | p02733 | python | s621795000 | s601442356 | 340 | 175 | 44,012 | 74,624 | Accepted | Accepted | 48.53 | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
def input(): return sys.stdin.readline().rstrip()
def main():
H,W,K=list(map(int,input().split()))
S=[[] for _ in range(H)]
for i in range(H):
S[i]=list(map(int,list(eval(input()))))
ans=INF
for i in range(2**(H-1)):
f=True
tmp=0
wari=0
d={}
d[0]=0
for j in range(H-1):
if (i>>j)&1:
tmp+=1
d[j+1]=tmp
wari+=tmp
l=[0]*H
for yoko in range(W):
f=False
for tate in range(H):
if S[tate][yoko]:
l[d[tate]]+=1
if l[d[tate]]>K:
wari+=1
l=[0]*H
f=True
break
if f:
f2=False
for tate in range(H):
if S[tate][yoko]:
l[d[tate]]+=1
if l[d[tate]]>K:
f2=True
break
if f2:
wari=INF
break
ans=min(ans,wari)
print(ans)
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
H,W,K=map(int,input().split())
S=[list(map(int,list(input()))) for _ in range(H)]
ans=INF
for i in range(2**(H-1)):
cnt=1+bin(i).count('1')
tmp=cnt-1
div=[0]*H
for j in range(H-1):
if (i>>j)&1:
div[j+1]=div[j]+1
else:
div[j+1]=div[j]
wc=[0]*cnt
for x in range(W):
tmp_wc=[0]*cnt
f=False
for y in range(H):
if S[y][x]==1:
tmp_wc[div[y]]+=1
wc[div[y]]+=1
if wc[div[y]]>K:
f=True
if tmp_wc[div[y]]>K:
break
else:
if f:
tmp+=1
wc=tmp_wc
tmp_wc=[0]*cnt
f=False
continue
break
else:
ans=min(ans,tmp)
print(ans)
| 54 | 45 | 1,367 | 1,141 | # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
def input():
return sys.stdin.readline().rstrip()
def main():
H, W, K = list(map(int, input().split()))
S = [[] for _ in range(H)]
for i in range(H):
S[i] = list(map(int, list(eval(input()))))
ans = INF
for i in range(2 ** (H - 1)):
f = True
tmp = 0
wari = 0
d = {}
d[0] = 0
for j in range(H - 1):
if (i >> j) & 1:
tmp += 1
d[j + 1] = tmp
wari += tmp
l = [0] * H
for yoko in range(W):
f = False
for tate in range(H):
if S[tate][yoko]:
l[d[tate]] += 1
if l[d[tate]] > K:
wari += 1
l = [0] * H
f = True
break
if f:
f2 = False
for tate in range(H):
if S[tate][yoko]:
l[d[tate]] += 1
if l[d[tate]] > K:
f2 = True
break
if f2:
wari = INF
break
ans = min(ans, wari)
print(ans)
if __name__ == "__main__":
main()
| # -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().rstrip()
YesNo = lambda b: bool([print("Yes")] if b else print("No"))
YESNO = lambda b: bool([print("YES")] if b else print("NO"))
int1 = lambda x: int(x) - 1
H, W, K = map(int, input().split())
S = [list(map(int, list(input()))) for _ in range(H)]
ans = INF
for i in range(2 ** (H - 1)):
cnt = 1 + bin(i).count("1")
tmp = cnt - 1
div = [0] * H
for j in range(H - 1):
if (i >> j) & 1:
div[j + 1] = div[j] + 1
else:
div[j + 1] = div[j]
wc = [0] * cnt
for x in range(W):
tmp_wc = [0] * cnt
f = False
for y in range(H):
if S[y][x] == 1:
tmp_wc[div[y]] += 1
wc[div[y]] += 1
if wc[div[y]] > K:
f = True
if tmp_wc[div[y]] > K:
break
else:
if f:
tmp += 1
wc = tmp_wc
tmp_wc = [0] * cnt
f = False
continue
break
else:
ans = min(ans, tmp)
print(ans)
| false | 16.666667 | [
"-",
"-",
"-def input():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def main():",
"- H, W, K = list(map(int, input().split()))",
"- S = [[] for _ in range(H)]",
"- for i in range(H):",
"- S[i] = list(map(int, list(eval(input()))))",
"- ans = INF",
"- for i in range(2 ** (H - 1)):",
"- f = True",
"- tmp = 0",
"- wari = 0",
"- d = {}",
"- d[0] = 0",
"- for j in range(H - 1):",
"- if (i >> j) & 1:",
"+input = lambda: sys.stdin.readline().rstrip()",
"+YesNo = lambda b: bool([print(\"Yes\")] if b else print(\"No\"))",
"+YESNO = lambda b: bool([print(\"YES\")] if b else print(\"NO\"))",
"+int1 = lambda x: int(x) - 1",
"+H, W, K = map(int, input().split())",
"+S = [list(map(int, list(input()))) for _ in range(H)]",
"+ans = INF",
"+for i in range(2 ** (H - 1)):",
"+ cnt = 1 + bin(i).count(\"1\")",
"+ tmp = cnt - 1",
"+ div = [0] * H",
"+ for j in range(H - 1):",
"+ if (i >> j) & 1:",
"+ div[j + 1] = div[j] + 1",
"+ else:",
"+ div[j + 1] = div[j]",
"+ wc = [0] * cnt",
"+ for x in range(W):",
"+ tmp_wc = [0] * cnt",
"+ f = False",
"+ for y in range(H):",
"+ if S[y][x] == 1:",
"+ tmp_wc[div[y]] += 1",
"+ wc[div[y]] += 1",
"+ if wc[div[y]] > K:",
"+ f = True",
"+ if tmp_wc[div[y]] > K:",
"+ break",
"+ else:",
"+ if f:",
"- d[j + 1] = tmp",
"- wari += tmp",
"- l = [0] * H",
"- for yoko in range(W):",
"- f = False",
"- for tate in range(H):",
"- if S[tate][yoko]:",
"- l[d[tate]] += 1",
"- if l[d[tate]] > K:",
"- wari += 1",
"- l = [0] * H",
"- f = True",
"- break",
"- if f:",
"- f2 = False",
"- for tate in range(H):",
"- if S[tate][yoko]:",
"- l[d[tate]] += 1",
"- if l[d[tate]] > K:",
"- f2 = True",
"- break",
"- if f2:",
"- wari = INF",
"- break",
"- ans = min(ans, wari)",
"- print(ans)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+ wc = tmp_wc",
"+ tmp_wc = [0] * cnt",
"+ f = False",
"+ continue",
"+ break",
"+ else:",
"+ ans = min(ans, tmp)",
"+print(ans)"
] | false | 0.045795 | 0.045504 | 1.006394 | [
"s621795000",
"s601442356"
] |
u888582202 | p02577 | python | s470237289 | s429336140 | 206 | 75 | 9,096 | 9,092 | Accepted | Accepted | 63.59 | N = int(eval(input()))
if N%9==0:
print('Yes')
else:
print('No') | N = eval(input())
a=0
for i in range(len(N)):
a+=int(N[i])%9
if a%9==0:
print('Yes')
if a%9!=0:
print('No') | 5 | 8 | 66 | 114 | N = int(eval(input()))
if N % 9 == 0:
print("Yes")
else:
print("No")
| N = eval(input())
a = 0
for i in range(len(N)):
a += int(N[i]) % 9
if a % 9 == 0:
print("Yes")
if a % 9 != 0:
print("No")
| false | 37.5 | [
"-N = int(eval(input()))",
"-if N % 9 == 0:",
"+N = eval(input())",
"+a = 0",
"+for i in range(len(N)):",
"+ a += int(N[i]) % 9",
"+if a % 9 == 0:",
"-else:",
"+if a % 9 != 0:"
] | false | 0.037274 | 0.045984 | 0.810585 | [
"s470237289",
"s429336140"
] |
u863442865 | p02684 | python | s092098290 | s567867246 | 223 | 94 | 176,352 | 90,172 | Accepted | Accepted | 57.85 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n,k = list(map(int, input().split()))
a = list(map(int, input().split()))
db = [a]
cnt = k.bit_length()
for c in range(1, cnt):
temp = [0]*n
for i in range(n):
temp[i] = db[c-1][db[c-1][i]-1]
db.append(temp)
res = 1
for i in range(cnt):
if (k>>i) & 1:
res = db[i][res-1]
print(res)
if __name__ == '__main__':
main() | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left,bisect_right
from heapq import heapify, heappop, heappush
import math
#from math import gcd
#inf = 10**17
#mod = 10**9 + 7
n,k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
# visited[i]:町iにvisited[i]回目の遷移で到達
visited = [0]*(n+1)
step = 0
i = 1
while k:
i = a[i]
step += 1
k -= 1
if visited[i] != 0:
k = k % (step - visited[i])
for _ in range(k):
i = a[i]
print(i)
break
visited[i] = step
else:
print(i)
if __name__ == '__main__':
main() | 32 | 37 | 831 | 919 | def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left, bisect_right
from heapq import heapify, heappop, heappush
import math
# from math import gcd
# inf = 10**17
# mod = 10**9 + 7
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
db = [a]
cnt = k.bit_length()
for c in range(1, cnt):
temp = [0] * n
for i in range(n):
temp[i] = db[c - 1][db[c - 1][i] - 1]
db.append(temp)
res = 1
for i in range(cnt):
if (k >> i) & 1:
res = db[i][res - 1]
print(res)
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
from itertools import combinations, permutations, accumulate, groupby, product
from bisect import bisect_left, bisect_right
from heapq import heapify, heappop, heappush
import math
# from math import gcd
# inf = 10**17
# mod = 10**9 + 7
n, k = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
# visited[i]:町iにvisited[i]回目の遷移で到達
visited = [0] * (n + 1)
step = 0
i = 1
while k:
i = a[i]
step += 1
k -= 1
if visited[i] != 0:
k = k % (step - visited[i])
for _ in range(k):
i = a[i]
print(i)
break
visited[i] = step
else:
print(i)
if __name__ == "__main__":
main()
| false | 13.513514 | [
"- a = list(map(int, input().split()))",
"- db = [a]",
"- cnt = k.bit_length()",
"- for c in range(1, cnt):",
"- temp = [0] * n",
"- for i in range(n):",
"- temp[i] = db[c - 1][db[c - 1][i] - 1]",
"- db.append(temp)",
"- res = 1",
"- for i in range(cnt):",
"- if (k >> i) & 1:",
"- res = db[i][res - 1]",
"- print(res)",
"+ a = [0] + list(map(int, input().split()))",
"+ # visited[i]:町iにvisited[i]回目の遷移で到達",
"+ visited = [0] * (n + 1)",
"+ step = 0",
"+ i = 1",
"+ while k:",
"+ i = a[i]",
"+ step += 1",
"+ k -= 1",
"+ if visited[i] != 0:",
"+ k = k % (step - visited[i])",
"+ for _ in range(k):",
"+ i = a[i]",
"+ print(i)",
"+ break",
"+ visited[i] = step",
"+ else:",
"+ print(i)"
] | false | 0.063345 | 0.105326 | 0.601416 | [
"s092098290",
"s567867246"
] |
u644907318 | p02882 | python | s932980084 | s698599885 | 73 | 65 | 62,436 | 62,252 | Accepted | Accepted | 10.96 | import math
a,b,x = list(map(int,input().split()))
if x<=(a**2*b)/2:
deg = math.degrees(math.atan((a*b**2)/(2*x)))
else:
deg = math.degrees(math.atan(2*(b*a**2-x)/a**3))
print(deg) | import math
a,b,x = list(map(int,input().split()))
if 2*x>=(a**2)*b:
theta = math.degrees(math.atan(2*(b-x/a**2)/a))
else:
theta = math.degrees(math.atan((a*b**2)/(2*x)))
print(theta) | 7 | 7 | 188 | 191 | import math
a, b, x = list(map(int, input().split()))
if x <= (a**2 * b) / 2:
deg = math.degrees(math.atan((a * b**2) / (2 * x)))
else:
deg = math.degrees(math.atan(2 * (b * a**2 - x) / a**3))
print(deg)
| import math
a, b, x = list(map(int, input().split()))
if 2 * x >= (a**2) * b:
theta = math.degrees(math.atan(2 * (b - x / a**2) / a))
else:
theta = math.degrees(math.atan((a * b**2) / (2 * x)))
print(theta)
| false | 0 | [
"-if x <= (a**2 * b) / 2:",
"- deg = math.degrees(math.atan((a * b**2) / (2 * x)))",
"+if 2 * x >= (a**2) * b:",
"+ theta = math.degrees(math.atan(2 * (b - x / a**2) / a))",
"- deg = math.degrees(math.atan(2 * (b * a**2 - x) / a**3))",
"-print(deg)",
"+ theta = math.degrees(math.atan((a * b**2) / (2 * x)))",
"+print(theta)"
] | false | 0.035247 | 0.044077 | 0.799665 | [
"s932980084",
"s698599885"
] |
u999750647 | p02713 | python | s584344367 | s126532784 | 1,941 | 1,771 | 9,176 | 9,060 | Accepted | Accepted | 8.76 | from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1,n+1):
for b in range(1,n+1):
for c in range(1,n+1):
ans += gcd(a,gcd(b,c))
print(ans) | from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1,n+1):
for b in range(1,n+1):
for c in range(1,n+1):
ans += gcd(c,gcd(a,b))
print(ans) | 9 | 9 | 181 | 181 | from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1, n + 1):
for b in range(1, n + 1):
for c in range(1, n + 1):
ans += gcd(a, gcd(b, c))
print(ans)
| from math import gcd
n = int(eval(input()))
ans = 0
for a in range(1, n + 1):
for b in range(1, n + 1):
for c in range(1, n + 1):
ans += gcd(c, gcd(a, b))
print(ans)
| false | 0 | [
"- ans += gcd(a, gcd(b, c))",
"+ ans += gcd(c, gcd(a, b))"
] | false | 0.080846 | 0.172999 | 0.467321 | [
"s584344367",
"s126532784"
] |
u596276291 | p03551 | python | s496886271 | s615874347 | 86 | 25 | 4,088 | 3,832 | Accepted | Accepted | 70.93 | import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def main():
N, M = list(map(int, input().split()))
ans = 0
ans += (2 ** M) * ((1900 * M) + (N - M) * 100)
print(ans)
if __name__ == '__main__':
main()
| import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool: return 0 <= y < H and 0 <= x < W
def main():
N, M = list(map(int, input().split()))
print((2 ** M * (M * 1900 + (N - M) * 100)))
if __name__ == '__main__':
main()
| 27 | 25 | 674 | 641 | import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool:
return 0 <= y < H and 0 <= x < W
def main():
N, M = list(map(int, input().split()))
ans = 0
ans += (2**M) * ((1900 * M) + (N - M) * 100)
print(ans)
if __name__ == "__main__":
main()
| import sys
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt, ceil, floor
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
INF = float("inf")
sys.setrecursionlimit(10**7)
# 4近傍（右, 下, 左, 上）
dy = [0, -1, 0, 1]
dx = [1, 0, -1, 0]
def inside(y: int, x: int, H: int, W: int) -> bool:
return 0 <= y < H and 0 <= x < W
def main():
N, M = list(map(int, input().split()))
print((2**M * (M * 1900 + (N - M) * 100)))
if __name__ == "__main__":
main()
| false | 7.407407 | [
"- ans = 0",
"- ans += (2**M) * ((1900 * M) + (N - M) * 100)",
"- print(ans)",
"+ print((2**M * (M * 1900 + (N - M) * 100)))"
] | false | 0.052468 | 0.037096 | 1.414413 | [
"s496886271",
"s615874347"
] |
u600402037 | p02837 | python | s741020570 | s716105360 | 306 | 258 | 3,064 | 47,084 | Accepted | Accepted | 15.69 | import sys
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
N = ri()
A = [[] for _ in range(N)]
for i in range(N):
a = ri()
l = []
for j in range(a):
x, y = rl()
l.append((x, y))
A[i] = l
answer = 0
for i in range(2 ** N):
honest = [False] * (N+1)
bool = True
for j in range(N):
if ((i >> j) & 1):
honest[N - j] = True
for k in range(1, N+1):
if honest[k] == True:
#k番目の人は正直者
for x, y in A[k-1]:
if y == 1 and honest[x] == False:
bool = False
break
if y == 0 and honest[x] == True:
bool = False
break
if bool and sum(honest) > answer:
answer = max(answer, sum(honest))
print(answer)
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
answer = 0
N = ir()
honest = [[] for _ in range(N+1)]
liar = [[] for _ in range(N+1)]
# bit全探索
for i in range(N):
a = ir()
for _ in range(a):
x, y = lr()
if y == 1:
honest[i].append(x-1)
else:
liar[i].append(x-1)
for bit in range(1<<N):
bl = True
h = []
for i in range(N):
if (bit >> i) & 1:
h.append(i)
s = set(h)
for person in h:
for x in honest[person]:
if x not in s:
bl = False
break
for y in liar[person]:
if y in s:
bl = False
break
if not bl:
break
if bl:
answer = max(answer, len(s))
print(answer)
| 40 | 42 | 964 | 903 | import sys
stdin = sys.stdin
ri = lambda: int(rs())
rl = lambda: list(map(int, stdin.readline().split()))
rs = lambda: stdin.readline().rstrip() # ignore trailing spaces
N = ri()
A = [[] for _ in range(N)]
for i in range(N):
a = ri()
l = []
for j in range(a):
x, y = rl()
l.append((x, y))
A[i] = l
answer = 0
for i in range(2**N):
honest = [False] * (N + 1)
bool = True
for j in range(N):
if (i >> j) & 1:
honest[N - j] = True
for k in range(1, N + 1):
if honest[k] == True:
# k番目の人は正直者
for x, y in A[k - 1]:
if y == 1 and honest[x] == False:
bool = False
break
if y == 0 and honest[x] == True:
bool = False
break
if bool and sum(honest) > answer:
answer = max(answer, sum(honest))
print(answer)
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
answer = 0
N = ir()
honest = [[] for _ in range(N + 1)]
liar = [[] for _ in range(N + 1)]
# bit全探索
for i in range(N):
a = ir()
for _ in range(a):
x, y = lr()
if y == 1:
honest[i].append(x - 1)
else:
liar[i].append(x - 1)
for bit in range(1 << N):
bl = True
h = []
for i in range(N):
if (bit >> i) & 1:
h.append(i)
s = set(h)
for person in h:
for x in honest[person]:
if x not in s:
bl = False
break
for y in liar[person]:
if y in s:
bl = False
break
if not bl:
break
if bl:
answer = max(answer, len(s))
print(answer)
| false | 4.761905 | [
"-stdin = sys.stdin",
"-ri = lambda: int(rs())",
"-rl = lambda: list(map(int, stdin.readline().split()))",
"-rs = lambda: stdin.readline().rstrip() # ignore trailing spaces",
"-N = ri()",
"-A = [[] for _ in range(N)]",
"+sr = lambda: sys.stdin.readline().rstrip()",
"+ir = lambda: int(sr())",
"+lr = lambda: list(map(int, sr().split()))",
"+answer = 0",
"+N = ir()",
"+honest = [[] for _ in range(N + 1)]",
"+liar = [[] for _ in range(N + 1)]",
"+# bit全探索",
"- a = ri()",
"- l = []",
"- for j in range(a):",
"- x, y = rl()",
"- l.append((x, y))",
"- A[i] = l",
"-answer = 0",
"-for i in range(2**N):",
"- honest = [False] * (N + 1)",
"- bool = True",
"- for j in range(N):",
"- if (i >> j) & 1:",
"- honest[N - j] = True",
"- for k in range(1, N + 1):",
"- if honest[k] == True:",
"- # k番目の人は正直者",
"- for x, y in A[k - 1]:",
"- if y == 1 and honest[x] == False:",
"- bool = False",
"- break",
"- if y == 0 and honest[x] == True:",
"- bool = False",
"- break",
"- if bool and sum(honest) > answer:",
"- answer = max(answer, sum(honest))",
"+ a = ir()",
"+ for _ in range(a):",
"+ x, y = lr()",
"+ if y == 1:",
"+ honest[i].append(x - 1)",
"+ else:",
"+ liar[i].append(x - 1)",
"+for bit in range(1 << N):",
"+ bl = True",
"+ h = []",
"+ for i in range(N):",
"+ if (bit >> i) & 1:",
"+ h.append(i)",
"+ s = set(h)",
"+ for person in h:",
"+ for x in honest[person]:",
"+ if x not in s:",
"+ bl = False",
"+ break",
"+ for y in liar[person]:",
"+ if y in s:",
"+ bl = False",
"+ break",
"+ if not bl:",
"+ break",
"+ if bl:",
"+ answer = max(answer, len(s))"
] | false | 0.078575 | 0.046784 | 1.679523 | [
"s741020570",
"s716105360"
] |
u738898077 | p02996 | python | s316090546 | s724911452 | 998 | 915 | 55,264 | 53,600 | Accepted | Accepted | 8.32 | n = int(eval(input()))
ab = [list(map(int,input().split())) for i in range(n)]
ab = sorted(ab,key=lambda x: x[1])
now = 0
for i in ab:
if i[1] >= now + i[0]:
now += i[0]
else:
print("No")
exit()
print("Yes") | n=int(eval(input()))
ab=[list(map(int,input().split())) for i in range(n)]
ab.sort(key=lambda x: x[1])
temp=0
for i in ab:
temp+=i[0]
if temp>i[1]:
print("No")
exit()
print("Yes") | 11 | 10 | 243 | 206 | n = int(eval(input()))
ab = [list(map(int, input().split())) for i in range(n)]
ab = sorted(ab, key=lambda x: x[1])
now = 0
for i in ab:
if i[1] >= now + i[0]:
now += i[0]
else:
print("No")
exit()
print("Yes")
| n = int(eval(input()))
ab = [list(map(int, input().split())) for i in range(n)]
ab.sort(key=lambda x: x[1])
temp = 0
for i in ab:
temp += i[0]
if temp > i[1]:
print("No")
exit()
print("Yes")
| false | 9.090909 | [
"-ab = sorted(ab, key=lambda x: x[1])",
"-now = 0",
"+ab.sort(key=lambda x: x[1])",
"+temp = 0",
"- if i[1] >= now + i[0]:",
"- now += i[0]",
"- else:",
"+ temp += i[0]",
"+ if temp > i[1]:"
] | false | 0.085189 | 0.120915 | 0.704534 | [
"s316090546",
"s724911452"
] |
u848535504 | p03493 | python | s265072077 | s648140122 | 32 | 28 | 8,948 | 8,920 | Accepted | Accepted | 12.5 | s = list(eval(input()))
print((s.count("1"))) | print((input().count("1"))) | 2 | 1 | 38 | 25 | s = list(eval(input()))
print((s.count("1")))
| print((input().count("1")))
| false | 50 | [
"-s = list(eval(input()))",
"-print((s.count(\"1\")))",
"+print((input().count(\"1\")))"
] | false | 0.040076 | 0.042122 | 0.951438 | [
"s265072077",
"s648140122"
] |
u312025627 | p03997 | python | s443139388 | s604228845 | 173 | 62 | 38,256 | 61,916 | Accepted | Accepted | 64.16 | a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b) * h // 2)) | def main():
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a+b)*h//2))
if __name__ == '__main__':
main()
| 4 | 9 | 75 | 145 | a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
| def main():
a = int(eval(input()))
b = int(eval(input()))
h = int(eval(input()))
print(((a + b) * h // 2))
if __name__ == "__main__":
main()
| false | 55.555556 | [
"-a = int(eval(input()))",
"-b = int(eval(input()))",
"-h = int(eval(input()))",
"-print(((a + b) * h // 2))",
"+def main():",
"+ a = int(eval(input()))",
"+ b = int(eval(input()))",
"+ h = int(eval(input()))",
"+ print(((a + b) * h // 2))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.177362 | 0.150337 | 1.17976 | [
"s443139388",
"s604228845"
] |
u028554976 | p03317 | python | s826653825 | s830392454 | 49 | 27 | 20,028 | 9,064 | Accepted | Accepted | 44.9 | n,k,*_=list(map(int,open(0).read().split()))
print((0--~-n//~-k)) | n,k=list(map(int,input().split()))
print((0--~-n//~-k)) | 2 | 2 | 58 | 48 | n, k, *_ = list(map(int, open(0).read().split()))
print((0 - -~-n // ~-k))
| n, k = list(map(int, input().split()))
print((0 - -~-n // ~-k))
| false | 0 | [
"-n, k, *_ = list(map(int, open(0).read().split()))",
"+n, k = list(map(int, input().split()))"
] | false | 0.083583 | 0.111044 | 0.752707 | [
"s826653825",
"s830392454"
] |
u357751375 | p03971 | python | s170371950 | s648578434 | 85 | 75 | 10,472 | 9,312 | Accepted | Accepted | 11.76 | #n = 人数,a = 日本,b = 海外
n,a,b = list(map(int,input().split()))
#s = 順位
s = list(eval(input()))
#k = 結果格納
k = []
j = a + b
c = 0
d = 0
for i in range(n):
if s[i] == 'a':
if c < j:
c += 1
k.append('Yes')
else:
k.append('No')
elif s[i] == 'b':
if c < j:
if d < b:
c += 1
d += 1
k.append('Yes')
else:
k.append('No')
else:
k.append('No')
else:
k.append('No')
for i in range(n):
print((k[i])) | n,a,b = list(map(int,input().split()))
s = eval(input())
x = a + b
y = 1
z = 1
for i in range(n):
if s[i] == 'a':
if y <= x:
print('Yes')
y += 1
else:
print('No')
elif s[i] == 'b':
if y <= x and z <= b:
print('Yes')
y += 1
z += 1
else:
print('No')
else:
print('No') | 32 | 21 | 595 | 409 | # n = 人数,a = 日本,b = 海外
n, a, b = list(map(int, input().split()))
# s = 順位
s = list(eval(input()))
# k = 結果格納
k = []
j = a + b
c = 0
d = 0
for i in range(n):
if s[i] == "a":
if c < j:
c += 1
k.append("Yes")
else:
k.append("No")
elif s[i] == "b":
if c < j:
if d < b:
c += 1
d += 1
k.append("Yes")
else:
k.append("No")
else:
k.append("No")
else:
k.append("No")
for i in range(n):
print((k[i]))
| n, a, b = list(map(int, input().split()))
s = eval(input())
x = a + b
y = 1
z = 1
for i in range(n):
if s[i] == "a":
if y <= x:
print("Yes")
y += 1
else:
print("No")
elif s[i] == "b":
if y <= x and z <= b:
print("Yes")
y += 1
z += 1
else:
print("No")
else:
print("No")
| false | 34.375 | [
"-# n = 人数,a = 日本,b = 海外",
"-# s = 順位",
"-s = list(eval(input()))",
"-# k = 結果格納",
"-k = []",
"-j = a + b",
"-c = 0",
"-d = 0",
"+s = eval(input())",
"+x = a + b",
"+y = 1",
"+z = 1",
"- if c < j:",
"- c += 1",
"- k.append(\"Yes\")",
"+ if y <= x:",
"+ print(\"Yes\")",
"+ y += 1",
"- k.append(\"No\")",
"+ print(\"No\")",
"- if c < j:",
"- if d < b:",
"- c += 1",
"- d += 1",
"- k.append(\"Yes\")",
"- else:",
"- k.append(\"No\")",
"+ if y <= x and z <= b:",
"+ print(\"Yes\")",
"+ y += 1",
"+ z += 1",
"- k.append(\"No\")",
"+ print(\"No\")",
"- k.append(\"No\")",
"-for i in range(n):",
"- print((k[i]))",
"+ print(\"No\")"
] | false | 0.036044 | 0.039105 | 0.921728 | [
"s170371950",
"s648578434"
] |
u227082700 | p02716 | python | s600409114 | s626964401 | 275 | 230 | 52,180 | 39,484 | Accepted | Accepted | 16.36 | n=int(eval(input()))
a=list(map(int,input().split()))
if n<=3:print((max(a)));exit()
if n&1:
dp=[3*[-(10**20)]for _ in range(n)]
dp[0][0]=a[0]
for i in range(1,n):
if i%2==0:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:dp[i][2]=max(dp[i-2][2]+a[i],dp[i-3][1]+a[i])
else:dp[i][2]=a[i]
else:
if i>=3:dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
else:dp[i][1]=a[i]
print((max(dp[-1][2],dp[-2][1],dp[-3][0])))
else:
b=[a[0]]
c=[a[1]]
for i in range(2,n):
if i%2==0:b.append(b[-1]+a[i])
else:c.append(c[-1]+a[i])
ans=max(b[-1],c[-1])
for i in range(n//2-1):
ans=max(ans,b[i]+c[-1]-c[i])
print(ans)
| n=int(eval(input()));l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+(p[i-2]if i>1else 0)
for i in range(1,n):
d[i]=p[i-1]if(i&1)else d[i-1]
d[i]=max(d[i],l[i]+(d[i-2]if i>1else 0))
print((d[-1])) | 25 | 6 | 667 | 226 | n = int(eval(input()))
a = list(map(int, input().split()))
if n <= 3:
print((max(a)))
exit()
if n & 1:
dp = [3 * [-(10**20)] for _ in range(n)]
dp[0][0] = a[0]
for i in range(1, n):
if i % 2 == 0:
dp[i][0] = dp[i - 2][0] + a[i]
if i >= 3:
dp[i][2] = max(dp[i - 2][2] + a[i], dp[i - 3][1] + a[i])
else:
dp[i][2] = a[i]
else:
if i >= 3:
dp[i][1] = max(dp[i - 2][1] + a[i], dp[i - 3][0] + a[i])
else:
dp[i][1] = a[i]
print((max(dp[-1][2], dp[-2][1], dp[-3][0])))
else:
b = [a[0]]
c = [a[1]]
for i in range(2, n):
if i % 2 == 0:
b.append(b[-1] + a[i])
else:
c.append(c[-1] + a[i])
ans = max(b[-1], c[-1])
for i in range(n // 2 - 1):
ans = max(ans, b[i] + c[-1] - c[i])
print(ans)
| n = int(eval(input()))
l = list(map(int, input().split()))
p = [0] * n
d = [0] * n
for i in range(n):
p[i] = l[i] + (p[i - 2] if i > 1 else 0)
for i in range(1, n):
d[i] = p[i - 1] if (i & 1) else d[i - 1]
d[i] = max(d[i], l[i] + (d[i - 2] if i > 1 else 0))
print((d[-1]))
| false | 76 | [
"-a = list(map(int, input().split()))",
"-if n <= 3:",
"- print((max(a)))",
"- exit()",
"-if n & 1:",
"- dp = [3 * [-(10**20)] for _ in range(n)]",
"- dp[0][0] = a[0]",
"- for i in range(1, n):",
"- if i % 2 == 0:",
"- dp[i][0] = dp[i - 2][0] + a[i]",
"- if i >= 3:",
"- dp[i][2] = max(dp[i - 2][2] + a[i], dp[i - 3][1] + a[i])",
"- else:",
"- dp[i][2] = a[i]",
"- else:",
"- if i >= 3:",
"- dp[i][1] = max(dp[i - 2][1] + a[i], dp[i - 3][0] + a[i])",
"- else:",
"- dp[i][1] = a[i]",
"- print((max(dp[-1][2], dp[-2][1], dp[-3][0])))",
"-else:",
"- b = [a[0]]",
"- c = [a[1]]",
"- for i in range(2, n):",
"- if i % 2 == 0:",
"- b.append(b[-1] + a[i])",
"- else:",
"- c.append(c[-1] + a[i])",
"- ans = max(b[-1], c[-1])",
"- for i in range(n // 2 - 1):",
"- ans = max(ans, b[i] + c[-1] - c[i])",
"- print(ans)",
"+l = list(map(int, input().split()))",
"+p = [0] * n",
"+d = [0] * n",
"+for i in range(n):",
"+ p[i] = l[i] + (p[i - 2] if i > 1 else 0)",
"+for i in range(1, n):",
"+ d[i] = p[i - 1] if (i & 1) else d[i - 1]",
"+ d[i] = max(d[i], l[i] + (d[i - 2] if i > 1 else 0))",
"+print((d[-1]))"
] | false | 0.048952 | 0.0398 | 1.229956 | [
"s600409114",
"s626964401"
] |
u685263709 | p03290 | python | s323419558 | s220296522 | 219 | 52 | 40,432 | 3,444 | Accepted | Accepted | 76.26 | D, G = list(map(int, input().split()))
PC = [list(map(int, input().split())) for i in range(D)]
def solve(G, i):
if i <= 0:
return float('inf')
n = min(int(G/(100*i)), PC[i-1][0])
score = 100 * i * n
if n == PC[i-1][0]:
score += PC[i-1][1]
if G > score:
n += solve(G-score, i-1)
return min(n, solve(G, i-1))
print((solve(G, D))) | D, G = list(map(int, input().split()))
PC = [list(map(int, input().split())) for i in range(D)]
PC_new = sorted([(PC[i][0]*100*(i+1) + PC[i][1], PC[i][0]) for i in range(D)],
key=lambda x: x[1], reverse=True)
ans = 99999999
for i in range(1<<D):
ct = 0
score = 0
for j in range(D):
if i>>j&1:
score += PC[j][1]
score += PC[j][0] * (j+1) * 100
ct += PC[j][0]
for j in range(D-1, -1, -1):
if i>>j&1: continue
if score >= G: break
g = (j+1)*100
got = (G-score+g-1)//g
score += min(got, PC[j][0]) * g
ct += min(got, PC[j][0])
ans = min(ans, ct)
print(ans)
| 17 | 23 | 388 | 697 | D, G = list(map(int, input().split()))
PC = [list(map(int, input().split())) for i in range(D)]
def solve(G, i):
if i <= 0:
return float("inf")
n = min(int(G / (100 * i)), PC[i - 1][0])
score = 100 * i * n
if n == PC[i - 1][0]:
score += PC[i - 1][1]
if G > score:
n += solve(G - score, i - 1)
return min(n, solve(G, i - 1))
print((solve(G, D)))
| D, G = list(map(int, input().split()))
PC = [list(map(int, input().split())) for i in range(D)]
PC_new = sorted(
[(PC[i][0] * 100 * (i + 1) + PC[i][1], PC[i][0]) for i in range(D)],
key=lambda x: x[1],
reverse=True,
)
ans = 99999999
for i in range(1 << D):
ct = 0
score = 0
for j in range(D):
if i >> j & 1:
score += PC[j][1]
score += PC[j][0] * (j + 1) * 100
ct += PC[j][0]
for j in range(D - 1, -1, -1):
if i >> j & 1:
continue
if score >= G:
break
g = (j + 1) * 100
got = (G - score + g - 1) // g
score += min(got, PC[j][0]) * g
ct += min(got, PC[j][0])
ans = min(ans, ct)
print(ans)
| false | 26.086957 | [
"-",
"-",
"-def solve(G, i):",
"- if i <= 0:",
"- return float(\"inf\")",
"- n = min(int(G / (100 * i)), PC[i - 1][0])",
"- score = 100 * i * n",
"- if n == PC[i - 1][0]:",
"- score += PC[i - 1][1]",
"- if G > score:",
"- n += solve(G - score, i - 1)",
"- return min(n, solve(G, i - 1))",
"-",
"-",
"-print((solve(G, D)))",
"+PC_new = sorted(",
"+ [(PC[i][0] * 100 * (i + 1) + PC[i][1], PC[i][0]) for i in range(D)],",
"+ key=lambda x: x[1],",
"+ reverse=True,",
"+)",
"+ans = 99999999",
"+for i in range(1 << D):",
"+ ct = 0",
"+ score = 0",
"+ for j in range(D):",
"+ if i >> j & 1:",
"+ score += PC[j][1]",
"+ score += PC[j][0] * (j + 1) * 100",
"+ ct += PC[j][0]",
"+ for j in range(D - 1, -1, -1):",
"+ if i >> j & 1:",
"+ continue",
"+ if score >= G:",
"+ break",
"+ g = (j + 1) * 100",
"+ got = (G - score + g - 1) // g",
"+ score += min(got, PC[j][0]) * g",
"+ ct += min(got, PC[j][0])",
"+ ans = min(ans, ct)",
"+print(ans)"
] | false | 0.037404 | 0.046065 | 0.811985 | [
"s323419558",
"s220296522"
] |
u671060652 | p02688 | python | s583171534 | s675489023 | 123 | 95 | 72,796 | 72,712 | Accepted | Accepted | 22.76 | import itertools
import math
import fractions
import functools
n, k = list(map(int, input().split()))
a = []
for i in range(k):
di = int(eval(input()))
ai = list(map(int, input().split()))
a.append(ai)
count = [0] * (n+1)
for i in range(k):
for j in range(len(a[i])):
count[a[i][j]] += 1
print((count.count(0)-1)) | import itertools
import math
import fractions
import functools
n, k = list(map(int, input().split()))
a = []
for i in range(k):
di = int(eval(input()))
ai = list(map(int, input().split()))
a.append(ai)
count=set()
for i in range(k):
for j in range(len(a[i])):
count.add(a[i][j])
print((n-len(count))) | 18 | 18 | 343 | 330 | import itertools
import math
import fractions
import functools
n, k = list(map(int, input().split()))
a = []
for i in range(k):
di = int(eval(input()))
ai = list(map(int, input().split()))
a.append(ai)
count = [0] * (n + 1)
for i in range(k):
for j in range(len(a[i])):
count[a[i][j]] += 1
print((count.count(0) - 1))
| import itertools
import math
import fractions
import functools
n, k = list(map(int, input().split()))
a = []
for i in range(k):
di = int(eval(input()))
ai = list(map(int, input().split()))
a.append(ai)
count = set()
for i in range(k):
for j in range(len(a[i])):
count.add(a[i][j])
print((n - len(count)))
| false | 0 | [
"-count = [0] * (n + 1)",
"+count = set()",
"- count[a[i][j]] += 1",
"-print((count.count(0) - 1))",
"+ count.add(a[i][j])",
"+print((n - len(count)))"
] | false | 0.101264 | 0.038098 | 2.658001 | [
"s583171534",
"s675489023"
] |
u206890818 | p02634 | python | s916861198 | s390349467 | 640 | 565 | 232,324 | 231,788 | Accepted | Accepted | 11.72 | #import numpy as np
import math
import collections
import bisect
def main():
a, b, c, d = list(map(int, input().split()))
dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]
dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]
for i in range(c + 1):
for j in range(d + 1):
if j < b or i < a:
dp0[i][j] = 0
dp1[i][j] = 0
for i in range(a, c + 1):
for j in range(b, d + 1):
# print(i, j, dp[i][j])
if a == i and b == j:
continue
dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353
dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353
print(((dp0[c][d] + dp1[c][d]) % 998244353))
if __name__ == '__main__':
main()
| #import numpy as np
import math
import collections
import bisect
a, b, c, d = list(map(int, input().split()))
dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]
dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]
for i in range(c + 1):
for j in range(d + 1):
if j < b or i < a:
dp0[i][j] = 0
dp1[i][j] = 0
for i in range(a, c + 1):
for j in range(b, d + 1):
# print(i, j, dp[i][j])
if a == i and b == j:
continue
dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353
dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353
print(((dp0[c][d] + dp1[c][d]) % 998244353))
| 29 | 24 | 839 | 718 | # import numpy as np
import math
import collections
import bisect
def main():
a, b, c, d = list(map(int, input().split()))
dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]
dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]
for i in range(c + 1):
for j in range(d + 1):
if j < b or i < a:
dp0[i][j] = 0
dp1[i][j] = 0
for i in range(a, c + 1):
for j in range(b, d + 1):
# print(i, j, dp[i][j])
if a == i and b == j:
continue
dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353
dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353
print(((dp0[c][d] + dp1[c][d]) % 998244353))
if __name__ == "__main__":
main()
| # import numpy as np
import math
import collections
import bisect
a, b, c, d = list(map(int, input().split()))
dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]
dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]
for i in range(c + 1):
for j in range(d + 1):
if j < b or i < a:
dp0[i][j] = 0
dp1[i][j] = 0
for i in range(a, c + 1):
for j in range(b, d + 1):
# print(i, j, dp[i][j])
if a == i and b == j:
continue
dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353
dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353
print(((dp0[c][d] + dp1[c][d]) % 998244353))
| false | 17.241379 | [
"-",
"-def main():",
"- a, b, c, d = list(map(int, input().split()))",
"- dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]",
"- dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]",
"- for i in range(c + 1):",
"- for j in range(d + 1):",
"- if j < b or i < a:",
"- dp0[i][j] = 0",
"- dp1[i][j] = 0",
"- for i in range(a, c + 1):",
"- for j in range(b, d + 1):",
"- # print(i, j, dp[i][j])",
"- if a == i and b == j:",
"- continue",
"- dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353",
"- dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353",
"- print(((dp0[c][d] + dp1[c][d]) % 998244353))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+a, b, c, d = list(map(int, input().split()))",
"+dp0 = [[1 for i in range(d + 1)] for j in range(c + 1)]",
"+dp1 = [[0 for i in range(d + 1)] for j in range(c + 1)]",
"+for i in range(c + 1):",
"+ for j in range(d + 1):",
"+ if j < b or i < a:",
"+ dp0[i][j] = 0",
"+ dp1[i][j] = 0",
"+for i in range(a, c + 1):",
"+ for j in range(b, d + 1):",
"+ # print(i, j, dp[i][j])",
"+ if a == i and b == j:",
"+ continue",
"+ dp0[i][j] = ((i * dp0[i][j - 1]) % 998244353 + dp1[i][j - 1]) % 998244353",
"+ dp1[i][j] = (j * (dp0[i - 1][j] + dp1[i - 1][j]) % 998244353) % 998244353",
"+print(((dp0[c][d] + dp1[c][d]) % 998244353))"
] | false | 0.055886 | 0.058537 | 0.954713 | [
"s916861198",
"s390349467"
] |
u562935282 | p03043 | python | s923434419 | s361724768 | 172 | 40 | 39,152 | 2,940 | Accepted | Accepted | 76.74 | N, K = list(map(int, input().split()))
p = 0
for i in range(1, N + 1):
t = 1 / N
while i < K:
i *= 2
t *= 1 / 2
p += t
print(p)
| n, k = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
p = 1 / n
while i < k:
p /= 2
i *= 2
ans += p
print(ans)
| 10 | 10 | 160 | 162 | N, K = list(map(int, input().split()))
p = 0
for i in range(1, N + 1):
t = 1 / N
while i < K:
i *= 2
t *= 1 / 2
p += t
print(p)
| n, k = list(map(int, input().split()))
ans = 0
for i in range(1, n + 1):
p = 1 / n
while i < k:
p /= 2
i *= 2
ans += p
print(ans)
| false | 0 | [
"-N, K = list(map(int, input().split()))",
"-p = 0",
"-for i in range(1, N + 1):",
"- t = 1 / N",
"- while i < K:",
"+n, k = list(map(int, input().split()))",
"+ans = 0",
"+for i in range(1, n + 1):",
"+ p = 1 / n",
"+ while i < k:",
"+ p /= 2",
"- t *= 1 / 2",
"- p += t",
"-print(p)",
"+ ans += p",
"+print(ans)"
] | false | 0.06768 | 0.052108 | 1.298832 | [
"s923434419",
"s361724768"
] |
u476604182 | p03732 | python | s118490082 | s324788172 | 955 | 177 | 3,460 | 15,276 | Accepted | Accepted | 81.47 | N, W = list(map(int,input().split()))
ls = []
for i in range(N):
w, v = list(map(int, input().split()))
ls += [[w,v]]
w1 = ls[0][0]
for i in range(N):
ls[i][0] -= w1
ans = 0
M = 3*N
dp = [[-1]*(M+1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
w, v = ls[i]
for h in range(N,0,-1):
for j in range(M,-1,-1):
if j-w>=0 and dp[h-1][j-w]!=-1:
dp[h][j] = max(dp[h][j], dp[h-1][j-w]+v)
for i in range(1,N+1):
B = i*w1
m = 0
for j in range(M+1):
if B+j<=W:
m = max(m,dp[i][j])
if ans<m:
ans = m
print(ans)
| import numpy as np
N, W, *L = list(map(int, open(0).read().split()))
M = 3*(N-1)+1
dp = np.zeros((M,N+1),np.int64)
for w,v in zip(*[iter(L)]*2):
w -= L[0]
dp[w:,1:] = np.maximum(dp[w:,1:], dp[:M-w,:N]+v)
ans = 0
for i in range(N+1):
m = i*L[0]
if m>W:
continue
m = min(W-m,M-1)
ans = max(ans, dp[m,i])
print(ans) | 27 | 16 | 570 | 339 | N, W = list(map(int, input().split()))
ls = []
for i in range(N):
w, v = list(map(int, input().split()))
ls += [[w, v]]
w1 = ls[0][0]
for i in range(N):
ls[i][0] -= w1
ans = 0
M = 3 * N
dp = [[-1] * (M + 1) for i in range(N + 1)]
dp[0][0] = 0
for i in range(N):
w, v = ls[i]
for h in range(N, 0, -1):
for j in range(M, -1, -1):
if j - w >= 0 and dp[h - 1][j - w] != -1:
dp[h][j] = max(dp[h][j], dp[h - 1][j - w] + v)
for i in range(1, N + 1):
B = i * w1
m = 0
for j in range(M + 1):
if B + j <= W:
m = max(m, dp[i][j])
if ans < m:
ans = m
print(ans)
| import numpy as np
N, W, *L = list(map(int, open(0).read().split()))
M = 3 * (N - 1) + 1
dp = np.zeros((M, N + 1), np.int64)
for w, v in zip(*[iter(L)] * 2):
w -= L[0]
dp[w:, 1:] = np.maximum(dp[w:, 1:], dp[: M - w, :N] + v)
ans = 0
for i in range(N + 1):
m = i * L[0]
if m > W:
continue
m = min(W - m, M - 1)
ans = max(ans, dp[m, i])
print(ans)
| false | 40.740741 | [
"-N, W = list(map(int, input().split()))",
"-ls = []",
"-for i in range(N):",
"- w, v = list(map(int, input().split()))",
"- ls += [[w, v]]",
"-w1 = ls[0][0]",
"-for i in range(N):",
"- ls[i][0] -= w1",
"+import numpy as np",
"+",
"+N, W, *L = list(map(int, open(0).read().split()))",
"+M = 3 * (N - 1) + 1",
"+dp = np.zeros((M, N + 1), np.int64)",
"+for w, v in zip(*[iter(L)] * 2):",
"+ w -= L[0]",
"+ dp[w:, 1:] = np.maximum(dp[w:, 1:], dp[: M - w, :N] + v)",
"-M = 3 * N",
"-dp = [[-1] * (M + 1) for i in range(N + 1)]",
"-dp[0][0] = 0",
"-for i in range(N):",
"- w, v = ls[i]",
"- for h in range(N, 0, -1):",
"- for j in range(M, -1, -1):",
"- if j - w >= 0 and dp[h - 1][j - w] != -1:",
"- dp[h][j] = max(dp[h][j], dp[h - 1][j - w] + v)",
"-for i in range(1, N + 1):",
"- B = i * w1",
"- m = 0",
"- for j in range(M + 1):",
"- if B + j <= W:",
"- m = max(m, dp[i][j])",
"- if ans < m:",
"- ans = m",
"+for i in range(N + 1):",
"+ m = i * L[0]",
"+ if m > W:",
"+ continue",
"+ m = min(W - m, M - 1)",
"+ ans = max(ans, dp[m, i])"
] | false | 0.048268 | 0.23057 | 0.209342 | [
"s118490082",
"s324788172"
] |
u569272329 | p02779 | python | s802996065 | s547992079 | 104 | 91 | 25,172 | 35,788 | Accepted | Accepted | 12.5 | N = int(eval(input()))
A = list(map(int, input().split()))
ans = set()
for a in A:
ans.add(a)
if len(ans) == N:
print('YES')
else:
print('NO')
| N = int(eval(input()))
A = set(map(int, input().split()))
if len(A) == N:
print('YES')
else:
print('NO')
| 9 | 6 | 157 | 112 | N = int(eval(input()))
A = list(map(int, input().split()))
ans = set()
for a in A:
ans.add(a)
if len(ans) == N:
print("YES")
else:
print("NO")
| N = int(eval(input()))
A = set(map(int, input().split()))
if len(A) == N:
print("YES")
else:
print("NO")
| false | 33.333333 | [
"-A = list(map(int, input().split()))",
"-ans = set()",
"-for a in A:",
"- ans.add(a)",
"-if len(ans) == N:",
"+A = set(map(int, input().split()))",
"+if len(A) == N:"
] | false | 0.043773 | 0.038119 | 1.148316 | [
"s802996065",
"s547992079"
] |
u943057856 | p03161 | python | s956074840 | s958809805 | 1,907 | 1,680 | 22,860 | 20,548 | Accepted | Accepted | 11.9 | import numpy as np
n,k=list(map(int,input().split()))
h=np.array(list(map(int,input().split())))
dp=np.zeros(n,dtype="int32")
for i in range(1,n):
start=0 if k>i else i-k
dp[i]=np.min(dp[start:i]+np.abs(h[i]-h[start:i]))
print((dp[-1])) | n,k=list(map(int,input().split()))
h=list(map(int,input().split()))
dp=[10**8]*n
dp[0]=0
dp[1]=abs(h[1]-h[0])
for i in range(2,n):
dp[i]=min([dp[j]+abs(h[i]-h[j]) for j in range(max(0,i-k),i)])
print((dp[n-1])) | 8 | 8 | 243 | 213 | import numpy as np
n, k = list(map(int, input().split()))
h = np.array(list(map(int, input().split())))
dp = np.zeros(n, dtype="int32")
for i in range(1, n):
start = 0 if k > i else i - k
dp[i] = np.min(dp[start:i] + np.abs(h[i] - h[start:i]))
print((dp[-1]))
| n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
dp = [10**8] * n
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, n):
dp[i] = min([dp[j] + abs(h[i] - h[j]) for j in range(max(0, i - k), i)])
print((dp[n - 1]))
| false | 0 | [
"-import numpy as np",
"-",
"-h = np.array(list(map(int, input().split())))",
"-dp = np.zeros(n, dtype=\"int32\")",
"-for i in range(1, n):",
"- start = 0 if k > i else i - k",
"- dp[i] = np.min(dp[start:i] + np.abs(h[i] - h[start:i]))",
"-print((dp[-1]))",
"+h = list(map(int, input().split()))",
"+dp = [10**8] * n",
"+dp[0] = 0",
"+dp[1] = abs(h[1] - h[0])",
"+for i in range(2, n):",
"+ dp[i] = min([dp[j] + abs(h[i] - h[j]) for j in range(max(0, i - k), i)])",
"+print((dp[n - 1]))"
] | false | 0.93719 | 0.10437 | 8.979491 | [
"s956074840",
"s958809805"
] |
u533039576 | p03965 | python | s248813091 | s758743889 | 68 | 32 | 6,376 | 3,316 | Accepted | Accepted | 52.94 | s = eval(input())
x = 0
np = []
for i in reversed(list(range(len(s)))):
if s[i] == 'p':
x += 1
np.append(x)
np = list(reversed(np))
y = 0
ans = 0
for i in range(len(s)):
if s[i] == 'g':
if y > np[i]:
ans += 1
y -= 1
else:
y += 1
else:
y -= 1
# print(np)
print(ans)
| s = eval(input())
np = 0
for i in range(len(s)):
if s[i] == 'p':
np += 1
ans = len(s) // 2 - np
print(ans)
| 23 | 9 | 361 | 123 | s = eval(input())
x = 0
np = []
for i in reversed(list(range(len(s)))):
if s[i] == "p":
x += 1
np.append(x)
np = list(reversed(np))
y = 0
ans = 0
for i in range(len(s)):
if s[i] == "g":
if y > np[i]:
ans += 1
y -= 1
else:
y += 1
else:
y -= 1
# print(np)
print(ans)
| s = eval(input())
np = 0
for i in range(len(s)):
if s[i] == "p":
np += 1
ans = len(s) // 2 - np
print(ans)
| false | 60.869565 | [
"-x = 0",
"-np = []",
"-for i in reversed(list(range(len(s)))):",
"+np = 0",
"+for i in range(len(s)):",
"- x += 1",
"- np.append(x)",
"-np = list(reversed(np))",
"-y = 0",
"-ans = 0",
"-for i in range(len(s)):",
"- if s[i] == \"g\":",
"- if y > np[i]:",
"- ans += 1",
"- y -= 1",
"- else:",
"- y += 1",
"- else:",
"- y -= 1",
"-# print(np)",
"+ np += 1",
"+ans = len(s) // 2 - np"
] | false | 0.038929 | 0.03238 | 1.20223 | [
"s248813091",
"s758743889"
] |
u588341295 | p03732 | python | s682996153 | s959606462 | 534 | 297 | 3,064 | 3,316 | Accepted | Accepted | 44.38 | # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc073/editorial.pdf
https://ei1333.hateblo.jp/entry/2017/05/01/004235
https://atcoder.jp/contests/abc060/submissions/3782609
・公式解
・とりあえず累積和なしでやってみる。
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
N, W = list(map(int, input().split()))
wN = [0] * N
vN = [[] for i in range(4)]
for i in range(N):
w, v = list(map(int, input().split()))
if i == 0:
offset = w
vN[w-offset].append(v)
# 重さ毎のリストを降順ソート
for i in range(4):
# 空リストのままだとこの後ループを回ってくれないので、[0]を追加する
vN[i] = [0] + sorted(vN[i], reverse=True)
ans = 0
for i in range(len(vN[0])):
for j in range(len(vN[1])):
for k in range(len(vN[2])):
for l in range(len(vN[3])):
# 重さリミットを超えるパターンは対象外
if offset * i + (offset+1) * j + (offset+2) * k + (offset+3) * l > W:
continue
ans = max(sum(vN[0][:i+1]) + sum(vN[1][:j+1]) + sum(vN[2][:k+1])+ sum(vN[3][:l+1]), ans)
print(ans)
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc073/editorial.pdf
https://ei1333.hateblo.jp/entry/2017/05/01/004235
https://atcoder.jp/contests/abc060/submissions/3782609
・公式解
・累積和あり
"""
import sys
def input(): return sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 9)
from collections import defaultdict
N, W = list(map(int, input().split()))
wN = [0] * N
vN = [[] for i in range(4)]
for i in range(N):
w, v = list(map(int, input().split()))
if i == 0:
offset = w
vN[w-offset].append(v)
# 重さ毎のリストを降順ソート
for i in range(4):
# 空リストのままだとこの後ループを回ってくれないので、[0]を追加する
vN[i] = [0] + sorted(vN[i], reverse=True)
# 累積和
for i in range(4):
for j in range(1, len(vN[i])):
vN[i][j] = vN[i][j-1] + vN[i][j]
ans = 0
for i in range(len(vN[0])):
for j in range(len(vN[1])):
for k in range(len(vN[2])):
for l in range(len(vN[3])):
# 重さリミットを超えるパターンは対象外
if offset * i + (offset+1) * j + (offset+2) * k + (offset+3) * l > W:
continue
ans = max(vN[0][i] + vN[1][j] + vN[2][k] + vN[3][l], ans)
print(ans)
| 38 | 45 | 1,072 | 1,175 | # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc073/editorial.pdf
https://ei1333.hateblo.jp/entry/2017/05/01/004235
https://atcoder.jp/contests/abc060/submissions/3782609
・公式解
・とりあえず累積和なしでやってみる。
"""
import sys
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(10**9)
N, W = list(map(int, input().split()))
wN = [0] * N
vN = [[] for i in range(4)]
for i in range(N):
w, v = list(map(int, input().split()))
if i == 0:
offset = w
vN[w - offset].append(v)
# 重さ毎のリストを降順ソート
for i in range(4):
# 空リストのままだとこの後ループを回ってくれないので、[0]を追加する
vN[i] = [0] + sorted(vN[i], reverse=True)
ans = 0
for i in range(len(vN[0])):
for j in range(len(vN[1])):
for k in range(len(vN[2])):
for l in range(len(vN[3])):
# 重さリミットを超えるパターンは対象外
if (
offset * i + (offset + 1) * j + (offset + 2) * k + (offset + 3) * l
> W
):
continue
ans = max(
sum(vN[0][: i + 1])
+ sum(vN[1][: j + 1])
+ sum(vN[2][: k + 1])
+ sum(vN[3][: l + 1]),
ans,
)
print(ans)
| # -*- coding: utf-8 -*-
"""
参考：https://img.atcoder.jp/arc073/editorial.pdf
https://ei1333.hateblo.jp/entry/2017/05/01/004235
https://atcoder.jp/contests/abc060/submissions/3782609
・公式解
・累積和あり
"""
import sys
def input():
return sys.stdin.readline().strip()
sys.setrecursionlimit(10**9)
from collections import defaultdict
N, W = list(map(int, input().split()))
wN = [0] * N
vN = [[] for i in range(4)]
for i in range(N):
w, v = list(map(int, input().split()))
if i == 0:
offset = w
vN[w - offset].append(v)
# 重さ毎のリストを降順ソート
for i in range(4):
# 空リストのままだとこの後ループを回ってくれないので、[0]を追加する
vN[i] = [0] + sorted(vN[i], reverse=True)
# 累積和
for i in range(4):
for j in range(1, len(vN[i])):
vN[i][j] = vN[i][j - 1] + vN[i][j]
ans = 0
for i in range(len(vN[0])):
for j in range(len(vN[1])):
for k in range(len(vN[2])):
for l in range(len(vN[3])):
# 重さリミットを超えるパターンは対象外
if (
offset * i + (offset + 1) * j + (offset + 2) * k + (offset + 3) * l
> W
):
continue
ans = max(vN[0][i] + vN[1][j] + vN[2][k] + vN[3][l], ans)
print(ans)
| false | 15.555556 | [
"-・とりあえず累積和なしでやってみる。",
"+・累積和あり",
"+from collections import defaultdict",
"+",
"+# 累積和",
"+for i in range(4):",
"+ for j in range(1, len(vN[i])):",
"+ vN[i][j] = vN[i][j - 1] + vN[i][j]",
"- ans = max(",
"- sum(vN[0][: i + 1])",
"- + sum(vN[1][: j + 1])",
"- + sum(vN[2][: k + 1])",
"- + sum(vN[3][: l + 1]),",
"- ans,",
"- )",
"+ ans = max(vN[0][i] + vN[1][j] + vN[2][k] + vN[3][l], ans)"
] | false | 0.048187 | 0.171368 | 0.281192 | [
"s682996153",
"s959606462"
] |
u021019433 | p02873 | python | s365578969 | s621084120 | 264 | 239 | 4,468 | 4,468 | Accepted | Accepted | 9.47 | from itertools import groupby
s = eval(input())
if s[-1] == '<':
s += '>'
r = p = 0
for k, g in groupby(s):
s = sum(1 for _ in g)
if k == '>':
r += (p * p + s * s - p - s) // 2 + max(p, s)
p = s
print(r)
| from itertools import groupby
r = p = 0
for k, g in groupby(eval(input())):
for i, _ in enumerate(g, 1):
r += i
if k == '>':
r -= min(i, p)
p = i
print(r)
| 12 | 10 | 236 | 187 | from itertools import groupby
s = eval(input())
if s[-1] == "<":
s += ">"
r = p = 0
for k, g in groupby(s):
s = sum(1 for _ in g)
if k == ">":
r += (p * p + s * s - p - s) // 2 + max(p, s)
p = s
print(r)
| from itertools import groupby
r = p = 0
for k, g in groupby(eval(input())):
for i, _ in enumerate(g, 1):
r += i
if k == ">":
r -= min(i, p)
p = i
print(r)
| false | 16.666667 | [
"-s = eval(input())",
"-if s[-1] == \"<\":",
"- s += \">\"",
"-for k, g in groupby(s):",
"- s = sum(1 for _ in g)",
"+for k, g in groupby(eval(input())):",
"+ for i, _ in enumerate(g, 1):",
"+ r += i",
"- r += (p * p + s * s - p - s) // 2 + max(p, s)",
"- p = s",
"+ r -= min(i, p)",
"+ p = i"
] | false | 0.085458 | 0.046256 | 1.84749 | [
"s365578969",
"s621084120"
] |
u893962649 | p02682 | python | s310393987 | s884375706 | 31 | 28 | 9,036 | 9,156 | Accepted | Accepted | 9.68 | A,B,C,K = list(map(int, input().split()))
ans=0
if K <= A:
ans=K
elif K <= A + B :
ans=A
else:
ans= A - (K - A - B)
print(ans) | A,B,C,K = list(map(int, input().split()))
if K <= A:print(K)
elif K <= A + B :print(A)
else:print((A*2 + B - K)) | 14 | 5 | 146 | 109 | A, B, C, K = list(map(int, input().split()))
ans = 0
if K <= A:
ans = K
elif K <= A + B:
ans = A
else:
ans = A - (K - A - B)
print(ans)
| A, B, C, K = list(map(int, input().split()))
if K <= A:
print(K)
elif K <= A + B:
print(A)
else:
print((A * 2 + B - K))
| false | 64.285714 | [
"-ans = 0",
"- ans = K",
"+ print(K)",
"- ans = A",
"+ print(A)",
"- ans = A - (K - A - B)",
"-print(ans)",
"+ print((A * 2 + B - K))"
] | false | 0.066688 | 0.098021 | 0.680351 | [
"s310393987",
"s884375706"
] |
u484052148 | p02741 | python | s117100341 | s466367418 | 181 | 17 | 38,256 | 3,060 | Accepted | Accepted | 90.61 | k = int(eval(input()))
s = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
l = s.split(",")
print((int(l[k-1]))) | a = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print((a[int(eval(input()))-1])) | 4 | 2 | 161 | 129 | k = int(eval(input()))
s = "1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51"
l = s.split(",")
print((int(l[k - 1])))
| a = [
1,
1,
1,
2,
1,
2,
1,
5,
2,
2,
1,
5,
1,
2,
1,
14,
1,
5,
1,
5,
2,
2,
1,
15,
2,
2,
5,
4,
1,
4,
1,
51,
]
print((a[int(eval(input())) - 1]))
| false | 50 | [
"-k = int(eval(input()))",
"-s = \"1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51\"",
"-l = s.split(\",\")",
"-print((int(l[k - 1])))",
"+a = [",
"+ 1,",
"+ 1,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 5,",
"+ 2,",
"+ 2,",
"+ 1,",
"+ 5,",
"+ 1,",
"+ 2,",
"+ 1,",
"+ 14,",
"+ 1,",
"+ 5,",
"+ 1,",
"+ 5,",
"+ 2,",
"+ 2,",
"+ 1,",
"+ 15,",
"+ 2,",
"+ 2,",
"+ 5,",
"+ 4,",
"+ 1,",
"+ 4,",
"+ 1,",
"+ 51,",
"+]",
"+print((a[int(eval(input())) - 1]))"
] | false | 0.040977 | 0.036004 | 1.138136 | [
"s117100341",
"s466367418"
] |
u620084012 | p03240 | python | s772658056 | s676286340 | 1,751 | 76 | 46,576 | 73,644 | Accepted | Accepted | 95.66 | N = int(eval(input()))
P = [list(map(int,input().split())) for k in range(N)]
for h in range(P[0][2],P[0][2]+201):
for x in range(101):
for y in range(101):
f = 1
for e in P:
if e[2] != max(0,h-abs(e[0]-x)-abs(e[1]-y)):
f = 0
break
if f == 1:
print((x,y,h))
exit(0)
| import sys
MOD = 10**9 + 7
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def input():
return sys.stdin.readline()[:-1]
def main():
n = int(eval(input()))
p = [list(map(int,input().split())) for _ in range(n)]
p = sorted(p,key=lambda x: -x[2])
for x in range(0,101):
for y in range(0,101):
h = p[0][2] + abs(x-p[0][0]) + abs(y-p[0][1])
flag = 1
for (a,b,c) in p:
if c != max(0,h-abs(x-a)-abs(y-b)):
flag = 0
break
if flag == 1:
print((x,y,h))
exit(0)
if __name__ == '__main__':
main()
| 14 | 24 | 408 | 700 | N = int(eval(input()))
P = [list(map(int, input().split())) for k in range(N)]
for h in range(P[0][2], P[0][2] + 201):
for x in range(101):
for y in range(101):
f = 1
for e in P:
if e[2] != max(0, h - abs(e[0] - x) - abs(e[1] - y)):
f = 0
break
if f == 1:
print((x, y, h))
exit(0)
| import sys
MOD = 10**9 + 7
# import io, os
# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline
def input():
return sys.stdin.readline()[:-1]
def main():
n = int(eval(input()))
p = [list(map(int, input().split())) for _ in range(n)]
p = sorted(p, key=lambda x: -x[2])
for x in range(0, 101):
for y in range(0, 101):
h = p[0][2] + abs(x - p[0][0]) + abs(y - p[0][1])
flag = 1
for (a, b, c) in p:
if c != max(0, h - abs(x - a) - abs(y - b)):
flag = 0
break
if flag == 1:
print((x, y, h))
exit(0)
if __name__ == "__main__":
main()
| false | 41.666667 | [
"-N = int(eval(input()))",
"-P = [list(map(int, input().split())) for k in range(N)]",
"-for h in range(P[0][2], P[0][2] + 201):",
"- for x in range(101):",
"- for y in range(101):",
"- f = 1",
"- for e in P:",
"- if e[2] != max(0, h - abs(e[0] - x) - abs(e[1] - y)):",
"- f = 0",
"+import sys",
"+",
"+MOD = 10**9 + 7",
"+# import io, os",
"+# input = io.BytesIO(os.read(0,os.fstat(0).st_size)).readline",
"+def input():",
"+ return sys.stdin.readline()[:-1]",
"+",
"+",
"+def main():",
"+ n = int(eval(input()))",
"+ p = [list(map(int, input().split())) for _ in range(n)]",
"+ p = sorted(p, key=lambda x: -x[2])",
"+ for x in range(0, 101):",
"+ for y in range(0, 101):",
"+ h = p[0][2] + abs(x - p[0][0]) + abs(y - p[0][1])",
"+ flag = 1",
"+ for (a, b, c) in p:",
"+ if c != max(0, h - abs(x - a) - abs(y - b)):",
"+ flag = 0",
"- if f == 1:",
"+ if flag == 1:",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.245944 | 0.040196 | 6.118614 | [
"s772658056",
"s676286340"
] |
u089230684 | p02924 | python | s529635339 | s027000969 | 177 | 19 | 38,256 | 2,940 | Accepted | Accepted | 89.27 | '''Haha this is python? How could you tell, Sherlock?'''
n = int(eval(input()))
print(((n * (n - 1)) // 2)) | n=int(eval(input()))
suu=n*(n-1)//2
print(suu)
w=[1,2,3,4] | 4 | 4 | 103 | 55 | """Haha this is python? How could you tell, Sherlock?"""
n = int(eval(input()))
print(((n * (n - 1)) // 2))
| n = int(eval(input()))
suu = n * (n - 1) // 2
print(suu)
w = [1, 2, 3, 4]
| false | 0 | [
"-\"\"\"Haha this is python? How could you tell, Sherlock?\"\"\"",
"-print(((n * (n - 1)) // 2))",
"+suu = n * (n - 1) // 2",
"+print(suu)",
"+w = [1, 2, 3, 4]"
] | false | 0.109246 | 0.045652 | 2.393027 | [
"s529635339",
"s027000969"
] |
u498487134 | p02923 | python | s531673674 | s745072757 | 217 | 89 | 63,856 | 86,160 | Accepted | Accepted | 58.99 | N=int(eval(input()))
H=list(map(int,input().split()))
ans=0
temp=0
for i in range(N-1):
if H[i+1]<=H[i]:
temp+=1
ans=max(ans,temp)
else:
temp=0
print(ans) | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
N=I()
a=LI()+[10**10]
ans=0
now=-1
cnt=0
for i in range(N+1):
if a[i]>now:
ans=max(ans,cnt)
cnt=0
else:
cnt+=1
now=a[i]
print(ans)
main()
| 12 | 26 | 192 | 459 | N = int(eval(input()))
H = list(map(int, input().split()))
ans = 0
temp = 0
for i in range(N - 1):
if H[i + 1] <= H[i]:
temp += 1
ans = max(ans, temp)
else:
temp = 0
print(ans)
| import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
mod = 10**9 + 7
N = I()
a = LI() + [10**10]
ans = 0
now = -1
cnt = 0
for i in range(N + 1):
if a[i] > now:
ans = max(ans, cnt)
cnt = 0
else:
cnt += 1
now = a[i]
print(ans)
main()
| false | 53.846154 | [
"-N = int(eval(input()))",
"-H = list(map(int, input().split()))",
"-ans = 0",
"-temp = 0",
"-for i in range(N - 1):",
"- if H[i + 1] <= H[i]:",
"- temp += 1",
"- ans = max(ans, temp)",
"- else:",
"- temp = 0",
"-print(ans)",
"+import sys",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def I():",
"+ return int(eval(input()))",
"+",
"+",
"+def MI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LI():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def main():",
"+ mod = 10**9 + 7",
"+ N = I()",
"+ a = LI() + [10**10]",
"+ ans = 0",
"+ now = -1",
"+ cnt = 0",
"+ for i in range(N + 1):",
"+ if a[i] > now:",
"+ ans = max(ans, cnt)",
"+ cnt = 0",
"+ else:",
"+ cnt += 1",
"+ now = a[i]",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.03555 | 0.03404 | 1.044352 | [
"s531673674",
"s745072757"
] |
u576917603 | p03612 | python | s550594545 | s080051141 | 92 | 73 | 14,004 | 14,008 | Accepted | Accepted | 20.65 | n=int(eval(input()))
a=list([int(x)-1 for x in input().split()])
cnt=0
lis=set()
for i in range(n-1):
if i in lis:
continue
if a[i]==i and a[i+1]==i+1:
cnt+=1
lis.add(i+1)
elif a[i]==i:
cnt+=1
if n-1 not in lis and a[n-1]==n-1:
cnt+=1
print(cnt) | n=int(eval(input()))
a=list(map(int,input().split()))
ans=0
for i in range(n):
if i+1==a[i]:
ans+=1
if i!=n-1:
a[i+1]=a[i]
print(ans) | 16 | 9 | 306 | 167 | n = int(eval(input()))
a = list([int(x) - 1 for x in input().split()])
cnt = 0
lis = set()
for i in range(n - 1):
if i in lis:
continue
if a[i] == i and a[i + 1] == i + 1:
cnt += 1
lis.add(i + 1)
elif a[i] == i:
cnt += 1
if n - 1 not in lis and a[n - 1] == n - 1:
cnt += 1
print(cnt)
| n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
if i + 1 == a[i]:
ans += 1
if i != n - 1:
a[i + 1] = a[i]
print(ans)
| false | 43.75 | [
"-a = list([int(x) - 1 for x in input().split()])",
"-cnt = 0",
"-lis = set()",
"-for i in range(n - 1):",
"- if i in lis:",
"- continue",
"- if a[i] == i and a[i + 1] == i + 1:",
"- cnt += 1",
"- lis.add(i + 1)",
"- elif a[i] == i:",
"- cnt += 1",
"-if n - 1 not in lis and a[n - 1] == n - 1:",
"- cnt += 1",
"-print(cnt)",
"+a = list(map(int, input().split()))",
"+ans = 0",
"+for i in range(n):",
"+ if i + 1 == a[i]:",
"+ ans += 1",
"+ if i != n - 1:",
"+ a[i + 1] = a[i]",
"+print(ans)"
] | false | 0.039046 | 0.035922 | 1.086969 | [
"s550594545",
"s080051141"
] |
u631277801 | p03722 | python | s061926926 | s389582832 | 1,544 | 344 | 3,316 | 58,864 | Accepted | Accepted | 77.72 | import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
n,m = li()
# graph
adj_list = [[] for _ in range(n)]
for _ in range(m):
a,b,c = li()
a -= 1
b -= 1
adj_list[a].append((c,b))
# bellman-ford
INF = -10**15
dist = [INF]*n
dist[0] = 0
for j in range(n+1):
for i in range(n):
updated = False
for cost, nex in adj_list[i]:
bef = dist[nex]
dist[nex] = max(dist[nex], dist[i]+cost)
if bef != dist[nex]:
updated = True
if j == n-1:
dis_j1 = dist[n-1]
if j == n:
dis_j = dist[n-1]
if dis_j1 != dis_j:
print("inf")
else:
print(dis_j) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n,m = li()
# 隣接リストを作成(key:b, val:a)
edges = []
for _ in range(m):
ai, bi, ci = li()
ai -= 1
bi -= 1
edges.append((ai, bi, ci))
# ベルマンフォード
dist = [[-10**18]*n for _ in range(2*n+3)]
for i in range(2*n+2):
dist[i][0] = 0
ans = -10**18
chk = -10**18
for i in range(2*n+2):
for ai, bi, ci in edges:
dist[i+1][bi] = max(dist[i+1][bi],
dist[i][bi],
dist[i][ai] + ci)
if i == n:
ans = dist[i][n-1]
elif i == 2*n+1:
chk = dist[i][n-1]
print((ans if ans >= chk else "inf")) | 46 | 44 | 1,052 | 1,070 | import sys
stdin = sys.stdin
def li():
return [int(x) for x in stdin.readline().split()]
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return [float(x) for x in stdin.readline().split()]
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(ns())
def nf():
return float(ns())
n, m = li()
# graph
adj_list = [[] for _ in range(n)]
for _ in range(m):
a, b, c = li()
a -= 1
b -= 1
adj_list[a].append((c, b))
# bellman-ford
INF = -(10**15)
dist = [INF] * n
dist[0] = 0
for j in range(n + 1):
for i in range(n):
updated = False
for cost, nex in adj_list[i]:
bef = dist[nex]
dist[nex] = max(dist[nex], dist[i] + cost)
if bef != dist[nex]:
updated = True
if j == n - 1:
dis_j1 = dist[n - 1]
if j == n:
dis_j = dist[n - 1]
if dis_j1 != dis_j:
print("inf")
else:
print(dis_j)
| import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
n, m = li()
# 隣接リストを作成(key:b, val:a)
edges = []
for _ in range(m):
ai, bi, ci = li()
ai -= 1
bi -= 1
edges.append((ai, bi, ci))
# ベルマンフォード
dist = [[-(10**18)] * n for _ in range(2 * n + 3)]
for i in range(2 * n + 2):
dist[i][0] = 0
ans = -(10**18)
chk = -(10**18)
for i in range(2 * n + 2):
for ai, bi, ci in edges:
dist[i + 1][bi] = max(dist[i + 1][bi], dist[i][bi], dist[i][ai] + ci)
if i == n:
ans = dist[i][n - 1]
elif i == 2 * n + 1:
chk = dist[i][n - 1]
print((ans if ans >= chk else "inf"))
| false | 4.347826 | [
"+sys.setrecursionlimit(10**5)",
"- return [int(x) for x in stdin.readline().split()]",
"+ return list(map(int, stdin.readline().split()))",
"- return [float(x) for x in stdin.readline().split()]",
"+ return list(map(float, stdin.readline().split()))",
"- return int(ns())",
"+ return int(stdin.readline())",
"- return float(ns())",
"+ return float(stdin.readline())",
"-# graph",
"-adj_list = [[] for _ in range(n)]",
"+# 隣接リストを作成(key:b, val:a)",
"+edges = []",
"- a, b, c = li()",
"- a -= 1",
"- b -= 1",
"- adj_list[a].append((c, b))",
"-# bellman-ford",
"-INF = -(10**15)",
"-dist = [INF] * n",
"-dist[0] = 0",
"-for j in range(n + 1):",
"- for i in range(n):",
"- updated = False",
"- for cost, nex in adj_list[i]:",
"- bef = dist[nex]",
"- dist[nex] = max(dist[nex], dist[i] + cost)",
"- if bef != dist[nex]:",
"- updated = True",
"- if j == n - 1:",
"- dis_j1 = dist[n - 1]",
"- if j == n:",
"- dis_j = dist[n - 1]",
"-if dis_j1 != dis_j:",
"- print(\"inf\")",
"-else:",
"- print(dis_j)",
"+ ai, bi, ci = li()",
"+ ai -= 1",
"+ bi -= 1",
"+ edges.append((ai, bi, ci))",
"+# ベルマンフォード",
"+dist = [[-(10**18)] * n for _ in range(2 * n + 3)]",
"+for i in range(2 * n + 2):",
"+ dist[i][0] = 0",
"+ans = -(10**18)",
"+chk = -(10**18)",
"+for i in range(2 * n + 2):",
"+ for ai, bi, ci in edges:",
"+ dist[i + 1][bi] = max(dist[i + 1][bi], dist[i][bi], dist[i][ai] + ci)",
"+ if i == n:",
"+ ans = dist[i][n - 1]",
"+ elif i == 2 * n + 1:",
"+ chk = dist[i][n - 1]",
"+print((ans if ans >= chk else \"inf\"))"
] | false | 0.086762 | 0.059234 | 1.46472 | [
"s061926926",
"s389582832"
] |
u607155447 | p02756 | python | s987452399 | s471368632 | 1,985 | 101 | 9,904 | 9,852 | Accepted | Accepted | 94.91 | import sys
S = eval(input())
Q = int(eval(input()))
key = 1
for i in sys.stdin:
if i[0] == '0':
break
if i[0] == '1':
key = -key
elif key == 1:
if i[2] == '1':
S = i[4] + S
else:
S = S + i[4]
else:
if i[2] == '2':
S = i[4] + S
else:
S = S + i[4]
print((S[::key])) | import sys
S = eval(input())
A = ''
eval(input())
key = 1
for i in sys.stdin:
if i[0] == '0':
break
if i[0] == '1':
key = -key
elif key == 1:
if i[2] == '1':
A = A + i[4]
else:
S = S + i[4]
else:
if i[2] == '2':
A = A + i[4]
else:
S = S + i[4]
ans = A[::-1] + S
print((ans[::key]))
| 26 | 27 | 396 | 415 | import sys
S = eval(input())
Q = int(eval(input()))
key = 1
for i in sys.stdin:
if i[0] == "0":
break
if i[0] == "1":
key = -key
elif key == 1:
if i[2] == "1":
S = i[4] + S
else:
S = S + i[4]
else:
if i[2] == "2":
S = i[4] + S
else:
S = S + i[4]
print((S[::key]))
| import sys
S = eval(input())
A = ""
eval(input())
key = 1
for i in sys.stdin:
if i[0] == "0":
break
if i[0] == "1":
key = -key
elif key == 1:
if i[2] == "1":
A = A + i[4]
else:
S = S + i[4]
else:
if i[2] == "2":
A = A + i[4]
else:
S = S + i[4]
ans = A[::-1] + S
print((ans[::key]))
| false | 3.703704 | [
"-Q = int(eval(input()))",
"+A = \"\"",
"+eval(input())",
"- S = i[4] + S",
"+ A = A + i[4]",
"- S = i[4] + S",
"+ A = A + i[4]",
"-print((S[::key]))",
"+ans = A[::-1] + S",
"+print((ans[::key]))"
] | false | 0.041561 | 0.037112 | 1.119862 | [
"s987452399",
"s471368632"
] |
u296518383 | p03673 | python | s665883337 | s086698224 | 582 | 227 | 123,348 | 25,412 | Accepted | Accepted | 61 | N = int(eval(input()))
A = list(map(int, input().split()))
tmp = []
index = 0
for i in range(N):
tmp.append([index, A[i]])
if N % 2:
if index <= 0:
index = - index + 1
else:
index *= -1
else:
if index >= 0:
index = - index - 1
else:
index *= -1
tmp.sort()
#print("tmp:", tmp)
answer = []
for i in range(N):
answer.append(tmp[i][1])
print((*answer)) | from collections import deque
N = int(eval(input()))
A = list(map(int, input().split()))
answer = deque([])
for i, a in enumerate(A):
if i % 2 == 0:
answer.appendleft(a)
else:
answer.append(a)
answer = list(answer)
answer = answer if N % 2 else answer[::-1]
print((*answer)) | 26 | 16 | 417 | 301 | N = int(eval(input()))
A = list(map(int, input().split()))
tmp = []
index = 0
for i in range(N):
tmp.append([index, A[i]])
if N % 2:
if index <= 0:
index = -index + 1
else:
index *= -1
else:
if index >= 0:
index = -index - 1
else:
index *= -1
tmp.sort()
# print("tmp:", tmp)
answer = []
for i in range(N):
answer.append(tmp[i][1])
print((*answer))
| from collections import deque
N = int(eval(input()))
A = list(map(int, input().split()))
answer = deque([])
for i, a in enumerate(A):
if i % 2 == 0:
answer.appendleft(a)
else:
answer.append(a)
answer = list(answer)
answer = answer if N % 2 else answer[::-1]
print((*answer))
| false | 38.461538 | [
"+from collections import deque",
"+",
"-tmp = []",
"-index = 0",
"-for i in range(N):",
"- tmp.append([index, A[i]])",
"- if N % 2:",
"- if index <= 0:",
"- index = -index + 1",
"- else:",
"- index *= -1",
"+answer = deque([])",
"+for i, a in enumerate(A):",
"+ if i % 2 == 0:",
"+ answer.appendleft(a)",
"- if index >= 0:",
"- index = -index - 1",
"- else:",
"- index *= -1",
"-tmp.sort()",
"-# print(\"tmp:\", tmp)",
"-answer = []",
"-for i in range(N):",
"- answer.append(tmp[i][1])",
"+ answer.append(a)",
"+answer = list(answer)",
"+answer = answer if N % 2 else answer[::-1]"
] | false | 0.041796 | 0.041805 | 0.999774 | [
"s665883337",
"s086698224"
] |
u491550356 | p02678 | python | s829870909 | s282684092 | 1,060 | 788 | 65,512 | 64,900 | Accepted | Accepted | 25.66 | N, M = map(int, input().split())
AB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for a, b in AB:
es[a-1].append(b-1)
es[b-1].append(a-1)
ans = [-1] * N
ans[0] = 0
import queue
que = queue.Queue()
que.put(0)
while que.qsize():
s = que.get()
for v in es[s]:
if ans[v] == -1:
ans[v] = s+1
que.put(v)
print("Yes")
print(*ans[1:], sep="\n")
| N, M = map(int, input().split())
AB = [tuple(map(int,input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for a, b in AB:
es[a-1].append(b-1)
es[b-1].append(a-1)
ans = [-1] * N
ans[0] = 0
from collections import deque
que = deque([0])
while que:
s = que.popleft()
for v in es[s]:
if ans[v] == -1:
ans[v] = s+1
que.append(v)
print("Yes")
print(*ans[1:], sep="\n")
| 25 | 24 | 450 | 451 | N, M = map(int, input().split())
AB = [tuple(map(int, input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for a, b in AB:
es[a - 1].append(b - 1)
es[b - 1].append(a - 1)
ans = [-1] * N
ans[0] = 0
import queue
que = queue.Queue()
que.put(0)
while que.qsize():
s = que.get()
for v in es[s]:
if ans[v] == -1:
ans[v] = s + 1
que.put(v)
print("Yes")
print(*ans[1:], sep="\n")
| N, M = map(int, input().split())
AB = [tuple(map(int, input().split())) for i in range(M)]
es = [[] for _ in range(N)]
for a, b in AB:
es[a - 1].append(b - 1)
es[b - 1].append(a - 1)
ans = [-1] * N
ans[0] = 0
from collections import deque
que = deque([0])
while que:
s = que.popleft()
for v in es[s]:
if ans[v] == -1:
ans[v] = s + 1
que.append(v)
print("Yes")
print(*ans[1:], sep="\n")
| false | 4 | [
"-import queue",
"+from collections import deque",
"-que = queue.Queue()",
"-que.put(0)",
"-while que.qsize():",
"- s = que.get()",
"+que = deque([0])",
"+while que:",
"+ s = que.popleft()",
"- que.put(v)",
"+ que.append(v)"
] | false | 0.043066 | 0.041047 | 1.049188 | [
"s829870909",
"s282684092"
] |
u238940874 | p03775 | python | s466047198 | s650565686 | 35 | 30 | 3,060 | 3,060 | Accepted | Accepted | 14.29 | n=int(eval(input()))
ans=float('inf')
for i in range(1,int(n**0.5)+1):
if n%i ==0:
x=len(str(i))
y=len(str(n//i))
z=max(x,y)
if ans > z:
ans=z
print(ans) | n=int(eval(input()))
ans=float('inf')
for i in range(1,int(n**0.5)+1):
if n%i == 0:
x=len(str(i))
y=len(str(n//i))
z=max(x,y)
ans=min(z,ans)
print(ans)
| 10 | 9 | 196 | 190 | n = int(eval(input()))
ans = float("inf")
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
x = len(str(i))
y = len(str(n // i))
z = max(x, y)
if ans > z:
ans = z
print(ans)
| n = int(eval(input()))
ans = float("inf")
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
x = len(str(i))
y = len(str(n // i))
z = max(x, y)
ans = min(z, ans)
print(ans)
| false | 10 | [
"- if ans > z:",
"- ans = z",
"+ ans = min(z, ans)"
] | false | 0.084962 | 0.081259 | 1.045571 | [
"s466047198",
"s650565686"
] |
u600402037 | p02949 | python | s291924638 | s708419361 | 1,687 | 760 | 47,964 | 41,968 | Accepted | Accepted | 54.95 | import sys
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M, P = lr()
graph = [lr() for _ in range(M)]
def bellmanford(s, g):
INF = 10**19
dist = [INF] * (N+1)
dist[s] = 0
for i in range(2 * N):
for a, b, c in graph:
if dist[a] != INF and dist[b] > dist[a] - c + P:
dist[b] = dist[a] - c + P
if i >= N:
dist[b] = -float("inf")
if dist[g] == -float("inf"):
return -1
else:
return max(-dist[g], 0)
answer = bellmanford(1, N)
print(answer)
#
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M, P = lr()
# 終了時、T*P枚支払う
graph = []
for _ in range(M):
a, b, c = lr()
graph.append((a, b, c))
def bellmanford(N, start):
INF = 10 ** 12
dist = [-INF] * (N+1) # 1-indexed
dist[start] = 0
for i in range(N+N+5):
for (pre, ne, weight) in graph:
if dist[pre] != -INF and dist[pre] + weight - P > dist[ne]:
dist[ne] = dist[pre] + weight - P
# n回繰り返してもスコアが更新された場合
if i > N-1:
dist[ne] = INF
if dist[N] == INF:
return -1
else:
return max(0, dist[N])
answer = bellmanford(N, 1)
print(answer)
| 29 | 31 | 681 | 776 | import sys
sys.setrecursionlimit(10**9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M, P = lr()
graph = [lr() for _ in range(M)]
def bellmanford(s, g):
INF = 10**19
dist = [INF] * (N + 1)
dist[s] = 0
for i in range(2 * N):
for a, b, c in graph:
if dist[a] != INF and dist[b] > dist[a] - c + P:
dist[b] = dist[a] - c + P
if i >= N:
dist[b] = -float("inf")
if dist[g] == -float("inf"):
return -1
else:
return max(-dist[g], 0)
answer = bellmanford(1, N)
print(answer)
#
| import sys
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N, M, P = lr()
# 終了時、T*P枚支払う
graph = []
for _ in range(M):
a, b, c = lr()
graph.append((a, b, c))
def bellmanford(N, start):
INF = 10**12
dist = [-INF] * (N + 1) # 1-indexed
dist[start] = 0
for i in range(N + N + 5):
for (pre, ne, weight) in graph:
if dist[pre] != -INF and dist[pre] + weight - P > dist[ne]:
dist[ne] = dist[pre] + weight - P
# n回繰り返してもスコアが更新された場合
if i > N - 1:
dist[ne] = INF
if dist[N] == INF:
return -1
else:
return max(0, dist[N])
answer = bellmanford(N, 1)
print(answer)
| false | 6.451613 | [
"-sys.setrecursionlimit(10**9)",
"-graph = [lr() for _ in range(M)]",
"+# 終了時、T*P枚支払う",
"+graph = []",
"+for _ in range(M):",
"+ a, b, c = lr()",
"+ graph.append((a, b, c))",
"-def bellmanford(s, g):",
"- INF = 10**19",
"- dist = [INF] * (N + 1)",
"- dist[s] = 0",
"- for i in range(2 * N):",
"- for a, b, c in graph:",
"- if dist[a] != INF and dist[b] > dist[a] - c + P:",
"- dist[b] = dist[a] - c + P",
"- if i >= N:",
"- dist[b] = -float(\"inf\")",
"- if dist[g] == -float(\"inf\"):",
"+def bellmanford(N, start):",
"+ INF = 10**12",
"+ dist = [-INF] * (N + 1) # 1-indexed",
"+ dist[start] = 0",
"+ for i in range(N + N + 5):",
"+ for (pre, ne, weight) in graph:",
"+ if dist[pre] != -INF and dist[pre] + weight - P > dist[ne]:",
"+ dist[ne] = dist[pre] + weight - P",
"+ # n回繰り返してもスコアが更新された場合",
"+ if i > N - 1:",
"+ dist[ne] = INF",
"+ if dist[N] == INF:",
"- return max(-dist[g], 0)",
"+ return max(0, dist[N])",
"-answer = bellmanford(1, N)",
"+answer = bellmanford(N, 1)",
"-#"
] | false | 0.057348 | 0.066535 | 0.861925 | [
"s291924638",
"s708419361"
] |
u462329577 | p03059 | python | s467278580 | s755377221 | 173 | 17 | 39,888 | 2,940 | Accepted | Accepted | 90.17 | # T/A * B を出力する
a,b,t = list(map(int,input().split()))
print((b*(t//a)))
| a,b,c=list(map(int,input().split()))
print(((c//a)*b)) | 4 | 2 | 69 | 47 | # T/A * B を出力する
a, b, t = list(map(int, input().split()))
print((b * (t // a)))
| a, b, c = list(map(int, input().split()))
print(((c // a) * b))
| false | 50 | [
"-# T/A * B を出力する",
"-a, b, t = list(map(int, input().split()))",
"-print((b * (t // a)))",
"+a, b, c = list(map(int, input().split()))",
"+print(((c // a) * b))"
] | false | 0.032484 | 0.036343 | 0.893829 | [
"s467278580",
"s755377221"
] |
u380524497 | p02955 | python | s422972009 | s357774805 | 699 | 339 | 14,432 | 21,268 | Accepted | Accepted | 51.5 | import numpy as np
def divisors(num):
array = []
limit = int(num ** 0.5) + 1
for i in range(1, limit):
if num % i == 0:
div1 = i
div2 = num//i
array.append(div1)
if div1 != div2:
array.append(div2)
array.sort(reverse=True)
return array
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=int)
total = sum(A)
candidates = divisors(total)
for div in candidates:
mods = A % div
mods.sort()
add = div - mods
addcum = np.cumsum(add)
subcum = np.cumsum(mods)
for i in range(n):
addcount = addcum[n-1] - addcum[i]
subcount = subcum[i]
if addcount == subcount and addcount <= k:
print(div)
exit() | import numpy as np
def divisors(num):
array = []
limit = int(num ** 0.5) + 1
for i in range(1, limit):
if num % i == 0:
div1 = i
div2 = num//i
array.append(div1)
if div1 != div2:
array.append(div2)
array.sort(reverse=True)
return array
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=int)
total = sum(A)
candidates = divisors(total)
for div in candidates:
mods = A % div
mods.sort()
subcum = np.cumsum(mods)
idx = subcum[n-1] // div
count = subcum[-1-idx]
if count <= k:
print(div)
exit() | 37 | 33 | 830 | 697 | import numpy as np
def divisors(num):
array = []
limit = int(num**0.5) + 1
for i in range(1, limit):
if num % i == 0:
div1 = i
div2 = num // i
array.append(div1)
if div1 != div2:
array.append(div2)
array.sort(reverse=True)
return array
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=int)
total = sum(A)
candidates = divisors(total)
for div in candidates:
mods = A % div
mods.sort()
add = div - mods
addcum = np.cumsum(add)
subcum = np.cumsum(mods)
for i in range(n):
addcount = addcum[n - 1] - addcum[i]
subcount = subcum[i]
if addcount == subcount and addcount <= k:
print(div)
exit()
| import numpy as np
def divisors(num):
array = []
limit = int(num**0.5) + 1
for i in range(1, limit):
if num % i == 0:
div1 = i
div2 = num // i
array.append(div1)
if div1 != div2:
array.append(div2)
array.sort(reverse=True)
return array
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=int)
total = sum(A)
candidates = divisors(total)
for div in candidates:
mods = A % div
mods.sort()
subcum = np.cumsum(mods)
idx = subcum[n - 1] // div
count = subcum[-1 - idx]
if count <= k:
print(div)
exit()
| false | 10.810811 | [
"- add = div - mods",
"- addcum = np.cumsum(add)",
"- for i in range(n):",
"- addcount = addcum[n - 1] - addcum[i]",
"- subcount = subcum[i]",
"- if addcount == subcount and addcount <= k:",
"- print(div)",
"- exit()",
"+ idx = subcum[n - 1] // div",
"+ count = subcum[-1 - idx]",
"+ if count <= k:",
"+ print(div)",
"+ exit()"
] | false | 0.242366 | 0.536077 | 0.45211 | [
"s422972009",
"s357774805"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.