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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u566311709
|
p02381
|
python
|
s343639115
|
s600610320
| 50 | 40 | 7,092 | 5,680 |
Accepted
|
Accepted
| 20 |
from statistics import mean
import math
ans = []
while 1:
n = int(eval(input()))
if n == 0: break
l = list(map(int, input().split()))
m = mean(l)
print(("{0:.8f}".format(math.sqrt(sum([(s - m) ** 2 for s in l]) / n))))
|
while eval(input()) != "0":
l = list(map(int, input().split()))
print(("{0:.8f}".format((sum([(s - sum(l) / len(l)) ** 2 for s in l]) / len(l)) ** 0.5)))
| 9 | 3 | 229 | 152 |
from statistics import mean
import math
ans = []
while 1:
n = int(eval(input()))
if n == 0:
break
l = list(map(int, input().split()))
m = mean(l)
print(("{0:.8f}".format(math.sqrt(sum([(s - m) ** 2 for s in l]) / n))))
|
while eval(input()) != "0":
l = list(map(int, input().split()))
print(
(
"{0:.8f}".format(
(sum([(s - sum(l) / len(l)) ** 2 for s in l]) / len(l)) ** 0.5
)
)
)
| false | 66.666667 |
[
"-from statistics import mean",
"-import math",
"-",
"-ans = []",
"-while 1:",
"- n = int(eval(input()))",
"- if n == 0:",
"- break",
"+while eval(input()) != \"0\":",
"- m = mean(l)",
"- print((\"{0:.8f}\".format(math.sqrt(sum([(s - m) ** 2 for s in l]) / n))))",
"+ print(",
"+ (",
"+ \"{0:.8f}\".format(",
"+ (sum([(s - sum(l) / len(l)) ** 2 for s in l]) / len(l)) ** 0.5",
"+ )",
"+ )",
"+ )"
] | false | 0.056342 | 0.045303 | 1.243672 |
[
"s343639115",
"s600610320"
] |
u238956837
|
p02958
|
python
|
s014898104
|
s798413257
| 24 | 17 | 3,444 | 3,060 |
Accepted
|
Accepted
| 29.17 |
import copy
n = int(eval(input()))
p = list(map(int, input().split()))
p_new = copy.copy(p)
for i in range(n-1):
if p[i] > p[i+1]:
min_val = min(p[i+1:])
for j in range(n):
if p[j] == min_val:
p_new[i] = min_val
p_new[j] = p[i]
break
break
if p_new == sorted(p):
print('YES')
else:
print('NO')
|
n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 0
for k,v in enumerate(p):
if k+1 != v:
cnt += 1
if cnt > 2:
print('NO')
else:
print('YES')
| 19 | 12 | 355 | 173 |
import copy
n = int(eval(input()))
p = list(map(int, input().split()))
p_new = copy.copy(p)
for i in range(n - 1):
if p[i] > p[i + 1]:
min_val = min(p[i + 1 :])
for j in range(n):
if p[j] == min_val:
p_new[i] = min_val
p_new[j] = p[i]
break
break
if p_new == sorted(p):
print("YES")
else:
print("NO")
|
n = int(eval(input()))
p = list(map(int, input().split()))
cnt = 0
for k, v in enumerate(p):
if k + 1 != v:
cnt += 1
if cnt > 2:
print("NO")
else:
print("YES")
| false | 36.842105 |
[
"-import copy",
"-",
"-p_new = copy.copy(p)",
"-for i in range(n - 1):",
"- if p[i] > p[i + 1]:",
"- min_val = min(p[i + 1 :])",
"- for j in range(n):",
"- if p[j] == min_val:",
"- p_new[i] = min_val",
"- p_new[j] = p[i]",
"- break",
"- break",
"-if p_new == sorted(p):",
"+cnt = 0",
"+for k, v in enumerate(p):",
"+ if k + 1 != v:",
"+ cnt += 1",
"+if cnt > 2:",
"+ print(\"NO\")",
"+else:",
"-else:",
"- print(\"NO\")"
] | false | 0.037461 | 0.039767 | 0.942014 |
[
"s014898104",
"s798413257"
] |
u596536048
|
p02909
|
python
|
s825757922
|
s016550236
| 24 | 22 | 8,824 | 8,944 |
Accepted
|
Accepted
| 8.33 |
Weather = ['Sunny','Cloudy','Rainy']
print((Weather[(Weather.index(eval(input())) + 1) % 3]))
|
S = eval(input())
Weather = ['Sunny','Cloudy','Rainy']
print((Weather[(Weather.index(S) + 1) % 3]))
| 2 | 3 | 86 | 93 |
Weather = ["Sunny", "Cloudy", "Rainy"]
print((Weather[(Weather.index(eval(input())) + 1) % 3]))
|
S = eval(input())
Weather = ["Sunny", "Cloudy", "Rainy"]
print((Weather[(Weather.index(S) + 1) % 3]))
| false | 33.333333 |
[
"+S = eval(input())",
"-print((Weather[(Weather.index(eval(input())) + 1) % 3]))",
"+print((Weather[(Weather.index(S) + 1) % 3]))"
] | false | 0.047055 | 0.037256 | 1.263015 |
[
"s825757922",
"s016550236"
] |
u589886885
|
p02269
|
python
|
s192093591
|
s352132059
| 1,730 | 1,100 | 378,740 | 112,408 |
Accepted
|
Accepted
| 36.42 |
import sys
n = int(eval(input()))
dic = {}
input_ = [x.split() for x in sys.stdin.readlines()]
for c, s in input_:
if c == 'insert':
dic[s] = 0
else:
if s in dic:
print('yes')
else:
print('no')
|
import sys
n = int(eval(input()))
dic = {}
input_ = sys.stdin.readlines()
for i in input_:
c, s = i.split()
if c == 'insert':
dic[s] = 0
else:
if s in dic:
print('yes')
else:
print('no')
| 14 | 15 | 258 | 256 |
import sys
n = int(eval(input()))
dic = {}
input_ = [x.split() for x in sys.stdin.readlines()]
for c, s in input_:
if c == "insert":
dic[s] = 0
else:
if s in dic:
print("yes")
else:
print("no")
|
import sys
n = int(eval(input()))
dic = {}
input_ = sys.stdin.readlines()
for i in input_:
c, s = i.split()
if c == "insert":
dic[s] = 0
else:
if s in dic:
print("yes")
else:
print("no")
| false | 6.666667 |
[
"-input_ = [x.split() for x in sys.stdin.readlines()]",
"-for c, s in input_:",
"+input_ = sys.stdin.readlines()",
"+for i in input_:",
"+ c, s = i.split()"
] | false | 0.068169 | 0.033889 | 2.011547 |
[
"s192093591",
"s352132059"
] |
u784022244
|
p03608
|
python
|
s448225481
|
s915323027
| 493 | 278 | 59,864 | 70,756 |
Accepted
|
Accepted
| 43.61 |
import itertools
N,M,R=list(map(int, input().split()))
r=list(map(int, input().split()))
G = [[float("inf")]*N for i in range(N)]
for i in range(M):
a,b,c=list(map(int, input().split()))
G[a-1][b-1]=c
G[b-1][a-1]=c
def warshall_floyd(G):
#d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j],G[i][k] + G[k][j])
return G
G=warshall_floyd(G)
ans=10**8
for L in itertools.permutations(r):
L=list(L)
sub=0
for i in range(1,R):
s=L[i-1]
t=L[i]
sub+=G[s-1][t-1]
ans=min(ans, sub)
print(ans)
|
from itertools import permutations
N,M,R=list(map(int, input().split()))
G=[[float("INF")]*N for _ in range(N)]
r=list(map(int, input().split()))
for i in range(M):
a,b,c=list(map(int, input().split()))
G[a-1][b-1]=c
G[b-1][a-1]=c
def warshall_floyd(d):
#d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
#print(G)
for i in range(N):
G[i][i] = 0 #自身のところに行くコストは０
warshall_floyd(G)
#print(G)
ans=float("INf")
for t in permutations(r):
sub=0
#print(t)
for i in range(R):
if i==0:
now=t[i]
sub+=G[now-1][t[i]-1]
now=t[i]
#print(now)
ans=min(ans, sub)
print(ans)
| 27 | 36 | 646 | 785 |
import itertools
N, M, R = list(map(int, input().split()))
r = list(map(int, input().split()))
G = [[float("inf")] * N for i in range(N)]
for i in range(M):
a, b, c = list(map(int, input().split()))
G[a - 1][b - 1] = c
G[b - 1][a - 1] = c
def warshall_floyd(G):
# d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
for j in range(N):
G[i][j] = min(G[i][j], G[i][k] + G[k][j])
return G
G = warshall_floyd(G)
ans = 10**8
for L in itertools.permutations(r):
L = list(L)
sub = 0
for i in range(1, R):
s = L[i - 1]
t = L[i]
sub += G[s - 1][t - 1]
ans = min(ans, sub)
print(ans)
|
from itertools import permutations
N, M, R = list(map(int, input().split()))
G = [[float("INF")] * N for _ in range(N)]
r = list(map(int, input().split()))
for i in range(M):
a, b, c = list(map(int, input().split()))
G[a - 1][b - 1] = c
G[b - 1][a - 1] = c
def warshall_floyd(d):
# d[i][j]: iからjへの最短距離
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
# print(G)
for i in range(N):
G[i][i] = 0 # 自身のところに行くコストは０
warshall_floyd(G)
# print(G)
ans = float("INf")
for t in permutations(r):
sub = 0
# print(t)
for i in range(R):
if i == 0:
now = t[i]
sub += G[now - 1][t[i] - 1]
now = t[i]
# print(now)
ans = min(ans, sub)
print(ans)
| false | 25 |
[
"-import itertools",
"+from itertools import permutations",
"+G = [[float(\"INF\")] * N for _ in range(N)]",
"-G = [[float(\"inf\")] * N for i in range(N)]",
"-def warshall_floyd(G):",
"+def warshall_floyd(d):",
"- G[i][j] = min(G[i][j], G[i][k] + G[k][j])",
"- return G",
"+ d[i][j] = min(d[i][j], d[i][k] + d[k][j])",
"+ return d",
"-G = warshall_floyd(G)",
"-ans = 10**8",
"-for L in itertools.permutations(r):",
"- L = list(L)",
"+# print(G)",
"+for i in range(N):",
"+ G[i][i] = 0 # 自身のところに行くコストは０",
"+warshall_floyd(G)",
"+# print(G)",
"+ans = float(\"INf\")",
"+for t in permutations(r):",
"- for i in range(1, R):",
"- s = L[i - 1]",
"- t = L[i]",
"- sub += G[s - 1][t - 1]",
"+ # print(t)",
"+ for i in range(R):",
"+ if i == 0:",
"+ now = t[i]",
"+ sub += G[now - 1][t[i] - 1]",
"+ now = t[i]",
"+ # print(now)"
] | false | 0.038264 | 0.041994 | 0.91118 |
[
"s448225481",
"s915323027"
] |
u690536347
|
p02834
|
python
|
s374939101
|
s104027584
| 861 | 468 | 85,976 | 73,180 |
Accepted
|
Accepted
| 45.64 |
from collections import defaultdict
N, u, v = list(map(int, input().split()))
d = defaultdict(list)
for _ in range(N-1):
A, B = list(map(int, input().split()))
d[A].append(B)
d[B].append(A)
def get_dist(s):
dist = [-1]*(N+1)
dist[s] = 0
q = [s]
while q:
a = q.pop()
for b in d[a]:
if dist[b]!=-1:
continue
dist[b] = dist[a] + 1
q.append(b)
return dist
du, dv = get_dist(u), get_dist(v)
ds = [(i,j[0], j[1]) for i,j in enumerate(zip(du, dv)) if j[0]<j[1]]
ds.sort(key=lambda x:-x[2])
a, b, c = ds[0]
print((c-1))
|
from collections import defaultdict
import sys
input=sys.stdin.readline
def get_dist(s, d, N):
dist = [-1]*(N+1)
dist[s] = 0
q = [s]
while q:
a = q.pop()
for b in d[a]:
if dist[b]!=-1:
continue
dist[b] = dist[a] + 1
q.append(b)
return dist
def solve():
N, u, v = list(map(int, input().split()))
d = defaultdict(list)
for _ in range(N-1):
A, B = list(map(int, input().split()))
d[A].append(B)
d[B].append(A)
du, dv = get_dist(u, d, N), get_dist(v, d, N)
ds = [(i, j) for i, j in zip(du, dv) if i<j]
ds.sort(key=lambda x:-x[1])
print((ds[0][1]-1))
if __name__ == "__main__":
solve()
| 27 | 34 | 626 | 750 |
from collections import defaultdict
N, u, v = list(map(int, input().split()))
d = defaultdict(list)
for _ in range(N - 1):
A, B = list(map(int, input().split()))
d[A].append(B)
d[B].append(A)
def get_dist(s):
dist = [-1] * (N + 1)
dist[s] = 0
q = [s]
while q:
a = q.pop()
for b in d[a]:
if dist[b] != -1:
continue
dist[b] = dist[a] + 1
q.append(b)
return dist
du, dv = get_dist(u), get_dist(v)
ds = [(i, j[0], j[1]) for i, j in enumerate(zip(du, dv)) if j[0] < j[1]]
ds.sort(key=lambda x: -x[2])
a, b, c = ds[0]
print((c - 1))
|
from collections import defaultdict
import sys
input = sys.stdin.readline
def get_dist(s, d, N):
dist = [-1] * (N + 1)
dist[s] = 0
q = [s]
while q:
a = q.pop()
for b in d[a]:
if dist[b] != -1:
continue
dist[b] = dist[a] + 1
q.append(b)
return dist
def solve():
N, u, v = list(map(int, input().split()))
d = defaultdict(list)
for _ in range(N - 1):
A, B = list(map(int, input().split()))
d[A].append(B)
d[B].append(A)
du, dv = get_dist(u, d, N), get_dist(v, d, N)
ds = [(i, j) for i, j in zip(du, dv) if i < j]
ds.sort(key=lambda x: -x[1])
print((ds[0][1] - 1))
if __name__ == "__main__":
solve()
| false | 20.588235 |
[
"+import sys",
"-N, u, v = list(map(int, input().split()))",
"-d = defaultdict(list)",
"-for _ in range(N - 1):",
"- A, B = list(map(int, input().split()))",
"- d[A].append(B)",
"- d[B].append(A)",
"+input = sys.stdin.readline",
"-def get_dist(s):",
"+def get_dist(s, d, N):",
"-du, dv = get_dist(u), get_dist(v)",
"-ds = [(i, j[0], j[1]) for i, j in enumerate(zip(du, dv)) if j[0] < j[1]]",
"-ds.sort(key=lambda x: -x[2])",
"-a, b, c = ds[0]",
"-print((c - 1))",
"+def solve():",
"+ N, u, v = list(map(int, input().split()))",
"+ d = defaultdict(list)",
"+ for _ in range(N - 1):",
"+ A, B = list(map(int, input().split()))",
"+ d[A].append(B)",
"+ d[B].append(A)",
"+ du, dv = get_dist(u, d, N), get_dist(v, d, N)",
"+ ds = [(i, j) for i, j in zip(du, dv) if i < j]",
"+ ds.sort(key=lambda x: -x[1])",
"+ print((ds[0][1] - 1))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.03702 | 0.046531 | 0.795597 |
[
"s374939101",
"s104027584"
] |
u389910364
|
p02720
|
python
|
s073273559
|
s074485911
| 549 | 180 | 119,240 | 17,012 |
Accepted
|
Accepted
| 67.21 |
import os
import sys
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
def is_ok(n):
s = str(n)
ok = True
for a, b in zip(s, s[1:]):
if not abs(int(a) - int(b)) <= 1:
return False
return True
@lru_cache(maxsize=None)
def rekkyo(n, d):
if d == 0:
return ['']
ret = []
if n > 0:
for s in rekkyo(n - 1, d - 1):
ret.append(str(n - 1) + s)
for s in rekkyo(n, d - 1):
ret.append(str(n) + s)
if n < 9:
for s in rekkyo(n + 1, d - 1):
ret.append(str(n + 1) + s)
return ret
K = int(sys.stdin.buffer.readline())
s = set()
for i in range(10):
for j in range(1,11):
a = rekkyo(i, j)
s |= set(a)
a = list(sorted(set(list(map(int, s)))))
print((a[K]))
# for aa in a:
# print(aa)
|
import os
import sys
from collections import deque
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10 ** 9)
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
# 解説
K = int(sys.stdin.buffer.readline())
que = deque(list(map(str, list(range(1, 10)))))
for _ in range(K - 1):
# print(que)
s = que.popleft()
d = int(s[-1])
if d > 0:
que.append(s + str(d - 1))
que.append(s + str(d))
if d < 9:
que.append(s + str(d + 1))
print((int(que[0])))
| 53 | 26 | 1,010 | 550 |
import os
import sys
from functools import lru_cache
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
def is_ok(n):
s = str(n)
ok = True
for a, b in zip(s, s[1:]):
if not abs(int(a) - int(b)) <= 1:
return False
return True
@lru_cache(maxsize=None)
def rekkyo(n, d):
if d == 0:
return [""]
ret = []
if n > 0:
for s in rekkyo(n - 1, d - 1):
ret.append(str(n - 1) + s)
for s in rekkyo(n, d - 1):
ret.append(str(n) + s)
if n < 9:
for s in rekkyo(n + 1, d - 1):
ret.append(str(n + 1) + s)
return ret
K = int(sys.stdin.buffer.readline())
s = set()
for i in range(10):
for j in range(1, 11):
a = rekkyo(i, j)
s |= set(a)
a = list(sorted(set(list(map(int, s)))))
print((a[K]))
# for aa in a:
# print(aa)
|
import os
import sys
from collections import deque
if os.getenv("LOCAL"):
sys.stdin = open("_in.txt", "r")
sys.setrecursionlimit(10**9)
INF = float("inf")
IINF = 10**18
MOD = 10**9 + 7
# MOD = 998244353
# 解説
K = int(sys.stdin.buffer.readline())
que = deque(list(map(str, list(range(1, 10)))))
for _ in range(K - 1):
# print(que)
s = que.popleft()
d = int(s[-1])
if d > 0:
que.append(s + str(d - 1))
que.append(s + str(d))
if d < 9:
que.append(s + str(d + 1))
print((int(que[0])))
| false | 50.943396 |
[
"-from functools import lru_cache",
"+from collections import deque",
"-def is_ok(n):",
"- s = str(n)",
"- ok = True",
"- for a, b in zip(s, s[1:]):",
"- if not abs(int(a) - int(b)) <= 1:",
"- return False",
"- return True",
"-",
"-",
"-@lru_cache(maxsize=None)",
"-def rekkyo(n, d):",
"- if d == 0:",
"- return [\"\"]",
"- ret = []",
"- if n > 0:",
"- for s in rekkyo(n - 1, d - 1):",
"- ret.append(str(n - 1) + s)",
"- for s in rekkyo(n, d - 1):",
"- ret.append(str(n) + s)",
"- if n < 9:",
"- for s in rekkyo(n + 1, d - 1):",
"- ret.append(str(n + 1) + s)",
"- return ret",
"-",
"-",
"+# 解説",
"-s = set()",
"-for i in range(10):",
"- for j in range(1, 11):",
"- a = rekkyo(i, j)",
"- s |= set(a)",
"-a = list(sorted(set(list(map(int, s)))))",
"-print((a[K]))",
"-# for aa in a:",
"-# print(aa)",
"+que = deque(list(map(str, list(range(1, 10)))))",
"+for _ in range(K - 1):",
"+ # print(que)",
"+ s = que.popleft()",
"+ d = int(s[-1])",
"+ if d > 0:",
"+ que.append(s + str(d - 1))",
"+ que.append(s + str(d))",
"+ if d < 9:",
"+ que.append(s + str(d + 1))",
"+print((int(que[0])))"
] | false | 1.408784 | 0.12702 | 11.091045 |
[
"s073273559",
"s074485911"
] |
u867848444
|
p02832
|
python
|
s245857783
|
s038562571
| 121 | 109 | 26,140 | 24,744 |
Accepted
|
Accepted
| 9.92 |
def solve():
l=[0]
count=0
for i in a:
if i==l[-1]+1:
l+=[i]
else:
count+=1
print((count if len(l)!=1 else -1))
n=int(eval(input()))
a=list(map(int,input().split()))
solve()
|
n = int(eval(input()))
a = list(map(int,input().split()))
cnt = 0
num = 1
for i in range(n):
if a[i] != num:
cnt += 1
continue
num += 1
print((cnt if cnt != n else -1))
| 13 | 11 | 234 | 195 |
def solve():
l = [0]
count = 0
for i in a:
if i == l[-1] + 1:
l += [i]
else:
count += 1
print((count if len(l) != 1 else -1))
n = int(eval(input()))
a = list(map(int, input().split()))
solve()
|
n = int(eval(input()))
a = list(map(int, input().split()))
cnt = 0
num = 1
for i in range(n):
if a[i] != num:
cnt += 1
continue
num += 1
print((cnt if cnt != n else -1))
| false | 15.384615 |
[
"-def solve():",
"- l = [0]",
"- count = 0",
"- for i in a:",
"- if i == l[-1] + 1:",
"- l += [i]",
"- else:",
"- count += 1",
"- print((count if len(l) != 1 else -1))",
"-",
"-",
"-solve()",
"+cnt = 0",
"+num = 1",
"+for i in range(n):",
"+ if a[i] != num:",
"+ cnt += 1",
"+ continue",
"+ num += 1",
"+print((cnt if cnt != n else -1))"
] | false | 0.008756 | 0.03791 | 0.230956 |
[
"s245857783",
"s038562571"
] |
u057964173
|
p02627
|
python
|
s062653111
|
s569943013
| 30 | 23 | 8,984 | 9,096 |
Accepted
|
Accepted
| 23.33 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
s=eval(input())
alphabets=list(chr(ord('a')+i) for i in range(26))
if s in alphabets:
print('a')
else:
print('A')
resolve()
|
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
s=eval(input())
if s.lower()==s:
print('a')
else:
print('A')
resolve()
| 11 | 10 | 235 | 177 |
import sys
def input():
return sys.stdin.readline().strip()
def resolve():
s = eval(input())
alphabets = list(chr(ord("a") + i) for i in range(26))
if s in alphabets:
print("a")
else:
print("A")
resolve()
|
import sys
def input():
return sys.stdin.readline().strip()
def resolve():
s = eval(input())
if s.lower() == s:
print("a")
else:
print("A")
resolve()
| false | 9.090909 |
[
"- alphabets = list(chr(ord(\"a\") + i) for i in range(26))",
"- if s in alphabets:",
"+ if s.lower() == s:"
] | false | 0.104223 | 0.075731 | 1.376224 |
[
"s062653111",
"s569943013"
] |
u075539606
|
p03160
|
python
|
s733218669
|
s350990455
| 676 | 228 | 119,624 | 52,208 |
Accepted
|
Accepted
| 66.27 |
import sys
sys.setrecursionlimit(10**5-10)
N = int(eval(input()))
h = list(map(int,input().split()))
memo = [-1]*N
def func(i):
# メモのロード
if memo[i]!=-1:
return memo[i]
# 初期値の部分
if i==0:
return 0
elif i==1:
return abs(h[1]-h[0])
# 二択の部分
a = func(i-1)+abs(h[i]-h[i-1])
b = func(i-2)+abs(h[i]-h[i-2])
memo[i] = min(a,b) # メモのセーブ
return memo[i]
print((func(N-1)))
|
N = int(eval(input()))
h = list(map(int,input().split()))
dp = [-1]*N
dp[0] = 0
dp[1] = abs(h[1]-h[0])
for i in range(2,N):
a = dp[i-1]+abs(h[i]-h[i-1])
b = dp[i-2]+abs(h[i]-h[i-2])
dp[i] = min(a,b)
print((dp[N-1]))
| 24 | 11 | 412 | 225 |
import sys
sys.setrecursionlimit(10**5 - 10)
N = int(eval(input()))
h = list(map(int, input().split()))
memo = [-1] * N
def func(i):
# メモのロード
if memo[i] != -1:
return memo[i]
# 初期値の部分
if i == 0:
return 0
elif i == 1:
return abs(h[1] - h[0])
# 二択の部分
a = func(i - 1) + abs(h[i] - h[i - 1])
b = func(i - 2) + abs(h[i] - h[i - 2])
memo[i] = min(a, b) # メモのセーブ
return memo[i]
print((func(N - 1)))
|
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [-1] * N
dp[0] = 0
dp[1] = abs(h[1] - h[0])
for i in range(2, N):
a = dp[i - 1] + abs(h[i] - h[i - 1])
b = dp[i - 2] + abs(h[i] - h[i - 2])
dp[i] = min(a, b)
print((dp[N - 1]))
| false | 54.166667 |
[
"-import sys",
"-",
"-sys.setrecursionlimit(10**5 - 10)",
"-memo = [-1] * N",
"-",
"-",
"-def func(i):",
"- # メモのロード",
"- if memo[i] != -1:",
"- return memo[i]",
"- # 初期値の部分",
"- if i == 0:",
"- return 0",
"- elif i == 1:",
"- return abs(h[1] - h[0])",
"- # 二択の部分",
"- a = func(i - 1) + abs(h[i] - h[i - 1])",
"- b = func(i - 2) + abs(h[i] - h[i - 2])",
"- memo[i] = min(a, b) # メモのセーブ",
"- return memo[i]",
"-",
"-",
"-print((func(N - 1)))",
"+dp = [-1] * N",
"+dp[0] = 0",
"+dp[1] = abs(h[1] - h[0])",
"+for i in range(2, N):",
"+ a = dp[i - 1] + abs(h[i] - h[i - 1])",
"+ b = dp[i - 2] + abs(h[i] - h[i - 2])",
"+ dp[i] = min(a, b)",
"+print((dp[N - 1]))"
] | false | 0.03669 | 0.081026 | 0.452824 |
[
"s733218669",
"s350990455"
] |
u564902833
|
p02984
|
python
|
s616869332
|
s822457759
| 123 | 85 | 16,304 | 16,304 |
Accepted
|
Accepted
| 30.89 |
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
# x_1 = (A_1 - A_2 + A_3 - A_4 + ... + A_N) / 2 である
# x_2 以降は代入しながら求めればよい
ans = ' '.join(
str(2 * x)
for x in accumulate(
[sum((-1)**i * A[i] for i in range(N)) // 2] + A[:-1],
lambda acc, a: a - acc
)
)
print(ans)
|
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
# x_1 = (A_1 - A_2 + A_3 - A_4 + ... + A_N) / 2 である
# x_2 以降は代入しながら求めればよい
ans = ' '.join(
str(2 * x)
for x in accumulate(
[(sum(A[::2]) - sum(A[1::2])) // 2] + A[:-1],
lambda acc, a: a - acc
)
)
print(ans)
| 16 | 16 | 347 | 338 |
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
# x_1 = (A_1 - A_2 + A_3 - A_4 + ... + A_N) / 2 である
# x_2 以降は代入しながら求めればよい
ans = " ".join(
str(2 * x)
for x in accumulate(
[sum((-1) ** i * A[i] for i in range(N)) // 2] + A[:-1], lambda acc, a: a - acc
)
)
print(ans)
|
from itertools import accumulate
N = int(eval(input()))
A = list(map(int, input().split()))
# x_1 = (A_1 - A_2 + A_3 - A_4 + ... + A_N) / 2 である
# x_2 以降は代入しながら求めればよい
ans = " ".join(
str(2 * x)
for x in accumulate(
[(sum(A[::2]) - sum(A[1::2])) // 2] + A[:-1], lambda acc, a: a - acc
)
)
print(ans)
| false | 0 |
[
"- [sum((-1) ** i * A[i] for i in range(N)) // 2] + A[:-1], lambda acc, a: a - acc",
"+ [(sum(A[::2]) - sum(A[1::2])) // 2] + A[:-1], lambda acc, a: a - acc"
] | false | 0.042189 | 0.112005 | 0.376671 |
[
"s616869332",
"s822457759"
] |
u600402037
|
p03835
|
python
|
s874316835
|
s893986962
| 1,564 | 1,364 | 2,940 | 2,940 |
Accepted
|
Accepted
| 12.79 |
K, S = list(map(int, input().split()))
count = 0
for i in range(K+1):
for j in range(K+1):
if S - K <= i + j <= S:
count += 1
print(count)
|
K, S = list(map(int, input().split()))
print((sum(S-K <= i+j <= S for j in range(K+1) for i in range(K+1))))
| 8 | 3 | 176 | 103 |
K, S = list(map(int, input().split()))
count = 0
for i in range(K + 1):
for j in range(K + 1):
if S - K <= i + j <= S:
count += 1
print(count)
|
K, S = list(map(int, input().split()))
print((sum(S - K <= i + j <= S for j in range(K + 1) for i in range(K + 1))))
| false | 62.5 |
[
"-count = 0",
"-for i in range(K + 1):",
"- for j in range(K + 1):",
"- if S - K <= i + j <= S:",
"- count += 1",
"-print(count)",
"+print((sum(S - K <= i + j <= S for j in range(K + 1) for i in range(K + 1))))"
] | false | 0.037262 | 0.03696 | 1.008165 |
[
"s874316835",
"s893986962"
] |
u903005414
|
p03673
|
python
|
s619385132
|
s276656034
| 1,062 | 204 | 34,208 | 25,412 |
Accepted
|
Accepted
| 80.79 |
import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
b = np.zeros(n, dtype='int')
cnt = 0
if n % 2 == 0:
for i in range(n // 2):
left_idx = n // 2 - 1 - i
right_idx = n // 2 + i
b[left_idx] = 2 * i + 1
b[right_idx] = 2 * i + 2
b = b[::-1]
else:
for i in range(n // 2):
left_idx = n // 2 - i
right_idx = n // 2 + 1 + i
b[left_idx] = 2 * i + 1
b[right_idx] = 2 * i + 2
b[0] = n
# print('b', b)
for i in a[[b - 1]]:
print(i)
|
from collections import deque
n = int(input())
a = list(map(int, input().split()))
d = deque()
for i, v in enumerate(a):
if i % 2 == 0:
d.appendleft(v)
else:
d.append(v)
if i % 2 == 1:
d = list(d)[::-1]
print(*d, sep=' ')
| 25 | 13 | 562 | 263 |
import numpy as np
n = int(eval(input()))
a = np.array(list(map(int, input().split())))
b = np.zeros(n, dtype="int")
cnt = 0
if n % 2 == 0:
for i in range(n // 2):
left_idx = n // 2 - 1 - i
right_idx = n // 2 + i
b[left_idx] = 2 * i + 1
b[right_idx] = 2 * i + 2
b = b[::-1]
else:
for i in range(n // 2):
left_idx = n // 2 - i
right_idx = n // 2 + 1 + i
b[left_idx] = 2 * i + 1
b[right_idx] = 2 * i + 2
b[0] = n
# print('b', b)
for i in a[[b - 1]]:
print(i)
|
from collections import deque
n = int(input())
a = list(map(int, input().split()))
d = deque()
for i, v in enumerate(a):
if i % 2 == 0:
d.appendleft(v)
else:
d.append(v)
if i % 2 == 1:
d = list(d)[::-1]
print(*d, sep=" ")
| false | 48 |
[
"-import numpy as np",
"+from collections import deque",
"-n = int(eval(input()))",
"-a = np.array(list(map(int, input().split())))",
"-b = np.zeros(n, dtype=\"int\")",
"-cnt = 0",
"-if n % 2 == 0:",
"- for i in range(n // 2):",
"- left_idx = n // 2 - 1 - i",
"- right_idx = n // 2 + i",
"- b[left_idx] = 2 * i + 1",
"- b[right_idx] = 2 * i + 2",
"- b = b[::-1]",
"-else:",
"- for i in range(n // 2):",
"- left_idx = n // 2 - i",
"- right_idx = n // 2 + 1 + i",
"- b[left_idx] = 2 * i + 1",
"- b[right_idx] = 2 * i + 2",
"- b[0] = n",
"-# print('b', b)",
"-for i in a[[b - 1]]:",
"- print(i)",
"+n = int(input())",
"+a = list(map(int, input().split()))",
"+d = deque()",
"+for i, v in enumerate(a):",
"+ if i % 2 == 0:",
"+ d.appendleft(v)",
"+ else:",
"+ d.append(v)",
"+if i % 2 == 1:",
"+ d = list(d)[::-1]",
"+print(*d, sep=\" \")"
] | false | 0.171266 | 0.038204 | 4.48287 |
[
"s619385132",
"s276656034"
] |
u077291787
|
p02558
|
python
|
s039723048
|
s062521814
| 289 | 265 | 53,624 | 144,916 |
Accepted
|
Accepted
| 8.3 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
def arc032_b():
# https://atcoder.jp/contests/arc032/tasks/arc032_2
N, M, *AB = list(map(int, open(0).read().split()))
tree = UnionFind(N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree.unite(a, b)
print((len(tree) - 2))
if __name__ == "__main__":
unionfind()
# arc032_b()
|
class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| 80 | 38 | 2,398 | 959 |
from typing import List
class UnionFind:
"""Union Find (Disjoint Set): O(α(N))
References:
https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp
https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html
"""
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
"""Find the group (root) of vertex x in O(α(n)) amortized."""
while self._roots[x] >= 0:
x = self._roots[x]
return x
def __len__(self) -> int:
"""Count the number of groups (roots)."""
return len(self.groups)
@property
def groups(self) -> List[int]:
"""Return the set of groups (roots) in O(n)."""
return [i for i, r in enumerate(self._roots) if r < 0]
def is_connected(self, x: int, y: int) -> bool:
"""Return whether two vertices x and y are connected in O(α(n)) amortized."""
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
"""Unite two groups of vertices x and y in O(α(n)) amortized."""
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
def get_size(self, x: int) -> int:
"""Return the size of the group where vertex x belongs in O(α(n)) amortized."""
return -self._roots[self[x]]
def unionfind():
# https://judge.yosupo.jp/problem/unionfind
# https://atcoder.jp/contests/practice2/tasks/practice2_a
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
def arc032_b():
# https://atcoder.jp/contests/arc032/tasks/arc032_2
N, M, *AB = list(map(int, open(0).read().split()))
tree = UnionFind(N + 1)
for a, b in zip(*[iter(AB)] * 2):
tree.unite(a, b)
print((len(tree) - 2))
if __name__ == "__main__":
unionfind()
# arc032_b()
|
class UnionFind:
__slots__ = ["_data_size", "_roots"]
def __init__(self, data_size: int) -> None:
self._data_size = data_size
self._roots = [-1] * data_size
def __getitem__(self, x: int) -> int:
while self._roots[x] >= 0:
x = self._roots[x]
return x
def is_connected(self, x: int, y: int) -> bool:
return self[x] == self[y]
def unite(self, x: int, y: int) -> None:
x, y = self[x], self[y]
if x == y:
return
if self._roots[x] > self._roots[y]:
x, y = y, x
self._roots[x] += self._roots[y]
self._roots[y] = x
import sys
read = sys.stdin.buffer.read
N, Q, *TUV = list(map(int, read().split()))
tree = UnionFind(N)
res = []
for t, u, v in zip(*[iter(TUV)] * 3):
if t:
res.append(int(tree.is_connected(u, v)))
else:
tree.unite(u, v)
print(("\n".join(map(str, res))))
| false | 52.5 |
[
"-from typing import List",
"-",
"-",
"- \"\"\"Union Find (Disjoint Set): O(α(N))",
"- References:",
"- https://github.com/atcoder/ac-library/blob/master/atcoder/dsu.hpp",
"- https://tumoiyorozu.github.io/single-file-ac-library/document_en/dsu.html",
"- \"\"\"",
"-",
"- \"\"\"Find the group (root) of vertex x in O(α(n)) amortized.\"\"\"",
"- def __len__(self) -> int:",
"- \"\"\"Count the number of groups (roots).\"\"\"",
"- return len(self.groups)",
"-",
"- @property",
"- def groups(self) -> List[int]:",
"- \"\"\"Return the set of groups (roots) in O(n).\"\"\"",
"- return [i for i, r in enumerate(self._roots) if r < 0]",
"-",
"- \"\"\"Return whether two vertices x and y are connected in O(α(n)) amortized.\"\"\"",
"- \"\"\"Unite two groups of vertices x and y in O(α(n)) amortized.\"\"\"",
"- def get_size(self, x: int) -> int:",
"- \"\"\"Return the size of the group where vertex x belongs in O(α(n)) amortized.\"\"\"",
"- return -self._roots[self[x]]",
"+import sys",
"-def unionfind():",
"- # https://judge.yosupo.jp/problem/unionfind",
"- # https://atcoder.jp/contests/practice2/tasks/practice2_a",
"- import sys",
"-",
"- read = sys.stdin.buffer.read",
"- N, Q, *TUV = list(map(int, read().split()))",
"- tree = UnionFind(N)",
"- res = []",
"- for t, u, v in zip(*[iter(TUV)] * 3):",
"- if t:",
"- res.append(int(tree.is_connected(u, v)))",
"- else:",
"- tree.unite(u, v)",
"- print((\"\\n\".join(map(str, res))))",
"-",
"-",
"-def arc032_b():",
"- # https://atcoder.jp/contests/arc032/tasks/arc032_2",
"- N, M, *AB = list(map(int, open(0).read().split()))",
"- tree = UnionFind(N + 1)",
"- for a, b in zip(*[iter(AB)] * 2):",
"- tree.unite(a, b)",
"- print((len(tree) - 2))",
"-",
"-",
"-if __name__ == \"__main__\":",
"- unionfind()",
"- # arc032_b()",
"+read = sys.stdin.buffer.read",
"+N, Q, *TUV = list(map(int, read().split()))",
"+tree = UnionFind(N)",
"+res = []",
"+for t, u, v in zip(*[iter(TUV)] * 3):",
"+ if t:",
"+ res.append(int(tree.is_connected(u, v)))",
"+ else:",
"+ tree.unite(u, v)",
"+print((\"\\n\".join(map(str, res))))"
] | false | 0.049746 | 0.050268 | 0.98963 |
[
"s039723048",
"s062521814"
] |
u268318377
|
p03200
|
python
|
s260476877
|
s652318501
| 45 | 39 | 7,476 | 7,400 |
Accepted
|
Accepted
| 13.33 |
S = eval(input())
N = S.count('W')
B = sum([b for b in range(1, N+1) if S[b-1] == 'B'])
W = sum([w for w in range(N+1, len(S)+1) if S[w-1] == 'W'])
print((W-B))
|
S = eval(input())
N = S.count('W')
B = sum([b for b in range(N) if S[b] == 'B'])
W = sum([w for w in range(N, len(S)) if S[w] == 'W'])
print((W-B))
| 5 | 5 | 156 | 143 |
S = eval(input())
N = S.count("W")
B = sum([b for b in range(1, N + 1) if S[b - 1] == "B"])
W = sum([w for w in range(N + 1, len(S) + 1) if S[w - 1] == "W"])
print((W - B))
|
S = eval(input())
N = S.count("W")
B = sum([b for b in range(N) if S[b] == "B"])
W = sum([w for w in range(N, len(S)) if S[w] == "W"])
print((W - B))
| false | 0 |
[
"-B = sum([b for b in range(1, N + 1) if S[b - 1] == \"B\"])",
"-W = sum([w for w in range(N + 1, len(S) + 1) if S[w - 1] == \"W\"])",
"+B = sum([b for b in range(N) if S[b] == \"B\"])",
"+W = sum([w for w in range(N, len(S)) if S[w] == \"W\"])"
] | false | 0.040182 | 0.039505 | 1.01714 |
[
"s260476877",
"s652318501"
] |
u392319141
|
p03252
|
python
|
s488267568
|
s804565641
| 126 | 87 | 10,408 | 3,632 |
Accepted
|
Accepted
| 30.95 |
S = list(eval(input()))
T = list(eval(input()))
countT = {}
countS = {}
for s, t in zip(S, T) :
if t in countT :
countT[t].append(s)
else :
countT[t] = [s]
if s in countS :
countS[s].append(t)
else :
countS[s] = [t]
for (_, s), (_, t) in zip(list(countS.items()), list(countT.items())) :
if len(set(s)) >= 2 or len(set(t)) >= 2:
print('No')
break
else :
print('Yes')
|
S = eval(input())
T = eval(input())
tToS = {}
sToT = {}
for s, t in zip(S, T):
if not t in tToS:
tToS[t] = s
if not s in sToT:
sToT[s] = t
if tToS[t] != s or sToT[s] != t:
print('No')
exit()
print('Yes')
| 22 | 16 | 439 | 254 |
S = list(eval(input()))
T = list(eval(input()))
countT = {}
countS = {}
for s, t in zip(S, T):
if t in countT:
countT[t].append(s)
else:
countT[t] = [s]
if s in countS:
countS[s].append(t)
else:
countS[s] = [t]
for (_, s), (_, t) in zip(list(countS.items()), list(countT.items())):
if len(set(s)) >= 2 or len(set(t)) >= 2:
print("No")
break
else:
print("Yes")
|
S = eval(input())
T = eval(input())
tToS = {}
sToT = {}
for s, t in zip(S, T):
if not t in tToS:
tToS[t] = s
if not s in sToT:
sToT[s] = t
if tToS[t] != s or sToT[s] != t:
print("No")
exit()
print("Yes")
| false | 27.272727 |
[
"-S = list(eval(input()))",
"-T = list(eval(input()))",
"-countT = {}",
"-countS = {}",
"+S = eval(input())",
"+T = eval(input())",
"+tToS = {}",
"+sToT = {}",
"- if t in countT:",
"- countT[t].append(s)",
"- else:",
"- countT[t] = [s]",
"- if s in countS:",
"- countS[s].append(t)",
"- else:",
"- countS[s] = [t]",
"-for (_, s), (_, t) in zip(list(countS.items()), list(countT.items())):",
"- if len(set(s)) >= 2 or len(set(t)) >= 2:",
"+ if not t in tToS:",
"+ tToS[t] = s",
"+ if not s in sToT:",
"+ sToT[s] = t",
"+ if tToS[t] != s or sToT[s] != t:",
"- break",
"-else:",
"- print(\"Yes\")",
"+ exit()",
"+print(\"Yes\")"
] | false | 0.071626 | 0.110705 | 0.646996 |
[
"s488267568",
"s804565641"
] |
u036104576
|
p03274
|
python
|
s390381467
|
s894052727
| 128 | 97 | 20,484 | 20,456 |
Accepted
|
Accepted
| 24.22 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ps = [0] + list([x for x in X if x >= 0])
ns = [0] + list(sorted([x for x in X if x < 0], reverse=True))
ans = INF
for i in range(len(ns)):
val = abs(ns[i]) * 2
if K - i >= 0 and K - i < len(ps):
val += abs(ps[K - i])
ans = min(ans, val)
for i in range(len(ps)):
val = abs(ps[i]) * 2
if K - i >= 0 and K - i < len(ns):
val += abs(ns[K - i])
ans = min(ans, val)
print(ans)
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
left = 0
right = K - 1
ans = INF
while right < len(X):
if X[right] <= 0:
ans = min(ans, abs(X[left]))
elif X[left] >= 0:
ans = min(ans, X[right])
else:
val1 = abs(X[left] - 0) * 2 + abs(X[right] - 0)
val2 = abs(X[right] - 0) * 2 + abs(X[left] - 0)
ans = min(ans, val1, val2)
left += 1
right += 1
print(ans)
| 36 | 36 | 856 | 795 |
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ps = [0] + list([x for x in X if x >= 0])
ns = [0] + list(sorted([x for x in X if x < 0], reverse=True))
ans = INF
for i in range(len(ns)):
val = abs(ns[i]) * 2
if K - i >= 0 and K - i < len(ps):
val += abs(ps[K - i])
ans = min(ans, val)
for i in range(len(ps)):
val = abs(ps[i]) * 2
if K - i >= 0 and K - i < len(ns):
val += abs(ns[K - i])
ans = min(ans, val)
print(ans)
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
from collections import defaultdict
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
left = 0
right = K - 1
ans = INF
while right < len(X):
if X[right] <= 0:
ans = min(ans, abs(X[left]))
elif X[left] >= 0:
ans = min(ans, X[right])
else:
val1 = abs(X[left] - 0) * 2 + abs(X[right] - 0)
val2 = abs(X[right] - 0) * 2 + abs(X[left] - 0)
ans = min(ans, val1, val2)
left += 1
right += 1
print(ans)
| false | 0 |
[
"-ps = [0] + list([x for x in X if x >= 0])",
"-ns = [0] + list(sorted([x for x in X if x < 0], reverse=True))",
"+left = 0",
"+right = K - 1",
"-for i in range(len(ns)):",
"- val = abs(ns[i]) * 2",
"- if K - i >= 0 and K - i < len(ps):",
"- val += abs(ps[K - i])",
"- ans = min(ans, val)",
"-for i in range(len(ps)):",
"- val = abs(ps[i]) * 2",
"- if K - i >= 0 and K - i < len(ns):",
"- val += abs(ns[K - i])",
"- ans = min(ans, val)",
"+while right < len(X):",
"+ if X[right] <= 0:",
"+ ans = min(ans, abs(X[left]))",
"+ elif X[left] >= 0:",
"+ ans = min(ans, X[right])",
"+ else:",
"+ val1 = abs(X[left] - 0) * 2 + abs(X[right] - 0)",
"+ val2 = abs(X[right] - 0) * 2 + abs(X[left] - 0)",
"+ ans = min(ans, val1, val2)",
"+ left += 1",
"+ right += 1"
] | false | 0.040433 | 0.130473 | 0.309892 |
[
"s390381467",
"s894052727"
] |
u442030035
|
p03013
|
python
|
s349315613
|
s549507822
| 462 | 200 | 460,020 | 6,900 |
Accepted
|
Accepted
| 56.71 |
N, M = list(map(int, input().split()))
a = [0] * N
for _ in range(M):
a[int(eval(input()))-1] = '!'
for i in range(N):
if i == 0:
if a[i] != '!':
a[i] = 1
else:
a[i] = 0
elif i == 1:
if a[i] != '!':
a[i] = a[i-1] + 1
else:
a[i] = 0
else:
if a[i] != '!':
a[i] = a[i-1] + a[i-2]
else:
a[i] = 0
print((a[N-1] % 1000000007))
|
N, M = list(map(int, input().split()))
a = [0] * N
for _ in range(M):
a[int(eval(input()))-1] = '!'
for i in range(N):
if i == 0:
if a[i] != '!':
a[i] = 1
else:
a[i] = 0
elif i == 1:
if a[i] != '!':
a[i] = a[i-1] + 1
else:
a[i] = 0
else:
if a[i] != '!':
a[i] = (a[i-1] + a[i-2]) % 1000000007
else:
a[i] = 0
print((a[N-1] % 1000000007))
| 23 | 23 | 467 | 482 |
N, M = list(map(int, input().split()))
a = [0] * N
for _ in range(M):
a[int(eval(input())) - 1] = "!"
for i in range(N):
if i == 0:
if a[i] != "!":
a[i] = 1
else:
a[i] = 0
elif i == 1:
if a[i] != "!":
a[i] = a[i - 1] + 1
else:
a[i] = 0
else:
if a[i] != "!":
a[i] = a[i - 1] + a[i - 2]
else:
a[i] = 0
print((a[N - 1] % 1000000007))
|
N, M = list(map(int, input().split()))
a = [0] * N
for _ in range(M):
a[int(eval(input())) - 1] = "!"
for i in range(N):
if i == 0:
if a[i] != "!":
a[i] = 1
else:
a[i] = 0
elif i == 1:
if a[i] != "!":
a[i] = a[i - 1] + 1
else:
a[i] = 0
else:
if a[i] != "!":
a[i] = (a[i - 1] + a[i - 2]) % 1000000007
else:
a[i] = 0
print((a[N - 1] % 1000000007))
| false | 0 |
[
"- a[i] = a[i - 1] + a[i - 2]",
"+ a[i] = (a[i - 1] + a[i - 2]) % 1000000007"
] | false | 0.198517 | 0.106687 | 1.860739 |
[
"s349315613",
"s549507822"
] |
u141610915
|
p02718
|
python
|
s367161790
|
s363405426
| 179 | 63 | 38,256 | 61,264 |
Accepted
|
Accepted
| 64.8 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
t = 0
for i in range(N):
if a[i] >= sm / (4 * M): t += 1
if t >= M: print("Yes")
else: print("No")
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse = True)
sm = sum(a)
for i in range(M):
if a[i] < sm / 4 / M:
print("No")
break
else: print("Yes")
| 10 | 11 | 228 | 239 |
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
sm = sum(a)
t = 0
for i in range(N):
if a[i] >= sm / (4 * M):
t += 1
if t >= M:
print("Yes")
else:
print("No")
|
import sys
input = sys.stdin.readline
N, M = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
sm = sum(a)
for i in range(M):
if a[i] < sm / 4 / M:
print("No")
break
else:
print("Yes")
| false | 9.090909 |
[
"+a.sort(reverse=True)",
"-t = 0",
"-for i in range(N):",
"- if a[i] >= sm / (4 * M):",
"- t += 1",
"-if t >= M:",
"+for i in range(M):",
"+ if a[i] < sm / 4 / M:",
"+ print(\"No\")",
"+ break",
"+else:",
"-else:",
"- print(\"No\")"
] | false | 0.080495 | 0.043377 | 1.855693 |
[
"s367161790",
"s363405426"
] |
u128999728
|
p02859
|
python
|
s110311054
|
s334517835
| 31 | 27 | 9,072 | 9,100 |
Accepted
|
Accepted
| 12.9 |
r = int(eval(input()))
print((r**2))
|
r = int(eval(input()))
print((r*r))
| 2 | 2 | 29 | 28 |
r = int(eval(input()))
print((r**2))
|
r = int(eval(input()))
print((r * r))
| false | 0 |
[
"-print((r**2))",
"+print((r * r))"
] | false | 0.14025 | 0.083527 | 1.679103 |
[
"s110311054",
"s334517835"
] |
u072053884
|
p02264
|
python
|
s166532184
|
s299668256
| 1,080 | 810 | 19,784 | 18,752 |
Accepted
|
Accepted
| 25 |
class Queue():
def __init__(self):
self.size = 0
self.Max = 100000
self.queue = [None]
def isEmpty(self):
return self.size == 0
def isFull(self):
return self.size >= self.Max
def enqueue(self, x):
if self.isFull():
print("Queue overflow!")
else:
self.queue.append(x)
self.size += 1
def dequeue(self):
if self.isEmpty():
print("Queue underflow!")
else:
self.size -= 1
return self.queue.pop(1)
p_queue = Queue()
e_time = 0
n, q = list(map(int, input().split()))
for i in range(n):
process = input().split()
process[1] = int(process[1])
p_queue.enqueue(process)
while not p_queue.isEmpty():
process = p_queue.dequeue()
if process[1] <= q:
e_time += process[1]
print((process[0], e_time))
else:
e_time += q
process[1] -= q
p_queue.enqueue(process)
|
class Process_Queue:
class Process:
def __init__(self, name, r_time, link = None):
self.name = name
self.r_time = r_time
self.link = link
def __init__(self, q):
self.size = 0
self.e_time = 0
self.q = q
self.front = None
self.rear = None
def enqueue(self, name, r_time):
if self.size == 0:
self.front = self.rear = Process_Queue.Process(name, r_time)
elif self.size == 100000:
raise Exception("queue overflow")
else:
new_process = Process_Queue.Process(name, r_time)
self.rear.link = new_process
self.rear = new_process
self.size += 1
def dequeue(self):
if self.size == 0:
raise Exception("queue underflow")
elif self.front.r_time > self.q:
self.enqueue(self.front.name, self.front.r_time - self.q)
self.front = self.front.link
self.e_time += self.q
elif self.front.r_time <= self.q:
p_name = self.front.name
self.e_time += self.front.r_time
print((p_name, self.e_time))
self.front = self.front.link
self.size -= 1
if self.size == 0:
self.rear = None
def isEmpty(self):
return self.size == 0
def isFull(self):
return self.size == 100000
n, q = list(map(int, input().split()))
p_queue = Process_Queue(q)
for i in range(n):
p = input().split()
p_queue.enqueue(p[0], int(p[1]))
while not p_queue.isEmpty():
p_queue.dequeue()
| 45 | 58 | 1,015 | 1,676 |
class Queue:
def __init__(self):
self.size = 0
self.Max = 100000
self.queue = [None]
def isEmpty(self):
return self.size == 0
def isFull(self):
return self.size >= self.Max
def enqueue(self, x):
if self.isFull():
print("Queue overflow!")
else:
self.queue.append(x)
self.size += 1
def dequeue(self):
if self.isEmpty():
print("Queue underflow!")
else:
self.size -= 1
return self.queue.pop(1)
p_queue = Queue()
e_time = 0
n, q = list(map(int, input().split()))
for i in range(n):
process = input().split()
process[1] = int(process[1])
p_queue.enqueue(process)
while not p_queue.isEmpty():
process = p_queue.dequeue()
if process[1] <= q:
e_time += process[1]
print((process[0], e_time))
else:
e_time += q
process[1] -= q
p_queue.enqueue(process)
|
class Process_Queue:
class Process:
def __init__(self, name, r_time, link=None):
self.name = name
self.r_time = r_time
self.link = link
def __init__(self, q):
self.size = 0
self.e_time = 0
self.q = q
self.front = None
self.rear = None
def enqueue(self, name, r_time):
if self.size == 0:
self.front = self.rear = Process_Queue.Process(name, r_time)
elif self.size == 100000:
raise Exception("queue overflow")
else:
new_process = Process_Queue.Process(name, r_time)
self.rear.link = new_process
self.rear = new_process
self.size += 1
def dequeue(self):
if self.size == 0:
raise Exception("queue underflow")
elif self.front.r_time > self.q:
self.enqueue(self.front.name, self.front.r_time - self.q)
self.front = self.front.link
self.e_time += self.q
elif self.front.r_time <= self.q:
p_name = self.front.name
self.e_time += self.front.r_time
print((p_name, self.e_time))
self.front = self.front.link
self.size -= 1
if self.size == 0:
self.rear = None
def isEmpty(self):
return self.size == 0
def isFull(self):
return self.size == 100000
n, q = list(map(int, input().split()))
p_queue = Process_Queue(q)
for i in range(n):
p = input().split()
p_queue.enqueue(p[0], int(p[1]))
while not p_queue.isEmpty():
p_queue.dequeue()
| false | 22.413793 |
[
"-class Queue:",
"- def __init__(self):",
"+class Process_Queue:",
"+ class Process:",
"+ def __init__(self, name, r_time, link=None):",
"+ self.name = name",
"+ self.r_time = r_time",
"+ self.link = link",
"+",
"+ def __init__(self, q):",
"- self.Max = 100000",
"- self.queue = [None]",
"+ self.e_time = 0",
"+ self.q = q",
"+ self.front = None",
"+ self.rear = None",
"+",
"+ def enqueue(self, name, r_time):",
"+ if self.size == 0:",
"+ self.front = self.rear = Process_Queue.Process(name, r_time)",
"+ elif self.size == 100000:",
"+ raise Exception(\"queue overflow\")",
"+ else:",
"+ new_process = Process_Queue.Process(name, r_time)",
"+ self.rear.link = new_process",
"+ self.rear = new_process",
"+ self.size += 1",
"+",
"+ def dequeue(self):",
"+ if self.size == 0:",
"+ raise Exception(\"queue underflow\")",
"+ elif self.front.r_time > self.q:",
"+ self.enqueue(self.front.name, self.front.r_time - self.q)",
"+ self.front = self.front.link",
"+ self.e_time += self.q",
"+ elif self.front.r_time <= self.q:",
"+ p_name = self.front.name",
"+ self.e_time += self.front.r_time",
"+ print((p_name, self.e_time))",
"+ self.front = self.front.link",
"+ self.size -= 1",
"+ if self.size == 0:",
"+ self.rear = None",
"- return self.size >= self.Max",
"-",
"- def enqueue(self, x):",
"- if self.isFull():",
"- print(\"Queue overflow!\")",
"- else:",
"- self.queue.append(x)",
"- self.size += 1",
"-",
"- def dequeue(self):",
"- if self.isEmpty():",
"- print(\"Queue underflow!\")",
"- else:",
"- self.size -= 1",
"- return self.queue.pop(1)",
"+ return self.size == 100000",
"-p_queue = Queue()",
"-e_time = 0",
"+p_queue = Process_Queue(q)",
"- process = input().split()",
"- process[1] = int(process[1])",
"- p_queue.enqueue(process)",
"+ p = input().split()",
"+ p_queue.enqueue(p[0], int(p[1]))",
"- process = p_queue.dequeue()",
"- if process[1] <= q:",
"- e_time += process[1]",
"- print((process[0], e_time))",
"- else:",
"- e_time += q",
"- process[1] -= q",
"- p_queue.enqueue(process)",
"+ p_queue.dequeue()"
] | false | 0.03772 | 0.036173 | 1.042746 |
[
"s166532184",
"s299668256"
] |
u706786134
|
p02911
|
python
|
s316322143
|
s527416088
| 272 | 220 | 4,680 | 7,052 |
Accepted
|
Accepted
| 19.12 |
n, k, q = list(map(int, input().split()))
score = [0] * n
for _ in range(q):
i = int(eval(input()))
i -= 1
score[i] += 1
for i in range(n):
print(('Yes' if k > q - score[i] else 'No'))
|
n, k, q = list(map(int, input().split()))
score = [k - q] * n
for _ in range(q):
i = int(eval(input()))
i -= 1
score[i] += 1
ans = '\n'.join('No' if x <= 0 else 'Yes' for x in score)
print(ans)
| 8 | 8 | 194 | 200 |
n, k, q = list(map(int, input().split()))
score = [0] * n
for _ in range(q):
i = int(eval(input()))
i -= 1
score[i] += 1
for i in range(n):
print(("Yes" if k > q - score[i] else "No"))
|
n, k, q = list(map(int, input().split()))
score = [k - q] * n
for _ in range(q):
i = int(eval(input()))
i -= 1
score[i] += 1
ans = "\n".join("No" if x <= 0 else "Yes" for x in score)
print(ans)
| false | 0 |
[
"-score = [0] * n",
"+score = [k - q] * n",
"-for i in range(n):",
"- print((\"Yes\" if k > q - score[i] else \"No\"))",
"+ans = \"\\n\".join(\"No\" if x <= 0 else \"Yes\" for x in score)",
"+print(ans)"
] | false | 0.035716 | 0.037403 | 0.954902 |
[
"s316322143",
"s527416088"
] |
u513081876
|
p04012
|
python
|
s580704598
|
s860243605
| 56 | 18 | 61,824 | 2,940 |
Accepted
|
Accepted
| 67.86 |
w = eval(input())
ww = set(w)
check = []
ans = 0
for i in ww:
check.append(w.count(i))
for i in check:
if i % 2 != 0:
print('No')
break
else:
print('Yes')
|
w = eval(input())
for i in set(list(w)):
if w.count(i) % 2 != 0:
print('No')
break
else:
print('Yes')
| 14 | 7 | 191 | 125 |
w = eval(input())
ww = set(w)
check = []
ans = 0
for i in ww:
check.append(w.count(i))
for i in check:
if i % 2 != 0:
print("No")
break
else:
print("Yes")
|
w = eval(input())
for i in set(list(w)):
if w.count(i) % 2 != 0:
print("No")
break
else:
print("Yes")
| false | 50 |
[
"-ww = set(w)",
"-check = []",
"-ans = 0",
"-for i in ww:",
"- check.append(w.count(i))",
"-for i in check:",
"- if i % 2 != 0:",
"+for i in set(list(w)):",
"+ if w.count(i) % 2 != 0:"
] | false | 0.037672 | 0.06788 | 0.554977 |
[
"s580704598",
"s860243605"
] |
u157232135
|
p02571
|
python
|
s906589656
|
s454840077
| 74 | 39 | 73,100 | 8,992 |
Accepted
|
Accepted
| 47.3 |
s=eval(input())
t=eval(input())
len_t = len(t)
ans=len_t
change=0
for i in range(len(s)-len_t+1):
ss=s[i:i+len_t]
for j in range(len_t):
if ss[j] != t[j]:
change += 1
ans=min(ans,change)
change=0
print(ans)
|
def main():
s=eval(input())
t=eval(input())
len_t=len(t)
ans = len_t
for i in range(len(s)-len_t+1):
c = 0
for j in range(len_t):
if s[i+j] != t[j]:
c += 1
ans = min(ans, c)
print(ans)
if __name__ == "__main__":
main()
| 13 | 15 | 242 | 305 |
s = eval(input())
t = eval(input())
len_t = len(t)
ans = len_t
change = 0
for i in range(len(s) - len_t + 1):
ss = s[i : i + len_t]
for j in range(len_t):
if ss[j] != t[j]:
change += 1
ans = min(ans, change)
change = 0
print(ans)
|
def main():
s = eval(input())
t = eval(input())
len_t = len(t)
ans = len_t
for i in range(len(s) - len_t + 1):
c = 0
for j in range(len_t):
if s[i + j] != t[j]:
c += 1
ans = min(ans, c)
print(ans)
if __name__ == "__main__":
main()
| false | 13.333333 |
[
"-s = eval(input())",
"-t = eval(input())",
"-len_t = len(t)",
"-ans = len_t",
"-change = 0",
"-for i in range(len(s) - len_t + 1):",
"- ss = s[i : i + len_t]",
"- for j in range(len_t):",
"- if ss[j] != t[j]:",
"- change += 1",
"- ans = min(ans, change)",
"- change = 0",
"-print(ans)",
"+def main():",
"+ s = eval(input())",
"+ t = eval(input())",
"+ len_t = len(t)",
"+ ans = len_t",
"+ for i in range(len(s) - len_t + 1):",
"+ c = 0",
"+ for j in range(len_t):",
"+ if s[i + j] != t[j]:",
"+ c += 1",
"+ ans = min(ans, c)",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.036134 | 0.035784 | 1.009778 |
[
"s906589656",
"s454840077"
] |
u166340293
|
p02659
|
python
|
s026649271
|
s010136976
| 28 | 23 | 10,068 | 9,104 |
Accepted
|
Accepted
| 17.86 |
import decimal
A,B=input().split()
A=int(A)
B=decimal.Decimal(B)
print((int(A*B)))
|
A,B=input().split()
A=int(A)
bb=[str (c) for c in B]
flag=1
bb.remove(".")
b="".join(bb)
print((A*int(b)//100))
| 5 | 9 | 84 | 119 |
import decimal
A, B = input().split()
A = int(A)
B = decimal.Decimal(B)
print((int(A * B)))
|
A, B = input().split()
A = int(A)
bb = [str(c) for c in B]
flag = 1
bb.remove(".")
b = "".join(bb)
print((A * int(b) // 100))
| false | 44.444444 |
[
"-import decimal",
"-",
"-B = decimal.Decimal(B)",
"-print((int(A * B)))",
"+bb = [str(c) for c in B]",
"+flag = 1",
"+bb.remove(\".\")",
"+b = \"\".join(bb)",
"+print((A * int(b) // 100))"
] | false | 0.039791 | 0.072594 | 0.548133 |
[
"s026649271",
"s010136976"
] |
u620238824
|
p02695
|
python
|
s304405815
|
s059928405
| 1,793 | 1,525 | 73,924 | 9,096 |
Accepted
|
Accepted
| 14.95 |
N, M, Q = list(map(int, input().split())) #数字
Q = [list(map(int, input().split())) for i in range(Q)] #数字複数列、複数行
import itertools
A = []
for i in itertools.combinations_with_replacement(list(range(M)),N):
score = 0
for j in range(len(Q)):
if i[Q[j][1]-1] - i[Q[j][0]-1] == Q[j][2]:
score += Q[j][3]
A.append(score)
print((max(A)))
|
N, M, Q = list(map(int, input().split())) #数字
Q = [list(map(int, input().split())) for i in range(Q)] #数字複数列、複数行
import itertools
A = 0
for i in itertools.combinations_with_replacement(list(range(M)),N):
score = 0
for j in range(len(Q)):
if i[Q[j][1]-1] - i[Q[j][0]-1] == Q[j][2]:
score += Q[j][3]
if score > A:
A = score
print(A)
| 13 | 14 | 368 | 383 |
N, M, Q = list(map(int, input().split())) # 数字
Q = [list(map(int, input().split())) for i in range(Q)] # 数字複数列、複数行
import itertools
A = []
for i in itertools.combinations_with_replacement(list(range(M)), N):
score = 0
for j in range(len(Q)):
if i[Q[j][1] - 1] - i[Q[j][0] - 1] == Q[j][2]:
score += Q[j][3]
A.append(score)
print((max(A)))
|
N, M, Q = list(map(int, input().split())) # 数字
Q = [list(map(int, input().split())) for i in range(Q)] # 数字複数列、複数行
import itertools
A = 0
for i in itertools.combinations_with_replacement(list(range(M)), N):
score = 0
for j in range(len(Q)):
if i[Q[j][1] - 1] - i[Q[j][0] - 1] == Q[j][2]:
score += Q[j][3]
if score > A:
A = score
print(A)
| false | 7.142857 |
[
"-A = []",
"+A = 0",
"- A.append(score)",
"-print((max(A)))",
"+ if score > A:",
"+ A = score",
"+print(A)"
] | false | 0.075073 | 0.060904 | 1.232646 |
[
"s304405815",
"s059928405"
] |
u535423069
|
p02726
|
python
|
s181335577
|
s849545690
| 517 | 322 | 51,292 | 49,116 |
Accepted
|
Accepted
| 37.72 |
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import defaultdict, deque
n, x, y = na()
x -= 1
y -= 1
d = defaultdict(int)
g = [[] for _ in range(n)]
for i in range(n - 1):
g[i].append(i + 1)
g[i + 1].append(i)
g[x].append(y)
g[y].append(x)
def bfs(i):
q = deque()
q.append(i)
dist = [-1] * n
dist[i] = 0
while len(q):
p = q.popleft()
for j in g[p]:
if dist[j] != -1:
continue
dist[j] = dist[p] + 1
q.append(j)
return dist
dic = defaultdict(int)
for i in range(n):
d = bfs(i)
for j in range(n):
dic[d[j]] += 1
for i in range(1, n):
print((dic[i] // 2))
|
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import defaultdict
n, x, y = na()
x -= 1
y -= 1
dic = defaultdict(int)
for i in range(n):
for j in range(i + 1, n):
dist = min(j - i, 1 + abs(x - i) + abs(y - j))
dic[dist] += 1
for i in range(1, n):
print((dic[i]))
| 57 | 35 | 1,368 | 958 |
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import defaultdict, deque
n, x, y = na()
x -= 1
y -= 1
d = defaultdict(int)
g = [[] for _ in range(n)]
for i in range(n - 1):
g[i].append(i + 1)
g[i + 1].append(i)
g[x].append(y)
g[y].append(x)
def bfs(i):
q = deque()
q.append(i)
dist = [-1] * n
dist[i] = 0
while len(q):
p = q.popleft()
for j in g[p]:
if dist[j] != -1:
continue
dist[j] = dist[p] + 1
q.append(j)
return dist
dic = defaultdict(int)
for i in range(n):
d = bfs(i)
for j in range(n):
dic[d[j]] += 1
for i in range(1, n):
print((dic[i] // 2))
|
# Author: cr4zjh0bp
# Created: Sat Mar 28 11:53:27 UTC 2020
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
from collections import defaultdict
n, x, y = na()
x -= 1
y -= 1
dic = defaultdict(int)
for i in range(n):
for j in range(i + 1, n):
dist = min(j - i, 1 + abs(x - i) + abs(y - j))
dic[dist] += 1
for i in range(1, n):
print((dic[i]))
| false | 38.596491 |
[
"-from collections import defaultdict, deque",
"+from collections import defaultdict",
"-d = defaultdict(int)",
"-g = [[] for _ in range(n)]",
"-for i in range(n - 1):",
"- g[i].append(i + 1)",
"- g[i + 1].append(i)",
"-g[x].append(y)",
"-g[y].append(x)",
"-",
"-",
"-def bfs(i):",
"- q = deque()",
"- q.append(i)",
"- dist = [-1] * n",
"- dist[i] = 0",
"- while len(q):",
"- p = q.popleft()",
"- for j in g[p]:",
"- if dist[j] != -1:",
"- continue",
"- dist[j] = dist[p] + 1",
"- q.append(j)",
"- return dist",
"-",
"-",
"- d = bfs(i)",
"- for j in range(n):",
"- dic[d[j]] += 1",
"+ for j in range(i + 1, n):",
"+ dist = min(j - i, 1 + abs(x - i) + abs(y - j))",
"+ dic[dist] += 1",
"- print((dic[i] // 2))",
"+ print((dic[i]))"
] | false | 0.045265 | 0.090309 | 0.501223 |
[
"s181335577",
"s849545690"
] |
u408325839
|
p03043
|
python
|
s799666106
|
s360087901
| 514 | 45 | 18,744 | 9,104 |
Accepted
|
Accepted
| 91.25 |
from decimal import Decimal
from fractions import Fraction
n, k = list(map(int, input().split()))
prob = []
for base in range(1, n+1):
p = 0
while (base < k):
p += 1
base = base * 2
prob.append(Fraction(1, n * (2 ** p)))
print((Decimal(sum(prob).numerator / sum(prob).denominator)))
|
N, K = list(map(int, input().split()))
result = 0
for i in range(1, N+1):
score = i
sub_prob_recip = N
while score < K:
sub_prob_recip *= 2
score *= 2
result += 1/sub_prob_recip
print(result)
| 13 | 12 | 303 | 231 |
from decimal import Decimal
from fractions import Fraction
n, k = list(map(int, input().split()))
prob = []
for base in range(1, n + 1):
p = 0
while base < k:
p += 1
base = base * 2
prob.append(Fraction(1, n * (2**p)))
print((Decimal(sum(prob).numerator / sum(prob).denominator)))
|
N, K = list(map(int, input().split()))
result = 0
for i in range(1, N + 1):
score = i
sub_prob_recip = N
while score < K:
sub_prob_recip *= 2
score *= 2
result += 1 / sub_prob_recip
print(result)
| false | 7.692308 |
[
"-from decimal import Decimal",
"-from fractions import Fraction",
"-",
"-n, k = list(map(int, input().split()))",
"-prob = []",
"-for base in range(1, n + 1):",
"- p = 0",
"- while base < k:",
"- p += 1",
"- base = base * 2",
"- prob.append(Fraction(1, n * (2**p)))",
"-print((Decimal(sum(prob).numerator / sum(prob).denominator)))",
"+N, K = list(map(int, input().split()))",
"+result = 0",
"+for i in range(1, N + 1):",
"+ score = i",
"+ sub_prob_recip = N",
"+ while score < K:",
"+ sub_prob_recip *= 2",
"+ score *= 2",
"+ result += 1 / sub_prob_recip",
"+print(result)"
] | false | 0.542004 | 0.052271 | 10.369102 |
[
"s799666106",
"s360087901"
] |
u644171993
|
p03160
|
python
|
s449892883
|
s479041576
| 103 | 92 | 76,384 | 84,256 |
Accepted
|
Accepted
| 10.68 |
#!/usr/bin/env python3
n = int(eval(input()))
harr = [int(i) for i in input().split(' ')]
twojump = 0
onejump = abs(harr[1] - harr[0])
ans = onejump
for i in range(2, n):
ans = min(abs(harr[i]-harr[i-1])+onejump, abs(harr[i]-harr[i-2])+twojump)
twojump = onejump
onejump = ans
print(ans)
|
#!/usr/bin/env python3
n = int(eval(input()))
arr = [int(i) for i in input().split(' ')]
dp = [10**10]*n
dp[0] = 0
for i in range(0, n):
for j in range(1, 3):
if i+j < n:
dp[i+j] = min(dp[i+j], dp[i] + abs(arr[i+j]-arr[i]))
print((dp[n-1]))
| 16 | 16 | 314 | 278 |
#!/usr/bin/env python3
n = int(eval(input()))
harr = [int(i) for i in input().split(" ")]
twojump = 0
onejump = abs(harr[1] - harr[0])
ans = onejump
for i in range(2, n):
ans = min(
abs(harr[i] - harr[i - 1]) + onejump, abs(harr[i] - harr[i - 2]) + twojump
)
twojump = onejump
onejump = ans
print(ans)
|
#!/usr/bin/env python3
n = int(eval(input()))
arr = [int(i) for i in input().split(" ")]
dp = [10**10] * n
dp[0] = 0
for i in range(0, n):
for j in range(1, 3):
if i + j < n:
dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i + j] - arr[i]))
print((dp[n - 1]))
| false | 0 |
[
"-harr = [int(i) for i in input().split(\" \")]",
"-twojump = 0",
"-onejump = abs(harr[1] - harr[0])",
"-ans = onejump",
"-for i in range(2, n):",
"- ans = min(",
"- abs(harr[i] - harr[i - 1]) + onejump, abs(harr[i] - harr[i - 2]) + twojump",
"- )",
"- twojump = onejump",
"- onejump = ans",
"-print(ans)",
"+arr = [int(i) for i in input().split(\" \")]",
"+dp = [10**10] * n",
"+dp[0] = 0",
"+for i in range(0, n):",
"+ for j in range(1, 3):",
"+ if i + j < n:",
"+ dp[i + j] = min(dp[i + j], dp[i] + abs(arr[i + j] - arr[i]))",
"+print((dp[n - 1]))"
] | false | 0.044917 | 0.048327 | 0.929432 |
[
"s449892883",
"s479041576"
] |
u839188633
|
p03064
|
python
|
s516844792
|
s893223572
| 823 | 741 | 14,556 | 14,676 |
Accepted
|
Accepted
| 9.96 |
import numpy as np
from math import ceil
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
modulo = 998244353
s = sum(a)
dp = np.zeros(s + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = 2 * dp[ai:] + dp[:-ai]
dp[:ai] = 2 * dp[:ai]
dp %= modulo
sol = 3 ** n % modulo
sol -= 3 * dp[ceil(s / 2) :].sum()
if s % 2 == 0:
dp = np.zeros(s // 2 + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = (dp[ai:] + dp[:-ai]) % modulo
sol += 3 * dp[s // 2]
sol %= modulo
print(sol)
|
import numpy as np
from math import ceil
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
modulo = 998244353
a.sort(reverse=True)
cumsump1 = 1
s = sum(a)
dp = np.zeros(s + 1, dtype=np.int)
dp[0] = 1
for ai in a:
cumsump1 += ai
dp[ai:cumsump1] = 2 * dp[ai:cumsump1] + dp[: -ai + cumsump1]
dp[:ai] = 2 * dp[:ai]
dp %= modulo
ans = 3 ** n % modulo
ans -= 3 * dp[ceil(s / 2) :].sum()
if s % 2 == 0:
dp = np.zeros(s // 2 + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = (dp[ai:] + dp[:-ai]) % modulo
ans += 3 * dp[s // 2]
ans %= modulo
print(ans)
| 30 | 34 | 546 | 632 |
import numpy as np
from math import ceil
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
modulo = 998244353
s = sum(a)
dp = np.zeros(s + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = 2 * dp[ai:] + dp[:-ai]
dp[:ai] = 2 * dp[:ai]
dp %= modulo
sol = 3**n % modulo
sol -= 3 * dp[ceil(s / 2) :].sum()
if s % 2 == 0:
dp = np.zeros(s // 2 + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = (dp[ai:] + dp[:-ai]) % modulo
sol += 3 * dp[s // 2]
sol %= modulo
print(sol)
|
import numpy as np
from math import ceil
n = int(eval(input()))
a = [int(eval(input())) for _ in range(n)]
modulo = 998244353
a.sort(reverse=True)
cumsump1 = 1
s = sum(a)
dp = np.zeros(s + 1, dtype=np.int)
dp[0] = 1
for ai in a:
cumsump1 += ai
dp[ai:cumsump1] = 2 * dp[ai:cumsump1] + dp[: -ai + cumsump1]
dp[:ai] = 2 * dp[:ai]
dp %= modulo
ans = 3**n % modulo
ans -= 3 * dp[ceil(s / 2) :].sum()
if s % 2 == 0:
dp = np.zeros(s // 2 + 1, dtype=np.int)
dp[0] = 1
for ai in a:
dp[ai:] = (dp[ai:] + dp[:-ai]) % modulo
ans += 3 * dp[s // 2]
ans %= modulo
print(ans)
| false | 11.764706 |
[
"+a.sort(reverse=True)",
"+cumsump1 = 1",
"- dp[ai:] = 2 * dp[ai:] + dp[:-ai]",
"+ cumsump1 += ai",
"+ dp[ai:cumsump1] = 2 * dp[ai:cumsump1] + dp[: -ai + cumsump1]",
"-sol = 3**n % modulo",
"-sol -= 3 * dp[ceil(s / 2) :].sum()",
"+ans = 3**n % modulo",
"+ans -= 3 * dp[ceil(s / 2) :].sum()",
"- sol += 3 * dp[s // 2]",
"-sol %= modulo",
"-print(sol)",
"+ ans += 3 * dp[s // 2]",
"+ans %= modulo",
"+print(ans)"
] | false | 0.284025 | 0.271382 | 1.046587 |
[
"s516844792",
"s893223572"
] |
u729133443
|
p02844
|
python
|
s426600873
|
s875911086
| 1,259 | 663 | 3,188 | 3,188 |
Accepted
|
Accepted
| 47.34 |
_,s=open(0)
dp=[[0]*1000for _ in range(4)]
dp[0][0]=1
for c in map(int,s[:-1]):
for i in range(3,0,-1):
for j in range(10**(i-1)):
dp[i][j*10+c]|=dp[i-1][j]
print((sum(dp[3][i]for i in range(1000))))
|
eval(input())
a=set(),set(),set(),{''}
for s in eval(input()):
for b,c in zip(a,a[1:]):b|={t+s for t in c}
print((len(a[0])))
| 8 | 5 | 216 | 116 |
_, s = open(0)
dp = [[0] * 1000 for _ in range(4)]
dp[0][0] = 1
for c in map(int, s[:-1]):
for i in range(3, 0, -1):
for j in range(10 ** (i - 1)):
dp[i][j * 10 + c] |= dp[i - 1][j]
print((sum(dp[3][i] for i in range(1000))))
|
eval(input())
a = set(), set(), set(), {""}
for s in eval(input()):
for b, c in zip(a, a[1:]):
b |= {t + s for t in c}
print((len(a[0])))
| false | 37.5 |
[
"-_, s = open(0)",
"-dp = [[0] * 1000 for _ in range(4)]",
"-dp[0][0] = 1",
"-for c in map(int, s[:-1]):",
"- for i in range(3, 0, -1):",
"- for j in range(10 ** (i - 1)):",
"- dp[i][j * 10 + c] |= dp[i - 1][j]",
"-print((sum(dp[3][i] for i in range(1000))))",
"+eval(input())",
"+a = set(), set(), set(), {\"\"}",
"+for s in eval(input()):",
"+ for b, c in zip(a, a[1:]):",
"+ b |= {t + s for t in c}",
"+print((len(a[0])))"
] | false | 0.0459 | 0.037642 | 1.21937 |
[
"s426600873",
"s875911086"
] |
u626337957
|
p03474
|
python
|
s270836465
|
s633888203
| 20 | 17 | 3,060 | 2,940 |
Accepted
|
Accepted
| 15 |
def is_int(s):
try:
int(s)
return True
except ValueError:
return False
A, B = list(map(int, input().split()))
S = eval(input())
if is_int(S[:A]) and S[A] == '-' and is_int(S[A+1:]):
print('Yes')
else:
print('No')
|
A, B = list(map(int, input().split()))
S = eval(input())
if not '-' in S[:A]+S[A+1:] and S[A] == '-':
print('Yes')
else:
print('No')
| 13 | 6 | 249 | 129 |
def is_int(s):
try:
int(s)
return True
except ValueError:
return False
A, B = list(map(int, input().split()))
S = eval(input())
if is_int(S[:A]) and S[A] == "-" and is_int(S[A + 1 :]):
print("Yes")
else:
print("No")
|
A, B = list(map(int, input().split()))
S = eval(input())
if not "-" in S[:A] + S[A + 1 :] and S[A] == "-":
print("Yes")
else:
print("No")
| false | 53.846154 |
[
"-def is_int(s):",
"- try:",
"- int(s)",
"- return True",
"- except ValueError:",
"- return False",
"-",
"-",
"-if is_int(S[:A]) and S[A] == \"-\" and is_int(S[A + 1 :]):",
"+if not \"-\" in S[:A] + S[A + 1 :] and S[A] == \"-\":"
] | false | 0.049128 | 0.049964 | 0.983273 |
[
"s270836465",
"s633888203"
] |
u426534722
|
p02243
|
python
|
s565286375
|
s798327612
| 390 | 350 | 42,520 | 42,444 |
Accepted
|
Accepted
| 10.26 |
from sys import stdin
import heapq
INF = 1<<21
n = int(stdin.readline())
adj = [[]] * n
for u in range(0, n):
U = list(map(int, stdin.readline().split()[2:]))
adj[u] = (e for e in zip(U[0::2], U[1::2]))
def dijkstra():
d = [0] + [INF] * (n - 1)
hq = [(0, 0)]
while hq:
u = heapq.heappop(hq)[1]
for v, c in adj[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
heapq.heappush(hq, (alt, v))
for i, c in enumerate(d):
print((i, c))
dijkstra()
|
from sys import stdin
import heapq
INF = 1<<21
n = int(stdin.readline())
adj = [[]] * n
for u in range(0, n):
U = list(map(int, stdin.readline().split()[2:]))
adj[u] = list(zip(U[0::2], U[1::2]))
def dijkstra():
d = [0] + [INF] * (n - 1)
hq = [(0, 0)]
while hq:
u = heapq.heappop(hq)[1]
for v, c in adj[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
heapq.heappush(hq, (alt, v))
for i, c in enumerate(d):
print((i, c))
dijkstra()
| 21 | 21 | 556 | 543 |
from sys import stdin
import heapq
INF = 1 << 21
n = int(stdin.readline())
adj = [[]] * n
for u in range(0, n):
U = list(map(int, stdin.readline().split()[2:]))
adj[u] = (e for e in zip(U[0::2], U[1::2]))
def dijkstra():
d = [0] + [INF] * (n - 1)
hq = [(0, 0)]
while hq:
u = heapq.heappop(hq)[1]
for v, c in adj[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
heapq.heappush(hq, (alt, v))
for i, c in enumerate(d):
print((i, c))
dijkstra()
|
from sys import stdin
import heapq
INF = 1 << 21
n = int(stdin.readline())
adj = [[]] * n
for u in range(0, n):
U = list(map(int, stdin.readline().split()[2:]))
adj[u] = list(zip(U[0::2], U[1::2]))
def dijkstra():
d = [0] + [INF] * (n - 1)
hq = [(0, 0)]
while hq:
u = heapq.heappop(hq)[1]
for v, c in adj[u]:
alt = d[u] + c
if d[v] > alt:
d[v] = alt
heapq.heappush(hq, (alt, v))
for i, c in enumerate(d):
print((i, c))
dijkstra()
| false | 0 |
[
"- adj[u] = (e for e in zip(U[0::2], U[1::2]))",
"+ adj[u] = list(zip(U[0::2], U[1::2]))"
] | false | 0.054986 | 0.03942 | 1.394895 |
[
"s565286375",
"s798327612"
] |
u785266893
|
p02641
|
python
|
s555621007
|
s923692236
| 123 | 26 | 27,288 | 9,152 |
Accepted
|
Accepted
| 78.86 |
import numpy as np
x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit()
p = np.array(list(map(int, input().split())))
for i in range(100):
if not x-i in p:
print((x-i))
exit()
elif not x+i in p:
print((x+i))
exit()
|
x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit()
p = list(map(int, input().split()))
for i in range(100):
if not x-i in p:
print((x-i))
exit()
elif not x+i in p:
print((x+i))
exit()
| 15 | 13 | 281 | 250 |
import numpy as np
x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit()
p = np.array(list(map(int, input().split())))
for i in range(100):
if not x - i in p:
print((x - i))
exit()
elif not x + i in p:
print((x + i))
exit()
|
x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit()
p = list(map(int, input().split()))
for i in range(100):
if not x - i in p:
print((x - i))
exit()
elif not x + i in p:
print((x + i))
exit()
| false | 13.333333 |
[
"-import numpy as np",
"-",
"-p = np.array(list(map(int, input().split())))",
"+p = list(map(int, input().split()))"
] | false | 0.284967 | 0.038244 | 7.45122 |
[
"s555621007",
"s923692236"
] |
u699089116
|
p02754
|
python
|
s101682157
|
s722162127
| 223 | 169 | 38,384 | 38,384 |
Accepted
|
Accepted
| 24.22 |
n, a, b = list(map(int, input().split()))
ans = (n // (a + b)) * a
if n % (a + b) <= a:
ans += n % (a + b)
else:
ans += a
print(ans)
|
n, a, b = list(map(int, input().split()))
ans = n // (a+b) * a
ans += n % (a + b) if n % (a + b) <= a else a
print(ans)
| 10 | 6 | 146 | 120 |
n, a, b = list(map(int, input().split()))
ans = (n // (a + b)) * a
if n % (a + b) <= a:
ans += n % (a + b)
else:
ans += a
print(ans)
|
n, a, b = list(map(int, input().split()))
ans = n // (a + b) * a
ans += n % (a + b) if n % (a + b) <= a else a
print(ans)
| false | 40 |
[
"-ans = (n // (a + b)) * a",
"-if n % (a + b) <= a:",
"- ans += n % (a + b)",
"-else:",
"- ans += a",
"+ans = n // (a + b) * a",
"+ans += n % (a + b) if n % (a + b) <= a else a"
] | false | 0.038811 | 0.040218 | 0.965012 |
[
"s101682157",
"s722162127"
] |
u254871849
|
p02971
|
python
|
s817798416
|
s426001429
| 271 | 245 | 25,036 | 25,156 |
Accepted
|
Accepted
| 9.59 |
# 2019-11-15 14:12:24(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n, *a = [int(x) for x in sys.stdin.read().split()]
b = a.copy()
b.sort()
largest = b[-1]
second_largest = None
if b[-2] == largest:
pass
else:
second_largest = b[-2]
if not second_largest:
for i in range(n):
print(largest)
else:
for i in range(n):
if a[i] == largest:
print(second_largest)
else:
print(largest)
if __name__ == "__main__":
main()
|
import sys
n, *a = map(int, sys.stdin.read().split())
def main():
b = sorted(a.copy())
m1 = b[-1]
m2 = b[-2]
if m1 == m2:
res = [m1] * n
else:
res = [None] * n
for i in range(n):
if a[i] < m1:
res[i] = m1
else:
res[i] = m2
return res
if __name__ == '__main__':
ans = main()
print(*ans, sep='\n')
| 36 | 22 | 872 | 435 |
# 2019-11-15 14:12:24(JST)
import sys
# import collections
# import math
# from string import ascii_lowercase, ascii_uppercase, digits
# from bisect import bisect_left as bi_l, bisect_right as bi_r
# import itertools
# from functools import reduce
# import operator as op
# from scipy.misc import comb # float
# import numpy as np
def main():
n, *a = [int(x) for x in sys.stdin.read().split()]
b = a.copy()
b.sort()
largest = b[-1]
second_largest = None
if b[-2] == largest:
pass
else:
second_largest = b[-2]
if not second_largest:
for i in range(n):
print(largest)
else:
for i in range(n):
if a[i] == largest:
print(second_largest)
else:
print(largest)
if __name__ == "__main__":
main()
|
import sys
n, *a = map(int, sys.stdin.read().split())
def main():
b = sorted(a.copy())
m1 = b[-1]
m2 = b[-2]
if m1 == m2:
res = [m1] * n
else:
res = [None] * n
for i in range(n):
if a[i] < m1:
res[i] = m1
else:
res[i] = m2
return res
if __name__ == "__main__":
ans = main()
print(*ans, sep="\n")
| false | 38.888889 |
[
"-# 2019-11-15 14:12:24(JST)",
"-# import collections",
"-# import math",
"-# from string import ascii_lowercase, ascii_uppercase, digits",
"-# from bisect import bisect_left as bi_l, bisect_right as bi_r",
"-# import itertools",
"-# from functools import reduce",
"-# import operator as op",
"-# from scipy.misc import comb # float",
"-# import numpy as np",
"+n, *a = map(int, sys.stdin.read().split())",
"+",
"+",
"- n, *a = [int(x) for x in sys.stdin.read().split()]",
"- b = a.copy()",
"- b.sort()",
"- largest = b[-1]",
"- second_largest = None",
"- if b[-2] == largest:",
"- pass",
"+ b = sorted(a.copy())",
"+ m1 = b[-1]",
"+ m2 = b[-2]",
"+ if m1 == m2:",
"+ res = [m1] * n",
"- second_largest = b[-2]",
"- if not second_largest:",
"+ res = [None] * n",
"- print(largest)",
"- else:",
"- for i in range(n):",
"- if a[i] == largest:",
"- print(second_largest)",
"+ if a[i] < m1:",
"+ res[i] = m1",
"- print(largest)",
"+ res[i] = m2",
"+ return res",
"- main()",
"+ ans = main()",
"+ print(*ans, sep=\"\\n\")"
] | false | 0.035014 | 0.031838 | 1.099754 |
[
"s817798416",
"s426001429"
] |
u614314290
|
p03137
|
python
|
s709505961
|
s820873373
| 122 | 101 | 13,968 | 13,968 |
Accepted
|
Accepted
| 17.21 |
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
x = sorted(X)
diff = []
for n in range(1, M):
diff += [abs(x[n] - x[n - 1])]
diff.sort(reverse=True)
print((abs(x[-1] - x[0]) - sum(diff[:N - 1])))
|
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
x = sorted(X)
x_diff = [(x[m] - x[m - 1]) for m in range(1, M)]
x_diff.sort(reverse=True)
print(((x[-1] - x[0]) - sum(x_diff[:N - 1])))
| 11 | 8 | 229 | 212 |
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
x = sorted(X)
diff = []
for n in range(1, M):
diff += [abs(x[n] - x[n - 1])]
diff.sort(reverse=True)
print((abs(x[-1] - x[0]) - sum(diff[: N - 1])))
|
N, M = list(map(int, input().split()))
X = list(map(int, input().split()))
x = sorted(X)
x_diff = [(x[m] - x[m - 1]) for m in range(1, M)]
x_diff.sort(reverse=True)
print(((x[-1] - x[0]) - sum(x_diff[: N - 1])))
| false | 27.272727 |
[
"-diff = []",
"-for n in range(1, M):",
"- diff += [abs(x[n] - x[n - 1])]",
"-diff.sort(reverse=True)",
"-print((abs(x[-1] - x[0]) - sum(diff[: N - 1])))",
"+x_diff = [(x[m] - x[m - 1]) for m in range(1, M)]",
"+x_diff.sort(reverse=True)",
"+print(((x[-1] - x[0]) - sum(x_diff[: N - 1])))"
] | false | 0.044253 | 0.039034 | 1.133697 |
[
"s709505961",
"s820873373"
] |
u790710233
|
p02684
|
python
|
s617556026
|
s376035141
| 284 | 166 | 176,040 | 32,188 |
Accepted
|
Accepted
| 41.55 |
n, k = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
bit = k.bit_length()
table = [[0]*n for _ in range(bit)]
table[0] = A
for i in range(1, bit):
for j in range(n):
table[i][j] = table[i-1][table[i-1][j]]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[i][ans]
print((ans+1))
|
n, k = list(map(int, input().split()))
A = list([int(x)-1 for x in input().split()])
history = [-1]*n
cur = 0
for i in range(n):
if history[cur] != -1:
init_cnt = history[cur]
loop_cnt = i - history[cur]
break
history[cur] = i
cur = A[cur]
loop = k if k <= init_cnt else init_cnt+((k-init_cnt) % loop_cnt)
print((history.index(loop)+1))
| 16 | 15 | 387 | 385 |
n, k = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
bit = k.bit_length()
table = [[0] * n for _ in range(bit)]
table[0] = A
for i in range(1, bit):
for j in range(n):
table[i][j] = table[i - 1][table[i - 1][j]]
ans = 0
for i in reversed(list(range(bit))):
if (1 << i) <= k:
k -= 1 << i
ans = table[i][ans]
print((ans + 1))
|
n, k = list(map(int, input().split()))
A = list([int(x) - 1 for x in input().split()])
history = [-1] * n
cur = 0
for i in range(n):
if history[cur] != -1:
init_cnt = history[cur]
loop_cnt = i - history[cur]
break
history[cur] = i
cur = A[cur]
loop = k if k <= init_cnt else init_cnt + ((k - init_cnt) % loop_cnt)
print((history.index(loop) + 1))
| false | 6.25 |
[
"-bit = k.bit_length()",
"-table = [[0] * n for _ in range(bit)]",
"-table[0] = A",
"-for i in range(1, bit):",
"- for j in range(n):",
"- table[i][j] = table[i - 1][table[i - 1][j]]",
"-ans = 0",
"-for i in reversed(list(range(bit))):",
"- if (1 << i) <= k:",
"- k -= 1 << i",
"- ans = table[i][ans]",
"-print((ans + 1))",
"+history = [-1] * n",
"+cur = 0",
"+for i in range(n):",
"+ if history[cur] != -1:",
"+ init_cnt = history[cur]",
"+ loop_cnt = i - history[cur]",
"+ break",
"+ history[cur] = i",
"+ cur = A[cur]",
"+loop = k if k <= init_cnt else init_cnt + ((k - init_cnt) % loop_cnt)",
"+print((history.index(loop) + 1))"
] | false | 0.035435 | 0.038412 | 0.922504 |
[
"s617556026",
"s376035141"
] |
u812576525
|
p03274
|
python
|
s043440881
|
s396621211
| 96 | 77 | 15,076 | 20,192 |
Accepted
|
Accepted
| 19.79 |
N, K = list(map(int,input().split()))
A = list(map(int,input().split()))
P = [0] + [abs(i) for i in A if i> 0 ]
M = [abs(i) for i in A if i< 0 ] +[0]
M = sorted(M,reverse =False)
cnt = 10000000000
if len(P) == len(M) == 1:
cnt = 0
elif len(P) == 1:
cnt = M[K]
elif len(M) == 1:
cnt = P[K]
else:
#リストがK以下の場合不具合が起きる
#for i in range(1,K):
#len(P)=4 len(M)=3 K=5の場合、IndexErrorとなる。rangeをうまく設定する必要があるが実装できない。
#正の方向でi個ろうそくを通って、負の方向にK-i個ろうそくを通る
s = max(0,K-len(M)+1)
e = min(K+1, len(P))
for i in range(s, e):
cnt =min(cnt,P[i]*2 + M[K-i])
#負の方向でi個ろうそくを通って、正の方向にK-i個ろうそくを通る
s1 = max(0,K-len(P)+1)
e1 = min(K+1, len(M))
for i in range(s1, e1):
cnt =min(cnt,M[i]*2 + P[K-i])
print(cnt)
|
N,K = list(map(int,input().split()))
X = list(map(int,input().split()))
ans = 10**10
for i in range(N-K+1):
#S = X[i:i+K]
#print(S,S[0],S[-1])
mi = X[i]
ma = X[i+K-1]
#print(mi,ma)
if ma<=0:
ans = min(ans ,abs(mi))
elif mi>0:
ans = min(ans ,ma)
elif mi<0 and ma>0:
if abs(mi) > ma :
ans = min(ans,abs(mi) + 2*ma)
else :
ans = min(ans,abs(mi)*2 + ma)
print(ans)
| 31 | 21 | 784 | 472 |
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
P = [0] + [abs(i) for i in A if i > 0]
M = [abs(i) for i in A if i < 0] + [0]
M = sorted(M, reverse=False)
cnt = 10000000000
if len(P) == len(M) == 1:
cnt = 0
elif len(P) == 1:
cnt = M[K]
elif len(M) == 1:
cnt = P[K]
else:
# リストがK以下の場合不具合が起きる
# for i in range(1,K):
# len(P)=4 len(M)=3 K=5の場合、IndexErrorとなる。rangeをうまく設定する必要があるが実装できない。
# 正の方向でi個ろうそくを通って、負の方向にK-i個ろうそくを通る
s = max(0, K - len(M) + 1)
e = min(K + 1, len(P))
for i in range(s, e):
cnt = min(cnt, P[i] * 2 + M[K - i])
# 負の方向でi個ろうそくを通って、正の方向にK-i個ろうそくを通る
s1 = max(0, K - len(P) + 1)
e1 = min(K + 1, len(M))
for i in range(s1, e1):
cnt = min(cnt, M[i] * 2 + P[K - i])
print(cnt)
|
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
ans = 10**10
for i in range(N - K + 1):
# S = X[i:i+K]
# print(S,S[0],S[-1])
mi = X[i]
ma = X[i + K - 1]
# print(mi,ma)
if ma <= 0:
ans = min(ans, abs(mi))
elif mi > 0:
ans = min(ans, ma)
elif mi < 0 and ma > 0:
if abs(mi) > ma:
ans = min(ans, abs(mi) + 2 * ma)
else:
ans = min(ans, abs(mi) * 2 + ma)
print(ans)
| false | 32.258065 |
[
"-A = list(map(int, input().split()))",
"-P = [0] + [abs(i) for i in A if i > 0]",
"-M = [abs(i) for i in A if i < 0] + [0]",
"-M = sorted(M, reverse=False)",
"-cnt = 10000000000",
"-if len(P) == len(M) == 1:",
"- cnt = 0",
"-elif len(P) == 1:",
"- cnt = M[K]",
"-elif len(M) == 1:",
"- cnt = P[K]",
"-else:",
"- # リストがK以下の場合不具合が起きる",
"- # for i in range(1,K):",
"- # len(P)=4 len(M)=3 K=5の場合、IndexErrorとなる。rangeをうまく設定する必要があるが実装できない。",
"- # 正の方向でi個ろうそくを通って、負の方向にK-i個ろうそくを通る",
"- s = max(0, K - len(M) + 1)",
"- e = min(K + 1, len(P))",
"- for i in range(s, e):",
"- cnt = min(cnt, P[i] * 2 + M[K - i])",
"- # 負の方向でi個ろうそくを通って、正の方向にK-i個ろうそくを通る",
"- s1 = max(0, K - len(P) + 1)",
"- e1 = min(K + 1, len(M))",
"- for i in range(s1, e1):",
"- cnt = min(cnt, M[i] * 2 + P[K - i])",
"-print(cnt)",
"+X = list(map(int, input().split()))",
"+ans = 10**10",
"+for i in range(N - K + 1):",
"+ # S = X[i:i+K]",
"+ # print(S,S[0],S[-1])",
"+ mi = X[i]",
"+ ma = X[i + K - 1]",
"+ # print(mi,ma)",
"+ if ma <= 0:",
"+ ans = min(ans, abs(mi))",
"+ elif mi > 0:",
"+ ans = min(ans, ma)",
"+ elif mi < 0 and ma > 0:",
"+ if abs(mi) > ma:",
"+ ans = min(ans, abs(mi) + 2 * ma)",
"+ else:",
"+ ans = min(ans, abs(mi) * 2 + ma)",
"+print(ans)"
] | false | 0.048474 | 0.048499 | 0.999475 |
[
"s043440881",
"s396621211"
] |
u691018832
|
p03086
|
python
|
s815479877
|
s390221913
| 19 | 17 | 3,060 | 3,060 |
Accepted
|
Accepted
| 10.53 |
S = eval(input())
n = 0
atgc = [0] * len(S)
for i in S:
if ('A' in i) or ('C' in i) or ('G' in i) or ('T' in i):
atgc[n] += 1
else:
n += 1
ans = max(atgc)
print(ans)
|
s = eval(input())
ans = [0] * 10 ** 3
cnt = 0
for i in range(len(s)):
for j in range(1, len(s) + 1):
memo = s[i:j]
for k in range(len(memo)):
if memo[k] == 'A' or memo[k] == 'C' or memo[k] == 'T' or memo[k] == 'G':
cnt += 1
else:
break
ans.append(cnt)
cnt = 0
print((max(ans)))
| 12 | 17 | 204 | 381 |
S = eval(input())
n = 0
atgc = [0] * len(S)
for i in S:
if ("A" in i) or ("C" in i) or ("G" in i) or ("T" in i):
atgc[n] += 1
else:
n += 1
ans = max(atgc)
print(ans)
|
s = eval(input())
ans = [0] * 10**3
cnt = 0
for i in range(len(s)):
for j in range(1, len(s) + 1):
memo = s[i:j]
for k in range(len(memo)):
if memo[k] == "A" or memo[k] == "C" or memo[k] == "T" or memo[k] == "G":
cnt += 1
else:
break
ans.append(cnt)
cnt = 0
print((max(ans)))
| false | 29.411765 |
[
"-S = eval(input())",
"-n = 0",
"-atgc = [0] * len(S)",
"-for i in S:",
"- if (\"A\" in i) or (\"C\" in i) or (\"G\" in i) or (\"T\" in i):",
"- atgc[n] += 1",
"- else:",
"- n += 1",
"-ans = max(atgc)",
"-print(ans)",
"+s = eval(input())",
"+ans = [0] * 10**3",
"+cnt = 0",
"+for i in range(len(s)):",
"+ for j in range(1, len(s) + 1):",
"+ memo = s[i:j]",
"+ for k in range(len(memo)):",
"+ if memo[k] == \"A\" or memo[k] == \"C\" or memo[k] == \"T\" or memo[k] == \"G\":",
"+ cnt += 1",
"+ else:",
"+ break",
"+ ans.append(cnt)",
"+ cnt = 0",
"+print((max(ans)))"
] | false | 0.047242 | 0.046678 | 1.012088 |
[
"s815479877",
"s390221913"
] |
u343977188
|
p02628
|
python
|
s581151793
|
s246347048
| 30 | 24 | 9,172 | 9,232 |
Accepted
|
Accepted
| 20 |
N,K=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:K])))
|
n,k=list(map(int,input().split()))
p=sorted(list(map(int,input().split())))
print((sum(p[:k])))
| 3 | 3 | 90 | 90 |
N, K = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:K])))
|
n, k = list(map(int, input().split()))
p = sorted(list(map(int, input().split())))
print((sum(p[:k])))
| false | 0 |
[
"-N, K = list(map(int, input().split()))",
"+n, k = list(map(int, input().split()))",
"-print((sum(p[:K])))",
"+print((sum(p[:k])))"
] | false | 0.035417 | 0.040746 | 0.869207 |
[
"s581151793",
"s246347048"
] |
u179304833
|
p02658
|
python
|
s165897546
|
s323465124
| 80 | 54 | 84,500 | 21,800 |
Accepted
|
Accepted
| 32.5 |
n=int(eval(input()))
A=list(map(int,input().split()))
ans=1
for i in range(n):
if A[i]==0:
print((0))
exit()
for i in range(n):
if len(str(A[i]))>19:
print((-1))
exit()
ans*=A[i]
if ans>10**18:
print((-1))
exit()
print(ans)
|
n=int(eval(input()))
A=list(map(int,input().split()))
ans=1
for i in range(n):
if A[i]==0:
print((0))
exit()
for i in range(n):
#if len(str(A[i]))>19:
# print(-1)
# exit()
ans*=A[i]
if ans>10**18:
print((-1))
exit()
print(ans)
| 16 | 16 | 258 | 261 |
n = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
for i in range(n):
if A[i] == 0:
print((0))
exit()
for i in range(n):
if len(str(A[i])) > 19:
print((-1))
exit()
ans *= A[i]
if ans > 10**18:
print((-1))
exit()
print(ans)
|
n = int(eval(input()))
A = list(map(int, input().split()))
ans = 1
for i in range(n):
if A[i] == 0:
print((0))
exit()
for i in range(n):
# if len(str(A[i]))>19:
# print(-1)
# exit()
ans *= A[i]
if ans > 10**18:
print((-1))
exit()
print(ans)
| false | 0 |
[
"- if len(str(A[i])) > 19:",
"- print((-1))",
"- exit()",
"+ # if len(str(A[i]))>19:",
"+ # print(-1)",
"+ # exit()"
] | false | 0.034868 | 0.109785 | 0.317603 |
[
"s165897546",
"s323465124"
] |
u729133443
|
p03329
|
python
|
s577206471
|
s950527372
| 444 | 281 | 48,220 | 2,940 |
Accepted
|
Accepted
| 36.71 |
def s(n,c):
if n<6:return c+n
a=b=1
while a*6<=n:a*=6
while b*9<=n:b*=9
return min(s(n-a,c+1),s(n-b,c+1))
print((s(int(eval(input())),0)))
|
def s(n,p):
while n>0:yield n%p;n//=p
c=lambda*a:sum(s(*a));n=int(eval(input()));print((min(c(i,6)+c(n-i,9)for i in range(n+1))))
| 7 | 3 | 146 | 125 |
def s(n, c):
if n < 6:
return c + n
a = b = 1
while a * 6 <= n:
a *= 6
while b * 9 <= n:
b *= 9
return min(s(n - a, c + 1), s(n - b, c + 1))
print((s(int(eval(input())), 0)))
|
def s(n, p):
while n > 0:
yield n % p
n //= p
c = lambda *a: sum(s(*a))
n = int(eval(input()))
print((min(c(i, 6) + c(n - i, 9) for i in range(n + 1))))
| false | 57.142857 |
[
"-def s(n, c):",
"- if n < 6:",
"- return c + n",
"- a = b = 1",
"- while a * 6 <= n:",
"- a *= 6",
"- while b * 9 <= n:",
"- b *= 9",
"- return min(s(n - a, c + 1), s(n - b, c + 1))",
"+def s(n, p):",
"+ while n > 0:",
"+ yield n % p",
"+ n //= p",
"-print((s(int(eval(input())), 0)))",
"+c = lambda *a: sum(s(*a))",
"+n = int(eval(input()))",
"+print((min(c(i, 6) + c(n - i, 9) for i in range(n + 1))))"
] | false | 0.172292 | 0.080502 | 2.140224 |
[
"s577206471",
"s950527372"
] |
u912237403
|
p00145
|
python
|
s768605614
|
s033572475
| 130 | 80 | 4,520 | 4,480 |
Accepted
|
Accepted
| 38.46 |
from functools import reduce
n = int(input())
Card = [[] for _ in [0]*n]
Cost = {}
for i in range(n):
Card[i] = list(map(int, input().split()))
Cost[(i, i)] = 0
for i in range(1, n):
for j in range(0, n-i):
a = j+i
Cost[(j, a)] = min([reduce(lambda a,b: a*b, [Card[j][0],Card[k][1],Card[k+1][0],Card[a][1]]) + Cost[(j, k)] + Cost[(k+1, a)] for k in range(j, j+i)])
print(Cost[0, n-1])
|
n = int(input())
Card = [[] for _ in [0]*n]
Cost = {}
for i in range(n):
Card[i] = list(map(int, input().split()))
Cost[(i, i)] = 0
for i in range(1, n):
for j in range(0, n-i):
a = j+i
Cost[(j, a)] = min([Card[j][0] * Card[k][1] * Card[k+1][0] * Card[a][1] + Cost[(j, k)] + Cost[(k+1, a)] for k in range(j, j+i)])
print(Cost[0, n-1])
| 11 | 11 | 380 | 359 |
from functools import reduce
n = int(input())
Card = [[] for _ in [0] * n]
Cost = {}
for i in range(n):
Card[i] = list(map(int, input().split()))
Cost[(i, i)] = 0
for i in range(1, n):
for j in range(0, n - i):
a = j + i
Cost[(j, a)] = min(
[
reduce(
lambda a, b: a * b,
[Card[j][0], Card[k][1], Card[k + 1][0], Card[a][1]],
)
+ Cost[(j, k)]
+ Cost[(k + 1, a)]
for k in range(j, j + i)
]
)
print(Cost[0, n - 1])
|
n = int(input())
Card = [[] for _ in [0] * n]
Cost = {}
for i in range(n):
Card[i] = list(map(int, input().split()))
Cost[(i, i)] = 0
for i in range(1, n):
for j in range(0, n - i):
a = j + i
Cost[(j, a)] = min(
[
Card[j][0] * Card[k][1] * Card[k + 1][0] * Card[a][1]
+ Cost[(j, k)]
+ Cost[(k + 1, a)]
for k in range(j, j + i)
]
)
print(Cost[0, n - 1])
| false | 0 |
[
"-from functools import reduce",
"-",
"- reduce(",
"- lambda a, b: a * b,",
"- [Card[j][0], Card[k][1], Card[k + 1][0], Card[a][1]],",
"- )",
"+ Card[j][0] * Card[k][1] * Card[k + 1][0] * Card[a][1]"
] | false | 0.110312 | 0.043936 | 2.510738 |
[
"s768605614",
"s033572475"
] |
u193182854
|
p02925
|
python
|
s806296606
|
s354187231
| 1,911 | 880 | 222,692 | 123,220 |
Accepted
|
Accepted
| 53.95 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n = int(eval(input()))
graph = [list() for _ in range(n**2)]
id_index = [[i+j*n for i in range(n)] for j in range(n)]
index_list = []
def toId(p, o):
if p > o:
index = id_index[o][p]
index_list.append(index)
return index
else: return id_index[p][o]
v_len = [-1 for _ in range(n)] * n
finished = [False for _ in range(n)] * n
def dfs(id):
next_list = graph[id]
if v_len[id] != -1:
if not finished[id]:
print((-1))
sys.exit()
return v_len[id]
v_len[id] = 1
for next in next_list:
v_len[id] = max(v_len[id], dfs(next)+1)
finished[id] = True
return v_len[id]
for p in range(n):
a = [toId(p, int(x)-1) for x in input().split()]
for i in range(n-2):
graph[a[i]].append(a[i+1])
ans = 0
for id in index_list:
ans = max(dfs(id), ans)
print(ans)
|
import sys
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
tdlist = lambda i, j, value=0: [[value] * j for _ in range(i)]
n = int(eval(input()))
m = n * (n-1) // 2
graph = [list() for _ in range(m)]
deg = [0] * m
to_id = tdlist(n, n)
cnt = 0
for i in range(n):
for j in range(i+1, n):
to_id[i][j], to_id[j][i] = cnt, cnt
cnt += 1
for i in range(n):
a = list(map(int, input().split()))
for j in range(n-2):
v = to_id[i][a[j]-1]
u = to_id[i][a[j+1]-1]
graph[v].append(u)
deg[u] += 1
q = deque(v for v in range(m) if deg[v] == 0)
cnt = 0
dp = [0] * m
while q:
v = q.popleft()
cnt += 1
for u in graph[v]:
deg[u] -= 1
dp[u] = max(dp[u], dp[v] + 1)
if deg[u] == 0:
q.append(u)
print((-1 if cnt != m else max(dp)+1))
| 49 | 39 | 984 | 882 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n = int(eval(input()))
graph = [list() for _ in range(n**2)]
id_index = [[i + j * n for i in range(n)] for j in range(n)]
index_list = []
def toId(p, o):
if p > o:
index = id_index[o][p]
index_list.append(index)
return index
else:
return id_index[p][o]
v_len = [-1 for _ in range(n)] * n
finished = [False for _ in range(n)] * n
def dfs(id):
next_list = graph[id]
if v_len[id] != -1:
if not finished[id]:
print((-1))
sys.exit()
return v_len[id]
v_len[id] = 1
for next in next_list:
v_len[id] = max(v_len[id], dfs(next) + 1)
finished[id] = True
return v_len[id]
for p in range(n):
a = [toId(p, int(x) - 1) for x in input().split()]
for i in range(n - 2):
graph[a[i]].append(a[i + 1])
ans = 0
for id in index_list:
ans = max(dfs(id), ans)
print(ans)
|
import sys
from collections import deque
input = lambda: sys.stdin.readline().rstrip()
tdlist = lambda i, j, value=0: [[value] * j for _ in range(i)]
n = int(eval(input()))
m = n * (n - 1) // 2
graph = [list() for _ in range(m)]
deg = [0] * m
to_id = tdlist(n, n)
cnt = 0
for i in range(n):
for j in range(i + 1, n):
to_id[i][j], to_id[j][i] = cnt, cnt
cnt += 1
for i in range(n):
a = list(map(int, input().split()))
for j in range(n - 2):
v = to_id[i][a[j] - 1]
u = to_id[i][a[j + 1] - 1]
graph[v].append(u)
deg[u] += 1
q = deque(v for v in range(m) if deg[v] == 0)
cnt = 0
dp = [0] * m
while q:
v = q.popleft()
cnt += 1
for u in graph[v]:
deg[u] -= 1
dp[u] = max(dp[u], dp[v] + 1)
if deg[u] == 0:
q.append(u)
print((-1 if cnt != m else max(dp) + 1))
| false | 20.408163 |
[
"+from collections import deque",
"-input = sys.stdin.readline",
"-sys.setrecursionlimit(10**6)",
"+input = lambda: sys.stdin.readline().rstrip()",
"+tdlist = lambda i, j, value=0: [[value] * j for _ in range(i)]",
"-graph = [list() for _ in range(n**2)]",
"-id_index = [[i + j * n for i in range(n)] for j in range(n)]",
"-index_list = []",
"-",
"-",
"-def toId(p, o):",
"- if p > o:",
"- index = id_index[o][p]",
"- index_list.append(index)",
"- return index",
"- else:",
"- return id_index[p][o]",
"-",
"-",
"-v_len = [-1 for _ in range(n)] * n",
"-finished = [False for _ in range(n)] * n",
"-",
"-",
"-def dfs(id):",
"- next_list = graph[id]",
"- if v_len[id] != -1:",
"- if not finished[id]:",
"- print((-1))",
"- sys.exit()",
"- return v_len[id]",
"- v_len[id] = 1",
"- for next in next_list:",
"- v_len[id] = max(v_len[id], dfs(next) + 1)",
"- finished[id] = True",
"- return v_len[id]",
"-",
"-",
"-for p in range(n):",
"- a = [toId(p, int(x) - 1) for x in input().split()]",
"- for i in range(n - 2):",
"- graph[a[i]].append(a[i + 1])",
"-ans = 0",
"-for id in index_list:",
"- ans = max(dfs(id), ans)",
"-print(ans)",
"+m = n * (n - 1) // 2",
"+graph = [list() for _ in range(m)]",
"+deg = [0] * m",
"+to_id = tdlist(n, n)",
"+cnt = 0",
"+for i in range(n):",
"+ for j in range(i + 1, n):",
"+ to_id[i][j], to_id[j][i] = cnt, cnt",
"+ cnt += 1",
"+for i in range(n):",
"+ a = list(map(int, input().split()))",
"+ for j in range(n - 2):",
"+ v = to_id[i][a[j] - 1]",
"+ u = to_id[i][a[j + 1] - 1]",
"+ graph[v].append(u)",
"+ deg[u] += 1",
"+q = deque(v for v in range(m) if deg[v] == 0)",
"+cnt = 0",
"+dp = [0] * m",
"+while q:",
"+ v = q.popleft()",
"+ cnt += 1",
"+ for u in graph[v]:",
"+ deg[u] -= 1",
"+ dp[u] = max(dp[u], dp[v] + 1)",
"+ if deg[u] == 0:",
"+ q.append(u)",
"+print((-1 if cnt != m else max(dp) + 1))"
] | false | 0.088832 | 0.040188 | 2.210409 |
[
"s806296606",
"s354187231"
] |
u560838141
|
p00002
|
python
|
s247569493
|
s875414199
| 20 | 10 | 4,204 | 4,200 |
Accepted
|
Accepted
| 50 |
while True:
try:
a, b = list(map(int, input().strip().split(" ")));
print(len(str(a + b)))
except:
break;
|
while True:
try:
print(len(str(sum(map(int, input().strip().split(" "))))))
except:
break;
| 6 | 5 | 115 | 103 |
while True:
try:
a, b = list(map(int, input().strip().split(" ")))
print(len(str(a + b)))
except:
break
|
while True:
try:
print(len(str(sum(map(int, input().strip().split(" "))))))
except:
break
| false | 16.666667 |
[
"- a, b = list(map(int, input().strip().split(\" \")))",
"- print(len(str(a + b)))",
"+ print(len(str(sum(map(int, input().strip().split(\" \"))))))"
] | false | 0.037199 | 0.037072 | 1.003419 |
[
"s247569493",
"s875414199"
] |
u047796752
|
p03550
|
python
|
s326762153
|
s493367517
| 701 | 100 | 47,708 | 74,484 |
Accepted
|
Accepted
| 85.73 |
import sys
input = sys.stdin.readline
from collections import *
sys.setrecursionlimit(2100)
def rec(sta, t):
if memo[sta][t]!=-1:
return memo[sta][t]
if t==0:
res = -10**18
for i in range(sta, N):
if i<N-1:
res = max(res, rec(i+1, 1))
else:
if sta==0:
res = max(res, abs(a[N-1]-W))
else:
res = max(res, abs(a[N-1]-a[sta-1]))
else:
res = 10**18
for i in range(sta, N):
if i<N-1:
res = min(res, rec(i+1, 0))
else:
if sta==0:
res = min(res, abs(a[N-1]-Z))
else:
res = min(res, abs(a[N-1]-a[sta-1]))
memo[sta][t] = res
return res
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
memo = [[-1]*2 for _ in range(N)]
print((rec(0, 0)))
|
import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0]*(2) for _ in range(N)]
for i in range(N-1, -1, -1):
if i==0:
dp[i][0] = abs(a[N-1]-W)
else:
dp[i][0] = abs(a[N-1]-a[i-1])
for j in range(i+1, N):
dp[i][0] = max(dp[i][0], dp[j][1])
if i==0:
dp[i][1] = abs(a[N-1]-Z)
else:
dp[i][1] = abs(a[N-1]-a[i-1])
for j in range(i+1, N):
dp[i][1] = min(dp[i][1], dp[j][0])
print((dp[0][0]))
| 40 | 25 | 1,006 | 559 |
import sys
input = sys.stdin.readline
from collections import *
sys.setrecursionlimit(2100)
def rec(sta, t):
if memo[sta][t] != -1:
return memo[sta][t]
if t == 0:
res = -(10**18)
for i in range(sta, N):
if i < N - 1:
res = max(res, rec(i + 1, 1))
else:
if sta == 0:
res = max(res, abs(a[N - 1] - W))
else:
res = max(res, abs(a[N - 1] - a[sta - 1]))
else:
res = 10**18
for i in range(sta, N):
if i < N - 1:
res = min(res, rec(i + 1, 0))
else:
if sta == 0:
res = min(res, abs(a[N - 1] - Z))
else:
res = min(res, abs(a[N - 1] - a[sta - 1]))
memo[sta][t] = res
return res
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
memo = [[-1] * 2 for _ in range(N)]
print((rec(0, 0)))
|
import sys
input = sys.stdin.readline
N, Z, W = list(map(int, input().split()))
a = list(map(int, input().split()))
dp = [[0] * (2) for _ in range(N)]
for i in range(N - 1, -1, -1):
if i == 0:
dp[i][0] = abs(a[N - 1] - W)
else:
dp[i][0] = abs(a[N - 1] - a[i - 1])
for j in range(i + 1, N):
dp[i][0] = max(dp[i][0], dp[j][1])
if i == 0:
dp[i][1] = abs(a[N - 1] - Z)
else:
dp[i][1] = abs(a[N - 1] - a[i - 1])
for j in range(i + 1, N):
dp[i][1] = min(dp[i][1], dp[j][0])
print((dp[0][0]))
| false | 37.5 |
[
"-from collections import *",
"-",
"-sys.setrecursionlimit(2100)",
"-",
"-",
"-def rec(sta, t):",
"- if memo[sta][t] != -1:",
"- return memo[sta][t]",
"- if t == 0:",
"- res = -(10**18)",
"- for i in range(sta, N):",
"- if i < N - 1:",
"- res = max(res, rec(i + 1, 1))",
"- else:",
"- if sta == 0:",
"- res = max(res, abs(a[N - 1] - W))",
"- else:",
"- res = max(res, abs(a[N - 1] - a[sta - 1]))",
"- else:",
"- res = 10**18",
"- for i in range(sta, N):",
"- if i < N - 1:",
"- res = min(res, rec(i + 1, 0))",
"- else:",
"- if sta == 0:",
"- res = min(res, abs(a[N - 1] - Z))",
"- else:",
"- res = min(res, abs(a[N - 1] - a[sta - 1]))",
"- memo[sta][t] = res",
"- return res",
"-",
"-",
"-memo = [[-1] * 2 for _ in range(N)]",
"-print((rec(0, 0)))",
"+dp = [[0] * (2) for _ in range(N)]",
"+for i in range(N - 1, -1, -1):",
"+ if i == 0:",
"+ dp[i][0] = abs(a[N - 1] - W)",
"+ else:",
"+ dp[i][0] = abs(a[N - 1] - a[i - 1])",
"+ for j in range(i + 1, N):",
"+ dp[i][0] = max(dp[i][0], dp[j][1])",
"+ if i == 0:",
"+ dp[i][1] = abs(a[N - 1] - Z)",
"+ else:",
"+ dp[i][1] = abs(a[N - 1] - a[i - 1])",
"+ for j in range(i + 1, N):",
"+ dp[i][1] = min(dp[i][1], dp[j][0])",
"+print((dp[0][0]))"
] | false | 0.115185 | 0.038902 | 2.960929 |
[
"s326762153",
"s493367517"
] |
u797673668
|
p00010
|
python
|
s154764030
|
s262056243
| 60 | 20 | 10,160 | 7,760 |
Accepted
|
Accepted
| 66.67 |
import fractions
def calc(x1, y1, x2, y2):
return 2 * (x2 - x1), 2 * (y2 - y1), x2 ** 2 + y2 ** 2 - x1 ** 2 - y1 ** 2
n = int(eval(input()))
for _ in range(n):
x1, y1, x2, y2, x3, y3 = list(map(float, input().split()))
cx1, cy1, z1 = calc(x1, y1, x2, y2)
cx2, cy2, z2 = calc(x1, y1, x3, y3)
gcd = fractions.gcd(cx1, cx2)
r1, r2 = cx2 // gcd, cx1 // gcd
dcy = r1 * cy1 - r2 * cy2
dz = r1 * z1 - r2 * z2
y = dz / dcy
x = (z1 - cy1 * y) / cx1 if cx1 else (z2 - cy2 * y) / cx2
r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(('{:.3f} {:.3f} {:.3f}'.format(x, y, r)))
|
def calc(x1, y1, x2, y2):
return 2 * (x2 - x1), 2 * (y2 - y1), x2 ** 2 + y2 ** 2 - x1 ** 2 - y1 ** 2
n = int(eval(input()))
for _ in range(n):
x1, y1, x2, y2, x3, y3 = list(map(float, input().split()))
cx1, cy1, z1 = calc(x1, y1, x2, y2)
cx2, cy2, z2 = calc(x1, y1, x3, y3)
dcy, dz = cx2 * cy1 - cx1 * cy2, cx2 * z1 - cx1 * z2
y = dz / dcy
x = (z1 - cy1 * y) / cx1 if cx1 else (z2 - cy2 * y) / cx2
r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(('{:.3f} {:.3f} {:.3f}'.format(x, y, r)))
| 20 | 14 | 620 | 525 |
import fractions
def calc(x1, y1, x2, y2):
return 2 * (x2 - x1), 2 * (y2 - y1), x2**2 + y2**2 - x1**2 - y1**2
n = int(eval(input()))
for _ in range(n):
x1, y1, x2, y2, x3, y3 = list(map(float, input().split()))
cx1, cy1, z1 = calc(x1, y1, x2, y2)
cx2, cy2, z2 = calc(x1, y1, x3, y3)
gcd = fractions.gcd(cx1, cx2)
r1, r2 = cx2 // gcd, cx1 // gcd
dcy = r1 * cy1 - r2 * cy2
dz = r1 * z1 - r2 * z2
y = dz / dcy
x = (z1 - cy1 * y) / cx1 if cx1 else (z2 - cy2 * y) / cx2
r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(("{:.3f} {:.3f} {:.3f}".format(x, y, r)))
|
def calc(x1, y1, x2, y2):
return 2 * (x2 - x1), 2 * (y2 - y1), x2**2 + y2**2 - x1**2 - y1**2
n = int(eval(input()))
for _ in range(n):
x1, y1, x2, y2, x3, y3 = list(map(float, input().split()))
cx1, cy1, z1 = calc(x1, y1, x2, y2)
cx2, cy2, z2 = calc(x1, y1, x3, y3)
dcy, dz = cx2 * cy1 - cx1 * cy2, cx2 * z1 - cx1 * z2
y = dz / dcy
x = (z1 - cy1 * y) / cx1 if cx1 else (z2 - cy2 * y) / cx2
r = ((x - x1) ** 2 + (y - y1) ** 2) ** 0.5
print(("{:.3f} {:.3f} {:.3f}".format(x, y, r)))
| false | 30 |
[
"-import fractions",
"-",
"-",
"- gcd = fractions.gcd(cx1, cx2)",
"- r1, r2 = cx2 // gcd, cx1 // gcd",
"- dcy = r1 * cy1 - r2 * cy2",
"- dz = r1 * z1 - r2 * z2",
"+ dcy, dz = cx2 * cy1 - cx1 * cy2, cx2 * z1 - cx1 * z2"
] | false | 0.050615 | 0.007758 | 6.524653 |
[
"s154764030",
"s262056243"
] |
u110580875
|
p02584
|
python
|
s261498009
|
s679885006
| 35 | 25 | 9,168 | 9,212 |
Accepted
|
Accepted
| 28.57 |
import sys
x,k,d=list(map(int,input().split()))
x=abs(x)
if(abs(x%d)<abs(x%d-d)):
min_num=x%d
min_num2=x%d-d
else:
min_num=x%d-d
min_num2=x%d
kaisuu=(x-min_num)/d
if(kaisuu>k):
print((abs(x-d*k)))
sys.exit()
if((k%2==0 and kaisuu%2==0)or(k%2==1 and kaisuu%2==1)):
print((abs(min_num)))
else:
print((abs(min_num2)))
|
import math
import sys
x,k,d=list(map(int,input().split()))
if x<0:
x*=-1
num=math.floor(x/d)
if num>k:
print((x-k*d))
sys.exit()
n=x-num*d
remaining=k-num
if remaining%2==0:
if n>0:
print(n)
else:
print((n*-1))
else:
if n>0:
n-=d
if n>0:
print(n)
else:
print((n*-1))
else:
n+=d
if n>0:
print(n)
else:
print((n*-1))
| 22 | 40 | 345 | 447 |
import sys
x, k, d = list(map(int, input().split()))
x = abs(x)
if abs(x % d) < abs(x % d - d):
min_num = x % d
min_num2 = x % d - d
else:
min_num = x % d - d
min_num2 = x % d
kaisuu = (x - min_num) / d
if kaisuu > k:
print((abs(x - d * k)))
sys.exit()
if (k % 2 == 0 and kaisuu % 2 == 0) or (k % 2 == 1 and kaisuu % 2 == 1):
print((abs(min_num)))
else:
print((abs(min_num2)))
|
import math
import sys
x, k, d = list(map(int, input().split()))
if x < 0:
x *= -1
num = math.floor(x / d)
if num > k:
print((x - k * d))
sys.exit()
n = x - num * d
remaining = k - num
if remaining % 2 == 0:
if n > 0:
print(n)
else:
print((n * -1))
else:
if n > 0:
n -= d
if n > 0:
print(n)
else:
print((n * -1))
else:
n += d
if n > 0:
print(n)
else:
print((n * -1))
| false | 45 |
[
"+import math",
"-x = abs(x)",
"-if abs(x % d) < abs(x % d - d):",
"- min_num = x % d",
"- min_num2 = x % d - d",
"+if x < 0:",
"+ x *= -1",
"+num = math.floor(x / d)",
"+if num > k:",
"+ print((x - k * d))",
"+ sys.exit()",
"+n = x - num * d",
"+remaining = k - num",
"+if remaining % 2 == 0:",
"+ if n > 0:",
"+ print(n)",
"+ else:",
"+ print((n * -1))",
"- min_num = x % d - d",
"- min_num2 = x % d",
"-kaisuu = (x - min_num) / d",
"-if kaisuu > k:",
"- print((abs(x - d * k)))",
"- sys.exit()",
"-if (k % 2 == 0 and kaisuu % 2 == 0) or (k % 2 == 1 and kaisuu % 2 == 1):",
"- print((abs(min_num)))",
"-else:",
"- print((abs(min_num2)))",
"+ if n > 0:",
"+ n -= d",
"+ if n > 0:",
"+ print(n)",
"+ else:",
"+ print((n * -1))",
"+ else:",
"+ n += d",
"+ if n > 0:",
"+ print(n)",
"+ else:",
"+ print((n * -1))"
] | false | 0.044598 | 0.081254 | 0.548872 |
[
"s261498009",
"s679885006"
] |
u072053884
|
p02257
|
python
|
s269703876
|
s020232736
| 1,120 | 1,030 | 7,812 | 7,848 |
Accepted
|
Accepted
| 8.04 |
def is_prime(x):
if x == 1:
return False
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return False
n += 1
return True
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for l in file_input:
x = int(l)
if is_prime(x):
cnt += 1
print(cnt)
solve()
|
def is_prime(x):
if x == 1:
return 0
l = x ** 0.5
n = 2
while n <= l:
if x % n == 0:
return 0
n += 1
return 1
import sys
def solve():
N = int(eval(input()))
cnt = 0
for i in range(N):
cnt += is_prime(int(eval(input())))
print(cnt)
solve()
| 24 | 21 | 407 | 329 |
def is_prime(x):
if x == 1:
return False
l = x**0.5
n = 2
while n <= l:
if x % n == 0:
return False
n += 1
return True
import sys
def solve():
file_input = sys.stdin
N = file_input.readline()
cnt = 0
for l in file_input:
x = int(l)
if is_prime(x):
cnt += 1
print(cnt)
solve()
|
def is_prime(x):
if x == 1:
return 0
l = x**0.5
n = 2
while n <= l:
if x % n == 0:
return 0
n += 1
return 1
import sys
def solve():
N = int(eval(input()))
cnt = 0
for i in range(N):
cnt += is_prime(int(eval(input())))
print(cnt)
solve()
| false | 12.5 |
[
"- return False",
"+ return 0",
"- return False",
"+ return 0",
"- return True",
"+ return 1",
"- file_input = sys.stdin",
"- N = file_input.readline()",
"+ N = int(eval(input()))",
"- for l in file_input:",
"- x = int(l)",
"- if is_prime(x):",
"- cnt += 1",
"+ for i in range(N):",
"+ cnt += is_prime(int(eval(input())))"
] | false | 0.046805 | 0.053541 | 0.874201 |
[
"s269703876",
"s020232736"
] |
u403301154
|
p03032
|
python
|
s344159944
|
s539203748
| 901 | 433 | 63,836 | 60,380 |
Accepted
|
Accepted
| 51.94 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
from heapq import heappush, heappop
for i in range(1, k+1):
for j in range(1, i+1):
for k in range(0, j+1):
minus = []
l = min(n, k)
r = min(n-l, j-l)
cur = 0
for ll in range(l):
cur += v[ll]
if v[ll]<0:
heappush(minus, v[ll])
for rr in range(r):
cur += v[n-rr-1]
if v[n-rr-1]<0:
heappush(minus, v[n-rr-1])
rm = i-l-r
while rm>0 and len(minus)>=rm:
rm -= 1
t = heappop(minus)
cur -= t
ans = max(ans, cur)
print(ans)
|
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
from heapq import heappush, heappop
for i in range(1, k+1):
for j in range(0, i+1):
minus = []
l = min(n, j)
r = min(n-l, i-l)
cur = 0
for ll in range(l):
cur += v[ll]
if v[ll]<0:
heappush(minus, v[ll])
for rr in range(r):
cur += v[n-rr-1]
if v[n-rr-1]<0:
heappush(minus, v[n-rr-1])
rm = k-l-r
while rm>0 and len(minus)>0:
rm -= 1
cur -= heappop(minus)
ans = max(ans, cur)
print(ans)
| 27 | 25 | 661 | 581 |
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
from heapq import heappush, heappop
for i in range(1, k + 1):
for j in range(1, i + 1):
for k in range(0, j + 1):
minus = []
l = min(n, k)
r = min(n - l, j - l)
cur = 0
for ll in range(l):
cur += v[ll]
if v[ll] < 0:
heappush(minus, v[ll])
for rr in range(r):
cur += v[n - rr - 1]
if v[n - rr - 1] < 0:
heappush(minus, v[n - rr - 1])
rm = i - l - r
while rm > 0 and len(minus) >= rm:
rm -= 1
t = heappop(minus)
cur -= t
ans = max(ans, cur)
print(ans)
|
n, k = list(map(int, input().split()))
v = list(map(int, input().split()))
ans = 0
from heapq import heappush, heappop
for i in range(1, k + 1):
for j in range(0, i + 1):
minus = []
l = min(n, j)
r = min(n - l, i - l)
cur = 0
for ll in range(l):
cur += v[ll]
if v[ll] < 0:
heappush(minus, v[ll])
for rr in range(r):
cur += v[n - rr - 1]
if v[n - rr - 1] < 0:
heappush(minus, v[n - rr - 1])
rm = k - l - r
while rm > 0 and len(minus) > 0:
rm -= 1
cur -= heappop(minus)
ans = max(ans, cur)
print(ans)
| false | 7.407407 |
[
"- for j in range(1, i + 1):",
"- for k in range(0, j + 1):",
"- minus = []",
"- l = min(n, k)",
"- r = min(n - l, j - l)",
"- cur = 0",
"- for ll in range(l):",
"- cur += v[ll]",
"- if v[ll] < 0:",
"- heappush(minus, v[ll])",
"- for rr in range(r):",
"- cur += v[n - rr - 1]",
"- if v[n - rr - 1] < 0:",
"- heappush(minus, v[n - rr - 1])",
"- rm = i - l - r",
"- while rm > 0 and len(minus) >= rm:",
"- rm -= 1",
"- t = heappop(minus)",
"- cur -= t",
"- ans = max(ans, cur)",
"+ for j in range(0, i + 1):",
"+ minus = []",
"+ l = min(n, j)",
"+ r = min(n - l, i - l)",
"+ cur = 0",
"+ for ll in range(l):",
"+ cur += v[ll]",
"+ if v[ll] < 0:",
"+ heappush(minus, v[ll])",
"+ for rr in range(r):",
"+ cur += v[n - rr - 1]",
"+ if v[n - rr - 1] < 0:",
"+ heappush(minus, v[n - rr - 1])",
"+ rm = k - l - r",
"+ while rm > 0 and len(minus) > 0:",
"+ rm -= 1",
"+ cur -= heappop(minus)",
"+ ans = max(ans, cur)"
] | false | 0.046776 | 0.037432 | 1.249631 |
[
"s344159944",
"s539203748"
] |
u148551245
|
p03407
|
python
|
s113709436
|
s001638063
| 163 | 17 | 38,320 | 2,940 |
Accepted
|
Accepted
| 89.57 |
(a, b, c) = list(map(int, input().split()))
if a + b >= c:
print("Yes")
else:
print("No")
|
a, b, x = list(map(int, input().split()))
if a+b >= x:
print("Yes")
else:
print("No")
| 5 | 6 | 95 | 93 |
(a, b, c) = list(map(int, input().split()))
if a + b >= c:
print("Yes")
else:
print("No")
|
a, b, x = list(map(int, input().split()))
if a + b >= x:
print("Yes")
else:
print("No")
| false | 16.666667 |
[
"-(a, b, c) = list(map(int, input().split()))",
"-if a + b >= c:",
"+a, b, x = list(map(int, input().split()))",
"+if a + b >= x:"
] | false | 0.092212 | 0.089679 | 1.028236 |
[
"s113709436",
"s001638063"
] |
u408260374
|
p00775
|
python
|
s556765188
|
s513427337
| 60 | 50 | 7,772 | 7,668 |
Accepted
|
Accepted
| 16.67 |
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)
print((min(buildings[i] - pow(R ** 2 - (i - geta + (i < geta)) ** 2, 0.5) + R for i in range(-R + geta, R + geta))))
|
from math import sqrt
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)
print((min(buildings[i] - sqrt(R * R - (i - geta + (i < geta)) * (i - geta + (i < geta))) + R for i in range(-R + geta, R + geta))))
| 12 | 13 | 423 | 462 |
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)
print(
(
min(
buildings[i] - pow(R**2 - (i - geta + (i < geta)) ** 2, 0.5) + R
for i in range(-R + geta, R + geta)
)
)
)
|
from math import sqrt
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)
print(
(
min(
buildings[i]
- sqrt(R * R - (i - geta + (i < geta)) * (i - geta + (i < geta)))
+ R
for i in range(-R + geta, R + geta)
)
)
)
| false | 7.692308 |
[
"+from math import sqrt",
"+",
"- buildings[i] - pow(R**2 - (i - geta + (i < geta)) ** 2, 0.5) + R",
"+ buildings[i]",
"+ - sqrt(R * R - (i - geta + (i < geta)) * (i - geta + (i < geta)))",
"+ + R"
] | false | 0.050228 | 0.049706 | 1.010489 |
[
"s556765188",
"s513427337"
] |
u230621983
|
p02773
|
python
|
s083047156
|
s160539364
| 688 | 583 | 47,636 | 45,300 |
Accepted
|
Accepted
| 15.26 |
import collections
n = int(eval(input()))
s_list = [eval(input()) for _ in range(n)]
s_cnt = collections.Counter(s_list)
s_sorted = s_cnt.most_common()
ans_list = [s[0] for s in s_sorted if s[1] == s_sorted[0][1]]
ans_list.sort()
for ans in ans_list:
print(ans)
|
from collections import Counter
n, *s = open(0).read().split()
c = Counter(s)
max_poll = c.most_common()[0][1]
candidates = []
for tpl in c.most_common():
if tpl[1] == max_poll:
candidates.append(tpl[0])
candidates.sort()
for candidate in candidates:
print(candidate)
| 10 | 15 | 263 | 301 |
import collections
n = int(eval(input()))
s_list = [eval(input()) for _ in range(n)]
s_cnt = collections.Counter(s_list)
s_sorted = s_cnt.most_common()
ans_list = [s[0] for s in s_sorted if s[1] == s_sorted[0][1]]
ans_list.sort()
for ans in ans_list:
print(ans)
|
from collections import Counter
n, *s = open(0).read().split()
c = Counter(s)
max_poll = c.most_common()[0][1]
candidates = []
for tpl in c.most_common():
if tpl[1] == max_poll:
candidates.append(tpl[0])
candidates.sort()
for candidate in candidates:
print(candidate)
| false | 33.333333 |
[
"-import collections",
"+from collections import Counter",
"-n = int(eval(input()))",
"-s_list = [eval(input()) for _ in range(n)]",
"-s_cnt = collections.Counter(s_list)",
"-s_sorted = s_cnt.most_common()",
"-ans_list = [s[0] for s in s_sorted if s[1] == s_sorted[0][1]]",
"-ans_list.sort()",
"-for ans in ans_list:",
"- print(ans)",
"+n, *s = open(0).read().split()",
"+c = Counter(s)",
"+max_poll = c.most_common()[0][1]",
"+candidates = []",
"+for tpl in c.most_common():",
"+ if tpl[1] == max_poll:",
"+ candidates.append(tpl[0])",
"+candidates.sort()",
"+for candidate in candidates:",
"+ print(candidate)"
] | false | 0.105533 | 0.088148 | 1.197232 |
[
"s083047156",
"s160539364"
] |
u758815106
|
p02598
|
python
|
s034665290
|
s485957562
| 639 | 488 | 31,140 | 31,148 |
Accepted
|
Accepted
| 23.63 |
import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# にぶたん！ 半開区間二分探索は正義
def calc(x):
count = 0
for a in A:
count += (a - 1) // x
return count <= K
A.sort(reverse=True)
r = 10 ** 9
l = 0
while abs(r - l) > 1:
mid = (r + l) // 2
if calc(mid):
r = mid
else:
l = mid
print(r)
|
import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# めぐる式二分探索で実装
def calc(x):
count = 0
for a in A:
count += (a - 1) // x
return count <= K
ok = 10 ** 9
ng = 0
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if calc(mid):
ok = mid
else:
ng = mid
print(ok)
| 28 | 26 | 390 | 369 |
import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# にぶたん！ 半開区間二分探索は正義
def calc(x):
count = 0
for a in A:
count += (a - 1) // x
return count <= K
A.sort(reverse=True)
r = 10**9
l = 0
while abs(r - l) > 1:
mid = (r + l) // 2
if calc(mid):
r = mid
else:
l = mid
print(r)
|
import math
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
# めぐる式二分探索で実装
def calc(x):
count = 0
for a in A:
count += (a - 1) // x
return count <= K
ok = 10**9
ng = 0
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if calc(mid):
ok = mid
else:
ng = mid
print(ok)
| false | 7.142857 |
[
"-# にぶたん！ 半開区間二分探索は正義",
"+# めぐる式二分探索で実装",
"-A.sort(reverse=True)",
"-r = 10**9",
"-l = 0",
"-while abs(r - l) > 1:",
"- mid = (r + l) // 2",
"+ok = 10**9",
"+ng = 0",
"+while abs(ok - ng) > 1:",
"+ mid = (ok + ng) // 2",
"- r = mid",
"+ ok = mid",
"- l = mid",
"-print(r)",
"+ ng = mid",
"+print(ok)"
] | false | 0.036508 | 0.035956 | 1.015346 |
[
"s034665290",
"s485957562"
] |
u618373524
|
p03416
|
python
|
s842250188
|
s577930173
| 55 | 40 | 2,940 | 3,060 |
Accepted
|
Accepted
| 27.27 |
a,b = list(map(int,input().split()))
print((sum(i == i[::-1] for i in map(str,list(range(a,b+1))))))
|
a,b = list(map(int,input().split()))
print((len([i for i in map(str,list(range(a,b+1)))if i == i[::-1]])))
| 2 | 2 | 87 | 93 |
a, b = list(map(int, input().split()))
print((sum(i == i[::-1] for i in map(str, list(range(a, b + 1))))))
|
a, b = list(map(int, input().split()))
print((len([i for i in map(str, list(range(a, b + 1))) if i == i[::-1]])))
| false | 0 |
[
"-print((sum(i == i[::-1] for i in map(str, list(range(a, b + 1))))))",
"+print((len([i for i in map(str, list(range(a, b + 1))) if i == i[::-1]])))"
] | false | 0.043601 | 0.095709 | 0.455559 |
[
"s842250188",
"s577930173"
] |
u924406834
|
p03455
|
python
|
s342305854
|
s964761108
| 166 | 17 | 38,256 | 2,940 |
Accepted
|
Accepted
| 89.76 |
a,b = list(map(int,input().split()))
ans = 0
if a*b%2==0:
print('Even')
else:
print('Odd')
|
R= list(map(int,input().split()))
if R[0] * R[1] % 2 == 0:
print('Even')
else:
print('Odd')
| 6 | 5 | 94 | 103 |
a, b = list(map(int, input().split()))
ans = 0
if a * b % 2 == 0:
print("Even")
else:
print("Odd")
|
R = list(map(int, input().split()))
if R[0] * R[1] % 2 == 0:
print("Even")
else:
print("Odd")
| false | 16.666667 |
[
"-a, b = list(map(int, input().split()))",
"-ans = 0",
"-if a * b % 2 == 0:",
"+R = list(map(int, input().split()))",
"+if R[0] * R[1] % 2 == 0:"
] | false | 0.035044 | 0.036907 | 0.949525 |
[
"s342305854",
"s964761108"
] |
u620868411
|
p03721
|
python
|
s816203852
|
s576574501
| 1,911 | 409 | 20,092 | 16,940 |
Accepted
|
Accepted
| 78.6 |
# -*- coding: utf-8 -*-
line = input().split(" ")
n = int(line[0])
k = int(line[1])
l = []
for _ in range(n):
line = input().split(" ")
a = int(line[0])
b = int(line[1])
l.append([a,b])
l.sort()
while k>0:
x = l.pop(0)
k = k-x[1]
print((x[0]))
|
# -*- coding: utf-8 -*-
n,k = list(map(int, input().split()))
ab = []
for _ in range(n):
a,b = list(map(int, input().split()))
ab.append((a,b))
ab.sort()
res = 0
for a,b in ab:
if b>=k:
res = a
break
else:
k -= b
print(res)
| 19 | 17 | 288 | 270 |
# -*- coding: utf-8 -*-
line = input().split(" ")
n = int(line[0])
k = int(line[1])
l = []
for _ in range(n):
line = input().split(" ")
a = int(line[0])
b = int(line[1])
l.append([a, b])
l.sort()
while k > 0:
x = l.pop(0)
k = k - x[1]
print((x[0]))
|
# -*- coding: utf-8 -*-
n, k = list(map(int, input().split()))
ab = []
for _ in range(n):
a, b = list(map(int, input().split()))
ab.append((a, b))
ab.sort()
res = 0
for a, b in ab:
if b >= k:
res = a
break
else:
k -= b
print(res)
| false | 10.526316 |
[
"-line = input().split(\" \")",
"-n = int(line[0])",
"-k = int(line[1])",
"-l = []",
"+n, k = list(map(int, input().split()))",
"+ab = []",
"- line = input().split(\" \")",
"- a = int(line[0])",
"- b = int(line[1])",
"- l.append([a, b])",
"-l.sort()",
"-while k > 0:",
"- x = l.pop(0)",
"- k = k - x[1]",
"-print((x[0]))",
"+ a, b = list(map(int, input().split()))",
"+ ab.append((a, b))",
"+ab.sort()",
"+res = 0",
"+for a, b in ab:",
"+ if b >= k:",
"+ res = a",
"+ break",
"+ else:",
"+ k -= b",
"+print(res)"
] | false | 0.048407 | 0.036079 | 1.341687 |
[
"s816203852",
"s576574501"
] |
u945181840
|
p02744
|
python
|
s016165829
|
s173351794
| 133 | 99 | 24,040 | 24,040 |
Accepted
|
Accepted
| 25.56 |
N = int(eval(input()))
answer = [(97, 'a')]
for _ in range(N - 1):
new_answer = []
for i, j in answer:
for k in range(97, i + 2):
new_answer.append((max(k, i), j + chr(k)))
answer = new_answer[:]
answer = [j for _, j in answer]
answer.sort()
print(('\n'.join(answer)))
|
N = int(eval(input()))
answer = [(97, 'a')]
for _ in range(N - 1):
new_answer = []
for i, j in answer:
for k in range(97, i + 1):
new_answer.append((i, j + chr(k)))
new_answer.append((i+1,j+chr(i+1)))
answer = new_answer[:]
answer = [j for _, j in answer]
answer.sort()
print(('\n'.join(answer)))
| 13 | 14 | 307 | 344 |
N = int(eval(input()))
answer = [(97, "a")]
for _ in range(N - 1):
new_answer = []
for i, j in answer:
for k in range(97, i + 2):
new_answer.append((max(k, i), j + chr(k)))
answer = new_answer[:]
answer = [j for _, j in answer]
answer.sort()
print(("\n".join(answer)))
|
N = int(eval(input()))
answer = [(97, "a")]
for _ in range(N - 1):
new_answer = []
for i, j in answer:
for k in range(97, i + 1):
new_answer.append((i, j + chr(k)))
new_answer.append((i + 1, j + chr(i + 1)))
answer = new_answer[:]
answer = [j for _, j in answer]
answer.sort()
print(("\n".join(answer)))
| false | 7.142857 |
[
"- for k in range(97, i + 2):",
"- new_answer.append((max(k, i), j + chr(k)))",
"+ for k in range(97, i + 1):",
"+ new_answer.append((i, j + chr(k)))",
"+ new_answer.append((i + 1, j + chr(i + 1)))"
] | false | 0.062409 | 0.060542 | 1.030843 |
[
"s016165829",
"s173351794"
] |
u077291787
|
p03559
|
python
|
s080179019
|
s369927106
| 376 | 321 | 23,744 | 23,240 |
Accepted
|
Accepted
| 14.63 |
# ABC084C - Snuke Festival
from bisect import bisect_left, bisect_right
n = int(eval(input()))
lst_a = sorted(list(map(int, input().rstrip().split())))
lst_b = list(map(int, input().rstrip().split()))
lst_c = sorted(list(map(int, input().rstrip().split())))
lgth = len(lst_c)
ans = 0
for i in lst_b:
ans += bisect_left(lst_a, i) * (lgth - bisect_right(lst_c, i))
print(ans)
|
# ABC084C - Snuke Festival
from bisect import bisect_left, bisect_right
n = int(eval(input()))
lst_a = sorted(list(map(int, input().rstrip().split())))
lst_b = sorted(list(map(int, input().rstrip().split())))
lst_c = sorted(list(map(int, input().rstrip().split())))
lgth = len(lst_c)
ans = 0
for i in lst_b:
ans += bisect_left(lst_a, i) * (lgth - bisect_right(lst_c, i))
print(ans)
| 12 | 12 | 383 | 391 |
# ABC084C - Snuke Festival
from bisect import bisect_left, bisect_right
n = int(eval(input()))
lst_a = sorted(list(map(int, input().rstrip().split())))
lst_b = list(map(int, input().rstrip().split()))
lst_c = sorted(list(map(int, input().rstrip().split())))
lgth = len(lst_c)
ans = 0
for i in lst_b:
ans += bisect_left(lst_a, i) * (lgth - bisect_right(lst_c, i))
print(ans)
|
# ABC084C - Snuke Festival
from bisect import bisect_left, bisect_right
n = int(eval(input()))
lst_a = sorted(list(map(int, input().rstrip().split())))
lst_b = sorted(list(map(int, input().rstrip().split())))
lst_c = sorted(list(map(int, input().rstrip().split())))
lgth = len(lst_c)
ans = 0
for i in lst_b:
ans += bisect_left(lst_a, i) * (lgth - bisect_right(lst_c, i))
print(ans)
| false | 0 |
[
"-lst_b = list(map(int, input().rstrip().split()))",
"+lst_b = sorted(list(map(int, input().rstrip().split())))"
] | false | 0.090507 | 0.050077 | 1.807365 |
[
"s080179019",
"s369927106"
] |
u078276601
|
p02583
|
python
|
s108507309
|
s366270907
| 157 | 108 | 9,168 | 9,176 |
Accepted
|
Accepted
| 31.21 |
N = int(eval(input()))
L = list(map(int, input().split()))
cnt = 0
for i in range(N-2):
for j in range(i+1,N-1):
for k in range(j+1,N):
if L[i]!=L[j] and L[j]!=L[k] and L[k]!=L[i]:
if L[i] < L[j] + L[k] and L[j] < L[k] + L[i] and L[k] < L[i] + L[j]:
cnt += 1
print(cnt)
|
n=int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
# ３つの相異なる数字（i, j, k）の組み合わせを調べること
for i in range(n):
for j in range(i+1, n):
for k in range(j+1, n):
a = l[i]
b = l[j]
c = l[k]
if a == b or b == c or c == a:
continue
else:
if a<b+c and b<c+a and c<a+b:
cnt+=1
print(cnt)
| 11 | 18 | 334 | 422 |
N = int(eval(input()))
L = list(map(int, input().split()))
cnt = 0
for i in range(N - 2):
for j in range(i + 1, N - 1):
for k in range(j + 1, N):
if L[i] != L[j] and L[j] != L[k] and L[k] != L[i]:
if L[i] < L[j] + L[k] and L[j] < L[k] + L[i] and L[k] < L[i] + L[j]:
cnt += 1
print(cnt)
|
n = int(eval(input()))
l = list(map(int, input().split()))
cnt = 0
# ３つの相異なる数字（i, j, k）の組み合わせを調べること
for i in range(n):
for j in range(i + 1, n):
for k in range(j + 1, n):
a = l[i]
b = l[j]
c = l[k]
if a == b or b == c or c == a:
continue
else:
if a < b + c and b < c + a and c < a + b:
cnt += 1
print(cnt)
| false | 38.888889 |
[
"-N = int(eval(input()))",
"-L = list(map(int, input().split()))",
"+n = int(eval(input()))",
"+l = list(map(int, input().split()))",
"-for i in range(N - 2):",
"- for j in range(i + 1, N - 1):",
"- for k in range(j + 1, N):",
"- if L[i] != L[j] and L[j] != L[k] and L[k] != L[i]:",
"- if L[i] < L[j] + L[k] and L[j] < L[k] + L[i] and L[k] < L[i] + L[j]:",
"+# ３つの相異なる数字（i, j, k）の組み合わせを調べること",
"+for i in range(n):",
"+ for j in range(i + 1, n):",
"+ for k in range(j + 1, n):",
"+ a = l[i]",
"+ b = l[j]",
"+ c = l[k]",
"+ if a == b or b == c or c == a:",
"+ continue",
"+ else:",
"+ if a < b + c and b < c + a and c < a + b:"
] | false | 0.034376 | 0.035896 | 0.957666 |
[
"s108507309",
"s366270907"
] |
u332906195
|
p03208
|
python
|
s019983332
|
s267466532
| 256 | 233 | 7,384 | 11,020 |
Accepted
|
Accepted
| 8.98 |
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
H = []
for i in range(N):
H.append(int(eval(input())))
H.sort()
ans = H[-1] - H[0]
for i in range(len(H) - K + 1):
ans = min(ans, H[i + K - 1] - H[i])
print(ans)
|
N, K = list(map(int, input().split()))
H = sorted([int(eval(input())) for _ in range(N)])
print((min([H[i + K - 1] - H[i] for i in range(N - K + 1)])))
| 14 | 3 | 238 | 140 |
# -*- coding: utf-8 -*-
N, K = list(map(int, input().split()))
H = []
for i in range(N):
H.append(int(eval(input())))
H.sort()
ans = H[-1] - H[0]
for i in range(len(H) - K + 1):
ans = min(ans, H[i + K - 1] - H[i])
print(ans)
|
N, K = list(map(int, input().split()))
H = sorted([int(eval(input())) for _ in range(N)])
print((min([H[i + K - 1] - H[i] for i in range(N - K + 1)])))
| false | 78.571429 |
[
"-# -*- coding: utf-8 -*-",
"-H = []",
"-for i in range(N):",
"- H.append(int(eval(input())))",
"-H.sort()",
"-ans = H[-1] - H[0]",
"-for i in range(len(H) - K + 1):",
"- ans = min(ans, H[i + K - 1] - H[i])",
"-print(ans)",
"+H = sorted([int(eval(input())) for _ in range(N)])",
"+print((min([H[i + K - 1] - H[i] for i in range(N - K + 1)])))"
] | false | 0.034838 | 0.054567 | 0.638432 |
[
"s019983332",
"s267466532"
] |
u263830634
|
p02890
|
python
|
s205237999
|
s387693801
| 871 | 781 | 37,884 | 37,724 |
Accepted
|
Accepted
| 10.33 |
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
lst = [0] * (N + 1)
for a in A:
lst[a - 1] += 1
lst.sort() #頻度列
s = [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + lst[i + 1]
# print (lst)
# print (s)
def check(x, k):
i = bisect_left(lst, x) - 1
total = x * (N - i) + s[i]
return total >= x * k
ans = N
for k in range(1, N + 1):
while True:
if check(ans, k):
break
ans -= 1
print (ans)
|
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
lst = [0] * (N)
for a in A:
lst[a - 1] += 1
lst.sort() #頻度列
s = [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + lst[i]
# print (lst)
# print (s)
# def check(x, k):
# i = bisect_left(lst, x) - 1
# total = x * (N - i) + s[i]
# return total >= x * k
ans = N
i = N
for k in range(1, N + 1):
while True:
while i >= 1 and lst[i - 1] >= ans:
i -= 1
total = ans * (N - i) + s[i]
if total >= ans * k:
break
ans -= 1
# print ('i =', i)
print (ans)
| 30 | 36 | 524 | 664 |
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
lst = [0] * (N + 1)
for a in A:
lst[a - 1] += 1
lst.sort() # 頻度列
s = [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + lst[i + 1]
# print (lst)
# print (s)
def check(x, k):
i = bisect_left(lst, x) - 1
total = x * (N - i) + s[i]
return total >= x * k
ans = N
for k in range(1, N + 1):
while True:
if check(ans, k):
break
ans -= 1
print(ans)
|
from bisect import bisect_left
N = int(eval(input()))
A = list(map(int, input().split()))
lst = [0] * (N)
for a in A:
lst[a - 1] += 1
lst.sort() # 頻度列
s = [0] * (N + 1)
for i in range(N):
s[i + 1] = s[i] + lst[i]
# print (lst)
# print (s)
# def check(x, k):
# i = bisect_left(lst, x) - 1
# total = x * (N - i) + s[i]
# return total >= x * k
ans = N
i = N
for k in range(1, N + 1):
while True:
while i >= 1 and lst[i - 1] >= ans:
i -= 1
total = ans * (N - i) + s[i]
if total >= ans * k:
break
ans -= 1
# print ('i =', i)
print(ans)
| false | 16.666667 |
[
"-lst = [0] * (N + 1)",
"+lst = [0] * (N)",
"- s[i + 1] = s[i] + lst[i + 1]",
"+ s[i + 1] = s[i] + lst[i]",
"-def check(x, k):",
"- i = bisect_left(lst, x) - 1",
"- total = x * (N - i) + s[i]",
"- return total >= x * k",
"-",
"-",
"+# def check(x, k):",
"+# i = bisect_left(lst, x) - 1",
"+# total = x * (N - i) + s[i]",
"+# return total >= x * k",
"+i = N",
"- if check(ans, k):",
"+ while i >= 1 and lst[i - 1] >= ans:",
"+ i -= 1",
"+ total = ans * (N - i) + s[i]",
"+ if total >= ans * k:",
"+ # print ('i =', i)"
] | false | 0.093765 | 0.044209 | 2.120972 |
[
"s205237999",
"s387693801"
] |
u631277801
|
p03346
|
python
|
s442207271
|
s084131733
| 294 | 238 | 26,828 | 18,984 |
Accepted
|
Accepted
| 19.05 |
import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
n = ni()
p = []
idx = [0]*(n+1)
for _ in range(n):
p.append(ni())
for i,pi in enumerate(p):
idx[pi] = i+1
con = [0]*(n+1)
con[1] = 1
for i in range(1,n):
if idx[i] < idx[i+1]:
con[i+1] = con[i] + 1
else:
con[i+1] = 1
print((n - max(con)))
|
import sys
stdin = sys.stdin
def li(): return [int(x) for x in stdin.readline().split()]
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return [float(x) for x in stdin.readline().split()]
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(ns())
def nf(): return float(ns())
n = ni()
p = []
for _ in range(n):
p.append(ni())
dp = [0]*(n+1)
for i in range(n):
dp[p[i]] = dp[p[i]-1] + 1
print((n - max(dp)))
| 31 | 24 | 695 | 548 |
import sys
stdin = sys.stdin
def li():
return [int(x) for x in stdin.readline().split()]
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return [float(x) for x in stdin.readline().split()]
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(ns())
def nf():
return float(ns())
n = ni()
p = []
idx = [0] * (n + 1)
for _ in range(n):
p.append(ni())
for i, pi in enumerate(p):
idx[pi] = i + 1
con = [0] * (n + 1)
con[1] = 1
for i in range(1, n):
if idx[i] < idx[i + 1]:
con[i + 1] = con[i] + 1
else:
con[i + 1] = 1
print((n - max(con)))
|
import sys
stdin = sys.stdin
def li():
return [int(x) for x in stdin.readline().split()]
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return [float(x) for x in stdin.readline().split()]
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(ns())
def nf():
return float(ns())
n = ni()
p = []
for _ in range(n):
p.append(ni())
dp = [0] * (n + 1)
for i in range(n):
dp[p[i]] = dp[p[i] - 1] + 1
print((n - max(dp)))
| false | 22.580645 |
[
"-idx = [0] * (n + 1)",
"-for i, pi in enumerate(p):",
"- idx[pi] = i + 1",
"-con = [0] * (n + 1)",
"-con[1] = 1",
"-for i in range(1, n):",
"- if idx[i] < idx[i + 1]:",
"- con[i + 1] = con[i] + 1",
"- else:",
"- con[i + 1] = 1",
"-print((n - max(con)))",
"+dp = [0] * (n + 1)",
"+for i in range(n):",
"+ dp[p[i]] = dp[p[i] - 1] + 1",
"+print((n - max(dp)))"
] | false | 0.111954 | 0.042777 | 2.617183 |
[
"s442207271",
"s084131733"
] |
u636683284
|
p02792
|
python
|
s726612605
|
s821357819
| 122 | 85 | 74,072 | 73,660 |
Accepted
|
Accepted
| 30.33 |
from collections import defaultdict
d1 = defaultdict(int)
d2 = defaultdict(int)
n = int(eval(input()))
for i in range(1,n+1):
si = str(i)
f = si[0]
l = si[-1]
if f == l:
d1[(f,l)]+=1
else:
d2[(f,l)]+=1
ans = 0
for v in list(d1.values()):
if v == 1:
ans += 1
else:
ans += v**2
for v in list(d2.keys()):
ans += d2[v]*d2[(v[1],v[0])]*2
d2[v] = 0
print(ans)
|
c = [[0]*10 for _ in range(10)]
n = int(eval(input()))
for i in range(1,n+1):
si = str(i)
c[int(si[0])][int(si[-1])] += 1
ans = 0
for i in range(10):
for j in range(10):
ans += c[i][j]*c[j][i]
print(ans)
| 28 | 14 | 442 | 234 |
from collections import defaultdict
d1 = defaultdict(int)
d2 = defaultdict(int)
n = int(eval(input()))
for i in range(1, n + 1):
si = str(i)
f = si[0]
l = si[-1]
if f == l:
d1[(f, l)] += 1
else:
d2[(f, l)] += 1
ans = 0
for v in list(d1.values()):
if v == 1:
ans += 1
else:
ans += v**2
for v in list(d2.keys()):
ans += d2[v] * d2[(v[1], v[0])] * 2
d2[v] = 0
print(ans)
|
c = [[0] * 10 for _ in range(10)]
n = int(eval(input()))
for i in range(1, n + 1):
si = str(i)
c[int(si[0])][int(si[-1])] += 1
ans = 0
for i in range(10):
for j in range(10):
ans += c[i][j] * c[j][i]
print(ans)
| false | 50 |
[
"-from collections import defaultdict",
"-",
"-d1 = defaultdict(int)",
"-d2 = defaultdict(int)",
"+c = [[0] * 10 for _ in range(10)]",
"- f = si[0]",
"- l = si[-1]",
"- if f == l:",
"- d1[(f, l)] += 1",
"- else:",
"- d2[(f, l)] += 1",
"+ c[int(si[0])][int(si[-1])] += 1",
"-for v in list(d1.values()):",
"- if v == 1:",
"- ans += 1",
"- else:",
"- ans += v**2",
"-for v in list(d2.keys()):",
"- ans += d2[v] * d2[(v[1], v[0])] * 2",
"- d2[v] = 0",
"+for i in range(10):",
"+ for j in range(10):",
"+ ans += c[i][j] * c[j][i]"
] | false | 0.062679 | 0.163549 | 0.383245 |
[
"s726612605",
"s821357819"
] |
u525065967
|
p02629
|
python
|
s723819039
|
s752244293
| 36 | 29 | 9,128 | 9,172 |
Accepted
|
Accepted
| 19.44 |
n = int(eval(input()))
a = 'abcdefghijklmnopqrstuvwxyz'
ans = ''
while n > 0:
n, r = divmod(n-1, 26)
ans = a[r] + ans
print(ans)
|
n = int(eval(input()))
ans = ''
while n > 0:
n, r = divmod(n-1, 26)
ans = chr(r+ord('a')) + ans
print(ans)
| 7 | 6 | 137 | 114 |
n = int(eval(input()))
a = "abcdefghijklmnopqrstuvwxyz"
ans = ""
while n > 0:
n, r = divmod(n - 1, 26)
ans = a[r] + ans
print(ans)
|
n = int(eval(input()))
ans = ""
while n > 0:
n, r = divmod(n - 1, 26)
ans = chr(r + ord("a")) + ans
print(ans)
| false | 14.285714 |
[
"-a = \"abcdefghijklmnopqrstuvwxyz\"",
"- ans = a[r] + ans",
"+ ans = chr(r + ord(\"a\")) + ans"
] | false | 0.041257 | 0.114089 | 0.361619 |
[
"s723819039",
"s752244293"
] |
u796424048
|
p03627
|
python
|
s879327606
|
s777861735
| 185 | 104 | 21,796 | 21,668 |
Accepted
|
Accepted
| 43.78 |
import collections
N = int(eval(input()))
A = list(map(int,input().split()))
A = sorted(A)[::-1]
s = collections.Counter(A)
res = 1
count = 0
for i in sorted(list(set(A)))[::-1]:
if 4 <= s[i] and count != 1:
res *= i
res *= i
count += 2
elif 2 <= s[i]:
res *= i
count += 1
if count == 2:
break
if count == 2:
print(res)
else:
print((0))
|
from collections import Counter
N = int(eval(input()))
A = list(map(int,input().split()))
counter = Counter(A)
res =[]
for word,cnt in counter.most_common():
if 4 <= cnt:
res.append(word)
res.append(word)
elif 2 <= cnt:
res.append(word)
res = sorted(res)[::-1]
if len(res) < 2:
print((0))
else:
print((res[0]*res[1]))
| 28 | 20 | 436 | 375 |
import collections
N = int(eval(input()))
A = list(map(int, input().split()))
A = sorted(A)[::-1]
s = collections.Counter(A)
res = 1
count = 0
for i in sorted(list(set(A)))[::-1]:
if 4 <= s[i] and count != 1:
res *= i
res *= i
count += 2
elif 2 <= s[i]:
res *= i
count += 1
if count == 2:
break
if count == 2:
print(res)
else:
print((0))
|
from collections import Counter
N = int(eval(input()))
A = list(map(int, input().split()))
counter = Counter(A)
res = []
for word, cnt in counter.most_common():
if 4 <= cnt:
res.append(word)
res.append(word)
elif 2 <= cnt:
res.append(word)
res = sorted(res)[::-1]
if len(res) < 2:
print((0))
else:
print((res[0] * res[1]))
| false | 28.571429 |
[
"-import collections",
"+from collections import Counter",
"-A = sorted(A)[::-1]",
"-s = collections.Counter(A)",
"-res = 1",
"-count = 0",
"-for i in sorted(list(set(A)))[::-1]:",
"- if 4 <= s[i] and count != 1:",
"- res *= i",
"- res *= i",
"- count += 2",
"- elif 2 <= s[i]:",
"- res *= i",
"- count += 1",
"- if count == 2:",
"- break",
"-if count == 2:",
"- print(res)",
"+counter = Counter(A)",
"+res = []",
"+for word, cnt in counter.most_common():",
"+ if 4 <= cnt:",
"+ res.append(word)",
"+ res.append(word)",
"+ elif 2 <= cnt:",
"+ res.append(word)",
"+res = sorted(res)[::-1]",
"+if len(res) < 2:",
"+ print((0))",
"- print((0))",
"+ print((res[0] * res[1]))"
] | false | 0.083705 | 0.039625 | 2.112415 |
[
"s879327606",
"s777861735"
] |
u877283726
|
p03262
|
python
|
s467000492
|
s219128778
| 105 | 83 | 16,296 | 14,252 |
Accepted
|
Accepted
| 20.95 |
import fractions
n, X = list(map(int,input().split()))
x = list(map(int,input().split()))
gcd_value = abs(X-x[0])
for i in range(1,n):
gcd_value = fractions.gcd(gcd_value,abs(X-x[i]))
print(gcd_value)
|
n, X = list(map(int,input().split()))
x = list(map(int,input().split()))
def gcd(a,b):
while b!=0:
a,b=b,a%b
return a
gcd_value = abs(X-x[0])
for i in range(1,n):
gcd_value = gcd(gcd_value,abs(X-x[i]))
print(gcd_value)
| 11 | 14 | 212 | 241 |
import fractions
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
gcd_value = abs(X - x[0])
for i in range(1, n):
gcd_value = fractions.gcd(gcd_value, abs(X - x[i]))
print(gcd_value)
|
n, X = list(map(int, input().split()))
x = list(map(int, input().split()))
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
gcd_value = abs(X - x[0])
for i in range(1, n):
gcd_value = gcd(gcd_value, abs(X - x[i]))
print(gcd_value)
| false | 21.428571 |
[
"-import fractions",
"-",
"+",
"+",
"+def gcd(a, b):",
"+ while b != 0:",
"+ a, b = b, a % b",
"+ return a",
"+",
"+",
"- gcd_value = fractions.gcd(gcd_value, abs(X - x[i]))",
"+ gcd_value = gcd(gcd_value, abs(X - x[i]))"
] | false | 0.043773 | 0.04287 | 1.021067 |
[
"s467000492",
"s219128778"
] |
u977389981
|
p03563
|
python
|
s143305353
|
s211804281
| 21 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 19.05 |
r = int(eval(input()))
g = int(eval(input()))
print((g + (g - r)))
|
r = int(eval(input()))
g = int(eval(input()))
print((2 * g - r))
| 4 | 3 | 56 | 52 |
r = int(eval(input()))
g = int(eval(input()))
print((g + (g - r)))
|
r = int(eval(input()))
g = int(eval(input()))
print((2 * g - r))
| false | 25 |
[
"-print((g + (g - r)))",
"+print((2 * g - r))"
] | false | 0.046777 | 0.047754 | 0.979547 |
[
"s143305353",
"s211804281"
] |
u969190727
|
p03835
|
python
|
s780625991
|
s146924114
| 1,908 | 811 | 3,060 | 39,704 |
Accepted
|
Accepted
| 57.49 |
k,s=list(map(int,input().split()))
ans=0
for x in range(k+1):
for y in range(k+1):
if s-x-y>=0 and s-x-y<=k:
ans+=1
print(ans)
|
k,s=list(map(int,input().split()))
print((len([1 for z in range(k+1) for y in range(k+1) if 0<=s-y-z<=k])))
| 7 | 2 | 138 | 100 |
k, s = list(map(int, input().split()))
ans = 0
for x in range(k + 1):
for y in range(k + 1):
if s - x - y >= 0 and s - x - y <= k:
ans += 1
print(ans)
|
k, s = list(map(int, input().split()))
print((len([1 for z in range(k + 1) for y in range(k + 1) if 0 <= s - y - z <= k])))
| false | 71.428571 |
[
"-ans = 0",
"-for x in range(k + 1):",
"- for y in range(k + 1):",
"- if s - x - y >= 0 and s - x - y <= k:",
"- ans += 1",
"-print(ans)",
"+print((len([1 for z in range(k + 1) for y in range(k + 1) if 0 <= s - y - z <= k])))"
] | false | 0.060279 | 0.059923 | 1.005948 |
[
"s780625991",
"s146924114"
] |
u426649993
|
p02900
|
python
|
s920965981
|
s644682873
| 244 | 208 | 5,208 | 40,172 |
Accepted
|
Accepted
| 14.75 |
from math import sqrt
def IsPrime(num):
if num < 2:
return True
elif num == 2:
return True
elif num % 2 == 0:
return False
sqrtNum = sqrt(num)
for i in range(3, int(sqrtNum) + 1, 2):
if num % i == 0:
return False
return True
def make_divisors(num):
divisors = []
for i in range(1, int(num**0.5)+1):
if num % i == 0:
divisors.append(i)
if i != num // i:
divisors.append(num//i)
# divisors.sort()
return divisors
if __name__ == "__main__":
A, B = list(map(int, input().split()))
A_list = make_divisors(A)
B_list = make_divisors(B)
AB_list = set(A_list) & set(B_list)
ans = list()
for i in AB_list:
if IsPrime(i):
ans.append(i)
print((len(ans)))
|
import math
a, b = list(map(int, input().split()))
list_a = []
list_b = []
sqrt_a = math.sqrt(a)
sqrt_b = math.sqrt(b)
for i in range(2, int(sqrt_a)):
if (a % (i) == 0):
list_a.append(i)
while(a % (i) == 0):
a = a//(i)
if a != 1:
list_a.append(a)
for i in range(2, int(sqrt_b)):
if (b % (i) == 0):
list_b.append(i)
while(b % (i) == 0):
b = b//(i)
if b != 1:
list_b.append(b)
# print(list_a)
# print(list_b)
set_a = set(list_a)
set_b = set(list_b)
set_ab = set_a & set_b
print((len(set_ab) + 1))
| 45 | 35 | 872 | 602 |
from math import sqrt
def IsPrime(num):
if num < 2:
return True
elif num == 2:
return True
elif num % 2 == 0:
return False
sqrtNum = sqrt(num)
for i in range(3, int(sqrtNum) + 1, 2):
if num % i == 0:
return False
return True
def make_divisors(num):
divisors = []
for i in range(1, int(num**0.5) + 1):
if num % i == 0:
divisors.append(i)
if i != num // i:
divisors.append(num // i)
# divisors.sort()
return divisors
if __name__ == "__main__":
A, B = list(map(int, input().split()))
A_list = make_divisors(A)
B_list = make_divisors(B)
AB_list = set(A_list) & set(B_list)
ans = list()
for i in AB_list:
if IsPrime(i):
ans.append(i)
print((len(ans)))
|
import math
a, b = list(map(int, input().split()))
list_a = []
list_b = []
sqrt_a = math.sqrt(a)
sqrt_b = math.sqrt(b)
for i in range(2, int(sqrt_a)):
if a % (i) == 0:
list_a.append(i)
while a % (i) == 0:
a = a // (i)
if a != 1:
list_a.append(a)
for i in range(2, int(sqrt_b)):
if b % (i) == 0:
list_b.append(i)
while b % (i) == 0:
b = b // (i)
if b != 1:
list_b.append(b)
# print(list_a)
# print(list_b)
set_a = set(list_a)
set_b = set(list_b)
set_ab = set_a & set_b
print((len(set_ab) + 1))
| false | 22.222222 |
[
"-from math import sqrt",
"+import math",
"-",
"-def IsPrime(num):",
"- if num < 2:",
"- return True",
"- elif num == 2:",
"- return True",
"- elif num % 2 == 0:",
"- return False",
"- sqrtNum = sqrt(num)",
"- for i in range(3, int(sqrtNum) + 1, 2):",
"- if num % i == 0:",
"- return False",
"- return True",
"-",
"-",
"-def make_divisors(num):",
"- divisors = []",
"- for i in range(1, int(num**0.5) + 1):",
"- if num % i == 0:",
"- divisors.append(i)",
"- if i != num // i:",
"- divisors.append(num // i)",
"- # divisors.sort()",
"- return divisors",
"-",
"-",
"-if __name__ == \"__main__\":",
"- A, B = list(map(int, input().split()))",
"- A_list = make_divisors(A)",
"- B_list = make_divisors(B)",
"- AB_list = set(A_list) & set(B_list)",
"- ans = list()",
"- for i in AB_list:",
"- if IsPrime(i):",
"- ans.append(i)",
"- print((len(ans)))",
"+a, b = list(map(int, input().split()))",
"+list_a = []",
"+list_b = []",
"+sqrt_a = math.sqrt(a)",
"+sqrt_b = math.sqrt(b)",
"+for i in range(2, int(sqrt_a)):",
"+ if a % (i) == 0:",
"+ list_a.append(i)",
"+ while a % (i) == 0:",
"+ a = a // (i)",
"+if a != 1:",
"+ list_a.append(a)",
"+for i in range(2, int(sqrt_b)):",
"+ if b % (i) == 0:",
"+ list_b.append(i)",
"+ while b % (i) == 0:",
"+ b = b // (i)",
"+if b != 1:",
"+ list_b.append(b)",
"+# print(list_a)",
"+# print(list_b)",
"+set_a = set(list_a)",
"+set_b = set(list_b)",
"+set_ab = set_a & set_b",
"+print((len(set_ab) + 1))"
] | false | 0.046266 | 0.047425 | 0.975571 |
[
"s920965981",
"s644682873"
] |
u022871813
|
p03073
|
python
|
s962774166
|
s309859859
| 64 | 51 | 3,188 | 3,188 |
Accepted
|
Accepted
| 20.31 |
S = eval(input())
out1 = out2 = 0
for i, j in enumerate(S):
xor = (j == '1') ^ (i % 2)
out1 += xor
out2 += (1 - xor)
print((out1 if out1 < out2 else out2))
|
S = eval(input())
l = len(S)
out1 = out2 = 0
for i, j in enumerate(S):
xor = (j == '1') ^ (i % 2)
out1 += xor
print((out1 if out1 < l - out1 else l - out1))
| 9 | 9 | 163 | 162 |
S = eval(input())
out1 = out2 = 0
for i, j in enumerate(S):
xor = (j == "1") ^ (i % 2)
out1 += xor
out2 += 1 - xor
print((out1 if out1 < out2 else out2))
|
S = eval(input())
l = len(S)
out1 = out2 = 0
for i, j in enumerate(S):
xor = (j == "1") ^ (i % 2)
out1 += xor
print((out1 if out1 < l - out1 else l - out1))
| false | 0 |
[
"+l = len(S)",
"- out2 += 1 - xor",
"-print((out1 if out1 < out2 else out2))",
"+print((out1 if out1 < l - out1 else l - out1))"
] | false | 0.007854 | 0.039258 | 0.200071 |
[
"s962774166",
"s309859859"
] |
u143051858
|
p02608
|
python
|
s182868366
|
s690982160
| 495 | 430 | 9,384 | 9,060 |
Accepted
|
Accepted
| 13.13 |
N = int(eval(input()))
a = [0]*10050
for i in range(1,105):
for j in range(1,105):
for k in range(1,105):
v = i*i+j*j+k*k+i*j+i*k+j*k
if v < 10050:
a[v-1] += 1
for i in range(N):
print((a[i]))
|
N = int(eval(input()))
a = [0]*10050
for i in range(1,100):
for j in range(1,100):
for k in range(1,100):
v = i*i+j*j+k*k+i*j+i*k+j*k
if v <= 10000:
a[v-1] += 1
for i in range(N):
print((a[i]))
| 11 | 11 | 252 | 253 |
N = int(eval(input()))
a = [0] * 10050
for i in range(1, 105):
for j in range(1, 105):
for k in range(1, 105):
v = i * i + j * j + k * k + i * j + i * k + j * k
if v < 10050:
a[v - 1] += 1
for i in range(N):
print((a[i]))
|
N = int(eval(input()))
a = [0] * 10050
for i in range(1, 100):
for j in range(1, 100):
for k in range(1, 100):
v = i * i + j * j + k * k + i * j + i * k + j * k
if v <= 10000:
a[v - 1] += 1
for i in range(N):
print((a[i]))
| false | 0 |
[
"-for i in range(1, 105):",
"- for j in range(1, 105):",
"- for k in range(1, 105):",
"+for i in range(1, 100):",
"+ for j in range(1, 100):",
"+ for k in range(1, 100):",
"- if v < 10050:",
"+ if v <= 10000:"
] | false | 0.898831 | 0.784116 | 1.146298 |
[
"s182868366",
"s690982160"
] |
u366482170
|
p02844
|
python
|
s586886789
|
s655467798
| 903 | 746 | 3,820 | 43,776 |
Accepted
|
Accepted
| 17.39 |
#import sys
MOD = 10 ** 9 + 7
#input = sys.stdin.readline
import math
#import bisect
def sosuhante(n):
for k in range(2, int(math.sqrt(n))+1):
if n% k ==0:
return False
return True
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def kingaku(a,b,n):
keta=len(str(n))
return a*n+b*keta
def my_index(l, x, default=False):
if x in l:
return l.index(x)
else:
return default
def main():
# h,w,a,b = map(int, input().split())
# c = [[0 for j in range(n)] for i in range(n)]
n=int(eval(input()))
s=list(map(str,eval(input())))
a=[]
for i in range(1000):
if i<10:
a.append("00"+str(i))
elif i>=10 and i<100:
a.append("0"+str(i))
else:
a.append(str(i))
# print(s)
# print(a)
count=0
for i in range(1000):
keta1=a[i][0]
keta2=a[i][1]
keta3=a[i][2]
# print(keta1,keta2,keta3)
x=my_index(s,keta1,n+1)
if x>=n-1:
continue
y = my_index(s[x+1:], keta2,n+1)
if y>=len(s[x+1:])-1:
continue
z = my_index(s[x+y+2:], keta3,n+1)
if z>len(s[x+y+2:]):
continue
if x!=n+1 and y!=n+1 and z!=n+1:
# print(s[x],s[y],s[z],i)
count+=1
print(count)
# print(c)
# print(n,kingaku(a,b,x))
if __name__ == "__main__":
main()
|
#import sys
MOD = 10 ** 9 + 7
#input = sys.stdin.readline
import math
#import bisect
def sosuhante(n):
for k in range(2, int(math.sqrt(n))+1):
if n% k ==0:
return False
return True
def cmb(n, r):
if n - r < r: r = n - r
if r == 0: return 1
if r == 1: return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2,r+1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p-1,r,p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def kingaku(a,b,n):
keta=len(str(n))
return a*n+b*keta
def main():
# h,w,a,b = map(int, input().split())
# c = [[0 for j in range(n)] for i in range(n)]
n=int(eval(input()))
s=list(map(int,eval(input())))
c = [[-2 for j in range(11)] for i in range(10)]
d={0}
# print(c)
for i in range(n):
for j in range(10):
if c[j][10] > -2:
for k in range(10):
if c[j][k]>-2:
d.add(str(j)+str(k)+str(s[i]))
c[j][s[i]]=-1
c[s[i]][10] = -1
# print(d)
# print(c)
for i in range(100):
d.discard(str(i))
d.discard(0)
# print(d)
print((len(d)))
# print(n,kingaku(a,b,x))
if __name__ == "__main__":
main()
| 91 | 68 | 2,012 | 1,609 |
# import sys
MOD = 10**9 + 7
# input = sys.stdin.readline
import math
# import bisect
def sosuhante(n):
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def kingaku(a, b, n):
keta = len(str(n))
return a * n + b * keta
def my_index(l, x, default=False):
if x in l:
return l.index(x)
else:
return default
def main():
# h,w,a,b = map(int, input().split())
# c = [[0 for j in range(n)] for i in range(n)]
n = int(eval(input()))
s = list(map(str, eval(input())))
a = []
for i in range(1000):
if i < 10:
a.append("00" + str(i))
elif i >= 10 and i < 100:
a.append("0" + str(i))
else:
a.append(str(i))
# print(s)
# print(a)
count = 0
for i in range(1000):
keta1 = a[i][0]
keta2 = a[i][1]
keta3 = a[i][2]
# print(keta1,keta2,keta3)
x = my_index(s, keta1, n + 1)
if x >= n - 1:
continue
y = my_index(s[x + 1 :], keta2, n + 1)
if y >= len(s[x + 1 :]) - 1:
continue
z = my_index(s[x + y + 2 :], keta3, n + 1)
if z > len(s[x + y + 2 :]):
continue
if x != n + 1 and y != n + 1 and z != n + 1:
# print(s[x],s[y],s[z],i)
count += 1
print(count)
# print(c)
# print(n,kingaku(a,b,x))
if __name__ == "__main__":
main()
|
# import sys
MOD = 10**9 + 7
# input = sys.stdin.readline
import math
# import bisect
def sosuhante(n):
for k in range(2, int(math.sqrt(n)) + 1):
if n % k == 0:
return False
return True
def cmb(n, r):
if n - r < r:
r = n - r
if r == 0:
return 1
if r == 1:
return n
numerator = [n - r + k + 1 for k in range(r)]
denominator = [k + 1 for k in range(r)]
for p in range(2, r + 1):
pivot = denominator[p - 1]
if pivot > 1:
offset = (n - r) % p
for k in range(p - 1, r, p):
numerator[k - offset] /= pivot
denominator[k] /= pivot
result = 1
for k in range(r):
if numerator[k] > 1:
result *= int(numerator[k])
return result
def kingaku(a, b, n):
keta = len(str(n))
return a * n + b * keta
def main():
# h,w,a,b = map(int, input().split())
# c = [[0 for j in range(n)] for i in range(n)]
n = int(eval(input()))
s = list(map(int, eval(input())))
c = [[-2 for j in range(11)] for i in range(10)]
d = {0}
# print(c)
for i in range(n):
for j in range(10):
if c[j][10] > -2:
for k in range(10):
if c[j][k] > -2:
d.add(str(j) + str(k) + str(s[i]))
c[j][s[i]] = -1
c[s[i]][10] = -1
# print(d)
# print(c)
for i in range(100):
d.discard(str(i))
d.discard(0)
# print(d)
print((len(d)))
# print(n,kingaku(a,b,x))
if __name__ == "__main__":
main()
| false | 25.274725 |
[
"-def my_index(l, x, default=False):",
"- if x in l:",
"- return l.index(x)",
"- else:",
"- return default",
"-",
"-",
"- s = list(map(str, eval(input())))",
"- a = []",
"- for i in range(1000):",
"- if i < 10:",
"- a.append(\"00\" + str(i))",
"- elif i >= 10 and i < 100:",
"- a.append(\"0\" + str(i))",
"- else:",
"- a.append(str(i))",
"- # print(s)",
"- # print(a)",
"- count = 0",
"- for i in range(1000):",
"- keta1 = a[i][0]",
"- keta2 = a[i][1]",
"- keta3 = a[i][2]",
"- # print(keta1,keta2,keta3)",
"- x = my_index(s, keta1, n + 1)",
"- if x >= n - 1:",
"- continue",
"- y = my_index(s[x + 1 :], keta2, n + 1)",
"- if y >= len(s[x + 1 :]) - 1:",
"- continue",
"- z = my_index(s[x + y + 2 :], keta3, n + 1)",
"- if z > len(s[x + y + 2 :]):",
"- continue",
"- if x != n + 1 and y != n + 1 and z != n + 1:",
"- # print(s[x],s[y],s[z],i)",
"- count += 1",
"- print(count)",
"+ s = list(map(int, eval(input())))",
"+ c = [[-2 for j in range(11)] for i in range(10)]",
"+ d = {0}",
"+ # print(c)",
"+ for i in range(n):",
"+ for j in range(10):",
"+ if c[j][10] > -2:",
"+ for k in range(10):",
"+ if c[j][k] > -2:",
"+ d.add(str(j) + str(k) + str(s[i]))",
"+ c[j][s[i]] = -1",
"+ c[s[i]][10] = -1",
"+ # print(d)",
"+ # print(c)",
"+ for i in range(100):",
"+ d.discard(str(i))",
"+ d.discard(0)",
"+ # print(d)",
"+ print((len(d)))",
"+ # print(n,kingaku(a,b,x))",
"-# print(c)",
"-# print(n,kingaku(a,b,x))"
] | false | 0.037577 | 0.043764 | 0.858614 |
[
"s586886789",
"s655467798"
] |
u329709276
|
p03292
|
python
|
s696643696
|
s222072207
| 20 | 18 | 3,064 | 2,940 |
Accepted
|
Accepted
| 10 |
A = list(map(int,input().split()))
A.sort()
ans = A[2]-A[1] + A[1]-A[0]
print(ans)
|
A = list(map(int,input().split()))
A.sort()
ans = A[2]-A[0]
print(ans)
| 4 | 4 | 85 | 74 |
A = list(map(int, input().split()))
A.sort()
ans = A[2] - A[1] + A[1] - A[0]
print(ans)
|
A = list(map(int, input().split()))
A.sort()
ans = A[2] - A[0]
print(ans)
| false | 0 |
[
"-ans = A[2] - A[1] + A[1] - A[0]",
"+ans = A[2] - A[0]"
] | false | 0.070027 | 0.036931 | 1.896132 |
[
"s696643696",
"s222072207"
] |
u816631826
|
p03556
|
python
|
s239290581
|
s779602618
| 23 | 17 | 2,940 | 2,940 |
Accepted
|
Accepted
| 26.09 |
n = int(eval(input()))
i = 1
while i * i <= n:
i += 1
print(((i - 1) * (i - 1)))
|
import math
n=int(eval(input()))
a=int(math.sqrt(n))
print((a*a))
| 5 | 4 | 80 | 60 |
n = int(eval(input()))
i = 1
while i * i <= n:
i += 1
print(((i - 1) * (i - 1)))
|
import math
n = int(eval(input()))
a = int(math.sqrt(n))
print((a * a))
| false | 20 |
[
"+import math",
"+",
"-i = 1",
"-while i * i <= n:",
"- i += 1",
"-print(((i - 1) * (i - 1)))",
"+a = int(math.sqrt(n))",
"+print((a * a))"
] | false | 0.04233 | 0.04051 | 1.044925 |
[
"s239290581",
"s779602618"
] |
u641446860
|
p02641
|
python
|
s745597046
|
s184495317
| 29 | 24 | 9,048 | 9,020 |
Accepted
|
Accepted
| 17.24 |
X, N = list(map(int, input().split()))
if N:
p = list(map(int, input().split()))
for i in range(N // 2 + 3):
if X - i not in p:
print((X - i))
break
if X + i not in p:
print((X + i))
break
else:
print(X)
|
X, N = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(N // 2 + 3):
if X - i not in p:
print((X - i))
break
if X + i not in p:
print((X + i))
break
| 12 | 9 | 281 | 221 |
X, N = list(map(int, input().split()))
if N:
p = list(map(int, input().split()))
for i in range(N // 2 + 3):
if X - i not in p:
print((X - i))
break
if X + i not in p:
print((X + i))
break
else:
print(X)
|
X, N = list(map(int, input().split()))
p = list(map(int, input().split()))
for i in range(N // 2 + 3):
if X - i not in p:
print((X - i))
break
if X + i not in p:
print((X + i))
break
| false | 25 |
[
"-if N:",
"- p = list(map(int, input().split()))",
"- for i in range(N // 2 + 3):",
"- if X - i not in p:",
"- print((X - i))",
"- break",
"- if X + i not in p:",
"- print((X + i))",
"- break",
"-else:",
"- print(X)",
"+p = list(map(int, input().split()))",
"+for i in range(N // 2 + 3):",
"+ if X - i not in p:",
"+ print((X - i))",
"+ break",
"+ if X + i not in p:",
"+ print((X + i))",
"+ break"
] | false | 0.044679 | 0.035701 | 1.251488 |
[
"s745597046",
"s184495317"
] |
u638902622
|
p03380
|
python
|
s829936824
|
s410416285
| 217 | 76 | 23,128 | 14,056 |
Accepted
|
Accepted
| 64.98 |
import sys
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
import numpy as np
def getNearestValue(list, num):
"""
概要: リストからある値に最も近い値を返却する関数
@param list: データ配列
@param num: 対象値
@return 対象値に最も近い値
"""
# リスト要素と対象値の差分を計算し最小値のインデックスを取得
idx = np.abs(np.asarray(list) - num).argmin()
return list[idx]
def main():
n = II()
aa = MII()
if n == 2: print(*aa); exit(0)
aa.sort()
maxa = aa[-1]
m = maxa/2
a = getNearestValue(aa, m)
print(maxa, a, end= ' ')
if __name__ == '__main__':
main()
|
import sys
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
from bisect import bisect_left
def main():
n = II()
aa = MII()
if n == 2: print(*aa); exit(0)
aa.sort()
ans_n = aa[-1]
m = ans_n/2
idx = bisect_left(aa, m+1)
ans_r = aa[idx] if idx!=n-1 else aa[idx-1]
if abs(aa[idx]-m) > abs(aa[idx-1]-m):
ans_r = aa[idx-1]
print(ans_n, ans_r, end= ' ')
if __name__ == '__main__':
main()
| 28 | 21 | 638 | 515 |
import sys
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
import numpy as np
def getNearestValue(list, num):
"""
概要: リストからある値に最も近い値を返却する関数
@param list: データ配列
@param num: 対象値
@return 対象値に最も近い値
"""
# リスト要素と対象値の差分を計算し最小値のインデックスを取得
idx = np.abs(np.asarray(list) - num).argmin()
return list[idx]
def main():
n = II()
aa = MII()
if n == 2:
print(*aa)
exit(0)
aa.sort()
maxa = aa[-1]
m = maxa / 2
a = getNearestValue(aa, m)
print(maxa, a, end=" ")
if __name__ == "__main__":
main()
|
import sys
IS = lambda: sys.stdin.readline().rstrip()
II = lambda: int(IS())
MII = lambda: list(map(int, IS().split()))
from bisect import bisect_left
def main():
n = II()
aa = MII()
if n == 2:
print(*aa)
exit(0)
aa.sort()
ans_n = aa[-1]
m = ans_n / 2
idx = bisect_left(aa, m + 1)
ans_r = aa[idx] if idx != n - 1 else aa[idx - 1]
if abs(aa[idx] - m) > abs(aa[idx - 1] - m):
ans_r = aa[idx - 1]
print(ans_n, ans_r, end=" ")
if __name__ == "__main__":
main()
| false | 25 |
[
"-import numpy as np",
"-",
"-",
"-def getNearestValue(list, num):",
"- \"\"\"",
"- 概要: リストからある値に最も近い値を返却する関数",
"- @param list: データ配列",
"- @param num: 対象値",
"- @return 対象値に最も近い値",
"- \"\"\"",
"- # リスト要素と対象値の差分を計算し最小値のインデックスを取得",
"- idx = np.abs(np.asarray(list) - num).argmin()",
"- return list[idx]",
"+from bisect import bisect_left",
"- maxa = aa[-1]",
"- m = maxa / 2",
"- a = getNearestValue(aa, m)",
"- print(maxa, a, end=\" \")",
"+ ans_n = aa[-1]",
"+ m = ans_n / 2",
"+ idx = bisect_left(aa, m + 1)",
"+ ans_r = aa[idx] if idx != n - 1 else aa[idx - 1]",
"+ if abs(aa[idx] - m) > abs(aa[idx - 1] - m):",
"+ ans_r = aa[idx - 1]",
"+ print(ans_n, ans_r, end=\" \")"
] | false | 0.276114 | 0.045351 | 6.088371 |
[
"s829936824",
"s410416285"
] |
u638456847
|
p02608
|
python
|
s912872810
|
s383446107
| 694 | 296 | 9,292 | 9,380 |
Accepted
|
Accepted
| 57.35 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
f = [0] * (N+1)
for x in range(1,100):
for y in range(1,100):
for z in range(1,100):
tmp = x**2 + y**2 + z**2 + x*y + y*z + z*x
if tmp <= N:
f[tmp] += 1
print(("\n".join(map(str, f[1:]))))
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
f = [0] * (N+1)
for x in range(1,100):
for y in range(1,100):
for z in range(1,100):
tmp = x*x + y*y + z*z + x*y + y*z + z*x
if tmp <= N:
f[tmp] += 1
print(("\n".join(map(str, f[1:]))))
if __name__ == "__main__":
main()
| 21 | 21 | 469 | 466 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
f = [0] * (N + 1)
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
tmp = x**2 + y**2 + z**2 + x * y + y * z + z * x
if tmp <= N:
f[tmp] += 1
print(("\n".join(map(str, f[1:]))))
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
N = int(readline())
f = [0] * (N + 1)
for x in range(1, 100):
for y in range(1, 100):
for z in range(1, 100):
tmp = x * x + y * y + z * z + x * y + y * z + z * x
if tmp <= N:
f[tmp] += 1
print(("\n".join(map(str, f[1:]))))
if __name__ == "__main__":
main()
| false | 0 |
[
"- tmp = x**2 + y**2 + z**2 + x * y + y * z + z * x",
"+ tmp = x * x + y * y + z * z + x * y + y * z + z * x"
] | false | 1.827461 | 0.957073 | 1.909426 |
[
"s912872810",
"s383446107"
] |
u554133763
|
p02713
|
python
|
s602053859
|
s701467368
| 500 | 73 | 68,708 | 65,856 |
Accepted
|
Accepted
| 85.4 |
import math
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
for c in range(1, k+1):
ans += math.gcd(math.gcd(a, b), c)
print(ans)
|
import math
k = int(eval(input()))
dec = {}
for a in range(1, k+1):
for b in range(1, k+1):
if math.gcd(a, b) not in dec:
dec[math.gcd(a,b)] = 1
else:
dec[math.gcd(a,b)] += 1
ans = 0
for c in range(1, k+1):
for d in list(dec.keys()):
ans += math.gcd(d, c) * dec[d]
print(ans)
| 9 | 15 | 187 | 334 |
import math
k = int(eval(input()))
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
for c in range(1, k + 1):
ans += math.gcd(math.gcd(a, b), c)
print(ans)
|
import math
k = int(eval(input()))
dec = {}
for a in range(1, k + 1):
for b in range(1, k + 1):
if math.gcd(a, b) not in dec:
dec[math.gcd(a, b)] = 1
else:
dec[math.gcd(a, b)] += 1
ans = 0
for c in range(1, k + 1):
for d in list(dec.keys()):
ans += math.gcd(d, c) * dec[d]
print(ans)
| false | 40 |
[
"-ans = 0",
"+dec = {}",
"- for c in range(1, k + 1):",
"- ans += math.gcd(math.gcd(a, b), c)",
"+ if math.gcd(a, b) not in dec:",
"+ dec[math.gcd(a, b)] = 1",
"+ else:",
"+ dec[math.gcd(a, b)] += 1",
"+ans = 0",
"+for c in range(1, k + 1):",
"+ for d in list(dec.keys()):",
"+ ans += math.gcd(d, c) * dec[d]"
] | false | 0.047127 | 0.119988 | 0.392761 |
[
"s602053859",
"s701467368"
] |
u121921603
|
p02947
|
python
|
s440000026
|
s819515872
| 672 | 617 | 71,744 | 69,080 |
Accepted
|
Accepted
| 8.18 |
from collections import Counter
N = int(eval(input()))
a=[]
for i in range(N):
s=eval(input())
S=[]
for j in range(10):
S.append(s[j])
S.sort()
s="".join(S).split()
a.append(s[0])
x=Counter(a)
num=list(x.values())
#print(list(num))
ans=0
for i in (list(num)):
ans+=i*(i-1)//2
print(ans)
|
from collections import Counter
N = int(eval(input()))
a=[]
for i in range(N):
s=eval(input())
s="".join(sorted(s)).split()
a.append(s[0])
num=list(Counter(a).values())
#print(list(num))
ans=0
for i in (list(num)):
ans+=i*(i-1)//2
print(ans)
| 19 | 14 | 324 | 254 |
from collections import Counter
N = int(eval(input()))
a = []
for i in range(N):
s = eval(input())
S = []
for j in range(10):
S.append(s[j])
S.sort()
s = "".join(S).split()
a.append(s[0])
x = Counter(a)
num = list(x.values())
# print(list(num))
ans = 0
for i in list(num):
ans += i * (i - 1) // 2
print(ans)
|
from collections import Counter
N = int(eval(input()))
a = []
for i in range(N):
s = eval(input())
s = "".join(sorted(s)).split()
a.append(s[0])
num = list(Counter(a).values())
# print(list(num))
ans = 0
for i in list(num):
ans += i * (i - 1) // 2
print(ans)
| false | 26.315789 |
[
"- S = []",
"- for j in range(10):",
"- S.append(s[j])",
"- S.sort()",
"- s = \"\".join(S).split()",
"+ s = \"\".join(sorted(s)).split()",
"-x = Counter(a)",
"-num = list(x.values())",
"+num = list(Counter(a).values())"
] | false | 0.059923 | 0.087714 | 0.683163 |
[
"s440000026",
"s819515872"
] |
u782098901
|
p03478
|
python
|
s214769815
|
s354022720
| 33 | 26 | 2,940 | 2,940 |
Accepted
|
Accepted
| 21.21 |
N, A, B = list(map(int, input().split()))
res = 0
for i in range(1, N + 1):
tmp = 0
for j in str(i):
tmp += int(j)
if tmp >= A and tmp <= B:
res += i
print(res)
|
N, A, B = list(map(int, input().split()))
def f(x):
res = 0
while x > 0:
res += x % 10
x //= 10
return res
res = 0
for i in range(1, N + 1):
x = f(i)
if A <= x and x <= B:
res += i
print(res)
| 10 | 17 | 193 | 250 |
N, A, B = list(map(int, input().split()))
res = 0
for i in range(1, N + 1):
tmp = 0
for j in str(i):
tmp += int(j)
if tmp >= A and tmp <= B:
res += i
print(res)
|
N, A, B = list(map(int, input().split()))
def f(x):
res = 0
while x > 0:
res += x % 10
x //= 10
return res
res = 0
for i in range(1, N + 1):
x = f(i)
if A <= x and x <= B:
res += i
print(res)
| false | 41.176471 |
[
"+",
"+",
"+def f(x):",
"+ res = 0",
"+ while x > 0:",
"+ res += x % 10",
"+ x //= 10",
"+ return res",
"+",
"+",
"- tmp = 0",
"- for j in str(i):",
"- tmp += int(j)",
"- if tmp >= A and tmp <= B:",
"+ x = f(i)",
"+ if A <= x and x <= B:"
] | false | 0.03616 | 0.043706 | 0.827347 |
[
"s214769815",
"s354022720"
] |
u686036872
|
p03160
|
python
|
s493757067
|
s470195419
| 259 | 121 | 53,496 | 13,980 |
Accepted
|
Accepted
| 53.28 |
N = int(eval(input()))
H = list(map(int, input().split()))
B = [0]*N
B[1]=abs(H[1]-H[0])
for i in range(2, N):
B[i] = min(B[i-2]+abs(H[i]-H[i-2]), B[i-1]+abs(H[i]-H[i-1]))
print((B[N-1]))
|
N = int(eval(input()))
H = list(map(int, input().split()))
dp =[0]*N
dp[1] = abs(H[1] - H[0])
for i in range(2, N):
dp[i] = min(dp[i-2]+abs(H[i-2] - H[i]), dp[i-1]+abs(H[i-1] - H[i]))
print((dp[-1]))
| 7 | 11 | 189 | 209 |
N = int(eval(input()))
H = list(map(int, input().split()))
B = [0] * N
B[1] = abs(H[1] - H[0])
for i in range(2, N):
B[i] = min(B[i - 2] + abs(H[i] - H[i - 2]), B[i - 1] + abs(H[i] - H[i - 1]))
print((B[N - 1]))
|
N = int(eval(input()))
H = list(map(int, input().split()))
dp = [0] * N
dp[1] = abs(H[1] - H[0])
for i in range(2, N):
dp[i] = min(dp[i - 2] + abs(H[i - 2] - H[i]), dp[i - 1] + abs(H[i - 1] - H[i]))
print((dp[-1]))
| false | 36.363636 |
[
"-B = [0] * N",
"-B[1] = abs(H[1] - H[0])",
"+dp = [0] * N",
"+dp[1] = abs(H[1] - H[0])",
"- B[i] = min(B[i - 2] + abs(H[i] - H[i - 2]), B[i - 1] + abs(H[i] - H[i - 1]))",
"-print((B[N - 1]))",
"+ dp[i] = min(dp[i - 2] + abs(H[i - 2] - H[i]), dp[i - 1] + abs(H[i - 1] - H[i]))",
"+print((dp[-1]))"
] | false | 0.073063 | 0.090585 | 0.806567 |
[
"s493757067",
"s470195419"
] |
u394721319
|
p03937
|
python
|
s388052676
|
s220521526
| 189 | 17 | 38,384 | 3,060 |
Accepted
|
Accepted
| 91.01 |
H,W = [int(i) for i in input().split()]
li = [list(eval(input())) for _ in range(H)]
flag = 0
for i in range(H):
tmp = []
for j,k in enumerate(li[i]):
if k == '#':
tmp.append(j)
if i != 0 and p != tmp[0]:
flag = 1
break
p = tmp[-1]
print((['Possible', 'Impossible'][flag]))
|
H,W = [int(zz) for zz in input().split()]
map = [list(eval(input())) for _ in range(H)]
r = 0
for j in range(W):
if map[0][j] == "#":
r = j
for i in range(1,H):
flag = 1
for j in range(W):
if flag and map[i][j] == "#":
if r != j:
print('Impossible')
exit()
flag = 0
elif map[i][j] == "#":
r = j
print('Possible')
| 15 | 19 | 334 | 431 |
H, W = [int(i) for i in input().split()]
li = [list(eval(input())) for _ in range(H)]
flag = 0
for i in range(H):
tmp = []
for j, k in enumerate(li[i]):
if k == "#":
tmp.append(j)
if i != 0 and p != tmp[0]:
flag = 1
break
p = tmp[-1]
print((["Possible", "Impossible"][flag]))
|
H, W = [int(zz) for zz in input().split()]
map = [list(eval(input())) for _ in range(H)]
r = 0
for j in range(W):
if map[0][j] == "#":
r = j
for i in range(1, H):
flag = 1
for j in range(W):
if flag and map[i][j] == "#":
if r != j:
print("Impossible")
exit()
flag = 0
elif map[i][j] == "#":
r = j
print("Possible")
| false | 21.052632 |
[
"-H, W = [int(i) for i in input().split()]",
"-li = [list(eval(input())) for _ in range(H)]",
"-flag = 0",
"-for i in range(H):",
"- tmp = []",
"- for j, k in enumerate(li[i]):",
"- if k == \"#\":",
"- tmp.append(j)",
"- if i != 0 and p != tmp[0]:",
"- flag = 1",
"- break",
"- p = tmp[-1]",
"-print(([\"Possible\", \"Impossible\"][flag]))",
"+H, W = [int(zz) for zz in input().split()]",
"+map = [list(eval(input())) for _ in range(H)]",
"+r = 0",
"+for j in range(W):",
"+ if map[0][j] == \"#\":",
"+ r = j",
"+for i in range(1, H):",
"+ flag = 1",
"+ for j in range(W):",
"+ if flag and map[i][j] == \"#\":",
"+ if r != j:",
"+ print(\"Impossible\")",
"+ exit()",
"+ flag = 0",
"+ elif map[i][j] == \"#\":",
"+ r = j",
"+print(\"Possible\")"
] | false | 0.035779 | 0.039749 | 0.900115 |
[
"s388052676",
"s220521526"
] |
u386819480
|
p03401
|
python
|
s404224065
|
s949587631
| 262 | 218 | 16,712 | 15,684 |
Accepted
|
Accepted
| 16.79 |
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
A = [0] + A + [0]
cost = 0
for i in range(1, len(A)):
cost += abs(A[i]-A[i-1])
# print(cost)
x = sorted(A)
for i in range(1,len(A)-1):
if((A[i-1] <= A[i] <= A[i+1]) or (A[i-1] >= A[i] >= A[i+1])):
print(cost)
else:
print((cost-2*min(abs(A[i+1]-A[i]),abs(A[i]-A[i-1]))))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
A = [0] + A + [0]
cost = 0
for i in range(1, len(A)):
cost += abs(A[i]-A[i-1])
for i in range(1,len(A)-1):
if((A[i-1] <= A[i] <= A[i+1]) or (A[i-1] >= A[i] >= A[i+1])):
print(cost)
else:
print((cost-2*min(abs(A[i+1]-A[i]),abs(A[i]-A[i-1]))))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == '__main__':
main()
| 37 | 34 | 956 | 916 |
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
A = [0] + A + [0]
cost = 0
for i in range(1, len(A)):
cost += abs(A[i] - A[i - 1])
# print(cost)
x = sorted(A)
for i in range(1, len(A) - 1):
if (A[i - 1] <= A[i] <= A[i + 1]) or (A[i - 1] >= A[i] >= A[i + 1]):
print(cost)
else:
print((cost - 2 * min(abs(A[i + 1] - A[i]), abs(A[i] - A[i - 1]))))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
def solve(N: int, A: "List[int]"):
A = [0] + A + [0]
cost = 0
for i in range(1, len(A)):
cost += abs(A[i] - A[i - 1])
for i in range(1, len(A) - 1):
if (A[i - 1] <= A[i] <= A[i + 1]) or (A[i - 1] >= A[i] >= A[i + 1]):
print(cost)
else:
print((cost - 2 * min(abs(A[i + 1] - A[i]), abs(A[i] - A[i - 1]))))
return
# Generated by 1.1.5 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
solve(N, A)
if __name__ == "__main__":
main()
| false | 8.108108 |
[
"- # print(cost)",
"- x = sorted(A)"
] | false | 0.057388 | 0.059766 | 0.960217 |
[
"s404224065",
"s949587631"
] |
u119456964
|
p02258
|
python
|
s292414427
|
s550520474
| 310 | 150 | 18,808 | 23,576 |
Accepted
|
Accepted
| 51.61 |
n = int(input())
R = [0 for i in range(n)]
ans = 1 - 10**9
min_R = int(input())
for i in range(n-1):
R[i] = int(input())
if R[i] - min_R > ans:
ans = R[i] - min_R
if R[i] < min_R:
min_R = R[i]
print(ans)
|
import sys
n = int(input())
min_R = int(input())
nums = list(map(int, sys.stdin.readlines()))
ans = -10**9
for num in nums:
if num - min_R > ans:
ans = num - min_R
if num < min_R:
min_R = num
print(ans)
| 17 | 16 | 284 | 255 |
n = int(input())
R = [0 for i in range(n)]
ans = 1 - 10**9
min_R = int(input())
for i in range(n - 1):
R[i] = int(input())
if R[i] - min_R > ans:
ans = R[i] - min_R
if R[i] < min_R:
min_R = R[i]
print(ans)
|
import sys
n = int(input())
min_R = int(input())
nums = list(map(int, sys.stdin.readlines()))
ans = -(10**9)
for num in nums:
if num - min_R > ans:
ans = num - min_R
if num < min_R:
min_R = num
print(ans)
| false | 5.882353 |
[
"+import sys",
"+",
"-R = [0 for i in range(n)]",
"-ans = 1 - 10**9",
"-for i in range(n - 1):",
"- R[i] = int(input())",
"- if R[i] - min_R > ans:",
"- ans = R[i] - min_R",
"- if R[i] < min_R:",
"- min_R = R[i]",
"+nums = list(map(int, sys.stdin.readlines()))",
"+ans = -(10**9)",
"+for num in nums:",
"+ if num - min_R > ans:",
"+ ans = num - min_R",
"+ if num < min_R:",
"+ min_R = num"
] | false | 0.038902 | 0.046239 | 0.84132 |
[
"s292414427",
"s550520474"
] |
u761320129
|
p03821
|
python
|
s631729085
|
s453101756
| 473 | 354 | 52,468 | 16,600 |
Accepted
|
Accepted
| 25.16 |
N = int(eval(input()))
src = [list(map(int,input().split())) for i in range(N)]
ans = 0
for a,b in reversed(src):
r = (ans+a) % b
if r == 0: continue
ans += (b-r)
print(ans)
|
N = int(eval(input()))
src = [tuple(map(int,input().split())) for i in range(N)]
ans = 0
for a,b in reversed(src):
a += ans
ans += (b-a)%b
print(ans)
| 9 | 8 | 183 | 159 |
N = int(eval(input()))
src = [list(map(int, input().split())) for i in range(N)]
ans = 0
for a, b in reversed(src):
r = (ans + a) % b
if r == 0:
continue
ans += b - r
print(ans)
|
N = int(eval(input()))
src = [tuple(map(int, input().split())) for i in range(N)]
ans = 0
for a, b in reversed(src):
a += ans
ans += (b - a) % b
print(ans)
| false | 11.111111 |
[
"-src = [list(map(int, input().split())) for i in range(N)]",
"+src = [tuple(map(int, input().split())) for i in range(N)]",
"- r = (ans + a) % b",
"- if r == 0:",
"- continue",
"- ans += b - r",
"+ a += ans",
"+ ans += (b - a) % b"
] | false | 0.070794 | 0.037286 | 1.898681 |
[
"s631729085",
"s453101756"
] |
u493520238
|
p02627
|
python
|
s143321995
|
s978731999
| 74 | 65 | 61,564 | 61,268 |
Accepted
|
Accepted
| 12.16 |
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
s = eval(input())
if s in ALP:
print('A')
else:
print('a')
|
alps = 'abcdefghijklmnopqrstuvwxyz'
s = eval(input())
if s in alps:
print('a')
else:
print('A')
| 8 | 6 | 138 | 102 |
ALP = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
alp = "abcdefghijklmnopqrstuvwxyz"
s = eval(input())
if s in ALP:
print("A")
else:
print("a")
|
alps = "abcdefghijklmnopqrstuvwxyz"
s = eval(input())
if s in alps:
print("a")
else:
print("A")
| false | 25 |
[
"-ALP = \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"",
"-alp = \"abcdefghijklmnopqrstuvwxyz\"",
"+alps = \"abcdefghijklmnopqrstuvwxyz\"",
"-if s in ALP:",
"+if s in alps:",
"+ print(\"a\")",
"+else:",
"-else:",
"- print(\"a\")"
] | false | 0.043876 | 0.039692 | 1.105388 |
[
"s143321995",
"s978731999"
] |
u972591645
|
p03088
|
python
|
s409643133
|
s374246094
| 28 | 23 | 9,180 | 9,148 |
Accepted
|
Accepted
| 17.86 |
n = int(eval(input()))
dp = [[0]*4 for i in range(n+1)]
mod = 10**9+7
dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = 1
dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = 4
for i in range(2,n):
for j in range(4):
dp[i][j] = sum(dp[i-1])%mod
dp[i][1] -= dp[i-2][0]
dp[i][2] -= (dp[i-2][0] + dp[i-2][1])
if i >= 3:
dp[i][2] -= 3*dp[i-3][0]
dp[i][1] += dp[i-3][1]
print((sum(dp[n-1])%mod))
|
n = int(eval(input()))
mod = 10**9 + 7
a = [0]*n
c = [0]*n
g = [0]*n
t = [0]*n
a[0] = c[0] = g[0] = t[0] = 1
a[1] = c[1] = g[1] = t[1] = 4
a[2], c[2], g[2], t[2] = 16, 14, 15, 16
for i in range(3, n):
v = (a[i-1] + c[i-1] + g[i-1] + t[i-1]) % mod
a[i] = v
c[i] = (v - a[i-2] - g[i-2] - 3*a[i-3]) % mod
g[i] = (v - a[i-2] + g[i-3]) % mod
t[i] = v
print(((a[n-1] + c[n-1] + g[n-1] + t[n-1]) % mod))
| 18 | 20 | 436 | 431 |
n = int(eval(input()))
dp = [[0] * 4 for i in range(n + 1)]
mod = 10**9 + 7
dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = 1
dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = 4
for i in range(2, n):
for j in range(4):
dp[i][j] = sum(dp[i - 1]) % mod
dp[i][1] -= dp[i - 2][0]
dp[i][2] -= dp[i - 2][0] + dp[i - 2][1]
if i >= 3:
dp[i][2] -= 3 * dp[i - 3][0]
dp[i][1] += dp[i - 3][1]
print((sum(dp[n - 1]) % mod))
|
n = int(eval(input()))
mod = 10**9 + 7
a = [0] * n
c = [0] * n
g = [0] * n
t = [0] * n
a[0] = c[0] = g[0] = t[0] = 1
a[1] = c[1] = g[1] = t[1] = 4
a[2], c[2], g[2], t[2] = 16, 14, 15, 16
for i in range(3, n):
v = (a[i - 1] + c[i - 1] + g[i - 1] + t[i - 1]) % mod
a[i] = v
c[i] = (v - a[i - 2] - g[i - 2] - 3 * a[i - 3]) % mod
g[i] = (v - a[i - 2] + g[i - 3]) % mod
t[i] = v
print(((a[n - 1] + c[n - 1] + g[n - 1] + t[n - 1]) % mod))
| false | 10 |
[
"-dp = [[0] * 4 for i in range(n + 1)]",
"-dp[0][0] = dp[0][1] = dp[0][2] = dp[0][3] = 1",
"-dp[1][0] = dp[1][1] = dp[1][2] = dp[1][3] = 4",
"-for i in range(2, n):",
"- for j in range(4):",
"- dp[i][j] = sum(dp[i - 1]) % mod",
"- dp[i][1] -= dp[i - 2][0]",
"- dp[i][2] -= dp[i - 2][0] + dp[i - 2][1]",
"- if i >= 3:",
"- dp[i][2] -= 3 * dp[i - 3][0]",
"- dp[i][1] += dp[i - 3][1]",
"-print((sum(dp[n - 1]) % mod))",
"+a = [0] * n",
"+c = [0] * n",
"+g = [0] * n",
"+t = [0] * n",
"+a[0] = c[0] = g[0] = t[0] = 1",
"+a[1] = c[1] = g[1] = t[1] = 4",
"+a[2], c[2], g[2], t[2] = 16, 14, 15, 16",
"+for i in range(3, n):",
"+ v = (a[i - 1] + c[i - 1] + g[i - 1] + t[i - 1]) % mod",
"+ a[i] = v",
"+ c[i] = (v - a[i - 2] - g[i - 2] - 3 * a[i - 3]) % mod",
"+ g[i] = (v - a[i - 2] + g[i - 3]) % mod",
"+ t[i] = v",
"+print(((a[n - 1] + c[n - 1] + g[n - 1] + t[n - 1]) % mod))"
] | false | 0.037875 | 0.038355 | 0.987491 |
[
"s409643133",
"s374246094"
] |
u947805421
|
p02659
|
python
|
s268286188
|
s104361404
| 30 | 22 | 10,504 | 9,156 |
Accepted
|
Accepted
| 26.67 |
import math
import fractions
a, b = input().split()
a = int(a)
b = fractions.Fraction(b)
print((math.floor(a * b)))
|
a, b = input().split()
a = int(a)
b = round(float(b) * 100)
print((a * b // 100))
| 6 | 4 | 119 | 83 |
import math
import fractions
a, b = input().split()
a = int(a)
b = fractions.Fraction(b)
print((math.floor(a * b)))
|
a, b = input().split()
a = int(a)
b = round(float(b) * 100)
print((a * b // 100))
| false | 33.333333 |
[
"-import math",
"-import fractions",
"-",
"-b = fractions.Fraction(b)",
"-print((math.floor(a * b)))",
"+b = round(float(b) * 100)",
"+print((a * b // 100))"
] | false | 0.069053 | 0.053255 | 1.296643 |
[
"s268286188",
"s104361404"
] |
u150749188
|
p02713
|
python
|
s783585767
|
s364118240
| 889 | 633 | 9,008 | 110,356 |
Accepted
|
Accepted
| 28.8 |
import math
k = int(eval(input()))
def ans():
sum = 0
temp = 0
for l in range(1,k+1):
for m in range(1,k+1):
temp = math.gcd(l,m)
for n in range(1,k+1):
sum += math.gcd(temp,n)
return(sum)
print((ans()))
|
import math
from numba import jit
k = int(eval(input()))
@jit
def ans():
sum = 0
temp = 0
for l in range(1,k+1):
for m in range(1,k+1):
temp = math.gcd(l,m)
for n in range(1,k+1):
sum += math.gcd(temp,n)
return(sum)
print((ans()))
| 13 | 16 | 272 | 303 |
import math
k = int(eval(input()))
def ans():
sum = 0
temp = 0
for l in range(1, k + 1):
for m in range(1, k + 1):
temp = math.gcd(l, m)
for n in range(1, k + 1):
sum += math.gcd(temp, n)
return sum
print((ans()))
|
import math
from numba import jit
k = int(eval(input()))
@jit
def ans():
sum = 0
temp = 0
for l in range(1, k + 1):
for m in range(1, k + 1):
temp = math.gcd(l, m)
for n in range(1, k + 1):
sum += math.gcd(temp, n)
return sum
print((ans()))
| false | 18.75 |
[
"+from numba import jit",
"+@jit"
] | false | 0.122596 | 0.038821 | 3.157973 |
[
"s783585767",
"s364118240"
] |
u375616706
|
p03575
|
python
|
s763837489
|
s865425208
| 182 | 30 | 38,640 | 3,064 |
Accepted
|
Accepted
| 83.52 |
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
edges.append([a-1, b-1])
nodes = [0]*N
mat = [[0]*N for _ in range(N)]
for s, g in edges:
nodes[s] += 1
nodes[g] += 1
mat[s][g] = 1
mat[g][s] = 1
ans = 0
def check(nodes):
return all(n != 1 for n in nodes)
ans = 0
while not check(nodes):
for i in range(N):
if nodes[i] == 1:
for j in range(N):
if mat[i][j]:
mat[i][j] = 0
mat[j][i] = 0
ans += 1
nodes[i] -= 1
nodes[j] -= 1
break
print(ans)
|
class UnionFind:
def __init__(self, size):
self.table = [i for i in range(size)]
def find(self, x):
return self.table[x]
def union(self, x, y):
x1 = self.find(x)
y1 = self.find(y)
if x1 == y1:
return False
for i in range(len(self.table)):
if self.table[i] == y1:
self.table[i] = x1
return True
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
edges.append([a-1, b-1])
mat = [[0]*N for _ in range(N)]
for s, g in edges:
mat[s][g] = 1
mat[g][s] = 1
ans = 0
for i in range(M):
uni = UnionFind(N)
for j in range(M):
if i != j:
uni.union(edges[j][0], edges[j][1])
if not all(uni.find(0) == uni.find(x) for x in range(N)):
ans += 1
print(ans)
| 36 | 45 | 723 | 905 |
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
edges.append([a - 1, b - 1])
nodes = [0] * N
mat = [[0] * N for _ in range(N)]
for s, g in edges:
nodes[s] += 1
nodes[g] += 1
mat[s][g] = 1
mat[g][s] = 1
ans = 0
def check(nodes):
return all(n != 1 for n in nodes)
ans = 0
while not check(nodes):
for i in range(N):
if nodes[i] == 1:
for j in range(N):
if mat[i][j]:
mat[i][j] = 0
mat[j][i] = 0
ans += 1
nodes[i] -= 1
nodes[j] -= 1
break
print(ans)
|
class UnionFind:
def __init__(self, size):
self.table = [i for i in range(size)]
def find(self, x):
return self.table[x]
def union(self, x, y):
x1 = self.find(x)
y1 = self.find(y)
if x1 == y1:
return False
for i in range(len(self.table)):
if self.table[i] == y1:
self.table[i] = x1
return True
N, M = list(map(int, input().split()))
edges = []
for _ in range(M):
a, b = list(map(int, input().split()))
edges.append([a - 1, b - 1])
mat = [[0] * N for _ in range(N)]
for s, g in edges:
mat[s][g] = 1
mat[g][s] = 1
ans = 0
for i in range(M):
uni = UnionFind(N)
for j in range(M):
if i != j:
uni.union(edges[j][0], edges[j][1])
if not all(uni.find(0) == uni.find(x) for x in range(N)):
ans += 1
print(ans)
| false | 20 |
[
"+class UnionFind:",
"+ def __init__(self, size):",
"+ self.table = [i for i in range(size)]",
"+",
"+ def find(self, x):",
"+ return self.table[x]",
"+",
"+ def union(self, x, y):",
"+ x1 = self.find(x)",
"+ y1 = self.find(y)",
"+ if x1 == y1:",
"+ return False",
"+ for i in range(len(self.table)):",
"+ if self.table[i] == y1:",
"+ self.table[i] = x1",
"+ return True",
"+",
"+",
"-nodes = [0] * N",
"- nodes[s] += 1",
"- nodes[g] += 1",
"-",
"-",
"-def check(nodes):",
"- return all(n != 1 for n in nodes)",
"-",
"-",
"-ans = 0",
"-while not check(nodes):",
"- for i in range(N):",
"- if nodes[i] == 1:",
"- for j in range(N):",
"- if mat[i][j]:",
"- mat[i][j] = 0",
"- mat[j][i] = 0",
"- ans += 1",
"- nodes[i] -= 1",
"- nodes[j] -= 1",
"- break",
"+for i in range(M):",
"+ uni = UnionFind(N)",
"+ for j in range(M):",
"+ if i != j:",
"+ uni.union(edges[j][0], edges[j][1])",
"+ if not all(uni.find(0) == uni.find(x) for x in range(N)):",
"+ ans += 1"
] | false | 0.08346 | 0.035942 | 2.322042 |
[
"s763837489",
"s865425208"
] |
u227082700
|
p02536
|
python
|
s627863084
|
s629659919
| 343 | 238 | 11,448 | 11,604 |
Accepted
|
Accepted
| 30.61 |
# UnionFind
import sys
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n,m=list(map(int,input().split()))
u=UnionFind(n)
for _ in range(m):
a,b=list(map(int,input().split()))
a-=1
b-=1
u.unite(a,b)
print((u.size()-1))
|
class UnionFind:
def __init__(self, n):
self.n = [-1]*n
self.r = [0]*n
self.co = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.co -= 1
def same(self, x, y):
return self.find_root(x) == self.find_root(y)
def size(self, x):
return -self.n[self.find_root(x)]
def set_count(self):
return self.co
import sys
input = lambda:sys.stdin.readline().rstrip()
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
a, b = list(map(int, input().split()))
uf.unite(a-1, b-1)
print((uf.set_count()-1))
| 48 | 46 | 981 | 987 |
# UnionFind
import sys
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, n):
self.n = [-1] * n
self.r = [0] * n
self.siz = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.siz -= 1
def root_same(self, x, y):
return self.find_root(x) == self.find_root(y)
def count(self, x):
return -self.n[self.find_root(x)]
def size(self):
return self.siz
n, m = list(map(int, input().split()))
u = UnionFind(n)
for _ in range(m):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
u.unite(a, b)
print((u.size() - 1))
|
class UnionFind:
def __init__(self, n):
self.n = [-1] * n
self.r = [0] * n
self.co = n
def find_root(self, x):
if self.n[x] < 0:
return x
else:
self.n[x] = self.find_root(self.n[x])
return self.n[x]
def unite(self, x, y):
x = self.find_root(x)
y = self.find_root(y)
if x == y:
return
elif self.r[x] > self.r[y]:
self.n[x] += self.n[y]
self.n[y] = x
else:
self.n[y] += self.n[x]
self.n[x] = y
if self.r[x] == self.r[y]:
self.r[y] += 1
self.co -= 1
def same(self, x, y):
return self.find_root(x) == self.find_root(y)
def size(self, x):
return -self.n[self.find_root(x)]
def set_count(self):
return self.co
import sys
input = lambda: sys.stdin.readline().rstrip()
n, m = list(map(int, input().split()))
uf = UnionFind(n)
for _ in range(m):
a, b = list(map(int, input().split()))
uf.unite(a - 1, b - 1)
print((uf.set_count() - 1))
| false | 4.166667 |
[
"-# UnionFind",
"-import sys",
"-",
"-sys.setrecursionlimit(1000000)",
"-",
"-",
"- self.siz = n",
"+ self.co = n",
"- self.siz -= 1",
"+ self.co -= 1",
"- def root_same(self, x, y):",
"+ def same(self, x, y):",
"- def count(self, x):",
"+ def size(self, x):",
"- def size(self):",
"- return self.siz",
"+ def set_count(self):",
"+ return self.co",
"+import sys",
"+",
"+input = lambda: sys.stdin.readline().rstrip()",
"-u = UnionFind(n)",
"+uf = UnionFind(n)",
"- a -= 1",
"- b -= 1",
"- u.unite(a, b)",
"-print((u.size() - 1))",
"+ uf.unite(a - 1, b - 1)",
"+print((uf.set_count() - 1))"
] | false | 0.036462 | 0.041216 | 0.884664 |
[
"s627863084",
"s629659919"
] |
u078042885
|
p00461
|
python
|
s877658100
|
s921575489
| 680 | 590 | 10,488 | 9,416 |
Accepted
|
Accepted
| 13.24 |
while 1:
n=int(eval(input()))
if n==0:break
a='I'+'OI'*n
b,s,c=int(eval(input())),eval(input()),0
for i in range(b-len(a)):
if s[i:i+len(a)]==a:c+=1
print(c)
|
while 1:
n=int(eval(input()))
if n==0:break
a='I'+'OI'*n
b,s=int(eval(input())),eval(input())
print((sum(1 for i in range(b-len(a)) if s[i:i+len(a)]==a)))
| 8 | 6 | 178 | 159 |
while 1:
n = int(eval(input()))
if n == 0:
break
a = "I" + "OI" * n
b, s, c = int(eval(input())), eval(input()), 0
for i in range(b - len(a)):
if s[i : i + len(a)] == a:
c += 1
print(c)
|
while 1:
n = int(eval(input()))
if n == 0:
break
a = "I" + "OI" * n
b, s = int(eval(input())), eval(input())
print((sum(1 for i in range(b - len(a)) if s[i : i + len(a)] == a)))
| false | 25 |
[
"- b, s, c = int(eval(input())), eval(input()), 0",
"- for i in range(b - len(a)):",
"- if s[i : i + len(a)] == a:",
"- c += 1",
"- print(c)",
"+ b, s = int(eval(input())), eval(input())",
"+ print((sum(1 for i in range(b - len(a)) if s[i : i + len(a)] == a)))"
] | false | 0.035993 | 0.043389 | 0.829541 |
[
"s877658100",
"s921575489"
] |
u354916249
|
p02927
|
python
|
s382997133
|
s699970149
| 25 | 20 | 3,060 | 3,060 |
Accepted
|
Accepted
| 20 |
M,D = list(map(int, input().split()))
D = int(D)
ans = 0
for i in range(1,M+1):
for j in range(1,D+1):
j = str(j)
if len(j) == 2:
j1 = int(j[0])
j2 = int(j[1])
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans)
|
M,D = list(map(int, input().split()))
ans = 0
for i in range(1,M+1):
for j in range(1,D+1):
j1 = j // 10
j2 = j % 10
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans)
| 16 | 13 | 306 | 227 |
M, D = list(map(int, input().split()))
D = int(D)
ans = 0
for i in range(1, M + 1):
for j in range(1, D + 1):
j = str(j)
if len(j) == 2:
j1 = int(j[0])
j2 = int(j[1])
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans)
|
M, D = list(map(int, input().split()))
ans = 0
for i in range(1, M + 1):
for j in range(1, D + 1):
j1 = j // 10
j2 = j % 10
if j1 >= 2 and j2 >= 2 and j1 * j2 == i:
ans += 1
print(ans)
| false | 18.75 |
[
"-D = int(D)",
"- j = str(j)",
"- if len(j) == 2:",
"- j1 = int(j[0])",
"- j2 = int(j[1])",
"- if j1 >= 2 and j2 >= 2 and j1 * j2 == i:",
"- ans += 1",
"+ j1 = j // 10",
"+ j2 = j % 10",
"+ if j1 >= 2 and j2 >= 2 and j1 * j2 == i:",
"+ ans += 1"
] | false | 0.036059 | 0.035419 | 1.018071 |
[
"s382997133",
"s699970149"
] |
u562935282
|
p03703
|
python
|
s521315389
|
s960302309
| 1,642 | 1,339 | 37,980 | 37,980 |
Accepted
|
Accepted
| 18.45 |
# 解説を見た
# https://tjkendev.github.io/procon-library/python/range_query/bit.html
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def main():
from itertools import accumulate
N, K = list(map(int, input().split()))
A = (int(eval(input())) - K for _ in range(N))
acc = (0,) + tuple(accumulate(A))
def compress(iter):
convert = {x: i for i, x in enumerate(sorted(iter), start=1)}
# BITで扱うので、1-indexedにする
# 値kがa番目とa+1番目に含まれているとき、k:a->k:a+1で上書きされる
return (convert[x] for x in iter)
comacc = tuple(compress(acc))
ret = 0
b = BIT(len(comacc))
for x in comacc:
ret += b.sum(x)
b.add(x, 1)
print(ret)
if __name__ == '__main__':
main()
|
# 解説を見た
# https://tjkendev.github.io/procon-library/python/range_query/bit.html
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def main():
from itertools import accumulate
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = (int(eval(input())) - K for _ in range(N))
acc = (0,) + tuple(accumulate(A))
def compress(iter):
convert = {x: i for i, x in enumerate(sorted(iter), start=1)}
# BITで扱うので、1-indexedにする
# 値kがa番目とa+1番目に含まれているとき、k:a->k:a+1で上書きされる
return (convert[x] for x in iter)
comacc = compress(acc)
ret = 0
b = BIT(N + 1)
for x in comacc:
ret += b.sum(x)
b.add(x, 1)
print(ret)
if __name__ == '__main__':
main()
| 58 | 61 | 1,292 | 1,329 |
# 解説を見た
# https://tjkendev.github.io/procon-library/python/range_query/bit.html
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def main():
from itertools import accumulate
N, K = list(map(int, input().split()))
A = (int(eval(input())) - K for _ in range(N))
acc = (0,) + tuple(accumulate(A))
def compress(iter):
convert = {x: i for i, x in enumerate(sorted(iter), start=1)}
# BITで扱うので、1-indexedにする
# 値kがa番目とa+1番目に含まれているとき、k:a->k:a+1で上書きされる
return (convert[x] for x in iter)
comacc = tuple(compress(acc))
ret = 0
b = BIT(len(comacc))
for x in comacc:
ret += b.sum(x)
b.add(x, 1)
print(ret)
if __name__ == "__main__":
main()
|
# 解説を見た
# https://tjkendev.github.io/procon-library/python/range_query/bit.html
# Binary Indexed Tree (Fenwick Tree)
class BIT:
def __init__(self, n):
self.n = n
self.data = [0] * (n + 1)
self.el = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.data[i]
i -= i & -i
return s
def add(self, i, x):
# assert i > 0
self.el[i] += x
while i <= self.n:
self.data[i] += x
i += i & -i
def get(self, i, j=None):
if j is None:
return self.el[i]
return self.sum(j) - self.sum(i)
def main():
from itertools import accumulate
import sys
input = sys.stdin.readline
N, K = list(map(int, input().split()))
A = (int(eval(input())) - K for _ in range(N))
acc = (0,) + tuple(accumulate(A))
def compress(iter):
convert = {x: i for i, x in enumerate(sorted(iter), start=1)}
# BITで扱うので、1-indexedにする
# 値kがa番目とa+1番目に含まれているとき、k:a->k:a+1で上書きされる
return (convert[x] for x in iter)
comacc = compress(acc)
ret = 0
b = BIT(N + 1)
for x in comacc:
ret += b.sum(x)
b.add(x, 1)
print(ret)
if __name__ == "__main__":
main()
| false | 4.918033 |
[
"+ import sys",
"+ input = sys.stdin.readline",
"- comacc = tuple(compress(acc))",
"+ comacc = compress(acc)",
"- b = BIT(len(comacc))",
"+ b = BIT(N + 1)"
] | false | 0.039412 | 0.043351 | 0.909129 |
[
"s521315389",
"s960302309"
] |
u089230684
|
p04030
|
python
|
s451643655
|
s295254611
| 163 | 17 | 38,256 | 3,064 |
Accepted
|
Accepted
| 89.57 |
s = eval(input())
l = []
for i in s:
if i=='B':
l=l[:-1]
else:
l.append(i)
print(("".join(l)))
|
s = input()
len = 0
op = []
for i in s:
if(i == '1'):
op.append('1')
len += 1
elif(i == '0'):
op.append('0')
len += 1
elif(i == 'B'):
if(len > 0):
op.pop()
len = len - 1
for i in op:
print(i, end = '')
| 8 | 18 | 99 | 300 |
s = eval(input())
l = []
for i in s:
if i == "B":
l = l[:-1]
else:
l.append(i)
print(("".join(l)))
|
s = input()
len = 0
op = []
for i in s:
if i == "1":
op.append("1")
len += 1
elif i == "0":
op.append("0")
len += 1
elif i == "B":
if len > 0:
op.pop()
len = len - 1
for i in op:
print(i, end="")
| false | 55.555556 |
[
"-s = eval(input())",
"-l = []",
"+s = input()",
"+len = 0",
"+op = []",
"- if i == \"B\":",
"- l = l[:-1]",
"- else:",
"- l.append(i)",
"-print((\"\".join(l)))",
"+ if i == \"1\":",
"+ op.append(\"1\")",
"+ len += 1",
"+ elif i == \"0\":",
"+ op.append(\"0\")",
"+ len += 1",
"+ elif i == \"B\":",
"+ if len > 0:",
"+ op.pop()",
"+ len = len - 1",
"+for i in op:",
"+ print(i, end=\"\")"
] | false | 0.081917 | 0.032513 | 2.51949 |
[
"s451643655",
"s295254611"
] |
u810356688
|
p03240
|
python
|
s313346572
|
s508599284
| 202 | 29 | 41,328 | 3,064 |
Accepted
|
Accepted
| 85.64 |
import sys
def input(): return sys.stdin.readline().rstrip()
from operator import itemgetter
def main():
n=int(eval(input()))
XYH=[tuple(map(int,input().split())) for i in range(n)]
XYH.sort(key=itemgetter(2),reverse=True)
for cy in range(101):
for cx in range(101):
hc=XYH[0][2]+abs(cx-XYH[0][0])+abs(cy-XYH[0][1])
for x,y,h in XYH:
if h!=max(0,hc-abs(x-cx)-abs(y-cy)):
break
else:
print((cx,cy,hc))
sys.exit()
if __name__=='__main__':
main()
|
import sys
def input(): return sys.stdin.readline().rstrip()
from operator import itemgetter
def main():
n=int(eval(input()))
XYH=[tuple(map(int,input().split())) for i in range(n)]
XYH.sort(key=itemgetter(2),reverse=True)
for cy in range(101):
for cx in range(101):
hc=XYH[0][2]+abs(cx-XYH[0][0])+abs(cy-XYH[0][1])
for x,y,h in XYH[1:]:
if h!=max(0,hc-abs(x-cx)-abs(y-cy)):
break
else:
print((cx,cy,hc))
sys.exit()
if __name__=='__main__':
main()
| 19 | 19 | 586 | 590 |
import sys
def input():
return sys.stdin.readline().rstrip()
from operator import itemgetter
def main():
n = int(eval(input()))
XYH = [tuple(map(int, input().split())) for i in range(n)]
XYH.sort(key=itemgetter(2), reverse=True)
for cy in range(101):
for cx in range(101):
hc = XYH[0][2] + abs(cx - XYH[0][0]) + abs(cy - XYH[0][1])
for x, y, h in XYH:
if h != max(0, hc - abs(x - cx) - abs(y - cy)):
break
else:
print((cx, cy, hc))
sys.exit()
if __name__ == "__main__":
main()
|
import sys
def input():
return sys.stdin.readline().rstrip()
from operator import itemgetter
def main():
n = int(eval(input()))
XYH = [tuple(map(int, input().split())) for i in range(n)]
XYH.sort(key=itemgetter(2), reverse=True)
for cy in range(101):
for cx in range(101):
hc = XYH[0][2] + abs(cx - XYH[0][0]) + abs(cy - XYH[0][1])
for x, y, h in XYH[1:]:
if h != max(0, hc - abs(x - cx) - abs(y - cy)):
break
else:
print((cx, cy, hc))
sys.exit()
if __name__ == "__main__":
main()
| false | 0 |
[
"- for x, y, h in XYH:",
"+ for x, y, h in XYH[1:]:"
] | false | 0.113716 | 0.118167 | 0.962332 |
[
"s313346572",
"s508599284"
] |
u393253137
|
p03073
|
python
|
s806959624
|
s459006740
| 76 | 18 | 3,316 | 3,188 |
Accepted
|
Accepted
| 76.32 |
S = eval(input())
n = len(S)
ans1, ans2 = 0, 0
for i, s in enumerate(S):
m = int(s)
if i % 2:
ans1 += 1 - m
ans2 += m
else:
ans1 += m
ans2 += 1 - m
print((min(ans1, ans2)))
|
s = eval(input())
# 偶数番目, 奇数番目を取り出すならスライス使おう!
c = s[::2].count('0') + s[1::2].count('1')
print((min(c, len(s)-c)))
| 12 | 4 | 219 | 109 |
S = eval(input())
n = len(S)
ans1, ans2 = 0, 0
for i, s in enumerate(S):
m = int(s)
if i % 2:
ans1 += 1 - m
ans2 += m
else:
ans1 += m
ans2 += 1 - m
print((min(ans1, ans2)))
|
s = eval(input())
# 偶数番目, 奇数番目を取り出すならスライス使おう!
c = s[::2].count("0") + s[1::2].count("1")
print((min(c, len(s) - c)))
| false | 66.666667 |
[
"-S = eval(input())",
"-n = len(S)",
"-ans1, ans2 = 0, 0",
"-for i, s in enumerate(S):",
"- m = int(s)",
"- if i % 2:",
"- ans1 += 1 - m",
"- ans2 += m",
"- else:",
"- ans1 += m",
"- ans2 += 1 - m",
"-print((min(ans1, ans2)))",
"+s = eval(input())",
"+# 偶数番目, 奇数番目を取り出すならスライス使おう!",
"+c = s[::2].count(\"0\") + s[1::2].count(\"1\")",
"+print((min(c, len(s) - c)))"
] | false | 0.035918 | 0.040829 | 0.879724 |
[
"s806959624",
"s459006740"
] |
u491729244
|
p02629
|
python
|
s374171624
|
s271491921
| 36 | 31 | 9,104 | 9,152 |
Accepted
|
Accepted
| 13.89 |
#!/usr/bin/env python3
def number_to_alphabet(number):
if number <= 26:
return chr(96 + number)
if number % 26 == 0:
return number_to_alphabet(number // 26 - 1) + 'z'
return number_to_alphabet(number // 26) + chr(96 + number % 26)
N = int(eval(input()))
result = number_to_alphabet(N)
print(result)
|
#!/usr/bin/env python3
def f(n):
if n == 0:
return ''
n -= 1
return f(n // 26) + chr(ord('a') + n % 26)
N = int(eval(input()))
print((f(N)))
| 16 | 13 | 342 | 170 |
#!/usr/bin/env python3
def number_to_alphabet(number):
if number <= 26:
return chr(96 + number)
if number % 26 == 0:
return number_to_alphabet(number // 26 - 1) + "z"
return number_to_alphabet(number // 26) + chr(96 + number % 26)
N = int(eval(input()))
result = number_to_alphabet(N)
print(result)
|
#!/usr/bin/env python3
def f(n):
if n == 0:
return ""
n -= 1
return f(n // 26) + chr(ord("a") + n % 26)
N = int(eval(input()))
print((f(N)))
| false | 18.75 |
[
"-def number_to_alphabet(number):",
"- if number <= 26:",
"- return chr(96 + number)",
"- if number % 26 == 0:",
"- return number_to_alphabet(number // 26 - 1) + \"z\"",
"- return number_to_alphabet(number // 26) + chr(96 + number % 26)",
"+def f(n):",
"+ if n == 0:",
"+ return \"\"",
"+ n -= 1",
"+ return f(n // 26) + chr(ord(\"a\") + n % 26)",
"-result = number_to_alphabet(N)",
"-print(result)",
"+print((f(N)))"
] | false | 0.138836 | 0.046557 | 2.982064 |
[
"s374171624",
"s271491921"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.