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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u392319141
|
p02781
|
python
|
s540277534
|
s590441154
| 49 | 24 | 4,828 | 3,812 |
Accepted
|
Accepted
| 51.02 |
from functools import lru_cache
N = eval(input())
K = int(eval(input()))
@lru_cache(maxsize=None)
def search(d, cnt, isEq):
if d == len(N):
return 1 if cnt == K else 0
n = int(N[d])
if isEq and n == 0:
return search(d + 1, cnt, isEq)
if isEq:
ret = 0
ret += search(d + 1, cnt, False)
for _ in range(1, n):
ret += search(d + 1, cnt + 1, False)
ret += search(d + 1, cnt + 1, True)
return ret
return search(d + 1, cnt, False) + search(d + 1, cnt + 1, False) * 9
print((search(0, 0, True)))
|
from functools import lru_cache
N = eval(input())
K = int(eval(input()))
@lru_cache(maxsize=None)
def search(d, k, isLess):
if k == K:
return 1
if d == len(N):
return 0
n = int(N[d])
if isLess:
return search(d + 1, k, isLess) + search(d + 1, k + 1, isLess) * 9
ret = 0
for i in range(n + 1):
ret += search(d + 1, k + (1 if i > 0 else 0) , isLess or (i < n))
return ret
print((search(0, 0, False)))
| 26 | 23 | 593 | 472 |
from functools import lru_cache
N = eval(input())
K = int(eval(input()))
@lru_cache(maxsize=None)
def search(d, cnt, isEq):
if d == len(N):
return 1 if cnt == K else 0
n = int(N[d])
if isEq and n == 0:
return search(d + 1, cnt, isEq)
if isEq:
ret = 0
ret += search(d + 1, cnt, False)
for _ in range(1, n):
ret += search(d + 1, cnt + 1, False)
ret += search(d + 1, cnt + 1, True)
return ret
return search(d + 1, cnt, False) + search(d + 1, cnt + 1, False) * 9
print((search(0, 0, True)))
|
from functools import lru_cache
N = eval(input())
K = int(eval(input()))
@lru_cache(maxsize=None)
def search(d, k, isLess):
if k == K:
return 1
if d == len(N):
return 0
n = int(N[d])
if isLess:
return search(d + 1, k, isLess) + search(d + 1, k + 1, isLess) * 9
ret = 0
for i in range(n + 1):
ret += search(d + 1, k + (1 if i > 0 else 0), isLess or (i < n))
return ret
print((search(0, 0, False)))
| false | 11.538462 |
[
"-def search(d, cnt, isEq):",
"+def search(d, k, isLess):",
"+ if k == K:",
"+ return 1",
"- return 1 if cnt == K else 0",
"+ return 0",
"- if isEq and n == 0:",
"- return search(d + 1, cnt, isEq)",
"- if isEq:",
"- ret = 0",
"- ret += search(d + 1, cnt, False)",
"- for _ in range(1, n):",
"- ret += search(d + 1, cnt + 1, False)",
"- ret += search(d + 1, cnt + 1, True)",
"- return ret",
"- return search(d + 1, cnt, False) + search(d + 1, cnt + 1, False) * 9",
"+ if isLess:",
"+ return search(d + 1, k, isLess) + search(d + 1, k + 1, isLess) * 9",
"+ ret = 0",
"+ for i in range(n + 1):",
"+ ret += search(d + 1, k + (1 if i > 0 else 0), isLess or (i < n))",
"+ return ret",
"-print((search(0, 0, True)))",
"+print((search(0, 0, False)))"
] | false | 0.036302 | 0.035741 | 1.01569 |
[
"s540277534",
"s590441154"
] |
u684241248
|
p02343
|
python
|
s193642951
|
s893302649
| 490 | 450 | 13,964 | 13,976 |
Accepted
|
Accepted
| 8.16 |
# -*- coding: utf-8 -*-
class DisjointSets:
'''
Implementing disjoint sets using disjoint sets forests structure.
--- methods ---
__init__(size): size should be the number of elements in this disjoint sets
unite(x, y): unite sets that contain x and y into a new set
same(x, y): check if x and y are in the same set
'''
def __init__(self, size):
self.size = size
self.ranks = [0] * self.size
self.roots = [0] * self.size
for x in range(self.size):
self._make_set(x)
def _make_set(self, x):
self.roots[x] = x
self.ranks[x] = 0
def _link(self, x, y):
if self.ranks[x] > self.ranks[y]:
self.roots[y] = x
else:
self.roots[x] = y
if self.ranks[x] == self.ranks[y]:
self.ranks[y] += 1
def _find_set(self, x):
# compression of the path
if x != self.roots[x]:
self.roots[x] = self._find_set(self.roots[x])
return self.roots[x]
def unite(self, x, y):
self._link(self._find_set(x), self._find_set(y))
def same(self, x, y):
return self._find_set(x) == self._find_set(y)
if __name__ == '__main__':
import sys
n, q = list(map(int, input().split()))
ds = DisjointSets(n)
for line in sys.stdin.readlines():
query, x, y = list(map(int, line.strip().split()))
if query == 0:
ds.unite(x, y)
elif query == 1:
if ds.same(x, y):
print((1))
else:
print((0))
|
# -*- coding: utf-8 -*-
class DisjointSets:
'''
Implementing disjoint sets using disjoint sets forests structure.
--- methods ---
__init__(size): size should be the number of elements in this disjoint sets
unite(x, y): unite sets that contain x and y into a new set
same(x, y): check if x and y are in the same set
'''
def __init__(self, size):
self.size = size
self.roots = [x for x in range(self.size)]
self.ranks = [0] * self.size
def _link(self, x, y):
if self.ranks[x] > self.ranks[y]:
self.roots[y] = x
else:
self.roots[x] = y
if self.ranks[x] == self.ranks[y]:
self.ranks[y] += 1
def _find_set(self, x):
# compression of the path
if x != self.roots[x]:
self.roots[x] = self._find_set(self.roots[x])
return self.roots[x]
def unite(self, x, y):
self._link(self._find_set(x), self._find_set(y))
def same(self, x, y):
return self._find_set(x) == self._find_set(y)
if __name__ == '__main__':
'''
an example of using this function
AIZU ONLINE JUDGE - DSL_1_A
'''
import sys
n, q = list(map(int, input().split()))
ds = DisjointSets(n)
for line in sys.stdin.readlines():
query, x, y = list(map(int, line.strip().split()))
if query == 0:
ds.unite(x, y)
elif query == 1:
if ds.same(x, y):
print((1))
else:
print((0))
| 59 | 58 | 1,629 | 1,583 |
# -*- coding: utf-8 -*-
class DisjointSets:
"""
Implementing disjoint sets using disjoint sets forests structure.
--- methods ---
__init__(size): size should be the number of elements in this disjoint sets
unite(x, y): unite sets that contain x and y into a new set
same(x, y): check if x and y are in the same set
"""
def __init__(self, size):
self.size = size
self.ranks = [0] * self.size
self.roots = [0] * self.size
for x in range(self.size):
self._make_set(x)
def _make_set(self, x):
self.roots[x] = x
self.ranks[x] = 0
def _link(self, x, y):
if self.ranks[x] > self.ranks[y]:
self.roots[y] = x
else:
self.roots[x] = y
if self.ranks[x] == self.ranks[y]:
self.ranks[y] += 1
def _find_set(self, x):
# compression of the path
if x != self.roots[x]:
self.roots[x] = self._find_set(self.roots[x])
return self.roots[x]
def unite(self, x, y):
self._link(self._find_set(x), self._find_set(y))
def same(self, x, y):
return self._find_set(x) == self._find_set(y)
if __name__ == "__main__":
import sys
n, q = list(map(int, input().split()))
ds = DisjointSets(n)
for line in sys.stdin.readlines():
query, x, y = list(map(int, line.strip().split()))
if query == 0:
ds.unite(x, y)
elif query == 1:
if ds.same(x, y):
print((1))
else:
print((0))
|
# -*- coding: utf-8 -*-
class DisjointSets:
"""
Implementing disjoint sets using disjoint sets forests structure.
--- methods ---
__init__(size): size should be the number of elements in this disjoint sets
unite(x, y): unite sets that contain x and y into a new set
same(x, y): check if x and y are in the same set
"""
def __init__(self, size):
self.size = size
self.roots = [x for x in range(self.size)]
self.ranks = [0] * self.size
def _link(self, x, y):
if self.ranks[x] > self.ranks[y]:
self.roots[y] = x
else:
self.roots[x] = y
if self.ranks[x] == self.ranks[y]:
self.ranks[y] += 1
def _find_set(self, x):
# compression of the path
if x != self.roots[x]:
self.roots[x] = self._find_set(self.roots[x])
return self.roots[x]
def unite(self, x, y):
self._link(self._find_set(x), self._find_set(y))
def same(self, x, y):
return self._find_set(x) == self._find_set(y)
if __name__ == "__main__":
"""
an example of using this function
AIZU ONLINE JUDGE - DSL_1_A
"""
import sys
n, q = list(map(int, input().split()))
ds = DisjointSets(n)
for line in sys.stdin.readlines():
query, x, y = list(map(int, line.strip().split()))
if query == 0:
ds.unite(x, y)
elif query == 1:
if ds.same(x, y):
print((1))
else:
print((0))
| false | 1.694915 |
[
"+ self.roots = [x for x in range(self.size)]",
"- self.roots = [0] * self.size",
"- for x in range(self.size):",
"- self._make_set(x)",
"-",
"- def _make_set(self, x):",
"- self.roots[x] = x",
"- self.ranks[x] = 0",
"+ \"\"\"",
"+ an example of using this function",
"+ AIZU ONLINE JUDGE - DSL_1_A",
"+ \"\"\""
] | false | 0.037452 | 0.038251 | 0.979109 |
[
"s193642951",
"s893302649"
] |
u744920373
|
p03166
|
python
|
s242907865
|
s217443306
| 942 | 549 | 144,008 | 75,672 |
Accepted
|
Accepted
| 41.72 |
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**6)
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp)))
|
import sys
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 i in range(N)]
def dp2(ini, i, j): return [[ini]*i for i2 in range(j)]
def dp3(ini, i, j, k): return [[[ini]*i for i2 in range(j)] for i3 in range(k)]
#import bisect #bisect.bisect_left(B, a)
#from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**8)
#メモ化再帰
def rec(x):
global dp
if dp[x]!=-1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a)+1)
dp[x] = num
return num
#入力受け取り
N, M = mi()
x = li2(M)
#隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
#メモ化再帰を実行
dp = [-1]*N
for i in range(N):
rec(i)
print((max(dp)))
| 39 | 40 | 955 | 972 |
import sys
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 i in range(N)]
def dp2(ini, i, j):
return [[ini] * i for i2 in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for i2 in range(j)] for i3 in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**6)
def rec(x):
global dp
if dp[x] != -1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a) + 1)
dp[x] = num
return num
# 入力受け取り
N, M = mi()
x = li2(M)
# 隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
dp = [-1] * N
for i in range(N):
rec(i)
print((max(dp)))
|
import sys
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 i in range(N)]
def dp2(ini, i, j):
return [[ini] * i for i2 in range(j)]
def dp3(ini, i, j, k):
return [[[ini] * i for i2 in range(j)] for i3 in range(k)]
# import bisect #bisect.bisect_left(B, a)
# from collections import defaultdict #d = defaultdict(int) d[key] += value
sys.setrecursionlimit(10**8)
# メモ化再帰
def rec(x):
global dp
if dp[x] != -1:
return dp[x]
num = 0
for a in adj[x]:
num = max(num, rec(a) + 1)
dp[x] = num
return num
# 入力受け取り
N, M = mi()
x = li2(M)
# 隣接リスト作成
adj = [[] for i in range(N)]
for i in range(M):
x[i][0] -= 1
x[i][1] -= 1
adj[x[i][0]].append(x[i][1])
# メモ化再帰を実行
dp = [-1] * N
for i in range(N):
rec(i)
print((max(dp)))
| false | 2.5 |
[
"-sys.setrecursionlimit(10**6)",
"-",
"-",
"+sys.setrecursionlimit(10**8)",
"+# メモ化再帰",
"+# メモ化再帰を実行"
] | false | 0.086881 | 0.080876 | 1.074245 |
[
"s242907865",
"s217443306"
] |
u312025627
|
p03425
|
python
|
s552860546
|
s195823647
| 450 | 189 | 54,616 | 83,084 |
Accepted
|
Accepted
| 58 |
def main():
N = int(eval(input()))
A = [eval(input()) for i in range(N)]
from itertools import combinations
S = {"M": 0, "A": 1, "R": 2, "C": 3, "H": 4}
ans = 0
cnt = [0]*5
for a in A:
c = a[0]
if c in list(S.keys()):
cnt[S[c]] += 1
for comb in combinations(list(range(5)), 3):
ans += cnt[comb[0]]*cnt[comb[1]]*cnt[comb[2]]
print(ans)
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
A = [input()[0] for i in range(N)]
from collections import Counter
from itertools import combinations
c = Counter(A)
d = ('M', 'A', 'R', 'C', 'H')
ans = 0
for (a1, a2, a3) in combinations(d, 3):
ans += c[a1] * c[a2] * c[a3]
print(ans)
if __name__ == '__main__':
main()
| 18 | 15 | 440 | 362 |
def main():
N = int(eval(input()))
A = [eval(input()) for i in range(N)]
from itertools import combinations
S = {"M": 0, "A": 1, "R": 2, "C": 3, "H": 4}
ans = 0
cnt = [0] * 5
for a in A:
c = a[0]
if c in list(S.keys()):
cnt[S[c]] += 1
for comb in combinations(list(range(5)), 3):
ans += cnt[comb[0]] * cnt[comb[1]] * cnt[comb[2]]
print(ans)
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
A = [input()[0] for i in range(N)]
from collections import Counter
from itertools import combinations
c = Counter(A)
d = ("M", "A", "R", "C", "H")
ans = 0
for (a1, a2, a3) in combinations(d, 3):
ans += c[a1] * c[a2] * c[a3]
print(ans)
if __name__ == "__main__":
main()
| false | 16.666667 |
[
"- A = [eval(input()) for i in range(N)]",
"+ A = [input()[0] for i in range(N)]",
"+ from collections import Counter",
"- S = {\"M\": 0, \"A\": 1, \"R\": 2, \"C\": 3, \"H\": 4}",
"+ c = Counter(A)",
"+ d = (\"M\", \"A\", \"R\", \"C\", \"H\")",
"- cnt = [0] * 5",
"- for a in A:",
"- c = a[0]",
"- if c in list(S.keys()):",
"- cnt[S[c]] += 1",
"- for comb in combinations(list(range(5)), 3):",
"- ans += cnt[comb[0]] * cnt[comb[1]] * cnt[comb[2]]",
"+ for (a1, a2, a3) in combinations(d, 3):",
"+ ans += c[a1] * c[a2] * c[a3]"
] | false | 0.031636 | 0.049218 | 0.642783 |
[
"s552860546",
"s195823647"
] |
u122428774
|
p02711
|
python
|
s050382477
|
s977147822
| 21 | 19 | 8,960 | 8,884 |
Accepted
|
Accepted
| 9.52 |
print(("Yes" if "7" in eval(input()) else "No"))
|
print(("YNeos"[not'7'in eval(input())::2]))
| 1 | 1 | 40 | 35 |
print(("Yes" if "7" in eval(input()) else "No"))
|
print(("YNeos"[not "7" in eval(input()) :: 2]))
| false | 0 |
[
"-print((\"Yes\" if \"7\" in eval(input()) else \"No\"))",
"+print((\"YNeos\"[not \"7\" in eval(input()) :: 2]))"
] | false | 0.046817 | 0.046273 | 1.011757 |
[
"s050382477",
"s977147822"
] |
u413165887
|
p02901
|
python
|
s599546975
|
s559379301
| 1,468 | 544 | 3,188 | 3,188 |
Accepted
|
Accepted
| 62.94 |
def main():
n ,m = list(map(int, input().split(' ')))
inf = 10**9
bit_dp = [inf for _ in range(2**(n))]
bit_dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split(' ')))
c = list(map(int, input().split(' ')))
bit_n = 0
for i in c:
bit_n |= 1 << i-1
for i in range(2**(n)):
bit_dp[i|bit_n] = min(bit_dp[i|bit_n], bit_dp[i] + a)
if bit_dp[-1] >= inf:
print((-1))
else:
print((bit_dp[-1]))
if __name__ == '__main__':
main()
|
def main():
n ,m = list(map(int, input().split(' ')))
inf = 10**9
bit_dp = [inf for _ in range(2**(n))]
bit_dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split(' ')))
c = list(map(int, input().split(' ')))
bit_n = 0
for i in c:
bit_n |= 1 << i-1
for i in range(2**(n)):
if bit_dp[i|bit_n] > bit_dp[i] + a:
bit_dp[i|bit_n] = bit_dp[i] + a
if bit_dp[-1] >= inf:
print((-1))
else:
print((bit_dp[-1]))
if __name__ == '__main__':
main()
| 19 | 20 | 543 | 574 |
def main():
n, m = list(map(int, input().split(" ")))
inf = 10**9
bit_dp = [inf for _ in range(2 ** (n))]
bit_dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split(" ")))
c = list(map(int, input().split(" ")))
bit_n = 0
for i in c:
bit_n |= 1 << i - 1
for i in range(2 ** (n)):
bit_dp[i | bit_n] = min(bit_dp[i | bit_n], bit_dp[i] + a)
if bit_dp[-1] >= inf:
print((-1))
else:
print((bit_dp[-1]))
if __name__ == "__main__":
main()
|
def main():
n, m = list(map(int, input().split(" ")))
inf = 10**9
bit_dp = [inf for _ in range(2 ** (n))]
bit_dp[0] = 0
for i in range(m):
a, b = list(map(int, input().split(" ")))
c = list(map(int, input().split(" ")))
bit_n = 0
for i in c:
bit_n |= 1 << i - 1
for i in range(2 ** (n)):
if bit_dp[i | bit_n] > bit_dp[i] + a:
bit_dp[i | bit_n] = bit_dp[i] + a
if bit_dp[-1] >= inf:
print((-1))
else:
print((bit_dp[-1]))
if __name__ == "__main__":
main()
| false | 5 |
[
"- bit_dp[i | bit_n] = min(bit_dp[i | bit_n], bit_dp[i] + a)",
"+ if bit_dp[i | bit_n] > bit_dp[i] + a:",
"+ bit_dp[i | bit_n] = bit_dp[i] + a"
] | false | 0.038247 | 0.03878 | 0.98626 |
[
"s599546975",
"s559379301"
] |
u759412327
|
p03862
|
python
|
s336866682
|
s299573128
| 109 | 88 | 14,092 | 14,160 |
Accepted
|
Accepted
| 19.27 |
N,X,*A = list(map(int,open(0).read().split()))
A+=[0]
s = 0
for n in range(N):
d=max(0,A[n]+A[n-1]-X)
s+=d
A[n]-=d
print(s)
|
N,x = list(map(int,input().split()))
A = list(map(int,input().split()))
pre = 0
ans = 0
for a in A:
eat = max(0,pre+a-x)
pre = a - eat
ans+= eat
print(ans)
| 10 | 11 | 134 | 167 |
N, X, *A = list(map(int, open(0).read().split()))
A += [0]
s = 0
for n in range(N):
d = max(0, A[n] + A[n - 1] - X)
s += d
A[n] -= d
print(s)
|
N, x = list(map(int, input().split()))
A = list(map(int, input().split()))
pre = 0
ans = 0
for a in A:
eat = max(0, pre + a - x)
pre = a - eat
ans += eat
print(ans)
| false | 9.090909 |
[
"-N, X, *A = list(map(int, open(0).read().split()))",
"-A += [0]",
"-s = 0",
"-for n in range(N):",
"- d = max(0, A[n] + A[n - 1] - X)",
"- s += d",
"- A[n] -= d",
"-print(s)",
"+N, x = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+pre = 0",
"+ans = 0",
"+for a in A:",
"+ eat = max(0, pre + a - x)",
"+ pre = a - eat",
"+ ans += eat",
"+print(ans)"
] | false | 0.037254 | 0.035316 | 1.054901 |
[
"s336866682",
"s299573128"
] |
u142211940
|
p02713
|
python
|
s310111677
|
s080765635
| 1,559 | 506 | 9,156 | 67,892 |
Accepted
|
Accepted
| 67.54 |
import math
K=int(eval(input()))
ans=0
for i in range(1,K+1,1):
for j in range(1,K+1,1):
a = math.gcd(i,j)
for k in range(1,K+1,1):
b = math.gcd(a,k)
ans += b
print(ans)
|
import math
K=int(eval(input()))
ans=0
for i in range(1,K+1,1):
for j in range(1,K+1,1):
for k in range(1,K+1,1):
a = math.gcd(i,j)
b = math.gcd(a,k)
ans += b
print(ans)
| 12 | 12 | 221 | 225 |
import math
K = int(eval(input()))
ans = 0
for i in range(1, K + 1, 1):
for j in range(1, K + 1, 1):
a = math.gcd(i, j)
for k in range(1, K + 1, 1):
b = math.gcd(a, k)
ans += b
print(ans)
|
import math
K = int(eval(input()))
ans = 0
for i in range(1, K + 1, 1):
for j in range(1, K + 1, 1):
for k in range(1, K + 1, 1):
a = math.gcd(i, j)
b = math.gcd(a, k)
ans += b
print(ans)
| false | 0 |
[
"- a = math.gcd(i, j)",
"+ a = math.gcd(i, j)"
] | false | 0.125761 | 0.034468 | 3.648581 |
[
"s310111677",
"s080765635"
] |
u404290207
|
p02861
|
python
|
s559645284
|
s100500850
| 459 | 312 | 8,180 | 65,768 |
Accepted
|
Accepted
| 32.03 |
n = int(eval(input()))
import itertools
arr = []
for i in range(n):
arr.append(list(map(int,input().split())))
ptr = list(itertools.permutations(arr, n))
dis = 0
for i in range(len(ptr)):
for j in range(n-1):
dis +=((ptr[i][j][1]-ptr[i][j+1][1]) **2 + (ptr[i][j][0]-ptr[i][j+1][0])**2)**0.5
print((dis/len(ptr)))
|
import sys
sys.setrecursionlimit(10**6)
from math import floor,ceil,sqrt,factorial,log
from heapq import heappop, heappush, heappushpop
from collections import Counter,defaultdict,deque
from itertools import accumulate,permutations,combinations,product,combinations_with_replacement
from bisect import bisect_left,bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10 ** 9 + 7
inf = float('inf')
ninf = -float('inf')
#整数input
def ii(): return int(sys.stdin.readline().rstrip()) #int(input())
def mii(): return list(map(int,sys.stdin.readline().rstrip().split()))
def limii(): return list(mii()) #list(map(int,input().split()))
def lin(n:int): return [ii() for _ in range(n)]
def llint(n: int): return [limii() for _ in range(n)]
#文字列input
def ss(): return sys.stdin.readline().rstrip() #input()
def mss(): return sys.stdin.readline().rstrip().split()
def limss(): return list(mss()) #list(input().split())
def lst(n:int): return [ss() for _ in range(n)]
def llstr(n: int): return [limss() for _ in range(n)]
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
#本当に貪欲法か？ DP法では？？
n=ii()
arr=llint(n)
ans=0
cnt=0
for i in permutations(list(range(n))):
cnt+=1
for j in range(n-1):
ans+=((arr[i[j]][0]-arr[i[j+1]][0])**2 + (arr[i[j]][1]-arr[i[j+1]][1])**2)**0.5
print((ans/cnt))
| 23 | 42 | 366 | 1,358 |
n = int(eval(input()))
import itertools
arr = []
for i in range(n):
arr.append(list(map(int, input().split())))
ptr = list(itertools.permutations(arr, n))
dis = 0
for i in range(len(ptr)):
for j in range(n - 1):
dis += (
(ptr[i][j][1] - ptr[i][j + 1][1]) ** 2
+ (ptr[i][j][0] - ptr[i][j + 1][0]) ** 2
) ** 0.5
print((dis / len(ptr)))
|
import sys
sys.setrecursionlimit(10**6)
from math import floor, ceil, sqrt, factorial, log
from heapq import heappop, heappush, heappushpop
from collections import Counter, defaultdict, deque
from itertools import (
accumulate,
permutations,
combinations,
product,
combinations_with_replacement,
)
from bisect import bisect_left, bisect_right
from copy import deepcopy
from operator import itemgetter
from fractions import gcd
mod = 10**9 + 7
inf = float("inf")
ninf = -float("inf")
# 整数input
def ii():
return int(sys.stdin.readline().rstrip()) # int(input())
def mii():
return list(map(int, sys.stdin.readline().rstrip().split()))
def limii():
return list(mii()) # list(map(int,input().split()))
def lin(n: int):
return [ii() for _ in range(n)]
def llint(n: int):
return [limii() for _ in range(n)]
# 文字列input
def ss():
return sys.stdin.readline().rstrip() # input()
def mss():
return sys.stdin.readline().rstrip().split()
def limss():
return list(mss()) # list(input().split())
def lst(n: int):
return [ss() for _ in range(n)]
def llstr(n: int):
return [limss() for _ in range(n)]
# 本当に貪欲法か？ DP法では？？
# 本当に貪欲法か？ DP法では？？
# 本当に貪欲法か？ DP法では？？
n = ii()
arr = llint(n)
ans = 0
cnt = 0
for i in permutations(list(range(n))):
cnt += 1
for j in range(n - 1):
ans += (
(arr[i[j]][0] - arr[i[j + 1]][0]) ** 2
+ (arr[i[j]][1] - arr[i[j + 1]][1]) ** 2
) ** 0.5
print((ans / cnt))
| false | 45.238095 |
[
"-n = int(eval(input()))",
"-import itertools",
"+import sys",
"-arr = []",
"-for i in range(n):",
"- arr.append(list(map(int, input().split())))",
"-ptr = list(itertools.permutations(arr, n))",
"-dis = 0",
"-for i in range(len(ptr)):",
"+sys.setrecursionlimit(10**6)",
"+from math import floor, ceil, sqrt, factorial, log",
"+from heapq import heappop, heappush, heappushpop",
"+from collections import Counter, defaultdict, deque",
"+from itertools import (",
"+ accumulate,",
"+ permutations,",
"+ combinations,",
"+ product,",
"+ combinations_with_replacement,",
"+)",
"+from bisect import bisect_left, bisect_right",
"+from copy import deepcopy",
"+from operator import itemgetter",
"+from fractions import gcd",
"+",
"+mod = 10**9 + 7",
"+inf = float(\"inf\")",
"+ninf = -float(\"inf\")",
"+# 整数input",
"+def ii():",
"+ return int(sys.stdin.readline().rstrip()) # int(input())",
"+",
"+",
"+def mii():",
"+ return list(map(int, sys.stdin.readline().rstrip().split()))",
"+",
"+",
"+def limii():",
"+ return list(mii()) # list(map(int,input().split()))",
"+",
"+",
"+def lin(n: int):",
"+ return [ii() for _ in range(n)]",
"+",
"+",
"+def llint(n: int):",
"+ return [limii() for _ in range(n)]",
"+",
"+",
"+# 文字列input",
"+def ss():",
"+ return sys.stdin.readline().rstrip() # input()",
"+",
"+",
"+def mss():",
"+ return sys.stdin.readline().rstrip().split()",
"+",
"+",
"+def limss():",
"+ return list(mss()) # list(input().split())",
"+",
"+",
"+def lst(n: int):",
"+ return [ss() for _ in range(n)]",
"+",
"+",
"+def llstr(n: int):",
"+ return [limss() for _ in range(n)]",
"+",
"+",
"+# 本当に貪欲法か？ DP法では？？",
"+# 本当に貪欲法か？ DP法では？？",
"+# 本当に貪欲法か？ DP法では？？",
"+n = ii()",
"+arr = llint(n)",
"+ans = 0",
"+cnt = 0",
"+for i in permutations(list(range(n))):",
"+ cnt += 1",
"- dis += (",
"- (ptr[i][j][1] - ptr[i][j + 1][1]) ** 2",
"- + (ptr[i][j][0] - ptr[i][j + 1][0]) ** 2",
"+ ans += (",
"+ (arr[i[j]][0] - arr[i[j + 1]][0]) ** 2",
"+ + (arr[i[j]][1] - arr[i[j + 1]][1]) ** 2",
"-print((dis / len(ptr)))",
"+print((ans / cnt))"
] | false | 0.055634 | 0.040926 | 1.359388 |
[
"s559645284",
"s100500850"
] |
u837340160
|
p02571
|
python
|
s767564475
|
s877531544
| 100 | 86 | 8,976 | 9,048 |
Accepted
|
Accepted
| 14 |
S = eval(input())
T = eval(input())
ans = len(T)
for i in range(len(S)-len(T)+1):
cnt = 0
for j in range(len(T)):
if T[j] != S[i:i+len(T)][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
|
S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N-M+1):
cnt = 0
for j in range(M):
if T[j] != S[i:i+M][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| 12 | 14 | 216 | 215 |
S = eval(input())
T = eval(input())
ans = len(T)
for i in range(len(S) - len(T) + 1):
cnt = 0
for j in range(len(T)):
if T[j] != S[i : i + len(T)][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
|
S = eval(input())
T = eval(input())
N = len(S)
M = len(T)
ans = M
for i in range(N - M + 1):
cnt = 0
for j in range(M):
if T[j] != S[i : i + M][j]:
cnt += 1
ans = min(ans, cnt)
print(ans)
| false | 14.285714 |
[
"-ans = len(T)",
"-for i in range(len(S) - len(T) + 1):",
"+N = len(S)",
"+M = len(T)",
"+ans = M",
"+for i in range(N - M + 1):",
"- for j in range(len(T)):",
"- if T[j] != S[i : i + len(T)][j]:",
"+ for j in range(M):",
"+ if T[j] != S[i : i + M][j]:"
] | false | 0.035112 | 0.070713 | 0.496538 |
[
"s767564475",
"s877531544"
] |
u810288681
|
p03971
|
python
|
s819948153
|
s030651312
| 295 | 113 | 53,464 | 4,016 |
Accepted
|
Accepted
| 61.69 |
n,a,b = list(map(int, input().split()))
s = eval(input())
p = a+b
cnt = 0
bcnt = 0
for i in range(n):
if s[i] == 'a' and cnt < p:
print('Yes')
cnt+=1
elif s[i] == 'b' and cnt < p and bcnt < b:
print('Yes')
cnt+=1
bcnt+=1
else:
print('No')
|
n,a,b = list(map(int, input().split()))
s = eval(input())
ap=0
bp=0
for i in range(n):
if s[i]=='a' and ap+bp<a+b:
ap+=1
print('Yes')
elif s[i]=='b' and ap+bp<a+b and bp<b:
bp+=1
print('Yes')
else:
print('No')
| 15 | 13 | 300 | 261 |
n, a, b = list(map(int, input().split()))
s = eval(input())
p = a + b
cnt = 0
bcnt = 0
for i in range(n):
if s[i] == "a" and cnt < p:
print("Yes")
cnt += 1
elif s[i] == "b" and cnt < p and bcnt < b:
print("Yes")
cnt += 1
bcnt += 1
else:
print("No")
|
n, a, b = list(map(int, input().split()))
s = eval(input())
ap = 0
bp = 0
for i in range(n):
if s[i] == "a" and ap + bp < a + b:
ap += 1
print("Yes")
elif s[i] == "b" and ap + bp < a + b and bp < b:
bp += 1
print("Yes")
else:
print("No")
| false | 13.333333 |
[
"-p = a + b",
"-cnt = 0",
"-bcnt = 0",
"+ap = 0",
"+bp = 0",
"- if s[i] == \"a\" and cnt < p:",
"+ if s[i] == \"a\" and ap + bp < a + b:",
"+ ap += 1",
"- cnt += 1",
"- elif s[i] == \"b\" and cnt < p and bcnt < b:",
"+ elif s[i] == \"b\" and ap + bp < a + b and bp < b:",
"+ bp += 1",
"- cnt += 1",
"- bcnt += 1"
] | false | 0.03645 | 0.060119 | 0.606289 |
[
"s819948153",
"s030651312"
] |
u928784113
|
p02711
|
python
|
s222263752
|
s264761264
| 105 | 24 | 27,224 | 9,632 |
Accepted
|
Accepted
| 77.14 |
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
from fractions import gcd
from copy import deepcopy
import math
import queue
import numpy as np
#import sympy as syp(素因数分解とか)
Mod = 1000000007
import sys
sys.setrecursionlimit(100000)
def sieve_of_eratosthenes(n):
if not isinstance(n,int):
raise TypeError("n is not int")
if n<2:
raise ValueError("n is not effective")
prime = [1]*(n+1)
for i in range(2,int(math.sqrt(n))+1):
if prime[i] == 1:
for j in range(2*i,n+1):
if j%i == 0:
prime[j] = 0
res = []
for i in range(2,n+1):
if prime[i] == 1:
res.append(i)
return res
class UnionFind:
def __init__(self,n):
self.parent = [i for i in range(n+1)]
self.rank = [0 for i in range(n+1)]
def findroot(self,x):
if x == self.parent[x]:
return x
else:
y = self.parent[x]
y = self.findroot(self.parent[x])
return y
def union(self,x,y):
px = self.findroot(x)
py = self.findroot(y)
if px < py:
self.parent[py] = px
else:
self.parent[px] = py
def same_group_or_no(self,x,y):
return self.findroot(x) == self.findroot(y)
def main(): #startline-------------------------------------------
print(("Yes" if "7" in eval(input()) else "No"))
if __name__ == "__main__":
main() #endline===============================================
|
import itertools
from collections import deque,defaultdict,Counter
from itertools import accumulate
import bisect
from heapq import heappop,heappush,heapify
import math
from copy import deepcopy
import queue
#import sympy as syp(素因数分解とか)
Mod = 1000000007
def sieve_of_eratosthenes(n):
if not isinstance(n,int):
raise TypeError("n is not int")
if n<2:
raise ValueError("n is not effective")
prime = [1]*(n+1)
for i in range(2,int(math.sqrt(n))+1):
if prime[i] == 1:
for j in range(2*i,n+1):
if j%i == 0:
prime[j] = 0
res = []
for i in range(2,n+1):
if prime[i] == 1:
res.append(i)
return res
class UnionFind:
def __init__(self,n):
self.parent = [i for i in range(n+1)]
self.rank = [0 for i in range(n+1)]
def findroot(self,x):
if x == self.parent[x]:
return x
else:
y = self.parent[x]
y = self.findroot(self.parent[x])
return y
def union(self,x,y):
px = self.findroot(x)
py = self.findroot(y)
if px < py:
self.parent[py] = px
else:
self.parent[px] = py
def same_group_or_no(self,x,y):
return self.findroot(x) == self.findroot(y)
def main(): #startline-------------------------------------------
print(("Yes" if "7" in eval(input()) else "No"))
if __name__ == "__main__":
main() #endline===============================================
| 61 | 57 | 1,678 | 1,587 |
import itertools
from collections import deque, defaultdict, Counter
from itertools import accumulate
import bisect
from heapq import heappop, heappush, heapify
from fractions import gcd
from copy import deepcopy
import math
import queue
import numpy as np
# import sympy as syp(素因数分解とか)
Mod = 1000000007
import sys
sys.setrecursionlimit(100000)
def sieve_of_eratosthenes(n):
if not isinstance(n, int):
raise TypeError("n is not int")
if n < 2:
raise ValueError("n is not effective")
prime = [1] * (n + 1)
for i in range(2, int(math.sqrt(n)) + 1):
if prime[i] == 1:
for j in range(2 * i, n + 1):
if j % i == 0:
prime[j] = 0
res = []
for i in range(2, n + 1):
if prime[i] == 1:
res.append(i)
return res
class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n + 1)]
self.rank = [0 for i in range(n + 1)]
def findroot(self, x):
if x == self.parent[x]:
return x
else:
y = self.parent[x]
y = self.findroot(self.parent[x])
return y
def union(self, x, y):
px = self.findroot(x)
py = self.findroot(y)
if px < py:
self.parent[py] = px
else:
self.parent[px] = py
def same_group_or_no(self, x, y):
return self.findroot(x) == self.findroot(y)
def main(): # startline-------------------------------------------
print(("Yes" if "7" in eval(input()) else "No"))
if __name__ == "__main__":
main() # endline===============================================
|
import itertools
from collections import deque, defaultdict, Counter
from itertools import accumulate
import bisect
from heapq import heappop, heappush, heapify
import math
from copy import deepcopy
import queue
# import sympy as syp(素因数分解とか)
Mod = 1000000007
def sieve_of_eratosthenes(n):
if not isinstance(n, int):
raise TypeError("n is not int")
if n < 2:
raise ValueError("n is not effective")
prime = [1] * (n + 1)
for i in range(2, int(math.sqrt(n)) + 1):
if prime[i] == 1:
for j in range(2 * i, n + 1):
if j % i == 0:
prime[j] = 0
res = []
for i in range(2, n + 1):
if prime[i] == 1:
res.append(i)
return res
class UnionFind:
def __init__(self, n):
self.parent = [i for i in range(n + 1)]
self.rank = [0 for i in range(n + 1)]
def findroot(self, x):
if x == self.parent[x]:
return x
else:
y = self.parent[x]
y = self.findroot(self.parent[x])
return y
def union(self, x, y):
px = self.findroot(x)
py = self.findroot(y)
if px < py:
self.parent[py] = px
else:
self.parent[px] = py
def same_group_or_no(self, x, y):
return self.findroot(x) == self.findroot(y)
def main(): # startline-------------------------------------------
print(("Yes" if "7" in eval(input()) else "No"))
if __name__ == "__main__":
main() # endline===============================================
| false | 6.557377 |
[
"-from fractions import gcd",
"+import math",
"-import math",
"-import numpy as np",
"-import sys",
"-",
"-sys.setrecursionlimit(100000)"
] | false | 0.038503 | 0.038313 | 1.004956 |
[
"s222263752",
"s264761264"
] |
u683134447
|
p02744
|
python
|
s742630465
|
s348542115
| 438 | 314 | 57,564 | 59,300 |
Accepted
|
Accepted
| 28.31 |
n = int(eval(input()))
from itertools import product
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
def dfs(ans, i):
if len(ans) == n:
print(("".join(ans)))
return
for j in range(i+1):
dfs(ans+ascii_lowercase[j], max(j+1, i))
dfs("", 0)
|
n = int(eval(input()))
ansl = []
def dfs(s, max_s):
if len(s) == n:
ansl.append(s)
return
ascii_lowercase = 'abcdefghijklmnopqrstuvwxyz'
for i in range(max_s+1):
dfs(s+ascii_lowercase[i], max(i+1, max_s))
dfs("", 0)
for a in ansl:
print(a)
| 14 | 14 | 277 | 288 |
n = int(eval(input()))
from itertools import product
ascii_lowercase = "abcdefghijklmnopqrstuvwxyz"
def dfs(ans, i):
if len(ans) == n:
print(("".join(ans)))
return
for j in range(i + 1):
dfs(ans + ascii_lowercase[j], max(j + 1, i))
dfs("", 0)
|
n = int(eval(input()))
ansl = []
def dfs(s, max_s):
if len(s) == n:
ansl.append(s)
return
ascii_lowercase = "abcdefghijklmnopqrstuvwxyz"
for i in range(max_s + 1):
dfs(s + ascii_lowercase[i], max(i + 1, max_s))
dfs("", 0)
for a in ansl:
print(a)
| false | 0 |
[
"-from itertools import product",
"-",
"-ascii_lowercase = \"abcdefghijklmnopqrstuvwxyz\"",
"+ansl = []",
"-def dfs(ans, i):",
"- if len(ans) == n:",
"- print((\"\".join(ans)))",
"+def dfs(s, max_s):",
"+ if len(s) == n:",
"+ ansl.append(s)",
"- for j in range(i + 1):",
"- dfs(ans + ascii_lowercase[j], max(j + 1, i))",
"+ ascii_lowercase = \"abcdefghijklmnopqrstuvwxyz\"",
"+ for i in range(max_s + 1):",
"+ dfs(s + ascii_lowercase[i], max(i + 1, max_s))",
"+for a in ansl:",
"+ print(a)"
] | false | 0.041876 | 0.034025 | 1.230711 |
[
"s742630465",
"s348542115"
] |
u497596438
|
p04001
|
python
|
s187837000
|
s568131627
| 185 | 23 | 38,640 | 3,444 |
Accepted
|
Accepted
| 87.57 |
import copy
S=eval(input())
lst=[]
def Sum(l,S):
if S=="A":
return sum(l)
a=l.pop()
x=copy.copy(l)
x.append(a*10+int(S[0]))
y=copy.copy(l)
y.extend([a,int(S[0])])
return Sum(x,S[1:])+Sum(y,S[1:])
S+="A"
lst.append(int(S[0]))
print((Sum(lst,S[1:])))
|
from collections import deque
S=eval(input())
queue=deque()
lst=[]
lst.append([0,0])
for i in range(0,len(S)):
l=len(lst)
for _ in range(l):
x,y=lst.pop(0)
lst.append([x,y*10+int(S[i])])#plus
lst.append([x+y*10+int(S[i]),0])
l=len(lst)
for _ in range(l):
x,y=lst.pop(0)
lst.append(x+y)
print((int(sum(lst)/2)))
| 15 | 16 | 290 | 358 |
import copy
S = eval(input())
lst = []
def Sum(l, S):
if S == "A":
return sum(l)
a = l.pop()
x = copy.copy(l)
x.append(a * 10 + int(S[0]))
y = copy.copy(l)
y.extend([a, int(S[0])])
return Sum(x, S[1:]) + Sum(y, S[1:])
S += "A"
lst.append(int(S[0]))
print((Sum(lst, S[1:])))
|
from collections import deque
S = eval(input())
queue = deque()
lst = []
lst.append([0, 0])
for i in range(0, len(S)):
l = len(lst)
for _ in range(l):
x, y = lst.pop(0)
lst.append([x, y * 10 + int(S[i])]) # plus
lst.append([x + y * 10 + int(S[i]), 0])
l = len(lst)
for _ in range(l):
x, y = lst.pop(0)
lst.append(x + y)
print((int(sum(lst) / 2)))
| false | 6.25 |
[
"-import copy",
"+from collections import deque",
"+queue = deque()",
"-",
"-",
"-def Sum(l, S):",
"- if S == \"A\":",
"- return sum(l)",
"- a = l.pop()",
"- x = copy.copy(l)",
"- x.append(a * 10 + int(S[0]))",
"- y = copy.copy(l)",
"- y.extend([a, int(S[0])])",
"- return Sum(x, S[1:]) + Sum(y, S[1:])",
"-",
"-",
"-S += \"A\"",
"-lst.append(int(S[0]))",
"-print((Sum(lst, S[1:])))",
"+lst.append([0, 0])",
"+for i in range(0, len(S)):",
"+ l = len(lst)",
"+ for _ in range(l):",
"+ x, y = lst.pop(0)",
"+ lst.append([x, y * 10 + int(S[i])]) # plus",
"+ lst.append([x + y * 10 + int(S[i]), 0])",
"+l = len(lst)",
"+for _ in range(l):",
"+ x, y = lst.pop(0)",
"+ lst.append(x + y)",
"+print((int(sum(lst) / 2)))"
] | false | 0.046391 | 0.040292 | 1.151374 |
[
"s187837000",
"s568131627"
] |
u050103839
|
p02577
|
python
|
s643782921
|
s782072798
| 756 | 29 | 10,772 | 9,220 |
Accepted
|
Accepted
| 96.16 |
N = int(eval(input()))
if sum(int(i) for i in list(str(N))) % 9 == 0:
print('Yes')
else:
print('No')
|
N = str(eval(input()))
cnt = 0
for i in range(10):
cnt += i * N.count(str(i))
print(('Yes' if cnt % 9 == 0 else 'No'))
| 5 | 6 | 102 | 120 |
N = int(eval(input()))
if sum(int(i) for i in list(str(N))) % 9 == 0:
print("Yes")
else:
print("No")
|
N = str(eval(input()))
cnt = 0
for i in range(10):
cnt += i * N.count(str(i))
print(("Yes" if cnt % 9 == 0 else "No"))
| false | 16.666667 |
[
"-N = int(eval(input()))",
"-if sum(int(i) for i in list(str(N))) % 9 == 0:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+N = str(eval(input()))",
"+cnt = 0",
"+for i in range(10):",
"+ cnt += i * N.count(str(i))",
"+print((\"Yes\" if cnt % 9 == 0 else \"No\"))"
] | false | 0.035103 | 0.036322 | 0.966463 |
[
"s643782921",
"s782072798"
] |
u145231176
|
p02850
|
python
|
s486767993
|
s589331319
| 529 | 392 | 130,536 | 125,872 |
Accepted
|
Accepted
| 25.9 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = getN()
dist = [[] for i in range(N)]
edge = {}
for i in range(N - 1):
a, b = getNM()
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
# queryの何番目のエッジか
edge[(a - 1, b - 1)] = i
edge[(b - 1, a - 1)] = i
ignore = [-1] * N
ignore[0] = 0
ans = [0] * (N - 1)
pos = deque([0])
while len(pos) > 0:
u = pos.popleft()
j = 1
for i in dist[u]:
if ignore[i] < 0:
if j == ignore[u]:
j += 1
ignore[i] = j
ans[edge[(i, u)]] = j
pos.append(i)
j += 1
print((max(ans)))
for i in ans:
print(i)
|
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
N = getN()
dist = [[] for i in range(N)]
edges = {}
for i in range(N - 1):
a, b = getNM()
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
edges[(a - 1, b - 1)] = i
edges[(b - 1, a - 1)] = i
color = [-1] * N
color[0] = 0
ans = [0] * (N - 1)
pos = deque([0])
while pos:
u = pos.popleft()
j = 1
for i in dist[u]:
if color[i] != -1:
continue
if j == color[u]:
j += 1
color[i] = j
ans[edges[(i, u)]] = j
pos.append(i)
j += 1
print((max(ans)))
for i in ans:
print(i)
| 82 | 83 | 1,941 | 1,944 |
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
N = getN()
dist = [[] for i in range(N)]
edge = {}
for i in range(N - 1):
a, b = getNM()
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
# queryの何番目のエッジか
edge[(a - 1, b - 1)] = i
edge[(b - 1, a - 1)] = i
ignore = [-1] * N
ignore[0] = 0
ans = [0] * (N - 1)
pos = deque([0])
while len(pos) > 0:
u = pos.popleft()
j = 1
for i in dist[u]:
if ignore[i] < 0:
if j == ignore[u]:
j += 1
ignore[i] = j
ans[edge[(i, u)]] = j
pos.append(i)
j += 1
print((max(ans)))
for i in ans:
print(i)
|
def getN():
return int(eval(input()))
def getNM():
return list(map(int, input().split()))
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(eval(input())) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
from heapq import heapify, heappop, heappush
import math
import random
import string
from copy import deepcopy
from itertools import combinations, permutations, product
from operator import mul, itemgetter
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10**9 + 7
#############
# Main Code #
#############
N = getN()
dist = [[] for i in range(N)]
edges = {}
for i in range(N - 1):
a, b = getNM()
dist[a - 1].append(b - 1)
dist[b - 1].append(a - 1)
edges[(a - 1, b - 1)] = i
edges[(b - 1, a - 1)] = i
color = [-1] * N
color[0] = 0
ans = [0] * (N - 1)
pos = deque([0])
while pos:
u = pos.popleft()
j = 1
for i in dist[u]:
if color[i] != -1:
continue
if j == color[u]:
j += 1
color[i] = j
ans[edges[(i, u)]] = j
pos.append(i)
j += 1
print((max(ans)))
for i in ans:
print(i)
| false | 1.204819 |
[
"-import heapq",
"+from heapq import heapify, heappop, heappush",
"-from fractions import gcd",
"-import copy",
"+from copy import deepcopy",
"-from operator import mul",
"+from operator import mul, itemgetter",
"-edge = {}",
"+edges = {}",
"- # queryの何番目のエッジか",
"- edge[(a - 1, b - 1)] = i",
"- edge[(b - 1, a - 1)] = i",
"-ignore = [-1] * N",
"-ignore[0] = 0",
"+ edges[(a - 1, b - 1)] = i",
"+ edges[(b - 1, a - 1)] = i",
"+color = [-1] * N",
"+color[0] = 0",
"-while len(pos) > 0:",
"+while pos:",
"- if ignore[i] < 0:",
"- if j == ignore[u]:",
"- j += 1",
"- ignore[i] = j",
"- ans[edge[(i, u)]] = j",
"- pos.append(i)",
"+ if color[i] != -1:",
"+ continue",
"+ if j == color[u]:",
"+ color[i] = j",
"+ ans[edges[(i, u)]] = j",
"+ pos.append(i)",
"+ j += 1"
] | false | 0.045617 | 0.044386 | 1.027733 |
[
"s486767993",
"s589331319"
] |
u160414758
|
p03576
|
python
|
s531399124
|
s647111565
| 173 | 35 | 14,472 | 3,192 |
Accepted
|
Accepted
| 79.77 |
import math,heapq,collections,sys,numpy
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return eval(input())
N,K = LI()
p = []
for i in range(N):
a,b = LI()
p.append((a,b,i))
sx = sorted(p)
ans = 10**50
for x,y,i in sx:
for x2,y2,i2 in sx:
if x2 <= x:
continue
points = sx.index((x2,y2,i2)) - sx.index((x,y,i)) + 1
if points >= K:
sy2 = sorted(sx[sx.index((x,y,i)):sx.index((x2,y2,i2))+1],key=lambda sx: sx[1])
for j in range(len(sy2)-K+1):
if sy2[j][1] <= y and sy2[j+K-1][1] >= y2:
ans = min(ans, (x2 - x) * (sy2[j+K-1][1]-sy2[j][1]))
print(ans)
|
import sys
def LI(): return [int(x) for x in sys.stdin.readline().split()]
N,K = LI()
p = []
for i in range(N):
a,b = LI()
p.append((a,b,i))
sx = sorted(p)
ans = 10**50
for x,y,i in sx:
for x2,y2,i2 in sx:
if x2 <= x:
continue
points = sx.index((x2,y2,i2)) - sx.index((x,y,i)) + 1
if points < K:
continue
sy = sorted(sx[sx.index((x,y,i)):sx.index((x2,y2,i2))+1],key=lambda sx: sx[1])
for j in range(len(sy)-K+1):
if sy[j][1] <= y and y2 <= sy[j+K-1][1]:
ans = min(ans, (x2 - x) * (sy[j+K-1][1]-sy[j][1]))
print(ans)
| 29 | 22 | 1,009 | 643 |
import math, heapq, collections, sys, numpy
sys.setrecursionlimit(10**7)
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LI_():
return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def LS():
return sys.stdin.readline().split()
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def S():
return eval(input())
N, K = LI()
p = []
for i in range(N):
a, b = LI()
p.append((a, b, i))
sx = sorted(p)
ans = 10**50
for x, y, i in sx:
for x2, y2, i2 in sx:
if x2 <= x:
continue
points = sx.index((x2, y2, i2)) - sx.index((x, y, i)) + 1
if points >= K:
sy2 = sorted(
sx[sx.index((x, y, i)) : sx.index((x2, y2, i2)) + 1],
key=lambda sx: sx[1],
)
for j in range(len(sy2) - K + 1):
if sy2[j][1] <= y and sy2[j + K - 1][1] >= y2:
ans = min(ans, (x2 - x) * (sy2[j + K - 1][1] - sy2[j][1]))
print(ans)
|
import sys
def LI():
return [int(x) for x in sys.stdin.readline().split()]
N, K = LI()
p = []
for i in range(N):
a, b = LI()
p.append((a, b, i))
sx = sorted(p)
ans = 10**50
for x, y, i in sx:
for x2, y2, i2 in sx:
if x2 <= x:
continue
points = sx.index((x2, y2, i2)) - sx.index((x, y, i)) + 1
if points < K:
continue
sy = sorted(
sx[sx.index((x, y, i)) : sx.index((x2, y2, i2)) + 1], key=lambda sx: sx[1]
)
for j in range(len(sy) - K + 1):
if sy[j][1] <= y and y2 <= sy[j + K - 1][1]:
ans = min(ans, (x2 - x) * (sy[j + K - 1][1] - sy[j][1]))
print(ans)
| false | 24.137931 |
[
"-import math, heapq, collections, sys, numpy",
"-",
"-sys.setrecursionlimit(10**7)",
"+import sys",
"-",
"-",
"-def LI_():",
"- return [int(x) - 1 for x in sys.stdin.readline().split()]",
"-",
"-",
"-def LF():",
"- return [float(x) for x in sys.stdin.readline().split()]",
"-",
"-",
"-def LS():",
"- return sys.stdin.readline().split()",
"-",
"-",
"-def I():",
"- return int(sys.stdin.readline())",
"-",
"-",
"-def F():",
"- return float(sys.stdin.readline())",
"-",
"-",
"-def S():",
"- return eval(input())",
"- if points >= K:",
"- sy2 = sorted(",
"- sx[sx.index((x, y, i)) : sx.index((x2, y2, i2)) + 1],",
"- key=lambda sx: sx[1],",
"- )",
"- for j in range(len(sy2) - K + 1):",
"- if sy2[j][1] <= y and sy2[j + K - 1][1] >= y2:",
"- ans = min(ans, (x2 - x) * (sy2[j + K - 1][1] - sy2[j][1]))",
"+ if points < K:",
"+ continue",
"+ sy = sorted(",
"+ sx[sx.index((x, y, i)) : sx.index((x2, y2, i2)) + 1], key=lambda sx: sx[1]",
"+ )",
"+ for j in range(len(sy) - K + 1):",
"+ if sy[j][1] <= y and y2 <= sy[j + K - 1][1]:",
"+ ans = min(ans, (x2 - x) * (sy[j + K - 1][1] - sy[j][1]))"
] | false | 0.045114 | 0.045673 | 0.987759 |
[
"s531399124",
"s647111565"
] |
u820839927
|
p03037
|
python
|
s903081057
|
s912108982
| 563 | 377 | 45,160 | 3,316 |
Accepted
|
Accepted
| 33.04 |
import os, sys, re, math
N, M = [int(s) for s in input().split(' ')]
min_idx = 1
max_idx = 1e+5
for _ in range(M):
l,r = [int(s) for s in input().split(' ')]
min_idx = max(min_idx, l)
max_idx = min(max_idx, r)
if max_idx >= min_idx:
print((min(N, int(max_idx - min_idx + 1))))
else:
print((0))
|
import os, sys, re, math
N,M = list(map(int,input().split(' ')))
L = 1
R = N
for _ in range(M):
l,r = list(map(int,input().split(' ')))
L = max(L,l)
R = min(R,r)
ret = max(0, R-L+1)
print(ret)
| 15 | 14 | 327 | 212 |
import os, sys, re, math
N, M = [int(s) for s in input().split(" ")]
min_idx = 1
max_idx = 1e5
for _ in range(M):
l, r = [int(s) for s in input().split(" ")]
min_idx = max(min_idx, l)
max_idx = min(max_idx, r)
if max_idx >= min_idx:
print((min(N, int(max_idx - min_idx + 1))))
else:
print((0))
|
import os, sys, re, math
N, M = list(map(int, input().split(" ")))
L = 1
R = N
for _ in range(M):
l, r = list(map(int, input().split(" ")))
L = max(L, l)
R = min(R, r)
ret = max(0, R - L + 1)
print(ret)
| false | 6.666667 |
[
"-N, M = [int(s) for s in input().split(\" \")]",
"-min_idx = 1",
"-max_idx = 1e5",
"+N, M = list(map(int, input().split(\" \")))",
"+L = 1",
"+R = N",
"- l, r = [int(s) for s in input().split(\" \")]",
"- min_idx = max(min_idx, l)",
"- max_idx = min(max_idx, r)",
"-if max_idx >= min_idx:",
"- print((min(N, int(max_idx - min_idx + 1))))",
"-else:",
"- print((0))",
"+ l, r = list(map(int, input().split(\" \")))",
"+ L = max(L, l)",
"+ R = min(R, r)",
"+ret = max(0, R - L + 1)",
"+print(ret)"
] | false | 0.044667 | 0.042535 | 1.050121 |
[
"s903081057",
"s912108982"
] |
u228232845
|
p02727
|
python
|
s291243224
|
s596206288
| 414 | 182 | 52,908 | 29,844 |
Accepted
|
Accepted
| 56.04 |
# :20
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return eval(input())
def LS(): return input().split()
INF = float('inf')
x, y, a, b, c = LI()
p = sorted(LI())[::-1][:x]
q = sorted(LI())[::-1][:y]
r = sorted(LI())[::-1][:x+y]
# print(p, q, r)
bucket = []
bucket += [[i, 'p'] for i in p]
bucket += [[i, 'q'] for i in q]
bucket += [[i, 'r'] for i in r]
bucket = sorted(bucket, key=lambda x: x[0])
# print(bucket)
d = {'p': 0, 'q': 0}
ans = 0
cnt = 0
while cnt < x + y:
if bucket[-1][1] == 'p' and d[bucket[-1][1]] < x:
ans += bucket.pop()[0]
d['p'] += 1
cnt += 1
elif bucket[-1][1] == 'q' and d[bucket[-1][1]] < y:
ans += bucket.pop()[0]
d['q'] += 1
cnt += 1
else:
ans += bucket.pop()[0]
cnt += 1
print(ans)
|
# :20
import sys
def input(): return sys.stdin.readline().strip()
def I(): return int(eval(input()))
def LI(): return list(map(int, input().split()))
def IR(n): return [I() for i in range(n)]
def LIR(n): return [LI() for i in range(n)]
def SR(n): return [S() for i in range(n)]
def S(): return eval(input())
def LS(): return input().split()
INF = float('inf')
x, y, a, b, c = LI()
p = sorted(LI())[::-1][:x]
q = sorted(LI())[::-1][:y]
r = sorted(LI())[::-1][:x+y]
bucket = []
bucket += [i for i in p]
bucket += [i for i in q]
bucket += [i for i in r]
bucket = sorted(bucket)[::-1]
ans = sum(bucket[:x+y])
print(ans)
| 44 | 28 | 1,057 | 637 |
# :20
import sys
def input():
return sys.stdin.readline().strip()
def I():
return int(eval(input()))
def LI():
return list(map(int, input().split()))
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def S():
return eval(input())
def LS():
return input().split()
INF = float("inf")
x, y, a, b, c = LI()
p = sorted(LI())[::-1][:x]
q = sorted(LI())[::-1][:y]
r = sorted(LI())[::-1][: x + y]
# print(p, q, r)
bucket = []
bucket += [[i, "p"] for i in p]
bucket += [[i, "q"] for i in q]
bucket += [[i, "r"] for i in r]
bucket = sorted(bucket, key=lambda x: x[0])
# print(bucket)
d = {"p": 0, "q": 0}
ans = 0
cnt = 0
while cnt < x + y:
if bucket[-1][1] == "p" and d[bucket[-1][1]] < x:
ans += bucket.pop()[0]
d["p"] += 1
cnt += 1
elif bucket[-1][1] == "q" and d[bucket[-1][1]] < y:
ans += bucket.pop()[0]
d["q"] += 1
cnt += 1
else:
ans += bucket.pop()[0]
cnt += 1
print(ans)
|
# :20
import sys
def input():
return sys.stdin.readline().strip()
def I():
return int(eval(input()))
def LI():
return list(map(int, input().split()))
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def S():
return eval(input())
def LS():
return input().split()
INF = float("inf")
x, y, a, b, c = LI()
p = sorted(LI())[::-1][:x]
q = sorted(LI())[::-1][:y]
r = sorted(LI())[::-1][: x + y]
bucket = []
bucket += [i for i in p]
bucket += [i for i in q]
bucket += [i for i in r]
bucket = sorted(bucket)[::-1]
ans = sum(bucket[: x + y])
print(ans)
| false | 36.363636 |
[
"-# print(p, q, r)",
"-bucket += [[i, \"p\"] for i in p]",
"-bucket += [[i, \"q\"] for i in q]",
"-bucket += [[i, \"r\"] for i in r]",
"-bucket = sorted(bucket, key=lambda x: x[0])",
"-# print(bucket)",
"-d = {\"p\": 0, \"q\": 0}",
"-ans = 0",
"-cnt = 0",
"-while cnt < x + y:",
"- if bucket[-1][1] == \"p\" and d[bucket[-1][1]] < x:",
"- ans += bucket.pop()[0]",
"- d[\"p\"] += 1",
"- cnt += 1",
"- elif bucket[-1][1] == \"q\" and d[bucket[-1][1]] < y:",
"- ans += bucket.pop()[0]",
"- d[\"q\"] += 1",
"- cnt += 1",
"- else:",
"- ans += bucket.pop()[0]",
"- cnt += 1",
"+bucket += [i for i in p]",
"+bucket += [i for i in q]",
"+bucket += [i for i in r]",
"+bucket = sorted(bucket)[::-1]",
"+ans = sum(bucket[: x + y])"
] | false | 0.037949 | 0.037573 | 1.010001 |
[
"s291243224",
"s596206288"
] |
u588341295
|
p02734
|
python
|
s072292033
|
s056288947
| 1,119 | 858 | 246,792 | 50,140 |
Accepted
|
Accepted
| 23.32 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 998244353
N, S = MAP()
A = LIST()
# dp0[i][j] := i番目の要素まで見て、総和がjで、使う区間が未確定の状態の通り数
dp0 = list2d(N+1, S+1, 0)
# dp1[i][j] := i番目の要素まで見て、総和がjで、使う区間がL確定済の状態の通り数
dp1 = list2d(N+1, S+1, 0)
# dp2[i][j] := i番目の要素まで見て、総和がjで、使う区間がLR確定済の状態の通り数
dp2 = list2d(N+1, S+1, 0)
dp0[0][0] = 1
for i, a in enumerate(A):
for j in range(S+1):
# aを総和に足さない遷移は全部OK
dp0[i+1][j] += dp0[i][j]
dp1[i+1][j] += dp0[i][j] + dp1[i][j]
dp2[i+1][j] += dp0[i][j] + dp1[i][j] + dp2[i][j]
# aを総和に足す遷移は、遷移元が状態2と遷移先が状態0は無理
if j+a <= S:
dp1[i+1][j+a] += dp0[i][j] + dp1[i][j]
dp2[i+1][j+a] += dp0[i][j] + dp1[i][j]
dp0[i+1][j] %= MOD
dp1[i+1][j] %= MOD
dp2[i+1][j] %= MOD
ans = dp2[N][S]
print(ans)
|
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 998244353
N, S = MAP()
A = LIST()
dp0 = [0] * (S+1)
dp1 = [0] * (S+1)
dp2 = [0] * (S+1)
nxt0 = [0] * (S+1)
nxt1 = [0] * (S+1)
nxt2 = [0] * (S+1)
dp0[0] = 1
for i, a in enumerate(A):
for j in range(S+1):
# aを総和に足さない遷移は全部OK
nxt0[j] += dp0[j]
nxt1[j] += dp0[j] + dp1[j]
nxt2[j] += dp0[j] + dp1[j] + dp2[j]
# aを総和に足す遷移は、遷移元が状態2と遷移先が状態0は無理
if j+a <= S:
nxt1[j+a] += dp0[j] + dp1[j]
nxt2[j+a] += dp0[j] + dp1[j]
nxt0[j] %= MOD
nxt1[j] %= MOD
nxt2[j] %= MOD
dp0 = nxt0[:]
dp1 = nxt1[:]
dp2 = nxt2[:]
nxt0 = [0] * (S+1)
nxt1 = [0] * (S+1)
nxt2 = [0] * (S+1)
ans = dp2[S]
print(ans)
| 45 | 51 | 1,467 | 1,414 |
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 998244353
N, S = MAP()
A = LIST()
# dp0[i][j] := i番目の要素まで見て、総和がjで、使う区間が未確定の状態の通り数
dp0 = list2d(N + 1, S + 1, 0)
# dp1[i][j] := i番目の要素まで見て、総和がjで、使う区間がL確定済の状態の通り数
dp1 = list2d(N + 1, S + 1, 0)
# dp2[i][j] := i番目の要素まで見て、総和がjで、使う区間がLR確定済の状態の通り数
dp2 = list2d(N + 1, S + 1, 0)
dp0[0][0] = 1
for i, a in enumerate(A):
for j in range(S + 1):
# aを総和に足さない遷移は全部OK
dp0[i + 1][j] += dp0[i][j]
dp1[i + 1][j] += dp0[i][j] + dp1[i][j]
dp2[i + 1][j] += dp0[i][j] + dp1[i][j] + dp2[i][j]
# aを総和に足す遷移は、遷移元が状態2と遷移先が状態0は無理
if j + a <= S:
dp1[i + 1][j + a] += dp0[i][j] + dp1[i][j]
dp2[i + 1][j + a] += dp0[i][j] + dp1[i][j]
dp0[i + 1][j] %= MOD
dp1[i + 1][j] %= MOD
dp2[i + 1][j] %= MOD
ans = dp2[N][S]
print(ans)
|
# -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 998244353
N, S = MAP()
A = LIST()
dp0 = [0] * (S + 1)
dp1 = [0] * (S + 1)
dp2 = [0] * (S + 1)
nxt0 = [0] * (S + 1)
nxt1 = [0] * (S + 1)
nxt2 = [0] * (S + 1)
dp0[0] = 1
for i, a in enumerate(A):
for j in range(S + 1):
# aを総和に足さない遷移は全部OK
nxt0[j] += dp0[j]
nxt1[j] += dp0[j] + dp1[j]
nxt2[j] += dp0[j] + dp1[j] + dp2[j]
# aを総和に足す遷移は、遷移元が状態2と遷移先が状態0は無理
if j + a <= S:
nxt1[j + a] += dp0[j] + dp1[j]
nxt2[j + a] += dp0[j] + dp1[j]
nxt0[j] %= MOD
nxt1[j] %= MOD
nxt2[j] %= MOD
dp0 = nxt0[:]
dp1 = nxt1[:]
dp2 = nxt2[:]
nxt0 = [0] * (S + 1)
nxt1 = [0] * (S + 1)
nxt2 = [0] * (S + 1)
ans = dp2[S]
print(ans)
| false | 11.764706 |
[
"-# dp0[i][j] := i番目の要素まで見て、総和がjで、使う区間が未確定の状態の通り数",
"-dp0 = list2d(N + 1, S + 1, 0)",
"-# dp1[i][j] := i番目の要素まで見て、総和がjで、使う区間がL確定済の状態の通り数",
"-dp1 = list2d(N + 1, S + 1, 0)",
"-# dp2[i][j] := i番目の要素まで見て、総和がjで、使う区間がLR確定済の状態の通り数",
"-dp2 = list2d(N + 1, S + 1, 0)",
"-dp0[0][0] = 1",
"+dp0 = [0] * (S + 1)",
"+dp1 = [0] * (S + 1)",
"+dp2 = [0] * (S + 1)",
"+nxt0 = [0] * (S + 1)",
"+nxt1 = [0] * (S + 1)",
"+nxt2 = [0] * (S + 1)",
"+dp0[0] = 1",
"- dp0[i + 1][j] += dp0[i][j]",
"- dp1[i + 1][j] += dp0[i][j] + dp1[i][j]",
"- dp2[i + 1][j] += dp0[i][j] + dp1[i][j] + dp2[i][j]",
"+ nxt0[j] += dp0[j]",
"+ nxt1[j] += dp0[j] + dp1[j]",
"+ nxt2[j] += dp0[j] + dp1[j] + dp2[j]",
"- dp1[i + 1][j + a] += dp0[i][j] + dp1[i][j]",
"- dp2[i + 1][j + a] += dp0[i][j] + dp1[i][j]",
"- dp0[i + 1][j] %= MOD",
"- dp1[i + 1][j] %= MOD",
"- dp2[i + 1][j] %= MOD",
"-ans = dp2[N][S]",
"+ nxt1[j + a] += dp0[j] + dp1[j]",
"+ nxt2[j + a] += dp0[j] + dp1[j]",
"+ nxt0[j] %= MOD",
"+ nxt1[j] %= MOD",
"+ nxt2[j] %= MOD",
"+ dp0 = nxt0[:]",
"+ dp1 = nxt1[:]",
"+ dp2 = nxt2[:]",
"+ nxt0 = [0] * (S + 1)",
"+ nxt1 = [0] * (S + 1)",
"+ nxt2 = [0] * (S + 1)",
"+ans = dp2[S]"
] | false | 0.106223 | 0.044682 | 2.377285 |
[
"s072292033",
"s056288947"
] |
u057109575
|
p02606
|
python
|
s544420190
|
s740013518
| 84 | 61 | 61,484 | 61,704 |
Accepted
|
Accepted
| 27.38 |
l, r, d = list(map(int, input().split()))
print((r // d - -(-l // d) + 1))
|
L, R, d = list(map(int, input().split()))
print((R // d - (L - 1) // d))
| 3 | 4 | 70 | 70 |
l, r, d = list(map(int, input().split()))
print((r // d - -(-l // d) + 1))
|
L, R, d = list(map(int, input().split()))
print((R // d - (L - 1) // d))
| false | 25 |
[
"-l, r, d = list(map(int, input().split()))",
"-print((r // d - -(-l // d) + 1))",
"+L, R, d = list(map(int, input().split()))",
"+print((R // d - (L - 1) // d))"
] | false | 0.062266 | 0.064834 | 0.96038 |
[
"s544420190",
"s740013518"
] |
u977389981
|
p03262
|
python
|
s479445670
|
s308819938
| 156 | 117 | 14,252 | 14,224 |
Accepted
|
Accepted
| 25 |
n, x = list(map(int, input().split()))
A = sorted([int(i) for i in input().split()], reverse=True)
B = [abs(A[0] - x)]
for i in range(n-1):
B.append(A[i] - A[i+1])
def gcd(x, y):
while y > 0:
x, y = y, x % y
return x
for i in range(n-1):
B[i+1] = gcd(B[i], B[i+1])
print((B[-1]))
|
n, x = list(map(int, input().split()))
A = [int(i) for i in input().split()]
D = []
for i in range(n):
D.append(abs(x - A[i]))
def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
for i in range(n - 1):
D[i + 1] = gcd(D[i], D[i + 1])
print((D[-1]))
| 16 | 16 | 322 | 292 |
n, x = list(map(int, input().split()))
A = sorted([int(i) for i in input().split()], reverse=True)
B = [abs(A[0] - x)]
for i in range(n - 1):
B.append(A[i] - A[i + 1])
def gcd(x, y):
while y > 0:
x, y = y, x % y
return x
for i in range(n - 1):
B[i + 1] = gcd(B[i], B[i + 1])
print((B[-1]))
|
n, x = list(map(int, input().split()))
A = [int(i) for i in input().split()]
D = []
for i in range(n):
D.append(abs(x - A[i]))
def gcd(x, y):
while y != 0:
x, y = y, x % y
return x
for i in range(n - 1):
D[i + 1] = gcd(D[i], D[i + 1])
print((D[-1]))
| false | 0 |
[
"-A = sorted([int(i) for i in input().split()], reverse=True)",
"-B = [abs(A[0] - x)]",
"-for i in range(n - 1):",
"- B.append(A[i] - A[i + 1])",
"+A = [int(i) for i in input().split()]",
"+D = []",
"+for i in range(n):",
"+ D.append(abs(x - A[i]))",
"- while y > 0:",
"+ while y != 0:",
"- B[i + 1] = gcd(B[i], B[i + 1])",
"-print((B[-1]))",
"+ D[i + 1] = gcd(D[i], D[i + 1])",
"+print((D[-1]))"
] | false | 0.039103 | 0.041073 | 0.952041 |
[
"s479445670",
"s308819938"
] |
u761320129
|
p04035
|
python
|
s317497578
|
s125978978
| 122 | 104 | 14,668 | 14,052 |
Accepted
|
Accepted
| 14.75 |
N,L = list(map(int,input().split()))
src = list(map(int,input().split()))
for i,(a,b) in enumerate(zip(src, src[1:])):
if a+b >= L:
print('Possible')
for j in range(1,i+1): print(j)
for j in range(N-1,i,-1): print(j)
exit()
print('Impossible')
|
N,L = map(int,input().split())
A = list(map(int,input().split()))
for i,(a,b) in enumerate(zip(A,A[1:])):
if a+b >= L:
print('Possible')
break
else:
print('Impossible')
exit()
ans = []
for j in range(1,i+1):
ans.append(j)
for j in range(N-1,i+1,-1):
ans.append(j)
ans.append(i+1)
print(*ans, sep='\n')
| 10 | 17 | 284 | 354 |
N, L = list(map(int, input().split()))
src = list(map(int, input().split()))
for i, (a, b) in enumerate(zip(src, src[1:])):
if a + b >= L:
print("Possible")
for j in range(1, i + 1):
print(j)
for j in range(N - 1, i, -1):
print(j)
exit()
print("Impossible")
|
N, L = map(int, input().split())
A = list(map(int, input().split()))
for i, (a, b) in enumerate(zip(A, A[1:])):
if a + b >= L:
print("Possible")
break
else:
print("Impossible")
exit()
ans = []
for j in range(1, i + 1):
ans.append(j)
for j in range(N - 1, i + 1, -1):
ans.append(j)
ans.append(i + 1)
print(*ans, sep="\n")
| false | 41.176471 |
[
"-N, L = list(map(int, input().split()))",
"-src = list(map(int, input().split()))",
"-for i, (a, b) in enumerate(zip(src, src[1:])):",
"+N, L = map(int, input().split())",
"+A = list(map(int, input().split()))",
"+for i, (a, b) in enumerate(zip(A, A[1:])):",
"- for j in range(1, i + 1):",
"- print(j)",
"- for j in range(N - 1, i, -1):",
"- print(j)",
"- exit()",
"-print(\"Impossible\")",
"+ break",
"+else:",
"+ print(\"Impossible\")",
"+ exit()",
"+ans = []",
"+for j in range(1, i + 1):",
"+ ans.append(j)",
"+for j in range(N - 1, i + 1, -1):",
"+ ans.append(j)",
"+ans.append(i + 1)",
"+print(*ans, sep=\"\\n\")"
] | false | 0.041908 | 0.041417 | 1.011847 |
[
"s317497578",
"s125978978"
] |
u941407962
|
p03222
|
python
|
s894727183
|
s119649850
| 226 | 167 | 81,776 | 38,384 |
Accepted
|
Accepted
| 26.11 |
import sys
mod = pow(10, 9) + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (10**5) * 2
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def erabu(aW):
r = 0
for i in range(aW // 2 + 1 + 1):
sp = aW - (2*i -1)
r += cmb(sp+i+1-1, sp, mod)
return r
N, W, K = [int(x) for x in input().strip().split(" ")]
hasi = 0
cc = []
if W == 1:
if K == 1:
print((1))
else:
print((0))
sys.exit()
elif W == 2:
cccl = [1, 1]
cc = [1, 1]
elif W == 3:
cccl = [1, 1, 1]
cc = [2, 1, 2]
elif W >= 4:
aW = W - 1
hW = aW - 2
nhW = aW - 3
cc = []
cccl = []
for w in range(W):
nn = max(W - 1 - w - 1, 0)
nnn = max((W - 1) - nn - 2, 0)
if w == W -1:
nnn += 1
cc.append(erabu(nn) * erabu(nnn))
cccl.append(erabu(nn) * erabu(nnn-1))
cccl[0] = 0
cccr = cccl[::-1]
d = [1] + [0 for x in range(W-1)]
for i in range(N):
newd = []
for j in range(W):
newd.append(0)
if j != 0:
newd[j] = (newd[j] + (d[j-1] * cccl[j]) )% mod
if j != W-1:
newd[j] = (newd[j] + (d[j+1] * cccr[j])) % mod
newd[j] = (newd[j] + (d[j] * cc[j])) % mod
d = newd[:]
print((d[K-1]))
|
import sys
mod = pow(10, 9) + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
NNN = (10**2)
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range( 2, NNN + 1 ):
g1.append( ( g1[-1] * i ) % mod )
inverse.append( ( -inverse[mod % i] * (mod//i) ) % mod )
g2.append( (g2[-1] * inverse[-1]) % mod )
def erabu(aW):
r = 0
for i in range(aW // 2 + 1 + 1):
sp = aW - (2*i -1)
r += cmb(sp+i+1-1, sp, mod)
return r
N, W, K = [int(x) for x in input().strip().split(" ")]
hasi = 0
cc = []
if W == 1:
if K == 1:
print((1))
else:
print((0))
sys.exit()
elif W == 2:
cccl = [1, 1]
cc = [1, 1]
elif W == 3:
cccl = [1, 1, 1]
cc = [2, 1, 2]
elif W >= 4:
aW = W - 1
hW = aW - 2
nhW = aW - 3
cc = []
cccl = []
for w in range(W):
nn = max(W - 1 - w - 1, 0)
nnn = max((W - 1) - nn - 2, 0)
if w == W -1:
nnn += 1
cc.append(erabu(nn) * erabu(nnn))
cccl.append(erabu(nn) * erabu(nnn-1))
cccl[0] = 0
cccr = cccl[::-1]
d = [1] + [0 for x in range(W-1)]
for i in range(N):
newd = []
for j in range(W):
newd.append(0)
if j != 0:
newd[j] = (newd[j] + (d[j-1] * cccl[j]) )% mod
if j != W-1:
newd[j] = (newd[j] + (d[j+1] * cccr[j])) % mod
newd[j] = (newd[j] + (d[j] * cc[j])) % mod
d = newd[:]
print((d[K-1]))
| 73 | 73 | 1,615 | 1,611 |
import sys
mod = pow(10, 9) + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
NNN = (10**5) * 2
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, NNN + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def erabu(aW):
r = 0
for i in range(aW // 2 + 1 + 1):
sp = aW - (2 * i - 1)
r += cmb(sp + i + 1 - 1, sp, mod)
return r
N, W, K = [int(x) for x in input().strip().split(" ")]
hasi = 0
cc = []
if W == 1:
if K == 1:
print((1))
else:
print((0))
sys.exit()
elif W == 2:
cccl = [1, 1]
cc = [1, 1]
elif W == 3:
cccl = [1, 1, 1]
cc = [2, 1, 2]
elif W >= 4:
aW = W - 1
hW = aW - 2
nhW = aW - 3
cc = []
cccl = []
for w in range(W):
nn = max(W - 1 - w - 1, 0)
nnn = max((W - 1) - nn - 2, 0)
if w == W - 1:
nnn += 1
cc.append(erabu(nn) * erabu(nnn))
cccl.append(erabu(nn) * erabu(nnn - 1))
cccl[0] = 0
cccr = cccl[::-1]
d = [1] + [0 for x in range(W - 1)]
for i in range(N):
newd = []
for j in range(W):
newd.append(0)
if j != 0:
newd[j] = (newd[j] + (d[j - 1] * cccl[j])) % mod
if j != W - 1:
newd[j] = (newd[j] + (d[j + 1] * cccr[j])) % mod
newd[j] = (newd[j] + (d[j] * cc[j])) % mod
d = newd[:]
print((d[K - 1]))
|
import sys
mod = pow(10, 9) + 7
def mul(a, b):
return ((a % mod) * (b % mod)) % mod
def cmb(n, r, mod):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
NNN = 10**2
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, NNN + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
def erabu(aW):
r = 0
for i in range(aW // 2 + 1 + 1):
sp = aW - (2 * i - 1)
r += cmb(sp + i + 1 - 1, sp, mod)
return r
N, W, K = [int(x) for x in input().strip().split(" ")]
hasi = 0
cc = []
if W == 1:
if K == 1:
print((1))
else:
print((0))
sys.exit()
elif W == 2:
cccl = [1, 1]
cc = [1, 1]
elif W == 3:
cccl = [1, 1, 1]
cc = [2, 1, 2]
elif W >= 4:
aW = W - 1
hW = aW - 2
nhW = aW - 3
cc = []
cccl = []
for w in range(W):
nn = max(W - 1 - w - 1, 0)
nnn = max((W - 1) - nn - 2, 0)
if w == W - 1:
nnn += 1
cc.append(erabu(nn) * erabu(nnn))
cccl.append(erabu(nn) * erabu(nnn - 1))
cccl[0] = 0
cccr = cccl[::-1]
d = [1] + [0 for x in range(W - 1)]
for i in range(N):
newd = []
for j in range(W):
newd.append(0)
if j != 0:
newd[j] = (newd[j] + (d[j - 1] * cccl[j])) % mod
if j != W - 1:
newd[j] = (newd[j] + (d[j + 1] * cccr[j])) % mod
newd[j] = (newd[j] + (d[j] * cc[j])) % mod
d = newd[:]
print((d[K - 1]))
| false | 0 |
[
"-NNN = (10**5) * 2",
"+NNN = 10**2"
] | false | 0.807032 | 0.037363 | 21.599967 |
[
"s894727183",
"s119649850"
] |
u408260374
|
p00775
|
python
|
s654109422
|
s231456334
| 110 | 60 | 7,684 | 7,640 |
Accepted
|
Accepted
| 45.45 |
while True:
R, N = list(map(int, input().split()))
if not (R | N):
break
geta = 20
buildings = [0] * (geta * 2)
for _ in range(N):
xl, xr, h = list(map(int, input().split()))
for i in range(xl + geta, xr + geta):
buildings[i] = max(buildings[i], h)
sun = [0] * (geta * 2)
for i in range(-R + geta, R + geta):
if i < geta:
buildings[i] -= pow(R * R - (i - geta + 1) * (i - geta + 1), 0.5) - R
else:
buildings[i] -= pow(R * R - (i - geta) * (i - geta), 0.5) - R
left, right = 0, 20
while right - left > 1e-4:
mid = (left + right) / 2
flag = True
for i in range(-R + geta, R + geta):
if i < geta:
flag &= buildings[i] >= mid
else:
y = pow(R * R - (i - geta) * (i - geta), 0.5)
flag &= buildings[i] >= mid
if flag:
left = mid
else:
right = mid
print(("{:.20f}".format(left)))
|
while True:
R, N = list(map(int, input().split()))
if not (R | N):
break
geta = 20
buildings = [0] * (geta * 2)
for _ in range(N):
xl, xr, h = list(map(int, input().split()))
for i in range(xl + geta, xr + geta):
buildings[i] = max(buildings[i], h)
ans = 20
for i in range(-R + geta, R + geta):
if i < geta:
buildings[i] -= pow(R * R - (i - geta + 1) * (i - geta + 1), 0.5) - R
else:
buildings[i] -= pow(R * R - (i - geta) * (i - geta), 0.5) - R
ans = min(ans, buildings[i])
print(ans)
| 34 | 19 | 1,045 | 608 |
while True:
R, N = list(map(int, input().split()))
if not (R | N):
break
geta = 20
buildings = [0] * (geta * 2)
for _ in range(N):
xl, xr, h = list(map(int, input().split()))
for i in range(xl + geta, xr + geta):
buildings[i] = max(buildings[i], h)
sun = [0] * (geta * 2)
for i in range(-R + geta, R + geta):
if i < geta:
buildings[i] -= pow(R * R - (i - geta + 1) * (i - geta + 1), 0.5) - R
else:
buildings[i] -= pow(R * R - (i - geta) * (i - geta), 0.5) - R
left, right = 0, 20
while right - left > 1e-4:
mid = (left + right) / 2
flag = True
for i in range(-R + geta, R + geta):
if i < geta:
flag &= buildings[i] >= mid
else:
y = pow(R * R - (i - geta) * (i - geta), 0.5)
flag &= buildings[i] >= mid
if flag:
left = mid
else:
right = mid
print(("{:.20f}".format(left)))
|
while True:
R, N = list(map(int, input().split()))
if not (R | N):
break
geta = 20
buildings = [0] * (geta * 2)
for _ in range(N):
xl, xr, h = list(map(int, input().split()))
for i in range(xl + geta, xr + geta):
buildings[i] = max(buildings[i], h)
ans = 20
for i in range(-R + geta, R + geta):
if i < geta:
buildings[i] -= pow(R * R - (i - geta + 1) * (i - geta + 1), 0.5) - R
else:
buildings[i] -= pow(R * R - (i - geta) * (i - geta), 0.5) - R
ans = min(ans, buildings[i])
print(ans)
| false | 44.117647 |
[
"- sun = [0] * (geta * 2)",
"+ ans = 20",
"- left, right = 0, 20",
"- while right - left > 1e-4:",
"- mid = (left + right) / 2",
"- flag = True",
"- for i in range(-R + geta, R + geta):",
"- if i < geta:",
"- flag &= buildings[i] >= mid",
"- else:",
"- y = pow(R * R - (i - geta) * (i - geta), 0.5)",
"- flag &= buildings[i] >= mid",
"- if flag:",
"- left = mid",
"- else:",
"- right = mid",
"- print((\"{:.20f}\".format(left)))",
"+ ans = min(ans, buildings[i])",
"+ print(ans)"
] | false | 0.048113 | 0.047542 | 1.011997 |
[
"s654109422",
"s231456334"
] |
u433532588
|
p03162
|
python
|
s420331505
|
s594575492
| 909 | 509 | 51,904 | 36,168 |
Accepted
|
Accepted
| 44 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
N = int(eval(input()))
# 「翌日の値をセット」しているので、最終日+1日まで入る関係で+1
dp = [ [0 for _ in range(3)] for _ in range(N+1) ]
#print(dp)
ABC = [[]] * N
for i in range(N):
x = list(map(int, input().split()))
ABC[i] = x
#print(ABC)
# i日目
for i in range(N):
'''
j k
dp[ i ][ 0 ] から dp[ i + 1 ][ 0 ] はcontinue(以下略）
dp[ i ][ 0 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
dp[ i ][ 0 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 1 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 1 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 2 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 2 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
'''
# i日目の選択肢
for j in range(3):
# i+1日目の選択肢
for k in range(3):
# 翌日が今日と同じならパス
if j == k:
continue
### 配るdp
# 翌日の活動kと、今日の幸福度+選択した活動を比較
dp[i+1][k] = max(dp[i+1][k], dp[i][j]+ABC[i][k])
ans = 0
for i in range(3):
ans = max(ans, dp[N][i])
print(ans)
|
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()))
A = []
B = []
C = []
for i in range(N):
a, b, c = list(map(int, input().split()))
A.append(a)
B.append(b)
C.append(c)
dp = [ [0 for _ in range(3)] for _ in range(N+1) ]
for i in range(1, N+1):
dp[i][0] = max(dp[i-1][1]+B[i-1], dp[i-1][2]+C[i-1])
dp[i][1] = max(dp[i-1][0]+A[i-1], dp[i-1][2]+C[i-1])
dp[i][2] = max(dp[i-1][0]+A[i-1], dp[i-1][1]+B[i-1])
print((max(dp[N])))
| 50 | 27 | 1,168 | 613 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
N = int(eval(input()))
# 「翌日の値をセット」しているので、最終日+1日まで入る関係で+1
dp = [[0 for _ in range(3)] for _ in range(N + 1)]
# print(dp)
ABC = [[]] * N
for i in range(N):
x = list(map(int, input().split()))
ABC[i] = x
# print(ABC)
# i日目
for i in range(N):
"""
j k
dp[ i ][ 0 ] から dp[ i + 1 ][ 0 ] はcontinue(以下略）
dp[ i ][ 0 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
dp[ i ][ 0 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 1 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 1 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])
dp[ i ][ 2 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])
dp[ i ][ 2 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])
"""
# i日目の選択肢
for j in range(3):
# i+1日目の選択肢
for k in range(3):
# 翌日が今日と同じならパス
if j == k:
continue
### 配るdp
# 翌日の活動kと、今日の幸福度+選択した活動を比較
dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + ABC[i][k])
ans = 0
for i in range(3):
ans = max(ans, dp[N][i])
print(ans)
|
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()))
A = []
B = []
C = []
for i in range(N):
a, b, c = list(map(int, input().split()))
A.append(a)
B.append(b)
C.append(c)
dp = [[0 for _ in range(3)] for _ in range(N + 1)]
for i in range(1, N + 1):
dp[i][0] = max(dp[i - 1][1] + B[i - 1], dp[i - 1][2] + C[i - 1])
dp[i][1] = max(dp[i - 1][0] + A[i - 1], dp[i - 1][2] + C[i - 1])
dp[i][2] = max(dp[i - 1][0] + A[i - 1], dp[i - 1][1] + B[i - 1])
print((max(dp[N])))
| false | 46 |
[
"-sys.setrecursionlimit(10**6)",
"+sys.setrecursionlimit(2147483647)",
"+INF = float(\"inf\")",
"+MOD = 10**9 + 7",
"+# A = [ int(input()) for _ in range(N) ]",
"-# 「翌日の値をセット」しているので、最終日+1日まで入る関係で+1",
"+A = []",
"+B = []",
"+C = []",
"+for i in range(N):",
"+ a, b, c = list(map(int, input().split()))",
"+ A.append(a)",
"+ B.append(b)",
"+ C.append(c)",
"-# print(dp)",
"-ABC = [[]] * N",
"-for i in range(N):",
"- x = list(map(int, input().split()))",
"- ABC[i] = x",
"-# print(ABC)",
"-# i日目",
"-for i in range(N):",
"- \"\"\"",
"- j k",
"- dp[ i ][ 0 ] から dp[ i + 1 ][ 0 ] はcontinue(以下略）",
"- dp[ i ][ 0 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])",
"- dp[ i ][ 0 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])",
"- dp[ i ][ 1 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])",
"- dp[ i ][ 1 ] から dp[ i + 1 ][ 2 ] への遷移(ABC[i][2])",
"- dp[ i ][ 2 ] から dp[ i + 1 ][ 0 ] への遷移(ABC[i][0])",
"- dp[ i ][ 2 ] から dp[ i + 1 ][ 1 ] への遷移(ABC[i][1])",
"- \"\"\"",
"- # i日目の選択肢",
"- for j in range(3):",
"- # i+1日目の選択肢",
"- for k in range(3):",
"- # 翌日が今日と同じならパス",
"- if j == k:",
"- continue",
"- ### 配るdp",
"- # 翌日の活動kと、今日の幸福度+選択した活動を比較",
"- dp[i + 1][k] = max(dp[i + 1][k], dp[i][j] + ABC[i][k])",
"-ans = 0",
"-for i in range(3):",
"- ans = max(ans, dp[N][i])",
"-print(ans)",
"+for i in range(1, N + 1):",
"+ dp[i][0] = max(dp[i - 1][1] + B[i - 1], dp[i - 1][2] + C[i - 1])",
"+ dp[i][1] = max(dp[i - 1][0] + A[i - 1], dp[i - 1][2] + C[i - 1])",
"+ dp[i][2] = max(dp[i - 1][0] + A[i - 1], dp[i - 1][1] + B[i - 1])",
"+print((max(dp[N])))"
] | false | 0.121177 | 0.038211 | 3.171236 |
[
"s420331505",
"s594575492"
] |
u546285759
|
p00219
|
python
|
s018820385
|
s845608423
| 120 | 110 | 7,784 | 7,712 |
Accepted
|
Accepted
| 8.33 |
while True:
n = int(eval(input()))
if n == 0:
break
ice = [int(eval(input())) for _ in range(n)]
for i in range(10):
print(("*"*ice.count(i) + "-"*(ice.count(i)==0)))
|
while True:
n = int(eval(input()))
if n == 0:
break
ice = [int(eval(input())) for _ in range(n)]
for i in range(10):
nums = ice.count(i)
print(("*"*nums + "-"*(nums==0)))
| 8 | 9 | 192 | 205 |
while True:
n = int(eval(input()))
if n == 0:
break
ice = [int(eval(input())) for _ in range(n)]
for i in range(10):
print(("*" * ice.count(i) + "-" * (ice.count(i) == 0)))
|
while True:
n = int(eval(input()))
if n == 0:
break
ice = [int(eval(input())) for _ in range(n)]
for i in range(10):
nums = ice.count(i)
print(("*" * nums + "-" * (nums == 0)))
| false | 11.111111 |
[
"- print((\"*\" * ice.count(i) + \"-\" * (ice.count(i) == 0)))",
"+ nums = ice.count(i)",
"+ print((\"*\" * nums + \"-\" * (nums == 0)))"
] | false | 0.032296 | 0.037661 | 0.857528 |
[
"s018820385",
"s845608423"
] |
u690536347
|
p03152
|
python
|
s370819312
|
s417505922
| 263 | 240 | 41,968 | 42,096 |
Accepted
|
Accepted
| 8.75 |
from collections import Counter
import sys
input=sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in range(N):
for j in range(M):
if A[i]==B[j]:
if A[i] in used:
print((0))
return
else:
used.add(A[i])
c[min(A[i], B[j])] += 1
cd = 0
ans = 1
bef = 0
for i, j in sorted(c.items()):
cd += (i - bef)
if i not in used:
ans *= j
cd -= 1
for k in range(j-1):
ans *= (cd-k)
ans %= MOD
cd -= j-1
bef = i
print((ans%MOD))
if __name__ == "__main__":
solve()
|
from collections import Counter
import sys
input=sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
*A, = list(map(int, input().split()))
*B, = list(map(int, input().split()))
c = Counter()
MOD = 10**9+7
used = set()
for i in A:
for j in B:
if i==j:
if i in used:
print((0))
return
else:
used.add(i)
c[min(i, j)] += 1
v, ans, bef = 0, 1, 0
for i, j in sorted(c.items()):
ans *= 1 if i in used else j
v += i-bef-1
for k in range(j-1):
ans *= v-k
ans %= MOD
v -= j-1
bef = i
print(ans)
if __name__ == "__main__":
solve()
| 41 | 37 | 875 | 793 |
from collections import Counter
import sys
input = sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
(*B,) = list(map(int, input().split()))
c = Counter()
MOD = 10**9 + 7
used = set()
for i in range(N):
for j in range(M):
if A[i] == B[j]:
if A[i] in used:
print((0))
return
else:
used.add(A[i])
c[min(A[i], B[j])] += 1
cd = 0
ans = 1
bef = 0
for i, j in sorted(c.items()):
cd += i - bef
if i not in used:
ans *= j
cd -= 1
for k in range(j - 1):
ans *= cd - k
ans %= MOD
cd -= j - 1
bef = i
print((ans % MOD))
if __name__ == "__main__":
solve()
|
from collections import Counter
import sys
input = sys.stdin.readline
def solve():
N, M = list(map(int, input().split()))
(*A,) = list(map(int, input().split()))
(*B,) = list(map(int, input().split()))
c = Counter()
MOD = 10**9 + 7
used = set()
for i in A:
for j in B:
if i == j:
if i in used:
print((0))
return
else:
used.add(i)
c[min(i, j)] += 1
v, ans, bef = 0, 1, 0
for i, j in sorted(c.items()):
ans *= 1 if i in used else j
v += i - bef - 1
for k in range(j - 1):
ans *= v - k
ans %= MOD
v -= j - 1
bef = i
print(ans)
if __name__ == "__main__":
solve()
| false | 9.756098 |
[
"- for i in range(N):",
"- for j in range(M):",
"- if A[i] == B[j]:",
"- if A[i] in used:",
"+ for i in A:",
"+ for j in B:",
"+ if i == j:",
"+ if i in used:",
"- used.add(A[i])",
"- c[min(A[i], B[j])] += 1",
"- cd = 0",
"- ans = 1",
"- bef = 0",
"+ used.add(i)",
"+ c[min(i, j)] += 1",
"+ v, ans, bef = 0, 1, 0",
"- cd += i - bef",
"- if i not in used:",
"- ans *= j",
"- cd -= 1",
"+ ans *= 1 if i in used else j",
"+ v += i - bef - 1",
"- ans *= cd - k",
"+ ans *= v - k",
"- cd -= j - 1",
"+ v -= j - 1",
"- print((ans % MOD))",
"+ print(ans)"
] | false | 0.035159 | 0.036037 | 0.975624 |
[
"s370819312",
"s417505922"
] |
u150984829
|
p00448
|
python
|
s913232504
|
s898192270
| 4,230 | 3,660 | 6,924 | 6,912 |
Accepted
|
Accepted
| 13.48 |
def v():
for e in iter(input,'0 0'):
r=int(e.split()[0])
d=[int(''.join(x),2)for x in zip(*[input().split()for _ in[0]*r])]
a=0
for m in range(1<<~-r):
t=0
for s in d:
c=bin(m^s).count('1')
t+=c if c>r/2 else r-c
if a<t:a=t
print(a)
if'__main__'==__name__:v()
|
def v():
for e in iter(input,'0 0'):
r=int(e.split()[0])
d=[int(''.join(x),2)for x in zip(*[input().split()for _ in[0]*r])]
a=0
for m in range(1<<~-r):
t=0
for s in d:
c=bin(m^s).count('1')
t+=c if c>r//2 else r-c
if a<t:a=t
print(a)
if'__main__'==__name__:v()
| 13 | 13 | 300 | 301 |
def v():
for e in iter(input, "0 0"):
r = int(e.split()[0])
d = [int("".join(x), 2) for x in zip(*[input().split() for _ in [0] * r])]
a = 0
for m in range(1 << ~-r):
t = 0
for s in d:
c = bin(m ^ s).count("1")
t += c if c > r / 2 else r - c
if a < t:
a = t
print(a)
if "__main__" == __name__:
v()
|
def v():
for e in iter(input, "0 0"):
r = int(e.split()[0])
d = [int("".join(x), 2) for x in zip(*[input().split() for _ in [0] * r])]
a = 0
for m in range(1 << ~-r):
t = 0
for s in d:
c = bin(m ^ s).count("1")
t += c if c > r // 2 else r - c
if a < t:
a = t
print(a)
if "__main__" == __name__:
v()
| false | 0 |
[
"- t += c if c > r / 2 else r - c",
"+ t += c if c > r // 2 else r - c"
] | false | 0.039981 | 0.041814 | 0.956159 |
[
"s913232504",
"s898192270"
] |
u673361376
|
p03031
|
python
|
s303463099
|
s709247151
| 206 | 23 | 41,456 | 3,064 |
Accepted
|
Accepted
| 88.83 |
N,M = list(map(int, input().split()))
S = []
for _ in range(M):
s_list = ['0' for _ in range(N)]
for s in list(map(int, input().split()))[1:]:s_list[s-1] = '1'
S.append(int(''.join(s_list),2))
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
flag = True
for idx, s in enumerate(S):
if bin(i&s)[2:].count('1')%2 != P[idx]:
flag = False
break
if flag is True: ans += 1
print(ans)
|
def is_all_switches_on(on_case):
for i, s in enumerate(S):
on_switch_num = 0
for si in s:
if on_case[si] == '1':
on_switch_num += 1
if on_switch_num % 2 != switches[i]:
return False
return True
if __name__ == '__main__':
N, M = list(map(int, input().split()))
S = []
for _ in range(M):
k, *s = list(map(int, input().split()))
S.append(s)
switches = list(map(int, input().split()))
ans = 0
for i in range(2 ** N):
on_case = '0' + bin(i)[2:].zfill(N)
if is_all_switches_on(on_case):
ans += 1
print(ans)
| 17 | 27 | 433 | 663 |
N, M = list(map(int, input().split()))
S = []
for _ in range(M):
s_list = ["0" for _ in range(N)]
for s in list(map(int, input().split()))[1:]:
s_list[s - 1] = "1"
S.append(int("".join(s_list), 2))
P = list(map(int, input().split()))
ans = 0
for i in range(2**N):
flag = True
for idx, s in enumerate(S):
if bin(i & s)[2:].count("1") % 2 != P[idx]:
flag = False
break
if flag is True:
ans += 1
print(ans)
|
def is_all_switches_on(on_case):
for i, s in enumerate(S):
on_switch_num = 0
for si in s:
if on_case[si] == "1":
on_switch_num += 1
if on_switch_num % 2 != switches[i]:
return False
return True
if __name__ == "__main__":
N, M = list(map(int, input().split()))
S = []
for _ in range(M):
k, *s = list(map(int, input().split()))
S.append(s)
switches = list(map(int, input().split()))
ans = 0
for i in range(2**N):
on_case = "0" + bin(i)[2:].zfill(N)
if is_all_switches_on(on_case):
ans += 1
print(ans)
| false | 37.037037 |
[
"-N, M = list(map(int, input().split()))",
"-S = []",
"-for _ in range(M):",
"- s_list = [\"0\" for _ in range(N)]",
"- for s in list(map(int, input().split()))[1:]:",
"- s_list[s - 1] = \"1\"",
"- S.append(int(\"\".join(s_list), 2))",
"-P = list(map(int, input().split()))",
"-ans = 0",
"-for i in range(2**N):",
"- flag = True",
"- for idx, s in enumerate(S):",
"- if bin(i & s)[2:].count(\"1\") % 2 != P[idx]:",
"- flag = False",
"- break",
"- if flag is True:",
"- ans += 1",
"-print(ans)",
"+def is_all_switches_on(on_case):",
"+ for i, s in enumerate(S):",
"+ on_switch_num = 0",
"+ for si in s:",
"+ if on_case[si] == \"1\":",
"+ on_switch_num += 1",
"+ if on_switch_num % 2 != switches[i]:",
"+ return False",
"+ return True",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ N, M = list(map(int, input().split()))",
"+ S = []",
"+ for _ in range(M):",
"+ k, *s = list(map(int, input().split()))",
"+ S.append(s)",
"+ switches = list(map(int, input().split()))",
"+ ans = 0",
"+ for i in range(2**N):",
"+ on_case = \"0\" + bin(i)[2:].zfill(N)",
"+ if is_all_switches_on(on_case):",
"+ ans += 1",
"+ print(ans)"
] | false | 0.218614 | 0.037617 | 5.811609 |
[
"s303463099",
"s709247151"
] |
u912237403
|
p00134
|
python
|
s504562833
|
s647206599
| 90 | 20 | 4,424 | 4,256 |
Accepted
|
Accepted
| 77.78 |
x = []
for _ in [0] * eval(input()):
x.append(eval(input()))
print(sum(x)/len(x))
|
x = 0
n = int(input())
for _ in [0] * n:
x += int(input())
print(x/n)
| 4 | 5 | 73 | 82 |
x = []
for _ in [0] * eval(input()):
x.append(eval(input()))
print(sum(x) / len(x))
|
x = 0
n = int(input())
for _ in [0] * n:
x += int(input())
print(x / n)
| false | 20 |
[
"-x = []",
"-for _ in [0] * eval(input()):",
"- x.append(eval(input()))",
"-print(sum(x) / len(x))",
"+x = 0",
"+n = int(input())",
"+for _ in [0] * n:",
"+ x += int(input())",
"+print(x / n)"
] | false | 0.071789 | 0.036818 | 1.949863 |
[
"s504562833",
"s647206599"
] |
u077291787
|
p03880
|
python
|
s995276463
|
s183098447
| 141 | 127 | 14,264 | 7,484 |
Accepted
|
Accepted
| 9.93 |
# cf16-exhibition-final-openC - Cheating Nim
import sys
input = sys.stdin.readline
def main():
# player is second move -> make xor 0
N = int(eval(input()))
A = sorted(map(int, [eval(input()) for _ in range(N)]), reverse=1)
ans, x, flg = 0, 0, [0] * 30
for i in A:
x ^= i
p = bin(i ^ i - 1)[::-1].rfind("1")
flg[p] = 1
for i in range(29, -1, -1):
p = 2 ** i
if x & p: # i-th bit is on
if flg[i]: # possible to erase i-th bit of x
x ^= p - 1
ans += 1
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main()
|
# cf16-exhibition-final-openC - Cheating Nim
def main():
# player is second move -> make xor 0
N, *A = list(map(int, open(0)))
A.sort(reverse=1)
ans, x, flg = 0, 0, [0] * 30
for i in A:
x ^= i
p = bin(i ^ i - 1)[::-1].rfind("1") # rightmost bits of i^i-1
flg[p] = 1
for i in range(29, -1, -1):
p = 2 ** i
if x & p: # i-th bit is on
if flg[i]: # possible to erase i-th bit of x
x ^= p - 1
ans += 1
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main()
| 28 | 24 | 697 | 646 |
# cf16-exhibition-final-openC - Cheating Nim
import sys
input = sys.stdin.readline
def main():
# player is second move -> make xor 0
N = int(eval(input()))
A = sorted(map(int, [eval(input()) for _ in range(N)]), reverse=1)
ans, x, flg = 0, 0, [0] * 30
for i in A:
x ^= i
p = bin(i ^ i - 1)[::-1].rfind("1")
flg[p] = 1
for i in range(29, -1, -1):
p = 2**i
if x & p: # i-th bit is on
if flg[i]: # possible to erase i-th bit of x
x ^= p - 1
ans += 1
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main()
|
# cf16-exhibition-final-openC - Cheating Nim
def main():
# player is second move -> make xor 0
N, *A = list(map(int, open(0)))
A.sort(reverse=1)
ans, x, flg = 0, 0, [0] * 30
for i in A:
x ^= i
p = bin(i ^ i - 1)[::-1].rfind("1") # rightmost bits of i^i-1
flg[p] = 1
for i in range(29, -1, -1):
p = 2**i
if x & p: # i-th bit is on
if flg[i]: # possible to erase i-th bit of x
x ^= p - 1
ans += 1
else:
print((-1))
return
print(ans)
if __name__ == "__main__":
main()
| false | 14.285714 |
[
"-import sys",
"-",
"-input = sys.stdin.readline",
"-",
"-",
"- N = int(eval(input()))",
"- A = sorted(map(int, [eval(input()) for _ in range(N)]), reverse=1)",
"+ N, *A = list(map(int, open(0)))",
"+ A.sort(reverse=1)",
"- p = bin(i ^ i - 1)[::-1].rfind(\"1\")",
"+ p = bin(i ^ i - 1)[::-1].rfind(\"1\") # rightmost bits of i^i-1"
] | false | 0.078747 | 0.040676 | 1.935922 |
[
"s995276463",
"s183098447"
] |
u869790980
|
p03828
|
python
|
s530058290
|
s237320626
| 368 | 146 | 85,796 | 72,128 |
Accepted
|
Accepted
| 60.33 |
import collections
n = int(input())
mod = ( 10 ** 9 ) + 7
def f(u):
cu = collections.Counter()
cur = 2
while(u != 1):
if u % cur == 0:
while(u % cur == 0):
cc[cur] +=1
u/= cur
cur +=1
return cu
cc = collections.Counter()
for u in range(2, n + 1):
cu = f(u)
for k in cu: cc[k]+=cu[k]
ans = 1
for k in cc:
ans *= (cc[k] + 1)
ans %= mod
print(ans)
|
import collections
n = int(input())
mod = ( 10 ** 9 ) + 7
def f(u):
cu = collections.Counter()
cur = 2
while(u != 1):
if u % cur == 0:
while(u % cur == 0):
cc[cur] +=1
u/= cur
cur +=1
return cu
cc = collections.Counter()
for u in range(2, n + 1):
for k,v in f(u).items(): cc[k]+=cu[k]
ans = 1
for k in cc:
ans *= (cc[k] + 1)
ans %= mod
print(ans)
| 22 | 21 | 392 | 396 |
import collections
n = int(input())
mod = (10**9) + 7
def f(u):
cu = collections.Counter()
cur = 2
while u != 1:
if u % cur == 0:
while u % cur == 0:
cc[cur] += 1
u /= cur
cur += 1
return cu
cc = collections.Counter()
for u in range(2, n + 1):
cu = f(u)
for k in cu:
cc[k] += cu[k]
ans = 1
for k in cc:
ans *= cc[k] + 1
ans %= mod
print(ans)
|
import collections
n = int(input())
mod = (10**9) + 7
def f(u):
cu = collections.Counter()
cur = 2
while u != 1:
if u % cur == 0:
while u % cur == 0:
cc[cur] += 1
u /= cur
cur += 1
return cu
cc = collections.Counter()
for u in range(2, n + 1):
for k, v in f(u).items():
cc[k] += cu[k]
ans = 1
for k in cc:
ans *= cc[k] + 1
ans %= mod
print(ans)
| false | 4.545455 |
[
"- cu = f(u)",
"- for k in cu:",
"+ for k, v in f(u).items():"
] | false | 0.039208 | 0.045631 | 0.859239 |
[
"s530058290",
"s237320626"
] |
u511965386
|
p02794
|
python
|
s893373844
|
s081190719
| 2,264 | 1,570 | 42,348 | 42,092 |
Accepted
|
Accepted
| 30.65 |
from collections import defaultdict, Counter
N = int(eval(input()))
ab = [[] for _ in range(N)]
for i in range(N - 1) :
a, b = list(map(int, input().split()))
ab[a-1].append((b-1, i))
ab[b-1].append((a-1, i))
M = int(eval(input()))
uv = [[int(i) for i in input().split()] for _ in range(M)]
cnt = [set() for _ in range(M)]
def dfs(cur, pre, dest, i) :
if cur == dest :
return True
for nex, j in ab[cur] :
if nex == pre :
continue
if dfs(nex, cur, dest, i) :
cnt[i].add(j)
return True
return False
for i, (u, v) in enumerate(uv) :
dfs(u - 1, -1, v - 1, i)
ret = 1 << (N - 1)
for i in range(1, 1 << M) :
sgn = 1
s = set([])
for j in range(M) :
if i & (1 << j) :
s |= cnt[j]
sgn *= -1
ret += sgn * (1 << (N - 1 - len(s)))
print(ret)
|
N = int(eval(input()))
ab = [[] for _ in range(N)]
for i in range(N-1) :
a, b = list(map(int, input().split()))
ab[a-1].append((b-1, i))
ab[b-1].append((a-1, i))
M = int(eval(input()))
uv = [[int(i) for i in input().split()] for _ in range(M)]
dp = [0] * M
def dfs(cur, pre, t, i) :
if cur == t : return True
for nex, j in ab[cur] :
if nex == pre : continue
if dfs(nex, cur, t, i) :
dp[i] |= 1<<j
return True
return False
for i, (u, v) in enumerate(uv) :
dfs(u-1, -1, v-1, i)
ret = 1<<(N-1)
for i in range(1, 1<<M) :
sgn = 1
s = 0
for j in range(M) :
if i & (1<<j) :
s |= dp[j]
sgn *= -1
ret += sgn * (1<<(N-1-bin(s).count('1')))
print(ret)
| 40 | 33 | 828 | 716 |
from collections import defaultdict, Counter
N = int(eval(input()))
ab = [[] for _ in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
ab[a - 1].append((b - 1, i))
ab[b - 1].append((a - 1, i))
M = int(eval(input()))
uv = [[int(i) for i in input().split()] for _ in range(M)]
cnt = [set() for _ in range(M)]
def dfs(cur, pre, dest, i):
if cur == dest:
return True
for nex, j in ab[cur]:
if nex == pre:
continue
if dfs(nex, cur, dest, i):
cnt[i].add(j)
return True
return False
for i, (u, v) in enumerate(uv):
dfs(u - 1, -1, v - 1, i)
ret = 1 << (N - 1)
for i in range(1, 1 << M):
sgn = 1
s = set([])
for j in range(M):
if i & (1 << j):
s |= cnt[j]
sgn *= -1
ret += sgn * (1 << (N - 1 - len(s)))
print(ret)
|
N = int(eval(input()))
ab = [[] for _ in range(N)]
for i in range(N - 1):
a, b = list(map(int, input().split()))
ab[a - 1].append((b - 1, i))
ab[b - 1].append((a - 1, i))
M = int(eval(input()))
uv = [[int(i) for i in input().split()] for _ in range(M)]
dp = [0] * M
def dfs(cur, pre, t, i):
if cur == t:
return True
for nex, j in ab[cur]:
if nex == pre:
continue
if dfs(nex, cur, t, i):
dp[i] |= 1 << j
return True
return False
for i, (u, v) in enumerate(uv):
dfs(u - 1, -1, v - 1, i)
ret = 1 << (N - 1)
for i in range(1, 1 << M):
sgn = 1
s = 0
for j in range(M):
if i & (1 << j):
s |= dp[j]
sgn *= -1
ret += sgn * (1 << (N - 1 - bin(s).count("1")))
print(ret)
| false | 17.5 |
[
"-from collections import defaultdict, Counter",
"-",
"-cnt = [set() for _ in range(M)]",
"+dp = [0] * M",
"-def dfs(cur, pre, dest, i):",
"- if cur == dest:",
"+def dfs(cur, pre, t, i):",
"+ if cur == t:",
"- if dfs(nex, cur, dest, i):",
"- cnt[i].add(j)",
"+ if dfs(nex, cur, t, i):",
"+ dp[i] |= 1 << j",
"- s = set([])",
"+ s = 0",
"- s |= cnt[j]",
"+ s |= dp[j]",
"- ret += sgn * (1 << (N - 1 - len(s)))",
"+ ret += sgn * (1 << (N - 1 - bin(s).count(\"1\")))"
] | false | 0.038061 | 0.129965 | 0.292855 |
[
"s893373844",
"s081190719"
] |
u629454253
|
p02837
|
python
|
s004576006
|
s241559375
| 1,735 | 190 | 3,064 | 3,064 |
Accepted
|
Accepted
| 89.05 |
N = int(eval(input()))
ls = []
for i in range(N):
a = int(eval(input()))
for _ in range(a):
x,y = list(map(int, input().split()))
ls.append((i,x-1,y==1))
max = 0
for i in range(2**N):
c = 0
hon = set()
unhon = set()
for x in range(N):
if (i>>x)&1 == 1:
c += 1
for x,y,z in ls:
if (i>>x)&1 == 1:
if z:
hon.add(y)
else:
unhon.add(y)
if len(hon & unhon) == 0:
flag = True
for n in range(N):
if (i>>n)&1 == 1:
if n in unhon:
flag = False
break
else:
if n in hon:
flag = False
break
if flag and c >= max:
max = c
print(max)
|
N = int(eval(input()))
h = []
for i in range(N):
m = int(eval(input()))
g = []
for j in range(m):
a, b = list(map(int, input().split()))
g.append((a-1, b))
h.append(g)
def judge(a, b):
for i in range(N):
if (b >> i) & 1:
for j in a[i]:
if ((b >> j[0]) & 1) != j[1]:
return False
return True
x = 0b0
ans = -1
for i in range(2**N):
if judge(h, x):
tmp = 0
for i in range(N):
if (x >> i) & 1:
tmp += 1
if tmp > ans:
ans = tmp
x += 1
print(ans)
| 39 | 33 | 716 | 547 |
N = int(eval(input()))
ls = []
for i in range(N):
a = int(eval(input()))
for _ in range(a):
x, y = list(map(int, input().split()))
ls.append((i, x - 1, y == 1))
max = 0
for i in range(2**N):
c = 0
hon = set()
unhon = set()
for x in range(N):
if (i >> x) & 1 == 1:
c += 1
for x, y, z in ls:
if (i >> x) & 1 == 1:
if z:
hon.add(y)
else:
unhon.add(y)
if len(hon & unhon) == 0:
flag = True
for n in range(N):
if (i >> n) & 1 == 1:
if n in unhon:
flag = False
break
else:
if n in hon:
flag = False
break
if flag and c >= max:
max = c
print(max)
|
N = int(eval(input()))
h = []
for i in range(N):
m = int(eval(input()))
g = []
for j in range(m):
a, b = list(map(int, input().split()))
g.append((a - 1, b))
h.append(g)
def judge(a, b):
for i in range(N):
if (b >> i) & 1:
for j in a[i]:
if ((b >> j[0]) & 1) != j[1]:
return False
return True
x = 0b0
ans = -1
for i in range(2**N):
if judge(h, x):
tmp = 0
for i in range(N):
if (x >> i) & 1:
tmp += 1
if tmp > ans:
ans = tmp
x += 1
print(ans)
| false | 15.384615 |
[
"-ls = []",
"+h = []",
"- a = int(eval(input()))",
"- for _ in range(a):",
"- x, y = list(map(int, input().split()))",
"- ls.append((i, x - 1, y == 1))",
"-max = 0",
"+ m = int(eval(input()))",
"+ g = []",
"+ for j in range(m):",
"+ a, b = list(map(int, input().split()))",
"+ g.append((a - 1, b))",
"+ h.append(g)",
"+",
"+",
"+def judge(a, b):",
"+ for i in range(N):",
"+ if (b >> i) & 1:",
"+ for j in a[i]:",
"+ if ((b >> j[0]) & 1) != j[1]:",
"+ return False",
"+ return True",
"+",
"+",
"+x = 0b0",
"+ans = -1",
"- c = 0",
"- hon = set()",
"- unhon = set()",
"- for x in range(N):",
"- if (i >> x) & 1 == 1:",
"- c += 1",
"- for x, y, z in ls:",
"- if (i >> x) & 1 == 1:",
"- if z:",
"- hon.add(y)",
"- else:",
"- unhon.add(y)",
"- if len(hon & unhon) == 0:",
"- flag = True",
"- for n in range(N):",
"- if (i >> n) & 1 == 1:",
"- if n in unhon:",
"- flag = False",
"- break",
"- else:",
"- if n in hon:",
"- flag = False",
"- break",
"- if flag and c >= max:",
"- max = c",
"-print(max)",
"+ if judge(h, x):",
"+ tmp = 0",
"+ for i in range(N):",
"+ if (x >> i) & 1:",
"+ tmp += 1",
"+ if tmp > ans:",
"+ ans = tmp",
"+ x += 1",
"+print(ans)"
] | false | 0.09842 | 0.038573 | 2.551531 |
[
"s004576006",
"s241559375"
] |
u057109575
|
p02722
|
python
|
s884538797
|
s330126978
| 247 | 84 | 41,068 | 65,496 |
Accepted
|
Accepted
| 65.99 |
N = int(eval(input()))
divisor = set([N, N - 1])
x = N
for i in range(2, int(x ** 0.5) + 1):
z = x
while z % i == 0:
z //= i
if z % i == 1:
divisor.add(i)
if i == x // i:
continue
z = x
while z % (x // i) == 0:
z //= (x // i)
if z % (x // i) == 1:
divisor.add((x // i))
x = N - 1
for i in range(2, int(x ** 0.5) + 1):
if x % i == 0:
divisor.add(i)
divisor.add(x // i)
print((len(divisor) if N > 2 else 1))
|
N = int(eval(input()))
def calc_divisor(x):
divisor = []
for i in range(1, int(x ** 0.5) + 1):
if x % i == 0:
if i != 1:
divisor.append(i)
if i != x // i:
divisor.append(x // i)
return divisor
cand = len(calc_divisor(N - 1))
divisor_n = calc_divisor(N)
for v in divisor_n:
x = N
while x % v == 0:
x //= v
if x % v == 1:
cand += 1
print(cand)
| 27 | 26 | 541 | 472 |
N = int(eval(input()))
divisor = set([N, N - 1])
x = N
for i in range(2, int(x**0.5) + 1):
z = x
while z % i == 0:
z //= i
if z % i == 1:
divisor.add(i)
if i == x // i:
continue
z = x
while z % (x // i) == 0:
z //= x // i
if z % (x // i) == 1:
divisor.add((x // i))
x = N - 1
for i in range(2, int(x**0.5) + 1):
if x % i == 0:
divisor.add(i)
divisor.add(x // i)
print((len(divisor) if N > 2 else 1))
|
N = int(eval(input()))
def calc_divisor(x):
divisor = []
for i in range(1, int(x**0.5) + 1):
if x % i == 0:
if i != 1:
divisor.append(i)
if i != x // i:
divisor.append(x // i)
return divisor
cand = len(calc_divisor(N - 1))
divisor_n = calc_divisor(N)
for v in divisor_n:
x = N
while x % v == 0:
x //= v
if x % v == 1:
cand += 1
print(cand)
| false | 3.703704 |
[
"-divisor = set([N, N - 1])",
"-x = N",
"-for i in range(2, int(x**0.5) + 1):",
"- z = x",
"- while z % i == 0:",
"- z //= i",
"- if z % i == 1:",
"- divisor.add(i)",
"- if i == x // i:",
"- continue",
"- z = x",
"- while z % (x // i) == 0:",
"- z //= x // i",
"- if z % (x // i) == 1:",
"- divisor.add((x // i))",
"-x = N - 1",
"-for i in range(2, int(x**0.5) + 1):",
"- if x % i == 0:",
"- divisor.add(i)",
"- divisor.add(x // i)",
"-print((len(divisor) if N > 2 else 1))",
"+",
"+",
"+def calc_divisor(x):",
"+ divisor = []",
"+ for i in range(1, int(x**0.5) + 1):",
"+ if x % i == 0:",
"+ if i != 1:",
"+ divisor.append(i)",
"+ if i != x // i:",
"+ divisor.append(x // i)",
"+ return divisor",
"+",
"+",
"+cand = len(calc_divisor(N - 1))",
"+divisor_n = calc_divisor(N)",
"+for v in divisor_n:",
"+ x = N",
"+ while x % v == 0:",
"+ x //= v",
"+ if x % v == 1:",
"+ cand += 1",
"+print(cand)"
] | false | 0.157021 | 0.06388 | 2.458067 |
[
"s884538797",
"s330126978"
] |
u185966380
|
p02899
|
python
|
s962222639
|
s575627750
| 267 | 132 | 22,068 | 14,008 |
Accepted
|
Accepted
| 50.56 |
N = int(input())
A_list = list(map(int, input().split()))
A_sum = [[A, i + 1] for i, A in enumerate(A_list)]
A_sum.sort()
[print(a[1]) for a in A_sum]
|
N = int(input())
A_list = list(map(int, input().split()))
ans = [0]*(N+1)
for i, a in enumerate(A_list):
ans[a] = i + 1
[print(ANS) for ANS in ans[1:]]
| 5 | 8 | 154 | 165 |
N = int(input())
A_list = list(map(int, input().split()))
A_sum = [[A, i + 1] for i, A in enumerate(A_list)]
A_sum.sort()
[print(a[1]) for a in A_sum]
|
N = int(input())
A_list = list(map(int, input().split()))
ans = [0] * (N + 1)
for i, a in enumerate(A_list):
ans[a] = i + 1
[print(ANS) for ANS in ans[1:]]
| false | 37.5 |
[
"-A_sum = [[A, i + 1] for i, A in enumerate(A_list)]",
"-A_sum.sort()",
"-[print(a[1]) for a in A_sum]",
"+ans = [0] * (N + 1)",
"+for i, a in enumerate(A_list):",
"+ ans[a] = i + 1",
"+[print(ANS) for ANS in ans[1:]]"
] | false | 0.049064 | 0.073366 | 0.668758 |
[
"s962222639",
"s575627750"
] |
u416011173
|
p03308
|
python
|
s082938318
|
s895272658
| 31 | 28 | 9,060 | 9,052 |
Accepted
|
Accepted
| 9.68 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
A = list(map(int, input().split()))
# 求解処理
ans = 0
for A_i, A_j in itertools.combinations(A, r=2):
ans = max(ans, abs(A_i - A_j))
# 結果出力
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
A = list(map(int, input().split()))
return N, A
def main(A: list) -> None:
"""
メイン処理.
Args:\n
A (list): 整数列(1 <= A_i <= 10^9)
"""
# 求解処理
ans = max(A) - min(A)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, A = get_input()
# メイン処理
main(A)
| 15 | 35 | 251 | 494 |
# -*- coding: utf-8 -*-
# モジュールのインポート
import itertools
# 標準入力を取得
N = int(eval(input()))
A = list(map(int, input().split()))
# 求解処理
ans = 0
for A_i, A_j in itertools.combinations(A, r=2):
ans = max(ans, abs(A_i - A_j))
# 結果出力
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(eval(input()))
A = list(map(int, input().split()))
return N, A
def main(A: list) -> None:
"""
メイン処理.
Args:\n
A (list): 整数列(1 <= A_i <= 10^9)
"""
# 求解処理
ans = max(A) - min(A)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, A = get_input()
# メイン処理
main(A)
| false | 57.142857 |
[
"-# モジュールのインポート",
"-import itertools",
"+def get_input() -> tuple:",
"+ \"\"\"",
"+ 標準入力を取得する.",
"+ Returns:\\n",
"+ tuple: 標準入力",
"+ \"\"\"",
"+ N = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ return N, A",
"-# 標準入力を取得",
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-# 求解処理",
"-ans = 0",
"-for A_i, A_j in itertools.combinations(A, r=2):",
"- ans = max(ans, abs(A_i - A_j))",
"-# 結果出力",
"-print(ans)",
"+",
"+def main(A: list) -> None:",
"+ \"\"\"",
"+ メイン処理.",
"+ Args:\\n",
"+ A (list): 整数列(1 <= A_i <= 10^9)",
"+ \"\"\"",
"+ # 求解処理",
"+ ans = max(A) - min(A)",
"+ # 結果出力",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # 標準入力を取得",
"+ N, A = get_input()",
"+ # メイン処理",
"+ main(A)"
] | false | 0.167201 | 0.124907 | 1.338604 |
[
"s082938318",
"s895272658"
] |
u226108478
|
p03965
|
python
|
s373327484
|
s741822949
| 73 | 18 | 3,316 | 3,188 |
Accepted
|
Accepted
| 75.34 |
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem D
def execute_janken(self, other):
if self == 'p' and other == 'g':
return 1
elif self == 'g' and other == 'p':
return -1
else:
return 0
if __name__ == '__main__':
s = eval(input())
p_count = 0
g_count = 0
score = 0
hand = ''
for si in s:
if p_count == g_count:
hand = 'g'
g_count += 1
elif p_count < g_count:
hand = 'p'
p_count += 1
score += execute_janken(self=hand, other=si)
print(score)
|
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem D
if __name__ == '__main__':
s = eval(input())
print((len(s) // 2 - s.count('p')))
| 33 | 9 | 623 | 155 |
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem D
def execute_janken(self, other):
if self == "p" and other == "g":
return 1
elif self == "g" and other == "p":
return -1
else:
return 0
if __name__ == "__main__":
s = eval(input())
p_count = 0
g_count = 0
score = 0
hand = ""
for si in s:
if p_count == g_count:
hand = "g"
g_count += 1
elif p_count < g_count:
hand = "p"
p_count += 1
score += execute_janken(self=hand, other=si)
print(score)
|
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem D
if __name__ == "__main__":
s = eval(input())
print((len(s) // 2 - s.count("p")))
| false | 72.727273 |
[
"-def execute_janken(self, other):",
"- if self == \"p\" and other == \"g\":",
"- return 1",
"- elif self == \"g\" and other == \"p\":",
"- return -1",
"- else:",
"- return 0",
"-",
"-",
"- p_count = 0",
"- g_count = 0",
"- score = 0",
"- hand = \"\"",
"- for si in s:",
"- if p_count == g_count:",
"- hand = \"g\"",
"- g_count += 1",
"- elif p_count < g_count:",
"- hand = \"p\"",
"- p_count += 1",
"- score += execute_janken(self=hand, other=si)",
"- print(score)",
"+ print((len(s) // 2 - s.count(\"p\")))"
] | false | 0.035502 | 0.045031 | 0.788391 |
[
"s373327484",
"s741822949"
] |
u364027015
|
p02623
|
python
|
s253925961
|
s426603356
| 630 | 552 | 45,900 | 45,860 |
Accepted
|
Accepted
| 12.38 |
N,M,K=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
c=0
k=M
import numpy as np
A=np.array(A).cumsum()
B=np.array(B).cumsum()
for i in range(N):
d=K-A[i]
if d<0:
for j in reversed(list(range(M))):
if K-B[j]>=0:
if c<j+1:
c=j+1
break
break
else:
for j in reversed(list(range(k))):
if d>=B[j]:
if c<i+j+2:
c=i+j+2
k=j+1
break
if d<B[0]:
if c<i+1:
c=i+1
k=0
for j in reversed(list(range(M))):
if K-B[j]>=0:
if c<j+1:
c=j+1
print(c)
|
N,M,K=list(map(int,input().split()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
c=0
A.insert(0,0)
B.insert(0,0)
import numpy as np
A=np.array(A).cumsum()
B=np.array(B).cumsum()
for i in range(N+1):
d=K-A[i]
for j in reversed(list(range(M+1))):
if d-B[j]>=0:
if c<i+j:
c=i+j
M=j
break
print(c)
| 33 | 19 | 612 | 356 |
N, M, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
c = 0
k = M
import numpy as np
A = np.array(A).cumsum()
B = np.array(B).cumsum()
for i in range(N):
d = K - A[i]
if d < 0:
for j in reversed(list(range(M))):
if K - B[j] >= 0:
if c < j + 1:
c = j + 1
break
break
else:
for j in reversed(list(range(k))):
if d >= B[j]:
if c < i + j + 2:
c = i + j + 2
k = j + 1
break
if d < B[0]:
if c < i + 1:
c = i + 1
k = 0
for j in reversed(list(range(M))):
if K - B[j] >= 0:
if c < j + 1:
c = j + 1
print(c)
|
N, M, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
c = 0
A.insert(0, 0)
B.insert(0, 0)
import numpy as np
A = np.array(A).cumsum()
B = np.array(B).cumsum()
for i in range(N + 1):
d = K - A[i]
for j in reversed(list(range(M + 1))):
if d - B[j] >= 0:
if c < i + j:
c = i + j
M = j
break
print(c)
| false | 42.424242 |
[
"-k = M",
"+A.insert(0, 0)",
"+B.insert(0, 0)",
"-for i in range(N):",
"+for i in range(N + 1):",
"- if d < 0:",
"- for j in reversed(list(range(M))):",
"- if K - B[j] >= 0:",
"- if c < j + 1:",
"- c = j + 1",
"- break",
"- break",
"- else:",
"- for j in reversed(list(range(k))):",
"- if d >= B[j]:",
"- if c < i + j + 2:",
"- c = i + j + 2",
"- k = j + 1",
"- break",
"- if d < B[0]:",
"- if c < i + 1:",
"- c = i + 1",
"- k = 0",
"-for j in reversed(list(range(M))):",
"- if K - B[j] >= 0:",
"- if c < j + 1:",
"- c = j + 1",
"+ for j in reversed(list(range(M + 1))):",
"+ if d - B[j] >= 0:",
"+ if c < i + j:",
"+ c = i + j",
"+ M = j",
"+ break"
] | false | 0.292077 | 0.296924 | 0.983677 |
[
"s253925961",
"s426603356"
] |
u532966492
|
p03394
|
python
|
s061084785
|
s921441984
| 104 | 40 | 7,304 | 4,560 |
Accepted
|
Accepted
| 61.54 |
def main():
from fractions import gcd
n=int(eval(input()))
ans=[]
cnt=0
i=2
while cnt<n-1:
if i%2==0 or i%3==0:
ans.append(i)
cnt+=1
i+=1
a=sum(ans)
for j in range(30000,0,-1):
if gcd(j,a)>1 and gcd(a+j,2)>1 and gcd(a+j,3)>1:
print((*(ans+[j])))
return 0
main()
|
def main():
n=int(eval(input()))
if n==3:
print((2,5,63))
return 0
ans=[2,3]
cnt=0
i=10
while cnt<n-4:
if i%2==0 or i%3==0:
ans.append(i)
cnt+=1
i+=1
a=sum(ans)
if n==20000:
ans.pop()
ans.pop()
ans.append(8)
ans.append(9)
elif n==19999:
ans.pop()
ans.append(8)
if a%6==0:
ans.append(4)
ans.append(8)
elif a%6==1:
ans.append(8)
ans.append(9)
elif a%6==2:
ans.append(4)
ans.append(6)
elif a%6==3:
ans.append(6)
ans.append(9)
elif a%6==4:
ans.append(8)
ans.append(6)
elif a%6==5:
ans.append(9)
ans.append(4)
print((*ans))
main()
| 17 | 42 | 373 | 820 |
def main():
from fractions import gcd
n = int(eval(input()))
ans = []
cnt = 0
i = 2
while cnt < n - 1:
if i % 2 == 0 or i % 3 == 0:
ans.append(i)
cnt += 1
i += 1
a = sum(ans)
for j in range(30000, 0, -1):
if gcd(j, a) > 1 and gcd(a + j, 2) > 1 and gcd(a + j, 3) > 1:
print((*(ans + [j])))
return 0
main()
|
def main():
n = int(eval(input()))
if n == 3:
print((2, 5, 63))
return 0
ans = [2, 3]
cnt = 0
i = 10
while cnt < n - 4:
if i % 2 == 0 or i % 3 == 0:
ans.append(i)
cnt += 1
i += 1
a = sum(ans)
if n == 20000:
ans.pop()
ans.pop()
ans.append(8)
ans.append(9)
elif n == 19999:
ans.pop()
ans.append(8)
if a % 6 == 0:
ans.append(4)
ans.append(8)
elif a % 6 == 1:
ans.append(8)
ans.append(9)
elif a % 6 == 2:
ans.append(4)
ans.append(6)
elif a % 6 == 3:
ans.append(6)
ans.append(9)
elif a % 6 == 4:
ans.append(8)
ans.append(6)
elif a % 6 == 5:
ans.append(9)
ans.append(4)
print((*ans))
main()
| false | 59.52381 |
[
"- from fractions import gcd",
"-",
"- ans = []",
"+ if n == 3:",
"+ print((2, 5, 63))",
"+ return 0",
"+ ans = [2, 3]",
"- i = 2",
"- while cnt < n - 1:",
"+ i = 10",
"+ while cnt < n - 4:",
"- for j in range(30000, 0, -1):",
"- if gcd(j, a) > 1 and gcd(a + j, 2) > 1 and gcd(a + j, 3) > 1:",
"- print((*(ans + [j])))",
"- return 0",
"+ if n == 20000:",
"+ ans.pop()",
"+ ans.pop()",
"+ ans.append(8)",
"+ ans.append(9)",
"+ elif n == 19999:",
"+ ans.pop()",
"+ ans.append(8)",
"+ if a % 6 == 0:",
"+ ans.append(4)",
"+ ans.append(8)",
"+ elif a % 6 == 1:",
"+ ans.append(8)",
"+ ans.append(9)",
"+ elif a % 6 == 2:",
"+ ans.append(4)",
"+ ans.append(6)",
"+ elif a % 6 == 3:",
"+ ans.append(6)",
"+ ans.append(9)",
"+ elif a % 6 == 4:",
"+ ans.append(8)",
"+ ans.append(6)",
"+ elif a % 6 == 5:",
"+ ans.append(9)",
"+ ans.append(4)",
"+ print((*ans))"
] | false | 0.05897 | 0.046568 | 1.266319 |
[
"s061084785",
"s921441984"
] |
u382431597
|
p03352
|
python
|
s783511835
|
s630082314
| 23 | 17 | 3,060 | 3,064 |
Accepted
|
Accepted
| 26.09 |
import sys
import math
def isExponential(i : int) -> bool:
#math.ceil(math.sqrt(i))+1
for j in range(2,i):
devidend = i
devisor = j
#print(devidend,devisor,"inFor")
while 1:
#print(devidend,devisor,"inWhile")
if devidend % devisor != 0:
break
else:
if devidend == devisor:
return True
else:
devidend //= devisor
return False
x = int(eval(input()))
if x == 1:
print((1))
for i in range(x,0,-1):
if isExponential(i) == True:
print(i)
#print("wtf")
break
|
import sys
import math
def isExponential(i : int) -> bool:
for j in range(2,math.ceil(math.sqrt(i))+1):
devidend = i
devisor = j
#print(devidend,devisor,"inFor")
while 1:
#print(devidend,devisor,"inWhile")
if devidend % devisor != 0:
break
else:
if devidend == devisor:
return True
else:
devidend //= devisor
return False
x = int(eval(input()))
if x == 1:
print((1))
for i in range(x,0,-1):
if isExponential(i) == True:
print(i)
#print("wtf")
break
| 28 | 27 | 680 | 672 |
import sys
import math
def isExponential(i: int) -> bool:
# math.ceil(math.sqrt(i))+1
for j in range(2, i):
devidend = i
devisor = j
# print(devidend,devisor,"inFor")
while 1:
# print(devidend,devisor,"inWhile")
if devidend % devisor != 0:
break
else:
if devidend == devisor:
return True
else:
devidend //= devisor
return False
x = int(eval(input()))
if x == 1:
print((1))
for i in range(x, 0, -1):
if isExponential(i) == True:
print(i)
# print("wtf")
break
|
import sys
import math
def isExponential(i: int) -> bool:
for j in range(2, math.ceil(math.sqrt(i)) + 1):
devidend = i
devisor = j
# print(devidend,devisor,"inFor")
while 1:
# print(devidend,devisor,"inWhile")
if devidend % devisor != 0:
break
else:
if devidend == devisor:
return True
else:
devidend //= devisor
return False
x = int(eval(input()))
if x == 1:
print((1))
for i in range(x, 0, -1):
if isExponential(i) == True:
print(i)
# print("wtf")
break
| false | 3.571429 |
[
"- # math.ceil(math.sqrt(i))+1",
"- for j in range(2, i):",
"+ for j in range(2, math.ceil(math.sqrt(i)) + 1):"
] | false | 0.038787 | 0.04532 | 0.85585 |
[
"s783511835",
"s630082314"
] |
u075012704
|
p02918
|
python
|
s262347370
|
s815878451
| 84 | 61 | 3,316 | 4,468 |
Accepted
|
Accepted
| 27.38 |
from math import ceil
N, K = list(map(int, input().split()))
S = 'x' + eval(input()) + 'x'
ans = 0
X = ''
ns = ''
for i, s in enumerate(S[1:-1], start=1):
if s == 'L':
if S[i - 1] == 'L':
ans += 1
else:
X += s
else:
if S[i + 1] == 'R':
ans += 1
else:
X += s
target = 'L' if X[0] == 'R' else 'R'
k_cnt = 0
for i, x in enumerate(X):
if x == target and k_cnt < K:
k_cnt += 1
if i == len(X) - 1:
ans += 1
else:
ans += 2
print(ans)
|
N, K = list(map(int, input().split()))
S = eval(input())
ans = 0
for i in range(N):
if S[i] == 'L':
if i - 1 < 0:
continue
if S[i - 1] == 'L':
ans += 1
else:
if i + 1 >= N:
continue
if S[i + 1] == 'R':
ans += 1
X = (len([s for s in S.split('L') if s != '']) + len([s for s in S.split('R') if s != '']))
ans += min(X, K) * 2
print((min(ans, N - 1)))
| 33 | 20 | 593 | 445 |
from math import ceil
N, K = list(map(int, input().split()))
S = "x" + eval(input()) + "x"
ans = 0
X = ""
ns = ""
for i, s in enumerate(S[1:-1], start=1):
if s == "L":
if S[i - 1] == "L":
ans += 1
else:
X += s
else:
if S[i + 1] == "R":
ans += 1
else:
X += s
target = "L" if X[0] == "R" else "R"
k_cnt = 0
for i, x in enumerate(X):
if x == target and k_cnt < K:
k_cnt += 1
if i == len(X) - 1:
ans += 1
else:
ans += 2
print(ans)
|
N, K = list(map(int, input().split()))
S = eval(input())
ans = 0
for i in range(N):
if S[i] == "L":
if i - 1 < 0:
continue
if S[i - 1] == "L":
ans += 1
else:
if i + 1 >= N:
continue
if S[i + 1] == "R":
ans += 1
X = len([s for s in S.split("L") if s != ""]) + len(
[s for s in S.split("R") if s != ""]
)
ans += min(X, K) * 2
print((min(ans, N - 1)))
| false | 39.393939 |
[
"-from math import ceil",
"-",
"-S = \"x\" + eval(input()) + \"x\"",
"+S = eval(input())",
"-X = \"\"",
"-ns = \"\"",
"-for i, s in enumerate(S[1:-1], start=1):",
"- if s == \"L\":",
"+for i in range(N):",
"+ if S[i] == \"L\":",
"+ if i - 1 < 0:",
"+ continue",
"- else:",
"- X += s",
"+ if i + 1 >= N:",
"+ continue",
"- else:",
"- X += s",
"-target = \"L\" if X[0] == \"R\" else \"R\"",
"-k_cnt = 0",
"-for i, x in enumerate(X):",
"- if x == target and k_cnt < K:",
"- k_cnt += 1",
"- if i == len(X) - 1:",
"- ans += 1",
"- else:",
"- ans += 2",
"-print(ans)",
"+X = len([s for s in S.split(\"L\") if s != \"\"]) + len(",
"+ [s for s in S.split(\"R\") if s != \"\"]",
"+)",
"+ans += min(X, K) * 2",
"+print((min(ans, N - 1)))"
] | false | 0.037037 | 0.033192 | 1.115822 |
[
"s262347370",
"s815878451"
] |
u891518152
|
p02953
|
python
|
s413125542
|
s496260462
| 246 | 224 | 63,856 | 63,984 |
Accepted
|
Accepted
| 8.94 |
N=int(eval(input()))
H=list(map(int, input().split()))
h=H[::-1]
a=True
for i in range(N-1):
if h[i] < h[i + 1]:
if h[i+1]-h[i] <= 1:
h[i+1] -=1
else:
a = False
break
if a:
print('Yes')
else:
print('No')
|
N = int(eval(input()))
h = list(map(int, input().split()))
H = h[::-1]
a = True
for i in range(N-1):
if H[i]<=H[i+1]:
if H[i]+1==H[i+1]:
H[i+1] -= 1
elif H[i+1]>=H[i]+2:
a = False
break
for i in range(N-1):
if H[i]>=H[i+1]:
a = True
else:
a = False
break
if a:
print('Yes')
else:
print('No')
| 16 | 23 | 278 | 413 |
N = int(eval(input()))
H = list(map(int, input().split()))
h = H[::-1]
a = True
for i in range(N - 1):
if h[i] < h[i + 1]:
if h[i + 1] - h[i] <= 1:
h[i + 1] -= 1
else:
a = False
break
if a:
print("Yes")
else:
print("No")
|
N = int(eval(input()))
h = list(map(int, input().split()))
H = h[::-1]
a = True
for i in range(N - 1):
if H[i] <= H[i + 1]:
if H[i] + 1 == H[i + 1]:
H[i + 1] -= 1
elif H[i + 1] >= H[i] + 2:
a = False
break
for i in range(N - 1):
if H[i] >= H[i + 1]:
a = True
else:
a = False
break
if a:
print("Yes")
else:
print("No")
| false | 30.434783 |
[
"-H = list(map(int, input().split()))",
"-h = H[::-1]",
"+h = list(map(int, input().split()))",
"+H = h[::-1]",
"- if h[i] < h[i + 1]:",
"- if h[i + 1] - h[i] <= 1:",
"- h[i + 1] -= 1",
"- else:",
"+ if H[i] <= H[i + 1]:",
"+ if H[i] + 1 == H[i + 1]:",
"+ H[i + 1] -= 1",
"+ elif H[i + 1] >= H[i] + 2:",
"+for i in range(N - 1):",
"+ if H[i] >= H[i + 1]:",
"+ a = True",
"+ else:",
"+ a = False",
"+ break"
] | false | 0.042939 | 0.0431 | 0.996271 |
[
"s413125542",
"s496260462"
] |
u762420987
|
p02862
|
python
|
s281741171
|
s410454926
| 196 | 94 | 3,064 | 3,064 |
Accepted
|
Accepted
| 52.04 |
def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod)**2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10**9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
from sys import exit
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
exit()
if X % 2 == 0:
syurui = X - (X // 2) + 1
else:
syurui = X - (X // 2)
for i in range(syurui):
two = i
one = X - two * 2
if (two + one * 2) == Y:
print((nCk(two + one, two)))
exit()
print((0))
|
def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod)**2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10 ** 9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
else:
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n < 0 or m < 0:
print((0))
else:
print((nCk(n + m, n)))
| 39 | 32 | 867 | 741 |
def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod) ** 2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10**9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
from sys import exit
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
exit()
if X % 2 == 0:
syurui = X - (X // 2) + 1
else:
syurui = X - (X // 2)
for i in range(syurui):
two = i
one = X - two * 2
if (two + one * 2) == Y:
print((nCk(two + one, two)))
exit()
print((0))
|
def sq(a, b, mod): # aのb乗を剰余,kは初期値#20191116-D-Knight
if b == 0:
return 1
elif b % 2 == 0:
return sq(a, b // 2, mod) ** 2 % mod
else:
return sq(a, b - 1, mod) * a % mod
def nCk(n, k, mod=10**9 + 7):
x = max(k, n - k)
y = min(k, n - k)
kkai = 1
for i in range(2, y + 1):
kkai = (kkai * i) % mod
nkkai = 1
for i in range(x + 1, n + 1):
nkkai = (nkkai * i) % mod
answer = sq(kkai, mod - 2, mod) * nkkai % mod
return answer
X, Y = list(map(int, input().split()))
if (X + Y) % 3 != 0:
print((0))
else:
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n < 0 or m < 0:
print((0))
else:
print((nCk(n + m, n)))
| false | 17.948718 |
[
"-from sys import exit",
"-",
"- exit()",
"-if X % 2 == 0:",
"- syurui = X - (X // 2) + 1",
"- syurui = X - (X // 2)",
"-for i in range(syurui):",
"- two = i",
"- one = X - two * 2",
"- if (two + one * 2) == Y:",
"- print((nCk(two + one, two)))",
"- exit()",
"-print((0))",
"+ n = (2 * Y - X) // 3",
"+ m = (2 * X - Y) // 3",
"+ if n < 0 or m < 0:",
"+ print((0))",
"+ else:",
"+ print((nCk(n + m, n)))"
] | false | 0.073264 | 0.053161 | 1.378153 |
[
"s281741171",
"s410454926"
] |
u663767599
|
p02866
|
python
|
s553035627
|
s783201973
| 344 | 167 | 26,840 | 26,840 |
Accepted
|
Accepted
| 51.45 |
from collections import Counter
from itertools import tee
N = int(eval(input()))
D = list(map(int, input().split(" ")))
R = 998244353
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return list(zip(a, b))
def is_leap(distance):
cc = Counter(distance)
for x, y in pairwise(sorted(cc.keys())):
if y - x > 1:
return True
else:
return False
if D[0] > 0:
"""頂点1が根ではない"""
print((0))
elif not all(D[1:]):
"""連結グラフではない"""
print((0))
elif is_leap(D):
print((0))
else:
ans = 1
c = Counter(D[1:])
edges = [t[1] for t in sorted(c.items())]
for d, e in pairwise(edges):
ans *= pow(d, e)
print((ans % R))
|
from collections import Counter
from itertools import tee
N = int(eval(input()))
D = list(map(int, input().split(" ")))
R = 998244353
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return list(zip(a, b))
def is_leap(distance):
cc = Counter(distance)
for x, y in pairwise(sorted(cc.keys())):
if y - x > 1:
return True
else:
return False
if D[0] > 0:
"""頂点1が根ではない"""
print((0))
elif not all(D[1:]):
"""連結グラフではない"""
print((0))
elif is_leap(D):
"""連結グラフではない"""
print((0))
else:
ans = 1
c = Counter(D[1:])
edges = [t[1] for t in sorted(c.items())]
for d, e in pairwise(edges):
ans *= pow(d, e)
ans = ans % R
print((ans % R))
| 38 | 40 | 726 | 770 |
from collections import Counter
from itertools import tee
N = int(eval(input()))
D = list(map(int, input().split(" ")))
R = 998244353
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return list(zip(a, b))
def is_leap(distance):
cc = Counter(distance)
for x, y in pairwise(sorted(cc.keys())):
if y - x > 1:
return True
else:
return False
if D[0] > 0:
"""頂点1が根ではない"""
print((0))
elif not all(D[1:]):
"""連結グラフではない"""
print((0))
elif is_leap(D):
print((0))
else:
ans = 1
c = Counter(D[1:])
edges = [t[1] for t in sorted(c.items())]
for d, e in pairwise(edges):
ans *= pow(d, e)
print((ans % R))
|
from collections import Counter
from itertools import tee
N = int(eval(input()))
D = list(map(int, input().split(" ")))
R = 998244353
def pairwise(iterable):
a, b = tee(iterable)
next(b, None)
return list(zip(a, b))
def is_leap(distance):
cc = Counter(distance)
for x, y in pairwise(sorted(cc.keys())):
if y - x > 1:
return True
else:
return False
if D[0] > 0:
"""頂点1が根ではない"""
print((0))
elif not all(D[1:]):
"""連結グラフではない"""
print((0))
elif is_leap(D):
"""連結グラフではない"""
print((0))
else:
ans = 1
c = Counter(D[1:])
edges = [t[1] for t in sorted(c.items())]
for d, e in pairwise(edges):
ans *= pow(d, e)
ans = ans % R
print((ans % R))
| false | 5 |
[
"+ \"\"\"連結グラフではない\"\"\"",
"+ ans = ans % R"
] | false | 0.044167 | 0.153481 | 0.287771 |
[
"s553035627",
"s783201973"
] |
u815878613
|
p02999
|
python
|
s791421540
|
s789584364
| 21 | 17 | 3,316 | 2,940 |
Accepted
|
Accepted
| 19.05 |
import sys
X, A = list(map(int, input().split()))
if X < A:
print('0')
else:
print('10')
|
X, A = list(map(int, input().split()))
print((0 if X < A else 10))
| 8 | 2 | 106 | 60 |
import sys
X, A = list(map(int, input().split()))
if X < A:
print("0")
else:
print("10")
|
X, A = list(map(int, input().split()))
print((0 if X < A else 10))
| false | 75 |
[
"-import sys",
"-",
"-if X < A:",
"- print(\"0\")",
"-else:",
"- print(\"10\")",
"+print((0 if X < A else 10))"
] | false | 0.041981 | 0.038053 | 1.103224 |
[
"s791421540",
"s789584364"
] |
u237362582
|
p02901
|
python
|
s230566823
|
s141947588
| 1,381 | 1,108 | 3,188 | 3,188 |
Accepted
|
Accepted
| 19.77 |
N, M = list(map(int, input().split()))
C = [float('inf')] * (1 << N)
C[0] = 0
key_v = [float('inf')] * (1 << N)
for j in range(M):
a, b = list(map(int, input().split()))
box = list(map(int, input().split()))
ex_status = 0
for j in box:
ex_status += 1 << (j-1)
key_v[ex_status] = min(a, key_v[ex_status])
for key, val in enumerate(key_v):
if val == float('inf'):
continue
for i in range(1 << N):
now_status = i
score = C[now_status] + val
if score == float("inf"):
continue
now_status = i | key
if C[now_status] > score:
C[now_status] = score
if C[-1] == float("inf"):
print((-1))
else:
print((C[-1]))
|
N, M = list(map(int, input().split()))
A = []
min_state = [10**9] * (2**N)
min_state[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
key = 0
for tmp in c:
key += 2**(tmp-1)
A.append((a, key))
L = len(min_state)
for a, key in A:
for i, score in enumerate(min_state):
next_key = key | i
if min_state[next_key] > score + a:
min_state[next_key] = score + a
if min_state[-1] == 10**9:
print((-1))
else:
print((min_state[-1]))
| 33 | 23 | 740 | 550 |
N, M = list(map(int, input().split()))
C = [float("inf")] * (1 << N)
C[0] = 0
key_v = [float("inf")] * (1 << N)
for j in range(M):
a, b = list(map(int, input().split()))
box = list(map(int, input().split()))
ex_status = 0
for j in box:
ex_status += 1 << (j - 1)
key_v[ex_status] = min(a, key_v[ex_status])
for key, val in enumerate(key_v):
if val == float("inf"):
continue
for i in range(1 << N):
now_status = i
score = C[now_status] + val
if score == float("inf"):
continue
now_status = i | key
if C[now_status] > score:
C[now_status] = score
if C[-1] == float("inf"):
print((-1))
else:
print((C[-1]))
|
N, M = list(map(int, input().split()))
A = []
min_state = [10**9] * (2**N)
min_state[0] = 0
for _ in range(M):
a, b = list(map(int, input().split()))
c = list(map(int, input().split()))
key = 0
for tmp in c:
key += 2 ** (tmp - 1)
A.append((a, key))
L = len(min_state)
for a, key in A:
for i, score in enumerate(min_state):
next_key = key | i
if min_state[next_key] > score + a:
min_state[next_key] = score + a
if min_state[-1] == 10**9:
print((-1))
else:
print((min_state[-1]))
| false | 30.30303 |
[
"-C = [float(\"inf\")] * (1 << N)",
"-C[0] = 0",
"-key_v = [float(\"inf\")] * (1 << N)",
"-for j in range(M):",
"+A = []",
"+min_state = [10**9] * (2**N)",
"+min_state[0] = 0",
"+for _ in range(M):",
"- box = list(map(int, input().split()))",
"- ex_status = 0",
"- for j in box:",
"- ex_status += 1 << (j - 1)",
"- key_v[ex_status] = min(a, key_v[ex_status])",
"-for key, val in enumerate(key_v):",
"- if val == float(\"inf\"):",
"- continue",
"- for i in range(1 << N):",
"- now_status = i",
"- score = C[now_status] + val",
"- if score == float(\"inf\"):",
"- continue",
"- now_status = i | key",
"- if C[now_status] > score:",
"- C[now_status] = score",
"-if C[-1] == float(\"inf\"):",
"+ c = list(map(int, input().split()))",
"+ key = 0",
"+ for tmp in c:",
"+ key += 2 ** (tmp - 1)",
"+ A.append((a, key))",
"+L = len(min_state)",
"+for a, key in A:",
"+ for i, score in enumerate(min_state):",
"+ next_key = key | i",
"+ if min_state[next_key] > score + a:",
"+ min_state[next_key] = score + a",
"+if min_state[-1] == 10**9:",
"- print((C[-1]))",
"+ print((min_state[-1]))"
] | false | 0.043949 | 0.115016 | 0.38211 |
[
"s230566823",
"s141947588"
] |
u428199834
|
p02596
|
python
|
s241124690
|
s983487211
| 505 | 358 | 16,696 | 16,584 |
Accepted
|
Accepted
| 29.11 |
k=int(eval(input()))
ama=[0]*(k)
now=7
if now%k==0:
print((1))
exit()
else:
ama[now%k]+=1
for _ in range(2*k):
now=(now*10+7)%k
if now%k==0:
print((_+2))
exit()
elif ama[now%k]==0:
ama[now%k]+=1
else:
print((-1))
exit()
|
k=int(eval(input()))
ama=[0]*(k)
now=7%k
ama[now]+=1
if now==0:
print((1))
exit()
for i in range(2,k+1):
now=(10*now+7)%k
if ama[now]!=0 and now>0:
print((-1))
exit()
elif now==0:
print(i)
exit()
else:
ama[now]+=1
| 20 | 18 | 270 | 257 |
k = int(eval(input()))
ama = [0] * (k)
now = 7
if now % k == 0:
print((1))
exit()
else:
ama[now % k] += 1
for _ in range(2 * k):
now = (now * 10 + 7) % k
if now % k == 0:
print((_ + 2))
exit()
elif ama[now % k] == 0:
ama[now % k] += 1
else:
print((-1))
exit()
|
k = int(eval(input()))
ama = [0] * (k)
now = 7 % k
ama[now] += 1
if now == 0:
print((1))
exit()
for i in range(2, k + 1):
now = (10 * now + 7) % k
if ama[now] != 0 and now > 0:
print((-1))
exit()
elif now == 0:
print(i)
exit()
else:
ama[now] += 1
| false | 10 |
[
"-now = 7",
"-if now % k == 0:",
"+now = 7 % k",
"+ama[now] += 1",
"+if now == 0:",
"-else:",
"- ama[now % k] += 1",
"-for _ in range(2 * k):",
"- now = (now * 10 + 7) % k",
"- if now % k == 0:",
"- print((_ + 2))",
"- exit()",
"- elif ama[now % k] == 0:",
"- ama[now % k] += 1",
"- else:",
"+for i in range(2, k + 1):",
"+ now = (10 * now + 7) % k",
"+ if ama[now] != 0 and now > 0:",
"+ elif now == 0:",
"+ print(i)",
"+ exit()",
"+ else:",
"+ ama[now] += 1"
] | false | 0.129883 | 0.148412 | 0.87515 |
[
"s241124690",
"s983487211"
] |
u638795007
|
p02732
|
python
|
s823287695
|
s496000085
| 441 | 282 | 84,308 | 30,268 |
Accepted
|
Accepted
| 36.05 |
def examA():
N, M = LI()
ans = N*(N-1)//2 + M*(M-1)//2
print(ans)
return
def examB():
def judge(A):
#print(A)
n = len(A)
for i in range(n//2):
if A[i]!=A[n-i-1]:
return False
return True
S = SI()
N = len(S)
if not judge(S):
print("No")
return
if judge(S[:(N-1)//2]) and judge(S[(N+1)//2:]):
print("Yes")
else:
print("No")
return
def examC():
L = I()
ans = (L/3)**3
print(ans)
return
def examD():
N = I()
A = LI()
D = defaultdict(bool)
C = Counter(A)
M = 0
for key,c in list(C.items()):
M += c*(c-1)//2
#print(C)
#print(M)
ans = [0]*N
for i in range(N):
a = A[i]
c = C[a]
ans[i] = M -(c*(c-1)//2) + ((c-1)*(c-2)//2)
for v in ans:
print(v)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == '__main__':
examD()
"""
"""
|
def examA():
N = I()
ans = ((N+1)//2)/N
print(ans)
return
def examB():
N, K = LI()
H = [I()for _ in range(N)]
H.sort()
ans = inf
for i in range(N-K+1):
cur = H[i+K-1]-H[i]
if ans>cur:
ans = cur
print(ans)
return
def examC():
N = I()
A = LI()
ans = [0]*N
C = Counter(A)
base = 0
for c in list(C.values()):
base += c*(c-1)//2
#print(C)
#print(base)
for i in range(N):
ans[i] = base - (C[A[i]]-1)
for v in ans:
print(v)
return
def examD():
ans = 0
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys,bisect,itertools,heapq,math,random
from copy import deepcopy
from heapq import heappop,heappush,heapify
from collections import Counter,defaultdict,deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I(): return int(readline())
def LI(): return list(map(int,readline().split()))
def LSI(): return list(map(str,sys.stdin.readline().split()))
def LS(): return sys.stdin.readline().split()
def SI(): return sys.stdin.readline().strip()
global mod,mod2,inf,alphabet,_ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10**(-12)
alphabet = [chr(ord('a') + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == '__main__':
examC()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
| 84 | 79 | 1,716 | 1,563 |
def examA():
N, M = LI()
ans = N * (N - 1) // 2 + M * (M - 1) // 2
print(ans)
return
def examB():
def judge(A):
# print(A)
n = len(A)
for i in range(n // 2):
if A[i] != A[n - i - 1]:
return False
return True
S = SI()
N = len(S)
if not judge(S):
print("No")
return
if judge(S[: (N - 1) // 2]) and judge(S[(N + 1) // 2 :]):
print("Yes")
else:
print("No")
return
def examC():
L = I()
ans = (L / 3) ** 3
print(ans)
return
def examD():
N = I()
A = LI()
D = defaultdict(bool)
C = Counter(A)
M = 0
for key, c in list(C.items()):
M += c * (c - 1) // 2
# print(C)
# print(M)
ans = [0] * N
for i in range(N):
a = A[i]
c = C[a]
ans[i] = M - (c * (c - 1) // 2) + ((c - 1) * (c - 2) // 2)
for v in ans:
print(v)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys, bisect, itertools, heapq, math, random
from copy import deepcopy
from heapq import heappop, heappush, heapify
from collections import Counter, defaultdict, deque
def I():
return int(sys.stdin.readline())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LSI():
return list(map(str, sys.stdin.readline().split()))
def LS():
return sys.stdin.readline().split()
def SI():
return sys.stdin.readline().strip()
global mod, mod2, inf, alphabet, _ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10 ** (-12)
alphabet = [chr(ord("a") + i) for i in range(26)]
sys.setrecursionlimit(10**6)
if __name__ == "__main__":
examD()
"""
"""
|
def examA():
N = I()
ans = ((N + 1) // 2) / N
print(ans)
return
def examB():
N, K = LI()
H = [I() for _ in range(N)]
H.sort()
ans = inf
for i in range(N - K + 1):
cur = H[i + K - 1] - H[i]
if ans > cur:
ans = cur
print(ans)
return
def examC():
N = I()
A = LI()
ans = [0] * N
C = Counter(A)
base = 0
for c in list(C.values()):
base += c * (c - 1) // 2
# print(C)
# print(base)
for i in range(N):
ans[i] = base - (C[A[i]] - 1)
for v in ans:
print(v)
return
def examD():
ans = 0
print(ans)
return
def examE():
ans = 0
print(ans)
return
def examF():
ans = 0
print(ans)
return
import sys, bisect, itertools, heapq, math, random
from copy import deepcopy
from heapq import heappop, heappush, heapify
from collections import Counter, defaultdict, deque
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
def I():
return int(readline())
def LI():
return list(map(int, readline().split()))
def LSI():
return list(map(str, sys.stdin.readline().split()))
def LS():
return sys.stdin.readline().split()
def SI():
return sys.stdin.readline().strip()
global mod, mod2, inf, alphabet, _ep
mod = 10**9 + 7
mod2 = 998244353
inf = 10**18
_ep = 10 ** (-12)
alphabet = [chr(ord("a") + i) for i in range(26)]
sys.setrecursionlimit(10**7)
if __name__ == "__main__":
examC()
"""
142
12 9 1445 0 1
asd dfg hj o o
aidn
"""
| false | 5.952381 |
[
"- N, M = LI()",
"- ans = N * (N - 1) // 2 + M * (M - 1) // 2",
"+ N = I()",
"+ ans = ((N + 1) // 2) / N",
"- def judge(A):",
"- # print(A)",
"- n = len(A)",
"- for i in range(n // 2):",
"- if A[i] != A[n - i - 1]:",
"- return False",
"- return True",
"-",
"- S = SI()",
"- N = len(S)",
"- if not judge(S):",
"- print(\"No\")",
"- return",
"- if judge(S[: (N - 1) // 2]) and judge(S[(N + 1) // 2 :]):",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"+ N, K = LI()",
"+ H = [I() for _ in range(N)]",
"+ H.sort()",
"+ ans = inf",
"+ for i in range(N - K + 1):",
"+ cur = H[i + K - 1] - H[i]",
"+ if ans > cur:",
"+ ans = cur",
"+ print(ans)",
"- L = I()",
"- ans = (L / 3) ** 3",
"- print(ans)",
"+ N = I()",
"+ A = LI()",
"+ ans = [0] * N",
"+ C = Counter(A)",
"+ base = 0",
"+ for c in list(C.values()):",
"+ base += c * (c - 1) // 2",
"+ # print(C)",
"+ # print(base)",
"+ for i in range(N):",
"+ ans[i] = base - (C[A[i]] - 1)",
"+ for v in ans:",
"+ print(v)",
"- N = I()",
"- A = LI()",
"- D = defaultdict(bool)",
"- C = Counter(A)",
"- M = 0",
"- for key, c in list(C.items()):",
"- M += c * (c - 1) // 2",
"- # print(C)",
"- # print(M)",
"- ans = [0] * N",
"- for i in range(N):",
"- a = A[i]",
"- c = C[a]",
"- ans[i] = M - (c * (c - 1) // 2) + ((c - 1) * (c - 2) // 2)",
"- for v in ans:",
"- print(v)",
"+ ans = 0",
"+ print(ans)",
"+read = sys.stdin.buffer.read",
"+readline = sys.stdin.buffer.readline",
"+readlines = sys.stdin.buffer.readlines",
"+",
"- return int(sys.stdin.readline())",
"+ return int(readline())",
"- return list(map(int, sys.stdin.readline().split()))",
"+ return list(map(int, readline().split()))",
"-sys.setrecursionlimit(10**6)",
"+sys.setrecursionlimit(10**7)",
"- examD()",
"+ examC()",
"+142",
"+12 9 1445 0 1",
"+asd dfg hj o o",
"+aidn"
] | false | 0.042928 | 0.061954 | 0.692901 |
[
"s823287695",
"s496000085"
] |
u620084012
|
p03361
|
python
|
s325207654
|
s402777208
| 177 | 18 | 39,280 | 3,064 |
Accepted
|
Accepted
| 89.83 |
H, W = list(map(int,input().split()))
S = [eval(input()) for k in range(H)]
for y in range(H):
for x in range(W):
if S[y][x] == "#":
f = 1
if y+1 < H:
if S[y+1][x] == "#":
f = 0
if x+1 < W:
if S[y][x+1] == "#":
f = 0
if 0 <= y-1:
if S[y-1][x] == "#":
f = 0
if 0 <= x-1:
if S[y][x-1] == "#":
f = 0
if f:
print("No")
exit(0)
print("Yes")
|
H, W = list(map(int,input().split()))
G = ["."*(W+2)]
for k in range(H):
G.append("."+eval(input())+".")
G.append("."*(W+2))
for k in range(1,H+1):
for l in range(1,W+1):
if G[k][l] == "#":
if G[k+1][l] == "." and G[k-1][l] == "." and G[k][l-1] == "." and G[k][l+1] == ".":
print("No")
exit(0)
print("Yes")
| 24 | 12 | 609 | 366 |
H, W = list(map(int, input().split()))
S = [eval(input()) for k in range(H)]
for y in range(H):
for x in range(W):
if S[y][x] == "#":
f = 1
if y + 1 < H:
if S[y + 1][x] == "#":
f = 0
if x + 1 < W:
if S[y][x + 1] == "#":
f = 0
if 0 <= y - 1:
if S[y - 1][x] == "#":
f = 0
if 0 <= x - 1:
if S[y][x - 1] == "#":
f = 0
if f:
print("No")
exit(0)
print("Yes")
|
H, W = list(map(int, input().split()))
G = ["." * (W + 2)]
for k in range(H):
G.append("." + eval(input()) + ".")
G.append("." * (W + 2))
for k in range(1, H + 1):
for l in range(1, W + 1):
if G[k][l] == "#":
if (
G[k + 1][l] == "."
and G[k - 1][l] == "."
and G[k][l - 1] == "."
and G[k][l + 1] == "."
):
print("No")
exit(0)
print("Yes")
| false | 50 |
[
"-S = [eval(input()) for k in range(H)]",
"-for y in range(H):",
"- for x in range(W):",
"- if S[y][x] == \"#\":",
"- f = 1",
"- if y + 1 < H:",
"- if S[y + 1][x] == \"#\":",
"- f = 0",
"- if x + 1 < W:",
"- if S[y][x + 1] == \"#\":",
"- f = 0",
"- if 0 <= y - 1:",
"- if S[y - 1][x] == \"#\":",
"- f = 0",
"- if 0 <= x - 1:",
"- if S[y][x - 1] == \"#\":",
"- f = 0",
"- if f:",
"+G = [\".\" * (W + 2)]",
"+for k in range(H):",
"+ G.append(\".\" + eval(input()) + \".\")",
"+G.append(\".\" * (W + 2))",
"+for k in range(1, H + 1):",
"+ for l in range(1, W + 1):",
"+ if G[k][l] == \"#\":",
"+ if (",
"+ G[k + 1][l] == \".\"",
"+ and G[k - 1][l] == \".\"",
"+ and G[k][l - 1] == \".\"",
"+ and G[k][l + 1] == \".\"",
"+ ):"
] | false | 0.039189 | 0.038817 | 1.009581 |
[
"s325207654",
"s402777208"
] |
u671060652
|
p02682
|
python
|
s544086068
|
s979514899
| 133 | 98 | 72,736 | 72,812 |
Accepted
|
Accepted
| 26.32 |
import itertools
import math
import fractions
import functools
a, b, c, k = list(map(int, input().split()))
sum = 0
if k <= a:
print(k)
quit()
else:
sum = a
k -= a
if k <= b:
print(sum)
quit()
else:
k -= b
print((sum-k))
|
import itertools
import math
import fractions
import functools
a, b, c, k = list(map(int, input().split()))
if k <= a:
print(k)
elif k <= a+b:
print(a)
else: print((a-(k-a-b)))
| 19 | 11 | 260 | 187 |
import itertools
import math
import fractions
import functools
a, b, c, k = list(map(int, input().split()))
sum = 0
if k <= a:
print(k)
quit()
else:
sum = a
k -= a
if k <= b:
print(sum)
quit()
else:
k -= b
print((sum - k))
|
import itertools
import math
import fractions
import functools
a, b, c, k = list(map(int, input().split()))
if k <= a:
print(k)
elif k <= a + b:
print(a)
else:
print((a - (k - a - b)))
| false | 42.105263 |
[
"-sum = 0",
"- quit()",
"+elif k <= a + b:",
"+ print(a)",
"- sum = a",
"- k -= a",
"-if k <= b:",
"- print(sum)",
"- quit()",
"-else:",
"- k -= b",
"-print((sum - k))",
"+ print((a - (k - a - b)))"
] | false | 0.147558 | 0.036567 | 4.035251 |
[
"s544086068",
"s979514899"
] |
u977389981
|
p03044
|
python
|
s234761496
|
s554380962
| 1,462 | 785 | 154,380 | 81,952 |
Accepted
|
Accepted
| 46.31 |
import sys
sys.setrecursionlimit(10 ** 8)
N = int(eval(input()))
G = [[] for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([b - 1, c])
G[b - 1].append([a - 1, c])
color = [0] * N
def dfs(v, c):
if color[v] == 0:
color[v] = c
for i in range(len(G[v])):
if color[G[v][i][0]] == 0:
if G[v][i][1] % 2 == 0:
dfs(G[v][i][0], color[v])
else:
dfs(G[v][i][0] , -color[v])
for i in range(N):
dfs(i, 1)
# print(color)
for i in range(N):
if color[i] == 1:
print((0))
else:
print((1))
|
N = int(eval(input()))
G = [[] for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([b - 1, c])
G[b - 1].append([a - 1, c])
color = [-1] * N
color[0] = 0
Q = [0]
while len(Q) != 0:
cur = Q.pop()
for to, dist in G[cur]:
if color[to] == -1:
color[to] = (color[cur] + dist) % 2
Q.append(to)
for i in range(N):
print((color[i]))
| 32 | 21 | 698 | 461 |
import sys
sys.setrecursionlimit(10**8)
N = int(eval(input()))
G = [[] for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([b - 1, c])
G[b - 1].append([a - 1, c])
color = [0] * N
def dfs(v, c):
if color[v] == 0:
color[v] = c
for i in range(len(G[v])):
if color[G[v][i][0]] == 0:
if G[v][i][1] % 2 == 0:
dfs(G[v][i][0], color[v])
else:
dfs(G[v][i][0], -color[v])
for i in range(N):
dfs(i, 1)
# print(color)
for i in range(N):
if color[i] == 1:
print((0))
else:
print((1))
|
N = int(eval(input()))
G = [[] for i in range(N)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
G[a - 1].append([b - 1, c])
G[b - 1].append([a - 1, c])
color = [-1] * N
color[0] = 0
Q = [0]
while len(Q) != 0:
cur = Q.pop()
for to, dist in G[cur]:
if color[to] == -1:
color[to] = (color[cur] + dist) % 2
Q.append(to)
for i in range(N):
print((color[i]))
| false | 34.375 |
[
"-import sys",
"-",
"-sys.setrecursionlimit(10**8)",
"-color = [0] * N",
"-",
"-",
"-def dfs(v, c):",
"- if color[v] == 0:",
"- color[v] = c",
"- for i in range(len(G[v])):",
"- if color[G[v][i][0]] == 0:",
"- if G[v][i][1] % 2 == 0:",
"- dfs(G[v][i][0], color[v])",
"- else:",
"- dfs(G[v][i][0], -color[v])",
"-",
"-",
"+color = [-1] * N",
"+color[0] = 0",
"+Q = [0]",
"+while len(Q) != 0:",
"+ cur = Q.pop()",
"+ for to, dist in G[cur]:",
"+ if color[to] == -1:",
"+ color[to] = (color[cur] + dist) % 2",
"+ Q.append(to)",
"- dfs(i, 1)",
"- # print(color)",
"-for i in range(N):",
"- if color[i] == 1:",
"- print((0))",
"- else:",
"- print((1))",
"+ print((color[i]))"
] | false | 0.060517 | 0.04047 | 1.495346 |
[
"s234761496",
"s554380962"
] |
u906501980
|
p03354
|
python
|
s858299505
|
s940661354
| 490 | 326 | 14,008 | 12,392 |
Accepted
|
Accepted
| 33.47 |
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
x = root(x)
y = root(y)
if x != y:
parent[y] = x
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.buffer.readline
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n+1))
rank = [0]*(n+1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
x = root(x)
y = root(y)
if x != y:
parent[y] = x
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| 38 | 40 | 903 | 950 |
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n + 1))
rank = [0] * (n + 1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
x = root(x)
y = root(y)
if x != y:
parent[y] = x
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
import sys
input = sys.stdin.buffer.readline
def main():
n, m = list(map(int, input().split()))
p = list(map(int, input().split()))
parent = list(range(n + 1))
rank = [0] * (n + 1)
cnt = 0
def root(x):
if parent[x] == x:
return x
parent[x] = root(parent[x])
return parent[x]
def unite(x, y):
x = root(x)
y = root(y)
if x != y:
if rank[x] < rank[y]:
parent[x] = y
elif rank[x] > rank[y]:
parent[y] = x
else:
parent[y] = x
rank[x] += 1
for _ in range(m):
x, y = list(map(int, input().split()))
x = root(x)
y = root(y)
if x != y:
parent[y] = x
for i, pi in enumerate(p, 1):
if root(i) == root(pi):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| false | 5 |
[
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"+",
"+"
] | false | 0.063163 | 0.038266 | 1.650608 |
[
"s858299505",
"s940661354"
] |
u523087093
|
p02571
|
python
|
s796443660
|
s530135931
| 438 | 56 | 73,764 | 9,016 |
Accepted
|
Accepted
| 87.21 |
S = eval(input())
T = eval(input())
max_count = 0
for start_t in range(len(T)):
for start_s in range(start_t, len(S)):
if len(S) - start_s < len(T) - start_t:
break
if T[start_t] == S[start_s]:
count = 0
for i in range(len(T) - start_t):
if T[start_t+i] == S[start_s+i]:
count += 1
max_count = max(max_count, count)
answer = len(T) - max_count
print(answer)
|
S = eval(input())
T = eval(input())
answer = float('inf')
for s in range(len(S)):
if len(S) - s < len(T):
break
count = 0
for i in range(len(T)):
if S[s+i] != T[i]:
count += 1
answer = min(answer, count)
print(answer)
| 20 | 16 | 486 | 268 |
S = eval(input())
T = eval(input())
max_count = 0
for start_t in range(len(T)):
for start_s in range(start_t, len(S)):
if len(S) - start_s < len(T) - start_t:
break
if T[start_t] == S[start_s]:
count = 0
for i in range(len(T) - start_t):
if T[start_t + i] == S[start_s + i]:
count += 1
max_count = max(max_count, count)
answer = len(T) - max_count
print(answer)
|
S = eval(input())
T = eval(input())
answer = float("inf")
for s in range(len(S)):
if len(S) - s < len(T):
break
count = 0
for i in range(len(T)):
if S[s + i] != T[i]:
count += 1
answer = min(answer, count)
print(answer)
| false | 20 |
[
"-max_count = 0",
"-for start_t in range(len(T)):",
"- for start_s in range(start_t, len(S)):",
"- if len(S) - start_s < len(T) - start_t:",
"- break",
"- if T[start_t] == S[start_s]:",
"- count = 0",
"- for i in range(len(T) - start_t):",
"- if T[start_t + i] == S[start_s + i]:",
"- count += 1",
"- max_count = max(max_count, count)",
"-answer = len(T) - max_count",
"+answer = float(\"inf\")",
"+for s in range(len(S)):",
"+ if len(S) - s < len(T):",
"+ break",
"+ count = 0",
"+ for i in range(len(T)):",
"+ if S[s + i] != T[i]:",
"+ count += 1",
"+ answer = min(answer, count)"
] | false | 0.078614 | 0.036193 | 2.172083 |
[
"s796443660",
"s530135931"
] |
u483896240
|
p03075
|
python
|
s428432983
|
s782654670
| 24 | 17 | 3,064 | 2,940 |
Accepted
|
Accepted
| 29.17 |
# -*- coding: utf-8 -*-
l = []
for i in range(5):
b = int(eval(input()))
l.append(b)
k = int(eval(input()))
a = []
for i in range(4):
for j in range(i+1,5):
ans = l[j]-l[i]
a.append(ans)
b = 0
for i in range(10):
if a[i]>k:
b = 1
break
if b == 1:
print(':(')
elif b == 0:
print('Yay!')
|
# -*- coding: utf-8 -*-
L = []
for i in range(5):
a = int(eval(input()))
L.append(a)
K = int(eval(input()))
if L[4]-L[0]<=K:
ans = 'Yay!'
else:
ans = ':('
print(ans)
| 26 | 15 | 360 | 187 |
# -*- coding: utf-8 -*-
l = []
for i in range(5):
b = int(eval(input()))
l.append(b)
k = int(eval(input()))
a = []
for i in range(4):
for j in range(i + 1, 5):
ans = l[j] - l[i]
a.append(ans)
b = 0
for i in range(10):
if a[i] > k:
b = 1
break
if b == 1:
print(":(")
elif b == 0:
print("Yay!")
|
# -*- coding: utf-8 -*-
L = []
for i in range(5):
a = int(eval(input()))
L.append(a)
K = int(eval(input()))
if L[4] - L[0] <= K:
ans = "Yay!"
else:
ans = ":("
print(ans)
| false | 42.307692 |
[
"-l = []",
"+L = []",
"- b = int(eval(input()))",
"- l.append(b)",
"-k = int(eval(input()))",
"-a = []",
"-for i in range(4):",
"- for j in range(i + 1, 5):",
"- ans = l[j] - l[i]",
"- a.append(ans)",
"-b = 0",
"-for i in range(10):",
"- if a[i] > k:",
"- b = 1",
"- break",
"-if b == 1:",
"- print(\":(\")",
"-elif b == 0:",
"- print(\"Yay!\")",
"+ a = int(eval(input()))",
"+ L.append(a)",
"+K = int(eval(input()))",
"+if L[4] - L[0] <= K:",
"+ ans = \"Yay!\"",
"+else:",
"+ ans = \":(\"",
"+print(ans)"
] | false | 0.077153 | 0.056965 | 1.354387 |
[
"s428432983",
"s782654670"
] |
u353797797
|
p03087
|
python
|
s961913401
|
s972996918
| 1,104 | 363 | 5,780 | 8,212 |
Accepted
|
Accepted
| 67.12 |
from bisect import bisect_left as b_l
n,q=list(map(int,input().split()))
s=eval(input())
pi=0
aci=[]
while 1:
ni=s[pi:].find("AC")
if ni==-1:
break
aci+=[ni+pi]
pi+=ni+1
for i in range(q):
si,ei=list(map(int,input().split()))
print((b_l(aci,ei-1)-b_l(aci,si-1)))
|
from collections import *
from heapq import *
import sys
sys.setrecursionlimit(10 ** 5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def MI1(): return map(int1, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LI1(): return list(map(int1, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
dij = [(1, 0), (-1, 0), (0, 1), (0, -1)]
def main():
n,q=MI()
s=SI()
cs=[0]*(n+1)
for i in range(n-1):
if s[i:i+2]=="AC":cs[i+2]+=1
for i in range(n):cs[i+1]+=cs[i]
for _ in range(q):
l,r=MI()
l,r=l-1,r-1
ans=cs[r+1]-cs[l]
if s[l-1:l+1]=="AC":ans-=1
print(ans)
main()
| 14 | 32 | 287 | 917 |
from bisect import bisect_left as b_l
n, q = list(map(int, input().split()))
s = eval(input())
pi = 0
aci = []
while 1:
ni = s[pi:].find("AC")
if ni == -1:
break
aci += [ni + pi]
pi += ni + 1
for i in range(q):
si, ei = list(map(int, input().split()))
print((b_l(aci, ei - 1) - b_l(aci, si - 1)))
|
from collections import *
from heapq import *
import sys
sys.setrecursionlimit(10**5)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II():
return int(sys.stdin.readline())
def MI():
return map(int, sys.stdin.readline().split())
def MI1():
return map(int1, sys.stdin.readline().split())
def LI():
return list(map(int, sys.stdin.readline().split()))
def LI1():
return list(map(int1, sys.stdin.readline().split()))
def LLI(rows_number):
return [LI() for _ in range(rows_number)]
def SI():
return sys.stdin.readline()[:-1]
dij = [(1, 0), (-1, 0), (0, 1), (0, -1)]
def main():
n, q = MI()
s = SI()
cs = [0] * (n + 1)
for i in range(n - 1):
if s[i : i + 2] == "AC":
cs[i + 2] += 1
for i in range(n):
cs[i + 1] += cs[i]
for _ in range(q):
l, r = MI()
l, r = l - 1, r - 1
ans = cs[r + 1] - cs[l]
if s[l - 1 : l + 1] == "AC":
ans -= 1
print(ans)
main()
| false | 56.25 |
[
"-from bisect import bisect_left as b_l",
"+from collections import *",
"+from heapq import *",
"+import sys",
"-n, q = list(map(int, input().split()))",
"-s = eval(input())",
"-pi = 0",
"-aci = []",
"-while 1:",
"- ni = s[pi:].find(\"AC\")",
"- if ni == -1:",
"- break",
"- aci += [ni + pi]",
"- pi += ni + 1",
"-for i in range(q):",
"- si, ei = list(map(int, input().split()))",
"- print((b_l(aci, ei - 1) - b_l(aci, si - 1)))",
"+sys.setrecursionlimit(10**5)",
"+int1 = lambda x: int(x) - 1",
"+p2D = lambda x: print(*x, sep=\"\\n\")",
"+",
"+",
"+def II():",
"+ return int(sys.stdin.readline())",
"+",
"+",
"+def MI():",
"+ return map(int, sys.stdin.readline().split())",
"+",
"+",
"+def MI1():",
"+ return map(int1, sys.stdin.readline().split())",
"+",
"+",
"+def LI():",
"+ return list(map(int, sys.stdin.readline().split()))",
"+",
"+",
"+def LI1():",
"+ return list(map(int1, sys.stdin.readline().split()))",
"+",
"+",
"+def LLI(rows_number):",
"+ return [LI() for _ in range(rows_number)]",
"+",
"+",
"+def SI():",
"+ return sys.stdin.readline()[:-1]",
"+",
"+",
"+dij = [(1, 0), (-1, 0), (0, 1), (0, -1)]",
"+",
"+",
"+def main():",
"+ n, q = MI()",
"+ s = SI()",
"+ cs = [0] * (n + 1)",
"+ for i in range(n - 1):",
"+ if s[i : i + 2] == \"AC\":",
"+ cs[i + 2] += 1",
"+ for i in range(n):",
"+ cs[i + 1] += cs[i]",
"+ for _ in range(q):",
"+ l, r = MI()",
"+ l, r = l - 1, r - 1",
"+ ans = cs[r + 1] - cs[l]",
"+ if s[l - 1 : l + 1] == \"AC\":",
"+ ans -= 1",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.046309 | 0.038649 | 1.198198 |
[
"s961913401",
"s972996918"
] |
u888933875
|
p03210
|
python
|
s957469174
|
s986731512
| 29 | 25 | 9,056 | 8,740 |
Accepted
|
Accepted
| 13.79 |
ans=["YES","NO"][eval(input()) not in "357"]
print(ans)
|
print((["NO","YES"][eval(input()) in "357"]))
| 2 | 1 | 50 | 37 |
ans = ["YES", "NO"][eval(input()) not in "357"]
print(ans)
|
print((["NO", "YES"][eval(input()) in "357"]))
| false | 50 |
[
"-ans = [\"YES\", \"NO\"][eval(input()) not in \"357\"]",
"-print(ans)",
"+print(([\"NO\", \"YES\"][eval(input()) in \"357\"]))"
] | false | 0.035971 | 0.073893 | 0.486791 |
[
"s957469174",
"s986731512"
] |
u401487574
|
p03645
|
python
|
s353033678
|
s119168694
| 919 | 641 | 38,320 | 6,260 |
Accepted
|
Accepted
| 30.25 |
ma = lambda :map(int,input().split())
n,m = ma()
tr = [[] for i in range(n)]
for i in range(m):
a,b = ma()
tr[a-1].append(b-1)
tr[b-1].append(a-1)
f = False
for i in tr[0]:
for s in tr[i]:
if s==n-1:
f =True
print("POSSIBLE") if f else print("IMPOSSIBLE")
|
ma = lambda :map(int,input().split())
n,m = ma()
st = [False]*(n+1)
goal = [False]*(n+1)
for i in range(m):
a,b = ma()
if a==n:
goal[b] =True
if b==n:
goal[a] =True
if a==1:
st[b] = True
if b==1:
st[a] = True
f = False
for i in range(1,n+1):
if st[i] and goal[i]:
f=True
print("POSSIBLE") if f else print("IMPOSSIBLE")
| 13 | 20 | 304 | 407 |
ma = lambda: map(int, input().split())
n, m = ma()
tr = [[] for i in range(n)]
for i in range(m):
a, b = ma()
tr[a - 1].append(b - 1)
tr[b - 1].append(a - 1)
f = False
for i in tr[0]:
for s in tr[i]:
if s == n - 1:
f = True
print("POSSIBLE") if f else print("IMPOSSIBLE")
|
ma = lambda: map(int, input().split())
n, m = ma()
st = [False] * (n + 1)
goal = [False] * (n + 1)
for i in range(m):
a, b = ma()
if a == n:
goal[b] = True
if b == n:
goal[a] = True
if a == 1:
st[b] = True
if b == 1:
st[a] = True
f = False
for i in range(1, n + 1):
if st[i] and goal[i]:
f = True
print("POSSIBLE") if f else print("IMPOSSIBLE")
| false | 35 |
[
"-tr = [[] for i in range(n)]",
"+st = [False] * (n + 1)",
"+goal = [False] * (n + 1)",
"- tr[a - 1].append(b - 1)",
"- tr[b - 1].append(a - 1)",
"+ if a == n:",
"+ goal[b] = True",
"+ if b == n:",
"+ goal[a] = True",
"+ if a == 1:",
"+ st[b] = True",
"+ if b == 1:",
"+ st[a] = True",
"-for i in tr[0]:",
"- for s in tr[i]:",
"- if s == n - 1:",
"- f = True",
"+for i in range(1, n + 1):",
"+ if st[i] and goal[i]:",
"+ f = True"
] | false | 0.112578 | 0.040522 | 2.778173 |
[
"s353033678",
"s119168694"
] |
u075012704
|
p03745
|
python
|
s025518354
|
s099978487
| 84 | 76 | 14,252 | 14,252 |
Accepted
|
Accepted
| 9.52 |
N = int(eval(input()))
A = list(map(int, input().split()))
First = True
ans = 1
status = None
for i in range(1, N):
if First:
if A[i-1] < A[i]:
status = "up"
First = False
continue
elif A[i-1] > A[i]:
status = "down"
First = False
continue
if (status == "up") & (A[i-1] > A[i]):
ans += 1
First = True
continue
if (status == "down") & (A[i-1] < A[i]):
ans += 1
First = True
continue
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
status = "Unset"
for i in range(1, N):
if status == "Unset":
if A[i-1] < A[i]:
status = "UP"
elif A[i-1] > A[i]:
status = "DOWN"
else:
if status == "UP" and A[i-1] > A[i]:
ans += 1
status = "Unset"
if status == "DOWN" and A[i-1] < A[i]:
ans += 1
status = "Unset"
print(ans)
| 32 | 22 | 574 | 472 |
N = int(eval(input()))
A = list(map(int, input().split()))
First = True
ans = 1
status = None
for i in range(1, N):
if First:
if A[i - 1] < A[i]:
status = "up"
First = False
continue
elif A[i - 1] > A[i]:
status = "down"
First = False
continue
if (status == "up") & (A[i - 1] > A[i]):
ans += 1
First = True
continue
if (status == "down") & (A[i - 1] < A[i]):
ans += 1
First = True
continue
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
status = "Unset"
for i in range(1, N):
if status == "Unset":
if A[i - 1] < A[i]:
status = "UP"
elif A[i - 1] > A[i]:
status = "DOWN"
else:
if status == "UP" and A[i - 1] > A[i]:
ans += 1
status = "Unset"
if status == "DOWN" and A[i - 1] < A[i]:
ans += 1
status = "Unset"
print(ans)
| false | 31.25 |
[
"-First = True",
"-status = None",
"+status = \"Unset\"",
"- if First:",
"+ if status == \"Unset\":",
"- status = \"up\"",
"- First = False",
"- continue",
"+ status = \"UP\"",
"- status = \"down\"",
"- First = False",
"- continue",
"- if (status == \"up\") & (A[i - 1] > A[i]):",
"- ans += 1",
"- First = True",
"- continue",
"- if (status == \"down\") & (A[i - 1] < A[i]):",
"- ans += 1",
"- First = True",
"- continue",
"+ status = \"DOWN\"",
"+ else:",
"+ if status == \"UP\" and A[i - 1] > A[i]:",
"+ ans += 1",
"+ status = \"Unset\"",
"+ if status == \"DOWN\" and A[i - 1] < A[i]:",
"+ ans += 1",
"+ status = \"Unset\""
] | false | 0.048442 | 0.047936 | 1.010562 |
[
"s025518354",
"s099978487"
] |
u847467233
|
p00629
|
python
|
s539091048
|
s397256424
| 30 | 20 | 5,620 | 5,624 |
Accepted
|
Accepted
| 33.33 |
# AOJ 1043: Selecting Teams Advanced to Regional
# Python3 2018.7.6 bal4u
def pr(i, u):
global total
print((team[i][0]))
total, affi[u] = total+1, affi[u]+1
while True:
n = int(eval(input()))
if n == 0: break
team = []
for i in range(n):
id, u, a, p = list(map(int, input().split()))
team.append((id, u, a, p))
team.sort(key=lambda x:(-x[2],x[3],x[0]))
total, affi = 0, [0]*1002
for i in range(n):
u = team[i][1]
if total < 10 and affi[u] < 3: pr(i, u)
elif total < 20 and affi[u] < 2: pr(i, u)
elif total < 26 and affi[u] < 1: pr(i, u)
|
# AOJ 1043: Selecting Teams Advanced to Regional
# Python3 2018.7.6 bal4u
def pr(i, u):
global total
print((team[i][0]))
total, affi[u] = total + 1, affi[u] + 1
while True:
n = int(eval(input()))
if n == 0: break
team = [list(map(int, input().split())) for i in range(n)]
team.sort(key=lambda x: (-x[2], x[3], x[0]))
total, affi = 0, [0] * 1002
for i in range(n):
u = team[i][1]
if total < 10 and affi[u] < 3: pr(i, u)
elif total < 20 and affi[u] < 2: pr(i, u)
elif total < 26 and affi[u] < 1: pr(i, u)
| 22 | 21 | 570 | 589 |
# AOJ 1043: Selecting Teams Advanced to Regional
# Python3 2018.7.6 bal4u
def pr(i, u):
global total
print((team[i][0]))
total, affi[u] = total + 1, affi[u] + 1
while True:
n = int(eval(input()))
if n == 0:
break
team = []
for i in range(n):
id, u, a, p = list(map(int, input().split()))
team.append((id, u, a, p))
team.sort(key=lambda x: (-x[2], x[3], x[0]))
total, affi = 0, [0] * 1002
for i in range(n):
u = team[i][1]
if total < 10 and affi[u] < 3:
pr(i, u)
elif total < 20 and affi[u] < 2:
pr(i, u)
elif total < 26 and affi[u] < 1:
pr(i, u)
|
# AOJ 1043: Selecting Teams Advanced to Regional
# Python3 2018.7.6 bal4u
def pr(i, u):
global total
print((team[i][0]))
total, affi[u] = total + 1, affi[u] + 1
while True:
n = int(eval(input()))
if n == 0:
break
team = [list(map(int, input().split())) for i in range(n)]
team.sort(key=lambda x: (-x[2], x[3], x[0]))
total, affi = 0, [0] * 1002
for i in range(n):
u = team[i][1]
if total < 10 and affi[u] < 3:
pr(i, u)
elif total < 20 and affi[u] < 2:
pr(i, u)
elif total < 26 and affi[u] < 1:
pr(i, u)
| false | 4.545455 |
[
"- team = []",
"- for i in range(n):",
"- id, u, a, p = list(map(int, input().split()))",
"- team.append((id, u, a, p))",
"+ team = [list(map(int, input().split())) for i in range(n)]"
] | false | 0.047964 | 0.06624 | 0.724097 |
[
"s539091048",
"s397256424"
] |
u970197315
|
p02990
|
python
|
s894828374
|
s662746736
| 1,296 | 816 | 3,316 | 9,216 |
Accepted
|
Accepted
| 37.04 |
def factorial_mod(n, mod):
a = 1
for i in range(1, n + 1):
a *= i
a %= mod
return a
def comb_mod(n, k, mod):
if k > n or k < 0:
return 0
fact_n = factorial_mod(n, mod)
fact_k = factorial_mod(k, mod)
fact_n_k = factorial_mod(n - k, mod)
return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod
n,k=list(map(int,input().split()))
MOD=10**9+7
for i in range(1,k+1):
print(((comb_mod(n-k+1,i,MOD)*comb_mod(k-1,i-1,MOD))%MOD))
|
def comb(n,k,mod):
a = 1
b = 1
for i in range(k):
a = a * (n-i) % mod
b = b * (i+1) % mod
return a * pow(b, mod-2, mod) % mod
n,k=list(map(int,input().split()))
mod=10**9+7
for i in range(1,k+1):
print(((comb(n-k+1,i,mod)*comb(k-1,i-1,mod))%mod))
| 19 | 11 | 487 | 267 |
def factorial_mod(n, mod):
a = 1
for i in range(1, n + 1):
a *= i
a %= mod
return a
def comb_mod(n, k, mod):
if k > n or k < 0:
return 0
fact_n = factorial_mod(n, mod)
fact_k = factorial_mod(k, mod)
fact_n_k = factorial_mod(n - k, mod)
return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod
n, k = list(map(int, input().split()))
MOD = 10**9 + 7
for i in range(1, k + 1):
print(((comb_mod(n - k + 1, i, MOD) * comb_mod(k - 1, i - 1, MOD)) % MOD))
|
def comb(n, k, mod):
a = 1
b = 1
for i in range(k):
a = a * (n - i) % mod
b = b * (i + 1) % mod
return a * pow(b, mod - 2, mod) % mod
n, k = list(map(int, input().split()))
mod = 10**9 + 7
for i in range(1, k + 1):
print(((comb(n - k + 1, i, mod) * comb(k - 1, i - 1, mod)) % mod))
| false | 42.105263 |
[
"-def factorial_mod(n, mod):",
"+def comb(n, k, mod):",
"- for i in range(1, n + 1):",
"- a *= i",
"- a %= mod",
"- return a",
"-",
"-",
"-def comb_mod(n, k, mod):",
"- if k > n or k < 0:",
"- return 0",
"- fact_n = factorial_mod(n, mod)",
"- fact_k = factorial_mod(k, mod)",
"- fact_n_k = factorial_mod(n - k, mod)",
"- return (fact_n * pow(fact_k, mod - 2, mod) * pow(fact_n_k, mod - 2, mod)) % mod",
"+ b = 1",
"+ for i in range(k):",
"+ a = a * (n - i) % mod",
"+ b = b * (i + 1) % mod",
"+ return a * pow(b, mod - 2, mod) % mod",
"-MOD = 10**9 + 7",
"+mod = 10**9 + 7",
"- print(((comb_mod(n - k + 1, i, MOD) * comb_mod(k - 1, i - 1, MOD)) % MOD))",
"+ print(((comb(n - k + 1, i, mod) * comb(k - 1, i - 1, mod)) % mod))"
] | false | 0.039131 | 0.112186 | 0.348808 |
[
"s894828374",
"s662746736"
] |
u905582793
|
p03038
|
python
|
s317227968
|
s830219781
| 761 | 485 | 82,456 | 74,520 |
Accepted
|
Accepted
| 36.27 |
import bisect
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
bc=[list(map(int,input().split())) for i in range(m)]
a.sort()
bc.sort(key=lambda x:x[1],reverse=True)
s=0
for i in range(m):
if a[s]<bc[i][1]:
t=bisect.bisect_left(a,bc[i][1],s,n)
for j in range(s,min(t,s+bc[i][0])):
a[j]=bc[i][1]
s=min(t,s+bc[i][0])
if s>=n:
break
else:
break
print((sum(a)))
|
import bisect
import sys
input=sys.stdin.readline
from operator import itemgetter
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
bc=[list(map(int,input().split())) for i in range(m)]
a.sort()
bc.sort(key=itemgetter(1),reverse=True)
s=0
ans=0
for i in range(m):
if a[s]<bc[i][1]:
t=bisect.bisect_left(a,bc[i][1],s,n)
cvt=min(t-s,bc[i][0])
ans+=bc[i][1]*cvt
s+=cvt
if s>=n:
break
else:
break
print((ans+sum(a[s:])))
| 18 | 22 | 422 | 482 |
import bisect
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [list(map(int, input().split())) for i in range(m)]
a.sort()
bc.sort(key=lambda x: x[1], reverse=True)
s = 0
for i in range(m):
if a[s] < bc[i][1]:
t = bisect.bisect_left(a, bc[i][1], s, n)
for j in range(s, min(t, s + bc[i][0])):
a[j] = bc[i][1]
s = min(t, s + bc[i][0])
if s >= n:
break
else:
break
print((sum(a)))
|
import bisect
import sys
input = sys.stdin.readline
from operator import itemgetter
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
bc = [list(map(int, input().split())) for i in range(m)]
a.sort()
bc.sort(key=itemgetter(1), reverse=True)
s = 0
ans = 0
for i in range(m):
if a[s] < bc[i][1]:
t = bisect.bisect_left(a, bc[i][1], s, n)
cvt = min(t - s, bc[i][0])
ans += bc[i][1] * cvt
s += cvt
if s >= n:
break
else:
break
print((ans + sum(a[s:])))
| false | 18.181818 |
[
"+import sys",
"+",
"+input = sys.stdin.readline",
"+from operator import itemgetter",
"-bc.sort(key=lambda x: x[1], reverse=True)",
"+bc.sort(key=itemgetter(1), reverse=True)",
"+ans = 0",
"- for j in range(s, min(t, s + bc[i][0])):",
"- a[j] = bc[i][1]",
"- s = min(t, s + bc[i][0])",
"+ cvt = min(t - s, bc[i][0])",
"+ ans += bc[i][1] * cvt",
"+ s += cvt",
"-print((sum(a)))",
"+print((ans + sum(a[s:])))"
] | false | 0.048635 | 0.044604 | 1.090363 |
[
"s317227968",
"s830219781"
] |
u633068244
|
p00009
|
python
|
s978269324
|
s678216335
| 1,180 | 260 | 35,632 | 36,984 |
Accepted
|
Accepted
| 77.97 |
n = []
while True:
try:
n.append(int(input()))
except:
break
R = max(n)+1
p = [1]*R
p[0] = p[1] = 0
i = 2
while i*i <= R:
if p[i]:
p[2*i::i] = [0 for x in range(2*i,R,i)]
i += p[i+1:].index(1)+1
for i in n:
print(sum(p[:i+1]))
|
n = []
while True:
try:n.append(int(input()))
except:break
R = max(n)+1
p = [1]*R
p[0] = p[1] = 0
p[4::2] = [0 for i in range(4,R,2)]
for i in range(3,int(R**0.5)+1,2):
if p[i]:
p[2*i::i] = [0]*len(p[2*i::i])
for i in n:
print(sum(p[:i+1]))
| 17 | 13 | 291 | 280 |
n = []
while True:
try:
n.append(int(input()))
except:
break
R = max(n) + 1
p = [1] * R
p[0] = p[1] = 0
i = 2
while i * i <= R:
if p[i]:
p[2 * i :: i] = [0 for x in range(2 * i, R, i)]
i += p[i + 1 :].index(1) + 1
for i in n:
print(sum(p[: i + 1]))
|
n = []
while True:
try:
n.append(int(input()))
except:
break
R = max(n) + 1
p = [1] * R
p[0] = p[1] = 0
p[4::2] = [0 for i in range(4, R, 2)]
for i in range(3, int(R**0.5) + 1, 2):
if p[i]:
p[2 * i :: i] = [0] * len(p[2 * i :: i])
for i in n:
print(sum(p[: i + 1]))
| false | 23.529412 |
[
"-i = 2",
"-while i * i <= R:",
"+p[4::2] = [0 for i in range(4, R, 2)]",
"+for i in range(3, int(R**0.5) + 1, 2):",
"- p[2 * i :: i] = [0 for x in range(2 * i, R, i)]",
"- i += p[i + 1 :].index(1) + 1",
"+ p[2 * i :: i] = [0] * len(p[2 * i :: i])"
] | false | 0.035569 | 0.036751 | 0.967844 |
[
"s978269324",
"s678216335"
] |
u633068244
|
p00735
|
python
|
s337814921
|
s569359515
| 4,180 | 2,530 | 7,724 | 7,556 |
Accepted
|
Accepted
| 39.47 |
p = [1]*300003
p[0] = p[1] = 0
for i in range(2,300003):
if p[i] and i%7 in (1,6):
p[2*i::i] = [0]*len(p[2*i::i])
else:
p[i] = 0
prime = [i for i in range(2,300003) if p[i]]
while 1:
N = int(input())
if N == 1: break
ans = [p for p in prime if N%p == 0]
print("%d: %s"%(N," ".join(map(str,ans))))
|
from bisect import *
p = [1]*300003
p[0] = p[1] = 0
for i in range(2,300003):
if p[i] and i%7 in (1,6):
p[2*i::i] = [0]*len(p[2*i::i])
else:
p[i] = 0
p = [i for i in range(2,300003) if p[i]]
while 1:
N = int(input())
if N == 1: break
ans = [i for i in p[:bisect(p,N+1)] if N%i == 0]
print("%d: %s"%(N," ".join(map(str,ans))))
| 14 | 15 | 355 | 385 |
p = [1] * 300003
p[0] = p[1] = 0
for i in range(2, 300003):
if p[i] and i % 7 in (1, 6):
p[2 * i :: i] = [0] * len(p[2 * i :: i])
else:
p[i] = 0
prime = [i for i in range(2, 300003) if p[i]]
while 1:
N = int(input())
if N == 1:
break
ans = [p for p in prime if N % p == 0]
print("%d: %s" % (N, " ".join(map(str, ans))))
|
from bisect import *
p = [1] * 300003
p[0] = p[1] = 0
for i in range(2, 300003):
if p[i] and i % 7 in (1, 6):
p[2 * i :: i] = [0] * len(p[2 * i :: i])
else:
p[i] = 0
p = [i for i in range(2, 300003) if p[i]]
while 1:
N = int(input())
if N == 1:
break
ans = [i for i in p[: bisect(p, N + 1)] if N % i == 0]
print("%d: %s" % (N, " ".join(map(str, ans))))
| false | 6.666667 |
[
"+from bisect import *",
"+",
"-prime = [i for i in range(2, 300003) if p[i]]",
"+p = [i for i in range(2, 300003) if p[i]]",
"- ans = [p for p in prime if N % p == 0]",
"+ ans = [i for i in p[: bisect(p, N + 1)] if N % i == 0]"
] | false | 0.173212 | 0.246553 | 0.702536 |
[
"s337814921",
"s569359515"
] |
u145950990
|
p03324
|
python
|
s607707847
|
s144939925
| 184 | 166 | 38,384 | 38,256 |
Accepted
|
Accepted
| 9.78 |
d,n = list(map(int,input().split()))
if 100**d*n%(100**(d+1))==0:
print((100**d*(n+1)))
else:
print((100**d*n))
|
d,n = list(map(int,input().split()))
if n==100:
print((100**d*(n+1)))
else:
print((100**d*n))
| 5 | 5 | 113 | 95 |
d, n = list(map(int, input().split()))
if 100**d * n % (100 ** (d + 1)) == 0:
print((100**d * (n + 1)))
else:
print((100**d * n))
|
d, n = list(map(int, input().split()))
if n == 100:
print((100**d * (n + 1)))
else:
print((100**d * n))
| false | 0 |
[
"-if 100**d * n % (100 ** (d + 1)) == 0:",
"+if n == 100:"
] | false | 0.101715 | 0.041679 | 2.440447 |
[
"s607707847",
"s144939925"
] |
u729133443
|
p02588
|
python
|
s298406245
|
s963921696
| 1,776 | 1,521 | 88,880 | 89,580 |
Accepted
|
Accepted
| 14.36 |
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*1e9);x=y=1
while a%2**x<1:x+=1
while a%5**y<1:y+=1
r+=sum(sum(d[max(0,20-y):])for d in c[max(0,20-x):]);c[x][y]+=1
print(r)
|
c=eval('[0]*50,'*50)
r=0
for a in[*open(0)][1:]:
a=round(float(a)*1e9);y=1
while a%5**y<1:y+=1
x=len(bin(a&-a));r+=sum(sum(d[max(0,20-y):])for d in c[max(0,24-x):]);c[x][y]+=1
print(r)
| 8 | 7 | 200 | 193 |
c = eval("[0]*50," * 50)
r = 0
for a in [*open(0)][1:]:
a = round(float(a) * 1e9)
x = y = 1
while a % 2**x < 1:
x += 1
while a % 5**y < 1:
y += 1
r += sum(sum(d[max(0, 20 - y) :]) for d in c[max(0, 20 - x) :])
c[x][y] += 1
print(r)
|
c = eval("[0]*50," * 50)
r = 0
for a in [*open(0)][1:]:
a = round(float(a) * 1e9)
y = 1
while a % 5**y < 1:
y += 1
x = len(bin(a & -a))
r += sum(sum(d[max(0, 20 - y) :]) for d in c[max(0, 24 - x) :])
c[x][y] += 1
print(r)
| false | 12.5 |
[
"- x = y = 1",
"- while a % 2**x < 1:",
"- x += 1",
"+ y = 1",
"- r += sum(sum(d[max(0, 20 - y) :]) for d in c[max(0, 20 - x) :])",
"+ x = len(bin(a & -a))",
"+ r += sum(sum(d[max(0, 20 - y) :]) for d in c[max(0, 24 - x) :])"
] | false | 0.045824 | 0.04619 | 0.99208 |
[
"s298406245",
"s963921696"
] |
u672475305
|
p03862
|
python
|
s278313631
|
s648234343
| 118 | 105 | 14,152 | 14,068 |
Accepted
|
Accepted
| 11.02 |
n,x = list(map(int,input().split()))
lst = [int(i) for i in input().split()]
cnt = 0
if lst[0] > x:
cnt += lst[0]-x
lst[0] = x
for i in range(n-1):
dis = 0
if lst[i]+lst[i+1] > x:
dis = lst[i] + lst[i+1] - x
lst[i+1] -= dis
cnt += dis
print(cnt)
|
n,k = list(map(int,input().split()))
A = list(map(int,input().split()))
ans = 0
if A[0]>k:
ans += A[0]-k
A[0] = k
for i in range(1, n):
if A[i]+A[i-1]<=k:
continue
ans += (A[i]+A[i-1])-k
A[i] = k-A[i-1]
print(ans)
| 17 | 12 | 299 | 246 |
n, x = list(map(int, input().split()))
lst = [int(i) for i in input().split()]
cnt = 0
if lst[0] > x:
cnt += lst[0] - x
lst[0] = x
for i in range(n - 1):
dis = 0
if lst[i] + lst[i + 1] > x:
dis = lst[i] + lst[i + 1] - x
lst[i + 1] -= dis
cnt += dis
print(cnt)
|
n, k = list(map(int, input().split()))
A = list(map(int, input().split()))
ans = 0
if A[0] > k:
ans += A[0] - k
A[0] = k
for i in range(1, n):
if A[i] + A[i - 1] <= k:
continue
ans += (A[i] + A[i - 1]) - k
A[i] = k - A[i - 1]
print(ans)
| false | 29.411765 |
[
"-n, x = list(map(int, input().split()))",
"-lst = [int(i) for i in input().split()]",
"-cnt = 0",
"-if lst[0] > x:",
"- cnt += lst[0] - x",
"- lst[0] = x",
"-for i in range(n - 1):",
"- dis = 0",
"- if lst[i] + lst[i + 1] > x:",
"- dis = lst[i] + lst[i + 1] - x",
"- lst[i + 1] -= dis",
"- cnt += dis",
"-print(cnt)",
"+n, k = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+ans = 0",
"+if A[0] > k:",
"+ ans += A[0] - k",
"+ A[0] = k",
"+for i in range(1, n):",
"+ if A[i] + A[i - 1] <= k:",
"+ continue",
"+ ans += (A[i] + A[i - 1]) - k",
"+ A[i] = k - A[i - 1]",
"+print(ans)"
] | false | 0.045348 | 0.044001 | 1.030609 |
[
"s278313631",
"s648234343"
] |
u614197626
|
p02247
|
python
|
s941267911
|
s672219549
| 30 | 20 | 7,476 | 7,428 |
Accepted
|
Accepted
| 33.33 |
T = eval(input())
P = eval(input())
idx = 0
ans = 1000
while (ans != -1):
ans = T.find(P, idx)
if (ans == -1):
break
else:
print(ans)
if (ans==0):
idx+=1
else:
idx=ans+1
|
T = eval(input())
P = eval(input())
idx = 0
while (1):
ans = T.find(P, idx)
if (ans == -1):
break
else:
print(ans)
if (ans==0):
idx+=1
else:
idx=ans+1
| 14 | 13 | 238 | 218 |
T = eval(input())
P = eval(input())
idx = 0
ans = 1000
while ans != -1:
ans = T.find(P, idx)
if ans == -1:
break
else:
print(ans)
if ans == 0:
idx += 1
else:
idx = ans + 1
|
T = eval(input())
P = eval(input())
idx = 0
while 1:
ans = T.find(P, idx)
if ans == -1:
break
else:
print(ans)
if ans == 0:
idx += 1
else:
idx = ans + 1
| false | 7.142857 |
[
"-ans = 1000",
"-while ans != -1:",
"+while 1:"
] | false | 0.040723 | 0.034512 | 1.179955 |
[
"s941267911",
"s672219549"
] |
u873139556
|
p03240
|
python
|
s950031005
|
s607921797
| 45 | 41 | 3,064 | 3,064 |
Accepted
|
Accepted
| 8.89 |
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
#高さが0でない情報を探す
for i in range(n):
if xyh[i][2] != 0:
x_ex, y_ex, h_ex = xyh[i]
break
for cx in range(101): #Cx 0~100
for cy in range(101): #Cy 0~100
h = abs(x_ex - cx) + abs(y_ex - cy) + h_ex #高さHを求める
#先程出した高さHが他の例にも当てはまるか確認
flag = 0
for i in range(n):
x_i, y_i, h_i = xyh[i]
if h_i == max(h - abs(x_i - cx) - abs(y_i - cy), 0):
flag += 1
else:
break
if flag == n:
print((cx, cy, h))
|
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
#高さが0でない情報を探す
for i in range(n):
if xyh[i][2] != 0:
x_ex, y_ex, h_ex = xyh[i]
break
for cx in range(101): #Cx 0~100
for cy in range(101): #Cy 0~100
h = abs(x_ex - cx) + abs(y_ex - cy) + h_ex #高さHを求める
#先程出した高さHが他の例にも当てはまるか確認
flag = 0
for i in range(n):
x_i, y_i, h_i = xyh[i]
if h_i == max(h - abs(x_i - cx) - abs(y_i - cy), 0):
flag += 1
else:
break
if flag == n:
print((cx, cy, h))
exit()
| 27 | 28 | 649 | 669 |
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
# 高さが0でない情報を探す
for i in range(n):
if xyh[i][2] != 0:
x_ex, y_ex, h_ex = xyh[i]
break
for cx in range(101): # Cx 0~100
for cy in range(101): # Cy 0~100
h = abs(x_ex - cx) + abs(y_ex - cy) + h_ex # 高さHを求める
# 先程出した高さHが他の例にも当てはまるか確認
flag = 0
for i in range(n):
x_i, y_i, h_i = xyh[i]
if h_i == max(h - abs(x_i - cx) - abs(y_i - cy), 0):
flag += 1
else:
break
if flag == n:
print((cx, cy, h))
|
n = int(eval(input()))
xyh = []
for i in range(n):
xyh.append(list(map(int, input().split())))
# 高さが0でない情報を探す
for i in range(n):
if xyh[i][2] != 0:
x_ex, y_ex, h_ex = xyh[i]
break
for cx in range(101): # Cx 0~100
for cy in range(101): # Cy 0~100
h = abs(x_ex - cx) + abs(y_ex - cy) + h_ex # 高さHを求める
# 先程出した高さHが他の例にも当てはまるか確認
flag = 0
for i in range(n):
x_i, y_i, h_i = xyh[i]
if h_i == max(h - abs(x_i - cx) - abs(y_i - cy), 0):
flag += 1
else:
break
if flag == n:
print((cx, cy, h))
exit()
| false | 3.571429 |
[
"+ exit()"
] | false | 0.073588 | 0.183316 | 0.40143 |
[
"s950031005",
"s607921797"
] |
u510829608
|
p02256
|
python
|
s607443886
|
s518677520
| 50 | 20 | 7,648 | 7,628 |
Accepted
|
Accepted
| 60 |
a,b = list(map(int,input().split()))
while a % b != 0:
a,b = b, a % b
print(b)
|
def gcm(x,y):
while y:
x, y = y, x % y
return x
a,b = list(map(int, input().split()))
print((gcm(a,b)))
| 4 | 7 | 76 | 118 |
a, b = list(map(int, input().split()))
while a % b != 0:
a, b = b, a % b
print(b)
|
def gcm(x, y):
while y:
x, y = y, x % y
return x
a, b = list(map(int, input().split()))
print((gcm(a, b)))
| false | 42.857143 |
[
"+def gcm(x, y):",
"+ while y:",
"+ x, y = y, x % y",
"+ return x",
"+",
"+",
"-while a % b != 0:",
"- a, b = b, a % b",
"-print(b)",
"+print((gcm(a, b)))"
] | false | 0.036983 | 0.034674 | 1.066583 |
[
"s607443886",
"s518677520"
] |
u133936772
|
p02548
|
python
|
s241291104
|
s922800593
| 167 | 116 | 9,148 | 9,124 |
Accepted
|
Accepted
| 30.54 |
n=int(eval(input()))
a=0
for i in range(1,n):
a+=(n-1)//i
print(a)
|
n=int(eval(input()))-1
print((sum(n//-~i for i in range(n))))
| 5 | 2 | 66 | 54 |
n = int(eval(input()))
a = 0
for i in range(1, n):
a += (n - 1) // i
print(a)
|
n = int(eval(input())) - 1
print((sum(n // -~i for i in range(n))))
| false | 60 |
[
"-n = int(eval(input()))",
"-a = 0",
"-for i in range(1, n):",
"- a += (n - 1) // i",
"-print(a)",
"+n = int(eval(input())) - 1",
"+print((sum(n // -~i for i in range(n))))"
] | false | 0.077976 | 0.065028 | 1.199126 |
[
"s241291104",
"s922800593"
] |
u094191970
|
p02691
|
python
|
s898907153
|
s932967453
| 249 | 187 | 63,280 | 50,704 |
Accepted
|
Accepted
| 24.9 |
from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
l1=[i+a[i] for i in range(n)]
l2=[i-a[i] for i in range(n)]
c1=Counter(l1)
c2=Counter(l2)
ans=0
for i in c1:
ans+=c1[i]*c2[i]
print(ans)
|
from collections import Counter
n=int(eval(input()))
a=list(map(int,input().split()))
l1=[i+a[i] for i in range(n)]
l2=[i-a[i] for i in range(n)]
c2=Counter(l2)
ans=0
for i in l1:
ans+=c2[i]
print(ans)
| 16 | 15 | 238 | 216 |
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
l1 = [i + a[i] for i in range(n)]
l2 = [i - a[i] for i in range(n)]
c1 = Counter(l1)
c2 = Counter(l2)
ans = 0
for i in c1:
ans += c1[i] * c2[i]
print(ans)
|
from collections import Counter
n = int(eval(input()))
a = list(map(int, input().split()))
l1 = [i + a[i] for i in range(n)]
l2 = [i - a[i] for i in range(n)]
c2 = Counter(l2)
ans = 0
for i in l1:
ans += c2[i]
print(ans)
| false | 6.25 |
[
"-c1 = Counter(l1)",
"-for i in c1:",
"- ans += c1[i] * c2[i]",
"+for i in l1:",
"+ ans += c2[i]"
] | false | 0.042228 | 0.042659 | 0.989902 |
[
"s898907153",
"s932967453"
] |
u061539997
|
p02832
|
python
|
s901450379
|
s558720833
| 106 | 93 | 24,744 | 26,268 |
Accepted
|
Accepted
| 12.26 |
N = int(eval(input()))
a = list(map(int,input().split()))
b = 1
for i in range(N):
if b == a[i]:
b += 1
if b == 1:
print((-1))
else:
print((N-b+1))
|
N = int(eval(input()))
a = list(map(int,input().split()))
b = 1
for i in a:
if b == i:
b += 1
if b == 1:
print((-1))
else:
print((N-b+1))
| 10 | 10 | 166 | 156 |
N = int(eval(input()))
a = list(map(int, input().split()))
b = 1
for i in range(N):
if b == a[i]:
b += 1
if b == 1:
print((-1))
else:
print((N - b + 1))
|
N = int(eval(input()))
a = list(map(int, input().split()))
b = 1
for i in a:
if b == i:
b += 1
if b == 1:
print((-1))
else:
print((N - b + 1))
| false | 0 |
[
"-for i in range(N):",
"- if b == a[i]:",
"+for i in a:",
"+ if b == i:"
] | false | 0.045599 | 0.038393 | 1.1877 |
[
"s901450379",
"s558720833"
] |
u652057333
|
p02793
|
python
|
s243996112
|
s989097742
| 1,995 | 728 | 263,140 | 15,020 |
Accepted
|
Accepted
| 63.51 |
from functools import reduce
# python > pypy
MOD = 10**9 + 7
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(x, y):
return (x * y) // gcd(x, y)
def gcd_list(numbers):
return reduce(gcd, numbers)
def lcm_list(numbers):
return reduce(lcm, numbers)
n = int(eval(input()))
a = list(map(int, input().split()))
lcm_ = lcm_list(a)
b = list([lcm_//x for x in a])
ans = 0
for i in range(len(b)):
ans += b[i]
print((ans% MOD))
|
from collections import defaultdict
class LCM_mod:
"""
最小公倍数の計算を行う
オーバーフローが発生しないように素因数分解し,
因数の積を逐次余りに置き換えて最小公倍数を導出する.
"""
def __init__(self, max_num, p=10**9+7):
self.max_num = max_num + 1
self.p = p
self.prime = [0 for _ in range(self.max_num)]
self.max_map = defaultdict(int)
self.sieve()
def rep_sqr(self, base, k):
# 繰り返し二乗法
if k == 0:
return 1
elif k % 2 == 0:
return (self.rep_sqr(base, k / 2) ** 2) % self.p
else:
return (self.rep_sqr(base, k - 1) * base) % self.p
def sieve(self):
"""
エラトステネスの篩 O(n)
nまでに含まれる素数を導出
"""
self.prime[0], self.prime[1] = 1, 1
for i in range(2, self.max_num):
if self.prime[i] == 0:
for j in range(i * 2, self.max_num, i):
if self.prime[j] == 0:
self.prime[j] = i
self.prime[i] = i
def lcm_list_mod(self, arr):
"""
listのそれぞれの要素について、素因数分解する
それぞれの因数について最大であれば更新する
"""
for i in range(len(arr)):
num = arr[i]
d = defaultdict(int)
while num > 1:
fact = self.prime[num]
d[fact] += 1
num //= fact
for i in list(d.keys()):
self.max_map[i] = max(self.max_map[i], d[i])
ans = 1
for i in list(self.max_map.keys()):
ans = (ans * self.rep_sqr(i, self.max_map[i])) % self.p
return ans
class FLT:
def __init__(self, mod=10**9+7):
self.mod = mod
def rep_sqr(self, base, k):
if k == 0:
return 1
elif k % 2 == 0:
return (self.rep_sqr(base, k // 2) ** 2) % self.mod
else:
return (self.rep_sqr(base, k - 1) * base) % self.mod
def inv(self, a):
""" 逆元を取る """
return self.rep_sqr(a, self.mod-2)
n = int(eval(input()))
a = list(map(int, input().split()))
MOD = 10**9+7
lcm_mod = LCM_mod(max(a), MOD)
lcm_all = lcm_mod.lcm_list_mod(a)
flt = FLT(MOD)
b = list([lcm_all * flt.inv(x) for x in a])
ans = 0
for i in range(len(b)):
ans += b[i]
ans %= MOD
print(ans)
| 26 | 90 | 485 | 2,333 |
from functools import reduce
# python > pypy
MOD = 10**9 + 7
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(x, y):
return (x * y) // gcd(x, y)
def gcd_list(numbers):
return reduce(gcd, numbers)
def lcm_list(numbers):
return reduce(lcm, numbers)
n = int(eval(input()))
a = list(map(int, input().split()))
lcm_ = lcm_list(a)
b = list([lcm_ // x for x in a])
ans = 0
for i in range(len(b)):
ans += b[i]
print((ans % MOD))
|
from collections import defaultdict
class LCM_mod:
"""
最小公倍数の計算を行う
オーバーフローが発生しないように素因数分解し,
因数の積を逐次余りに置き換えて最小公倍数を導出する.
"""
def __init__(self, max_num, p=10**9 + 7):
self.max_num = max_num + 1
self.p = p
self.prime = [0 for _ in range(self.max_num)]
self.max_map = defaultdict(int)
self.sieve()
def rep_sqr(self, base, k):
# 繰り返し二乗法
if k == 0:
return 1
elif k % 2 == 0:
return (self.rep_sqr(base, k / 2) ** 2) % self.p
else:
return (self.rep_sqr(base, k - 1) * base) % self.p
def sieve(self):
"""
エラトステネスの篩 O(n)
nまでに含まれる素数を導出
"""
self.prime[0], self.prime[1] = 1, 1
for i in range(2, self.max_num):
if self.prime[i] == 0:
for j in range(i * 2, self.max_num, i):
if self.prime[j] == 0:
self.prime[j] = i
self.prime[i] = i
def lcm_list_mod(self, arr):
"""
listのそれぞれの要素について、素因数分解する
それぞれの因数について最大であれば更新する
"""
for i in range(len(arr)):
num = arr[i]
d = defaultdict(int)
while num > 1:
fact = self.prime[num]
d[fact] += 1
num //= fact
for i in list(d.keys()):
self.max_map[i] = max(self.max_map[i], d[i])
ans = 1
for i in list(self.max_map.keys()):
ans = (ans * self.rep_sqr(i, self.max_map[i])) % self.p
return ans
class FLT:
def __init__(self, mod=10**9 + 7):
self.mod = mod
def rep_sqr(self, base, k):
if k == 0:
return 1
elif k % 2 == 0:
return (self.rep_sqr(base, k // 2) ** 2) % self.mod
else:
return (self.rep_sqr(base, k - 1) * base) % self.mod
def inv(self, a):
"""逆元を取る"""
return self.rep_sqr(a, self.mod - 2)
n = int(eval(input()))
a = list(map(int, input().split()))
MOD = 10**9 + 7
lcm_mod = LCM_mod(max(a), MOD)
lcm_all = lcm_mod.lcm_list_mod(a)
flt = FLT(MOD)
b = list([lcm_all * flt.inv(x) for x in a])
ans = 0
for i in range(len(b)):
ans += b[i]
ans %= MOD
print(ans)
| false | 71.111111 |
[
"-from functools import reduce",
"-",
"-# python > pypy",
"-MOD = 10**9 + 7",
"+from collections import defaultdict",
"-def gcd(a, b):",
"- while b:",
"- a, b = b, a % b",
"- return a",
"+class LCM_mod:",
"+ \"\"\"",
"+ 最小公倍数の計算を行う",
"+ オーバーフローが発生しないように素因数分解し,",
"+ 因数の積を逐次余りに置き換えて最小公倍数を導出する.",
"+ \"\"\"",
"+",
"+ def __init__(self, max_num, p=10**9 + 7):",
"+ self.max_num = max_num + 1",
"+ self.p = p",
"+ self.prime = [0 for _ in range(self.max_num)]",
"+ self.max_map = defaultdict(int)",
"+ self.sieve()",
"+",
"+ def rep_sqr(self, base, k):",
"+ # 繰り返し二乗法",
"+ if k == 0:",
"+ return 1",
"+ elif k % 2 == 0:",
"+ return (self.rep_sqr(base, k / 2) ** 2) % self.p",
"+ else:",
"+ return (self.rep_sqr(base, k - 1) * base) % self.p",
"+",
"+ def sieve(self):",
"+ \"\"\"",
"+ エラトステネスの篩 O(n)",
"+ nまでに含まれる素数を導出",
"+ \"\"\"",
"+ self.prime[0], self.prime[1] = 1, 1",
"+ for i in range(2, self.max_num):",
"+ if self.prime[i] == 0:",
"+ for j in range(i * 2, self.max_num, i):",
"+ if self.prime[j] == 0:",
"+ self.prime[j] = i",
"+ self.prime[i] = i",
"+",
"+ def lcm_list_mod(self, arr):",
"+ \"\"\"",
"+ listのそれぞれの要素について、素因数分解する",
"+ それぞれの因数について最大であれば更新する",
"+ \"\"\"",
"+ for i in range(len(arr)):",
"+ num = arr[i]",
"+ d = defaultdict(int)",
"+ while num > 1:",
"+ fact = self.prime[num]",
"+ d[fact] += 1",
"+ num //= fact",
"+ for i in list(d.keys()):",
"+ self.max_map[i] = max(self.max_map[i], d[i])",
"+ ans = 1",
"+ for i in list(self.max_map.keys()):",
"+ ans = (ans * self.rep_sqr(i, self.max_map[i])) % self.p",
"+ return ans",
"-def lcm(x, y):",
"- return (x * y) // gcd(x, y)",
"+class FLT:",
"+ def __init__(self, mod=10**9 + 7):",
"+ self.mod = mod",
"+ def rep_sqr(self, base, k):",
"+ if k == 0:",
"+ return 1",
"+ elif k % 2 == 0:",
"+ return (self.rep_sqr(base, k // 2) ** 2) % self.mod",
"+ else:",
"+ return (self.rep_sqr(base, k - 1) * base) % self.mod",
"-def gcd_list(numbers):",
"- return reduce(gcd, numbers)",
"-",
"-",
"-def lcm_list(numbers):",
"- return reduce(lcm, numbers)",
"+ def inv(self, a):",
"+ \"\"\"逆元を取る\"\"\"",
"+ return self.rep_sqr(a, self.mod - 2)",
"-lcm_ = lcm_list(a)",
"-b = list([lcm_ // x for x in a])",
"+MOD = 10**9 + 7",
"+lcm_mod = LCM_mod(max(a), MOD)",
"+lcm_all = lcm_mod.lcm_list_mod(a)",
"+flt = FLT(MOD)",
"+b = list([lcm_all * flt.inv(x) for x in a])",
"-print((ans % MOD))",
"+ ans %= MOD",
"+print(ans)"
] | false | 0.052136 | 0.301338 | 0.173015 |
[
"s243996112",
"s989097742"
] |
u633068244
|
p00135
|
python
|
s558785041
|
s577195491
| 20 | 10 | 4,220 | 4,220 |
Accepted
|
Accepted
| 50 |
for roop in range(int(input())):
h,m = list(map(int,input().split(":")))
s = 120*h + 2*m
l = 24*m
if l < s: l,s = s,l
arg = l - s if l - s < 180*4 else 360*4-(l-s)
if arg < 30*4: print("alert")
elif arg < 90*4: print("warning")
else : print("safe")
|
for roop in range(int(input())):
h,m = list(map(int,input().split(":")))
s = 60*h + m
l = 12*m
if l < s: l,s = s,l
arg = l - s if l - s < 180*2 else 360*2-(l-s)
if arg < 30*2: print("alert")
elif arg < 90*2: print("warning")
else : print("safe")
| 9 | 9 | 299 | 296 |
for roop in range(int(input())):
h, m = list(map(int, input().split(":")))
s = 120 * h + 2 * m
l = 24 * m
if l < s:
l, s = s, l
arg = l - s if l - s < 180 * 4 else 360 * 4 - (l - s)
if arg < 30 * 4:
print("alert")
elif arg < 90 * 4:
print("warning")
else:
print("safe")
|
for roop in range(int(input())):
h, m = list(map(int, input().split(":")))
s = 60 * h + m
l = 12 * m
if l < s:
l, s = s, l
arg = l - s if l - s < 180 * 2 else 360 * 2 - (l - s)
if arg < 30 * 2:
print("alert")
elif arg < 90 * 2:
print("warning")
else:
print("safe")
| false | 0 |
[
"- s = 120 * h + 2 * m",
"- l = 24 * m",
"+ s = 60 * h + m",
"+ l = 12 * m",
"- arg = l - s if l - s < 180 * 4 else 360 * 4 - (l - s)",
"- if arg < 30 * 4:",
"+ arg = l - s if l - s < 180 * 2 else 360 * 2 - (l - s)",
"+ if arg < 30 * 2:",
"- elif arg < 90 * 4:",
"+ elif arg < 90 * 2:"
] | false | 0.031787 | 0.066043 | 0.48131 |
[
"s558785041",
"s577195491"
] |
u926393759
|
p03108
|
python
|
s411894313
|
s066333442
| 621 | 447 | 30,788 | 30,896 |
Accepted
|
Accepted
| 28.02 |
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 12 10:38:04 2019
D - Decayed Bridges
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
400
点
@author: justwah
"""
import sys
read = sys.stdin.readline
n, m = list(map(int, read().split()))
score = n * (n-1) // 2
l = reversed([list(tuple(map(int, input().split()))) for i in range(m)])
parent = [i for i in range(n+1)]
rank = [0]*(n+1)
size = [1]*(n+1)
def root(x): #recursively find root for a node
if parent[x] == x: # if at root, return self
return x
else:
parent[x] = root(parent[x]) # while searching rejoint queried node to a common parent for hierarchical tree
return parent[x]
def merge(a, b):
a = root(a)
b = root(b)
if rank[a] < rank[b]: # joint lower rank node to a higher rank one
parent[a] = b
else:
parent[b] = a
if rank[a] == rank[b]: # rank only change if two same rank node joined
rank[a] +=1
size[a] += size[b]
size[b] = size[a]
return
ans = [score]
for a, b in l:
a = root(a)
b = root(b)
if a != b:
score -= size[a] * size[b]
merge(a, b)
ans.append(score)
else:
ans.append(score)
print((*reversed(ans[:-1])))
|
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 12 10:38:04 2019
D - Decayed Bridges
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
400
点
@author: justwah
"""
import sys
read = sys.stdin.readline
n, m = list(map(int, input().split()))
score = n * (n-1) // 2
l = reversed([list(tuple(map(int, read().split()))) for i in range(m)])
parent = [i for i in range(n+1)]
rank = [0]*(n+1)
size = [1]*(n+1)
def root(x): #recursively find root for a node
if parent[x] == x: # if at root, return self
return x
else:
parent[x] = root(parent[x]) # while searching rejoint queried node to a common parent for hierarchical tree
return parent[x]
def merge(a, b):
a = root(a)
b = root(b)
if rank[a] < rank[b]: # joint lower rank node to a higher rank one
parent[a] = b
else:
parent[b] = a
if rank[a] == rank[b]: # rank only change if two same rank node joined
rank[a] +=1
size[a] += size[b]
size[b] = size[a]
return
ans = [score]
for a, b in l:
a = root(a)
b = root(b)
if a != b:
score -= size[a] * size[b]
merge(a, b)
ans.append(score)
else:
ans.append(score)
print((*reversed(ans[:-1])))
| 56 | 56 | 1,271 | 1,271 |
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 12 10:38:04 2019
D - Decayed Bridges
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
400
点
@author: justwah
"""
import sys
read = sys.stdin.readline
n, m = list(map(int, read().split()))
score = n * (n - 1) // 2
l = reversed([list(tuple(map(int, input().split()))) for i in range(m)])
parent = [i for i in range(n + 1)]
rank = [0] * (n + 1)
size = [1] * (n + 1)
def root(x): # recursively find root for a node
if parent[x] == x: # if at root, return self
return x
else:
parent[x] = root(
parent[x]
) # while searching rejoint queried node to a common parent for hierarchical tree
return parent[x]
def merge(a, b):
a = root(a)
b = root(b)
if rank[a] < rank[b]: # joint lower rank node to a higher rank one
parent[a] = b
else:
parent[b] = a
if rank[a] == rank[b]: # rank only change if two same rank node joined
rank[a] += 1
size[a] += size[b]
size[b] = size[a]
return
ans = [score]
for a, b in l:
a = root(a)
b = root(b)
if a != b:
score -= size[a] * size[b]
merge(a, b)
ans.append(score)
else:
ans.append(score)
print((*reversed(ans[:-1])))
|
# -*- coding: utf-8 -*-
"""
Created on Thu Sep 12 10:38:04 2019
D - Decayed Bridges
実行時間制限: 2 sec / メモリ制限: 1024 MB
配点 :
400
点
@author: justwah
"""
import sys
read = sys.stdin.readline
n, m = list(map(int, input().split()))
score = n * (n - 1) // 2
l = reversed([list(tuple(map(int, read().split()))) for i in range(m)])
parent = [i for i in range(n + 1)]
rank = [0] * (n + 1)
size = [1] * (n + 1)
def root(x): # recursively find root for a node
if parent[x] == x: # if at root, return self
return x
else:
parent[x] = root(
parent[x]
) # while searching rejoint queried node to a common parent for hierarchical tree
return parent[x]
def merge(a, b):
a = root(a)
b = root(b)
if rank[a] < rank[b]: # joint lower rank node to a higher rank one
parent[a] = b
else:
parent[b] = a
if rank[a] == rank[b]: # rank only change if two same rank node joined
rank[a] += 1
size[a] += size[b]
size[b] = size[a]
return
ans = [score]
for a, b in l:
a = root(a)
b = root(b)
if a != b:
score -= size[a] * size[b]
merge(a, b)
ans.append(score)
else:
ans.append(score)
print((*reversed(ans[:-1])))
| false | 0 |
[
"-n, m = list(map(int, read().split()))",
"+n, m = list(map(int, input().split()))",
"-l = reversed([list(tuple(map(int, input().split()))) for i in range(m)])",
"+l = reversed([list(tuple(map(int, read().split()))) for i in range(m)])"
] | false | 0.091993 | 0.036596 | 2.513739 |
[
"s411894313",
"s066333442"
] |
u387774811
|
p02762
|
python
|
s437961895
|
s852386974
| 1,527 | 741 | 100,056 | 18,832 |
Accepted
|
Accepted
| 51.47 |
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
N,M,K = list(map(int,input().split()))
uf = UnionFind(N)
lst=[0]*(N)
ans=[0]*(N)
for i in range(M):
A,B=list(map(int,input().split()))
uf.union(A-1,B-1)
lst[A-1]+=1
lst[B-1]+=1
for i in range(K):
A,B=list(map(int,input().split()))
if uf.same(A-1,B-1):
lst[A-1]+=1
lst[B-1]+=1
for i in range(N):
ans[i]=uf.size(i)-lst[i]-1
L=[str(a) for a in ans]
L=' '.join(L)
print(L)
|
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
import sys
input = sys.stdin.readline
N,M,K = list(map(int,input().split()))
uf = UnionFind(N)
lst=[0]*(N)
ans=[0]*(N)
for i in range(M):
A,B=list(map(int,input().split()))
uf.union(A-1,B-1)
lst[A-1]+=1
lst[B-1]+=1
for i in range(K):
A,B=list(map(int,input().split()))
if uf.same(A-1,B-1):
lst[A-1]+=1
lst[B-1]+=1
for i in range(N):
ans[i]=uf.size(i)-lst[i]-1
L=[str(a) for a in ans]
L=' '.join(L)
print(L)
| 49 | 80 | 955 | 1,569 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
lst = [0] * (N)
ans = [0] * (N)
for i in range(M):
A, B = list(map(int, input().split()))
uf.union(A - 1, B - 1)
lst[A - 1] += 1
lst[B - 1] += 1
for i in range(K):
A, B = list(map(int, input().split()))
if uf.same(A - 1, B - 1):
lst[A - 1] += 1
lst[B - 1] += 1
for i in range(N):
ans[i] = uf.size(i) - lst[i] - 1
L = [str(a) for a in ans]
L = " ".join(L)
print(L)
|
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
import sys
input = sys.stdin.readline
N, M, K = list(map(int, input().split()))
uf = UnionFind(N)
lst = [0] * (N)
ans = [0] * (N)
for i in range(M):
A, B = list(map(int, input().split()))
uf.union(A - 1, B - 1)
lst[A - 1] += 1
lst[B - 1] += 1
for i in range(K):
A, B = list(map(int, input().split()))
if uf.same(A - 1, B - 1):
lst[A - 1] += 1
lst[B - 1] += 1
for i in range(N):
ans[i] = uf.size(i) - lst[i] - 1
L = [str(a) for a in ans]
L = " ".join(L)
print(L)
| false | 38.75 |
[
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.parents = [-1] * n",
"+",
"+ def find(self, x):",
"+ if self.parents[x] < 0:",
"+ return x",
"+ else:",
"+ self.parents[x] = self.find(self.parents[x])",
"+ return self.parents[x]",
"+",
"+ def union(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ if self.parents[x] > self.parents[y]:",
"+ x, y = y, x",
"+ self.parents[x] += self.parents[y]",
"+ self.parents[y] = x",
"+",
"+ def size(self, x):",
"+ return -self.parents[self.find(x)]",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"+",
"+",
"+import sys",
"+",
"+input = sys.stdin.readline"
] | false | 0.133746 | 0.070249 | 1.903886 |
[
"s437961895",
"s852386974"
] |
u597374218
|
p03555
|
python
|
s686795233
|
s357984264
| 19 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 10.53 |
a=eval(input())
b=eval(input())
print(("YES" if a==b[::-1] else "NO"))
|
print(("YES" if eval(input())==input()[::-1] else "NO"))
| 3 | 1 | 58 | 48 |
a = eval(input())
b = eval(input())
print(("YES" if a == b[::-1] else "NO"))
|
print(("YES" if eval(input()) == input()[::-1] else "NO"))
| false | 66.666667 |
[
"-a = eval(input())",
"-b = eval(input())",
"-print((\"YES\" if a == b[::-1] else \"NO\"))",
"+print((\"YES\" if eval(input()) == input()[::-1] else \"NO\"))"
] | false | 0.060412 | 0.045699 | 1.321954 |
[
"s686795233",
"s357984264"
] |
u814986259
|
p02900
|
python
|
s646437491
|
s319654312
| 215 | 131 | 5,216 | 5,304 |
Accepted
|
Accepted
| 39.07 |
from math import sqrt, ceil
import fractions
A, B = list(map(int, input().split()))
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n**0.5)+1):
if n % i == 0:
return False
return True
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)
return divisors
ans = 1
tmp = make_divisors(fractions.gcd(A, B))
for x in tmp:
if is_prime(x):
ans += 1
print(ans)
|
def main():
import fractions
import math
A, B = list(map(int, input().split()))
gcd = fractions.gcd(A, B)
tmp = gcd
ans = 1
for i in range(2, int(-(-gcd**0.5//1))+1):
if tmp % i == 0:
ans += 1
while(tmp % i == 0):
tmp = tmp//i
if tmp != 1:
ans += 1
print(ans)
main()
| 34 | 20 | 605 | 376 |
from math import sqrt, ceil
import fractions
A, B = list(map(int, input().split()))
def is_prime(n):
if n == 1:
return False
for i in range(2, int(n**0.5) + 1):
if n % i == 0:
return False
return True
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)
return divisors
ans = 1
tmp = make_divisors(fractions.gcd(A, B))
for x in tmp:
if is_prime(x):
ans += 1
print(ans)
|
def main():
import fractions
import math
A, B = list(map(int, input().split()))
gcd = fractions.gcd(A, B)
tmp = gcd
ans = 1
for i in range(2, int(-(-(gcd**0.5) // 1)) + 1):
if tmp % i == 0:
ans += 1
while tmp % i == 0:
tmp = tmp // i
if tmp != 1:
ans += 1
print(ans)
main()
| false | 41.176471 |
[
"-from math import sqrt, ceil",
"-import fractions",
"+def main():",
"+ import fractions",
"+ import math",
"-A, B = list(map(int, input().split()))",
"+ A, B = list(map(int, input().split()))",
"+ gcd = fractions.gcd(A, B)",
"+ tmp = gcd",
"+ ans = 1",
"+ for i in range(2, int(-(-(gcd**0.5) // 1)) + 1):",
"+ if tmp % i == 0:",
"+ ans += 1",
"+ while tmp % i == 0:",
"+ tmp = tmp // i",
"+ if tmp != 1:",
"+ ans += 1",
"+ print(ans)",
"-def is_prime(n):",
"- if n == 1:",
"- return False",
"- for i in range(2, int(n**0.5) + 1):",
"- if n % i == 0:",
"- return False",
"- return True",
"-",
"-",
"-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)",
"- return divisors",
"-",
"-",
"-ans = 1",
"-tmp = make_divisors(fractions.gcd(A, B))",
"-for x in tmp:",
"- if is_prime(x):",
"- ans += 1",
"-print(ans)",
"+main()"
] | false | 0.045326 | 0.045292 | 1.000742 |
[
"s646437491",
"s319654312"
] |
u955251526
|
p03239
|
python
|
s751953102
|
s419805121
| 20 | 17 | 3,188 | 3,060 |
Accepted
|
Accepted
| 15 |
n, limit = list(map(int, input().split()))
c = [0] * n
t = [0] * n
for i in range(n):
c[i], t[i] = list(map(int, input().split()))
intime = []
for i in range(n):
if t[i] <= limit:
intime.append(i)
minn = 100000
for i in intime:
if c[i] < minn:
minn = c[i]
if intime == []:
print('TLE')
else:
print(minn)
|
n, time = list(map(int, input().split()))
path = [tuple(map(int, input().split())) for _ in range(n)]
mincost = 10 ** 9
for c, t in path:
if t <= time:
mincost = min(mincost, c)
if mincost == 10 ** 9:
print('TLE')
else:
print(mincost)
| 17 | 10 | 343 | 257 |
n, limit = list(map(int, input().split()))
c = [0] * n
t = [0] * n
for i in range(n):
c[i], t[i] = list(map(int, input().split()))
intime = []
for i in range(n):
if t[i] <= limit:
intime.append(i)
minn = 100000
for i in intime:
if c[i] < minn:
minn = c[i]
if intime == []:
print("TLE")
else:
print(minn)
|
n, time = list(map(int, input().split()))
path = [tuple(map(int, input().split())) for _ in range(n)]
mincost = 10**9
for c, t in path:
if t <= time:
mincost = min(mincost, c)
if mincost == 10**9:
print("TLE")
else:
print(mincost)
| false | 41.176471 |
[
"-n, limit = list(map(int, input().split()))",
"-c = [0] * n",
"-t = [0] * n",
"-for i in range(n):",
"- c[i], t[i] = list(map(int, input().split()))",
"-intime = []",
"-for i in range(n):",
"- if t[i] <= limit:",
"- intime.append(i)",
"-minn = 100000",
"-for i in intime:",
"- if c[i] < minn:",
"- minn = c[i]",
"-if intime == []:",
"+n, time = list(map(int, input().split()))",
"+path = [tuple(map(int, input().split())) for _ in range(n)]",
"+mincost = 10**9",
"+for c, t in path:",
"+ if t <= time:",
"+ mincost = min(mincost, c)",
"+if mincost == 10**9:",
"- print(minn)",
"+ print(mincost)"
] | false | 0.04771 | 0.047594 | 1.002431 |
[
"s751953102",
"s419805121"
] |
u197300773
|
p02744
|
python
|
s805208252
|
s491340312
| 1,087 | 550 | 86,108 | 4,412 |
Accepted
|
Accepted
| 49.4 |
def cur(n):
if ans[n]!=[]: return ans[n]
for x in cur(n-1):
tmp1=[0]+[x[i] for i in range(n-1)]
tmp2=[0]+[x[i]+1 for i in range(n-1)]
ans[n].append(tmp1)
ans[n].append(tmp2)
if max(x)!=0:
for k in range(1,max(x)+1):
tmp3=[0]+[x[i] for i in range(n-1)]
for i in range(1,n):
if tmp3[i]==k: tmp3[i]=0
elif tmp3[i]<k: tmp3[i]+=1
ans[n].append(tmp3)
return ans[n]
def pri(x):
s=""
for i in range(p):
s+=chr( ord("a")+x[i] )
print(s)
p=int(eval(input()))
ans=[[] for i in range(11)]
ans[1]=[[0]]
ans[2]=[[0,0],[0,1]]
cur(p)
ans[p].sort()
pri(ans[p][0])
for i in range(1,len(ans[p])):
if ans[p][i]!=ans[p][i-1]: pri(ans[p][i])
|
n=int(eval(input()))
def cur(x):
if len(x)==n:
s="".join([chr( ord("a")+x[i]) for i in range(n)])
print(s)
else:
for i in range(max(x)+2):
cur(x+[i])
cur([0])
| 33 | 11 | 830 | 210 |
def cur(n):
if ans[n] != []:
return ans[n]
for x in cur(n - 1):
tmp1 = [0] + [x[i] for i in range(n - 1)]
tmp2 = [0] + [x[i] + 1 for i in range(n - 1)]
ans[n].append(tmp1)
ans[n].append(tmp2)
if max(x) != 0:
for k in range(1, max(x) + 1):
tmp3 = [0] + [x[i] for i in range(n - 1)]
for i in range(1, n):
if tmp3[i] == k:
tmp3[i] = 0
elif tmp3[i] < k:
tmp3[i] += 1
ans[n].append(tmp3)
return ans[n]
def pri(x):
s = ""
for i in range(p):
s += chr(ord("a") + x[i])
print(s)
p = int(eval(input()))
ans = [[] for i in range(11)]
ans[1] = [[0]]
ans[2] = [[0, 0], [0, 1]]
cur(p)
ans[p].sort()
pri(ans[p][0])
for i in range(1, len(ans[p])):
if ans[p][i] != ans[p][i - 1]:
pri(ans[p][i])
|
n = int(eval(input()))
def cur(x):
if len(x) == n:
s = "".join([chr(ord("a") + x[i]) for i in range(n)])
print(s)
else:
for i in range(max(x) + 2):
cur(x + [i])
cur([0])
| false | 66.666667 |
[
"-def cur(n):",
"- if ans[n] != []:",
"- return ans[n]",
"- for x in cur(n - 1):",
"- tmp1 = [0] + [x[i] for i in range(n - 1)]",
"- tmp2 = [0] + [x[i] + 1 for i in range(n - 1)]",
"- ans[n].append(tmp1)",
"- ans[n].append(tmp2)",
"- if max(x) != 0:",
"- for k in range(1, max(x) + 1):",
"- tmp3 = [0] + [x[i] for i in range(n - 1)]",
"- for i in range(1, n):",
"- if tmp3[i] == k:",
"- tmp3[i] = 0",
"- elif tmp3[i] < k:",
"- tmp3[i] += 1",
"- ans[n].append(tmp3)",
"- return ans[n]",
"+n = int(eval(input()))",
"-def pri(x):",
"- s = \"\"",
"- for i in range(p):",
"- s += chr(ord(\"a\") + x[i])",
"- print(s)",
"+def cur(x):",
"+ if len(x) == n:",
"+ s = \"\".join([chr(ord(\"a\") + x[i]) for i in range(n)])",
"+ print(s)",
"+ else:",
"+ for i in range(max(x) + 2):",
"+ cur(x + [i])",
"-p = int(eval(input()))",
"-ans = [[] for i in range(11)]",
"-ans[1] = [[0]]",
"-ans[2] = [[0, 0], [0, 1]]",
"-cur(p)",
"-ans[p].sort()",
"-pri(ans[p][0])",
"-for i in range(1, len(ans[p])):",
"- if ans[p][i] != ans[p][i - 1]:",
"- pri(ans[p][i])",
"+cur([0])"
] | false | 0.044432 | 0.042971 | 1.034013 |
[
"s805208252",
"s491340312"
] |
u414458988
|
p02742
|
python
|
s531744965
|
s910963833
| 194 | 179 | 38,256 | 38,384 |
Accepted
|
Accepted
| 7.73 |
def main():
#from sys import stdin, setrecursionlimit
#setrecursionlimit(10**9)
#r = input()
#n = int(input())
#a, b = map(int, input().split())
#s, y = input().split()
#a = input().split()
#a = list(map(int, input().split()))
#a = [input().split() for i in range(n)]
#a = [int(input()) for i in range(n)]
#a = [list(map(int, input().split())) for i in range(n)]
#a = [int(s) - 1 for s in input().split()]
#l=[int(input()) for _ in range(int(input()))]
#res = 0
h,w=list(map(int,input().split()))
if h == 1 or w == 1:
print((1))
return 0
res = h*w//2
if (h*w)%2 != 0:
res += 1
print(res)
if __name__ == '__main__':
main()
|
def main():
h,w = list(map(int,input().split()))
if h == 1 or w == 1:
print((1))
return 0
print(((h*w+1)//2))
if __name__ == '__main__':
main()
| 27 | 10 | 746 | 177 |
def main():
# from sys import stdin, setrecursionlimit
# setrecursionlimit(10**9)
# r = input()
# n = int(input())
# a, b = map(int, input().split())
# s, y = input().split()
# a = input().split()
# a = list(map(int, input().split()))
# a = [input().split() for i in range(n)]
# a = [int(input()) for i in range(n)]
# a = [list(map(int, input().split())) for i in range(n)]
# a = [int(s) - 1 for s in input().split()]
# l=[int(input()) for _ in range(int(input()))]
# res = 0
h, w = list(map(int, input().split()))
if h == 1 or w == 1:
print((1))
return 0
res = h * w // 2
if (h * w) % 2 != 0:
res += 1
print(res)
if __name__ == "__main__":
main()
|
def main():
h, w = list(map(int, input().split()))
if h == 1 or w == 1:
print((1))
return 0
print(((h * w + 1) // 2))
if __name__ == "__main__":
main()
| false | 62.962963 |
[
"- # from sys import stdin, setrecursionlimit",
"- # setrecursionlimit(10**9)",
"- # r = input()",
"- # n = int(input())",
"- # a, b = map(int, input().split())",
"- # s, y = input().split()",
"- # a = input().split()",
"- # a = list(map(int, input().split()))",
"- # a = [input().split() for i in range(n)]",
"- # a = [int(input()) for i in range(n)]",
"- # a = [list(map(int, input().split())) for i in range(n)]",
"- # a = [int(s) - 1 for s in input().split()]",
"- # l=[int(input()) for _ in range(int(input()))]",
"- # res = 0",
"- res = h * w // 2",
"- if (h * w) % 2 != 0:",
"- res += 1",
"- print(res)",
"+ print(((h * w + 1) // 2))"
] | false | 0.035606 | 0.035874 | 0.992522 |
[
"s531744965",
"s910963833"
] |
u075012704
|
p02659
|
python
|
s822111925
|
s843979636
| 27 | 24 | 10,072 | 9,140 |
Accepted
|
Accepted
| 11.11 |
from decimal import Decimal
A, B = list(map(Decimal, input().split()))
print((int(A * B)))
|
A, B = input().split()
A, B = int(A), int(B.replace('.', ''))
print((A * B // 100))
| 3 | 3 | 85 | 84 |
from decimal import Decimal
A, B = list(map(Decimal, input().split()))
print((int(A * B)))
|
A, B = input().split()
A, B = int(A), int(B.replace(".", ""))
print((A * B // 100))
| false | 0 |
[
"-from decimal import Decimal",
"-",
"-A, B = list(map(Decimal, input().split()))",
"-print((int(A * B)))",
"+A, B = input().split()",
"+A, B = int(A), int(B.replace(\".\", \"\"))",
"+print((A * B // 100))"
] | false | 0.05006 | 0.046962 | 1.065964 |
[
"s822111925",
"s843979636"
] |
u909848367
|
p02594
|
python
|
s975902017
|
s233143956
| 31 | 27 | 9,128 | 9,108 |
Accepted
|
Accepted
| 12.9 |
n=int(eval(input()))
if n>=30:
print("Yes")
elif n<30:
print("No")
|
x=int(eval(input()))
if x>=30:
print("Yes")
else:
print("No")
| 6 | 5 | 78 | 67 |
n = int(eval(input()))
if n >= 30:
print("Yes")
elif n < 30:
print("No")
|
x = int(eval(input()))
if x >= 30:
print("Yes")
else:
print("No")
| false | 16.666667 |
[
"-n = int(eval(input()))",
"-if n >= 30:",
"+x = int(eval(input()))",
"+if x >= 30:",
"-elif n < 30:",
"+else:"
] | false | 0.097459 | 0.124277 | 0.784206 |
[
"s975902017",
"s233143956"
] |
u297109012
|
p03244
|
python
|
s192729068
|
s534354877
| 74 | 63 | 15,972 | 16,808 |
Accepted
|
Accepted
| 14.86 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
a = v[::2]
b = v[1::2]
ac = collections.Counter(a).most_common(2)
bc = collections.Counter(b).most_common(2)
if ac[0][0] != bc[0][0]:
print((n - ac[0][1] - bc[0][1]))
else:
if len(ac) == 1:
print((n // 2))
else:
print((n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])))
|
from collections import Counter
def solve(V):
n = len(V)
ac = Counter(V[::2]).most_common(2)
bc = Counter(V[1::2]).most_common(2)
if ac[0][0] != bc[0][0]:
return n - ac[0][1] - bc[0][1]
else:
if len(bc) == 1 or len(ac) == 1:
return n // 2
else:
return n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])
if __name__ == "__main__":
n = int(eval(input()))
l = eval(input())
print((solve(l.split(" "))))
| 15 | 21 | 380 | 490 |
import collections
n = int(eval(input()))
v = list(map(int, input().split()))
a = v[::2]
b = v[1::2]
ac = collections.Counter(a).most_common(2)
bc = collections.Counter(b).most_common(2)
if ac[0][0] != bc[0][0]:
print((n - ac[0][1] - bc[0][1]))
else:
if len(ac) == 1:
print((n // 2))
else:
print((n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])))
|
from collections import Counter
def solve(V):
n = len(V)
ac = Counter(V[::2]).most_common(2)
bc = Counter(V[1::2]).most_common(2)
if ac[0][0] != bc[0][0]:
return n - ac[0][1] - bc[0][1]
else:
if len(bc) == 1 or len(ac) == 1:
return n // 2
else:
return n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])
if __name__ == "__main__":
n = int(eval(input()))
l = eval(input())
print((solve(l.split(" "))))
| false | 28.571429 |
[
"-import collections",
"+from collections import Counter",
"-n = int(eval(input()))",
"-v = list(map(int, input().split()))",
"-a = v[::2]",
"-b = v[1::2]",
"-ac = collections.Counter(a).most_common(2)",
"-bc = collections.Counter(b).most_common(2)",
"-if ac[0][0] != bc[0][0]:",
"- print((n - ac[0][1] - bc[0][1]))",
"-else:",
"- if len(ac) == 1:",
"- print((n // 2))",
"+",
"+def solve(V):",
"+ n = len(V)",
"+ ac = Counter(V[::2]).most_common(2)",
"+ bc = Counter(V[1::2]).most_common(2)",
"+ if ac[0][0] != bc[0][0]:",
"+ return n - ac[0][1] - bc[0][1]",
"- print((n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])))",
"+ if len(bc) == 1 or len(ac) == 1:",
"+ return n // 2",
"+ else:",
"+ return n - max(ac[0][1] + bc[1][1], ac[1][1] + bc[0][1])",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ n = int(eval(input()))",
"+ l = eval(input())",
"+ print((solve(l.split(\" \"))))"
] | false | 0.037704 | 0.039598 | 0.952156 |
[
"s192729068",
"s534354877"
] |
u131984977
|
p02412
|
python
|
s292449463
|
s591954891
| 1,030 | 580 | 7,664 | 7,676 |
Accepted
|
Accepted
| 43.69 |
while True:
n, x = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for s in range(1, n - 1):
for m in range(s + 1, n):
for e in range(m + 1, n + 1):
if x == sum([s, m, e]):
count += 1
print(count)
|
while True:
n, x = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for s in range(1, n - 1):
for m in range(s + 1, n):
for e in range(m + 1, n + 1):
if x == s + m + e:
count += 1
print(count)
| 14 | 14 | 314 | 309 |
while True:
n, x = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for s in range(1, n - 1):
for m in range(s + 1, n):
for e in range(m + 1, n + 1):
if x == sum([s, m, e]):
count += 1
print(count)
|
while True:
n, x = [int(i) for i in input().split()]
if n == x == 0:
break
count = 0
for s in range(1, n - 1):
for m in range(s + 1, n):
for e in range(m + 1, n + 1):
if x == s + m + e:
count += 1
print(count)
| false | 0 |
[
"- if x == sum([s, m, e]):",
"+ if x == s + m + e:"
] | false | 0.138202 | 0.037827 | 3.653485 |
[
"s292449463",
"s591954891"
] |
u077291787
|
p03380
|
python
|
s761552704
|
s997987238
| 77 | 59 | 14,052 | 14,180 |
Accepted
|
Accepted
| 23.38 |
# ABC094D - Binomial Coefficients (ARC095D)
from bisect import bisect_left as bs
def main():
# pascal's triangle := mid area (nCn/2) is the biggest -> bisect
N = int(eval(input()))
A = sorted(map(int, input().split()))
if N == 2:
print((A[1], A[0]))
return
n, idx = A[-1], bs(A[:-1], A[-1] // 2)
cand = [(abs(A[i] - n / 2), A[i]) for i in (idx - 1, idx, idx + 1)]
r = min(cand)[1]
print((n, r))
if __name__ == "__main__":
main()
|
# ABC094D - Binomial Coefficients (ARC095D)
def main():
# pascal's triangle := mid area (nCn/2) is the biggest
N = int(eval(input()))
A = tuple(map(int, input().split()))
n = max(A)
mid, r, dif = n / 2, -1, float("inf")
for i in A:
if i != n:
x = abs(mid - i)
if x < dif:
r, dif = i, x
print((n, r))
if __name__ == "__main__":
main()
| 19 | 17 | 492 | 423 |
# ABC094D - Binomial Coefficients (ARC095D)
from bisect import bisect_left as bs
def main():
# pascal's triangle := mid area (nCn/2) is the biggest -> bisect
N = int(eval(input()))
A = sorted(map(int, input().split()))
if N == 2:
print((A[1], A[0]))
return
n, idx = A[-1], bs(A[:-1], A[-1] // 2)
cand = [(abs(A[i] - n / 2), A[i]) for i in (idx - 1, idx, idx + 1)]
r = min(cand)[1]
print((n, r))
if __name__ == "__main__":
main()
|
# ABC094D - Binomial Coefficients (ARC095D)
def main():
# pascal's triangle := mid area (nCn/2) is the biggest
N = int(eval(input()))
A = tuple(map(int, input().split()))
n = max(A)
mid, r, dif = n / 2, -1, float("inf")
for i in A:
if i != n:
x = abs(mid - i)
if x < dif:
r, dif = i, x
print((n, r))
if __name__ == "__main__":
main()
| false | 10.526316 |
[
"-from bisect import bisect_left as bs",
"-",
"-",
"- # pascal's triangle := mid area (nCn/2) is the biggest -> bisect",
"+ # pascal's triangle := mid area (nCn/2) is the biggest",
"- A = sorted(map(int, input().split()))",
"- if N == 2:",
"- print((A[1], A[0]))",
"- return",
"- n, idx = A[-1], bs(A[:-1], A[-1] // 2)",
"- cand = [(abs(A[i] - n / 2), A[i]) for i in (idx - 1, idx, idx + 1)]",
"- r = min(cand)[1]",
"+ A = tuple(map(int, input().split()))",
"+ n = max(A)",
"+ mid, r, dif = n / 2, -1, float(\"inf\")",
"+ for i in A:",
"+ if i != n:",
"+ x = abs(mid - i)",
"+ if x < dif:",
"+ r, dif = i, x"
] | false | 0.043733 | 0.04276 | 1.022742 |
[
"s761552704",
"s997987238"
] |
u633068244
|
p00254
|
python
|
s313348375
|
s550354999
| 350 | 190 | 4,236 | 4,208 |
Accepted
|
Accepted
| 45.71 |
while 1:
n=list(input())
if n==["0"]*4: break
elif n[0]==n[1]==n[2]==n[3]:
print("NA")
continue
count=0
while 1:
if n==["6","1","7","4"]:
print(count)
break
n=sorted(n)
l=int("".join(map(str,n[::-1])))
s=int("".join(map(str,n[n.count("0"):])))
n=list(str(l-s))
n=["0"]*(4-len(n))+n
count+=1
|
while 1:
n=input()
if n=="0000": break
if int(n)%1111==0:
print("NA")
continue
ans = 0
while n!="6174":
n="".join(sorted(n))
n=str(int(n[::-1])-int(n)).zfill(4)
ans+=1
print(ans)
| 17 | 12 | 337 | 255 |
while 1:
n = list(input())
if n == ["0"] * 4:
break
elif n[0] == n[1] == n[2] == n[3]:
print("NA")
continue
count = 0
while 1:
if n == ["6", "1", "7", "4"]:
print(count)
break
n = sorted(n)
l = int("".join(map(str, n[::-1])))
s = int("".join(map(str, n[n.count("0") :])))
n = list(str(l - s))
n = ["0"] * (4 - len(n)) + n
count += 1
|
while 1:
n = input()
if n == "0000":
break
if int(n) % 1111 == 0:
print("NA")
continue
ans = 0
while n != "6174":
n = "".join(sorted(n))
n = str(int(n[::-1]) - int(n)).zfill(4)
ans += 1
print(ans)
| false | 29.411765 |
[
"- n = list(input())",
"- if n == [\"0\"] * 4:",
"+ n = input()",
"+ if n == \"0000\":",
"- elif n[0] == n[1] == n[2] == n[3]:",
"+ if int(n) % 1111 == 0:",
"- count = 0",
"- while 1:",
"- if n == [\"6\", \"1\", \"7\", \"4\"]:",
"- print(count)",
"- break",
"- n = sorted(n)",
"- l = int(\"\".join(map(str, n[::-1])))",
"- s = int(\"\".join(map(str, n[n.count(\"0\") :])))",
"- n = list(str(l - s))",
"- n = [\"0\"] * (4 - len(n)) + n",
"- count += 1",
"+ ans = 0",
"+ while n != \"6174\":",
"+ n = \"\".join(sorted(n))",
"+ n = str(int(n[::-1]) - int(n)).zfill(4)",
"+ ans += 1",
"+ print(ans)"
] | false | 0.037589 | 0.044393 | 0.846722 |
[
"s313348375",
"s550354999"
] |
u936985471
|
p03111
|
python
|
s364240415
|
s547162812
| 134 | 112 | 3,188 | 3,188 |
Accepted
|
Accepted
| 16.42 |
N,A,B,C=list(map(int,input().split()))
L=[0]*N
for i in range(N):
L[i]=int(eval(input()))
# ある竹を,Aに使う、Bに使う、Cに使う、どれにも使わない の4パターンで全探索
# A,B,C それぞれに対して2つ目以降は10Pかかる
stack=[]
# Aの長さ、Bの長さ、Cの長さ、処理した竹の本数、消費MP
stack.append([0,0,0,0,0])
ans=1000*10
while stack:
a,b,c,num,mp=stack.pop()
if num==N:
if a==0 or b==0 or c==0:
continue
mp+=abs(A-a)+abs(B-b)+abs(C-c)
if mp<ans:
ans=mp
continue
for i in range(4):
if i==0:
stack.append([a+L[num],b,c,num+1,mp+(a!=0)*10])
if i==1:
stack.append([a,b+L[num],c,num+1,mp+(b!=0)*10])
if i==2:
stack.append([a,b,c+L[num],num+1,mp+(c!=0)*10])
if i==3:
stack.append([a,b,c,num+1,mp])
print(ans)
|
N,A,B,C=list(map(int,input().split()))
L=[0]*N
for i in range(N):
L[i]=int(eval(input()))
# ある竹を,Aに使う、Bに使う、Cに使う、どれにも使わない の4パターンで全探索
# A,B,C それぞれに対して2つ目以降は10Pかかる
stack=[]
# Aの長さ、Bの長さ、Cの長さ、処理した竹の本数、消費MP
stack.append([0,0,0,0,0])
ans=1000*10
while stack:
a,b,c,num,mp=stack.pop()
if num==N:
if a==0 or b==0 or c==0:
continue
mp+=abs(A-a)+abs(B-b)+abs(C-c)
if mp<ans:
ans=mp
continue
stack.append([a+L[num],b,c,num+1,mp+(a!=0)*10])
stack.append([a,b+L[num],c,num+1,mp+(b!=0)*10])
stack.append([a,b,c+L[num],num+1,mp+(c!=0)*10])
stack.append([a,b,c,num+1,mp])
print(ans)
| 31 | 26 | 716 | 622 |
N, A, B, C = list(map(int, input().split()))
L = [0] * N
for i in range(N):
L[i] = int(eval(input()))
# ある竹を,Aに使う、Bに使う、Cに使う、どれにも使わない の4パターンで全探索
# A,B,C それぞれに対して2つ目以降は10Pかかる
stack = []
# Aの長さ、Bの長さ、Cの長さ、処理した竹の本数、消費MP
stack.append([0, 0, 0, 0, 0])
ans = 1000 * 10
while stack:
a, b, c, num, mp = stack.pop()
if num == N:
if a == 0 or b == 0 or c == 0:
continue
mp += abs(A - a) + abs(B - b) + abs(C - c)
if mp < ans:
ans = mp
continue
for i in range(4):
if i == 0:
stack.append([a + L[num], b, c, num + 1, mp + (a != 0) * 10])
if i == 1:
stack.append([a, b + L[num], c, num + 1, mp + (b != 0) * 10])
if i == 2:
stack.append([a, b, c + L[num], num + 1, mp + (c != 0) * 10])
if i == 3:
stack.append([a, b, c, num + 1, mp])
print(ans)
|
N, A, B, C = list(map(int, input().split()))
L = [0] * N
for i in range(N):
L[i] = int(eval(input()))
# ある竹を,Aに使う、Bに使う、Cに使う、どれにも使わない の4パターンで全探索
# A,B,C それぞれに対して2つ目以降は10Pかかる
stack = []
# Aの長さ、Bの長さ、Cの長さ、処理した竹の本数、消費MP
stack.append([0, 0, 0, 0, 0])
ans = 1000 * 10
while stack:
a, b, c, num, mp = stack.pop()
if num == N:
if a == 0 or b == 0 or c == 0:
continue
mp += abs(A - a) + abs(B - b) + abs(C - c)
if mp < ans:
ans = mp
continue
stack.append([a + L[num], b, c, num + 1, mp + (a != 0) * 10])
stack.append([a, b + L[num], c, num + 1, mp + (b != 0) * 10])
stack.append([a, b, c + L[num], num + 1, mp + (c != 0) * 10])
stack.append([a, b, c, num + 1, mp])
print(ans)
| false | 16.129032 |
[
"- for i in range(4):",
"- if i == 0:",
"- stack.append([a + L[num], b, c, num + 1, mp + (a != 0) * 10])",
"- if i == 1:",
"- stack.append([a, b + L[num], c, num + 1, mp + (b != 0) * 10])",
"- if i == 2:",
"- stack.append([a, b, c + L[num], num + 1, mp + (c != 0) * 10])",
"- if i == 3:",
"- stack.append([a, b, c, num + 1, mp])",
"+ stack.append([a + L[num], b, c, num + 1, mp + (a != 0) * 10])",
"+ stack.append([a, b + L[num], c, num + 1, mp + (b != 0) * 10])",
"+ stack.append([a, b, c + L[num], num + 1, mp + (c != 0) * 10])",
"+ stack.append([a, b, c, num + 1, mp])"
] | false | 0.174341 | 0.170811 | 1.020666 |
[
"s364240415",
"s547162812"
] |
u297574184
|
p02843
|
python
|
s588165677
|
s350883050
| 126 | 68 | 21,716 | 3,828 |
Accepted
|
Accepted
| 46.03 |
from collections import deque
def solve(X):
if X >= 2000:
return 1
prices = list(range(100, 106))
Q = deque([(0, 0)])
while Q:
i, pNow = Q.popleft()
if i == 6:
if pNow == X:
return 1
else:
price = prices[i]
for num in range(20):
p2 = pNow + price*num
if p2 > X: break
Q.append((i+1, p2))
return 0
X = int(eval(input()))
print((solve(X)))
|
X = int(eval(input()))
dp = [False] * (X+1)
dp[0] = True
for i in range(1, X+1):
dp[i] = any(dp[i-(X+1)-105:i-(X+1)-99])
print((int(dp[X])))
| 25 | 8 | 511 | 146 |
from collections import deque
def solve(X):
if X >= 2000:
return 1
prices = list(range(100, 106))
Q = deque([(0, 0)])
while Q:
i, pNow = Q.popleft()
if i == 6:
if pNow == X:
return 1
else:
price = prices[i]
for num in range(20):
p2 = pNow + price * num
if p2 > X:
break
Q.append((i + 1, p2))
return 0
X = int(eval(input()))
print((solve(X)))
|
X = int(eval(input()))
dp = [False] * (X + 1)
dp[0] = True
for i in range(1, X + 1):
dp[i] = any(dp[i - (X + 1) - 105 : i - (X + 1) - 99])
print((int(dp[X])))
| false | 68 |
[
"-from collections import deque",
"-",
"-",
"-def solve(X):",
"- if X >= 2000:",
"- return 1",
"- prices = list(range(100, 106))",
"- Q = deque([(0, 0)])",
"- while Q:",
"- i, pNow = Q.popleft()",
"- if i == 6:",
"- if pNow == X:",
"- return 1",
"- else:",
"- price = prices[i]",
"- for num in range(20):",
"- p2 = pNow + price * num",
"- if p2 > X:",
"- break",
"- Q.append((i + 1, p2))",
"- return 0",
"-",
"-",
"-print((solve(X)))",
"+dp = [False] * (X + 1)",
"+dp[0] = True",
"+for i in range(1, X + 1):",
"+ dp[i] = any(dp[i - (X + 1) - 105 : i - (X + 1) - 99])",
"+print((int(dp[X])))"
] | false | 0.041424 | 0.121776 | 0.340163 |
[
"s588165677",
"s350883050"
] |
u753803401
|
p02881
|
python
|
s438347521
|
s058810059
| 199 | 180 | 38,640 | 38,640 |
Accepted
|
Accepted
| 9.55 |
import sys
def solve():
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
t = n
mt = 10 ** 20
for i in range(1, int(n ** 0.5) + 1):
if t % i == 0:
mt = min(mt, (i - 1) + (t // i - 1))
print(mt)
if __name__ == '__main__':
solve()
|
import sys
def solve():
sys.setrecursionlimit(2000)
input = sys.stdin.readline
mod = 10 ** 9 + 7
n = int(input().rstrip('\n'))
mt = 10 ** 20
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
mt = min(mt, i + (n // i) - 2)
print(mt)
if __name__ == '__main__':
solve()
| 17 | 17 | 326 | 342 |
import sys
def solve():
input = sys.stdin.readline
mod = 10**9 + 7
n = int(input().rstrip("\n"))
t = n
mt = 10**20
for i in range(1, int(n**0.5) + 1):
if t % i == 0:
mt = min(mt, (i - 1) + (t // i - 1))
print(mt)
if __name__ == "__main__":
solve()
|
import sys
def solve():
sys.setrecursionlimit(2000)
input = sys.stdin.readline
mod = 10**9 + 7
n = int(input().rstrip("\n"))
mt = 10**20
for i in range(1, int(n**0.5) + 1):
if n % i == 0:
mt = min(mt, i + (n // i) - 2)
print(mt)
if __name__ == "__main__":
solve()
| false | 0 |
[
"+ sys.setrecursionlimit(2000)",
"- t = n",
"- if t % i == 0:",
"- mt = min(mt, (i - 1) + (t // i - 1))",
"+ if n % i == 0:",
"+ mt = min(mt, i + (n // i) - 2)"
] | false | 0.049732 | 0.048427 | 1.02695 |
[
"s438347521",
"s058810059"
] |
u745087332
|
p03231
|
python
|
s763107057
|
s106797816
| 74 | 22 | 3,828 | 3,828 |
Accepted
|
Accepted
| 70.27 |
# coding:utf-8
import sys
input = sys.stdin.readline
INF = float('inf')
def inpl(): return list(map(int, input().split()))
# 整数(x, y)最大公約数を求める
def gcd(x, y):
if x % y == 0:
return y
else:
x, y = y, x % y
return gcd(x, y)
def lcm(x, y):
return x * y // gcd(x, y)
N, M = inpl()
S = eval(input())
T = eval(input())
L = lcm(N, M)
LCM = lcm(L//N, L//M)
# print(L, LCM)
ss = L // N
cnt = 0
tmp = 0
S_li = [S[0]]
while tmp <= L:
tmp = ss * cnt + 1
if tmp % LCM == 1:
S_li.append(S[cnt])
cnt += 1
tt = L // M
cnt = 0
tmp = 0
T_li = [T[0]]
while tmp < L:
tmp = tt * cnt + 1
if tmp % LCM == 1:
T_li.append(T[cnt])
cnt += 1
# print(S_li)
# print(T_li)
if S_li == T_li:
print(L)
else:
print((-1))
|
# coding:utf-8
import sys
input = sys.stdin.readline
INF = float('inf')
def inpl(): return list(map(int, input().split()))
# 整数(x, y)最大公約数を求める
def gcd(x, y):
if x % y == 0:
return y
else:
x, y = y, x % y
return gcd(x, y)
# 整数(x, y)最小公倍数を求める
def lcm(x, y):
return x * y // gcd(x, y)
def solve(N, M, S, T):
L = lcm(N, M)
ln, lm = L // N, L // M
# 文字列Xのk * D + 1(k = 0 ~ L // D)番目の文字は
# Sのk * D // ln + 1(k = 0 ~ D // lm)文字目と、
# Tのk * D // lm + 1(k = 0 ~ D // ln)文字目の
# 両方で使われる
D = lcm(ln, lm)
li_S = []
for i in range(0, N, D // ln):
li_S.append(S[i])
li_T = []
for i in range(0, M, D // lm):
li_T.append(T[i])
# print(li_S, li_T)
# S, Tの両方で使われる文字が一致しているか判定
if li_S == li_T:
return L
else:
return -1
N, M = inpl()
S = eval(input())
T = eval(input())
print((solve(N, M, S, T)))
| 61 | 56 | 832 | 961 |
# coding:utf-8
import sys
input = sys.stdin.readline
INF = float("inf")
def inpl():
return list(map(int, input().split()))
# 整数(x, y)最大公約数を求める
def gcd(x, y):
if x % y == 0:
return y
else:
x, y = y, x % y
return gcd(x, y)
def lcm(x, y):
return x * y // gcd(x, y)
N, M = inpl()
S = eval(input())
T = eval(input())
L = lcm(N, M)
LCM = lcm(L // N, L // M)
# print(L, LCM)
ss = L // N
cnt = 0
tmp = 0
S_li = [S[0]]
while tmp <= L:
tmp = ss * cnt + 1
if tmp % LCM == 1:
S_li.append(S[cnt])
cnt += 1
tt = L // M
cnt = 0
tmp = 0
T_li = [T[0]]
while tmp < L:
tmp = tt * cnt + 1
if tmp % LCM == 1:
T_li.append(T[cnt])
cnt += 1
# print(S_li)
# print(T_li)
if S_li == T_li:
print(L)
else:
print((-1))
|
# coding:utf-8
import sys
input = sys.stdin.readline
INF = float("inf")
def inpl():
return list(map(int, input().split()))
# 整数(x, y)最大公約数を求める
def gcd(x, y):
if x % y == 0:
return y
else:
x, y = y, x % y
return gcd(x, y)
# 整数(x, y)最小公倍数を求める
def lcm(x, y):
return x * y // gcd(x, y)
def solve(N, M, S, T):
L = lcm(N, M)
ln, lm = L // N, L // M
# 文字列Xのk * D + 1(k = 0 ~ L // D)番目の文字は
# Sのk * D // ln + 1(k = 0 ~ D // lm)文字目と、
# Tのk * D // lm + 1(k = 0 ~ D // ln)文字目の
# 両方で使われる
D = lcm(ln, lm)
li_S = []
for i in range(0, N, D // ln):
li_S.append(S[i])
li_T = []
for i in range(0, M, D // lm):
li_T.append(T[i])
# print(li_S, li_T)
# S, Tの両方で使われる文字が一致しているか判定
if li_S == li_T:
return L
else:
return -1
N, M = inpl()
S = eval(input())
T = eval(input())
print((solve(N, M, S, T)))
| false | 8.196721 |
[
"+# 整数(x, y)最小公倍数を求める",
"+",
"+",
"+def solve(N, M, S, T):",
"+ L = lcm(N, M)",
"+ ln, lm = L // N, L // M",
"+ # 文字列Xのk * D + 1(k = 0 ~ L // D)番目の文字は",
"+ # Sのk * D // ln + 1(k = 0 ~ D // lm)文字目と、",
"+ # Tのk * D // lm + 1(k = 0 ~ D // ln)文字目の",
"+ # 両方で使われる",
"+ D = lcm(ln, lm)",
"+ li_S = []",
"+ for i in range(0, N, D // ln):",
"+ li_S.append(S[i])",
"+ li_T = []",
"+ for i in range(0, M, D // lm):",
"+ li_T.append(T[i])",
"+ # print(li_S, li_T)",
"+ # S, Tの両方で使われる文字が一致しているか判定",
"+ if li_S == li_T:",
"+ return L",
"+ else:",
"+ return -1",
"-L = lcm(N, M)",
"-LCM = lcm(L // N, L // M)",
"-# print(L, LCM)",
"-ss = L // N",
"-cnt = 0",
"-tmp = 0",
"-S_li = [S[0]]",
"-while tmp <= L:",
"- tmp = ss * cnt + 1",
"- if tmp % LCM == 1:",
"- S_li.append(S[cnt])",
"- cnt += 1",
"-tt = L // M",
"-cnt = 0",
"-tmp = 0",
"-T_li = [T[0]]",
"-while tmp < L:",
"- tmp = tt * cnt + 1",
"- if tmp % LCM == 1:",
"- T_li.append(T[cnt])",
"- cnt += 1",
"-# print(S_li)",
"-# print(T_li)",
"-if S_li == T_li:",
"- print(L)",
"-else:",
"- print((-1))",
"+print((solve(N, M, S, T)))"
] | false | 0.123883 | 0.074698 | 1.658463 |
[
"s763107057",
"s106797816"
] |
u912237403
|
p00173
|
python
|
s334473233
|
s429881202
| 20 | 10 | 4,192 | 4,192 |
Accepted
|
Accepted
| 50 |
for i in range(1,10):
s = input().split()
a = list(map(int, s[1:]))
print(s[0], sum(a), a[0]*200+a[1]*300)
|
for _ in range(1,10):
a,b,c = input().split()
b,c = list(map(int, [b,c]))
print(a, b+c, b*200+c*300)
| 4 | 4 | 112 | 106 |
for i in range(1, 10):
s = input().split()
a = list(map(int, s[1:]))
print(s[0], sum(a), a[0] * 200 + a[1] * 300)
|
for _ in range(1, 10):
a, b, c = input().split()
b, c = list(map(int, [b, c]))
print(a, b + c, b * 200 + c * 300)
| false | 0 |
[
"-for i in range(1, 10):",
"- s = input().split()",
"- a = list(map(int, s[1:]))",
"- print(s[0], sum(a), a[0] * 200 + a[1] * 300)",
"+for _ in range(1, 10):",
"+ a, b, c = input().split()",
"+ b, c = list(map(int, [b, c]))",
"+ print(a, b + c, b * 200 + c * 300)"
] | false | 0.037205 | 0.036014 | 1.033061 |
[
"s334473233",
"s429881202"
] |
u466917094
|
p03291
|
python
|
s538585772
|
s343285978
| 1,209 | 1,028 | 14,668 | 14,660 |
Accepted
|
Accepted
| 14.97 |
import numpy as np
s=eval(input())
n=len(s)
MOD=1000000007
wayA=np.array([0,0,0,0],dtype=np.int64)
wayB=np.array([0,0,0,0],dtype=np.int64)
wayC=np.array([0,0,0,0],dtype=np.int64)
MOD2=np.array([MOD,MOD,MOD,MOD],dtype=np.int32)
hatena=0
for c in s:
if c=="A":
wayA[0]+=1
if c=="B":
wayB+=wayA
if c=='C':
wayC+=wayB
if c=='?':
wayC[1]=wayC[1]+wayB[0]
wayC[2]=wayC[2]+wayB[1]
wayC[3]=wayC[3]+wayB[2]
wayB[1]=wayB[1]+wayA[0]
wayB[2]=wayB[2]+wayA[1]
wayA[1]=wayA[1]+1
hatena+=1
wayA%=MOD2
wayB%=MOD2
wayC%=MOD2
ans=0
for i in range(0,4):
ans=ans+pow(3,hatena-i)*wayC[i]
ans=ans%MOD
print((int(ans)))
|
import numpy as np
s=eval(input())
n=len(s)
MOD=1000000007
wayA=np.array([0,0,0,0])
wayB=np.array([0,0,0,0])
wayC=np.array([0,0,0,0])
MOD2=np.array([MOD,MOD,MOD,MOD])
hatena=0
for c in s:
if c=="A":
wayA[0]+=1
if c=="B":
wayB+=wayA
if c=='C':
wayC+=wayB
if c=='?':
wayC[1]=wayC[1]+wayB[0]
wayC[2]=wayC[2]+wayB[1]
wayC[3]=wayC[3]+wayB[2]
wayB[1]=wayB[1]+wayA[0]
wayB[2]=wayB[2]+wayA[1]
wayA[1]=wayA[1]+1
hatena+=1
wayA%=MOD2
wayB%=MOD2
wayC%=MOD2
ans=0
for i in range(0,4):
ans=ans+pow(3,hatena-i)*wayC[i]
ans=ans%MOD
print((int(ans)))
| 32 | 32 | 646 | 586 |
import numpy as np
s = eval(input())
n = len(s)
MOD = 1000000007
wayA = np.array([0, 0, 0, 0], dtype=np.int64)
wayB = np.array([0, 0, 0, 0], dtype=np.int64)
wayC = np.array([0, 0, 0, 0], dtype=np.int64)
MOD2 = np.array([MOD, MOD, MOD, MOD], dtype=np.int32)
hatena = 0
for c in s:
if c == "A":
wayA[0] += 1
if c == "B":
wayB += wayA
if c == "C":
wayC += wayB
if c == "?":
wayC[1] = wayC[1] + wayB[0]
wayC[2] = wayC[2] + wayB[1]
wayC[3] = wayC[3] + wayB[2]
wayB[1] = wayB[1] + wayA[0]
wayB[2] = wayB[2] + wayA[1]
wayA[1] = wayA[1] + 1
hatena += 1
wayA %= MOD2
wayB %= MOD2
wayC %= MOD2
ans = 0
for i in range(0, 4):
ans = ans + pow(3, hatena - i) * wayC[i]
ans = ans % MOD
print((int(ans)))
|
import numpy as np
s = eval(input())
n = len(s)
MOD = 1000000007
wayA = np.array([0, 0, 0, 0])
wayB = np.array([0, 0, 0, 0])
wayC = np.array([0, 0, 0, 0])
MOD2 = np.array([MOD, MOD, MOD, MOD])
hatena = 0
for c in s:
if c == "A":
wayA[0] += 1
if c == "B":
wayB += wayA
if c == "C":
wayC += wayB
if c == "?":
wayC[1] = wayC[1] + wayB[0]
wayC[2] = wayC[2] + wayB[1]
wayC[3] = wayC[3] + wayB[2]
wayB[1] = wayB[1] + wayA[0]
wayB[2] = wayB[2] + wayA[1]
wayA[1] = wayA[1] + 1
hatena += 1
wayA %= MOD2
wayB %= MOD2
wayC %= MOD2
ans = 0
for i in range(0, 4):
ans = ans + pow(3, hatena - i) * wayC[i]
ans = ans % MOD
print((int(ans)))
| false | 0 |
[
"-wayA = np.array([0, 0, 0, 0], dtype=np.int64)",
"-wayB = np.array([0, 0, 0, 0], dtype=np.int64)",
"-wayC = np.array([0, 0, 0, 0], dtype=np.int64)",
"-MOD2 = np.array([MOD, MOD, MOD, MOD], dtype=np.int32)",
"+wayA = np.array([0, 0, 0, 0])",
"+wayB = np.array([0, 0, 0, 0])",
"+wayC = np.array([0, 0, 0, 0])",
"+MOD2 = np.array([MOD, MOD, MOD, MOD])"
] | false | 0.31055 | 0.272485 | 1.139695 |
[
"s538585772",
"s343285978"
] |
u644907318
|
p02873
|
python
|
s599518470
|
s548450159
| 587 | 124 | 24,092 | 118,596 |
Accepted
|
Accepted
| 78.88 |
S = input().strip()
N = len(S)+1
A = [0 for _ in range(N)]
B = []
for i in range(N):
if i==0 and S[i]=="<":
B.append(0)
elif i<N-2 and S[i]==">" and S[i+1]=="<":
B.append(i+1)
elif i==N-2 and S[i]==">":
B.append(i+1)
for j in range(len(B)-1):
ind0 = B[j]
ind1 = B[j+1]
c = ind0
while S[c]=="<":
A[c+1] = max(A[c+1],A[c]+1)
c += 1
c = ind1
while S[c-1]==">":
A[c-1] = max(A[c-1],A[c]+1)
c -= 1
c = B[0]
if c>0:
for i in range(c-1,-1,-1):
A[i] = A[i+1]+1
c = B[-1]
if c<N-1:
for i in range(c+1,N):
A[i] = A[i-1]+1
print((sum(A)))
|
S = input().strip()
N = len(S)+1
A = [0 for _ in range(N)]
flag = -1
B = []
for i in range(N-1):
if flag==-1 and S[i]=="<":
B.append(i)
flag = 1
elif flag==1 and S[i]==">":
flag = -1
if flag==-1:
B.append(N-1)
for b in B:
for i in range(b,N-1):
if S[i]=="<":
A[i+1] = max(A[i+1],A[i]+1)
else:break
for i in range(b-1,-1,-1):
if S[i]==">":
A[i] = max(A[i],A[i+1]+1)
else:break
print((sum(A)))
| 31 | 23 | 671 | 511 |
S = input().strip()
N = len(S) + 1
A = [0 for _ in range(N)]
B = []
for i in range(N):
if i == 0 and S[i] == "<":
B.append(0)
elif i < N - 2 and S[i] == ">" and S[i + 1] == "<":
B.append(i + 1)
elif i == N - 2 and S[i] == ">":
B.append(i + 1)
for j in range(len(B) - 1):
ind0 = B[j]
ind1 = B[j + 1]
c = ind0
while S[c] == "<":
A[c + 1] = max(A[c + 1], A[c] + 1)
c += 1
c = ind1
while S[c - 1] == ">":
A[c - 1] = max(A[c - 1], A[c] + 1)
c -= 1
c = B[0]
if c > 0:
for i in range(c - 1, -1, -1):
A[i] = A[i + 1] + 1
c = B[-1]
if c < N - 1:
for i in range(c + 1, N):
A[i] = A[i - 1] + 1
print((sum(A)))
|
S = input().strip()
N = len(S) + 1
A = [0 for _ in range(N)]
flag = -1
B = []
for i in range(N - 1):
if flag == -1 and S[i] == "<":
B.append(i)
flag = 1
elif flag == 1 and S[i] == ">":
flag = -1
if flag == -1:
B.append(N - 1)
for b in B:
for i in range(b, N - 1):
if S[i] == "<":
A[i + 1] = max(A[i + 1], A[i] + 1)
else:
break
for i in range(b - 1, -1, -1):
if S[i] == ">":
A[i] = max(A[i], A[i + 1] + 1)
else:
break
print((sum(A)))
| false | 25.806452 |
[
"+flag = -1",
"-for i in range(N):",
"- if i == 0 and S[i] == \"<\":",
"- B.append(0)",
"- elif i < N - 2 and S[i] == \">\" and S[i + 1] == \"<\":",
"- B.append(i + 1)",
"- elif i == N - 2 and S[i] == \">\":",
"- B.append(i + 1)",
"-for j in range(len(B) - 1):",
"- ind0 = B[j]",
"- ind1 = B[j + 1]",
"- c = ind0",
"- while S[c] == \"<\":",
"- A[c + 1] = max(A[c + 1], A[c] + 1)",
"- c += 1",
"- c = ind1",
"- while S[c - 1] == \">\":",
"- A[c - 1] = max(A[c - 1], A[c] + 1)",
"- c -= 1",
"-c = B[0]",
"-if c > 0:",
"- for i in range(c - 1, -1, -1):",
"- A[i] = A[i + 1] + 1",
"-c = B[-1]",
"-if c < N - 1:",
"- for i in range(c + 1, N):",
"- A[i] = A[i - 1] + 1",
"+for i in range(N - 1):",
"+ if flag == -1 and S[i] == \"<\":",
"+ B.append(i)",
"+ flag = 1",
"+ elif flag == 1 and S[i] == \">\":",
"+ flag = -1",
"+if flag == -1:",
"+ B.append(N - 1)",
"+for b in B:",
"+ for i in range(b, N - 1):",
"+ if S[i] == \"<\":",
"+ A[i + 1] = max(A[i + 1], A[i] + 1)",
"+ else:",
"+ break",
"+ for i in range(b - 1, -1, -1):",
"+ if S[i] == \">\":",
"+ A[i] = max(A[i], A[i + 1] + 1)",
"+ else:",
"+ break"
] | false | 0.039806 | 0.074266 | 0.535992 |
[
"s599518470",
"s548450159"
] |
u794173881
|
p03329
|
python
|
s416553887
|
s687469485
| 741 | 223 | 6,900 | 41,708 |
Accepted
|
Accepted
| 69.91 |
n = int(eval(input()))
c = [1]
for i in range(6):
c.append(6**(i+1))
for i in range(5):
c.append(9**(i+1))
INF = float("inf")
dp = [INF]*(n+1)
dp[0] = 0
for i in range(len(c)):
for j in range(n+1):
if j - c[i] < 0:
continue
else:
dp[j] = min(dp[j], dp[j - c[i]] + 1)
print((dp[n]))
|
n = int(eval(input()))
dp = [10 ** 18] * (n + 1)
dp[0] = 0
info = [[1, 1]]
for i in range(1, 10):
info.append([6**i, 1])
for i in range(1, 10):
info.append([9**i, 1])
for i in range(n):
for w, v in info:
if i + w >= n + 1:
continue
dp[i + w] = min(dp[i] + 1, dp[i + w])
print((dp[-1]))
| 19 | 16 | 349 | 338 |
n = int(eval(input()))
c = [1]
for i in range(6):
c.append(6 ** (i + 1))
for i in range(5):
c.append(9 ** (i + 1))
INF = float("inf")
dp = [INF] * (n + 1)
dp[0] = 0
for i in range(len(c)):
for j in range(n + 1):
if j - c[i] < 0:
continue
else:
dp[j] = min(dp[j], dp[j - c[i]] + 1)
print((dp[n]))
|
n = int(eval(input()))
dp = [10**18] * (n + 1)
dp[0] = 0
info = [[1, 1]]
for i in range(1, 10):
info.append([6**i, 1])
for i in range(1, 10):
info.append([9**i, 1])
for i in range(n):
for w, v in info:
if i + w >= n + 1:
continue
dp[i + w] = min(dp[i] + 1, dp[i + w])
print((dp[-1]))
| false | 15.789474 |
[
"-c = [1]",
"-for i in range(6):",
"- c.append(6 ** (i + 1))",
"-for i in range(5):",
"- c.append(9 ** (i + 1))",
"-INF = float(\"inf\")",
"-dp = [INF] * (n + 1)",
"+dp = [10**18] * (n + 1)",
"-for i in range(len(c)):",
"- for j in range(n + 1):",
"- if j - c[i] < 0:",
"+info = [[1, 1]]",
"+for i in range(1, 10):",
"+ info.append([6**i, 1])",
"+for i in range(1, 10):",
"+ info.append([9**i, 1])",
"+for i in range(n):",
"+ for w, v in info:",
"+ if i + w >= n + 1:",
"- else:",
"- dp[j] = min(dp[j], dp[j - c[i]] + 1)",
"-print((dp[n]))",
"+ dp[i + w] = min(dp[i] + 1, dp[i + w])",
"+print((dp[-1]))"
] | false | 0.09581 | 0.115132 | 0.832171 |
[
"s416553887",
"s687469485"
] |
u347640436
|
p02838
|
python
|
s908420014
|
s723248080
| 284 | 222 | 44,560 | 29,120 |
Accepted
|
Accepted
| 21.83 |
import numpy as np
N = int(eval(input()))
A = np.fromiter(list(map(int, input().split())), np.int64)
result = 0
for bit in range(60):
c = int((A & 1).sum())
A >>= 1
result = (result + c * (N - c) * (1 << bit)) % 1000000007
print(result)
|
import numpy as np
N = int(eval(input()))
A = np.fromstring(eval(input()), dtype = np.int64, sep = ' ')
result = 0
for bit in range(60):
c = int((A & 1).sum())
A >>= 1
result = (result + c * (N - c) * (1 << bit)) % 1000000007
print(result)
| 11 | 11 | 243 | 252 |
import numpy as np
N = int(eval(input()))
A = np.fromiter(list(map(int, input().split())), np.int64)
result = 0
for bit in range(60):
c = int((A & 1).sum())
A >>= 1
result = (result + c * (N - c) * (1 << bit)) % 1000000007
print(result)
|
import numpy as np
N = int(eval(input()))
A = np.fromstring(eval(input()), dtype=np.int64, sep=" ")
result = 0
for bit in range(60):
c = int((A & 1).sum())
A >>= 1
result = (result + c * (N - c) * (1 << bit)) % 1000000007
print(result)
| false | 0 |
[
"-A = np.fromiter(list(map(int, input().split())), np.int64)",
"+A = np.fromstring(eval(input()), dtype=np.int64, sep=\" \")"
] | false | 1.061759 | 0.294381 | 3.606746 |
[
"s908420014",
"s723248080"
] |
u531220228
|
p03101
|
python
|
s570143015
|
s633284783
| 152 | 17 | 12,488 | 2,940 |
Accepted
|
Accepted
| 88.82 |
import numpy as np
H,W = list(map(int, input().split()))
h,w = list(map(int, input().split()))
matrix = [[1 if (i>w-1 and j>h-1) else 0 for i in range(W)] for j in range(H)]
print((np.sum(matrix)))
|
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print((H*W - W*h - H*w + h*w))
| 5 | 4 | 187 | 98 |
import numpy as np
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
matrix = [[1 if (i > w - 1 and j > h - 1) else 0 for i in range(W)] for j in range(H)]
print((np.sum(matrix)))
|
H, W = list(map(int, input().split()))
h, w = list(map(int, input().split()))
print((H * W - W * h - H * w + h * w))
| false | 20 |
[
"-import numpy as np",
"-",
"-matrix = [[1 if (i > w - 1 and j > h - 1) else 0 for i in range(W)] for j in range(H)]",
"-print((np.sum(matrix)))",
"+print((H * W - W * h - H * w + h * w))"
] | false | 0.20379 | 0.04041 | 5.043111 |
[
"s570143015",
"s633284783"
] |
u761320129
|
p02850
|
python
|
s343715136
|
s221147382
| 800 | 637 | 66,968 | 93,960 |
Accepted
|
Accepted
| 20.38 |
N = int(input())
AB = [tuple(map(int,input().split())) for i in range(N-1)]
es = [[] for i in range(N)]
ei = {}
for i,(a,b) in enumerate(AB):
a,b = a-1,b-1
es[a].append(b)
es[b].append(a)
ei[(a,b)] = ei[(b,a)] = i
max_e = root = 0
for i in range(N):
if len(es[i]) > max_e:
max_e = len(es[i])
root = i
ans = [None]*(N-1)
visited = [0]*N
visited[root] = 1
stack = []
for i,to in enumerate(es[root]):
ans[ei[(root,to)]] = i+1
visited[to] = 1
stack.append((to,i+1))
while stack:
v,pc = stack.pop()
c = 0
for to in es[v]:
if visited[to]: continue
visited[to] = 1
c += 1
if c == pc:
c += 1
pi = ei[(v,to)]
ans[pi] = c
stack.append((to,c))
print(max(ans))
print(*ans, sep='\n')
|
import sys
sys.setrecursionlimit(10**8)
N = int(input())
AB = [tuple(map(int,input().split())) for i in range(N-1)]
es = [[] for i in range(N)]
for i,(a,b) in enumerate(AB):
a,b = a-1,b-1
es[a].append((b,i))
es[b].append((a,i))
visited = [0]*N
ans = [None]*(N-1)
def dfs(v,c=-1):
nc = 1
for to,i in es[v]:
if visited[to]: continue
visited[v] = 1
if nc==c:
nc += 1
ans[i] = nc
dfs(to,nc)
nc += 1
dfs(0)
print(max(ans))
print(*ans,sep='\n')
| 40 | 26 | 841 | 545 |
N = int(input())
AB = [tuple(map(int, input().split())) for i in range(N - 1)]
es = [[] for i in range(N)]
ei = {}
for i, (a, b) in enumerate(AB):
a, b = a - 1, b - 1
es[a].append(b)
es[b].append(a)
ei[(a, b)] = ei[(b, a)] = i
max_e = root = 0
for i in range(N):
if len(es[i]) > max_e:
max_e = len(es[i])
root = i
ans = [None] * (N - 1)
visited = [0] * N
visited[root] = 1
stack = []
for i, to in enumerate(es[root]):
ans[ei[(root, to)]] = i + 1
visited[to] = 1
stack.append((to, i + 1))
while stack:
v, pc = stack.pop()
c = 0
for to in es[v]:
if visited[to]:
continue
visited[to] = 1
c += 1
if c == pc:
c += 1
pi = ei[(v, to)]
ans[pi] = c
stack.append((to, c))
print(max(ans))
print(*ans, sep="\n")
|
import sys
sys.setrecursionlimit(10**8)
N = int(input())
AB = [tuple(map(int, input().split())) for i in range(N - 1)]
es = [[] for i in range(N)]
for i, (a, b) in enumerate(AB):
a, b = a - 1, b - 1
es[a].append((b, i))
es[b].append((a, i))
visited = [0] * N
ans = [None] * (N - 1)
def dfs(v, c=-1):
nc = 1
for to, i in es[v]:
if visited[to]:
continue
visited[v] = 1
if nc == c:
nc += 1
ans[i] = nc
dfs(to, nc)
nc += 1
dfs(0)
print(max(ans))
print(*ans, sep="\n")
| false | 35 |
[
"+import sys",
"+",
"+sys.setrecursionlimit(10**8)",
"-ei = {}",
"- es[a].append(b)",
"- es[b].append(a)",
"- ei[(a, b)] = ei[(b, a)] = i",
"-max_e = root = 0",
"-for i in range(N):",
"- if len(es[i]) > max_e:",
"- max_e = len(es[i])",
"- root = i",
"+ es[a].append((b, i))",
"+ es[b].append((a, i))",
"+visited = [0] * N",
"-visited = [0] * N",
"-visited[root] = 1",
"-stack = []",
"-for i, to in enumerate(es[root]):",
"- ans[ei[(root, to)]] = i + 1",
"- visited[to] = 1",
"- stack.append((to, i + 1))",
"-while stack:",
"- v, pc = stack.pop()",
"- c = 0",
"- for to in es[v]:",
"+",
"+",
"+def dfs(v, c=-1):",
"+ nc = 1",
"+ for to, i in es[v]:",
"- visited[to] = 1",
"- c += 1",
"- if c == pc:",
"- c += 1",
"- pi = ei[(v, to)]",
"- ans[pi] = c",
"- stack.append((to, c))",
"+ visited[v] = 1",
"+ if nc == c:",
"+ nc += 1",
"+ ans[i] = nc",
"+ dfs(to, nc)",
"+ nc += 1",
"+",
"+",
"+dfs(0)"
] | false | 0.063323 | 0.044868 | 1.411297 |
[
"s343715136",
"s221147382"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.