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
list | 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
list |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u588341295
|
p03229
|
python
|
s097013480
|
s960655788
| 420 | 360 | 10,044 | 10,656 |
Accepted
|
Accepted
| 14.29 |
# -*- coding: utf-8 -*-
import copy
from collections import deque
N = int(eval(input()))
aN = [int(eval(input())) for i in range(N)]
aN_sorted = sorted(aN)
aN_sorted = deque(aN_sorted)
aN2 = [0] * N
for i in range(N):
if i % 2 == 0:
aN2[i] = aN_sorted.popleft()
else:
aN2[i] = aN_sorted.pop()
aN_sorted2 = sorted(aN, reverse=True)
aN_sorted2 = deque(aN_sorted2)
aN3 = [0] * N
for i in range(N):
if i % 2 == 0:
aN3[i] = aN_sorted2.popleft()
else:
aN3[i] = aN_sorted2.pop()
ans = 0
for i in range(1,N):
if i == N-1:
ans += max(abs(aN2[i-1] - aN2[i]), abs(aN2[i] - aN2[0]))
else:
ans += abs(aN2[i-1] - aN2[i])
ans2 = 0
for i in range(1,N):
if i == N-1:
ans2 += max(abs(aN3[i-1] - aN3[i]), abs(aN3[i] - aN3[0]))
else:
ans2 += abs(aN3[i-1] - aN3[i])
print((max(ans, ans2)))
|
# -*- coding: utf-8 -*-
# 終了後、重複処理を整理した版
from collections import deque
N = int(eval(input()))
aN = [int(eval(input())) for i in range(N)]
# 受け取ったリストを前後から交互に並べていく
def changeList(_list):
_list = deque(_list)
res = [0] * N
for i in range(N):
if i % 2 == 0:
res[i] = _list.popleft()
else:
res[i] = _list.pop()
return res
# 受け取ったリストの隣り合う差の合計、最後だけ先頭とも比べて大きい方
def sumList(_list):
ans = 0
for i in range(1,N):
if i == N-1:
ans += max(abs(_list[i-1] - _list[i]), abs(_list[i] - _list[0]))
else:
ans += abs(_list[i-1] - _list[i])
return ans
# 昇順と降順、両方試して良かった方を使う
aN2 = changeList(sorted(aN))
aN3 = changeList(sorted(aN, reverse=True))
print((max(sumList(aN2), sumList(aN3))))
| 39 | 35 | 893 | 800 |
# -*- coding: utf-8 -*-
import copy
from collections import deque
N = int(eval(input()))
aN = [int(eval(input())) for i in range(N)]
aN_sorted = sorted(aN)
aN_sorted = deque(aN_sorted)
aN2 = [0] * N
for i in range(N):
if i % 2 == 0:
aN2[i] = aN_sorted.popleft()
else:
aN2[i] = aN_sorted.pop()
aN_sorted2 = sorted(aN, reverse=True)
aN_sorted2 = deque(aN_sorted2)
aN3 = [0] * N
for i in range(N):
if i % 2 == 0:
aN3[i] = aN_sorted2.popleft()
else:
aN3[i] = aN_sorted2.pop()
ans = 0
for i in range(1, N):
if i == N - 1:
ans += max(abs(aN2[i - 1] - aN2[i]), abs(aN2[i] - aN2[0]))
else:
ans += abs(aN2[i - 1] - aN2[i])
ans2 = 0
for i in range(1, N):
if i == N - 1:
ans2 += max(abs(aN3[i - 1] - aN3[i]), abs(aN3[i] - aN3[0]))
else:
ans2 += abs(aN3[i - 1] - aN3[i])
print((max(ans, ans2)))
|
# -*- coding: utf-8 -*-
# 終了後、重複処理を整理した版
from collections import deque
N = int(eval(input()))
aN = [int(eval(input())) for i in range(N)]
# 受け取ったリストを前後から交互に並べていく
def changeList(_list):
_list = deque(_list)
res = [0] * N
for i in range(N):
if i % 2 == 0:
res[i] = _list.popleft()
else:
res[i] = _list.pop()
return res
# 受け取ったリストの隣り合う差の合計、最後だけ先頭とも比べて大きい方
def sumList(_list):
ans = 0
for i in range(1, N):
if i == N - 1:
ans += max(abs(_list[i - 1] - _list[i]), abs(_list[i] - _list[0]))
else:
ans += abs(_list[i - 1] - _list[i])
return ans
# 昇順と降順、両方試して良かった方を使う
aN2 = changeList(sorted(aN))
aN3 = changeList(sorted(aN, reverse=True))
print((max(sumList(aN2), sumList(aN3))))
| false | 10.25641 |
[
"-import copy",
"+# 終了後、重複処理を整理した版",
"-aN_sorted = sorted(aN)",
"-aN_sorted = deque(aN_sorted)",
"-aN2 = [0] * N",
"-for i in range(N):",
"- if i % 2 == 0:",
"- aN2[i] = aN_sorted.popleft()",
"- else:",
"- aN2[i] = aN_sorted.pop()",
"-aN_sorted2 = sorted(aN, reverse=True)",
"-aN_sorted2 = deque(aN_sorted2)",
"-aN3 = [0] * N",
"-for i in range(N):",
"- if i % 2 == 0:",
"- aN3[i] = aN_sorted2.popleft()",
"- else:",
"- aN3[i] = aN_sorted2.pop()",
"-ans = 0",
"-for i in range(1, N):",
"- if i == N - 1:",
"- ans += max(abs(aN2[i - 1] - aN2[i]), abs(aN2[i] - aN2[0]))",
"- else:",
"- ans += abs(aN2[i - 1] - aN2[i])",
"-ans2 = 0",
"-for i in range(1, N):",
"- if i == N - 1:",
"- ans2 += max(abs(aN3[i - 1] - aN3[i]), abs(aN3[i] - aN3[0]))",
"- else:",
"- ans2 += abs(aN3[i - 1] - aN3[i])",
"-print((max(ans, ans2)))",
"+# 受け取ったリストを前後から交互に並べていく",
"+def changeList(_list):",
"+ _list = deque(_list)",
"+ res = [0] * N",
"+ for i in range(N):",
"+ if i % 2 == 0:",
"+ res[i] = _list.popleft()",
"+ else:",
"+ res[i] = _list.pop()",
"+ return res",
"+",
"+",
"+# 受け取ったリストの隣り合う差の合計、最後だけ先頭とも比べて大きい方",
"+def sumList(_list):",
"+ ans = 0",
"+ for i in range(1, N):",
"+ if i == N - 1:",
"+ ans += max(abs(_list[i - 1] - _list[i]), abs(_list[i] - _list[0]))",
"+ else:",
"+ ans += abs(_list[i - 1] - _list[i])",
"+ return ans",
"+",
"+",
"+# 昇順と降順、両方試して良かった方を使う",
"+aN2 = changeList(sorted(aN))",
"+aN3 = changeList(sorted(aN, reverse=True))",
"+print((max(sumList(aN2), sumList(aN3))))"
] | false | 0.040973 | 0.042028 | 0.974904 |
[
"s097013480",
"s960655788"
] |
u622045059
|
p02796
|
python
|
s728474952
|
s963353219
| 858 | 561 | 94,036 | 35,188 |
Accepted
|
Accepted
| 34.62 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
N = iin()
XL = sorted([iln() for _ in range(N)], key=lambda x:x[0]+x[1])
prev_r = XL[0][0]+XL[0][1]
ans = 1
for i in range(1, N):
if prev_r <= XL[i][0]-XL[i][1]:
ans += 1
prev_r = XL[i][0]+XL[i][1]
print(ans)
|
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9+7
def gcd(a,b):return fractions.gcd(a,b) #最大公約数
def lcm(a,b):return (a*b) // fractions.gcd(a,b) #最小公倍数
def iin(): return int(eval(input())) #整数読み込み
def ifn(): return float(eval(input())) #浮動小数点読み込み
def isn(): return input().split() #文字列読み込み
def imn(): return list(map(int, input().split())) #整数map取得
def fmn(): return list(map(float, input().split())) #浮動小数点map取得
def iln(): return list(map(int, input().split())) #整数リスト取得
def iln_s(): return sorted(iln()) # 昇順の整数リスト取得
def iln_r(): return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln(): return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=''): return s.join(l) #リストを文字列に変換
def perm(l, n): return itertools.permutations(l, n) # 順列取得
def perm_count(n, r): return math.factorial(n) // math.factorial(n-r) # 順列の総数
def comb(l, n): return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r): return math.factorial(n) // (math.factorial(n-r) * math.factorial(r)) #組み合わせの総数
def two_distance(a, b, c, d): return ((c-a)**2 + (d-b)**2)**.5 # 2点間の距離
def m_add(a,b): return (a+b) % MOD
N = iin()
XL = [iln() for _ in range(N)]
XL = sorted(XL, key=lambda x: x[0]+x[1])
prev = -10**9
ans = 0
for i in range(0, N):
if prev <= XL[i][0] - XL[i][1]:
ans += 1
prev = XL[i][0] + XL[i][1]
print(ans)
| 36 | 45 | 1,207 | 1,502 |
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
def gcd(a, b):
return fractions.gcd(a, b) # 最大公約数
def lcm(a, b):
return (a * b) // fractions.gcd(a, b) # 最小公倍数
def iin():
return int(eval(input())) # 整数読み込み
def isn():
return input().split() # 文字列読み込み
def imn():
return list(map(int, input().split())) # 整数map取得
def iln():
return list(map(int, input().split())) # 整数リスト取得
def iln_s():
return sorted(iln()) # 昇順の整数リスト取得
def iln_r():
return sorted(iln(), reverse=True) # 降順の整数リスト取得
def join(l, s=""):
return s.join(l) # リストを文字列に変換
def perm(l, n):
return itertools.permutations(l, n) # 順列取得
def perm_count(n, r):
return math.factorial(n) // math.factorial(n - r) # 順列の総数
def comb(l, n):
return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r)) # 組み合わせの総数
N = iin()
XL = sorted([iln() for _ in range(N)], key=lambda x: x[0] + x[1])
prev_r = XL[0][0] + XL[0][1]
ans = 1
for i in range(1, N):
if prev_r <= XL[i][0] - XL[i][1]:
ans += 1
prev_r = XL[i][0] + XL[i][1]
print(ans)
|
import math
import fractions
import bisect
import collections
import itertools
import heapq
import string
import sys
import copy
from collections import deque
sys.setrecursionlimit(10**7)
MOD = 10**9 + 7
def gcd(a, b):
return fractions.gcd(a, b) # 最大公約数
def lcm(a, b):
return (a * b) // fractions.gcd(a, b) # 最小公倍数
def iin():
return int(eval(input())) # 整数読み込み
def ifn():
return float(eval(input())) # 浮動小数点読み込み
def isn():
return input().split() # 文字列読み込み
def imn():
return list(map(int, input().split())) # 整数map取得
def fmn():
return list(map(float, input().split())) # 浮動小数点map取得
def iln():
return list(map(int, input().split())) # 整数リスト取得
def iln_s():
return sorted(iln()) # 昇順の整数リスト取得
def iln_r():
return sorted(iln(), reverse=True) # 降順の整数リスト取得
def fln():
return list(map(float, input().split())) # 浮動小数点リスト取得
def join(l, s=""):
return s.join(l) # リストを文字列に変換
def perm(l, n):
return itertools.permutations(l, n) # 順列取得
def perm_count(n, r):
return math.factorial(n) // math.factorial(n - r) # 順列の総数
def comb(l, n):
return itertools.combinations(l, n) # 組み合わせ取得
def comb_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r)) # 組み合わせの総数
def two_distance(a, b, c, d):
return ((c - a) ** 2 + (d - b) ** 2) ** 0.5 # 2点間の距離
def m_add(a, b):
return (a + b) % MOD
N = iin()
XL = [iln() for _ in range(N)]
XL = sorted(XL, key=lambda x: x[0] + x[1])
prev = -(10**9)
ans = 0
for i in range(0, N):
if prev <= XL[i][0] - XL[i][1]:
ans += 1
prev = XL[i][0] + XL[i][1]
print(ans)
| false | 20 |
[
"+MOD = 10**9 + 7",
"+def ifn():",
"+ return float(eval(input())) # 浮動小数点読み込み",
"+",
"+",
"+",
"+",
"+def fmn():",
"+ return list(map(float, input().split())) # 浮動小数点map取得",
"+",
"+",
"+def fln():",
"+ return list(map(float, input().split())) # 浮動小数点リスト取得",
"+def two_distance(a, b, c, d):",
"+ return ((c - a) ** 2 + (d - b) ** 2) ** 0.5 # 2点間の距離",
"+",
"+",
"+def m_add(a, b):",
"+ return (a + b) % MOD",
"+",
"+",
"-XL = sorted([iln() for _ in range(N)], key=lambda x: x[0] + x[1])",
"-prev_r = XL[0][0] + XL[0][1]",
"-ans = 1",
"-for i in range(1, N):",
"- if prev_r <= XL[i][0] - XL[i][1]:",
"+XL = [iln() for _ in range(N)]",
"+XL = sorted(XL, key=lambda x: x[0] + x[1])",
"+prev = -(10**9)",
"+ans = 0",
"+for i in range(0, N):",
"+ if prev <= XL[i][0] - XL[i][1]:",
"- prev_r = XL[i][0] + XL[i][1]",
"+ prev = XL[i][0] + XL[i][1]"
] | false | 0.045396 | 0.056159 | 0.808338 |
[
"s728474952",
"s963353219"
] |
u127499732
|
p02873
|
python
|
s287641990
|
s776331222
| 207 | 127 | 12,316 | 7,584 |
Accepted
|
Accepted
| 38.65 |
def main():
from itertools import groupby
s = list(eval(input()))
f = 0
ans = 0
for k,v in groupby(s):
d = len(tuple(v))
left = d if k==">" else 0
right = d if k=="<" else 0
if f>left:
ans += d*(d+1)//2 - left
else:
ans += -1*f + d*(d+1)//2
f = right
print(ans)
if __name__ == '__main__':
main()
|
def main():
s = tuple(eval(input()))
f = "" # 前回のステップの文字 "<" or ">"
ans = 0 # Answer
count = 0 # Ai
continuous = 0 # ">" が何回連続するか
for m in s:
if m=="<":
if f==">" and count>0:
# 清算
ans-=count*continuous
count=0
count+=1
else:
if f=="<":
# セット
continuous=0
count-=1
continuous+=1
if count>=0:
ans+=count
else:
ans+=continuous
count=0
f=m
print(ans)
if __name__ == '__main__':
main()
| 22 | 35 | 371 | 563 |
def main():
from itertools import groupby
s = list(eval(input()))
f = 0
ans = 0
for k, v in groupby(s):
d = len(tuple(v))
left = d if k == ">" else 0
right = d if k == "<" else 0
if f > left:
ans += d * (d + 1) // 2 - left
else:
ans += -1 * f + d * (d + 1) // 2
f = right
print(ans)
if __name__ == "__main__":
main()
|
def main():
s = tuple(eval(input()))
f = "" # 前回のステップの文字 "<" or ">"
ans = 0 # Answer
count = 0 # Ai
continuous = 0 # ">" が何回連続するか
for m in s:
if m == "<":
if f == ">" and count > 0:
# 清算
ans -= count * continuous
count = 0
count += 1
else:
if f == "<":
# セット
continuous = 0
count -= 1
continuous += 1
if count >= 0:
ans += count
else:
ans += continuous
count = 0
f = m
print(ans)
if __name__ == "__main__":
main()
| false | 37.142857 |
[
"- from itertools import groupby",
"-",
"- s = list(eval(input()))",
"- f = 0",
"- ans = 0",
"- for k, v in groupby(s):",
"- d = len(tuple(v))",
"- left = d if k == \">\" else 0",
"- right = d if k == \"<\" else 0",
"- if f > left:",
"- ans += d * (d + 1) // 2 - left",
"+ s = tuple(eval(input()))",
"+ f = \"\" # 前回のステップの文字 \"<\" or \">\"",
"+ ans = 0 # Answer",
"+ count = 0 # Ai",
"+ continuous = 0 # \">\" が何回連続するか",
"+ for m in s:",
"+ if m == \"<\":",
"+ if f == \">\" and count > 0:",
"+ # 清算",
"+ ans -= count * continuous",
"+ count = 0",
"+ count += 1",
"- ans += -1 * f + d * (d + 1) // 2",
"- f = right",
"+ if f == \"<\":",
"+ # セット",
"+ continuous = 0",
"+ count -= 1",
"+ continuous += 1",
"+ if count >= 0:",
"+ ans += count",
"+ else:",
"+ ans += continuous",
"+ count = 0",
"+ f = m"
] | false | 0.046823 | 0.042316 | 1.106509 |
[
"s287641990",
"s776331222"
] |
u411353821
|
p02732
|
python
|
s939937034
|
s467266142
| 431 | 318 | 26,612 | 27,036 |
Accepted
|
Accepted
| 26.22 |
from collections import defaultdict
n, *D = [list(map(int, s.split())) for s in open(0)]
D = D[0]
dic = defaultdict(int)
for i in D:
dic[i] += 1
total_comb = 0
for j in dic:
if dic[j] >= 2:
total_comb += dic[j] * (dic[j] - 1) / 2
for k in D:
if dic[k] >= 2:
print((int(total_comb - dic[k] + 1)))
else:
print((int(total_comb)))
|
from collections import defaultdict
def main():
d = defaultdict(int)
nums = []
_ = eval(input())
nums = list(map(int, input().split()))
for n in nums:
d[n] += 1
total_combs = 0
for k in list(d.keys()):
total_combs += int((d[k]*(d[k]-1))/2)
for n in nums:
print((total_combs - (d[n] - 1)))
if __name__ == "__main__":
main()
| 16 | 21 | 379 | 411 |
from collections import defaultdict
n, *D = [list(map(int, s.split())) for s in open(0)]
D = D[0]
dic = defaultdict(int)
for i in D:
dic[i] += 1
total_comb = 0
for j in dic:
if dic[j] >= 2:
total_comb += dic[j] * (dic[j] - 1) / 2
for k in D:
if dic[k] >= 2:
print((int(total_comb - dic[k] + 1)))
else:
print((int(total_comb)))
|
from collections import defaultdict
def main():
d = defaultdict(int)
nums = []
_ = eval(input())
nums = list(map(int, input().split()))
for n in nums:
d[n] += 1
total_combs = 0
for k in list(d.keys()):
total_combs += int((d[k] * (d[k] - 1)) / 2)
for n in nums:
print((total_combs - (d[n] - 1)))
if __name__ == "__main__":
main()
| false | 23.809524 |
[
"-n, *D = [list(map(int, s.split())) for s in open(0)]",
"-D = D[0]",
"-dic = defaultdict(int)",
"-for i in D:",
"- dic[i] += 1",
"-total_comb = 0",
"-for j in dic:",
"- if dic[j] >= 2:",
"- total_comb += dic[j] * (dic[j] - 1) / 2",
"-for k in D:",
"- if dic[k] >= 2:",
"- print((int(total_comb - dic[k] + 1)))",
"- else:",
"- print((int(total_comb)))",
"+",
"+def main():",
"+ d = defaultdict(int)",
"+ nums = []",
"+ _ = eval(input())",
"+ nums = list(map(int, input().split()))",
"+ for n in nums:",
"+ d[n] += 1",
"+ total_combs = 0",
"+ for k in list(d.keys()):",
"+ total_combs += int((d[k] * (d[k] - 1)) / 2)",
"+ for n in nums:",
"+ print((total_combs - (d[n] - 1)))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.069257 | 0.036182 | 1.914136 |
[
"s939937034",
"s467266142"
] |
u067299340
|
p00009
|
python
|
s142782204
|
s137097931
| 390 | 210 | 44,448 | 44,524 |
Accepted
|
Accepted
| 46.15 |
#coding: UTF-8
# 指定した数以下の素数の個数を返却する
# 素数判定はエラストテネスのふるい
# 要素1000000のリスト（素数かどうかのリスト）を準備
max_number = 1000000
prime_flag_list = [True] * max_number
# 0、1は素数でない
prime_flag_list[0] = False
prime_flag_list[1] = False
# 2の倍数（2を除く）は素数でない
prime_flag_list[4::2] = [False] * len(prime_flag_list[4::2])
# 3以上の数について、素数ならその倍数を振るい落とす
for i in range(3, int(max_number**0.5) + 1, 2):
prime_flag_list[i*i::i] = [False] * len(prime_flag_list[i*i::i])
# フラグの立ったままの箇所は素数なので、そこだけ取り出す
prime_list = [i for i in range(2, max_number) if prime_flag_list[i]]
while True:
try:
input = int(input())
except EOFError:
break
for i in range(0, len(prime_list)):
if prime_list[i] > input:
print(i)
break
if i >= len(prime_list) - 1:
print(len(prime_list))
|
#coding: UTF-8
import bisect
# 指定した数以下の素数の個数を返却する
# 素数判定はエラストテネスのふるい
# 要素1000000のリスト（素数かどうかのリスト）を準備
max_number = 1000000
prime_flag_list = [True] * max_number
# 0、1は素数でない
prime_flag_list[0] = False
prime_flag_list[1] = False
# 2の倍数（2を除く）は素数でない
prime_flag_list[4::2] = [False] * len(prime_flag_list[4::2])
# 3以上の数について、素数ならその倍数を振るい落とす
for i in range(3, int(max_number**0.5) + 1, 2):
prime_flag_list[i*i::i] = [False] * len(prime_flag_list[i*i::i])
# フラグの立ったままの箇所は素数なので、そこだけ取り出す
prime_list = [i for i in range(2, max_number) if prime_flag_list[i]]
while True:
try:
input = int(input())
except EOFError:
break
print(bisect.bisect_right(prime_list, input))
| 34 | 31 | 838 | 724 |
# coding: UTF-8
# 指定した数以下の素数の個数を返却する
# 素数判定はエラストテネスのふるい
# 要素1000000のリスト（素数かどうかのリスト）を準備
max_number = 1000000
prime_flag_list = [True] * max_number
# 0、1は素数でない
prime_flag_list[0] = False
prime_flag_list[1] = False
# 2の倍数（2を除く）は素数でない
prime_flag_list[4::2] = [False] * len(prime_flag_list[4::2])
# 3以上の数について、素数ならその倍数を振るい落とす
for i in range(3, int(max_number**0.5) + 1, 2):
prime_flag_list[i * i :: i] = [False] * len(prime_flag_list[i * i :: i])
# フラグの立ったままの箇所は素数なので、そこだけ取り出す
prime_list = [i for i in range(2, max_number) if prime_flag_list[i]]
while True:
try:
input = int(input())
except EOFError:
break
for i in range(0, len(prime_list)):
if prime_list[i] > input:
print(i)
break
if i >= len(prime_list) - 1:
print(len(prime_list))
|
# coding: UTF-8
import bisect
# 指定した数以下の素数の個数を返却する
# 素数判定はエラストテネスのふるい
# 要素1000000のリスト（素数かどうかのリスト）を準備
max_number = 1000000
prime_flag_list = [True] * max_number
# 0、1は素数でない
prime_flag_list[0] = False
prime_flag_list[1] = False
# 2の倍数（2を除く）は素数でない
prime_flag_list[4::2] = [False] * len(prime_flag_list[4::2])
# 3以上の数について、素数ならその倍数を振るい落とす
for i in range(3, int(max_number**0.5) + 1, 2):
prime_flag_list[i * i :: i] = [False] * len(prime_flag_list[i * i :: i])
# フラグの立ったままの箇所は素数なので、そこだけ取り出す
prime_list = [i for i in range(2, max_number) if prime_flag_list[i]]
while True:
try:
input = int(input())
except EOFError:
break
print(bisect.bisect_right(prime_list, input))
| false | 8.823529 |
[
"+import bisect",
"+",
"- for i in range(0, len(prime_list)):",
"- if prime_list[i] > input:",
"- print(i)",
"- break",
"- if i >= len(prime_list) - 1:",
"- print(len(prime_list))",
"+ print(bisect.bisect_right(prime_list, input))"
] | false | 0.93284 | 0.905536 | 1.030152 |
[
"s142782204",
"s137097931"
] |
u592248346
|
p02898
|
python
|
s431517397
|
s542208293
| 55 | 45 | 11,916 | 10,384 |
Accepted
|
Accepted
| 18.18 |
n,k=list(map(int,input().split()))
l=list(map(int,input().split()))
cnt=0
for i in range(n):
if l[i]>=k: cnt+=1
print(cnt)
|
n,k = list(map(int,input().split()))
print((sum([i>=k for i in map(int,input().split())])))
| 6 | 2 | 123 | 84 |
n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
cnt = 0
for i in range(n):
if l[i] >= k:
cnt += 1
print(cnt)
|
n, k = list(map(int, input().split()))
print((sum([i >= k for i in map(int, input().split())])))
| false | 66.666667 |
[
"-l = list(map(int, input().split()))",
"-cnt = 0",
"-for i in range(n):",
"- if l[i] >= k:",
"- cnt += 1",
"-print(cnt)",
"+print((sum([i >= k for i in map(int, input().split())])))"
] | false | 0.045455 | 0.045431 | 1.000518 |
[
"s431517397",
"s542208293"
] |
u225388820
|
p02607
|
python
|
s476345184
|
s443174694
| 63 | 29 | 61,556 | 8,936 |
Accepted
|
Accepted
| 53.97 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
if i % 2 == 0 and a[i] % 2:
ans += 1
print(ans)
|
n=eval(input())
print((sum(i&1 for i in list(map(int, input().split()))[::2])))
| 7 | 2 | 145 | 72 |
n = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
for i in range(n):
if i % 2 == 0 and a[i] % 2:
ans += 1
print(ans)
|
n = eval(input())
print((sum(i & 1 for i in list(map(int, input().split()))[::2])))
| false | 71.428571 |
[
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(n):",
"- if i % 2 == 0 and a[i] % 2:",
"- ans += 1",
"-print(ans)",
"+n = eval(input())",
"+print((sum(i & 1 for i in list(map(int, input().split()))[::2])))"
] | false | 0.035895 | 0.090735 | 0.395607 |
[
"s476345184",
"s443174694"
] |
u595856802
|
p03166
|
python
|
s110441045
|
s546877536
| 1,282 | 718 | 194,564 | 80,088 |
Accepted
|
Accepted
| 43.99 |
from sys import setrecursionlimit
setrecursionlimit(10 ** 9)
N, M = list(map(int, input().split()))
xys = [list(map(int, input().split())) for _ in range(M)]
children = [[] for _ in range(N)]
for x, y in xys:
children[x-1].append(y-1)
has_no_parent = [True] * N
has_no_child = [True] * N
for x, y in xys:
has_no_child[x-1] = False
has_no_parent[y-1] = False
lp = [None] * N
for node in range(N):
if has_no_child[node]:
lp[node] = 0
def dp(node):
if lp[node] is not None:
return lp[node]
result = max([dp(child) + 1 for child in children[node]])
lp[node] = result
return result
for node in range(N):
if lp[node] is None:
dp(node)
print((max(lp)))
|
N, M = list(map(int, input().split()))
xys = [list(map(int, input().split())) for _ in range(M)]
children = [[] for _ in range(N)]
for x, y in xys:
children[x-1].append(y-1)
has_no_parent = [True] * N
has_no_child = [True] * N
for x, y in xys:
has_no_child[x-1] = False
has_no_parent[y-1] = False
dp = [None] * N
for node in range(N):
if has_no_child[node]:
dp[node] = 0
for node in range(N):
if dp[node] is not None:
continue
stack = []
stack.append(node)
while stack:
parent = stack[-1]
all_children_defined = True
for child in children[parent]:
if dp[child] is None:
stack.append(child)
all_children_defined = False
if all_children_defined:
stack.pop()
dp[parent] = max([dp[child] + 1 for child in children[parent]])
print((max(dp)))
| 33 | 35 | 738 | 917 |
from sys import setrecursionlimit
setrecursionlimit(10**9)
N, M = list(map(int, input().split()))
xys = [list(map(int, input().split())) for _ in range(M)]
children = [[] for _ in range(N)]
for x, y in xys:
children[x - 1].append(y - 1)
has_no_parent = [True] * N
has_no_child = [True] * N
for x, y in xys:
has_no_child[x - 1] = False
has_no_parent[y - 1] = False
lp = [None] * N
for node in range(N):
if has_no_child[node]:
lp[node] = 0
def dp(node):
if lp[node] is not None:
return lp[node]
result = max([dp(child) + 1 for child in children[node]])
lp[node] = result
return result
for node in range(N):
if lp[node] is None:
dp(node)
print((max(lp)))
|
N, M = list(map(int, input().split()))
xys = [list(map(int, input().split())) for _ in range(M)]
children = [[] for _ in range(N)]
for x, y in xys:
children[x - 1].append(y - 1)
has_no_parent = [True] * N
has_no_child = [True] * N
for x, y in xys:
has_no_child[x - 1] = False
has_no_parent[y - 1] = False
dp = [None] * N
for node in range(N):
if has_no_child[node]:
dp[node] = 0
for node in range(N):
if dp[node] is not None:
continue
stack = []
stack.append(node)
while stack:
parent = stack[-1]
all_children_defined = True
for child in children[parent]:
if dp[child] is None:
stack.append(child)
all_children_defined = False
if all_children_defined:
stack.pop()
dp[parent] = max([dp[child] + 1 for child in children[parent]])
print((max(dp)))
| false | 5.714286 |
[
"-from sys import setrecursionlimit",
"-",
"-setrecursionlimit(10**9)",
"-lp = [None] * N",
"+dp = [None] * N",
"- lp[node] = 0",
"-",
"-",
"-def dp(node):",
"- if lp[node] is not None:",
"- return lp[node]",
"- result = max([dp(child) + 1 for child in children[node]])",
"- lp[node] = result",
"- return result",
"-",
"-",
"+ dp[node] = 0",
"- if lp[node] is None:",
"- dp(node)",
"-print((max(lp)))",
"+ if dp[node] is not None:",
"+ continue",
"+ stack = []",
"+ stack.append(node)",
"+ while stack:",
"+ parent = stack[-1]",
"+ all_children_defined = True",
"+ for child in children[parent]:",
"+ if dp[child] is None:",
"+ stack.append(child)",
"+ all_children_defined = False",
"+ if all_children_defined:",
"+ stack.pop()",
"+ dp[parent] = max([dp[child] + 1 for child in children[parent]])",
"+print((max(dp)))"
] | false | 0.069281 | 0.062982 | 1.100002 |
[
"s110441045",
"s546877536"
] |
u691896522
|
p02996
|
python
|
s214392516
|
s172659582
| 965 | 573 | 53,720 | 116,296 |
Accepted
|
Accepted
| 40.62 |
from operator import itemgetter
n = int(eval(input()))
data = []
for i in range(n):
data.append(list(map(int, input().split())))
data.sort(key = itemgetter(1))
time = 0
for i in range(n):
time += data[i][0]
if time > data[i][1]:
print("No")
exit()
print("Yes")
|
n = int(eval(input()))
data = []
for i in range(n):
data.append(list(map(int, input().split())))
data.sort(key = lambda x : x[1])
now = 0
for i in range(n):
now += data[i][0]
if now > data[i][1]:
print("No")
exit()
print("Yes")
| 13 | 12 | 294 | 260 |
from operator import itemgetter
n = int(eval(input()))
data = []
for i in range(n):
data.append(list(map(int, input().split())))
data.sort(key=itemgetter(1))
time = 0
for i in range(n):
time += data[i][0]
if time > data[i][1]:
print("No")
exit()
print("Yes")
|
n = int(eval(input()))
data = []
for i in range(n):
data.append(list(map(int, input().split())))
data.sort(key=lambda x: x[1])
now = 0
for i in range(n):
now += data[i][0]
if now > data[i][1]:
print("No")
exit()
print("Yes")
| false | 7.692308 |
[
"-from operator import itemgetter",
"-",
"-data.sort(key=itemgetter(1))",
"-time = 0",
"+data.sort(key=lambda x: x[1])",
"+now = 0",
"- time += data[i][0]",
"- if time > data[i][1]:",
"+ now += data[i][0]",
"+ if now > data[i][1]:"
] | false | 0.10592 | 0.099645 | 1.062974 |
[
"s214392516",
"s172659582"
] |
u476225888
|
p03168
|
python
|
s338717809
|
s192038362
| 1,822 | 1,466 | 3,700 | 3,572 |
Accepted
|
Accepted
| 19.54 |
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
# from math import *
from collections import defaultdict as dd, deque
def data(): return eval(input())
def mdata(): return list(map(float, data().split()))
out = sys.stdout.write
# sys.setrecursionlimit(100000)
INF = int(1e9)
mod = int(1e9) + 7
n = int(data())
P = list(mdata())
dp = [0.0] * (n // 2 + 2)
dp[1] = float(1)
for i in range(n):
p=P[i]
for j in range(len(dp) - 1, 0, -1):
dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)
print((sum(dp)))
|
def main():
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
# from math import *
from collections import defaultdict as dd, deque
def data(): return sys.stdin.readline()
def mdata(): return list(map(float, data().split()))
out = sys.stdout.write
# sys.setrecursionlimit(100000)
INF = int(1e9)
mod = int(1e9) + 7
n = int(data())
P = list(mdata())
dp = [0.0] * (n // 2 + 2)
dp[1] = float(1)
for i in range(n):
p=P[i]
for j in range(len(dp) - 1, 0, -1):
dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)
print((sum(dp)))
if __name__ == '__main__':
main()
| 21 | 25 | 554 | 702 |
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
# from math import *
from collections import defaultdict as dd, deque
def data():
return eval(input())
def mdata():
return list(map(float, data().split()))
out = sys.stdout.write
# sys.setrecursionlimit(100000)
INF = int(1e9)
mod = int(1e9) + 7
n = int(data())
P = list(mdata())
dp = [0.0] * (n // 2 + 2)
dp[1] = float(1)
for i in range(n):
p = P[i]
for j in range(len(dp) - 1, 0, -1):
dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)
print((sum(dp)))
|
def main():
from bisect import bisect_left as bl, bisect_right as br, insort
import sys
import heapq
# from math import *
from collections import defaultdict as dd, deque
def data():
return sys.stdin.readline()
def mdata():
return list(map(float, data().split()))
out = sys.stdout.write
# sys.setrecursionlimit(100000)
INF = int(1e9)
mod = int(1e9) + 7
n = int(data())
P = list(mdata())
dp = [0.0] * (n // 2 + 2)
dp[1] = float(1)
for i in range(n):
p = P[i]
for j in range(len(dp) - 1, 0, -1):
dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)
print((sum(dp)))
if __name__ == "__main__":
main()
| false | 16 |
[
"-from bisect import bisect_left as bl, bisect_right as br, insort",
"-import sys",
"-import heapq",
"+def main():",
"+ from bisect import bisect_left as bl, bisect_right as br, insort",
"+ import sys",
"+ import heapq",
"-# from math import *",
"-from collections import defaultdict as dd, deque",
"+ # from math import *",
"+ from collections import defaultdict as dd, deque",
"+",
"+ def data():",
"+ return sys.stdin.readline()",
"+",
"+ def mdata():",
"+ return list(map(float, data().split()))",
"+",
"+ out = sys.stdout.write",
"+ # sys.setrecursionlimit(100000)",
"+ INF = int(1e9)",
"+ mod = int(1e9) + 7",
"+ n = int(data())",
"+ P = list(mdata())",
"+ dp = [0.0] * (n // 2 + 2)",
"+ dp[1] = float(1)",
"+ for i in range(n):",
"+ p = P[i]",
"+ for j in range(len(dp) - 1, 0, -1):",
"+ dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)",
"+ print((sum(dp)))",
"-def data():",
"- return eval(input())",
"-",
"-",
"-def mdata():",
"- return list(map(float, data().split()))",
"-",
"-",
"-out = sys.stdout.write",
"-# sys.setrecursionlimit(100000)",
"-INF = int(1e9)",
"-mod = int(1e9) + 7",
"-n = int(data())",
"-P = list(mdata())",
"-dp = [0.0] * (n // 2 + 2)",
"-dp[1] = float(1)",
"-for i in range(n):",
"- p = P[i]",
"- for j in range(len(dp) - 1, 0, -1):",
"- dp[j] = dp[j - 1] * (1 - p) + dp[j] * (p)",
"-print((sum(dp)))",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.042226 | 0.042298 | 0.998283 |
[
"s338717809",
"s192038362"
] |
u511965386
|
p02782
|
python
|
s575058048
|
s254596678
| 1,922 | 367 | 135,792 | 87,276 |
Accepted
|
Accepted
| 80.91 |
r1, c1, r2, c2 = list(map(int, input().split()))
mod = 10 ** 9 + 7
fac = [1]
inv = [1]
for i in range(1, r2 + c2 + 10) :
fac.append(fac[-1] * i % mod)
inv.append(pow(fac[-1], mod - 2, mod))
def comb(n, r) :
return fac[n] * inv[n-r] % mod * inv[r] % mod
def g(x, y) :
return comb(x + y, y)
ret = g(r2+1, c2+1) - g(r2+1, c1) - g(r1, c2+1) + g(r1, c1)
ret %= mod
print(ret)
|
r1, c1, r2, c2 = list(map(int, input().split()))
mod = 10 ** 9 + 7
n = r2 + c2 + 10
fac = [0] * n
inv = [0] * n
finv = [0] * n
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, n) :
fac[i] = fac[i-1] * i % mod
inv[i] = mod - inv[mod%i] * (mod // i) % mod
finv[i] = finv[i-1] * inv[i] % mod
def comb(n, r) :
return fac[n] * finv[n-r] % mod * finv[r] % mod
def g(x, y) :
return comb(x + y, y)
ret = g(r2+1, c2+1) - g(r2+1, c1) - g(r1, c2+1) + g(r1, c1)
ret %= mod
print(ret)
| 19 | 27 | 395 | 530 |
r1, c1, r2, c2 = list(map(int, input().split()))
mod = 10**9 + 7
fac = [1]
inv = [1]
for i in range(1, r2 + c2 + 10):
fac.append(fac[-1] * i % mod)
inv.append(pow(fac[-1], mod - 2, mod))
def comb(n, r):
return fac[n] * inv[n - r] % mod * inv[r] % mod
def g(x, y):
return comb(x + y, y)
ret = g(r2 + 1, c2 + 1) - g(r2 + 1, c1) - g(r1, c2 + 1) + g(r1, c1)
ret %= mod
print(ret)
|
r1, c1, r2, c2 = list(map(int, input().split()))
mod = 10**9 + 7
n = r2 + c2 + 10
fac = [0] * n
inv = [0] * n
finv = [0] * n
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2, n):
fac[i] = fac[i - 1] * i % mod
inv[i] = mod - inv[mod % i] * (mod // i) % mod
finv[i] = finv[i - 1] * inv[i] % mod
def comb(n, r):
return fac[n] * finv[n - r] % mod * finv[r] % mod
def g(x, y):
return comb(x + y, y)
ret = g(r2 + 1, c2 + 1) - g(r2 + 1, c1) - g(r1, c2 + 1) + g(r1, c1)
ret %= mod
print(ret)
| false | 29.62963 |
[
"-fac = [1]",
"-inv = [1]",
"-for i in range(1, r2 + c2 + 10):",
"- fac.append(fac[-1] * i % mod)",
"- inv.append(pow(fac[-1], mod - 2, mod))",
"+n = r2 + c2 + 10",
"+fac = [0] * n",
"+inv = [0] * n",
"+finv = [0] * n",
"+fac[0] = fac[1] = 1",
"+finv[0] = finv[1] = 1",
"+inv[1] = 1",
"+for i in range(2, n):",
"+ fac[i] = fac[i - 1] * i % mod",
"+ inv[i] = mod - inv[mod % i] * (mod // i) % mod",
"+ finv[i] = finv[i - 1] * inv[i] % mod",
"- return fac[n] * inv[n - r] % mod * inv[r] % mod",
"+ return fac[n] * finv[n - r] % mod * finv[r] % mod"
] | false | 0.132714 | 0.098609 | 1.345861 |
[
"s575058048",
"s254596678"
] |
u415905784
|
p02947
|
python
|
s329576525
|
s089721485
| 739 | 488 | 23,908 | 18,148 |
Accepted
|
Accepted
| 33.96 |
from collections import defaultdict
N = int(eval(input()))
H = defaultdict(int)
for _ in range(N):
S = eval(input())
C = [0] * 26
for s in S:
C[ord(s) - 97] += 1
H[str(C)] += 1
cnt = 0
for v in list(H.values()):
cnt += v * (v - 1) // 2
print(cnt)
|
from collections import defaultdict
N = int(eval(input()))
H = defaultdict(int)
for _ in range(N):
S = eval(input())
H[''.join(sorted([s for s in S]))] += 1
cnt = 0
for v in list(H.values()):
cnt += v * (v - 1) // 2
print(cnt)
| 13 | 10 | 254 | 223 |
from collections import defaultdict
N = int(eval(input()))
H = defaultdict(int)
for _ in range(N):
S = eval(input())
C = [0] * 26
for s in S:
C[ord(s) - 97] += 1
H[str(C)] += 1
cnt = 0
for v in list(H.values()):
cnt += v * (v - 1) // 2
print(cnt)
|
from collections import defaultdict
N = int(eval(input()))
H = defaultdict(int)
for _ in range(N):
S = eval(input())
H["".join(sorted([s for s in S]))] += 1
cnt = 0
for v in list(H.values()):
cnt += v * (v - 1) // 2
print(cnt)
| false | 23.076923 |
[
"- C = [0] * 26",
"- for s in S:",
"- C[ord(s) - 97] += 1",
"- H[str(C)] += 1",
"+ H[\"\".join(sorted([s for s in S]))] += 1"
] | false | 0.071697 | 0.047505 | 1.50924 |
[
"s329576525",
"s089721485"
] |
u671060652
|
p02783
|
python
|
s257701898
|
s602141661
| 285 | 175 | 66,156 | 38,384 |
Accepted
|
Accepted
| 38.6 |
import itertools
import math
import fractions
import functools
h, a = list(map(int,input().split()))
print((math.ceil(h / a)))
|
h, a = list(map(int, input().split()))
print(((h+a-1)//a))
| 6 | 3 | 123 | 53 |
import itertools
import math
import fractions
import functools
h, a = list(map(int, input().split()))
print((math.ceil(h / a)))
|
h, a = list(map(int, input().split()))
print(((h + a - 1) // a))
| false | 50 |
[
"-import itertools",
"-import math",
"-import fractions",
"-import functools",
"-",
"-print((math.ceil(h / a)))",
"+print(((h + a - 1) // a))"
] | false | 0.038498 | 0.036711 | 1.048675 |
[
"s257701898",
"s602141661"
] |
u606045429
|
p03331
|
python
|
s014819491
|
s684173919
| 253 | 186 | 3,064 | 3,316 |
Accepted
|
Accepted
| 26.48 |
N = int(eval(input()))
result = 10 ** 10
for a in range(1, N):
b = N - a
A = 0
while a != 0:
A += a % 10
a = a // 10
B = 0
while b != 0:
B += b % 10
b = b // 10
result = min(result, A + B)
print(result)
|
def digit_sum(n):
result = 0
while n > 0:
result += n % 10
n = n // 10
return result
N = int(eval(input()))
mi = 1e10
for i in range(1, N):
mi = min(mi, digit_sum(i) + digit_sum(N - i))
print(mi)
| 18 | 12 | 273 | 234 |
N = int(eval(input()))
result = 10**10
for a in range(1, N):
b = N - a
A = 0
while a != 0:
A += a % 10
a = a // 10
B = 0
while b != 0:
B += b % 10
b = b // 10
result = min(result, A + B)
print(result)
|
def digit_sum(n):
result = 0
while n > 0:
result += n % 10
n = n // 10
return result
N = int(eval(input()))
mi = 1e10
for i in range(1, N):
mi = min(mi, digit_sum(i) + digit_sum(N - i))
print(mi)
| false | 33.333333 |
[
"+def digit_sum(n):",
"+ result = 0",
"+ while n > 0:",
"+ result += n % 10",
"+ n = n // 10",
"+ return result",
"+",
"+",
"-result = 10**10",
"-for a in range(1, N):",
"- b = N - a",
"- A = 0",
"- while a != 0:",
"- A += a % 10",
"- a = a // 10",
"- B = 0",
"- while b != 0:",
"- B += b % 10",
"- b = b // 10",
"- result = min(result, A + B)",
"-print(result)",
"+mi = 1e10",
"+for i in range(1, N):",
"+ mi = min(mi, digit_sum(i) + digit_sum(N - i))",
"+print(mi)"
] | false | 0.076008 | 0.190812 | 0.398342 |
[
"s014819491",
"s684173919"
] |
u312025627
|
p02716
|
python
|
s643066381
|
s633000994
| 668 | 142 | 224,868 | 109,152 |
Accepted
|
Accepted
| 78.74 |
C = -(10**15 + 7)
def main():
from collections import defaultdict
N = int(eval(input()))
K = N//2
A = [int(i) for i in input().split()]
dp = defaultdict(lambda: C)
for i in range(N+1):
dp[i, 0] = 0
if i != 0:
dp[(i, 1)] = max(dp[i-1, 1], A[i-1])
for i in range(2, N+1):
for j in range(i//2-1, (i+1)//2 + 1):
if j < 0:
continue
# A_i(1-index)でj個選ばなければいけない
dp[i, j] = max(dp[i, j], dp[i-2, j-1] + A[i-1],
dp[i-3, j-1] + A[i-1], dp[i-4, j-1] + A[i-1])
print((max(dp[N, K], dp[N-1, K], dp[N-2, K])))
# for i in range(N+1):
# for j in range(K+1):
# print("{:>4}".format(dp[i, j] if dp[i, j] != C else "C"),
# end=" " if j != K else "\n")
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
if N % 2 == 0:
dp = [[0]*2 for _ in range(N//2 + 1)]
for i in range(N//2):
dp[i+1][0] = dp[i][0] + A[2*i]
dp[i+1][1] = max(dp[i][0], dp[i][1]) + A[2*i+1]
print((max(dp[-1])))
else:
dp = [[0]*3 for _ in range(N//2 + 1)]
for i in range(N//2):
dp[i+1][0] = dp[i][0] + A[2*i]
dp[i+1][1] = max(dp[i][0], dp[i][1]) + A[2*i+1]
dp[i+1][2] = max(dp[i][0], dp[i][1], dp[i][2]) + A[2*i+2]
print((max(dp[-1])))
if __name__ == '__main__':
main()
| 29 | 25 | 884 | 655 |
C = -(10**15 + 7)
def main():
from collections import defaultdict
N = int(eval(input()))
K = N // 2
A = [int(i) for i in input().split()]
dp = defaultdict(lambda: C)
for i in range(N + 1):
dp[i, 0] = 0
if i != 0:
dp[(i, 1)] = max(dp[i - 1, 1], A[i - 1])
for i in range(2, N + 1):
for j in range(i // 2 - 1, (i + 1) // 2 + 1):
if j < 0:
continue
# A_i(1-index)でj個選ばなければいけない
dp[i, j] = max(
dp[i, j],
dp[i - 2, j - 1] + A[i - 1],
dp[i - 3, j - 1] + A[i - 1],
dp[i - 4, j - 1] + A[i - 1],
)
print((max(dp[N, K], dp[N - 1, K], dp[N - 2, K])))
# for i in range(N+1):
# for j in range(K+1):
# print("{:>4}".format(dp[i, j] if dp[i, j] != C else "C"),
# end=" " if j != K else "\n")
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
A = [int(i) for i in input().split()]
if N % 2 == 0:
dp = [[0] * 2 for _ in range(N // 2 + 1)]
for i in range(N // 2):
dp[i + 1][0] = dp[i][0] + A[2 * i]
dp[i + 1][1] = max(dp[i][0], dp[i][1]) + A[2 * i + 1]
print((max(dp[-1])))
else:
dp = [[0] * 3 for _ in range(N // 2 + 1)]
for i in range(N // 2):
dp[i + 1][0] = dp[i][0] + A[2 * i]
dp[i + 1][1] = max(dp[i][0], dp[i][1]) + A[2 * i + 1]
dp[i + 1][2] = max(dp[i][0], dp[i][1], dp[i][2]) + A[2 * i + 2]
print((max(dp[-1])))
if __name__ == "__main__":
main()
| false | 13.793103 |
[
"-C = -(10**15 + 7)",
"-",
"-",
"- from collections import defaultdict",
"-",
"- K = N // 2",
"- dp = defaultdict(lambda: C)",
"- for i in range(N + 1):",
"- dp[i, 0] = 0",
"- if i != 0:",
"- dp[(i, 1)] = max(dp[i - 1, 1], A[i - 1])",
"- for i in range(2, N + 1):",
"- for j in range(i // 2 - 1, (i + 1) // 2 + 1):",
"- if j < 0:",
"- continue",
"- # A_i(1-index)でj個選ばなければいけない",
"- dp[i, j] = max(",
"- dp[i, j],",
"- dp[i - 2, j - 1] + A[i - 1],",
"- dp[i - 3, j - 1] + A[i - 1],",
"- dp[i - 4, j - 1] + A[i - 1],",
"- )",
"- print((max(dp[N, K], dp[N - 1, K], dp[N - 2, K])))",
"- # for i in range(N+1):",
"- # for j in range(K+1):",
"- # print(\"{:>4}\".format(dp[i, j] if dp[i, j] != C else \"C\"),",
"- # end=\" \" if j != K else \"\\n\")",
"+ if N % 2 == 0:",
"+ dp = [[0] * 2 for _ in range(N // 2 + 1)]",
"+ for i in range(N // 2):",
"+ dp[i + 1][0] = dp[i][0] + A[2 * i]",
"+ dp[i + 1][1] = max(dp[i][0], dp[i][1]) + A[2 * i + 1]",
"+ print((max(dp[-1])))",
"+ else:",
"+ dp = [[0] * 3 for _ in range(N // 2 + 1)]",
"+ for i in range(N // 2):",
"+ dp[i + 1][0] = dp[i][0] + A[2 * i]",
"+ dp[i + 1][1] = max(dp[i][0], dp[i][1]) + A[2 * i + 1]",
"+ dp[i + 1][2] = max(dp[i][0], dp[i][1], dp[i][2]) + A[2 * i + 2]",
"+ print((max(dp[-1])))"
] | false | 0.084157 | 0.037124 | 2.266914 |
[
"s643066381",
"s633000994"
] |
u941438707
|
p03379
|
python
|
s246933207
|
s103818695
| 338 | 299 | 25,620 | 25,052 |
Accepted
|
Accepted
| 11.54 |
n=int(eval(input()))
x=[int(i) for i in input().split()]
y=sorted(x)
for i in x:
if i>y[n//2-1]:
print((y[n//2-1]))
else:
print((y[n//2]))
|
n,*a=list(map(int,open(0).read().split()))
b=sorted(a)
c,d=b[n//2-1],b[n//2]
for i in a:
print((d if i<=c else c))
| 8 | 5 | 159 | 114 |
n = int(eval(input()))
x = [int(i) for i in input().split()]
y = sorted(x)
for i in x:
if i > y[n // 2 - 1]:
print((y[n // 2 - 1]))
else:
print((y[n // 2]))
|
n, *a = list(map(int, open(0).read().split()))
b = sorted(a)
c, d = b[n // 2 - 1], b[n // 2]
for i in a:
print((d if i <= c else c))
| false | 37.5 |
[
"-n = int(eval(input()))",
"-x = [int(i) for i in input().split()]",
"-y = sorted(x)",
"-for i in x:",
"- if i > y[n // 2 - 1]:",
"- print((y[n // 2 - 1]))",
"- else:",
"- print((y[n // 2]))",
"+n, *a = list(map(int, open(0).read().split()))",
"+b = sorted(a)",
"+c, d = b[n // 2 - 1], b[n // 2]",
"+for i in a:",
"+ print((d if i <= c else c))"
] | false | 0.109128 | 0.034252 | 3.185995 |
[
"s246933207",
"s103818695"
] |
u502389123
|
p03835
|
python
|
s997333698
|
s169304091
| 1,458 | 1,243 | 2,940 | 2,940 |
Accepted
|
Accepted
| 14.75 |
K, S = list(map(int, input().split()))
count = 0
for i in range(K+1):
for j in range(K+1):
k = S - i - j
if 0 <= k <= K:
count += 1
print(count)
|
K, S = list(map(int, input().split()))
count = 0
for i in range(K+1):
for j in range(K+1):
if 0 <= S - i - j <= K:
count += 1
print(count)
| 10 | 9 | 174 | 167 |
K, S = list(map(int, input().split()))
count = 0
for i in range(K + 1):
for j in range(K + 1):
k = S - i - j
if 0 <= k <= K:
count += 1
print(count)
|
K, S = list(map(int, input().split()))
count = 0
for i in range(K + 1):
for j in range(K + 1):
if 0 <= S - i - j <= K:
count += 1
print(count)
| false | 10 |
[
"- k = S - i - j",
"- if 0 <= k <= K:",
"+ if 0 <= S - i - j <= K:"
] | false | 0.044069 | 0.047739 | 0.923117 |
[
"s997333698",
"s169304091"
] |
u040298438
|
p02647
|
python
|
s125023238
|
s407070564
| 1,044 | 718 | 137,172 | 129,824 |
Accepted
|
Accepted
| 31.23 |
import numpy as np
from numba import jit, i8
@jit(i8[:](i8, i8, i8[:]), nopython=True)
def myfunc(n, k, A):
for _ in range(k):
l = np.zeros((n + 1,), dtype=np.int64)
for i, a in enumerate(A[:-1]):
l[max(0, i - a)] += 1
l[min(n, i + a + 1)] -= 1
A = np.cumsum(l)
if np.all(A[:-1] == n):
break
return A
def main():
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=np.int64)
A = np.append(A, 0)
print((*myfunc(n, k, A)[:-1]))
if __name__ == "__main__":
main()
|
import numpy as np
from numba import jit
@jit("i8[:](i8, i8, i8[:])", nopython=True, cache=True)
def myfunc(n, k, A):
for _ in range(k):
l = np.zeros((n + 1,), dtype=np.int64)
for i, a in enumerate(A[:-1]):
l[max(0, i - a)] += 1
l[min(n, i + a + 1)] -= 1
A = np.cumsum(l)
if np.all(A[:-1] == n):
break
return A
def main():
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=np.int64)
A = np.append(A, 0)
print((*myfunc(n, k, A)[:-1]))
if __name__ == "__main__":
main()
| 26 | 26 | 617 | 627 |
import numpy as np
from numba import jit, i8
@jit(i8[:](i8, i8, i8[:]), nopython=True)
def myfunc(n, k, A):
for _ in range(k):
l = np.zeros((n + 1,), dtype=np.int64)
for i, a in enumerate(A[:-1]):
l[max(0, i - a)] += 1
l[min(n, i + a + 1)] -= 1
A = np.cumsum(l)
if np.all(A[:-1] == n):
break
return A
def main():
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=np.int64)
A = np.append(A, 0)
print((*myfunc(n, k, A)[:-1]))
if __name__ == "__main__":
main()
|
import numpy as np
from numba import jit
@jit("i8[:](i8, i8, i8[:])", nopython=True, cache=True)
def myfunc(n, k, A):
for _ in range(k):
l = np.zeros((n + 1,), dtype=np.int64)
for i, a in enumerate(A[:-1]):
l[max(0, i - a)] += 1
l[min(n, i + a + 1)] -= 1
A = np.cumsum(l)
if np.all(A[:-1] == n):
break
return A
def main():
n, k = list(map(int, input().split()))
A = np.array(list(map(int, input().split())), dtype=np.int64)
A = np.append(A, 0)
print((*myfunc(n, k, A)[:-1]))
if __name__ == "__main__":
main()
| false | 0 |
[
"-from numba import jit, i8",
"+from numba import jit",
"-@jit(i8[:](i8, i8, i8[:]), nopython=True)",
"+@jit(\"i8[:](i8, i8, i8[:])\", nopython=True, cache=True)"
] | false | 0.650273 | 0.23413 | 2.777397 |
[
"s125023238",
"s407070564"
] |
u904804404
|
p03069
|
python
|
s247511442
|
s818245865
| 874 | 356 | 25,096 | 42,928 |
Accepted
|
Accepted
| 59.27 |
N = int(eval(input()))
S = eval(input())
import numpy as np
N = np.zeros((len(S),2))
B,W = 0,1
# 左から.W 右へ#B
for idx,s in enumerate(S):
if s is "#":
N[idx,B] = N[idx-1,B] + 1
N[idx,W] = N[idx-1,W]
else:
N[idx,B] = N[idx-1,B]
N[idx,W] = N[idx-1,W] + 1
print((int(min([N[i,B]+N[-1,W]-N[i,W] for i in range(len(S)-1)]+[N[-1,W],N[-1,B]] ))))
|
N = int(eval(input()))
S = eval(input())
N = [[0 for _ in range(2)] for _ in range(len(S))]
B,W = 0,1
# 左から.W 右へ#B
for idx,s in enumerate(S):
if s is "#":
N[idx][B] = N[idx-1][B] + 1
N[idx][W] = N[idx-1][W]
else:
N[idx][B] = N[idx-1][B]
N[idx][W] = N[idx-1][W] + 1
print((int(min([N[i][B]+N[-1][W]-N[i][W] for i in range(len(S)-1)]+[N[-1][W],N[-1][B]] ))))
| 17 | 15 | 363 | 383 |
N = int(eval(input()))
S = eval(input())
import numpy as np
N = np.zeros((len(S), 2))
B, W = 0, 1
# 左から.W 右へ#B
for idx, s in enumerate(S):
if s is "#":
N[idx, B] = N[idx - 1, B] + 1
N[idx, W] = N[idx - 1, W]
else:
N[idx, B] = N[idx - 1, B]
N[idx, W] = N[idx - 1, W] + 1
print(
(
int(
min(
[N[i, B] + N[-1, W] - N[i, W] for i in range(len(S) - 1)]
+ [N[-1, W], N[-1, B]]
)
)
)
)
|
N = int(eval(input()))
S = eval(input())
N = [[0 for _ in range(2)] for _ in range(len(S))]
B, W = 0, 1
# 左から.W 右へ#B
for idx, s in enumerate(S):
if s is "#":
N[idx][B] = N[idx - 1][B] + 1
N[idx][W] = N[idx - 1][W]
else:
N[idx][B] = N[idx - 1][B]
N[idx][W] = N[idx - 1][W] + 1
print(
(
int(
min(
[N[i][B] + N[-1][W] - N[i][W] for i in range(len(S) - 1)]
+ [N[-1][W], N[-1][B]]
)
)
)
)
| false | 11.764706 |
[
"-import numpy as np",
"-",
"-N = np.zeros((len(S), 2))",
"+N = [[0 for _ in range(2)] for _ in range(len(S))]",
"- N[idx, B] = N[idx - 1, B] + 1",
"- N[idx, W] = N[idx - 1, W]",
"+ N[idx][B] = N[idx - 1][B] + 1",
"+ N[idx][W] = N[idx - 1][W]",
"- N[idx, B] = N[idx - 1, B]",
"- N[idx, W] = N[idx - 1, W] + 1",
"+ N[idx][B] = N[idx - 1][B]",
"+ N[idx][W] = N[idx - 1][W] + 1",
"- [N[i, B] + N[-1, W] - N[i, W] for i in range(len(S) - 1)]",
"- + [N[-1, W], N[-1, B]]",
"+ [N[i][B] + N[-1][W] - N[i][W] for i in range(len(S) - 1)]",
"+ + [N[-1][W], N[-1][B]]"
] | false | 0.045247 | 0.155267 | 0.291415 |
[
"s247511442",
"s818245865"
] |
u150984829
|
p02412
|
python
|
s050686540
|
s200842394
| 50 | 40 | 5,592 | 5,612 |
Accepted
|
Accepted
| 20 |
while 1:
n,x=list(map(int,input().split()))
if n+x==0:break
c=0
for i in range(3,n+1):
for j in range(2,x-i):
if x-i-j<j<i:
c+=1
print(c)
|
while 1:
n,x=list(map(int,input().split()))
if n+x==0:break
print((sum([1 for i in range(3,n+1)for j in range(2,x-i)if x-i-j<j<i])))
| 9 | 4 | 153 | 130 |
while 1:
n, x = list(map(int, input().split()))
if n + x == 0:
break
c = 0
for i in range(3, n + 1):
for j in range(2, x - i):
if x - i - j < j < i:
c += 1
print(c)
|
while 1:
n, x = list(map(int, input().split()))
if n + x == 0:
break
print(
(
sum(
[
1
for i in range(3, n + 1)
for j in range(2, x - i)
if x - i - j < j < i
]
)
)
)
| false | 55.555556 |
[
"- c = 0",
"- for i in range(3, n + 1):",
"- for j in range(2, x - i):",
"- if x - i - j < j < i:",
"- c += 1",
"- print(c)",
"+ print(",
"+ (",
"+ sum(",
"+ [",
"+ 1",
"+ for i in range(3, n + 1)",
"+ for j in range(2, x - i)",
"+ if x - i - j < j < i",
"+ ]",
"+ )",
"+ )",
"+ )"
] | false | 0.03627 | 0.03672 | 0.987736 |
[
"s050686540",
"s200842394"
] |
u744920373
|
p02768
|
python
|
s461231946
|
s187320692
| 229 | 211 | 53,104 | 52,976 |
Accepted
|
Accepted
| 7.86 |
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a:int, b:int, mod:int)->int:
if b % 2 == 0:
return (mod_pow(a, b//2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b//2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
for i in range(1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P)
|
import sys
sys.setrecursionlimit(10**8)
def ii(): return int(sys.stdin.readline())
def mi(): return list(map(int, sys.stdin.readline().split()))
def li(): return list(map(int, sys.stdin.readline().split()))
def li2(N): return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j): return [[ini]*i for _ in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for _ in range(j)] for _ in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
#from itertools import accumulate #list(accumulate(A))
# 繰り返し二乗法
def pow_r_mod(x:int, n:int, mod=10**9+7)->int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
m, a, b = mi()
P = 10**9+7
N = 2*(10**5)+1
inv_t = [0]+[1]
# 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a+1):
mca *= (m-i+1) * inv_t[i]
mca %= P
mcb = mca
for i in range(a+1, b+1):
mcb *= (m-i+1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m)-1-mca-mcb) % P))
#print((mod_pow(2, m, P)-1-mca-mcb) % P)
| 53 | 49 | 1,462 | 1,269 |
import sys
sys.setrecursionlimit(10**8)
def ii():
return int(sys.stdin.readline())
def mi():
return list(map(int, sys.stdin.readline().split()))
def li():
return list(map(int, sys.stdin.readline().split()))
def li2(N):
return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j):
return [[ini] * i for _ in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for _ in range(j)] for _ in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
# from itertools import accumulate #list(accumulate(A))
def pow_r_mod(x: int, n: int, mod=10**9 + 7) -> int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
def mod_pow(a: int, b: int, mod: int) -> int:
if b % 2 == 0:
return (mod_pow(a, b // 2, mod) ** 2) % mod
elif b == 1:
return a % mod
else:
return ((mod_pow(a, b // 2, mod) ** 2) * a) % mod
m, a, b = mi()
P = 10**9 + 7
N = 2 * (10**5) + 1
inv_t = [0] + [1]
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a + 1):
mca *= (m - i + 1) * inv_t[i]
mca %= P
for i in range(1, b + 1):
mcb *= (m - i + 1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m) - 1 - mca - mcb) % P))
# print((mod_pow(2, m, P)-1-mca-mcb) % P)
|
import sys
sys.setrecursionlimit(10**8)
def ii():
return int(sys.stdin.readline())
def mi():
return list(map(int, sys.stdin.readline().split()))
def li():
return list(map(int, sys.stdin.readline().split()))
def li2(N):
return [list(map(int, sys.stdin.readline().split())) for _ in range(N)]
def dp2(ini, i, j):
return [[ini] * i for _ in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for _ in range(j)] for _ in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
# from itertools import accumulate #list(accumulate(A))
# 繰り返し二乗法
def pow_r_mod(x: int, n: int, mod=10**9 + 7) -> int:
# 計算量 : log N
if n == 0:
return 1
K = 1
while n > 1:
if n % 2 != 0:
K *= x
x *= x
x %= mod
n //= 2
return (K * x) % mod
m, a, b = mi()
P = 10**9 + 7
N = 2 * (10**5) + 1
inv_t = [0] + [1]
# 逆元
for i in range(2, N):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
mca = mcb = 1
for i in range(1, a + 1):
mca *= (m - i + 1) * inv_t[i]
mca %= P
mcb = mca
for i in range(a + 1, b + 1):
mcb *= (m - i + 1) * inv_t[i]
mcb %= P
print(((pow_r_mod(2, m) - 1 - mca - mcb) % P))
# print((mod_pow(2, m, P)-1-mca-mcb) % P)
| false | 7.54717 |
[
"+# 繰り返し二乗法",
"-def mod_pow(a: int, b: int, mod: int) -> int:",
"- if b % 2 == 0:",
"- return (mod_pow(a, b // 2, mod) ** 2) % mod",
"- elif b == 1:",
"- return a % mod",
"- else:",
"- return ((mod_pow(a, b // 2, mod) ** 2) * a) % mod",
"-",
"-",
"+# 逆元",
"-for i in range(1, b + 1):",
"+mcb = mca",
"+for i in range(a + 1, b + 1):"
] | false | 0.628421 | 0.532916 | 1.179212 |
[
"s461231946",
"s187320692"
] |
u014333473
|
p02641
|
python
|
s710652508
|
s074916537
| 24 | 21 | 9,164 | 9,192 |
Accepted
|
Accepted
| 12.5 |
X, N = list(map(int, input().split()))
p = list(map(int, input().split()))
i = 0
while True:
if X - i not in (p):
print((X-i))
exit()
if X + i not in (p):
print((X+i))
exit()
i += 1
|
X, N = list(map(int, input().split()))
if N==0: print(X);exit()
p = list(map(int, input().split()))
count = 0
while True:
if X - count not in p:
print((X-count))
exit()
if X + count not in p:
print((X+count))
exit()
count += 1
| 12 | 12 | 233 | 249 |
X, N = list(map(int, input().split()))
p = list(map(int, input().split()))
i = 0
while True:
if X - i not in (p):
print((X - i))
exit()
if X + i not in (p):
print((X + i))
exit()
i += 1
|
X, N = list(map(int, input().split()))
if N == 0:
print(X)
exit()
p = list(map(int, input().split()))
count = 0
while True:
if X - count not in p:
print((X - count))
exit()
if X + count not in p:
print((X + count))
exit()
count += 1
| false | 0 |
[
"+if N == 0:",
"+ print(X)",
"+ exit()",
"-i = 0",
"+count = 0",
"- if X - i not in (p):",
"- print((X - i))",
"+ if X - count not in p:",
"+ print((X - count))",
"- if X + i not in (p):",
"- print((X + i))",
"+ if X + count not in p:",
"+ print((X + count))",
"- i += 1",
"+ count += 1"
] | false | 0.04024 | 0.040663 | 0.989598 |
[
"s710652508",
"s074916537"
] |
u433532588
|
p03212
|
python
|
s998506702
|
s079723805
| 54 | 44 | 3,064 | 3,064 |
Accepted
|
Accepted
| 18.52 |
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
##############################
N = int(eval(input()))
def dfs(next_value, value, count_flag, count):
value += next_value
int_value = int(value)
# print(int_value)
if int_value > N:
return count
if int_value >= 357:
if count_flag == False:
if len(set(list(value))) == 3:
count_flag = True
if count_flag:
count += 1
count = dfs('3', value, count_flag, count)
count = dfs('5', value, count_flag, count)
count = dfs('7', value, count_flag, count)
return count
count = 0
value = ''
count = dfs('3', '', False, count)
count = dfs('5', '', False, count)
count = dfs('7', '', False, count)
print(count)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
# A = [ int(input()) for _ in range(N) ]
##############################
N = int(eval(input()))
def dfs(X, bit, count):
if bit == 7:
if X <= N:
count += 1
if X >= N:
return count
count = dfs(X*10+7, bit|4, count)
count = dfs(X*10+5, bit|2, count)
count = dfs(X*10+3, bit|1, count)
return count
count = dfs(0, 0, 0)
print(count)
| 40 | 30 | 808 | 513 |
import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
##############################
N = int(eval(input()))
def dfs(next_value, value, count_flag, count):
value += next_value
int_value = int(value)
# print(int_value)
if int_value > N:
return count
if int_value >= 357:
if count_flag == False:
if len(set(list(value))) == 3:
count_flag = True
if count_flag:
count += 1
count = dfs("3", value, count_flag, count)
count = dfs("5", value, count_flag, count)
count = dfs("7", value, count_flag, count)
return count
count = 0
value = ""
count = dfs("3", "", False, count)
count = dfs("5", "", False, count)
count = dfs("7", "", False, count)
print(count)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
INF = float("inf")
MOD = 10**9 + 7
# A = [ int(input()) for _ in range(N) ]
##############################
N = int(eval(input()))
def dfs(X, bit, count):
if bit == 7:
if X <= N:
count += 1
if X >= N:
return count
count = dfs(X * 10 + 7, bit | 4, count)
count = dfs(X * 10 + 5, bit | 2, count)
count = dfs(X * 10 + 3, bit | 1, count)
return count
count = dfs(0, 0, 0)
print(count)
| false | 25 |
[
"-sys.setrecursionlimit(1000000)",
"+sys.setrecursionlimit(2147483647)",
"+INF = float(\"inf\")",
"+MOD = 10**9 + 7",
"+# A = [ int(input()) for _ in range(N) ]",
"-def dfs(next_value, value, count_flag, count):",
"- value += next_value",
"- int_value = int(value)",
"- # print(int_value)",
"- if int_value > N:",
"+def dfs(X, bit, count):",
"+ if bit == 7:",
"+ if X <= N:",
"+ count += 1",
"+ if X >= N:",
"- if int_value >= 357:",
"- if count_flag == False:",
"- if len(set(list(value))) == 3:",
"- count_flag = True",
"- if count_flag:",
"- count += 1",
"- count = dfs(\"3\", value, count_flag, count)",
"- count = dfs(\"5\", value, count_flag, count)",
"- count = dfs(\"7\", value, count_flag, count)",
"+ count = dfs(X * 10 + 7, bit | 4, count)",
"+ count = dfs(X * 10 + 5, bit | 2, count)",
"+ count = dfs(X * 10 + 3, bit | 1, count)",
"-count = 0",
"-value = \"\"",
"-count = dfs(\"3\", \"\", False, count)",
"-count = dfs(\"5\", \"\", False, count)",
"-count = dfs(\"7\", \"\", False, count)",
"+count = dfs(0, 0, 0)"
] | false | 0.060687 | 0.05427 | 1.118253 |
[
"s998506702",
"s079723805"
] |
u762420987
|
p02996
|
python
|
s964269716
|
s462379828
| 1,314 | 895 | 83,032 | 53,724 |
Accepted
|
Accepted
| 31.89 |
N = int(eval(input()))
ABlist = sorted([tuple(map(int, input().split())) for _ in range(N)], key=lambda x: x[1])
now = 0
for a, b in ABlist:
now += a
if now <= b:
continue
else:
print("No")
break
else:
print("Yes")
|
N = int(eval(input()))
ABlist = [list(map(int, input().split())) for _ in range(N)]
ABlist.sort(key=lambda x: x[1])
time = 0
for a, b in ABlist:
time += a
if time > b:
print("No")
break
else:
print("Yes")
| 12 | 11 | 260 | 237 |
N = int(eval(input()))
ABlist = sorted(
[tuple(map(int, input().split())) for _ in range(N)], key=lambda x: x[1]
)
now = 0
for a, b in ABlist:
now += a
if now <= b:
continue
else:
print("No")
break
else:
print("Yes")
|
N = int(eval(input()))
ABlist = [list(map(int, input().split())) for _ in range(N)]
ABlist.sort(key=lambda x: x[1])
time = 0
for a, b in ABlist:
time += a
if time > b:
print("No")
break
else:
print("Yes")
| false | 8.333333 |
[
"-ABlist = sorted(",
"- [tuple(map(int, input().split())) for _ in range(N)], key=lambda x: x[1]",
"-)",
"-now = 0",
"+ABlist = [list(map(int, input().split())) for _ in range(N)]",
"+ABlist.sort(key=lambda x: x[1])",
"+time = 0",
"- now += a",
"- if now <= b:",
"- continue",
"- else:",
"+ time += a",
"+ if time > b:"
] | false | 0.035945 | 0.035292 | 1.018498 |
[
"s964269716",
"s462379828"
] |
u652656291
|
p02757
|
python
|
s493436093
|
s201916126
| 487 | 144 | 6,560 | 14,888 |
Accepted
|
Accepted
| 70.43 |
n, p = list(map(int, input().split()))
s = list(map(int, list(eval(input()))))[::-1]
sum = 0
cnt = [0] * p
cnt[0] = 1
n = len(s)
for i in range(n):
d = s[i] * pow(10, i, p)
sum = (sum + d) % p
cnt[sum] += 1
ans = 0
if p in [2, 5]:
if p == 2:
ok_list = [0, 2, 4, 6, 8]
if p == 5:
ok_list = [0, 5]
for i in range(n):
d = s[i]
if d in ok_list:
ans += n - i
else:
for i in range(p):
ans += cnt[i] * (cnt[i]-1) // 2
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import Counter
N, P = list(map(int, readline().split()))
S = list(map(int, read().rstrip().decode()))
def solve_2(S):
ind = (i for i, x in enumerate(S, 1) if x % 2 == 0)
return sum(ind)
def solve_5(S):
ind = (i for i, x in enumerate(S, 1) if x % 5 == 0)
return sum(ind)
def solve(S,P):
if P == 2:
return solve_2(S)
if P == 5:
return solve_5(S)
S = S[::-1]
T = [0] * len(S)
T[0] = S[0] % P
power = 1
for i in range(1, len(S)):
power *= 10
power %= P
T[i] = T[i-1] + power * S[i]
T[i] %= P
counter = Counter(T)
return sum(x * (x - 1) // 2 for x in list(counter.values())) + counter[0]
print((solve(S,P)))
| 30 | 36 | 536 | 863 |
n, p = list(map(int, input().split()))
s = list(map(int, list(eval(input()))))[::-1]
sum = 0
cnt = [0] * p
cnt[0] = 1
n = len(s)
for i in range(n):
d = s[i] * pow(10, i, p)
sum = (sum + d) % p
cnt[sum] += 1
ans = 0
if p in [2, 5]:
if p == 2:
ok_list = [0, 2, 4, 6, 8]
if p == 5:
ok_list = [0, 5]
for i in range(n):
d = s[i]
if d in ok_list:
ans += n - i
else:
for i in range(p):
ans += cnt[i] * (cnt[i] - 1) // 2
print(ans)
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import Counter
N, P = list(map(int, readline().split()))
S = list(map(int, read().rstrip().decode()))
def solve_2(S):
ind = (i for i, x in enumerate(S, 1) if x % 2 == 0)
return sum(ind)
def solve_5(S):
ind = (i for i, x in enumerate(S, 1) if x % 5 == 0)
return sum(ind)
def solve(S, P):
if P == 2:
return solve_2(S)
if P == 5:
return solve_5(S)
S = S[::-1]
T = [0] * len(S)
T[0] = S[0] % P
power = 1
for i in range(1, len(S)):
power *= 10
power %= P
T[i] = T[i - 1] + power * S[i]
T[i] %= P
counter = Counter(T)
return sum(x * (x - 1) // 2 for x in list(counter.values())) + counter[0]
print((solve(S, P)))
| false | 16.666667 |
[
"-n, p = list(map(int, input().split()))",
"-s = list(map(int, list(eval(input()))))[::-1]",
"-sum = 0",
"-cnt = [0] * p",
"-cnt[0] = 1",
"-n = len(s)",
"-for i in range(n):",
"- d = s[i] * pow(10, i, p)",
"- sum = (sum + d) % p",
"- cnt[sum] += 1",
"-ans = 0",
"-if p in [2, 5]:",
"- if p == 2:",
"- ok_list = [0, 2, 4, 6, 8]",
"- if p == 5:",
"- ok_list = [0, 5]",
"- for i in range(n):",
"- d = s[i]",
"- if d in ok_list:",
"- ans += n - i",
"-else:",
"- for i in range(p):",
"- ans += cnt[i] * (cnt[i] - 1) // 2",
"-print(ans)",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+from collections import Counter",
"+",
"+N, P = list(map(int, readline().split()))",
"+S = list(map(int, read().rstrip().decode()))",
"+",
"+",
"+def solve_2(S):",
"+ ind = (i for i, x in enumerate(S, 1) if x % 2 == 0)",
"+ return sum(ind)",
"+",
"+",
"+def solve_5(S):",
"+ ind = (i for i, x in enumerate(S, 1) if x % 5 == 0)",
"+ return sum(ind)",
"+",
"+",
"+def solve(S, P):",
"+ if P == 2:",
"+ return solve_2(S)",
"+ if P == 5:",
"+ return solve_5(S)",
"+ S = S[::-1]",
"+ T = [0] * len(S)",
"+ T[0] = S[0] % P",
"+ power = 1",
"+ for i in range(1, len(S)):",
"+ power *= 10",
"+ power %= P",
"+ T[i] = T[i - 1] + power * S[i]",
"+ T[i] %= P",
"+ counter = Counter(T)",
"+ return sum(x * (x - 1) // 2 for x in list(counter.values())) + counter[0]",
"+",
"+",
"+print((solve(S, P)))"
] | false | 0.046685 | 0.047524 | 0.982327 |
[
"s493436093",
"s201916126"
] |
u953110527
|
p02631
|
python
|
s159173580
|
s643394654
| 299 | 146 | 110,684 | 114,764 |
Accepted
|
Accepted
| 51.17 |
n = int(eval(input()))
a = list(map(int,input().split()))
an = [0 for i in range(30)]
ans = []
for i in a:
c = bin(i)
d = len(c)-1
count = 0
while c[d] != 'b':
if c[d] == '1':
an[count] += 1
an[count] %= 2
d-=1
count+=1
tmp = 0
for i in range(len(an)):
if an[i] == 1:
tmp += 2**i
for i in a:
ans.append(i ^ tmp)
print((*ans))
|
n = int(eval(input()))
a = list(map(int,input().split()))
xora = 0
for i in range(n):
xora = xora^a[i]
ans = []
for i in range(n):
ans.append(xora^a[i])
print((*ans))
| 21 | 9 | 417 | 174 |
n = int(eval(input()))
a = list(map(int, input().split()))
an = [0 for i in range(30)]
ans = []
for i in a:
c = bin(i)
d = len(c) - 1
count = 0
while c[d] != "b":
if c[d] == "1":
an[count] += 1
an[count] %= 2
d -= 1
count += 1
tmp = 0
for i in range(len(an)):
if an[i] == 1:
tmp += 2**i
for i in a:
ans.append(i ^ tmp)
print((*ans))
|
n = int(eval(input()))
a = list(map(int, input().split()))
xora = 0
for i in range(n):
xora = xora ^ a[i]
ans = []
for i in range(n):
ans.append(xora ^ a[i])
print((*ans))
| false | 57.142857 |
[
"-an = [0 for i in range(30)]",
"+xora = 0",
"+for i in range(n):",
"+ xora = xora ^ a[i]",
"-for i in a:",
"- c = bin(i)",
"- d = len(c) - 1",
"- count = 0",
"- while c[d] != \"b\":",
"- if c[d] == \"1\":",
"- an[count] += 1",
"- an[count] %= 2",
"- d -= 1",
"- count += 1",
"-tmp = 0",
"-for i in range(len(an)):",
"- if an[i] == 1:",
"- tmp += 2**i",
"-for i in a:",
"- ans.append(i ^ tmp)",
"+for i in range(n):",
"+ ans.append(xora ^ a[i])"
] | false | 0.036185 | 0.03583 | 1.009902 |
[
"s159173580",
"s643394654"
] |
u594244257
|
p02955
|
python
|
s225251766
|
s621923267
| 138 | 125 | 3,064 | 3,064 |
Accepted
|
Accepted
| 9.42 |
def solve():
N,K = list(map(int , input().split()))
A = list(map(int , input().split()))
max_total = 22361 # sqrt(10**6 * 500)
total = sum(A)
search_space = set([])
max_d = 1
for d in range(1, min(total, max_total) ):
if total % d == 0:
search_space.add(d)
search_space.add(total // d)
# print(search_space)
for d in search_space:
if total % d == 0:
remainders = [a%d for a in A]
remainders = sorted(remainders)
# print(d, remainders)
positive_rem = 0
negative_rem = 0
flag = True
for rem in remainders:
if positive_rem+rem <= K:
positive_rem += rem
elif negative_rem+(d-rem) <=K:
negative_rem += (d-rem)
else:
flag = False
break
if flag and d > max_d:
# print(d, remainders, positive_rem, negative_rem)
max_d = d
print(max_d)
solve()
|
def get_divisor(num, max_val):
ret = []
num_sq = int(num**0.5)
for k in range(1, num_sq+1):
if num % k == 0:
if k <= max_val: ret.append(k)
if num//k <= max_val: ret.append(num//k)
return ret
# 下からmodが低いのを取ってきてマッチングを取る
def solve():
N,K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
max_A = max(A)
div = get_divisor(sum_A, max_A+K)
ret = 1
for d in div:
sum_k = 0
red_k = 0
flag = True
mod_d = [a%d for a in A]
mod_d.sort()
# print(d, mod_d)
for a in mod_d:
if sum_k+a <= K:
sum_k += a
else:
red_k += d-a
if sum_k-red_k < 0:
break
if (sum_k-red_k)%d == 0: ret = max(ret, d)
print(ret)
solve()
| 39 | 38 | 1,133 | 923 |
def solve():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
max_total = 22361 # sqrt(10**6 * 500)
total = sum(A)
search_space = set([])
max_d = 1
for d in range(1, min(total, max_total)):
if total % d == 0:
search_space.add(d)
search_space.add(total // d)
# print(search_space)
for d in search_space:
if total % d == 0:
remainders = [a % d for a in A]
remainders = sorted(remainders)
# print(d, remainders)
positive_rem = 0
negative_rem = 0
flag = True
for rem in remainders:
if positive_rem + rem <= K:
positive_rem += rem
elif negative_rem + (d - rem) <= K:
negative_rem += d - rem
else:
flag = False
break
if flag and d > max_d:
# print(d, remainders, positive_rem, negative_rem)
max_d = d
print(max_d)
solve()
|
def get_divisor(num, max_val):
ret = []
num_sq = int(num**0.5)
for k in range(1, num_sq + 1):
if num % k == 0:
if k <= max_val:
ret.append(k)
if num // k <= max_val:
ret.append(num // k)
return ret
# 下からmodが低いのを取ってきてマッチングを取る
def solve():
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
sum_A = sum(A)
max_A = max(A)
div = get_divisor(sum_A, max_A + K)
ret = 1
for d in div:
sum_k = 0
red_k = 0
flag = True
mod_d = [a % d for a in A]
mod_d.sort()
# print(d, mod_d)
for a in mod_d:
if sum_k + a <= K:
sum_k += a
else:
red_k += d - a
if sum_k - red_k < 0:
break
if (sum_k - red_k) % d == 0:
ret = max(ret, d)
print(ret)
solve()
| false | 2.564103 |
[
"+def get_divisor(num, max_val):",
"+ ret = []",
"+ num_sq = int(num**0.5)",
"+ for k in range(1, num_sq + 1):",
"+ if num % k == 0:",
"+ if k <= max_val:",
"+ ret.append(k)",
"+ if num // k <= max_val:",
"+ ret.append(num // k)",
"+ return ret",
"+",
"+",
"+# 下からmodが低いのを取ってきてマッチングを取る",
"- max_total = 22361 # sqrt(10**6 * 500)",
"- total = sum(A)",
"- search_space = set([])",
"- max_d = 1",
"- for d in range(1, min(total, max_total)):",
"- if total % d == 0:",
"- search_space.add(d)",
"- search_space.add(total // d)",
"- # print(search_space)",
"- for d in search_space:",
"- if total % d == 0:",
"- remainders = [a % d for a in A]",
"- remainders = sorted(remainders)",
"- # print(d, remainders)",
"- positive_rem = 0",
"- negative_rem = 0",
"- flag = True",
"- for rem in remainders:",
"- if positive_rem + rem <= K:",
"- positive_rem += rem",
"- elif negative_rem + (d - rem) <= K:",
"- negative_rem += d - rem",
"- else:",
"- flag = False",
"- break",
"- if flag and d > max_d:",
"- # print(d, remainders, positive_rem, negative_rem)",
"- max_d = d",
"- print(max_d)",
"+ sum_A = sum(A)",
"+ max_A = max(A)",
"+ div = get_divisor(sum_A, max_A + K)",
"+ ret = 1",
"+ for d in div:",
"+ sum_k = 0",
"+ red_k = 0",
"+ flag = True",
"+ mod_d = [a % d for a in A]",
"+ mod_d.sort()",
"+ # print(d, mod_d)",
"+ for a in mod_d:",
"+ if sum_k + a <= K:",
"+ sum_k += a",
"+ else:",
"+ red_k += d - a",
"+ if sum_k - red_k < 0:",
"+ break",
"+ if (sum_k - red_k) % d == 0:",
"+ ret = max(ret, d)",
"+ print(ret)"
] | false | 0.037231 | 0.036589 | 1.017549 |
[
"s225251766",
"s621923267"
] |
u133936772
|
p02936
|
python
|
s264697464
|
s430626963
| 1,800 | 1,488 | 268,432 | 283,156 |
Accepted
|
Accepted
| 17.33 |
import sys
sys.setrecursionlimit(10**6)
f=lambda:list(map(int,sys.stdin.readline().split()))
n,q=f()
g=[[] for _ in range(n)]
for i in range(n-1):
a,b=f()
g[a-1]+=[b-1]
g[b-1]+=[a-1]
l=[0]*n
for i in range(q):
p,x=f()
l[p-1]+=x
def dfs(v,p=-1):
for c in g[v]:
if c==p: continue
l[c]+=l[v]
dfs(c,v)
dfs(0)
print((*l))
|
import sys
sys.setrecursionlimit(10**6)
f=lambda:list(map(int,input().split()))
n,k=f()
g=[[] for _ in range(n)]
for i in range(n-1):
a,b=f()
g[a-1]+=[b-1]
g[b-1]+=[a-1]
l=[0]*n
for _ in range(k):
p,x=f()
l[p-1]+=x
def dfs(v,p=-1):
for c in g[v]:
if c==p: continue
l[c]+=l[v]
dfs(c,v)
dfs(0)
print((*l))
| 20 | 20 | 351 | 338 |
import sys
sys.setrecursionlimit(10**6)
f = lambda: list(map(int, sys.stdin.readline().split()))
n, q = f()
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = f()
g[a - 1] += [b - 1]
g[b - 1] += [a - 1]
l = [0] * n
for i in range(q):
p, x = f()
l[p - 1] += x
def dfs(v, p=-1):
for c in g[v]:
if c == p:
continue
l[c] += l[v]
dfs(c, v)
dfs(0)
print((*l))
|
import sys
sys.setrecursionlimit(10**6)
f = lambda: list(map(int, input().split()))
n, k = f()
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = f()
g[a - 1] += [b - 1]
g[b - 1] += [a - 1]
l = [0] * n
for _ in range(k):
p, x = f()
l[p - 1] += x
def dfs(v, p=-1):
for c in g[v]:
if c == p:
continue
l[c] += l[v]
dfs(c, v)
dfs(0)
print((*l))
| false | 0 |
[
"-f = lambda: list(map(int, sys.stdin.readline().split()))",
"-n, q = f()",
"+f = lambda: list(map(int, input().split()))",
"+n, k = f()",
"-for i in range(q):",
"+for _ in range(k):"
] | false | 0.040787 | 0.043887 | 0.929375 |
[
"s264697464",
"s430626963"
] |
u454022848
|
p02390
|
python
|
s045787689
|
s287910448
| 40 | 10 | 6,732 | 6,428 |
Accepted
|
Accepted
| 75 |
sec=int(eval(input()))
print((":".join(map(str, [int(sec/3600), int(sec/60)%60, sec%60]))))
|
# encoding:utf-8
input = eval(input())
second = input % 60
minute = input / 60 % 60
hour = input / 60 / 60 % 60
print((":".join(map(str, (hour, minute, second)))))
| 2 | 9 | 84 | 166 |
sec = int(eval(input()))
print((":".join(map(str, [int(sec / 3600), int(sec / 60) % 60, sec % 60]))))
|
# encoding:utf-8
input = eval(input())
second = input % 60
minute = input / 60 % 60
hour = input / 60 / 60 % 60
print((":".join(map(str, (hour, minute, second)))))
| false | 77.777778 |
[
"-sec = int(eval(input()))",
"-print((\":\".join(map(str, [int(sec / 3600), int(sec / 60) % 60, sec % 60]))))",
"+# encoding:utf-8",
"+input = eval(input())",
"+second = input % 60",
"+minute = input / 60 % 60",
"+hour = input / 60 / 60 % 60",
"+print((\":\".join(map(str, (hour, minute, second)))))"
] | false | 0.036959 | 0.04416 | 0.836924 |
[
"s045787689",
"s287910448"
] |
u970197315
|
p03425
|
python
|
s449153680
|
s705308768
| 173 | 158 | 3,064 | 9,476 |
Accepted
|
Accepted
| 8.67 |
n=int(eval(input()))
m=0
a=0
r=0
c=0
h=0
for i in range(n):
s=input()[0:1]
if s=="M":m+=1
elif s=="A":a+=1
elif s=="R":r+=1
elif s=="C":c+=1
elif s=="H":h+=1
ans=0
ans+=m*a*r
ans+=m*a*c
ans+=m*a*h
ans+=m*r*c
ans+=m*r*h
ans+=m*c*h
ans+=a*r*c
ans+=a*r*h
ans+=a*c*h
ans+=r*c*h
print(ans)
|
n = int(eval(input()))
from collections import Counter
c = Counter()
for _ in range(n):
s = input()[0]
c[s] += 1
ans = 0
ans += c["M"]*c["A"]*c["R"]
ans += c["M"]*c["A"]*c["C"]
ans += c["M"]*c["A"]*c["H"]
ans += c["M"]*c["R"]*c["C"]
ans += c["M"]*c["R"]*c["H"]
ans += c["M"]*c["C"]*c["H"]
ans += c["A"]*c["R"]*c["C"]
ans += c["A"]*c["R"]*c["H"]
ans += c["A"]*c["C"]*c["H"]
ans += c["R"]*c["C"]*c["H"]
print(ans)
| 25 | 20 | 314 | 434 |
n = int(eval(input()))
m = 0
a = 0
r = 0
c = 0
h = 0
for i in range(n):
s = input()[0:1]
if s == "M":
m += 1
elif s == "A":
a += 1
elif s == "R":
r += 1
elif s == "C":
c += 1
elif s == "H":
h += 1
ans = 0
ans += m * a * r
ans += m * a * c
ans += m * a * h
ans += m * r * c
ans += m * r * h
ans += m * c * h
ans += a * r * c
ans += a * r * h
ans += a * c * h
ans += r * c * h
print(ans)
|
n = int(eval(input()))
from collections import Counter
c = Counter()
for _ in range(n):
s = input()[0]
c[s] += 1
ans = 0
ans += c["M"] * c["A"] * c["R"]
ans += c["M"] * c["A"] * c["C"]
ans += c["M"] * c["A"] * c["H"]
ans += c["M"] * c["R"] * c["C"]
ans += c["M"] * c["R"] * c["H"]
ans += c["M"] * c["C"] * c["H"]
ans += c["A"] * c["R"] * c["C"]
ans += c["A"] * c["R"] * c["H"]
ans += c["A"] * c["C"] * c["H"]
ans += c["R"] * c["C"] * c["H"]
print(ans)
| false | 20 |
[
"-m = 0",
"-a = 0",
"-r = 0",
"-c = 0",
"-h = 0",
"-for i in range(n):",
"- s = input()[0:1]",
"- if s == \"M\":",
"- m += 1",
"- elif s == \"A\":",
"- a += 1",
"- elif s == \"R\":",
"- r += 1",
"- elif s == \"C\":",
"- c += 1",
"- elif s == \"H\":",
"- h += 1",
"+from collections import Counter",
"+",
"+c = Counter()",
"+for _ in range(n):",
"+ s = input()[0]",
"+ c[s] += 1",
"-ans += m * a * r",
"-ans += m * a * c",
"-ans += m * a * h",
"-ans += m * r * c",
"-ans += m * r * h",
"-ans += m * c * h",
"-ans += a * r * c",
"-ans += a * r * h",
"-ans += a * c * h",
"-ans += r * c * h",
"+ans += c[\"M\"] * c[\"A\"] * c[\"R\"]",
"+ans += c[\"M\"] * c[\"A\"] * c[\"C\"]",
"+ans += c[\"M\"] * c[\"A\"] * c[\"H\"]",
"+ans += c[\"M\"] * c[\"R\"] * c[\"C\"]",
"+ans += c[\"M\"] * c[\"R\"] * c[\"H\"]",
"+ans += c[\"M\"] * c[\"C\"] * c[\"H\"]",
"+ans += c[\"A\"] * c[\"R\"] * c[\"C\"]",
"+ans += c[\"A\"] * c[\"R\"] * c[\"H\"]",
"+ans += c[\"A\"] * c[\"C\"] * c[\"H\"]",
"+ans += c[\"R\"] * c[\"C\"] * c[\"H\"]"
] | false | 0.044368 | 0.041935 | 1.058017 |
[
"s449153680",
"s705308768"
] |
u225642513
|
p03146
|
python
|
s524764300
|
s387688418
| 33 | 18 | 10,868 | 2,940 |
Accepted
|
Accepted
| 45.45 |
s = int(eval(input()))
MAX = 10**6
def f(n):
if n%2==0:
return n//2
else:
return 3*n + 1
l = [0] * MAX
l[s] = 1
for i in range(2,MAX+1):
temp = f(s)
if l[temp]==1:
print(i)
exit()
l[temp] = 1
s = temp
|
s = int(eval(input()))
MAX = 10**6
def f(n):
if n%2==0:
return n//2
else:
return 3*n + 1
l = []
l.append(s)
for i in range(2,MAX+1):
temp = f(s)
if temp in l:
print(i)
exit()
l.append(temp)
s = temp
| 17 | 17 | 268 | 266 |
s = int(eval(input()))
MAX = 10**6
def f(n):
if n % 2 == 0:
return n // 2
else:
return 3 * n + 1
l = [0] * MAX
l[s] = 1
for i in range(2, MAX + 1):
temp = f(s)
if l[temp] == 1:
print(i)
exit()
l[temp] = 1
s = temp
|
s = int(eval(input()))
MAX = 10**6
def f(n):
if n % 2 == 0:
return n // 2
else:
return 3 * n + 1
l = []
l.append(s)
for i in range(2, MAX + 1):
temp = f(s)
if temp in l:
print(i)
exit()
l.append(temp)
s = temp
| false | 0 |
[
"-l = [0] * MAX",
"-l[s] = 1",
"+l = []",
"+l.append(s)",
"- if l[temp] == 1:",
"+ if temp in l:",
"- l[temp] = 1",
"+ l.append(temp)"
] | false | 0.068918 | 0.035167 | 1.959757 |
[
"s524764300",
"s387688418"
] |
u893063840
|
p02642
|
python
|
s569286851
|
s257108056
| 1,887 | 475 | 108,048 | 55,512 |
Accepted
|
Accepted
| 74.83 |
from time import time
def fact(x):
i = 1
while i * i <= x:
if x % i == 0:
yield i
yield x // i
i += 1
def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
now = time()
c = [0] * (max(a) + 1)
for e in a:
c[e] += 1
ans = n
for e in a:
c[e] -= 1
for fct in fact(e):
if c[fct]:
ans -= 1
break
if time() - now >= 1.8:
print(n)
exit()
c[e] += 1
print(ans)
if __name__ == "__main__":
main()
|
from collections import Counter
import numpy as np
n = int(eval(input()))
a = list(map(int, input().split()))
MAX = 10 ** 6
c = Counter(a)
arr = np.zeros(MAX + 1, np.int64)
st = set()
for k, v in list(c.items()):
if v != 1:
st.add(k)
arr[k] = 1
for i in range(MAX + 1):
if arr[i]:
arr[i*2::i] = 0
if i in st:
arr[i] = 0
print((arr.sum()))
| 41 | 23 | 641 | 392 |
from time import time
def fact(x):
i = 1
while i * i <= x:
if x % i == 0:
yield i
yield x // i
i += 1
def main():
n = int(eval(input()))
a = tuple(map(int, input().split()))
now = time()
c = [0] * (max(a) + 1)
for e in a:
c[e] += 1
ans = n
for e in a:
c[e] -= 1
for fct in fact(e):
if c[fct]:
ans -= 1
break
if time() - now >= 1.8:
print(n)
exit()
c[e] += 1
print(ans)
if __name__ == "__main__":
main()
|
from collections import Counter
import numpy as np
n = int(eval(input()))
a = list(map(int, input().split()))
MAX = 10**6
c = Counter(a)
arr = np.zeros(MAX + 1, np.int64)
st = set()
for k, v in list(c.items()):
if v != 1:
st.add(k)
arr[k] = 1
for i in range(MAX + 1):
if arr[i]:
arr[i * 2 :: i] = 0
if i in st:
arr[i] = 0
print((arr.sum()))
| false | 43.902439 |
[
"-from time import time",
"+from collections import Counter",
"+import numpy as np",
"-",
"-def fact(x):",
"- i = 1",
"- while i * i <= x:",
"- if x % i == 0:",
"- yield i",
"- yield x // i",
"- i += 1",
"-",
"-",
"-def main():",
"- n = int(eval(input()))",
"- a = tuple(map(int, input().split()))",
"- now = time()",
"- c = [0] * (max(a) + 1)",
"- for e in a:",
"- c[e] += 1",
"- ans = n",
"- for e in a:",
"- c[e] -= 1",
"- for fct in fact(e):",
"- if c[fct]:",
"- ans -= 1",
"- break",
"- if time() - now >= 1.8:",
"- print(n)",
"- exit()",
"- c[e] += 1",
"- print(ans)",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+n = int(eval(input()))",
"+a = list(map(int, input().split()))",
"+MAX = 10**6",
"+c = Counter(a)",
"+arr = np.zeros(MAX + 1, np.int64)",
"+st = set()",
"+for k, v in list(c.items()):",
"+ if v != 1:",
"+ st.add(k)",
"+ arr[k] = 1",
"+for i in range(MAX + 1):",
"+ if arr[i]:",
"+ arr[i * 2 :: i] = 0",
"+ if i in st:",
"+ arr[i] = 0",
"+print((arr.sum()))"
] | false | 0.087592 | 0.558321 | 0.156885 |
[
"s569286851",
"s257108056"
] |
u326609687
|
p03128
|
python
|
s862053879
|
s345249964
| 119 | 18 | 14,436 | 3,188 |
Accepted
|
Accepted
| 84.87 |
def f(x):
k = int(x)
return c[k], k
c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
N, M = list(map(int, input().split()))
A = list(map(f, input().split()))
A = sorted(A, key=lambda x: x[0] * 10 - x[1])
# 数字を作成するのに必要なマッチ数のリストを作成
b = []
dic = {}
n = 0
for d in A:
if n != d[0]:
b.append(d[0])
n = d[0]
dic[n] = d[1]
ans = [0] * b[0]
n = b[0]
while True:
max_ = 0
for d in b:
if n - d == 0:
if dic[d] > max_:
max_ = dic[d]
elif n - d > 0 and ans[n - d] > 0:
t = ans[n - d] * 10 + dic[d]
max_ = max(max_, t)
if n == N:
print(max_)
break
ans.append(max_)
n += 1
|
def f(x):
k = int(x)
return c[k], k
c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
N, M = list(map(int, input().split()))
A = list(map(f, input().split()))
A = sorted(A, key=lambda x: x[0] * 10 - x[1])
b = []
dic = {}
n = 0
for d in A:
if n != d[0]:
b.append(d[0])
n = d[0]
dic[n] = d[1]
ans = [0] * b[0]
n = b[0]
count = 0
while True:
max_ = 0
for d in b:
if n - d == 0:
if dic[d] > max_:
max_ = dic[d]
elif n - d > 0 and ans[n - d] > 0:
t = ans[n - d] * 10 + dic[d]
max_ = max(max_, t)
if n == N:
print(max_)
break;
if max_ > 0 and (N - n) % b[0] == 0:
if count < 2:
count += 1
else:
print((''.join(sorted(list(str(max_) + str(dic[b[0]])*((N - n)//b[0])), reverse=True))))
break
ans.append(max_)
n += 1
| 37 | 43 | 725 | 933 |
def f(x):
k = int(x)
return c[k], k
c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
N, M = list(map(int, input().split()))
A = list(map(f, input().split()))
A = sorted(A, key=lambda x: x[0] * 10 - x[1])
# 数字を作成するのに必要なマッチ数のリストを作成
b = []
dic = {}
n = 0
for d in A:
if n != d[0]:
b.append(d[0])
n = d[0]
dic[n] = d[1]
ans = [0] * b[0]
n = b[0]
while True:
max_ = 0
for d in b:
if n - d == 0:
if dic[d] > max_:
max_ = dic[d]
elif n - d > 0 and ans[n - d] > 0:
t = ans[n - d] * 10 + dic[d]
max_ = max(max_, t)
if n == N:
print(max_)
break
ans.append(max_)
n += 1
|
def f(x):
k = int(x)
return c[k], k
c = [0, 2, 5, 5, 4, 5, 6, 3, 7, 6]
N, M = list(map(int, input().split()))
A = list(map(f, input().split()))
A = sorted(A, key=lambda x: x[0] * 10 - x[1])
b = []
dic = {}
n = 0
for d in A:
if n != d[0]:
b.append(d[0])
n = d[0]
dic[n] = d[1]
ans = [0] * b[0]
n = b[0]
count = 0
while True:
max_ = 0
for d in b:
if n - d == 0:
if dic[d] > max_:
max_ = dic[d]
elif n - d > 0 and ans[n - d] > 0:
t = ans[n - d] * 10 + dic[d]
max_ = max(max_, t)
if n == N:
print(max_)
break
if max_ > 0 and (N - n) % b[0] == 0:
if count < 2:
count += 1
else:
print(
(
"".join(
sorted(
list(str(max_) + str(dic[b[0]]) * ((N - n) // b[0])),
reverse=True,
)
)
)
)
break
ans.append(max_)
n += 1
| false | 13.953488 |
[
"-# 数字を作成するのに必要なマッチ数のリストを作成",
"+count = 0",
"+ if max_ > 0 and (N - n) % b[0] == 0:",
"+ if count < 2:",
"+ count += 1",
"+ else:",
"+ print(",
"+ (",
"+ \"\".join(",
"+ sorted(",
"+ list(str(max_) + str(dic[b[0]]) * ((N - n) // b[0])),",
"+ reverse=True,",
"+ )",
"+ )",
"+ )",
"+ )",
"+ break"
] | false | 0.087555 | 0.062915 | 1.391636 |
[
"s862053879",
"s345249964"
] |
u052499405
|
p03158
|
python
|
s626597263
|
s784229117
| 1,382 | 1,236 | 96,108 | 96,108 |
Accepted
|
Accepted
| 10.56 |
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
l = 0
r = n - 1
# l: aoki takes, r: takahashi takes
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans])))
|
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i+1] = sum_odd[i] + a[i]
sum_even[i+1] = sum_even[i]
else:
sum_even[i+1] = sum_even[i] + a[i]
sum_odd[i+1] = sum_odd[i]
sum_all[i+1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
x = int(eval(input()))
# Get div of aoki - takahashi
# l: aoki takes, r: takahashi takes
l = 0; r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans])))
| 56 | 55 | 1,429 | 1,425 |
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i + 1] = sum_odd[i] + a[i]
sum_even[i + 1] = sum_even[i]
else:
sum_even[i + 1] = sum_even[i] + a[i]
sum_odd[i + 1] = sum_odd[i]
sum_all[i + 1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
# Get div of aoki - takahashi
x = int(eval(input()))
l = 0
r = n - 1
# l: aoki takes, r: takahashi takes
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans])))
|
import bisect
import sys
input = sys.stdin.readline
INF = 10**12
n, q = [int(item) for item in input().split()]
a = [int(item) for item in input().split()]
# Calc cumrative sum
sum_even = [0] * (n + 1)
sum_odd = [0] * (n + 1)
sum_all = [0] * (n + 1)
for i, item in enumerate(a):
if i % 2 == 0:
sum_odd[i + 1] = sum_odd[i] + a[i]
sum_even[i + 1] = sum_even[i]
else:
sum_even[i + 1] = sum_even[i] + a[i]
sum_odd[i + 1] = sum_odd[i]
sum_all[i + 1] = sum_all[i] + a[i]
# Iterate in query
a.append(INF)
ans = []
for i in range(q):
x = int(eval(input()))
# Get div of aoki - takahashi
# l: aoki takes, r: takahashi takes
l = 0
r = n - 1
while r - l > 1:
m = (r + l) // 2
rng = abs(x - a[m])
t_num = n - m
a_num = n - t_num - (bisect.bisect_left(a, x - rng))
if t_num <= a_num + 1:
r = m
else:
l = m
rng = abs(x - a[r])
t_num = n - r
rest = n - 2 * t_num
t_sum = sum_all[n] - sum_all[n - t_num]
a_sum = sum_all[r] - sum_all[r - t_num]
# Add stripe area
if n - t_num * 2 > 0:
if rest % 2 == 0:
t_sum += sum_even[rest]
a_sum += sum_odd[rest]
else:
t_sum += sum_odd[rest]
a_sum += sum_even[rest]
ans.append(t_sum)
print(("\n".join([str(item) for item in ans])))
| false | 1.785714 |
[
"+ x = int(eval(input()))",
"- x = int(eval(input()))",
"+ # l: aoki takes, r: takahashi takes",
"- # l: aoki takes, r: takahashi takes"
] | false | 0.04581 | 0.04068 | 1.126117 |
[
"s626597263",
"s784229117"
] |
u413659369
|
p02617
|
python
|
s801311317
|
s754358895
| 587 | 533 | 27,112 | 26,876 |
Accepted
|
Accepted
| 9.2 |
import numpy as np
N = int(eval(input()))
num = 0
for i in range(1, N+1):
num += i * (N+1-i)
for _ in range(N-1):
u, v = list(map(int, input().split()))
x, y = min(u, v), max(u, v)
num -= (N+1-y) * x
print(num)
|
import numpy as np
N = int(eval(input()))
num = 0
for i in range(1, N+1):
num += i * (N+1-i)
for _ in range(N-1):
u, v = sorted(map(int, input().split()))
num -= (N+1-v) * u
print(num)
| 10 | 9 | 215 | 192 |
import numpy as np
N = int(eval(input()))
num = 0
for i in range(1, N + 1):
num += i * (N + 1 - i)
for _ in range(N - 1):
u, v = list(map(int, input().split()))
x, y = min(u, v), max(u, v)
num -= (N + 1 - y) * x
print(num)
|
import numpy as np
N = int(eval(input()))
num = 0
for i in range(1, N + 1):
num += i * (N + 1 - i)
for _ in range(N - 1):
u, v = sorted(map(int, input().split()))
num -= (N + 1 - v) * u
print(num)
| false | 10 |
[
"- u, v = list(map(int, input().split()))",
"- x, y = min(u, v), max(u, v)",
"- num -= (N + 1 - y) * x",
"+ u, v = sorted(map(int, input().split()))",
"+ num -= (N + 1 - v) * u"
] | false | 0.154397 | 0.041595 | 3.711925 |
[
"s801311317",
"s754358895"
] |
u729133443
|
p03307
|
python
|
s528346404
|
s371365034
| 34 | 27 | 27,500 | 9,148 |
Accepted
|
Accepted
| 20.59 |
a=eval(input());print(a+a%2*a)
|
n=int(eval(input()))
print((n+n%2*n))
| 1 | 2 | 23 | 30 |
a = eval(input())
print(a + a % 2 * a)
|
n = int(eval(input()))
print((n + n % 2 * n))
| false | 50 |
[
"-a = eval(input())",
"-print(a + a % 2 * a)",
"+n = int(eval(input()))",
"+print((n + n % 2 * n))"
] | false | 0.044036 | 0.03603 | 1.22219 |
[
"s528346404",
"s371365034"
] |
u564902833
|
p03031
|
python
|
s898952639
|
s419151383
| 28 | 25 | 3,064 | 3,064 |
Accepted
|
Accepted
| 10.71 |
from itertools import product
N, M = list(map(int, input().split()))
k = []
s = []
for _ in range(M):
t = list(map(int, input().split()))
k.append(t[0])
s.append(t[1:])
p = list(map(int, input().split()))
ans = sum(
all(
sum(
t[j - 1]
for j in s[i]
) % 2 == p[i]
for i in range(M)
)
for t in product(list(range(2)), repeat=N)
)
print(ans)
|
from itertools import product
# 入力
N, M = list(map(int, input().split()))
k, s = list(zip(
*(
(int(k), list(map(int, s.split())))
for _ in range(M)
for k, s in [input().split(maxsplit=1)]
)
))
p = list(map(int, input().split()))
# 全探索で解を求める
ans = sum(
all(
sum(t[j - 1] for j in S) % 2 == P
for S, P in zip(s, p)
)
for t in product(list(range(2)), repeat=N)
)
# 出力
print(ans)
| 25 | 24 | 428 | 444 |
from itertools import product
N, M = list(map(int, input().split()))
k = []
s = []
for _ in range(M):
t = list(map(int, input().split()))
k.append(t[0])
s.append(t[1:])
p = list(map(int, input().split()))
ans = sum(
all(sum(t[j - 1] for j in s[i]) % 2 == p[i] for i in range(M))
for t in product(list(range(2)), repeat=N)
)
print(ans)
|
from itertools import product
# 入力
N, M = list(map(int, input().split()))
k, s = list(
zip(
*(
(int(k), list(map(int, s.split())))
for _ in range(M)
for k, s in [input().split(maxsplit=1)]
)
)
)
p = list(map(int, input().split()))
# 全探索で解を求める
ans = sum(
all(sum(t[j - 1] for j in S) % 2 == P for S, P in zip(s, p))
for t in product(list(range(2)), repeat=N)
)
# 出力
print(ans)
| false | 4 |
[
"+# 入力",
"-k = []",
"-s = []",
"-for _ in range(M):",
"- t = list(map(int, input().split()))",
"- k.append(t[0])",
"- s.append(t[1:])",
"+k, s = list(",
"+ zip(",
"+ *(",
"+ (int(k), list(map(int, s.split())))",
"+ for _ in range(M)",
"+ for k, s in [input().split(maxsplit=1)]",
"+ )",
"+ )",
"+)",
"+# 全探索で解を求める",
"- all(sum(t[j - 1] for j in s[i]) % 2 == p[i] for i in range(M))",
"+ all(sum(t[j - 1] for j in S) % 2 == P for S, P in zip(s, p))",
"+# 出力"
] | false | 0.072111 | 0.035915 | 2.007833 |
[
"s898952639",
"s419151383"
] |
u130900604
|
p02722
|
python
|
s893007760
|
s939436408
| 688 | 211 | 3,064 | 3,188 |
Accepted
|
Accepted
| 69.33 |
def MI():return list(map(int,input().split()))
def LI():return list(MI())
# n,k,c=MI()
# s=input()
"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
n=int(eval(input()))
l=[]
yakusuu=(make_divisors(n-1))
for k in range(2,min(10**6,n)+1):
NN=int(n)
while NN>=k:
if NN%k==0:
NN=NN//k
else:
NN=NN%k
if NN==1:
l+=k,
ll=(l+yakusuu+[n])
print((len(set(ll))))
|
def MI():return list(map(int,input().split()))
def LI():return list(MI())
def factorization(n):
arr=[]
temp=n
for i in range(2,int(n**0.5)+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp//=i
arr.append([i,cnt])
if temp!=1:arr.append([temp,1])
if arr==[]:arr.append([n,1])
return arr
def make_divisors(n):
divisors=[]
for i in range(1,int(n**0.5)+1):
if n%i==0:
divisors.append(i)
if i!=n//i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
n=int(eval(input()))
l=[]
for k in make_divisors(n):
NN=int(n)
while NN>=k:
if NN%k==0:
NN=NN//k
else:
NN=NN%k
if NN==1:l+=k,
ll=(l+make_divisors(n-1))
print((len(ll)))
| 57 | 42 | 1,063 | 771 |
def MI():
return list(map(int, input().split()))
def LI():
return list(MI())
# n,k,c=MI()
# s=input()
"""nを素因数分解"""
"""2以上の整数n => [[素因数, 指数], ...]の2次元リスト"""
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-(n**0.5) // 1)) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors[1:]
n = int(eval(input()))
l = []
yakusuu = make_divisors(n - 1)
for k in range(2, min(10**6, n) + 1):
NN = int(n)
while NN >= k:
if NN % k == 0:
NN = NN // k
else:
NN = NN % k
if NN == 1:
l += (k,)
ll = l + yakusuu + [n]
print((len(set(ll))))
|
def MI():
return list(map(int, input().split()))
def LI():
return list(MI())
def factorization(n):
arr = []
temp = n
for i in range(2, int(n**0.5) + 1):
if temp % i == 0:
cnt = 0
while temp % i == 0:
cnt += 1
temp //= i
arr.append([i, cnt])
if temp != 1:
arr.append([temp, 1])
if arr == []:
arr.append([n, 1])
return arr
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n // i)
divisors.sort()
return divisors[1:]
n = int(eval(input()))
l = []
for k in make_divisors(n):
NN = int(n)
while NN >= k:
if NN % k == 0:
NN = NN // k
else:
NN = NN % k
if NN == 1:
l += (k,)
ll = l + make_divisors(n - 1)
print((len(ll)))
| false | 26.315789 |
[
"-# n,k,c=MI()",
"-# s=input()",
"-\"\"\"nを素因数分解\"\"\"",
"-\"\"\"2以上の整数n => [[素因数, 指数], ...]の2次元リスト\"\"\"",
"-",
"-",
"- for i in range(2, int(-(-(n**0.5) // 1)) + 1):",
"+ for i in range(2, int(n**0.5) + 1):",
"-yakusuu = make_divisors(n - 1)",
"-for k in range(2, min(10**6, n) + 1):",
"+for k in make_divisors(n):",
"-ll = l + yakusuu + [n]",
"-print((len(set(ll))))",
"+ll = l + make_divisors(n - 1)",
"+print((len(ll)))"
] | false | 0.373002 | 0.14905 | 2.502523 |
[
"s893007760",
"s939436408"
] |
u016881126
|
p02629
|
python
|
s406757422
|
s480608992
| 34 | 28 | 9,200 | 9,208 |
Accepted
|
Accepted
| 17.65 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')
N = int(eval(input()))
komoji = [chr(i) for i in range(97, 97+26)]
ans = ""
# print(N)
while True:
q, mod = divmod(N, 26)
ans = komoji[mod-1] + ans
# print("q: {} mod: {} ans: {}".format(q, mod, ans))
if mod == 0:
q = q - 1
N = q
if q == 0:
break
print(ans)
|
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10 ** 7)
INF = float('inf')
N = int(eval(input()))
komoji = [chr(i) for i in range(97, 97+26)]
ans = ""
# print(N)
while True:
N -= 1
q, mod = divmod(N, 26)
ans = komoji[mod] + ans
# print("q: {} mod: {} ans: {}".format(q, mod, ans))
if q == 0:
break
N = q
print(ans)
| 22 | 21 | 480 | 453 |
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10**7)
INF = float("inf")
N = int(eval(input()))
komoji = [chr(i) for i in range(97, 97 + 26)]
ans = ""
# print(N)
while True:
q, mod = divmod(N, 26)
ans = komoji[mod - 1] + ans
# print("q: {} mod: {} ans: {}".format(q, mod, ans))
if mod == 0:
q = q - 1
N = q
if q == 0:
break
print(ans)
|
import sys
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
read = sys.stdin.buffer.read
sys.setrecursionlimit(10**7)
INF = float("inf")
N = int(eval(input()))
komoji = [chr(i) for i in range(97, 97 + 26)]
ans = ""
# print(N)
while True:
N -= 1
q, mod = divmod(N, 26)
ans = komoji[mod] + ans
# print("q: {} mod: {} ans: {}".format(q, mod, ans))
if q == 0:
break
N = q
print(ans)
| false | 4.545455 |
[
"+ N -= 1",
"- ans = komoji[mod - 1] + ans",
"+ ans = komoji[mod] + ans",
"- if mod == 0:",
"- q = q - 1",
"- N = q",
"+ N = q"
] | false | 0.076715 | 0.069045 | 1.111079 |
[
"s406757422",
"s480608992"
] |
u757117214
|
p03244
|
python
|
s962990308
|
s342983266
| 104 | 82 | 21,984 | 18,528 |
Accepted
|
Accepted
| 21.15 |
n,*v = list(map(int,open(0).read().split()))
v0,v1 = {},{}
flg = True
for i in v:
if flg:
v0[i]= v0[i]+1 if i in v0 else 1
else:
v1[i]= v1[i]+1 if i in v1 else 1
flg = not flg
len0,len1 = len(v0),len(v1)
if len0==1 and len1==1:
if list(v0.keys()) != list(v1.keys()):
print((0))
else:
sv = sorted(v1.values())[0]
print(sv)
elif len0 == 1:
sort_v1 = sorted(list(v1.items()),key=lambda x:x[1])
sum1 = sum(v1.values())
print((sum1 - max(v1.values())))
elif len1 == 1:
sort_v0 = sorted(list(v0.items()),key=lambda x:x[1])
sum0 = sum(v0.values())
print((sum0 - max(v0.values())))
else:
sort_v1 = sorted(list(v1.items()),key=lambda x:x[1])
sort_v0 = sorted(list(v0.items()),key=lambda x:x[1])
#print(sort_v0,sort_v1)
if sort_v0[-1][0] != sort_v1[-1][0]:
sum0 = sum(v0.values()) - sort_v0[-1][1]
sum1 = sum(v1.values()) - sort_v1[-1][1]
print((sum0 + sum1))
else:
sum0 = sum(v0.values())
sum1 = sum(v1.values())
sum0_1 = sum0 - sort_v0[-1][1]
sum0_2 = sum0 - sort_v0[-2][1]
sum1_1 = sum1 - sort_v1[-1][1]
sum1_2 = sum1 - sort_v1[-2][1]
print((min(sum0_1 + sum1_2 , sum0_2 + sum1_1)))
|
from collections import Counter
n,*v = list(map(int,open(0).read().split()))
v0,v1 = Counter(v[::2]),Counter(v[1::2])
len0,len1 = len(v0),len(v1)
if len0==1 and len1==1:
if list(v0.keys()) != list(v1.keys()):
print((0))
else:
sv = sorted(v1.values())[0]
print(sv)
elif len0 == 1:
print((sum(v1.values()) - max(v1.values())))
elif len1 == 1:
print((sum(v0.values()) - max(v0.values())))
else:
v0_1,v0_2 = v0.most_common(2)
v1_1,v1_2 = v1.most_common(2)
if v0_1[0] != v1_1[0]:
sum0 = sum(v0.values()) - v0_1[1]
sum1 = sum(v1.values()) - v1_1[1]
print((sum0 + sum1))
else:
sum0 = sum(v0.values())
sum1 = sum(v1.values())
sum0_1 = sum0 - v0_1[1]
sum0_2 = sum0 - v0_2[1]
sum1_1 = sum1 - v1_1[1]
sum1_2 = sum1 - v1_2[1]
print((min(sum0_1 + sum1_2 , sum0_2 + sum1_1)))
| 41 | 30 | 1,253 | 899 |
n, *v = list(map(int, open(0).read().split()))
v0, v1 = {}, {}
flg = True
for i in v:
if flg:
v0[i] = v0[i] + 1 if i in v0 else 1
else:
v1[i] = v1[i] + 1 if i in v1 else 1
flg = not flg
len0, len1 = len(v0), len(v1)
if len0 == 1 and len1 == 1:
if list(v0.keys()) != list(v1.keys()):
print((0))
else:
sv = sorted(v1.values())[0]
print(sv)
elif len0 == 1:
sort_v1 = sorted(list(v1.items()), key=lambda x: x[1])
sum1 = sum(v1.values())
print((sum1 - max(v1.values())))
elif len1 == 1:
sort_v0 = sorted(list(v0.items()), key=lambda x: x[1])
sum0 = sum(v0.values())
print((sum0 - max(v0.values())))
else:
sort_v1 = sorted(list(v1.items()), key=lambda x: x[1])
sort_v0 = sorted(list(v0.items()), key=lambda x: x[1])
# print(sort_v0,sort_v1)
if sort_v0[-1][0] != sort_v1[-1][0]:
sum0 = sum(v0.values()) - sort_v0[-1][1]
sum1 = sum(v1.values()) - sort_v1[-1][1]
print((sum0 + sum1))
else:
sum0 = sum(v0.values())
sum1 = sum(v1.values())
sum0_1 = sum0 - sort_v0[-1][1]
sum0_2 = sum0 - sort_v0[-2][1]
sum1_1 = sum1 - sort_v1[-1][1]
sum1_2 = sum1 - sort_v1[-2][1]
print((min(sum0_1 + sum1_2, sum0_2 + sum1_1)))
|
from collections import Counter
n, *v = list(map(int, open(0).read().split()))
v0, v1 = Counter(v[::2]), Counter(v[1::2])
len0, len1 = len(v0), len(v1)
if len0 == 1 and len1 == 1:
if list(v0.keys()) != list(v1.keys()):
print((0))
else:
sv = sorted(v1.values())[0]
print(sv)
elif len0 == 1:
print((sum(v1.values()) - max(v1.values())))
elif len1 == 1:
print((sum(v0.values()) - max(v0.values())))
else:
v0_1, v0_2 = v0.most_common(2)
v1_1, v1_2 = v1.most_common(2)
if v0_1[0] != v1_1[0]:
sum0 = sum(v0.values()) - v0_1[1]
sum1 = sum(v1.values()) - v1_1[1]
print((sum0 + sum1))
else:
sum0 = sum(v0.values())
sum1 = sum(v1.values())
sum0_1 = sum0 - v0_1[1]
sum0_2 = sum0 - v0_2[1]
sum1_1 = sum1 - v1_1[1]
sum1_2 = sum1 - v1_2[1]
print((min(sum0_1 + sum1_2, sum0_2 + sum1_1)))
| false | 26.829268 |
[
"+from collections import Counter",
"+",
"-v0, v1 = {}, {}",
"-flg = True",
"-for i in v:",
"- if flg:",
"- v0[i] = v0[i] + 1 if i in v0 else 1",
"- else:",
"- v1[i] = v1[i] + 1 if i in v1 else 1",
"- flg = not flg",
"+v0, v1 = Counter(v[::2]), Counter(v[1::2])",
"- sort_v1 = sorted(list(v1.items()), key=lambda x: x[1])",
"- sum1 = sum(v1.values())",
"- print((sum1 - max(v1.values())))",
"+ print((sum(v1.values()) - max(v1.values())))",
"- sort_v0 = sorted(list(v0.items()), key=lambda x: x[1])",
"- sum0 = sum(v0.values())",
"- print((sum0 - max(v0.values())))",
"+ print((sum(v0.values()) - max(v0.values())))",
"- sort_v1 = sorted(list(v1.items()), key=lambda x: x[1])",
"- sort_v0 = sorted(list(v0.items()), key=lambda x: x[1])",
"- # print(sort_v0,sort_v1)",
"- if sort_v0[-1][0] != sort_v1[-1][0]:",
"- sum0 = sum(v0.values()) - sort_v0[-1][1]",
"- sum1 = sum(v1.values()) - sort_v1[-1][1]",
"+ v0_1, v0_2 = v0.most_common(2)",
"+ v1_1, v1_2 = v1.most_common(2)",
"+ if v0_1[0] != v1_1[0]:",
"+ sum0 = sum(v0.values()) - v0_1[1]",
"+ sum1 = sum(v1.values()) - v1_1[1]",
"- sum0_1 = sum0 - sort_v0[-1][1]",
"- sum0_2 = sum0 - sort_v0[-2][1]",
"- sum1_1 = sum1 - sort_v1[-1][1]",
"- sum1_2 = sum1 - sort_v1[-2][1]",
"+ sum0_1 = sum0 - v0_1[1]",
"+ sum0_2 = sum0 - v0_2[1]",
"+ sum1_1 = sum1 - v1_1[1]",
"+ sum1_2 = sum1 - v1_2[1]"
] | false | 0.044659 | 0.04388 | 1.017759 |
[
"s962990308",
"s342983266"
] |
u423585790
|
p02691
|
python
|
s277539300
|
s376647226
| 334 | 215 | 151,960 | 151,724 |
Accepted
|
Accepted
| 35.63 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
n = II()
a = LI()
d = defaultdict(int)
for i in range(n):
d[a[i] + i + 1] += 1
ans = 0
for i in range(n):
x = i + 1 - a[i]
ans += d[x]
print(ans)
return
#main
if __name__ == '__main__':
solve()
|
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def S(): return input().rstrip()
def LS(): return S().split()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
#solve
def solve():
n = II()
a = LI()
d = defaultdict(int)
ans = 0
for i in range(n):
x = i + 1 - a[i]
ans += d[x]
d[a[i] + i + 1] += 1
print(ans)
return
#main
if __name__ == '__main__':
solve()
| 43 | 42 | 1,205 | 1,181 |
#!/usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI():
return list(map(int, input().split()))
def LF():
return list(map(float, input().split()))
def LI_():
return list([int(x) - 1 for x in input().split()])
def II():
return int(eval(input()))
def IF():
return float(eval(input()))
def S():
return input().rstrip()
def LS():
return S().split()
def IR(n):
return [II() for _ in range(n)]
def LIR(n):
return [LI() for _ in range(n)]
def FR(n):
return [IF() for _ in range(n)]
def LFR(n):
return [LI() for _ in range(n)]
def LIR_(n):
return [LI_() for _ in range(n)]
def SR(n):
return [S() for _ in range(n)]
def LSR(n):
return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
# solve
def solve():
n = II()
a = LI()
d = defaultdict(int)
for i in range(n):
d[a[i] + i + 1] += 1
ans = 0
for i in range(n):
x = i + 1 - a[i]
ans += d[x]
print(ans)
return
# main
if __name__ == "__main__":
solve()
|
#!/usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI():
return list(map(int, input().split()))
def LF():
return list(map(float, input().split()))
def LI_():
return list([int(x) - 1 for x in input().split()])
def II():
return int(eval(input()))
def IF():
return float(eval(input()))
def S():
return input().rstrip()
def LS():
return S().split()
def IR(n):
return [II() for _ in range(n)]
def LIR(n):
return [LI() for _ in range(n)]
def FR(n):
return [IF() for _ in range(n)]
def LFR(n):
return [LI() for _ in range(n)]
def LIR_(n):
return [LI_() for _ in range(n)]
def SR(n):
return [S() for _ in range(n)]
def LSR(n):
return [LS() for _ in range(n)]
mod = 1000000007
inf = float("INF")
# solve
def solve():
n = II()
a = LI()
d = defaultdict(int)
ans = 0
for i in range(n):
x = i + 1 - a[i]
ans += d[x]
d[a[i] + i + 1] += 1
print(ans)
return
# main
if __name__ == "__main__":
solve()
| false | 2.325581 |
[
"- for i in range(n):",
"- d[a[i] + i + 1] += 1",
"+ d[a[i] + i + 1] += 1"
] | false | 0.045518 | 0.136574 | 0.333288 |
[
"s277539300",
"s376647226"
] |
u055941944
|
p03730
|
python
|
s045326605
|
s754347396
| 225 | 34 | 2,940 | 2,940 |
Accepted
|
Accepted
| 84.89 |
# -*- coding utf-8 -*-
a,b,c=list(map(int,input().split()))
ans="NO"
for i in range(1000000):
if (a*i-c)%b==0:
ans='YES'
break
print(ans)
|
a,b,c=list(map(int,input().split()))
ans="NO"
for i in range (100000):
if a*i%b==c:
ans="YES"
break
print(ans)
| 9 | 9 | 161 | 135 |
# -*- coding utf-8 -*-
a, b, c = list(map(int, input().split()))
ans = "NO"
for i in range(1000000):
if (a * i - c) % b == 0:
ans = "YES"
break
print(ans)
|
a, b, c = list(map(int, input().split()))
ans = "NO"
for i in range(100000):
if a * i % b == c:
ans = "YES"
break
print(ans)
| false | 0 |
[
"-# -*- coding utf-8 -*-",
"-for i in range(1000000):",
"- if (a * i - c) % b == 0:",
"+for i in range(100000):",
"+ if a * i % b == c:"
] | false | 0.007698 | 0.04045 | 0.190304 |
[
"s045326605",
"s754347396"
] |
u693953100
|
p03274
|
python
|
s614101852
|
s281660176
| 113 | 93 | 14,384 | 14,384 |
Accepted
|
Accepted
| 17.7 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9
for i in range(k-1,n):
if x[i]*x[i-k+1]<0:
mn = min(abs(x[i-k+1]),abs(x[i]))
mx = max(abs(x[i-k+1]),abs(x[i]))
ans = min(ans,2*mn+mx)
else:
ans = min(ans, max(abs(x[i-k+1]),abs(x[i])))
print(ans)
|
n,k = list(map(int,input().split()))
x = list(map(int,input().split()))
ans = 10**18
for i in range(n-k+1):
l = x[i]
r = x[i+k-1]
if r<=0:
ans = min(ans,abs(l))
if l*r<0:
ans = min(ans,min(abs(l),abs(r))+r-l)
if l>=0:
ans = min(ans,r)
print(ans)
| 11 | 13 | 326 | 295 |
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**9
for i in range(k - 1, n):
if x[i] * x[i - k + 1] < 0:
mn = min(abs(x[i - k + 1]), abs(x[i]))
mx = max(abs(x[i - k + 1]), abs(x[i]))
ans = min(ans, 2 * mn + mx)
else:
ans = min(ans, max(abs(x[i - k + 1]), abs(x[i])))
print(ans)
|
n, k = list(map(int, input().split()))
x = list(map(int, input().split()))
ans = 10**18
for i in range(n - k + 1):
l = x[i]
r = x[i + k - 1]
if r <= 0:
ans = min(ans, abs(l))
if l * r < 0:
ans = min(ans, min(abs(l), abs(r)) + r - l)
if l >= 0:
ans = min(ans, r)
print(ans)
| false | 15.384615 |
[
"-ans = 10**9",
"-for i in range(k - 1, n):",
"- if x[i] * x[i - k + 1] < 0:",
"- mn = min(abs(x[i - k + 1]), abs(x[i]))",
"- mx = max(abs(x[i - k + 1]), abs(x[i]))",
"- ans = min(ans, 2 * mn + mx)",
"- else:",
"- ans = min(ans, max(abs(x[i - k + 1]), abs(x[i])))",
"+ans = 10**18",
"+for i in range(n - k + 1):",
"+ l = x[i]",
"+ r = x[i + k - 1]",
"+ if r <= 0:",
"+ ans = min(ans, abs(l))",
"+ if l * r < 0:",
"+ ans = min(ans, min(abs(l), abs(r)) + r - l)",
"+ if l >= 0:",
"+ ans = min(ans, r)"
] | false | 0.036468 | 0.037382 | 0.975541 |
[
"s614101852",
"s281660176"
] |
u939585142
|
p03408
|
python
|
s923853525
|
s018763030
| 21 | 18 | 3,316 | 3,064 |
Accepted
|
Accepted
| 14.29 |
from collections import Counter
N = int(eval(input()))
s = [eval(input()) for i in range(N)]
M = int(eval(input()))
t = [eval(input()) for i in range(M)]
a = Counter(s)
a = a.most_common()
ans = 0
for i in a:
if i[0] not in t:
ans = max(i[1],ans)
elif i[0] in t:
ans = max(i[1] - t.count(i[0]),ans)
print(ans)
|
N = int(eval(input()))
s = [eval(input()) for i in range(N)]
M = int(eval(input()))
t = [eval(input()) for i in range(M)]
ans = 0
for i in s:
ans = max(ans, s.count(i) - t.count(i))
print(ans)
| 20 | 10 | 322 | 181 |
from collections import Counter
N = int(eval(input()))
s = [eval(input()) for i in range(N)]
M = int(eval(input()))
t = [eval(input()) for i in range(M)]
a = Counter(s)
a = a.most_common()
ans = 0
for i in a:
if i[0] not in t:
ans = max(i[1], ans)
elif i[0] in t:
ans = max(i[1] - t.count(i[0]), ans)
print(ans)
|
N = int(eval(input()))
s = [eval(input()) for i in range(N)]
M = int(eval(input()))
t = [eval(input()) for i in range(M)]
ans = 0
for i in s:
ans = max(ans, s.count(i) - t.count(i))
print(ans)
| false | 50 |
[
"-from collections import Counter",
"-",
"-a = Counter(s)",
"-a = a.most_common()",
"-for i in a:",
"- if i[0] not in t:",
"- ans = max(i[1], ans)",
"- elif i[0] in t:",
"- ans = max(i[1] - t.count(i[0]), ans)",
"+for i in s:",
"+ ans = max(ans, s.count(i) - t.count(i))"
] | false | 0.041498 | 0.040813 | 1.016779 |
[
"s923853525",
"s018763030"
] |
u983918956
|
p02973
|
python
|
s811211632
|
s740864206
| 506 | 253 | 8,064 | 8,608 |
Accepted
|
Accepted
| 50 |
from collections import deque
from bisect import bisect_left
inf = float('inf')
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
color = deque()
for a in A:
pos = bisect_left(color, a)
if pos == 0:
color.appendleft(a)
else:
color[pos-1] = a
ans = len(color)
print(ans)
|
from bisect import bisect
inf = float('inf')
# 広義単調増加
def LIS(arr):
N = len(arr)
dp = [inf] * N
res = 0
for a in arr:
pos = bisect(dp,a)
dp[pos] = a
res = max(res, pos + 1)
return res
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
ans = LIS(A[::-1])
print(ans)
| 19 | 19 | 324 | 332 |
from collections import deque
from bisect import bisect_left
inf = float("inf")
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
color = deque()
for a in A:
pos = bisect_left(color, a)
if pos == 0:
color.appendleft(a)
else:
color[pos - 1] = a
ans = len(color)
print(ans)
|
from bisect import bisect
inf = float("inf")
# 広義単調増加
def LIS(arr):
N = len(arr)
dp = [inf] * N
res = 0
for a in arr:
pos = bisect(dp, a)
dp[pos] = a
res = max(res, pos + 1)
return res
N = int(eval(input()))
A = [int(eval(input())) for _ in range(N)]
ans = LIS(A[::-1])
print(ans)
| false | 0 |
[
"-from collections import deque",
"-from bisect import bisect_left",
"+from bisect import bisect",
"+# 広義単調増加",
"+def LIS(arr):",
"+ N = len(arr)",
"+ dp = [inf] * N",
"+ res = 0",
"+ for a in arr:",
"+ pos = bisect(dp, a)",
"+ dp[pos] = a",
"+ res = max(res, pos + 1)",
"+ return res",
"+",
"+",
"-color = deque()",
"-for a in A:",
"- pos = bisect_left(color, a)",
"- if pos == 0:",
"- color.appendleft(a)",
"- else:",
"- color[pos - 1] = a",
"-ans = len(color)",
"+ans = LIS(A[::-1])"
] | false | 0.096003 | 0.040127 | 2.392496 |
[
"s811211632",
"s740864206"
] |
u790710233
|
p02684
|
python
|
s887012016
|
s617556026
| 1,300 | 284 | 202,804 | 176,040 |
Accepted
|
Accepted
| 78.15 |
n, k = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
bit = k.bit_length()
table = [[0]*bit for _ in range(n)]
for i in range(n):
table[i][0] = A[i]
for i in range(1, bit):
for j in range(n):
table[j][i] = table[table[j][i-1]][i-1]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[ans][i]
print((ans+1))
|
n, k = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
bit = k.bit_length()
table = [[0]*n for _ in range(bit)]
table[0] = A
for i in range(1, bit):
for j in range(n):
table[i][j] = table[i-1][table[i-1][j]]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[i][ans]
print((ans+1))
| 17 | 16 | 418 | 387 |
n, k = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
bit = k.bit_length()
table = [[0] * bit for _ in range(n)]
for i in range(n):
table[i][0] = A[i]
for i in range(1, bit):
for j in range(n):
table[j][i] = table[table[j][i - 1]][i - 1]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[ans][i]
print((ans + 1))
|
n, k = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
bit = k.bit_length()
table = [[0] * n for _ in range(bit)]
table[0] = A
for i in range(1, bit):
for j in range(n):
table[i][j] = table[i - 1][table[i - 1][j]]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[i][ans]
print((ans + 1))
| false | 5.882353 |
[
"-table = [[0] * bit for _ in range(n)]",
"-for i in range(n):",
"- table[i][0] = A[i]",
"+table = [[0] * n for _ in range(bit)]",
"+table[0] = A",
"- table[j][i] = table[table[j][i - 1]][i - 1]",
"+ table[i][j] = table[i - 1][table[i - 1][j]]",
"- ans = table[ans][i]",
"+ ans = table[i][ans]"
] | false | 0.036096 | 0.035435 | 1.018655 |
[
"s887012016",
"s617556026"
] |
u625007136
|
p02689
|
python
|
s897932673
|
s205065196
| 449 | 374 | 43,048 | 32,820 |
Accepted
|
Accepted
| 16.7 |
import sys
input = sys.stdin.readline
def peaks(n,m,h,ab):
g = [0] * n
path = [ [] for i in range(n)]
#print(ab)
for l,r in ab:
path[l-1].append(r)
path[r-1].append(l)
#print(path)
for i,p in enumerate(path):
if p == []:
g[i] = 1
continue
for j in p:
#print(i+1,j,h[i],h[j-1])
if h[i] > h[j-1]:
g[i] = 1
else:
g[i] = 0
break
print((sum(g)))
if __name__ == "__main__":
n,m = list(map(int,input().split()))
h = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(m)]
ab_sorted = sorted(ab)
peaks(n,m,h,ab_sorted)
|
import sys
input = sys.stdin.readline
def ppp(n,m,h,ab):
g = [1] * n
for l,r in ab:
if h[l-1] >= h[r-1]:
g[r-1] = 0
if h[l-1] <= h[r-1]:
g[l-1] = 0
print((sum(g)))
if __name__ == "__main__":
n,m = list(map(int,input().split()))
h = list(map(int,input().split()))
ab = [list(map(int,input().split())) for _ in range(m)]
ab_sorted = sorted(ab)
ppp(n,m,h,ab_sorted)
| 33 | 17 | 767 | 444 |
import sys
input = sys.stdin.readline
def peaks(n, m, h, ab):
g = [0] * n
path = [[] for i in range(n)]
# print(ab)
for l, r in ab:
path[l - 1].append(r)
path[r - 1].append(l)
# print(path)
for i, p in enumerate(path):
if p == []:
g[i] = 1
continue
for j in p:
# print(i+1,j,h[i],h[j-1])
if h[i] > h[j - 1]:
g[i] = 1
else:
g[i] = 0
break
print((sum(g)))
if __name__ == "__main__":
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab_sorted = sorted(ab)
peaks(n, m, h, ab_sorted)
|
import sys
input = sys.stdin.readline
def ppp(n, m, h, ab):
g = [1] * n
for l, r in ab:
if h[l - 1] >= h[r - 1]:
g[r - 1] = 0
if h[l - 1] <= h[r - 1]:
g[l - 1] = 0
print((sum(g)))
if __name__ == "__main__":
n, m = list(map(int, input().split()))
h = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(m)]
ab_sorted = sorted(ab)
ppp(n, m, h, ab_sorted)
| false | 48.484848 |
[
"-def peaks(n, m, h, ab):",
"- g = [0] * n",
"- path = [[] for i in range(n)]",
"- # print(ab)",
"+def ppp(n, m, h, ab):",
"+ g = [1] * n",
"- path[l - 1].append(r)",
"- path[r - 1].append(l)",
"- # print(path)",
"- for i, p in enumerate(path):",
"- if p == []:",
"- g[i] = 1",
"- continue",
"- for j in p:",
"- # print(i+1,j,h[i],h[j-1])",
"- if h[i] > h[j - 1]:",
"- g[i] = 1",
"- else:",
"- g[i] = 0",
"- break",
"+ if h[l - 1] >= h[r - 1]:",
"+ g[r - 1] = 0",
"+ if h[l - 1] <= h[r - 1]:",
"+ g[l - 1] = 0",
"- peaks(n, m, h, ab_sorted)",
"+ ppp(n, m, h, ab_sorted)"
] | false | 0.055 | 0.03636 | 1.512628 |
[
"s897932673",
"s205065196"
] |
u609061751
|
p02754
|
python
|
s920791959
|
s917140866
| 198 | 174 | 38,256 | 38,384 |
Accepted
|
Accepted
| 12.12 |
import sys
input = sys.stdin.readline
N, A, B = [int(x) for x in input().split()]
AB = A + B
if AB == 0:
print((0))
sys.exit()
ans = A * (N // AB)
ans_mod = N % AB
if ans_mod == 0:
print(ans)
sys.exit()
if ans_mod >= A:
ans += A
elif ans_mod < A:
ans += ans_mod
print(ans)
|
import sys
input = sys.stdin.readline
n, a, b = [int(x) for x in input().split()]
if a == 0:
print((0))
sys.exit()
if b == 0:
print(n)
sys.exit()
ab = a + b
n_ab = n // ab
ans = n_ab * a
remain = n - ab * n_ab
ans += min(a, remain)
print(ans)
| 24 | 24 | 325 | 288 |
import sys
input = sys.stdin.readline
N, A, B = [int(x) for x in input().split()]
AB = A + B
if AB == 0:
print((0))
sys.exit()
ans = A * (N // AB)
ans_mod = N % AB
if ans_mod == 0:
print(ans)
sys.exit()
if ans_mod >= A:
ans += A
elif ans_mod < A:
ans += ans_mod
print(ans)
|
import sys
input = sys.stdin.readline
n, a, b = [int(x) for x in input().split()]
if a == 0:
print((0))
sys.exit()
if b == 0:
print(n)
sys.exit()
ab = a + b
n_ab = n // ab
ans = n_ab * a
remain = n - ab * n_ab
ans += min(a, remain)
print(ans)
| false | 0 |
[
"-N, A, B = [int(x) for x in input().split()]",
"-AB = A + B",
"-if AB == 0:",
"+n, a, b = [int(x) for x in input().split()]",
"+if a == 0:",
"-ans = A * (N // AB)",
"-ans_mod = N % AB",
"-if ans_mod == 0:",
"- print(ans)",
"+if b == 0:",
"+ print(n)",
"-if ans_mod >= A:",
"- ans += A",
"-elif ans_mod < A:",
"- ans += ans_mod",
"+ab = a + b",
"+n_ab = n // ab",
"+ans = n_ab * a",
"+remain = n - ab * n_ab",
"+ans += min(a, remain)"
] | false | 0.037579 | 0.038709 | 0.970814 |
[
"s920791959",
"s917140866"
] |
u833070958
|
p03013
|
python
|
s217680651
|
s748872365
| 498 | 187 | 47,344 | 7,888 |
Accepted
|
Accepted
| 62.45 |
N, M = list(map(int, input().split()))
A = [True for i in range(N + 1)]
dp = [0 for i in range(N + 2)]
for i in range(M):
a = int(eval(input()))
A[a] = False
dp[0] = 1
for i in range(N):
if A[i] == 0:
continue
dp[i + 1] += dp[i]
dp[i + 1] %= 1000000007
dp[i + 2] += dp[i]
dp[i + 2] %= 1000000007
print((dp[N]))
|
N, M = list(map(int, input().split()))
A = [True for i in range(N + 2)]
dp = [0 for i in range(N + 3)]
for i in range(M):
a = int(eval(input()))
A[a] = False
dp[0] = 1
for i in range(N):
if A[i] == False:
continue
dp[i + 1] += dp[i]
dp[i + 1] %= 1000000007
dp[i + 2] += dp[i]
dp[i + 2] %= 1000000007
print((dp[N]))
| 20 | 20 | 357 | 361 |
N, M = list(map(int, input().split()))
A = [True for i in range(N + 1)]
dp = [0 for i in range(N + 2)]
for i in range(M):
a = int(eval(input()))
A[a] = False
dp[0] = 1
for i in range(N):
if A[i] == 0:
continue
dp[i + 1] += dp[i]
dp[i + 1] %= 1000000007
dp[i + 2] += dp[i]
dp[i + 2] %= 1000000007
print((dp[N]))
|
N, M = list(map(int, input().split()))
A = [True for i in range(N + 2)]
dp = [0 for i in range(N + 3)]
for i in range(M):
a = int(eval(input()))
A[a] = False
dp[0] = 1
for i in range(N):
if A[i] == False:
continue
dp[i + 1] += dp[i]
dp[i + 1] %= 1000000007
dp[i + 2] += dp[i]
dp[i + 2] %= 1000000007
print((dp[N]))
| false | 0 |
[
"-A = [True for i in range(N + 1)]",
"-dp = [0 for i in range(N + 2)]",
"+A = [True for i in range(N + 2)]",
"+dp = [0 for i in range(N + 3)]",
"- if A[i] == 0:",
"+ if A[i] == False:"
] | false | 0.098341 | 0.035154 | 2.797438 |
[
"s217680651",
"s748872365"
] |
u974788383
|
p01125
|
python
|
s036827131
|
s090777447
| 90 | 80 | 7,840 | 7,916 |
Accepted
|
Accepted
| 11.11 |
def between(x, y, a):
lrg = max(x, y)
sml = min(x, y)
if (sml <= a <= lrg):
return True
else:
return False
while (True):
pos = [10, 10]
result = 'No'
N = int(input()) # Total number of jewels
if N == 0:
break
jewelPositions = list()
for i in range(N):
jewelPos = list(map(int, input().split()))
jewelPositions.append(jewelPos)
M = int(input()) # Number of instructions
# instructions = list()
for i in range(M):
# print('==== Currently at ', pos)
instruction = input().split()
# print('instruction : ', i)
if (result == 'Yes'):
continue
instruction[1] = int(instruction[1])
if (instruction[0] == 'E'):
move = ('x', instruction[1])
elif (instruction[0] == 'W'):
move = ('x', -1*instruction[1])
elif (instruction[0] == 'N'):
move = ('y', instruction[1])
elif (instruction[0] == 'S'):
move = ('y', -1*instruction[1])
else:
raise NotImplementedError
# print('>>>>>>>>>>>>>>> pos: ', pos, ', move: ', move)
jewelToRemove = []
for jewel in jewelPositions:
'''
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (pos[0] <= jewel[0] <= pos[0]+move[1])) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (pos[1] <= jewel[1] <= pos[1]+move[1])):
'''
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (between(0, move[1], jewel[0]-pos[0]))) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (between(0, move[1], jewel[1]-pos[1]))):
# print('---- Collecting a jewel at ', jewel)
# jewelPositions.remove(jewel)
jewelToRemove.append(jewel)
else:
# print('xxxx Jewel not collected at ', jewel)
pass
for jewel in jewelToRemove:
jewelPositions.remove(jewel)
if (move[0] == 'x'):
pos[0] += move[1]
elif (move[0] == 'y'):
pos[1] += move[1]
if not jewelPositions:
"""
if empty,
all jewels are collected
"""
result = 'Yes'
else:
pass
# print('jewels are left at ', jewelPositions)
print(result)
"""
2
10 11
11 12
2
N 2
E 1
2
10 11
11 12
2
N 2
W 1
3
0 15
5 10
5 15
5
W 10
S 10
N 20
E 10
S 10
0
"""
|
def between(x, y, a):
lrg = max(x, y)
sml = min(x, y)
if (sml <= a <= lrg):
return True
else:
return False
while (True):
pos = [10, 10]
result = 'No'
N = int(input()) # Total number of jewels
if N == 0:
break
jewelPositions = list()
for i in range(N):
jewelPos = list(map(int, input().split()))
jewelPositions.append(jewelPos)
M = int(input()) # Number of instructions
# instructions = list()
for i in range(M):
# print('==== Currently at ', pos)
instruction = input().split()
# print('instruction : ', i)
if (result == 'Yes'):
continue
instruction[1] = int(instruction[1])
if (instruction[0] == 'E'):
move = ('x', instruction[1])
elif (instruction[0] == 'W'):
move = ('x', -1*instruction[1])
elif (instruction[0] == 'N'):
move = ('y', instruction[1])
elif (instruction[0] == 'S'):
move = ('y', -1*instruction[1])
else:
raise NotImplementedError
# print('>>>>>>>>>>>>>>> pos: ', pos, ', move: ', move)
jewelToRemove = []
for jewel in jewelPositions:
'''
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (pos[0] <= jewel[0] <= pos[0]+move[1])) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (pos[1] <= jewel[1] <= pos[1]+move[1])):
'''
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (between(0, move[1], jewel[0]-pos[0]))) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (between(0, move[1], jewel[1]-pos[1]))):
# print('---- Collecting a jewel at ', jewel)
# jewelPositions.remove(jewel)
jewelToRemove.append(jewel)
else:
# print('xxxx Jewel not collected at ', jewel)
pass
for jewel in jewelToRemove:
jewelPositions.remove(jewel)
if (move[0] == 'x'):
pos[0] += move[1]
elif (move[0] == 'y'):
pos[1] += move[1]
if not jewelPositions:
"""
if empty,
all jewels are collected
"""
result = 'Yes'
else:
pass
# print('jewels are left at ', jewelPositions)
print(result)
| 102 | 76 | 2,597 | 2,468 |
def between(x, y, a):
lrg = max(x, y)
sml = min(x, y)
if sml <= a <= lrg:
return True
else:
return False
while True:
pos = [10, 10]
result = "No"
N = int(input()) # Total number of jewels
if N == 0:
break
jewelPositions = list()
for i in range(N):
jewelPos = list(map(int, input().split()))
jewelPositions.append(jewelPos)
M = int(input()) # Number of instructions
# instructions = list()
for i in range(M):
# print('==== Currently at ', pos)
instruction = input().split()
# print('instruction : ', i)
if result == "Yes":
continue
instruction[1] = int(instruction[1])
if instruction[0] == "E":
move = ("x", instruction[1])
elif instruction[0] == "W":
move = ("x", -1 * instruction[1])
elif instruction[0] == "N":
move = ("y", instruction[1])
elif instruction[0] == "S":
move = ("y", -1 * instruction[1])
else:
raise NotImplementedError
# print('>>>>>>>>>>>>>>> pos: ', pos, ', move: ', move)
jewelToRemove = []
for jewel in jewelPositions:
"""
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (pos[0] <= jewel[0] <= pos[0]+move[1])) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (pos[1] <= jewel[1] <= pos[1]+move[1])):
"""
if (
(move[0] == "x")
and (pos[1] == jewel[1])
and (between(0, move[1], jewel[0] - pos[0]))
) or (
(move[0] == "y")
and (pos[0] == jewel[0])
and (between(0, move[1], jewel[1] - pos[1]))
):
# print('---- Collecting a jewel at ', jewel)
# jewelPositions.remove(jewel)
jewelToRemove.append(jewel)
else:
# print('xxxx Jewel not collected at ', jewel)
pass
for jewel in jewelToRemove:
jewelPositions.remove(jewel)
if move[0] == "x":
pos[0] += move[1]
elif move[0] == "y":
pos[1] += move[1]
if not jewelPositions:
"""
if empty,
all jewels are collected
"""
result = "Yes"
else:
pass
# print('jewels are left at ', jewelPositions)
print(result)
"""
2
10 11
11 12
2
N 2
E 1
2
10 11
11 12
2
N 2
W 1
3
0 15
5 10
5 15
5
W 10
S 10
N 20
E 10
S 10
0
"""
|
def between(x, y, a):
lrg = max(x, y)
sml = min(x, y)
if sml <= a <= lrg:
return True
else:
return False
while True:
pos = [10, 10]
result = "No"
N = int(input()) # Total number of jewels
if N == 0:
break
jewelPositions = list()
for i in range(N):
jewelPos = list(map(int, input().split()))
jewelPositions.append(jewelPos)
M = int(input()) # Number of instructions
# instructions = list()
for i in range(M):
# print('==== Currently at ', pos)
instruction = input().split()
# print('instruction : ', i)
if result == "Yes":
continue
instruction[1] = int(instruction[1])
if instruction[0] == "E":
move = ("x", instruction[1])
elif instruction[0] == "W":
move = ("x", -1 * instruction[1])
elif instruction[0] == "N":
move = ("y", instruction[1])
elif instruction[0] == "S":
move = ("y", -1 * instruction[1])
else:
raise NotImplementedError
# print('>>>>>>>>>>>>>>> pos: ', pos, ', move: ', move)
jewelToRemove = []
for jewel in jewelPositions:
"""
if ((move[0] == 'x') and (pos[1] == jewel[1]) and (pos[0] <= jewel[0] <= pos[0]+move[1])) \
or ((move[0] == 'y') and (pos[0] == jewel[0]) and (pos[1] <= jewel[1] <= pos[1]+move[1])):
"""
if (
(move[0] == "x")
and (pos[1] == jewel[1])
and (between(0, move[1], jewel[0] - pos[0]))
) or (
(move[0] == "y")
and (pos[0] == jewel[0])
and (between(0, move[1], jewel[1] - pos[1]))
):
# print('---- Collecting a jewel at ', jewel)
# jewelPositions.remove(jewel)
jewelToRemove.append(jewel)
else:
# print('xxxx Jewel not collected at ', jewel)
pass
for jewel in jewelToRemove:
jewelPositions.remove(jewel)
if move[0] == "x":
pos[0] += move[1]
elif move[0] == "y":
pos[1] += move[1]
if not jewelPositions:
"""
if empty,
all jewels are collected
"""
result = "Yes"
else:
pass
# print('jewels are left at ', jewelPositions)
print(result)
| false | 25.490196 |
[
"-\"\"\"",
"-2",
"-10 11",
"-11 12",
"-2",
"-N 2",
"-E 1",
"-2",
"-10 11",
"-11 12",
"-2",
"-N 2",
"-W 1",
"-3",
"-0 15",
"-5 10",
"-5 15",
"-5",
"-W 10",
"-S 10",
"-N 20",
"-E 10",
"-S 10",
"-0",
"-\"\"\""
] | false | 0.043707 | 0.045115 | 0.968796 |
[
"s036827131",
"s090777447"
] |
u297767059
|
p03478
|
python
|
s381532018
|
s033914800
| 36 | 27 | 3,060 | 3,060 |
Accepted
|
Accepted
| 25 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
(N, A, B) = list(map(int, input().split(' ')))
r = 0
for n in range(1, N + 1):
s = sum(list(map(int, list(str(n)))))
if A <= s <= B:
r += n
print(r)
|
import sys
def sum_digits(n):
r = 0
while n > 0:
r += n % 10
n = int(n / 10)
return r
def solve(inp):
(N, A, B) = list(map(int, inp.readline().split(' ')))
r = 0
for n in range(1, N + 1):
s = sum_digits(n)
if A <= s <= B:
r += n
return r
def main():
result = solve(sys.stdin)
if result:
print(result)
if __name__ == '__main__':
main()
| 12 | 31 | 219 | 461 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
(N, A, B) = list(map(int, input().split(" ")))
r = 0
for n in range(1, N + 1):
s = sum(list(map(int, list(str(n)))))
if A <= s <= B:
r += n
print(r)
|
import sys
def sum_digits(n):
r = 0
while n > 0:
r += n % 10
n = int(n / 10)
return r
def solve(inp):
(N, A, B) = list(map(int, inp.readline().split(" ")))
r = 0
for n in range(1, N + 1):
s = sum_digits(n)
if A <= s <= B:
r += n
return r
def main():
result = solve(sys.stdin)
if result:
print(result)
if __name__ == "__main__":
main()
| false | 61.290323 |
[
"-#!/usr/bin/env python",
"-# -*- coding: utf-8 -*-",
"-(N, A, B) = list(map(int, input().split(\" \")))",
"-r = 0",
"-for n in range(1, N + 1):",
"- s = sum(list(map(int, list(str(n)))))",
"- if A <= s <= B:",
"- r += n",
"-print(r)",
"+import sys",
"+",
"+",
"+def sum_digits(n):",
"+ r = 0",
"+ while n > 0:",
"+ r += n % 10",
"+ n = int(n / 10)",
"+ return r",
"+",
"+",
"+def solve(inp):",
"+ (N, A, B) = list(map(int, inp.readline().split(\" \")))",
"+ r = 0",
"+ for n in range(1, N + 1):",
"+ s = sum_digits(n)",
"+ if A <= s <= B:",
"+ r += n",
"+ return r",
"+",
"+",
"+def main():",
"+ result = solve(sys.stdin)",
"+ if result:",
"+ print(result)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.046617 | 0.047909 | 0.973029 |
[
"s381532018",
"s033914800"
] |
u874395007
|
p02406
|
python
|
s961947688
|
s716158705
| 30 | 20 | 5,880 | 5,880 |
Accepted
|
Accepted
| 33.33 |
num = int(input())
for i in range(1, num + 1):
if i % 3 == 0:
print(f' {i}', end='')
continue
x = i
while True:
if x % 10 == 3:
print(f' {i}', end='')
break
x = int(x / 10)
if x < 1:
break
print()
|
num = int(input())
for i in range(1, num + 1):
if i % 3 == 0:
print(f' {i}', end='')
else:
x = i
while x:
if x % 10 == 3:
print(f' {i}', end='')
break
x //= 10 # 切り捨て除算
print()
| 14 | 12 | 298 | 277 |
num = int(input())
for i in range(1, num + 1):
if i % 3 == 0:
print(f" {i}", end="")
continue
x = i
while True:
if x % 10 == 3:
print(f" {i}", end="")
break
x = int(x / 10)
if x < 1:
break
print()
|
num = int(input())
for i in range(1, num + 1):
if i % 3 == 0:
print(f" {i}", end="")
else:
x = i
while x:
if x % 10 == 3:
print(f" {i}", end="")
break
x //= 10 # 切り捨て除算
print()
| false | 14.285714 |
[
"- continue",
"- x = i",
"- while True:",
"- if x % 10 == 3:",
"- print(f\" {i}\", end=\"\")",
"- break",
"- x = int(x / 10)",
"- if x < 1:",
"- break",
"+ else:",
"+ x = i",
"+ while x:",
"+ if x % 10 == 3:",
"+ print(f\" {i}\", end=\"\")",
"+ break",
"+ x //= 10 # 切り捨て除算"
] | false | 0.061081 | 0.054817 | 1.114279 |
[
"s961947688",
"s716158705"
] |
u312025627
|
p02683
|
python
|
s226493745
|
s166269523
| 384 | 99 | 91,444 | 74,772 |
Accepted
|
Accepted
| 74.22 |
INF = 10**8
def main():
N, M, X = (int(i) for i in input().split())
T = [[int(i) for i in input().split()] for j in range(N)]
answer = INF
for bit in range(1, 1 << N):
intelligibility = [0]*M
current_money = 0
for i in range(N):
if bit & 1 << i:
current_money += T[i][0]
for j, a in enumerate(T[i][1:]):
intelligibility[j] += a
if all(X <= intelligence for intelligence in intelligibility):
answer = min(answer, current_money)
print((answer if answer != INF else -1))
if __name__ == '__main__':
main()
|
INF = 10**9 + 7
def main():
N, M, X = (int(i) for i in input().split())
CA = [[int(i) for i in input().split()] for j in range(N)]
ans = INF
for bit in range(1 << N):
wakaru = [0]*M
cur = 0
for i in range(N):
if bit & (1 << i):
c, *A = CA[i]
cur += c
for j in range(M):
wakaru[j] += A[j]
if all(m >= X for m in wakaru):
ans = min(ans, cur)
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == '__main__':
main()
| 23 | 27 | 659 | 615 |
INF = 10**8
def main():
N, M, X = (int(i) for i in input().split())
T = [[int(i) for i in input().split()] for j in range(N)]
answer = INF
for bit in range(1, 1 << N):
intelligibility = [0] * M
current_money = 0
for i in range(N):
if bit & 1 << i:
current_money += T[i][0]
for j, a in enumerate(T[i][1:]):
intelligibility[j] += a
if all(X <= intelligence for intelligence in intelligibility):
answer = min(answer, current_money)
print((answer if answer != INF else -1))
if __name__ == "__main__":
main()
|
INF = 10**9 + 7
def main():
N, M, X = (int(i) for i in input().split())
CA = [[int(i) for i in input().split()] for j in range(N)]
ans = INF
for bit in range(1 << N):
wakaru = [0] * M
cur = 0
for i in range(N):
if bit & (1 << i):
c, *A = CA[i]
cur += c
for j in range(M):
wakaru[j] += A[j]
if all(m >= X for m in wakaru):
ans = min(ans, cur)
if ans == INF:
print((-1))
else:
print(ans)
if __name__ == "__main__":
main()
| false | 14.814815 |
[
"-INF = 10**8",
"+INF = 10**9 + 7",
"- T = [[int(i) for i in input().split()] for j in range(N)]",
"- answer = INF",
"- for bit in range(1, 1 << N):",
"- intelligibility = [0] * M",
"- current_money = 0",
"+ CA = [[int(i) for i in input().split()] for j in range(N)]",
"+ ans = INF",
"+ for bit in range(1 << N):",
"+ wakaru = [0] * M",
"+ cur = 0",
"- if bit & 1 << i:",
"- current_money += T[i][0]",
"- for j, a in enumerate(T[i][1:]):",
"- intelligibility[j] += a",
"- if all(X <= intelligence for intelligence in intelligibility):",
"- answer = min(answer, current_money)",
"- print((answer if answer != INF else -1))",
"+ if bit & (1 << i):",
"+ c, *A = CA[i]",
"+ cur += c",
"+ for j in range(M):",
"+ wakaru[j] += A[j]",
"+ if all(m >= X for m in wakaru):",
"+ ans = min(ans, cur)",
"+ if ans == INF:",
"+ print((-1))",
"+ else:",
"+ print(ans)"
] | false | 0.04087 | 0.038783 | 1.053809 |
[
"s226493745",
"s166269523"
] |
u879674287
|
p03103
|
python
|
s927767919
|
s827135184
| 531 | 388 | 28,180 | 25,636 |
Accepted
|
Accepted
| 26.93 |
import numpy as np
N, M = list(map(int, input().split(' ')))
store_list = []
for i in range(N):
a, b = list(map(int, input().split(' ')))
store_list.append((a, b))
store_list = sorted(store_list, key=lambda x: x[0])
ans = 0
cnt = 0
for a, b in store_list:
if (M - cnt) > b:
ans += a * b
cnt += b
else:
ans += a * (M - cnt)
cnt += (M - cnt)
print(ans)
|
# coding: utf-8
import sys
import itertools
def sr(): return sys.stdin.readline().rstrip()
def ir(): return int(sr())
def lr(): return list(map(int, sr().split()))
N, M = lr()
d_list = []
for i in range(N):
a, b = lr()
d_list.append([a, b, i])
d_list = sorted(d_list, key=lambda x: x[0])
cnt = 0
ans = 0
for d in d_list:
if (M - cnt) > d[1]:
ans += d[1] * d[0]
cnt += d[1]
elif (M - cnt) > 0:
ans += (M - cnt) * d[0]
cnt += (M - cnt)
else:
break
print(ans)
| 21 | 35 | 411 | 562 |
import numpy as np
N, M = list(map(int, input().split(" ")))
store_list = []
for i in range(N):
a, b = list(map(int, input().split(" ")))
store_list.append((a, b))
store_list = sorted(store_list, key=lambda x: x[0])
ans = 0
cnt = 0
for a, b in store_list:
if (M - cnt) > b:
ans += a * b
cnt += b
else:
ans += a * (M - cnt)
cnt += M - cnt
print(ans)
|
# coding: utf-8
import sys
import itertools
def sr():
return sys.stdin.readline().rstrip()
def ir():
return int(sr())
def lr():
return list(map(int, sr().split()))
N, M = lr()
d_list = []
for i in range(N):
a, b = lr()
d_list.append([a, b, i])
d_list = sorted(d_list, key=lambda x: x[0])
cnt = 0
ans = 0
for d in d_list:
if (M - cnt) > d[1]:
ans += d[1] * d[0]
cnt += d[1]
elif (M - cnt) > 0:
ans += (M - cnt) * d[0]
cnt += M - cnt
else:
break
print(ans)
| false | 40 |
[
"-import numpy as np",
"+# coding: utf-8",
"+import sys",
"+import itertools",
"-N, M = list(map(int, input().split(\" \")))",
"-store_list = []",
"+",
"+def sr():",
"+ return sys.stdin.readline().rstrip()",
"+",
"+",
"+def ir():",
"+ return int(sr())",
"+",
"+",
"+def lr():",
"+ return list(map(int, sr().split()))",
"+",
"+",
"+N, M = lr()",
"+d_list = []",
"- a, b = list(map(int, input().split(\" \")))",
"- store_list.append((a, b))",
"-store_list = sorted(store_list, key=lambda x: x[0])",
"+ a, b = lr()",
"+ d_list.append([a, b, i])",
"+d_list = sorted(d_list, key=lambda x: x[0])",
"+cnt = 0",
"-cnt = 0",
"-for a, b in store_list:",
"- if (M - cnt) > b:",
"- ans += a * b",
"- cnt += b",
"+for d in d_list:",
"+ if (M - cnt) > d[1]:",
"+ ans += d[1] * d[0]",
"+ cnt += d[1]",
"+ elif (M - cnt) > 0:",
"+ ans += (M - cnt) * d[0]",
"+ cnt += M - cnt",
"- ans += a * (M - cnt)",
"- cnt += M - cnt",
"+ break"
] | false | 0.132772 | 0.036894 | 3.598786 |
[
"s927767919",
"s827135184"
] |
u167988719
|
p03293
|
python
|
s066276105
|
s347544646
| 22 | 18 | 3,316 | 2,940 |
Accepted
|
Accepted
| 18.18 |
from collections import deque
s = deque(eval(input()))
t = deque(eval(input()))
n=len(s)
yes = False
for _ in range(n):
if s == t:
yes = True
break
s.rotate()
print(('Yes' if yes else 'No'))
|
S = eval(input())
T = eval(input())
S = S * 2
yes = S.find(T) != -1
print(('Yes' if yes else 'No'))
| 14 | 5 | 216 | 89 |
from collections import deque
s = deque(eval(input()))
t = deque(eval(input()))
n = len(s)
yes = False
for _ in range(n):
if s == t:
yes = True
break
s.rotate()
print(("Yes" if yes else "No"))
|
S = eval(input())
T = eval(input())
S = S * 2
yes = S.find(T) != -1
print(("Yes" if yes else "No"))
| false | 64.285714 |
[
"-from collections import deque",
"-",
"-s = deque(eval(input()))",
"-t = deque(eval(input()))",
"-n = len(s)",
"-yes = False",
"-for _ in range(n):",
"- if s == t:",
"- yes = True",
"- break",
"- s.rotate()",
"+S = eval(input())",
"+T = eval(input())",
"+S = S * 2",
"+yes = S.find(T) != -1"
] | false | 0.041284 | 0.049338 | 0.836753 |
[
"s066276105",
"s347544646"
] |
u650950012
|
p03380
|
python
|
s956752039
|
s708717670
| 130 | 104 | 14,428 | 15,328 |
Accepted
|
Accepted
| 20 |
n = int(eval(input()))
a_list = list(map(int, input().split()))
ai = max(a_list)
a_list.remove(ai)
sorted([a - (ai / 2) for a in a_list])[0]
tmp = ai
cand = ai
for x in [a - (ai / 2) for a in a_list]:
if abs(x) < tmp:
tmp = abs(x)
cand = int(x + (ai / 2))
print((ai, cand))
|
n = int(eval(input()))
a_list = list(map(int, input().split()))
ai = max(a_list)
a_list.remove(ai)
aj = int(sorted([a - (ai / 2) for a in a_list], key=abs)[0] + (ai / 2))
print((ai, aj))
| 15 | 8 | 302 | 187 |
n = int(eval(input()))
a_list = list(map(int, input().split()))
ai = max(a_list)
a_list.remove(ai)
sorted([a - (ai / 2) for a in a_list])[0]
tmp = ai
cand = ai
for x in [a - (ai / 2) for a in a_list]:
if abs(x) < tmp:
tmp = abs(x)
cand = int(x + (ai / 2))
print((ai, cand))
|
n = int(eval(input()))
a_list = list(map(int, input().split()))
ai = max(a_list)
a_list.remove(ai)
aj = int(sorted([a - (ai / 2) for a in a_list], key=abs)[0] + (ai / 2))
print((ai, aj))
| false | 46.666667 |
[
"-sorted([a - (ai / 2) for a in a_list])[0]",
"-tmp = ai",
"-cand = ai",
"-for x in [a - (ai / 2) for a in a_list]:",
"- if abs(x) < tmp:",
"- tmp = abs(x)",
"- cand = int(x + (ai / 2))",
"-print((ai, cand))",
"+aj = int(sorted([a - (ai / 2) for a in a_list], key=abs)[0] + (ai / 2))",
"+print((ai, aj))"
] | false | 0.047137 | 0.048004 | 0.981944 |
[
"s956752039",
"s708717670"
] |
u775681539
|
p02762
|
python
|
s044224533
|
s004930708
| 1,423 | 1,203 | 43,584 | 79,172 |
Accepted
|
Accepted
| 15.46 |
#python3
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
n, m, k = map(int, input().split())
uf = UnionFind(n)
to = [[] for _ in range(n)]
for _ in range(m):
a, b = map(lambda x: int(x)-1, input().split())
to[a].append(b)
to[b].append(a)
uf.unite(a, b)
block = [[] for _ in range(n)]
block_count = [0 for _ in range(n)]
for _ in range(k):
c, d = map(lambda x: int(x)-1, input().split())
block[c].append(d)
block[d].append(c)
if uf.isSameGroup(c, d):
block_count[c] += 1
block_count[d] += 1
#同じグループ内にいるときのみブロックを引く
for i in range(n):
ans = uf.getLength(i) - len(to[i]) - block_count[i] - 1
print(ans, end=' ')
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M, K = map(int, readline().split())
friend = [set() for _ in range(N)]
block = [set() for _ in range(N)]
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
a-=1
b-=1
friend[a].add(b)
friend[b].add(a)
uf.unite(a, b)
for _ in range(K):
c, d = map(int, readline().split())
c-=1
d-=1
block[c].add(d)
block[d].add(c)
for i in range(N):
cnt = 0
for blk in block[i]:
if uf.isSameGroup(i, blk):
cnt += 1
ans = uf.getLength(i)-cnt-len(friend[i])-1
if i == N-1:
print(ans)
else:
print(ans, end=" ")
if __name__ == '__main__':
main()
| 67 | 76 | 1,881 | 2,063 |
# python3
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
n, m, k = map(int, input().split())
uf = UnionFind(n)
to = [[] for _ in range(n)]
for _ in range(m):
a, b = map(lambda x: int(x) - 1, input().split())
to[a].append(b)
to[b].append(a)
uf.unite(a, b)
block = [[] for _ in range(n)]
block_count = [0 for _ in range(n)]
for _ in range(k):
c, d = map(lambda x: int(x) - 1, input().split())
block[c].append(d)
block[d].append(c)
if uf.isSameGroup(c, d):
block_count[c] += 1
block_count[d] += 1
# 同じグループ内にいるときのみブロックを引く
for i in range(n):
ans = uf.getLength(i) - len(to[i]) - block_count[i] - 1
print(ans, end=" ")
main()
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
class UnionFind:
def __init__(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def makeSet(self, n):
self.parents = [i for i in range(n)]
self.rank = [0 for _ in range(n)]
self.length = [1 for _ in range(n)]
def find(self, x):
if self.parents[x] == x:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.rank[x] < self.rank[y]:
self.parents[x] = y
self.length[y] += self.length[x]
else:
self.parents[y] = x
self.length[x] += self.length[y]
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def getLength(self, x):
x = self.find(x)
return self.length[x]
def isSameGroup(self, x, y):
return self.find(x) == self.find(y)
def main():
N, M, K = map(int, readline().split())
friend = [set() for _ in range(N)]
block = [set() for _ in range(N)]
uf = UnionFind(N)
for _ in range(M):
a, b = map(int, readline().split())
a -= 1
b -= 1
friend[a].add(b)
friend[b].add(a)
uf.unite(a, b)
for _ in range(K):
c, d = map(int, readline().split())
c -= 1
d -= 1
block[c].add(d)
block[d].add(c)
for i in range(N):
cnt = 0
for blk in block[i]:
if uf.isSameGroup(i, blk):
cnt += 1
ans = uf.getLength(i) - cnt - len(friend[i]) - 1
if i == N - 1:
print(ans)
else:
print(ans, end=" ")
if __name__ == "__main__":
main()
| false | 11.842105 |
[
"-# python3",
"+import sys",
"+",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+",
"+",
"- n, m, k = map(int, input().split())",
"- uf = UnionFind(n)",
"- to = [[] for _ in range(n)]",
"- for _ in range(m):",
"- a, b = map(lambda x: int(x) - 1, input().split())",
"- to[a].append(b)",
"- to[b].append(a)",
"+ N, M, K = map(int, readline().split())",
"+ friend = [set() for _ in range(N)]",
"+ block = [set() for _ in range(N)]",
"+ uf = UnionFind(N)",
"+ for _ in range(M):",
"+ a, b = map(int, readline().split())",
"+ a -= 1",
"+ b -= 1",
"+ friend[a].add(b)",
"+ friend[b].add(a)",
"- block = [[] for _ in range(n)]",
"- block_count = [0 for _ in range(n)]",
"- for _ in range(k):",
"- c, d = map(lambda x: int(x) - 1, input().split())",
"- block[c].append(d)",
"- block[d].append(c)",
"- if uf.isSameGroup(c, d):",
"- block_count[c] += 1",
"- block_count[d] += 1",
"- # 同じグループ内にいるときのみブロックを引く",
"- for i in range(n):",
"- ans = uf.getLength(i) - len(to[i]) - block_count[i] - 1",
"- print(ans, end=\" \")",
"+ for _ in range(K):",
"+ c, d = map(int, readline().split())",
"+ c -= 1",
"+ d -= 1",
"+ block[c].add(d)",
"+ block[d].add(c)",
"+ for i in range(N):",
"+ cnt = 0",
"+ for blk in block[i]:",
"+ if uf.isSameGroup(i, blk):",
"+ cnt += 1",
"+ ans = uf.getLength(i) - cnt - len(friend[i]) - 1",
"+ if i == N - 1:",
"+ print(ans)",
"+ else:",
"+ print(ans, end=\" \")",
"-main()",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036806 | 0.037215 | 0.989002 |
[
"s044224533",
"s004930708"
] |
u608088992
|
p03767
|
python
|
s455743685
|
s560711473
| 286 | 225 | 37,084 | 37,084 |
Accepted
|
Accepted
| 21.33 |
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort()
A = A[N:]
ans = 0
for i in range(N):
ans += A[2*i]
print(ans)
|
import sys
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort(reverse = True)
ans = 0
for i in range(N):
ans += A[2 * i + 1]
print(ans)
return 0
if __name__ == "__main__":
solve()
| 8 | 15 | 136 | 290 |
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort()
A = A[N:]
ans = 0
for i in range(N):
ans += A[2 * i]
print(ans)
|
import sys
def solve():
input = sys.stdin.readline
N = int(eval(input()))
A = [int(a) for a in input().split()]
A.sort(reverse=True)
ans = 0
for i in range(N):
ans += A[2 * i + 1]
print(ans)
return 0
if __name__ == "__main__":
solve()
| false | 46.666667 |
[
"-N = int(eval(input()))",
"-A = [int(a) for a in input().split()]",
"-A.sort()",
"-A = A[N:]",
"-ans = 0",
"-for i in range(N):",
"- ans += A[2 * i]",
"-print(ans)",
"+import sys",
"+",
"+",
"+def solve():",
"+ input = sys.stdin.readline",
"+ N = int(eval(input()))",
"+ A = [int(a) for a in input().split()]",
"+ A.sort(reverse=True)",
"+ ans = 0",
"+ for i in range(N):",
"+ ans += A[2 * i + 1]",
"+ print(ans)",
"+ return 0",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.093915 | 0.082174 | 1.14287 |
[
"s455743685",
"s560711473"
] |
u906769651
|
p03160
|
python
|
s322247080
|
s644955244
| 135 | 123 | 20,676 | 20,572 |
Accepted
|
Accepted
| 8.89 |
# coding: utf-8
# Your code here!
import math
n=int(eval(input()))
h=list(map(int,input().split()))
dp=[math.inf for _ in range(n)]
dp[0]=0
for i in range(1,n):
if i==1:
dp[i]=dp[i-1]+abs(h[i]-h[i-1])
else:
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1]))
|
n=int(eval(input()))
h=list(map(int,input().split()))
dp=[0 for i in range(n)]
for i in range(1,n):
if i==1:
dp[i]=dp[i-1]+abs(h[i]-h[i-1])
else:
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
print((dp[n-1]))
| 13 | 10 | 312 | 249 |
# coding: utf-8
# Your code here!
import math
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [math.inf for _ in range(n)]
dp[0] = 0
for i in range(1, n):
if i == 1:
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
else:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n - 1]))
|
n = int(eval(input()))
h = list(map(int, input().split()))
dp = [0 for i in range(n)]
for i in range(1, n):
if i == 1:
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
else:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
print((dp[n - 1]))
| false | 23.076923 |
[
"-# coding: utf-8",
"-# Your code here!",
"-import math",
"-",
"-dp = [math.inf for _ in range(n)]",
"-dp[0] = 0",
"+dp = [0 for i in range(n)]"
] | false | 0.037035 | 0.094855 | 0.390437 |
[
"s322247080",
"s644955244"
] |
u636251914
|
p02996
|
python
|
s455413129
|
s689137987
| 1,194 | 1,097 | 78,804 | 52,292 |
Accepted
|
Accepted
| 8.12 |
N = int(eval(input()))
Works = [dict(list(zip(["require", "limit"], [int(_) for _ in input().split()]))) for i in range(N)]
def solve(Works):
Works.sort(key=lambda x: x["limit"])
acc = 0
for w in Works:
acc += w["require"]
if acc > w["limit"]:
return "No"
return "Yes"
print((solve(Works)))
|
class Work:
require = 0
limit = 0
def __init__(self, require, limit) -> None:
self.require = require
self.limit = limit
def from_list(xs) -> Work:
return Work(xs[0], xs[1])
N = int(eval(input()))
works = [from_list([int(_) for _ in input().split()]) for i in range(N)]
def solve(works):
works.sort(key=lambda x: x.limit)
acc = 0
for w in works:
acc += w.require
if acc > w.limit:
return "No"
return "Yes"
print((solve(works)))
| 14 | 24 | 336 | 523 |
N = int(eval(input()))
Works = [
dict(list(zip(["require", "limit"], [int(_) for _ in input().split()])))
for i in range(N)
]
def solve(Works):
Works.sort(key=lambda x: x["limit"])
acc = 0
for w in Works:
acc += w["require"]
if acc > w["limit"]:
return "No"
return "Yes"
print((solve(Works)))
|
class Work:
require = 0
limit = 0
def __init__(self, require, limit) -> None:
self.require = require
self.limit = limit
def from_list(xs) -> Work:
return Work(xs[0], xs[1])
N = int(eval(input()))
works = [from_list([int(_) for _ in input().split()]) for i in range(N)]
def solve(works):
works.sort(key=lambda x: x.limit)
acc = 0
for w in works:
acc += w.require
if acc > w.limit:
return "No"
return "Yes"
print((solve(works)))
| false | 41.666667 |
[
"-N = int(eval(input()))",
"-Works = [",
"- dict(list(zip([\"require\", \"limit\"], [int(_) for _ in input().split()])))",
"- for i in range(N)",
"-]",
"+class Work:",
"+ require = 0",
"+ limit = 0",
"+",
"+ def __init__(self, require, limit) -> None:",
"+ self.require = require",
"+ self.limit = limit",
"-def solve(Works):",
"- Works.sort(key=lambda x: x[\"limit\"])",
"+def from_list(xs) -> Work:",
"+ return Work(xs[0], xs[1])",
"+",
"+",
"+N = int(eval(input()))",
"+works = [from_list([int(_) for _ in input().split()]) for i in range(N)]",
"+",
"+",
"+def solve(works):",
"+ works.sort(key=lambda x: x.limit)",
"- for w in Works:",
"- acc += w[\"require\"]",
"- if acc > w[\"limit\"]:",
"+ for w in works:",
"+ acc += w.require",
"+ if acc > w.limit:",
"-print((solve(Works)))",
"+print((solve(works)))"
] | false | 0.039701 | 0.03679 | 1.079121 |
[
"s455413129",
"s689137987"
] |
u977389981
|
p03680
|
python
|
s504397189
|
s211533573
| 241 | 197 | 20,392 | 7,084 |
Accepted
|
Accepted
| 18.26 |
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
B = []
for i, a in enumerate(A):
B.append([i + 1, a])
idx = 1
for i in range(n):
x = B[idx - 1][1]
if x == 2:
print((i + 1))
break
else:
idx = x
else:
print((-1))
|
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
cnt = 1
x = A[0]
while x != 2 and cnt != n:
x = A[x - 1]
cnt += 1
if cnt == n:
print((-1))
else:
print(cnt)
| 16 | 13 | 276 | 193 |
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
B = []
for i, a in enumerate(A):
B.append([i + 1, a])
idx = 1
for i in range(n):
x = B[idx - 1][1]
if x == 2:
print((i + 1))
break
else:
idx = x
else:
print((-1))
|
n = int(eval(input()))
A = [int(eval(input())) for i in range(n)]
cnt = 1
x = A[0]
while x != 2 and cnt != n:
x = A[x - 1]
cnt += 1
if cnt == n:
print((-1))
else:
print(cnt)
| false | 18.75 |
[
"-B = []",
"-for i, a in enumerate(A):",
"- B.append([i + 1, a])",
"-idx = 1",
"-for i in range(n):",
"- x = B[idx - 1][1]",
"- if x == 2:",
"- print((i + 1))",
"- break",
"- else:",
"- idx = x",
"+cnt = 1",
"+x = A[0]",
"+while x != 2 and cnt != n:",
"+ x = A[x - 1]",
"+ cnt += 1",
"+if cnt == n:",
"+ print((-1))",
"- print((-1))",
"+ print(cnt)"
] | false | 0.042424 | 0.042083 | 1.008093 |
[
"s504397189",
"s211533573"
] |
u781262926
|
p03838
|
python
|
s934294493
|
s187883500
| 30 | 23 | 9,196 | 9,080 |
Accepted
|
Accepted
| 23.33 |
x, y = list(map(int, input().split()))
d = abs(abs(x) - abs(y))
if 0 <= x < y or x < y <= 0:
print(d)
elif y < 0 < x or x < 0 < y:
print((d+1))
elif 0 < y < x or y < x < 0:
print((d+2))
elif y == 0 < x or y < x == 0:
print((d+1))
else:
raise Exception
|
x, y = list(map(int, input().split()))
d = abs(abs(x) - abs(y))
if 0 <= x < y or x < y <= 0:
print(d)
elif y <= 0 <= x or x < 0 < y:
print((d+1))
elif 0 < y < x or y < x < 0:
print((d+2))
else:
raise Exception
| 12 | 10 | 260 | 216 |
x, y = list(map(int, input().split()))
d = abs(abs(x) - abs(y))
if 0 <= x < y or x < y <= 0:
print(d)
elif y < 0 < x or x < 0 < y:
print((d + 1))
elif 0 < y < x or y < x < 0:
print((d + 2))
elif y == 0 < x or y < x == 0:
print((d + 1))
else:
raise Exception
|
x, y = list(map(int, input().split()))
d = abs(abs(x) - abs(y))
if 0 <= x < y or x < y <= 0:
print(d)
elif y <= 0 <= x or x < 0 < y:
print((d + 1))
elif 0 < y < x or y < x < 0:
print((d + 2))
else:
raise Exception
| false | 16.666667 |
[
"-elif y < 0 < x or x < 0 < y:",
"+elif y <= 0 <= x or x < 0 < y:",
"-elif y == 0 < x or y < x == 0:",
"- print((d + 1))"
] | false | 0.036135 | 0.086919 | 0.415727 |
[
"s934294493",
"s187883500"
] |
u748241164
|
p02924
|
python
|
s476435105
|
s254554257
| 202 | 17 | 38,384 | 2,940 |
Accepted
|
Accepted
| 91.58 |
N = int(eval(input()))
print((N * (N - 1) // 2))
|
N = int(eval(input()))
print((int((N) * (N - 1) // 2)))
| 2 | 5 | 41 | 55 |
N = int(eval(input()))
print((N * (N - 1) // 2))
|
N = int(eval(input()))
print((int((N) * (N - 1) // 2)))
| false | 60 |
[
"-print((N * (N - 1) // 2))",
"+print((int((N) * (N - 1) // 2)))"
] | false | 0.042286 | 0.042687 | 0.990589 |
[
"s476435105",
"s254554257"
] |
u331606500
|
p03086
|
python
|
s077652682
|
s252554704
| 19 | 17 | 3,064 | 2,940 |
Accepted
|
Accepted
| 10.53 |
print((len(max("".join(str(int(c in{"A","T","G","C"}))for c in eval(input())).split("0")))))
|
print((len(max("".join(str(int(c in"ATGC"))for c in eval(input())).split("0")))))
| 1 | 1 | 84 | 73 |
print(
(
len(
max(
"".join(
str(int(c in {"A", "T", "G", "C"})) for c in eval(input())
).split("0")
)
)
)
)
|
print((len(max("".join(str(int(c in "ATGC")) for c in eval(input())).split("0")))))
| false | 0 |
[
"-print(",
"- (",
"- len(",
"- max(",
"- \"\".join(",
"- str(int(c in {\"A\", \"T\", \"G\", \"C\"})) for c in eval(input())",
"- ).split(\"0\")",
"- )",
"- )",
"- )",
"-)",
"+print((len(max(\"\".join(str(int(c in \"ATGC\")) for c in eval(input())).split(\"0\")))))"
] | false | 0.043706 | 0.049114 | 0.88989 |
[
"s077652682",
"s252554704"
] |
u548624367
|
p03283
|
python
|
s756951892
|
s457243202
| 2,081 | 1,543 | 9,460 | 10,860 |
Accepted
|
Accepted
| 25.85 |
n,m,q=list(map(int,input().split()))
d=[[0 for j in range(n)] for i in range(n)]
for i in range(m):
l,r=[int(x)-1 for x in input().split()]
d[l][r]+=1
for l in range(n):
for r in range(1,n):
d[l][r]+=d[l][r-1]
for l in range(n-1,0,-1):
for r in range(n):
d[l-1][r]+=d[l][r]
for i in range(q):
l,r=[int(x)-1 for x in input().split()]
print((d[l][r]))
|
n,m,q=list(map(int,input().split()))
d=[[0 for j in range(n)] for i in range(n)]
for i in range(m):
l,r=list(map(int,input().split()))
d[n-l][r-1]+=1
for l in range(n):
for r in range(1,n):
d[l][r]+=d[l][r-1]
for l in range(1,n):
for r in range(n):
d[l][r]+=d[l-1][r]
for i in range(q):
l,r=list(map(int,input().split()))
print((d[n-l][r-1]))
| 14 | 14 | 370 | 345 |
n, m, q = list(map(int, input().split()))
d = [[0 for j in range(n)] for i in range(n)]
for i in range(m):
l, r = [int(x) - 1 for x in input().split()]
d[l][r] += 1
for l in range(n):
for r in range(1, n):
d[l][r] += d[l][r - 1]
for l in range(n - 1, 0, -1):
for r in range(n):
d[l - 1][r] += d[l][r]
for i in range(q):
l, r = [int(x) - 1 for x in input().split()]
print((d[l][r]))
|
n, m, q = list(map(int, input().split()))
d = [[0 for j in range(n)] for i in range(n)]
for i in range(m):
l, r = list(map(int, input().split()))
d[n - l][r - 1] += 1
for l in range(n):
for r in range(1, n):
d[l][r] += d[l][r - 1]
for l in range(1, n):
for r in range(n):
d[l][r] += d[l - 1][r]
for i in range(q):
l, r = list(map(int, input().split()))
print((d[n - l][r - 1]))
| false | 0 |
[
"- l, r = [int(x) - 1 for x in input().split()]",
"- d[l][r] += 1",
"+ l, r = list(map(int, input().split()))",
"+ d[n - l][r - 1] += 1",
"-for l in range(n - 1, 0, -1):",
"+for l in range(1, n):",
"- d[l - 1][r] += d[l][r]",
"+ d[l][r] += d[l - 1][r]",
"- l, r = [int(x) - 1 for x in input().split()]",
"- print((d[l][r]))",
"+ l, r = list(map(int, input().split()))",
"+ print((d[n - l][r - 1]))"
] | false | 0.088233 | 0.066929 | 1.318307 |
[
"s756951892",
"s457243202"
] |
u046187684
|
p02888
|
python
|
s869919914
|
s280417511
| 696 | 424 | 3,188 | 3,188 |
Accepted
|
Accepted
| 39.08 |
def solve(string):
n, *l = list(map(int, string.split()))
l.sort()
nums = 0
for i, a in enumerate(l[:-2]):
k = i + 2
for j, b in enumerate(l[i + 1:-1], i + 1):
while k < n and l[k] < a + b:
k += 1
nums += k - j - 1
return str(nums)
if __name__ == '__main__':
print((solve('\n'.join([eval(input()), eval(input())]))))
|
def solve(string):
n, *l = list(map(int, string.split()))
l.sort(reverse=True)
nums = 0
for i, a in enumerate(l[:-2]):
j, k = i + 1, n - 1
while (j < k):
if (a < l[j] + l[k]):
nums += k - j
j += 1
else:
k -= 1
return str(nums)
if __name__ == '__main__':
print((solve('\n'.join([eval(input()), eval(input())]))))
| 15 | 17 | 393 | 422 |
def solve(string):
n, *l = list(map(int, string.split()))
l.sort()
nums = 0
for i, a in enumerate(l[:-2]):
k = i + 2
for j, b in enumerate(l[i + 1 : -1], i + 1):
while k < n and l[k] < a + b:
k += 1
nums += k - j - 1
return str(nums)
if __name__ == "__main__":
print((solve("\n".join([eval(input()), eval(input())]))))
|
def solve(string):
n, *l = list(map(int, string.split()))
l.sort(reverse=True)
nums = 0
for i, a in enumerate(l[:-2]):
j, k = i + 1, n - 1
while j < k:
if a < l[j] + l[k]:
nums += k - j
j += 1
else:
k -= 1
return str(nums)
if __name__ == "__main__":
print((solve("\n".join([eval(input()), eval(input())]))))
| false | 11.764706 |
[
"- l.sort()",
"+ l.sort(reverse=True)",
"- k = i + 2",
"- for j, b in enumerate(l[i + 1 : -1], i + 1):",
"- while k < n and l[k] < a + b:",
"- k += 1",
"- nums += k - j - 1",
"+ j, k = i + 1, n - 1",
"+ while j < k:",
"+ if a < l[j] + l[k]:",
"+ nums += k - j",
"+ j += 1",
"+ else:",
"+ k -= 1"
] | false | 0.040808 | 0.03849 | 1.060219 |
[
"s869919914",
"s280417511"
] |
u129749062
|
p02683
|
python
|
s469352667
|
s755776881
| 121 | 104 | 9,240 | 9,216 |
Accepted
|
Accepted
| 14.05 |
N,M,X = list(map(int,input().split()))
c_list = [list(map(int,input().split())) for _ in range(N)]
cost_list = []
for i in range(2**N):
achive = [0]*M
achive_list = [0]*M
cost = 0
for j in range(N):
if ((i>>j)&1)==1:
cost = cost + c_list[j][0]
for k in range(M):
achive[k] = achive[k] + c_list[j][k+1]
if achive[k] >= X:
achive_list[k] = -1
if sum(achive_list) == -1*M:
cost_list.append(cost)
print((min(cost_list) if cost_list else -1))
|
N,M,X = list(map(int,input().split()))
CA = [list(map(int,input().split())) for _ in range(N)]
ans = 10**9
for i in range(2**N):
cost = 0
skill = [0]*M
cnt = 0
for j in range(N):
if (i>>j)&1 == 1:
for k in range(M):
skill[k] += CA[j][k+1]
cost += CA[j][0]
for l in range(M):
if skill[l] >= X:
cnt += 1
if cnt == M:
ans = min(ans,cost)
if ans == 10**9:
print((-1))
else:
print(ans)
| 17 | 22 | 501 | 452 |
N, M, X = list(map(int, input().split()))
c_list = [list(map(int, input().split())) for _ in range(N)]
cost_list = []
for i in range(2**N):
achive = [0] * M
achive_list = [0] * M
cost = 0
for j in range(N):
if ((i >> j) & 1) == 1:
cost = cost + c_list[j][0]
for k in range(M):
achive[k] = achive[k] + c_list[j][k + 1]
if achive[k] >= X:
achive_list[k] = -1
if sum(achive_list) == -1 * M:
cost_list.append(cost)
print((min(cost_list) if cost_list else -1))
|
N, M, X = list(map(int, input().split()))
CA = [list(map(int, input().split())) for _ in range(N)]
ans = 10**9
for i in range(2**N):
cost = 0
skill = [0] * M
cnt = 0
for j in range(N):
if (i >> j) & 1 == 1:
for k in range(M):
skill[k] += CA[j][k + 1]
cost += CA[j][0]
for l in range(M):
if skill[l] >= X:
cnt += 1
if cnt == M:
ans = min(ans, cost)
if ans == 10**9:
print((-1))
else:
print(ans)
| false | 22.727273 |
[
"-c_list = [list(map(int, input().split())) for _ in range(N)]",
"-cost_list = []",
"+CA = [list(map(int, input().split())) for _ in range(N)]",
"+ans = 10**9",
"- achive = [0] * M",
"- achive_list = [0] * M",
"+ skill = [0] * M",
"+ cnt = 0",
"- if ((i >> j) & 1) == 1:",
"- cost = cost + c_list[j][0]",
"+ if (i >> j) & 1 == 1:",
"- achive[k] = achive[k] + c_list[j][k + 1]",
"- if achive[k] >= X:",
"- achive_list[k] = -1",
"- if sum(achive_list) == -1 * M:",
"- cost_list.append(cost)",
"-print((min(cost_list) if cost_list else -1))",
"+ skill[k] += CA[j][k + 1]",
"+ cost += CA[j][0]",
"+ for l in range(M):",
"+ if skill[l] >= X:",
"+ cnt += 1",
"+ if cnt == M:",
"+ ans = min(ans, cost)",
"+if ans == 10**9:",
"+ print((-1))",
"+else:",
"+ print(ans)"
] | false | 0.047068 | 0.045852 | 1.026527 |
[
"s469352667",
"s755776881"
] |
u197300260
|
p03160
|
python
|
s919335661
|
s451589132
| 189 | 171 | 14,912 | 15,592 |
Accepted
|
Accepted
| 9.52 |
# _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# 貰う型DP
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0,blockMAXElement,+1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = list()
for _ in blockElementRange:
dp.append(sys.maxsize)
N = int(input().strip())
blockRange = list(range(0,N,+1))
h = list(map(int,input().strip().split(' ')))
# 初期の条件 0歩の時は値が与えられていないのでDPは0にセット
dp[0] = 0
for position in range(1,N,+1):
# 一つ手前の足場までで最適な値のはず、のコスト
previousMinCost = dp[position-1]
# 一つ手前から来た場合の足場positionでのコスト計
# pM = previousMin
pMNowCost = dp[position-1]+abs(h[position]-h[position-1])
# 今の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if pMNowCost <= dp[position]:
dp[position] = pMNowCost
# これは二つ手前から来たケースを考えるのでpositon = 1の場合を除いて考える
# それ以降は一個手前からと同じ
if 1 < position:
previous2MinCost = dp[position-2]
pM2NowCost = dp[position-2]+abs(h[position]-h[position-2])
if pM2NowCost <= dp[position]:
dp[position] = pM2NowCost
print(("{}".format(dp[N-1])))
|
# _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1_other1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# TODO 配る型DP https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E5%88%A5%E8%A7%A3-1-%E9%85%8D%E3%82%8B-dp
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0,blockMAXElement,+1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = [sys.maxsize] * blockMAXElement
# コスト
# 参考文献のC++では配列は宣言時に初期化されるがpythonはそれがないのでまずはあえて0で初期化
h = [0] * blockMAXElement
N = int(input().strip())
inputh = list(map(int,input().strip().split(' ')))
# h配列を入力データから取り出した物に置き換える
for i in range(0,len(inputh),+1):
h[i] = inputh[i]
# 初期の条件 0歩の時だけはコストがないので、0にセット
dp[0] = 0
# 現在の位置から最後の一歩手前(N-2歩き目)まで(仮にそこで2歩進んだ場合もDPテーブルはあるのでエラーにはならず)
for position in range(0,N-1,+1):
# 現在の岩場で最適な値のコスト
nowMinCost = dp[position]
# 1歩進んだときのコスト計
nextOneCost = nowMinCost+abs(h[position+1]-h[position])
# 一歩次の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if nextOneCost < dp[position+1]:
dp[position+1]=nextOneCost
# 2歩足場をまたいだケースを考える。貰う場合と異なるのはpositionは0から始めて良いし
# 逆にN-2の石の足場から2歩飛んでもプログラム上ではエラーにならない
# それ以降は1個手前からと同じ
nextTwoCost = dp[position]+abs(h[position+2]-h[position])
if nextTwoCost < dp[position+2]:
dp[position+2] = nextTwoCost
print(("{}".format(dp[N-1])))
| 41 | 44 | 1,188 | 1,414 |
# _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# 貰う型DP
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0, blockMAXElement, +1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = list()
for _ in blockElementRange:
dp.append(sys.maxsize)
N = int(input().strip())
blockRange = list(range(0, N, +1))
h = list(map(int, input().strip().split(" ")))
# 初期の条件 0歩の時は値が与えられていないのでDPは0にセット
dp[0] = 0
for position in range(1, N, +1):
# 一つ手前の足場までで最適な値のはず、のコスト
previousMinCost = dp[position - 1]
# 一つ手前から来た場合の足場positionでのコスト計
# pM = previousMin
pMNowCost = dp[position - 1] + abs(h[position] - h[position - 1])
# 今の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if pMNowCost <= dp[position]:
dp[position] = pMNowCost
# これは二つ手前から来たケースを考えるのでpositon = 1の場合を除いて考える
# それ以降は一個手前からと同じ
if 1 < position:
previous2MinCost = dp[position - 2]
pM2NowCost = dp[position - 2] + abs(h[position] - h[position - 2])
if pM2NowCost <= dp[position]:
dp[position] = pM2NowCost
print(("{}".format(dp[N - 1])))
|
# _*_ coding:utf-8 _*_
# Atcoder_EducationDP_ContestX-1_other1
# TODO https://atcoder.jp/contests/dp/tasks/dp_a
# 参考文献 https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E8%A7%A3%E6%B3%95
# C++ バージョンを上から書き下す
# TODO 配る型DP https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E5%88%A5%E8%A7%A3-1-%E9%85%8D%E3%82%8B-dp
import sys
# 初期化
# 足場の数となる要素数は足場の値の最大値であるMAX
blockMAXElement = 100010
blockElementRange = list(range(0, blockMAXElement, +1))
# DPテーブルの中身は今回は最小値を求めるため最大値を利用
dp = [sys.maxsize] * blockMAXElement
# コスト
# 参考文献のC++では配列は宣言時に初期化されるがpythonはそれがないのでまずはあえて0で初期化
h = [0] * blockMAXElement
N = int(input().strip())
inputh = list(map(int, input().strip().split(" ")))
# h配列を入力データから取り出した物に置き換える
for i in range(0, len(inputh), +1):
h[i] = inputh[i]
# 初期の条件 0歩の時だけはコストがないので、0にセット
dp[0] = 0
# 現在の位置から最後の一歩手前(N-2歩き目)まで(仮にそこで2歩進んだ場合もDPテーブルはあるのでエラーにはならず)
for position in range(0, N - 1, +1):
# 現在の岩場で最適な値のコスト
nowMinCost = dp[position]
# 1歩進んだときのコスト計
nextOneCost = nowMinCost + abs(h[position + 1] - h[position])
# 一歩次の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる
if nextOneCost < dp[position + 1]:
dp[position + 1] = nextOneCost
# 2歩足場をまたいだケースを考える。貰う場合と異なるのはpositionは0から始めて良いし
# 逆にN-2の石の足場から2歩飛んでもプログラム上ではエラーにならない
# それ以降は1個手前からと同じ
nextTwoCost = dp[position] + abs(h[position + 2] - h[position])
if nextTwoCost < dp[position + 2]:
dp[position + 2] = nextTwoCost
print(("{}".format(dp[N - 1])))
| false | 6.818182 |
[
"-# Atcoder_EducationDP_ContestX-1",
"+# Atcoder_EducationDP_ContestX-1_other1",
"-# 貰う型DP",
"+# TODO 配る型DP https://qiita.com/drken/items/dc53c683d6de8aeacf5a#%E5%88%A5%E8%A7%A3-1-%E9%85%8D%E3%82%8B-dp",
"-dp = list()",
"-for _ in blockElementRange:",
"- dp.append(sys.maxsize)",
"+dp = [sys.maxsize] * blockMAXElement",
"+# コスト",
"+# 参考文献のC++では配列は宣言時に初期化されるがpythonはそれがないのでまずはあえて0で初期化",
"+h = [0] * blockMAXElement",
"-blockRange = list(range(0, N, +1))",
"-h = list(map(int, input().strip().split(\" \")))",
"-# 初期の条件 0歩の時は値が与えられていないのでDPは0にセット",
"+inputh = list(map(int, input().strip().split(\" \")))",
"+# h配列を入力データから取り出した物に置き換える",
"+for i in range(0, len(inputh), +1):",
"+ h[i] = inputh[i]",
"+# 初期の条件 0歩の時だけはコストがないので、0にセット",
"-for position in range(1, N, +1):",
"- # 一つ手前の足場までで最適な値のはず、のコスト",
"- previousMinCost = dp[position - 1]",
"- # 一つ手前から来た場合の足場positionでのコスト計",
"- # pM = previousMin",
"- pMNowCost = dp[position - 1] + abs(h[position] - h[position - 1])",
"- # 今の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる",
"- if pMNowCost <= dp[position]:",
"- dp[position] = pMNowCost",
"- # これは二つ手前から来たケースを考えるのでpositon = 1の場合を除いて考える",
"- # それ以降は一個手前からと同じ",
"- if 1 < position:",
"- previous2MinCost = dp[position - 2]",
"- pM2NowCost = dp[position - 2] + abs(h[position] - h[position - 2])",
"- if pM2NowCost <= dp[position]:",
"- dp[position] = pM2NowCost",
"+# 現在の位置から最後の一歩手前(N-2歩き目)まで(仮にそこで2歩進んだ場合もDPテーブルはあるのでエラーにはならず)",
"+for position in range(0, N - 1, +1):",
"+ # 現在の岩場で最適な値のコスト",
"+ nowMinCost = dp[position]",
"+ # 1歩進んだときのコスト計",
"+ nextOneCost = nowMinCost + abs(h[position + 1] - h[position])",
"+ # 一歩次の足場で設定されている足場へのコストより小さくなるならそれを改めて入れる",
"+ if nextOneCost < dp[position + 1]:",
"+ dp[position + 1] = nextOneCost",
"+ # 2歩足場をまたいだケースを考える。貰う場合と異なるのはpositionは0から始めて良いし",
"+ # 逆にN-2の石の足場から2歩飛んでもプログラム上ではエラーにならない",
"+ # それ以降は1個手前からと同じ",
"+ nextTwoCost = dp[position] + abs(h[position + 2] - h[position])",
"+ if nextTwoCost < dp[position + 2]:",
"+ dp[position + 2] = nextTwoCost"
] | false | 0.076291 | 0.045248 | 1.686044 |
[
"s919335661",
"s451589132"
] |
u426534722
|
p02343
|
python
|
s819910295
|
s048175730
| 420 | 370 | 9,996 | 10,004 |
Accepted
|
Accepted
| 11.9 |
from sys import stdin
high = [0] * 10000
par = [i for i in range(10000)]
def findSet(x):
if par[x] == x: return x
par[x] = findSet(par[x])
return par[x]
def unite(x, y):
x = findSet(x)
y = findSet(y)
if x == y: return
if high[x] > high[y]: par[y] = x;
else:
par[x] = y
if high[x] == high[y]: high[y] += 1
def same(x, y):
return findSet(x) == findSet(y)
n, q = map(int, stdin.readline().split())
ans = []
ans_append = ans.append
for i in range(q):
t, a, b = map(int, stdin.readline().split())
if t == 0: unite(a, b);
elif t == 1: ans_append(1 if same(a, b) else 0)
print(*ans, sep='\n')
|
from sys import stdin
n, q = map(int, stdin.readline().split())
ans = []
ans_append = ans.append
high = [0] * n
par = [i for i in range(n)]
def findSet(x):
if par[x] == x: return x
par[x] = findSet(par[x])
return par[x]
def unite(x, y):
x = findSet(x)
y = findSet(y)
if x == y: return
if high[x] > high[y]: par[y] = x;
else:
par[x] = y
if high[x] == high[y]: high[y] += 1
def same(x, y):
return findSet(x) == findSet(y)
for i in range(q):
t, a, b = map(int, stdin.readline().split())
if t == 0: unite(a, b);
elif t == 1: ans_append(1 if same(a, b) else 0)
print(*ans, sep='\n')
| 25 | 25 | 673 | 665 |
from sys import stdin
high = [0] * 10000
par = [i for i in range(10000)]
def findSet(x):
if par[x] == x:
return x
par[x] = findSet(par[x])
return par[x]
def unite(x, y):
x = findSet(x)
y = findSet(y)
if x == y:
return
if high[x] > high[y]:
par[y] = x
else:
par[x] = y
if high[x] == high[y]:
high[y] += 1
def same(x, y):
return findSet(x) == findSet(y)
n, q = map(int, stdin.readline().split())
ans = []
ans_append = ans.append
for i in range(q):
t, a, b = map(int, stdin.readline().split())
if t == 0:
unite(a, b)
elif t == 1:
ans_append(1 if same(a, b) else 0)
print(*ans, sep="\n")
|
from sys import stdin
n, q = map(int, stdin.readline().split())
ans = []
ans_append = ans.append
high = [0] * n
par = [i for i in range(n)]
def findSet(x):
if par[x] == x:
return x
par[x] = findSet(par[x])
return par[x]
def unite(x, y):
x = findSet(x)
y = findSet(y)
if x == y:
return
if high[x] > high[y]:
par[y] = x
else:
par[x] = y
if high[x] == high[y]:
high[y] += 1
def same(x, y):
return findSet(x) == findSet(y)
for i in range(q):
t, a, b = map(int, stdin.readline().split())
if t == 0:
unite(a, b)
elif t == 1:
ans_append(1 if same(a, b) else 0)
print(*ans, sep="\n")
| false | 0 |
[
"-high = [0] * 10000",
"-par = [i for i in range(10000)]",
"+n, q = map(int, stdin.readline().split())",
"+ans = []",
"+ans_append = ans.append",
"+high = [0] * n",
"+par = [i for i in range(n)]",
"-n, q = map(int, stdin.readline().split())",
"-ans = []",
"-ans_append = ans.append"
] | false | 0.035043 | 0.036757 | 0.95337 |
[
"s819910295",
"s048175730"
] |
u416011173
|
p02596
|
python
|
s097532523
|
s045076378
| 1,489 | 906 | 9,156 | 9,176 |
Accepted
|
Accepted
| 39.15 |
# -*- coding: utf-8 -*-
# 標準入力を取得
K = int(eval(input()))
# 求解処理
ans = -1
remainder = 7 % K
for i in range(1, 9000000):
if remainder == 0:
ans = i
break
remainder = (10 * remainder + 7) % K
# 結果出力
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> int:
"""
標準入力を取得する.
Returns:\n
int: 標準入力
"""
K = int(eval(input()))
return K
def main(K: int) -> None:
"""
メイン処理.
Args:\n
K (int): 整数（1 <= K <= 10^6）
"""
# 求解処理
ans = -1
remainder = 7 % K
for i in range(1, 9000000):
if remainder == 0:
ans = i
break
remainder = (10 * remainder + 7) % K
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
K = get_input()
# メイン処理
main(K)
| 15 | 40 | 241 | 595 |
# -*- coding: utf-8 -*-
# 標準入力を取得
K = int(eval(input()))
# 求解処理
ans = -1
remainder = 7 % K
for i in range(1, 9000000):
if remainder == 0:
ans = i
break
remainder = (10 * remainder + 7) % K
# 結果出力
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> int:
"""
標準入力を取得する.
Returns:\n
int: 標準入力
"""
K = int(eval(input()))
return K
def main(K: int) -> None:
"""
メイン処理.
Args:\n
K (int): 整数（1 <= K <= 10^6）
"""
# 求解処理
ans = -1
remainder = 7 % K
for i in range(1, 9000000):
if remainder == 0:
ans = i
break
remainder = (10 * remainder + 7) % K
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
K = get_input()
# メイン処理
main(K)
| false | 62.5 |
[
"-# 標準入力を取得",
"-K = int(eval(input()))",
"-# 求解処理",
"-ans = -1",
"-remainder = 7 % K",
"-for i in range(1, 9000000):",
"- if remainder == 0:",
"- ans = i",
"- break",
"- remainder = (10 * remainder + 7) % K",
"-# 結果出力",
"-print(ans)",
"+def get_input() -> int:",
"+ \"\"\"",
"+ 標準入力を取得する.",
"+ Returns:\\n",
"+ int: 標準入力",
"+ \"\"\"",
"+ K = int(eval(input()))",
"+ return K",
"+",
"+",
"+def main(K: int) -> None:",
"+ \"\"\"",
"+ メイン処理.",
"+ Args:\\n",
"+ K (int): 整数（1 <= K <= 10^6）",
"+ \"\"\"",
"+ # 求解処理",
"+ ans = -1",
"+ remainder = 7 % K",
"+ for i in range(1, 9000000):",
"+ if remainder == 0:",
"+ ans = i",
"+ break",
"+ remainder = (10 * remainder + 7) % K",
"+ # 結果出力",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # 標準入力を取得",
"+ K = get_input()",
"+ # メイン処理",
"+ main(K)"
] | false | 0.247781 | 0.233687 | 1.06031 |
[
"s097532523",
"s045076378"
] |
u818349438
|
p02820
|
python
|
s791952644
|
s850794627
| 967 | 360 | 24,444 | 25,932 |
Accepted
|
Accepted
| 62.77 |
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = input().strip()
def pon(computer, mine):
if computer == 'r' and mine == 2: return P
if computer == 's' and mine == 0: return R
if computer == 'p' and mine == 1: return S
return 0
dp = [[0 for _ in range(3)] for _ in range(N+10)]
ans = 0
for st in range(K):
for i in range(st, N, K):
for j in range(3):
for k in range(3):
if j == k:
continue
if i+1-K >= 0:
dp[i+1][k] = max(dp[i+1][k], dp[i+1-K][j] + pon(T[i], k))
else:
dp[i+1][k] = max(dp[i+1][k], pon(T[i], k))
ans += max(dp[i+1])
print(ans)
|
n,k = list(map(int,input().split()))
r,s,p = list(map(int,input().split()))
t = eval(input())
#dp[i][ｊ]:=i番目までで、最後にｊを出したときの点数の最大値
dp = [[-10**9]*3for i in range(n+k)]
for i in range(k):
dp[i][0],dp[i][1],dp[i][2] = 0,0,0
for i in range(k):
for j in range(n//k+3):
if i > n-1:continue
if t[i] == "r":
dp[i+k][0] = max(dp[i][1],dp[i][2])
dp[i+k][1] = max(dp[i][0],dp[i][2])
dp[i+k][2] = max(dp[i][0]+p,dp[i][1]+p)
elif t[i] == "s":
dp[i+k][0] = max(dp[i][1]+r,dp[i][2]+r)
dp[i+k][1] = max(dp[i][0],dp[i][2])
dp[i+k][2] = max(dp[i][0],dp[i][1])
elif t[i] == "p":
dp[i+k][0] = max(dp[i][1],dp[i][2])
dp[i+k][1] = max(dp[i][0]+s,dp[i][2]+s)
dp[i+k][2] = max(dp[i][0],dp[i][1])
i += k
ans = 0
for i in range(n,n+k):
ans += max(dp[i])
print(ans)
| 28 | 32 | 752 | 946 |
N, K = list(map(int, input().split()))
R, S, P = list(map(int, input().split()))
T = input().strip()
def pon(computer, mine):
if computer == "r" and mine == 2:
return P
if computer == "s" and mine == 0:
return R
if computer == "p" and mine == 1:
return S
return 0
dp = [[0 for _ in range(3)] for _ in range(N + 10)]
ans = 0
for st in range(K):
for i in range(st, N, K):
for j in range(3):
for k in range(3):
if j == k:
continue
if i + 1 - K >= 0:
dp[i + 1][k] = max(dp[i + 1][k], dp[i + 1 - K][j] + pon(T[i], k))
else:
dp[i + 1][k] = max(dp[i + 1][k], pon(T[i], k))
ans += max(dp[i + 1])
print(ans)
|
n, k = list(map(int, input().split()))
r, s, p = list(map(int, input().split()))
t = eval(input())
# dp[i][ｊ]:=i番目までで、最後にｊを出したときの点数の最大値
dp = [[-(10**9)] * 3 for i in range(n + k)]
for i in range(k):
dp[i][0], dp[i][1], dp[i][2] = 0, 0, 0
for i in range(k):
for j in range(n // k + 3):
if i > n - 1:
continue
if t[i] == "r":
dp[i + k][0] = max(dp[i][1], dp[i][2])
dp[i + k][1] = max(dp[i][0], dp[i][2])
dp[i + k][2] = max(dp[i][0] + p, dp[i][1] + p)
elif t[i] == "s":
dp[i + k][0] = max(dp[i][1] + r, dp[i][2] + r)
dp[i + k][1] = max(dp[i][0], dp[i][2])
dp[i + k][2] = max(dp[i][0], dp[i][1])
elif t[i] == "p":
dp[i + k][0] = max(dp[i][1], dp[i][2])
dp[i + k][1] = max(dp[i][0] + s, dp[i][2] + s)
dp[i + k][2] = max(dp[i][0], dp[i][1])
i += k
ans = 0
for i in range(n, n + k):
ans += max(dp[i])
print(ans)
| false | 12.5 |
[
"-N, K = list(map(int, input().split()))",
"-R, S, P = list(map(int, input().split()))",
"-T = input().strip()",
"-",
"-",
"-def pon(computer, mine):",
"- if computer == \"r\" and mine == 2:",
"- return P",
"- if computer == \"s\" and mine == 0:",
"- return R",
"- if computer == \"p\" and mine == 1:",
"- return S",
"- return 0",
"-",
"-",
"-dp = [[0 for _ in range(3)] for _ in range(N + 10)]",
"+n, k = list(map(int, input().split()))",
"+r, s, p = list(map(int, input().split()))",
"+t = eval(input())",
"+# dp[i][ｊ]:=i番目までで、最後にｊを出したときの点数の最大値",
"+dp = [[-(10**9)] * 3 for i in range(n + k)]",
"+for i in range(k):",
"+ dp[i][0], dp[i][1], dp[i][2] = 0, 0, 0",
"+for i in range(k):",
"+ for j in range(n // k + 3):",
"+ if i > n - 1:",
"+ continue",
"+ if t[i] == \"r\":",
"+ dp[i + k][0] = max(dp[i][1], dp[i][2])",
"+ dp[i + k][1] = max(dp[i][0], dp[i][2])",
"+ dp[i + k][2] = max(dp[i][0] + p, dp[i][1] + p)",
"+ elif t[i] == \"s\":",
"+ dp[i + k][0] = max(dp[i][1] + r, dp[i][2] + r)",
"+ dp[i + k][1] = max(dp[i][0], dp[i][2])",
"+ dp[i + k][2] = max(dp[i][0], dp[i][1])",
"+ elif t[i] == \"p\":",
"+ dp[i + k][0] = max(dp[i][1], dp[i][2])",
"+ dp[i + k][1] = max(dp[i][0] + s, dp[i][2] + s)",
"+ dp[i + k][2] = max(dp[i][0], dp[i][1])",
"+ i += k",
"-for st in range(K):",
"- for i in range(st, N, K):",
"- for j in range(3):",
"- for k in range(3):",
"- if j == k:",
"- continue",
"- if i + 1 - K >= 0:",
"- dp[i + 1][k] = max(dp[i + 1][k], dp[i + 1 - K][j] + pon(T[i], k))",
"- else:",
"- dp[i + 1][k] = max(dp[i + 1][k], pon(T[i], k))",
"- ans += max(dp[i + 1])",
"+for i in range(n, n + k):",
"+ ans += max(dp[i])"
] | false | 0.045049 | 0.041344 | 1.089628 |
[
"s791952644",
"s850794627"
] |
u673361376
|
p02837
|
python
|
s188048320
|
s847374622
| 261 | 102 | 44,892 | 3,064 |
Accepted
|
Accepted
| 60.92 |
def is_right(i):
trueA =bin(i)[2:].zfill(N)
for ii,flag in enumerate(trueA):
if flag == '1':
for x,y in A[ii]:
if trueA[x] != str(y):
return False
return True
N = int(eval(input()))
A = []
for _ in range(N):
a = int(eval(input()))
tmpA = []
for _ in range(a):
x,y = list(map(int,input().split()))
tmpA.append([x-1,y])
A.append(tmpA)
ans = 0
for i in range(2**N):
if is_right(i):
ans = max(ans,bin(i).count('1'))
print(ans)
|
def is_case_possible(case):
for i, flag in enumerate(case):
if flag == '1':
for x, y in XY[i]:
x -= 1
if case[x] != str(y):
return False
return True
N = int(eval(input()))
XY = []
for _ in range(N):
A = int(eval(input()))
xy = [list(map(int, input().split())) for _ in range(A)]
XY.append(xy)
ans = 0
for i in range(2**N):
case = bin(i)[2:].zfill(N)
if is_case_possible(case):
ans = max(ans, case.count('1'))
print(ans)
| 24 | 22 | 485 | 538 |
def is_right(i):
trueA = bin(i)[2:].zfill(N)
for ii, flag in enumerate(trueA):
if flag == "1":
for x, y in A[ii]:
if trueA[x] != str(y):
return False
return True
N = int(eval(input()))
A = []
for _ in range(N):
a = int(eval(input()))
tmpA = []
for _ in range(a):
x, y = list(map(int, input().split()))
tmpA.append([x - 1, y])
A.append(tmpA)
ans = 0
for i in range(2**N):
if is_right(i):
ans = max(ans, bin(i).count("1"))
print(ans)
|
def is_case_possible(case):
for i, flag in enumerate(case):
if flag == "1":
for x, y in XY[i]:
x -= 1
if case[x] != str(y):
return False
return True
N = int(eval(input()))
XY = []
for _ in range(N):
A = int(eval(input()))
xy = [list(map(int, input().split())) for _ in range(A)]
XY.append(xy)
ans = 0
for i in range(2**N):
case = bin(i)[2:].zfill(N)
if is_case_possible(case):
ans = max(ans, case.count("1"))
print(ans)
| false | 8.333333 |
[
"-def is_right(i):",
"- trueA = bin(i)[2:].zfill(N)",
"- for ii, flag in enumerate(trueA):",
"+def is_case_possible(case):",
"+ for i, flag in enumerate(case):",
"- for x, y in A[ii]:",
"- if trueA[x] != str(y):",
"+ for x, y in XY[i]:",
"+ x -= 1",
"+ if case[x] != str(y):",
"-A = []",
"+XY = []",
"- a = int(eval(input()))",
"- tmpA = []",
"- for _ in range(a):",
"- x, y = list(map(int, input().split()))",
"- tmpA.append([x - 1, y])",
"- A.append(tmpA)",
"+ A = int(eval(input()))",
"+ xy = [list(map(int, input().split())) for _ in range(A)]",
"+ XY.append(xy)",
"- if is_right(i):",
"- ans = max(ans, bin(i).count(\"1\"))",
"+ case = bin(i)[2:].zfill(N)",
"+ if is_case_possible(case):",
"+ ans = max(ans, case.count(\"1\"))"
] | false | 0.057418 | 0.069995 | 0.820309 |
[
"s188048320",
"s847374622"
] |
u298297089
|
p03645
|
python
|
s069984412
|
s426804330
| 1,210 | 927 | 125,052 | 96,620 |
Accepted
|
Accepted
| 23.39 |
N,M = list(map(int, input().split()))
islands = {}
for i in range(M):
a,b = list(map(int, input().split()))
if a not in islands:
islands[a] = {}
if b not in islands:
islands[b] = {}
islands[a][b] = islands[b][a] = 1
if N not in islands:
print('IMPOSSIBLE')
exit()
for i in list(islands[1].keys()):
if i in islands[N]:
print('POSSIBLE')
exit()
print('IMPOSSIBLE')
|
n,m = list(map(int, input().split()))
d = {}
for _ in range(m):
a,b = list(map(int, input().split()))
if a not in d:
d[a] = {}
if b not in d:
d[b] = {}
d[a][b] = d[b][a] = 1
for v in list(d.values()):
if 1 in v and n in v:
print('POSSIBLE')
break
else:
print('IMPOSSIBLE')
| 19 | 16 | 424 | 327 |
N, M = list(map(int, input().split()))
islands = {}
for i in range(M):
a, b = list(map(int, input().split()))
if a not in islands:
islands[a] = {}
if b not in islands:
islands[b] = {}
islands[a][b] = islands[b][a] = 1
if N not in islands:
print("IMPOSSIBLE")
exit()
for i in list(islands[1].keys()):
if i in islands[N]:
print("POSSIBLE")
exit()
print("IMPOSSIBLE")
|
n, m = list(map(int, input().split()))
d = {}
for _ in range(m):
a, b = list(map(int, input().split()))
if a not in d:
d[a] = {}
if b not in d:
d[b] = {}
d[a][b] = d[b][a] = 1
for v in list(d.values()):
if 1 in v and n in v:
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
| false | 15.789474 |
[
"-N, M = list(map(int, input().split()))",
"-islands = {}",
"-for i in range(M):",
"+n, m = list(map(int, input().split()))",
"+d = {}",
"+for _ in range(m):",
"- if a not in islands:",
"- islands[a] = {}",
"- if b not in islands:",
"- islands[b] = {}",
"- islands[a][b] = islands[b][a] = 1",
"-if N not in islands:",
"+ if a not in d:",
"+ d[a] = {}",
"+ if b not in d:",
"+ d[b] = {}",
"+ d[a][b] = d[b][a] = 1",
"+for v in list(d.values()):",
"+ if 1 in v and n in v:",
"+ print(\"POSSIBLE\")",
"+ break",
"+else:",
"- exit()",
"-for i in list(islands[1].keys()):",
"- if i in islands[N]:",
"- print(\"POSSIBLE\")",
"- exit()",
"-print(\"IMPOSSIBLE\")"
] | false | 0.050906 | 0.109577 | 0.464565 |
[
"s069984412",
"s426804330"
] |
u022407960
|
p02295
|
python
|
s242741974
|
s898712441
| 40 | 30 | 7,936 | 8,320 |
Accepted
|
Accepted
| 25 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
0 0 2 0 1 1 1 -1
0 0 1 1 0 1 1 0
0 0 1 1 1 0 0 1
output:
1.0000000000 0.0000000000
0.5000000000 0.5000000000
0.5000000000 0.5000000000
"""
import sys
class Segment(object):
__slots__ = ('source', 'target')
def __init__(self, source, target):
self.source = complex(source)
self.target = complex(target)
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def get_cross_point(s1, s2):
base_vector = s2.target - s2.source
d1 = abs(cross(base_vector, s1.source - s2.source))
d2 = abs(cross(base_vector, s1.target - s2.source))
t = d1 / (d1 + d2)
cross_point = s1.source + (s1.target - s1.source) * t
print(('{real:.10f} {imag:.10f}'.format(real=cross_point.real, imag=cross_point.imag)))
return None
def solve(_lines):
for line in _lines:
line = tuple(map(int, line))
p0, p1, p2, p3 = (x + y * 1j for x, y in zip(line[::2], line[1::2]))
s1, s2 = Segment(p0, p1), Segment(p2, p3)
get_cross_point(s1, s2)
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
l_num = int(_input[0])
lines = [x.split() for x in _input[1:]]
solve(lines)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
0 0 2 0 1 1 1 -1
0 0 1 1 0 1 1 0
0 0 1 1 1 0 0 1
output:
1.0000000000 0.0000000000
0.5000000000 0.5000000000
0.5000000000 0.5000000000
"""
import sys
from collections import namedtuple
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def get_cross_point(s1, s2):
base_vector = s2.target - s2.source
d1 = abs(cross(base_vector, s1.source - s2.source))
d2 = abs(cross(base_vector, s1.target - s2.source))
t = d1 / (d1 + d2)
cross_point = s1.source + (s1.target - s1.source) * t
print(('{real:.10f} {imag:.10f}'.format(real=cross_point.real, imag=cross_point.imag)))
return None
def solve(_segments):
for segment in _segments:
segment = tuple(map(int, segment))
p0, p1, p2, p3 = (x + y * 1j for x, y in zip(segment[::2], segment[1::2]))
s1, s2 = Segment(p0, p1), Segment(p2, p3)
get_cross_point(s1, s2)
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
l_num = int(_input[0])
segments = [x.split() for x in _input[1:]]
Segment = namedtuple('Segment', ('source', 'target'))
solve(segments)
| 62 | 55 | 1,364 | 1,297 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
0 0 2 0 1 1 1 -1
0 0 1 1 0 1 1 0
0 0 1 1 1 0 0 1
output:
1.0000000000 0.0000000000
0.5000000000 0.5000000000
0.5000000000 0.5000000000
"""
import sys
class Segment(object):
__slots__ = ("source", "target")
def __init__(self, source, target):
self.source = complex(source)
self.target = complex(target)
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def get_cross_point(s1, s2):
base_vector = s2.target - s2.source
d1 = abs(cross(base_vector, s1.source - s2.source))
d2 = abs(cross(base_vector, s1.target - s2.source))
t = d1 / (d1 + d2)
cross_point = s1.source + (s1.target - s1.source) * t
print(
("{real:.10f} {imag:.10f}".format(real=cross_point.real, imag=cross_point.imag))
)
return None
def solve(_lines):
for line in _lines:
line = tuple(map(int, line))
p0, p1, p2, p3 = (x + y * 1j for x, y in zip(line[::2], line[1::2]))
s1, s2 = Segment(p0, p1), Segment(p2, p3)
get_cross_point(s1, s2)
return None
if __name__ == "__main__":
_input = sys.stdin.readlines()
l_num = int(_input[0])
lines = [x.split() for x in _input[1:]]
solve(lines)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3
0 0 2 0 1 1 1 -1
0 0 1 1 0 1 1 0
0 0 1 1 1 0 0 1
output:
1.0000000000 0.0000000000
0.5000000000 0.5000000000
0.5000000000 0.5000000000
"""
import sys
from collections import namedtuple
def cross(a, b):
return a.real * b.imag - a.imag * b.real
def dot(a, b):
return a.real * b.real + a.imag * b.imag
def get_cross_point(s1, s2):
base_vector = s2.target - s2.source
d1 = abs(cross(base_vector, s1.source - s2.source))
d2 = abs(cross(base_vector, s1.target - s2.source))
t = d1 / (d1 + d2)
cross_point = s1.source + (s1.target - s1.source) * t
print(
("{real:.10f} {imag:.10f}".format(real=cross_point.real, imag=cross_point.imag))
)
return None
def solve(_segments):
for segment in _segments:
segment = tuple(map(int, segment))
p0, p1, p2, p3 = (x + y * 1j for x, y in zip(segment[::2], segment[1::2]))
s1, s2 = Segment(p0, p1), Segment(p2, p3)
get_cross_point(s1, s2)
return None
if __name__ == "__main__":
_input = sys.stdin.readlines()
l_num = int(_input[0])
segments = [x.split() for x in _input[1:]]
Segment = namedtuple("Segment", ("source", "target"))
solve(segments)
| false | 11.290323 |
[
"-",
"-",
"-class Segment(object):",
"- __slots__ = (\"source\", \"target\")",
"-",
"- def __init__(self, source, target):",
"- self.source = complex(source)",
"- self.target = complex(target)",
"+from collections import namedtuple",
"-def solve(_lines):",
"- for line in _lines:",
"- line = tuple(map(int, line))",
"- p0, p1, p2, p3 = (x + y * 1j for x, y in zip(line[::2], line[1::2]))",
"+def solve(_segments):",
"+ for segment in _segments:",
"+ segment = tuple(map(int, segment))",
"+ p0, p1, p2, p3 = (x + y * 1j for x, y in zip(segment[::2], segment[1::2]))",
"- lines = [x.split() for x in _input[1:]]",
"- solve(lines)",
"+ segments = [x.split() for x in _input[1:]]",
"+ Segment = namedtuple(\"Segment\", (\"source\", \"target\"))",
"+ solve(segments)"
] | false | 0.102831 | 0.040164 | 2.560266 |
[
"s242741974",
"s898712441"
] |
u638282348
|
p03814
|
python
|
s529510953
|
s584042054
| 22 | 18 | 4,968 | 3,500 |
Accepted
|
Accepted
| 18.18 |
string = input().rstrip("\n")
string_r = "".join(reversed(string))
print((len(string) - string_r.index("Z") - string.index("A")))
|
[print(len(string) - string[::-1].index("Z") - string.index("A")) for string in [input()]]
| 3 | 1 | 129 | 91 |
string = input().rstrip("\n")
string_r = "".join(reversed(string))
print((len(string) - string_r.index("Z") - string.index("A")))
|
[
print(len(string) - string[::-1].index("Z") - string.index("A"))
for string in [input()]
]
| false | 66.666667 |
[
"-string = input().rstrip(\"\\n\")",
"-string_r = \"\".join(reversed(string))",
"-print((len(string) - string_r.index(\"Z\") - string.index(\"A\")))",
"+[",
"+ print(len(string) - string[::-1].index(\"Z\") - string.index(\"A\"))",
"+ for string in [input()]",
"+]"
] | false | 0.044021 | 0.099394 | 0.442894 |
[
"s529510953",
"s584042054"
] |
u823585596
|
p02554
|
python
|
s352070719
|
s323928934
| 92 | 30 | 73,292 | 8,928 |
Accepted
|
Accepted
| 67.39 |
N=int(eval(input()))
mod=10**9+7
t=0
a,b,c=1,1,1
for i in range(N):
a*=10
b*=9
c*=8
if i%10==0:
a%=mod
b%=mod
c%=mod
ans=(a+c-(2*b))%mod
print(ans)
|
N=int(eval(input()))
mod = 10**9+7
ans = pow(10,N,mod)
ans -= pow(9,N,mod)*2
ans += pow(8,N,mod)
print((ans%mod))
| 14 | 6 | 194 | 111 |
N = int(eval(input()))
mod = 10**9 + 7
t = 0
a, b, c = 1, 1, 1
for i in range(N):
a *= 10
b *= 9
c *= 8
if i % 10 == 0:
a %= mod
b %= mod
c %= mod
ans = (a + c - (2 * b)) % mod
print(ans)
|
N = int(eval(input()))
mod = 10**9 + 7
ans = pow(10, N, mod)
ans -= pow(9, N, mod) * 2
ans += pow(8, N, mod)
print((ans % mod))
| false | 57.142857 |
[
"-t = 0",
"-a, b, c = 1, 1, 1",
"-for i in range(N):",
"- a *= 10",
"- b *= 9",
"- c *= 8",
"- if i % 10 == 0:",
"- a %= mod",
"- b %= mod",
"- c %= mod",
"-ans = (a + c - (2 * b)) % mod",
"-print(ans)",
"+ans = pow(10, N, mod)",
"+ans -= pow(9, N, mod) * 2",
"+ans += pow(8, N, mod)",
"+print((ans % mod))"
] | false | 0.146716 | 0.036236 | 4.048875 |
[
"s352070719",
"s323928934"
] |
u888092736
|
p02973
|
python
|
s336395723
|
s078263236
| 421 | 101 | 20,660 | 19,968 |
Accepted
|
Accepted
| 76.01 |
def binary_search(key):
bad, good = -1, len(ans)
while good - bad > 1:
mid = (bad + good) // 2
if ans[mid][-1] < key:
good = mid
else:
bad = mid
return good
N = int(eval(input()))
ans = []
for _ in range(N):
A = int(eval(input()))
idx = binary_search(A)
if idx == len(ans):
ans.append([A])
else:
ans[idx].append(A)
print((len(ans)))
|
from bisect import bisect_right
N, *A = list(map(int, open(0).read().split()))
A = [-a for a in A]
q = []
for a in A:
idx = bisect_right(q, a)
if idx == len(q):
q.append(a)
else:
q[idx] = a
print((len(q)))
| 21 | 13 | 433 | 240 |
def binary_search(key):
bad, good = -1, len(ans)
while good - bad > 1:
mid = (bad + good) // 2
if ans[mid][-1] < key:
good = mid
else:
bad = mid
return good
N = int(eval(input()))
ans = []
for _ in range(N):
A = int(eval(input()))
idx = binary_search(A)
if idx == len(ans):
ans.append([A])
else:
ans[idx].append(A)
print((len(ans)))
|
from bisect import bisect_right
N, *A = list(map(int, open(0).read().split()))
A = [-a for a in A]
q = []
for a in A:
idx = bisect_right(q, a)
if idx == len(q):
q.append(a)
else:
q[idx] = a
print((len(q)))
| false | 38.095238 |
[
"-def binary_search(key):",
"- bad, good = -1, len(ans)",
"- while good - bad > 1:",
"- mid = (bad + good) // 2",
"- if ans[mid][-1] < key:",
"- good = mid",
"- else:",
"- bad = mid",
"- return good",
"+from bisect import bisect_right",
"-",
"-N = int(eval(input()))",
"-ans = []",
"-for _ in range(N):",
"- A = int(eval(input()))",
"- idx = binary_search(A)",
"- if idx == len(ans):",
"- ans.append([A])",
"+N, *A = list(map(int, open(0).read().split()))",
"+A = [-a for a in A]",
"+q = []",
"+for a in A:",
"+ idx = bisect_right(q, a)",
"+ if idx == len(q):",
"+ q.append(a)",
"- ans[idx].append(A)",
"-print((len(ans)))",
"+ q[idx] = a",
"+print((len(q)))"
] | false | 0.037335 | 0.050939 | 0.732941 |
[
"s336395723",
"s078263236"
] |
u813387707
|
p02773
|
python
|
s613419106
|
s847212400
| 891 | 727 | 46,880 | 33,364 |
Accepted
|
Accepted
| 18.41 |
from collections import defaultdict
from operator import itemgetter
n = int(eval(input()))
s_dict = defaultdict(int)
for _ in range(n):
s = eval(input())
s_dict[s] += 1
def multisort(xs, specs):
for key, reverse in reversed(specs):
xs.sort(key=itemgetter(key), reverse=reverse)
return xs
s_list = multisort(list(s_dict.items()), ((1, True), (0, False)))
count_max = s_list[0][1]
for s, count in s_list:
if count < count_max:
break
print(s)
|
from collections import defaultdict
n = int(eval(input()))
s_dict = defaultdict(int)
for _ in range(n):
s_dict[eval(input())] += 1
count_max = sorted(s_dict.values())[-1]
s_list = sorted([s for s, count in list(s_dict.items()) if count == count_max])
for s in s_list:
print(s)
| 21 | 9 | 491 | 274 |
from collections import defaultdict
from operator import itemgetter
n = int(eval(input()))
s_dict = defaultdict(int)
for _ in range(n):
s = eval(input())
s_dict[s] += 1
def multisort(xs, specs):
for key, reverse in reversed(specs):
xs.sort(key=itemgetter(key), reverse=reverse)
return xs
s_list = multisort(list(s_dict.items()), ((1, True), (0, False)))
count_max = s_list[0][1]
for s, count in s_list:
if count < count_max:
break
print(s)
|
from collections import defaultdict
n = int(eval(input()))
s_dict = defaultdict(int)
for _ in range(n):
s_dict[eval(input())] += 1
count_max = sorted(s_dict.values())[-1]
s_list = sorted([s for s, count in list(s_dict.items()) if count == count_max])
for s in s_list:
print(s)
| false | 57.142857 |
[
"-from operator import itemgetter",
"- s = eval(input())",
"- s_dict[s] += 1",
"-",
"-",
"-def multisort(xs, specs):",
"- for key, reverse in reversed(specs):",
"- xs.sort(key=itemgetter(key), reverse=reverse)",
"- return xs",
"-",
"-",
"-s_list = multisort(list(s_dict.items()), ((1, True), (0, False)))",
"-count_max = s_list[0][1]",
"-for s, count in s_list:",
"- if count < count_max:",
"- break",
"+ s_dict[eval(input())] += 1",
"+count_max = sorted(s_dict.values())[-1]",
"+s_list = sorted([s for s, count in list(s_dict.items()) if count == count_max])",
"+for s in s_list:"
] | false | 0.046092 | 0.045511 | 1.01277 |
[
"s613419106",
"s847212400"
] |
u088552457
|
p03721
|
python
|
s213868175
|
s227639939
| 537 | 418 | 28,640 | 76,120 |
Accepted
|
Accepted
| 22.16 |
n, k = list(map(int, input().split()))
nums = []
for _ in range(n):
ab = list(map(int, input().split()))
nums.append(ab)
sn = sorted(nums)
i = 0
while k > 0:
if sn[i][1] < k:
k -= sn[i][1]
else:
print((sn[i][0]))
break
i += 1
|
import fractions
import sys
from functools import reduce
import collections
import time
input = sys.stdin.readline
def main():
n, k = input_list()
total = 0
a_map = {}
for _ in range(n):
num, count = input_list()
if num in a_map:
a_map[num] += count
else:
a_map[num] = count
sa_map = sorted(list(a_map.items()), key=lambda x: x[0])
for num, count in sa_map:
total += count
if k <= total:
print(num)
break
# 2 3 3 3 4 4 4
def get_camulative(l):
import itertools
# 累積和
return [0] + list(itertools.accumulate(l))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
def gcd(*numbers):
return reduce(fractions.gcd, numbers)
def gcd_list(numbers):
return reduce(fractions.gcd, numbers)
if __name__ == "__main__":
main()
| 17 | 59 | 261 | 1,123 |
n, k = list(map(int, input().split()))
nums = []
for _ in range(n):
ab = list(map(int, input().split()))
nums.append(ab)
sn = sorted(nums)
i = 0
while k > 0:
if sn[i][1] < k:
k -= sn[i][1]
else:
print((sn[i][0]))
break
i += 1
|
import fractions
import sys
from functools import reduce
import collections
import time
input = sys.stdin.readline
def main():
n, k = input_list()
total = 0
a_map = {}
for _ in range(n):
num, count = input_list()
if num in a_map:
a_map[num] += count
else:
a_map[num] = count
sa_map = sorted(list(a_map.items()), key=lambda x: x[0])
for num, count in sa_map:
total += count
if k <= total:
print(num)
break
# 2 3 3 3 4 4 4
def get_camulative(l):
import itertools
# 累積和
return [0] + list(itertools.accumulate(l))
def input_list():
return list(map(int, input().split()))
def input_list_str():
return list(map(str, input().split()))
def lcm_base(x, y):
return (x * y) // fractions.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
def gcd(*numbers):
return reduce(fractions.gcd, numbers)
def gcd_list(numbers):
return reduce(fractions.gcd, numbers)
if __name__ == "__main__":
main()
| false | 71.186441 |
[
"-n, k = list(map(int, input().split()))",
"-nums = []",
"-for _ in range(n):",
"- ab = list(map(int, input().split()))",
"- nums.append(ab)",
"-sn = sorted(nums)",
"-i = 0",
"-while k > 0:",
"- if sn[i][1] < k:",
"- k -= sn[i][1]",
"- else:",
"- print((sn[i][0]))",
"- break",
"- i += 1",
"+import fractions",
"+import sys",
"+from functools import reduce",
"+import collections",
"+import time",
"+",
"+input = sys.stdin.readline",
"+",
"+",
"+def main():",
"+ n, k = input_list()",
"+ total = 0",
"+ a_map = {}",
"+ for _ in range(n):",
"+ num, count = input_list()",
"+ if num in a_map:",
"+ a_map[num] += count",
"+ else:",
"+ a_map[num] = count",
"+ sa_map = sorted(list(a_map.items()), key=lambda x: x[0])",
"+ for num, count in sa_map:",
"+ total += count",
"+ if k <= total:",
"+ print(num)",
"+ break",
"+ # 2 3 3 3 4 4 4",
"+",
"+",
"+def get_camulative(l):",
"+ import itertools",
"+",
"+ # 累積和",
"+ return [0] + list(itertools.accumulate(l))",
"+",
"+",
"+def input_list():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def input_list_str():",
"+ return list(map(str, input().split()))",
"+",
"+",
"+def lcm_base(x, y):",
"+ return (x * y) // fractions.gcd(x, y)",
"+",
"+",
"+def lcm_list(numbers):",
"+ return reduce(lcm_base, numbers, 1)",
"+",
"+",
"+def gcd(*numbers):",
"+ return reduce(fractions.gcd, numbers)",
"+",
"+",
"+def gcd_list(numbers):",
"+ return reduce(fractions.gcd, numbers)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.041663 | 0.101635 | 0.409932 |
[
"s213868175",
"s227639939"
] |
u583507988
|
p02983
|
python
|
s957736174
|
s905648205
| 523 | 81 | 81,016 | 65,504 |
Accepted
|
Accepted
| 84.51 |
L,R=list(map(int,input().split()))
l1=L//2019
r1=R//2019
if l1<r1:
print((0))
elif l1==r1:
res=[]
for i in range(L,R+1):
for j in range(i+1,R+1):
res.append((i*j)%2019)
print((min(res)))
|
l,r=list(map(int,input().split()))
mod=2019
a=l%mod
b=l//mod
c=r%mod
d=r//mod
if d-b!=0:
print((0))
else:
ans=float('inf')
for i in range(l,r):
for j in range(i+1,r+1):
ans=min(ans,(i*j)%mod)
print(ans)
| 11 | 14 | 204 | 225 |
L, R = list(map(int, input().split()))
l1 = L // 2019
r1 = R // 2019
if l1 < r1:
print((0))
elif l1 == r1:
res = []
for i in range(L, R + 1):
for j in range(i + 1, R + 1):
res.append((i * j) % 2019)
print((min(res)))
|
l, r = list(map(int, input().split()))
mod = 2019
a = l % mod
b = l // mod
c = r % mod
d = r // mod
if d - b != 0:
print((0))
else:
ans = float("inf")
for i in range(l, r):
for j in range(i + 1, r + 1):
ans = min(ans, (i * j) % mod)
print(ans)
| false | 21.428571 |
[
"-L, R = list(map(int, input().split()))",
"-l1 = L // 2019",
"-r1 = R // 2019",
"-if l1 < r1:",
"+l, r = list(map(int, input().split()))",
"+mod = 2019",
"+a = l % mod",
"+b = l // mod",
"+c = r % mod",
"+d = r // mod",
"+if d - b != 0:",
"-elif l1 == r1:",
"- res = []",
"- for i in range(L, R + 1):",
"- for j in range(i + 1, R + 1):",
"- res.append((i * j) % 2019)",
"- print((min(res)))",
"+else:",
"+ ans = float(\"inf\")",
"+ for i in range(l, r):",
"+ for j in range(i + 1, r + 1):",
"+ ans = min(ans, (i * j) % mod)",
"+ print(ans)"
] | false | 0.038682 | 0.046597 | 0.830129 |
[
"s957736174",
"s905648205"
] |
u191874006
|
p02842
|
python
|
s989177890
|
s916126402
| 166 | 76 | 38,512 | 66,632 |
Accepted
|
Accepted
| 54.22 |
#!/usr/bin/env python3
#三井住友信託銀行プログラミングコンテスト2019 B
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
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()
for i in range(500001):
if int(i*1.08) == n:
print(i)
break
else:
print(':(')
|
#!/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()
for i in range(10**6+1):
if (i * 108) // 100 == n:
print(i)
quit()
print(":(")
| 27 | 25 | 701 | 671 |
#!/usr/bin/env python3
# 三井住友信託銀行プログラミングコンテスト2019 B
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
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()
for i in range(500001):
if int(i * 1.08) == n:
print(i)
break
else:
print(":(")
|
#!/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()
for i in range(10**6 + 1):
if (i * 108) // 100 == n:
print(i)
quit()
print(":(")
| false | 7.407407 |
[
"-# 三井住友信託銀行プログラミングコンテスト2019 B",
"-sys.setrecursionlimit(1000000)",
"+sys.setrecursionlimit(2147483647)",
"-for i in range(500001):",
"- if int(i * 1.08) == n:",
"+for i in range(10**6 + 1):",
"+ if (i * 108) // 100 == n:",
"- break",
"-else:",
"- print(\":(\")",
"+ quit()",
"+print(\":(\")"
] | false | 0.051456 | 0.076093 | 0.676225 |
[
"s989177890",
"s916126402"
] |
u745687363
|
p02678
|
python
|
s383174421
|
s095792760
| 909 | 753 | 182,888 | 69,680 |
Accepted
|
Accepted
| 17.16 |
n, m = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**6)
L=[set() for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
L[a-1] |= {b}
L[b-1] |= {a}
Y = {list(range(1, n+1))}
Z = [0]*(n-1)
S = {1}
def f(X):
global S, Z
X_next = set()
for j in X:
R = L[j-1]-S
S |= L[j-1]
X_next |= R
for k in R:
Z[k-2] += j
if X_next == set():
print("Yes")
print(('\n'.join(map(str, Z))))
else:
return f(X_next)
f({1})
|
n, m = list(map(int, input().split()))
L=[set() for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
L[a-1] |= {b}
L[b-1] |= {a}
Y = {list(range(1, n+1))}
Z = [0]*(n-1)
S = {1}
X = {1}
while len(S) != n:
X_next = set()
for j in X:
R = L[j-1]-S
S |= R
X_next |= R
for k in R:
Z[k-2] += j
X = X_next
continue
else:
print("Yes")
print(('\n'.join(map(str, Z))))
| 26 | 23 | 553 | 465 |
n, m = list(map(int, input().split()))
import sys
sys.setrecursionlimit(10**6)
L = [set() for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
L[a - 1] |= {b}
L[b - 1] |= {a}
Y = {list(range(1, n + 1))}
Z = [0] * (n - 1)
S = {1}
def f(X):
global S, Z
X_next = set()
for j in X:
R = L[j - 1] - S
S |= L[j - 1]
X_next |= R
for k in R:
Z[k - 2] += j
if X_next == set():
print("Yes")
print(("\n".join(map(str, Z))))
else:
return f(X_next)
f({1})
|
n, m = list(map(int, input().split()))
L = [set() for i in range(n)]
for i in range(m):
a, b = list(map(int, input().split()))
L[a - 1] |= {b}
L[b - 1] |= {a}
Y = {list(range(1, n + 1))}
Z = [0] * (n - 1)
S = {1}
X = {1}
while len(S) != n:
X_next = set()
for j in X:
R = L[j - 1] - S
S |= R
X_next |= R
for k in R:
Z[k - 2] += j
X = X_next
continue
else:
print("Yes")
print(("\n".join(map(str, Z))))
| false | 11.538462 |
[
"-import sys",
"-",
"-sys.setrecursionlimit(10**6)",
"-",
"-",
"-def f(X):",
"- global S, Z",
"+X = {1}",
"+while len(S) != n:",
"- S |= L[j - 1]",
"+ S |= R",
"- if X_next == set():",
"- print(\"Yes\")",
"- print((\"\\n\".join(map(str, Z))))",
"- else:",
"- return f(X_next)",
"-",
"-",
"-f({1})",
"+ X = X_next",
"+ continue",
"+else:",
"+ print(\"Yes\")",
"+ print((\"\\n\".join(map(str, Z))))"
] | false | 0.041981 | 0.04391 | 0.956065 |
[
"s383174421",
"s095792760"
] |
u562935282
|
p03338
|
python
|
s257665570
|
s887858617
| 36 | 18 | 3,768 | 2,940 |
Accepted
|
Accepted
| 50 |
import string
def f(s, t):
ret = 0
for c in string.ascii_lowercase:
found_s = False
found_t = False
for i in range(len(s)):
if s[i] == c:
found_s = True
break
for i in range(len(t)):
if t[i] == c:
found_t = True
break
if found_s and found_t:
ret += 1
return ret
if __name__ == '__main__':
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(n + 1):
#i文字目が壁になる
#0文字目の手前まで:空文字列
#n+1文字目の手前まで:全文字列
tmp = f(s[:i], s[i:])
ans = max(ans, tmp)
print(ans)
|
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(n):
ans = max(ans, len(set(s[:i]) & set(s[i:])))
print(ans)
| 31 | 7 | 696 | 122 |
import string
def f(s, t):
ret = 0
for c in string.ascii_lowercase:
found_s = False
found_t = False
for i in range(len(s)):
if s[i] == c:
found_s = True
break
for i in range(len(t)):
if t[i] == c:
found_t = True
break
if found_s and found_t:
ret += 1
return ret
if __name__ == "__main__":
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(n + 1):
# i文字目が壁になる
# 0文字目の手前まで:空文字列
# n+1文字目の手前まで:全文字列
tmp = f(s[:i], s[i:])
ans = max(ans, tmp)
print(ans)
|
n = int(eval(input()))
s = eval(input())
ans = 0
for i in range(n):
ans = max(ans, len(set(s[:i]) & set(s[i:])))
print(ans)
| false | 77.419355 |
[
"-import string",
"-",
"-",
"-def f(s, t):",
"- ret = 0",
"- for c in string.ascii_lowercase:",
"- found_s = False",
"- found_t = False",
"- for i in range(len(s)):",
"- if s[i] == c:",
"- found_s = True",
"- break",
"- for i in range(len(t)):",
"- if t[i] == c:",
"- found_t = True",
"- break",
"- if found_s and found_t:",
"- ret += 1",
"- return ret",
"-",
"-",
"-if __name__ == \"__main__\":",
"- n = int(eval(input()))",
"- s = eval(input())",
"- ans = 0",
"- for i in range(n + 1):",
"- # i文字目が壁になる",
"- # 0文字目の手前まで:空文字列",
"- # n+1文字目の手前まで:全文字列",
"- tmp = f(s[:i], s[i:])",
"- ans = max(ans, tmp)",
"- print(ans)",
"+n = int(eval(input()))",
"+s = eval(input())",
"+ans = 0",
"+for i in range(n):",
"+ ans = max(ans, len(set(s[:i]) & set(s[i:])))",
"+print(ans)"
] | false | 0.047865 | 0.035894 | 1.333514 |
[
"s257665570",
"s887858617"
] |
u423585790
|
p03626
|
python
|
s830382151
|
s515542477
| 206 | 182 | 40,688 | 38,384 |
Accepted
|
Accepted
| 11.65 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI(): return list(map(int, stdin.readline().split()))
def LF(): return list(map(float, stdin.readline().split()))
def LI_(): return list([int(x)-1 for x in stdin.readline().split()])
def II(): return int(stdin.readline())
def IF(): return float(stdin.readline())
def LS(): return list(map(list, stdin.readline().split()))
def S(): return list(stdin.readline().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
alp = [chr(ord('a') + i) for i in range(26)]
#A
def A():
x, a, b = LI()
if abs(x - a) > abs(x - b):
print("B")
else:
print("A")
return
#B
def B():
s = S()
s = set(s)
for i in s:
alp.remove(i)
if len(alp) == 0:
print("None")
else:
print((alp[0]))
return
#C
def C():
n = II()
a = LI()
i = 1
a.sort(reverse=True)
ans = []
while i < n:
if a[i] == a[i - 1]:
ans.append(a[i])
if len(ans) == 2:
print((ans[0] * ans[1]))
return
i += 2
else:
i += 1
print((0))
#D
def D():
n = II()
s1 = S()
s2 = S()
i = 0
f = 0
if s1[i] == s2[i]:
ans = 3
i += 1
f = 1
else:
ans = 6
i += 2
while i < n:
if s1[i] == s2[i]:
ans *= 2 if f else 1
ans %= mod
i += 1
f = 1
continue
i += 2
ans *= 2 if f else 3
f = 0
ans %= mod
print((ans%mod))
return
#Solve
if __name__ == '__main__':
D()
|
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list([int(x)-1 for x in input().split()])
def II(): return int(eval(input()))
def IF(): return float(eval(input()))
def LS(): return list(map(list, input().split()))
def S(): return list(input().rstrip())
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10
#solve
def solve():
n = II()
s1 = S()
s2 = S()
i = 0
f = 0
if s1[i] == s2[i]:
ans = 3
i += 1
f = 1
else:
ans = 6
i += 2
while i < n:
if s1[i] == s2[i]:
ans *= 2 if f else 1
ans %= mod
i += 1
f = 1
continue
i += 2
ans *= 2 if f else 3
f = 0
ans %= mod
print(ans)
return
#main
if __name__ == '__main__':
solve()
| 98 | 57 | 2,179 | 1,458 |
#!usr/bin/env python3
from collections import defaultdict
from collections import deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
import itertools
sys.setrecursionlimit(10**5)
stdin = sys.stdin
def LI():
return list(map(int, stdin.readline().split()))
def LF():
return list(map(float, stdin.readline().split()))
def LI_():
return list([int(x) - 1 for x in stdin.readline().split()])
def II():
return int(stdin.readline())
def IF():
return float(stdin.readline())
def LS():
return list(map(list, stdin.readline().split()))
def S():
return list(stdin.readline().rstrip())
def IR(n):
return [II() for _ in range(n)]
def LIR(n):
return [LI() for _ in range(n)]
def FR(n):
return [IF() for _ in range(n)]
def LFR(n):
return [LI() for _ in range(n)]
def LIR_(n):
return [LI_() for _ in range(n)]
def SR(n):
return [S() for _ in range(n)]
def LSR(n):
return [LS() for _ in range(n)]
mod = 1000000007
alp = [chr(ord("a") + i) for i in range(26)]
# A
def A():
x, a, b = LI()
if abs(x - a) > abs(x - b):
print("B")
else:
print("A")
return
# B
def B():
s = S()
s = set(s)
for i in s:
alp.remove(i)
if len(alp) == 0:
print("None")
else:
print((alp[0]))
return
# C
def C():
n = II()
a = LI()
i = 1
a.sort(reverse=True)
ans = []
while i < n:
if a[i] == a[i - 1]:
ans.append(a[i])
if len(ans) == 2:
print((ans[0] * ans[1]))
return
i += 2
else:
i += 1
print((0))
# D
def D():
n = II()
s1 = S()
s2 = S()
i = 0
f = 0
if s1[i] == s2[i]:
ans = 3
i += 1
f = 1
else:
ans = 6
i += 2
while i < n:
if s1[i] == s2[i]:
ans *= 2 if f else 1
ans %= mod
i += 1
f = 1
continue
i += 2
ans *= 2 if f else 3
f = 0
ans %= mod
print((ans % mod))
return
# Solve
if __name__ == "__main__":
D()
|
#!/usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI():
return list(map(int, input().split()))
def LF():
return list(map(float, input().split()))
def LI_():
return list([int(x) - 1 for x in input().split()])
def II():
return int(eval(input()))
def IF():
return float(eval(input()))
def LS():
return list(map(list, input().split()))
def S():
return list(input().rstrip())
def IR(n):
return [II() for _ in range(n)]
def LIR(n):
return [LI() for _ in range(n)]
def FR(n):
return [IF() for _ in range(n)]
def LFR(n):
return [LI() for _ in range(n)]
def LIR_(n):
return [LI_() for _ in range(n)]
def SR(n):
return [S() for _ in range(n)]
def LSR(n):
return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10
# solve
def solve():
n = II()
s1 = S()
s2 = S()
i = 0
f = 0
if s1[i] == s2[i]:
ans = 3
i += 1
f = 1
else:
ans = 6
i += 2
while i < n:
if s1[i] == s2[i]:
ans *= 2 if f else 1
ans %= mod
i += 1
f = 1
continue
i += 2
ans *= 2 if f else 3
f = 0
ans %= mod
print(ans)
return
# main
if __name__ == "__main__":
solve()
| false | 41.836735 |
[
"-#!usr/bin/env python3",
"-from collections import defaultdict",
"-from collections import deque",
"+#!/usr/bin/env python3",
"+from collections import defaultdict, deque",
"-import sys",
"-import math",
"-import bisect",
"-import random",
"-import itertools",
"+from bisect import bisect_left, bisect_right",
"+import sys, random, itertools, math",
"-stdin = sys.stdin",
"+input = sys.stdin.readline",
"+sqrt = math.sqrt",
"- return list(map(int, stdin.readline().split()))",
"+ return list(map(int, input().split()))",
"- return list(map(float, stdin.readline().split()))",
"+ return list(map(float, input().split()))",
"- return list([int(x) - 1 for x in stdin.readline().split()])",
"+ return list([int(x) - 1 for x in input().split()])",
"- return int(stdin.readline())",
"+ return int(eval(input()))",
"- return float(stdin.readline())",
"+ return float(eval(input()))",
"- return list(map(list, stdin.readline().split()))",
"+ return list(map(list, input().split()))",
"- return list(stdin.readline().rstrip())",
"+ return list(input().rstrip())",
"-alp = [chr(ord(\"a\") + i) for i in range(26)]",
"-# A",
"-def A():",
"- x, a, b = LI()",
"- if abs(x - a) > abs(x - b):",
"- print(\"B\")",
"- else:",
"- print(\"A\")",
"- return",
"-",
"-",
"-# B",
"-def B():",
"- s = S()",
"- s = set(s)",
"- for i in s:",
"- alp.remove(i)",
"- if len(alp) == 0:",
"- print(\"None\")",
"- else:",
"- print((alp[0]))",
"- return",
"-",
"-",
"-# C",
"-def C():",
"- n = II()",
"- a = LI()",
"- i = 1",
"- a.sort(reverse=True)",
"- ans = []",
"- while i < n:",
"- if a[i] == a[i - 1]:",
"- ans.append(a[i])",
"- if len(ans) == 2:",
"- print((ans[0] * ans[1]))",
"- return",
"- i += 2",
"- else:",
"- i += 1",
"- print((0))",
"-",
"-",
"-# D",
"-def D():",
"+inf = 1e10",
"+# solve",
"+def solve():",
"- print((ans % mod))",
"+ print(ans)",
"-# Solve",
"+# main",
"- D()",
"+ solve()"
] | false | 0.037082 | 0.03832 | 0.967683 |
[
"s830382151",
"s515542477"
] |
u977389981
|
p03135
|
python
|
s572493143
|
s186765325
| 20 | 17 | 3,316 | 2,940 |
Accepted
|
Accepted
| 15 |
t, x = list(map(int, input().split()))
print((t / x))
|
T, X = list(map(int, input().split()))
print((T / X))
| 2 | 2 | 46 | 46 |
t, x = list(map(int, input().split()))
print((t / x))
|
T, X = list(map(int, input().split()))
print((T / X))
| false | 0 |
[
"-t, x = list(map(int, input().split()))",
"-print((t / x))",
"+T, X = list(map(int, input().split()))",
"+print((T / X))"
] | false | 0.051691 | 0.07131 | 0.724876 |
[
"s572493143",
"s186765325"
] |
u819048695
|
p03078
|
python
|
s306575515
|
s173465716
| 1,656 | 1,322 | 194,080 | 104,296 |
Accepted
|
Accepted
| 20.17 |
#D
from heapq import heappush,heappop
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
d=[]
for i in range(x):
for j in range(y):
heappush(d,-a[i]-b[j])
e=[]
for i in range(min(3000,x*y)):
e.append(-heappop(d))
f=[]
for i in range(len(e)):
for j in range(z):
heappush(f,-e[i]-c[j])
for i in range(k):
print((-heappop(f)))
|
#D
from heapq import heappush,heappop,heapify
x,y,z,k=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
c=list(map(int,input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d=[]
for i in range(x):
for j in range(y):
if i*j>k:
break
for l in range(z):
if i*j*l>k:
break
heappush(d,-a[i]-b[j]-c[l])
for i in range(k):
print((-heappop(d)))
| 19 | 20 | 452 | 497 |
# D
from heapq import heappush, heappop
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
d = []
for i in range(x):
for j in range(y):
heappush(d, -a[i] - b[j])
e = []
for i in range(min(3000, x * y)):
e.append(-heappop(d))
f = []
for i in range(len(e)):
for j in range(z):
heappush(f, -e[i] - c[j])
for i in range(k):
print((-heappop(f)))
|
# D
from heapq import heappush, heappop, heapify
x, y, z, k = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
c = list(map(int, input().split()))
a.sort(reverse=True)
b.sort(reverse=True)
c.sort(reverse=True)
d = []
for i in range(x):
for j in range(y):
if i * j > k:
break
for l in range(z):
if i * j * l > k:
break
heappush(d, -a[i] - b[j] - c[l])
for i in range(k):
print((-heappop(d)))
| false | 5 |
[
"-from heapq import heappush, heappop",
"+from heapq import heappush, heappop, heapify",
"+a.sort(reverse=True)",
"+b.sort(reverse=True)",
"+c.sort(reverse=True)",
"- heappush(d, -a[i] - b[j])",
"-e = []",
"-for i in range(min(3000, x * y)):",
"- e.append(-heappop(d))",
"-f = []",
"-for i in range(len(e)):",
"- for j in range(z):",
"- heappush(f, -e[i] - c[j])",
"+ if i * j > k:",
"+ break",
"+ for l in range(z):",
"+ if i * j * l > k:",
"+ break",
"+ heappush(d, -a[i] - b[j] - c[l])",
"- print((-heappop(f)))",
"+ print((-heappop(d)))"
] | false | 0.039387 | 0.046541 | 0.846291 |
[
"s306575515",
"s173465716"
] |
u518042385
|
p02947
|
python
|
s479911701
|
s387386267
| 573 | 463 | 25,420 | 18,184 |
Accepted
|
Accepted
| 19.2 |
n=int(eval(input()))
l=[]
for i in range(n):
w=sorted(list(eval(input())))
l.append(w)
l=sorted(l)
c=0
c1=0
w1=l[0]
for i in range(n):
if w1==l[i]:
c1+=1
else:
w1=l[i]
c+=c1*(c1-1)//2
c1=1
c+=c1*(c1-1)//2
print(c)
|
from collections import defaultdict
n=int(eval(input()))
l=defaultdict(int)
for i in range(n):
l1=sorted(list(eval(input())))
w1="".join(l1)
l[w1]+=1
count=0
for i in l:
if l[i]!=1:
count+=l[i]*(l[i]-1)//2
print(count)
| 19 | 12 | 248 | 229 |
n = int(eval(input()))
l = []
for i in range(n):
w = sorted(list(eval(input())))
l.append(w)
l = sorted(l)
c = 0
c1 = 0
w1 = l[0]
for i in range(n):
if w1 == l[i]:
c1 += 1
else:
w1 = l[i]
c += c1 * (c1 - 1) // 2
c1 = 1
c += c1 * (c1 - 1) // 2
print(c)
|
from collections import defaultdict
n = int(eval(input()))
l = defaultdict(int)
for i in range(n):
l1 = sorted(list(eval(input())))
w1 = "".join(l1)
l[w1] += 1
count = 0
for i in l:
if l[i] != 1:
count += l[i] * (l[i] - 1) // 2
print(count)
| false | 36.842105 |
[
"+from collections import defaultdict",
"+",
"-l = []",
"+l = defaultdict(int)",
"- w = sorted(list(eval(input())))",
"- l.append(w)",
"-l = sorted(l)",
"-c = 0",
"-c1 = 0",
"-w1 = l[0]",
"-for i in range(n):",
"- if w1 == l[i]:",
"- c1 += 1",
"- else:",
"- w1 = l[i]",
"- c += c1 * (c1 - 1) // 2",
"- c1 = 1",
"-c += c1 * (c1 - 1) // 2",
"-print(c)",
"+ l1 = sorted(list(eval(input())))",
"+ w1 = \"\".join(l1)",
"+ l[w1] += 1",
"+count = 0",
"+for i in l:",
"+ if l[i] != 1:",
"+ count += l[i] * (l[i] - 1) // 2",
"+print(count)"
] | false | 0.097621 | 0.097697 | 0.99922 |
[
"s479911701",
"s387386267"
] |
u634046173
|
p03574
|
python
|
s462028878
|
s255096068
| 43 | 36 | 9,236 | 9,220 |
Accepted
|
Accepted
| 16.28 |
def bakudanda (S,y,x):
if y < 0 or y >= len(S):
return 0
if x < 0 or x >= len(S[y]):
return 0
if S[y][x] == '#':
return 1
else:
return 0
H,W = list(map(int,input().split()))
s=[]
for i in range(H):
s.append(eval(input()))
for i in range(len(s)):
a = s[i]
fp = ''
for j in range(len(a)):
if a[j] == '.':
c = 0
ds = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0,1), (1, -1), (1, 0), (1, 1)]
for (y, x) in ds:
c+= bakudanda(s,i+y,j+x)
fp += str(c)
else:
fp += '#'
print(fp)
|
def bakudanda (y,x):
if y < 0 or y >= len(s):
return 0
if x < 0 or x >= len(s[y]):
return 0
if s[y][x] == '#':
return 1
else:
return 0
H,W = list(map(int,input().split()))
s=[]
for i in range(H):
s.append(eval(input()))
for i in range(len(s)):
a = s[i]
fp = ''
for j in range(len(a)):
if a[j] == '.':
c = 0
ds = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0,1), (1, -1), (1, 0), (1, 1)]
for (y, x) in ds:
c+= bakudanda(i+y,j+x)
fp += str(c)
else:
fp += '#'
print(fp)
| 28 | 28 | 572 | 569 |
def bakudanda(S, y, x):
if y < 0 or y >= len(S):
return 0
if x < 0 or x >= len(S[y]):
return 0
if S[y][x] == "#":
return 1
else:
return 0
H, W = list(map(int, input().split()))
s = []
for i in range(H):
s.append(eval(input()))
for i in range(len(s)):
a = s[i]
fp = ""
for j in range(len(a)):
if a[j] == ".":
c = 0
ds = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
for (y, x) in ds:
c += bakudanda(s, i + y, j + x)
fp += str(c)
else:
fp += "#"
print(fp)
|
def bakudanda(y, x):
if y < 0 or y >= len(s):
return 0
if x < 0 or x >= len(s[y]):
return 0
if s[y][x] == "#":
return 1
else:
return 0
H, W = list(map(int, input().split()))
s = []
for i in range(H):
s.append(eval(input()))
for i in range(len(s)):
a = s[i]
fp = ""
for j in range(len(a)):
if a[j] == ".":
c = 0
ds = [(-1, -1), (-1, 0), (-1, 1), (0, -1), (0, 1), (1, -1), (1, 0), (1, 1)]
for (y, x) in ds:
c += bakudanda(i + y, j + x)
fp += str(c)
else:
fp += "#"
print(fp)
| false | 0 |
[
"-def bakudanda(S, y, x):",
"- if y < 0 or y >= len(S):",
"+def bakudanda(y, x):",
"+ if y < 0 or y >= len(s):",
"- if x < 0 or x >= len(S[y]):",
"+ if x < 0 or x >= len(s[y]):",
"- if S[y][x] == \"#\":",
"+ if s[y][x] == \"#\":",
"- c += bakudanda(s, i + y, j + x)",
"+ c += bakudanda(i + y, j + x)"
] | false | 0.037493 | 0.036426 | 1.029296 |
[
"s462028878",
"s255096068"
] |
u160414758
|
p03599
|
python
|
s328023764
|
s599024818
| 313 | 21 | 3,064 | 3,064 |
Accepted
|
Accepted
| 93.29 |
A,B,C,D,E,F = list(map(int,input().split()))
A,B = 100*A,100*B
def ql():
ans = (0,A)
for a in range(0,F,A):
for b in range(0,F,B):
for c in range(0,F,C):
for d in range(0,F,D):
wat,sug = (a + b),(c + d)
if wat+sug > F or 100*sug > E*wat:
break
elif sug*ans[1] > ans[0]*wat:
ans = (sug,wat)
return ans
ans = ql()
print(("{} {}".format(sum(ans),ans[0])))
|
A,B,C,D,E,F = list(map(int,input().split()))
def FS():
ans = (100*A,0)
for a in range(0,F,100*A):
for b in range(0,F,100*B):
for c in range(0,F,C):
for d in range(0,F,D):
wat,sug = (a + b),(c + d)
if wat == 0 or wat+sug > F or 100*sug > E*wat:
break
elif 100*sug == E*wat:
return (wat,sug)
elif sug*ans[0] > ans[1]*wat:
ans = (wat,sug)
return ans
ans = FS()
print((sum(ans),ans[1]))
| 16 | 17 | 517 | 592 |
A, B, C, D, E, F = list(map(int, input().split()))
A, B = 100 * A, 100 * B
def ql():
ans = (0, A)
for a in range(0, F, A):
for b in range(0, F, B):
for c in range(0, F, C):
for d in range(0, F, D):
wat, sug = (a + b), (c + d)
if wat + sug > F or 100 * sug > E * wat:
break
elif sug * ans[1] > ans[0] * wat:
ans = (sug, wat)
return ans
ans = ql()
print(("{} {}".format(sum(ans), ans[0])))
|
A, B, C, D, E, F = list(map(int, input().split()))
def FS():
ans = (100 * A, 0)
for a in range(0, F, 100 * A):
for b in range(0, F, 100 * B):
for c in range(0, F, C):
for d in range(0, F, D):
wat, sug = (a + b), (c + d)
if wat == 0 or wat + sug > F or 100 * sug > E * wat:
break
elif 100 * sug == E * wat:
return (wat, sug)
elif sug * ans[0] > ans[1] * wat:
ans = (wat, sug)
return ans
ans = FS()
print((sum(ans), ans[1]))
| false | 5.882353 |
[
"-A, B = 100 * A, 100 * B",
"-def ql():",
"- ans = (0, A)",
"- for a in range(0, F, A):",
"- for b in range(0, F, B):",
"+def FS():",
"+ ans = (100 * A, 0)",
"+ for a in range(0, F, 100 * A):",
"+ for b in range(0, F, 100 * B):",
"- if wat + sug > F or 100 * sug > E * wat:",
"+ if wat == 0 or wat + sug > F or 100 * sug > E * wat:",
"- elif sug * ans[1] > ans[0] * wat:",
"- ans = (sug, wat)",
"+ elif 100 * sug == E * wat:",
"+ return (wat, sug)",
"+ elif sug * ans[0] > ans[1] * wat:",
"+ ans = (wat, sug)",
"-ans = ql()",
"-print((\"{} {}\".format(sum(ans), ans[0])))",
"+ans = FS()",
"+print((sum(ans), ans[1]))"
] | false | 0.117521 | 0.045367 | 2.590454 |
[
"s328023764",
"s599024818"
] |
u367965715
|
p02838
|
python
|
s655996483
|
s367917228
| 976 | 337 | 122,936 | 49,804 |
Accepted
|
Accepted
| 65.47 |
from itertools import count
n = int(eval(input()))
a = list(map(int, input().split()))
d_cumsum = [0] * 60
for v in a:
for i in count():
d_cumsum[i] += v % 2
v //= 2
if v == 0:
break
res = 0
mod = 10**9 + 7
for i, d in enumerate(d_cumsum):
res += (2**i * d * (n-d)) % mod
res %= mod
print(res)
|
import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
res = 0
mod = 10**9 + 7
for i in range(61):
cnt = np.count_nonzero(a >> i & 1)
res += cnt * (n-cnt) << i
res %= mod
print(res)
| 20 | 13 | 359 | 236 |
from itertools import count
n = int(eval(input()))
a = list(map(int, input().split()))
d_cumsum = [0] * 60
for v in a:
for i in count():
d_cumsum[i] += v % 2
v //= 2
if v == 0:
break
res = 0
mod = 10**9 + 7
for i, d in enumerate(d_cumsum):
res += (2**i * d * (n - d)) % mod
res %= mod
print(res)
|
import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
res = 0
mod = 10**9 + 7
for i in range(61):
cnt = np.count_nonzero(a >> i & 1)
res += cnt * (n - cnt) << i
res %= mod
print(res)
| false | 35 |
[
"-from itertools import count",
"+import numpy as np",
"-a = list(map(int, input().split()))",
"-d_cumsum = [0] * 60",
"-for v in a:",
"- for i in count():",
"- d_cumsum[i] += v % 2",
"- v //= 2",
"- if v == 0:",
"- break",
"+a = np.array(list(map(int, input().split())))",
"-for i, d in enumerate(d_cumsum):",
"- res += (2**i * d * (n - d)) % mod",
"+for i in range(61):",
"+ cnt = np.count_nonzero(a >> i & 1)",
"+ res += cnt * (n - cnt) << i"
] | false | 0.082295 | 0.573294 | 0.143548 |
[
"s655996483",
"s367917228"
] |
u186838327
|
p03026
|
python
|
s326957575
|
s458100666
| 320 | 239 | 50,264 | 45,808 |
Accepted
|
Accepted
| 25.31 |
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
C = list(map(int, input().split()))
C.sort(reverse=True)
order = []
par = [-1]*n
s = []
visit = [-1]*n
s.append(0)
visit[0] = 0
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if u == par[v]:
continue
par[u] = v
s.append(u)
order.reverse()
ans = [0]*n
m = 0
for v in order:
ans[v] = C.pop()
if par[v] != -1:
m += ans[v]
print(m)
print((*ans))
|
import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n-1):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
g[a].append(b)
g[b].append(a)
C = list(map(int, input().split()))
C.sort()
s = []
parent = [-1]*n
order = []
s.append(0)
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if parent[v] == u:
continue
parent[u] = v
s.append(u)
order.reverse()
ans = 0
D = [0]*n
for i in range(n):
v = order[i]
D[v] = C[i]
if i != n-1:
ans += C[i]
print(ans)
print((*D))
| 35 | 36 | 605 | 632 |
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
g[a].append(b)
g[b].append(a)
C = list(map(int, input().split()))
C.sort(reverse=True)
order = []
par = [-1] * n
s = []
visit = [-1] * n
s.append(0)
visit[0] = 0
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if u == par[v]:
continue
par[u] = v
s.append(u)
order.reverse()
ans = [0] * n
m = 0
for v in order:
ans[v] = C.pop()
if par[v] != -1:
m += ans[v]
print(m)
print((*ans))
|
import sys
input = sys.stdin.buffer.readline
n = int(eval(input()))
g = [[] for _ in range(n)]
for i in range(n - 1):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
g[a].append(b)
g[b].append(a)
C = list(map(int, input().split()))
C.sort()
s = []
parent = [-1] * n
order = []
s.append(0)
while s:
v = s.pop()
order.append(v)
for u in g[v]:
if parent[v] == u:
continue
parent[u] = v
s.append(u)
order.reverse()
ans = 0
D = [0] * n
for i in range(n):
v = order[i]
D[v] = C[i]
if i != n - 1:
ans += C[i]
print(ans)
print((*D))
| false | 2.777778 |
[
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"-C.sort(reverse=True)",
"+C.sort()",
"+s = []",
"+parent = [-1] * n",
"-par = [-1] * n",
"-s = []",
"-visit = [-1] * n",
"-visit[0] = 0",
"- if u == par[v]:",
"+ if parent[v] == u:",
"- par[u] = v",
"+ parent[u] = v",
"-ans = [0] * n",
"-m = 0",
"-for v in order:",
"- ans[v] = C.pop()",
"- if par[v] != -1:",
"- m += ans[v]",
"-print(m)",
"-print((*ans))",
"+ans = 0",
"+D = [0] * n",
"+for i in range(n):",
"+ v = order[i]",
"+ D[v] = C[i]",
"+ if i != n - 1:",
"+ ans += C[i]",
"+print(ans)",
"+print((*D))"
] | false | 0.046705 | 0.046087 | 1.013422 |
[
"s326957575",
"s458100666"
] |
u621935300
|
p03212
|
python
|
s667411094
|
s888541729
| 100 | 74 | 36,252 | 36,380 |
Accepted
|
Accepted
| 26 |
import itertools
from collections import defaultdict
N=input()
k=len(N)
if int(N)<357:
print(0)
quit()
ans=0
for k in range(3,k+1):
L=list(itertools.product( (3,5,7) , repeat=k))
for t in L:
C=defaultdict(lambda: 0)
v=0
for idx, x in enumerate(t):
v+=x*(10**idx)
if x!=0:
C[x]+=1
if v<=int(N) and len(C)==3:
ans+=1
print(ans)
|
N=eval(input())
l=len( str(N) )
s="357"
P=[ set() for i in range(l+1) ] #Pattern
P[0].add(0)
for i in range(1,l+1):
k=l-i #keta
for x in P[i-1]:
for j in s:
j=int(j)
P[i].add( x+(10**k)*j )
P[i].add( 0 )
ans=0
for x in P[-1]:
if 1<= x <= N:
for i in s:
if i not in str(x):
break
else:
ans+=1
print(ans)
| 29 | 29 | 392 | 364 |
import itertools
from collections import defaultdict
N = input()
k = len(N)
if int(N) < 357:
print(0)
quit()
ans = 0
for k in range(3, k + 1):
L = list(itertools.product((3, 5, 7), repeat=k))
for t in L:
C = defaultdict(lambda: 0)
v = 0
for idx, x in enumerate(t):
v += x * (10**idx)
if x != 0:
C[x] += 1
if v <= int(N) and len(C) == 3:
ans += 1
print(ans)
|
N = eval(input())
l = len(str(N))
s = "357"
P = [set() for i in range(l + 1)] # Pattern
P[0].add(0)
for i in range(1, l + 1):
k = l - i # keta
for x in P[i - 1]:
for j in s:
j = int(j)
P[i].add(x + (10**k) * j)
P[i].add(0)
ans = 0
for x in P[-1]:
if 1 <= x <= N:
for i in s:
if i not in str(x):
break
else:
ans += 1
print(ans)
| false | 0 |
[
"-import itertools",
"-from collections import defaultdict",
"-",
"-N = input()",
"-k = len(N)",
"-if int(N) < 357:",
"- print(0)",
"- quit()",
"+N = eval(input())",
"+l = len(str(N))",
"+s = \"357\"",
"+P = [set() for i in range(l + 1)] # Pattern",
"+P[0].add(0)",
"+for i in range(1, l + 1):",
"+ k = l - i # keta",
"+ for x in P[i - 1]:",
"+ for j in s:",
"+ j = int(j)",
"+ P[i].add(x + (10**k) * j)",
"+ P[i].add(0)",
"-for k in range(3, k + 1):",
"- L = list(itertools.product((3, 5, 7), repeat=k))",
"- for t in L:",
"- C = defaultdict(lambda: 0)",
"- v = 0",
"- for idx, x in enumerate(t):",
"- v += x * (10**idx)",
"- if x != 0:",
"- C[x] += 1",
"- if v <= int(N) and len(C) == 3:",
"+for x in P[-1]:",
"+ if 1 <= x <= N:",
"+ for i in s:",
"+ if i not in str(x):",
"+ break",
"+ else:"
] | false | 0.207268 | 0.05675 | 3.652276 |
[
"s667411094",
"s888541729"
] |
u692453235
|
p03265
|
python
|
s941336151
|
s191365009
| 32 | 29 | 9,132 | 9,060 |
Accepted
|
Accepted
| 9.38 |
x1, y1, x2, y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
ans = [x2 - Y, y2 + X, x1 - Y, y1 + X]
print((" ".join([str(i) for i in ans])))
|
x1, y1, x2, y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
ans = [x2 - Y, y2 + X, x1 - Y, y1 + X]
print((*ans))
| 8 | 8 | 154 | 127 |
x1, y1, x2, y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
ans = [x2 - Y, y2 + X, x1 - Y, y1 + X]
print((" ".join([str(i) for i in ans])))
|
x1, y1, x2, y2 = list(map(int, input().split()))
X = x2 - x1
Y = y2 - y1
ans = [x2 - Y, y2 + X, x1 - Y, y1 + X]
print((*ans))
| false | 0 |
[
"-print((\" \".join([str(i) for i in ans])))",
"+print((*ans))"
] | false | 0.101789 | 0.043896 | 2.318894 |
[
"s941336151",
"s191365009"
] |
u919633157
|
p03556
|
python
|
s058652361
|
s002825411
| 39 | 17 | 2,940 | 3,060 |
Accepted
|
Accepted
| 56.41 |
n=int(eval(input()))
i=1
while i**2<=n:
ans=i**2
i+=1
print(ans)
|
print((int(int(eval(input()))**.5)**2))
#
| 6 | 2 | 71 | 34 |
n = int(eval(input()))
i = 1
while i**2 <= n:
ans = i**2
i += 1
print(ans)
|
print((int(int(eval(input())) ** 0.5) ** 2))
#
| false | 66.666667 |
[
"-n = int(eval(input()))",
"-i = 1",
"-while i**2 <= n:",
"- ans = i**2",
"- i += 1",
"-print(ans)",
"+print((int(int(eval(input())) ** 0.5) ** 2))",
"+#"
] | false | 0.04049 | 0.035629 | 1.136429 |
[
"s058652361",
"s002825411"
] |
u950825280
|
p02725
|
python
|
s352679167
|
s516366310
| 156 | 141 | 26,100 | 25,840 |
Accepted
|
Accepted
| 9.62 |
k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = k
b = a[0] + (k-a[-1])
prev = a[0]
for i, v in enumerate(a):
if i == 0:
ans = min(ans, k-b)
ans = min(ans, k-(v-prev))
prev = v
print(ans)
|
k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = k
b = a[0] + (k-a[-1])
prev = a[0]
for v in a[1:]:
ans = min(ans, k-(v-prev))
prev = v
ans = min(ans, k-b)
print(ans)
| 14 | 13 | 253 | 219 |
k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = k
b = a[0] + (k - a[-1])
prev = a[0]
for i, v in enumerate(a):
if i == 0:
ans = min(ans, k - b)
ans = min(ans, k - (v - prev))
prev = v
print(ans)
|
k, n = list(map(int, input().split()))
a = list(map(int, input().split()))
ans = k
b = a[0] + (k - a[-1])
prev = a[0]
for v in a[1:]:
ans = min(ans, k - (v - prev))
prev = v
ans = min(ans, k - b)
print(ans)
| false | 7.142857 |
[
"-for i, v in enumerate(a):",
"- if i == 0:",
"- ans = min(ans, k - b)",
"+for v in a[1:]:",
"+ans = min(ans, k - b)"
] | false | 0.113191 | 0.125349 | 0.903005 |
[
"s352679167",
"s516366310"
] |
u813098295
|
p03287
|
python
|
s604346296
|
s201775740
| 136 | 114 | 14,224 | 14,224 |
Accepted
|
Accepted
| 16.18 |
N, M = list(map(int, input().split()))
A = [ int(x) for x in input().split() ]
B = [0]
sum_v = 0
for a in A:
sum_v += a
sum_v %= M
B += [ sum_v ]
B.sort()
B += [ "@" ]
cur = B[0]
cnt, ans = 1, 0
for i, b in enumerate(B):
if B[i+1] == "@":
ans += cnt*(cnt-1)//2
break
if cur == B[i+1]:
cnt += 1
else:
cur = B[i+1]
ans += cnt*(cnt-1)//2
cnt = 1
print(ans)
|
N, M = list(map(int, input().split()))
A = [ int(x) for x in input().split() ]
d = {0:1}
ans, s = 0, 0
for a in A:
s += a
s %= M
ans += d.get(s, 0)
d[s] = d.get(s, 0) + 1
print(ans)
| 30 | 13 | 456 | 209 |
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
B = [0]
sum_v = 0
for a in A:
sum_v += a
sum_v %= M
B += [sum_v]
B.sort()
B += ["@"]
cur = B[0]
cnt, ans = 1, 0
for i, b in enumerate(B):
if B[i + 1] == "@":
ans += cnt * (cnt - 1) // 2
break
if cur == B[i + 1]:
cnt += 1
else:
cur = B[i + 1]
ans += cnt * (cnt - 1) // 2
cnt = 1
print(ans)
|
N, M = list(map(int, input().split()))
A = [int(x) for x in input().split()]
d = {0: 1}
ans, s = 0, 0
for a in A:
s += a
s %= M
ans += d.get(s, 0)
d[s] = d.get(s, 0) + 1
print(ans)
| false | 56.666667 |
[
"-B = [0]",
"-sum_v = 0",
"+d = {0: 1}",
"+ans, s = 0, 0",
"- sum_v += a",
"- sum_v %= M",
"- B += [sum_v]",
"-B.sort()",
"-B += [\"@\"]",
"-cur = B[0]",
"-cnt, ans = 1, 0",
"-for i, b in enumerate(B):",
"- if B[i + 1] == \"@\":",
"- ans += cnt * (cnt - 1) // 2",
"- break",
"- if cur == B[i + 1]:",
"- cnt += 1",
"- else:",
"- cur = B[i + 1]",
"- ans += cnt * (cnt - 1) // 2",
"- cnt = 1",
"+ s += a",
"+ s %= M",
"+ ans += d.get(s, 0)",
"+ d[s] = d.get(s, 0) + 1"
] | false | 0.041098 | 0.033987 | 1.209253 |
[
"s604346296",
"s201775740"
] |
u835534360
|
p02682
|
python
|
s545096987
|
s857402587
| 24 | 22 | 9,184 | 9,160 |
Accepted
|
Accepted
| 8.33 |
import sys
def main():
a,b,c,k=tuple(map(int,sys.stdin.readline().split()))
if k<=a:
print(k)
else:
if k<=a+b:
print(a)
else:
print((2*a+b-k))
if __name__=='__main__':main()
|
import sys
def main():
a,b,c,k=tuple(map(int,sys.stdin.readline().split()))
print(k) if k<=a else print(a) if k<=a+b else print(2*a+b-k)
if __name__=='__main__':main()
| 11 | 5 | 241 | 179 |
import sys
def main():
a, b, c, k = tuple(map(int, sys.stdin.readline().split()))
if k <= a:
print(k)
else:
if k <= a + b:
print(a)
else:
print((2 * a + b - k))
if __name__ == "__main__":
main()
|
import sys
def main():
a, b, c, k = tuple(map(int, sys.stdin.readline().split()))
print(k) if k <= a else print(a) if k <= a + b else print(2 * a + b - k)
if __name__ == "__main__":
main()
| false | 54.545455 |
[
"- if k <= a:",
"- print(k)",
"- else:",
"- if k <= a + b:",
"- print(a)",
"- else:",
"- print((2 * a + b - k))",
"+ print(k) if k <= a else print(a) if k <= a + b else print(2 * a + b - k)"
] | false | 0.049201 | 0.037508 | 1.311755 |
[
"s545096987",
"s857402587"
] |
u707498674
|
p02744
|
python
|
s443461101
|
s559841693
| 178 | 161 | 12,684 | 12,684 |
Accepted
|
Accepted
| 9.55 |
import sys
sys.setrecursionlimit(10**8)
alpha = "abcdefghij"
ans = []
N = int(eval(input()))
def get_right(S):
alpha_idx = 0
for i in range(len(S)):
flag = S.find(alpha[i])
if flag > 0:
alpha_idx = i
return alpha_idx + 2
def dfs(S):
if len(S) == N:
ans.append(S)
else:
right = get_right(S)
seq = alpha[:right]
for c in seq:
dfs(S+c)
return
dfs("a")
ans = sorted(ans)
for a in ans:
print(a)
|
import sys
sys.setrecursionlimit(10**8)
alpha = "abcdefghij"
ans = []
N = int(eval(input()))
def get_right(S):
alpha_idx = 0
for i in range(len(S)):
flag = S.find(alpha[i])
if flag > 0:
alpha_idx = i
return alpha_idx + 2
def dfs(S, num):
if len(S) == N:
ans.append(S)
else:
right = num + 2
seq = alpha[:right]
for i, c in enumerate(seq):
dfs(S+c, max(i, num))
dfs("a", 0)
ans = sorted(ans)
for a in ans:
print(a)
| 30 | 28 | 517 | 533 |
import sys
sys.setrecursionlimit(10**8)
alpha = "abcdefghij"
ans = []
N = int(eval(input()))
def get_right(S):
alpha_idx = 0
for i in range(len(S)):
flag = S.find(alpha[i])
if flag > 0:
alpha_idx = i
return alpha_idx + 2
def dfs(S):
if len(S) == N:
ans.append(S)
else:
right = get_right(S)
seq = alpha[:right]
for c in seq:
dfs(S + c)
return
dfs("a")
ans = sorted(ans)
for a in ans:
print(a)
|
import sys
sys.setrecursionlimit(10**8)
alpha = "abcdefghij"
ans = []
N = int(eval(input()))
def get_right(S):
alpha_idx = 0
for i in range(len(S)):
flag = S.find(alpha[i])
if flag > 0:
alpha_idx = i
return alpha_idx + 2
def dfs(S, num):
if len(S) == N:
ans.append(S)
else:
right = num + 2
seq = alpha[:right]
for i, c in enumerate(seq):
dfs(S + c, max(i, num))
dfs("a", 0)
ans = sorted(ans)
for a in ans:
print(a)
| false | 6.666667 |
[
"-def dfs(S):",
"+def dfs(S, num):",
"- right = get_right(S)",
"+ right = num + 2",
"- for c in seq:",
"- dfs(S + c)",
"- return",
"+ for i, c in enumerate(seq):",
"+ dfs(S + c, max(i, num))",
"-dfs(\"a\")",
"+dfs(\"a\", 0)"
] | false | 0.048907 | 0.050132 | 0.975575 |
[
"s443461101",
"s559841693"
] |
u561231954
|
p03634
|
python
|
s448225906
|
s550658948
| 1,623 | 844 | 55,480 | 55,112 |
Accepted
|
Accepted
| 48 |
import heapq
def dijkstra(V, edges, s):
inf=float('inf')
dist=[inf]*V
dist[s]=0
que=[[0,s]]
heapq.heapify(que) #最小値を管理 [dist[i],i]となる要素
while que:
p=heapq.heappop(que) #距離が最小のものを取り出す
dis=p[0]
v=p[1]
if dist[v] <dis:
continue
for edge in edges[v]:
to_v=edge[0]
cost=edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v]=dist[v]+cost
heapq.heappush(que,[dist[to_v], to_v])
return dist
def main():
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(n,edges,k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main()
|
import heapq
def dijkstra(V, edges, s):
inf=float('inf')
dist=[inf]*V
dist[s]=0
que=[[0,s]]
heapq.heapify(que) #最小値を管理 [dist[i],i]となる要素
while que:
p=heapq.heappop(que) #距離が最小のものを取り出す
dis=p[0]
v=p[1]
if dist[v] <dis:
continue
for edge in edges[v]:
to_v=edge[0]
cost=edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v]=dist[v]+cost
heapq.heappush(que,[dist[to_v], to_v])
return dist
def main():
import sys
input=sys.stdin.readline
n=int(eval(input()))
edges=[[] for _ in range(n)]
for i in range(n-1):
a,b,c=list(map(int,input().split()))
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
q,k=list(map(int,input().split()))
k-=1
dist=dijkstra(n,edges,k)
for i in range(q):
x,y=list(map(int,input().split()))
x-=1
y-=1
print((dist[x]+dist[y]))
if __name__=='__main__':
main()
| 46 | 48 | 1,039 | 1,085 |
import heapq
def dijkstra(V, edges, s):
inf = float("inf")
dist = [inf] * V
dist[s] = 0
que = [[0, s]]
heapq.heapify(que) # 最小値を管理 [dist[i],i]となる要素
while que:
p = heapq.heappop(que) # 距離が最小のものを取り出す
dis = p[0]
v = p[1]
if dist[v] < dis:
continue
for edge in edges[v]:
to_v = edge[0]
cost = edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v] = dist[v] + cost
heapq.heappush(que, [dist[to_v], to_v])
return dist
def main():
n = int(eval(input()))
edges = [[] for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append([b, c])
edges[b].append([a, c])
q, k = list(map(int, input().split()))
k -= 1
dist = dijkstra(n, edges, k)
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((dist[x] + dist[y]))
if __name__ == "__main__":
main()
|
import heapq
def dijkstra(V, edges, s):
inf = float("inf")
dist = [inf] * V
dist[s] = 0
que = [[0, s]]
heapq.heapify(que) # 最小値を管理 [dist[i],i]となる要素
while que:
p = heapq.heappop(que) # 距離が最小のものを取り出す
dis = p[0]
v = p[1]
if dist[v] < dis:
continue
for edge in edges[v]:
to_v = edge[0]
cost = edge[1]
if dist[to_v] > dist[v] + cost:
dist[to_v] = dist[v] + cost
heapq.heappush(que, [dist[to_v], to_v])
return dist
def main():
import sys
input = sys.stdin.readline
n = int(eval(input()))
edges = [[] for _ in range(n)]
for i in range(n - 1):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
edges[a].append([b, c])
edges[b].append([a, c])
q, k = list(map(int, input().split()))
k -= 1
dist = dijkstra(n, edges, k)
for i in range(q):
x, y = list(map(int, input().split()))
x -= 1
y -= 1
print((dist[x] + dist[y]))
if __name__ == "__main__":
main()
| false | 4.166667 |
[
"+ import sys",
"+",
"+ input = sys.stdin.readline"
] | false | 0.036297 | 0.035652 | 1.018118 |
[
"s448225906",
"s550658948"
] |
u869154953
|
p03573
|
python
|
s617741567
|
s903657782
| 30 | 26 | 9,096 | 9,100 |
Accepted
|
Accepted
| 13.33 |
A,B,C=list(map(int,input().split()))
if A==B:
print(C)
else:
if A==C:
print(B)
else:
print(A)
|
A,B,C=list(map(int,input().split()))
if A==B:
print(C)
elif B==C:
print(A)
else:
print(B)
| 10 | 8 | 108 | 94 |
A, B, C = list(map(int, input().split()))
if A == B:
print(C)
else:
if A == C:
print(B)
else:
print(A)
|
A, B, C = list(map(int, input().split()))
if A == B:
print(C)
elif B == C:
print(A)
else:
print(B)
| false | 20 |
[
"+elif B == C:",
"+ print(A)",
"- if A == C:",
"- print(B)",
"- else:",
"- print(A)",
"+ print(B)"
] | false | 0.035102 | 0.038236 | 0.918033 |
[
"s617741567",
"s903657782"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.