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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u505420467 | p03061 | python | s545503877 | s183604231 | 379 | 232 | 85,228 | 16,120 | Accepted | Accepted | 38.79 | from operator import itemgetter
from functools import reduce
import fractions as f
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
rev_a = list(reversed(a))
ans = 0
accumulation_gcd = [0] * n
rev_accumulation_gcd = [0] * n
accumulation_gcd[0] = a[0]
rev_accumulation_gcd[0] = rev_a[0]
for i in range(1, n):
accumulation_gcd[i] = f.gcd(a[i], accumulation_gcd[i-1])
rev_accumulation_gcd[i] = f.gcd(rev_a[i], rev_accumulation_gcd[i-1])
rev_accumulation_gcd.reverse()
for i in range(n):
if i == 0:
ans = max(ans, rev_accumulation_gcd[1])
elif i == (n - 1):
ans = max(ans, accumulation_gcd[n-2])
else:
ans = max(ans, f.gcd(accumulation_gcd[i-1], rev_accumulation_gcd[i+1]))
print(ans)
| import fractions
n = int(eval(input()))
a = list(map(int, input().split()))
gcd_from_left = [a[0]]
gcd_from_right = [a[-1]]
for i in range(1, n):
gcd_from_left.append(fractions.gcd(gcd_from_left[i - 1], a[i]))
gcd_from_right.append(fractions.gcd(gcd_from_right[i - 1], a[n - 1 - i]))
gcd_from_right.reverse()
ans = 0
for i in range(n):
if i == 0:
ans = max(ans, gcd_from_right[1])
elif i == n - 1:
ans = max(ans, gcd_from_left[n - 2])
else:
ans = max(ans, fractions.gcd(gcd_from_left[i - 1], gcd_from_right[i + 1]))
print(ans)
| 31 | 22 | 803 | 590 | from operator import itemgetter
from functools import reduce
import fractions as f
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int, input().split()))
rev_a = list(reversed(a))
ans = 0
accumulation_gcd = [0] * n
rev_accumulation_gcd = [0] * n
accumulation_gcd[0] = a[0]
rev_accumulation_gcd[0] = rev_a[0]
for i in range(1, n):
accumulation_gcd[i] = f.gcd(a[i], accumulation_gcd[i - 1])
rev_accumulation_gcd[i] = f.gcd(rev_a[i], rev_accumulation_gcd[i - 1])
rev_accumulation_gcd.reverse()
for i in range(n):
if i == 0:
ans = max(ans, rev_accumulation_gcd[1])
elif i == (n - 1):
ans = max(ans, accumulation_gcd[n - 2])
else:
ans = max(ans, f.gcd(accumulation_gcd[i - 1], rev_accumulation_gcd[i + 1]))
print(ans)
| import fractions
n = int(eval(input()))
a = list(map(int, input().split()))
gcd_from_left = [a[0]]
gcd_from_right = [a[-1]]
for i in range(1, n):
gcd_from_left.append(fractions.gcd(gcd_from_left[i - 1], a[i]))
gcd_from_right.append(fractions.gcd(gcd_from_right[i - 1], a[n - 1 - i]))
gcd_from_right.reverse()
ans = 0
for i in range(n):
if i == 0:
ans = max(ans, gcd_from_right[1])
elif i == n - 1:
ans = max(ans, gcd_from_left[n - 2])
else:
ans = max(ans, fractions.gcd(gcd_from_left[i - 1], gcd_from_right[i + 1]))
print(ans)
| false | 29.032258 | [
"-from operator import itemgetter",
"-from functools import reduce",
"-import fractions as f",
"-import sys",
"+import fractions",
"-input = sys.stdin.readline",
"-rev_a = list(reversed(a))",
"+gcd_from_left = [a[0]]",
"+gcd_from_right = [a[-1]]",
"+for i in range(1, n):",
"+ gcd_from_left.append(fractions.gcd(gcd_from_left[i - 1], a[i]))",
"+ gcd_from_right.append(fractions.gcd(gcd_from_right[i - 1], a[n - 1 - i]))",
"+gcd_from_right.reverse()",
"-accumulation_gcd = [0] * n",
"-rev_accumulation_gcd = [0] * n",
"-accumulation_gcd[0] = a[0]",
"-rev_accumulation_gcd[0] = rev_a[0]",
"-for i in range(1, n):",
"- accumulation_gcd[i] = f.gcd(a[i], accumulation_gcd[i - 1])",
"- rev_accumulation_gcd[i] = f.gcd(rev_a[i], rev_accumulation_gcd[i - 1])",
"-rev_accumulation_gcd.reverse()",
"- ans = max(ans, rev_accumulation_gcd[1])",
"- elif i == (n - 1):",
"- ans = max(ans, accumulation_gcd[n - 2])",
"+ ans = max(ans, gcd_from_right[1])",
"+ elif i == n - 1:",
"+ ans = max(ans, gcd_from_left[n - 2])",
"- ans = max(ans, f.gcd(accumulation_gcd[i - 1], rev_accumulation_gcd[i + 1]))",
"+ ans = max(ans, fractions.gcd(gcd_from_left[i - 1], gcd_from_right[i + 1]))"
]
| false | 0.044381 | 0.044568 | 0.995799 | [
"s545503877",
"s183604231"
]
|
u525065967 | p02642 | python | s587898839 | s164794170 | 523 | 471 | 32,304 | 32,248 | Accepted | Accepted | 9.94 | n = int(eval(input()))
A = [*list(map(int, input().split()))]
mx = max(A)
c = [0]*(1000000+1)
for a in A:
for i in range(a, mx+1, a): c[i] += 1
ans = 0
for a in A:
if c[a] == 1: ans += 1
print(ans)
| n = int(eval(input()))
A = [*list(map(int, input().split()))]
mx = max(A)
c = [0]*(mx+1)
for a in A:
for i in range(a, mx+1, a): c[i] += 1
ans = 0
for a in A:
if c[a] == 1: ans += 1
print(ans)
| 10 | 10 | 203 | 198 | n = int(eval(input()))
A = [*list(map(int, input().split()))]
mx = max(A)
c = [0] * (1000000 + 1)
for a in A:
for i in range(a, mx + 1, a):
c[i] += 1
ans = 0
for a in A:
if c[a] == 1:
ans += 1
print(ans)
| n = int(eval(input()))
A = [*list(map(int, input().split()))]
mx = max(A)
c = [0] * (mx + 1)
for a in A:
for i in range(a, mx + 1, a):
c[i] += 1
ans = 0
for a in A:
if c[a] == 1:
ans += 1
print(ans)
| false | 0 | [
"-c = [0] * (1000000 + 1)",
"+c = [0] * (mx + 1)"
]
| false | 0.061697 | 0.073524 | 0.839139 | [
"s587898839",
"s164794170"
]
|
u788703383 | p02971 | python | s947376009 | s159569554 | 315 | 266 | 25,156 | 25,036 | Accepted | Accepted | 15.56 | n,*a = list(map(int,open(0).read().split()))
b = sorted(a)
max = b[-1]
maxs= b[-2]
for i in range(n):
if a[i] == max:
print(maxs)
else:
print(max)
| def main():
n,*a = list(map(int,open(0).read().split()))
b = sorted(a)
max = b[-1]
maxs= b[-2]
for i in range(n):
if a[i] == max:
print(maxs)
else:
print(max)
return()
if __name__=='__main__':
main() | 10 | 16 | 175 | 279 | n, *a = list(map(int, open(0).read().split()))
b = sorted(a)
max = b[-1]
maxs = b[-2]
for i in range(n):
if a[i] == max:
print(maxs)
else:
print(max)
| def main():
n, *a = list(map(int, open(0).read().split()))
b = sorted(a)
max = b[-1]
maxs = b[-2]
for i in range(n):
if a[i] == max:
print(maxs)
else:
print(max)
return ()
if __name__ == "__main__":
main()
| false | 37.5 | [
"-n, *a = list(map(int, open(0).read().split()))",
"-b = sorted(a)",
"-max = b[-1]",
"-maxs = b[-2]",
"-for i in range(n):",
"- if a[i] == max:",
"- print(maxs)",
"- else:",
"- print(max)",
"+def main():",
"+ n, *a = list(map(int, open(0).read().split()))",
"+ b = sorted(a)",
"+ max = b[-1]",
"+ maxs = b[-2]",
"+ for i in range(n):",
"+ if a[i] == max:",
"+ print(maxs)",
"+ else:",
"+ print(max)",
"+ return ()",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.036426 | 0.036366 | 1.001665 | [
"s947376009",
"s159569554"
]
|
u392319141 | p02744 | python | s592039576 | s694317959 | 1,060 | 113 | 66,476 | 5,232 | Accepted | Accepted | 89.34 | from collections import defaultdict
import string
import sys
sys.setrecursionlimit(10 ** 7)
from functools import lru_cache
N = int(input())
alph = string.ascii_lowercase
ans = defaultdict(int)
@lru_cache(maxsize=None)
def search(S, nums):
if nums in ans:
return
if len(nums) == N:
ans[nums] = S
return
for i in range(len(nums)):
for s, n in zip(S, nums):
if n == i:
search(S + s, nums + (n, ))
break
C = set(list(S))
for s in alph:
if not s in C:
search(S + s, nums + (len(nums), ))
break
search('a', (0, ))
ans = list(ans.values())
ans.sort()
print(*ans, sep='\n')
| from collections import defaultdict
import string
import sys
sys.setrecursionlimit(10 ** 7)
from functools import lru_cache
N = int(eval(input()))
alph = string.ascii_lowercase
def search(S, mx):
if len(S) == N:
print(S)
else:
for s in alph[: mx + 1]:
search(S + s, mx)
search(S + alph[mx + 1], mx + 1)
search('a', 0)
| 34 | 18 | 733 | 376 | from collections import defaultdict
import string
import sys
sys.setrecursionlimit(10**7)
from functools import lru_cache
N = int(input())
alph = string.ascii_lowercase
ans = defaultdict(int)
@lru_cache(maxsize=None)
def search(S, nums):
if nums in ans:
return
if len(nums) == N:
ans[nums] = S
return
for i in range(len(nums)):
for s, n in zip(S, nums):
if n == i:
search(S + s, nums + (n,))
break
C = set(list(S))
for s in alph:
if not s in C:
search(S + s, nums + (len(nums),))
break
search("a", (0,))
ans = list(ans.values())
ans.sort()
print(*ans, sep="\n")
| from collections import defaultdict
import string
import sys
sys.setrecursionlimit(10**7)
from functools import lru_cache
N = int(eval(input()))
alph = string.ascii_lowercase
def search(S, mx):
if len(S) == N:
print(S)
else:
for s in alph[: mx + 1]:
search(S + s, mx)
search(S + alph[mx + 1], mx + 1)
search("a", 0)
| false | 47.058824 | [
"-N = int(input())",
"+N = int(eval(input()))",
"-ans = defaultdict(int)",
"-@lru_cache(maxsize=None)",
"-def search(S, nums):",
"- if nums in ans:",
"- return",
"- if len(nums) == N:",
"- ans[nums] = S",
"- return",
"- for i in range(len(nums)):",
"- for s, n in zip(S, nums):",
"- if n == i:",
"- search(S + s, nums + (n,))",
"- break",
"- C = set(list(S))",
"- for s in alph:",
"- if not s in C:",
"- search(S + s, nums + (len(nums),))",
"- break",
"+def search(S, mx):",
"+ if len(S) == N:",
"+ print(S)",
"+ else:",
"+ for s in alph[: mx + 1]:",
"+ search(S + s, mx)",
"+ search(S + alph[mx + 1], mx + 1)",
"-search(\"a\", (0,))",
"-ans = list(ans.values())",
"-ans.sort()",
"-print(*ans, sep=\"\\n\")",
"+search(\"a\", 0)"
]
| false | 0.057135 | 0.053973 | 1.058583 | [
"s592039576",
"s694317959"
]
|
u724687935 | p03003 | python | s569964011 | s071590838 | 413 | 330 | 104,540 | 72,668 | Accepted | Accepted | 20.1 | MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
S = list(map(int, input().split()))
T = list(map(int, input().split()))
dp = [[0] * (M + 1) for _ in range(N + 1)]
dp[0][0] = 1
sm = [[0] * (M + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, M + 1):
if S[i - 1] == T[j - 1]:
dp[i][j] = (sm[i - 1][j - 1] + 1) % MOD
else:
dp[i][j] = 0
sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + dp[i][j]) % MOD
print((sm[N][M] + 1))
| MOD = 10 ** 9 + 7
N, M = list(map(int, input().split()))
S = list(map(int, input().split()))
T = list(map(int, input().split()))
sm = [[0] * (M + 1) for _ in range(N + 1)]
for i in range(N + 1):
sm[i][0] = 1
for j in range(M + 1):
sm[0][j] = 1
for i in range(1, N + 1):
for j in range(1, M + 1):
tmp = sm[i - 1][j - 1] if S[i - 1] == T[j - 1] else 0
sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + tmp) % MOD
print((sm[N][M]))
| 19 | 17 | 529 | 479 | MOD = 10**9 + 7
N, M = list(map(int, input().split()))
S = list(map(int, input().split()))
T = list(map(int, input().split()))
dp = [[0] * (M + 1) for _ in range(N + 1)]
dp[0][0] = 1
sm = [[0] * (M + 1) for _ in range(N + 1)]
for i in range(1, N + 1):
for j in range(1, M + 1):
if S[i - 1] == T[j - 1]:
dp[i][j] = (sm[i - 1][j - 1] + 1) % MOD
else:
dp[i][j] = 0
sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + dp[i][j]) % MOD
print((sm[N][M] + 1))
| MOD = 10**9 + 7
N, M = list(map(int, input().split()))
S = list(map(int, input().split()))
T = list(map(int, input().split()))
sm = [[0] * (M + 1) for _ in range(N + 1)]
for i in range(N + 1):
sm[i][0] = 1
for j in range(M + 1):
sm[0][j] = 1
for i in range(1, N + 1):
for j in range(1, M + 1):
tmp = sm[i - 1][j - 1] if S[i - 1] == T[j - 1] else 0
sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + tmp) % MOD
print((sm[N][M]))
| false | 10.526316 | [
"-dp = [[0] * (M + 1) for _ in range(N + 1)]",
"-dp[0][0] = 1",
"+for i in range(N + 1):",
"+ sm[i][0] = 1",
"+for j in range(M + 1):",
"+ sm[0][j] = 1",
"- if S[i - 1] == T[j - 1]:",
"- dp[i][j] = (sm[i - 1][j - 1] + 1) % MOD",
"- else:",
"- dp[i][j] = 0",
"- sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + dp[i][j]) % MOD",
"-print((sm[N][M] + 1))",
"+ tmp = sm[i - 1][j - 1] if S[i - 1] == T[j - 1] else 0",
"+ sm[i][j] = (sm[i - 1][j] + sm[i][j - 1] - sm[i - 1][j - 1] + tmp) % MOD",
"+print((sm[N][M]))"
]
| false | 0.03794 | 0.038 | 0.998428 | [
"s569964011",
"s071590838"
]
|
u992910889 | p03273 | python | s494213701 | s575123096 | 159 | 21 | 14,704 | 4,596 | Accepted | Accepted | 86.79 | import bisect
import copy
import fractions
import math
import numpy as np
from collections import Counter, deque
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product
def resolve():
h, w = map(int, input().split())
A = [[_ for _ in input()] for _ in range(h)]
B = [i for i in A if '#' in i]
C = zip(*[i for i in zip(*B) if '#' in i])
for i in C:
print(*i, sep='')
resolve()
| def resolve():
h, w = map(int, input().split())
A = [[_ for _ in input()] for _ in range(h)]
B = [i for i in A if '#' in i]
C = zip(*[i for i in zip(*B) if '#' in i])
for i in C:
print(*i, sep='')
# print(*C,sep='')
resolve()
| 20 | 12 | 476 | 275 | import bisect
import copy
import fractions
import math
import numpy as np
from collections import Counter, deque
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
)
def resolve():
h, w = map(int, input().split())
A = [[_ for _ in input()] for _ in range(h)]
B = [i for i in A if "#" in i]
C = zip(*[i for i in zip(*B) if "#" in i])
for i in C:
print(*i, sep="")
resolve()
| def resolve():
h, w = map(int, input().split())
A = [[_ for _ in input()] for _ in range(h)]
B = [i for i in A if "#" in i]
C = zip(*[i for i in zip(*B) if "#" in i])
for i in C:
print(*i, sep="")
# print(*C,sep='')
resolve()
| false | 40 | [
"-import bisect",
"-import copy",
"-import fractions",
"-import math",
"-import numpy as np",
"-from collections import Counter, deque",
"-from itertools import (",
"- accumulate,",
"- permutations,",
"- combinations,",
"- combinations_with_replacement,",
"- product,",
"-)",
"-",
"-",
"+ # print(*C,sep='')"
]
| false | 0.063559 | 0.065479 | 0.97067 | [
"s494213701",
"s575123096"
]
|
u459419927 | p03752 | python | s597953364 | s915792713 | 339 | 73 | 3,192 | 3,064 | Accepted | Accepted | 78.47 | N, K = list(map(int, input().split()))
height = list(map(int, input().split()))
ans = 10 ** 10
if N==K:
cost=0
for i in range(1,N):
if height[i-1]>=height[i]:
cost+=height[i-1]-height[i]+1
height[i]+=height[i-1]-height[i]+1
print(cost)
exit()
for i in range(2 ** N):
count=1
cost = 0
height2 = height.copy()
for j in range(N):
if i >> j & 1:
if j!=0:
tarou=max(height2[:j])
if height2[j]<=tarou:
cost+=tarou-height2[j]+1
height2[j]+=tarou-height2[j]+1
count+=1
else:count+=1
# zenkai=0
# for x in range(1,N):
# if height2[zenkai] < height2[x]:
# count += 1
# zenkai=x
if ans > cost and count >= K:
ans = cost
print(ans) | N, K = list(map(int, input().split()))
height = list(map(int, input().split()))
height2=height.copy()
ans = 10 ** 10
if N==K:
cost=0
for i in range(1,N):
tarou=max(height2[:i])
if tarou>=height2[i]:
cost+=tarou-height2[i]+1
height2[i]=tarou+1
print(cost)
exit()
for i in range(2 ** N):
cost = 0
height2 = height.copy()
if bin(i).count("1")==K:
for j in range(1,N):
if i >> j & 1:
if N==K:
if height2[j-1]>=height2[j]:
cost+=height2[j-1]-height2[j]+1
height2[j]+=height2[j-1]-height2[j]+1
else:
tarou=max(height2[:j])
if height2[j]<=tarou:
cost+=tarou-height2[j]+1
height2[j]=tarou+1
if ans > cost:
ans = cost
print(ans) | 33 | 33 | 896 | 957 | N, K = list(map(int, input().split()))
height = list(map(int, input().split()))
ans = 10**10
if N == K:
cost = 0
for i in range(1, N):
if height[i - 1] >= height[i]:
cost += height[i - 1] - height[i] + 1
height[i] += height[i - 1] - height[i] + 1
print(cost)
exit()
for i in range(2**N):
count = 1
cost = 0
height2 = height.copy()
for j in range(N):
if i >> j & 1:
if j != 0:
tarou = max(height2[:j])
if height2[j] <= tarou:
cost += tarou - height2[j] + 1
height2[j] += tarou - height2[j] + 1
count += 1
else:
count += 1
# zenkai=0
# for x in range(1,N):
# if height2[zenkai] < height2[x]:
# count += 1
# zenkai=x
if ans > cost and count >= K:
ans = cost
print(ans)
| N, K = list(map(int, input().split()))
height = list(map(int, input().split()))
height2 = height.copy()
ans = 10**10
if N == K:
cost = 0
for i in range(1, N):
tarou = max(height2[:i])
if tarou >= height2[i]:
cost += tarou - height2[i] + 1
height2[i] = tarou + 1
print(cost)
exit()
for i in range(2**N):
cost = 0
height2 = height.copy()
if bin(i).count("1") == K:
for j in range(1, N):
if i >> j & 1:
if N == K:
if height2[j - 1] >= height2[j]:
cost += height2[j - 1] - height2[j] + 1
height2[j] += height2[j - 1] - height2[j] + 1
else:
tarou = max(height2[:j])
if height2[j] <= tarou:
cost += tarou - height2[j] + 1
height2[j] = tarou + 1
if ans > cost:
ans = cost
print(ans)
| false | 0 | [
"+height2 = height.copy()",
"- if height[i - 1] >= height[i]:",
"- cost += height[i - 1] - height[i] + 1",
"- height[i] += height[i - 1] - height[i] + 1",
"+ tarou = max(height2[:i])",
"+ if tarou >= height2[i]:",
"+ cost += tarou - height2[i] + 1",
"+ height2[i] = tarou + 1",
"- count = 1",
"- for j in range(N):",
"- if i >> j & 1:",
"- if j != 0:",
"- tarou = max(height2[:j])",
"- if height2[j] <= tarou:",
"- cost += tarou - height2[j] + 1",
"- height2[j] += tarou - height2[j] + 1",
"- count += 1",
"+ if bin(i).count(\"1\") == K:",
"+ for j in range(1, N):",
"+ if i >> j & 1:",
"+ if N == K:",
"+ if height2[j - 1] >= height2[j]:",
"+ cost += height2[j - 1] - height2[j] + 1",
"+ height2[j] += height2[j - 1] - height2[j] + 1",
"- count += 1",
"- # zenkai=0",
"- # for x in range(1,N):",
"- # if height2[zenkai] < height2[x]:",
"- # count += 1",
"- # zenkai=x",
"- if ans > cost and count >= K:",
"- ans = cost",
"+ tarou = max(height2[:j])",
"+ if height2[j] <= tarou:",
"+ cost += tarou - height2[j] + 1",
"+ height2[j] = tarou + 1",
"+ if ans > cost:",
"+ ans = cost"
]
| false | 0.043298 | 0.079022 | 0.547922 | [
"s597953364",
"s915792713"
]
|
u391731808 | p03026 | python | s835220927 | s456847317 | 350 | 71 | 53,208 | 7,800 | Accepted | Accepted | 79.71 | N = int(eval(input()))
AB = [list(map(int,input().split())) for _ in [0]*(N-1)]
*C, = list(map(int,input().split()))
connect = [[] for _ in [0]*N]
for a,b in AB:
connect[a-1].append(b-1)
connect[b-1].append(a-1)
d = [-1]*N
d[0] = 0
q = [0]
while q:
qq = []
for i in q:
for j in connect[i]:
if d[j] == -1:
d[j] = d[i]+1
qq.append(j)
q = qq
o = sorted(zip(d,list(range(N))),key =lambda x:-x[0])
C.sort()
ans = [0]*N
for j,tmp in enumerate(o):
d,i = tmp
ans[i] = C[j]
print((sum(C)-C[-1]))
print((*ans)) | N = int(eval(input()))
AB = [list(map(int,input().split())) for _ in [0]*(N-1)]
*C, = sorted(map(int,input().split()))
print((sum(C[:-1])))
E = [[] for _ in [0]*N]
d = [0]*N
for a,b in AB:
E[a-1].append(b-1)
E[b-1].append(a-1)
for i in range(N):
if len(E[i])>1:break
q = [i]
while q:
i = q.pop()
d[i] = C.pop()
for j in E[i]:
if d[j] != 0:continue
q.append(j)
print((*d)) | 28 | 20 | 587 | 421 | N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in [0] * (N - 1)]
(*C,) = list(map(int, input().split()))
connect = [[] for _ in [0] * N]
for a, b in AB:
connect[a - 1].append(b - 1)
connect[b - 1].append(a - 1)
d = [-1] * N
d[0] = 0
q = [0]
while q:
qq = []
for i in q:
for j in connect[i]:
if d[j] == -1:
d[j] = d[i] + 1
qq.append(j)
q = qq
o = sorted(zip(d, list(range(N))), key=lambda x: -x[0])
C.sort()
ans = [0] * N
for j, tmp in enumerate(o):
d, i = tmp
ans[i] = C[j]
print((sum(C) - C[-1]))
print((*ans))
| N = int(eval(input()))
AB = [list(map(int, input().split())) for _ in [0] * (N - 1)]
(*C,) = sorted(map(int, input().split()))
print((sum(C[:-1])))
E = [[] for _ in [0] * N]
d = [0] * N
for a, b in AB:
E[a - 1].append(b - 1)
E[b - 1].append(a - 1)
for i in range(N):
if len(E[i]) > 1:
break
q = [i]
while q:
i = q.pop()
d[i] = C.pop()
for j in E[i]:
if d[j] != 0:
continue
q.append(j)
print((*d))
| false | 28.571429 | [
"-(*C,) = list(map(int, input().split()))",
"-connect = [[] for _ in [0] * N]",
"+(*C,) = sorted(map(int, input().split()))",
"+print((sum(C[:-1])))",
"+E = [[] for _ in [0] * N]",
"+d = [0] * N",
"- connect[a - 1].append(b - 1)",
"- connect[b - 1].append(a - 1)",
"-d = [-1] * N",
"-d[0] = 0",
"-q = [0]",
"+ E[a - 1].append(b - 1)",
"+ E[b - 1].append(a - 1)",
"+for i in range(N):",
"+ if len(E[i]) > 1:",
"+ break",
"+q = [i]",
"- qq = []",
"- for i in q:",
"- for j in connect[i]:",
"- if d[j] == -1:",
"- d[j] = d[i] + 1",
"- qq.append(j)",
"- q = qq",
"-o = sorted(zip(d, list(range(N))), key=lambda x: -x[0])",
"-C.sort()",
"-ans = [0] * N",
"-for j, tmp in enumerate(o):",
"- d, i = tmp",
"- ans[i] = C[j]",
"-print((sum(C) - C[-1]))",
"-print((*ans))",
"+ i = q.pop()",
"+ d[i] = C.pop()",
"+ for j in E[i]:",
"+ if d[j] != 0:",
"+ continue",
"+ q.append(j)",
"+print((*d))"
]
| false | 0.038219 | 0.091189 | 0.419115 | [
"s835220927",
"s456847317"
]
|
u445624660 | p02928 | python | s407816129 | s592943800 | 810 | 539 | 3,188 | 9,272 | Accepted | Accepted | 33.46 | # つよいさんすう
# 最初のAを単独で考えたらいける 等差数列の和の公式はググった
# ex) k = 3, a = [1, 3, 2]
# 1 3 2 1 3 2 1 3 2
# 最初の1 3 2
# 3...[2,1,2,1,2]で5
# 2...[1.1]で2
# 二番目の1 3 2
# 3...[2,1,2]
# 2...[1]
# 三番目の1 3 2
# 3...[2]で1
# 3だけでみると初項1 末項5 公差2で n(2*a1 +(n-1)*2)/2 = 3*(2*1 + (3-1)*2)/2 = 3*6/2 = 9
# n*(a1+an)/2 = 3*(1+5)/2 = 9
# これを一般化すればいけそう
# ex) k = 3, a = [3, 5, 2, 4, 1]とすると
# 3 5 2 4 1 3 5 2 4 1 3 5 2 4 1
# 3の初項は2で公差2 -> 3*(2*2+(3-1)*2)/2 = 12 (6+4+2)
# 5の初項は3で公差4 -> 3*(2*3 + (3-1)*4)/2 = 21 (11+7+3)
# 2の初項は1で公差2 -> 3*(2*1 + (3-1)*2)/2 = 9
# 4の初項は1で公差2 -> 3*(2*1 + (3-1)*3)/2 = 12
# 1の初項は0で公差0 -> 3*(2*0 + (3-1)*0)/2 = 0
# ...みたいな感じ
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
MOD = 10**9 + 7
first_subarr = [0] * n
rest_arr = [0] * n
for i in range(n):
for j in range(i, n):
if a[i] > a[j]:
first_subarr[i] += 1
for i in range(n - 1, -1, -1):
for j in range(i, -1, -1):
if a[j] < a[i]:
rest_arr[i] += 1
diffs = [0] * n
for i in range(n):
diffs[i] = first_subarr[i] + rest_arr[i]
ans = 0
for i in range(n):
# print("{}について".format(a[i]))
# print("初項:{} 公差:{}なので".format(first_subarr[i], diffs[i]))
tmp = k * (2 * first_subarr[i] + (k - 1) * diffs[i]) // 2
# print("総和は{}".format(tmp))
ans += tmp
ans %= MOD
print(ans) | # A内で完結するものと、連結したときに変わるものがある
#
# 3 4 2 1 2 -> 3+3+1+0+0 = 7
# 3 4 2 1 2 | 3 4 2 1 2 -> (3*2)+(1*1+3*2)+(1*2)+0+(1*1) + 7 = 16 + 7
# 3 4 2 1 2 | 3 4 2 1 2 | 3 4 2 1 2 -> (3*3)+(2*1+3*3)+(1*3)+0+(2*1) + 16+7 = 25+16+7
# Aについて、i<jなるjでAi>Ajになるものがk個、Ai<Ajになるものがk-1個ある
# k=3で考えると
# 順方向: (m*3)+(m*3)+(m*1)+(0)+(0), m=1~3 = 7+14+21=42
# 逆方向：(0)+(m*1)+(0)+(0)+(m*1), m=1~2 = 2+4=6 （逆方向はk-1個）
# 合わせて48となりこれは上記で試してたのと等しい
# ということで、それぞれ等差数列の和が使えそう
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10**9 + 7
# 順方向
base = 0
for i in range(n):
for j in range(i, n):
if a[i] > a[j]:
base += 1
# 逆方向
additional = 0
for i in range(n):
for j in range(i):
if a[i] > a[j]:
additional += 1
ans = (k * (k + 1) // 2 % mod * base +
(k - 1) * k // 2 % mod * additional) % mod
print(ans)
| 54 | 31 | 1,359 | 874 | # つよいさんすう
# 最初のAを単独で考えたらいける 等差数列の和の公式はググった
# ex) k = 3, a = [1, 3, 2]
# 1 3 2 1 3 2 1 3 2
# 最初の1 3 2
# 3...[2,1,2,1,2]で5
# 2...[1.1]で2
# 二番目の1 3 2
# 3...[2,1,2]
# 2...[1]
# 三番目の1 3 2
# 3...[2]で1
# 3だけでみると初項1 末項5 公差2で n(2*a1 +(n-1)*2)/2 = 3*(2*1 + (3-1)*2)/2 = 3*6/2 = 9
# n*(a1+an)/2 = 3*(1+5)/2 = 9
# これを一般化すればいけそう
# ex) k = 3, a = [3, 5, 2, 4, 1]とすると
# 3 5 2 4 1 3 5 2 4 1 3 5 2 4 1
# 3の初項は2で公差2 -> 3*(2*2+(3-1)*2)/2 = 12 (6+4+2)
# 5の初項は3で公差4 -> 3*(2*3 + (3-1)*4)/2 = 21 (11+7+3)
# 2の初項は1で公差2 -> 3*(2*1 + (3-1)*2)/2 = 9
# 4の初項は1で公差2 -> 3*(2*1 + (3-1)*3)/2 = 12
# 1の初項は0で公差0 -> 3*(2*0 + (3-1)*0)/2 = 0
# ...みたいな感じ
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
MOD = 10**9 + 7
first_subarr = [0] * n
rest_arr = [0] * n
for i in range(n):
for j in range(i, n):
if a[i] > a[j]:
first_subarr[i] += 1
for i in range(n - 1, -1, -1):
for j in range(i, -1, -1):
if a[j] < a[i]:
rest_arr[i] += 1
diffs = [0] * n
for i in range(n):
diffs[i] = first_subarr[i] + rest_arr[i]
ans = 0
for i in range(n):
# print("{}について".format(a[i]))
# print("初項:{} 公差:{}なので".format(first_subarr[i], diffs[i]))
tmp = k * (2 * first_subarr[i] + (k - 1) * diffs[i]) // 2
# print("総和は{}".format(tmp))
ans += tmp
ans %= MOD
print(ans)
| # A内で完結するものと、連結したときに変わるものがある
#
# 3 4 2 1 2 -> 3+3+1+0+0 = 7
# 3 4 2 1 2 | 3 4 2 1 2 -> (3*2)+(1*1+3*2)+(1*2)+0+(1*1) + 7 = 16 + 7
# 3 4 2 1 2 | 3 4 2 1 2 | 3 4 2 1 2 -> (3*3)+(2*1+3*3)+(1*3)+0+(2*1) + 16+7 = 25+16+7
# Aについて、i<jなるjでAi>Ajになるものがk個、Ai<Ajになるものがk-1個ある
# k=3で考えると
# 順方向: (m*3)+(m*3)+(m*1)+(0)+(0), m=1~3 = 7+14+21=42
# 逆方向：(0)+(m*1)+(0)+(0)+(m*1), m=1~2 = 2+4=6 （逆方向はk-1個）
# 合わせて48となりこれは上記で試してたのと等しい
# ということで、それぞれ等差数列の和が使えそう
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
mod = 10**9 + 7
# 順方向
base = 0
for i in range(n):
for j in range(i, n):
if a[i] > a[j]:
base += 1
# 逆方向
additional = 0
for i in range(n):
for j in range(i):
if a[i] > a[j]:
additional += 1
ans = (k * (k + 1) // 2 % mod * base + (k - 1) * k // 2 % mod * additional) % mod
print(ans)
| false | 42.592593 | [
"-# つよいさんすう",
"-# 最初のAを単独で考えたらいける 等差数列の和の公式はググった",
"-# ex) k = 3, a = [1, 3, 2]",
"-# 1 3 2 1 3 2 1 3 2",
"-# 最初の1 3 2",
"-# 3...[2,1,2,1,2]で5",
"-# 2...[1.1]で2",
"-# 二番目の1 3 2",
"-# 3...[2,1,2]",
"-# 2...[1]",
"-# 三番目の1 3 2",
"-# 3...[2]で1",
"-# 3だけでみると初項1 末項5 公差2で n(2*a1 +(n-1)*2)/2 = 3*(2*1 + (3-1)*2)/2 = 3*6/2 = 9",
"-# n*(a1+an)/2 = 3*(1+5)/2 = 9",
"-# これを一般化すればいけそう",
"-# ex) k = 3, a = [3, 5, 2, 4, 1]とすると",
"-# 3 5 2 4 1 3 5 2 4 1 3 5 2 4 1",
"-# 3の初項は2で公差2 -> 3*(2*2+(3-1)*2)/2 = 12 (6+4+2)",
"-# 5の初項は3で公差4 -> 3*(2*3 + (3-1)*4)/2 = 21 (11+7+3)",
"-# 2の初項は1で公差2 -> 3*(2*1 + (3-1)*2)/2 = 9",
"-# 4の初項は1で公差2 -> 3*(2*1 + (3-1)*3)/2 = 12",
"-# 1の初項は0で公差0 -> 3*(2*0 + (3-1)*0)/2 = 0",
"-# ...みたいな感じ",
"+# A\b内で完結するものと、連結したときに変わるものがある",
"+#",
"+# 3 4 2 1 2 -> 3+3+1+0+0 = 7",
"+# 3 4 2 1 2 | 3 4 2 1 2 -> (3*2)+(1*1+3*2)+(1*2)+0+(1*1) + 7 = 16 + 7",
"+# 3 4 2 1 2 | 3 4 2 1 2 | 3 4 2 1 2 -> (3*3)+(2*1+3*3)+(1*3)+0+(2*1) + 16+7 = 25+16+7",
"+# Aについて、i<jなるjでAi>Ajになるものがk個、Ai<Ajになるものがk-1個ある",
"+# k=3で考えると",
"+# 順方向: (m*3)+(m*3)+(m*1)+(0)+(0), m=1~3 = 7+14+21=42",
"+# 逆方向：(0)+(m*1)+(0)+(0)+(m*1), m=1~2 = 2+4=6 （逆方向はk-1個）",
"+# 合わせて48となりこれは上記で試してたのと等しい",
"+# ということで、それぞれ等差数列の和が使えそう",
"-MOD = 10**9 + 7",
"-first_subarr = [0] * n",
"-rest_arr = [0] * n",
"+mod = 10**9 + 7",
"+# 順方向",
"+base = 0",
"- first_subarr[i] += 1",
"-for i in range(n - 1, -1, -1):",
"- for j in range(i, -1, -1):",
"- if a[j] < a[i]:",
"- rest_arr[i] += 1",
"-diffs = [0] * n",
"+ base += 1",
"+# 逆方向",
"+additional = 0",
"- diffs[i] = first_subarr[i] + rest_arr[i]",
"-ans = 0",
"-for i in range(n):",
"- # print(\"{}について\".format(a[i]))",
"- # print(\"初項:{} 公差:{}なので\".format(first_subarr[i], diffs[i]))",
"- tmp = k * (2 * first_subarr[i] + (k - 1) * diffs[i]) // 2",
"- # print(\"総和は{}\".format(tmp))",
"- ans += tmp",
"- ans %= MOD",
"+ for j in range(i):",
"+ if a[i] > a[j]:",
"+ additional += 1",
"+ans = (k * (k + 1) // 2 % mod * base + (k - 1) * k // 2 % mod * additional) % mod"
]
| false | 0.038858 | 0.06819 | 0.569845 | [
"s407816129",
"s592943800"
]
|
u525065967 | p02617 | python | s565680096 | s012172163 | 433 | 380 | 9,184 | 9,192 | Accepted | Accepted | 12.24 | n = int(eval(input()))
V = E = 0
for i in range(1, n+1): V += i * (n - i + 1)
for _ in range(n-1):
a, b = list(map(int, input().split()))
if a > b: a, b = b, a
E += a * (n - b + 1)
print((V - E))
| n = int(eval(input()))
V = n*(n+1)*(n+2)//6; E = 0
for _ in range(n-1):
a, b = list(map(int, input().split()))
if a > b: a, b = b, a
E += a * (n - b + 1)
print((V - E))
| 8 | 7 | 201 | 173 | n = int(eval(input()))
V = E = 0
for i in range(1, n + 1):
V += i * (n - i + 1)
for _ in range(n - 1):
a, b = list(map(int, input().split()))
if a > b:
a, b = b, a
E += a * (n - b + 1)
print((V - E))
| n = int(eval(input()))
V = n * (n + 1) * (n + 2) // 6
E = 0
for _ in range(n - 1):
a, b = list(map(int, input().split()))
if a > b:
a, b = b, a
E += a * (n - b + 1)
print((V - E))
| false | 12.5 | [
"-V = E = 0",
"-for i in range(1, n + 1):",
"- V += i * (n - i + 1)",
"+V = n * (n + 1) * (n + 2) // 6",
"+E = 0"
]
| false | 0.096727 | 0.05299 | 1.825385 | [
"s565680096",
"s012172163"
]
|
u995004106 | p02603 | python | s657326917 | s407434482 | 80 | 70 | 64,896 | 64,984 | Accepted | Accepted | 12.5 | import collections
N=int(eval(input()))
A=list(map(int,input().split()))
i=0
A.insert(0,float("inf"))
#print(A)
buy=[0]*N
sell=[0]*N
for i in range(N-1):
if (A[i]>=A[i+1])and(A[i+2]>=A[i+1]):
buy[i]=1
if (A[i]<=A[i+1])and(A[i+2]<=A[i+1]):
sell[i]=1
kabu=0
money=1000
#print(buy,sell)
#print(money,kabu)
A=A[1:]
#print(A)
for i in range(N):
if sell[i]==1:
money=money+kabu*A[i]
kabu=0
if buy[i]==1:
kabu=kabu+money//A[i]
money=money-(money//A[i])*A[i]
#print(money,kabu,A[i])
#input()
#print(money,kabu)
money=money+kabu*A[N-1]
print(money)
| import collections
N=int(eval(input()))
A=list(map(int,input().split()))
i=0
A.insert(0,float("inf"))
#print(A)
buy=[0]*N
sell=[0]*N
for i in range(N-1):
if (A[i]>=A[i+1])and(A[i+2]>=A[i+1]):
buy[i]=1
if (A[i]<=A[i+1])and(A[i+2]<=A[i+1]):
sell[i]=1
kabu=0
money=1000
#print(buy,sell)
#print(money,kabu)
A=A[1:]
#print(A)
for i in range(N):
if buy[i]==1:
kabu=kabu+money//A[i]
money=money-(money//A[i])*A[i]
if sell[i]==1:
money=money+kabu*A[i]
kabu=0
#print(money,kabu,A[i])
#input()
#print(money,kabu)
money=money+kabu*A[N-1]
print(money)
| 33 | 35 | 640 | 644 | import collections
N = int(eval(input()))
A = list(map(int, input().split()))
i = 0
A.insert(0, float("inf"))
# print(A)
buy = [0] * N
sell = [0] * N
for i in range(N - 1):
if (A[i] >= A[i + 1]) and (A[i + 2] >= A[i + 1]):
buy[i] = 1
if (A[i] <= A[i + 1]) and (A[i + 2] <= A[i + 1]):
sell[i] = 1
kabu = 0
money = 1000
# print(buy,sell)
# print(money,kabu)
A = A[1:]
# print(A)
for i in range(N):
if sell[i] == 1:
money = money + kabu * A[i]
kabu = 0
if buy[i] == 1:
kabu = kabu + money // A[i]
money = money - (money // A[i]) * A[i]
# print(money,kabu,A[i])
# input()
# print(money,kabu)
money = money + kabu * A[N - 1]
print(money)
| import collections
N = int(eval(input()))
A = list(map(int, input().split()))
i = 0
A.insert(0, float("inf"))
# print(A)
buy = [0] * N
sell = [0] * N
for i in range(N - 1):
if (A[i] >= A[i + 1]) and (A[i + 2] >= A[i + 1]):
buy[i] = 1
if (A[i] <= A[i + 1]) and (A[i + 2] <= A[i + 1]):
sell[i] = 1
kabu = 0
money = 1000
# print(buy,sell)
# print(money,kabu)
A = A[1:]
# print(A)
for i in range(N):
if buy[i] == 1:
kabu = kabu + money // A[i]
money = money - (money // A[i]) * A[i]
if sell[i] == 1:
money = money + kabu * A[i]
kabu = 0
# print(money,kabu,A[i])
# input()
# print(money,kabu)
money = money + kabu * A[N - 1]
print(money)
| false | 5.714286 | [
"+ if buy[i] == 1:",
"+ kabu = kabu + money // A[i]",
"+ money = money - (money // A[i]) * A[i]",
"- if buy[i] == 1:",
"- kabu = kabu + money // A[i]",
"- money = money - (money // A[i]) * A[i]"
]
| false | 0.04381 | 0.046653 | 0.939065 | [
"s657326917",
"s407434482"
]
|
u040298438 | p03943 | python | s455321840 | s317517929 | 31 | 24 | 9,120 | 9,052 | Accepted | Accepted | 22.58 | a = list(map(int, input().split()))
print(("Yes" if sum(a) == max(a) * 2 else "No"))
| a, b, c = sorted(map(int, input().split()))
print((("No", "Yes")[a + b == c])) | 2 | 2 | 84 | 77 | a = list(map(int, input().split()))
print(("Yes" if sum(a) == max(a) * 2 else "No"))
| a, b, c = sorted(map(int, input().split()))
print((("No", "Yes")[a + b == c]))
| false | 0 | [
"-a = list(map(int, input().split()))",
"-print((\"Yes\" if sum(a) == max(a) * 2 else \"No\"))",
"+a, b, c = sorted(map(int, input().split()))",
"+print(((\"No\", \"Yes\")[a + b == c]))"
]
| false | 0.04812 | 0.048484 | 0.992484 | [
"s455321840",
"s317517929"
]
|
u022407960 | p02378 | python | s071216115 | s077655269 | 70 | 50 | 8,428 | 9,260 | Accepted | Accepted | 28.57 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def generate_adj_table(_edges):
for edge in _edges:
vx, vy = list(map(int, edge))
init_adj_table[vx].append(vy)
return init_adj_table
def graph_dfs(current, matching, visited):
for adj in range(y_num):
if (not visited[adj]) and (adj in adj_table[current]):
visited[adj] = True
if matching[adj] == -1 or graph_dfs(matching[adj], matching, visited):
matching[adj] = current
return True
return False
def mbm():
matching = [-1] * y_num
res = 0
for v in range(x_num):
visited = [False] * y_num
if graph_dfs(v, matching, visited):
res += 1
# print(matching)
return res
if __name__ == '__main__':
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
init_adj_table = [[] for _ in range(x_num)]
adj_table = generate_adj_table(edges)
print((mbm())) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def generate_adj_table(_edges):
for edge in _edges:
vx, vy = list(map(int, edge))
init_adj_table[vx].add(vy)
return init_adj_table
def graph_dfs(current, matching, visited):
for adj in range(y_num):
if (not visited[adj]) and (adj in adj_table[current]):
visited[adj] = True
# matching[adj] = -1: target in y not assigned to any of x
# matching[adj] -> an assigned source in x
# graph_dfs(matching[adj], matching, visited) = True indicates that source has been
if matching[adj] == -1 or graph_dfs(matching[adj], matching, visited):
matching[adj] = current
return True
return False
def mbm():
matching = [-1] * y_num
res = 0
for v in range(x_num):
visited = [False] * y_num
if graph_dfs(v, matching, visited):
res += 1
# print(matching)
return res
if __name__ == '__main__':
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
init_adj_table = [set() for _ in range(x_num)]
adj_table = generate_adj_table(edges)
print((mbm())) | 57 | 60 | 1,153 | 1,378 | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def generate_adj_table(_edges):
for edge in _edges:
vx, vy = list(map(int, edge))
init_adj_table[vx].append(vy)
return init_adj_table
def graph_dfs(current, matching, visited):
for adj in range(y_num):
if (not visited[adj]) and (adj in adj_table[current]):
visited[adj] = True
if matching[adj] == -1 or graph_dfs(matching[adj], matching, visited):
matching[adj] = current
return True
return False
def mbm():
matching = [-1] * y_num
res = 0
for v in range(x_num):
visited = [False] * y_num
if graph_dfs(v, matching, visited):
res += 1
# print(matching)
return res
if __name__ == "__main__":
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
init_adj_table = [[] for _ in range(x_num)]
adj_table = generate_adj_table(edges)
print((mbm()))
| #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
3 4 6
0 0
0 2
0 3
1 1
2 1
2 3
output:
3
"""
import sys
def generate_adj_table(_edges):
for edge in _edges:
vx, vy = list(map(int, edge))
init_adj_table[vx].add(vy)
return init_adj_table
def graph_dfs(current, matching, visited):
for adj in range(y_num):
if (not visited[adj]) and (adj in adj_table[current]):
visited[adj] = True
# matching[adj] = -1: target in y not assigned to any of x
# matching[adj] -> an assigned source in x
# graph_dfs(matching[adj], matching, visited) = True indicates that source has been
if matching[adj] == -1 or graph_dfs(matching[adj], matching, visited):
matching[adj] = current
return True
return False
def mbm():
matching = [-1] * y_num
res = 0
for v in range(x_num):
visited = [False] * y_num
if graph_dfs(v, matching, visited):
res += 1
# print(matching)
return res
if __name__ == "__main__":
_input = sys.stdin.readlines()
x_num, y_num, e_num = list(map(int, _input[0].split()))
edges = [x.split() for x in _input[1:]]
init_adj_table = [set() for _ in range(x_num)]
adj_table = generate_adj_table(edges)
print((mbm()))
| false | 5 | [
"- init_adj_table[vx].append(vy)",
"+ init_adj_table[vx].add(vy)",
"+ # matching[adj] = -1: target in y not assigned to any of x",
"+ # matching[adj] -> an assigned source in x",
"+ # graph_dfs(matching[adj], matching, visited) = True indicates that source has been",
"- init_adj_table = [[] for _ in range(x_num)]",
"+ init_adj_table = [set() for _ in range(x_num)]"
]
| false | 0.048785 | 0.076718 | 0.635896 | [
"s071216115",
"s077655269"
]
|
u279266699 | p02614 | python | s849516757 | s009536294 | 237 | 60 | 27,024 | 9,116 | Accepted | Accepted | 74.68 | import copy
import numpy as np
def count_black(c):
count = 0
for row in c:
count += row.count('#')
return count
h, w, k = list(map(int, input().split()))
c = [list(eval(input())) for _ in range(h)]
ans = 0
for h_p in range(2 ** h):
for w_p in range(2 ** w):
c_cp = np.array(copy.deepcopy(c))
for i in range(h):
if (h_p >> i) & 1:
c_cp[i, :] = 'r'
for j in range(w):
if (w_p >> j) & 1:
c_cp[:, j] = 'r'
if count_black(c_cp.tolist()) == k:
ans += 1
print(ans)
| h, w, k = list(map(int, input().split()))
c = [eval(input()) for _ in range(h)]
ans = 0
for h_p in range(2 ** h):
for w_p in range(2 ** w):
cnt = 0
for i in range(h):
for j in range(w):
if (h_p >> i) & 1 and (w_p >> j) & 1 and c[i][j] == '#':
cnt += 1
if cnt == k:
ans += 1
print(ans) | 29 | 13 | 605 | 372 | import copy
import numpy as np
def count_black(c):
count = 0
for row in c:
count += row.count("#")
return count
h, w, k = list(map(int, input().split()))
c = [list(eval(input())) for _ in range(h)]
ans = 0
for h_p in range(2**h):
for w_p in range(2**w):
c_cp = np.array(copy.deepcopy(c))
for i in range(h):
if (h_p >> i) & 1:
c_cp[i, :] = "r"
for j in range(w):
if (w_p >> j) & 1:
c_cp[:, j] = "r"
if count_black(c_cp.tolist()) == k:
ans += 1
print(ans)
| h, w, k = list(map(int, input().split()))
c = [eval(input()) for _ in range(h)]
ans = 0
for h_p in range(2**h):
for w_p in range(2**w):
cnt = 0
for i in range(h):
for j in range(w):
if (h_p >> i) & 1 and (w_p >> j) & 1 and c[i][j] == "#":
cnt += 1
if cnt == k:
ans += 1
print(ans)
| false | 55.172414 | [
"-import copy",
"-import numpy as np",
"-",
"-",
"-def count_black(c):",
"- count = 0",
"- for row in c:",
"- count += row.count(\"#\")",
"- return count",
"-",
"-",
"-c = [list(eval(input())) for _ in range(h)]",
"+c = [eval(input()) for _ in range(h)]",
"- c_cp = np.array(copy.deepcopy(c))",
"+ cnt = 0",
"- if (h_p >> i) & 1:",
"- c_cp[i, :] = \"r\"",
"- for j in range(w):",
"- if (w_p >> j) & 1:",
"- c_cp[:, j] = \"r\"",
"- if count_black(c_cp.tolist()) == k:",
"+ for j in range(w):",
"+ if (h_p >> i) & 1 and (w_p >> j) & 1 and c[i][j] == \"#\":",
"+ cnt += 1",
"+ if cnt == k:"
]
| false | 0.283339 | 0.045382 | 6.243409 | [
"s849516757",
"s009536294"
]
|
u750990077 | p02691 | python | s602340774 | s279831533 | 904 | 171 | 139,580 | 149,920 | Accepted | Accepted | 81.08 | from collections import Counter
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
bigger = [None]*n
smaller = [None]*n
for i, ai in enumerate(a):
bigger[i] = i - ai
smaller[i] = i + ai
b = sorted(Counter(bigger).items())
s = sorted(Counter(smaller).items())
nb = len(b)
ns = len(s)
b.append((10**10, 0))
s.append((10**11, 0))
i, j = 0, 0
ans = 0
while i < nb or j < ns:
bi, nbi = b[i]
si, nsi = s[j]
if bi == si:
ans += nbi*nsi
i += 1
j += 1
elif bi > si:
j += 1
else:
i += 1
print(ans)
if __name__ == "__main__":
main() | from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(lambda : 0)
ans = 0
for i, ai in enumerate(a):
sa = i - ai
ans += d[sa]
wa = i + ai
d[wa] += 1
print(ans)
if __name__ == "__main__":
main() | 34 | 17 | 759 | 343 | from collections import Counter
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
bigger = [None] * n
smaller = [None] * n
for i, ai in enumerate(a):
bigger[i] = i - ai
smaller[i] = i + ai
b = sorted(Counter(bigger).items())
s = sorted(Counter(smaller).items())
nb = len(b)
ns = len(s)
b.append((10**10, 0))
s.append((10**11, 0))
i, j = 0, 0
ans = 0
while i < nb or j < ns:
bi, nbi = b[i]
si, nsi = s[j]
if bi == si:
ans += nbi * nsi
i += 1
j += 1
elif bi > si:
j += 1
else:
i += 1
print(ans)
if __name__ == "__main__":
main()
| from collections import defaultdict
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
d = defaultdict(lambda: 0)
ans = 0
for i, ai in enumerate(a):
sa = i - ai
ans += d[sa]
wa = i + ai
d[wa] += 1
print(ans)
if __name__ == "__main__":
main()
| false | 50 | [
"-from collections import Counter",
"+from collections import defaultdict",
"- bigger = [None] * n",
"- smaller = [None] * n",
"+ d = defaultdict(lambda: 0)",
"+ ans = 0",
"- bigger[i] = i - ai",
"- smaller[i] = i + ai",
"- b = sorted(Counter(bigger).items())",
"- s = sorted(Counter(smaller).items())",
"- nb = len(b)",
"- ns = len(s)",
"- b.append((10**10, 0))",
"- s.append((10**11, 0))",
"- i, j = 0, 0",
"- ans = 0",
"- while i < nb or j < ns:",
"- bi, nbi = b[i]",
"- si, nsi = s[j]",
"- if bi == si:",
"- ans += nbi * nsi",
"- i += 1",
"- j += 1",
"- elif bi > si:",
"- j += 1",
"- else:",
"- i += 1",
"+ sa = i - ai",
"+ ans += d[sa]",
"+ wa = i + ai",
"+ d[wa] += 1"
]
| false | 0.04267 | 0.03637 | 1.173231 | [
"s602340774",
"s279831533"
]
|
u150984829 | p00086 | python | s141884066 | s296401853 | 30 | 20 | 5,616 | 5,608 | Accepted | Accepted | 33.33 | import sys
v=[0]*101
for e in sys.stdin:
a,b=list(map(int,e.split()))
v[a]+=1;v[b]+=1
if a==0:
print((['NG','OK'][1&v[1]and 1&v[2]and sum(x&1 for x in v)==2]))
v=[0]*101
| import sys
v=[0]*101
for e in sys.stdin:
a,b=list(map(int,e.split()))
v[a]+=1;v[b]+=1
if a==0:
print((['NG','OK'][(v[1]&1)*(v[2]&1)*sum(x&1 for x in v)==2]))
v=[0]*101
| 8 | 8 | 176 | 174 | import sys
v = [0] * 101
for e in sys.stdin:
a, b = list(map(int, e.split()))
v[a] += 1
v[b] += 1
if a == 0:
print((["NG", "OK"][1 & v[1] and 1 & v[2] and sum(x & 1 for x in v) == 2]))
v = [0] * 101
| import sys
v = [0] * 101
for e in sys.stdin:
a, b = list(map(int, e.split()))
v[a] += 1
v[b] += 1
if a == 0:
print((["NG", "OK"][(v[1] & 1) * (v[2] & 1) * sum(x & 1 for x in v) == 2]))
v = [0] * 101
| false | 0 | [
"- print(([\"NG\", \"OK\"][1 & v[1] and 1 & v[2] and sum(x & 1 for x in v) == 2]))",
"+ print(([\"NG\", \"OK\"][(v[1] & 1) * (v[2] & 1) * sum(x & 1 for x in v) == 2]))"
]
| false | 0.045905 | 0.07162 | 0.640952 | [
"s141884066",
"s296401853"
]
|
u434428594 | p00494 | python | s437673115 | s606756278 | 1,280 | 430 | 5,320 | 49,564 | Accepted | Accepted | 66.41 | s = input()
p = 0
ans = 0
while p < len(s):
joi = 'JOI'
cnt = [0] * 3
for i in range(3):
while p < len(s) and s[p] == joi[i]:
cnt[i] += 1
p += 1
if cnt[0] >= cnt[1] and cnt[1] <= cnt[2]:
ans = max(ans, cnt[1])
print(ans) | import re
s = input()
ans = 0
for joi_str in re.findall('(J*)(O*)(I*)', s):
j = len(joi_str[0])
o = len(joi_str[1])
i = len(joi_str[2])
if j >= o and o <= i:
ans = max(ans, o)
print(ans) | 15 | 12 | 296 | 226 | s = input()
p = 0
ans = 0
while p < len(s):
joi = "JOI"
cnt = [0] * 3
for i in range(3):
while p < len(s) and s[p] == joi[i]:
cnt[i] += 1
p += 1
if cnt[0] >= cnt[1] and cnt[1] <= cnt[2]:
ans = max(ans, cnt[1])
print(ans)
| import re
s = input()
ans = 0
for joi_str in re.findall("(J*)(O*)(I*)", s):
j = len(joi_str[0])
o = len(joi_str[1])
i = len(joi_str[2])
if j >= o and o <= i:
ans = max(ans, o)
print(ans)
| false | 20 | [
"+import re",
"+",
"-p = 0",
"-while p < len(s):",
"- joi = \"JOI\"",
"- cnt = [0] * 3",
"- for i in range(3):",
"- while p < len(s) and s[p] == joi[i]:",
"- cnt[i] += 1",
"- p += 1",
"- if cnt[0] >= cnt[1] and cnt[1] <= cnt[2]:",
"- ans = max(ans, cnt[1])",
"+for joi_str in re.findall(\"(J*)(O*)(I*)\", s):",
"+ j = len(joi_str[0])",
"+ o = len(joi_str[1])",
"+ i = len(joi_str[2])",
"+ if j >= o and o <= i:",
"+ ans = max(ans, o)"
]
| false | 0.043382 | 0.135745 | 0.319585 | [
"s437673115",
"s606756278"
]
|
u714225686 | p03013 | python | s347633613 | s443937083 | 384 | 91 | 461,736 | 8,744 | Accepted | Accepted | 76.3 | # n = int(sys.stdin.readline())
# a, b = map(int, sys.stdin.readline().split())
# c = list(map(int, sys.stdin.readline().split()))
# s = [list(map(int,list(sys.stdin.readline()))) for i in range(h)] # 二次元配列入力 二次元マップみたいな入力のとき
# a = 100
# b = 0.987654321
# print('{0:06d}-{1:6f}'.format(a,b)) # 0埋め, 小数点出力桁指定時のときの出力
# 000100-0.987654
import math
import sys
import itertools
import queue
mod = 1000000007
if __name__ == "__main__":
N, M = list(map(int, sys.stdin.readline().split()))
broken = [False for _ in range(N + 2)]
for _ in range(M):
broken[int(sys.stdin.readline())] = True
dp = [0 for _ in range(N + 2)]
dp[N] = 1
for i in range(0, N)[::-1]:
if not broken[i]:
dp[i] = dp[i + 1] + dp[i + 2]
print((dp[0] % mod)) | # n = int(sys.stdin.readline())
# a, b = map(int, sys.stdin.readline().split())
# c = list(map(int, sys.stdin.readline().split()))
# s = [list(map(int,list(sys.stdin.readline()))) for i in range(h)] # 二次元配列入力 二次元マップみたいな入力のとき
# a = 100
# b = 0.987654321
# print('{0:06d}-{1:6f}'.format(a,b)) # 0埋め, 小数点出力桁指定時のときの出力
# 000100-0.987654
import math
import sys
import itertools
import queue
mod = 1000000007
if __name__ == "__main__":
N, M = list(map(int, sys.stdin.readline().split()))
broken = [False for _ in range(N + 2)]
for _ in range(M):
broken[int(sys.stdin.readline())] = True
dp = [0 for _ in range(N + 2)]
dp[N] = 1
for i in range(0, N)[::-1]:
if not broken[i]:
dp[i] = (dp[i + 1] + dp[i + 2]) % mod
print((dp[0])) | 30 | 30 | 802 | 804 | # n = int(sys.stdin.readline())
# a, b = map(int, sys.stdin.readline().split())
# c = list(map(int, sys.stdin.readline().split()))
# s = [list(map(int,list(sys.stdin.readline()))) for i in range(h)] # 二次元配列入力 二次元マップみたいな入力のとき
# a = 100
# b = 0.987654321
# print('{0:06d}-{1:6f}'.format(a,b)) # 0埋め, 小数点出力桁指定時のときの出力
# 000100-0.987654
import math
import sys
import itertools
import queue
mod = 1000000007
if __name__ == "__main__":
N, M = list(map(int, sys.stdin.readline().split()))
broken = [False for _ in range(N + 2)]
for _ in range(M):
broken[int(sys.stdin.readline())] = True
dp = [0 for _ in range(N + 2)]
dp[N] = 1
for i in range(0, N)[::-1]:
if not broken[i]:
dp[i] = dp[i + 1] + dp[i + 2]
print((dp[0] % mod))
| # n = int(sys.stdin.readline())
# a, b = map(int, sys.stdin.readline().split())
# c = list(map(int, sys.stdin.readline().split()))
# s = [list(map(int,list(sys.stdin.readline()))) for i in range(h)] # 二次元配列入力 二次元マップみたいな入力のとき
# a = 100
# b = 0.987654321
# print('{0:06d}-{1:6f}'.format(a,b)) # 0埋め, 小数点出力桁指定時のときの出力
# 000100-0.987654
import math
import sys
import itertools
import queue
mod = 1000000007
if __name__ == "__main__":
N, M = list(map(int, sys.stdin.readline().split()))
broken = [False for _ in range(N + 2)]
for _ in range(M):
broken[int(sys.stdin.readline())] = True
dp = [0 for _ in range(N + 2)]
dp[N] = 1
for i in range(0, N)[::-1]:
if not broken[i]:
dp[i] = (dp[i + 1] + dp[i + 2]) % mod
print((dp[0]))
| false | 0 | [
"- dp[i] = dp[i + 1] + dp[i + 2]",
"- print((dp[0] % mod))",
"+ dp[i] = (dp[i + 1] + dp[i + 2]) % mod",
"+ print((dp[0]))"
]
| false | 0.043984 | 0.045723 | 0.961983 | [
"s347633613",
"s443937083"
]
|
u505830998 | p02642 | python | s160587586 | s353565744 | 517 | 227 | 165,396 | 122,084 | Accepted | Accepted | 56.09 | import sys
import collections
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
n = int(eval(input()))
#b , c = tin()
al = lin()
al.sort()
unique_al = list(set(al))
unique_al.sort()
al_counter = collections.Counter(al)
ok=[v for v in list(al_counter.keys()) if al_counter[v] == 1]
d = {v:i for i,v in enumerate(ok)}
max_v = 10**6+1
for check in unique_al:
for v in range(2*check, max_v, check):
if v in d:
ok[d[v]]=0
return sum([v > 0 for v in ok ])
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | import sys
input_methods=['clipboard','file','key']
using_method=0
input_method=input_methods[using_method]
tin=lambda : list(map(int, input().split()))
lin=lambda : list(tin())
mod=1000000007
#+++++
def main():
n = int(eval(input()))
#b , c = tin()
#s = input()
al=lin()
vm=10**6+1
rr = [0]*(vm)
for v in al:
rr[v]+=1
for v in list(set(al)):
for i in range(2*v, vm, v):
rr[i]=0
ret = rr.count(1)
print(ret)
#+++++
isTest=False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text=clipboard.get()
input_l=input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform =='ios':
if input_method==input_methods[0]:
ic=input_clipboard()
input = lambda : ic.__next__()
elif input_method==input_methods[1]:
sys.stdin=open('inputFile.txt')
else:
pass
isTest=True
else:
pass
#input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret) | 69 | 59 | 1,235 | 1,016 | import sys
import collections
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
n = int(eval(input()))
# b , c = tin()
al = lin()
al.sort()
unique_al = list(set(al))
unique_al.sort()
al_counter = collections.Counter(al)
ok = [v for v in list(al_counter.keys()) if al_counter[v] == 1]
d = {v: i for i, v in enumerate(ok)}
max_v = 10**6 + 1
for check in unique_al:
for v in range(2 * check, max_v, check):
if v in d:
ok[d[v]] = 0
return sum([v > 0 for v in ok])
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| import sys
input_methods = ["clipboard", "file", "key"]
using_method = 0
input_method = input_methods[using_method]
tin = lambda: list(map(int, input().split()))
lin = lambda: list(tin())
mod = 1000000007
# +++++
def main():
n = int(eval(input()))
# b , c = tin()
# s = input()
al = lin()
vm = 10**6 + 1
rr = [0] * (vm)
for v in al:
rr[v] += 1
for v in list(set(al)):
for i in range(2 * v, vm, v):
rr[i] = 0
ret = rr.count(1)
print(ret)
# +++++
isTest = False
def pa(v):
if isTest:
print(v)
def input_clipboard():
import clipboard
input_text = clipboard.get()
input_l = input_text.splitlines()
for l in input_l:
yield l
if __name__ == "__main__":
if sys.platform == "ios":
if input_method == input_methods[0]:
ic = input_clipboard()
input = lambda: ic.__next__()
elif input_method == input_methods[1]:
sys.stdin = open("inputFile.txt")
else:
pass
isTest = True
else:
pass
# input = sys.stdin.readline
ret = main()
if ret is not None:
print(ret)
| false | 14.492754 | [
"-import collections",
"+ # s = input()",
"- al.sort()",
"- unique_al = list(set(al))",
"- unique_al.sort()",
"- al_counter = collections.Counter(al)",
"- ok = [v for v in list(al_counter.keys()) if al_counter[v] == 1]",
"- d = {v: i for i, v in enumerate(ok)}",
"- max_v = 10**6 + 1",
"- for check in unique_al:",
"- for v in range(2 * check, max_v, check):",
"- if v in d:",
"- ok[d[v]] = 0",
"- return sum([v > 0 for v in ok])",
"+ vm = 10**6 + 1",
"+ rr = [0] * (vm)",
"+ for v in al:",
"+ rr[v] += 1",
"+ for v in list(set(al)):",
"+ for i in range(2 * v, vm, v):",
"+ rr[i] = 0",
"+ ret = rr.count(1)",
"+ print(ret)"
]
| false | 0.085292 | 0.109391 | 0.779698 | [
"s160587586",
"s353565744"
]
|
u373499377 | p03853 | python | s150606828 | s847333842 | 22 | 17 | 3,316 | 3,060 | Accepted | Accepted | 22.73 | def main():
h, w = list(map(int, input().split()))
px = [[0 for j in range(w)] for i in range(h)]
px_stretch = [[0 for j in range(w)] for i in range(2 * h)]
for row in range(h):
px[row] = list(eval(input()))
for row in range(2 * h):
px_stretch[row] = [px[row // 2][i] for i in range(w)]
print((''.join(px_stretch[row])))
if __name__ == "__main__":
main()
| def main():
h, w = map(int, input().split())
px = [input() for i in range(h)]
for row in range(h):
print(px[row], px[row], sep='\n')
# px = [[0 for j in range(w)] for i in range(h)]
# px_stretch = [[0 for j in range(w)] for i in range(2 * h)]
#
# for row in range(h):
# px[row] = list(input())
#
# for row in range(2 * h):
# px_stretch[row] = [px[row // 2][i] for i in range(w)]
# print(''.join(px_stretch[row]))
if __name__ == "__main__":
main()
| 17 | 21 | 411 | 546 | def main():
h, w = list(map(int, input().split()))
px = [[0 for j in range(w)] for i in range(h)]
px_stretch = [[0 for j in range(w)] for i in range(2 * h)]
for row in range(h):
px[row] = list(eval(input()))
for row in range(2 * h):
px_stretch[row] = [px[row // 2][i] for i in range(w)]
print(("".join(px_stretch[row])))
if __name__ == "__main__":
main()
| def main():
h, w = map(int, input().split())
px = [input() for i in range(h)]
for row in range(h):
print(px[row], px[row], sep="\n")
# px = [[0 for j in range(w)] for i in range(h)]
# px_stretch = [[0 for j in range(w)] for i in range(2 * h)]
#
# for row in range(h):
# px[row] = list(input())
#
# for row in range(2 * h):
# px_stretch[row] = [px[row // 2][i] for i in range(w)]
# print(''.join(px_stretch[row]))
if __name__ == "__main__":
main()
| false | 19.047619 | [
"- h, w = list(map(int, input().split()))",
"- px = [[0 for j in range(w)] for i in range(h)]",
"- px_stretch = [[0 for j in range(w)] for i in range(2 * h)]",
"+ h, w = map(int, input().split())",
"+ px = [input() for i in range(h)]",
"- px[row] = list(eval(input()))",
"- for row in range(2 * h):",
"- px_stretch[row] = [px[row // 2][i] for i in range(w)]",
"- print((\"\".join(px_stretch[row])))",
"+ print(px[row], px[row], sep=\"\\n\")",
"+ # px = [[0 for j in range(w)] for i in range(h)]",
"+ # px_stretch = [[0 for j in range(w)] for i in range(2 * h)]",
"+ #",
"+ # for row in range(h):",
"+ # px[row] = list(input())",
"+ #",
"+ # for row in range(2 * h):",
"+ # px_stretch[row] = [px[row // 2][i] for i in range(w)]",
"+ # print(''.join(px_stretch[row]))"
]
| false | 0.049375 | 0.0467 | 1.057268 | [
"s150606828",
"s847333842"
]
|
u371350984 | p03494 | python | s825859201 | s365134552 | 31 | 28 | 9,128 | 9,084 | Accepted | Accepted | 9.68 | n = int(eval(input()))
a = list(map(int, input().split()))
i = 0
per = True
while per == True:
for index in range(n):
num = a[index]
ans = divmod(num, 2)
if num == 0 or ans[1] != 0:
per = False
break
a[index] = ans[0]
if per == True:
i += 1
print(i) | import math
n = eval(input())
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print((round(ans))) | 16 | 7 | 331 | 170 | n = int(eval(input()))
a = list(map(int, input().split()))
i = 0
per = True
while per == True:
for index in range(n):
num = a[index]
ans = divmod(num, 2)
if num == 0 or ans[1] != 0:
per = False
break
a[index] = ans[0]
if per == True:
i += 1
print(i)
| import math
n = eval(input())
a = list(map(int, input().split()))
ans = float("inf")
for i in a:
ans = min(ans, len(bin(i)) - bin(i).rfind("1") - 1)
print((round(ans)))
| false | 56.25 | [
"-n = int(eval(input()))",
"+import math",
"+",
"+n = eval(input())",
"-i = 0",
"-per = True",
"-while per == True:",
"- for index in range(n):",
"- num = a[index]",
"- ans = divmod(num, 2)",
"- if num == 0 or ans[1] != 0:",
"- per = False",
"- break",
"- a[index] = ans[0]",
"- if per == True:",
"- i += 1",
"-print(i)",
"+ans = float(\"inf\")",
"+for i in a:",
"+ ans = min(ans, len(bin(i)) - bin(i).rfind(\"1\") - 1)",
"+print((round(ans)))"
]
| false | 0.038217 | 0.037546 | 1.017875 | [
"s825859201",
"s365134552"
]
|
u968166680 | p02960 | python | s000689872 | s182208561 | 271 | 248 | 80,368 | 73,756 | Accepted | Accepted | 8.49 | 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():
S = readline().strip()
N = len(S)
power = [0] * N
power[0] = 1
for i in range(N - 1):
power[i + 1] = 10 * power[i] % 13
S = S[::-1]
Q = []
const = 0
for i, c in enumerate(S):
if c == '?':
Q.append(i)
else:
const = (const + power[i] * int(c)) % 13
dp = [0] * 13
dp[const] = 1
for i in range(len(Q)):
dp, dp_prev = [0] * 13, dp
p = power[Q[i]]
for j in range(10):
for k in range(13):
idx = (p * j + k) % 13
dp[idx] = (dp[idx] + dp_prev[k]) % MOD
print((dp[5]))
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():
S = readline().strip()
S = S[::-1]
dp = [0] * 13
dp[0] = 1
p = 1
for i, c in enumerate(S):
dp, dp_prev = [0] * 13, dp
for k in range(13):
if c == '?':
for j in range(10):
dp[(p * j + k) % 13] = (dp[(p * j + k) % 13] + dp_prev[k]) % MOD
else:
dp[(p * int(c) + k) % 13] = (dp[(p * int(c) + k) % 13] + dp_prev[k]) % MOD
p = p * 10 % 13
print((dp[5]))
return
if __name__ == '__main__':
main()
| 45 | 35 | 897 | 735 | 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():
S = readline().strip()
N = len(S)
power = [0] * N
power[0] = 1
for i in range(N - 1):
power[i + 1] = 10 * power[i] % 13
S = S[::-1]
Q = []
const = 0
for i, c in enumerate(S):
if c == "?":
Q.append(i)
else:
const = (const + power[i] * int(c)) % 13
dp = [0] * 13
dp[const] = 1
for i in range(len(Q)):
dp, dp_prev = [0] * 13, dp
p = power[Q[i]]
for j in range(10):
for k in range(13):
idx = (p * j + k) % 13
dp[idx] = (dp[idx] + dp_prev[k]) % MOD
print((dp[5]))
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():
S = readline().strip()
S = S[::-1]
dp = [0] * 13
dp[0] = 1
p = 1
for i, c in enumerate(S):
dp, dp_prev = [0] * 13, dp
for k in range(13):
if c == "?":
for j in range(10):
dp[(p * j + k) % 13] = (dp[(p * j + k) % 13] + dp_prev[k]) % MOD
else:
dp[(p * int(c) + k) % 13] = (
dp[(p * int(c) + k) % 13] + dp_prev[k]
) % MOD
p = p * 10 % 13
print((dp[5]))
return
if __name__ == "__main__":
main()
| false | 22.222222 | [
"- N = len(S)",
"- power = [0] * N",
"- power[0] = 1",
"- for i in range(N - 1):",
"- power[i + 1] = 10 * power[i] % 13",
"- Q = []",
"- const = 0",
"+ dp = [0] * 13",
"+ dp[0] = 1",
"+ p = 1",
"- if c == \"?\":",
"- Q.append(i)",
"- else:",
"- const = (const + power[i] * int(c)) % 13",
"- dp = [0] * 13",
"- dp[const] = 1",
"- for i in range(len(Q)):",
"- p = power[Q[i]]",
"- for j in range(10):",
"- for k in range(13):",
"- idx = (p * j + k) % 13",
"- dp[idx] = (dp[idx] + dp_prev[k]) % MOD",
"+ for k in range(13):",
"+ if c == \"?\":",
"+ for j in range(10):",
"+ dp[(p * j + k) % 13] = (dp[(p * j + k) % 13] + dp_prev[k]) % MOD",
"+ else:",
"+ dp[(p * int(c) + k) % 13] = (",
"+ dp[(p * int(c) + k) % 13] + dp_prev[k]",
"+ ) % MOD",
"+ p = p * 10 % 13"
]
| false | 0.072046 | 0.080143 | 0.898965 | [
"s000689872",
"s182208561"
]
|
u222668979 | p02579 | python | s324525120 | s522865461 | 1,493 | 1,377 | 99,728 | 99,736 | Accepted | Accepted | 7.77 | from collections import deque
from itertools import product
def bfs(x, y):
dist = [[10 ** 9] * w for _ in range(h)]
dist[y][x] = 0
que = deque([(x,y)])
while len(que) > 0:
x, y = que.popleft()
near_a = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
num = product([-2, -1, 0, 1, 2], repeat=2)
near_b = [(x + dx, y + dy) for dx, dy in num]
for cnt, l in enumerate((near_a, near_b)):
for i, j in l:
if (0 <= i < w and 0 <= j < h and
dist[j][i] > dist[y][x] + cnt and s[j][i] == '.'):
dist[j][i] = dist[y][x] + cnt
if cnt == 0:
que.appendleft((i, j))
elif cnt == 1:
que.append((i, j))
return dist
h, w = list(map(int, input().split()))
Ch, Cw = list(map(int, input().split()))
Dh, Dw = list(map(int, input().split()))
s = [eval(input()) for _ in range(h)]
ans = bfs(Cw - 1, Ch - 1)[Dh - 1][Dw - 1]
print((-1 if ans == 10 ** 9 else ans))
| from collections import deque
from itertools import product
def bfs(x, y):
dist = [[10 ** 9] * w for _ in range(h)]
dist[y][x] = 0
for i, si in enumerate(s):
for j, sij in enumerate(si):
if sij == '#':
dist[i][j] = -1
que = deque([(x, y)])
while len(que) > 0:
x, y = que.popleft()
near_a = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
num = product([-2, -1, 0, 1, 2], repeat=2)
near_b = [(x + dx, y + dy) for dx, dy in num]
for cnt, l in enumerate((near_a, near_b)):
for i, j in l:
if (0 <= i < w and 0 <= j < h and
dist[j][i] > dist[y][x] + cnt and s[j][i] == '.'):
dist[j][i] = dist[y][x] + cnt
if cnt == 0:
que.appendleft((i, j))
elif cnt == 1:
que.append((i, j))
return dist
h, w = list(map(int, input().split()))
Ch, Cw = list(map(int, input().split()))
Dh, Dw = list(map(int, input().split()))
s = [eval(input()) for _ in range(h)]
ans = bfs(Cw - 1, Ch - 1)[Dh - 1][Dw - 1]
print((-1 if ans == 10 ** 9 else ans))
| 34 | 38 | 1,069 | 1,201 | from collections import deque
from itertools import product
def bfs(x, y):
dist = [[10**9] * w for _ in range(h)]
dist[y][x] = 0
que = deque([(x, y)])
while len(que) > 0:
x, y = que.popleft()
near_a = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
num = product([-2, -1, 0, 1, 2], repeat=2)
near_b = [(x + dx, y + dy) for dx, dy in num]
for cnt, l in enumerate((near_a, near_b)):
for i, j in l:
if (
0 <= i < w
and 0 <= j < h
and dist[j][i] > dist[y][x] + cnt
and s[j][i] == "."
):
dist[j][i] = dist[y][x] + cnt
if cnt == 0:
que.appendleft((i, j))
elif cnt == 1:
que.append((i, j))
return dist
h, w = list(map(int, input().split()))
Ch, Cw = list(map(int, input().split()))
Dh, Dw = list(map(int, input().split()))
s = [eval(input()) for _ in range(h)]
ans = bfs(Cw - 1, Ch - 1)[Dh - 1][Dw - 1]
print((-1 if ans == 10**9 else ans))
| from collections import deque
from itertools import product
def bfs(x, y):
dist = [[10**9] * w for _ in range(h)]
dist[y][x] = 0
for i, si in enumerate(s):
for j, sij in enumerate(si):
if sij == "#":
dist[i][j] = -1
que = deque([(x, y)])
while len(que) > 0:
x, y = que.popleft()
near_a = [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)]
num = product([-2, -1, 0, 1, 2], repeat=2)
near_b = [(x + dx, y + dy) for dx, dy in num]
for cnt, l in enumerate((near_a, near_b)):
for i, j in l:
if (
0 <= i < w
and 0 <= j < h
and dist[j][i] > dist[y][x] + cnt
and s[j][i] == "."
):
dist[j][i] = dist[y][x] + cnt
if cnt == 0:
que.appendleft((i, j))
elif cnt == 1:
que.append((i, j))
return dist
h, w = list(map(int, input().split()))
Ch, Cw = list(map(int, input().split()))
Dh, Dw = list(map(int, input().split()))
s = [eval(input()) for _ in range(h)]
ans = bfs(Cw - 1, Ch - 1)[Dh - 1][Dw - 1]
print((-1 if ans == 10**9 else ans))
| false | 10.526316 | [
"+ for i, si in enumerate(s):",
"+ for j, sij in enumerate(si):",
"+ if sij == \"#\":",
"+ dist[i][j] = -1"
]
| false | 0.043111 | 0.038414 | 1.122279 | [
"s324525120",
"s522865461"
]
|
u633068244 | p00116 | python | s092585220 | s063283905 | 2,430 | 2,050 | 10,316 | 10,308 | Accepted | Accepted | 15.64 | while 1:
H,W = list(map(int,input().split()))
if H == 0: break
M = [input() for i in range(H)]
A = [[0]*W for i in range(H)]
B = [[0]*W for i in range(H)]
ans = 0
for h in range(H):
L = 0
for w in range(W):
if M[h][w] == ".":
L += 1
else:
L = 0
A[h][w] = L
B[h][w] = (B[h-1][w] if h > 0 else 0) + 1 if L > 0 else 0
if L*B[h][w] > ans:
a = min([A[h-i][w] for i in range(ans/L+1)])
for hi in range(B[h][w]):
a = min(a,A[h-hi][w])
if a*B[h][w] <= ans:
break
ans = max(ans,a*(hi+1))
print(ans) | while 1:
H,W = list(map(int,input().split()))
if H == 0: break
M = [input() for i in range(H)]
A = [[0]*W for i in range(H)]
B = [[0]*W for i in range(H)]
ans = 0
for h in range(H):
L = 0
for w in range(W):
if M[h][w] == ".":
L += 1
else:
L = 0
A[h][w] = L
B[h][w] = (B[h-1][w] if h > 0 else 0) + 1 if L > 0 else 0
if L*B[h][w] > ans:
a = L
for hi in range(B[h][w]):
a = min(a,A[h-hi][w])
if a*B[h][w] <= ans:
break
ans = max(ans,a*(hi+1))
print(ans) | 24 | 24 | 577 | 538 | while 1:
H, W = list(map(int, input().split()))
if H == 0:
break
M = [input() for i in range(H)]
A = [[0] * W for i in range(H)]
B = [[0] * W for i in range(H)]
ans = 0
for h in range(H):
L = 0
for w in range(W):
if M[h][w] == ".":
L += 1
else:
L = 0
A[h][w] = L
B[h][w] = (B[h - 1][w] if h > 0 else 0) + 1 if L > 0 else 0
if L * B[h][w] > ans:
a = min([A[h - i][w] for i in range(ans / L + 1)])
for hi in range(B[h][w]):
a = min(a, A[h - hi][w])
if a * B[h][w] <= ans:
break
ans = max(ans, a * (hi + 1))
print(ans)
| while 1:
H, W = list(map(int, input().split()))
if H == 0:
break
M = [input() for i in range(H)]
A = [[0] * W for i in range(H)]
B = [[0] * W for i in range(H)]
ans = 0
for h in range(H):
L = 0
for w in range(W):
if M[h][w] == ".":
L += 1
else:
L = 0
A[h][w] = L
B[h][w] = (B[h - 1][w] if h > 0 else 0) + 1 if L > 0 else 0
if L * B[h][w] > ans:
a = L
for hi in range(B[h][w]):
a = min(a, A[h - hi][w])
if a * B[h][w] <= ans:
break
ans = max(ans, a * (hi + 1))
print(ans)
| false | 0 | [
"- a = min([A[h - i][w] for i in range(ans / L + 1)])",
"+ a = L"
]
| false | 0.035684 | 0.054863 | 0.65042 | [
"s092585220",
"s063283905"
]
|
u465699806 | p03111 | python | s063846553 | s703036074 | 485 | 60 | 3,828 | 3,188 | Accepted | Accepted | 87.63 | import random as rng
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
pass
dump = dump_impl if "DEBUG" in sys.argv else dump_dummy
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
ans = 10**20
for use in it.product({0, 1, 2, 3}, repeat=N):
ABC = {0: [], 1: [], 2: [], 3: []}
for i, u in enumerate(use):
dump(i, u, use)
ABC[u].append(l[i])
if any([len(ABC[u]) == 0 for u in {1, 2, 3}]):
continue
ans = min(ans, sum([abs(sum(ABC[i]) - x) + (len(ABC[i]) - 1)
* 10 for i, x in zip([1, 2, 3], [A, B, C])]))
print(ans)
| n, a, b, c = [int(it) for it in input().split()]
ls = [int(eval(input())) for it in range(n)]
def dfs(cur, tmpA, tmpB, tmpC):
if cur == n:
return abs(a - tmpA) + abs(b - tmpB) + abs(c - tmpC) if tmpA > 0 and tmpB > 0 and tmpC else 10**20
return min(
dfs(cur + 1, tmpA + ls[cur], tmpB, tmpC) + (10 if tmpA > 0 else 0),
dfs(cur + 1, tmpA, tmpB + ls[cur], tmpC) + (10 if tmpB > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC + ls[cur]) + (10 if tmpC > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC)
)
print((dfs(0, 0, 0, 0)))
| 32 | 13 | 811 | 569 | import random as rng
import itertools as it
import collections as col
import heapq as hq
import sys
import copy as cp
sys.setrecursionlimit(10**9)
def dump_impl(*objects):
print(*objects, file=sys.stderr)
def dump_dummy(*objects):
pass
dump = dump_impl if "DEBUG" in sys.argv else dump_dummy
N, A, B, C = map(int, input().split())
l = [int(input()) for i in range(N)]
ans = 10**20
for use in it.product({0, 1, 2, 3}, repeat=N):
ABC = {0: [], 1: [], 2: [], 3: []}
for i, u in enumerate(use):
dump(i, u, use)
ABC[u].append(l[i])
if any([len(ABC[u]) == 0 for u in {1, 2, 3}]):
continue
ans = min(
ans,
sum(
[
abs(sum(ABC[i]) - x) + (len(ABC[i]) - 1) * 10
for i, x in zip([1, 2, 3], [A, B, C])
]
),
)
print(ans)
| n, a, b, c = [int(it) for it in input().split()]
ls = [int(eval(input())) for it in range(n)]
def dfs(cur, tmpA, tmpB, tmpC):
if cur == n:
return (
abs(a - tmpA) + abs(b - tmpB) + abs(c - tmpC)
if tmpA > 0 and tmpB > 0 and tmpC
else 10**20
)
return min(
dfs(cur + 1, tmpA + ls[cur], tmpB, tmpC) + (10 if tmpA > 0 else 0),
dfs(cur + 1, tmpA, tmpB + ls[cur], tmpC) + (10 if tmpB > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC + ls[cur]) + (10 if tmpC > 0 else 0),
dfs(cur + 1, tmpA, tmpB, tmpC),
)
print((dfs(0, 0, 0, 0)))
| false | 59.375 | [
"-import random as rng",
"-import itertools as it",
"-import collections as col",
"-import heapq as hq",
"-import sys",
"-import copy as cp",
"-",
"-sys.setrecursionlimit(10**9)",
"+n, a, b, c = [int(it) for it in input().split()]",
"+ls = [int(eval(input())) for it in range(n)]",
"-def dump_impl(*objects):",
"- print(*objects, file=sys.stderr)",
"+def dfs(cur, tmpA, tmpB, tmpC):",
"+ if cur == n:",
"+ return (",
"+ abs(a - tmpA) + abs(b - tmpB) + abs(c - tmpC)",
"+ if tmpA > 0 and tmpB > 0 and tmpC",
"+ else 10**20",
"+ )",
"+ return min(",
"+ dfs(cur + 1, tmpA + ls[cur], tmpB, tmpC) + (10 if tmpA > 0 else 0),",
"+ dfs(cur + 1, tmpA, tmpB + ls[cur], tmpC) + (10 if tmpB > 0 else 0),",
"+ dfs(cur + 1, tmpA, tmpB, tmpC + ls[cur]) + (10 if tmpC > 0 else 0),",
"+ dfs(cur + 1, tmpA, tmpB, tmpC),",
"+ )",
"-def dump_dummy(*objects):",
"- pass",
"-",
"-",
"-dump = dump_impl if \"DEBUG\" in sys.argv else dump_dummy",
"-N, A, B, C = map(int, input().split())",
"-l = [int(input()) for i in range(N)]",
"-ans = 10**20",
"-for use in it.product({0, 1, 2, 3}, repeat=N):",
"- ABC = {0: [], 1: [], 2: [], 3: []}",
"- for i, u in enumerate(use):",
"- dump(i, u, use)",
"- ABC[u].append(l[i])",
"- if any([len(ABC[u]) == 0 for u in {1, 2, 3}]):",
"- continue",
"- ans = min(",
"- ans,",
"- sum(",
"- [",
"- abs(sum(ABC[i]) - x) + (len(ABC[i]) - 1) * 10",
"- for i, x in zip([1, 2, 3], [A, B, C])",
"- ]",
"- ),",
"- )",
"-print(ans)",
"+print((dfs(0, 0, 0, 0)))"
]
| false | 0.367132 | 0.134578 | 2.728019 | [
"s063846553",
"s703036074"
]
|
u887207211 | p03307 | python | s184852002 | s178773130 | 19 | 17 | 3,064 | 2,940 | Accepted | Accepted | 10.53 | N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
def lcm(m, n):
return int((m * n) / gcd(m, n))
print((lcm(N,2))) | N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m%n
return m
def lcm(m, n):
print((m * n // gcd(m, n)))
lcm(N,2) | 11 | 11 | 149 | 136 | N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m % n
return m
def lcm(m, n):
return int((m * n) / gcd(m, n))
print((lcm(N, 2)))
| N = int(eval(input()))
def gcd(m, n):
while n:
m, n = n, m % n
return m
def lcm(m, n):
print((m * n // gcd(m, n)))
lcm(N, 2)
| false | 0 | [
"- return int((m * n) / gcd(m, n))",
"+ print((m * n // gcd(m, n)))",
"-print((lcm(N, 2)))",
"+lcm(N, 2)"
]
| false | 0.051334 | 0.050814 | 1.010238 | [
"s184852002",
"s178773130"
]
|
u614181788 | p03329 | python | s287014635 | s635911655 | 1,218 | 1,003 | 9,616 | 9,592 | Accepted | Accepted | 17.65 | n = int(eval(input()))
dp = [float("Inf")]*(n+1)
dp[0] = 0
for i in range(n):
for j in range(1,6):
if i + j > n:
break
dp[i+j] = min(dp[i+j], dp[i] + j)
for j in range(1,n//6+1):
if i + 6**j > n:
break
dp[i+6**j] = min(dp[i+6**j], dp[i] + 1)
for j in range(1,n//9+1):
if i + 9**j > n:
break
dp[i+9**j] = min(dp[i+9**j], dp[i] + 1)
print((dp[-1])) | n = int(eval(input()))
dp = [float("Inf")]*(n+1)
for i in range(min(6, n+1)):
dp[i] = i
for i in range(n):
for j in range(1,n//6+1):
if i + 6**j > n:
break
dp[i+6**j] = min(dp[i+6**j], dp[i] + 1)
for j in range(1,n//9+1):
if i + 9**j > n:
break
dp[i+9**j] = min(dp[i+9**j], dp[i] + 1)
print((dp[-1])) | 17 | 14 | 450 | 373 | n = int(eval(input()))
dp = [float("Inf")] * (n + 1)
dp[0] = 0
for i in range(n):
for j in range(1, 6):
if i + j > n:
break
dp[i + j] = min(dp[i + j], dp[i] + j)
for j in range(1, n // 6 + 1):
if i + 6**j > n:
break
dp[i + 6**j] = min(dp[i + 6**j], dp[i] + 1)
for j in range(1, n // 9 + 1):
if i + 9**j > n:
break
dp[i + 9**j] = min(dp[i + 9**j], dp[i] + 1)
print((dp[-1]))
| n = int(eval(input()))
dp = [float("Inf")] * (n + 1)
for i in range(min(6, n + 1)):
dp[i] = i
for i in range(n):
for j in range(1, n // 6 + 1):
if i + 6**j > n:
break
dp[i + 6**j] = min(dp[i + 6**j], dp[i] + 1)
for j in range(1, n // 9 + 1):
if i + 9**j > n:
break
dp[i + 9**j] = min(dp[i + 9**j], dp[i] + 1)
print((dp[-1]))
| false | 17.647059 | [
"-dp[0] = 0",
"+for i in range(min(6, n + 1)):",
"+ dp[i] = i",
"- for j in range(1, 6):",
"- if i + j > n:",
"- break",
"- dp[i + j] = min(dp[i + j], dp[i] + j)"
]
| false | 0.427141 | 0.250294 | 1.706557 | [
"s287014635",
"s635911655"
]
|
u968166680 | p04013 | python | s283997454 | s309894581 | 102 | 87 | 70,268 | 67,276 | Accepted | Accepted | 14.71 | 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, A, *X = list(map(int, read().split()))
dp = [[0] * (N * 50 + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, -1, -1):
for k in range(N * 50 + 1):
if k - X[i] >= 0 and j > 0:
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[j][A * j]
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, A, *X = list(map(int, read().split()))
dp = [[0] * (N * 50 + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, 0, -1):
for k in range(X[i], N * 50 + 1):
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[j][A * j]
print(ans)
return
if __name__ == '__main__':
main()
| 32 | 31 | 646 | 602 | 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, A, *X = list(map(int, read().split()))
dp = [[0] * (N * 50 + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, -1, -1):
for k in range(N * 50 + 1):
if k - X[i] >= 0 and j > 0:
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[j][A * j]
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, A, *X = list(map(int, read().split()))
dp = [[0] * (N * 50 + 1) for j in range(N + 1)]
dp[0][0] = 1
for i in range(N):
for j in range(N, 0, -1):
for k in range(X[i], N * 50 + 1):
dp[j][k] += dp[j - 1][k - X[i]]
ans = 0
for j in range(1, N + 1):
ans += dp[j][A * j]
print(ans)
return
if __name__ == "__main__":
main()
| false | 3.125 | [
"- for j in range(N, -1, -1):",
"- for k in range(N * 50 + 1):",
"- if k - X[i] >= 0 and j > 0:",
"- dp[j][k] += dp[j - 1][k - X[i]]",
"+ for j in range(N, 0, -1):",
"+ for k in range(X[i], N * 50 + 1):",
"+ dp[j][k] += dp[j - 1][k - X[i]]"
]
| false | 0.046325 | 0.033187 | 1.39586 | [
"s283997454",
"s309894581"
]
|
u951814007 | p02714 | python | s714496235 | s130843323 | 768 | 135 | 75,532 | 68,280 | Accepted | Accepted | 82.42 | n = int(eval(input()))
s = eval(input())
count = {"R":0,"G":0,"B":0}
for c in s:
count[c] += 1
r,g,b = list(count.values())
ans = r*g*b
for i in range(1,(n-1)//2+1): #1から
for rgb in zip(s,s[i:],s[i*2:]): #rgbに連続した三つのリストの要素を入れ込む
if len(set(rgb)) == 3: #リストrgbをセットにまとめ、長さが
ans -=1
print(ans) | n = int(eval(input()))
s = eval(input())
r_cnt = s.count('R')
g_cnt = s.count('G')
b_cnt = s.count('B')
ans = r_cnt * g_cnt * b_cnt
for i in range(n): #s[i]
for d in range(n):
j = i + d #s[j] s[i]etcこれらは等間隔となるが
k = j + d #s[k] この時点でi!=j, j!=k, i!=k
if k >= n:break #kが一番大きいが、n以上になることはない
if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
ans -= 1 #等間隔でRGB揃っているものを引く
print(ans)
| 14 | 18 | 318 | 454 | n = int(eval(input()))
s = eval(input())
count = {"R": 0, "G": 0, "B": 0}
for c in s:
count[c] += 1
r, g, b = list(count.values())
ans = r * g * b
for i in range(1, (n - 1) // 2 + 1): # 1から
for rgb in zip(s, s[i:], s[i * 2 :]): # rgbに連続した三つのリストの要素を入れ込む
if len(set(rgb)) == 3: # リストrgbをセットにまとめ、長さが
ans -= 1
print(ans)
| n = int(eval(input()))
s = eval(input())
r_cnt = s.count("R")
g_cnt = s.count("G")
b_cnt = s.count("B")
ans = r_cnt * g_cnt * b_cnt
for i in range(n): # s[i]
for d in range(n):
j = i + d # s[j] s[i]etcこれらは等間隔となるが
k = j + d # s[k] この時点でi!=j, j!=k, i!=k
if k >= n:
break # kが一番大きいが、n以上になることはない
if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
ans -= 1 # 等間隔でRGB揃っているものを引く
print(ans)
| false | 22.222222 | [
"-count = {\"R\": 0, \"G\": 0, \"B\": 0}",
"-for c in s:",
"- count[c] += 1",
"-r, g, b = list(count.values())",
"-ans = r * g * b",
"-for i in range(1, (n - 1) // 2 + 1): # 1から",
"- for rgb in zip(s, s[i:], s[i * 2 :]): # rgbに連続した三つのリストの要素を入れ込む",
"- if len(set(rgb)) == 3: # リストrgbをセットにまとめ、長さが",
"- ans -= 1",
"+r_cnt = s.count(\"R\")",
"+g_cnt = s.count(\"G\")",
"+b_cnt = s.count(\"B\")",
"+ans = r_cnt * g_cnt * b_cnt",
"+for i in range(n): # s[i]",
"+ for d in range(n):",
"+ j = i + d # s[j] s[i]etcこれらは等間隔となるが",
"+ k = j + d # s[k] この時点でi!=j, j!=k, i!=k",
"+ if k >= n:",
"+ break # kが一番大きいが、n以上になることはない",
"+ if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:",
"+ ans -= 1 # 等間隔でRGB揃っているものを引く"
]
| false | 0.038754 | 0.047264 | 0.819945 | [
"s714496235",
"s130843323"
]
|
u103902792 | p03295 | python | s026578427 | s393148452 | 444 | 379 | 17,468 | 18,204 | Accepted | Accepted | 14.64 | n,m = list(map(int,input().split()))
cut = []
for _ in range(m):
a,b = list(map(int,input().split()))
cut.append((a,b))
cut.sort()
b_min = cut[0][1]
count = 0
for a,b in cut[1:]:
if b_min > b:
b_min = b
continue
if b_min <= a:
count += 1
b_min = b
print((count+1))
| n,m = list(map(int,input().split()))
cut = []
for _ in range(m):
a,b = list(map(int,input().split()))
cut.append((a,b))
cut.sort(key = lambda x:x[1])
ex_b = cut[0][1]
count = 0
for a,b in cut[1:]:
if a >= ex_b:
count += 1
ex_b = b
print((count+1))
| 22 | 15 | 303 | 265 | n, m = list(map(int, input().split()))
cut = []
for _ in range(m):
a, b = list(map(int, input().split()))
cut.append((a, b))
cut.sort()
b_min = cut[0][1]
count = 0
for a, b in cut[1:]:
if b_min > b:
b_min = b
continue
if b_min <= a:
count += 1
b_min = b
print((count + 1))
| n, m = list(map(int, input().split()))
cut = []
for _ in range(m):
a, b = list(map(int, input().split()))
cut.append((a, b))
cut.sort(key=lambda x: x[1])
ex_b = cut[0][1]
count = 0
for a, b in cut[1:]:
if a >= ex_b:
count += 1
ex_b = b
print((count + 1))
| false | 31.818182 | [
"-cut.sort()",
"-b_min = cut[0][1]",
"+cut.sort(key=lambda x: x[1])",
"+ex_b = cut[0][1]",
"- if b_min > b:",
"- b_min = b",
"- continue",
"- if b_min <= a:",
"+ if a >= ex_b:",
"- b_min = b",
"+ ex_b = b"
]
| false | 0.0407 | 0.037349 | 1.089722 | [
"s026578427",
"s393148452"
]
|
u135847648 | p03339 | python | s281558813 | s119361640 | 499 | 355 | 43,852 | 4,084 | Accepted | Accepted | 28.86 | import collections
n = int(eval(input()))
s = eval(input())
dic = dict(collections.Counter(s))
#W,Eどちらかしか無い場合
if len(dic)==1:
print((0))
exit()
left_w = 0
right_e = dic["E"]
cnt = [[] for _ in range(n)]
#(左にあるWの数+右にあるEの数)の最小値が答え
ans = n
for i in range(n):
if s[i] == "W":
cnt[i] = [left_w,right_e]
ans = min(ans,left_w+right_e)
left_w += 1
elif s[i] == "E":
cnt[i] = [left_w,right_e]
ans = min(ans,left_w+right_e)
right_e -= 1
#(右にあるWの数+左にあるEの数)の最小値が答えの場合もあるか
left_e = 0
right_w = dic["W"]
for i in range(n-1,-1,-1):
if s[i] == "E":
ans = min(ans,left_e+right_w)
left_e += 1
elif s[i] == "W":
ans = min(ans,left_e + right_w)
right_w -= 1
print(ans)
| import collections
n = int(eval(input()))
s = eval(input())
dic = dict(collections.Counter(s))
#W,Eどちらかしか無い場合
if len(dic)==1:
print((0))
exit()
left_w = 0
right_e = dic["E"]
#(左にあるWの数+右にあるEの数)の最小値が答え
ans = n
for i in range(n):
if s[i] == "W":
ans = min(ans,left_w+right_e)
left_w += 1
elif s[i] == "E":
ans = min(ans,left_w+right_e)
right_e -= 1
#(右にあるWの数+左にあるEの数)の最小値が答えの場合もあるか
left_e = 0
right_w = dic["W"]
for i in range(n-1,-1,-1):
if s[i] == "E":
ans = min(ans,left_e+right_w)
left_e += 1
elif s[i] == "W":
ans = min(ans,left_e + right_w)
right_w -= 1
print(ans)
| 39 | 35 | 731 | 637 | import collections
n = int(eval(input()))
s = eval(input())
dic = dict(collections.Counter(s))
# W,Eどちらかしか無い場合
if len(dic) == 1:
print((0))
exit()
left_w = 0
right_e = dic["E"]
cnt = [[] for _ in range(n)]
# (左にあるWの数+右にあるEの数)の最小値が答え
ans = n
for i in range(n):
if s[i] == "W":
cnt[i] = [left_w, right_e]
ans = min(ans, left_w + right_e)
left_w += 1
elif s[i] == "E":
cnt[i] = [left_w, right_e]
ans = min(ans, left_w + right_e)
right_e -= 1
# (右にあるWの数+左にあるEの数)の最小値が答えの場合もあるか
left_e = 0
right_w = dic["W"]
for i in range(n - 1, -1, -1):
if s[i] == "E":
ans = min(ans, left_e + right_w)
left_e += 1
elif s[i] == "W":
ans = min(ans, left_e + right_w)
right_w -= 1
print(ans)
| import collections
n = int(eval(input()))
s = eval(input())
dic = dict(collections.Counter(s))
# W,Eどちらかしか無い場合
if len(dic) == 1:
print((0))
exit()
left_w = 0
right_e = dic["E"]
# (左にあるWの数+右にあるEの数)の最小値が答え
ans = n
for i in range(n):
if s[i] == "W":
ans = min(ans, left_w + right_e)
left_w += 1
elif s[i] == "E":
ans = min(ans, left_w + right_e)
right_e -= 1
# (右にあるWの数+左にあるEの数)の最小値が答えの場合もあるか
left_e = 0
right_w = dic["W"]
for i in range(n - 1, -1, -1):
if s[i] == "E":
ans = min(ans, left_e + right_w)
left_e += 1
elif s[i] == "W":
ans = min(ans, left_e + right_w)
right_w -= 1
print(ans)
| false | 10.25641 | [
"-cnt = [[] for _ in range(n)]",
"- cnt[i] = [left_w, right_e]",
"- cnt[i] = [left_w, right_e]"
]
| false | 0.045946 | 0.045664 | 1.00618 | [
"s281558813",
"s119361640"
]
|
u131811591 | p02329 | python | s912345391 | s647350387 | 1,120 | 1,020 | 179,080 | 179,044 | Accepted | Accepted | 8.93 | import sys
from collections import defaultdict
if __name__ == '__main__':
n, v = list(map(int, sys.stdin.readline().split()))
a = list(map(int, sys.stdin.readline().split()))
b = list(map(int, sys.stdin.readline().split()))
c = list(map(int, sys.stdin.readline().split()))
d = list(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1+val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v-val1-val2]
print(ans)
| import sys
from collections import defaultdict
if __name__ == '__main__':
n, v = list(map(int, sys.stdin.readline().split()))
a = tuple(map(int, sys.stdin.readline().split()))
b = tuple(map(int, sys.stdin.readline().split()))
c = tuple(map(int, sys.stdin.readline().split()))
d = tuple(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1+val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v-val1-val2]
print(ans)
| 20 | 20 | 571 | 575 | import sys
from collections import defaultdict
if __name__ == "__main__":
n, v = list(map(int, sys.stdin.readline().split()))
a = list(map(int, sys.stdin.readline().split()))
b = list(map(int, sys.stdin.readline().split()))
c = list(map(int, sys.stdin.readline().split()))
d = list(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1 + val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v - val1 - val2]
print(ans)
| import sys
from collections import defaultdict
if __name__ == "__main__":
n, v = list(map(int, sys.stdin.readline().split()))
a = tuple(map(int, sys.stdin.readline().split()))
b = tuple(map(int, sys.stdin.readline().split()))
c = tuple(map(int, sys.stdin.readline().split()))
d = tuple(map(int, sys.stdin.readline().split()))
mp = defaultdict(int)
ls = []
for val1 in c:
for val2 in d:
mp[val1 + val2] += 1
ans = 0
for val1 in a:
for val2 in b:
ans += mp[v - val1 - val2]
print(ans)
| false | 0 | [
"- a = list(map(int, sys.stdin.readline().split()))",
"- b = list(map(int, sys.stdin.readline().split()))",
"- c = list(map(int, sys.stdin.readline().split()))",
"- d = list(map(int, sys.stdin.readline().split()))",
"+ a = tuple(map(int, sys.stdin.readline().split()))",
"+ b = tuple(map(int, sys.stdin.readline().split()))",
"+ c = tuple(map(int, sys.stdin.readline().split()))",
"+ d = tuple(map(int, sys.stdin.readline().split()))"
]
| false | 0.04179 | 0.086562 | 0.482776 | [
"s912345391",
"s647350387"
]
|
u119148115 | p03311 | python | s779472868 | s365607907 | 142 | 130 | 94,456 | 104,448 | Accepted | Accepted | 8.45 | import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
N = I()
A = LI()
for i in range(N):
A[i] -= i+1
A.sort()
def f(x):
return sum(abs(A[i]-x) for i in range(N))
print((f((A[(N-1)//2]+A[N//2])//2)))
# 中間値
| 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()) #空白なし
N = I()
A = LI()
for i in range(N):
A[i] -= i+1
A.sort()
x = A[N//2]
y = A[(N-1)//2]
z = (x+y)//2
print((sum(abs(A[i]-z) for i in range(N))))
| 18 | 23 | 320 | 648 | import sys
def I():
return int(sys.stdin.readline().rstrip())
def LI():
return list(map(int, sys.stdin.readline().rstrip().split())) # 空白あり
N = I()
A = LI()
for i in range(N):
A[i] -= i + 1
A.sort()
def f(x):
return sum(abs(A[i] - x) for i in range(N))
print((f((A[(N - 1) // 2] + A[N // 2]) // 2)))
# 中間値
| 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()) # 空白なし
N = I()
A = LI()
for i in range(N):
A[i] -= i + 1
A.sort()
x = A[N // 2]
y = A[(N - 1) // 2]
z = (x + y) // 2
print((sum(abs(A[i] - z) for i in range(N))))
| false | 21.73913 | [
"+",
"+sys.setrecursionlimit(10**7)",
"+def MI():",
"+ 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()) # 空白なし",
"-",
"-",
"-def f(x):",
"- return sum(abs(A[i] - x) for i in range(N))",
"-",
"-",
"-print((f((A[(N - 1) // 2] + A[N // 2]) // 2)))",
"-# 中間値",
"+x = A[N // 2]",
"+y = A[(N - 1) // 2]",
"+z = (x + y) // 2",
"+print((sum(abs(A[i] - z) for i in range(N))))"
]
| false | 0.086456 | 0.087471 | 0.988396 | [
"s779472868",
"s365607907"
]
|
u919633157 | p03107 | python | s228176656 | s662821856 | 34 | 18 | 3,188 | 3,188 | Accepted | Accepted | 47.06 | # 2019/07/25
s=eval(input())
cnt=0
for e in s:
if e=='1':cnt+=1
else:cnt-=1
print((len(s)-abs(cnt))) | s=eval(input())
z=s.count('0')
o=s.count('1')
print((len(s)-abs(z-o))) | 9 | 4 | 110 | 65 | # 2019/07/25
s = eval(input())
cnt = 0
for e in s:
if e == "1":
cnt += 1
else:
cnt -= 1
print((len(s) - abs(cnt)))
| s = eval(input())
z = s.count("0")
o = s.count("1")
print((len(s) - abs(z - o)))
| false | 55.555556 | [
"-# 2019/07/25",
"-cnt = 0",
"-for e in s:",
"- if e == \"1\":",
"- cnt += 1",
"- else:",
"- cnt -= 1",
"-print((len(s) - abs(cnt)))",
"+z = s.count(\"0\")",
"+o = s.count(\"1\")",
"+print((len(s) - abs(z - o)))"
]
| false | 0.04462 | 0.043597 | 1.023467 | [
"s228176656",
"s662821856"
]
|
u546285759 | p00011 | python | s660766099 | s257798072 | 30 | 20 | 7,604 | 5,600 | Accepted | Accepted | 33.33 | w = int(input())
n = int(input())
am = [i for i in range(w+1)]
for _ in range(n):
a, b = map(int, input().split(','))
am[a], am[b] = am[b], am[a]
print(*am[1:], sep="\n")
| w = int(input())
n = int(input())
kuji = [i+1 for i in range(w)]
for _ in range(n):
a, b = map(int, input().split(','))
kuji[a-1], kuji[b-1] = kuji[b-1], kuji[a-1]
print(*kuji, sep="\n")
| 7 | 8 | 184 | 203 | w = int(input())
n = int(input())
am = [i for i in range(w + 1)]
for _ in range(n):
a, b = map(int, input().split(","))
am[a], am[b] = am[b], am[a]
print(*am[1:], sep="\n")
| w = int(input())
n = int(input())
kuji = [i + 1 for i in range(w)]
for _ in range(n):
a, b = map(int, input().split(","))
kuji[a - 1], kuji[b - 1] = kuji[b - 1], kuji[a - 1]
print(*kuji, sep="\n")
| false | 12.5 | [
"-am = [i for i in range(w + 1)]",
"+kuji = [i + 1 for i in range(w)]",
"- am[a], am[b] = am[b], am[a]",
"-print(*am[1:], sep=\"\\n\")",
"+ kuji[a - 1], kuji[b - 1] = kuji[b - 1], kuji[a - 1]",
"+print(*kuji, sep=\"\\n\")"
]
| false | 0.153163 | 0.056361 | 2.717528 | [
"s660766099",
"s257798072"
]
|
u436807165 | p02388 | python | s322614691 | s723950792 | 30 | 10 | 6,424 | 6,424 | Accepted | Accepted | 66.67 | input = input()
print(int(input) ** 3) | x = eval(input())
print(x**3) | 2 | 2 | 42 | 23 | input = input()
print(int(input) ** 3)
| x = eval(input())
print(x**3)
| false | 0 | [
"-input = input()",
"-print(int(input) ** 3)",
"+x = eval(input())",
"+print(x**3)"
]
| false | 0.078395 | 0.045304 | 1.730416 | [
"s322614691",
"s723950792"
]
|
u670180528 | p03295 | python | s691112087 | s041176321 | 141 | 127 | 25,132 | 25,132 | Accepted | Accepted | 9.93 | n,m,*t=list(map(int,open(0).read().split()));r=[n+1]*(n+1)
for a,b in zip(*[iter(t)]*2):
r[a]=min(r[a],b)
a=0;cur=n+1
for i in range(n+1):
cur=min(cur, r[i])
if i==cur:
cur=r[i]
a+=1
print(a) | def solve():
n,_,*t=list(map(int,open(0).read().split()));r=[n+1]*(n+1)
for a,b in zip(*[iter(t)]*2):
r[a]=min(r[a],b)
a=0;cur=n+1
for i in range(n+1):
cur=min(cur, r[i])
if i==cur:
#追いついた
cur=r[i]
a+=1
print(a)
if __name__=="__main__":
solve() | 10 | 14 | 201 | 272 | n, m, *t = list(map(int, open(0).read().split()))
r = [n + 1] * (n + 1)
for a, b in zip(*[iter(t)] * 2):
r[a] = min(r[a], b)
a = 0
cur = n + 1
for i in range(n + 1):
cur = min(cur, r[i])
if i == cur:
cur = r[i]
a += 1
print(a)
| def solve():
n, _, *t = list(map(int, open(0).read().split()))
r = [n + 1] * (n + 1)
for a, b in zip(*[iter(t)] * 2):
r[a] = min(r[a], b)
a = 0
cur = n + 1
for i in range(n + 1):
cur = min(cur, r[i])
if i == cur:
# 追いついた
cur = r[i]
a += 1
print(a)
if __name__ == "__main__":
solve()
| false | 28.571429 | [
"-n, m, *t = list(map(int, open(0).read().split()))",
"-r = [n + 1] * (n + 1)",
"-for a, b in zip(*[iter(t)] * 2):",
"- r[a] = min(r[a], b)",
"-a = 0",
"-cur = n + 1",
"-for i in range(n + 1):",
"- cur = min(cur, r[i])",
"- if i == cur:",
"- cur = r[i]",
"- a += 1",
"-print(a)",
"+def solve():",
"+ n, _, *t = list(map(int, open(0).read().split()))",
"+ r = [n + 1] * (n + 1)",
"+ for a, b in zip(*[iter(t)] * 2):",
"+ r[a] = min(r[a], b)",
"+ a = 0",
"+ cur = n + 1",
"+ for i in range(n + 1):",
"+ cur = min(cur, r[i])",
"+ if i == cur:",
"+ # 追いついた",
"+ cur = r[i]",
"+ a += 1",
"+ print(a)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
]
| false | 0.035886 | 0.041625 | 0.862128 | [
"s691112087",
"s041176321"
]
|
u952708174 | p03472 | python | s739247466 | s974530419 | 615 | 360 | 36,624 | 22,284 | Accepted | Accepted | 41.46 | def d_Katana_Thrower(N, H, S):
import numpy
import math
swing = numpy.asarray([x[0] for x in S])
throw = numpy.asarray([x[1] for x in S])
swing_max = numpy.max(swing)
throw_t = throw[throw >= swing_max]
throw_t = sorted(throw_t, reverse=True)
hp = H
ans = 0
for d in throw_t:
if hp <= 0:
break
hp -= d
ans += 1
if hp > 0:
ans += math.ceil(hp / swing_max)
return ans
N,H=[int(i) for i in input().split()]
S=[[int(i) for i in input().split()] for j in range(N)]
print((d_Katana_Thrower(N, H, S))) | def d_katana_thrower(N, H, Swords):
import math
# 振ったとき最もダメージが大きい刀以上に投げたときのダメージが大きな刀
# について、ダメージが大きなものから投げていく。そのダメージの総和が
# 敵の体力より大きければ投げて倒せばいいし、足りなければ刀を降って倒せばいい。
# ただし、振る刀の投げダメージが振るより高ければ、投げる前に振らなければならないが、
# 計算時には「投げてから振る」とみなしても問題ない。
swing_damage_max = max([s[0] for s in Swords])
throw_higher_than_swing = [s[1] for s in Swords if s[1] >= swing_damage_max]
throw_higher_than_swing.sort(reverse=True)
minimum_moving = 0
for damage in throw_higher_than_swing:
if H <= 0: # 刀を投げている途中で敵を倒したら終わり
H = 0
break
H -= damage
minimum_moving += 1
minimum_moving += math.ceil(H / swing_damage_max)
return minimum_moving
N, H = [int(i) for i in input().split()]
Swords = [[int(i) for i in input().split()] for j in range(N)]
print((d_katana_thrower(N, H, Swords))) | 25 | 24 | 614 | 875 | def d_Katana_Thrower(N, H, S):
import numpy
import math
swing = numpy.asarray([x[0] for x in S])
throw = numpy.asarray([x[1] for x in S])
swing_max = numpy.max(swing)
throw_t = throw[throw >= swing_max]
throw_t = sorted(throw_t, reverse=True)
hp = H
ans = 0
for d in throw_t:
if hp <= 0:
break
hp -= d
ans += 1
if hp > 0:
ans += math.ceil(hp / swing_max)
return ans
N, H = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(N)]
print((d_Katana_Thrower(N, H, S)))
| def d_katana_thrower(N, H, Swords):
import math
# 振ったとき最もダメージが大きい刀以上に投げたときのダメージが大きな刀
# について、ダメージが大きなものから投げていく。そのダメージの総和が
# 敵の体力より大きければ投げて倒せばいいし、足りなければ刀を降って倒せばいい。
# ただし、振る刀の投げダメージが振るより高ければ、投げる前に振らなければならないが、
# 計算時には「投げてから振る」とみなしても問題ない。
swing_damage_max = max([s[0] for s in Swords])
throw_higher_than_swing = [s[1] for s in Swords if s[1] >= swing_damage_max]
throw_higher_than_swing.sort(reverse=True)
minimum_moving = 0
for damage in throw_higher_than_swing:
if H <= 0: # 刀を投げている途中で敵を倒したら終わり
H = 0
break
H -= damage
minimum_moving += 1
minimum_moving += math.ceil(H / swing_damage_max)
return minimum_moving
N, H = [int(i) for i in input().split()]
Swords = [[int(i) for i in input().split()] for j in range(N)]
print((d_katana_thrower(N, H, Swords)))
| false | 4 | [
"-def d_Katana_Thrower(N, H, S):",
"- import numpy",
"+def d_katana_thrower(N, H, Swords):",
"- swing = numpy.asarray([x[0] for x in S])",
"- throw = numpy.asarray([x[1] for x in S])",
"- swing_max = numpy.max(swing)",
"- throw_t = throw[throw >= swing_max]",
"- throw_t = sorted(throw_t, reverse=True)",
"- hp = H",
"- ans = 0",
"- for d in throw_t:",
"- if hp <= 0:",
"+ # 振ったとき最もダメージが大きい刀以上に投げたときのダメージが大きな刀",
"+ # について、ダメージが大きなものから投げていく。そのダメージの総和が",
"+ # 敵の体力より大きければ投げて倒せばいいし、足りなければ刀を降って倒せばいい。",
"+ # ただし、振る刀の投げダメージが振るより高ければ、投げる前に振らなければならないが、",
"+ # 計算時には「投げてから振る」とみなしても問題ない。",
"+ swing_damage_max = max([s[0] for s in Swords])",
"+ throw_higher_than_swing = [s[1] for s in Swords if s[1] >= swing_damage_max]",
"+ throw_higher_than_swing.sort(reverse=True)",
"+ minimum_moving = 0",
"+ for damage in throw_higher_than_swing:",
"+ if H <= 0: # 刀を投げている途中で敵を倒したら終わり",
"+ H = 0",
"- hp -= d",
"- ans += 1",
"- if hp > 0:",
"- ans += math.ceil(hp / swing_max)",
"- return ans",
"+ H -= damage",
"+ minimum_moving += 1",
"+ minimum_moving += math.ceil(H / swing_damage_max)",
"+ return minimum_moving",
"-S = [[int(i) for i in input().split()] for j in range(N)]",
"-print((d_Katana_Thrower(N, H, S)))",
"+Swords = [[int(i) for i in input().split()] for j in range(N)]",
"+print((d_katana_thrower(N, H, Swords)))"
]
| false | 0.241095 | 0.045371 | 5.313838 | [
"s739247466",
"s974530419"
]
|
u620084012 | p02835 | python | s760035256 | s741996088 | 205 | 17 | 38,384 | 2,940 | Accepted | Accepted | 91.71 | A, B, C = list(map(int,input().split()))
if A+B+C >= 22:
print("bust")
else:
print("win")
| import sys
def input():
return sys.stdin.readline()[:-1]
def main():
# N = int(input())
A, B, C = list(map(int,input().split()))
# S = input()
print(("bust" if (A+B+C) >= 22 else "win"))
if __name__ == '__main__':
main()
| 5 | 10 | 96 | 244 | A, B, C = list(map(int, input().split()))
if A + B + C >= 22:
print("bust")
else:
print("win")
| import sys
def input():
return sys.stdin.readline()[:-1]
def main():
# N = int(input())
A, B, C = list(map(int, input().split()))
# S = input()
print(("bust" if (A + B + C) >= 22 else "win"))
if __name__ == "__main__":
main()
| false | 50 | [
"-A, B, C = list(map(int, input().split()))",
"-if A + B + C >= 22:",
"- print(\"bust\")",
"-else:",
"- print(\"win\")",
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline()[:-1]",
"+",
"+",
"+def main():",
"+ # N = int(input())",
"+ A, B, C = list(map(int, input().split()))",
"+ # S = input()",
"+ print((\"bust\" if (A + B + C) >= 22 else \"win\"))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.066831 | 0.037386 | 1.787564 | [
"s760035256",
"s741996088"
]
|
u746419473 | p02813 | python | s993618348 | s037488834 | 29 | 26 | 8,052 | 8,052 | Accepted | Accepted | 10.34 | import itertools
import bisect
n = int(eval(input()))
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
*per, = itertools.permutations(list(range(1, n+1)))
a = bisect.bisect_right(per, p)
b = bisect.bisect_right(per, q)
print((abs(a-b)))
| import bisect
import itertools
n = int(eval(input()))
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
*perm, = itertools.permutations(list(range(1, n+1)), n)
a = bisect.bisect_right(perm, p)
b = bisect.bisect_right(perm, q)
print((abs(a-b)))
| 12 | 10 | 262 | 270 | import itertools
import bisect
n = int(eval(input()))
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
(*per,) = itertools.permutations(list(range(1, n + 1)))
a = bisect.bisect_right(per, p)
b = bisect.bisect_right(per, q)
print((abs(a - b)))
| import bisect
import itertools
n = int(eval(input()))
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
(*perm,) = itertools.permutations(list(range(1, n + 1)), n)
a = bisect.bisect_right(perm, p)
b = bisect.bisect_right(perm, q)
print((abs(a - b)))
| false | 16.666667 | [
"+import bisect",
"-import bisect",
"-(*per,) = itertools.permutations(list(range(1, n + 1)))",
"-a = bisect.bisect_right(per, p)",
"-b = bisect.bisect_right(per, q)",
"+(*perm,) = itertools.permutations(list(range(1, n + 1)), n)",
"+a = bisect.bisect_right(perm, p)",
"+b = bisect.bisect_right(perm, q)"
]
| false | 0.047882 | 0.090238 | 0.530622 | [
"s993618348",
"s037488834"
]
|
u513081876 | p03252 | python | s325974456 | s537079097 | 258 | 121 | 6,832 | 3,888 | Accepted | Accepted | 53.1 | S = eval(input())
T = eval(input())
used = []
res = []
for i in range(len(S)):
if S[i] not in used:
used.append(S[i])
res.append(used.index(S[i]))
#print(used)
#print(res)
used = []
ret = []
for i in range(len(T)):
if T[i] not in used:
used.append(T[i])
ret.append(used.index(T[i]))
if res == ret:
print('Yes')
else:
print('No') | import sys
from collections import defaultdict
S = eval(input())
T = eval(input())
L = len(S)
dcts = defaultdict(int)
dctt = defaultdict(int)
for i in range(L):
s = S[i]
t = T[i]
if dcts[s] == 0:
dcts[s] = t
else:
if dcts[s] != t:
print('No')
sys.exit()
if dctt[t] == 0:
dctt[t] = s
else:
if dctt[t] != s:
print('No')
sys.exit()
print('Yes') | 25 | 25 | 386 | 459 | S = eval(input())
T = eval(input())
used = []
res = []
for i in range(len(S)):
if S[i] not in used:
used.append(S[i])
res.append(used.index(S[i]))
# print(used)
# print(res)
used = []
ret = []
for i in range(len(T)):
if T[i] not in used:
used.append(T[i])
ret.append(used.index(T[i]))
if res == ret:
print("Yes")
else:
print("No")
| import sys
from collections import defaultdict
S = eval(input())
T = eval(input())
L = len(S)
dcts = defaultdict(int)
dctt = defaultdict(int)
for i in range(L):
s = S[i]
t = T[i]
if dcts[s] == 0:
dcts[s] = t
else:
if dcts[s] != t:
print("No")
sys.exit()
if dctt[t] == 0:
dctt[t] = s
else:
if dctt[t] != s:
print("No")
sys.exit()
print("Yes")
| false | 0 | [
"+import sys",
"+from collections import defaultdict",
"+",
"-used = []",
"-res = []",
"-for i in range(len(S)):",
"- if S[i] not in used:",
"- used.append(S[i])",
"- res.append(used.index(S[i]))",
"-# print(used)",
"-# print(res)",
"-used = []",
"-ret = []",
"-for i in range(len(T)):",
"- if T[i] not in used:",
"- used.append(T[i])",
"- ret.append(used.index(T[i]))",
"-if res == ret:",
"- print(\"Yes\")",
"-else:",
"- print(\"No\")",
"+L = len(S)",
"+dcts = defaultdict(int)",
"+dctt = defaultdict(int)",
"+for i in range(L):",
"+ s = S[i]",
"+ t = T[i]",
"+ if dcts[s] == 0:",
"+ dcts[s] = t",
"+ else:",
"+ if dcts[s] != t:",
"+ print(\"No\")",
"+ sys.exit()",
"+ if dctt[t] == 0:",
"+ dctt[t] = s",
"+ else:",
"+ if dctt[t] != s:",
"+ print(\"No\")",
"+ sys.exit()",
"+print(\"Yes\")"
]
| false | 0.042795 | 0.043999 | 0.972618 | [
"s325974456",
"s537079097"
]
|
u506549878 | p03835 | python | s211252062 | s207832943 | 1,476 | 1,358 | 2,940 | 2,940 | Accepted | Accepted | 7.99 | k, s = list(map(int, input().split()))
flg = 0
for x in range(k+1):
for y in range(k+1):
z = s-x-y
if 0<= z <= k:
flg += 1
print(flg) | k, s =list(map(int,input().split()))
cnt = 0
for i in range(k+1):
for j in range(k+1):
if 0<=s-i-j<=k:
cnt += 1
print(cnt) | 8 | 7 | 178 | 152 | k, s = list(map(int, input().split()))
flg = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - x - y
if 0 <= z <= k:
flg += 1
print(flg)
| k, s = list(map(int, input().split()))
cnt = 0
for i in range(k + 1):
for j in range(k + 1):
if 0 <= s - i - j <= k:
cnt += 1
print(cnt)
| false | 12.5 | [
"-flg = 0",
"-for x in range(k + 1):",
"- for y in range(k + 1):",
"- z = s - x - y",
"- if 0 <= z <= k:",
"- flg += 1",
"-print(flg)",
"+cnt = 0",
"+for i in range(k + 1):",
"+ for j in range(k + 1):",
"+ if 0 <= s - i - j <= k:",
"+ cnt += 1",
"+print(cnt)"
]
| false | 0.044741 | 0.110405 | 0.405244 | [
"s211252062",
"s207832943"
]
|
u914797917 | p03814 | python | s117393340 | s428496228 | 36 | 18 | 3,512 | 3,516 | Accepted | Accepted | 50 | S=eval(input())
for i in range(len(S)):
if S[i]=='A':
S=S[i:]
break
for i in range(len(S)-1,0,-1):
if S[i]=='Z':
S=S[:i+1]
break
print((len(S))) | S=eval(input())
S=S[S.find('A'):S.rfind('Z')+1]
print((len(S))) | 13 | 3 | 175 | 57 | S = eval(input())
for i in range(len(S)):
if S[i] == "A":
S = S[i:]
break
for i in range(len(S) - 1, 0, -1):
if S[i] == "Z":
S = S[: i + 1]
break
print((len(S)))
| S = eval(input())
S = S[S.find("A") : S.rfind("Z") + 1]
print((len(S)))
| false | 76.923077 | [
"-for i in range(len(S)):",
"- if S[i] == \"A\":",
"- S = S[i:]",
"- break",
"-for i in range(len(S) - 1, 0, -1):",
"- if S[i] == \"Z\":",
"- S = S[: i + 1]",
"- break",
"+S = S[S.find(\"A\") : S.rfind(\"Z\") + 1]"
]
| false | 0.034903 | 0.036724 | 0.950412 | [
"s117393340",
"s428496228"
]
|
u346812984 | p02939 | python | s727939591 | s793575356 | 435 | 335 | 22,064 | 19,108 | Accepted | Accepted | 22.99 | S = list(eval(input()))
N = len(S)
# n文字まで見て最後が1文字か2文字化
dp_1 = [0] * N
dp_2 = [0] * N
dp_1[0] = 1
dp_2[1] = 1
if S[0] != S[1]:
dp_1[1] = 2
for i, s in enumerate(S[2:], 2):
# dp_1
# 2 -> 1
tmp = dp_2[i - 1] + 1
# 1 -> 1
if S[i - 1] != S[i]:
tmp = max(tmp, dp_1[i - 1] + 1)
dp_1[i] = tmp
# dp_2
# 1->2
tmp = dp_1[i - 2] + 1
# 2->2
if S[i - 3 : i - 1] != S[i - 1 : i + 1]:
tmp = max(tmp, dp_2[i - 2] + 1)
dp_2[i] = tmp
print((max(dp_1[-1], dp_2[-1])))
| import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
S = eval(input())
N = len(S)
# n文字まで見て最後が1文字か2文字か
dp_1 = [0] * N
dp_2 = [0] * N
dp_1[0] = 1
dp_2[1] = 1
if S[0] != S[1]:
dp_1[1] = 2
for i in range(2, N):
# 2 -> 1
dp_1[i] = max(dp_2[i - 1] + 1, dp_1[i])
# 2 -> 2
if S[i - 2 : i] != S[i : i + 2]:
dp_2[i] = max(dp_2[i - 2] + 1, dp_2[i])
# 1 -> 2
dp_2[i] = max(dp_1[i - 2] + 1, dp_2[i])
# 1 -> 1
if S[i - 1] != S[i]:
dp_1[i] = max(dp_1[i - 1] + 1, dp_1[i])
ans = max(dp_1[-1], dp_2[-1])
print(ans)
if __name__ == "__main__":
main()
| 30 | 44 | 543 | 818 | S = list(eval(input()))
N = len(S)
# n文字まで見て最後が1文字か2文字化
dp_1 = [0] * N
dp_2 = [0] * N
dp_1[0] = 1
dp_2[1] = 1
if S[0] != S[1]:
dp_1[1] = 2
for i, s in enumerate(S[2:], 2):
# dp_1
# 2 -> 1
tmp = dp_2[i - 1] + 1
# 1 -> 1
if S[i - 1] != S[i]:
tmp = max(tmp, dp_1[i - 1] + 1)
dp_1[i] = tmp
# dp_2
# 1->2
tmp = dp_1[i - 2] + 1
# 2->2
if S[i - 3 : i - 1] != S[i - 1 : i + 1]:
tmp = max(tmp, dp_2[i - 2] + 1)
dp_2[i] = tmp
print((max(dp_1[-1], dp_2[-1])))
| import sys
sys.setrecursionlimit(10**6)
INF = float("inf")
MOD = 10**9 + 7
def input():
return sys.stdin.readline().strip()
def main():
S = eval(input())
N = len(S)
# n文字まで見て最後が1文字か2文字か
dp_1 = [0] * N
dp_2 = [0] * N
dp_1[0] = 1
dp_2[1] = 1
if S[0] != S[1]:
dp_1[1] = 2
for i in range(2, N):
# 2 -> 1
dp_1[i] = max(dp_2[i - 1] + 1, dp_1[i])
# 2 -> 2
if S[i - 2 : i] != S[i : i + 2]:
dp_2[i] = max(dp_2[i - 2] + 1, dp_2[i])
# 1 -> 2
dp_2[i] = max(dp_1[i - 2] + 1, dp_2[i])
# 1 -> 1
if S[i - 1] != S[i]:
dp_1[i] = max(dp_1[i - 1] + 1, dp_1[i])
ans = max(dp_1[-1], dp_2[-1])
print(ans)
if __name__ == "__main__":
main()
| false | 31.818182 | [
"-S = list(eval(input()))",
"-N = len(S)",
"-# n文字まで見て最後が1文字か2文字化",
"-dp_1 = [0] * N",
"-dp_2 = [0] * N",
"-dp_1[0] = 1",
"-dp_2[1] = 1",
"-if S[0] != S[1]:",
"- dp_1[1] = 2",
"-for i, s in enumerate(S[2:], 2):",
"- # dp_1",
"- # 2 -> 1",
"- tmp = dp_2[i - 1] + 1",
"- # 1 -> 1",
"- if S[i - 1] != S[i]:",
"- tmp = max(tmp, dp_1[i - 1] + 1)",
"- dp_1[i] = tmp",
"- # dp_2",
"- # 1->2",
"- tmp = dp_1[i - 2] + 1",
"- # 2->2",
"- if S[i - 3 : i - 1] != S[i - 1 : i + 1]:",
"- tmp = max(tmp, dp_2[i - 2] + 1)",
"- dp_2[i] = tmp",
"-print((max(dp_1[-1], dp_2[-1])))",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+INF = float(\"inf\")",
"+MOD = 10**9 + 7",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def main():",
"+ S = eval(input())",
"+ N = len(S)",
"+ # n文字まで見て最後が1文字か2文字か",
"+ dp_1 = [0] * N",
"+ dp_2 = [0] * N",
"+ dp_1[0] = 1",
"+ dp_2[1] = 1",
"+ if S[0] != S[1]:",
"+ dp_1[1] = 2",
"+ for i in range(2, N):",
"+ # 2 -> 1",
"+ dp_1[i] = max(dp_2[i - 1] + 1, dp_1[i])",
"+ # 2 -> 2",
"+ if S[i - 2 : i] != S[i : i + 2]:",
"+ dp_2[i] = max(dp_2[i - 2] + 1, dp_2[i])",
"+ # 1 -> 2",
"+ dp_2[i] = max(dp_1[i - 2] + 1, dp_2[i])",
"+ # 1 -> 1",
"+ if S[i - 1] != S[i]:",
"+ dp_1[i] = max(dp_1[i - 1] + 1, dp_1[i])",
"+ ans = max(dp_1[-1], dp_2[-1])",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.045595 | 0.085546 | 0.532995 | [
"s727939591",
"s793575356"
]
|
u498487134 | p02755 | python | s499349093 | s916222635 | 189 | 70 | 39,536 | 63,976 | Accepted | Accepted | 62.96 | import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
a,b=MI()
ans=-1
for i in range(10000):
aa=int(i*0.08)
bb=i//10
if a==aa and b==bb:
ans=i
break
print(ans)
main()
| import sys
input = sys.stdin.readline
def I(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
ans=-1
A,B=MI()
for i in range(10000):
a=int(i*0.08)
b=int(i*0.1)
if a==A and b==B:
ans=i
break
print(ans)
main()
| 20 | 24 | 386 | 415 | import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
mod = 10**9 + 7
a, b = MI()
ans = -1
for i in range(10000):
aa = int(i * 0.08)
bb = i // 10
if a == aa and b == bb:
ans = i
break
print(ans)
main()
| import sys
input = sys.stdin.readline
def I():
return int(eval(input()))
def MI():
return list(map(int, input().split()))
def LI():
return list(map(int, input().split()))
def main():
mod = 10**9 + 7
ans = -1
A, B = MI()
for i in range(10000):
a = int(i * 0.08)
b = int(i * 0.1)
if a == A and b == B:
ans = i
break
print(ans)
main()
| false | 16.666667 | [
"- a, b = MI()",
"+ A, B = MI()",
"- aa = int(i * 0.08)",
"- bb = i // 10",
"- if a == aa and b == bb:",
"+ a = int(i * 0.08)",
"+ b = int(i * 0.1)",
"+ if a == A and b == B:"
]
| false | 0.050121 | 0.145563 | 0.344325 | [
"s499349093",
"s916222635"
]
|
u562935282 | p03055 | python | s742596075 | s295555535 | 1,471 | 994 | 49,212 | 47,616 | Accepted | Accepted | 32.43 | from collections import deque
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
dist = [-1 for _ in range(N)]
dist[0] = 0
q = deque()
q.append(0)
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
# 探索終了後
# (v,d)=頂点0から最遠点の頂点番号v,頂点0からの距離d
dist = [-1 for _ in range(N)]
dist[v] = 0
q = deque()
q.append(v)
while q:
w = q.popleft()
d = dist[w]
for nw in [x for x in e[w] if dist[x] == -1]:
dist[nw] = d + 1
q.append(nw)
# 探索終了後
# (w,d)=頂点vから最遠点の頂点番号w,頂点vからの距離d
print(('Second' if d % 3 == 1 else 'First')) | from collections import deque
import sys
input = sys.stdin.readline
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
def bfs(i):
"""
:param i: bfsの始点, 0-indexed
:return: (v,d), iの最遠点vまでの距離d
"""
dist = [-1 for _ in range(N)]
dist[i] = 0
q = deque((i,))
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
return v, d
x, _ = bfs(0)
_, d = bfs(x)
print(('Second' if d % 3 == 1 else 'First'))
| 45 | 40 | 814 | 721 | from collections import deque
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
dist = [-1 for _ in range(N)]
dist[0] = 0
q = deque()
q.append(0)
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
# 探索終了後
# (v,d)=頂点0から最遠点の頂点番号v,頂点0からの距離d
dist = [-1 for _ in range(N)]
dist[v] = 0
q = deque()
q.append(v)
while q:
w = q.popleft()
d = dist[w]
for nw in [x for x in e[w] if dist[x] == -1]:
dist[nw] = d + 1
q.append(nw)
# 探索終了後
# (w,d)=頂点vから最遠点の頂点番号w,頂点vからの距離d
print(("Second" if d % 3 == 1 else "First"))
| from collections import deque
import sys
input = sys.stdin.readline
N = int(eval(input()))
e = [[] for _ in range(N)]
# 隣接リスト
for _ in range(N - 1):
a, b = list(map(int, input().split()))
a -= 1
b -= 1
e[a].append(b)
e[b].append(a)
# BFS*2で直径を求める
def bfs(i):
"""
:param i: bfsの始点, 0-indexed
:return: (v,d), iの最遠点vまでの距離d
"""
dist = [-1 for _ in range(N)]
dist[i] = 0
q = deque((i,))
while q:
v = q.popleft()
d = dist[v]
for nv in [x for x in e[v] if dist[x] == -1]:
dist[nv] = d + 1
q.append(nv)
return v, d
x, _ = bfs(0)
_, d = bfs(x)
print(("Second" if d % 3 == 1 else "First"))
| false | 11.111111 | [
"+import sys",
"+input = sys.stdin.readline",
"-dist = [-1 for _ in range(N)]",
"-dist[0] = 0",
"-q = deque()",
"-q.append(0)",
"-while q:",
"- v = q.popleft()",
"- d = dist[v]",
"- for nv in [x for x in e[v] if dist[x] == -1]:",
"- dist[nv] = d + 1",
"- q.append(nv)",
"-# 探索終了後",
"-# (v,d)=頂点0から最遠点の頂点番号v,頂点0からの距離d",
"-dist = [-1 for _ in range(N)]",
"-dist[v] = 0",
"-q = deque()",
"-q.append(v)",
"-while q:",
"- w = q.popleft()",
"- d = dist[w]",
"- for nw in [x for x in e[w] if dist[x] == -1]:",
"- dist[nw] = d + 1",
"- q.append(nw)",
"-# 探索終了後",
"-# (w,d)=頂点vから最遠点の頂点番号w,頂点vからの距離d",
"+def bfs(i):",
"+ \"\"\"",
"+ :param i: bfsの始点, 0-indexed",
"+ :return: (v,d), iの最遠点vまでの距離d",
"+ \"\"\"",
"+ dist = [-1 for _ in range(N)]",
"+ dist[i] = 0",
"+ q = deque((i,))",
"+ while q:",
"+ v = q.popleft()",
"+ d = dist[v]",
"+ for nv in [x for x in e[v] if dist[x] == -1]:",
"+ dist[nv] = d + 1",
"+ q.append(nv)",
"+ return v, d",
"+",
"+",
"+x, _ = bfs(0)",
"+_, d = bfs(x)"
]
| false | 0.040697 | 0.036312 | 1.12077 | [
"s742596075",
"s295555535"
]
|
u492605584 | p03164 | python | s107163941 | s667284909 | 1,125 | 1,021 | 310,808 | 308,296 | Accepted | Accepted | 9.24 | n,w=list(map(int, input().split()))
m=10**5+1
x=[list(map(int, input().split())) for i in range(n)]
dp=[[float('inf')]*m for i in range(n+1)]
dp[0][0]=0
for i in range(n):
for j in range(m):
if j>=x[i][1]:
dp[i+1][j]=min(dp[i][j],dp[i][j-x[i][1]]+x[i][0])
else:
dp[i+1][j]=dp[i][j]
ans=0
for i in range(m):
if dp[-1][i]<=w:ans=max(ans,i)
print(ans) | N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[float('inf')] * (V + 1) for i in range(N+1)]
dp[0][0] = 0
for i in range(N):
for j in range(V+1):
if j - L[i][1] >= 0:
dp[i+1][j] = min(dp[i][j], dp[i][j-L[i][1]] + L[i][0])
else:
dp[i+1][j] = dp[i][j]
ans = 0
for j in range(V+1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans) | 15 | 19 | 404 | 486 | n, w = list(map(int, input().split()))
m = 10**5 + 1
x = [list(map(int, input().split())) for i in range(n)]
dp = [[float("inf")] * m for i in range(n + 1)]
dp[0][0] = 0
for i in range(n):
for j in range(m):
if j >= x[i][1]:
dp[i + 1][j] = min(dp[i][j], dp[i][j - x[i][1]] + x[i][0])
else:
dp[i + 1][j] = dp[i][j]
ans = 0
for i in range(m):
if dp[-1][i] <= w:
ans = max(ans, i)
print(ans)
| N, W = list(map(int, input().split()))
L = [list(map(int, input().split())) for i in range(N)]
V = 0
for i in range(N):
V += L[i][1]
dp = [[float("inf")] * (V + 1) for i in range(N + 1)]
dp[0][0] = 0
for i in range(N):
for j in range(V + 1):
if j - L[i][1] >= 0:
dp[i + 1][j] = min(dp[i][j], dp[i][j - L[i][1]] + L[i][0])
else:
dp[i + 1][j] = dp[i][j]
ans = 0
for j in range(V + 1):
if W >= dp[-1][j]:
ans = max(ans, j)
print(ans)
| false | 21.052632 | [
"-n, w = list(map(int, input().split()))",
"-m = 10**5 + 1",
"-x = [list(map(int, input().split())) for i in range(n)]",
"-dp = [[float(\"inf\")] * m for i in range(n + 1)]",
"+N, W = list(map(int, input().split()))",
"+L = [list(map(int, input().split())) for i in range(N)]",
"+V = 0",
"+for i in range(N):",
"+ V += L[i][1]",
"+dp = [[float(\"inf\")] * (V + 1) for i in range(N + 1)]",
"-for i in range(n):",
"- for j in range(m):",
"- if j >= x[i][1]:",
"- dp[i + 1][j] = min(dp[i][j], dp[i][j - x[i][1]] + x[i][0])",
"+for i in range(N):",
"+ for j in range(V + 1):",
"+ if j - L[i][1] >= 0:",
"+ dp[i + 1][j] = min(dp[i][j], dp[i][j - L[i][1]] + L[i][0])",
"-for i in range(m):",
"- if dp[-1][i] <= w:",
"- ans = max(ans, i)",
"+for j in range(V + 1):",
"+ if W >= dp[-1][j]:",
"+ ans = max(ans, j)"
]
| false | 0.381087 | 0.060143 | 6.336334 | [
"s107163941",
"s667284909"
]
|
u970197315 | p02756 | python | s276083392 | s911388304 | 722 | 407 | 46,936 | 13,908 | Accepted | Accepted | 43.63 | # ABC158 D
from collections import deque
s=eval(input())
q=int(eval(input()))
l=[]
for i in range(q):
l.append(list(map(str,input().split())))
cnt=0
front_str=''
end_str=''
t_str=deque(s)
front_str=deque(front_str)
end_str=deque(end_str)
for ll in l:
if ll[0]=='1':
cnt+=1
elif ll[0]=='2':
if cnt%2==0:
if ll[1]=='1':
front_str.appendleft(ll[2])
elif ll[1]=='2':
end_str.append(ll[2])
elif cnt%2==1:
if ll[1]=='1':
end_str.append(ll[2])
elif ll[1]=='2':
front_str.appendleft(ll[2])
ans=list(front_str)+list(t_str)+list(end_str)
if cnt%2==0:
ans=''.join(ans)
else:
ans=ans[::-1]
ans=''.join(ans)
print(ans)
| s=eval(input())
q=int(eval(input()))
m=0
from collections import deque
s=deque(s)
for i in range(q):
l=list(map(str,input().split()))
if l[0]=="1":
m+=1
m%=2
else:
if m==0:
if l[1]=="1":
s.appendleft(l[2])
else:
s.append(l[2])
else:
if l[1]=="1":
s.append(l[2])
else:
s.appendleft(l[2])
s=list(s)
if m==1:
s=s[::-1]
print(("".join(s)))
| 40 | 26 | 799 | 428 | # ABC158 D
from collections import deque
s = eval(input())
q = int(eval(input()))
l = []
for i in range(q):
l.append(list(map(str, input().split())))
cnt = 0
front_str = ""
end_str = ""
t_str = deque(s)
front_str = deque(front_str)
end_str = deque(end_str)
for ll in l:
if ll[0] == "1":
cnt += 1
elif ll[0] == "2":
if cnt % 2 == 0:
if ll[1] == "1":
front_str.appendleft(ll[2])
elif ll[1] == "2":
end_str.append(ll[2])
elif cnt % 2 == 1:
if ll[1] == "1":
end_str.append(ll[2])
elif ll[1] == "2":
front_str.appendleft(ll[2])
ans = list(front_str) + list(t_str) + list(end_str)
if cnt % 2 == 0:
ans = "".join(ans)
else:
ans = ans[::-1]
ans = "".join(ans)
print(ans)
| s = eval(input())
q = int(eval(input()))
m = 0
from collections import deque
s = deque(s)
for i in range(q):
l = list(map(str, input().split()))
if l[0] == "1":
m += 1
m %= 2
else:
if m == 0:
if l[1] == "1":
s.appendleft(l[2])
else:
s.append(l[2])
else:
if l[1] == "1":
s.append(l[2])
else:
s.appendleft(l[2])
s = list(s)
if m == 1:
s = s[::-1]
print(("".join(s)))
| false | 35 | [
"-# ABC158 D",
"+s = eval(input())",
"+q = int(eval(input()))",
"+m = 0",
"-s = eval(input())",
"-q = int(eval(input()))",
"-l = []",
"+s = deque(s)",
"- l.append(list(map(str, input().split())))",
"-cnt = 0",
"-front_str = \"\"",
"-end_str = \"\"",
"-t_str = deque(s)",
"-front_str = deque(front_str)",
"-end_str = deque(end_str)",
"-for ll in l:",
"- if ll[0] == \"1\":",
"- cnt += 1",
"- elif ll[0] == \"2\":",
"- if cnt % 2 == 0:",
"- if ll[1] == \"1\":",
"- front_str.appendleft(ll[2])",
"- elif ll[1] == \"2\":",
"- end_str.append(ll[2])",
"- elif cnt % 2 == 1:",
"- if ll[1] == \"1\":",
"- end_str.append(ll[2])",
"- elif ll[1] == \"2\":",
"- front_str.appendleft(ll[2])",
"-ans = list(front_str) + list(t_str) + list(end_str)",
"-if cnt % 2 == 0:",
"- ans = \"\".join(ans)",
"-else:",
"- ans = ans[::-1]",
"- ans = \"\".join(ans)",
"-print(ans)",
"+ l = list(map(str, input().split()))",
"+ if l[0] == \"1\":",
"+ m += 1",
"+ m %= 2",
"+ else:",
"+ if m == 0:",
"+ if l[1] == \"1\":",
"+ s.appendleft(l[2])",
"+ else:",
"+ s.append(l[2])",
"+ else:",
"+ if l[1] == \"1\":",
"+ s.append(l[2])",
"+ else:",
"+ s.appendleft(l[2])",
"+s = list(s)",
"+if m == 1:",
"+ s = s[::-1]",
"+print((\"\".join(s)))"
]
| false | 0.038849 | 0.03821 | 1.016736 | [
"s276083392",
"s911388304"
]
|
u367130284 | p04039 | python | s833194681 | s908224081 | 123 | 87 | 2,940 | 3,864 | Accepted | Accepted | 29.27 | n,k,*a=open(0).read().split();n=int(n)
while any(s in set(a)for s in str(n)):n+=1
print(n) | n,_=input().split();s=set(list(eval(input())));n=int(n);print((n+[len(s&set(str(b)))for b in range(n,99999)].index(0))) | 3 | 1 | 92 | 111 | n, k, *a = open(0).read().split()
n = int(n)
while any(s in set(a) for s in str(n)):
n += 1
print(n)
| n, _ = input().split()
s = set(list(eval(input())))
n = int(n)
print((n + [len(s & set(str(b))) for b in range(n, 99999)].index(0)))
| false | 66.666667 | [
"-n, k, *a = open(0).read().split()",
"+n, _ = input().split()",
"+s = set(list(eval(input())))",
"-while any(s in set(a) for s in str(n)):",
"- n += 1",
"-print(n)",
"+print((n + [len(s & set(str(b))) for b in range(n, 99999)].index(0)))"
]
| false | 0.095253 | 0.036526 | 2.60782 | [
"s833194681",
"s908224081"
]
|
u585482323 | p03229 | python | s139938152 | s126509361 | 812 | 535 | 67,932 | 53,212 | Accepted | Accepted | 34.11 | #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
b = IR(n)
b.sort()
a = deque(b)
q = deque([a.pop()])
n -= 1
for i in range(n):
if i&1:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if abs(x-ai) < abs(y-ai):
q.append(ai)
else:
q.appendleft(ai)
ans = 0
for i in range(n):
ans += abs(q[i+1]-q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i&1:
ai = a.popleft()
else:
ai = a.pop()
x = q[0]
y = q[-1]
if abs(x-ai) < abs(y-ai):
q.append(ai)
else:
q.appendleft(ai)
ans2 = 0
for i in range(n):
ans2 += abs(q[i+1]-q[i])
a = deque(b)
q = deque([a.pop()])
for i in range(n):
if i&2:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if abs(x-ai) < abs(y-ai):
q.append(ai)
else:
q.appendleft(ai)
ans3 = 0
for i in range(n):
ans3 += abs(q[i+1]-q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i&2:
ai = a.popleft()
else:
ai = a.pop()
x = q[0]
y = q[-1]
if abs(x-ai) < abs(y-ai):
q.append(ai)
else:
q.appendleft(ai)
ans4 = 0
for i in range(n):
ans4 += abs(q[i+1]-q[i])
print((max(ans,ans2,ans3,ans4)))
return
#Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
b = IR(n)
b.sort()
a = deque(b)
q = deque([a.pop()])
n -= 1
for i in range(n):
if i&2:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if i&1:
q.append(ai)
else:
q.appendleft(ai)
ans = 0
for i in range(n):
ans += abs(q[i+1]-q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i&2:
ai = a.popleft()
else:
ai = a.pop()
if i&1:
q.append(ai)
else:
q.appendleft(ai)
ans2 = 0
for i in range(n):
ans2 += abs(q[i+1]-q[i])
print((max(ans,ans2)))
return
#Solve
if __name__ == "__main__":
solve()
| 103 | 69 | 2,353 | 1,524 | #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
b = IR(n)
b.sort()
a = deque(b)
q = deque([a.pop()])
n -= 1
for i in range(n):
if i & 1:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if abs(x - ai) < abs(y - ai):
q.append(ai)
else:
q.appendleft(ai)
ans = 0
for i in range(n):
ans += abs(q[i + 1] - q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i & 1:
ai = a.popleft()
else:
ai = a.pop()
x = q[0]
y = q[-1]
if abs(x - ai) < abs(y - ai):
q.append(ai)
else:
q.appendleft(ai)
ans2 = 0
for i in range(n):
ans2 += abs(q[i + 1] - q[i])
a = deque(b)
q = deque([a.pop()])
for i in range(n):
if i & 2:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if abs(x - ai) < abs(y - ai):
q.append(ai)
else:
q.appendleft(ai)
ans3 = 0
for i in range(n):
ans3 += abs(q[i + 1] - q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i & 2:
ai = a.popleft()
else:
ai = a.pop()
x = q[0]
y = q[-1]
if abs(x - ai) < abs(y - ai):
q.append(ai)
else:
q.appendleft(ai)
ans4 = 0
for i in range(n):
ans4 += abs(q[i + 1] - q[i])
print((max(ans, ans2, ans3, ans4)))
return
# Solve
if __name__ == "__main__":
solve()
| #!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
import sys
import math
import bisect
import random
def LI():
return [int(x) for x in sys.stdin.readline().split()]
def I():
return int(sys.stdin.readline())
def LS():
return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
b = IR(n)
b.sort()
a = deque(b)
q = deque([a.pop()])
n -= 1
for i in range(n):
if i & 2:
ai = a.pop()
else:
ai = a.popleft()
x = q[0]
y = q[-1]
if i & 1:
q.append(ai)
else:
q.appendleft(ai)
ans = 0
for i in range(n):
ans += abs(q[i + 1] - q[i])
a = deque(b)
q = deque([a.popleft()])
for i in range(n):
if i & 2:
ai = a.popleft()
else:
ai = a.pop()
if i & 1:
q.append(ai)
else:
q.appendleft(ai)
ans2 = 0
for i in range(n):
ans2 += abs(q[i + 1] - q[i])
print((max(ans, ans2)))
return
# Solve
if __name__ == "__main__":
solve()
| false | 33.009709 | [
"- if i & 1:",
"+ if i & 2:",
"- if abs(x - ai) < abs(y - ai):",
"+ if i & 1:",
"- if i & 1:",
"+ if i & 2:",
"- x = q[0]",
"- y = q[-1]",
"- if abs(x - ai) < abs(y - ai):",
"+ if i & 1:",
"- a = deque(b)",
"- q = deque([a.pop()])",
"- for i in range(n):",
"- if i & 2:",
"- ai = a.pop()",
"- else:",
"- ai = a.popleft()",
"- x = q[0]",
"- y = q[-1]",
"- if abs(x - ai) < abs(y - ai):",
"- q.append(ai)",
"- else:",
"- q.appendleft(ai)",
"- ans3 = 0",
"- for i in range(n):",
"- ans3 += abs(q[i + 1] - q[i])",
"- a = deque(b)",
"- q = deque([a.popleft()])",
"- for i in range(n):",
"- if i & 2:",
"- ai = a.popleft()",
"- else:",
"- ai = a.pop()",
"- x = q[0]",
"- y = q[-1]",
"- if abs(x - ai) < abs(y - ai):",
"- q.append(ai)",
"- else:",
"- q.appendleft(ai)",
"- ans4 = 0",
"- for i in range(n):",
"- ans4 += abs(q[i + 1] - q[i])",
"- print((max(ans, ans2, ans3, ans4)))",
"+ print((max(ans, ans2)))"
]
| false | 0.04951 | 0.085644 | 0.578093 | [
"s139938152",
"s126509361"
]
|
u094191970 | p03006 | python | s039276250 | s316611747 | 757 | 106 | 9,316 | 9,280 | Accepted | Accepted | 86 | from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n=int(eval(input()))
xy=[lnii() for i in range(n)]
xy.sort(key=lambda x:x[0])
ans=n
pq=[]
for i in range(n-1):
for j in range(i+1,n):
t_p=xy[j][0]-xy[i][0]
t_q=xy[j][1]-xy[i][1]
pq.append([t_p,t_q])
for p,q in pq:
cnt=0
# for x,y in xy:
# if [x+p,y+q] in xy:
# cnt+=1
for i in range(n):
for j in range(n):
if i==j:
continue
x1,y1=xy[i]
x2,y2=xy[j]
if (x2-x1)==p and (y2-y1)==q:
cnt+=1
ans=min(ans,n-cnt)
print(ans) | from sys import stdin
nii=lambda:list(map(int,stdin.readline().split()))
lnii=lambda:list(map(int,stdin.readline().split()))
n=int(eval(input()))
xy=[lnii() for i in range(n)]
xy.sort(key=lambda x:x[0])
pq=[]
for i in range(n-1):
for j in range(i+1,n):
t_p=xy[j][0]-xy[i][0]
t_q=xy[j][1]-xy[i][1]
pq.append([t_p,t_q])
ans=n
for p,q in pq:
cnt=0
for x,y in xy:
if [x+p,y+q] in xy:
cnt+=1
'''
for i in range(n):
for j in range(n):
if i==j:
continue
x1,y1=xy[i]
x2,y2=xy[j]
if (x2-x1)==p and (y2-y1)==q:
cnt+=1
'''
ans=min(ans,n-cnt)
print(ans) | 32 | 34 | 635 | 646 | from sys import stdin
nii = lambda: list(map(int, stdin.readline().split()))
lnii = lambda: list(map(int, stdin.readline().split()))
n = int(eval(input()))
xy = [lnii() for i in range(n)]
xy.sort(key=lambda x: x[0])
ans = n
pq = []
for i in range(n - 1):
for j in range(i + 1, n):
t_p = xy[j][0] - xy[i][0]
t_q = xy[j][1] - xy[i][1]
pq.append([t_p, t_q])
for p, q in pq:
cnt = 0
# for x,y in xy:
# if [x+p,y+q] in xy:
# cnt+=1
for i in range(n):
for j in range(n):
if i == j:
continue
x1, y1 = xy[i]
x2, y2 = xy[j]
if (x2 - x1) == p and (y2 - y1) == q:
cnt += 1
ans = min(ans, n - cnt)
print(ans)
| from sys import stdin
nii = lambda: list(map(int, stdin.readline().split()))
lnii = lambda: list(map(int, stdin.readline().split()))
n = int(eval(input()))
xy = [lnii() for i in range(n)]
xy.sort(key=lambda x: x[0])
pq = []
for i in range(n - 1):
for j in range(i + 1, n):
t_p = xy[j][0] - xy[i][0]
t_q = xy[j][1] - xy[i][1]
pq.append([t_p, t_q])
ans = n
for p, q in pq:
cnt = 0
for x, y in xy:
if [x + p, y + q] in xy:
cnt += 1
"""
for i in range(n):
for j in range(n):
if i==j:
continue
x1,y1=xy[i]
x2,y2=xy[j]
if (x2-x1)==p and (y2-y1)==q:
cnt+=1
"""
ans = min(ans, n - cnt)
print(ans)
| false | 5.882353 | [
"-ans = n",
"+ans = n",
"- # for x,y in xy:",
"- # if [x+p,y+q] in xy:",
"- # cnt+=1",
"- for i in range(n):",
"- for j in range(n):",
"- if i == j:",
"- continue",
"- x1, y1 = xy[i]",
"- x2, y2 = xy[j]",
"- if (x2 - x1) == p and (y2 - y1) == q:",
"- cnt += 1",
"+ for x, y in xy:",
"+ if [x + p, y + q] in xy:",
"+ cnt += 1",
"+ \"\"\"",
"+ for i in range(n):",
"+ for j in range(n):",
"+ if i==j:",
"+ continue",
"+ x1,y1=xy[i]",
"+ x2,y2=xy[j]",
"+ if (x2-x1)==p and (y2-y1)==q:",
"+ cnt+=1",
"+ \"\"\""
]
| false | 0.074264 | 0.072438 | 1.025213 | [
"s039276250",
"s316611747"
]
|
u380524497 | p03739 | python | s686549689 | s789813279 | 109 | 75 | 14,468 | 20,460 | Accepted | Accepted | 31.19 | n = int(eval(input()))
a_list = list(map(int, input().split()))
total = 0
count = 0
pos_or_neg = True # True = +, False = -
for a in a_list:
total += a
if pos_or_neg:
if total <= 0:
count += -total + 1
total += -total + 1
pos_or_neg = False
else:
if total >= 0:
count += total + 1
total -= total + 1
pos_or_neg = True
first_count = count
count = 0
total = 0
pos_or_neg = False
for a in a_list:
total += a
if pos_or_neg:
if total <= 0:
count += -total + 1
total += -total + 1
pos_or_neg = False
else:
if total >= 0:
count += total + 1
total -= total + 1
pos_or_neg = True
print((min(count, first_count))) | def main():
n = int(eval(input()))
A = list(map(int, input().split()))
ans1 = 0
total = 0
is_plus = True
for a in A:
total += a
if is_plus:
if total <= 0:
ans1 += -total + 1
total = 1
else:
if total >= 0:
ans1 += total + 1
total = -1
is_plus = not is_plus
ans2 = 0
total = 0
is_plus = False
for a in A:
total += a
if is_plus:
if total <= 0:
ans2 += -total + 1
total = 1
else:
if total >= 0:
ans2 += total + 1
total = -1
is_plus = not is_plus
print((min(ans1, ans2)))
if __name__ == "__main__":
main()
| 41 | 43 | 827 | 832 | n = int(eval(input()))
a_list = list(map(int, input().split()))
total = 0
count = 0
pos_or_neg = True # True = +, False = -
for a in a_list:
total += a
if pos_or_neg:
if total <= 0:
count += -total + 1
total += -total + 1
pos_or_neg = False
else:
if total >= 0:
count += total + 1
total -= total + 1
pos_or_neg = True
first_count = count
count = 0
total = 0
pos_or_neg = False
for a in a_list:
total += a
if pos_or_neg:
if total <= 0:
count += -total + 1
total += -total + 1
pos_or_neg = False
else:
if total >= 0:
count += total + 1
total -= total + 1
pos_or_neg = True
print((min(count, first_count)))
| def main():
n = int(eval(input()))
A = list(map(int, input().split()))
ans1 = 0
total = 0
is_plus = True
for a in A:
total += a
if is_plus:
if total <= 0:
ans1 += -total + 1
total = 1
else:
if total >= 0:
ans1 += total + 1
total = -1
is_plus = not is_plus
ans2 = 0
total = 0
is_plus = False
for a in A:
total += a
if is_plus:
if total <= 0:
ans2 += -total + 1
total = 1
else:
if total >= 0:
ans2 += total + 1
total = -1
is_plus = not is_plus
print((min(ans1, ans2)))
if __name__ == "__main__":
main()
| false | 4.651163 | [
"-n = int(eval(input()))",
"-a_list = list(map(int, input().split()))",
"-total = 0",
"-count = 0",
"-pos_or_neg = True # True = +, False = -",
"-for a in a_list:",
"- total += a",
"- if pos_or_neg:",
"- if total <= 0:",
"- count += -total + 1",
"- total += -total + 1",
"- pos_or_neg = False",
"- else:",
"- if total >= 0:",
"- count += total + 1",
"- total -= total + 1",
"- pos_or_neg = True",
"-first_count = count",
"-count = 0",
"-total = 0",
"-pos_or_neg = False",
"-for a in a_list:",
"- total += a",
"- if pos_or_neg:",
"- if total <= 0:",
"- count += -total + 1",
"- total += -total + 1",
"- pos_or_neg = False",
"- else:",
"- if total >= 0:",
"- count += total + 1",
"- total -= total + 1",
"- pos_or_neg = True",
"-print((min(count, first_count)))",
"+def main():",
"+ n = int(eval(input()))",
"+ A = list(map(int, input().split()))",
"+ ans1 = 0",
"+ total = 0",
"+ is_plus = True",
"+ for a in A:",
"+ total += a",
"+ if is_plus:",
"+ if total <= 0:",
"+ ans1 += -total + 1",
"+ total = 1",
"+ else:",
"+ if total >= 0:",
"+ ans1 += total + 1",
"+ total = -1",
"+ is_plus = not is_plus",
"+ ans2 = 0",
"+ total = 0",
"+ is_plus = False",
"+ for a in A:",
"+ total += a",
"+ if is_plus:",
"+ if total <= 0:",
"+ ans2 += -total + 1",
"+ total = 1",
"+ else:",
"+ if total >= 0:",
"+ ans2 += total + 1",
"+ total = -1",
"+ is_plus = not is_plus",
"+ print((min(ans1, ans2)))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.112768 | 0.1672 | 0.67445 | [
"s686549689",
"s789813279"
]
|
u624475441 | p03285 | python | s068024900 | s593785868 | 20 | 18 | 2,940 | 2,940 | Accepted | Accepted | 10 | N = int(eval(input()))
for i in range(101):
if N - 7 * i < 0:
break
if (N - 7 * i) % 4 == 0:
print('Yes')
exit()
print('No') | if int(eval(input())) in [1, 2, 3, 5, 6, 9, 10, 13, 17]:
print('No')
else:
print('Yes') | 8 | 4 | 157 | 92 | N = int(eval(input()))
for i in range(101):
if N - 7 * i < 0:
break
if (N - 7 * i) % 4 == 0:
print("Yes")
exit()
print("No")
| if int(eval(input())) in [1, 2, 3, 5, 6, 9, 10, 13, 17]:
print("No")
else:
print("Yes")
| false | 50 | [
"-N = int(eval(input()))",
"-for i in range(101):",
"- if N - 7 * i < 0:",
"- break",
"- if (N - 7 * i) % 4 == 0:",
"- print(\"Yes\")",
"- exit()",
"-print(\"No\")",
"+if int(eval(input())) in [1, 2, 3, 5, 6, 9, 10, 13, 17]:",
"+ print(\"No\")",
"+else:",
"+ print(\"Yes\")"
]
| false | 0.036091 | 0.038172 | 0.945486 | [
"s068024900",
"s593785868"
]
|
u731896389 | p02410 | python | s694941631 | s577138881 | 30 | 20 | 7,976 | 8,072 | Accepted | Accepted | 33.33 | n,m = list(map(int,input().split()))
A = []
b = []
for i in range(n):
A.append([int(j) for j in input().split()])
for i in range(m):
b.append(int(eval(input())))
for i in range(n):
sum = 0
for j in range(m):
sum += A[i][j]*b[j]
print(sum) | n,m=list(map(int,input().split()))
A =[[int(i) for i in input().split()] for j in range(n)]
b = []
for i in range(m):
b.append(int(eval(input())))
ans = [0 for i in range(n)]
for i in range(n):
for j in range(m):
ans[i] += A[i][j]*b[j]
for i in ans:
print(i) | 12 | 11 | 265 | 276 | n, m = list(map(int, input().split()))
A = []
b = []
for i in range(n):
A.append([int(j) for j in input().split()])
for i in range(m):
b.append(int(eval(input())))
for i in range(n):
sum = 0
for j in range(m):
sum += A[i][j] * b[j]
print(sum)
| n, m = list(map(int, input().split()))
A = [[int(i) for i in input().split()] for j in range(n)]
b = []
for i in range(m):
b.append(int(eval(input())))
ans = [0 for i in range(n)]
for i in range(n):
for j in range(m):
ans[i] += A[i][j] * b[j]
for i in ans:
print(i)
| false | 8.333333 | [
"-A = []",
"+A = [[int(i) for i in input().split()] for j in range(n)]",
"-for i in range(n):",
"- A.append([int(j) for j in input().split()])",
"+ans = [0 for i in range(n)]",
"- sum = 0",
"- sum += A[i][j] * b[j]",
"- print(sum)",
"+ ans[i] += A[i][j] * b[j]",
"+for i in ans:",
"+ print(i)"
]
| false | 0.042558 | 0.043872 | 0.970068 | [
"s694941631",
"s577138881"
]
|
u489959379 | p03696 | python | s632552495 | s634684891 | 162 | 25 | 38,256 | 9,192 | Accepted | Accepted | 84.57 | import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
S = eval(input())
insert_L = 0
cnt_L = 0
for s in S:
if s == '(':
cnt_L += 1
else:
if cnt_L:
cnt_L -= 1
else:
insert_L += 1
insert_R = cnt_L
res = '(' * insert_L + S + ')' * insert_R
print(res)
if __name__ == '__main__':
resolve()
| import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(eval(input()))
S = eval(input())
right = 0
left = 0
for i in range(n):
if S[i] == "(":
left += 1
else:
if left:
left -= 1
else:
right += 1
res = "(" * right + S + ")" * left
print(res)
if __name__ == '__main__':
resolve()
| 31 | 27 | 497 | 462 | import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
S = eval(input())
insert_L = 0
cnt_L = 0
for s in S:
if s == "(":
cnt_L += 1
else:
if cnt_L:
cnt_L -= 1
else:
insert_L += 1
insert_R = cnt_L
res = "(" * insert_L + S + ")" * insert_R
print(res)
if __name__ == "__main__":
resolve()
| import sys
sys.setrecursionlimit(10**7)
f_inf = float("inf")
mod = 10**9 + 7
def resolve():
n = int(eval(input()))
S = eval(input())
right = 0
left = 0
for i in range(n):
if S[i] == "(":
left += 1
else:
if left:
left -= 1
else:
right += 1
res = "(" * right + S + ")" * left
print(res)
if __name__ == "__main__":
resolve()
| false | 12.903226 | [
"- insert_L = 0",
"- cnt_L = 0",
"- for s in S:",
"- if s == \"(\":",
"- cnt_L += 1",
"+ right = 0",
"+ left = 0",
"+ for i in range(n):",
"+ if S[i] == \"(\":",
"+ left += 1",
"- if cnt_L:",
"- cnt_L -= 1",
"+ if left:",
"+ left -= 1",
"- insert_L += 1",
"- insert_R = cnt_L",
"- res = \"(\" * insert_L + S + \")\" * insert_R",
"+ right += 1",
"+ res = \"(\" * right + S + \")\" * left"
]
| false | 0.037461 | 0.056965 | 0.657621 | [
"s632552495",
"s634684891"
]
|
u062691227 | p04046 | python | s539781020 | s811976266 | 376 | 173 | 88,692 | 73,692 | Accepted | Accepted | 53.99 | H, W, A, B = list(map(int, open(0).read().split()))
MOD = 10**9+7
factorials = [1] * (H + W + 1)
inv_factorials = [1] * (H + W + 1)
tmp = 1
for i in range(H + W):
tmp = tmp * (i + 1) % MOD
factorials[i+1] = tmp
inv_factorials = list([pow(n, MOD - 2, MOD) for n in factorials])
def modcomb(m, n, mod):
return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD
# total = modcomb(H + W - 2, W - 1, MOD)
total = 0
# for i in range(B):
for i in range(B, W):
total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD
total %= MOD
print(total) | H, W, A, B = list(map(int, open(0).read().split()))
MOD = 10**9+7
factorials = [1] * (H + W + 1)
inv_factorials = [1] * (H + W + 1)
for i in range(H + W):
factorials[i+1] = factorials[i] * (i + 1) % MOD
for i in range(H + W):
inv_factorials[i+1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD
def modcomb(m, n, mod):
return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD
# total = modcomb(H + W - 2, W - 1, MOD)
total = 0
# for i in range(B):
for i in range(B, W):
total += modcomb(H - A - 1 + i, i, MOD) * modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD) % MOD
total %= MOD
print(total) | 25 | 24 | 641 | 658 | H, W, A, B = list(map(int, open(0).read().split()))
MOD = 10**9 + 7
factorials = [1] * (H + W + 1)
inv_factorials = [1] * (H + W + 1)
tmp = 1
for i in range(H + W):
tmp = tmp * (i + 1) % MOD
factorials[i + 1] = tmp
inv_factorials = list([pow(n, MOD - 2, MOD) for n in factorials])
def modcomb(m, n, mod):
return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD
# total = modcomb(H + W - 2, W - 1, MOD)
total = 0
# for i in range(B):
for i in range(B, W):
total += (
modcomb(H - A - 1 + i, i, MOD)
* modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)
% MOD
)
total %= MOD
print(total)
| H, W, A, B = list(map(int, open(0).read().split()))
MOD = 10**9 + 7
factorials = [1] * (H + W + 1)
inv_factorials = [1] * (H + W + 1)
for i in range(H + W):
factorials[i + 1] = factorials[i] * (i + 1) % MOD
for i in range(H + W):
inv_factorials[i + 1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD
def modcomb(m, n, mod):
return factorials[m] * inv_factorials[n] % MOD * inv_factorials[m - n] % MOD
# total = modcomb(H + W - 2, W - 1, MOD)
total = 0
# for i in range(B):
for i in range(B, W):
total += (
modcomb(H - A - 1 + i, i, MOD)
* modcomb(A - 1 + W - 1 - i, W - 1 - i, MOD)
% MOD
)
total %= MOD
print(total)
| false | 4 | [
"-tmp = 1",
"- tmp = tmp * (i + 1) % MOD",
"- factorials[i + 1] = tmp",
"-inv_factorials = list([pow(n, MOD - 2, MOD) for n in factorials])",
"+ factorials[i + 1] = factorials[i] * (i + 1) % MOD",
"+for i in range(H + W):",
"+ inv_factorials[i + 1] = inv_factorials[i] * pow(i + 1, MOD - 2, MOD) % MOD"
]
| false | 0.040502 | 0.041577 | 0.974146 | [
"s539781020",
"s811976266"
]
|
u935558307 | p03716 | python | s917352118 | s468289416 | 671 | 291 | 120,080 | 125,988 | Accepted | Accepted | 56.63 | import heapq
N = int(eval(input()))
A = list(map(int,input().split()))
#前半部分の最適化辞書作成
SUM = sum(A[:N])
firstDic = {N-1:SUM}
que = A[:N]
heapq.heapify(que)
for i in range(N,2*N):
SUM += A[i]
heapq.heappush(que,A[i])
SUM -= heapq.heappop(que)
firstDic[i] = SUM
#後半部分の最適化辞書作成
SUM = sum(A[2*N:])*-1
latterDic = {2*N-1:SUM*-1}
que = [A[i]*-1 for i in range(2*N,3*N)]
heapq.heapify(que)
for i in range(2*N-1,N-1,-1):
SUM += A[i]*-1
heapq.heappush(que,A[i]*-1)
SUM -= heapq.heappop(que)
latterDic[i-1] = SUM*-1
ans = -1*float("INF")
for k,v in list(firstDic.items()):
ans = max(ans,v-latterDic[k])
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
B = []
for i in range(3*N-1,-1,-1):
B.append(A[i]*-1)
"""
前半をできるだけおおきく、後半をできるだけ小さくする。
前半はpriority queにぶっこんでいって、最小値を除去していく
"""
import heapq
frontSum = sum(A[:N])
frontQue = A[:N]
heapq.heapify(frontQue)
front = [frontSum]
for i in range(N,2*N):
frontSum += A[i]
heapq.heappush(frontQue,A[i])
frontSum -= heapq.heappop(frontQue)
front.append(frontSum)
backSum = sum(B[:N])
backQue = B[:N]
heapq.heapify(backQue)
back = [backSum*-1]
for i in range(N,2*N):
backSum += B[i]
heapq.heappush(backQue,B[i])
backSum -= heapq.heappop(backQue)
back.append(backSum*-1)
back = back[::-1]
candi = []
for i in range(len(front)):
candi.append(front[i]-back[i])
print((max(candi)))
| 31 | 35 | 658 | 790 | import heapq
N = int(eval(input()))
A = list(map(int, input().split()))
# 前半部分の最適化辞書作成
SUM = sum(A[:N])
firstDic = {N - 1: SUM}
que = A[:N]
heapq.heapify(que)
for i in range(N, 2 * N):
SUM += A[i]
heapq.heappush(que, A[i])
SUM -= heapq.heappop(que)
firstDic[i] = SUM
# 後半部分の最適化辞書作成
SUM = sum(A[2 * N :]) * -1
latterDic = {2 * N - 1: SUM * -1}
que = [A[i] * -1 for i in range(2 * N, 3 * N)]
heapq.heapify(que)
for i in range(2 * N - 1, N - 1, -1):
SUM += A[i] * -1
heapq.heappush(que, A[i] * -1)
SUM -= heapq.heappop(que)
latterDic[i - 1] = SUM * -1
ans = -1 * float("INF")
for k, v in list(firstDic.items()):
ans = max(ans, v - latterDic[k])
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = []
for i in range(3 * N - 1, -1, -1):
B.append(A[i] * -1)
"""
前半をできるだけおおきく、後半をできるだけ小さくする。
前半はpriority queにぶっこんでいって、最小値を除去していく
"""
import heapq
frontSum = sum(A[:N])
frontQue = A[:N]
heapq.heapify(frontQue)
front = [frontSum]
for i in range(N, 2 * N):
frontSum += A[i]
heapq.heappush(frontQue, A[i])
frontSum -= heapq.heappop(frontQue)
front.append(frontSum)
backSum = sum(B[:N])
backQue = B[:N]
heapq.heapify(backQue)
back = [backSum * -1]
for i in range(N, 2 * N):
backSum += B[i]
heapq.heappush(backQue, B[i])
backSum -= heapq.heappop(backQue)
back.append(backSum * -1)
back = back[::-1]
candi = []
for i in range(len(front)):
candi.append(front[i] - back[i])
print((max(candi)))
| false | 11.428571 | [
"+N = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+B = []",
"+for i in range(3 * N - 1, -1, -1):",
"+ B.append(A[i] * -1)",
"+\"\"\"",
"+前半をできるだけおおきく、後半をできるだけ小さくする。",
"+前半はpriority queにぶっこんでいって、最小値を除去していく",
"+\"\"\"",
"-N = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-# 前半部分の最適化辞書作成",
"-SUM = sum(A[:N])",
"-firstDic = {N - 1: SUM}",
"-que = A[:N]",
"-heapq.heapify(que)",
"+frontSum = sum(A[:N])",
"+frontQue = A[:N]",
"+heapq.heapify(frontQue)",
"+front = [frontSum]",
"- SUM += A[i]",
"- heapq.heappush(que, A[i])",
"- SUM -= heapq.heappop(que)",
"- firstDic[i] = SUM",
"-# 後半部分の最適化辞書作成",
"-SUM = sum(A[2 * N :]) * -1",
"-latterDic = {2 * N - 1: SUM * -1}",
"-que = [A[i] * -1 for i in range(2 * N, 3 * N)]",
"-heapq.heapify(que)",
"-for i in range(2 * N - 1, N - 1, -1):",
"- SUM += A[i] * -1",
"- heapq.heappush(que, A[i] * -1)",
"- SUM -= heapq.heappop(que)",
"- latterDic[i - 1] = SUM * -1",
"-ans = -1 * float(\"INF\")",
"-for k, v in list(firstDic.items()):",
"- ans = max(ans, v - latterDic[k])",
"-print(ans)",
"+ frontSum += A[i]",
"+ heapq.heappush(frontQue, A[i])",
"+ frontSum -= heapq.heappop(frontQue)",
"+ front.append(frontSum)",
"+backSum = sum(B[:N])",
"+backQue = B[:N]",
"+heapq.heapify(backQue)",
"+back = [backSum * -1]",
"+for i in range(N, 2 * N):",
"+ backSum += B[i]",
"+ heapq.heappush(backQue, B[i])",
"+ backSum -= heapq.heappop(backQue)",
"+ back.append(backSum * -1)",
"+back = back[::-1]",
"+candi = []",
"+for i in range(len(front)):",
"+ candi.append(front[i] - back[i])",
"+print((max(candi)))"
]
| false | 0.044663 | 0.090408 | 0.494018 | [
"s917352118",
"s468289416"
]
|
u673361376 | p03380 | python | s704394686 | s613426752 | 236 | 137 | 62,704 | 14,052 | Accepted | Accepted | 41.95 | from operator import mul
from functools import reduce
import bisect
def cmb(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
N = int(eval(input()))
A = sorted(list(map(int,input().split())))
maxA = max(A)
A.remove(maxA)
idx = bisect.bisect(A,maxA//2)
if idx == len(A):
print((maxA,A[-1]))
elif idx == 0:
print((maxA, idx))
else:
if abs(maxA//2 - A[idx]) > abs(maxA//2 - A[idx-1]):
print((maxA,A[idx-1]))
else:
print((maxA,A[idx])) | N = int(eval(input()))
A = sorted(list(map(int, input().split())))
n = A[-1]
r_val = -float('inf')
r_row = None
for idx in range(N - 1):
if r_val < min(n - A[idx], A[idx]):
r_val = min(n - A[idx], A[idx])
r_row = A[idx]
print((n, r_row))
| 26 | 11 | 569 | 261 | from operator import mul
from functools import reduce
import bisect
def cmb(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
N = int(eval(input()))
A = sorted(list(map(int, input().split())))
maxA = max(A)
A.remove(maxA)
idx = bisect.bisect(A, maxA // 2)
if idx == len(A):
print((maxA, A[-1]))
elif idx == 0:
print((maxA, idx))
else:
if abs(maxA // 2 - A[idx]) > abs(maxA // 2 - A[idx - 1]):
print((maxA, A[idx - 1]))
else:
print((maxA, A[idx]))
| N = int(eval(input()))
A = sorted(list(map(int, input().split())))
n = A[-1]
r_val = -float("inf")
r_row = None
for idx in range(N - 1):
if r_val < min(n - A[idx], A[idx]):
r_val = min(n - A[idx], A[idx])
r_row = A[idx]
print((n, r_row))
| false | 57.692308 | [
"-from operator import mul",
"-from functools import reduce",
"-import bisect",
"-",
"-",
"-def cmb(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",
"-",
"-",
"-maxA = max(A)",
"-A.remove(maxA)",
"-idx = bisect.bisect(A, maxA // 2)",
"-if idx == len(A):",
"- print((maxA, A[-1]))",
"-elif idx == 0:",
"- print((maxA, idx))",
"-else:",
"- if abs(maxA // 2 - A[idx]) > abs(maxA // 2 - A[idx - 1]):",
"- print((maxA, A[idx - 1]))",
"- else:",
"- print((maxA, A[idx]))",
"+n = A[-1]",
"+r_val = -float(\"inf\")",
"+r_row = None",
"+for idx in range(N - 1):",
"+ if r_val < min(n - A[idx], A[idx]):",
"+ r_val = min(n - A[idx], A[idx])",
"+ r_row = A[idx]",
"+print((n, r_row))"
]
| false | 0.038397 | 0.038094 | 1.00795 | [
"s704394686",
"s613426752"
]
|
u579699847 | p03993 | python | s540750439 | s532012152 | 228 | 202 | 29,596 | 23,464 | Accepted | Accepted | 11.4 | import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
a = LI()
count = 0
a_dict = {}
for i,x in enumerate(a,1):
a_dict[i] = x
for k,v in list(a_dict.items()):
if k in [a_dict[v]]:
count +=1
print((count//2))
| import bisect,collections,copy,heapq,itertools,math,numpy,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
N = I()
a = LI()
ans = 0
for i,x in enumerate(a,1):
if x=='*':
continue
if a[x-1]==i:
ans += 1
a[x-1] = '*'
print(ans)
| 14 | 14 | 380 | 361 | import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
def I():
return int(sys.stdin.readline().rstrip())
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
a = LI()
count = 0
a_dict = {}
for i, x in enumerate(a, 1):
a_dict[i] = x
for k, v in list(a_dict.items()):
if k in [a_dict[v]]:
count += 1
print((count // 2))
| import bisect, collections, copy, heapq, itertools, math, numpy, string
import sys
def I():
return int(sys.stdin.readline().rstrip())
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
N = I()
a = LI()
ans = 0
for i, x in enumerate(a, 1):
if x == "*":
continue
if a[x - 1] == i:
ans += 1
a[x - 1] = "*"
print(ans)
| false | 0 | [
"-count = 0",
"-a_dict = {}",
"+ans = 0",
"- a_dict[i] = x",
"-for k, v in list(a_dict.items()):",
"- if k in [a_dict[v]]:",
"- count += 1",
"-print((count // 2))",
"+ if x == \"*\":",
"+ continue",
"+ if a[x - 1] == i:",
"+ ans += 1",
"+ a[x - 1] = \"*\"",
"+print(ans)"
]
| false | 0.034524 | 0.034779 | 0.992676 | [
"s540750439",
"s532012152"
]
|
u707808519 | p03854 | python | s814675348 | s228476961 | 86 | 71 | 3,188 | 3,236 | Accepted | Accepted | 17.44 | S = eval(input())
divide = ["dream", "dreamer", "erase", "eraser"]
S = S[::-1]
divide = [divide[i][::-1] for i in range(4)]
while len(S) > 0:
for i in range(4):
if S[:len(divide[i])] == divide[i]:
flag = "YES"
S = S[len(divide[i]):]
break
else:
flag = "NO"
if flag == "NO":
break
print(flag) | S = eval(input())
buff = ['dream', 'dreamer', 'erase', 'eraser']
for i in range(4):
buff[i] = buff[i][::-1]
S = S[::-1]
while len(S) > 0:
if S[:7] == buff[1]:
S = S[7:]
elif S[:6] == buff[3]:
S = S[6:]
elif S[:5] == buff[0] or S[:5] == buff[2]:
S = S[5:]
else:
break
if S: print('NO')
else: print('YES') | 17 | 16 | 384 | 364 | S = eval(input())
divide = ["dream", "dreamer", "erase", "eraser"]
S = S[::-1]
divide = [divide[i][::-1] for i in range(4)]
while len(S) > 0:
for i in range(4):
if S[: len(divide[i])] == divide[i]:
flag = "YES"
S = S[len(divide[i]) :]
break
else:
flag = "NO"
if flag == "NO":
break
print(flag)
| S = eval(input())
buff = ["dream", "dreamer", "erase", "eraser"]
for i in range(4):
buff[i] = buff[i][::-1]
S = S[::-1]
while len(S) > 0:
if S[:7] == buff[1]:
S = S[7:]
elif S[:6] == buff[3]:
S = S[6:]
elif S[:5] == buff[0] or S[:5] == buff[2]:
S = S[5:]
else:
break
if S:
print("NO")
else:
print("YES")
| false | 5.882353 | [
"-divide = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]",
"+buff = [\"dream\", \"dreamer\", \"erase\", \"eraser\"]",
"+for i in range(4):",
"+ buff[i] = buff[i][::-1]",
"-divide = [divide[i][::-1] for i in range(4)]",
"- for i in range(4):",
"- if S[: len(divide[i])] == divide[i]:",
"- flag = \"YES\"",
"- S = S[len(divide[i]) :]",
"- break",
"- else:",
"- flag = \"NO\"",
"- if flag == \"NO\":",
"+ if S[:7] == buff[1]:",
"+ S = S[7:]",
"+ elif S[:6] == buff[3]:",
"+ S = S[6:]",
"+ elif S[:5] == buff[0] or S[:5] == buff[2]:",
"+ S = S[5:]",
"+ else:",
"-print(flag)",
"+if S:",
"+ print(\"NO\")",
"+else:",
"+ print(\"YES\")"
]
| false | 0.041757 | 0.044179 | 0.945195 | [
"s814675348",
"s228476961"
]
|
u753803401 | p03565 | python | s359584852 | s856106269 | 166 | 17 | 38,384 | 3,192 | Accepted | Accepted | 89.76 | import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
t = str(readline().rstrip().decode('utf-8'))
k = len(t)
for i in range(len(s) - k, -1, -1):
ts = s[i:i+k]
b = True
for j in range(k):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
a = []
f = True
for j in range(len(s)):
if j < i or i + k <= j:
if s[j] == "?":
a.append("a")
else:
a.append(s[j])
else:
if f:
a = a + list(t)
f = False
print(("".join(a)))
exit()
print("UNRESTORABLE")
if __name__ == '__main__':
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
t = str(readline().rstrip().decode('utf-8'))
lt = len(t)
for i in range(len(s) - lt, -1, -1):
ts = s[i:i+lt]
b = True
for j in range(len(ts)):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
ans = []
for j in range(len(s)):
if i <= j < i + lt:
ans.append(t[j-i])
else:
if s[j] == "?":
ans.append("a")
else:
ans.append(s[j])
print(("".join(ans)))
exit()
print("UNRESTORABLE")
if __name__ == '__main__':
solve()
| 36 | 33 | 945 | 873 | import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10**9 + 7
s = str(readline().rstrip().decode("utf-8"))
t = str(readline().rstrip().decode("utf-8"))
k = len(t)
for i in range(len(s) - k, -1, -1):
ts = s[i : i + k]
b = True
for j in range(k):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
a = []
f = True
for j in range(len(s)):
if j < i or i + k <= j:
if s[j] == "?":
a.append("a")
else:
a.append(s[j])
else:
if f:
a = a + list(t)
f = False
print(("".join(a)))
exit()
print("UNRESTORABLE")
if __name__ == "__main__":
solve()
| import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10**9 + 7
s = str(readline().rstrip().decode("utf-8"))
t = str(readline().rstrip().decode("utf-8"))
lt = len(t)
for i in range(len(s) - lt, -1, -1):
ts = s[i : i + lt]
b = True
for j in range(len(ts)):
if ts[j] != "?" and ts[j] != t[j]:
b = False
break
if b:
ans = []
for j in range(len(s)):
if i <= j < i + lt:
ans.append(t[j - i])
else:
if s[j] == "?":
ans.append("a")
else:
ans.append(s[j])
print(("".join(ans)))
exit()
print("UNRESTORABLE")
if __name__ == "__main__":
solve()
| false | 8.333333 | [
"- k = len(t)",
"- for i in range(len(s) - k, -1, -1):",
"- ts = s[i : i + k]",
"+ lt = len(t)",
"+ for i in range(len(s) - lt, -1, -1):",
"+ ts = s[i : i + lt]",
"- for j in range(k):",
"+ for j in range(len(ts)):",
"- a = []",
"- f = True",
"+ ans = []",
"- if j < i or i + k <= j:",
"+ if i <= j < i + lt:",
"+ ans.append(t[j - i])",
"+ else:",
"- a.append(\"a\")",
"+ ans.append(\"a\")",
"- a.append(s[j])",
"- else:",
"- if f:",
"- a = a + list(t)",
"- f = False",
"- print((\"\".join(a)))",
"+ ans.append(s[j])",
"+ print((\"\".join(ans)))"
]
| false | 0.044397 | 0.043722 | 1.015446 | [
"s359584852",
"s856106269"
]
|
u487252913 | p03108 | python | s295638294 | s048514460 | 712 | 655 | 62,600 | 15,768 | Accepted | Accepted | 8.01 | import sys
sys.setrecursionlimit(10 ** 7)
class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
self.size = [1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.parent[px] > self.parent[py]:
self.parent[py] = px
self.parent[px] -= 1
self.size[px] += self.size[py]
self.size[py] = 0
else:
self.parent[px] = py
self.parent[py] -= 1
self.size[py] += self.size[px]
self.size[px] = 0
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
brs = [list(map(int, input().split())) for _ in range(M)]
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N*(N-1)//2]
for i in range(M-1, 0, -1):
a, b = brs[i][0], brs[i][1]
a, b = a-1, b-1
p1 = uf.find(a)
p2 = uf.find(b)
if p1 != p2:
ans.append(ans[-1] - uf.size[p1]*uf.size[p2])
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px == py:
return
if self.size(px) > self.size(py):
px, py = py, px
self.parent[py] += self.parent[px]
self.parent[px] = py
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def size(self, x):
return -self.parent[self.find(x)]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
A, B = [], []
for _ in range(M):
a, b = map(int, input().split())
A.append(a-1)
B.append(b-1)
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N*(N-1)//2]
for i in range(M-1, 0, -1):
p1 = uf.find(A[i])
p2 = uf.find(B[i])
if p1 != p2:
ans.append(ans[-1] - uf.size(p1)*uf.size(p2))
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| 59 | 55 | 1,666 | 1,433 | import sys
sys.setrecursionlimit(10**7)
class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
self.size = [1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px != py:
if self.parent[px] > self.parent[py]:
self.parent[py] = px
self.parent[px] -= 1
self.size[px] += self.size[py]
self.size[py] = 0
else:
self.parent[px] = py
self.parent[py] -= 1
self.size[py] += self.size[px]
self.size[px] = 0
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
brs = [list(map(int, input().split())) for _ in range(M)]
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N * (N - 1) // 2]
for i in range(M - 1, 0, -1):
a, b = brs[i][0], brs[i][1]
a, b = a - 1, b - 1
p1 = uf.find(a)
p2 = uf.find(b)
if p1 != p2:
ans.append(ans[-1] - uf.size[p1] * uf.size[p2])
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| class UnionFind:
def __init__(self, size: int):
self.parent = [-1 for _ in range(size)]
def unite(self, x, y):
px = self.find(x)
py = self.find(y)
if px == py:
return
if self.size(px) > self.size(py):
px, py = py, px
self.parent[py] += self.parent[px]
self.parent[px] = py
return
def find(self, x: int) -> int:
if self.parent[x] < 0:
return x
self.parent[x] = self.find(self.parent[x])
return self.parent[x]
def size(self, x):
return -self.parent[self.find(x)]
def is_same(self, x: int, y: int) -> bool:
return self.find(x) == self.find(y)
def main():
# input
N, M = map(int, input().split())
A, B = [], []
for _ in range(M):
a, b = map(int, input().split())
A.append(a - 1)
B.append(b - 1)
# solve
# ref: http://drken1215.hatenablog.com/entry/2019/03/03/224600
# ref: https://atcoder.jp/contests/abc120/submissions/4450601
uf = UnionFind(N)
ans = [N * (N - 1) // 2]
for i in range(M - 1, 0, -1):
p1 = uf.find(A[i])
p2 = uf.find(B[i])
if p1 != p2:
ans.append(ans[-1] - uf.size(p1) * uf.size(p2))
else:
ans.append(ans[-1])
uf.unite(p1, p2)
return ans
print(*list(reversed(main())), sep="\n")
| false | 6.779661 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**7)",
"-",
"-",
"- self.size = [1 for _ in range(size)]",
"- if px != py:",
"- if self.parent[px] > self.parent[py]:",
"- self.parent[py] = px",
"- self.parent[px] -= 1",
"- self.size[px] += self.size[py]",
"- self.size[py] = 0",
"- else:",
"- self.parent[px] = py",
"- self.parent[py] -= 1",
"- self.size[py] += self.size[px]",
"- self.size[px] = 0",
"+ if px == py:",
"+ return",
"+ if self.size(px) > self.size(py):",
"+ px, py = py, px",
"+ self.parent[py] += self.parent[px]",
"+ self.parent[px] = py",
"+ def size(self, x):",
"+ return -self.parent[self.find(x)]",
"+",
"- brs = [list(map(int, input().split())) for _ in range(M)]",
"+ A, B = [], []",
"+ for _ in range(M):",
"+ a, b = map(int, input().split())",
"+ A.append(a - 1)",
"+ B.append(b - 1)",
"- a, b = brs[i][0], brs[i][1]",
"- a, b = a - 1, b - 1",
"- p1 = uf.find(a)",
"- p2 = uf.find(b)",
"+ p1 = uf.find(A[i])",
"+ p2 = uf.find(B[i])",
"- ans.append(ans[-1] - uf.size[p1] * uf.size[p2])",
"+ ans.append(ans[-1] - uf.size(p1) * uf.size(p2))"
]
| false | 0.039998 | 0.0388 | 1.030886 | [
"s295638294",
"s048514460"
]
|
u922172470 | p03448 | python | s126200966 | s116381067 | 43 | 17 | 3,064 | 3,060 | Accepted | Accepted | 60.47 | def resolve():
A,B,C,X = [int(eval(input())) for i in range(4)]
res = 0
for a in range(A+1):
for b in range(B+1):
for c in range(C+1):
total = 500*a + 100*b + 50*c
if total == X:
res += 1
print(res)
resolve() | def resolve():
A,B,C,X = [int(eval(input())) for i in range(4)]
res = 0
mA = min(X//500, A)
for i in range(mA+1):
Y = X - 500 * i
mB = min(Y//100, B)
for j in range(mB+1):
Z = Y - 100 * j
if Z <= 50*C:
res += 1
print(res)
resolve() | 14 | 16 | 310 | 331 | def resolve():
A, B, C, X = [int(eval(input())) for i in range(4)]
res = 0
for a in range(A + 1):
for b in range(B + 1):
for c in range(C + 1):
total = 500 * a + 100 * b + 50 * c
if total == X:
res += 1
print(res)
resolve()
| def resolve():
A, B, C, X = [int(eval(input())) for i in range(4)]
res = 0
mA = min(X // 500, A)
for i in range(mA + 1):
Y = X - 500 * i
mB = min(Y // 100, B)
for j in range(mB + 1):
Z = Y - 100 * j
if Z <= 50 * C:
res += 1
print(res)
resolve()
| false | 12.5 | [
"- for a in range(A + 1):",
"- for b in range(B + 1):",
"- for c in range(C + 1):",
"- total = 500 * a + 100 * b + 50 * c",
"- if total == X:",
"- res += 1",
"+ mA = min(X // 500, A)",
"+ for i in range(mA + 1):",
"+ Y = X - 500 * i",
"+ mB = min(Y // 100, B)",
"+ for j in range(mB + 1):",
"+ Z = Y - 100 * j",
"+ if Z <= 50 * C:",
"+ res += 1"
]
| false | 0.061363 | 0.036613 | 1.67599 | [
"s126200966",
"s116381067"
]
|
u595289165 | p02629 | python | s815030426 | s024515678 | 32 | 29 | 9,216 | 9,092 | Accepted | Accepted | 9.38 | def base_k(n, k=26):
ret = []
ny = n
while ny:
ret.append(ny % k)
ny //= k
return ret[::-1]
def letter(i):
return chr(i+97)
def solve(n):
check = 26
cnt = 1
k = n
while True:
if n <= check:
break
check *= 26
check += 26
cnt += 1
k -= check//26 - 1
t = base_k(k-1)
ans = ""
if not t:
ans = "a" * cnt
else:
for _ in range(cnt):
if not t:
ans += "a"
continue
ans += letter(t.pop())
return ans[::-1]
n = int(eval(input()))
print((solve(n)))
| def answer(n):
if n <= 26:
return chr(n-1 + 97)
r = n % 26 - 1
if r == -1:
r += 26
return answer((n-r) // 26) + chr(r + 97)
n = int(eval(input()))
print((answer(n))) | 41 | 11 | 669 | 201 | def base_k(n, k=26):
ret = []
ny = n
while ny:
ret.append(ny % k)
ny //= k
return ret[::-1]
def letter(i):
return chr(i + 97)
def solve(n):
check = 26
cnt = 1
k = n
while True:
if n <= check:
break
check *= 26
check += 26
cnt += 1
k -= check // 26 - 1
t = base_k(k - 1)
ans = ""
if not t:
ans = "a" * cnt
else:
for _ in range(cnt):
if not t:
ans += "a"
continue
ans += letter(t.pop())
return ans[::-1]
n = int(eval(input()))
print((solve(n)))
| def answer(n):
if n <= 26:
return chr(n - 1 + 97)
r = n % 26 - 1
if r == -1:
r += 26
return answer((n - r) // 26) + chr(r + 97)
n = int(eval(input()))
print((answer(n)))
| false | 73.170732 | [
"-def base_k(n, k=26):",
"- ret = []",
"- ny = n",
"- while ny:",
"- ret.append(ny % k)",
"- ny //= k",
"- return ret[::-1]",
"-",
"-",
"-def letter(i):",
"- return chr(i + 97)",
"-",
"-",
"-def solve(n):",
"- check = 26",
"- cnt = 1",
"- k = n",
"- while True:",
"- if n <= check:",
"- break",
"- check *= 26",
"- check += 26",
"- cnt += 1",
"- k -= check // 26 - 1",
"- t = base_k(k - 1)",
"- ans = \"\"",
"- if not t:",
"- ans = \"a\" * cnt",
"- else:",
"- for _ in range(cnt):",
"- if not t:",
"- ans += \"a\"",
"- continue",
"- ans += letter(t.pop())",
"- return ans[::-1]",
"+def answer(n):",
"+ if n <= 26:",
"+ return chr(n - 1 + 97)",
"+ r = n % 26 - 1",
"+ if r == -1:",
"+ r += 26",
"+ return answer((n - r) // 26) + chr(r + 97)",
"-print((solve(n)))",
"+print((answer(n)))"
]
| false | 0.038125 | 0.090343 | 0.421997 | [
"s815030426",
"s024515678"
]
|
u609061751 | p03033 | python | s254876951 | s854231952 | 1,499 | 1,227 | 129,784 | 112,348 | Accepted | Accepted | 18.15 | import sys
input = lambda : sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = float("inf")
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == float("inf"):
print((-1))
else:
print(res)
| import sys
input = lambda : sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = 10**9 + 1
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == ide_ele:
print((-1))
else:
print(res)
| 63 | 63 | 1,472 | 1,464 | import sys
input = lambda: sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = float("inf")
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == float("inf"):
print((-1))
else:
print(res)
| import sys
input = lambda: sys.stdin.readline().rstrip()
def segfun(x, y):
return min(x, y)
ide_ele = 10**9 + 1
class SegmentTree:
def __init__(self, n, ele, segfun):
self.ide_ele = ele
self.segfun = segfun
self.n = n
self.N0 = 1 << n.bit_length()
self.data = [self.ide_ele] * (self.N0 * 2)
def update(self, l, r, val):
l += self.N0
r += self.N0
while l < r:
if l & 1:
self.data[l] = self.segfun(self.data[l], val)
l += 1
if r & 1:
self.data[r - 1] = self.segfun(self.data[r - 1], val)
r -= 1
l //= 2
r //= 2
def query(self, i):
i += len(self.data) // 2
ret = self.data[i]
while i > 0:
i //= 2
ret = self.segfun(ret, self.data[i])
return ret
n, q = list(map(int, input().split()))
stx = []
for _ in range(n):
s, t, x = list(map(int, input().split()))
stx.append([x, s - x, t - x])
# stx.sort(reverse=True)
d = [int(eval(input())) for _ in range(q)]
import bisect
seg = SegmentTree(q, ide_ele, segfun)
for x, start, last in stx:
l = bisect.bisect_left(d, start)
r = bisect.bisect_left(d, last)
seg.update(l, r, x)
for i, j in enumerate(d):
res = seg.query(i)
if res == ide_ele:
print((-1))
else:
print(res)
| false | 0 | [
"-ide_ele = float(\"inf\")",
"+ide_ele = 10**9 + 1",
"- if res == float(\"inf\"):",
"+ if res == ide_ele:"
]
| false | 0.050664 | 0.050425 | 1.004752 | [
"s254876951",
"s854231952"
]
|
u116038906 | p02678 | python | s738822544 | s262303927 | 791 | 539 | 82,668 | 54,076 | Accepted | Accepted | 31.86 |
from collections import deque
import sys
input = sys.stdin.readline
N,M = (int(x) for x in input().split())
connection ={i:set() for i in range(1,N+1)}
#構造入力
for i in range(1,M+1):
a,b = (int(x) for x in input().split())
connection[a].add(b)
connection[b].add(a)
#幅優先探索
dq =deque()
dq.append(1)
parent ={i:-1 for i in range(1,N+1)} #1につながっている＝答え
parent[1] =0
while dq:
now =dq.popleft()
for next in connection[now]:
if parent[next] !=-1:
continue
else:
parent[next] =now
dq.append(next)
if -1 not in parent.values():
del parent[1]
print("Yes")
print(*parent.values(),sep="\n")
| from collections import deque
from copy import copy
import sys
input = sys.stdin.readline
N,M = (int(x) for x in input().split())
connection ={i:[] for i in range(0,N+1)}
connection[0] =[1]
#connection[1] =[0]
#構造入力
for i in range(M):
a,b = (int(x) for x in input().split())
connection[a].append(b)
connection[b].append(a)
# 幅優先探索
parent ={i:-1 for i in range(1,N+1)} #親＝通過済、通過してない部屋はー１
parent[1] =0
children = deque()
children.extend(connection[1])
for i in children:
parent[i] =1
while children:
next =children.popleft()
for i in connection[next]:
if parent[i] != -1:
continue
else:
parent[i] =next
children.append(i)
#出力
print("Yes")
for i in range(2,N+1):
print((parent[i])) | 30 | 35 | 692 | 793 | from collections import deque
import sys
input = sys.stdin.readline
N, M = (int(x) for x in input().split())
connection = {i: set() for i in range(1, N + 1)}
# 構造入力
for i in range(1, M + 1):
a, b = (int(x) for x in input().split())
connection[a].add(b)
connection[b].add(a)
# 幅優先探索
dq = deque()
dq.append(1)
parent = {i: -1 for i in range(1, N + 1)} # 1につながっている＝答え
parent[1] = 0
while dq:
now = dq.popleft()
for next in connection[now]:
if parent[next] != -1:
continue
else:
parent[next] = now
dq.append(next)
if -1 not in parent.values():
del parent[1]
print("Yes")
print(*parent.values(), sep="\n")
| from collections import deque
from copy import copy
import sys
input = sys.stdin.readline
N, M = (int(x) for x in input().split())
connection = {i: [] for i in range(0, N + 1)}
connection[0] = [1]
# connection[1] =[0]
# 構造入力
for i in range(M):
a, b = (int(x) for x in input().split())
connection[a].append(b)
connection[b].append(a)
# 幅優先探索
parent = {i: -1 for i in range(1, N + 1)} # 親＝通過済、通過してない部屋はー１
parent[1] = 0
children = deque()
children.extend(connection[1])
for i in children:
parent[i] = 1
while children:
next = children.popleft()
for i in connection[next]:
if parent[i] != -1:
continue
else:
parent[i] = next
children.append(i)
# 出力
print("Yes")
for i in range(2, N + 1):
print((parent[i]))
| false | 14.285714 | [
"+from copy import copy",
"-connection = {i: set() for i in range(1, N + 1)}",
"+connection = {i: [] for i in range(0, N + 1)}",
"+connection[0] = [1]",
"+# connection[1] =[0]",
"-for i in range(1, M + 1):",
"+for i in range(M):",
"- connection[a].add(b)",
"- connection[b].add(a)",
"+ connection[a].append(b)",
"+ connection[b].append(a)",
"-dq = deque()",
"-dq.append(1)",
"-parent = {i: -1 for i in range(1, N + 1)} # 1につながっている＝答え",
"+parent = {i: -1 for i in range(1, N + 1)} # 親＝通過済、通過してない部屋はー１",
"-while dq:",
"- now = dq.popleft()",
"- for next in connection[now]:",
"- if parent[next] != -1:",
"+children = deque()",
"+children.extend(connection[1])",
"+for i in children:",
"+ parent[i] = 1",
"+while children:",
"+ next = children.popleft()",
"+ for i in connection[next]:",
"+ if parent[i] != -1:",
"- parent[next] = now",
"- dq.append(next)",
"-if -1 not in parent.values():",
"- del parent[1]",
"- print(\"Yes\")",
"- print(*parent.values(), sep=\"\\n\")",
"+ parent[i] = next",
"+ children.append(i)",
"+# 出力",
"+print(\"Yes\")",
"+for i in range(2, N + 1):",
"+ print((parent[i]))"
]
| false | 0.037134 | 0.037241 | 0.997124 | [
"s738822544",
"s262303927"
]
|
u816587940 | p02713 | python | s051144224 | s050721066 | 241 | 125 | 68,528 | 67,764 | Accepted | Accepted | 48.13 | k = int(eval(input()))
def gcd(a, b):
if a < b: a, b = b, a
c = a % b
if c == 0: return b
while c!=0:
c = a % b
a, b = b, c
return a
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k+1):
ans += gcd(t, c)
print(ans)
| from math import gcd
k = int(eval(input()))
ans = 0
for a in range(1, k+1):
for b in range(1, k+1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k+1): ans += gcd(t, c)
print(ans) | 21 | 11 | 400 | 250 | k = int(eval(input()))
def gcd(a, b):
if a < b:
a, b = b, a
c = a % b
if c == 0:
return b
while c != 0:
c = a % b
a, b = b, c
return a
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k + 1):
ans += gcd(t, c)
print(ans)
| from math import gcd
k = int(eval(input()))
ans = 0
for a in range(1, k + 1):
for b in range(1, k + 1):
t = gcd(a, b)
if t == 1:
ans += k
continue
for c in range(1, k + 1):
ans += gcd(t, c)
print(ans)
| false | 47.619048 | [
"+from math import gcd",
"+",
"-",
"-",
"-def gcd(a, b):",
"- if a < b:",
"- a, b = b, a",
"- c = a % b",
"- if c == 0:",
"- return b",
"- while c != 0:",
"- c = a % b",
"- a, b = b, c",
"- return a",
"-",
"-"
]
| false | 0.118687 | 0.090338 | 1.313809 | [
"s051144224",
"s050721066"
]
|
u978313283 | p03160 | python | s937136917 | s460568070 | 209 | 144 | 51,236 | 13,980 | Accepted | Accepted | 31.1 | import sys
INF=100000000
def frog(i,h,dp):
global INF
if dp[i]!=INF:
return dp[i]
else:
if i==1:
dp[i]=0
return dp[i]
elif i==2:
dp[i]=abs(h[1]-h[0])
return dp[i]
else:
dp[i]=min(frog(i-2,h,dp)+abs(h[i-1]-h[i-3]),frog(i-1,h,dp)+abs(h[i-1]-h[i-2]))
return dp[i]
sys.setrecursionlimit(INF)
N=int(eval(input()))
h=list(map(int,input().split()))
dp=[INF for i in range(N+1)]
print((frog(N,h,dp)))
| INF=10**15
N=int(eval(input()))
h=list(map(int,input().split()))
dp=[INF for i in range(N)]
dp[0]=0
for i in range(1,N):
if i>1:
dp[i]=min(dp[i-1]+abs(h[i]-h[i-1]),dp[i-2]+abs(h[i]-h[i-2]))
else:
dp[i]=dp[i-1]+abs(h[i]-h[i-1])
print((dp[N-1])) | 21 | 11 | 521 | 269 | import sys
INF = 100000000
def frog(i, h, dp):
global INF
if dp[i] != INF:
return dp[i]
else:
if i == 1:
dp[i] = 0
return dp[i]
elif i == 2:
dp[i] = abs(h[1] - h[0])
return dp[i]
else:
dp[i] = min(
frog(i - 2, h, dp) + abs(h[i - 1] - h[i - 3]),
frog(i - 1, h, dp) + abs(h[i - 1] - h[i - 2]),
)
return dp[i]
sys.setrecursionlimit(INF)
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [INF for i in range(N + 1)]
print((frog(N, h, dp)))
| INF = 10**15
N = int(eval(input()))
h = list(map(int, input().split()))
dp = [INF for i in range(N)]
dp[0] = 0
for i in range(1, N):
if i > 1:
dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))
else:
dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])
print((dp[N - 1]))
| false | 47.619048 | [
"-import sys",
"-",
"-INF = 100000000",
"-",
"-",
"-def frog(i, h, dp):",
"- global INF",
"- if dp[i] != INF:",
"- return dp[i]",
"- else:",
"- if i == 1:",
"- dp[i] = 0",
"- return dp[i]",
"- elif i == 2:",
"- dp[i] = abs(h[1] - h[0])",
"- return dp[i]",
"- else:",
"- dp[i] = min(",
"- frog(i - 2, h, dp) + abs(h[i - 1] - h[i - 3]),",
"- frog(i - 1, h, dp) + abs(h[i - 1] - h[i - 2]),",
"- )",
"- return dp[i]",
"-",
"-",
"-sys.setrecursionlimit(INF)",
"+INF = 10**15",
"-dp = [INF for i in range(N + 1)]",
"-print((frog(N, h, dp)))",
"+dp = [INF for i in range(N)]",
"+dp[0] = 0",
"+for i in range(1, N):",
"+ if i > 1:",
"+ dp[i] = min(dp[i - 1] + abs(h[i] - h[i - 1]), dp[i - 2] + abs(h[i] - h[i - 2]))",
"+ else:",
"+ dp[i] = dp[i - 1] + abs(h[i] - h[i - 1])",
"+print((dp[N - 1]))"
]
| false | 0.06012 | 0.041336 | 1.454426 | [
"s937136917",
"s460568070"
]
|
u017810624 | p03152 | python | s419901655 | s105093027 | 777 | 716 | 12,404 | 3,188 | Accepted | Accepted | 7.85 | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
A=set(a);B=set(b)
if len(A)!=len(a) or len(B)!=len(b):
print((0))
else:
L=[]
for i in range(n):
l=[]
for j in range(m):
l.append(0)
L.append(l)
ct=1;ctn=0;ctm=0
for k in range(m*n,0,-1):
if k in A and k in B:
L[n-ctn-1][m-ctm-1]=k
ctn+=1;ctm+=1
elif k in A:
ct*=ctm;ctn+=1
elif k in B:
ct*=ctn;ctm+=1
else:
ct*=(ctm*ctn-m*n+k)
if ct==0:
break
ct=ct%(10**9+7)
print(ct) | n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
A=set(a);B=set(b)
if len(A)!=len(a) or len(B)!=len(b):
print((0))
else:
L=[]
l=[0 for j in range(m)]
for i in range(n):
L.append(l)
ct=1;ctn=0;ctm=0
for k in range(m*n,0,-1):
if k in A and k in B:
L[n-ctn-1][m-ctm-1]=k
ctn+=1;ctm+=1
elif k in A:
ct*=ctm;ctn+=1
elif k in B:
ct*=ctn;ctm+=1
else:
ct*=(ctm*ctn-m*n+k)
if ct==0:
break
ct=ct%(10**9+7)
print(ct) | 28 | 26 | 578 | 552 | n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
A = set(a)
B = set(b)
if len(A) != len(a) or len(B) != len(b):
print((0))
else:
L = []
for i in range(n):
l = []
for j in range(m):
l.append(0)
L.append(l)
ct = 1
ctn = 0
ctm = 0
for k in range(m * n, 0, -1):
if k in A and k in B:
L[n - ctn - 1][m - ctm - 1] = k
ctn += 1
ctm += 1
elif k in A:
ct *= ctm
ctn += 1
elif k in B:
ct *= ctn
ctm += 1
else:
ct *= ctm * ctn - m * n + k
if ct == 0:
break
ct = ct % (10**9 + 7)
print(ct)
| n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
A = set(a)
B = set(b)
if len(A) != len(a) or len(B) != len(b):
print((0))
else:
L = []
l = [0 for j in range(m)]
for i in range(n):
L.append(l)
ct = 1
ctn = 0
ctm = 0
for k in range(m * n, 0, -1):
if k in A and k in B:
L[n - ctn - 1][m - ctm - 1] = k
ctn += 1
ctm += 1
elif k in A:
ct *= ctm
ctn += 1
elif k in B:
ct *= ctn
ctm += 1
else:
ct *= ctm * ctn - m * n + k
if ct == 0:
break
ct = ct % (10**9 + 7)
print(ct)
| false | 7.142857 | [
"+ l = [0 for j in range(m)]",
"- l = []",
"- for j in range(m):",
"- l.append(0)"
]
| false | 0.03991 | 0.047482 | 0.84052 | [
"s419901655",
"s105093027"
]
|
u441064181 | p02701 | python | s672999419 | s521073361 | 137 | 121 | 38,396 | 38,468 | Accepted | Accepted | 11.68 | #import bisect,collections,copy,heapq,itertools,math,numpy,string
#from operator import itemgetter
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
S = [S() for _ in range(N)]
dict = {}
for s in S:
if s not in dict:
dict[s] = 1
print((len(dict)))
| #import bisect,collections,copy,heapq,itertools,math,numpy,string
#from operator import itemgetter
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
S = [S() for _ in range(N)]
dict = {}
for s in S:
dict[s] = 1
print((len(dict)))
| 15 | 14 | 461 | 440 | # import bisect,collections,copy,heapq,itertools,math,numpy,string
# from operator import itemgetter
import sys
def I():
return int(sys.stdin.readline().rstrip())
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split())
N = I()
S = [S() for _ in range(N)]
dict = {}
for s in S:
if s not in dict:
dict[s] = 1
print((len(dict)))
| # import bisect,collections,copy,heapq,itertools,math,numpy,string
# from operator import itemgetter
import sys
def I():
return int(sys.stdin.readline().rstrip())
def LI():
return list(map(int, sys.stdin.readline().rstrip().split()))
def S():
return sys.stdin.readline().rstrip()
def LS():
return list(sys.stdin.readline().rstrip().split())
N = I()
S = [S() for _ in range(N)]
dict = {}
for s in S:
dict[s] = 1
print((len(dict)))
| false | 6.666667 | [
"- if s not in dict:",
"- dict[s] = 1",
"+ dict[s] = 1"
]
| false | 0.068402 | 0.048767 | 1.402626 | [
"s672999419",
"s521073361"
]
|
u059210959 | p03377 | python | s342559056 | s411786859 | 156 | 39 | 13,124 | 10,820 | Accepted | Accepted | 75 | # encoding:utf-8
import copy
import numpy as np
import random
a,b,x = list(map(int,input().split()))
if a<= x <= a+b:
ans = True
else:
ans = False
if ans:
print("YES")
else:
print("NO")
| #!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
A, B, X = LI()
if A <= X <= A + B:
print("YES")
else:
print("NO") | 17 | 23 | 216 | 471 | # encoding:utf-8
import copy
import numpy as np
import random
a, b, x = list(map(int, input().split()))
if a <= x <= a + b:
ans = True
else:
ans = False
if ans:
print("YES")
else:
print("NO")
| #!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect # bisect_left これで二部探索の大小検索が行える
import fractions # 最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9 + 7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI():
return list(map(int, sys.stdin.readline().split()))
A, B, X = LI()
if A <= X <= A + B:
print("YES")
else:
print("NO")
| false | 26.086957 | [
"+#!/usr/bin/env python3",
"-import numpy as np",
"+import bisect # bisect_left これで二部探索の大小検索が行える",
"+import fractions # 最小公倍数などはこっち",
"+import math",
"+import sys",
"+import collections",
"+from decimal import Decimal # 10進数で考慮できる",
"-a, b, x = list(map(int, input().split()))",
"-if a <= x <= a + b:",
"- ans = True",
"-else:",
"- ans = False",
"-if ans:",
"+mod = 10**9 + 7",
"+sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000",
"+d = collections.deque()",
"+",
"+",
"+def LI():",
"+ return list(map(int, sys.stdin.readline().split()))",
"+",
"+",
"+A, B, X = LI()",
"+if A <= X <= A + B:"
]
| false | 0.076095 | 0.045497 | 1.672546 | [
"s342559056",
"s411786859"
]
|
u186838327 | p03695 | python | s471432108 | s934392177 | 163 | 18 | 38,256 | 3,064 | Accepted | Accepted | 88.96 | n = int(eval(input()))
l = list(map(int, input().split()))
d = {}
for i in range(n):
if 1<=l[i]<=399:
a = 0
elif 400<=l[i]<=799:
a = 1
elif 800<=l[i]<=1199:
a = 2
elif 1200<=l[i]<=1599:
a = 3
elif 1600<=l[i]<=1999:
a = 4
elif 2000<=l[i]<=2399:
a = 5
elif 2400<=l[i]<=2799:
a = 6
elif 2800<=l[i]<=3199:
a = 7
else:
a = 8
if a in d:
d[a] += 1
else:
d[a] = 1
if not(8 in d):
print((len(list(d.keys())), len(list(d.keys()))))
else:
if len(list(d.keys())) == 1:
print((len(list(d.keys())), len(list(d.keys()))-1+d[8]))
else:
print((len(list(d.keys()))-1, len(list(d.keys()))-1+d[8]))
| n = int(eval(input()))
A =list(map(int, input().split()))
cnt = 0
B = []
for i in range(n):
if 1 <= A[i] <= 399:
B.append(0)
elif 400 <= A[i] <= 799:
B.append(1)
elif 800 <= A[i] <= 1199:
B.append(2)
elif 1200 <= A[i] <= 1599:
B.append(3)
elif 1600 <= A[i] <= 1999:
B.append(4)
elif 2000 <= A[i] <= 2399:
B.append(5)
elif 2400 <= A[i] <= 2799:
B.append(6)
elif 2800 <= A[i] <= 3199:
B.append(7)
else:
#A[i] = 8
cnt += 1
#ans =len(set(A))+cnt-1
if len(B) == 0 and cnt != 0:
print((1, cnt))
else:
print((len(set(B)), len(set(B))+cnt))
| 34 | 29 | 640 | 675 | n = int(eval(input()))
l = list(map(int, input().split()))
d = {}
for i in range(n):
if 1 <= l[i] <= 399:
a = 0
elif 400 <= l[i] <= 799:
a = 1
elif 800 <= l[i] <= 1199:
a = 2
elif 1200 <= l[i] <= 1599:
a = 3
elif 1600 <= l[i] <= 1999:
a = 4
elif 2000 <= l[i] <= 2399:
a = 5
elif 2400 <= l[i] <= 2799:
a = 6
elif 2800 <= l[i] <= 3199:
a = 7
else:
a = 8
if a in d:
d[a] += 1
else:
d[a] = 1
if not (8 in d):
print((len(list(d.keys())), len(list(d.keys()))))
else:
if len(list(d.keys())) == 1:
print((len(list(d.keys())), len(list(d.keys())) - 1 + d[8]))
else:
print((len(list(d.keys())) - 1, len(list(d.keys())) - 1 + d[8]))
| n = int(eval(input()))
A = list(map(int, input().split()))
cnt = 0
B = []
for i in range(n):
if 1 <= A[i] <= 399:
B.append(0)
elif 400 <= A[i] <= 799:
B.append(1)
elif 800 <= A[i] <= 1199:
B.append(2)
elif 1200 <= A[i] <= 1599:
B.append(3)
elif 1600 <= A[i] <= 1999:
B.append(4)
elif 2000 <= A[i] <= 2399:
B.append(5)
elif 2400 <= A[i] <= 2799:
B.append(6)
elif 2800 <= A[i] <= 3199:
B.append(7)
else:
# A[i] = 8
cnt += 1
# ans =len(set(A))+cnt-1
if len(B) == 0 and cnt != 0:
print((1, cnt))
else:
print((len(set(B)), len(set(B)) + cnt))
| false | 14.705882 | [
"-l = list(map(int, input().split()))",
"-d = {}",
"+A = list(map(int, input().split()))",
"+cnt = 0",
"+B = []",
"- if 1 <= l[i] <= 399:",
"- a = 0",
"- elif 400 <= l[i] <= 799:",
"- a = 1",
"- elif 800 <= l[i] <= 1199:",
"- a = 2",
"- elif 1200 <= l[i] <= 1599:",
"- a = 3",
"- elif 1600 <= l[i] <= 1999:",
"- a = 4",
"- elif 2000 <= l[i] <= 2399:",
"- a = 5",
"- elif 2400 <= l[i] <= 2799:",
"- a = 6",
"- elif 2800 <= l[i] <= 3199:",
"- a = 7",
"+ if 1 <= A[i] <= 399:",
"+ B.append(0)",
"+ elif 400 <= A[i] <= 799:",
"+ B.append(1)",
"+ elif 800 <= A[i] <= 1199:",
"+ B.append(2)",
"+ elif 1200 <= A[i] <= 1599:",
"+ B.append(3)",
"+ elif 1600 <= A[i] <= 1999:",
"+ B.append(4)",
"+ elif 2000 <= A[i] <= 2399:",
"+ B.append(5)",
"+ elif 2400 <= A[i] <= 2799:",
"+ B.append(6)",
"+ elif 2800 <= A[i] <= 3199:",
"+ B.append(7)",
"- a = 8",
"- if a in d:",
"- d[a] += 1",
"- else:",
"- d[a] = 1",
"-if not (8 in d):",
"- print((len(list(d.keys())), len(list(d.keys()))))",
"+ # A[i] = 8",
"+ cnt += 1",
"+# ans =len(set(A))+cnt-1",
"+if len(B) == 0 and cnt != 0:",
"+ print((1, cnt))",
"- if len(list(d.keys())) == 1:",
"- print((len(list(d.keys())), len(list(d.keys())) - 1 + d[8]))",
"- else:",
"- print((len(list(d.keys())) - 1, len(list(d.keys())) - 1 + d[8]))",
"+ print((len(set(B)), len(set(B)) + cnt))"
]
| false | 0.08229 | 0.153426 | 0.536348 | [
"s471432108",
"s934392177"
]
|
u094191970 | p03730 | python | s379446548 | s106693637 | 180 | 17 | 2,940 | 2,940 | Accepted | Accepted | 90.56 | a,b,c=list(map(int,input().split()))
for i in range(1,10**6):
if (a*i)%b==c:
print('YES')
exit()
print('NO') | a,b,c=list(map(int,input().split()))
for i in range(1,b):
if (i*a)%b==c:
print('YES')
exit()
print('NO') | 8 | 7 | 121 | 115 | a, b, c = list(map(int, input().split()))
for i in range(1, 10**6):
if (a * i) % b == c:
print("YES")
exit()
print("NO")
| a, b, c = list(map(int, input().split()))
for i in range(1, b):
if (i * a) % b == c:
print("YES")
exit()
print("NO")
| false | 12.5 | [
"-for i in range(1, 10**6):",
"- if (a * i) % b == c:",
"+for i in range(1, b):",
"+ if (i * a) % b == c:"
]
| false | 0.098002 | 0.042255 | 2.319315 | [
"s379446548",
"s106693637"
]
|
u970197315 | p02762 | python | s713218119 | s526391499 | 1,622 | 972 | 63,988 | 37,944 | Accepted | Accepted | 40.07 | # D - Friend Suggestions
from collections import Counter
N,M,K = list(map(int,input().split()))
AB = [tuple(map(int,input().split())) for i in range(M)]
CD = [tuple(map(int,input().split())) for i in range(K)]
class UnionFind:
def __init__(self,N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self,a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self,a,b):
return self.root(a) == self.root(b)
def unite(self,a,b):
ra = self.root(a)
rb = self.root(b)
if ra == rb: return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]: self.rank[ra] += 1
self.count += 1
blocks = [[] for _ in range(N)]
for c,d in CD:
c,d = c-1,d-1
blocks[c].append(d)
blocks[d].append(c)
friends = [0] * N
uf = UnionFind(N)
for a,b in AB:
a,b = a-1,b-1
friends[a] += 1
friends[b] += 1
if uf.is_same(a,b): continue
uf.unite(a,b)
for i in range(N):
uf.root(i)
ctr = Counter()
for i in range(N):
r = uf.root(i)
ctr[r] += 1
ans = []
for i in range(N):
tmp = ctr[uf.root(i)] - 1 - friends[i]
for b in blocks[i]:
if uf.is_same(i,b):
tmp -= 1
ans.append(tmp)
print((*ans))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m, k = list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.p = [-1]*n
# union by rank
self.r = [1]*n
def find(self, x):
if self.p[x] < 0:
return x
else:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
rx, ry = self.find(x), self.find(y)
if rx != ry:
if self.r[rx] > self.r[ry]:
rx, ry = ry, rx
if self.r[rx] == self.r[ry]:
self.r[ry] += 1
self.p[ry] += self.p[rx]
self.p[rx] = ry
def same(self, x, y):
return self.find(x) == self.find(y)
def count_member(self, x):
return -self.p[self.find(x)]
uf = UnionFind(n)
ab = []
cd = []
for _ in range(m):
a, b = [int(x)-1 for x in input().split()]
ab.append((a, b))
uf.union(a, b)
for _ in range(k):
c, d = [int(x)-1 for x in input().split()]
cd.append((c, d))
ans = [uf.count_member(i)-1 for i in range(n)]
for a, b in ab:
if uf.same(a, b):
ans[a] -= 1
ans[b] -= 1
for c, d in cd:
if uf.same(c, d):
ans[c] -= 1
ans[d] -= 1
print((*ans))
| 60 | 62 | 1,525 | 1,345 | # D - Friend Suggestions
from collections import Counter
N, M, K = list(map(int, input().split()))
AB = [tuple(map(int, input().split())) for i in range(M)]
CD = [tuple(map(int, input().split())) for i in range(K)]
class UnionFind:
def __init__(self, N):
self.parent = [i for i in range(N)]
self.rank = [0] * N
self.count = 0
def root(self, a):
if self.parent[a] == a:
return a
else:
self.parent[a] = self.root(self.parent[a])
return self.parent[a]
def is_same(self, a, b):
return self.root(a) == self.root(b)
def unite(self, a, b):
ra = self.root(a)
rb = self.root(b)
if ra == rb:
return
if self.rank[ra] < self.rank[rb]:
self.parent[ra] = rb
else:
self.parent[rb] = ra
if self.rank[ra] == self.rank[rb]:
self.rank[ra] += 1
self.count += 1
blocks = [[] for _ in range(N)]
for c, d in CD:
c, d = c - 1, d - 1
blocks[c].append(d)
blocks[d].append(c)
friends = [0] * N
uf = UnionFind(N)
for a, b in AB:
a, b = a - 1, b - 1
friends[a] += 1
friends[b] += 1
if uf.is_same(a, b):
continue
uf.unite(a, b)
for i in range(N):
uf.root(i)
ctr = Counter()
for i in range(N):
r = uf.root(i)
ctr[r] += 1
ans = []
for i in range(N):
tmp = ctr[uf.root(i)] - 1 - friends[i]
for b in blocks[i]:
if uf.is_same(i, b):
tmp -= 1
ans.append(tmp)
print((*ans))
| import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**7)
n, m, k = list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.p = [-1] * n
# union by rank
self.r = [1] * n
def find(self, x):
if self.p[x] < 0:
return x
else:
self.p[x] = self.find(self.p[x])
return self.p[x]
def union(self, x, y):
rx, ry = self.find(x), self.find(y)
if rx != ry:
if self.r[rx] > self.r[ry]:
rx, ry = ry, rx
if self.r[rx] == self.r[ry]:
self.r[ry] += 1
self.p[ry] += self.p[rx]
self.p[rx] = ry
def same(self, x, y):
return self.find(x) == self.find(y)
def count_member(self, x):
return -self.p[self.find(x)]
uf = UnionFind(n)
ab = []
cd = []
for _ in range(m):
a, b = [int(x) - 1 for x in input().split()]
ab.append((a, b))
uf.union(a, b)
for _ in range(k):
c, d = [int(x) - 1 for x in input().split()]
cd.append((c, d))
ans = [uf.count_member(i) - 1 for i in range(n)]
for a, b in ab:
if uf.same(a, b):
ans[a] -= 1
ans[b] -= 1
for c, d in cd:
if uf.same(c, d):
ans[c] -= 1
ans[d] -= 1
print((*ans))
| false | 3.225806 | [
"-# D - Friend Suggestions",
"-from collections import Counter",
"+import sys",
"-N, M, K = list(map(int, input().split()))",
"-AB = [tuple(map(int, input().split())) for i in range(M)]",
"-CD = [tuple(map(int, input().split())) for i in range(K)]",
"+input = sys.stdin.readline",
"+sys.setrecursionlimit(10**7)",
"+n, m, k = list(map(int, input().split()))",
"- def __init__(self, N):",
"- self.parent = [i for i in range(N)]",
"- self.rank = [0] * N",
"- self.count = 0",
"+ def __init__(self, n):",
"+ self.p = [-1] * n",
"+ # union by rank",
"+ self.r = [1] * n",
"- def root(self, a):",
"- if self.parent[a] == a:",
"- return a",
"+ def find(self, x):",
"+ if self.p[x] < 0:",
"+ return x",
"- self.parent[a] = self.root(self.parent[a])",
"- return self.parent[a]",
"+ self.p[x] = self.find(self.p[x])",
"+ return self.p[x]",
"- def is_same(self, a, b):",
"- return self.root(a) == self.root(b)",
"+ def union(self, x, y):",
"+ rx, ry = self.find(x), self.find(y)",
"+ if rx != ry:",
"+ if self.r[rx] > self.r[ry]:",
"+ rx, ry = ry, rx",
"+ if self.r[rx] == self.r[ry]:",
"+ self.r[ry] += 1",
"+ self.p[ry] += self.p[rx]",
"+ self.p[rx] = ry",
"- def unite(self, a, b):",
"- ra = self.root(a)",
"- rb = self.root(b)",
"- if ra == rb:",
"- return",
"- if self.rank[ra] < self.rank[rb]:",
"- self.parent[ra] = rb",
"- else:",
"- self.parent[rb] = ra",
"- if self.rank[ra] == self.rank[rb]:",
"- self.rank[ra] += 1",
"- self.count += 1",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"+",
"+ def count_member(self, x):",
"+ return -self.p[self.find(x)]",
"-blocks = [[] for _ in range(N)]",
"-for c, d in CD:",
"- c, d = c - 1, d - 1",
"- blocks[c].append(d)",
"- blocks[d].append(c)",
"-friends = [0] * N",
"-uf = UnionFind(N)",
"-for a, b in AB:",
"- a, b = a - 1, b - 1",
"- friends[a] += 1",
"- friends[b] += 1",
"- if uf.is_same(a, b):",
"- continue",
"- uf.unite(a, b)",
"-for i in range(N):",
"- uf.root(i)",
"-ctr = Counter()",
"-for i in range(N):",
"- r = uf.root(i)",
"- ctr[r] += 1",
"-ans = []",
"-for i in range(N):",
"- tmp = ctr[uf.root(i)] - 1 - friends[i]",
"- for b in blocks[i]:",
"- if uf.is_same(i, b):",
"- tmp -= 1",
"- ans.append(tmp)",
"+uf = UnionFind(n)",
"+ab = []",
"+cd = []",
"+for _ in range(m):",
"+ a, b = [int(x) - 1 for x in input().split()]",
"+ ab.append((a, b))",
"+ uf.union(a, b)",
"+for _ in range(k):",
"+ c, d = [int(x) - 1 for x in input().split()]",
"+ cd.append((c, d))",
"+ans = [uf.count_member(i) - 1 for i in range(n)]",
"+for a, b in ab:",
"+ if uf.same(a, b):",
"+ ans[a] -= 1",
"+ ans[b] -= 1",
"+for c, d in cd:",
"+ if uf.same(c, d):",
"+ ans[c] -= 1",
"+ ans[d] -= 1"
]
| false | 0.039947 | 0.110907 | 0.360183 | [
"s713218119",
"s526391499"
]
|
u906428167 | p02821 | python | s466439957 | s228028161 | 1,050 | 305 | 57,220 | 55,448 | Accepted | Accepted | 70.95 | from bisect import bisect_left
from bisect import bisect_right
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
a_count = [0]*110000
a_sum = [0]*110000
for i in range(n):
a_count[a[i]] += 1
a_sum[a[i]] += a[i]
for i in range(100005,0,-1):
a_count[i] += a_count[i+1]
a_sum[i] += a_sum[i+1]
def chk(x):
case = 0
for i in range(n):
case += n-bisect_right(a,x-a[i]-1)
if case >= m:
ch = True
else:
ch = False
return ch
l = 2*a[-1]+1 #NG
r = 1 #OK
while abs(r-l) > 1:
kk = (r+l)//2
if chk(kk):
r = kk
else:
l = kk
ans = 0
sm = sum(a)
l = r
case = 0
for i in range(n):
num = n-bisect_right(a,l-a[i]-1)
case += num
ans += num*a[i]*2
ans -= (case-m)*l
print(ans) | from bisect import bisect_left
from bisect import bisect_right
n,m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
a_count = [0]*100010
a_sum = [0]*100010
for i in range(n):
a_count[a[i]] += 1
a_sum[a[i]] += a[i]
for i in range(100005,-1,-1):
a_count[i] += a_count[i+1]
a_sum[i] += a_sum[i+1]
def chk(x):
case = 0
for i in range(n):
if 0<= x-a[i]<= 10**5+5:
case += a_count[x-a[i]]
elif x-a[i] < 0:
case += n
if case >= m:
ch = True
else:
ch = False
return ch
l = 2*a[-1]+1 #NG
r = 1 #OK
while abs(r-l) > 1:
kk = (r+l)//2
if chk(kk):
r = kk
else:
l = kk
ans = 0
sm = sum(a)
l = r
case = 0
for i in range(n):
num = n-bisect_right(a,l-a[i]-1)
case += num
ans += num*a[i]*2
ans -= (case-m)*l
print(ans) | 53 | 55 | 855 | 930 | from bisect import bisect_left
from bisect import bisect_right
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
a_count = [0] * 110000
a_sum = [0] * 110000
for i in range(n):
a_count[a[i]] += 1
a_sum[a[i]] += a[i]
for i in range(100005, 0, -1):
a_count[i] += a_count[i + 1]
a_sum[i] += a_sum[i + 1]
def chk(x):
case = 0
for i in range(n):
case += n - bisect_right(a, x - a[i] - 1)
if case >= m:
ch = True
else:
ch = False
return ch
l = 2 * a[-1] + 1 # NG
r = 1 # OK
while abs(r - l) > 1:
kk = (r + l) // 2
if chk(kk):
r = kk
else:
l = kk
ans = 0
sm = sum(a)
l = r
case = 0
for i in range(n):
num = n - bisect_right(a, l - a[i] - 1)
case += num
ans += num * a[i] * 2
ans -= (case - m) * l
print(ans)
| from bisect import bisect_left
from bisect import bisect_right
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a = sorted(a)
a_count = [0] * 100010
a_sum = [0] * 100010
for i in range(n):
a_count[a[i]] += 1
a_sum[a[i]] += a[i]
for i in range(100005, -1, -1):
a_count[i] += a_count[i + 1]
a_sum[i] += a_sum[i + 1]
def chk(x):
case = 0
for i in range(n):
if 0 <= x - a[i] <= 10**5 + 5:
case += a_count[x - a[i]]
elif x - a[i] < 0:
case += n
if case >= m:
ch = True
else:
ch = False
return ch
l = 2 * a[-1] + 1 # NG
r = 1 # OK
while abs(r - l) > 1:
kk = (r + l) // 2
if chk(kk):
r = kk
else:
l = kk
ans = 0
sm = sum(a)
l = r
case = 0
for i in range(n):
num = n - bisect_right(a, l - a[i] - 1)
case += num
ans += num * a[i] * 2
ans -= (case - m) * l
print(ans)
| false | 3.636364 | [
"-a_count = [0] * 110000",
"-a_sum = [0] * 110000",
"+a_count = [0] * 100010",
"+a_sum = [0] * 100010",
"-for i in range(100005, 0, -1):",
"+for i in range(100005, -1, -1):",
"- case += n - bisect_right(a, x - a[i] - 1)",
"+ if 0 <= x - a[i] <= 10**5 + 5:",
"+ case += a_count[x - a[i]]",
"+ elif x - a[i] < 0:",
"+ case += n"
]
| false | 0.099495 | 0.092737 | 1.072877 | [
"s466439957",
"s228028161"
]
|
u811733736 | p02271 | python | s445190921 | s804921818 | 6,150 | 830 | 7,756 | 135,424 | Accepted | Accepted | 86.5 | from itertools import combinations
if __name__ == '__main__':
# ??????????????\???
num1 = int(eval(input()))
A = [int(x) for x in input().split(' ')]
num2 = int(eval(input()))
M = [int(x) for x in input().split(' ')]
#A = [1, 5, 7, 10, 21]
#pick = 4
#M = [2, 4, 17, 8]
# ????????????
results = ['no' for x in range(len(M))] # M?????¨??????????´?????????????????????????????????§????????????????????±???(no)??¨????????????
for p in range(1, len(A)+1): # A????????????1????????¨????????°?????????????????¢????????????
combi = combinations(A, p) # n??????????????¢??????????????´????????¨?????????????????????
for choice in combi:
total = sum(choice)
while total in M:
i = M.index(total)
results[i] = 'yes'
M[i] = 'Done'
# ???????????????
for txt in results:
print(txt) | from functools import lru_cache
@lru_cache(maxsize=None)
def is_possible(n, target, total):
if n == 0:
return total == target
return is_possible(n-1, target, total) or is_possible(n-1, target, total + A[n-1])
n = int(eval(input()))
A = [int(i) for i in input().split()]
_ = int(eval(input()))
for target in map(int, input().split()):
print(('yes' if is_possible(n, target, 0) else'no'))
| 27 | 17 | 935 | 415 | from itertools import combinations
if __name__ == "__main__":
# ??????????????\???
num1 = int(eval(input()))
A = [int(x) for x in input().split(" ")]
num2 = int(eval(input()))
M = [int(x) for x in input().split(" ")]
# A = [1, 5, 7, 10, 21]
# pick = 4
# M = [2, 4, 17, 8]
# ????????????
results = [
"no" for x in range(len(M))
] # M?????¨??????????´?????????????????????????????????§????????????????????±???(no)??¨????????????
for p in range(
1, len(A) + 1
): # A????????????1????????¨????????°?????????????????¢????????????
combi = combinations(
A, p
) # n??????????????¢??????????????´????????¨?????????????????????
for choice in combi:
total = sum(choice)
while total in M:
i = M.index(total)
results[i] = "yes"
M[i] = "Done"
# ???????????????
for txt in results:
print(txt)
| from functools import lru_cache
@lru_cache(maxsize=None)
def is_possible(n, target, total):
if n == 0:
return total == target
return is_possible(n - 1, target, total) or is_possible(
n - 1, target, total + A[n - 1]
)
n = int(eval(input()))
A = [int(i) for i in input().split()]
_ = int(eval(input()))
for target in map(int, input().split()):
print(("yes" if is_possible(n, target, 0) else "no"))
| false | 37.037037 | [
"-from itertools import combinations",
"+from functools import lru_cache",
"-if __name__ == \"__main__\":",
"- # ??????????????\\???",
"- num1 = int(eval(input()))",
"- A = [int(x) for x in input().split(\" \")]",
"- num2 = int(eval(input()))",
"- M = [int(x) for x in input().split(\" \")]",
"- # A = [1, 5, 7, 10, 21]",
"- # pick = 4",
"- # M = [2, 4, 17, 8]",
"- # ????????????",
"- results = [",
"- \"no\" for x in range(len(M))",
"- ] # M?????¨??????????´?????????????????????????????????§????????????????????±???(no)??¨????????????",
"- for p in range(",
"- 1, len(A) + 1",
"- ): # A????????????1????????¨????????°?????????????????¢????????????",
"- combi = combinations(",
"- A, p",
"- ) # n??????????????¢??????????????´????????¨?????????????????????",
"- for choice in combi:",
"- total = sum(choice)",
"- while total in M:",
"- i = M.index(total)",
"- results[i] = \"yes\"",
"- M[i] = \"Done\"",
"- # ???????????????",
"- for txt in results:",
"- print(txt)",
"+",
"+@lru_cache(maxsize=None)",
"+def is_possible(n, target, total):",
"+ if n == 0:",
"+ return total == target",
"+ return is_possible(n - 1, target, total) or is_possible(",
"+ n - 1, target, total + A[n - 1]",
"+ )",
"+",
"+",
"+n = int(eval(input()))",
"+A = [int(i) for i in input().split()]",
"+_ = int(eval(input()))",
"+for target in map(int, input().split()):",
"+ print((\"yes\" if is_possible(n, target, 0) else \"no\"))"
]
| false | 0.036723 | 0.036594 | 1.003527 | [
"s445190921",
"s804921818"
]
|
u910288980 | p03416 | python | s828545791 | s091411646 | 104 | 53 | 2,940 | 2,940 | Accepted | Accepted | 49.04 | a, b = list(map(int, input().split()))
ans = 0
for x in range(a,b+1):
s = str(x)
if s == ''.join(reversed(s)):
ans += 1
print(ans)
| a, b = list(map(int, input().split()))
ans = 0
for x in range(a,b+1):
s = str(x)
# if s == ''.join(reversed(s)):
if s == s[::-1] :
ans += 1
print(ans)
| 9 | 10 | 151 | 176 | a, b = list(map(int, input().split()))
ans = 0
for x in range(a, b + 1):
s = str(x)
if s == "".join(reversed(s)):
ans += 1
print(ans)
| a, b = list(map(int, input().split()))
ans = 0
for x in range(a, b + 1):
s = str(x)
# if s == ''.join(reversed(s)):
if s == s[::-1]:
ans += 1
print(ans)
| false | 10 | [
"- if s == \"\".join(reversed(s)):",
"+ # if s == ''.join(reversed(s)):",
"+ if s == s[::-1]:"
]
| false | 0.050231 | 0.04443 | 1.130563 | [
"s828545791",
"s091411646"
]
|
u698868214 | p02898 | python | s790087177 | s024333140 | 63 | 58 | 18,532 | 18,652 | Accepted | Accepted | 7.94 | N,K = list(map(int,input().split()))
h = list(map(int,input().split()))
h = sorted(h)
line = 0
bool1 = False
for i in range(N):
if h[i] >= K:
line = i
bool1 = True
break
if bool1:
print((N-i))
else:
print((0)) | N,K = list(map(int,input().split()))
h = list(map(int,input().split()))
ans = 0
for i in h:
if i >= K:
ans += 1
print(ans) | 16 | 8 | 234 | 130 | N, K = list(map(int, input().split()))
h = list(map(int, input().split()))
h = sorted(h)
line = 0
bool1 = False
for i in range(N):
if h[i] >= K:
line = i
bool1 = True
break
if bool1:
print((N - i))
else:
print((0))
| N, K = list(map(int, input().split()))
h = list(map(int, input().split()))
ans = 0
for i in h:
if i >= K:
ans += 1
print(ans)
| false | 50 | [
"-h = sorted(h)",
"-line = 0",
"-bool1 = False",
"-for i in range(N):",
"- if h[i] >= K:",
"- line = i",
"- bool1 = True",
"- break",
"-if bool1:",
"- print((N - i))",
"-else:",
"- print((0))",
"+ans = 0",
"+for i in h:",
"+ if i >= K:",
"+ ans += 1",
"+print(ans)"
]
| false | 0.048011 | 0.044964 | 1.067773 | [
"s790087177",
"s024333140"
]
|
u401452016 | p02936 | python | s227915521 | s991455134 | 1,897 | 1,660 | 351,060 | 328,172 | Accepted | Accepted | 12.49 | import sys
sys.setrecursionlimit(1000000)
L = sys.stdin.readlines()
for i in range(len(L)):
L[i] = list(map(int, L[i].split()))
n =L[0][0]
rin = [[] for _ in range(n)]
for v in L[1:n]:
rin[v[0]-1].append(v[1]-1)
rin[v[1]-1].append(v[0]-1)
score = [0 for _ in range(n)]
for ele in L[n:]:
score[ele[0]-1] +=ele[1]
#print(score)
def dfs(p, bp=-1):
for c in rin[p]:
if c != bp:
#print(c)
score[c]+= score[p]
dfs(c, p)
dfs(0)
print((*score)) | #ABC138D
#node:節 edge:枝
def main():
import sys
sys.setrecursionlimit(200005)
N, Q = list(map(int, sys.stdin.readline().split()))
edge = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N-1)]
#1:ノードのリストを作る
nodeL = [[] for _ in range(N)]
for a, b in edge:
nodeL[a-1].append(b-1)
nodeL[b-1].append(a-1)
#print(nodeL)
px = [tuple(map(int, sys.stdin.readline().split())) for _ in range(Q)]
#print(px)
score = [0 for i in range(N)]
for p, x in px:
score[p-1] +=x
#print(score)
result = score.copy()
def dfs(p, g=-1):
for c in nodeL[p]:
if c !=g:
score[c] +=score[p]
dfs(c, p)
dfs(0)
print((*score))
if __name__=='__main__':
main()
| 26 | 35 | 533 | 834 | import sys
sys.setrecursionlimit(1000000)
L = sys.stdin.readlines()
for i in range(len(L)):
L[i] = list(map(int, L[i].split()))
n = L[0][0]
rin = [[] for _ in range(n)]
for v in L[1:n]:
rin[v[0] - 1].append(v[1] - 1)
rin[v[1] - 1].append(v[0] - 1)
score = [0 for _ in range(n)]
for ele in L[n:]:
score[ele[0] - 1] += ele[1]
# print(score)
def dfs(p, bp=-1):
for c in rin[p]:
if c != bp:
# print(c)
score[c] += score[p]
dfs(c, p)
dfs(0)
print((*score))
| # ABC138D
# node:節 edge:枝
def main():
import sys
sys.setrecursionlimit(200005)
N, Q = list(map(int, sys.stdin.readline().split()))
edge = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N - 1)]
# 1:ノードのリストを作る
nodeL = [[] for _ in range(N)]
for a, b in edge:
nodeL[a - 1].append(b - 1)
nodeL[b - 1].append(a - 1)
# print(nodeL)
px = [tuple(map(int, sys.stdin.readline().split())) for _ in range(Q)]
# print(px)
score = [0 for i in range(N)]
for p, x in px:
score[p - 1] += x
# print(score)
result = score.copy()
def dfs(p, g=-1):
for c in nodeL[p]:
if c != g:
score[c] += score[p]
dfs(c, p)
dfs(0)
print((*score))
if __name__ == "__main__":
main()
| false | 25.714286 | [
"-import sys",
"+# ABC138D",
"+# node:節 edge:枝",
"+def main():",
"+ import sys",
"-sys.setrecursionlimit(1000000)",
"-L = sys.stdin.readlines()",
"-for i in range(len(L)):",
"- L[i] = list(map(int, L[i].split()))",
"-n = L[0][0]",
"-rin = [[] for _ in range(n)]",
"-for v in L[1:n]:",
"- rin[v[0] - 1].append(v[1] - 1)",
"- rin[v[1] - 1].append(v[0] - 1)",
"-score = [0 for _ in range(n)]",
"-for ele in L[n:]:",
"- score[ele[0] - 1] += ele[1]",
"-# print(score)",
"-def dfs(p, bp=-1):",
"- for c in rin[p]:",
"- if c != bp:",
"- # print(c)",
"- score[c] += score[p]",
"- dfs(c, p)",
"+ sys.setrecursionlimit(200005)",
"+ N, Q = list(map(int, sys.stdin.readline().split()))",
"+ edge = [tuple(map(int, sys.stdin.readline().split())) for _ in range(N - 1)]",
"+ # 1:ノードのリストを作る",
"+ nodeL = [[] for _ in range(N)]",
"+ for a, b in edge:",
"+ nodeL[a - 1].append(b - 1)",
"+ nodeL[b - 1].append(a - 1)",
"+ # print(nodeL)",
"+ px = [tuple(map(int, sys.stdin.readline().split())) for _ in range(Q)]",
"+ # print(px)",
"+ score = [0 for i in range(N)]",
"+ for p, x in px:",
"+ score[p - 1] += x",
"+ # print(score)",
"+ result = score.copy()",
"+",
"+ def dfs(p, g=-1):",
"+ for c in nodeL[p]:",
"+ if c != g:",
"+ score[c] += score[p]",
"+ dfs(c, p)",
"+",
"+ dfs(0)",
"+ print((*score))",
"-dfs(0)",
"-print((*score))",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.040481 | 0.040663 | 0.995509 | [
"s227915521",
"s991455134"
]
|
u102242691 | p03658 | python | s615073701 | s316258470 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 |
N,K = list(map(int,input().split()))
l = list(map(int,input().split()))
k = sorted(l)
ans = 0
for i in range(K):
ans += k.pop()
print(ans)
|
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
l.sort(reverse = True)
ans = 0
for i in range(k):
ans += l[i]
print(ans)
| 12 | 9 | 153 | 153 | N, K = list(map(int, input().split()))
l = list(map(int, input().split()))
k = sorted(l)
ans = 0
for i in range(K):
ans += k.pop()
print(ans)
| n, k = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort(reverse=True)
ans = 0
for i in range(k):
ans += l[i]
print(ans)
| false | 25 | [
"-N, K = list(map(int, input().split()))",
"+n, k = list(map(int, input().split()))",
"-k = sorted(l)",
"+l.sort(reverse=True)",
"-for i in range(K):",
"- ans += k.pop()",
"+for i in range(k):",
"+ ans += l[i]"
]
| false | 0.0468 | 0.044821 | 1.044139 | [
"s615073701",
"s316258470"
]
|
u229973939 | p02388 | python | s636003275 | s963204137 | 20 | 10 | 5,576 | 5,576 | Accepted | Accepted | 50 |
x = eval(input())
print((int(x) ** 3))
|
x = int(eval(input()))
print((x*x*x))
| 3 | 3 | 34 | 33 | x = eval(input())
print((int(x) ** 3))
| x = int(eval(input()))
print((x * x * x))
| false | 0 | [
"-x = eval(input())",
"-print((int(x) ** 3))",
"+x = int(eval(input()))",
"+print((x * x * x))"
]
| false | 0.039025 | 0.074343 | 0.524936 | [
"s636003275",
"s963204137"
]
|
u425762225 | p03971 | python | s011244473 | s826927679 | 407 | 69 | 4,000 | 9,780 | Accepted | Accepted | 83.05 | N, A, B = list(map(int,input().split()))
S = eval(input())
a_counter = 0
b_counter = 0
for i in range(N):
s = S[0]
if s == "a" and a_counter + b_counter <A+B:
a_counter += 1
print("Yes")
elif s == "b" and b_counter < B and a_counter + b_counter <A+B:
b_counter += 1
print("Yes")
else:
print("No")
S = S[1:] | #!/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
# @njit
def solve(n,a,b,s):
ans = [""]*n
japaneseStudents = 0
foreignStudents = 0
for i in range(n):
if s[i] == "a" and japaneseStudents + foreignStudents < a+b:
ans[i] = "Yes"
japaneseStudents += 1
elif s[i] == "b" and japaneseStudents + foreignStudents < a+b and foreignStudents < b:
ans[i] = "Yes"
foreignStudents += 1
else:
ans[i] = "No"
return ans
def main():
N,A,B = list(map(int,input().split()))
s = eval(input())
ans = solve(N,A,B,s)
for i in range(N):
print((ans[i]))
return
if __name__ == '__main__':
main()
| 18 | 38 | 346 | 825 | N, A, B = list(map(int, input().split()))
S = eval(input())
a_counter = 0
b_counter = 0
for i in range(N):
s = S[0]
if s == "a" and a_counter + b_counter < A + B:
a_counter += 1
print("Yes")
elif s == "b" and b_counter < B and a_counter + b_counter < A + B:
b_counter += 1
print("Yes")
else:
print("No")
S = S[1:]
| #!/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
# @njit
def solve(n, a, b, s):
ans = [""] * n
japaneseStudents = 0
foreignStudents = 0
for i in range(n):
if s[i] == "a" and japaneseStudents + foreignStudents < a + b:
ans[i] = "Yes"
japaneseStudents += 1
elif (
s[i] == "b"
and japaneseStudents + foreignStudents < a + b
and foreignStudents < b
):
ans[i] = "Yes"
foreignStudents += 1
else:
ans[i] = "No"
return ans
def main():
N, A, B = list(map(int, input().split()))
s = eval(input())
ans = solve(N, A, B, s)
for i in range(N):
print((ans[i]))
return
if __name__ == "__main__":
main()
| false | 52.631579 | [
"-N, A, B = list(map(int, input().split()))",
"-S = eval(input())",
"-a_counter = 0",
"-b_counter = 0",
"-for i in range(N):",
"- s = S[0]",
"- if s == \"a\" and a_counter + b_counter < A + B:",
"- a_counter += 1",
"- print(\"Yes\")",
"- elif s == \"b\" and b_counter < B and a_counter + b_counter < A + B:",
"- b_counter += 1",
"- print(\"Yes\")",
"- else:",
"- print(\"No\")",
"- S = S[1:]",
"+#!/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",
"+# @njit",
"+def solve(n, a, b, s):",
"+ ans = [\"\"] * n",
"+ japaneseStudents = 0",
"+ foreignStudents = 0",
"+ for i in range(n):",
"+ if s[i] == \"a\" and japaneseStudents + foreignStudents < a + b:",
"+ ans[i] = \"Yes\"",
"+ japaneseStudents += 1",
"+ elif (",
"+ s[i] == \"b\"",
"+ and japaneseStudents + foreignStudents < a + b",
"+ and foreignStudents < b",
"+ ):",
"+ ans[i] = \"Yes\"",
"+ foreignStudents += 1",
"+ else:",
"+ ans[i] = \"No\"",
"+ return ans",
"+",
"+",
"+def main():",
"+ N, A, B = list(map(int, input().split()))",
"+ s = eval(input())",
"+ ans = solve(N, A, B, s)",
"+ for i in range(N):",
"+ print((ans[i]))",
"+ return",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.11444 | 0.036171 | 3.163887 | [
"s011244473",
"s826927679"
]
|
u761529120 | p02949 | python | s963096695 | s873243156 | 1,635 | 717 | 54,748 | 48,876 | Accepted | Accepted | 56.15 | from collections import deque
import sys
input = sys.stdin.readline
def main():
N, M, P = list(map(int, input().split()))
edge = [[] for _ in range(N)]
redge = [[] for _ in range(N)]
for _ in range(M):
A, B, C = list(map(int, input().split()))
A -= 1
B -= 1
C -= P
C = -C
edge[A].append((B,C))
redge[B].append(A)
# 0 => N-1の間にある閉路を検出したいので
# 0とN-1からたどりつけない場所は前処理で取り除く
visited1, visited2 = {0}, {N-1}
stack = [0]
while stack:
v = stack.pop()
for dest, _ in edge[v]:
if dest in visited1:
continue
visited1.add(dest)
stack.append(dest)
stack = [N-1]
while stack:
v = stack.pop()
for dest in redge[v]:
if dest in visited2:
continue
visited2.add(dest)
stack.append(dest)
OK = visited1 & visited2
new_edge = [[] for _ in range(N)]
for s in range(N):
for t, c in edge[s]:
if t in OK:
new_edge[s].append((t,c))
flag = True
d = [float('inf')] * N
d[0] = 0
#ベルマンフォード法、N回実行してまだ更新されている場合は負の閉路が存在する
for _ in range(N):
flag = False
for v, e in enumerate(new_edge):
for t, c in e:
if d[v] != float('inf') and d[v] + c < d[t]:
d[t] = d[v] + c
flag = True
if not flag:
print((max(0,-d[N-1])))
exit()
else:
print((-1))
exit()
if __name__ == "__main__":
main() | from collections import deque
import sys
input = sys.stdin.readline
def main():
N, M, P = list(map(int, input().split()))
edge = []
g = [[] for _ in range(N)]
rg = [[] for _ in range(N)]
for _ in range(M):
A, B, C = list(map(int, input().split()))
A -= 1
B -= 1
C -= P
C = -C
edge.append((A,B,C))
g[A].append(B)
rg[B].append(A)
# 0 => N-1の間にある閉路を検出したいので
# 0とN-1からたどりつけない場所は前処理で取り除く
visited1 = set()
visited2 = set()
visited1.add(0)
visited2.add(N-1)
Q = deque()
Q.append(0)
while Q:
v = Q.popleft()
for dest in g[v]:
if dest in visited1:
continue
visited1.add(dest)
Q.append(dest)
Q.append(N-1)
while Q:
v = Q.popleft()
for dest in rg[v]:
if dest in visited2:
continue
visited2.add(dest)
Q.append(dest)
OK = visited1 & visited2
flag = True
d = [float('inf')] * N
d[0] = 0
#ベルマンフォード法、N回実行してまだ更新されている場合は負の閉路が存在する
for _ in range(N):
flag = False
for a, b, c in edge:
if not a in OK:
continue
if not b in OK:
continue
newD = d[a] + c
if newD < d[b]:
d[b] = newD
flag = True
if not flag:
print((max(0,-d[N-1])))
exit()
else:
print((-1))
exit()
if __name__ == "__main__":
main() | 70 | 73 | 1,668 | 1,626 | from collections import deque
import sys
input = sys.stdin.readline
def main():
N, M, P = list(map(int, input().split()))
edge = [[] for _ in range(N)]
redge = [[] for _ in range(N)]
for _ in range(M):
A, B, C = list(map(int, input().split()))
A -= 1
B -= 1
C -= P
C = -C
edge[A].append((B, C))
redge[B].append(A)
# 0 => N-1の間にある閉路を検出したいので
# 0とN-1からたどりつけない場所は前処理で取り除く
visited1, visited2 = {0}, {N - 1}
stack = [0]
while stack:
v = stack.pop()
for dest, _ in edge[v]:
if dest in visited1:
continue
visited1.add(dest)
stack.append(dest)
stack = [N - 1]
while stack:
v = stack.pop()
for dest in redge[v]:
if dest in visited2:
continue
visited2.add(dest)
stack.append(dest)
OK = visited1 & visited2
new_edge = [[] for _ in range(N)]
for s in range(N):
for t, c in edge[s]:
if t in OK:
new_edge[s].append((t, c))
flag = True
d = [float("inf")] * N
d[0] = 0
# ベルマンフォード法、N回実行してまだ更新されている場合は負の閉路が存在する
for _ in range(N):
flag = False
for v, e in enumerate(new_edge):
for t, c in e:
if d[v] != float("inf") and d[v] + c < d[t]:
d[t] = d[v] + c
flag = True
if not flag:
print((max(0, -d[N - 1])))
exit()
else:
print((-1))
exit()
if __name__ == "__main__":
main()
| from collections import deque
import sys
input = sys.stdin.readline
def main():
N, M, P = list(map(int, input().split()))
edge = []
g = [[] for _ in range(N)]
rg = [[] for _ in range(N)]
for _ in range(M):
A, B, C = list(map(int, input().split()))
A -= 1
B -= 1
C -= P
C = -C
edge.append((A, B, C))
g[A].append(B)
rg[B].append(A)
# 0 => N-1の間にある閉路を検出したいので
# 0とN-1からたどりつけない場所は前処理で取り除く
visited1 = set()
visited2 = set()
visited1.add(0)
visited2.add(N - 1)
Q = deque()
Q.append(0)
while Q:
v = Q.popleft()
for dest in g[v]:
if dest in visited1:
continue
visited1.add(dest)
Q.append(dest)
Q.append(N - 1)
while Q:
v = Q.popleft()
for dest in rg[v]:
if dest in visited2:
continue
visited2.add(dest)
Q.append(dest)
OK = visited1 & visited2
flag = True
d = [float("inf")] * N
d[0] = 0
# ベルマンフォード法、N回実行してまだ更新されている場合は負の閉路が存在する
for _ in range(N):
flag = False
for a, b, c in edge:
if not a in OK:
continue
if not b in OK:
continue
newD = d[a] + c
if newD < d[b]:
d[b] = newD
flag = True
if not flag:
print((max(0, -d[N - 1])))
exit()
else:
print((-1))
exit()
if __name__ == "__main__":
main()
| false | 4.109589 | [
"- edge = [[] for _ in range(N)]",
"- redge = [[] for _ in range(N)]",
"+ edge = []",
"+ g = [[] for _ in range(N)]",
"+ rg = [[] for _ in range(N)]",
"- edge[A].append((B, C))",
"- redge[B].append(A)",
"+ edge.append((A, B, C))",
"+ g[A].append(B)",
"+ rg[B].append(A)",
"- visited1, visited2 = {0}, {N - 1}",
"- stack = [0]",
"- while stack:",
"- v = stack.pop()",
"- for dest, _ in edge[v]:",
"+ visited1 = set()",
"+ visited2 = set()",
"+ visited1.add(0)",
"+ visited2.add(N - 1)",
"+ Q = deque()",
"+ Q.append(0)",
"+ while Q:",
"+ v = Q.popleft()",
"+ for dest in g[v]:",
"- stack.append(dest)",
"- stack = [N - 1]",
"- while stack:",
"- v = stack.pop()",
"- for dest in redge[v]:",
"+ Q.append(dest)",
"+ Q.append(N - 1)",
"+ while Q:",
"+ v = Q.popleft()",
"+ for dest in rg[v]:",
"- stack.append(dest)",
"+ Q.append(dest)",
"- new_edge = [[] for _ in range(N)]",
"- for s in range(N):",
"- for t, c in edge[s]:",
"- if t in OK:",
"- new_edge[s].append((t, c))",
"- for v, e in enumerate(new_edge):",
"- for t, c in e:",
"- if d[v] != float(\"inf\") and d[v] + c < d[t]:",
"- d[t] = d[v] + c",
"- flag = True",
"+ for a, b, c in edge:",
"+ if not a in OK:",
"+ continue",
"+ if not b in OK:",
"+ continue",
"+ newD = d[a] + c",
"+ if newD < d[b]:",
"+ d[b] = newD",
"+ flag = True"
]
| false | 0.081132 | 0.099846 | 0.812568 | [
"s963096695",
"s873243156"
]
|
u633068244 | p01225 | python | s787475387 | s286757113 | 20 | 10 | 4,280 | 4,276 | Accepted | Accepted | 50 | def rm_123(A):
if len(A) == 0: return 1
for a in set(A):
if set([a,a+1,a+2]) <= set(A):
if len(A) == 3: return 1
A1 = A[:]
for i in range(3): A1.remove(a+i)
return judge(A1)
def rm_111(A):
if len(A) == 0: return 1
for a in set(A):
if A.count(a) >= 3:
if len(A) == 3: return 1
A1 = A[:]
for i in range(3): A1.remove(a)
return judge(A1)
def judge(A):
return rm_123(A) or rm_111(A)
for _ in range(eval(input())):
n = list(map(int,input().split()))
R = []; G = []; B = []
s = input().split()
for i in range(len(n)):
if s[i] == "R": R.append(n[i])
elif s[i] == "G": G.append(n[i])
elif s[i] == "B": B.append(n[i])
print(1 if judge(R) and judge(G) and judge(B) else 0)
| def rm_123(A):
if len(A) == 0: return 1
for a in set(A):
if set([a,a+1,a+2]) <= set(A):
A1 = A[:]
for i in range(3): A1.remove(a+i)
return judge(A1)
def rm_111(A):
if len(A) == 0: return 1
for a in set(A):
if A.count(a) >= 3:
A1 = A[:]
for i in range(3): A1.remove(a)
return judge(A1)
def judge(A):
return rm_123(A) or rm_111(A)
for _ in range(eval(input())):
n = list(map(int,input().split()))
R = []; G = []; B = []
s = input().split()
for i in range(len(n)):
if s[i] == "R": R.append(n[i])
elif s[i] == "G": G.append(n[i])
elif s[i] == "B": B.append(n[i])
print(1 if judge(R) and judge(G) and judge(B) else 0)
| 31 | 29 | 739 | 681 | def rm_123(A):
if len(A) == 0:
return 1
for a in set(A):
if set([a, a + 1, a + 2]) <= set(A):
if len(A) == 3:
return 1
A1 = A[:]
for i in range(3):
A1.remove(a + i)
return judge(A1)
def rm_111(A):
if len(A) == 0:
return 1
for a in set(A):
if A.count(a) >= 3:
if len(A) == 3:
return 1
A1 = A[:]
for i in range(3):
A1.remove(a)
return judge(A1)
def judge(A):
return rm_123(A) or rm_111(A)
for _ in range(eval(input())):
n = list(map(int, input().split()))
R = []
G = []
B = []
s = input().split()
for i in range(len(n)):
if s[i] == "R":
R.append(n[i])
elif s[i] == "G":
G.append(n[i])
elif s[i] == "B":
B.append(n[i])
print(1 if judge(R) and judge(G) and judge(B) else 0)
| def rm_123(A):
if len(A) == 0:
return 1
for a in set(A):
if set([a, a + 1, a + 2]) <= set(A):
A1 = A[:]
for i in range(3):
A1.remove(a + i)
return judge(A1)
def rm_111(A):
if len(A) == 0:
return 1
for a in set(A):
if A.count(a) >= 3:
A1 = A[:]
for i in range(3):
A1.remove(a)
return judge(A1)
def judge(A):
return rm_123(A) or rm_111(A)
for _ in range(eval(input())):
n = list(map(int, input().split()))
R = []
G = []
B = []
s = input().split()
for i in range(len(n)):
if s[i] == "R":
R.append(n[i])
elif s[i] == "G":
G.append(n[i])
elif s[i] == "B":
B.append(n[i])
print(1 if judge(R) and judge(G) and judge(B) else 0)
| false | 6.451613 | [
"- if len(A) == 3:",
"- return 1",
"- if len(A) == 3:",
"- return 1"
]
| false | 0.036398 | 0.042036 | 0.865881 | [
"s787475387",
"s286757113"
]
|
u347184682 | p02947 | python | s732045366 | s024886464 | 461 | 288 | 44,800 | 28,048 | Accepted | Accepted | 37.53 | n=int(eval(input()))
ans=0
s=[[x for x in eval(input())] for i in range(n)]
dic={}
for i in s:
temp=tuple(sorted(i))
if temp in dic:
ans+=dic[temp]
dic[temp]+=1
else:
dic[temp]=1
print(ans) | import collections
ans=0
dic={}
n=int(eval(input()))
for i in range(n):
s=eval(input())
sl=[i for i in s]
sl.sort()
ss=tuple(sl)
if ss not in dic:
dic[ss]=1
else:
ans+=dic[ss]
dic[ss]+=1
print(ans) | 13 | 18 | 208 | 229 | n = int(eval(input()))
ans = 0
s = [[x for x in eval(input())] for i in range(n)]
dic = {}
for i in s:
temp = tuple(sorted(i))
if temp in dic:
ans += dic[temp]
dic[temp] += 1
else:
dic[temp] = 1
print(ans)
| import collections
ans = 0
dic = {}
n = int(eval(input()))
for i in range(n):
s = eval(input())
sl = [i for i in s]
sl.sort()
ss = tuple(sl)
if ss not in dic:
dic[ss] = 1
else:
ans += dic[ss]
dic[ss] += 1
print(ans)
| false | 27.777778 | [
"+import collections",
"+",
"+ans = 0",
"+dic = {}",
"-ans = 0",
"-s = [[x for x in eval(input())] for i in range(n)]",
"-dic = {}",
"-for i in s:",
"- temp = tuple(sorted(i))",
"- if temp in dic:",
"- ans += dic[temp]",
"- dic[temp] += 1",
"+for i in range(n):",
"+ s = eval(input())",
"+ sl = [i for i in s]",
"+ sl.sort()",
"+ ss = tuple(sl)",
"+ if ss not in dic:",
"+ dic[ss] = 1",
"- dic[temp] = 1",
"+ ans += dic[ss]",
"+ dic[ss] += 1"
]
| false | 0.07756 | 0.04317 | 1.796627 | [
"s732045366",
"s024886464"
]
|
u347640436 | p03295 | python | s479933886 | s901028856 | 1,059 | 310 | 32,272 | 23,368 | Accepted | Accepted | 70.73 | # Segment tree
class SegmentTree():
_data = []
_offset = 0
_size = 0
def __init__(self, size):
_size = size
t = 1
while t < size:
t *= 2
self._offset = t - 1
self._data = [0 for _ in range(t * 2 - 1)]
def update(self, index, value):
i = self._offset + index
self._data[i] = value
while i >= 1:
i = (i - 1) // 2
self._data[i] = self._data[i * 2 + 1] + self._data[i * 2 + 2]
def query(self, start, stop):
result = 0
l = start + self._offset
r = stop + self._offset
while l < r:
if l & 1 == 0:
result = result + self._data[l]
if r & 1 == 0:
result = result + self._data[r - 1]
l = l // 2
r = (r - 1) // 2
return result
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
ab.sort(key=lambda x: x[1])
st = SegmentTree(N - 1)
result = 0
for a, b in ab:
a, b = a - 1, b - 1
if st.query(a, b) != 0:
continue
result += 1
st.update(b - 1, 1)
print(result)
| N, M = list(map(int, input().split()))
ab = [[] for _ in range(N + 1)]
for _ in range(M):
a, b = list(map(int, input().split()))
ab[a].append(b)
dp = [0] * (N + 1)
for i in range(1, N + 1):
dp[i] = max(dp[i], dp[i - 1])
for j in ab[i]:
dp[j] = max(dp[j], dp[i] + 1)
print((dp[N]))
| 49 | 14 | 1,207 | 307 | # Segment tree
class SegmentTree:
_data = []
_offset = 0
_size = 0
def __init__(self, size):
_size = size
t = 1
while t < size:
t *= 2
self._offset = t - 1
self._data = [0 for _ in range(t * 2 - 1)]
def update(self, index, value):
i = self._offset + index
self._data[i] = value
while i >= 1:
i = (i - 1) // 2
self._data[i] = self._data[i * 2 + 1] + self._data[i * 2 + 2]
def query(self, start, stop):
result = 0
l = start + self._offset
r = stop + self._offset
while l < r:
if l & 1 == 0:
result = result + self._data[l]
if r & 1 == 0:
result = result + self._data[r - 1]
l = l // 2
r = (r - 1) // 2
return result
N, M = list(map(int, input().split()))
ab = [list(map(int, input().split())) for _ in range(M)]
ab.sort(key=lambda x: x[1])
st = SegmentTree(N - 1)
result = 0
for a, b in ab:
a, b = a - 1, b - 1
if st.query(a, b) != 0:
continue
result += 1
st.update(b - 1, 1)
print(result)
| N, M = list(map(int, input().split()))
ab = [[] for _ in range(N + 1)]
for _ in range(M):
a, b = list(map(int, input().split()))
ab[a].append(b)
dp = [0] * (N + 1)
for i in range(1, N + 1):
dp[i] = max(dp[i], dp[i - 1])
for j in ab[i]:
dp[j] = max(dp[j], dp[i] + 1)
print((dp[N]))
| false | 71.428571 | [
"-# Segment tree",
"-class SegmentTree:",
"- _data = []",
"- _offset = 0",
"- _size = 0",
"-",
"- def __init__(self, size):",
"- _size = size",
"- t = 1",
"- while t < size:",
"- t *= 2",
"- self._offset = t - 1",
"- self._data = [0 for _ in range(t * 2 - 1)]",
"-",
"- def update(self, index, value):",
"- i = self._offset + index",
"- self._data[i] = value",
"- while i >= 1:",
"- i = (i - 1) // 2",
"- self._data[i] = self._data[i * 2 + 1] + self._data[i * 2 + 2]",
"-",
"- def query(self, start, stop):",
"- result = 0",
"- l = start + self._offset",
"- r = stop + self._offset",
"- while l < r:",
"- if l & 1 == 0:",
"- result = result + self._data[l]",
"- if r & 1 == 0:",
"- result = result + self._data[r - 1]",
"- l = l // 2",
"- r = (r - 1) // 2",
"- return result",
"-",
"-",
"-ab = [list(map(int, input().split())) for _ in range(M)]",
"-ab.sort(key=lambda x: x[1])",
"-st = SegmentTree(N - 1)",
"-result = 0",
"-for a, b in ab:",
"- a, b = a - 1, b - 1",
"- if st.query(a, b) != 0:",
"- continue",
"- result += 1",
"- st.update(b - 1, 1)",
"-print(result)",
"+ab = [[] for _ in range(N + 1)]",
"+for _ in range(M):",
"+ a, b = list(map(int, input().split()))",
"+ ab[a].append(b)",
"+dp = [0] * (N + 1)",
"+for i in range(1, N + 1):",
"+ dp[i] = max(dp[i], dp[i - 1])",
"+ for j in ab[i]:",
"+ dp[j] = max(dp[j], dp[i] + 1)",
"+print((dp[N]))"
]
| false | 0.085413 | 0.119762 | 0.713188 | [
"s479933886",
"s901028856"
]
|
u182765930 | p02909 | python | s148687581 | s751990326 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | l=["Sunny","Cloudy","Rainy"]
print((l[(l.index(eval(input()))+1)%3]))
| l=["Rainy","Cloudy","Sunny"]
print((l[l.index(eval(input()))-1])) | 2 | 2 | 63 | 58 | l = ["Sunny", "Cloudy", "Rainy"]
print((l[(l.index(eval(input())) + 1) % 3]))
| l = ["Rainy", "Cloudy", "Sunny"]
print((l[l.index(eval(input())) - 1]))
| false | 0 | [
"-l = [\"Sunny\", \"Cloudy\", \"Rainy\"]",
"-print((l[(l.index(eval(input())) + 1) % 3]))",
"+l = [\"Rainy\", \"Cloudy\", \"Sunny\"]",
"+print((l[l.index(eval(input())) - 1]))"
]
| false | 0.041914 | 0.040708 | 1.029623 | [
"s148687581",
"s751990326"
]
|
u743164083 | p03106 | python | s803555823 | s496907768 | 28 | 25 | 8,968 | 8,992 | Accepted | Accepted | 10.71 | def com_div(x, y):
dv = []
m = min(x, y)
for i in range(1, m + 1):
if x % i == 0 and y % i == 0:
dv.append(i)
dv.sort()
return dv[::-1]
a, b, k = list(map(int, input().split()))
print((com_div(a, b)[k - 1])) | def com_div(x, y):
dv = []
for i in range(min(x, y), 0, -1):
if x % i == 0 and y % i == 0:
dv.append(i)
return dv
a, b, k = list(map(int, input().split()))
print((com_div(a, b)[k - 1]))
| 12 | 10 | 258 | 227 | def com_div(x, y):
dv = []
m = min(x, y)
for i in range(1, m + 1):
if x % i == 0 and y % i == 0:
dv.append(i)
dv.sort()
return dv[::-1]
a, b, k = list(map(int, input().split()))
print((com_div(a, b)[k - 1]))
| def com_div(x, y):
dv = []
for i in range(min(x, y), 0, -1):
if x % i == 0 and y % i == 0:
dv.append(i)
return dv
a, b, k = list(map(int, input().split()))
print((com_div(a, b)[k - 1]))
| false | 16.666667 | [
"- m = min(x, y)",
"- for i in range(1, m + 1):",
"+ for i in range(min(x, y), 0, -1):",
"- dv.sort()",
"- return dv[::-1]",
"+ return dv"
]
| false | 0.047383 | 0.04742 | 0.999218 | [
"s803555823",
"s496907768"
]
|
u784022244 | p02897 | python | s930165673 | s028661612 | 19 | 17 | 2,940 | 2,940 | Accepted | Accepted | 10.53 | N=int(eval(input()))
if N%2==0:
print(((N/2)/N))
else:
print(((N//2+1)/N)) | N=int(eval(input()))
if N%2==0:
print((0.5))
else:
print(((N//2+1)/N)) | 7 | 6 | 78 | 70 | N = int(eval(input()))
if N % 2 == 0:
print(((N / 2) / N))
else:
print(((N // 2 + 1) / N))
| N = int(eval(input()))
if N % 2 == 0:
print((0.5))
else:
print(((N // 2 + 1) / N))
| false | 14.285714 | [
"- print(((N / 2) / N))",
"+ print((0.5))"
]
| false | 0.042899 | 0.04592 | 0.934214 | [
"s930165673",
"s028661612"
]
|
u309977459 | p03682 | python | s845983461 | s153301268 | 1,798 | 1,137 | 122,968 | 54,488 | Accepted | Accepted | 36.76 | from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
G = [[] for _ in range(N)]
for i in range(N-1):
G[X[i][1]].append((X[i+1][0]-X[i][0], X[i+1][1]))
G[X[i+1][1]].append((X[i+1][0]-X[i][0], X[i][1]))
G[Y[i][1]].append((Y[i+1][0]-Y[i][0], Y[i+1][1]))
G[Y[i+1][1]].append((Y[i+1][0]-Y[i][0], Y[i][1]))
q = []
heapq.heapify(q)
for elem in G[0]:
heapq.heappush(q, elem)
used = [False] * N
used[0] = True
ans = 0
while q:
res = heapq.heappop(q)
cost, nq = res
if not used[nq]:
used[nq] = True
ans += cost
for elem in G[nq]:
heapq.heappush(q, elem)
print(ans)
| from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
import sys
sys.setrecursionlimit(10**6)
class UnionFind(object):
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
else:
return False
u = UnionFind(N)
q = []
for i in range(N-1):
q.append((X[i+1][0]-X[i][0], X[i+1][1], X[i][1]))
q.append((Y[i+1][0]-Y[i][0], Y[i+1][1], Y[i][1]))
q.sort(key=itemgetter(0))
ans = 0
for elem in q:
cost, a, b = elem
if u.union(a, b):
ans += cost
print(ans)
| 34 | 53 | 830 | 1,277 | from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
G = [[] for _ in range(N)]
for i in range(N - 1):
G[X[i][1]].append((X[i + 1][0] - X[i][0], X[i + 1][1]))
G[X[i + 1][1]].append((X[i + 1][0] - X[i][0], X[i][1]))
G[Y[i][1]].append((Y[i + 1][0] - Y[i][0], Y[i + 1][1]))
G[Y[i + 1][1]].append((Y[i + 1][0] - Y[i][0], Y[i][1]))
q = []
heapq.heapify(q)
for elem in G[0]:
heapq.heappush(q, elem)
used = [False] * N
used[0] = True
ans = 0
while q:
res = heapq.heappop(q)
cost, nq = res
if not used[nq]:
used[nq] = True
ans += cost
for elem in G[nq]:
heapq.heappush(q, elem)
print(ans)
| from operator import itemgetter
import heapq
N = int(eval(input()))
X = []
Y = []
for i in range(N):
x, y = list(map(int, input().split()))
X.append((x, i))
Y.append((y, i))
X.sort(key=itemgetter(0))
Y.sort(key=itemgetter(0))
import sys
sys.setrecursionlimit(10**6)
class UnionFind(object):
def __init__(self, size):
self.table = [-1 for _ in range(size)]
def find(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self.find(self.table[x])
return self.table[x]
def union(self, x, y):
s1 = self.find(x)
s2 = self.find(y)
if s1 != s2:
if self.table[s1] <= self.table[s2]:
self.table[s1] += self.table[s2]
self.table[s2] = s1
else:
self.table[s2] += self.table[s1]
self.table[s1] = s2
return True
else:
return False
u = UnionFind(N)
q = []
for i in range(N - 1):
q.append((X[i + 1][0] - X[i][0], X[i + 1][1], X[i][1]))
q.append((Y[i + 1][0] - Y[i][0], Y[i + 1][1], Y[i][1]))
q.sort(key=itemgetter(0))
ans = 0
for elem in q:
cost, a, b = elem
if u.union(a, b):
ans += cost
print(ans)
| false | 35.849057 | [
"-G = [[] for _ in range(N)]",
"+import sys",
"+",
"+sys.setrecursionlimit(10**6)",
"+",
"+",
"+class UnionFind(object):",
"+ def __init__(self, size):",
"+ self.table = [-1 for _ in range(size)]",
"+",
"+ def find(self, x):",
"+ if self.table[x] < 0:",
"+ return x",
"+ else:",
"+ self.table[x] = self.find(self.table[x])",
"+ return self.table[x]",
"+",
"+ def union(self, x, y):",
"+ s1 = self.find(x)",
"+ s2 = self.find(y)",
"+ if s1 != s2:",
"+ if self.table[s1] <= self.table[s2]:",
"+ self.table[s1] += self.table[s2]",
"+ self.table[s2] = s1",
"+ else:",
"+ self.table[s2] += self.table[s1]",
"+ self.table[s1] = s2",
"+ return True",
"+ else:",
"+ return False",
"+",
"+",
"+u = UnionFind(N)",
"+q = []",
"- G[X[i][1]].append((X[i + 1][0] - X[i][0], X[i + 1][1]))",
"- G[X[i + 1][1]].append((X[i + 1][0] - X[i][0], X[i][1]))",
"- G[Y[i][1]].append((Y[i + 1][0] - Y[i][0], Y[i + 1][1]))",
"- G[Y[i + 1][1]].append((Y[i + 1][0] - Y[i][0], Y[i][1]))",
"-q = []",
"-heapq.heapify(q)",
"-for elem in G[0]:",
"- heapq.heappush(q, elem)",
"-used = [False] * N",
"-used[0] = True",
"+ q.append((X[i + 1][0] - X[i][0], X[i + 1][1], X[i][1]))",
"+ q.append((Y[i + 1][0] - Y[i][0], Y[i + 1][1], Y[i][1]))",
"+q.sort(key=itemgetter(0))",
"-while q:",
"- res = heapq.heappop(q)",
"- cost, nq = res",
"- if not used[nq]:",
"- used[nq] = True",
"+for elem in q:",
"+ cost, a, b = elem",
"+ if u.union(a, b):",
"- for elem in G[nq]:",
"- heapq.heappush(q, elem)"
]
| false | 0.170722 | 0.088064 | 1.938624 | [
"s845983461",
"s153301268"
]
|
u606878291 | p03208 | python | s500959832 | s148271409 | 233 | 214 | 11,628 | 8,280 | Accepted | Accepted | 8.15 | N, K = list(map(int, input().split(' ')))
heights = sorted([int(eval(input())) for _ in range(N)])
print((min([_max - _min for _min, _max in zip(heights, heights[K - 1:])])))
| N, K = list(map(int, input().split(' ')))
heights = sorted([int(eval(input())) for _ in range(N)])
print((min((_max - _min for _min, _max in zip(heights, heights[K - 1:])))))
| 3 | 3 | 163 | 163 | N, K = list(map(int, input().split(" ")))
heights = sorted([int(eval(input())) for _ in range(N)])
print((min([_max - _min for _min, _max in zip(heights, heights[K - 1 :])])))
| N, K = list(map(int, input().split(" ")))
heights = sorted([int(eval(input())) for _ in range(N)])
print((min((_max - _min for _min, _max in zip(heights, heights[K - 1 :])))))
| false | 0 | [
"-print((min([_max - _min for _min, _max in zip(heights, heights[K - 1 :])])))",
"+print((min((_max - _min for _min, _max in zip(heights, heights[K - 1 :])))))"
]
| false | 0.046896 | 0.040987 | 1.144174 | [
"s500959832",
"s148271409"
]
|
u333945892 | p02845 | python | s039444088 | s283610645 | 97 | 76 | 15,412 | 15,164 | Accepted | Accepted | 21.65 |
from collections import defaultdict,deque
import sys,heapq,bisect,math,itertools,string,queue,copy,time
sys.setrecursionlimit(10**8)
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
def inpl_str(): return list(sys.stdin.readline().split())
N = inp()
AA = inpl()
cnts = [0]*(N+1)
cnts[-1] = 3
ans = 1
for a in AA:
ans *= (cnts[a-1] - cnts[a])
ans %= mod
cnts[a] += 1
print(ans)
| c = [0]*(int(eval(input()))+1)
c[-1] = 3
ans = 1
for a in list(map(int, input().split())):
ans = (ans * (c[a-1] - c[a]))%(10**9+7)
c[a] += 1
print(ans)
| 25 | 7 | 524 | 160 | from collections import defaultdict, deque
import sys, heapq, bisect, math, itertools, string, queue, copy, time
sys.setrecursionlimit(10**8)
INF = float("inf")
mod = 10**9 + 7
eps = 10**-7
def inp():
return int(sys.stdin.readline())
def inpl():
return list(map(int, sys.stdin.readline().split()))
def inpl_str():
return list(sys.stdin.readline().split())
N = inp()
AA = inpl()
cnts = [0] * (N + 1)
cnts[-1] = 3
ans = 1
for a in AA:
ans *= cnts[a - 1] - cnts[a]
ans %= mod
cnts[a] += 1
print(ans)
| c = [0] * (int(eval(input())) + 1)
c[-1] = 3
ans = 1
for a in list(map(int, input().split())):
ans = (ans * (c[a - 1] - c[a])) % (10**9 + 7)
c[a] += 1
print(ans)
| false | 72 | [
"-from collections import defaultdict, deque",
"-import sys, heapq, bisect, math, itertools, string, queue, copy, time",
"-",
"-sys.setrecursionlimit(10**8)",
"-INF = float(\"inf\")",
"-mod = 10**9 + 7",
"-eps = 10**-7",
"-",
"-",
"-def inp():",
"- return int(sys.stdin.readline())",
"-",
"-",
"-def inpl():",
"- return list(map(int, sys.stdin.readline().split()))",
"-",
"-",
"-def inpl_str():",
"- return list(sys.stdin.readline().split())",
"-",
"-",
"-N = inp()",
"-AA = inpl()",
"-cnts = [0] * (N + 1)",
"-cnts[-1] = 3",
"+c = [0] * (int(eval(input())) + 1)",
"+c[-1] = 3",
"-for a in AA:",
"- ans *= cnts[a - 1] - cnts[a]",
"- ans %= mod",
"- cnts[a] += 1",
"+for a in list(map(int, input().split())):",
"+ ans = (ans * (c[a - 1] - c[a])) % (10**9 + 7)",
"+ c[a] += 1"
]
| false | 0.095322 | 0.120956 | 0.788072 | [
"s039444088",
"s283610645"
]
|
u509739538 | p02708 | python | s659151314 | s719878584 | 162 | 140 | 9,648 | 9,188 | Accepted | Accepted | 13.58 | import math
import queue
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChars():
return input().split()
x = readInts()
n = x[0]
k = x[1]
def ts(l):
return int((l*(l-1))/2)
def ts2(l):
return int(l*(n+n-(l-1))/2)
s = 0
for i in range(k,n+2):
s += ts2(i)+1-ts(i)
print((s%(1000000007))) | x=list(map(int,input().split()))
n,k=x
s=0
for i in range(k,n+2):
s+=int(i*(n+n-(i-1))/2)+1-int((i*(i-1))/2)
print((s%(1000000007))) | 28 | 6 | 378 | 136 | import math
import queue
def readInt():
return int(eval(input()))
def readInts():
return list(map(int, input().split()))
def readChars():
return input().split()
x = readInts()
n = x[0]
k = x[1]
def ts(l):
return int((l * (l - 1)) / 2)
def ts2(l):
return int(l * (n + n - (l - 1)) / 2)
s = 0
for i in range(k, n + 2):
s += ts2(i) + 1 - ts(i)
print((s % (1000000007)))
| x = list(map(int, input().split()))
n, k = x
s = 0
for i in range(k, n + 2):
s += int(i * (n + n - (i - 1)) / 2) + 1 - int((i * (i - 1)) / 2)
print((s % (1000000007)))
| false | 78.571429 | [
"-import math",
"-import queue",
"-",
"-",
"-def readInt():",
"- return int(eval(input()))",
"-",
"-",
"-def readInts():",
"- return list(map(int, input().split()))",
"-",
"-",
"-def readChars():",
"- return input().split()",
"-",
"-",
"-x = readInts()",
"-n = x[0]",
"-k = x[1]",
"-",
"-",
"-def ts(l):",
"- return int((l * (l - 1)) / 2)",
"-",
"-",
"-def ts2(l):",
"- return int(l * (n + n - (l - 1)) / 2)",
"-",
"-",
"+x = list(map(int, input().split()))",
"+n, k = x",
"- s += ts2(i) + 1 - ts(i)",
"+ s += int(i * (n + n - (i - 1)) / 2) + 1 - int((i * (i - 1)) / 2)"
]
| false | 0.071888 | 0.062141 | 1.156843 | [
"s659151314",
"s719878584"
]
|
u761529120 | p03286 | python | s895046572 | s508938357 | 165 | 64 | 38,256 | 61,864 | Accepted | Accepted | 61.21 | def main():
N = int(eval(input()))
ans = ''
while N != 0:
if N % 2 != 0:
N -= 1
ans = '1' + ans
else:
ans = "0" + ans
N = N // (-2)
if ans == "":
ans = "0"
print(ans)
main() | def main():
N = int(eval(input()))
if N == 0:
print((0))
ans = ''
base = 1
while N != 0:
if N % (base * -2) == 0:
ans += '0'
else:
ans += "1"
N -= base
base *= -2
ans = list(ans)
ans.reverse()
print((''.join(ans)))
if __name__ == "__main__":
main() | 19 | 19 | 294 | 361 | def main():
N = int(eval(input()))
ans = ""
while N != 0:
if N % 2 != 0:
N -= 1
ans = "1" + ans
else:
ans = "0" + ans
N = N // (-2)
if ans == "":
ans = "0"
print(ans)
main()
| def main():
N = int(eval(input()))
if N == 0:
print((0))
ans = ""
base = 1
while N != 0:
if N % (base * -2) == 0:
ans += "0"
else:
ans += "1"
N -= base
base *= -2
ans = list(ans)
ans.reverse()
print(("".join(ans)))
if __name__ == "__main__":
main()
| false | 0 | [
"+ if N == 0:",
"+ print((0))",
"+ base = 1",
"- if N % 2 != 0:",
"- N -= 1",
"- ans = \"1\" + ans",
"+ if N % (base * -2) == 0:",
"+ ans += \"0\"",
"- ans = \"0\" + ans",
"- N = N // (-2)",
"- if ans == \"\":",
"- ans = \"0\"",
"- print(ans)",
"+ ans += \"1\"",
"+ N -= base",
"+ base *= -2",
"+ ans = list(ans)",
"+ ans.reverse()",
"+ print((\"\".join(ans)))",
"-main()",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.058838 | 0.037227 | 1.580516 | [
"s895046572",
"s508938357"
]
|
u072717685 | p02819 | python | s557886135 | s066756729 | 98 | 71 | 86,600 | 62,744 | Accepted | Accepted | 27.55 | from bisect import bisect
def main():
maxa2 = 200000
maxa2 = max(6, maxa2) # maxa2が6未満だとエラーになる
p = [False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(maxa2)]
p[0] = p[1] = False
p[2] = p[3] = p[5] = True
for is1 in range(3, maxa2, 2):
for is2 in range(is1 ** 2, maxa2, is1):
p[is2] = False
prime_list = [i for i, b in enumerate(p) if b]
x = int(eval(input()))
if x in prime_list:
print(x)
else:
xp = bisect(prime_list, x)
r = prime_list[xp]
print(r)
if __name__ == '__main__':
main() | from math import sqrt, ceil
def main():
x = int(eval(input()))
while True:
for i1 in range(2, ceil(sqrt(x))):
if x % i1 == 0:
x += 1
break
else:
break
print(x)
if __name__ == '__main__':
main()
| 22 | 14 | 620 | 290 | from bisect import bisect
def main():
maxa2 = 200000
maxa2 = max(6, maxa2) # maxa2が6未満だとエラーになる
p = [
False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(maxa2)
]
p[0] = p[1] = False
p[2] = p[3] = p[5] = True
for is1 in range(3, maxa2, 2):
for is2 in range(is1**2, maxa2, is1):
p[is2] = False
prime_list = [i for i, b in enumerate(p) if b]
x = int(eval(input()))
if x in prime_list:
print(x)
else:
xp = bisect(prime_list, x)
r = prime_list[xp]
print(r)
if __name__ == "__main__":
main()
| from math import sqrt, ceil
def main():
x = int(eval(input()))
while True:
for i1 in range(2, ceil(sqrt(x))):
if x % i1 == 0:
x += 1
break
else:
break
print(x)
if __name__ == "__main__":
main()
| false | 36.363636 | [
"-from bisect import bisect",
"+from math import sqrt, ceil",
"- maxa2 = 200000",
"- maxa2 = max(6, maxa2) # maxa2が6未満だとエラーになる",
"- p = [",
"- False if i % 2 == 0 or i % 3 == 0 or i % 5 == 0 else True for i in range(maxa2)",
"- ]",
"- p[0] = p[1] = False",
"- p[2] = p[3] = p[5] = True",
"- for is1 in range(3, maxa2, 2):",
"- for is2 in range(is1**2, maxa2, is1):",
"- p[is2] = False",
"- prime_list = [i for i, b in enumerate(p) if b]",
"- if x in prime_list:",
"- print(x)",
"- else:",
"- xp = bisect(prime_list, x)",
"- r = prime_list[xp]",
"- print(r)",
"+ while True:",
"+ for i1 in range(2, ceil(sqrt(x))):",
"+ if x % i1 == 0:",
"+ x += 1",
"+ break",
"+ else:",
"+ break",
"+ print(x)"
]
| false | 0.651809 | 0.039674 | 16.429013 | [
"s557886135",
"s066756729"
]
|
u326609687 | p03108 | python | s596927420 | s824053492 | 598 | 423 | 23,252 | 23,224 | Accepted | Accepted | 29.26 | N, M = list(map(int, input().split()))
ab = [tuple([int(x)-1 for x in input().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main() | import sys
N, M = list(map(int, input().split()))
ab = [tuple([int(x)-1 for x in sys.stdin.readline().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main() | 46 | 48 | 1,161 | 1,188 | N, M = list(map(int, input().split()))
ab = [tuple([int(x) - 1 for x in input().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main()
| import sys
N, M = list(map(int, input().split()))
ab = [tuple([int(x) - 1 for x in sys.stdin.readline().split()]) for _ in range(M)]
class UnionFind:
def __init__(self, size):
self.rank = [-1 for _ in range(size)]
self.number = [1 for _ in range(size)]
def find(self, x):
while self.rank[x] >= 0:
x = self.rank[x]
return x
def union(self, s1, s2):
if s1 == s2:
return
if self.rank[s1] == self.rank[s2]:
self.rank[s1] -= 1
self.rank[s2] = s1
self.number[s1] += self.number[s2]
elif self.rank[s1] < self.rank[s2]:
self.rank[s2] = s1
self.number[s1] += self.number[s2]
else:
self.rank[s1] = s2
self.number[s2] += self.number[s1]
def main():
uf = UnionFind(N)
p = N * (N - 1) // 2
ans = [p]
for x, y in reversed(ab[1:]):
px = uf.find(x)
py = uf.find(y)
if px != py:
p -= uf.number[px] * uf.number[py]
uf.union(px, py)
ans.append(p)
for a in reversed(ans):
print(a)
main()
| false | 4.166667 | [
"+import sys",
"+",
"-ab = [tuple([int(x) - 1 for x in input().split()]) for _ in range(M)]",
"+ab = [tuple([int(x) - 1 for x in sys.stdin.readline().split()]) for _ in range(M)]"
]
| false | 0.079896 | 0.03372 | 2.369378 | [
"s596927420",
"s824053492"
]
|
u532966492 | p03766 | python | s241458769 | s374508116 | 742 | 490 | 2,940 | 10,740 | Accepted | Accepted | 33.96 | n=int(eval(input()));a,b,c,p=1,1,n,n-1
for i in range(n-1):
p+=a-1;a,b,c=b,c,((n-1)**2+p+c)%(10**9+7)
print(c) | n=int(eval(input()))-1;a,b,c,p=1,1,n+1,n
for _ in[0]*n:p+=a-1;a,b,c=b,c,(n*n+p+c)%(10**9+7)
print(c) | 4 | 3 | 108 | 96 | n = int(eval(input()))
a, b, c, p = 1, 1, n, n - 1
for i in range(n - 1):
p += a - 1
a, b, c = b, c, ((n - 1) ** 2 + p + c) % (10**9 + 7)
print(c)
| n = int(eval(input())) - 1
a, b, c, p = 1, 1, n + 1, n
for _ in [0] * n:
p += a - 1
a, b, c = b, c, (n * n + p + c) % (10**9 + 7)
print(c)
| false | 25 | [
"-n = int(eval(input()))",
"-a, b, c, p = 1, 1, n, n - 1",
"-for i in range(n - 1):",
"+n = int(eval(input())) - 1",
"+a, b, c, p = 1, 1, n + 1, n",
"+for _ in [0] * n:",
"- a, b, c = b, c, ((n - 1) ** 2 + p + c) % (10**9 + 7)",
"+ a, b, c = b, c, (n * n + p + c) % (10**9 + 7)"
]
| false | 0.182729 | 0.139388 | 1.310933 | [
"s241458769",
"s374508116"
]
|
u711693740 | p02733 | python | s312762237 | s383524023 | 417 | 360 | 3,188 | 3,188 | Accepted | Accepted | 13.67 | from itertools import product
H, W, K = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
S_T = [[int(s[w]) for s in S] for w in range(W)]
sumS = sum(map(sum, S_T))
ans = (H - 1) * (W - 1)
if sumS <= K:
print((0))
else:
for i in product([True, False], repeat=H-1):
cnt = sum(i)
if cnt >= ans:
continue
M = [[0]]
for j, k in enumerate(i):
if k:
M.append([])
M[-1].append(j+1)
A = [0] * len(M)
for s_t in S_T:
for l, m in enumerate(M):
A[l] += sum(s_t[i] for i in m)
if any(a > K for a in A):
cnt += 1
if cnt >= ans:
break
A = [sum(s_t[i] for i in m) for m in M]
if any(a > K for a in A):
cnt = ans + 1
break
ans = min(cnt, ans)
print(ans)
| def main():
from itertools import product
H, W, K = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
S_T = [[int(s[w]) for s in S] for w in range(W)]
sumS = sum(map(sum, S_T))
ans = (H - 1) * (W - 1)
if sumS <= K:
print((0))
else:
for i in product([True, False], repeat=H-1):
cnt = sum(i)
if cnt >= ans:
continue
M = [[0]]
for j, k in enumerate(i):
if k:
M.append([])
M[-1].append(j+1)
A = [0] * len(M)
for s_t in S_T:
for l, m in enumerate(M):
A[l] += sum(s_t[i] for i in m)
if any(a > K for a in A):
cnt += 1
if cnt >= ans:
break
A = [sum(s_t[i] for i in m) for m in M]
if any(a > K for a in A):
cnt = ans + 1
break
ans = min(cnt, ans)
print(ans)
if __name__ == '__main__':
main() | 34 | 38 | 963 | 1,145 | from itertools import product
H, W, K = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
S_T = [[int(s[w]) for s in S] for w in range(W)]
sumS = sum(map(sum, S_T))
ans = (H - 1) * (W - 1)
if sumS <= K:
print((0))
else:
for i in product([True, False], repeat=H - 1):
cnt = sum(i)
if cnt >= ans:
continue
M = [[0]]
for j, k in enumerate(i):
if k:
M.append([])
M[-1].append(j + 1)
A = [0] * len(M)
for s_t in S_T:
for l, m in enumerate(M):
A[l] += sum(s_t[i] for i in m)
if any(a > K for a in A):
cnt += 1
if cnt >= ans:
break
A = [sum(s_t[i] for i in m) for m in M]
if any(a > K for a in A):
cnt = ans + 1
break
ans = min(cnt, ans)
print(ans)
| def main():
from itertools import product
H, W, K = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
S_T = [[int(s[w]) for s in S] for w in range(W)]
sumS = sum(map(sum, S_T))
ans = (H - 1) * (W - 1)
if sumS <= K:
print((0))
else:
for i in product([True, False], repeat=H - 1):
cnt = sum(i)
if cnt >= ans:
continue
M = [[0]]
for j, k in enumerate(i):
if k:
M.append([])
M[-1].append(j + 1)
A = [0] * len(M)
for s_t in S_T:
for l, m in enumerate(M):
A[l] += sum(s_t[i] for i in m)
if any(a > K for a in A):
cnt += 1
if cnt >= ans:
break
A = [sum(s_t[i] for i in m) for m in M]
if any(a > K for a in A):
cnt = ans + 1
break
ans = min(cnt, ans)
print(ans)
if __name__ == "__main__":
main()
| false | 10.526316 | [
"-from itertools import product",
"+def main():",
"+ from itertools import product",
"-H, W, K = list(map(int, input().split()))",
"-S = [eval(input()) for _ in range(H)]",
"-S_T = [[int(s[w]) for s in S] for w in range(W)]",
"-sumS = sum(map(sum, S_T))",
"-ans = (H - 1) * (W - 1)",
"-if sumS <= K:",
"- print((0))",
"-else:",
"- for i in product([True, False], repeat=H - 1):",
"- cnt = sum(i)",
"- if cnt >= ans:",
"- continue",
"- M = [[0]]",
"- for j, k in enumerate(i):",
"- if k:",
"- M.append([])",
"- M[-1].append(j + 1)",
"- A = [0] * len(M)",
"- for s_t in S_T:",
"- for l, m in enumerate(M):",
"- A[l] += sum(s_t[i] for i in m)",
"- if any(a > K for a in A):",
"- cnt += 1",
"- if cnt >= ans:",
"- break",
"- A = [sum(s_t[i] for i in m) for m in M]",
"+ H, W, K = list(map(int, input().split()))",
"+ S = [eval(input()) for _ in range(H)]",
"+ S_T = [[int(s[w]) for s in S] for w in range(W)]",
"+ sumS = sum(map(sum, S_T))",
"+ ans = (H - 1) * (W - 1)",
"+ if sumS <= K:",
"+ print((0))",
"+ else:",
"+ for i in product([True, False], repeat=H - 1):",
"+ cnt = sum(i)",
"+ if cnt >= ans:",
"+ continue",
"+ M = [[0]]",
"+ for j, k in enumerate(i):",
"+ if k:",
"+ M.append([])",
"+ M[-1].append(j + 1)",
"+ A = [0] * len(M)",
"+ for s_t in S_T:",
"+ for l, m in enumerate(M):",
"+ A[l] += sum(s_t[i] for i in m)",
"- cnt = ans + 1",
"- break",
"- ans = min(cnt, ans)",
"- print(ans)",
"+ cnt += 1",
"+ if cnt >= ans:",
"+ break",
"+ A = [sum(s_t[i] for i in m) for m in M]",
"+ if any(a > K for a in A):",
"+ cnt = ans + 1",
"+ break",
"+ ans = min(cnt, ans)",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
]
| false | 0.074642 | 0.034568 | 2.159309 | [
"s312762237",
"s383524023"
]
|
u957872856 | p03273 | python | s697756143 | s532660600 | 30 | 18 | 4,468 | 3,188 | Accepted | Accepted | 40 | h, w = map(int, input().split())
a = [''] * h
for i in range(h):
a[i] = input()
row = [False] * h
col = [False] * w
for i in range(h):
for j in range(w):
if a[i][j] == '#':
row[i] = True
col[j] = True
for i in range(h):
if row[i]:
for j in range(w):
if col[j]:
print(a[i][j], end = '')
print()
| h,w = list(map(int,input().split()))
a = [[j for j in eval(input())] for i in range(h)]
b = [x for x in a if "#" in x]
c = list(zip(*[y for y in zip(*b) if "#" in y]))
for d in c:
print(("".join(d))) | 17 | 6 | 331 | 186 | h, w = map(int, input().split())
a = [""] * h
for i in range(h):
a[i] = input()
row = [False] * h
col = [False] * w
for i in range(h):
for j in range(w):
if a[i][j] == "#":
row[i] = True
col[j] = True
for i in range(h):
if row[i]:
for j in range(w):
if col[j]:
print(a[i][j], end="")
print()
| h, w = list(map(int, input().split()))
a = [[j for j in eval(input())] for i in range(h)]
b = [x for x in a if "#" in x]
c = list(zip(*[y for y in zip(*b) if "#" in y]))
for d in c:
print(("".join(d)))
| false | 64.705882 | [
"-h, w = map(int, input().split())",
"-a = [\"\"] * h",
"-for i in range(h):",
"- a[i] = input()",
"-row = [False] * h",
"-col = [False] * w",
"-for i in range(h):",
"- for j in range(w):",
"- if a[i][j] == \"#\":",
"- row[i] = True",
"- col[j] = True",
"-for i in range(h):",
"- if row[i]:",
"- for j in range(w):",
"- if col[j]:",
"- print(a[i][j], end=\"\")",
"- print()",
"+h, w = list(map(int, input().split()))",
"+a = [[j for j in eval(input())] for i in range(h)]",
"+b = [x for x in a if \"#\" in x]",
"+c = list(zip(*[y for y in zip(*b) if \"#\" in y]))",
"+for d in c:",
"+ print((\"\".join(d)))"
]
| false | 0.046484 | 0.046372 | 1.002416 | [
"s697756143",
"s532660600"
]
|
u571281863 | p02660 | python | s704216152 | s529504381 | 201 | 82 | 9,276 | 9,292 | Accepted | Accepted | 59.2 | N=int(eval(input()))
p=[]
r=0
if N%2==0:
c=0
while N%2==0:
c+=1
N/=2
p.append([c])
i=3
while i<N**0.5+1:
if N%i==0:
c=0
while N%i==0:
c+=1
N/=i
p.append([c])
i+=2
if N!=1:
p.append([1])
for i in range(len(p)):
j=1
while p[i][0]>=j:
p[i][0]-=j
j+=1
r+=1
print(r) | N=int(eval(input()))
p=[]
r=0
if N%2==0:
c=0
while N%2==0:
c+=1
N/=2
p.append(c)
for i in range(3,int(N**0.5)+1,2):
if N%i==0:
c=0
while N%i==0:
c+=1
N/=i
p.append(c)
if N!=1:
p.append(1)
for i in p:
r+=int(((8*i+1)**0.5-1)/2)
print(r) | 32 | 25 | 361 | 307 | N = int(eval(input()))
p = []
r = 0
if N % 2 == 0:
c = 0
while N % 2 == 0:
c += 1
N /= 2
p.append([c])
i = 3
while i < N**0.5 + 1:
if N % i == 0:
c = 0
while N % i == 0:
c += 1
N /= i
p.append([c])
i += 2
if N != 1:
p.append([1])
for i in range(len(p)):
j = 1
while p[i][0] >= j:
p[i][0] -= j
j += 1
r += 1
print(r)
| N = int(eval(input()))
p = []
r = 0
if N % 2 == 0:
c = 0
while N % 2 == 0:
c += 1
N /= 2
p.append(c)
for i in range(3, int(N**0.5) + 1, 2):
if N % i == 0:
c = 0
while N % i == 0:
c += 1
N /= i
p.append(c)
if N != 1:
p.append(1)
for i in p:
r += int(((8 * i + 1) ** 0.5 - 1) / 2)
print(r)
| false | 21.875 | [
"- p.append([c])",
"-i = 3",
"-while i < N**0.5 + 1:",
"+ p.append(c)",
"+for i in range(3, int(N**0.5) + 1, 2):",
"- p.append([c])",
"- i += 2",
"+ p.append(c)",
"- p.append([1])",
"-for i in range(len(p)):",
"- j = 1",
"- while p[i][0] >= j:",
"- p[i][0] -= j",
"- j += 1",
"- r += 1",
"+ p.append(1)",
"+for i in p:",
"+ r += int(((8 * i + 1) ** 0.5 - 1) / 2)"
]
| false | 0.037475 | 0.04208 | 0.89058 | [
"s704216152",
"s529504381"
]
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.