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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u244459371
|
p03112
|
python
|
s065029715
|
s678096319
| 1,494
| 761
| 90,584
| 69,084
|
Accepted
|
Accepted
| 49.06
|
from bisect import bisect_left, bisect_right
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(a)]
t = [int(eval(input())) for _ in range(b)]
q = [int(eval(input())) for _ in range(q)]
for qi in q:
qans = 10**18
ai = bisect_left(s, qi)
bi = bisect_left(t, qi)
ac = []
bc = []
for i in range(2):
if (0 <= ai + i < a):
ac.append(ai + i);
if (0 <= ai - i < a):
ac.append(ai - i);
for i in range(2):
if (0 <= bi + i < b):
bc.append(bi + i);
if (0 <= bi - i < b):
bc.append(bi - i);
for i in ac:
for j in bc:
aa = s[i];
bb = t[j];
if (max(aa, bb) <= qi):
qans = min(qans, qi - min(aa, bb))
elif (qi <= min(aa, bb)):
qans = min(qans, max(aa, bb) - qi)
else:
qans = min(qans, min(abs(aa - qi), abs(bb - qi)) * 2 + max(abs(aa - qi), abs(bb - qi)))
print(qans)
|
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(a)]
t = [int(eval(input())) for _ in range(b)]
q = [int(eval(input())) for _ in range(q)]
for qi in q:
qans = 10**18
ai = bisect_left(s, qi)
bi = bisect_left(t, qi)
ac = []
bc = []
for i in range(2):
if (0 <= ai + i < a):
ac.append(ai + i);
if (0 <= ai - i < a):
ac.append(ai - i);
for i in range(2):
if (0 <= bi + i < b):
bc.append(bi + i);
if (0 <= bi - i < b):
bc.append(bi - i);
for i in ac:
for j in bc:
aa = s[i];
bb = t[j];
if (max(aa, bb) <= qi):
qans = min(qans, qi - min(aa, bb))
elif (qi <= min(aa, bb)):
qans = min(qans, max(aa, bb) - qi)
else:
qans = min(qans, min(abs(aa - qi), abs(bb - qi)) * 2 + max(abs(aa - qi), abs(bb - qi)))
print(qans)
| 32
| 34
| 1,022
| 1,062
|
from bisect import bisect_left, bisect_right
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(a)]
t = [int(eval(input())) for _ in range(b)]
q = [int(eval(input())) for _ in range(q)]
for qi in q:
qans = 10**18
ai = bisect_left(s, qi)
bi = bisect_left(t, qi)
ac = []
bc = []
for i in range(2):
if 0 <= ai + i < a:
ac.append(ai + i)
if 0 <= ai - i < a:
ac.append(ai - i)
for i in range(2):
if 0 <= bi + i < b:
bc.append(bi + i)
if 0 <= bi - i < b:
bc.append(bi - i)
for i in ac:
for j in bc:
aa = s[i]
bb = t[j]
if max(aa, bb) <= qi:
qans = min(qans, qi - min(aa, bb))
elif qi <= min(aa, bb):
qans = min(qans, max(aa, bb) - qi)
else:
qans = min(
qans,
min(abs(aa - qi), abs(bb - qi)) * 2
+ max(abs(aa - qi), abs(bb - qi)),
)
print(qans)
|
from bisect import bisect_left, bisect_right
import sys
input = sys.stdin.readline
a, b, q = list(map(int, input().split()))
s = [int(eval(input())) for _ in range(a)]
t = [int(eval(input())) for _ in range(b)]
q = [int(eval(input())) for _ in range(q)]
for qi in q:
qans = 10**18
ai = bisect_left(s, qi)
bi = bisect_left(t, qi)
ac = []
bc = []
for i in range(2):
if 0 <= ai + i < a:
ac.append(ai + i)
if 0 <= ai - i < a:
ac.append(ai - i)
for i in range(2):
if 0 <= bi + i < b:
bc.append(bi + i)
if 0 <= bi - i < b:
bc.append(bi - i)
for i in ac:
for j in bc:
aa = s[i]
bb = t[j]
if max(aa, bb) <= qi:
qans = min(qans, qi - min(aa, bb))
elif qi <= min(aa, bb):
qans = min(qans, max(aa, bb) - qi)
else:
qans = min(
qans,
min(abs(aa - qi), abs(bb - qi)) * 2
+ max(abs(aa - qi), abs(bb - qi)),
)
print(qans)
| false
| 5.882353
|
[
"+import sys",
"+input = sys.stdin.readline"
] | false
| 0.036044
| 0.036464
| 0.988467
|
[
"s065029715",
"s678096319"
] |
u215286521
|
p02700
|
python
|
s144829882
|
s654938019
| 98
| 23
| 26,988
| 9,556
|
Accepted
|
Accepted
| 76.53
|
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S(): return eval(input())
def I(): return int(eval(input()))
def MS(): return list(map(str,input().split()))
def MI(): return list(map(int,input().split()))
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in eval(input())]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
A,B,C,D = MI()
t = A
a = C
for i in range(100):
a -= B
if a <= 0:
print("Yes")
exit()
t -= D
if t <= 0:
print("No")
exit()
|
from math import floor,ceil,sqrt,factorial,log
from collections import Counter, deque
from functools import reduce
# import numpy as np
def S(): return eval(input())
def I(): return int(eval(input()))
def MS(): return list(map(str,input().split()))
def MI(): return list(map(int,input().split()))
def FLI(): return [int(i) for i in input().split()]
def LS(): return list(MS())
def LI(): return list(MI())
def LLS(): return [list(map(str, l.split() )) for l in eval(input())]
def LLI(): return [list(map(int, l.split() )) for l in eval(input())]
def LLSN(n: int): return [LS() for _ in range(n)]
def LLIN(n: int): return [LI() for _ in range(n)]
A,B,C,D = MI()
x = -(-A//D)
y = -(-C//B)
if x >= y:
print("Yes")
else:
print("No")
# for i in range(100):
# a -= B
# if a <= 0:
# print("Yes")
# exit()
# t -= D
# if t <= 0:
# print("No")
# exit()
| 31
| 36
| 816
| 906
|
from math import floor, ceil, sqrt, factorial, log
from collections import Counter, deque
from functools import reduce
import numpy as np
def S():
return eval(input())
def I():
return int(eval(input()))
def MS():
return list(map(str, input().split()))
def MI():
return list(map(int, input().split()))
def FLI():
return [int(i) for i in input().split()]
def LS():
return list(MS())
def LI():
return list(MI())
def LLS():
return [list(map(str, l.split())) for l in eval(input())]
def LLI():
return [list(map(int, l.split())) for l in eval(input())]
def LLSN(n: int):
return [LS() for _ in range(n)]
def LLIN(n: int):
return [LI() for _ in range(n)]
A, B, C, D = MI()
t = A
a = C
for i in range(100):
a -= B
if a <= 0:
print("Yes")
exit()
t -= D
if t <= 0:
print("No")
exit()
|
from math import floor, ceil, sqrt, factorial, log
from collections import Counter, deque
from functools import reduce
# import numpy as np
def S():
return eval(input())
def I():
return int(eval(input()))
def MS():
return list(map(str, input().split()))
def MI():
return list(map(int, input().split()))
def FLI():
return [int(i) for i in input().split()]
def LS():
return list(MS())
def LI():
return list(MI())
def LLS():
return [list(map(str, l.split())) for l in eval(input())]
def LLI():
return [list(map(int, l.split())) for l in eval(input())]
def LLSN(n: int):
return [LS() for _ in range(n)]
def LLIN(n: int):
return [LI() for _ in range(n)]
A, B, C, D = MI()
x = -(-A // D)
y = -(-C // B)
if x >= y:
print("Yes")
else:
print("No")
# for i in range(100):
# a -= B
# if a <= 0:
# print("Yes")
# exit()
# t -= D
# if t <= 0:
# print("No")
# exit()
| false
| 13.888889
|
[
"-import numpy as np",
"-",
"+# import numpy as np",
"-t = A",
"-a = C",
"-for i in range(100):",
"- a -= B",
"- if a <= 0:",
"- print(\"Yes\")",
"- exit()",
"- t -= D",
"- if t <= 0:",
"- print(\"No\")",
"- exit()",
"+x = -(-A // D)",
"+y = -(-C // B)",
"+if x >= y:",
"+ print(\"Yes\")",
"+else:",
"+ print(\"No\")",
"+# for i in range(100):",
"+# a -= B",
"+# if a <= 0:",
"+# print(\"Yes\")",
"+# exit()",
"+# t -= D",
"+# if t <= 0:",
"+# print(\"No\")",
"+# exit()"
] | false
| 0.110119
| 0.034819
| 3.162571
|
[
"s144829882",
"s654938019"
] |
u123756661
|
p03999
|
python
|
s417952502
|
s003384804
| 43
| 20
| 2,692
| 3,060
|
Accepted
|
Accepted
| 53.49
|
s=input()
t=len(s)-1
tmp=2**t
ans=0
for i in range(tmp):
p=bin(i)[2:]
p='0'*(t-len(p))+p
x=''
for j,k in enumerate(s):
x+=k
if j!=t and p[j]=='1':
x+='+'
ans+=eval(x)
print(ans)
|
#!/usr/bin/env python3
s=eval(input())
ans=tmp=0
t=len(s)
for i in range(1<<(t-1)):
# print(i)
tmp=int(s[0])
for j in range(t-1):
if (i & (1<<j)):
tmp*=10
tmp+=int(s[j+1])
else:
ans+=tmp
tmp=int(s[j+1])
ans+=tmp
print(ans)
| 14
| 19
| 241
| 316
|
s = input()
t = len(s) - 1
tmp = 2**t
ans = 0
for i in range(tmp):
p = bin(i)[2:]
p = "0" * (t - len(p)) + p
x = ""
for j, k in enumerate(s):
x += k
if j != t and p[j] == "1":
x += "+"
ans += eval(x)
print(ans)
|
#!/usr/bin/env python3
s = eval(input())
ans = tmp = 0
t = len(s)
for i in range(1 << (t - 1)):
# print(i)
tmp = int(s[0])
for j in range(t - 1):
if i & (1 << j):
tmp *= 10
tmp += int(s[j + 1])
else:
ans += tmp
tmp = int(s[j + 1])
ans += tmp
print(ans)
| false
| 26.315789
|
[
"-s = input()",
"-t = len(s) - 1",
"-tmp = 2**t",
"-ans = 0",
"-for i in range(tmp):",
"- p = bin(i)[2:]",
"- p = \"0\" * (t - len(p)) + p",
"- x = \"\"",
"- for j, k in enumerate(s):",
"- x += k",
"- if j != t and p[j] == \"1\":",
"- x += \"+\"",
"- ans += eval(x)",
"+#!/usr/bin/env python3",
"+s = eval(input())",
"+ans = tmp = 0",
"+t = len(s)",
"+for i in range(1 << (t - 1)):",
"+ # print(i)",
"+ tmp = int(s[0])",
"+ for j in range(t - 1):",
"+ if i & (1 << j):",
"+ tmp *= 10",
"+ tmp += int(s[j + 1])",
"+ else:",
"+ ans += tmp",
"+ tmp = int(s[j + 1])",
"+ ans += tmp"
] | false
| 0.040534
| 0.077803
| 0.520977
|
[
"s417952502",
"s003384804"
] |
u729133443
|
p03088
|
python
|
s968410757
|
s869707114
| 308
| 70
| 52,700
| 3,316
|
Accepted
|
Accepted
| 77.27
|
n=int(eval(input()))
A,C,G,T,M=0,1,2,3,10**9+7
r=range
dp=[[[[0]*4for k in r(4)]for j in r(4)]for i in r(n+1)]
dp[0][T][T][T]=1
for i in r(1,n+1):
for j in r(4):
for k in r(4):
for l in r(4):
for m in r(4):
if any(t==(k,l,m)for t in((A,G,C),(A,C,G),(G,A,C)))or(j,l,m)==(A,G,C)or(j,k,m)==(A,G,C):continue
dp[i][k][l][m]=(dp[i][k][l][m]+dp[i-1][j][k][l])%M
print((sum(dp[n][i][j][k]for i in r(4)for j in r(4)for k in r(4))%M))
|
n=int(eval(input()))
A,C,G,T,M,R=0,1,2,3,10**9+7,list(range(4))
dp=[[[[0]*4for k in R]for j in R]for i in range(n+1)]
dp[0][T][T][T]=1
for i in range(1,n+1):
for j in R:
for k in R:
for l in R:
for m in R:
if not(any(t==(k,l,m)for t in((A,G,C),(A,C,G),(G,A,C)))or(j,l,m)==(A,G,C)or(j,k,m)==(A,G,C)):dp[i][k][l][m]=(dp[i][k][l][m]+dp[i-1][j][k][l])%M
print((sum(c for a in dp[n]for b in a for c in b)%M))
| 13
| 11
| 468
| 429
|
n = int(eval(input()))
A, C, G, T, M = 0, 1, 2, 3, 10**9 + 7
r = range
dp = [[[[0] * 4 for k in r(4)] for j in r(4)] for i in r(n + 1)]
dp[0][T][T][T] = 1
for i in r(1, n + 1):
for j in r(4):
for k in r(4):
for l in r(4):
for m in r(4):
if (
any(t == (k, l, m) for t in ((A, G, C), (A, C, G), (G, A, C)))
or (j, l, m) == (A, G, C)
or (j, k, m) == (A, G, C)
):
continue
dp[i][k][l][m] = (dp[i][k][l][m] + dp[i - 1][j][k][l]) % M
print((sum(dp[n][i][j][k] for i in r(4) for j in r(4) for k in r(4)) % M))
|
n = int(eval(input()))
A, C, G, T, M, R = 0, 1, 2, 3, 10**9 + 7, list(range(4))
dp = [[[[0] * 4 for k in R] for j in R] for i in range(n + 1)]
dp[0][T][T][T] = 1
for i in range(1, n + 1):
for j in R:
for k in R:
for l in R:
for m in R:
if not (
any(t == (k, l, m) for t in ((A, G, C), (A, C, G), (G, A, C)))
or (j, l, m) == (A, G, C)
or (j, k, m) == (A, G, C)
):
dp[i][k][l][m] = (dp[i][k][l][m] + dp[i - 1][j][k][l]) % M
print((sum(c for a in dp[n] for b in a for c in b) % M))
| false
| 15.384615
|
[
"-A, C, G, T, M = 0, 1, 2, 3, 10**9 + 7",
"-r = range",
"-dp = [[[[0] * 4 for k in r(4)] for j in r(4)] for i in r(n + 1)]",
"+A, C, G, T, M, R = 0, 1, 2, 3, 10**9 + 7, list(range(4))",
"+dp = [[[[0] * 4 for k in R] for j in R] for i in range(n + 1)]",
"-for i in r(1, n + 1):",
"- for j in r(4):",
"- for k in r(4):",
"- for l in r(4):",
"- for m in r(4):",
"- if (",
"+for i in range(1, n + 1):",
"+ for j in R:",
"+ for k in R:",
"+ for l in R:",
"+ for m in R:",
"+ if not (",
"- continue",
"- dp[i][k][l][m] = (dp[i][k][l][m] + dp[i - 1][j][k][l]) % M",
"-print((sum(dp[n][i][j][k] for i in r(4) for j in r(4) for k in r(4)) % M))",
"+ dp[i][k][l][m] = (dp[i][k][l][m] + dp[i - 1][j][k][l]) % M",
"+print((sum(c for a in dp[n] for b in a for c in b) % M))"
] | false
| 0.191094
| 0.084648
| 2.257497
|
[
"s968410757",
"s869707114"
] |
u724687935
|
p02555
|
python
|
s806569708
|
s975843851
| 64
| 27
| 63,916
| 9,144
|
Accepted
|
Accepted
| 57.81
|
MOD = 10 ** 9 + 7
S = int(eval(input()))
dp = [0] * (S + 1)
dp[0] = 1
for i in range(3, S + 1):
if i >= 1:
dp[i] += dp[i - 1]
if i >= 3:
dp[i] += dp[i - 3]
dp[i] %= MOD
print((dp[S]))
|
MOD = 10 ** 9 + 7
def prepare(n):
global MOD
modFacts = [0] * (n + 1)
modFacts[0] = 1
for i in range(n):
modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD
invs = [1] * (n + 1)
invs[n] = pow(modFacts[n], MOD - 2, MOD)
for i in range(n, 1, -1):
invs[i - 1] = (invs[i] * i) % MOD
return modFacts, invs
def comb(n, r):
global MOD, modFacts, invs
return (modFacts[n] * invs[n - r] * invs[r]) % MOD
def perm(n, r):
global MOD, modFacts, invs
return (modFacts[n] * invs[n - r]) % MOD
S = int(eval(input()))
modFacts, invs = prepare(S)
ans = 0
for k in range(1, S // 3 + 1):
s = S - 3 * k
cnt = comb(k - 1 + s, s)
ans += cnt
ans %= MOD
print(ans)
| 12
| 37
| 216
| 757
|
MOD = 10**9 + 7
S = int(eval(input()))
dp = [0] * (S + 1)
dp[0] = 1
for i in range(3, S + 1):
if i >= 1:
dp[i] += dp[i - 1]
if i >= 3:
dp[i] += dp[i - 3]
dp[i] %= MOD
print((dp[S]))
|
MOD = 10**9 + 7
def prepare(n):
global MOD
modFacts = [0] * (n + 1)
modFacts[0] = 1
for i in range(n):
modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD
invs = [1] * (n + 1)
invs[n] = pow(modFacts[n], MOD - 2, MOD)
for i in range(n, 1, -1):
invs[i - 1] = (invs[i] * i) % MOD
return modFacts, invs
def comb(n, r):
global MOD, modFacts, invs
return (modFacts[n] * invs[n - r] * invs[r]) % MOD
def perm(n, r):
global MOD, modFacts, invs
return (modFacts[n] * invs[n - r]) % MOD
S = int(eval(input()))
modFacts, invs = prepare(S)
ans = 0
for k in range(1, S // 3 + 1):
s = S - 3 * k
cnt = comb(k - 1 + s, s)
ans += cnt
ans %= MOD
print(ans)
| false
| 67.567568
|
[
"+",
"+",
"+def prepare(n):",
"+ global MOD",
"+ modFacts = [0] * (n + 1)",
"+ modFacts[0] = 1",
"+ for i in range(n):",
"+ modFacts[i + 1] = (modFacts[i] * (i + 1)) % MOD",
"+ invs = [1] * (n + 1)",
"+ invs[n] = pow(modFacts[n], MOD - 2, MOD)",
"+ for i in range(n, 1, -1):",
"+ invs[i - 1] = (invs[i] * i) % MOD",
"+ return modFacts, invs",
"+",
"+",
"+def comb(n, r):",
"+ global MOD, modFacts, invs",
"+ return (modFacts[n] * invs[n - r] * invs[r]) % MOD",
"+",
"+",
"+def perm(n, r):",
"+ global MOD, modFacts, invs",
"+ return (modFacts[n] * invs[n - r]) % MOD",
"+",
"+",
"-dp = [0] * (S + 1)",
"-dp[0] = 1",
"-for i in range(3, S + 1):",
"- if i >= 1:",
"- dp[i] += dp[i - 1]",
"- if i >= 3:",
"- dp[i] += dp[i - 3]",
"- dp[i] %= MOD",
"-print((dp[S]))",
"+modFacts, invs = prepare(S)",
"+ans = 0",
"+for k in range(1, S // 3 + 1):",
"+ s = S - 3 * k",
"+ cnt = comb(k - 1 + s, s)",
"+ ans += cnt",
"+ ans %= MOD",
"+print(ans)"
] | false
| 0.037928
| 0.037611
| 1.008425
|
[
"s806569708",
"s975843851"
] |
u936985471
|
p03274
|
python
|
s470579986
|
s498030381
| 94
| 83
| 14,384
| 15,020
|
Accepted
|
Accepted
| 11.7
|
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
def culclen(l,r):
if X[l]*X[r]>=0:
return max(abs(X[l]),abs(X[r]))
else:
ldis=abs(X[l])
rdis=abs(X[r])
return min(ldis,rdis)*2+max(ldis,rdis)
ans=10**9
for x in range(len(X)-K+1):
ans=min(ans,culclen(x,x+K-1))
print(ans)
|
N,K=list(map(int,input().split()))
X=list(map(int,input().split()))
def culclen(l,r):
return abs(X[r]-X[l])+min(abs(X[l]),abs(X[r]))
ans=10**9
for x in range(len(X)-K+1):
ans=min(ans,culclen(x,x+K-1))
print(ans)
| 15
| 10
| 321
| 221
|
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
def culclen(l, r):
if X[l] * X[r] >= 0:
return max(abs(X[l]), abs(X[r]))
else:
ldis = abs(X[l])
rdis = abs(X[r])
return min(ldis, rdis) * 2 + max(ldis, rdis)
ans = 10**9
for x in range(len(X) - K + 1):
ans = min(ans, culclen(x, x + K - 1))
print(ans)
|
N, K = list(map(int, input().split()))
X = list(map(int, input().split()))
def culclen(l, r):
return abs(X[r] - X[l]) + min(abs(X[l]), abs(X[r]))
ans = 10**9
for x in range(len(X) - K + 1):
ans = min(ans, culclen(x, x + K - 1))
print(ans)
| false
| 33.333333
|
[
"- if X[l] * X[r] >= 0:",
"- return max(abs(X[l]), abs(X[r]))",
"- else:",
"- ldis = abs(X[l])",
"- rdis = abs(X[r])",
"- return min(ldis, rdis) * 2 + max(ldis, rdis)",
"+ return abs(X[r] - X[l]) + min(abs(X[l]), abs(X[r]))"
] | false
| 0.037857
| 0.046783
| 0.809204
|
[
"s470579986",
"s498030381"
] |
u119148115
|
p02580
|
python
|
s093994339
|
s586537359
| 522
| 468
| 213,620
| 167,916
|
Accepted
|
Accepted
| 10.34
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
H,W,M = MI()
hw = [tuple(MI()) for _ in range(M)]
A = [0]*(H+1)
B = [0]*(W+1)
from collections import defaultdict
d = defaultdict(int)
for h,w in hw:
A[h] += 1
B[w] += 1
d[(h,w)] = 1
ma = max(A)
mb = max(B)
ans = ma+mb
C,D = [],[]
for i in range(1,H+1):
if A[i] == ma:
C.append(i)
for i in range(1,W+1):
if B[i] == mb:
D.append(i)
if len(C)*len(D) > M:
print(ans)
else:
for i in C:
for j in D:
if d[(i,j)] == 0:
print(ans)
exit()
print((ans-1))
|
import sys
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
H,W,M = MI()
X = [0]*(H+1) # X[i] = x座標がiである爆破対象はいくつあるか
Y = [0]*(W+1) # Y[i] = y座標がiである爆破対象はいくつあるか
from collections import defaultdict
d = defaultdict(int) # d[(h,w)] == 1 ⇔ 座標(h,w)に爆破対象が存在する
for i in range(M):
h,w = MI()
X[h] += 1
Y[w] += 1
d[(h,w)] = 1
mx = max(X)
my = max(Y)
ans = mx+my
A = [i for i in range(1,H+1) if X[i] == mx]
B = [i for i in range(1,W+1) if Y[i] == my]
if len(A)*len(B) > M:
print(ans)
else:
for i in A:
for j in B:
if d[(i,j)] == 0:
print(ans)
exit()
print((ans-1))
| 44
| 32
| 1,069
| 686
|
import sys
sys.setrecursionlimit(10**7)
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def LI2():
return list(map(int, sys.stdin.readline().rstrip())) # 空白なし
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split()) # 空白あり
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
H, W, M = MI()
hw = [tuple(MI()) for _ in range(M)]
A = [0] * (H + 1)
B = [0] * (W + 1)
from collections import defaultdict
d = defaultdict(int)
for h, w in hw:
A[h] += 1
B[w] += 1
d[(h, w)] = 1
ma = max(A)
mb = max(B)
ans = ma + mb
C, D = [], []
for i in range(1, H + 1):
if A[i] == ma:
C.append(i)
for i in range(1, W + 1):
if B[i] == mb:
D.append(i)
if len(C) * len(D) > M:
print(ans)
else:
for i in C:
for j in D:
if d[(i, j)] == 0:
print(ans)
exit()
print((ans - 1))
|
import sys
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
H, W, M = MI()
X = [0] * (H + 1) # X[i] = x座標がiである爆破対象はいくつあるか
Y = [0] * (W + 1) # Y[i] = y座標がiである爆破対象はいくつあるか
from collections import defaultdict
d = defaultdict(int) # d[(h,w)] == 1 ⇔ 座標(h,w)に爆破対象が存在する
for i in range(M):
h, w = MI()
X[h] += 1
Y[w] += 1
d[(h, w)] = 1
mx = max(X)
my = max(Y)
ans = mx + my
A = [i for i in range(1, H + 1) if X[i] == mx]
B = [i for i in range(1, W + 1) if Y[i] == my]
if len(A) * len(B) > M:
print(ans)
else:
for i in A:
for j in B:
if d[(i, j)] == 0:
print(ans)
exit()
print((ans - 1))
| false
| 27.272727
|
[
"-",
"-sys.setrecursionlimit(10**7)",
"-",
"-",
"-def I():",
"- return int(sys.stdin.readline().rstrip())",
"-def LI():",
"- return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり",
"-",
"-",
"-def LI2():",
"- return list(map(int, sys.stdin.readline().rstrip())) # 空白なし",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def LS():",
"- return list(sys.stdin.readline().rstrip().split()) # 空白あり",
"-",
"-",
"-def LS2():",
"- return list(sys.stdin.readline().rstrip()) # 空白なし",
"-",
"-",
"-hw = [tuple(MI()) for _ in range(M)]",
"-A = [0] * (H + 1)",
"-B = [0] * (W + 1)",
"+X = [0] * (H + 1) # X[i] = x座標がiである爆破対象はいくつあるか",
"+Y = [0] * (W + 1) # Y[i] = y座標がiである爆破対象はいくつあるか",
"-d = defaultdict(int)",
"-for h, w in hw:",
"- A[h] += 1",
"- B[w] += 1",
"+d = defaultdict(int) # d[(h,w)] == 1 ⇔ 座標(h,w)に爆破対象が存在する",
"+for i in range(M):",
"+ h, w = MI()",
"+ X[h] += 1",
"+ Y[w] += 1",
"-ma = max(A)",
"-mb = max(B)",
"-ans = ma + mb",
"-C, D = [], []",
"-for i in range(1, H + 1):",
"- if A[i] == ma:",
"- C.append(i)",
"-for i in range(1, W + 1):",
"- if B[i] == mb:",
"- D.append(i)",
"-if len(C) * len(D) > M:",
"+mx = max(X)",
"+my = max(Y)",
"+ans = mx + my",
"+A = [i for i in range(1, H + 1) if X[i] == mx]",
"+B = [i for i in range(1, W + 1) if Y[i] == my]",
"+if len(A) * len(B) > M:",
"- for i in C:",
"- for j in D:",
"+ for i in A:",
"+ for j in B:"
] | false
| 0.037063
| 0.043361
| 0.854765
|
[
"s093994339",
"s586537359"
] |
u077291787
|
p03524
|
python
|
s457861506
|
s895886806
| 26
| 19
| 3,436
| 3,188
|
Accepted
|
Accepted
| 26.92
|
# cf17-finalB - Palindrome-phobia
from collections import Counter
def main():
S = input().rstrip()
C = list(Counter(S).values())
flg = [len(C) == 1 and sum(C) == 1] # e.g. "a"
flg += [len(C) == 2 and sum(C) == 2] # "ab"
flg += [len(C) == 3 and max(C) - min(C) <= 1] # "abcab"
print(("YES" if any(flg) else "NO"))
if __name__ == "__main__":
main()
|
# cf17-finalB - Palindrome-phobia
def main():
S = input().rstrip()
C = [S.count(i) for i in "abc"]
flg = max(C) - min(C) <= 1
print(("YES" if flg else "NO"))
if __name__ == "__main__":
main()
| 15
| 10
| 387
| 220
|
# cf17-finalB - Palindrome-phobia
from collections import Counter
def main():
S = input().rstrip()
C = list(Counter(S).values())
flg = [len(C) == 1 and sum(C) == 1] # e.g. "a"
flg += [len(C) == 2 and sum(C) == 2] # "ab"
flg += [len(C) == 3 and max(C) - min(C) <= 1] # "abcab"
print(("YES" if any(flg) else "NO"))
if __name__ == "__main__":
main()
|
# cf17-finalB - Palindrome-phobia
def main():
S = input().rstrip()
C = [S.count(i) for i in "abc"]
flg = max(C) - min(C) <= 1
print(("YES" if flg else "NO"))
if __name__ == "__main__":
main()
| false
| 33.333333
|
[
"-from collections import Counter",
"-",
"-",
"- C = list(Counter(S).values())",
"- flg = [len(C) == 1 and sum(C) == 1] # e.g. \"a\"",
"- flg += [len(C) == 2 and sum(C) == 2] # \"ab\"",
"- flg += [len(C) == 3 and max(C) - min(C) <= 1] # \"abcab\"",
"- print((\"YES\" if any(flg) else \"NO\"))",
"+ C = [S.count(i) for i in \"abc\"]",
"+ flg = max(C) - min(C) <= 1",
"+ print((\"YES\" if flg else \"NO\"))"
] | false
| 0.03948
| 0.038902
| 1.014862
|
[
"s457861506",
"s895886806"
] |
u117193815
|
p02819
|
python
|
s635919999
|
s563523738
| 320
| 274
| 3,064
| 3,060
|
Accepted
|
Accepted
| 14.37
|
x=int(eval(input()))
cont=0
for i in range(x,10**12):
for j in range(2,i):
if i%j==0:
cont+=1
if cont==0:
print(i)
exit()
cont=0
|
x=int(eval(input()))
j=x
while True:
cnt=0
for i in range(2,j+1):
if j%i==0:
cnt+=1
if cnt==1:
print(j)
exit()
else:
j+=1
| 10
| 12
| 181
| 186
|
x = int(eval(input()))
cont = 0
for i in range(x, 10**12):
for j in range(2, i):
if i % j == 0:
cont += 1
if cont == 0:
print(i)
exit()
cont = 0
|
x = int(eval(input()))
j = x
while True:
cnt = 0
for i in range(2, j + 1):
if j % i == 0:
cnt += 1
if cnt == 1:
print(j)
exit()
else:
j += 1
| false
| 16.666667
|
[
"-cont = 0",
"-for i in range(x, 10**12):",
"- for j in range(2, i):",
"- if i % j == 0:",
"- cont += 1",
"- if cont == 0:",
"- print(i)",
"+j = x",
"+while True:",
"+ cnt = 0",
"+ for i in range(2, j + 1):",
"+ if j % i == 0:",
"+ cnt += 1",
"+ if cnt == 1:",
"+ print(j)",
"- cont = 0",
"+ else:",
"+ j += 1"
] | false
| 0.053401
| 0.050522
| 1.056977
|
[
"s635919999",
"s563523738"
] |
u671060652
|
p03207
|
python
|
s608417123
|
s827706749
| 269
| 81
| 63,980
| 61,464
|
Accepted
|
Accepted
| 69.89
|
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
p = []
for i in range(n):
p.append(int(eval(input())))
print((sum(p)-max(p)//2))
|
def main():
n = int(eval(input()))
# t, a = map(int, input().split())
# h = list(map(int, input().split()))
# s = input()
p = []
for i in range(n):
p.append(int(eval(input())))
maxi = max(p)
print((sum(p) - maxi//2))
if __name__ == '__main__':
main()
| 12
| 17
| 181
| 306
|
import itertools
import math
import fractions
import functools
import copy
n = int(eval(input()))
p = []
for i in range(n):
p.append(int(eval(input())))
print((sum(p) - max(p) // 2))
|
def main():
n = int(eval(input()))
# t, a = map(int, input().split())
# h = list(map(int, input().split()))
# s = input()
p = []
for i in range(n):
p.append(int(eval(input())))
maxi = max(p)
print((sum(p) - maxi // 2))
if __name__ == "__main__":
main()
| false
| 29.411765
|
[
"-import itertools",
"-import math",
"-import fractions",
"-import functools",
"-import copy",
"+def main():",
"+ n = int(eval(input()))",
"+ # t, a = map(int, input().split())",
"+ # h = list(map(int, input().split()))",
"+ # s = input()",
"+ p = []",
"+ for i in range(n):",
"+ p.append(int(eval(input())))",
"+ maxi = max(p)",
"+ print((sum(p) - maxi // 2))",
"-n = int(eval(input()))",
"-p = []",
"-for i in range(n):",
"- p.append(int(eval(input())))",
"-print((sum(p) - max(p) // 2))",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.08398
| 0.067593
| 1.242432
|
[
"s608417123",
"s827706749"
] |
u690536347
|
p02975
|
python
|
s228440919
|
s495312257
| 59
| 53
| 14,468
| 14,468
|
Accepted
|
Accepted
| 10.17
|
from collections import Counter
N = int(eval(input()))
*a, = list(map(int, input().split()))
c = Counter(a)
used = set(c.keys())
size = len(used)
def check():
if 0 in used:
if size==1 or (size==2 and c[0]==N//3):
return True
elif size==3:
s, t, u = used
if s^t^u==0 and c[s]==c[t]==c[u]:
return True
return False
print(("Yes" if check() else "No"))
|
from collections import Counter
N = int(eval(input()))
*a, = list(map(int, input().split()))
c = Counter(a)
b = len(list(c.keys()))
def check():
if 0 in list(c.keys()):
if b==1 or (b==2 and c[0]==N//3):
return True
elif b==3:
s, t, u = list(c.keys())
if s^t^u==0 and c[s]==c[t]==c[u]:
return True
return False
print(("Yes" if check() else "No"))
| 19
| 18
| 415
| 393
|
from collections import Counter
N = int(eval(input()))
(*a,) = list(map(int, input().split()))
c = Counter(a)
used = set(c.keys())
size = len(used)
def check():
if 0 in used:
if size == 1 or (size == 2 and c[0] == N // 3):
return True
elif size == 3:
s, t, u = used
if s ^ t ^ u == 0 and c[s] == c[t] == c[u]:
return True
return False
print(("Yes" if check() else "No"))
|
from collections import Counter
N = int(eval(input()))
(*a,) = list(map(int, input().split()))
c = Counter(a)
b = len(list(c.keys()))
def check():
if 0 in list(c.keys()):
if b == 1 or (b == 2 and c[0] == N // 3):
return True
elif b == 3:
s, t, u = list(c.keys())
if s ^ t ^ u == 0 and c[s] == c[t] == c[u]:
return True
return False
print(("Yes" if check() else "No"))
| false
| 5.263158
|
[
"-used = set(c.keys())",
"-size = len(used)",
"+b = len(list(c.keys()))",
"- if 0 in used:",
"- if size == 1 or (size == 2 and c[0] == N // 3):",
"+ if 0 in list(c.keys()):",
"+ if b == 1 or (b == 2 and c[0] == N // 3):",
"- elif size == 3:",
"- s, t, u = used",
"+ elif b == 3:",
"+ s, t, u = list(c.keys())"
] | false
| 0.032631
| 0.040928
| 0.797278
|
[
"s228440919",
"s495312257"
] |
u644907318
|
p03013
|
python
|
s384405611
|
s083263853
| 492
| 185
| 51,180
| 87,692
|
Accepted
|
Accepted
| 62.4
|
p = 10**9+7
N,M = list(map(int,input().split()))
A = [0 for _ in range(N+1)]
for _ in range(M):
i = int(eval(input()))
A[i] = 1
dp = [0 for _ in range(N+1)]
dp[0] = 1
for i in range(1,N+1):
if A[i]==0:
dp[i] = dp[i-1]
if i>=2:
dp[i] = (dp[i]+dp[i-2])%p
print((dp[N]))
|
p = 10**9+7
N,M = list(map(int,input().split()))
A = {i:0 for i in range(N+1)}
for _ in range(M):
A[int(eval(input()))] = 1
dp = [0 for _ in range(N+1)]
dp[N] = 1
for i in range(N-1,-1,-1):
if A[i]==1:continue
if A[i+1]==0:
dp[i] = dp[i+1]
if i+2<=N and A[i+2]==0:
dp[i] = (dp[i]+dp[i+2])%p
print((dp[0]))
| 14
| 14
| 306
| 336
|
p = 10**9 + 7
N, M = list(map(int, input().split()))
A = [0 for _ in range(N + 1)]
for _ in range(M):
i = int(eval(input()))
A[i] = 1
dp = [0 for _ in range(N + 1)]
dp[0] = 1
for i in range(1, N + 1):
if A[i] == 0:
dp[i] = dp[i - 1]
if i >= 2:
dp[i] = (dp[i] + dp[i - 2]) % p
print((dp[N]))
|
p = 10**9 + 7
N, M = list(map(int, input().split()))
A = {i: 0 for i in range(N + 1)}
for _ in range(M):
A[int(eval(input()))] = 1
dp = [0 for _ in range(N + 1)]
dp[N] = 1
for i in range(N - 1, -1, -1):
if A[i] == 1:
continue
if A[i + 1] == 0:
dp[i] = dp[i + 1]
if i + 2 <= N and A[i + 2] == 0:
dp[i] = (dp[i] + dp[i + 2]) % p
print((dp[0]))
| false
| 0
|
[
"-A = [0 for _ in range(N + 1)]",
"+A = {i: 0 for i in range(N + 1)}",
"- i = int(eval(input()))",
"- A[i] = 1",
"+ A[int(eval(input()))] = 1",
"-dp[0] = 1",
"-for i in range(1, N + 1):",
"- if A[i] == 0:",
"- dp[i] = dp[i - 1]",
"- if i >= 2:",
"- dp[i] = (dp[i] + dp[i - 2]) % p",
"-print((dp[N]))",
"+dp[N] = 1",
"+for i in range(N - 1, -1, -1):",
"+ if A[i] == 1:",
"+ continue",
"+ if A[i + 1] == 0:",
"+ dp[i] = dp[i + 1]",
"+ if i + 2 <= N and A[i + 2] == 0:",
"+ dp[i] = (dp[i] + dp[i + 2]) % p",
"+print((dp[0]))"
] | false
| 0.034203
| 0.03312
| 1.032709
|
[
"s384405611",
"s083263853"
] |
u994521204
|
p02715
|
python
|
s245203526
|
s167473042
| 510
| 92
| 11,236
| 69,104
|
Accepted
|
Accepted
| 81.96
|
# 解説AC
mod = 10 ** 9 + 7
n, k = list(map(int, input().split()))
dp = [-1] * (k + 1)
ans = 0
for i in range(k, 0, -1):
dp[i] = pow(k // i, n, mod)
t = 0
t += 2 * i
while t <= k:
dp[i] -= dp[t]
dp[i] %= mod
t += i
ans += i * dp[i]
ans %= mod
print(ans)
|
n, k = list(map(int, input().split()))
mod = 10 ** 9 + 7
dp = [0] * (k + 1)
ans = 0
for i in range(k, 0, -1):
num = k // i
dp[i] += pow(num, n, mod)
for j in range(1, num):
dp[i] -= dp[(j + 1) * i]
ans += i * dp[i]
ans %= mod
print(ans)
| 16
| 13
| 308
| 272
|
# 解説AC
mod = 10**9 + 7
n, k = list(map(int, input().split()))
dp = [-1] * (k + 1)
ans = 0
for i in range(k, 0, -1):
dp[i] = pow(k // i, n, mod)
t = 0
t += 2 * i
while t <= k:
dp[i] -= dp[t]
dp[i] %= mod
t += i
ans += i * dp[i]
ans %= mod
print(ans)
|
n, k = list(map(int, input().split()))
mod = 10**9 + 7
dp = [0] * (k + 1)
ans = 0
for i in range(k, 0, -1):
num = k // i
dp[i] += pow(num, n, mod)
for j in range(1, num):
dp[i] -= dp[(j + 1) * i]
ans += i * dp[i]
ans %= mod
print(ans)
| false
| 18.75
|
[
"-# 解説AC",
"+n, k = list(map(int, input().split()))",
"-n, k = list(map(int, input().split()))",
"-dp = [-1] * (k + 1)",
"+dp = [0] * (k + 1)",
"- dp[i] = pow(k // i, n, mod)",
"- t = 0",
"- t += 2 * i",
"- while t <= k:",
"- dp[i] -= dp[t]",
"- dp[i] %= mod",
"- t += i",
"+ num = k // i",
"+ dp[i] += pow(num, n, mod)",
"+ for j in range(1, num):",
"+ dp[i] -= dp[(j + 1) * i]"
] | false
| 0.26827
| 0.368653
| 0.727705
|
[
"s245203526",
"s167473042"
] |
u347640436
|
p02701
|
python
|
s070222702
|
s504229583
| 303
| 260
| 35,272
| 30,984
|
Accepted
|
Accepted
| 14.19
|
N = int(eval(input()))
d = {}
for _ in range(N):
S = eval(input())
d.setdefault(S, 0)
d[S] += 1
print((len(list(d.keys()))))
|
N = int(eval(input()))
print((len(set(eval(input()) for _ in range(N)))))
| 8
| 3
| 125
| 63
|
N = int(eval(input()))
d = {}
for _ in range(N):
S = eval(input())
d.setdefault(S, 0)
d[S] += 1
print((len(list(d.keys()))))
|
N = int(eval(input()))
print((len(set(eval(input()) for _ in range(N)))))
| false
| 62.5
|
[
"-d = {}",
"-for _ in range(N):",
"- S = eval(input())",
"- d.setdefault(S, 0)",
"- d[S] += 1",
"-print((len(list(d.keys()))))",
"+print((len(set(eval(input()) for _ in range(N)))))"
] | false
| 0.045822
| 0.046508
| 0.985264
|
[
"s070222702",
"s504229583"
] |
u556594202
|
p03455
|
python
|
s336141719
|
s687401158
| 28
| 23
| 8,988
| 9,064
|
Accepted
|
Accepted
| 17.86
|
a,b = list(map(int,input().split()))
print(("Even" if a*b%2==0 else "Odd"))
|
a,b=list(map(int,input().split()))
print(("Odd" if a*b%2 else "Even"))
| 2
| 2
| 74
| 63
|
a, b = list(map(int, input().split()))
print(("Even" if a * b % 2 == 0 else "Odd"))
|
a, b = list(map(int, input().split()))
print(("Odd" if a * b % 2 else "Even"))
| false
| 0
|
[
"-print((\"Even\" if a * b % 2 == 0 else \"Odd\"))",
"+print((\"Odd\" if a * b % 2 else \"Even\"))"
] | false
| 0.038315
| 0.121527
| 0.315277
|
[
"s336141719",
"s687401158"
] |
u561083515
|
p02972
|
python
|
s136432159
|
s051875349
| 539
| 336
| 14,140
| 70,108
|
Accepted
|
Accepted
| 37.66
|
def main():
N = int(input())
A = [int(i) for i in input().split()]
box = [0] * N
for i in range(N - 1, -1, -1):
# ボールの総数
cnt = 0
# (i + 1)の倍数
num = i + 1
while num <= N:
cnt += box[num - 1]
num += (i + 1)
if cnt % 2 != A[i]:
box[i] = 1
ans = [idx + 1 for idx in range(N) if box[idx]]
print(len(ans))
if ans:
print(*ans, sep=" ")
if __name__ == "__main__":
main()
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
box = [0] * N
for i in range(N - 1, -1, -1):
cnt = 0
num = i + 1
while num <= N:
cnt += box[num - 1]
num += i + 1
if cnt % 2 != A[i]:
box[i] = 1
ans = [idx + 1 for idx in range(N) if box[idx]]
print((len(ans)))
print((*ans))
| 25
| 18
| 523
| 344
|
def main():
N = int(input())
A = [int(i) for i in input().split()]
box = [0] * N
for i in range(N - 1, -1, -1):
# ボールの総数
cnt = 0
# (i + 1)の倍数
num = i + 1
while num <= N:
cnt += box[num - 1]
num += i + 1
if cnt % 2 != A[i]:
box[i] = 1
ans = [idx + 1 for idx in range(N) if box[idx]]
print(len(ans))
if ans:
print(*ans, sep=" ")
if __name__ == "__main__":
main()
|
N = int(eval(input()))
A = [int(i) for i in input().split()]
box = [0] * N
for i in range(N - 1, -1, -1):
cnt = 0
num = i + 1
while num <= N:
cnt += box[num - 1]
num += i + 1
if cnt % 2 != A[i]:
box[i] = 1
ans = [idx + 1 for idx in range(N) if box[idx]]
print((len(ans)))
print((*ans))
| false
| 28
|
[
"-def main():",
"- N = int(input())",
"- A = [int(i) for i in input().split()]",
"- box = [0] * N",
"- for i in range(N - 1, -1, -1):",
"- # ボールの総数",
"- cnt = 0",
"- # (i + 1)の倍数",
"- num = i + 1",
"- while num <= N:",
"- cnt += box[num - 1]",
"- num += i + 1",
"- if cnt % 2 != A[i]:",
"- box[i] = 1",
"- ans = [idx + 1 for idx in range(N) if box[idx]]",
"- print(len(ans))",
"- if ans:",
"- print(*ans, sep=\" \")",
"-",
"-",
"-if __name__ == \"__main__\":",
"- main()",
"+N = int(eval(input()))",
"+A = [int(i) for i in input().split()]",
"+box = [0] * N",
"+for i in range(N - 1, -1, -1):",
"+ cnt = 0",
"+ num = i + 1",
"+ while num <= N:",
"+ cnt += box[num - 1]",
"+ num += i + 1",
"+ if cnt % 2 != A[i]:",
"+ box[i] = 1",
"+ans = [idx + 1 for idx in range(N) if box[idx]]",
"+print((len(ans)))",
"+print((*ans))"
] | false
| 0.037243
| 0.034858
| 1.068395
|
[
"s136432159",
"s051875349"
] |
u631025015
|
p02713
|
python
|
s564243533
|
s006689515
| 454
| 390
| 9,204
| 9,212
|
Accepted
|
Accepted
| 14.1
|
def gcd(a, b):
while b != 0 :
t = a % b
a = b
b = t
return a
sum = 0
N=int(eval(input("")))
for a in range(1, N + 1):
for b in range(1, N + 1):
x = gcd(a, b)
if x == 1:
sum = sum + N
elif x == 2:
sum = sum + (N + 1) // 2 + N // 2 * 2
elif x == 3:
sum = sum + N // 3 * 3 + (N - N // 3)
else:
for c in range(1, N + 1):
sum = sum + gcd(x, c)
print(sum)
|
def gcd(a, b):
while b != 0 :
t = a % b
a = b
b = t
return a
sum = 0
N=int(eval(input("")))
for a in range(1, N + 1):
for b in range(1, N + 1):
x = gcd(a, b)
if x == 1:
sum = sum + N
elif x == 2:
sum = sum + (N + 1) // 2 + N // 2 * 2
elif x == 3:
sum = sum + N // 3 * 3 + (N - N // 3)
elif x == 5:
sum = sum + N // 5 * 5 + (N - N // 5)
else:
for c in range(1, N + 1):
sum = sum + gcd(x, c)
print(sum)
| 22
| 24
| 513
| 586
|
def gcd(a, b):
while b != 0:
t = a % b
a = b
b = t
return a
sum = 0
N = int(eval(input("")))
for a in range(1, N + 1):
for b in range(1, N + 1):
x = gcd(a, b)
if x == 1:
sum = sum + N
elif x == 2:
sum = sum + (N + 1) // 2 + N // 2 * 2
elif x == 3:
sum = sum + N // 3 * 3 + (N - N // 3)
else:
for c in range(1, N + 1):
sum = sum + gcd(x, c)
print(sum)
|
def gcd(a, b):
while b != 0:
t = a % b
a = b
b = t
return a
sum = 0
N = int(eval(input("")))
for a in range(1, N + 1):
for b in range(1, N + 1):
x = gcd(a, b)
if x == 1:
sum = sum + N
elif x == 2:
sum = sum + (N + 1) // 2 + N // 2 * 2
elif x == 3:
sum = sum + N // 3 * 3 + (N - N // 3)
elif x == 5:
sum = sum + N // 5 * 5 + (N - N // 5)
else:
for c in range(1, N + 1):
sum = sum + gcd(x, c)
print(sum)
| false
| 8.333333
|
[
"+ elif x == 5:",
"+ sum = sum + N // 5 * 5 + (N - N // 5)"
] | false
| 0.078614
| 0.159266
| 0.493599
|
[
"s564243533",
"s006689515"
] |
u820351940
|
p03168
|
python
|
s035750675
|
s081206915
| 1,954
| 958
| 219,656
| 237,576
|
Accepted
|
Accepted
| 50.97
|
import sys
sys.setrecursionlimit(10 ** 6)
import functools
import operator
n = int(eval(input()))
p = list(map(float, input().split()))
half = n // 2 + 1
dp = [[None] * (n + 1) for _ in range(n + 1)]
def dfs(n=half, depth=n - 1):
if depth < 0:
return 0
if dp[n][depth] is not None:
return dp[n][depth]
if n == 0:
r = functools.reduce(operator.mul, [1 - x for x in p[:depth + 1]])
elif (n - 1) == depth:
r = functools.reduce(operator.mul, p[:depth + 1])
else:
r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])
dp[n][depth] = r
return r
print((sum(dfs(i) for i in range(half, n + 1))))
|
import sys
sys.setrecursionlimit(10 ** 6)
import functools
import operator
n = int(eval(input()))
p = list(map(float, input().split()))
half = n // 2 + 1
dp = [[None] * (n + 1) for _ in range(n + 1)]
# def dfs(n, depth=n - 1):
# if depth < 0:
# return 0
#
# if dp[n][depth] is not None:
# return dp[n][depth]
#
# if n == 0:
# r = functools.reduce(operator.mul, map(lambda x: 1 - x, p[:depth + 1]))
# elif (n - 1) == depth:
# r = functools.reduce(operator.mul, p[:depth + 1])
# else:
# r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])
# dp[n][depth] = r
# return r
#
# print(sum(dfs(i) for i in range(half, n + 1)))
for i in range(0, n + 1):
for depth in range(-1, n):
if depth == -1:
dp[i][depth] = 0
elif i == 0:
dp[i][depth] = functools.reduce(operator.mul, [1 - x for x in p[:depth + 1]])
elif (i - 1) == depth:
dp[i][depth] = functools.reduce(operator.mul, p[:depth + 1])
else:
dp[i][depth] = dp[i - 1][depth - 1] * p[depth] + dp[i][depth - 1] * (1 - p[depth])
print((sum(dp[i][n - 1] for i in range(half, n + 1))))
| 27
| 40
| 704
| 1,237
|
import sys
sys.setrecursionlimit(10**6)
import functools
import operator
n = int(eval(input()))
p = list(map(float, input().split()))
half = n // 2 + 1
dp = [[None] * (n + 1) for _ in range(n + 1)]
def dfs(n=half, depth=n - 1):
if depth < 0:
return 0
if dp[n][depth] is not None:
return dp[n][depth]
if n == 0:
r = functools.reduce(operator.mul, [1 - x for x in p[: depth + 1]])
elif (n - 1) == depth:
r = functools.reduce(operator.mul, p[: depth + 1])
else:
r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])
dp[n][depth] = r
return r
print((sum(dfs(i) for i in range(half, n + 1))))
|
import sys
sys.setrecursionlimit(10**6)
import functools
import operator
n = int(eval(input()))
p = list(map(float, input().split()))
half = n // 2 + 1
dp = [[None] * (n + 1) for _ in range(n + 1)]
# def dfs(n, depth=n - 1):
# if depth < 0:
# return 0
#
# if dp[n][depth] is not None:
# return dp[n][depth]
#
# if n == 0:
# r = functools.reduce(operator.mul, map(lambda x: 1 - x, p[:depth + 1]))
# elif (n - 1) == depth:
# r = functools.reduce(operator.mul, p[:depth + 1])
# else:
# r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])
# dp[n][depth] = r
# return r
#
# print(sum(dfs(i) for i in range(half, n + 1)))
for i in range(0, n + 1):
for depth in range(-1, n):
if depth == -1:
dp[i][depth] = 0
elif i == 0:
dp[i][depth] = functools.reduce(
operator.mul, [1 - x for x in p[: depth + 1]]
)
elif (i - 1) == depth:
dp[i][depth] = functools.reduce(operator.mul, p[: depth + 1])
else:
dp[i][depth] = dp[i - 1][depth - 1] * p[depth] + dp[i][depth - 1] * (
1 - p[depth]
)
print((sum(dp[i][n - 1] for i in range(half, n + 1))))
| false
| 32.5
|
[
"-",
"-",
"-def dfs(n=half, depth=n - 1):",
"- if depth < 0:",
"- return 0",
"- if dp[n][depth] is not None:",
"- return dp[n][depth]",
"- if n == 0:",
"- r = functools.reduce(operator.mul, [1 - x for x in p[: depth + 1]])",
"- elif (n - 1) == depth:",
"- r = functools.reduce(operator.mul, p[: depth + 1])",
"- else:",
"- r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])",
"- dp[n][depth] = r",
"- return r",
"-",
"-",
"-print((sum(dfs(i) for i in range(half, n + 1))))",
"+# def dfs(n, depth=n - 1):",
"+# if depth < 0:",
"+# return 0",
"+#",
"+# if dp[n][depth] is not None:",
"+# return dp[n][depth]",
"+#",
"+# if n == 0:",
"+# r = functools.reduce(operator.mul, map(lambda x: 1 - x, p[:depth + 1]))",
"+# elif (n - 1) == depth:",
"+# r = functools.reduce(operator.mul, p[:depth + 1])",
"+# else:",
"+# r = dfs(n - 1, depth - 1) * p[depth] + dfs(n, depth - 1) * (1 - p[depth])",
"+# dp[n][depth] = r",
"+# return r",
"+#",
"+# print(sum(dfs(i) for i in range(half, n + 1)))",
"+for i in range(0, n + 1):",
"+ for depth in range(-1, n):",
"+ if depth == -1:",
"+ dp[i][depth] = 0",
"+ elif i == 0:",
"+ dp[i][depth] = functools.reduce(",
"+ operator.mul, [1 - x for x in p[: depth + 1]]",
"+ )",
"+ elif (i - 1) == depth:",
"+ dp[i][depth] = functools.reduce(operator.mul, p[: depth + 1])",
"+ else:",
"+ dp[i][depth] = dp[i - 1][depth - 1] * p[depth] + dp[i][depth - 1] * (",
"+ 1 - p[depth]",
"+ )",
"+print((sum(dp[i][n - 1] for i in range(half, n + 1))))"
] | false
| 0.007709
| 0.03784
| 0.203722
|
[
"s035750675",
"s081206915"
] |
u968166680
|
p02918
|
python
|
s960679938
|
s885371774
| 60
| 41
| 9,824
| 9,220
|
Accepted
|
Accepted
| 31.67
|
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = groups = 0
for k, g in groupby(S):
ans += len(list(g)) - 1
groups += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = 0
for i in range(N-1):
if S[i] == S[i+1]:
ans += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == '__main__':
main()
| 30
| 29
| 525
| 478
|
import sys
from itertools import groupby
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = groups = 0
for k, g in groupby(S):
ans += len(list(g)) - 1
groups += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == "__main__":
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10**9)
INF = 1 << 60
MOD = 1000000007
def main():
N, K = list(map(int, readline().split()))
S = readline().strip()
ans = 0
for i in range(N - 1):
if S[i] == S[i + 1]:
ans += 1
ans += 2 * K
if ans > N - 1:
ans = N - 1
print(ans)
return
if __name__ == "__main__":
main()
| false
| 3.333333
|
[
"-from itertools import groupby",
"- ans = groups = 0",
"- for k, g in groupby(S):",
"- ans += len(list(g)) - 1",
"- groups += 1",
"+ ans = 0",
"+ for i in range(N - 1):",
"+ if S[i] == S[i + 1]:",
"+ ans += 1"
] | false
| 0.051689
| 0.035537
| 1.454485
|
[
"s960679938",
"s885371774"
] |
u977193988
|
p03759
|
python
|
s256025016
|
s503441281
| 22
| 17
| 3,316
| 2,940
|
Accepted
|
Accepted
| 22.73
|
a=[int(i) for i in input().split()]
if (a[2]+a[0])/2==a[1]:
print('YES')
else:
print('NO')
|
a,b,c=list(map(int,input().split()))
if (a+c)/2==b:
print('YES')
else:
print('NO')
| 5
| 5
| 102
| 88
|
a = [int(i) for i in input().split()]
if (a[2] + a[0]) / 2 == a[1]:
print("YES")
else:
print("NO")
|
a, b, c = list(map(int, input().split()))
if (a + c) / 2 == b:
print("YES")
else:
print("NO")
| false
| 0
|
[
"-a = [int(i) for i in input().split()]",
"-if (a[2] + a[0]) / 2 == a[1]:",
"+a, b, c = list(map(int, input().split()))",
"+if (a + c) / 2 == b:"
] | false
| 0.044214
| 0.044365
| 0.996584
|
[
"s256025016",
"s503441281"
] |
u379959788
|
p02988
|
python
|
s252709806
|
s497284254
| 22
| 17
| 3,316
| 3,060
|
Accepted
|
Accepted
| 22.73
|
#B
n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(1, n-1):
if p[i-1] < p[i] and p[i] < p[i+1]:
ans += 1
if p[i-1] > p[i] and p[i] > p[i+1]:
ans += 1
print(ans)
|
n = int(eval(input()))
p = list(map(int, input().split()))
count = 0
for i in range(1, n-1):
if p[i-1] < p[i] and p[i] < p[i+1]:
count += 1
elif p[i-1] > p[i] and p[i] > p[i+1]:
count += 1
else:
pass
print(count)
| 10
| 12
| 221
| 254
|
# B
n = int(eval(input()))
p = list(map(int, input().split()))
ans = 0
for i in range(1, n - 1):
if p[i - 1] < p[i] and p[i] < p[i + 1]:
ans += 1
if p[i - 1] > p[i] and p[i] > p[i + 1]:
ans += 1
print(ans)
|
n = int(eval(input()))
p = list(map(int, input().split()))
count = 0
for i in range(1, n - 1):
if p[i - 1] < p[i] and p[i] < p[i + 1]:
count += 1
elif p[i - 1] > p[i] and p[i] > p[i + 1]:
count += 1
else:
pass
print(count)
| false
| 16.666667
|
[
"-# B",
"-ans = 0",
"+count = 0",
"- ans += 1",
"- if p[i - 1] > p[i] and p[i] > p[i + 1]:",
"- ans += 1",
"-print(ans)",
"+ count += 1",
"+ elif p[i - 1] > p[i] and p[i] > p[i + 1]:",
"+ count += 1",
"+ else:",
"+ pass",
"+print(count)"
] | false
| 0.042476
| 0.033498
| 1.267998
|
[
"s252709806",
"s497284254"
] |
u353895424
|
p03673
|
python
|
s684495955
|
s588114646
| 231
| 150
| 26,892
| 32,516
|
Accepted
|
Accepted
| 35.06
|
from queue import deque
n = int(eval(input()))
a = list(map(int, input().split()))
b = deque()
for i in range(n):
if i%2 == 0:
b.append(a[i])
else:
b.appendleft(a[i])
ans = list(b)
if n%2 != 0:
ans = ans[::-1]
print((*ans))
|
from collections import deque
n = int(eval(input()))
A = list(map(int, input().split()))
B = deque()
for i in range(n):
if i%2 == 0:
B.append(A[i])
else:
B.appendleft(A[i])
B = list(B)
if n%2 != 0:
B = B[::-1]
print((*B))
| 19
| 15
| 267
| 266
|
from queue import deque
n = int(eval(input()))
a = list(map(int, input().split()))
b = deque()
for i in range(n):
if i % 2 == 0:
b.append(a[i])
else:
b.appendleft(a[i])
ans = list(b)
if n % 2 != 0:
ans = ans[::-1]
print((*ans))
|
from collections import deque
n = int(eval(input()))
A = list(map(int, input().split()))
B = deque()
for i in range(n):
if i % 2 == 0:
B.append(A[i])
else:
B.appendleft(A[i])
B = list(B)
if n % 2 != 0:
B = B[::-1]
print((*B))
| false
| 21.052632
|
[
"-from queue import deque",
"+from collections import deque",
"-a = list(map(int, input().split()))",
"-b = deque()",
"+A = list(map(int, input().split()))",
"+B = deque()",
"- b.append(a[i])",
"+ B.append(A[i])",
"- b.appendleft(a[i])",
"-ans = list(b)",
"+ B.appendleft(A[i])",
"+B = list(B)",
"- ans = ans[::-1]",
"-print((*ans))",
"+ B = B[::-1]",
"+print((*B))"
] | false
| 0.044314
| 0.037908
| 1.168971
|
[
"s684495955",
"s588114646"
] |
u672475305
|
p02996
|
python
|
s136992174
|
s891333202
| 979
| 902
| 53,596
| 54,212
|
Accepted
|
Accepted
| 7.87
|
n = int(eval(input()))
lst = [list(map(int,input().split())) for _ in range(n)]
lst.sort(key = lambda x:x[1])
time = 0
for x,y in lst:
time += x
if time > y:
print('No')
break
else:
print('Yes')
|
n = int(eval(input()))
lst = [list(map(int,input().split())) for _ in range(n)]
lst.sort(key = lambda x:x[1])
time = 0
for x,y in lst:
time += x
if time > y:
print('No')
exit()
else:
print('Yes')
| 12
| 12
| 228
| 229
|
n = int(eval(input()))
lst = [list(map(int, input().split())) for _ in range(n)]
lst.sort(key=lambda x: x[1])
time = 0
for x, y in lst:
time += x
if time > y:
print("No")
break
else:
print("Yes")
|
n = int(eval(input()))
lst = [list(map(int, input().split())) for _ in range(n)]
lst.sort(key=lambda x: x[1])
time = 0
for x, y in lst:
time += x
if time > y:
print("No")
exit()
else:
print("Yes")
| false
| 0
|
[
"- break",
"+ exit()"
] | false
| 0.039351
| 0.039525
| 0.995594
|
[
"s136992174",
"s891333202"
] |
u028260664
|
p03854
|
python
|
s616693511
|
s844044381
| 168
| 69
| 39,920
| 3,316
|
Accepted
|
Accepted
| 58.93
|
def check(s):
s = s.replace('eraser', '')
s = s.replace('erase', '')
s = s.replace('dreamer', '')
s = s.replace('dream', '')
if len(s) != 0:
return 'NO'
return 'YES'
print((check(eval(input()))))
|
# Me
def check(s):
words = [
'dream',
'dreamer',
'erase',
'eraser',
]
while len(s) != 0:
flag = False
for w in words:
if s[-len(w):] == w:
s = s[:-len(w)]
flag = True
break
if not flag:
return 'NO'
return 'YES'
print((check(eval(input()))))
| 11
| 22
| 232
| 424
|
def check(s):
s = s.replace("eraser", "")
s = s.replace("erase", "")
s = s.replace("dreamer", "")
s = s.replace("dream", "")
if len(s) != 0:
return "NO"
return "YES"
print((check(eval(input()))))
|
# Me
def check(s):
words = [
"dream",
"dreamer",
"erase",
"eraser",
]
while len(s) != 0:
flag = False
for w in words:
if s[-len(w) :] == w:
s = s[: -len(w)]
flag = True
break
if not flag:
return "NO"
return "YES"
print((check(eval(input()))))
| false
| 50
|
[
"+# Me",
"- s = s.replace(\"eraser\", \"\")",
"- s = s.replace(\"erase\", \"\")",
"- s = s.replace(\"dreamer\", \"\")",
"- s = s.replace(\"dream\", \"\")",
"- if len(s) != 0:",
"- return \"NO\"",
"+ words = [",
"+ \"dream\",",
"+ \"dreamer\",",
"+ \"erase\",",
"+ \"eraser\",",
"+ ]",
"+ while len(s) != 0:",
"+ flag = False",
"+ for w in words:",
"+ if s[-len(w) :] == w:",
"+ s = s[: -len(w)]",
"+ flag = True",
"+ break",
"+ if not flag:",
"+ return \"NO\""
] | false
| 0.048727
| 0.041918
| 1.162456
|
[
"s616693511",
"s844044381"
] |
u312025627
|
p03424
|
python
|
s508284590
|
s340890713
| 181
| 17
| 38,384
| 2,940
|
Accepted
|
Accepted
| 90.61
|
def main():
N = int(eval(input()))
A = [i for i in input().split()]
ans = ["Three", "Four"]
print((ans[0] if len(set(A)) == 3 else ans[1]))
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
A = {i for i in input().split()}
if "Y" in A:
print("Four")
else:
print("Three")
if __name__ == '__main__':
main()
| 9
| 11
| 196
| 192
|
def main():
N = int(eval(input()))
A = [i for i in input().split()]
ans = ["Three", "Four"]
print((ans[0] if len(set(A)) == 3 else ans[1]))
if __name__ == "__main__":
main()
|
def main():
N = int(eval(input()))
A = {i for i in input().split()}
if "Y" in A:
print("Four")
else:
print("Three")
if __name__ == "__main__":
main()
| false
| 18.181818
|
[
"- A = [i for i in input().split()]",
"- ans = [\"Three\", \"Four\"]",
"- print((ans[0] if len(set(A)) == 3 else ans[1]))",
"+ A = {i for i in input().split()}",
"+ if \"Y\" in A:",
"+ print(\"Four\")",
"+ else:",
"+ print(\"Three\")"
] | false
| 0.034765
| 0.066759
| 0.520755
|
[
"s508284590",
"s340890713"
] |
u871352270
|
p02767
|
python
|
s942376474
|
s521453177
| 184
| 167
| 39,536
| 38,768
|
Accepted
|
Accepted
| 9.24
|
N = int(eval(input()))
X = list(map(int, input().split()))
Min = 1e10
for p in range(1,101):
Min = min(Min,sum(list([(x-p)**2 for x in X])))
print(Min)
|
N = int(eval(input()))
X = list(map(int, input().split()))
Min = 1e10
for p in range(1,101):
Min = min(Min,sum([(x-p)**2 for x in X]))
print(Min)
| 6
| 6
| 159
| 153
|
N = int(eval(input()))
X = list(map(int, input().split()))
Min = 1e10
for p in range(1, 101):
Min = min(Min, sum(list([(x - p) ** 2 for x in X])))
print(Min)
|
N = int(eval(input()))
X = list(map(int, input().split()))
Min = 1e10
for p in range(1, 101):
Min = min(Min, sum([(x - p) ** 2 for x in X]))
print(Min)
| false
| 0
|
[
"- Min = min(Min, sum(list([(x - p) ** 2 for x in X])))",
"+ Min = min(Min, sum([(x - p) ** 2 for x in X]))"
] | false
| 0.03909
| 0.036369
| 1.074836
|
[
"s942376474",
"s521453177"
] |
u562016607
|
p03438
|
python
|
s924031745
|
s917351909
| 40
| 30
| 5,052
| 4,600
|
Accepted
|
Accepted
| 25
|
N = int(eval(input()))
st = input().split()
a = [0 for i in range(N)]
A = 0
for i in range(N):
a[i] = int(st[i])
A += a[i]
st = input().split()
b = [0 for i in range(N)]
B = 0
for i in range(N):
b[i] = int(st[i])
B += b[i]
def cost(n):
if n == 0:
return [0, 0]
elif n < 0:
return [0, -n]
elif n > 0 and n % 2 == 0:
return [n//2, 0]
else:
return [(n+1)//2, 1]
K = B - A
PC = 0
MC = 0
for i in range(N):
c = cost(b[i] - a[i])
PC += c[0]
MC += c[1]
if PC <= K and MC <= K and ((K-PC)*2 == (K-MC)):
print("Yes")
else:
print("No")
|
N = int(eval(input()))
a = [int(i) for i in input().split()]
A = sum(a)
b = [int(i) for i in input().split()]
B = sum(b)
def cost(n):
if n == 0:
return [0, 0]
elif n < 0:
return [0, -n]
elif n > 0 and n % 2 == 0:
return [n//2, 0]
else:
return [(n+1)//2, 1]
K = B - A
PC = 0
MC = 0
for i in range(N):
c = cost(b[i] - a[i])
PC += c[0]
MC += c[1]
if PC <= K and MC <= K and ((K-PC)*2 == (K-MC)):
print("Yes")
else:
print("No")
| 34
| 26
| 638
| 512
|
N = int(eval(input()))
st = input().split()
a = [0 for i in range(N)]
A = 0
for i in range(N):
a[i] = int(st[i])
A += a[i]
st = input().split()
b = [0 for i in range(N)]
B = 0
for i in range(N):
b[i] = int(st[i])
B += b[i]
def cost(n):
if n == 0:
return [0, 0]
elif n < 0:
return [0, -n]
elif n > 0 and n % 2 == 0:
return [n // 2, 0]
else:
return [(n + 1) // 2, 1]
K = B - A
PC = 0
MC = 0
for i in range(N):
c = cost(b[i] - a[i])
PC += c[0]
MC += c[1]
if PC <= K and MC <= K and ((K - PC) * 2 == (K - MC)):
print("Yes")
else:
print("No")
|
N = int(eval(input()))
a = [int(i) for i in input().split()]
A = sum(a)
b = [int(i) for i in input().split()]
B = sum(b)
def cost(n):
if n == 0:
return [0, 0]
elif n < 0:
return [0, -n]
elif n > 0 and n % 2 == 0:
return [n // 2, 0]
else:
return [(n + 1) // 2, 1]
K = B - A
PC = 0
MC = 0
for i in range(N):
c = cost(b[i] - a[i])
PC += c[0]
MC += c[1]
if PC <= K and MC <= K and ((K - PC) * 2 == (K - MC)):
print("Yes")
else:
print("No")
| false
| 23.529412
|
[
"-st = input().split()",
"-a = [0 for i in range(N)]",
"-A = 0",
"-for i in range(N):",
"- a[i] = int(st[i])",
"- A += a[i]",
"-st = input().split()",
"-b = [0 for i in range(N)]",
"-B = 0",
"-for i in range(N):",
"- b[i] = int(st[i])",
"- B += b[i]",
"+a = [int(i) for i in input().split()]",
"+A = sum(a)",
"+b = [int(i) for i in input().split()]",
"+B = sum(b)"
] | false
| 0.045908
| 0.046919
| 0.978446
|
[
"s924031745",
"s917351909"
] |
u796942881
|
p02759
|
python
|
s498820034
|
s059820041
| 20
| 17
| 3,060
| 2,940
|
Accepted
|
Accepted
| 15
|
def main():
N = int(eval(input()))
print(((N + 1) // 2))
return
main()
|
def main():
N = int(eval(input()))
print((-(-N // 2)))
return
main()
| 7
| 7
| 83
| 81
|
def main():
N = int(eval(input()))
print(((N + 1) // 2))
return
main()
|
def main():
N = int(eval(input()))
print((-(-N // 2)))
return
main()
| false
| 0
|
[
"- print(((N + 1) // 2))",
"+ print((-(-N // 2)))"
] | false
| 0.053251
| 0.052417
| 1.015915
|
[
"s498820034",
"s059820041"
] |
u072717685
|
p02606
|
python
|
s734158519
|
s446226866
| 27
| 23
| 9,056
| 9,152
|
Accepted
|
Accepted
| 14.81
|
import sys
read = sys.stdin.read
from itertools import accumulate
def main():
l, r, d = list(map(int, input().split()))
res = 0
for i1 in range(l, r + 1):
res += i1 % d == 0
print(res)
if __name__ == '__main__':
main()
|
def main():
l, r, d = list(map(int, input().split()))
res = r // d - (l-1) // d
print(res)
if __name__ == '__main__':
main()
| 14
| 7
| 256
| 142
|
import sys
read = sys.stdin.read
from itertools import accumulate
def main():
l, r, d = list(map(int, input().split()))
res = 0
for i1 in range(l, r + 1):
res += i1 % d == 0
print(res)
if __name__ == "__main__":
main()
|
def main():
l, r, d = list(map(int, input().split()))
res = r // d - (l - 1) // d
print(res)
if __name__ == "__main__":
main()
| false
| 50
|
[
"-import sys",
"-",
"-read = sys.stdin.read",
"-from itertools import accumulate",
"-",
"-",
"- res = 0",
"- for i1 in range(l, r + 1):",
"- res += i1 % d == 0",
"+ res = r // d - (l - 1) // d"
] | false
| 0.066265
| 0.047522
| 1.394403
|
[
"s734158519",
"s446226866"
] |
u374551537
|
p02725
|
python
|
s994086119
|
s728366758
| 184
| 115
| 28,100
| 26,444
|
Accepted
|
Accepted
| 37.5
|
List = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(0,List[1]):
A.append(A[i]+List[0])
D = []
for i in range(0,List[1]):
D.append(A[i+List[1]-1]-A[i])
print((min(D)))
|
List = list(map(int, input().split()))
A = list(map(int, input().split()))
D = []
for i in range(1,List[1]):
D.append(A[i]-A[i-1])
D.append(A[0]+List[0]-A[List[1]-1])
print((List[0]-max(D)))
| 11
| 10
| 223
| 204
|
List = list(map(int, input().split()))
A = list(map(int, input().split()))
for i in range(0, List[1]):
A.append(A[i] + List[0])
D = []
for i in range(0, List[1]):
D.append(A[i + List[1] - 1] - A[i])
print((min(D)))
|
List = list(map(int, input().split()))
A = list(map(int, input().split()))
D = []
for i in range(1, List[1]):
D.append(A[i] - A[i - 1])
D.append(A[0] + List[0] - A[List[1] - 1])
print((List[0] - max(D)))
| false
| 9.090909
|
[
"-for i in range(0, List[1]):",
"- A.append(A[i] + List[0])",
"-for i in range(0, List[1]):",
"- D.append(A[i + List[1] - 1] - A[i])",
"-print((min(D)))",
"+for i in range(1, List[1]):",
"+ D.append(A[i] - A[i - 1])",
"+D.append(A[0] + List[0] - A[List[1] - 1])",
"+print((List[0] - max(D)))"
] | false
| 0.006916
| 0.068675
| 0.1007
|
[
"s994086119",
"s728366758"
] |
u955248595
|
p03828
|
python
|
s992604669
|
s168923655
| 40
| 35
| 9,476
| 9,212
|
Accepted
|
Accepted
| 12.5
|
from operator import mul
from functools import reduce
def PrimeDecomp(N,ConcFlag):
if ConcFlag:
if N<=1:
return [1],1
else:
I = 2
PrimeDec = []
DivCount = 1
while I*I<=N:
Cnt = 0
while N%I==0:
N //= I
PrimeDec.append(I)
DivCount *= (Cnt+1)
I += 1
if N>=2:
PrimeDec.append(N)
DivCount *= 2
return PrimeDec,DivCount
else:
if N<=1:
return [1],[1],1
else:
I = 2
PrimeDec = []
PrimeCnt = []
DivCount = 1
while I*I<=N:
Cnt = 0
while N%I==0:
N //= I
Cnt += 1
if Cnt>=1:
PrimeDec.append(I)
PrimeCnt.append(Cnt)
DivCount *= (Cnt+1)
I += 1
if N>=2:
PrimeDec.append(N)
PrimeCnt.append(1)
DivCount *= 2
return PrimeDec,PrimeCnt,DivCount
def DivisorFactorial(N,FactDec,FactCnt,MemoFlag):
if MemoFlag:
if N<=1:
FDivCnt = 1
return FactDec,FactCnt,FDivCnt
else:
PrimeDec,PrimeCnt,_ = PrimeDecomp(N,False)
for TP in range(0,len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = reduce(mul,[(T+1) for T in FactCnt])
return FactDec,FactCnt,FDivCnt
else:
if N<=1:
FDivCnt = 1
return FactDec,FactCnt,FDivCnt
else:
for TN in range(2,N+1):
PrimeDec,PrimeCnt,_ = PrimeDecomp(TN,False)
for TP in range(0,len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = reduce(mul,[(T+1) for T in FactCnt])
return FactDec,FactCnt,FDivCnt
N = int(eval(input()))
FactDec,FactCnt,FDivCnt = DivisorFactorial(N,[],[],False)
print((FDivCnt%(10**9+7)))
|
def PrimeDecomp(N,ConcFlag):
if ConcFlag:
if N<=1:
return [1],1
else:
I = 2
PrimeDec = []
DivCount = 1
while I*I<=N:
Cnt = 0
while N%I==0:
N //= I
PrimeDec.append(I)
DivCount *= (Cnt+1)
I += 1
if N>=2:
PrimeDec.append(N)
DivCount *= 2
return PrimeDec,DivCount
else:
if N<=1:
return [1],[1],1
else:
I = 2
PrimeDec = []
PrimeCnt = []
DivCount = 1
while I*I<=N:
Cnt = 0
while N%I==0:
N //= I
Cnt += 1
if Cnt>=1:
PrimeDec.append(I)
PrimeCnt.append(Cnt)
DivCount *= (Cnt+1)
I += 1
if N>=2:
PrimeDec.append(N)
PrimeCnt.append(1)
DivCount *= 2
return PrimeDec,PrimeCnt,DivCount
def DivisorFactorial(N,FactDec,FactCnt,MemoFlag,Mod,ModFlag):
if MemoFlag:
if N<=1:
FDivCnt = 1
return FactDec,FactCnt,FDivCnt
else:
PrimeDec,PrimeCnt,_ = PrimeDecomp(N,False)
for TP in range(0,len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = 1
for TF in FactCnt:
FDivCnt = [FDivCnt*(TF+1),(FDivCnt*(TF+1))%Mod][ModFlag]
return FactDec,FactCnt,FDivCnt
else:
if N<=1:
FDivCnt = 1
return FactDec,FactCnt,FDivCnt
else:
for TN in range(2,N+1):
PrimeDec,PrimeCnt,_ = PrimeDecomp(TN,False)
for TP in range(0,len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = 1
for TF in FactCnt:
FDivCnt = [FDivCnt*(TF+1),(FDivCnt*(TF+1))%Mod][ModFlag]
return FactDec,FactCnt,FDivCnt
FactDec,FactCnt,FDivCnt = DivisorFactorial(int(eval(input())),[],[],False,10**9+7,True)
print(FDivCnt)
| 79
| 79
| 2,619
| 2,701
|
from operator import mul
from functools import reduce
def PrimeDecomp(N, ConcFlag):
if ConcFlag:
if N <= 1:
return [1], 1
else:
I = 2
PrimeDec = []
DivCount = 1
while I * I <= N:
Cnt = 0
while N % I == 0:
N //= I
PrimeDec.append(I)
DivCount *= Cnt + 1
I += 1
if N >= 2:
PrimeDec.append(N)
DivCount *= 2
return PrimeDec, DivCount
else:
if N <= 1:
return [1], [1], 1
else:
I = 2
PrimeDec = []
PrimeCnt = []
DivCount = 1
while I * I <= N:
Cnt = 0
while N % I == 0:
N //= I
Cnt += 1
if Cnt >= 1:
PrimeDec.append(I)
PrimeCnt.append(Cnt)
DivCount *= Cnt + 1
I += 1
if N >= 2:
PrimeDec.append(N)
PrimeCnt.append(1)
DivCount *= 2
return PrimeDec, PrimeCnt, DivCount
def DivisorFactorial(N, FactDec, FactCnt, MemoFlag):
if MemoFlag:
if N <= 1:
FDivCnt = 1
return FactDec, FactCnt, FDivCnt
else:
PrimeDec, PrimeCnt, _ = PrimeDecomp(N, False)
for TP in range(0, len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = reduce(mul, [(T + 1) for T in FactCnt])
return FactDec, FactCnt, FDivCnt
else:
if N <= 1:
FDivCnt = 1
return FactDec, FactCnt, FDivCnt
else:
for TN in range(2, N + 1):
PrimeDec, PrimeCnt, _ = PrimeDecomp(TN, False)
for TP in range(0, len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = reduce(mul, [(T + 1) for T in FactCnt])
return FactDec, FactCnt, FDivCnt
N = int(eval(input()))
FactDec, FactCnt, FDivCnt = DivisorFactorial(N, [], [], False)
print((FDivCnt % (10**9 + 7)))
|
def PrimeDecomp(N, ConcFlag):
if ConcFlag:
if N <= 1:
return [1], 1
else:
I = 2
PrimeDec = []
DivCount = 1
while I * I <= N:
Cnt = 0
while N % I == 0:
N //= I
PrimeDec.append(I)
DivCount *= Cnt + 1
I += 1
if N >= 2:
PrimeDec.append(N)
DivCount *= 2
return PrimeDec, DivCount
else:
if N <= 1:
return [1], [1], 1
else:
I = 2
PrimeDec = []
PrimeCnt = []
DivCount = 1
while I * I <= N:
Cnt = 0
while N % I == 0:
N //= I
Cnt += 1
if Cnt >= 1:
PrimeDec.append(I)
PrimeCnt.append(Cnt)
DivCount *= Cnt + 1
I += 1
if N >= 2:
PrimeDec.append(N)
PrimeCnt.append(1)
DivCount *= 2
return PrimeDec, PrimeCnt, DivCount
def DivisorFactorial(N, FactDec, FactCnt, MemoFlag, Mod, ModFlag):
if MemoFlag:
if N <= 1:
FDivCnt = 1
return FactDec, FactCnt, FDivCnt
else:
PrimeDec, PrimeCnt, _ = PrimeDecomp(N, False)
for TP in range(0, len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = 1
for TF in FactCnt:
FDivCnt = [FDivCnt * (TF + 1), (FDivCnt * (TF + 1)) % Mod][ModFlag]
return FactDec, FactCnt, FDivCnt
else:
if N <= 1:
FDivCnt = 1
return FactDec, FactCnt, FDivCnt
else:
for TN in range(2, N + 1):
PrimeDec, PrimeCnt, _ = PrimeDecomp(TN, False)
for TP in range(0, len(PrimeDec)):
if PrimeDec[TP] in set(FactDec):
FactCnt[FactDec.index(PrimeDec[TP])] += PrimeCnt[TP]
else:
FactDec.append(PrimeDec[TP])
FactCnt.append(PrimeCnt[TP])
FDivCnt = 1
for TF in FactCnt:
FDivCnt = [FDivCnt * (TF + 1), (FDivCnt * (TF + 1)) % Mod][ModFlag]
return FactDec, FactCnt, FDivCnt
FactDec, FactCnt, FDivCnt = DivisorFactorial(
int(eval(input())), [], [], False, 10**9 + 7, True
)
print(FDivCnt)
| false
| 0
|
[
"-from operator import mul",
"-from functools import reduce",
"-",
"-",
"-def DivisorFactorial(N, FactDec, FactCnt, MemoFlag):",
"+def DivisorFactorial(N, FactDec, FactCnt, MemoFlag, Mod, ModFlag):",
"- FDivCnt = reduce(mul, [(T + 1) for T in FactCnt])",
"+ FDivCnt = 1",
"+ for TF in FactCnt:",
"+ FDivCnt = [FDivCnt * (TF + 1), (FDivCnt * (TF + 1)) % Mod][ModFlag]",
"- FDivCnt = reduce(mul, [(T + 1) for T in FactCnt])",
"+ FDivCnt = 1",
"+ for TF in FactCnt:",
"+ FDivCnt = [FDivCnt * (TF + 1), (FDivCnt * (TF + 1)) % Mod][ModFlag]",
"-N = int(eval(input()))",
"-FactDec, FactCnt, FDivCnt = DivisorFactorial(N, [], [], False)",
"-print((FDivCnt % (10**9 + 7)))",
"+FactDec, FactCnt, FDivCnt = DivisorFactorial(",
"+ int(eval(input())), [], [], False, 10**9 + 7, True",
"+)",
"+print(FDivCnt)"
] | false
| 0.051561
| 0.05142
| 1.002752
|
[
"s992604669",
"s168923655"
] |
u365686736
|
p02396
|
python
|
s527663453
|
s784333727
| 70
| 50
| 6,256
| 5,676
|
Accepted
|
Accepted
| 28.57
|
a=[]
b=eval(input())
while b!="0":
a.append(b)
b=eval(input())
for c in range(len(a)):print(("Case "+str(c+1)+": "+ a[c]))
|
import sys
a=1
for b in sys.stdin:
b=b.strip()
if b=='0':break
print(f'Case {a}: {b}')
a+=1
| 6
| 7
| 126
| 101
|
a = []
b = eval(input())
while b != "0":
a.append(b)
b = eval(input())
for c in range(len(a)):
print(("Case " + str(c + 1) + ": " + a[c]))
|
import sys
a = 1
for b in sys.stdin:
b = b.strip()
if b == "0":
break
print(f"Case {a}: {b}")
a += 1
| false
| 14.285714
|
[
"-a = []",
"-b = eval(input())",
"-while b != \"0\":",
"- a.append(b)",
"- b = eval(input())",
"-for c in range(len(a)):",
"- print((\"Case \" + str(c + 1) + \": \" + a[c]))",
"+import sys",
"+",
"+a = 1",
"+for b in sys.stdin:",
"+ b = b.strip()",
"+ if b == \"0\":",
"+ break",
"+ print(f\"Case {a}: {b}\")",
"+ a += 1"
] | false
| 0.035897
| 0.037332
| 0.961547
|
[
"s527663453",
"s784333727"
] |
u425762225
|
p02767
|
python
|
s900663892
|
s085796499
| 182
| 32
| 38,512
| 9,112
|
Accepted
|
Accepted
| 82.42
|
N = int(eval(input()))
x = list(map(int,input().split()))
l=[]
for p in range(1,101):
sum=0
for i in range(N):
sum += (x[i]-p)**2
l.append(sum)
print((sorted(l)[0]))
|
#!/usr/bin/env python3
# from numba import njit
# from collections import Counter
# from itertools import accumulate
# import numpy as np
# from heapq import heappop,heappush
# from bisect import bisect_left
INF = pow(10,6)
# @njit
def solve(n,a):
res = INF
for i in range(1,101):
res = min(res,sum(pow(i-x,2) for x in a))
return res
def main():
N = int(eval(input()))
# N,M = map(int,input().split())
a = list(map(int,input().split()))
print((solve(N,a)))
return
if __name__ == '__main__':
main()
| 14
| 30
| 191
| 549
|
N = int(eval(input()))
x = list(map(int, input().split()))
l = []
for p in range(1, 101):
sum = 0
for i in range(N):
sum += (x[i] - p) ** 2
l.append(sum)
print((sorted(l)[0]))
|
#!/usr/bin/env python3
# from numba import njit
# from collections import Counter
# from itertools import accumulate
# import numpy as np
# from heapq import heappop,heappush
# from bisect import bisect_left
INF = pow(10, 6)
# @njit
def solve(n, a):
res = INF
for i in range(1, 101):
res = min(res, sum(pow(i - x, 2) for x in a))
return res
def main():
N = int(eval(input()))
# N,M = map(int,input().split())
a = list(map(int, input().split()))
print((solve(N, a)))
return
if __name__ == "__main__":
main()
| false
| 53.333333
|
[
"-N = int(eval(input()))",
"-x = list(map(int, input().split()))",
"-l = []",
"-for p in range(1, 101):",
"- sum = 0",
"- for i in range(N):",
"- sum += (x[i] - p) ** 2",
"- l.append(sum)",
"-print((sorted(l)[0]))",
"+#!/usr/bin/env python3",
"+# from numba import njit",
"+# from collections import Counter",
"+# from itertools import accumulate",
"+# import numpy as np",
"+# from heapq import heappop,heappush",
"+# from bisect import bisect_left",
"+INF = pow(10, 6)",
"+# @njit",
"+def solve(n, a):",
"+ res = INF",
"+ for i in range(1, 101):",
"+ res = min(res, sum(pow(i - x, 2) for x in a))",
"+ return res",
"+",
"+",
"+def main():",
"+ N = int(eval(input()))",
"+ # N,M = map(int,input().split())",
"+ a = list(map(int, input().split()))",
"+ print((solve(N, a)))",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false
| 0.007885
| 0.041546
| 0.189795
|
[
"s900663892",
"s085796499"
] |
u777283665
|
p03017
|
python
|
s381006097
|
s764539985
| 50
| 32
| 3,572
| 3,572
|
Accepted
|
Accepted
| 36
|
n, a, b, c, d = list(map(int, input().split()))
a, b, c, d = a-1, b-1, c-1, d-1
s = eval(input())
if "##" in s[a:d]:
print("No")
exit()
if c < d:
for i in range(b, d):
if s[i:i+2] == "##":
print("No")
exit()
print("Yes")
else:
for i in range(b, d+1):
if s[i] != "#" and s[i-1] == "." and s[i+1] == ".":
print("Yes")
exit()
print("No")
|
n, a, b, c, d = list(map(int, input().split()))
a, b, c, d = a-1, b-1, c-1, d-1
s = eval(input())
if c < d:
if "##" in s[a:d]:
print("No")
exit()
print("Yes")
else:
for i in range(b, d+1):
if s[i] != "#" and s[i-1] == "." and s[i+1] == ".":
print("Yes")
exit()
print("No")
| 23
| 18
| 437
| 345
|
n, a, b, c, d = list(map(int, input().split()))
a, b, c, d = a - 1, b - 1, c - 1, d - 1
s = eval(input())
if "##" in s[a:d]:
print("No")
exit()
if c < d:
for i in range(b, d):
if s[i : i + 2] == "##":
print("No")
exit()
print("Yes")
else:
for i in range(b, d + 1):
if s[i] != "#" and s[i - 1] == "." and s[i + 1] == ".":
print("Yes")
exit()
print("No")
|
n, a, b, c, d = list(map(int, input().split()))
a, b, c, d = a - 1, b - 1, c - 1, d - 1
s = eval(input())
if c < d:
if "##" in s[a:d]:
print("No")
exit()
print("Yes")
else:
for i in range(b, d + 1):
if s[i] != "#" and s[i - 1] == "." and s[i + 1] == ".":
print("Yes")
exit()
print("No")
| false
| 21.73913
|
[
"-if \"##\" in s[a:d]:",
"- print(\"No\")",
"- exit()",
"- for i in range(b, d):",
"- if s[i : i + 2] == \"##\":",
"- print(\"No\")",
"- exit()",
"+ if \"##\" in s[a:d]:",
"+ print(\"No\")",
"+ exit()"
] | false
| 0.044157
| 0.043448
| 1.016309
|
[
"s381006097",
"s764539985"
] |
u761087127
|
p02773
|
python
|
s342856533
|
s694057022
| 607
| 515
| 35,816
| 37,488
|
Accepted
|
Accepted
| 15.16
|
from collections import Counter
N = int(input())
S = [input() for _ in range(N)]
c = Counter(S)
m = max(c.values())
ans = sorted([k for k,v in c.items() if m==v])
[print(k) for k in ans]
|
from collections import Counter
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
c = Counter(S)
m = max(c.values())
ans = sorted([k for k,v in list(c.items()) if m==v])
print(('\n'.join(ans)))
| 8
| 8
| 194
| 193
|
from collections import Counter
N = int(input())
S = [input() for _ in range(N)]
c = Counter(S)
m = max(c.values())
ans = sorted([k for k, v in c.items() if m == v])
[print(k) for k in ans]
|
from collections import Counter
N = int(eval(input()))
S = [eval(input()) for _ in range(N)]
c = Counter(S)
m = max(c.values())
ans = sorted([k for k, v in list(c.items()) if m == v])
print(("\n".join(ans)))
| false
| 0
|
[
"-N = int(input())",
"-S = [input() for _ in range(N)]",
"+N = int(eval(input()))",
"+S = [eval(input()) for _ in range(N)]",
"-ans = sorted([k for k, v in c.items() if m == v])",
"-[print(k) for k in ans]",
"+ans = sorted([k for k, v in list(c.items()) if m == v])",
"+print((\"\\n\".join(ans)))"
] | false
| 0.044037
| 0.048301
| 0.911719
|
[
"s342856533",
"s694057022"
] |
u887207211
|
p03309
|
python
|
s964358334
|
s976672899
| 235
| 192
| 26,132
| 27,580
|
Accepted
|
Accepted
| 18.3
|
N = int(eval(input()))
A = list(map(int,input().split()))
tmp = []
for i in range(N):
tmp.append(A[i] - (i+1))
tmp.sort()
mid = tmp[int(N/2)]
ans = 0
for i in range(N):
ans += abs(tmp[i] - mid)
print(ans)
|
N = int(eval(input()))
A = list(map(int,input().split()))
tmp = sorted([A[i-1] - i for i in range(1, N+1)])
mid = tmp[int(N/2)]
print((sum([abs(t - mid) for t in tmp])))
| 11
| 5
| 212
| 165
|
N = int(eval(input()))
A = list(map(int, input().split()))
tmp = []
for i in range(N):
tmp.append(A[i] - (i + 1))
tmp.sort()
mid = tmp[int(N / 2)]
ans = 0
for i in range(N):
ans += abs(tmp[i] - mid)
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
tmp = sorted([A[i - 1] - i for i in range(1, N + 1)])
mid = tmp[int(N / 2)]
print((sum([abs(t - mid) for t in tmp])))
| false
| 54.545455
|
[
"-tmp = []",
"-for i in range(N):",
"- tmp.append(A[i] - (i + 1))",
"-tmp.sort()",
"+tmp = sorted([A[i - 1] - i for i in range(1, N + 1)])",
"-ans = 0",
"-for i in range(N):",
"- ans += abs(tmp[i] - mid)",
"-print(ans)",
"+print((sum([abs(t - mid) for t in tmp])))"
] | false
| 0.068271
| 0.045154
| 1.511959
|
[
"s964358334",
"s976672899"
] |
u017415492
|
p03062
|
python
|
s035788219
|
s661136553
| 130
| 78
| 14,412
| 19,916
|
Accepted
|
Accepted
| 40
|
n=int(eval(input()))
d=list(map(int,input().split()))
k=[]
t=0
ans=0
for i in range(n):
ans+=abs(d[i])
if d[i]<=0:
t+=1
for i in range(len(d)):
k.append(abs(d[i]))
k.sort()
if t%2:
ans-=2*k[0]
print(ans)
|
n=int(eval(input()))
a=list(map(int,input().split()))
count=0
ans=[]
for i in range(n):
ans.append(abs(a[i]))
if a[i]<0:
count+=1
if count%2==0:
print((sum(ans)))
else:
print((sum(ans)-2*min(ans)))
| 15
| 14
| 223
| 216
|
n = int(eval(input()))
d = list(map(int, input().split()))
k = []
t = 0
ans = 0
for i in range(n):
ans += abs(d[i])
if d[i] <= 0:
t += 1
for i in range(len(d)):
k.append(abs(d[i]))
k.sort()
if t % 2:
ans -= 2 * k[0]
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
count = 0
ans = []
for i in range(n):
ans.append(abs(a[i]))
if a[i] < 0:
count += 1
if count % 2 == 0:
print((sum(ans)))
else:
print((sum(ans) - 2 * min(ans)))
| false
| 6.666667
|
[
"-d = list(map(int, input().split()))",
"-k = []",
"-t = 0",
"-ans = 0",
"+a = list(map(int, input().split()))",
"+count = 0",
"+ans = []",
"- ans += abs(d[i])",
"- if d[i] <= 0:",
"- t += 1",
"-for i in range(len(d)):",
"- k.append(abs(d[i]))",
"-k.sort()",
"-if t % 2:",
"- ans -= 2 * k[0]",
"-print(ans)",
"+ ans.append(abs(a[i]))",
"+ if a[i] < 0:",
"+ count += 1",
"+if count % 2 == 0:",
"+ print((sum(ans)))",
"+else:",
"+ print((sum(ans) - 2 * min(ans)))"
] | false
| 0.047497
| 0.044205
| 1.074476
|
[
"s035788219",
"s661136553"
] |
u327466606
|
p03608
|
python
|
s879136561
|
s129953058
| 798
| 540
| 24,512
| 17,892
|
Accepted
|
Accepted
| 32.33
|
N,M,NR = list(map(int,input().split()))
R = list([int(x) - 1 for x in input().split()])
import scipy.sparse as ss
import numpy as np
G = ss.dok_matrix((N,N), dtype=np.uint32)
def it():
for _ in range(M):
a,b,c = list(map(int,input().split()))
a -= 1
b -= 1
yield ((a,b),c)
yield ((b,a),c)
G.update(it())
D = ss.csgraph.floyd_warshall(G.tocsr(), directed=False)
def it2():
from itertools import permutations
for p in permutations(R):
pp = iter(p)
next(pp)
yield sum(D[a,b] for a,b in zip(p,pp))
print((int(min(it2()))))
|
N,M,NR = list(map(int,input().split()))
R = list([int(x) - 1 for x in input().split()])
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
G = np.zeros((N,N))
for _ in range(M):
a,b,c = list(map(int,input().split()))
G[a-1,b-1] = c
floyd_warshall(G, directed=False, overwrite=True)
def it2():
from itertools import permutations
for p in permutations(R):
pp = iter(p)
next(pp)
yield sum(G[a,b] for a,b in zip(p,pp))
print((int(min(it2()))))
| 29
| 23
| 583
| 495
|
N, M, NR = list(map(int, input().split()))
R = list([int(x) - 1 for x in input().split()])
import scipy.sparse as ss
import numpy as np
G = ss.dok_matrix((N, N), dtype=np.uint32)
def it():
for _ in range(M):
a, b, c = list(map(int, input().split()))
a -= 1
b -= 1
yield ((a, b), c)
yield ((b, a), c)
G.update(it())
D = ss.csgraph.floyd_warshall(G.tocsr(), directed=False)
def it2():
from itertools import permutations
for p in permutations(R):
pp = iter(p)
next(pp)
yield sum(D[a, b] for a, b in zip(p, pp))
print((int(min(it2()))))
|
N, M, NR = list(map(int, input().split()))
R = list([int(x) - 1 for x in input().split()])
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
G = np.zeros((N, N))
for _ in range(M):
a, b, c = list(map(int, input().split()))
G[a - 1, b - 1] = c
floyd_warshall(G, directed=False, overwrite=True)
def it2():
from itertools import permutations
for p in permutations(R):
pp = iter(p)
next(pp)
yield sum(G[a, b] for a, b in zip(p, pp))
print((int(min(it2()))))
| false
| 20.689655
|
[
"-import scipy.sparse as ss",
"+from scipy.sparse.csgraph import floyd_warshall",
"-G = ss.dok_matrix((N, N), dtype=np.uint32)",
"-",
"-",
"-def it():",
"- for _ in range(M):",
"- a, b, c = list(map(int, input().split()))",
"- a -= 1",
"- b -= 1",
"- yield ((a, b), c)",
"- yield ((b, a), c)",
"-",
"-",
"-G.update(it())",
"-D = ss.csgraph.floyd_warshall(G.tocsr(), directed=False)",
"+G = np.zeros((N, N))",
"+for _ in range(M):",
"+ a, b, c = list(map(int, input().split()))",
"+ G[a - 1, b - 1] = c",
"+floyd_warshall(G, directed=False, overwrite=True)",
"- yield sum(D[a, b] for a, b in zip(p, pp))",
"+ yield sum(G[a, b] for a, b in zip(p, pp))"
] | false
| 0.692332
| 0.334539
| 2.06951
|
[
"s879136561",
"s129953058"
] |
u623231048
|
p03240
|
python
|
s360599187
|
s333293913
| 2,908
| 31
| 3,064
| 3,064
|
Accepted
|
Accepted
| 98.93
|
n = int(eval(input()))
li = [list(map(int,input().split())) for i in range(n)]
for i in range(n):
if li[i][2] != 0:
h1 = li[i][2]
break
flag = True
flag2 = False
for i in range(10**9):
if flag2 == True: break
for X in range(101):
for Y in range(101):
h = h1 + i
flag = True
for j in range(n):
if max(h - abs(li[j][0]-X) - abs(li[j][1]-Y),0) != li[j][2]:
flag = False
break
if flag == True:
print((X,Y,h))
flag2 = True
if flag2 == True: break
h = h1 - i
flag = True
for j in range(n):
if max(h - abs(li[j][0]-X) - abs(li[j][1]-Y),0) != li[j][2]:
flag = False
break
if flag == True:
print((X,Y,h))
flag2 = True
|
n = int(eval(input()))
li = [list(map(int,input().split())) for i in range(n)]
li.sort(key=lambda x: x[2])
a,b,c = li[-1]
for x in range(101):
for y in range(101):
h = abs(x-a) + abs(y-b) + c
if all(k == max(h-abs(x-i)-abs(y-j),0) for i,j,k in li):
print((x,y,h))
exit()
| 34
| 11
| 955
| 318
|
n = int(eval(input()))
li = [list(map(int, input().split())) for i in range(n)]
for i in range(n):
if li[i][2] != 0:
h1 = li[i][2]
break
flag = True
flag2 = False
for i in range(10**9):
if flag2 == True:
break
for X in range(101):
for Y in range(101):
h = h1 + i
flag = True
for j in range(n):
if max(h - abs(li[j][0] - X) - abs(li[j][1] - Y), 0) != li[j][2]:
flag = False
break
if flag == True:
print((X, Y, h))
flag2 = True
if flag2 == True:
break
h = h1 - i
flag = True
for j in range(n):
if max(h - abs(li[j][0] - X) - abs(li[j][1] - Y), 0) != li[j][2]:
flag = False
break
if flag == True:
print((X, Y, h))
flag2 = True
|
n = int(eval(input()))
li = [list(map(int, input().split())) for i in range(n)]
li.sort(key=lambda x: x[2])
a, b, c = li[-1]
for x in range(101):
for y in range(101):
h = abs(x - a) + abs(y - b) + c
if all(k == max(h - abs(x - i) - abs(y - j), 0) for i, j, k in li):
print((x, y, h))
exit()
| false
| 67.647059
|
[
"-for i in range(n):",
"- if li[i][2] != 0:",
"- h1 = li[i][2]",
"- break",
"-flag = True",
"-flag2 = False",
"-for i in range(10**9):",
"- if flag2 == True:",
"- break",
"- for X in range(101):",
"- for Y in range(101):",
"- h = h1 + i",
"- flag = True",
"- for j in range(n):",
"- if max(h - abs(li[j][0] - X) - abs(li[j][1] - Y), 0) != li[j][2]:",
"- flag = False",
"- break",
"- if flag == True:",
"- print((X, Y, h))",
"- flag2 = True",
"- if flag2 == True:",
"- break",
"- h = h1 - i",
"- flag = True",
"- for j in range(n):",
"- if max(h - abs(li[j][0] - X) - abs(li[j][1] - Y), 0) != li[j][2]:",
"- flag = False",
"- break",
"- if flag == True:",
"- print((X, Y, h))",
"- flag2 = True",
"+li.sort(key=lambda x: x[2])",
"+a, b, c = li[-1]",
"+for x in range(101):",
"+ for y in range(101):",
"+ h = abs(x - a) + abs(y - b) + c",
"+ if all(k == max(h - abs(x - i) - abs(y - j), 0) for i, j, k in li):",
"+ print((x, y, h))",
"+ exit()"
] | false
| 0.09115
| 0.047142
| 1.93351
|
[
"s360599187",
"s333293913"
] |
u375695365
|
p02995
|
python
|
s626267486
|
s875269265
| 57
| 35
| 5,560
| 5,048
|
Accepted
|
Accepted
| 38.6
|
import fractions
a,b,c,d=list(map(int,input().split()))
x1=b//c-(a-1)//c #ｃの割れるやつ
x2=b//d-(a-1)//d #ｄの割れるやつ
sks=c * d // fractions.gcd(c,d)#最小公倍数 普通ならmathメソッドにある
x3=b//sks-(a-1)//sks#ｃ＊ｄの割れるやつ
ans=b-a+1-(x1+x2-x3)
print (ans)
|
#二回目
import fractions
a,b,c,d=list(map(int,input().split()))
def lcm(x, y):
return (x * y) // fractions.gcd(x, y)
ans1=b
a-=1
ans2=0
ans1-=b//c
ans1-=b//d
ans1+=b//(lcm(c,d))
#print(ans1)
ans2+=a//c
ans2+=a//d
ans2-=a//(lcm(c,d))
print((ans1-(a-ans2)))
| 8
| 20
| 227
| 271
|
import fractions
a, b, c, d = list(map(int, input().split()))
x1 = b // c - (a - 1) // c # ｃの割れるやつ
x2 = b // d - (a - 1) // d # ｄの割れるやつ
sks = c * d // fractions.gcd(c, d) # 最小公倍数 普通ならmathメソッドにある
x3 = b // sks - (a - 1) // sks # ｃ＊ｄの割れるやつ
ans = b - a + 1 - (x1 + x2 - x3)
print(ans)
|
# 二回目
import fractions
a, b, c, d = list(map(int, input().split()))
def lcm(x, y):
return (x * y) // fractions.gcd(x, y)
ans1 = b
a -= 1
ans2 = 0
ans1 -= b // c
ans1 -= b // d
ans1 += b // (lcm(c, d))
# print(ans1)
ans2 += a // c
ans2 += a // d
ans2 -= a // (lcm(c, d))
print((ans1 - (a - ans2)))
| false
| 60
|
[
"+# 二回目",
"-x1 = b // c - (a - 1) // c # ｃの割れるやつ",
"-x2 = b // d - (a - 1) // d # ｄの割れるやつ",
"-sks = c * d // fractions.gcd(c, d) # 最小公倍数 普通ならmathメソッドにある",
"-x3 = b // sks - (a - 1) // sks # ｃ＊ｄの割れるやつ",
"-ans = b - a + 1 - (x1 + x2 - x3)",
"-print(ans)",
"+",
"+",
"+def lcm(x, y):",
"+ return (x * y) // fractions.gcd(x, y)",
"+",
"+",
"+ans1 = b",
"+a -= 1",
"+ans2 = 0",
"+ans1 -= b // c",
"+ans1 -= b // d",
"+ans1 += b // (lcm(c, d))",
"+# print(ans1)",
"+ans2 += a // c",
"+ans2 += a // d",
"+ans2 -= a // (lcm(c, d))",
"+print((ans1 - (a - ans2)))"
] | false
| 0.05878
| 0.13297
| 0.44205
|
[
"s626267486",
"s875269265"
] |
u218834617
|
p02570
|
python
|
s766716549
|
s629217465
| 69
| 59
| 61,200
| 61,540
|
Accepted
|
Accepted
| 14.49
|
d,t,s=list(map(int,input().split()))
print(('Yes' if d/s<=t else 'No'))
|
d,t,s=list(map(int,input().split()))
print(('Yes' if s*t>=d else 'No'))
| 2
| 2
| 65
| 65
|
d, t, s = list(map(int, input().split()))
print(("Yes" if d / s <= t else "No"))
|
d, t, s = list(map(int, input().split()))
print(("Yes" if s * t >= d else "No"))
| false
| 0
|
[
"-print((\"Yes\" if d / s <= t else \"No\"))",
"+print((\"Yes\" if s * t >= d else \"No\"))"
] | false
| 0.04065
| 0.036807
| 1.10443
|
[
"s766716549",
"s629217465"
] |
u619631862
|
p03292
|
python
|
s910099124
|
s623990399
| 190
| 165
| 38,496
| 38,384
|
Accepted
|
Accepted
| 13.16
|
def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
a=i2()
a.sort()
a=a[::-1]
print((a[0]-a[2]))
|
def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
a=i2()
b=[]
a.sort()
print((abs(a[0]-a[1])+abs(a[2]-a[1])))
| 8
| 8
| 132
| 148
|
def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
a = i2()
a.sort()
a = a[::-1]
print((a[0] - a[2]))
|
def i1():
return int(eval(input()))
def i2():
return [int(i) for i in input().split()]
a = i2()
b = []
a.sort()
print((abs(a[0] - a[1]) + abs(a[2] - a[1])))
| false
| 0
|
[
"+b = []",
"-a = a[::-1]",
"-print((a[0] - a[2]))",
"+print((abs(a[0] - a[1]) + abs(a[2] - a[1])))"
] | false
| 0.145609
| 0.123087
| 1.182982
|
[
"s910099124",
"s623990399"
] |
u544050502
|
p03543
|
python
|
s966907413
|
s841608038
| 19
| 17
| 2,940
| 2,940
|
Accepted
|
Accepted
| 10.53
|
N=eval(input())
answer="No"
for i in range(len(N)-2):
if N[i]==N[i+1]:
if N[i+1]==N[i+2]:
answer="Yes"
print(answer)
|
N=eval(input())
print(("Yes" if (N[0]==N[1]==N[2])or(N[1]==N[2]==N[3]) else "No" ))
| 7
| 2
| 128
| 76
|
N = eval(input())
answer = "No"
for i in range(len(N) - 2):
if N[i] == N[i + 1]:
if N[i + 1] == N[i + 2]:
answer = "Yes"
print(answer)
|
N = eval(input())
print(("Yes" if (N[0] == N[1] == N[2]) or (N[1] == N[2] == N[3]) else "No"))
| false
| 71.428571
|
[
"-answer = \"No\"",
"-for i in range(len(N) - 2):",
"- if N[i] == N[i + 1]:",
"- if N[i + 1] == N[i + 2]:",
"- answer = \"Yes\"",
"-print(answer)",
"+print((\"Yes\" if (N[0] == N[1] == N[2]) or (N[1] == N[2] == N[3]) else \"No\"))"
] | false
| 0.044942
| 0.044662
| 1.006281
|
[
"s966907413",
"s841608038"
] |
u256256172
|
p02416
|
python
|
s143471884
|
s257654986
| 60
| 20
| 7,660
| 7,648
|
Accepted
|
Accepted
| 66.67
|
while True:
n = list(eval(input()))
if n[0] == '0':
break
sum = 0
for i in n:
sum += int(i)
print(sum)
|
while True:
n = eval(input())
if n == '0':
break
sum = 0
for i in n:
sum += int(i)
print(sum)
| 8
| 8
| 139
| 130
|
while True:
n = list(eval(input()))
if n[0] == "0":
break
sum = 0
for i in n:
sum += int(i)
print(sum)
|
while True:
n = eval(input())
if n == "0":
break
sum = 0
for i in n:
sum += int(i)
print(sum)
| false
| 0
|
[
"- n = list(eval(input()))",
"- if n[0] == \"0\":",
"+ n = eval(input())",
"+ if n == \"0\":"
] | false
| 0.043965
| 0.039224
| 1.120865
|
[
"s143471884",
"s257654986"
] |
u562935282
|
p02755
|
python
|
s069821825
|
s575243768
| 22
| 17
| 3,064
| 3,060
|
Accepted
|
Accepted
| 22.73
|
def main():
A, B = list(map(int, input().split()))
for x in range(10000):
if int(x * 0.08) == A and int(x * 0.1) == B:
print(x)
return
print((-1))
if __name__ == '__main__':
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
|
def main():
from math import ceil
A, B = list(map(int, input().split()))
la, ra = ceil(A * 12.5), ceil((A + 1) * 12.5)
lb, rb = B * 10, (B + 1) * 10
L, R = max(la, lb), min(ra, rb) # [L,R)
if L >= R:
print((-1))
return
print(L)
if __name__ == '__main__':
main()
| 22
| 19
| 380
| 328
|
def main():
A, B = list(map(int, input().split()))
for x in range(10000):
if int(x * 0.08) == A and int(x * 0.1) == B:
print(x)
return
print((-1))
if __name__ == "__main__":
main()
# import sys
#
# sys.setrecursionlimit(10 ** 7)
#
# input = sys.stdin.readline
# rstrip()
# int(input())
# map(int, input().split())
|
def main():
from math import ceil
A, B = list(map(int, input().split()))
la, ra = ceil(A * 12.5), ceil((A + 1) * 12.5)
lb, rb = B * 10, (B + 1) * 10
L, R = max(la, lb), min(ra, rb) # [L,R)
if L >= R:
print((-1))
return
print(L)
if __name__ == "__main__":
main()
| false
| 13.636364
|
[
"+ from math import ceil",
"+",
"- for x in range(10000):",
"- if int(x * 0.08) == A and int(x * 0.1) == B:",
"- print(x)",
"- return",
"- print((-1))",
"+ la, ra = ceil(A * 12.5), ceil((A + 1) * 12.5)",
"+ lb, rb = B * 10, (B + 1) * 10",
"+ L, R = max(la, lb), min(ra, rb) # [L,R)",
"+ if L >= R:",
"+ print((-1))",
"+ return",
"+ print(L)",
"-# import sys",
"-#",
"-# sys.setrecursionlimit(10 ** 7)",
"-#",
"-# input = sys.stdin.readline",
"-# rstrip()",
"-# int(input())",
"-# map(int, input().split())"
] | false
| 0.042703
| 0.03683
| 1.159465
|
[
"s069821825",
"s575243768"
] |
u608088992
|
p03037
|
python
|
s434079804
|
s490104449
| 206
| 160
| 7,436
| 6,900
|
Accepted
|
Accepted
| 22.33
|
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input(): return F.readline().strip("\n")
def line_input(): return F.readline().strip("\n").split()
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b > 0: a, b = b, a % b
return b
def solve():
N, M = list(map(int, line_input()))
gate = [0 for n in range(N+1)]
for i in range(M):
l, r = list(map(int, line_input()))
gate[l-1] += 1
gate[r] -= 1
ans = (1 if gate[0] == M else 0)
for i in range(1, N):
gate[i] = gate[i] + gate[i-1]
if gate[i] == M: ans += 1
print(ans)
return 0
if __name__ == "__main__":
solve()
|
import sys
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
count = [0] * (N + 1)
for _ in range(M):
l, r = list(map(int, input().split()))
count[l - 1] += 1
count[r] -= 1
ans = (1 if count[0] == M else 0)
for i in range(1, N):
count[i] += count[i - 1]
if count[i] == M: ans += 1
print(ans)
return 0
if __name__ =="__main__":
solve()
| 25
| 20
| 687
| 449
|
import sys, math, collections, heapq, itertools
F = sys.stdin
def single_input():
return F.readline().strip("\n")
def line_input():
return F.readline().strip("\n").split()
def gcd(a, b):
a, b = max(a, b), min(a, b)
while a % b > 0:
a, b = b, a % b
return b
def solve():
N, M = list(map(int, line_input()))
gate = [0 for n in range(N + 1)]
for i in range(M):
l, r = list(map(int, line_input()))
gate[l - 1] += 1
gate[r] -= 1
ans = 1 if gate[0] == M else 0
for i in range(1, N):
gate[i] = gate[i] + gate[i - 1]
if gate[i] == M:
ans += 1
print(ans)
return 0
if __name__ == "__main__":
solve()
|
import sys
def solve():
input = sys.stdin.readline
N, M = list(map(int, input().split()))
count = [0] * (N + 1)
for _ in range(M):
l, r = list(map(int, input().split()))
count[l - 1] += 1
count[r] -= 1
ans = 1 if count[0] == M else 0
for i in range(1, N):
count[i] += count[i - 1]
if count[i] == M:
ans += 1
print(ans)
return 0
if __name__ == "__main__":
solve()
| false
| 20
|
[
"-import sys, math, collections, heapq, itertools",
"-",
"-F = sys.stdin",
"-",
"-",
"-def single_input():",
"- return F.readline().strip(\"\\n\")",
"-",
"-",
"-def line_input():",
"- return F.readline().strip(\"\\n\").split()",
"-",
"-",
"-def gcd(a, b):",
"- a, b = max(a, b), min(a, b)",
"- while a % b > 0:",
"- a, b = b, a % b",
"- return b",
"+import sys",
"- N, M = list(map(int, line_input()))",
"- gate = [0 for n in range(N + 1)]",
"- for i in range(M):",
"- l, r = list(map(int, line_input()))",
"- gate[l - 1] += 1",
"- gate[r] -= 1",
"- ans = 1 if gate[0] == M else 0",
"+ input = sys.stdin.readline",
"+ N, M = list(map(int, input().split()))",
"+ count = [0] * (N + 1)",
"+ for _ in range(M):",
"+ l, r = list(map(int, input().split()))",
"+ count[l - 1] += 1",
"+ count[r] -= 1",
"+ ans = 1 if count[0] == M else 0",
"- gate[i] = gate[i] + gate[i - 1]",
"- if gate[i] == M:",
"+ count[i] += count[i - 1]",
"+ if count[i] == M:"
] | false
| 0.046753
| 0.058314
| 0.80176
|
[
"s434079804",
"s490104449"
] |
u314188085
|
p02873
|
python
|
s730370126
|
s736526805
| 323
| 278
| 29,056
| 28,916
|
Accepted
|
Accepted
| 13.93
|
S = eval(input())
n = [0]*(len(S)+1)
if S[0]=='<':
n[0]==0
if S[-1]=='>':
n[-1]==0
for i in range(1,len(S)):
if S[i-1]=='<' and S[i]=='<':
n[i] = n[i-1]+1
n[i+1]=n[i]+1
elif S[i-1]=='>' and S[i]=='<':
n[i] = 0
n[i+1]=1
for i in range(len(S)-1,-1,-1):
if S[i]=='>':
n[i]=max(n[i],n[i+1]+1)
print((sum(n)))
|
S = eval(input())
n = [0]*(len(S)+1)
if S[0]=='<':
n[0]==0
for i in range(0,len(S)):
if S[i]=='>':
n[i+1]=0
else:
n[i+1]=n[i]+1
for i in range(len(S)-1,-1,-1):
if S[i]=='>':
n[i]=max(n[i],n[i+1]+1)
print((sum(n)))
| 20
| 16
| 394
| 279
|
S = eval(input())
n = [0] * (len(S) + 1)
if S[0] == "<":
n[0] == 0
if S[-1] == ">":
n[-1] == 0
for i in range(1, len(S)):
if S[i - 1] == "<" and S[i] == "<":
n[i] = n[i - 1] + 1
n[i + 1] = n[i] + 1
elif S[i - 1] == ">" and S[i] == "<":
n[i] = 0
n[i + 1] = 1
for i in range(len(S) - 1, -1, -1):
if S[i] == ">":
n[i] = max(n[i], n[i + 1] + 1)
print((sum(n)))
|
S = eval(input())
n = [0] * (len(S) + 1)
if S[0] == "<":
n[0] == 0
for i in range(0, len(S)):
if S[i] == ">":
n[i + 1] = 0
else:
n[i + 1] = n[i] + 1
for i in range(len(S) - 1, -1, -1):
if S[i] == ">":
n[i] = max(n[i], n[i + 1] + 1)
print((sum(n)))
| false
| 20
|
[
"-if S[-1] == \">\":",
"- n[-1] == 0",
"-for i in range(1, len(S)):",
"- if S[i - 1] == \"<\" and S[i] == \"<\":",
"- n[i] = n[i - 1] + 1",
"+for i in range(0, len(S)):",
"+ if S[i] == \">\":",
"+ n[i + 1] = 0",
"+ else:",
"- elif S[i - 1] == \">\" and S[i] == \"<\":",
"- n[i] = 0",
"- n[i + 1] = 1"
] | false
| 0.04208
| 0.046671
| 0.901642
|
[
"s730370126",
"s736526805"
] |
u186838327
|
p03645
|
python
|
s980062235
|
s965441851
| 930
| 358
| 49,112
| 108,128
|
Accepted
|
Accepted
| 61.51
|
n, m = list(map(int, input().split()))
l1 = [0]*n
l2 = [0]*n
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
if a == 0:
l1[b] = 1
elif b == n-1:
l2[a] = 1
else:
continue
for j in range(n):
if l1[j] == 1 and l2[j] == 1:
print('POSSIBLE')
exit()
else:
print('IMPOSSIBLE')
|
n, m = list(map(int, input().split()))
S = set()
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a-1, b-1
S.add((a, b))
for i in range(1, n-1):
if (0, i) in S and (i, n-1) in S:
print('POSSIBLE')
exit()
else:
print('IMPOSSIBLE')
| 21
| 13
| 343
| 283
|
n, m = list(map(int, input().split()))
l1 = [0] * n
l2 = [0] * n
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
if a == 0:
l1[b] = 1
elif b == n - 1:
l2[a] = 1
else:
continue
for j in range(n):
if l1[j] == 1 and l2[j] == 1:
print("POSSIBLE")
exit()
else:
print("IMPOSSIBLE")
|
n, m = list(map(int, input().split()))
S = set()
for i in range(m):
a, b = list(map(int, input().split()))
a, b = a - 1, b - 1
S.add((a, b))
for i in range(1, n - 1):
if (0, i) in S and (i, n - 1) in S:
print("POSSIBLE")
exit()
else:
print("IMPOSSIBLE")
| false
| 38.095238
|
[
"-l1 = [0] * n",
"-l2 = [0] * n",
"+S = set()",
"- if a == 0:",
"- l1[b] = 1",
"- elif b == n - 1:",
"- l2[a] = 1",
"- else:",
"- continue",
"-for j in range(n):",
"- if l1[j] == 1 and l2[j] == 1:",
"+ S.add((a, b))",
"+for i in range(1, n - 1):",
"+ if (0, i) in S and (i, n - 1) in S:"
] | false
| 0.04124
| 0.069607
| 0.592469
|
[
"s980062235",
"s965441851"
] |
u416758623
|
p03944
|
python
|
s680520097
|
s181745304
| 90
| 28
| 3,188
| 9,104
|
Accepted
|
Accepted
| 68.89
|
from operator import itemgetter
w, h, n = list(map(int, input().split()))
binary = [[0 for _ in range(h)] for i in range(w)]
for i in range(n):
x,y,a = list(map(int, input().split()))
if a == 1:
for j in range(x):
for k in range(h):
binary[j][k] += 1
elif a == 2:
for j in range(x,w):
for k in range(h):
binary[j][k] += 1
elif a == 3:
for j in range(w):
for k in range(y):
binary[j][k] += 1
elif a == 4:
for j in range(w):
for k in range(y,h):
binary[j][k] += 1
total = 0
for i in range(len(binary)):
total += binary[i].count(0)
print(total)
|
w, h, n = list(map(int, input().split()))
W = [1] * w
H = [1] * h
for i in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
for j in range(x):
W[j] = 0
elif a == 2:
for j in range(x, w):
W[j] = 0
elif a == 3:
for j in range(y):
H[j] = 0
elif a == 4:
for j in range(y, h):
H[j] = 0
print((sum(W) * sum(H)))
| 28
| 19
| 728
| 424
|
from operator import itemgetter
w, h, n = list(map(int, input().split()))
binary = [[0 for _ in range(h)] for i in range(w)]
for i in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
for j in range(x):
for k in range(h):
binary[j][k] += 1
elif a == 2:
for j in range(x, w):
for k in range(h):
binary[j][k] += 1
elif a == 3:
for j in range(w):
for k in range(y):
binary[j][k] += 1
elif a == 4:
for j in range(w):
for k in range(y, h):
binary[j][k] += 1
total = 0
for i in range(len(binary)):
total += binary[i].count(0)
print(total)
|
w, h, n = list(map(int, input().split()))
W = [1] * w
H = [1] * h
for i in range(n):
x, y, a = list(map(int, input().split()))
if a == 1:
for j in range(x):
W[j] = 0
elif a == 2:
for j in range(x, w):
W[j] = 0
elif a == 3:
for j in range(y):
H[j] = 0
elif a == 4:
for j in range(y, h):
H[j] = 0
print((sum(W) * sum(H)))
| false
| 32.142857
|
[
"-from operator import itemgetter",
"-",
"-binary = [[0 for _ in range(h)] for i in range(w)]",
"+W = [1] * w",
"+H = [1] * h",
"- for k in range(h):",
"- binary[j][k] += 1",
"+ W[j] = 0",
"- for k in range(h):",
"- binary[j][k] += 1",
"+ W[j] = 0",
"- for j in range(w):",
"- for k in range(y):",
"- binary[j][k] += 1",
"+ for j in range(y):",
"+ H[j] = 0",
"- for j in range(w):",
"- for k in range(y, h):",
"- binary[j][k] += 1",
"-total = 0",
"-for i in range(len(binary)):",
"- total += binary[i].count(0)",
"-print(total)",
"+ for j in range(y, h):",
"+ H[j] = 0",
"+print((sum(W) * sum(H)))"
] | false
| 0.105566
| 0.143097
| 0.73772
|
[
"s680520097",
"s181745304"
] |
u561231954
|
p03329
|
python
|
s238047340
|
s100932649
| 539
| 267
| 29,428
| 12,676
|
Accepted
|
Accepted
| 50.46
|
def main():
n=int(eval(input()))
mon6=[6]
mon9=[1]
for i in range(5):
mon6.append(6*mon6[i])
mon9.append(9*mon9[i])
mon=mon6+mon9
mon.sort()
inf=10**9
dp=[[inf]*(n+1) for i in range(13)]
for i in range(13):
dp[i][0]=0
for i in range(12):
for j in range(1,n+1):
if j-mon[i]>=0:
dp[i+1][j]=min(dp[i+1][j-mon[i]]+1,dp[i][j])
else:
dp[i+1][j]=dp[i][j]
print((dp[-1][-1]))
if __name__=='__main__':
main()
|
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
N = int(eval(input()))
money = [1]
for i in range(10):
money.append(money[-1]*6)
money.append(9)
for i in range(9):
money.append(money[-1]*9)
dp = [INF] * (1 + N)
dp[0] = 0
for m in money:
for j in range(m,N + 1):
dp[j] = min(dp[j],dp[j - m] + 1)
ans = dp[-1]
print(ans)
if __name__ == '__main__':
main()
| 25
| 23
| 565
| 494
|
def main():
n = int(eval(input()))
mon6 = [6]
mon9 = [1]
for i in range(5):
mon6.append(6 * mon6[i])
mon9.append(9 * mon9[i])
mon = mon6 + mon9
mon.sort()
inf = 10**9
dp = [[inf] * (n + 1) for i in range(13)]
for i in range(13):
dp[i][0] = 0
for i in range(12):
for j in range(1, n + 1):
if j - mon[i] >= 0:
dp[i + 1][j] = min(dp[i + 1][j - mon[i]] + 1, dp[i][j])
else:
dp[i + 1][j] = dp[i][j]
print((dp[-1][-1]))
if __name__ == "__main__":
main()
|
import sys
sys.setrecursionlimit(10000000)
MOD = 10**9 + 7
INF = 10**15
def main():
N = int(eval(input()))
money = [1]
for i in range(10):
money.append(money[-1] * 6)
money.append(9)
for i in range(9):
money.append(money[-1] * 9)
dp = [INF] * (1 + N)
dp[0] = 0
for m in money:
for j in range(m, N + 1):
dp[j] = min(dp[j], dp[j - m] + 1)
ans = dp[-1]
print(ans)
if __name__ == "__main__":
main()
| false
| 8
|
[
"+import sys",
"+",
"+sys.setrecursionlimit(10000000)",
"+MOD = 10**9 + 7",
"+INF = 10**15",
"+",
"+",
"- n = int(eval(input()))",
"- mon6 = [6]",
"- mon9 = [1]",
"- for i in range(5):",
"- mon6.append(6 * mon6[i])",
"- mon9.append(9 * mon9[i])",
"- mon = mon6 + mon9",
"- mon.sort()",
"- inf = 10**9",
"- dp = [[inf] * (n + 1) for i in range(13)]",
"- for i in range(13):",
"- dp[i][0] = 0",
"- for i in range(12):",
"- for j in range(1, n + 1):",
"- if j - mon[i] >= 0:",
"- dp[i + 1][j] = min(dp[i + 1][j - mon[i]] + 1, dp[i][j])",
"- else:",
"- dp[i + 1][j] = dp[i][j]",
"- print((dp[-1][-1]))",
"+ N = int(eval(input()))",
"+ money = [1]",
"+ for i in range(10):",
"+ money.append(money[-1] * 6)",
"+ money.append(9)",
"+ for i in range(9):",
"+ money.append(money[-1] * 9)",
"+ dp = [INF] * (1 + N)",
"+ dp[0] = 0",
"+ for m in money:",
"+ for j in range(m, N + 1):",
"+ dp[j] = min(dp[j], dp[j - m] + 1)",
"+ ans = dp[-1]",
"+ print(ans)"
] | false
| 0.093595
| 0.068167
| 1.373027
|
[
"s238047340",
"s100932649"
] |
u564525445
|
p02678
|
python
|
s512377529
|
s081139689
| 1,638
| 564
| 120,224
| 35,668
|
Accepted
|
Accepted
| 65.57
|
N, M = list(map(int, input().split()))
A, B = [], []
graph = [[] for i in range(N+1)]
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
graph[a].append(b)
graph[b].append(a)
class Rs():
def __init__(self):
self.Rs = []
def append(self, R):
self.Rs.append(R)
def search(self):
count = 1
new_nodes, count = self._search(1, count)
while count < N:
_new_nodes = set()
for num in new_nodes:
_new_node, count = self._search(num, count)
_new_nodes.update(_new_node)
new_nodes = _new_nodes
return [ self.Rs[i].fastest_room for i in range(1,len(self.Rs)) ]
def _search(self, num, count):
r = self.Rs[num-1]
cons = r.connection
new_nodes = set()
cons -= r.searched_from
for con in cons:
if len(self.Rs[con-1].searched_from) == 0:
self.Rs[con-1].fastest_room = num
self.Rs[con-1].searched_from.add(num)
new_nodes.add(con)
count += 1
else:
continue
return new_nodes, count
class R():
def __init__(self, num, connection):
self.num = num
self.connection = connection
self.searched_from = set([])
self.fastest_room = None
r = Rs()
for i in range(N):
r.append(R(i+1, set(graph[i+1])))
l = r.search()
print("Yes")
for room in l:
print(room)
|
from collections import deque
N, M = list(map(int, input().split()))
A, B = [], []
graph = [[] for i in range(N+1)]
for i in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
visited = [False for i in range(N+1)]
signs = [-1 for i in range(N+1)]
D = deque([1])
while D:
n = D.popleft()
for node in graph[n]:
if visited[node] is True:
continue
else:
visited[node] = True
signs[node] = n
D.append(node)
print("Yes")
for sign in signs[2:]:
print(sign)
| 61
| 26
| 1,569
| 592
|
N, M = list(map(int, input().split()))
A, B = [], []
graph = [[] for i in range(N + 1)]
for i in range(M):
a, b = list(map(int, input().split()))
A.append(a)
B.append(b)
graph[a].append(b)
graph[b].append(a)
class Rs:
def __init__(self):
self.Rs = []
def append(self, R):
self.Rs.append(R)
def search(self):
count = 1
new_nodes, count = self._search(1, count)
while count < N:
_new_nodes = set()
for num in new_nodes:
_new_node, count = self._search(num, count)
_new_nodes.update(_new_node)
new_nodes = _new_nodes
return [self.Rs[i].fastest_room for i in range(1, len(self.Rs))]
def _search(self, num, count):
r = self.Rs[num - 1]
cons = r.connection
new_nodes = set()
cons -= r.searched_from
for con in cons:
if len(self.Rs[con - 1].searched_from) == 0:
self.Rs[con - 1].fastest_room = num
self.Rs[con - 1].searched_from.add(num)
new_nodes.add(con)
count += 1
else:
continue
return new_nodes, count
class R:
def __init__(self, num, connection):
self.num = num
self.connection = connection
self.searched_from = set([])
self.fastest_room = None
r = Rs()
for i in range(N):
r.append(R(i + 1, set(graph[i + 1])))
l = r.search()
print("Yes")
for room in l:
print(room)
|
from collections import deque
N, M = list(map(int, input().split()))
A, B = [], []
graph = [[] for i in range(N + 1)]
for i in range(M):
a, b = list(map(int, input().split()))
graph[a].append(b)
graph[b].append(a)
visited = [False for i in range(N + 1)]
signs = [-1 for i in range(N + 1)]
D = deque([1])
while D:
n = D.popleft()
for node in graph[n]:
if visited[node] is True:
continue
else:
visited[node] = True
signs[node] = n
D.append(node)
print("Yes")
for sign in signs[2:]:
print(sign)
| false
| 57.377049
|
[
"+from collections import deque",
"+",
"- A.append(a)",
"- B.append(b)",
"-",
"-",
"-class Rs:",
"- def __init__(self):",
"- self.Rs = []",
"-",
"- def append(self, R):",
"- self.Rs.append(R)",
"-",
"- def search(self):",
"- count = 1",
"- new_nodes, count = self._search(1, count)",
"- while count < N:",
"- _new_nodes = set()",
"- for num in new_nodes:",
"- _new_node, count = self._search(num, count)",
"- _new_nodes.update(_new_node)",
"- new_nodes = _new_nodes",
"- return [self.Rs[i].fastest_room for i in range(1, len(self.Rs))]",
"-",
"- def _search(self, num, count):",
"- r = self.Rs[num - 1]",
"- cons = r.connection",
"- new_nodes = set()",
"- cons -= r.searched_from",
"- for con in cons:",
"- if len(self.Rs[con - 1].searched_from) == 0:",
"- self.Rs[con - 1].fastest_room = num",
"- self.Rs[con - 1].searched_from.add(num)",
"- new_nodes.add(con)",
"- count += 1",
"- else:",
"- continue",
"- return new_nodes, count",
"-",
"-",
"-class R:",
"- def __init__(self, num, connection):",
"- self.num = num",
"- self.connection = connection",
"- self.searched_from = set([])",
"- self.fastest_room = None",
"-",
"-",
"-r = Rs()",
"-for i in range(N):",
"- r.append(R(i + 1, set(graph[i + 1])))",
"-l = r.search()",
"+visited = [False for i in range(N + 1)]",
"+signs = [-1 for i in range(N + 1)]",
"+D = deque([1])",
"+while D:",
"+ n = D.popleft()",
"+ for node in graph[n]:",
"+ if visited[node] is True:",
"+ continue",
"+ else:",
"+ visited[node] = True",
"+ signs[node] = n",
"+ D.append(node)",
"-for room in l:",
"- print(room)",
"+for sign in signs[2:]:",
"+ print(sign)"
] | false
| 0.127547
| 0.038565
| 3.307327
|
[
"s512377529",
"s081139689"
] |
u021019433
|
p02959
|
python
|
s475567297
|
s221775916
| 170
| 143
| 16,576
| 16,044
|
Accepted
|
Accepted
| 15.88
|
R = lambda: list(map(int, input().split()))
eval(input())
a, b = list(R()), R()
r = 0
for i, u in enumerate(b):
x = min(a[i], u)
y = min(a[i + 1], u - x)
a[i + 1] -= y
r += x + y
print(r)
|
R = lambda: list(map(int, input().split()))
eval(input())
a, b = list(R()), R()
r = y = 0
for u, v, w in zip(b, a, a[1:]):
x = min(v - y, u)
y = min(w, u - x)
r += x + y
print(r)
| 10
| 9
| 201
| 187
|
R = lambda: list(map(int, input().split()))
eval(input())
a, b = list(R()), R()
r = 0
for i, u in enumerate(b):
x = min(a[i], u)
y = min(a[i + 1], u - x)
a[i + 1] -= y
r += x + y
print(r)
|
R = lambda: list(map(int, input().split()))
eval(input())
a, b = list(R()), R()
r = y = 0
for u, v, w in zip(b, a, a[1:]):
x = min(v - y, u)
y = min(w, u - x)
r += x + y
print(r)
| false
| 10
|
[
"-r = 0",
"-for i, u in enumerate(b):",
"- x = min(a[i], u)",
"- y = min(a[i + 1], u - x)",
"- a[i + 1] -= y",
"+r = y = 0",
"+for u, v, w in zip(b, a, a[1:]):",
"+ x = min(v - y, u)",
"+ y = min(w, u - x)"
] | false
| 0.036528
| 0.033267
| 1.098039
|
[
"s475567297",
"s221775916"
] |
u546285759
|
p00433
|
python
|
s670271414
|
s053127752
| 30
| 20
| 7,732
| 7,692
|
Accepted
|
Accepted
| 33.33
|
scores = [list(map(int, input().split())) for _ in range(2)]
print((max(sum(scores[0]), sum(scores[1]))))
|
print((max(sum(map(int, input().split())), sum(map(int, input().split())))))
| 2
| 1
| 104
| 74
|
scores = [list(map(int, input().split())) for _ in range(2)]
print((max(sum(scores[0]), sum(scores[1]))))
|
print((max(sum(map(int, input().split())), sum(map(int, input().split())))))
| false
| 50
|
[
"-scores = [list(map(int, input().split())) for _ in range(2)]",
"-print((max(sum(scores[0]), sum(scores[1]))))",
"+print((max(sum(map(int, input().split())), sum(map(int, input().split())))))"
] | false
| 0.084703
| 0.064628
| 1.310627
|
[
"s670271414",
"s053127752"
] |
u394721319
|
p02994
|
python
|
s884792170
|
s266888085
| 175
| 28
| 38,256
| 9,160
|
Accepted
|
Accepted
| 84
|
N,L = [int(i) for i in input().split()]
A = [L+i for i in range(N)]
tmp = 1000
ind = 0
for i in range(N):
if tmp > abs(A[i]):
tmp = abs(A[i])
ind = i
print((sum(A)-A[ind]))
|
N,L = [int(i) for i in input().split()]
A = [i+L-1 for i in range(1,N+1)]
B = [abs(i+L-1) for i in range(1,N+1)]
print((sum(A)-A[B.index(min(B))]))
| 11
| 6
| 203
| 153
|
N, L = [int(i) for i in input().split()]
A = [L + i for i in range(N)]
tmp = 1000
ind = 0
for i in range(N):
if tmp > abs(A[i]):
tmp = abs(A[i])
ind = i
print((sum(A) - A[ind]))
|
N, L = [int(i) for i in input().split()]
A = [i + L - 1 for i in range(1, N + 1)]
B = [abs(i + L - 1) for i in range(1, N + 1)]
print((sum(A) - A[B.index(min(B))]))
| false
| 45.454545
|
[
"-A = [L + i for i in range(N)]",
"-tmp = 1000",
"-ind = 0",
"-for i in range(N):",
"- if tmp > abs(A[i]):",
"- tmp = abs(A[i])",
"- ind = i",
"-print((sum(A) - A[ind]))",
"+A = [i + L - 1 for i in range(1, N + 1)]",
"+B = [abs(i + L - 1) for i in range(1, N + 1)]",
"+print((sum(A) - A[B.index(min(B))]))"
] | false
| 0.04073
| 0.033442
| 1.217918
|
[
"s884792170",
"s266888085"
] |
u729133443
|
p03238
|
python
|
s257819133
|
s072317399
| 21
| 17
| 3,316
| 3,064
|
Accepted
|
Accepted
| 19.05
|
def toInteger(string):
integer = int(string)
return integer
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString('Hello World')
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
a = myInput()
solve(a)
|
def toInteger(string):
try:
integer = int(string)
return integer
except:
print('Number Format Exception')
exit()
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString('Hello World')
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
def main():
a = myInput()
solve(a)
main()
| 62
| 69
| 1,089
| 1,191
|
def toInteger(string):
integer = int(string)
return integer
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString("Hello World")
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
a = myInput()
solve(a)
|
def toInteger(string):
try:
integer = int(string)
return integer
except:
print("Number Format Exception")
exit()
def myInput():
s = eval(input())
i = toInteger(s)
return i
def isEqual(a, b):
try:
1 / (a - b)
except:
return True
return False
def isValue1(v):
boolean = isEqual(v, 1)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def isValue2(v):
boolean = isEqual(v, 2)
if isEqual(boolean, True) == True:
return True
elif isEqual(boolean, False) == True:
return False
else:
None
def printString(String):
print(String)
def printHelloWorld():
printString("Hello World")
def printInteger(integer):
print(integer)
def sumTwoValues(a, b):
c = a + b
return c
def solve(v):
boolean1 = isValue1(v)
boolean2 = isValue2(v)
if isEqual(boolean1, True) == True:
printHelloWorld()
elif isEqual(boolean2, True) == True:
a = myInput()
b = myInput()
c = sumTwoValues(a, b)
printInteger(c)
else:
None
def main():
a = myInput()
solve(a)
main()
| false
| 10.144928
|
[
"- integer = int(string)",
"- return integer",
"+ try:",
"+ integer = int(string)",
"+ return integer",
"+ except:",
"+ print(\"Number Format Exception\")",
"+ exit()",
"-a = myInput()",
"-solve(a)",
"+def main():",
"+ a = myInput()",
"+ solve(a)",
"+",
"+",
"+main()"
] | false
| 0.045311
| 0.124277
| 0.364599
|
[
"s257819133",
"s072317399"
] |
u254871849
|
p02987
|
python
|
s340405127
|
s804367277
| 21
| 17
| 3,316
| 2,940
|
Accepted
|
Accepted
| 19.05
|
# 2019-11-15 00:35:39(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():
s = sys.stdin.readline().rstrip()
for v in list(collections.Counter(s).values()):
if v == 2:
continue
else:
ans = 'No'
break
else:
ans = 'Yes'
print(ans)
if __name__ == "__main__":
main()
|
import sys
s = sys.stdin.readline().rstrip()
def main():
for char in set(s):
if s.count(char) != 2:
return 'No'
return 'Yes'
if __name__ == '__main__':
ans = main()
print(ans)
| 27
| 13
| 633
| 226
|
# 2019-11-15 00:35:39(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():
s = sys.stdin.readline().rstrip()
for v in list(collections.Counter(s).values()):
if v == 2:
continue
else:
ans = "No"
break
else:
ans = "Yes"
print(ans)
if __name__ == "__main__":
main()
|
import sys
s = sys.stdin.readline().rstrip()
def main():
for char in set(s):
if s.count(char) != 2:
return "No"
return "Yes"
if __name__ == "__main__":
ans = main()
print(ans)
| false
| 51.851852
|
[
"-# 2019-11-15 00:35:39(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",
"+s = sys.stdin.readline().rstrip()",
"+",
"+",
"- s = sys.stdin.readline().rstrip()",
"- for v in list(collections.Counter(s).values()):",
"- if v == 2:",
"- continue",
"- else:",
"- ans = \"No\"",
"- break",
"- else:",
"- ans = \"Yes\"",
"- print(ans)",
"+ for char in set(s):",
"+ if s.count(char) != 2:",
"+ return \"No\"",
"+ return \"Yes\"",
"- main()",
"+ ans = main()",
"+ print(ans)"
] | false
| 0.055236
| 0.035846
| 1.540916
|
[
"s340405127",
"s804367277"
] |
u883621917
|
p02831
|
python
|
s265822925
|
s091687830
| 183
| 63
| 38,640
| 61,416
|
Accepted
|
Accepted
| 65.57
|
import sys
input = sys.stdin.readline
a, b = [int(i) for i in input().split()]
small = min(a,b)
big = max(a,b)
multi = 1
ans = big
while True:
ans = big * multi
if (ans % small) == 0:
break
multi += 1
print(ans)
|
import sys
iput = sys.stdin.readline
sys.setrecursionlimit(10 ** 7)
a, b = list(map(int, input().split()))
def gcd(big, small):
if small == 0:
return big
else:
return gcd(small, big % small)
# gcd(a, b) * lcm(a, b) == a * b
def lcm(a, b):
# 除算を先にしてオーバーフローのリスクを軽減する
# FYI: https://qiita.com/drken/items/0c88a37eec520f82b788#2-2-%E5%8D%98%E7%B4%94%E3%81%AA%E6%9C%80%E5%B0%8F%E5%85%AC%E5%80%8D%E6%95%B0%E3%82%B2%E3%83%BC
return (a // gcd(a, b)) * b
print((lcm(a, b)))
| 16
| 19
| 250
| 515
|
import sys
input = sys.stdin.readline
a, b = [int(i) for i in input().split()]
small = min(a, b)
big = max(a, b)
multi = 1
ans = big
while True:
ans = big * multi
if (ans % small) == 0:
break
multi += 1
print(ans)
|
import sys
iput = sys.stdin.readline
sys.setrecursionlimit(10**7)
a, b = list(map(int, input().split()))
def gcd(big, small):
if small == 0:
return big
else:
return gcd(small, big % small)
# gcd(a, b) * lcm(a, b) == a * b
def lcm(a, b):
# 除算を先にしてオーバーフローのリスクを軽減する
# FYI: https://qiita.com/drken/items/0c88a37eec520f82b788#2-2-%E5%8D%98%E7%B4%94%E3%81%AA%E6%9C%80%E5%B0%8F%E5%85%AC%E5%80%8D%E6%95%B0%E3%82%B2%E3%83%BC
return (a // gcd(a, b)) * b
print((lcm(a, b)))
| false
| 15.789474
|
[
"-input = sys.stdin.readline",
"-a, b = [int(i) for i in input().split()]",
"-small = min(a, b)",
"-big = max(a, b)",
"-multi = 1",
"-ans = big",
"-while True:",
"- ans = big * multi",
"- if (ans % small) == 0:",
"- break",
"- multi += 1",
"-print(ans)",
"+iput = sys.stdin.readline",
"+sys.setrecursionlimit(10**7)",
"+a, b = list(map(int, input().split()))",
"+",
"+",
"+def gcd(big, small):",
"+ if small == 0:",
"+ return big",
"+ else:",
"+ return gcd(small, big % small)",
"+",
"+",
"+# gcd(a, b) * lcm(a, b) == a * b",
"+def lcm(a, b):",
"+ # 除算を先にしてオーバーフローのリスクを軽減する",
"+ # FYI: https://qiita.com/drken/items/0c88a37eec520f82b788#2-2-%E5%8D%98%E7%B4%94%E3%81%AA%E6%9C%80%E5%B0%8F%E5%85%AC%E5%80%8D%E6%95%B0%E3%82%B2%E3%83%BC",
"+ return (a // gcd(a, b)) * b",
"+",
"+",
"+print((lcm(a, b)))"
] | false
| 0.09975
| 0.085259
| 1.16997
|
[
"s265822925",
"s091687830"
] |
u941047297
|
p03545
|
python
|
s698543486
|
s510720818
| 180
| 20
| 38,256
| 3,060
|
Accepted
|
Accepted
| 88.89
|
S = list(eval(input()))
for i in range(2 ** 3):
pm = ['-'] * 3
for j in range(3):
if i >> j & 1:
pm[j] = '+'
ans = [None] * 7
ans[::2] = S
ans[1::2] = pm
ans = ''.join(ans)
if eval(ans) == 7:
print((ans + '=7'))
break
|
n = eval(input())
for i in range(2 ** 3):
op = ['+'] * 3
for j in range(3):
if i >> j & 1:
op[j] = '-'
f = [0] * 7
f[::2] = n
f[1::2] = op
f = ''.join(f)
if eval(f) == 7:
print((''.join([f, '=7'])))
exit()
| 13
| 13
| 285
| 274
|
S = list(eval(input()))
for i in range(2**3):
pm = ["-"] * 3
for j in range(3):
if i >> j & 1:
pm[j] = "+"
ans = [None] * 7
ans[::2] = S
ans[1::2] = pm
ans = "".join(ans)
if eval(ans) == 7:
print((ans + "=7"))
break
|
n = eval(input())
for i in range(2**3):
op = ["+"] * 3
for j in range(3):
if i >> j & 1:
op[j] = "-"
f = [0] * 7
f[::2] = n
f[1::2] = op
f = "".join(f)
if eval(f) == 7:
print(("".join([f, "=7"])))
exit()
| false
| 0
|
[
"-S = list(eval(input()))",
"+n = eval(input())",
"- pm = [\"-\"] * 3",
"+ op = [\"+\"] * 3",
"- pm[j] = \"+\"",
"- ans = [None] * 7",
"- ans[::2] = S",
"- ans[1::2] = pm",
"- ans = \"\".join(ans)",
"- if eval(ans) == 7:",
"- print((ans + \"=7\"))",
"- break",
"+ op[j] = \"-\"",
"+ f = [0] * 7",
"+ f[::2] = n",
"+ f[1::2] = op",
"+ f = \"\".join(f)",
"+ if eval(f) == 7:",
"+ print((\"\".join([f, \"=7\"])))",
"+ exit()"
] | false
| 0.083299
| 0.037355
| 2.229929
|
[
"s698543486",
"s510720818"
] |
u092301301
|
p02714
|
python
|
s570129745
|
s652317934
| 1,997
| 139
| 27,240
| 68,684
|
Accepted
|
Accepted
| 93.04
|
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline
def I(): return list(map(int,inp().split()))
from collections import Counter
from numpy import prod
n=I()[0]
s=eval(input())
cut=0
for i in range(len(s)):
for j in range(i+1,len(s)):
if 2*j-i>=len(s): break
if len({s[i],s[j],s[2*j-i]})==3:
cut+=1
d=Counter(s)
if len(d)<3: print((0))
else: print((prod(list(d.values()))-cut))
|
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline
def I(): return list(map(int,inp().split()))
from collections import Counter
n=I()[0]
s=eval(input())
cut=0
for i in range(len(s)):
for j in range(i+1,len(s)):
if 2*j-i>=len(s): break
if not(s[i]==s[j] or s[i]==s[2*j-i] or s[j]==s[2*j-i]):
cut+=1
d=Counter(s) ; mul=1
for i in list(d.values()):
mul*=i
if len(d)<3: print((0))
else: print((mul-cut))
| 19
| 22
| 489
| 528
|
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline
def I():
return list(map(int, inp().split()))
from collections import Counter
from numpy import prod
n = I()[0]
s = eval(input())
cut = 0
for i in range(len(s)):
for j in range(i + 1, len(s)):
if 2 * j - i >= len(s):
break
if len({s[i], s[j], s[2 * j - i]}) == 3:
cut += 1
d = Counter(s)
if len(d) < 3:
print((0))
else:
print((prod(list(d.values())) - cut))
|
import sys
input = lambda: sys.stdin.readline().rstrip()
inp = sys.stdin.buffer.readline
def I():
return list(map(int, inp().split()))
from collections import Counter
n = I()[0]
s = eval(input())
cut = 0
for i in range(len(s)):
for j in range(i + 1, len(s)):
if 2 * j - i >= len(s):
break
if not (s[i] == s[j] or s[i] == s[2 * j - i] or s[j] == s[2 * j - i]):
cut += 1
d = Counter(s)
mul = 1
for i in list(d.values()):
mul *= i
if len(d) < 3:
print((0))
else:
print((mul - cut))
| false
| 13.636364
|
[
"-from numpy import prod",
"- if len({s[i], s[j], s[2 * j - i]}) == 3:",
"+ if not (s[i] == s[j] or s[i] == s[2 * j - i] or s[j] == s[2 * j - i]):",
"+mul = 1",
"+for i in list(d.values()):",
"+ mul *= i",
"- print((prod(list(d.values())) - cut))",
"+ print((mul - cut))"
] | false
| 0.451749
| 0.035908
| 12.580902
|
[
"s570129745",
"s652317934"
] |
u070201429
|
p02662
|
python
|
s896467308
|
s065596990
| 1,943
| 142
| 182,736
| 72,172
|
Accepted
|
Accepted
| 92.69
|
mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
while a[-1] > s:
a.pop(-1)
if a == []:
print((0))
exit()
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
newdp = [2 * j for j in dp]
for j in range(s - i + 1):
newdp[j+i] += dp[j]
dp = newdp
print((dp[s] * pow(2, n - len(a), mod) % mod))
|
mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
while a[-1] > s:
a.pop(-1)
if a == []:
print((0))
exit()
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
newdp = [2 * j % mod for j in dp]
for j in range(s - i + 1):
newdp[j+i] += dp[j]
dp = newdp
print((dp[s] * pow(2, n - len(a), mod) % mod))
| 22
| 22
| 390
| 396
|
mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
while a[-1] > s:
a.pop(-1)
if a == []:
print((0))
exit()
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
newdp = [2 * j for j in dp]
for j in range(s - i + 1):
newdp[j + i] += dp[j]
dp = newdp
print((dp[s] * pow(2, n - len(a), mod) % mod))
|
mod = 998244353
n, s = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
while a[-1] > s:
a.pop(-1)
if a == []:
print((0))
exit()
dp = [0] * (s + 1)
dp[0] = 1
for i in a:
newdp = [2 * j % mod for j in dp]
for j in range(s - i + 1):
newdp[j + i] += dp[j]
dp = newdp
print((dp[s] * pow(2, n - len(a), mod) % mod))
| false
| 0
|
[
"- newdp = [2 * j for j in dp]",
"+ newdp = [2 * j % mod for j in dp]"
] | false
| 0.07626
| 0.035468
| 2.15011
|
[
"s896467308",
"s065596990"
] |
u251515715
|
p03309
|
python
|
s540765122
|
s352728407
| 787
| 718
| 136,916
| 137,088
|
Accepted
|
Accepted
| 8.77
|
n=int(eval(input()))
a=list(map(int,input().split()))
b_low=-1*(10**12)
b_high=10**12
b_low_d=sum([abs(a[i]-(b_low+2+i)) for i in range(n)])-sum([abs(a[i]-(b_low+1+i)) for i in range(n)])
b_high_d=sum([abs(a[i]-(b_high+2+i)) for i in range(n)])-sum([abs(a[i]-(b_high+1+i)) for i in range(n)])
while b_high-b_low>10:
b_tmp=(b_low+b_high)//2
b_tmp_d=sum([abs(a[i]-(b_tmp+2+i)) for i in range(n)])-sum([abs(a[i]-(b_tmp+1+i)) for i in range(n)])
if b_tmp_d>0:
b_high=b_tmp
else:
b_low=b_tmp
ans=10**20
for j in range(b_low,b_high):
ans=min(ans,sum([abs(a[i]-(j+2+i)) for i in range(n)]))
print(ans)
|
n=int(eval(input()))
a=list(map(int,input().split()))
b_low=-1*(10**10)
b_high=10**10
b_low_d=sum([abs(a[i]-(b_low+2+i)) for i in range(n)])-sum([abs(a[i]-(b_low+1+i)) for i in range(n)])
b_high_d=sum([abs(a[i]-(b_high+2+i)) for i in range(n)])-sum([abs(a[i]-(b_high+1+i)) for i in range(n)])
while b_high-b_low>10:
b_tmp=(b_low+b_high)//2
b_tmp_d=sum([abs(a[i]-(b_tmp+2+i)) for i in range(n)])-sum([abs(a[i]-(b_tmp+1+i)) for i in range(n)])
if b_tmp_d>0:
b_high=b_tmp
else:
b_low=b_tmp
ans=10**20
for j in range(b_low,b_high):
ans=min(ans,sum([abs(a[i]-(j+2+i)) for i in range(n)]))
print(ans)
| 21
| 21
| 630
| 630
|
n = int(eval(input()))
a = list(map(int, input().split()))
b_low = -1 * (10**12)
b_high = 10**12
b_low_d = sum([abs(a[i] - (b_low + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_low + 1 + i)) for i in range(n)]
)
b_high_d = sum([abs(a[i] - (b_high + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_high + 1 + i)) for i in range(n)]
)
while b_high - b_low > 10:
b_tmp = (b_low + b_high) // 2
b_tmp_d = sum([abs(a[i] - (b_tmp + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_tmp + 1 + i)) for i in range(n)]
)
if b_tmp_d > 0:
b_high = b_tmp
else:
b_low = b_tmp
ans = 10**20
for j in range(b_low, b_high):
ans = min(ans, sum([abs(a[i] - (j + 2 + i)) for i in range(n)]))
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
b_low = -1 * (10**10)
b_high = 10**10
b_low_d = sum([abs(a[i] - (b_low + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_low + 1 + i)) for i in range(n)]
)
b_high_d = sum([abs(a[i] - (b_high + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_high + 1 + i)) for i in range(n)]
)
while b_high - b_low > 10:
b_tmp = (b_low + b_high) // 2
b_tmp_d = sum([abs(a[i] - (b_tmp + 2 + i)) for i in range(n)]) - sum(
[abs(a[i] - (b_tmp + 1 + i)) for i in range(n)]
)
if b_tmp_d > 0:
b_high = b_tmp
else:
b_low = b_tmp
ans = 10**20
for j in range(b_low, b_high):
ans = min(ans, sum([abs(a[i] - (j + 2 + i)) for i in range(n)]))
print(ans)
| false
| 0
|
[
"-b_low = -1 * (10**12)",
"-b_high = 10**12",
"+b_low = -1 * (10**10)",
"+b_high = 10**10"
] | false
| 0.106548
| 0.04041
| 2.636685
|
[
"s540765122",
"s352728407"
] |
u489959379
|
p03645
|
python
|
s939035005
|
s956588879
| 1,847
| 732
| 89,056
| 38,320
|
Accepted
|
Accepted
| 60.37
|
import sys
import heapq
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append([1, b - 1])
edge[b - 1].append([1, a - 1])
# ダイクストラ法：O(ElogV)
def dijkstra_heap(s):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
# まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist, [e[0] + d[v], e[1]])
return d
L = dijkstra_heap(n - 1)
if L[0] <= 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
resolve()
|
# https://atcoder.jp/contests/abc068/submissions/12987221
# C - Cat Snuke and a Voyage
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
for i in edge[0]:
if n - 1 in set(edge[i]):
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
if __name__ == '__main__':
resolve()
| 50
| 28
| 1,210
| 603
|
import sys
import heapq
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append([1, b - 1])
edge[b - 1].append([1, a - 1])
# ダイクストラ法：O(ElogV)
def dijkstra_heap(s):
# 始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n # True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist, e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
# まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist, [e[0] + d[v], e[1]])
return d
L = dijkstra_heap(n - 1)
if L[0] <= 2:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == "__main__":
resolve()
|
# https://atcoder.jp/contests/abc068/submissions/12987221
# C - Cat Snuke and a Voyage
import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n, m = list(map(int, input().split()))
edge = [[] for _ in range(n)]
for _ in range(m):
a, b = list(map(int, input().split()))
edge[a - 1].append(b - 1)
edge[b - 1].append(a - 1)
for i in edge[0]:
if n - 1 in set(edge[i]):
print("POSSIBLE")
break
else:
print("IMPOSSIBLE")
if __name__ == "__main__":
resolve()
| false
| 44
|
[
"+# https://atcoder.jp/contests/abc068/submissions/12987221",
"+# C - Cat Snuke and a Voyage",
"-import heapq",
"- edge[a - 1].append([1, b - 1])",
"- edge[b - 1].append([1, a - 1])",
"- # ダイクストラ法：O(ElogV)",
"- def dijkstra_heap(s):",
"- # 始点sから各頂点への最短距離",
"- d = [float(\"inf\")] * n",
"- used = [True] * n # True:未確定",
"- d[s] = 0",
"- used[s] = False",
"- edgelist = []",
"- for e in edge[s]:",
"- heapq.heappush(edgelist, e)",
"- while len(edgelist):",
"- minedge = heapq.heappop(edgelist)",
"- # まだ使われてない頂点の中から最小の距離のものを探す",
"- if not used[minedge[1]]:",
"- continue",
"- v = minedge[1]",
"- d[v] = minedge[0]",
"- used[v] = False",
"- for e in edge[v]:",
"- if used[e[1]]:",
"- heapq.heappush(edgelist, [e[0] + d[v], e[1]])",
"- return d",
"-",
"- L = dijkstra_heap(n - 1)",
"- if L[0] <= 2:",
"- print(\"POSSIBLE\")",
"+ edge[a - 1].append(b - 1)",
"+ edge[b - 1].append(a - 1)",
"+ for i in edge[0]:",
"+ if n - 1 in set(edge[i]):",
"+ print(\"POSSIBLE\")",
"+ break"
] | false
| 0.147653
| 0.047332
| 3.119539
|
[
"s939035005",
"s956588879"
] |
u312695001
|
p03557
|
python
|
s622285569
|
s372837472
| 547
| 335
| 34,204
| 17,704
|
Accepted
|
Accepted
| 38.76
|
import numpy as np
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A)
B = sorted(B)
C = sorted(C)
ans = 0
x = 0
z = 0
for y in B:
while x < N and A[x] < y:
x = x + 1
while z < N and C[z] <= y:
z = z + 1
ans = ans + x*(N-z)
print(ans)
|
from bisect import bisect_right, bisect_left
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A)
B = sorted(B)
C = sorted(C)
ans = 0
A_on_B = 0
C_under_B = 0
for y in B:
A_on_B = bisect_left(A, y)
C_under_B = N - bisect_right(C, y)
ans = ans + A_on_B*C_under_B
print(ans)
| 23
| 20
| 374
| 393
|
import numpy as np
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A)
B = sorted(B)
C = sorted(C)
ans = 0
x = 0
z = 0
for y in B:
while x < N and A[x] < y:
x = x + 1
while z < N and C[z] <= y:
z = z + 1
ans = ans + x * (N - z)
print(ans)
|
from bisect import bisect_right, bisect_left
N = int(input())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A = sorted(A)
B = sorted(B)
C = sorted(C)
ans = 0
A_on_B = 0
C_under_B = 0
for y in B:
A_on_B = bisect_left(A, y)
C_under_B = N - bisect_right(C, y)
ans = ans + A_on_B * C_under_B
print(ans)
| false
| 13.043478
|
[
"-import numpy as np",
"+from bisect import bisect_right, bisect_left",
"-x = 0",
"-z = 0",
"+A_on_B = 0",
"+C_under_B = 0",
"- while x < N and A[x] < y:",
"- x = x + 1",
"- while z < N and C[z] <= y:",
"- z = z + 1",
"- ans = ans + x * (N - z)",
"+ A_on_B = bisect_left(A, y)",
"+ C_under_B = N - bisect_right(C, y)",
"+ ans = ans + A_on_B * C_under_B"
] | false
| 0.044476
| 0.048571
| 0.915694
|
[
"s622285569",
"s372837472"
] |
u163907160
|
p02756
|
python
|
s442162296
|
s425239078
| 412
| 381
| 4,468
| 7,688
|
Accepted
|
Accepted
| 7.52
|
S=eval(input())
Q=int(eval(input()))
Rev=True
front=''
back=''
for i in range(Q):
a=eval(input())
if a=='1':
Rev=not(Rev)
else:
b,c,x=a.split()
if c == '1':
if Rev:
front += x
else:
back += x
else:
if Rev:
back += x
else:
front += x
if Rev:
print((front[::-1] + S + back))
else:
print((back[::-1]+S[::-1]+front))
|
S=list(eval(input()))
Q=int(eval(input()))
Rev=True
front=[]
back=[]
for i in range(Q):
a=eval(input())
if a=='1':
Rev=not(Rev)
else:
b,c,x=a.split()
if c == '1':
if Rev:
front.append(x)
else:
back.append(x)
else:
if Rev:
back.append(x)
else:
front.append(x)
if Rev:
front.reverse()
front.extend(S)
front.extend(back)
print(("".join(front)))
else:
back.reverse()
S.reverse()
back.extend(S)
back.extend(front)
print(("".join(back)))
| 25
| 32
| 479
| 633
|
S = eval(input())
Q = int(eval(input()))
Rev = True
front = ""
back = ""
for i in range(Q):
a = eval(input())
if a == "1":
Rev = not (Rev)
else:
b, c, x = a.split()
if c == "1":
if Rev:
front += x
else:
back += x
else:
if Rev:
back += x
else:
front += x
if Rev:
print((front[::-1] + S + back))
else:
print((back[::-1] + S[::-1] + front))
|
S = list(eval(input()))
Q = int(eval(input()))
Rev = True
front = []
back = []
for i in range(Q):
a = eval(input())
if a == "1":
Rev = not (Rev)
else:
b, c, x = a.split()
if c == "1":
if Rev:
front.append(x)
else:
back.append(x)
else:
if Rev:
back.append(x)
else:
front.append(x)
if Rev:
front.reverse()
front.extend(S)
front.extend(back)
print(("".join(front)))
else:
back.reverse()
S.reverse()
back.extend(S)
back.extend(front)
print(("".join(back)))
| false
| 21.875
|
[
"-S = eval(input())",
"+S = list(eval(input()))",
"-front = \"\"",
"-back = \"\"",
"+front = []",
"+back = []",
"- front += x",
"+ front.append(x)",
"- back += x",
"+ back.append(x)",
"- back += x",
"+ back.append(x)",
"- front += x",
"+ front.append(x)",
"- print((front[::-1] + S + back))",
"+ front.reverse()",
"+ front.extend(S)",
"+ front.extend(back)",
"+ print((\"\".join(front)))",
"- print((back[::-1] + S[::-1] + front))",
"+ back.reverse()",
"+ S.reverse()",
"+ back.extend(S)",
"+ back.extend(front)",
"+ print((\"\".join(back)))"
] | false
| 0.036638
| 0.036687
| 0.99865
|
[
"s442162296",
"s425239078"
] |
u678167152
|
p03635
|
python
|
s890187929
|
s774311056
| 174
| 64
| 38,512
| 61,772
|
Accepted
|
Accepted
| 63.22
|
N, M = list(map(int, input().split()))
ans=(N-1)*(M-1)
print(ans)
|
N, M = list(map(int, input().split()))
print(((N-1)*(M-1)))
| 4
| 2
| 63
| 52
|
N, M = list(map(int, input().split()))
ans = (N - 1) * (M - 1)
print(ans)
|
N, M = list(map(int, input().split()))
print(((N - 1) * (M - 1)))
| false
| 50
|
[
"-ans = (N - 1) * (M - 1)",
"-print(ans)",
"+print(((N - 1) * (M - 1)))"
] | false
| 0.044286
| 0.038144
| 1.161037
|
[
"s890187929",
"s774311056"
] |
u308033440
|
p02261
|
python
|
s824703209
|
s521199493
| 240
| 20
| 5,608
| 5,608
|
Accepted
|
Accepted
| 91.67
|
# #バブルソート
# def BubbleSort(C,N):
# for i in range (0,N,1):
# for j in range(N-1,i-1,-1):
# if int(C[j][1:2]) < int(C[j-1][1:2]):
# tmp = C[j]
# C[j] = C[j-1]
# C[j-1] = tmp
# print(' '.join(C))
#バブルソート
def BubbleSort(C,N):
flag = 1
while flag:
flag = 0
for j in range(N-1,0,-1):
if int(C[j][1:2]) < int(C[j-1][1:2]):
tmp = C[j]
C[j] = C[j-1]
C[j-1] = tmp
flag = 1
print((' '.join(C)))
#選択ソート
def SelectionSort(C,N):
for i in range(0,N,1):
minj = i
for j in range(i,N,1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((' '.join(C)))
#安定かどうかの判定
def isStable(inp, out,N):
for i in range(0,N):
for j in range(i+1,N):
for a in range(0,N):
for b in range(a+1,N):
# print("inp(i,j):",inp[i],inp[j],"out(b,a):",out[b],out[a]+"\n")
if int(inp[i][1]) == int(inp[j][1]) and inp[i] == out[b] and inp[j] == out[a]:
print('Not stable')
return
print('Stable')
#愚直に調べるパターン
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A,N)
isStable(A,Bubble_A,N)
SelectionSort(Selection_A,N)
isStable(A,Selection_A,N)
|
#バブルソート
def BubbleSort(C,N):
for i in range (0,N,1):
for j in range(N-1,i,-1):
if int(C[j][1:2]) < int(C[j-1][1:2]):
tmp = C[j]
C[j] = C[j-1]
C[j-1] = tmp
print((' '.join(C)))
#選択ソート
def SelectionSort(C,N):
for i in range(0,N,1):
minj = i
for j in range(i,N,1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((' '.join(C)))
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A,N)
print("Stable")
SelectionSort(Selection_A,N)
flag = True
for Bubble,Selection in zip(Bubble_A,Selection_A):
if Bubble != Selection:
flag = False
if flag :
print("Stable")
else:
print("Not stable")
| 61
| 43
| 1,593
| 915
|
# #バブルソート
# def BubbleSort(C,N):
# for i in range (0,N,1):
# for j in range(N-1,i-1,-1):
# if int(C[j][1:2]) < int(C[j-1][1:2]):
# tmp = C[j]
# C[j] = C[j-1]
# C[j-1] = tmp
# print(' '.join(C))
# バブルソート
def BubbleSort(C, N):
flag = 1
while flag:
flag = 0
for j in range(N - 1, 0, -1):
if int(C[j][1:2]) < int(C[j - 1][1:2]):
tmp = C[j]
C[j] = C[j - 1]
C[j - 1] = tmp
flag = 1
print((" ".join(C)))
# 選択ソート
def SelectionSort(C, N):
for i in range(0, N, 1):
minj = i
for j in range(i, N, 1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((" ".join(C)))
# 安定かどうかの判定
def isStable(inp, out, N):
for i in range(0, N):
for j in range(i + 1, N):
for a in range(0, N):
for b in range(a + 1, N):
# print("inp(i,j):",inp[i],inp[j],"out(b,a):",out[b],out[a]+"\n")
if (
int(inp[i][1]) == int(inp[j][1])
and inp[i] == out[b]
and inp[j] == out[a]
):
print("Not stable")
return
print("Stable")
# 愚直に調べるパターン
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A, N)
isStable(A, Bubble_A, N)
SelectionSort(Selection_A, N)
isStable(A, Selection_A, N)
|
# バブルソート
def BubbleSort(C, N):
for i in range(0, N, 1):
for j in range(N - 1, i, -1):
if int(C[j][1:2]) < int(C[j - 1][1:2]):
tmp = C[j]
C[j] = C[j - 1]
C[j - 1] = tmp
print((" ".join(C)))
# 選択ソート
def SelectionSort(C, N):
for i in range(0, N, 1):
minj = i
for j in range(i, N, 1):
if int(C[j][1:2]) < int(C[minj][1:2]):
minj = j
tmp = C[i]
C[i] = C[minj]
C[minj] = tmp
print((" ".join(C)))
N = int(eval(input()))
A = list(input().split())
Bubble_A = A.copy()
Selection_A = A.copy()
BubbleSort(Bubble_A, N)
print("Stable")
SelectionSort(Selection_A, N)
flag = True
for Bubble, Selection in zip(Bubble_A, Selection_A):
if Bubble != Selection:
flag = False
if flag:
print("Stable")
else:
print("Not stable")
| false
| 29.508197
|
[
"-# #バブルソート",
"-# def BubbleSort(C,N):",
"-# for i in range (0,N,1):",
"-# for j in range(N-1,i-1,-1):",
"-# if int(C[j][1:2]) < int(C[j-1][1:2]):",
"-# tmp = C[j]",
"-# C[j] = C[j-1]",
"-# C[j-1] = tmp",
"-# print(' '.join(C))",
"- flag = 1",
"- while flag:",
"- flag = 0",
"- for j in range(N - 1, 0, -1):",
"+ for i in range(0, N, 1):",
"+ for j in range(N - 1, i, -1):",
"- flag = 1",
"-# 安定かどうかの判定",
"-def isStable(inp, out, N):",
"- for i in range(0, N):",
"- for j in range(i + 1, N):",
"- for a in range(0, N):",
"- for b in range(a + 1, N):",
"- # print(\"inp(i,j):\",inp[i],inp[j],\"out(b,a):\",out[b],out[a]+\"\\n\")",
"- if (",
"- int(inp[i][1]) == int(inp[j][1])",
"- and inp[i] == out[b]",
"- and inp[j] == out[a]",
"- ):",
"- print(\"Not stable\")",
"- return",
"- print(\"Stable\")",
"-",
"-",
"-# 愚直に調べるパターン",
"-isStable(A, Bubble_A, N)",
"+print(\"Stable\")",
"-isStable(A, Selection_A, N)",
"+flag = True",
"+for Bubble, Selection in zip(Bubble_A, Selection_A):",
"+ if Bubble != Selection:",
"+ flag = False",
"+if flag:",
"+ print(\"Stable\")",
"+else:",
"+ print(\"Not stable\")"
] | false
| 0.156106
| 0.044612
| 3.499172
|
[
"s824703209",
"s521199493"
] |
u226155577
|
p03676
|
python
|
s376288592
|
s056877046
| 698
| 645
| 17,092
| 20,272
|
Accepted
|
Accepted
| 7.59
|
n,*A=list(map(int,open(0).read().split()))
f=[1]*(n+2);r=f[:]
MOD=10**9+7
for i in range(n+1):f[i+1]=e=f[i]*-~i%MOD;r[i+1]=pow(e,MOD-2,MOD)
B=[0]*(n+1)
for a in A:B[a]+=1
i=B.index(2)
L=A.index(i);R=A.index(i,L+1)
for k in range(1,n+2):
print(((f[n+1]*r[k]*r[n+1-k]-(k<=L+n+1-R and f[L-1+n+1-R]*r[k-1]*r[L+n+1-k-R]))%MOD))
|
n,*A=list(map(int,open(0).read().split()));n+=1;f=[1]*-~n;r=f[:];M=10**9+7
for a in A:r[a]+=1
i=r.index(3);d=A.index;L=d(i);L+=n-d(i,L+1);*X,=list(range(1,n+1))
for i in X:f[i]=e=f[i-1]*i%M;r[i]=pow(e,M-2,M)
for k in X:print(((f[n]*r[k]*r[n-k]-(k<=L)*(f[L-1]*r[k-1]*r[L-k]))%M))
| 10
| 5
| 327
| 269
|
n, *A = list(map(int, open(0).read().split()))
f = [1] * (n + 2)
r = f[:]
MOD = 10**9 + 7
for i in range(n + 1):
f[i + 1] = e = f[i] * -~i % MOD
r[i + 1] = pow(e, MOD - 2, MOD)
B = [0] * (n + 1)
for a in A:
B[a] += 1
i = B.index(2)
L = A.index(i)
R = A.index(i, L + 1)
for k in range(1, n + 2):
print(
(
(
f[n + 1] * r[k] * r[n + 1 - k]
- (
k <= L + n + 1 - R
and f[L - 1 + n + 1 - R] * r[k - 1] * r[L + n + 1 - k - R]
)
)
% MOD
)
)
|
n, *A = list(map(int, open(0).read().split()))
n += 1
f = [1] * -~n
r = f[:]
M = 10**9 + 7
for a in A:
r[a] += 1
i = r.index(3)
d = A.index
L = d(i)
L += n - d(i, L + 1)
(*X,) = list(range(1, n + 1))
for i in X:
f[i] = e = f[i - 1] * i % M
r[i] = pow(e, M - 2, M)
for k in X:
print(((f[n] * r[k] * r[n - k] - (k <= L) * (f[L - 1] * r[k - 1] * r[L - k])) % M))
| false
| 50
|
[
"-f = [1] * (n + 2)",
"+n += 1",
"+f = [1] * -~n",
"-MOD = 10**9 + 7",
"-for i in range(n + 1):",
"- f[i + 1] = e = f[i] * -~i % MOD",
"- r[i + 1] = pow(e, MOD - 2, MOD)",
"-B = [0] * (n + 1)",
"+M = 10**9 + 7",
"- B[a] += 1",
"-i = B.index(2)",
"-L = A.index(i)",
"-R = A.index(i, L + 1)",
"-for k in range(1, n + 2):",
"- print(",
"- (",
"- (",
"- f[n + 1] * r[k] * r[n + 1 - k]",
"- - (",
"- k <= L + n + 1 - R",
"- and f[L - 1 + n + 1 - R] * r[k - 1] * r[L + n + 1 - k - R]",
"- )",
"- )",
"- % MOD",
"- )",
"- )",
"+ r[a] += 1",
"+i = r.index(3)",
"+d = A.index",
"+L = d(i)",
"+L += n - d(i, L + 1)",
"+(*X,) = list(range(1, n + 1))",
"+for i in X:",
"+ f[i] = e = f[i - 1] * i % M",
"+ r[i] = pow(e, M - 2, M)",
"+for k in X:",
"+ print(((f[n] * r[k] * r[n - k] - (k <= L) * (f[L - 1] * r[k - 1] * r[L - k])) % M))"
] | false
| 0.041946
| 0.042045
| 0.997643
|
[
"s376288592",
"s056877046"
] |
u187516587
|
p02702
|
python
|
s408821732
|
s921327687
| 1,889
| 1,446
| 78,932
| 72,140
|
Accepted
|
Accepted
| 23.45
|
S=eval(input())
a=0
b=[0]*2019
No=[None]*2019
for i in S:
l=No.copy()
k=int(i)
for j in range(2019):
l[(j*10+k)%2019]=b[j]
l[k]+=1
a+=l[0]
b=l
print(a)
|
def main():
S=eval(input())
a=0
b=[0]*2019
No=[0]*2019
for i in S:
l=No.copy()
k=int(i)
for j in range(2019):
l[(j*10+k)%2019]=b[j]
l[k]+=1
a+=l[0]
b=l
print(a)
main()
| 13
| 15
| 190
| 260
|
S = eval(input())
a = 0
b = [0] * 2019
No = [None] * 2019
for i in S:
l = No.copy()
k = int(i)
for j in range(2019):
l[(j * 10 + k) % 2019] = b[j]
l[k] += 1
a += l[0]
b = l
print(a)
|
def main():
S = eval(input())
a = 0
b = [0] * 2019
No = [0] * 2019
for i in S:
l = No.copy()
k = int(i)
for j in range(2019):
l[(j * 10 + k) % 2019] = b[j]
l[k] += 1
a += l[0]
b = l
print(a)
main()
| false
| 13.333333
|
[
"-S = eval(input())",
"-a = 0",
"-b = [0] * 2019",
"-No = [None] * 2019",
"-for i in S:",
"- l = No.copy()",
"- k = int(i)",
"- for j in range(2019):",
"- l[(j * 10 + k) % 2019] = b[j]",
"- l[k] += 1",
"- a += l[0]",
"- b = l",
"-print(a)",
"+def main():",
"+ S = eval(input())",
"+ a = 0",
"+ b = [0] * 2019",
"+ No = [0] * 2019",
"+ for i in S:",
"+ l = No.copy()",
"+ k = int(i)",
"+ for j in range(2019):",
"+ l[(j * 10 + k) % 2019] = b[j]",
"+ l[k] += 1",
"+ a += l[0]",
"+ b = l",
"+ print(a)",
"+",
"+",
"+main()"
] | false
| 0.037274
| 0.037294
| 0.999476
|
[
"s408821732",
"s921327687"
] |
u947883560
|
p03003
|
python
|
s025410988
|
s659483101
| 451
| 376
| 73,180
| 73,308
|
Accepted
|
Accepted
| 16.63
|
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def solve(N: int, M: int, S: "List[int]", T: "List[int]"):
DP = [[1]*(N+1) for _ in range(M+1)]
for i in range(1, N+1):
for j in range(1, M+1):
DP[j][i] = DP[j-1][i] + DP[j][i-1] - \
DP[j-1][i-1]
DP[j][i] %= MOD
if S[i-1] == T[j-1]:
DP[j][i] += DP[j-1][i-1]
DP[j][i] %= MOD
# print(*DP, sep="\n")
print(DP[M][N])
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
M = int(next(tokens)) # type: int
S = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
T = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, S, T)
if __name__ == '__main__':
main()
|
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def solve(N: int, M: int, S: "List[int]", T: "List[int]"):
DP = [[1]*(N+1) for _ in range(M+1)]
for j in range(1, M+1):
for i in range(1, N+1):
DP[j][i] = DP[j-1][i] + DP[j][i-1] - \
DP[j-1][i-1]
DP[j][i] %= MOD
if S[i-1] == T[j-1]:
DP[j][i] += DP[j-1][i-1]
DP[j][i] %= MOD
# print(*DP, sep="\n")
print(DP[M][N])
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
M = int(next(tokens)) # type: int
S = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
T = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, S, T)
if __name__ == '__main__':
main()
| 38
| 38
| 986
| 986
|
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def solve(N: int, M: int, S: "List[int]", T: "List[int]"):
DP = [[1] * (N + 1) for _ in range(M + 1)]
for i in range(1, N + 1):
for j in range(1, M + 1):
DP[j][i] = DP[j - 1][i] + DP[j][i - 1] - DP[j - 1][i - 1]
DP[j][i] %= MOD
if S[i - 1] == T[j - 1]:
DP[j][i] += DP[j - 1][i - 1]
DP[j][i] %= MOD
# print(*DP, sep="\n")
print(DP[M][N])
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
M = int(next(tokens)) # type: int
S = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
T = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, S, T)
if __name__ == "__main__":
main()
|
#!/usr/bin/env python3
import sys
INF = float("inf")
MOD = 1000000007 # type: int
def solve(N: int, M: int, S: "List[int]", T: "List[int]"):
DP = [[1] * (N + 1) for _ in range(M + 1)]
for j in range(1, M + 1):
for i in range(1, N + 1):
DP[j][i] = DP[j - 1][i] + DP[j][i - 1] - DP[j - 1][i - 1]
DP[j][i] %= MOD
if S[i - 1] == T[j - 1]:
DP[j][i] += DP[j - 1][i - 1]
DP[j][i] %= MOD
# print(*DP, sep="\n")
print(DP[M][N])
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
M = int(next(tokens)) # type: int
S = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
T = [int(next(tokens)) for _ in range(M)] # type: "List[int]"
solve(N, M, S, T)
if __name__ == "__main__":
main()
| false
| 0
|
[
"- for i in range(1, N + 1):",
"- for j in range(1, M + 1):",
"+ for j in range(1, M + 1):",
"+ for i in range(1, N + 1):"
] | false
| 0.049792
| 0.048407
| 1.028616
|
[
"s025410988",
"s659483101"
] |
u987164499
|
p02995
|
python
|
s943107406
|
s032856332
| 36
| 28
| 5,048
| 9,144
|
Accepted
|
Accepted
| 22.22
|
from sys import stdin
import fractions
a,b,c,d = [int(x) for x in stdin.readline().rstrip().split()]
kouyaku = fractions.gcd(c, d)
koubai = c * d // fractions.gcd(c, d)
b_s = b - b//c - b//d + b//koubai
a_s = a-1 - (a-1)//c - (a-1)//d + (a-1)//koubai
print((b_s - a_s))
|
from math import gcd
def lcm(x, y):
return (x * y)//gcd(x, y)
a,b,c,d = list(map(int,input().split()))
cd = lcm(c,d)
ab = b-a+1
print((ab-(b//c-(a-1)//c)-(b//d-(a-1)//d)+(b//cd-(a-1)//cd)))
| 8
| 11
| 274
| 199
|
from sys import stdin
import fractions
a, b, c, d = [int(x) for x in stdin.readline().rstrip().split()]
kouyaku = fractions.gcd(c, d)
koubai = c * d // fractions.gcd(c, d)
b_s = b - b // c - b // d + b // koubai
a_s = a - 1 - (a - 1) // c - (a - 1) // d + (a - 1) // koubai
print((b_s - a_s))
|
from math import gcd
def lcm(x, y):
return (x * y) // gcd(x, y)
a, b, c, d = list(map(int, input().split()))
cd = lcm(c, d)
ab = b - a + 1
print(
(ab - (b // c - (a - 1) // c) - (b // d - (a - 1) // d) + (b // cd - (a - 1) // cd))
)
| false
| 27.272727
|
[
"-from sys import stdin",
"-import fractions",
"+from math import gcd",
"-a, b, c, d = [int(x) for x in stdin.readline().rstrip().split()]",
"-kouyaku = fractions.gcd(c, d)",
"-koubai = c * d // fractions.gcd(c, d)",
"-b_s = b - b // c - b // d + b // koubai",
"-a_s = a - 1 - (a - 1) // c - (a - 1) // d + (a - 1) // koubai",
"-print((b_s - a_s))",
"+",
"+def lcm(x, y):",
"+ return (x * y) // gcd(x, y)",
"+",
"+",
"+a, b, c, d = list(map(int, input().split()))",
"+cd = lcm(c, d)",
"+ab = b - a + 1",
"+print(",
"+ (ab - (b // c - (a - 1) // c) - (b // d - (a - 1) // d) + (b // cd - (a - 1) // cd))",
"+)"
] | false
| 0.138782
| 0.092428
| 1.501515
|
[
"s943107406",
"s032856332"
] |
u222668979
|
p02572
|
python
|
s233620152
|
s793976692
| 137
| 126
| 102,008
| 94,208
|
Accepted
|
Accepted
| 8.03
|
from itertools import accumulate
n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
ans, acc = 0, list(accumulate(a))
for i in range(n - 1):
ans += a[i] * (acc[-1] - acc[i])
ans %= mod
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
k = 0
num = sum(a)
import math
for i in range(n):
reje = num - a[i]
k += reje * a[i]
x = k//2
t = 10 ** 9 + 7
ans = x % t
print(ans)
| 11
| 15
| 236
| 211
|
from itertools import accumulate
n = int(eval(input()))
a = list(map(int, input().split()))
mod = 10**9 + 7
ans, acc = 0, list(accumulate(a))
for i in range(n - 1):
ans += a[i] * (acc[-1] - acc[i])
ans %= mod
print(ans)
|
n = int(eval(input()))
a = list(map(int, input().split()))
k = 0
num = sum(a)
import math
for i in range(n):
reje = num - a[i]
k += reje * a[i]
x = k // 2
t = 10**9 + 7
ans = x % t
print(ans)
| false
| 26.666667
|
[
"-from itertools import accumulate",
"-",
"-mod = 10**9 + 7",
"-ans, acc = 0, list(accumulate(a))",
"-for i in range(n - 1):",
"- ans += a[i] * (acc[-1] - acc[i])",
"- ans %= mod",
"+k = 0",
"+num = sum(a)",
"+import math",
"+",
"+for i in range(n):",
"+ reje = num - a[i]",
"+ k += reje * a[i]",
"+x = k // 2",
"+t = 10**9 + 7",
"+ans = x % t"
] | false
| 0.101134
| 0.068079
| 1.485533
|
[
"s233620152",
"s793976692"
] |
u170183831
|
p03687
|
python
|
s427628114
|
s787406507
| 237
| 211
| 43,112
| 42,348
|
Accepted
|
Accepted
| 10.97
|
from collections import Counter
def solve(s):
cs = Counter(s).most_common()
m = len(s)
for c in cs:
news = list(s)
size = len(s)
count = 0
while len(Counter(news[:size]).most_common()) > 1:
for i in range(size - 1):
if news[i] != c[0] and news[i + 1] == c[0]:
news[i] = c[0]
size -= 1
count += 1
if count < m:
m = count
return m
_s = eval(input())
print((solve(_s)))
|
from collections import Counter
def solve(s):
cs = Counter(s)
m = len(s)
for c in cs:
news = list(s)
size = len(s)
count = 0
while len(Counter(news[:size])) > 1:
for i in range(size - 1):
if news[i] != c[0] and news[i + 1] == c[0]:
news[i] = c[0]
size -= 1
count += 1
if count < m:
m = count
return m
_s = eval(input())
print((solve(_s)))
| 21
| 21
| 521
| 493
|
from collections import Counter
def solve(s):
cs = Counter(s).most_common()
m = len(s)
for c in cs:
news = list(s)
size = len(s)
count = 0
while len(Counter(news[:size]).most_common()) > 1:
for i in range(size - 1):
if news[i] != c[0] and news[i + 1] == c[0]:
news[i] = c[0]
size -= 1
count += 1
if count < m:
m = count
return m
_s = eval(input())
print((solve(_s)))
|
from collections import Counter
def solve(s):
cs = Counter(s)
m = len(s)
for c in cs:
news = list(s)
size = len(s)
count = 0
while len(Counter(news[:size])) > 1:
for i in range(size - 1):
if news[i] != c[0] and news[i + 1] == c[0]:
news[i] = c[0]
size -= 1
count += 1
if count < m:
m = count
return m
_s = eval(input())
print((solve(_s)))
| false
| 0
|
[
"- cs = Counter(s).most_common()",
"+ cs = Counter(s)",
"- while len(Counter(news[:size]).most_common()) > 1:",
"+ while len(Counter(news[:size])) > 1:"
] | false
| 0.035182
| 0.036387
| 0.966895
|
[
"s427628114",
"s787406507"
] |
u077291787
|
p03665
|
python
|
s494490743
|
s482440762
| 21
| 18
| 3,316
| 3,060
|
Accepted
|
Accepted
| 14.29
|
# AGC017A - Biscuits
def main():
n, p = tuple(map(int, input().rstrip().split()))
A = tuple([int(x) % 2 for x in input().rstrip().split()])
if sum(A) == 0: # all numbers are even
print((2 ** n if p == 0 else 0))
else:
print((2 ** (n - 1)))
if __name__ == "__main__":
main()
|
# AGC017A - Biscuits
def main():
N, P, *A = list(map(int, open(0).read().split()))
total = sum(i % 2 for i in A)
if total == 0: # all numbers are even
flg = P == 0
print((2 ** N if flg else 0))
else:
print((2 ** (N - 1)))
if __name__ == "__main__":
main()
| 12
| 13
| 324
| 304
|
# AGC017A - Biscuits
def main():
n, p = tuple(map(int, input().rstrip().split()))
A = tuple([int(x) % 2 for x in input().rstrip().split()])
if sum(A) == 0: # all numbers are even
print((2**n if p == 0 else 0))
else:
print((2 ** (n - 1)))
if __name__ == "__main__":
main()
|
# AGC017A - Biscuits
def main():
N, P, *A = list(map(int, open(0).read().split()))
total = sum(i % 2 for i in A)
if total == 0: # all numbers are even
flg = P == 0
print((2**N if flg else 0))
else:
print((2 ** (N - 1)))
if __name__ == "__main__":
main()
| false
| 7.692308
|
[
"- n, p = tuple(map(int, input().rstrip().split()))",
"- A = tuple([int(x) % 2 for x in input().rstrip().split()])",
"- if sum(A) == 0: # all numbers are even",
"- print((2**n if p == 0 else 0))",
"+ N, P, *A = list(map(int, open(0).read().split()))",
"+ total = sum(i % 2 for i in A)",
"+ if total == 0: # all numbers are even",
"+ flg = P == 0",
"+ print((2**N if flg else 0))",
"- print((2 ** (n - 1)))",
"+ print((2 ** (N - 1)))"
] | false
| 0.048655
| 0.048841
| 0.996193
|
[
"s494490743",
"s482440762"
] |
u197968862
|
p03163
|
python
|
s619754183
|
s962483579
| 1,109
| 688
| 310,068
| 171,784
|
Accepted
|
Accepted
| 37.96
|
n, w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
def knapsack(n,w,wv):
inf = float('inf')
dp = [[-inf for _ in range(w+1)] for _ in range(n+1)]
for i in range(w+1): dp[0][i] = 0
for i in range(n):
for w in range(w+1):
if wv[i][0]<=w:
dp[i+1][w] = max(dp[i][w-wv[i][0]]+wv[i][1],dp[i][w])
else:
dp[i+1][w] = dp[i][w]
return dp[n][w]
print((knapsack(n,w,wv)))
|
n, w = list(map(int,input().split()))
wv = [list(map(int,input().split())) for _ in range(n)]
dp = [[0 for _ in range(w+1)] for _ in range(n+1)]
for i in range(n):
for j in range(w+1):
if wv[i][0] <= j:
dp[i+1][j] = max(dp[i][j-wv[i][0]]+wv[i][1],dp[i][j])
else:
dp[i+1][j] = dp[i][j]
print((max(dp[-1])))
| 17
| 13
| 497
| 356
|
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
def knapsack(n, w, wv):
inf = float("inf")
dp = [[-inf for _ in range(w + 1)] for _ in range(n + 1)]
for i in range(w + 1):
dp[0][i] = 0
for i in range(n):
for w in range(w + 1):
if wv[i][0] <= w:
dp[i + 1][w] = max(dp[i][w - wv[i][0]] + wv[i][1], dp[i][w])
else:
dp[i + 1][w] = dp[i][w]
return dp[n][w]
print((knapsack(n, w, wv)))
|
n, w = list(map(int, input().split()))
wv = [list(map(int, input().split())) for _ in range(n)]
dp = [[0 for _ in range(w + 1)] for _ in range(n + 1)]
for i in range(n):
for j in range(w + 1):
if wv[i][0] <= j:
dp[i + 1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])
else:
dp[i + 1][j] = dp[i][j]
print((max(dp[-1])))
| false
| 23.529412
|
[
"-",
"-",
"-def knapsack(n, w, wv):",
"- inf = float(\"inf\")",
"- dp = [[-inf for _ in range(w + 1)] for _ in range(n + 1)]",
"- for i in range(w + 1):",
"- dp[0][i] = 0",
"- for i in range(n):",
"- for w in range(w + 1):",
"- if wv[i][0] <= w:",
"- dp[i + 1][w] = max(dp[i][w - wv[i][0]] + wv[i][1], dp[i][w])",
"- else:",
"- dp[i + 1][w] = dp[i][w]",
"- return dp[n][w]",
"-",
"-",
"-print((knapsack(n, w, wv)))",
"+dp = [[0 for _ in range(w + 1)] for _ in range(n + 1)]",
"+for i in range(n):",
"+ for j in range(w + 1):",
"+ if wv[i][0] <= j:",
"+ dp[i + 1][j] = max(dp[i][j - wv[i][0]] + wv[i][1], dp[i][j])",
"+ else:",
"+ dp[i + 1][j] = dp[i][j]",
"+print((max(dp[-1])))"
] | false
| 0.045877
| 0.044283
| 1.035992
|
[
"s619754183",
"s962483579"
] |
u652583512
|
p02606
|
python
|
s857152574
|
s826348907
| 150
| 100
| 61,316
| 61,712
|
Accepted
|
Accepted
| 33.33
|
L, R, D = list(map(int, input().split()))
ans = 0
for i in range(L, R + 1):
if i % D == 0:
ans += 1
print(ans)
|
L, R, D = list(map(int, input().split()))
first = L + (D - (L % D)) % D
last = R - (R % D)
ans = 0
if L <= first <= R and L <= last <= R:
ans = (last - first) // D + 1
print(ans)
| 8
| 10
| 126
| 189
|
L, R, D = list(map(int, input().split()))
ans = 0
for i in range(L, R + 1):
if i % D == 0:
ans += 1
print(ans)
|
L, R, D = list(map(int, input().split()))
first = L + (D - (L % D)) % D
last = R - (R % D)
ans = 0
if L <= first <= R and L <= last <= R:
ans = (last - first) // D + 1
print(ans)
| false
| 20
|
[
"+first = L + (D - (L % D)) % D",
"+last = R - (R % D)",
"-for i in range(L, R + 1):",
"- if i % D == 0:",
"- ans += 1",
"+if L <= first <= R and L <= last <= R:",
"+ ans = (last - first) // D + 1"
] | false
| 0.049325
| 0.049957
| 0.987356
|
[
"s857152574",
"s826348907"
] |
u941753895
|
p03044
|
python
|
s922669593
|
s131994766
| 871
| 394
| 88,008
| 83,476
|
Accepted
|
Accepted
| 54.76
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
visited=[False]*(10**5)
ans=[-1]*(10**5)
def f(n,edges,s):
all_visited=True
for i in range(n):
if visited[i]==False:
all_visited=False
break
if all_visited:
return
for x,c in edges[s]:
if visited[x]:
continue
if ans[s]==0:
if c%2==1:
ans[x]=1
else:
ans[x]=0
else:
if c%2==1:
ans[x]=0
else:
ans[x]=1
visited[x]=True
f(n,edges,x)
def main():
n=I()
edges=[[] for _ in range(n)]
for _ in range(n-1):
a,b,c=LI()
a-=1
b-=1
edges[a].append([b,c])
edges[b].append([a,c])
ans[0]=0
visited[0]=True
f(n,edges,0)
for x in ans[:n]:
print(x)
main()
# print(main())
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return eval(input())
color=[-1]*100100
G=[[] for _ in range(100100)]
def f(st):
st_c=color[st]
for v,d in G[st]:
if color[v]!=-1:
continue
if d%2==0:
color[v]=st_c
else:
color[v]=abs(st_c-1)
f(v)
def main():
n=I()
for _ in range(n-1):
a,b,c=LI()
a-=1
b-=1
G[a].append((b,c))
G[b].append((a,c))
color[0]=0
f(0)
for i in range(n):
print((color[i]))
main()
# print(main())
| 63
| 48
| 1,229
| 979
|
import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def LF():
return [float(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return eval(input())
visited = [False] * (10**5)
ans = [-1] * (10**5)
def f(n, edges, s):
all_visited = True
for i in range(n):
if visited[i] == False:
all_visited = False
break
if all_visited:
return
for x, c in edges[s]:
if visited[x]:
continue
if ans[s] == 0:
if c % 2 == 1:
ans[x] = 1
else:
ans[x] = 0
else:
if c % 2 == 1:
ans[x] = 0
else:
ans[x] = 1
visited[x] = True
f(n, edges, x)
def main():
n = I()
edges = [[] for _ in range(n)]
for _ in range(n - 1):
a, b, c = LI()
a -= 1
b -= 1
edges[a].append([b, c])
edges[b].append([a, c])
ans[0] = 0
visited[0] = True
f(n, edges, 0)
for x in ans[:n]:
print(x)
main()
# print(main())
|
import math, itertools, fractions, heapq, collections, bisect, sys, queue, copy
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
dd = [(-1, 0), (0, 1), (1, 0), (0, -1)]
ddn = [(-1, 0), (-1, 1), (0, 1), (1, 1), (1, 0), (1, -1), (0, -1), (-1, -1)]
def LI():
return [int(x) for x in sys.stdin.readline().split()]
# def LF(): return [float(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def F():
return float(sys.stdin.readline())
def LS():
return sys.stdin.readline().split()
def S():
return eval(input())
color = [-1] * 100100
G = [[] for _ in range(100100)]
def f(st):
st_c = color[st]
for v, d in G[st]:
if color[v] != -1:
continue
if d % 2 == 0:
color[v] = st_c
else:
color[v] = abs(st_c - 1)
f(v)
def main():
n = I()
for _ in range(n - 1):
a, b, c = LI()
a -= 1
b -= 1
G[a].append((b, c))
G[b].append((a, c))
color[0] = 0
f(0)
for i in range(n):
print((color[i]))
main()
# print(main())
| false
| 23.809524
|
[
"-def LF():",
"- return [float(x) for x in sys.stdin.readline().split()]",
"+# def LF(): return [float(x) for x in sys.stdin.readline().split()]",
"+def I():",
"+ return int(sys.stdin.readline())",
"-def I():",
"- return int(sys.stdin.readline())",
"+def F():",
"+ return float(sys.stdin.readline())",
"-visited = [False] * (10**5)",
"-ans = [-1] * (10**5)",
"+color = [-1] * 100100",
"+G = [[] for _ in range(100100)]",
"-def f(n, edges, s):",
"- all_visited = True",
"- for i in range(n):",
"- if visited[i] == False:",
"- all_visited = False",
"- break",
"- if all_visited:",
"- return",
"- for x, c in edges[s]:",
"- if visited[x]:",
"+def f(st):",
"+ st_c = color[st]",
"+ for v, d in G[st]:",
"+ if color[v] != -1:",
"- if ans[s] == 0:",
"- if c % 2 == 1:",
"- ans[x] = 1",
"- else:",
"- ans[x] = 0",
"+ if d % 2 == 0:",
"+ color[v] = st_c",
"- if c % 2 == 1:",
"- ans[x] = 0",
"- else:",
"- ans[x] = 1",
"- visited[x] = True",
"- f(n, edges, x)",
"+ color[v] = abs(st_c - 1)",
"+ f(v)",
"- edges = [[] for _ in range(n)]",
"- edges[a].append([b, c])",
"- edges[b].append([a, c])",
"- ans[0] = 0",
"- visited[0] = True",
"- f(n, edges, 0)",
"- for x in ans[:n]:",
"- print(x)",
"+ G[a].append((b, c))",
"+ G[b].append((a, c))",
"+ color[0] = 0",
"+ f(0)",
"+ for i in range(n):",
"+ print((color[i]))"
] | false
| 0.047422
| 0.073035
| 0.649302
|
[
"s922669593",
"s131994766"
] |
u680851063
|
p03212
|
python
|
s340676170
|
s582467731
| 118
| 55
| 25,004
| 8,052
|
Accepted
|
Accepted
| 53.39
|
from itertools import product
n = int(eval(input()))
a = ['7','5','3']
x =[]
for i in range(3,11):
x += list(product(a, repeat = i))
y = []
for j in x:
if '7' in j and '5' in j and '3' in j:
y.append(j)
z = []
for k in range(len(y)):
z.append(''.join(y[k]))
z = [int(_) for _ in z]
b = 0
for p in z:
if p <= n:
b += 1
print(b)
|
from itertools import product
l = []
for _ in range(3,10):
tmp = list(product('753', repeat = _))
l += tmp
m = []
for i in l:
if len(set(i)) == 3:
m.append(int(''.join(i)))
n = int(eval(input()))
ans = 0
for j in m:
if j <= n:
ans += 1
print(ans)
| 22
| 18
| 377
| 291
|
from itertools import product
n = int(eval(input()))
a = ["7", "5", "3"]
x = []
for i in range(3, 11):
x += list(product(a, repeat=i))
y = []
for j in x:
if "7" in j and "5" in j and "3" in j:
y.append(j)
z = []
for k in range(len(y)):
z.append("".join(y[k]))
z = [int(_) for _ in z]
b = 0
for p in z:
if p <= n:
b += 1
print(b)
|
from itertools import product
l = []
for _ in range(3, 10):
tmp = list(product("753", repeat=_))
l += tmp
m = []
for i in l:
if len(set(i)) == 3:
m.append(int("".join(i)))
n = int(eval(input()))
ans = 0
for j in m:
if j <= n:
ans += 1
print(ans)
| false
| 18.181818
|
[
"+l = []",
"+for _ in range(3, 10):",
"+ tmp = list(product(\"753\", repeat=_))",
"+ l += tmp",
"+m = []",
"+for i in l:",
"+ if len(set(i)) == 3:",
"+ m.append(int(\"\".join(i)))",
"-a = [\"7\", \"5\", \"3\"]",
"-x = []",
"-for i in range(3, 11):",
"- x += list(product(a, repeat=i))",
"-y = []",
"-for j in x:",
"- if \"7\" in j and \"5\" in j and \"3\" in j:",
"- y.append(j)",
"-z = []",
"-for k in range(len(y)):",
"- z.append(\"\".join(y[k]))",
"-z = [int(_) for _ in z]",
"-b = 0",
"-for p in z:",
"- if p <= n:",
"- b += 1",
"-print(b)",
"+ans = 0",
"+for j in m:",
"+ if j <= n:",
"+ ans += 1",
"+print(ans)"
] | false
| 0.226305
| 0.192854
| 1.173451
|
[
"s340676170",
"s582467731"
] |
u512266180
|
p03200
|
python
|
s446304858
|
s793536201
| 115
| 100
| 3,500
| 3,500
|
Accepted
|
Accepted
| 13.04
|
s=eval(input())
count=0
b=s.count("B")
w=s.count("W")
for x in range(len(s)):
if s[x:x+1] == "B":
count += w
b-=1
elif s[x:x+1] == "W":
w-=1
if w == 0:
break
print(count)
|
s=eval(input())
count=0
b=s.count("B")
w=s.count("W")
for x in range(len(s)):
if s[x:x+1] == "B":
count += w
b-=1
elif s[x:x+1] == "W":
w-=1
print(count)
| 14
| 12
| 222
| 199
|
s = eval(input())
count = 0
b = s.count("B")
w = s.count("W")
for x in range(len(s)):
if s[x : x + 1] == "B":
count += w
b -= 1
elif s[x : x + 1] == "W":
w -= 1
if w == 0:
break
print(count)
|
s = eval(input())
count = 0
b = s.count("B")
w = s.count("W")
for x in range(len(s)):
if s[x : x + 1] == "B":
count += w
b -= 1
elif s[x : x + 1] == "W":
w -= 1
print(count)
| false
| 14.285714
|
[
"- if w == 0:",
"- break"
] | false
| 0.031905
| 0.032968
| 0.967753
|
[
"s446304858",
"s793536201"
] |
u631277801
|
p03223
|
python
|
s631954117
|
s040714831
| 870
| 788
| 11,856
| 10,616
|
Accepted
|
Accepted
| 9.43
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import deque
n = ni()
a = []
for _ in range(n):
a.append(ni())
mx_cent = [ai for ai in a]
mn_cent = [ai for ai in a]
a.sort()
a = deque(a)
mx_cent = deque([ai for ai in a])
mn_cent = deque([ai for ai in a])
bmx = deque([mx_cent.pop()])
bmn = deque([mn_cent.popleft()])
cnt = 0
while len(mx_cent) > 1:
lf = 0
rt = 0
if cnt % 2 == 0:
lf = mx_cent.popleft()
rt = mx_cent.popleft()
else:
lf = mx_cent.pop()
rt = mx_cent.pop()
bmx.appendleft(lf)
bmx.append(rt)
if cnt % 2 == 0:
lf = mn_cent.pop()
rt = mn_cent.pop()
else:
lf = mn_cent.popleft()
rt = mn_cent.popleft()
bmn.appendleft(lf)
bmn.append(rt)
cnt += 1
if len(mx_cent) == 1:
last = mx_cent.pop()
if abs(bmx[0] - last) > abs(bmx[-1] - last):
bmx.appendleft(last)
else:
bmx.append(last)
last = mn_cent.pop()
if abs(bmn[0] - last) > abs(bmn[-1] - last):
bmn.appendleft(last)
else:
bmn.append(last)
diffmx, diffmn = 0, 0
for i in range(n-1):
diffmx += abs(bmx[i+1] - bmx[i])
diffmn += abs(bmn[i+1] - bmn[i])
print((max(diffmx, diffmn)))
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10 ** 7)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x) - 1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
from collections import deque
n = ni()
a = [ni() for _ in range(n)]
a.sort()
b = a.copy()
c = a.copy()
# 小さい順に詰める
bdeq = deque(b)
bret = deque()
bret.append(bdeq.popleft())
push_small = False
while len(bdeq) > 1:
if push_small:
bret.append(bdeq.popleft())
bret.appendleft(bdeq.popleft())
push_small = False
else:
bret.append(bdeq.pop())
bret.appendleft(bdeq.pop())
push_small = True
if len(bdeq) > 0:
if abs(bdeq[0] - bret[0]) > abs(bdeq[0] - bret[-1]):
bret.appendleft(bdeq[0])
else:
bret.append(bdeq[0])
# 大きい順に詰める
cdeq = deque(c)
cret = deque()
cret.append(cdeq.pop())
push_small = True
while len(cdeq) > 1:
if push_small:
cret.append(cdeq.popleft())
cret.appendleft(cdeq.popleft())
push_small = False
else:
cret.append(cdeq.pop())
cret.appendleft(cdeq.pop())
push_small = True
if len(cdeq) > 0:
if abs(cdeq[0] - cret[0]) > abs(cdeq[0] - cret[-1]):
cret.appendleft(cdeq[0])
else:
cret.append(cdeq[0])
# 答えが大きいほうを選択
bans = 0
for i in range(n-1):
bans += abs(bret[i] - bret[i+1])
cans = 0
for i in range(n-1):
cans += abs(cret[i] - cret[i+1])
print((max(bans, cans)))
| 83
| 80
| 1,756
| 1,760
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
from collections import deque
n = ni()
a = []
for _ in range(n):
a.append(ni())
mx_cent = [ai for ai in a]
mn_cent = [ai for ai in a]
a.sort()
a = deque(a)
mx_cent = deque([ai for ai in a])
mn_cent = deque([ai for ai in a])
bmx = deque([mx_cent.pop()])
bmn = deque([mn_cent.popleft()])
cnt = 0
while len(mx_cent) > 1:
lf = 0
rt = 0
if cnt % 2 == 0:
lf = mx_cent.popleft()
rt = mx_cent.popleft()
else:
lf = mx_cent.pop()
rt = mx_cent.pop()
bmx.appendleft(lf)
bmx.append(rt)
if cnt % 2 == 0:
lf = mn_cent.pop()
rt = mn_cent.pop()
else:
lf = mn_cent.popleft()
rt = mn_cent.popleft()
bmn.appendleft(lf)
bmn.append(rt)
cnt += 1
if len(mx_cent) == 1:
last = mx_cent.pop()
if abs(bmx[0] - last) > abs(bmx[-1] - last):
bmx.appendleft(last)
else:
bmx.append(last)
last = mn_cent.pop()
if abs(bmn[0] - last) > abs(bmn[-1] - last):
bmn.appendleft(last)
else:
bmn.append(last)
diffmx, diffmn = 0, 0
for i in range(n - 1):
diffmx += abs(bmx[i + 1] - bmx[i])
diffmn += abs(bmn[i + 1] - bmn[i])
print((max(diffmx, diffmn)))
|
import sys
stdin = sys.stdin
sys.setrecursionlimit(10**7)
def li():
return list(map(int, stdin.readline().split()))
def li_():
return [int(x) - 1 for x in stdin.readline().split()]
def lf():
return list(map(float, stdin.readline().split()))
def ls():
return stdin.readline().split()
def ns():
return stdin.readline().rstrip()
def lc():
return list(ns())
def ni():
return int(stdin.readline())
def nf():
return float(stdin.readline())
from collections import deque
n = ni()
a = [ni() for _ in range(n)]
a.sort()
b = a.copy()
c = a.copy()
# 小さい順に詰める
bdeq = deque(b)
bret = deque()
bret.append(bdeq.popleft())
push_small = False
while len(bdeq) > 1:
if push_small:
bret.append(bdeq.popleft())
bret.appendleft(bdeq.popleft())
push_small = False
else:
bret.append(bdeq.pop())
bret.appendleft(bdeq.pop())
push_small = True
if len(bdeq) > 0:
if abs(bdeq[0] - bret[0]) > abs(bdeq[0] - bret[-1]):
bret.appendleft(bdeq[0])
else:
bret.append(bdeq[0])
# 大きい順に詰める
cdeq = deque(c)
cret = deque()
cret.append(cdeq.pop())
push_small = True
while len(cdeq) > 1:
if push_small:
cret.append(cdeq.popleft())
cret.appendleft(cdeq.popleft())
push_small = False
else:
cret.append(cdeq.pop())
cret.appendleft(cdeq.pop())
push_small = True
if len(cdeq) > 0:
if abs(cdeq[0] - cret[0]) > abs(cdeq[0] - cret[-1]):
cret.appendleft(cdeq[0])
else:
cret.append(cdeq[0])
# 答えが大きいほうを選択
bans = 0
for i in range(n - 1):
bans += abs(bret[i] - bret[i + 1])
cans = 0
for i in range(n - 1):
cans += abs(cret[i] - cret[i + 1])
print((max(bans, cans)))
| false
| 3.614458
|
[
"-sys.setrecursionlimit(10**5)",
"+sys.setrecursionlimit(10**7)",
"-a = []",
"-for _ in range(n):",
"- a.append(ni())",
"-mx_cent = [ai for ai in a]",
"-mn_cent = [ai for ai in a]",
"+a = [ni() for _ in range(n)]",
"-a = deque(a)",
"-mx_cent = deque([ai for ai in a])",
"-mn_cent = deque([ai for ai in a])",
"-bmx = deque([mx_cent.pop()])",
"-bmn = deque([mn_cent.popleft()])",
"-cnt = 0",
"-while len(mx_cent) > 1:",
"- lf = 0",
"- rt = 0",
"- if cnt % 2 == 0:",
"- lf = mx_cent.popleft()",
"- rt = mx_cent.popleft()",
"+b = a.copy()",
"+c = a.copy()",
"+# 小さい順に詰める",
"+bdeq = deque(b)",
"+bret = deque()",
"+bret.append(bdeq.popleft())",
"+push_small = False",
"+while len(bdeq) > 1:",
"+ if push_small:",
"+ bret.append(bdeq.popleft())",
"+ bret.appendleft(bdeq.popleft())",
"+ push_small = False",
"- lf = mx_cent.pop()",
"- rt = mx_cent.pop()",
"- bmx.appendleft(lf)",
"- bmx.append(rt)",
"- if cnt % 2 == 0:",
"- lf = mn_cent.pop()",
"- rt = mn_cent.pop()",
"+ bret.append(bdeq.pop())",
"+ bret.appendleft(bdeq.pop())",
"+ push_small = True",
"+if len(bdeq) > 0:",
"+ if abs(bdeq[0] - bret[0]) > abs(bdeq[0] - bret[-1]):",
"+ bret.appendleft(bdeq[0])",
"- lf = mn_cent.popleft()",
"- rt = mn_cent.popleft()",
"- bmn.appendleft(lf)",
"- bmn.append(rt)",
"- cnt += 1",
"-if len(mx_cent) == 1:",
"- last = mx_cent.pop()",
"- if abs(bmx[0] - last) > abs(bmx[-1] - last):",
"- bmx.appendleft(last)",
"+ bret.append(bdeq[0])",
"+# 大きい順に詰める",
"+cdeq = deque(c)",
"+cret = deque()",
"+cret.append(cdeq.pop())",
"+push_small = True",
"+while len(cdeq) > 1:",
"+ if push_small:",
"+ cret.append(cdeq.popleft())",
"+ cret.appendleft(cdeq.popleft())",
"+ push_small = False",
"- bmx.append(last)",
"- last = mn_cent.pop()",
"- if abs(bmn[0] - last) > abs(bmn[-1] - last):",
"- bmn.appendleft(last)",
"+ cret.append(cdeq.pop())",
"+ cret.appendleft(cdeq.pop())",
"+ push_small = True",
"+if len(cdeq) > 0:",
"+ if abs(cdeq[0] - cret[0]) > abs(cdeq[0] - cret[-1]):",
"+ cret.appendleft(cdeq[0])",
"- bmn.append(last)",
"-diffmx, diffmn = 0, 0",
"+ cret.append(cdeq[0])",
"+# 答えが大きいほうを選択",
"+bans = 0",
"- diffmx += abs(bmx[i + 1] - bmx[i])",
"- diffmn += abs(bmn[i + 1] - bmn[i])",
"-print((max(diffmx, diffmn)))",
"+ bans += abs(bret[i] - bret[i + 1])",
"+cans = 0",
"+for i in range(n - 1):",
"+ cans += abs(cret[i] - cret[i + 1])",
"+print((max(bans, cans)))"
] | false
| 0.049777
| 0.048845
| 1.019079
|
[
"s631954117",
"s040714831"
] |
u408260374
|
p02373
|
python
|
s176470227
|
s573156179
| 2,750
| 2,390
| 73,588
| 40,292
|
Accepted
|
Accepted
| 13.09
|
import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
class Edge:
def __init__(self, dst, weight):
self.dst, self.weight = dst, weight
def __lt__(self, e):
return self.weight > e.weight
class Graph:
def __init__(self, V):
self.V = V
self.E = [[] for _ in range(V)]
def add_edge(self, src, dst, weight):
self.E[src].append(Edge(dst, weight))
class HeavyLightDecomposition:
def __init__(self, g, root=0):
self.g = g
self.vid, self.head, self.heavy, self.parent = [0] * g.V, [-1] * g.V, [-1] * g.V, [-1] * g.V
self.dfs(root)
self.bfs(root)
def dfs(self, root):
stack = [(root, -1, False)]
sub, max_sub = [1] * self.g.V, [(0, -1)] * self.g.V
while stack:
v, par, flag = stack.pop()
if not flag:
self.parent[v] = par
stack.append((v, par, True))
stack.extend((e.dst, v, False) for e in self.g.E[v] if e.dst != par)
else:
if par != -1:
sub[par] += sub[v]
max_sub[par] = max(max_sub[par], (sub[v], v))
self.heavy[v] = max_sub[v][1]
def bfs(self, root=0):
from collections import deque
k, que = 0, deque([root])
while que:
r = v = que.popleft()
while v != -1:
self.vid[v], self.head[v] = k, r
for e in self.g.E[v]:
if e.dst != self.parent[v] and e.dst != self.heavy[v]:
que.append(e.dst)
k += 1
v = self.heavy[v]
def lca(self, u, v):
while self.head[u] != self.head[v]:
if self.vid[u] > self.vid[v]:
u, v = v, u
v = self.parent[self.head[v]]
else:
if self.vid[u] > self.vid[v]:
u, v = v, u
return u
N = int(eval(input()))
g = Graph(N)
for i in range(N):
for c in map(int, input().split()[1:]):
g.add_edge(i, c, 1)
g.add_edge(c, i, 1)
hld = HeavyLightDecomposition(g)
Q = int(eval(input()))
for _ in range(Q):
u, v = list(map(int, input().split()))
print((hld.lca(u, v)))
|
import sys
if sys.version[0] == '2':
range, input = xrange, raw_input
class HeavyLightDecomposition:
def __init__(self, g, root=0):
self.g = g
self.vid, self.head, self.heavy, self.parent = [0] * len(g), [-1] * len(g), [-1] * len(g), [-1] * len(g)
self.dfs(root)
self.bfs(root)
def dfs(self, root):
stack = [(root, -1, False)]
sub, max_sub = [1] * len(self.g), [(0, -1)] * len(self.g)
while stack:
v, par, flag = stack.pop()
if not flag:
self.parent[v] = par
stack.append((v, par, True))
stack.extend((c, v, False) for c in self.g[v] if c != par)
else:
if par != -1:
sub[par] += sub[v]
max_sub[par] = max(max_sub[par], (sub[v], v))
self.heavy[v] = max_sub[v][1]
def bfs(self, root=0):
from collections import deque
k, que = 0, deque([root])
while que:
r = v = que.popleft()
while v != -1:
self.vid[v], self.head[v] = k, r
for c in self.g[v]:
if c != self.parent[v] and c != self.heavy[v]:
que.append(c)
k += 1
v = self.heavy[v]
def lca(self, u, v):
while self.head[u] != self.head[v]:
if self.vid[u] > self.vid[v]:
u, v = v, u
v = self.parent[self.head[v]]
else:
if self.vid[u] > self.vid[v]:
u, v = v, u
return u
N = int(eval(input()))
g = [[] for _ in range(N)]
for i in range(N):
for c in map(int, input().split()[1:]):
g[i].append(c)
g[c].append(i)
hld = HeavyLightDecomposition(g)
Q = int(eval(input()))
for _ in range(Q):
u, v = list(map(int, input().split()))
print((hld.lca(u, v)))
| 78
| 61
| 2,311
| 1,943
|
import sys
if sys.version[0] == "2":
range, input = xrange, raw_input
class Edge:
def __init__(self, dst, weight):
self.dst, self.weight = dst, weight
def __lt__(self, e):
return self.weight > e.weight
class Graph:
def __init__(self, V):
self.V = V
self.E = [[] for _ in range(V)]
def add_edge(self, src, dst, weight):
self.E[src].append(Edge(dst, weight))
class HeavyLightDecomposition:
def __init__(self, g, root=0):
self.g = g
self.vid, self.head, self.heavy, self.parent = (
[0] * g.V,
[-1] * g.V,
[-1] * g.V,
[-1] * g.V,
)
self.dfs(root)
self.bfs(root)
def dfs(self, root):
stack = [(root, -1, False)]
sub, max_sub = [1] * self.g.V, [(0, -1)] * self.g.V
while stack:
v, par, flag = stack.pop()
if not flag:
self.parent[v] = par
stack.append((v, par, True))
stack.extend((e.dst, v, False) for e in self.g.E[v] if e.dst != par)
else:
if par != -1:
sub[par] += sub[v]
max_sub[par] = max(max_sub[par], (sub[v], v))
self.heavy[v] = max_sub[v][1]
def bfs(self, root=0):
from collections import deque
k, que = 0, deque([root])
while que:
r = v = que.popleft()
while v != -1:
self.vid[v], self.head[v] = k, r
for e in self.g.E[v]:
if e.dst != self.parent[v] and e.dst != self.heavy[v]:
que.append(e.dst)
k += 1
v = self.heavy[v]
def lca(self, u, v):
while self.head[u] != self.head[v]:
if self.vid[u] > self.vid[v]:
u, v = v, u
v = self.parent[self.head[v]]
else:
if self.vid[u] > self.vid[v]:
u, v = v, u
return u
N = int(eval(input()))
g = Graph(N)
for i in range(N):
for c in map(int, input().split()[1:]):
g.add_edge(i, c, 1)
g.add_edge(c, i, 1)
hld = HeavyLightDecomposition(g)
Q = int(eval(input()))
for _ in range(Q):
u, v = list(map(int, input().split()))
print((hld.lca(u, v)))
|
import sys
if sys.version[0] == "2":
range, input = xrange, raw_input
class HeavyLightDecomposition:
def __init__(self, g, root=0):
self.g = g
self.vid, self.head, self.heavy, self.parent = (
[0] * len(g),
[-1] * len(g),
[-1] * len(g),
[-1] * len(g),
)
self.dfs(root)
self.bfs(root)
def dfs(self, root):
stack = [(root, -1, False)]
sub, max_sub = [1] * len(self.g), [(0, -1)] * len(self.g)
while stack:
v, par, flag = stack.pop()
if not flag:
self.parent[v] = par
stack.append((v, par, True))
stack.extend((c, v, False) for c in self.g[v] if c != par)
else:
if par != -1:
sub[par] += sub[v]
max_sub[par] = max(max_sub[par], (sub[v], v))
self.heavy[v] = max_sub[v][1]
def bfs(self, root=0):
from collections import deque
k, que = 0, deque([root])
while que:
r = v = que.popleft()
while v != -1:
self.vid[v], self.head[v] = k, r
for c in self.g[v]:
if c != self.parent[v] and c != self.heavy[v]:
que.append(c)
k += 1
v = self.heavy[v]
def lca(self, u, v):
while self.head[u] != self.head[v]:
if self.vid[u] > self.vid[v]:
u, v = v, u
v = self.parent[self.head[v]]
else:
if self.vid[u] > self.vid[v]:
u, v = v, u
return u
N = int(eval(input()))
g = [[] for _ in range(N)]
for i in range(N):
for c in map(int, input().split()[1:]):
g[i].append(c)
g[c].append(i)
hld = HeavyLightDecomposition(g)
Q = int(eval(input()))
for _ in range(Q):
u, v = list(map(int, input().split()))
print((hld.lca(u, v)))
| false
| 21.794872
|
[
"-class Edge:",
"- def __init__(self, dst, weight):",
"- self.dst, self.weight = dst, weight",
"-",
"- def __lt__(self, e):",
"- return self.weight > e.weight",
"-",
"-",
"-class Graph:",
"- def __init__(self, V):",
"- self.V = V",
"- self.E = [[] for _ in range(V)]",
"-",
"- def add_edge(self, src, dst, weight):",
"- self.E[src].append(Edge(dst, weight))",
"-",
"-",
"- [0] * g.V,",
"- [-1] * g.V,",
"- [-1] * g.V,",
"- [-1] * g.V,",
"+ [0] * len(g),",
"+ [-1] * len(g),",
"+ [-1] * len(g),",
"+ [-1] * len(g),",
"- sub, max_sub = [1] * self.g.V, [(0, -1)] * self.g.V",
"+ sub, max_sub = [1] * len(self.g), [(0, -1)] * len(self.g)",
"- stack.extend((e.dst, v, False) for e in self.g.E[v] if e.dst != par)",
"+ stack.extend((c, v, False) for c in self.g[v] if c != par)",
"- for e in self.g.E[v]:",
"- if e.dst != self.parent[v] and e.dst != self.heavy[v]:",
"- que.append(e.dst)",
"+ for c in self.g[v]:",
"+ if c != self.parent[v] and c != self.heavy[v]:",
"+ que.append(c)",
"-g = Graph(N)",
"+g = [[] for _ in range(N)]",
"- g.add_edge(i, c, 1)",
"- g.add_edge(c, i, 1)",
"+ g[i].append(c)",
"+ g[c].append(i)"
] | false
| 0.038616
| 0.066828
| 0.577838
|
[
"s176470227",
"s573156179"
] |
u618940213
|
p03910
|
python
|
s969676173
|
s386433168
| 1,422
| 33
| 9,172
| 9,176
|
Accepted
|
Accepted
| 97.68
|
n = int(eval(input()))
m = -1
for i in range(1, n+1):
if i * (i - 1) < 2 * n <= i * (i + 1):
m = i
top = m * (m + 1) // 2
for i in range(0, m):
if top - i == n:
ng = i
break
for i in range(1, m+1):
if i == ng:
continue
print(i)
|
n = int(eval(input()))
m = -1
for i in range(1, n+1):
if i * (i - 1) < 2 * n <= i * (i + 1):
m = i
break
top = m * (m + 1) // 2
for i in range(0, m):
if top - i == n:
ng = i
break
for i in range(1, m+1):
if i == ng:
continue
print(i)
| 14
| 15
| 282
| 297
|
n = int(eval(input()))
m = -1
for i in range(1, n + 1):
if i * (i - 1) < 2 * n <= i * (i + 1):
m = i
top = m * (m + 1) // 2
for i in range(0, m):
if top - i == n:
ng = i
break
for i in range(1, m + 1):
if i == ng:
continue
print(i)
|
n = int(eval(input()))
m = -1
for i in range(1, n + 1):
if i * (i - 1) < 2 * n <= i * (i + 1):
m = i
break
top = m * (m + 1) // 2
for i in range(0, m):
if top - i == n:
ng = i
break
for i in range(1, m + 1):
if i == ng:
continue
print(i)
| false
| 6.666667
|
[
"+ break"
] | false
| 0.054483
| 0.031181
| 1.747318
|
[
"s969676173",
"s386433168"
] |
u810356688
|
p02732
|
python
|
s498812068
|
s857657234
| 472
| 343
| 89,564
| 26,636
|
Accepted
|
Accepted
| 27.33
|
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter,defaultdict
from operator import mul
from functools import reduce
def cmb1(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
def main():
n=int(eval(input()))
A=[int(_) for _ in input().split()]
A_c=Counter(A)
combi=0
for ac in list(A_c.items()):
if ac[1]>=2:
combi+=cmb1(ac[1],2)
for i in range(n):
print((combi-(A_c[A[i]]-1)))
if __name__=='__main__':
main()
|
import sys
def input(): return sys.stdin.readline().rstrip()
from collections import Counter
from operator import mul
from functools import reduce
def cmb1(n,r):
r = min(n-r,r)
if r == 0: return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1,r + 1)))
return over // under
def main():
n=int(eval(input()))
A=[int(_) for _ in input().split()]
A_c=Counter(A)
combi=0
for ac in list(A_c.items()):
if ac[1]>=2:
combi+=cmb1(ac[1],2)
for i in range(n):
print((combi-(A_c[A[i]]-1)))
if __name__=='__main__':
main()
| 26
| 28
| 630
| 622
|
import sys
def input():
return sys.stdin.readline().rstrip()
from collections import Counter, defaultdict
from operator import mul
from functools import reduce
def cmb1(n, r):
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
n = int(eval(input()))
A = [int(_) for _ in input().split()]
A_c = Counter(A)
combi = 0
for ac in list(A_c.items()):
if ac[1] >= 2:
combi += cmb1(ac[1], 2)
for i in range(n):
print((combi - (A_c[A[i]] - 1)))
if __name__ == "__main__":
main()
|
import sys
def input():
return sys.stdin.readline().rstrip()
from collections import Counter
from operator import mul
from functools import reduce
def cmb1(n, r):
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, list(range(n, n - r, -1)))
under = reduce(mul, list(range(1, r + 1)))
return over // under
def main():
n = int(eval(input()))
A = [int(_) for _ in input().split()]
A_c = Counter(A)
combi = 0
for ac in list(A_c.items()):
if ac[1] >= 2:
combi += cmb1(ac[1], 2)
for i in range(n):
print((combi - (A_c[A[i]] - 1)))
if __name__ == "__main__":
main()
| false
| 7.142857
|
[
"-from collections import Counter, defaultdict",
"+from collections import Counter"
] | false
| 0.295841
| 0.158769
| 1.863338
|
[
"s498812068",
"s857657234"
] |
u724687935
|
p03612
|
python
|
s172500215
|
s841389320
| 101
| 89
| 14,008
| 14,008
|
Accepted
|
Accepted
| 11.88
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
t = 'o' if P[0] == 1 else 'x'
j = 0 if t == 'o' else 1
L = []
for i, p in enumerate(P):
s = 'o' if p == (i + 1) else 'x'
if s == t:
cnt += 1
else:
L.append(cnt)
cnt = 1
t = s
L.append(cnt)
ans = 0
for i, n in enumerate(L):
if i % 2 == j:
ans += (n + 2 - 1) // 2
print(ans)
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
ans = 0
t = 'o' if P[0] == 1 else 'x'
for i, p in enumerate(P):
s = 'o' if p == (i + 1) else 'x'
if s == t:
cnt += 1
else:
if t == 'o':
ans += (cnt + 2 - 1) // 2
cnt = 1
t = s
else:
if t == 'o':
ans += (cnt + 2 - 1) // 2
print(ans)
| 23
| 20
| 415
| 382
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
t = "o" if P[0] == 1 else "x"
j = 0 if t == "o" else 1
L = []
for i, p in enumerate(P):
s = "o" if p == (i + 1) else "x"
if s == t:
cnt += 1
else:
L.append(cnt)
cnt = 1
t = s
L.append(cnt)
ans = 0
for i, n in enumerate(L):
if i % 2 == j:
ans += (n + 2 - 1) // 2
print(ans)
|
N = int(eval(input()))
P = list(map(int, input().split()))
cnt = 0
ans = 0
t = "o" if P[0] == 1 else "x"
for i, p in enumerate(P):
s = "o" if p == (i + 1) else "x"
if s == t:
cnt += 1
else:
if t == "o":
ans += (cnt + 2 - 1) // 2
cnt = 1
t = s
else:
if t == "o":
ans += (cnt + 2 - 1) // 2
print(ans)
| false
| 13.043478
|
[
"+ans = 0",
"-j = 0 if t == \"o\" else 1",
"-L = []",
"- L.append(cnt)",
"+ if t == \"o\":",
"+ ans += (cnt + 2 - 1) // 2",
"-L.append(cnt)",
"-ans = 0",
"-for i, n in enumerate(L):",
"- if i % 2 == j:",
"- ans += (n + 2 - 1) // 2",
"+else:",
"+ if t == \"o\":",
"+ ans += (cnt + 2 - 1) // 2"
] | false
| 0.078253
| 0.089368
| 0.875628
|
[
"s172500215",
"s841389320"
] |
u083668616
|
p03210
|
python
|
s346702965
|
s376625298
| 13
| 10
| 2,568
| 2,568
|
Accepted
|
Accepted
| 23.08
|
shichigosan = [7, 5, 3]
X = int(input())
ans = 'NO'
for i in range(0, 3):
if X == shichigosan[i]: ans = 'YES'
print(ans)
|
lst = [7, 5, 3]
X = int(input())
if X in lst: print('YES')
else: print('NO')
| 9
| 4
| 135
| 81
|
shichigosan = [7, 5, 3]
X = int(input())
ans = "NO"
for i in range(0, 3):
if X == shichigosan[i]:
ans = "YES"
print(ans)
|
lst = [7, 5, 3]
X = int(input())
if X in lst:
print("YES")
else:
print("NO")
| false
| 55.555556
|
[
"-shichigosan = [7, 5, 3]",
"+lst = [7, 5, 3]",
"-ans = \"NO\"",
"-for i in range(0, 3):",
"- if X == shichigosan[i]:",
"- ans = \"YES\"",
"-print(ans)",
"+if X in lst:",
"+ print(\"YES\")",
"+else:",
"+ print(\"NO\")"
] | false
| 0.042748
| 0.038305
| 1.115988
|
[
"s346702965",
"s376625298"
] |
u623819879
|
p02901
|
python
|
s825210706
|
s013046464
| 1,049
| 716
| 150,872
| 73,572
|
Accepted
|
Accepted
| 31.74
|
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
#import math
#import time
import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
#ts=time.time()
sys.setrecursionlimit(10**6)
#input=sys.stdin.readline
show_flg=False
#show_flg=True
n,m=MI()
t=1<<n
key=[]
for i in range(m):
a,b=MI()
c=0
for j in LI_():
c+=1<<j
key.append((a,c))
inf=float('inf')
dp=[[inf]*(m+1) for _ in range(t)]
#dp[stat][m] # min value using up to m and open stat
dp[0][0]=0
for j in range(1,m+1):
for i in range(t):
cost,ck=key[j-1]
show(i,j,'|',dp[ck|i][j],min(dp[ck|i][j-1],dp[i][j-1]+cost))
dp[ck|i][j]=min(dp[ck|i][j],dp[ck|i][j-1],dp[i][j-1]+cost)
dp[i][j]=min(dp[i][j],dp[i][j-1])
for i in dp:
show(*i)
ans=dp[t-1][m] if dp[t-1][m]!=inf else -1
print(ans)
|
from subprocess import*
with open('e.cpp','w')as f:f.write(r"""
#include <bits/stdc++.h>
using namespace std;
const int maxs = 4096;
int dp[maxs];
int main() {
memset(dp, 0x3f, 16384);
dp[0] = 0;
int n, m;
cin >> n >> m;
while (m--) {
int a, b, s = 0;
cin >> a >> b;
while (b--) {
int c;
cin >> c;
s ^= 1 << c - 1;
}
dp[s] = min(dp[s], a);
}
for (int i = 0; i != n; ++i) for (int all = (1 << n) - 1 ^ 1 << i, sub = all; sub; sub = sub - 1 & all)
dp[sub] = min(dp[sub], dp[sub ^ 1 << i]);
for (int s = 0; s != (1 << n); ++s) if (s != (s & -s))
for (int t = s - 1 & s; t != s; t = t - 1 & s)
dp[s] = min(dp[s], dp[t] + dp[s ^ t]);
int mask = (1 << n) - 1;
if (dp[mask] == 0x3f3f3f3f) dp[mask] = -1;
cout << dp[mask] << endl;
}""")
call(('g++','e.cpp'))
call('./a.out')
| 57
| 34
| 1,305
| 839
|
from heapq import heappush, heappop
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations
import sys
import bisect
import string
# import math
# import time
import random
def I():
return int(input())
def MI():
return map(int, input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i) - 1 for i in input().split()]
def StoI():
return [ord(i) - 97 for i in input()]
def show(*inp, end="\n"):
if show_flg:
print(*inp, end=end)
YN = ["Yes", "No"]
mo = 10**9 + 7
# ts=time.time()
sys.setrecursionlimit(10**6)
# input=sys.stdin.readline
show_flg = False
# show_flg=True
n, m = MI()
t = 1 << n
key = []
for i in range(m):
a, b = MI()
c = 0
for j in LI_():
c += 1 << j
key.append((a, c))
inf = float("inf")
dp = [[inf] * (m + 1) for _ in range(t)]
# dp[stat][m] # min value using up to m and open stat
dp[0][0] = 0
for j in range(1, m + 1):
for i in range(t):
cost, ck = key[j - 1]
show(i, j, "|", dp[ck | i][j], min(dp[ck | i][j - 1], dp[i][j - 1] + cost))
dp[ck | i][j] = min(dp[ck | i][j], dp[ck | i][j - 1], dp[i][j - 1] + cost)
dp[i][j] = min(dp[i][j], dp[i][j - 1])
for i in dp:
show(*i)
ans = dp[t - 1][m] if dp[t - 1][m] != inf else -1
print(ans)
|
from subprocess import *
with open("e.cpp", "w") as f:
f.write(
r"""
#include <bits/stdc++.h>
using namespace std;
const int maxs = 4096;
int dp[maxs];
int main() {
memset(dp, 0x3f, 16384);
dp[0] = 0;
int n, m;
cin >> n >> m;
while (m--) {
int a, b, s = 0;
cin >> a >> b;
while (b--) {
int c;
cin >> c;
s ^= 1 << c - 1;
}
dp[s] = min(dp[s], a);
}
for (int i = 0; i != n; ++i) for (int all = (1 << n) - 1 ^ 1 << i, sub = all; sub; sub = sub - 1 & all)
dp[sub] = min(dp[sub], dp[sub ^ 1 << i]);
for (int s = 0; s != (1 << n); ++s) if (s != (s & -s))
for (int t = s - 1 & s; t != s; t = t - 1 & s)
dp[s] = min(dp[s], dp[t] + dp[s ^ t]);
int mask = (1 << n) - 1;
if (dp[mask] == 0x3f3f3f3f) dp[mask] = -1;
cout << dp[mask] << endl;
}"""
)
call(("g++", "e.cpp"))
call("./a.out")
| false
| 40.350877
|
[
"-from heapq import heappush, heappop",
"-from collections import deque, defaultdict, Counter",
"-import itertools",
"-from itertools import permutations, combinations",
"-import sys",
"-import bisect",
"-import string",
"+from subprocess import *",
"-# import math",
"-# import time",
"-import random",
"-",
"-",
"-def I():",
"- return int(input())",
"-",
"-",
"-def MI():",
"- return map(int, input().split())",
"-",
"-",
"-def LI():",
"- return [int(i) for i in input().split()]",
"-",
"-",
"-def LI_():",
"- return [int(i) - 1 for i in input().split()]",
"-",
"-",
"-def StoI():",
"- return [ord(i) - 97 for i in input()]",
"-",
"-",
"-def show(*inp, end=\"\\n\"):",
"- if show_flg:",
"- print(*inp, end=end)",
"-",
"-",
"-YN = [\"Yes\", \"No\"]",
"-mo = 10**9 + 7",
"-# ts=time.time()",
"-sys.setrecursionlimit(10**6)",
"-# input=sys.stdin.readline",
"-show_flg = False",
"-# show_flg=True",
"-n, m = MI()",
"-t = 1 << n",
"-key = []",
"-for i in range(m):",
"- a, b = MI()",
"- c = 0",
"- for j in LI_():",
"- c += 1 << j",
"- key.append((a, c))",
"-inf = float(\"inf\")",
"-dp = [[inf] * (m + 1) for _ in range(t)]",
"-# dp[stat][m] # min value using up to m and open stat",
"-dp[0][0] = 0",
"-for j in range(1, m + 1):",
"- for i in range(t):",
"- cost, ck = key[j - 1]",
"- show(i, j, \"|\", dp[ck | i][j], min(dp[ck | i][j - 1], dp[i][j - 1] + cost))",
"- dp[ck | i][j] = min(dp[ck | i][j], dp[ck | i][j - 1], dp[i][j - 1] + cost)",
"- dp[i][j] = min(dp[i][j], dp[i][j - 1])",
"-for i in dp:",
"- show(*i)",
"-ans = dp[t - 1][m] if dp[t - 1][m] != inf else -1",
"-print(ans)",
"+with open(\"e.cpp\", \"w\") as f:",
"+ f.write(",
"+ r\"\"\"",
"+#include <bits/stdc++.h>",
"+using namespace std;",
"+const int maxs = 4096;",
"+int dp[maxs];",
"+int main() {",
"+\tmemset(dp, 0x3f, 16384);",
"+\tdp[0] = 0;",
"+\tint n, m;",
"+\tcin >> n >> m;",
"+\twhile (m--) {",
"+\t\tint a, b, s = 0;",
"+\t\tcin >> a >> b;",
"+\t\twhile (b--) {",
"+\t\t\tint c;",
"+\t\t\tcin >> c;",
"+\t\t\ts ^= 1 << c - 1;",
"+\t\t}",
"+\t\tdp[s] = min(dp[s], a);",
"+\t}",
"+\tfor (int i = 0; i != n; ++i) for (int all = (1 << n) - 1 ^ 1 << i, sub = all; sub; sub = sub - 1 & all)",
"+\t\tdp[sub] = min(dp[sub], dp[sub ^ 1 << i]);",
"+\tfor (int s = 0; s != (1 << n); ++s) if (s != (s & -s))",
"+\t\tfor (int t = s - 1 & s; t != s; t = t - 1 & s)",
"+\t\t\tdp[s] = min(dp[s], dp[t] + dp[s ^ t]);",
"+\tint mask = (1 << n) - 1;",
"+\tif (dp[mask] == 0x3f3f3f3f) dp[mask] = -1;",
"+\tcout << dp[mask] << endl;",
"+}\"\"\"",
"+ )",
"+call((\"g++\", \"e.cpp\"))",
"+call(\"./a.out\")"
] | false
| 0.040965
| 1.666217
| 0.024586
|
[
"s825210706",
"s013046464"
] |
u346812984
|
p02743
|
python
|
s598962648
|
s119802826
| 36
| 17
| 5,204
| 2,940
|
Accepted
|
Accepted
| 52.78
|
from decimal import Decimal
a, b, c = list(map(int, input().split()))
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
print("Yes")
else:
print("No")
|
a, b, c = list(map(int, input().split()))
if c - a - b <= 0:
print("No")
else:
if (c - a - b) ** 2 - 4 * a * b > 0:
print("Yes")
else:
print("No")
| 7
| 8
| 172
| 176
|
from decimal import Decimal
a, b, c = list(map(int, input().split()))
if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():
print("Yes")
else:
print("No")
|
a, b, c = list(map(int, input().split()))
if c - a - b <= 0:
print("No")
else:
if (c - a - b) ** 2 - 4 * a * b > 0:
print("Yes")
else:
print("No")
| false
| 12.5
|
[
"-from decimal import Decimal",
"-",
"-if Decimal(a).sqrt() + Decimal(b).sqrt() < Decimal(c).sqrt():",
"- print(\"Yes\")",
"+if c - a - b <= 0:",
"+ print(\"No\")",
"- print(\"No\")",
"+ if (c - a - b) ** 2 - 4 * a * b > 0:",
"+ print(\"Yes\")",
"+ else:",
"+ print(\"No\")"
] | false
| 0.049768
| 0.06768
| 0.735334
|
[
"s598962648",
"s119802826"
] |
u323680411
|
p03944
|
python
|
s599103797
|
s879840900
| 417
| 166
| 12,516
| 3,064
|
Accepted
|
Accepted
| 60.19
|
import numpy as np
from sys import stdin
def main():
w = next_int()
h = next_int()
n = next_int()
arr = np.ones((h, w), dtype=np.int)
for i in range(n):
xi, yi, a = list(map(int, input().split()))
for y in range(h):
for x in range(w):
if a == 1:
if x < xi:
arr[y][x] = 0
if a == 2:
if x >= xi:
arr[y][x] = 0
if a == 3:
if y < yi:
arr[y][x] = 0
if a == 4:
if y >= yi:
arr[y][x] = 0
ans = arr.sum()
print(ans)
def next_int():
return int(next_str())
def next_str():
result = ""
while True:
tmp = stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != '\r':
break
return result
if __name__ == '__main__':
main()
|
from sys import stdin
def main():
w = next_int()
h = next_int()
n = next_int()
arr = [[1] * w for _ in range(h)]
for i in range(n):
xi, yi, a = list(map(int, input().split()))
for y in range(h):
for x in range(w):
if a == 1:
if x < xi:
arr[y][x] = 0
if a == 2:
if x >= xi:
arr[y][x] = 0
if a == 3:
if y < yi:
arr[y][x] = 0
if a == 4:
if y >= yi:
arr[y][x] = 0
ans = 0
for y in range(h):
ans += sum(arr[y])
print(ans)
def next_int():
return int(next_str())
def next_str():
result = ""
while True:
tmp = stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != '\r':
break
return result
if __name__ == '__main__':
main()
| 49
| 50
| 1,031
| 1,053
|
import numpy as np
from sys import stdin
def main():
w = next_int()
h = next_int()
n = next_int()
arr = np.ones((h, w), dtype=np.int)
for i in range(n):
xi, yi, a = list(map(int, input().split()))
for y in range(h):
for x in range(w):
if a == 1:
if x < xi:
arr[y][x] = 0
if a == 2:
if x >= xi:
arr[y][x] = 0
if a == 3:
if y < yi:
arr[y][x] = 0
if a == 4:
if y >= yi:
arr[y][x] = 0
ans = arr.sum()
print(ans)
def next_int():
return int(next_str())
def next_str():
result = ""
while True:
tmp = stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != "\r":
break
return result
if __name__ == "__main__":
main()
|
from sys import stdin
def main():
w = next_int()
h = next_int()
n = next_int()
arr = [[1] * w for _ in range(h)]
for i in range(n):
xi, yi, a = list(map(int, input().split()))
for y in range(h):
for x in range(w):
if a == 1:
if x < xi:
arr[y][x] = 0
if a == 2:
if x >= xi:
arr[y][x] = 0
if a == 3:
if y < yi:
arr[y][x] = 0
if a == 4:
if y >= yi:
arr[y][x] = 0
ans = 0
for y in range(h):
ans += sum(arr[y])
print(ans)
def next_int():
return int(next_str())
def next_str():
result = ""
while True:
tmp = stdin.read(1)
if tmp.strip() != "":
result += tmp
elif tmp != "\r":
break
return result
if __name__ == "__main__":
main()
| false
| 2
|
[
"-import numpy as np",
"- arr = np.ones((h, w), dtype=np.int)",
"+ arr = [[1] * w for _ in range(h)]",
"- ans = arr.sum()",
"+ ans = 0",
"+ for y in range(h):",
"+ ans += sum(arr[y])"
] | false
| 0.789439
| 0.121
| 6.524274
|
[
"s599103797",
"s879840900"
] |
u597436499
|
p03493
|
python
|
s656407695
|
s016763858
| 19
| 17
| 2,940
| 3,060
|
Accepted
|
Accepted
| 10.53
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
s = ns()
ans = 0
for i in s:
if i == '1':
ans += 1
else:
pass
print(ans)
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
s = ns()
ans = 0
if s[0] == '1':
ans += 1
if s[1] == '1':
ans += 1
if s[2] == '1':
ans += 1
print(ans)
| 16
| 17
| 251
| 270
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
s = ns()
ans = 0
for i in s:
if i == "1":
ans += 1
else:
pass
print(ans)
|
import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline()
s = ns()
ans = 0
if s[0] == "1":
ans += 1
if s[1] == "1":
ans += 1
if s[2] == "1":
ans += 1
print(ans)
| false
| 5.882353
|
[
"-for i in s:",
"- if i == \"1\":",
"- ans += 1",
"- else:",
"- pass",
"+if s[0] == \"1\":",
"+ ans += 1",
"+if s[1] == \"1\":",
"+ ans += 1",
"+if s[2] == \"1\":",
"+ ans += 1"
] | false
| 0.180651
| 0.04762
| 3.793602
|
[
"s656407695",
"s016763858"
] |
u606045429
|
p02868
|
python
|
s955585706
|
s412630868
| 677
| 588
| 54,244
| 50,164
|
Accepted
|
Accepted
| 13.15
|
from heapq import heappush, heappop
INF = float("inf")
N, M, *LRC = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i in range(N - 1):
E[i + 1].append((i, 0))
for l, r, c in zip(*[iter(LRC)] * 3):
E[l - 1].append((r - 1, c))
D = [INF] * N
D[0] = 0
Q = [(0, 0)]
while Q:
dist, cur = heappop(Q)
for nxt, cost in E[cur]:
cand = dist + cost
if D[nxt] > cand:
D[nxt] = cand
heappush(Q, (cand, nxt))
print((-1 if D[N - 1] == INF else D[N - 1]))
|
from heapq import heappush, heappop
INF = float("inf")
N, M, *LRC = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i in range(N - 1):
E[i + 1].append((i, 0))
for l, r, c in zip(*[iter(LRC)] * 3):
E[l - 1].append((r - 1, c))
D = [INF] * N
D[0] = 0
Q = [0]
while Q:
t = heappop(Q)
dist, cur = divmod(t, N)
for nxt, cost in E[cur]:
cand = dist + cost
if D[nxt] > cand:
D[nxt] = cand
heappush(Q, cand * N + nxt)
print((-1 if D[N - 1] == INF else D[N - 1]))
| 25
| 26
| 539
| 558
|
from heapq import heappush, heappop
INF = float("inf")
N, M, *LRC = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i in range(N - 1):
E[i + 1].append((i, 0))
for l, r, c in zip(*[iter(LRC)] * 3):
E[l - 1].append((r - 1, c))
D = [INF] * N
D[0] = 0
Q = [(0, 0)]
while Q:
dist, cur = heappop(Q)
for nxt, cost in E[cur]:
cand = dist + cost
if D[nxt] > cand:
D[nxt] = cand
heappush(Q, (cand, nxt))
print((-1 if D[N - 1] == INF else D[N - 1]))
|
from heapq import heappush, heappop
INF = float("inf")
N, M, *LRC = list(map(int, open(0).read().split()))
E = [[] for _ in range(N)]
for i in range(N - 1):
E[i + 1].append((i, 0))
for l, r, c in zip(*[iter(LRC)] * 3):
E[l - 1].append((r - 1, c))
D = [INF] * N
D[0] = 0
Q = [0]
while Q:
t = heappop(Q)
dist, cur = divmod(t, N)
for nxt, cost in E[cur]:
cand = dist + cost
if D[nxt] > cand:
D[nxt] = cand
heappush(Q, cand * N + nxt)
print((-1 if D[N - 1] == INF else D[N - 1]))
| false
| 3.846154
|
[
"-Q = [(0, 0)]",
"+Q = [0]",
"- dist, cur = heappop(Q)",
"+ t = heappop(Q)",
"+ dist, cur = divmod(t, N)",
"- heappush(Q, (cand, nxt))",
"+ heappush(Q, cand * N + nxt)"
] | false
| 0.038703
| 0.039189
| 0.987584
|
[
"s955585706",
"s412630868"
] |
u896741788
|
p03426
|
python
|
s347284975
|
s136548269
| 950
| 307
| 23,812
| 36,940
|
Accepted
|
Accepted
| 67.68
|
h,w,d=list(map(int,input().split()))
ind={}
for i in range(h):
l=list(map(int,input().split()))
for j in range(w):
ind[l[j]]=(i,j)
dp=[0]*(h*w)
for i in range(d+1,h*w+1):
x,y=ind[i]
z,q=ind[i-d]
dp[i-1]=abs(z-x)+abs(y-q)+dp[i-d-1]
q=int(eval(input()))
for i in range(q):
l,r=list(map(int,input().split()))
print((dp[r-1]-dp[l-1]))
|
import sys
input=sys.stdin.buffer.readline
inputs=sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
h,w,d=list(map(int,input().split()))
inds={}
for i in range(h):
for D,j in enumerate(input().split()):
inds[int(j)-1]=(i,D)
nows=[[0]for c in range(d)]
for k in range(d,h*w):
a,b=inds[k]
x,y=inds[k-d]
k%=d
nows[k].append(nows[k][-1]+abs(a-x)+abs(b-y))
q=eval(input())
for i in inputs():
l,r=list(map(int,i.split()))
l-=1;r-=1
l,b=divmod(l,d)
r,b=divmod(r,d)
print((nows[b][r]-nows[b][l]))
| 18
| 23
| 366
| 546
|
h, w, d = list(map(int, input().split()))
ind = {}
for i in range(h):
l = list(map(int, input().split()))
for j in range(w):
ind[l[j]] = (i, j)
dp = [0] * (h * w)
for i in range(d + 1, h * w + 1):
x, y = ind[i]
z, q = ind[i - d]
dp[i - 1] = abs(z - x) + abs(y - q) + dp[i - d - 1]
q = int(eval(input()))
for i in range(q):
l, r = list(map(int, input().split()))
print((dp[r - 1] - dp[l - 1]))
|
import sys
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**9)
h, w, d = list(map(int, input().split()))
inds = {}
for i in range(h):
for D, j in enumerate(input().split()):
inds[int(j) - 1] = (i, D)
nows = [[0] for c in range(d)]
for k in range(d, h * w):
a, b = inds[k]
x, y = inds[k - d]
k %= d
nows[k].append(nows[k][-1] + abs(a - x) + abs(b - y))
q = eval(input())
for i in inputs():
l, r = list(map(int, i.split()))
l -= 1
r -= 1
l, b = divmod(l, d)
r, b = divmod(r, d)
print((nows[b][r] - nows[b][l]))
| false
| 21.73913
|
[
"+import sys",
"+",
"+input = sys.stdin.buffer.readline",
"+inputs = sys.stdin.buffer.readlines",
"+sys.setrecursionlimit(10**9)",
"-ind = {}",
"+inds = {}",
"- l = list(map(int, input().split()))",
"- for j in range(w):",
"- ind[l[j]] = (i, j)",
"-dp = [0] * (h * w)",
"-for i in range(d + 1, h * w + 1):",
"- x, y = ind[i]",
"- z, q = ind[i - d]",
"- dp[i - 1] = abs(z - x) + abs(y - q) + dp[i - d - 1]",
"-q = int(eval(input()))",
"-for i in range(q):",
"- l, r = list(map(int, input().split()))",
"- print((dp[r - 1] - dp[l - 1]))",
"+ for D, j in enumerate(input().split()):",
"+ inds[int(j) - 1] = (i, D)",
"+nows = [[0] for c in range(d)]",
"+for k in range(d, h * w):",
"+ a, b = inds[k]",
"+ x, y = inds[k - d]",
"+ k %= d",
"+ nows[k].append(nows[k][-1] + abs(a - x) + abs(b - y))",
"+q = eval(input())",
"+for i in inputs():",
"+ l, r = list(map(int, i.split()))",
"+ l -= 1",
"+ r -= 1",
"+ l, b = divmod(l, d)",
"+ r, b = divmod(r, d)",
"+ print((nows[b][r] - nows[b][l]))"
] | false
| 0.043418
| 0.067922
| 0.639237
|
[
"s347284975",
"s136548269"
] |
u230621983
|
p02947
|
python
|
s216574417
|
s659113731
| 360
| 226
| 19,760
| 24,184
|
Accepted
|
Accepted
| 37.22
|
from collections import Counter
n = int(eval(input()))
s = [''.join(sorted(eval(input()))) for _ in range(n)]
c = Counter(s)
cnt = 0
for key in c:
val = c[key]
cnt += val*(val-1)//2
print(cnt)
|
from collections import Counter
n = int(eval(input()))
l = [''.join(sorted(eval(input()))) for i in range(n)]
c = Counter(l)
cnt = 0
for val in list(c.values()):
cnt += val * (val-1) //2
print(cnt)
| 13
| 10
| 204
| 198
|
from collections import Counter
n = int(eval(input()))
s = ["".join(sorted(eval(input()))) for _ in range(n)]
c = Counter(s)
cnt = 0
for key in c:
val = c[key]
cnt += val * (val - 1) // 2
print(cnt)
|
from collections import Counter
n = int(eval(input()))
l = ["".join(sorted(eval(input()))) for i in range(n)]
c = Counter(l)
cnt = 0
for val in list(c.values()):
cnt += val * (val - 1) // 2
print(cnt)
| false
| 23.076923
|
[
"-s = [\"\".join(sorted(eval(input()))) for _ in range(n)]",
"-c = Counter(s)",
"+l = [\"\".join(sorted(eval(input()))) for i in range(n)]",
"+c = Counter(l)",
"-for key in c:",
"- val = c[key]",
"+for val in list(c.values()):"
] | false
| 0.042304
| 0.042475
| 0.99597
|
[
"s216574417",
"s659113731"
] |
u945405878
|
p02659
|
python
|
s063969051
|
s498029663
| 30
| 20
| 10,060
| 9,100
|
Accepted
|
Accepted
| 33.33
|
from math import floor
from decimal import Decimal
a, b = input().split()
a = int(a)
b = Decimal(b)
print((floor(a * b)))
|
a, b = input().split(" ")
A, B = int(a), float(b)
B100 = round(B * 100)
C = A * B100
ans = C // 100
print(ans)
| 6
| 6
| 124
| 115
|
from math import floor
from decimal import Decimal
a, b = input().split()
a = int(a)
b = Decimal(b)
print((floor(a * b)))
|
a, b = input().split(" ")
A, B = int(a), float(b)
B100 = round(B * 100)
C = A * B100
ans = C // 100
print(ans)
| false
| 0
|
[
"-from math import floor",
"-from decimal import Decimal",
"-",
"-a, b = input().split()",
"-a = int(a)",
"-b = Decimal(b)",
"-print((floor(a * b)))",
"+a, b = input().split(\" \")",
"+A, B = int(a), float(b)",
"+B100 = round(B * 100)",
"+C = A * B100",
"+ans = C // 100",
"+print(ans)"
] | false
| 0.044224
| 0.043029
| 1.027767
|
[
"s063969051",
"s498029663"
] |
u607075479
|
p02573
|
python
|
s946542516
|
s663730951
| 453
| 404
| 137,768
| 132,700
|
Accepted
|
Accepted
| 10.82
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
#隣接リスト 1-index
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n+1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def main():
N, M = NMI()
F = {}
for _ in range(M):
a, b = NMI()
F[(a, b)] = 1
tree = make_adjlist_nond(N, list(F.keys()))
ans = 0
seen = [0] * (N + 1)
for start in range(1, N+1):
que = deque()
que.append(start)
seen[start] = 1
fri_cnt = 1
while que:
now = que.popleft()
for goto in tree[now]:
if seen[goto]:
continue
seen[goto] = 1
fri_cnt += 1
que.append(goto)
ans = max(fri_cnt, ans)
print(ans)
if __name__ == "__main__":
main()
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
#隣接リスト 1-index
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n+1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def main():
N, M = NMI()
F = [NLI() for _ in range(M)]
tree = make_adjlist_nond(N, F)
ans = 0
seen = [0] * (N + 1)
for start in range(1, N+1):
que = deque()
que.append(start)
seen[start] = 1
fri_cnt = 1
while que:
now = que.popleft()
for goto in tree[now]:
if seen[goto]:
continue
seen[goto] = 1
fri_cnt += 1
que.append(goto)
ans = max(fri_cnt, ans)
print(ans)
if __name__ == "__main__":
main()
| 56
| 53
| 1,161
| 1,102
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
# 隣接リスト 1-index
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def main():
N, M = NMI()
F = {}
for _ in range(M):
a, b = NMI()
F[(a, b)] = 1
tree = make_adjlist_nond(N, list(F.keys()))
ans = 0
seen = [0] * (N + 1)
for start in range(1, N + 1):
que = deque()
que.append(start)
seen[start] = 1
fri_cnt = 1
while que:
now = que.popleft()
for goto in tree[now]:
if seen[goto]:
continue
seen[goto] = 1
fri_cnt += 1
que.append(goto)
ans = max(fri_cnt, ans)
print(ans)
if __name__ == "__main__":
main()
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10**9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(eval(input()))
NMI = lambda: list(map(int, input().split()))
NLI = lambda: list(NMI())
SI = lambda: eval(input())
# 隣接リスト 1-index
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def main():
N, M = NMI()
F = [NLI() for _ in range(M)]
tree = make_adjlist_nond(N, F)
ans = 0
seen = [0] * (N + 1)
for start in range(1, N + 1):
que = deque()
que.append(start)
seen[start] = 1
fri_cnt = 1
while que:
now = que.popleft()
for goto in tree[now]:
if seen[goto]:
continue
seen[goto] = 1
fri_cnt += 1
que.append(goto)
ans = max(fri_cnt, ans)
print(ans)
if __name__ == "__main__":
main()
| false
| 5.357143
|
[
"- F = {}",
"- for _ in range(M):",
"- a, b = NMI()",
"- F[(a, b)] = 1",
"- tree = make_adjlist_nond(N, list(F.keys()))",
"+ F = [NLI() for _ in range(M)]",
"+ tree = make_adjlist_nond(N, F)"
] | false
| 0.10645
| 0.103657
| 1.026946
|
[
"s946542516",
"s663730951"
] |
u678167152
|
p03557
|
python
|
s052043023
|
s825601809
| 301
| 207
| 23,328
| 104,324
|
Accepted
|
Accepted
| 31.23
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
ans = 0
for b in B:
ans += bisect_left(A,b) * (N - bisect_right(C,b))
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
from bisect import *
ans = 0
for b in B:
a = bisect_left(A,b)
c = N-bisect_right(C,b)
ans += a*c
print(ans)
| 17
| 14
| 345
| 278
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
ans = 0
for b in B:
ans += bisect_left(A, b) * (N - bisect_right(C, b))
print(ans)
|
N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
from bisect import *
ans = 0
for b in B:
a = bisect_left(A, b)
c = N - bisect_right(C, b)
ans += a * c
print(ans)
| false
| 17.647059
|
[
"-from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort",
"+from bisect import *",
"- ans += bisect_left(A, b) * (N - bisect_right(C, b))",
"+ a = bisect_left(A, b)",
"+ c = N - bisect_right(C, b)",
"+ ans += a * c"
] | false
| 0.080236
| 0.045348
| 1.769328
|
[
"s052043023",
"s825601809"
] |
u263660661
|
p02773
|
python
|
s281098925
|
s540387963
| 816
| 691
| 46,348
| 35,220
|
Accepted
|
Accepted
| 15.32
|
n = int(eval(input()))
s = []
for i in range(n):
s.append(eval(input()))
d = {}
for word in s:
if word not in list(d.keys()):
d[word] = 1
else:
d[word] += 1
max_v = max(d.values())
d = sorted(list(d.items()), key=lambda x: x[0])
for k, v in d:
if v == max_v:
print(k)
|
n = int(eval(input()))
s = []
for i in range(n):
s.append(eval(input()))
dic = {}
for x in s:
if x in list(dic.keys()):
dic[x] += 1
else:
dic[x] = 1
max_v = max(dic.values())
a = []
for k, v in list(dic.items()):
if v == max_v:
a.append(k)
ans = sorted(a)
for a in ans:
print(a)
| 18
| 22
| 304
| 324
|
n = int(eval(input()))
s = []
for i in range(n):
s.append(eval(input()))
d = {}
for word in s:
if word not in list(d.keys()):
d[word] = 1
else:
d[word] += 1
max_v = max(d.values())
d = sorted(list(d.items()), key=lambda x: x[0])
for k, v in d:
if v == max_v:
print(k)
|
n = int(eval(input()))
s = []
for i in range(n):
s.append(eval(input()))
dic = {}
for x in s:
if x in list(dic.keys()):
dic[x] += 1
else:
dic[x] = 1
max_v = max(dic.values())
a = []
for k, v in list(dic.items()):
if v == max_v:
a.append(k)
ans = sorted(a)
for a in ans:
print(a)
| false
| 18.181818
|
[
"-d = {}",
"-for word in s:",
"- if word not in list(d.keys()):",
"- d[word] = 1",
"+dic = {}",
"+for x in s:",
"+ if x in list(dic.keys()):",
"+ dic[x] += 1",
"- d[word] += 1",
"-max_v = max(d.values())",
"-d = sorted(list(d.items()), key=lambda x: x[0])",
"-for k, v in d:",
"+ dic[x] = 1",
"+max_v = max(dic.values())",
"+a = []",
"+for k, v in list(dic.items()):",
"- print(k)",
"+ a.append(k)",
"+ans = sorted(a)",
"+for a in ans:",
"+ print(a)"
] | false
| 0.044692
| 0.102323
| 0.436779
|
[
"s281098925",
"s540387963"
] |
u077291787
|
p03354
|
python
|
s166264147
|
s398334772
| 480
| 388
| 25,184
| 35,324
|
Accepted
|
Accepted
| 19.17
|
# ABC097D - Equals (ARC097D)
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, N): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(N + 1)]
self.rank = [0] * (N + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x, y): # check two vertices are in the same group
return self.find(x) == self.find(y)
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# check i and Pi are connected components or not
N, M = tuple(map(int, input().split()))
P = tuple(map(int, input().split()))
E = tuple(tuple(map(int, input().split())) for _ in range(M))
U = UnionFind(N) # construct a Union-Find tree (1-idx)
for v, u in E: # connected components are in the same group
U.unite(v, u)
ans = sum(U.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main()
|
# ABC097D - Equals (ARC097D)
class UnionFind: # O(α(N))
def __init__(self, N): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(N + 1)]
self.rank = [0] * (N + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x, y): # check two vertices are in the same group
return self.find(x) == self.find(y)
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# check i and Pi are connected components or not
N, M, *A = list(map(int, open(0).read().split()))
P, E = A[:N], A[N:]
U = UnionFind(N) # construct a Union-Find tree (1-idx)
for v, u in zip(*[iter(E)] * 2): # connected components are in the same group
U.unite(v, u)
ans = sum(U.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main()
| 46
| 41
| 1,472
| 1,377
|
# ABC097D - Equals (ARC097D)
import sys
input = sys.stdin.readline
class UnionFind:
def __init__(self, N): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(N + 1)]
self.rank = [0] * (N + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x, y): # check two vertices are in the same group
return self.find(x) == self.find(y)
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# check i and Pi are connected components or not
N, M = tuple(map(int, input().split()))
P = tuple(map(int, input().split()))
E = tuple(tuple(map(int, input().split())) for _ in range(M))
U = UnionFind(N) # construct a Union-Find tree (1-idx)
for v, u in E: # connected components are in the same group
U.unite(v, u)
ans = sum(U.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main()
|
# ABC097D - Equals (ARC097D)
class UnionFind: # O(α(N))
def __init__(self, N): # construct a Union-Find tree (1-idx)
self.parent = [i for i in range(N + 1)]
self.rank = [0] * (N + 1)
def find(self, x): # find the group (root) of a vertex
if self.parent[x] == x:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x, y): # check two vertices are in the same group
return self.find(x) == self.find(y)
def unite(self, x, y): # unite two groups
x, y = self.find(x), self.find(y)
if x == y: # the same group
return
# unite a small one to a bigger one to balance trees
if self.rank[x] < self.rank[y]:
self.parent[x] = y
else:
self.parent[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def main():
# check i and Pi are connected components or not
N, M, *A = list(map(int, open(0).read().split()))
P, E = A[:N], A[N:]
U = UnionFind(N) # construct a Union-Find tree (1-idx)
for v, u in zip(*[iter(E)] * 2): # connected components are in the same group
U.unite(v, u)
ans = sum(U.is_same(i, p) for i, p in enumerate(P, 1))
print(ans)
if __name__ == "__main__":
main()
| false
| 10.869565
|
[
"-import sys",
"-",
"-input = sys.stdin.readline",
"-",
"-",
"-class UnionFind:",
"+class UnionFind: # O(α(N))",
"- N, M = tuple(map(int, input().split()))",
"- P = tuple(map(int, input().split()))",
"- E = tuple(tuple(map(int, input().split())) for _ in range(M))",
"+ N, M, *A = list(map(int, open(0).read().split()))",
"+ P, E = A[:N], A[N:]",
"- for v, u in E: # connected components are in the same group",
"+ for v, u in zip(*[iter(E)] * 2): # connected components are in the same group"
] | false
| 0.037626
| 0.038673
| 0.972926
|
[
"s166264147",
"s398334772"
] |
u077898957
|
p03378
|
python
|
s949557277
|
s698342466
| 20
| 18
| 3,060
| 2,940
|
Accepted
|
Accepted
| 10
|
n,m,x = list(map(int,input().split()))
a = list(map(int,input().split()))
c = 0
d = 0
for i in range(x):
if i in a:
c += 1
for i in range(x+1,n+1):
if i in a:
d += 1
print((min(c,d)))
|
n,m,x=list(map(int,input().split()))
A=list(map(int,input().split()))
left=0
right=0
for a in A:
if a<x:
left+=1
else:
right+=1
print((min(left,right)))
| 11
| 10
| 210
| 178
|
n, m, x = list(map(int, input().split()))
a = list(map(int, input().split()))
c = 0
d = 0
for i in range(x):
if i in a:
c += 1
for i in range(x + 1, n + 1):
if i in a:
d += 1
print((min(c, d)))
|
n, m, x = list(map(int, input().split()))
A = list(map(int, input().split()))
left = 0
right = 0
for a in A:
if a < x:
left += 1
else:
right += 1
print((min(left, right)))
| false
| 9.090909
|
[
"-a = list(map(int, input().split()))",
"-c = 0",
"-d = 0",
"-for i in range(x):",
"- if i in a:",
"- c += 1",
"-for i in range(x + 1, n + 1):",
"- if i in a:",
"- d += 1",
"-print((min(c, d)))",
"+A = list(map(int, input().split()))",
"+left = 0",
"+right = 0",
"+for a in A:",
"+ if a < x:",
"+ left += 1",
"+ else:",
"+ right += 1",
"+print((min(left, right)))"
] | false
| 0.038588
| 0.041839
| 0.922288
|
[
"s949557277",
"s698342466"
] |
u111365362
|
p02954
|
python
|
s398050780
|
s833076307
| 888
| 121
| 11,000
| 14,400
|
Accepted
|
Accepted
| 86.37
|
s = eval(input())
n = len(s)
up = []
down = []
parity = 0
for i in range(1,n):
if s[i] != s[i-1]:
if parity == 0:
down.append(i)
else:
up.append(i)
parity = 1 - parity
ans = [0 for i in range(n)]
#print(up,down)
for i in range(n):
if s[i] == 'R':
diff = down[0] - i
if diff % 2 == 1:
ans[down[0]-1] += 1
else:
ans[down[0]] += 1
else:
diff = i - down[0]
if diff % 2 == 1:
ans[down[0]-1] += 1
else:
ans[down[0]] += 1
if up != []:
if i+1 == up[0]:
del down[0]
del up[0]
ANS = list(map(str,ans))
print((' '.join(ANS)))
|
s = eval(input())
n = len(s)
up = []
down = []
for i in range(1,n):
if s[i] != s[i-1]:
if s[i] == 'L':
down.append(i)
else:
up.append(i)
ans = [0 for _ in range(n)]
try:
top = up[0]
except:
top = 2 * n
bottom = down[0]
count = 0
for i in range(n):
diff = i - bottom
if diff % 2 == 0:
ans[bottom] += 1
else:
ans[bottom-1] += 1
#print(ans)
if i+1 == top:
count += 1
try:
top = up[count]
except:
pass
bottom = down[count]
print((' '.join(map(str,ans))))
| 33
| 32
| 634
| 545
|
s = eval(input())
n = len(s)
up = []
down = []
parity = 0
for i in range(1, n):
if s[i] != s[i - 1]:
if parity == 0:
down.append(i)
else:
up.append(i)
parity = 1 - parity
ans = [0 for i in range(n)]
# print(up,down)
for i in range(n):
if s[i] == "R":
diff = down[0] - i
if diff % 2 == 1:
ans[down[0] - 1] += 1
else:
ans[down[0]] += 1
else:
diff = i - down[0]
if diff % 2 == 1:
ans[down[0] - 1] += 1
else:
ans[down[0]] += 1
if up != []:
if i + 1 == up[0]:
del down[0]
del up[0]
ANS = list(map(str, ans))
print((" ".join(ANS)))
|
s = eval(input())
n = len(s)
up = []
down = []
for i in range(1, n):
if s[i] != s[i - 1]:
if s[i] == "L":
down.append(i)
else:
up.append(i)
ans = [0 for _ in range(n)]
try:
top = up[0]
except:
top = 2 * n
bottom = down[0]
count = 0
for i in range(n):
diff = i - bottom
if diff % 2 == 0:
ans[bottom] += 1
else:
ans[bottom - 1] += 1
# print(ans)
if i + 1 == top:
count += 1
try:
top = up[count]
except:
pass
bottom = down[count]
print((" ".join(map(str, ans))))
| false
| 3.030303
|
[
"-parity = 0",
"- if parity == 0:",
"+ if s[i] == \"L\":",
"- parity = 1 - parity",
"-ans = [0 for i in range(n)]",
"-# print(up,down)",
"+ans = [0 for _ in range(n)]",
"+try:",
"+ top = up[0]",
"+except:",
"+ top = 2 * n",
"+bottom = down[0]",
"+count = 0",
"- if s[i] == \"R\":",
"- diff = down[0] - i",
"- if diff % 2 == 1:",
"- ans[down[0] - 1] += 1",
"- else:",
"- ans[down[0]] += 1",
"+ diff = i - bottom",
"+ if diff % 2 == 0:",
"+ ans[bottom] += 1",
"- diff = i - down[0]",
"- if diff % 2 == 1:",
"- ans[down[0] - 1] += 1",
"- else:",
"- ans[down[0]] += 1",
"- if up != []:",
"- if i + 1 == up[0]:",
"- del down[0]",
"- del up[0]",
"-ANS = list(map(str, ans))",
"-print((\" \".join(ANS)))",
"+ ans[bottom - 1] += 1",
"+ # print(ans)",
"+ if i + 1 == top:",
"+ count += 1",
"+ try:",
"+ top = up[count]",
"+ except:",
"+ pass",
"+ bottom = down[count]",
"+print((\" \".join(map(str, ans))))"
] | false
| 0.046535
| 0.045248
| 1.028443
|
[
"s398050780",
"s833076307"
] |
u863442865
|
p02972
|
python
|
s257025571
|
s913713533
| 423
| 316
| 14,436
| 65,656
|
Accepted
|
Accepted
| 25.3
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
res = []
#dp[i]:i番目の箱に入ってるかどうか
dp = [0]*n
#iの倍数の箱を調べる
for i in range(n, 0, -1):
#調べる箱列挙
t = 0
for j in range(i, n+1, i):
t += dp[j-1]
if t%2 != a[i-1]:
res.append(i)
dp[i-1] = 1
if not 1 in a:
print((0))
else:
if len(res)>0:
print((len(res)))
print((*res))
else:
print((-1))
if __name__ == '__main__':
main()
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
#from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
#from itertools import product
from bisect import bisect_left,bisect_right
import heapq
from math import floor, ceil
#from operator import itemgetter
#inf = 10**17
#mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
res = []
#dp[i]:i番目の箱に入ってるかどうか
dp = [0]*n
#iの倍数の箱を調べる
for i in range(n, 0, -1):
#調べる箱列挙
t = 0
for j in range(i, n+1, i):
t += dp[j-1]
if t%2 != a[i-1]:
res.append(i)
dp[i-1] = 1
if not 1 in a:
print((0))
else:
print((len(res)))
print((*res))
if __name__ == '__main__':
main()
| 43
| 40
| 1,027
| 957
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
# from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
# from itertools import product
from bisect import bisect_left, bisect_right
import heapq
from math import floor, ceil
# from operator import itemgetter
# inf = 10**17
# mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
res = []
# dp[i]:i番目の箱に入ってるかどうか
dp = [0] * n
# iの倍数の箱を調べる
for i in range(n, 0, -1):
# 調べる箱列挙
t = 0
for j in range(i, n + 1, i):
t += dp[j - 1]
if t % 2 != a[i - 1]:
res.append(i)
dp[i - 1] = 1
if not 1 in a:
print((0))
else:
if len(res) > 0:
print((len(res)))
print((*res))
else:
print((-1))
if __name__ == "__main__":
main()
|
def main():
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
from collections import Counter, deque
# from collections import defaultdict
from itertools import combinations, permutations, accumulate, groupby
# from itertools import product
from bisect import bisect_left, bisect_right
import heapq
from math import floor, ceil
# from operator import itemgetter
# inf = 10**17
# mod = 10**9 + 7
n = int(eval(input()))
a = list(map(int, input().split()))
res = []
# dp[i]:i番目の箱に入ってるかどうか
dp = [0] * n
# iの倍数の箱を調べる
for i in range(n, 0, -1):
# 調べる箱列挙
t = 0
for j in range(i, n + 1, i):
t += dp[j - 1]
if t % 2 != a[i - 1]:
res.append(i)
dp[i - 1] = 1
if not 1 in a:
print((0))
else:
print((len(res)))
print((*res))
if __name__ == "__main__":
main()
| false
| 6.976744
|
[
"- if len(res) > 0:",
"- print((len(res)))",
"- print((*res))",
"- else:",
"- print((-1))",
"+ print((len(res)))",
"+ print((*res))"
] | false
| 0.032924
| 0.034577
| 0.952206
|
[
"s257025571",
"s913713533"
] |
u119148115
|
p02571
|
python
|
s174421383
|
s177790722
| 126
| 62
| 64,828
| 65,288
|
Accepted
|
Accepted
| 50.79
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def MI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s-t+1):
count = 0
for j in range(t):
if T[j] != S[i+j]:
count += 1
ans = min(ans,count)
print(ans)
|
import sys
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s-t+1):
count = 0
for j in range(t):
if T[j] != S[i+j]:
count += 1
ans = min(ans,count)
print(ans)
| 26
| 18
| 707
| 293
|
import sys
sys.setrecursionlimit(10**7)
def I():
return int(sys.stdin.readline().rstrip())
def MI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
def LI2():
return list(map(int, sys.stdin.readline().rstrip())) # 空白なし
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split()) # 空白あり
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s - t + 1):
count = 0
for j in range(t):
if T[j] != S[i + j]:
count += 1
ans = min(ans, count)
print(ans)
|
import sys
def LS2():
return list(sys.stdin.readline().rstrip()) # 空白なし
S = LS2()
T = LS2()
s = len(S)
t = len(T)
ans = 10**5
for i in range(s - t + 1):
count = 0
for j in range(t):
if T[j] != S[i + j]:
count += 1
ans = min(ans, count)
print(ans)
| false
| 30.769231
|
[
"-",
"-sys.setrecursionlimit(10**7)",
"-",
"-",
"-def I():",
"- return int(sys.stdin.readline().rstrip())",
"-",
"-",
"-def MI():",
"- return list(map(int, sys.stdin.readline().rstrip().split()))",
"-",
"-",
"-def LI():",
"- return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり",
"-",
"-",
"-def LI2():",
"- return list(map(int, sys.stdin.readline().rstrip())) # 空白なし",
"-",
"-",
"-def S():",
"- return sys.stdin.readline().rstrip()",
"-",
"-",
"-def LS():",
"- return list(sys.stdin.readline().rstrip().split()) # 空白あり"
] | false
| 0.035916
| 0.03736
| 0.96137
|
[
"s174421383",
"s177790722"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.