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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
u073852194 | p03599 | python | s199892115 | s168482694 | 631 | 47 | 43,116 | 3,064 | Accepted | Accepted | 92.55 | a,b,c,d,e,f = list(map(int,input().split()))
total = 0
sugar = 0
max_concentration = 0
for i in range(f//(100*a)+1):
for j in range(f//(100*b)+1):
for k in range(f//c+1):
for l in range(f//d+1):
if 0 < 100*(a*i+b*j)+(c*k+d*l)<=f and c*k+d*l<=e*(a*i+b*j):
if max_concentration <= (c*k+d*l)/(100*(a*i+b*j)+(c*k+d*l)):
max_concentration = (c*k+d*l)/(100*(a*i+b*j)+(c*k+d*l))
total = 100*(a*i+b*j)+(c*k+d*l)
sugar = (c*k+d*l)
print((total,sugar)) | A, B, C, D, E, F = list(map(int, input().split()))
water = [0 for _ in range(30 + 1)]
sugar = [0 for _ in range(3000 + 1)]
water[0] = 1
sugar[0] = 1
for i in range(30):
if water[i]:
if i + A <= 30:
water[i + A] = 1
if i + B <= 30:
water[i + B] = 1
for j in range(3000):
if sugar[j]:
if j + C <= 3000:
sugar[j + C] = 1
if j + D <= 3000:
sugar[j + D] = 1
concentration = 0
ans = (100 * A, 0)
for i in range(31):
if not water[i]:
continue
for j in range(3001):
if not sugar[j]:
continue
if i + j == 0 or 100 * i + j > F or j > E * i:
continue
if concentration * (100 * i + j) < 100 * j:
concentration = (100 * j) / (100 * i + j)
ans = (100 * i + j, j)
print((*ans)) | 16 | 38 | 583 | 874 | a, b, c, d, e, f = list(map(int, input().split()))
total = 0
sugar = 0
max_concentration = 0
for i in range(f // (100 * a) + 1):
for j in range(f // (100 * b) + 1):
for k in range(f // c + 1):
for l in range(f // d + 1):
if 0 < 100 * (a * i + b * j) + (
c * k + d * l
) <= f and c * k + d * l <= e * (a * i + b * j):
if max_concentration <= (c * k + d * l) / (
100 * (a * i + b * j) + (c * k + d * l)
):
max_concentration = (c * k + d * l) / (
100 * (a * i + b * j) + (c * k + d * l)
)
total = 100 * (a * i + b * j) + (c * k + d * l)
sugar = c * k + d * l
print((total, sugar))
| A, B, C, D, E, F = list(map(int, input().split()))
water = [0 for _ in range(30 + 1)]
sugar = [0 for _ in range(3000 + 1)]
water[0] = 1
sugar[0] = 1
for i in range(30):
if water[i]:
if i + A <= 30:
water[i + A] = 1
if i + B <= 30:
water[i + B] = 1
for j in range(3000):
if sugar[j]:
if j + C <= 3000:
sugar[j + C] = 1
if j + D <= 3000:
sugar[j + D] = 1
concentration = 0
ans = (100 * A, 0)
for i in range(31):
if not water[i]:
continue
for j in range(3001):
if not sugar[j]:
continue
if i + j == 0 or 100 * i + j > F or j > E * i:
continue
if concentration * (100 * i + j) < 100 * j:
concentration = (100 * j) / (100 * i + j)
ans = (100 * i + j, j)
print((*ans))
| false | 57.894737 | [
"-a, b, c, d, e, f = list(map(int, input().split()))",
"-total = 0",
"-sugar = 0",
"-max_concentration = 0",
"-for i in range(f // (100 * a) + 1):",
"- for j in range(f // (100 * b) + 1):",
"- for k in range(f // c + 1):",
"- for l in range(f // d + 1):",
"- if 0 < 100 * (a * i + b * j) + (",
"- c * k + d * l",
"- ) <= f and c * k + d * l <= e * (a * i + b * j):",
"- if max_concentration <= (c * k + d * l) / (",
"- 100 * (a * i + b * j) + (c * k + d * l)",
"- ):",
"- max_concentration = (c * k + d * l) / (",
"- 100 * (a * i + b * j) + (c * k + d * l)",
"- )",
"- total = 100 * (a * i + b * j) + (c * k + d * l)",
"- sugar = c * k + d * l",
"-print((total, sugar))",
"+A, B, C, D, E, F = list(map(int, input().split()))",
"+water = [0 for _ in range(30 + 1)]",
"+sugar = [0 for _ in range(3000 + 1)]",
"+water[0] = 1",
"+sugar[0] = 1",
"+for i in range(30):",
"+ if water[i]:",
"+ if i + A <= 30:",
"+ water[i + A] = 1",
"+ if i + B <= 30:",
"+ water[i + B] = 1",
"+for j in range(3000):",
"+ if sugar[j]:",
"+ if j + C <= 3000:",
"+ sugar[j + C] = 1",
"+ if j + D <= 3000:",
"+ sugar[j + D] = 1",
"+concentration = 0",
"+ans = (100 * A, 0)",
"+for i in range(31):",
"+ if not water[i]:",
"+ continue",
"+ for j in range(3001):",
"+ if not sugar[j]:",
"+ continue",
"+ if i + j == 0 or 100 * i + j > F or j > E * i:",
"+ continue",
"+ if concentration * (100 * i + j) < 100 * j:",
"+ concentration = (100 * j) / (100 * i + j)",
"+ ans = (100 * i + j, j)",
"+print((*ans))"
] | false | 0.006409 | 0.047189 | 0.135808 | [
"s199892115",
"s168482694"
] |
u295361373 | p02627 | python | s893333809 | s344928218 | 180 | 92 | 67,308 | 69,768 | Accepted | Accepted | 48.89 | from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
abd={'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4, 'f': 5, 'g': 6, 'h': 7, 'i': 8, 'j': 9, 'k': 10, 'l': 11, 'm': 12, 'n': 13, 'o': 14, 'p': 15, 'q': 16, 'r': 17, 's': 18, 't': 19, 'u': 20, 'v': 21, 'w': 22, 'x': 23, 'y': 24, 'z': 25}
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
# for _ in range(ii()):
s=si()
if 97<=ord(s)<=122:
print('a')
else:
print('A')
| '''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
def solve():
# for _ in range(ii()):
s=si()
if 'a'<=s[0]<='z':
print('a')
else:
print('A')
if __name__ =="__main__":
if path.exists('input.txt'):
sys.stdin=open('input.txt', 'r')
sys.stdout=open('output.txt','w')
else:
input=sys.stdin.readline
solve()
| 47 | 59 | 916 | 1,109 | from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd
def ii():
return int(eval(input()))
def si():
return eval(input())
def mi():
return list(map(int, input().split()))
def li():
return list(mi())
abc = "abcdefghijklmnopqrstuvwxyz"
abd = {
"a": 0,
"b": 1,
"c": 2,
"d": 3,
"e": 4,
"f": 5,
"g": 6,
"h": 7,
"i": 8,
"j": 9,
"k": 10,
"l": 11,
"m": 12,
"n": 13,
"o": 14,
"p": 15,
"q": 16,
"r": 17,
"s": 18,
"t": 19,
"u": 20,
"v": 21,
"w": 22,
"x": 23,
"y": 24,
"z": 25,
}
mod = 1000000007
# mod=998244353
inf = float("inf")
vow = ["a", "e", "i", "o", "u"]
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def bo(i):
return ord(i) - ord("a")
# for _ in range(ii()):
s = si()
if 97 <= ord(s) <= 122:
print("a")
else:
print("A")
| """
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
"""
from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque, defaultdict as dd
from bisect import bisect, bisect_left, bisect_right, insort, insort_left, insort_right
from itertools import permutations
from datetime import datetime
from math import ceil, sqrt, log, gcd
def ii():
return int(eval(input()))
def si():
return eval(input())
def mi():
return list(map(int, input().split()))
def li():
return list(mi())
abc = "abcdefghijklmnopqrstuvwxyz"
mod = 1000000007
# mod=998244353
inf = float("inf")
vow = ["a", "e", "i", "o", "u"]
dx, dy = [-1, 1, 0, 0], [0, 0, 1, -1]
def bo(i):
return ord(i) - ord("a")
def solve():
# for _ in range(ii()):
s = si()
if "a" <= s[0] <= "z":
print("a")
else:
print("A")
if __name__ == "__main__":
if path.exists("input.txt"):
sys.stdin = open("input.txt", "r")
sys.stdout = open("output.txt", "w")
else:
input = sys.stdin.readline
solve()
| false | 20.338983 | [
"+\"\"\"",
"+ Auther: ghoshashis545 Ashis Ghosh",
"+ College: jalpaiguri Govt Enggineering College",
"+\"\"\"",
"+from os import path",
"+import sys",
"+from functools import cmp_to_key as ctk",
"-abd = {",
"- \"a\": 0,",
"- \"b\": 1,",
"- \"c\": 2,",
"- \"d\": 3,",
"- \"e\": 4,",
"- \"f\": 5,",
"- \"g\": 6,",
"- \"h\": 7,",
"- \"i\": 8,",
"- \"j\": 9,",
"- \"k\": 10,",
"- \"l\": 11,",
"- \"m\": 12,",
"- \"n\": 13,",
"- \"o\": 14,",
"- \"p\": 15,",
"- \"q\": 16,",
"- \"r\": 17,",
"- \"s\": 18,",
"- \"t\": 19,",
"- \"u\": 20,",
"- \"v\": 21,",
"- \"w\": 22,",
"- \"x\": 23,",
"- \"y\": 24,",
"- \"z\": 25,",
"-}",
"-# for _ in range(ii()):",
"-s = si()",
"-if 97 <= ord(s) <= 122:",
"- print(\"a\")",
"-else:",
"- print(\"A\")",
"+def solve():",
"+ # for _ in range(ii()):",
"+ s = si()",
"+ if \"a\" <= s[0] <= \"z\":",
"+ print(\"a\")",
"+ else:",
"+ print(\"A\")",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ if path.exists(\"input.txt\"):",
"+ sys.stdin = open(\"input.txt\", \"r\")",
"+ sys.stdout = open(\"output.txt\", \"w\")",
"+ else:",
"+ input = sys.stdin.readline",
"+ solve()"
] | false | 0.05544 | 0.034213 | 1.620448 | [
"s893333809",
"s344928218"
] |
u411203878 | p02684 | python | s828693496 | s300440097 | 129 | 116 | 96,628 | 99,500 | Accepted | Accepted | 10.08 | n,k = list(map(int,input().split()))
t = list(map(int,input().split()))
memo = [0]*(n+1)
for i in range(n):
memo[i+1] = t[i]
move = 1
count = 0
check = [0]*(n+1)
while check[move] == 0 and count < k-1:
check[move] += 1
move=memo[move]
count += 1
if k == count:
print((memo[move]))
else:
count2 = 0
check = [0]*(n+1)
move_log = []
while check[move] == 0:
move_log.append(move)
check[move] += 1
move=memo[move]
count2 += 1
print((move_log[(k-count)%count2]))
| N,K = list(map(int,input().split()))
A = list(map(int,input().split()))
check = [0]*N
jump = 0
count = 0
while check[A[jump]-1] == 0 and count < K:
n_jump = A[jump]-1
check[n_jump] = check[jump]+1
count += 1
jump = n_jump
if count == K:
key = max(check)
ans = check.index(key)+1
else:
count2 = 0
key = max(check)
jump = check.index(key)
check2 = [0]*N
while check2[A[jump]-1] == 0:
n_jump = A[jump]-1
check2[n_jump] = check2[jump]+1
count2 += 1
jump = n_jump
amari = (K-count)%count2
if amari == 0:
key = max(check2)
ans = check2.index(key)+1
else:
ans = check2.index(amari)+1
print(ans)
| 32 | 37 | 558 | 740 | n, k = list(map(int, input().split()))
t = list(map(int, input().split()))
memo = [0] * (n + 1)
for i in range(n):
memo[i + 1] = t[i]
move = 1
count = 0
check = [0] * (n + 1)
while check[move] == 0 and count < k - 1:
check[move] += 1
move = memo[move]
count += 1
if k == count:
print((memo[move]))
else:
count2 = 0
check = [0] * (n + 1)
move_log = []
while check[move] == 0:
move_log.append(move)
check[move] += 1
move = memo[move]
count2 += 1
print((move_log[(k - count) % count2]))
| N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
check = [0] * N
jump = 0
count = 0
while check[A[jump] - 1] == 0 and count < K:
n_jump = A[jump] - 1
check[n_jump] = check[jump] + 1
count += 1
jump = n_jump
if count == K:
key = max(check)
ans = check.index(key) + 1
else:
count2 = 0
key = max(check)
jump = check.index(key)
check2 = [0] * N
while check2[A[jump] - 1] == 0:
n_jump = A[jump] - 1
check2[n_jump] = check2[jump] + 1
count2 += 1
jump = n_jump
amari = (K - count) % count2
if amari == 0:
key = max(check2)
ans = check2.index(key) + 1
else:
ans = check2.index(amari) + 1
print(ans)
| false | 13.513514 | [
"-n, k = list(map(int, input().split()))",
"-t = list(map(int, input().split()))",
"-memo = [0] * (n + 1)",
"-for i in range(n):",
"- memo[i + 1] = t[i]",
"-move = 1",
"+N, K = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+check = [0] * N",
"+jump = 0",
"-check = [0] * (n + 1)",
"-while check[move] == 0 and count < k - 1:",
"- check[move] += 1",
"- move = memo[move]",
"+while check[A[jump] - 1] == 0 and count < K:",
"+ n_jump = A[jump] - 1",
"+ check[n_jump] = check[jump] + 1",
"-if k == count:",
"- print((memo[move]))",
"+ jump = n_jump",
"+if count == K:",
"+ key = max(check)",
"+ ans = check.index(key) + 1",
"- check = [0] * (n + 1)",
"- move_log = []",
"- while check[move] == 0:",
"- move_log.append(move)",
"- check[move] += 1",
"- move = memo[move]",
"+ key = max(check)",
"+ jump = check.index(key)",
"+ check2 = [0] * N",
"+ while check2[A[jump] - 1] == 0:",
"+ n_jump = A[jump] - 1",
"+ check2[n_jump] = check2[jump] + 1",
"- print((move_log[(k - count) % count2]))",
"+ jump = n_jump",
"+ amari = (K - count) % count2",
"+ if amari == 0:",
"+ key = max(check2)",
"+ ans = check2.index(key) + 1",
"+ else:",
"+ ans = check2.index(amari) + 1",
"+print(ans)"
] | false | 0.041876 | 0.04222 | 0.991855 | [
"s828693496",
"s300440097"
] |
u539692012 | p02627 | python | s082561917 | s111666297 | 32 | 29 | 9,072 | 8,916 | Accepted | Accepted | 9.38 | print(('a' if input().islower() else 'A'))
| print(('Aa'[input().islower()])) | 1 | 1 | 41 | 30 | print(("a" if input().islower() else "A"))
| print(("Aa"[input().islower()]))
| false | 0 | [
"-print((\"a\" if input().islower() else \"A\"))",
"+print((\"Aa\"[input().islower()]))"
] | false | 0.090862 | 0.038092 | 2.385312 | [
"s082561917",
"s111666297"
] |
u102461423 | p02702 | python | s740022149 | s285042631 | 858 | 593 | 108,872 | 29,016 | Accepted | Accepted | 30.89 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from numba import njit
@njit('(i4[:],)', cache=True)
def solve(S):
dp = np.zeros(2019, np.int64)
pow10 = 1
answer = 0
for x in S[::-1]:
dp[0] += 1
x = x * pow10 % 2019
newdp = np.zeros_like(dp)
newdp[x:] += dp[:-x]
newdp[:x] += dp[-x:]
answer += newdp[0]
pow10 *= 10
pow10 %= 2019
dp = newdp
return answer
S = np.array(list(read().rstrip()), dtype=np.int32) - ord('0')
print((solve(S)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
def solve(S):
dp = np.zeros(2019, np.int64)
pow10 = 1
answer = 0
for x in S[::-1]:
dp[0] += 1
x = x * pow10 % 2019
newdp = np.zeros_like(dp)
newdp[x:] += dp[:-x]
newdp[:x] += dp[-x:]
answer += newdp[0]
pow10 *= 10
pow10 %= 2019
dp = newdp
return answer
def cc_export():
from numba.pycc import CC
cc = CC('my_module')
cc.export('solve', '(i4[:],)')(solve)
cc.compile()
try:
from my_module import solve
except:
cc_export()
exit()
S = np.array(list(read().rstrip()), dtype=np.int32) - ord('0')
print((solve(S)))
| 27 | 39 | 641 | 807 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
from numba import njit
@njit("(i4[:],)", cache=True)
def solve(S):
dp = np.zeros(2019, np.int64)
pow10 = 1
answer = 0
for x in S[::-1]:
dp[0] += 1
x = x * pow10 % 2019
newdp = np.zeros_like(dp)
newdp[x:] += dp[:-x]
newdp[:x] += dp[-x:]
answer += newdp[0]
pow10 *= 10
pow10 %= 2019
dp = newdp
return answer
S = np.array(list(read().rstrip()), dtype=np.int32) - ord("0")
print((solve(S)))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
import numpy as np
def solve(S):
dp = np.zeros(2019, np.int64)
pow10 = 1
answer = 0
for x in S[::-1]:
dp[0] += 1
x = x * pow10 % 2019
newdp = np.zeros_like(dp)
newdp[x:] += dp[:-x]
newdp[:x] += dp[-x:]
answer += newdp[0]
pow10 *= 10
pow10 %= 2019
dp = newdp
return answer
def cc_export():
from numba.pycc import CC
cc = CC("my_module")
cc.export("solve", "(i4[:],)")(solve)
cc.compile()
try:
from my_module import solve
except:
cc_export()
exit()
S = np.array(list(read().rstrip()), dtype=np.int32) - ord("0")
print((solve(S)))
| false | 30.769231 | [
"-from numba import njit",
"-@njit(\"(i4[:],)\", cache=True)",
"+def cc_export():",
"+ from numba.pycc import CC",
"+",
"+ cc = CC(\"my_module\")",
"+ cc.export(\"solve\", \"(i4[:],)\")(solve)",
"+ cc.compile()",
"+",
"+",
"+try:",
"+ from my_module import solve",
"+except:",
"+ cc_export()",
"+ exit()"
] | false | 0.216998 | 0.223169 | 0.972351 | [
"s740022149",
"s285042631"
] |
u906428167 | p03181 | python | s984095079 | s589635607 | 1,076 | 761 | 146,388 | 112,492 | Accepted | Accepted | 29.28 | import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1]*self.n
self.depth = [-1]*self.n
self.subsize = [1]*self.n
self.result = [1]*self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v]+1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the result you want using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
FromParent = [0]*n
ans = [0]*n
ans[0] = self.result[0]
s = [self.root]
while s:
v = s.pop()
if v != self.root:
ans[v] = (FromParent[v]+1)*self.result[v]
ans[v] %= m
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1]*(self.result[w]+1) % m)
s.append(w)
else:
cum1[v].append(cum1[v][-1]*(FromParent[v]+1) % m)
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1]*(self.result[w]+1) % m)
else:
cum2[v].append(cum2[v][-1]*(FromParent[v]+1) % m)
cum2[v] = cum2[v][::-1]
for i, w in enumerate(self.g[v]):
FromParent[w] = cum1[v][i]*cum2[v][i+1] % m
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
T1 = Tree(n, g, 0)
ans = T1.rerooting()
for x in T1.rerooting():
print(x)
| import sys
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1]*self.n
self.depth = [-1]*self.n
self.subsize = [1]*self.n
self.result = [1]*self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v]+1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the item you want by using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
# Modify below if you want to use rerooting
ans = [0]*n
ans[self.root] = self.result[self.root]
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
FromParent = [0]*n
s = [self.root]
while s:
v = s.pop()
# accumulate nbhd's result from the left side
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1]*(self.result[w]+1) % m)
s.append(w)
else:
cum1[v].append(cum1[v][-1]*(FromParent[v]+1) % m)
# accumulate nbhd's result from the right side
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1]*(self.result[w]+1) % m)
else:
cum2[v].append(cum2[v][-1]*(FromParent[v]+1) % m)
cum2[v] = cum2[v][::-1]
# calculate the sub-result for parent's subtree when you see the child as root.
# get the answer for each child.
for i, w in enumerate(self.g[v]):
if w != self.parent[v]:
FromParent[w] = cum1[v][i]*cum2[v][i+1] % m
ans[w] = (FromParent[w]+1) * self.result[w]
ans[w] %= m
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n-1):
x, y = list(map(int, input().split()))
g[x-1].append(y-1)
g[y-1].append(x-1)
T1 = Tree(n, g, 0)
for x in T1.rerooting():
print(x)
| 92 | 94 | 2,757 | 3,082 | import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1] * self.n
self.depth = [-1] * self.n
self.subsize = [1] * self.n
self.result = [1] * self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v] + 1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the result you want using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
FromParent = [0] * n
ans = [0] * n
ans[0] = self.result[0]
s = [self.root]
while s:
v = s.pop()
if v != self.root:
ans[v] = (FromParent[v] + 1) * self.result[v]
ans[v] %= m
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1] * (self.result[w] + 1) % m)
s.append(w)
else:
cum1[v].append(cum1[v][-1] * (FromParent[v] + 1) % m)
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1] * (self.result[w] + 1) % m)
else:
cum2[v].append(cum2[v][-1] * (FromParent[v] + 1) % m)
cum2[v] = cum2[v][::-1]
for i, w in enumerate(self.g[v]):
FromParent[w] = cum1[v][i] * cum2[v][i + 1] % m
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n - 1):
x, y = list(map(int, input().split()))
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
T1 = Tree(n, g, 0)
ans = T1.rerooting()
for x in T1.rerooting():
print(x)
| import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
class Tree:
def __init__(self, crdinal, adjgrph, root):
self.n = crdinal
self.g = adjgrph
self.root = root
self.parent = [-1] * self.n
self.depth = [-1] * self.n
self.subsize = [1] * self.n
self.result = [1] * self.n # 0 : additive, 1 : multiplicative
s = [self.root]
while s:
v = s.pop()
if self.depth[v] == -1:
if v == self.root:
self.depth[v] = 0
else:
self.depth[v] = self.depth[self.parent[v]] + 1
s.append(v)
for w in self.g[v]:
if self.depth[w] == -1:
self.parent[w] = v
s.append(w)
else:
self.subsize[self.parent[v]] += self.subsize[v]
self.calc(v)
def calc(self, v):
# The following formula is calculated by bottom-up:
self.result[self.parent[v]] *= self.result[v] + 1
self.result[self.parent[v]] %= m
return None
def wanted(self):
# Edit the item you want by using self.depth, self.subsize, etc..
# Default : self.parent
return self.parent
def rerooting(self) -> list:
# Modify below if you want to use rerooting
ans = [0] * n
ans[self.root] = self.result[self.root]
cum1 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
cum2 = [[1] for i in range(n)] # 0 : additive, 1 : multiplicative
FromParent = [0] * n
s = [self.root]
while s:
v = s.pop()
# accumulate nbhd's result from the left side
for w in self.g[v]:
if w != self.parent[v]:
cum1[v].append(cum1[v][-1] * (self.result[w] + 1) % m)
s.append(w)
else:
cum1[v].append(cum1[v][-1] * (FromParent[v] + 1) % m)
# accumulate nbhd's result from the right side
for w in self.g[v][::-1]:
if w != self.parent[v]:
cum2[v].append(cum2[v][-1] * (self.result[w] + 1) % m)
else:
cum2[v].append(cum2[v][-1] * (FromParent[v] + 1) % m)
cum2[v] = cum2[v][::-1]
# calculate the sub-result for parent's subtree when you see the child as root.
# get the answer for each child.
for i, w in enumerate(self.g[v]):
if w != self.parent[v]:
FromParent[w] = cum1[v][i] * cum2[v][i + 1] % m
ans[w] = (FromParent[w] + 1) * self.result[w]
ans[w] %= m
return ans
n, m = list(map(int, input().split()))
g = [[] for _ in range(n)]
for _ in range(n - 1):
x, y = list(map(int, input().split()))
g[x - 1].append(y - 1)
g[y - 1].append(x - 1)
T1 = Tree(n, g, 0)
for x in T1.rerooting():
print(x)
| false | 2.12766 | [
"- # Edit the result you want using self.depth, self.subsize, etc..",
"+ # Edit the item you want by using self.depth, self.subsize, etc..",
"+ # Modify below if you want to use rerooting",
"+ ans = [0] * n",
"+ ans[self.root] = self.result[self.root]",
"- ans = [0] * n",
"- ans[0] = self.result[0]",
"- if v != self.root:",
"- ans[v] = (FromParent[v] + 1) * self.result[v]",
"- ans[v] %= m",
"+ # accumulate nbhd's result from the left side",
"+ # accumulate nbhd's result from the right side",
"+ # calculate the sub-result for parent's subtree when you see the child as root.",
"+ # get the answer for each child.",
"- FromParent[w] = cum1[v][i] * cum2[v][i + 1] % m",
"+ if w != self.parent[v]:",
"+ FromParent[w] = cum1[v][i] * cum2[v][i + 1] % m",
"+ ans[w] = (FromParent[w] + 1) * self.result[w]",
"+ ans[w] %= m",
"-ans = T1.rerooting()"
] | false | 0.201201 | 0.037196 | 5.409225 | [
"s984095079",
"s589635607"
] |
u384679440 | p03325 | python | s792955249 | s083342341 | 165 | 142 | 4,140 | 4,148 | Accepted | Accepted | 13.94 | N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
while True:
odd = 0
for i in range(N):
if a[i] % 2 != 0:
odd += 1
else:
a[i] /= 2
ans += 1
if odd == len(a):
break
print(ans) | N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
while True:
odd = 0
for i in range(len(a)):
if a[i] % 2 != 0:
odd += 1
else:
a[i] /= 2
ans += 1
if odd == len(a):
break
print(ans) | 14 | 14 | 217 | 224 | N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
while True:
odd = 0
for i in range(N):
if a[i] % 2 != 0:
odd += 1
else:
a[i] /= 2
ans += 1
if odd == len(a):
break
print(ans)
| N = int(eval(input()))
a = list(map(int, input().split()))
ans = 0
while True:
odd = 0
for i in range(len(a)):
if a[i] % 2 != 0:
odd += 1
else:
a[i] /= 2
ans += 1
if odd == len(a):
break
print(ans)
| false | 0 | [
"- for i in range(N):",
"+ for i in range(len(a)):"
] | false | 0.043845 | 0.037447 | 1.170833 | [
"s792955249",
"s083342341"
] |
u319957725 | p02676 | python | s692991008 | s265992924 | 23 | 21 | 9,124 | 9,092 | Accepted | Accepted | 8.7 | '''
問題文
S: 文字列，英小文字
条件１（長さK以下）→Sをそのまま出力
条件２（長さK以上）→先頭K文字+'...'を出力
アルゴリズム
1. Sの文字数を取得(len(S))
2. Sの文字数とKを比較
2-a. if(len(S)<=K)Sを出力
2-b. if(len(S)>K)先頭K文字+'...'を出力，for文を使って先頭K文字の配列を作り直して'...'を結合し出力．
'''
K = int(eval(input()))
S = eval(input())
if(len(S)<=K):
print(S)
else:
S_K = ''
for i in range(K):
S_K += S[i]
print((S_K + '...'))
| K = int(input())
S = input()
for i, s in enumerate(S):
if(i == K):
print('...')
break
print(s, end='')
print('')
| 26 | 9 | 374 | 146 | """
問題文
S: 文字列，英小文字
条件１（長さK以下）→Sをそのまま出力
条件２（長さK以上）→先頭K文字+'...'を出力
アルゴリズム
1. Sの文字数を取得(len(S))
2. Sの文字数とKを比較
2-a. if(len(S)<=K)Sを出力
2-b. if(len(S)>K)先頭K文字+'...'を出力，for文を使って先頭K文字の配列を作り直して'...'を結合し出力．
"""
K = int(eval(input()))
S = eval(input())
if len(S) <= K:
print(S)
else:
S_K = ""
for i in range(K):
S_K += S[i]
print((S_K + "..."))
| K = int(input())
S = input()
for i, s in enumerate(S):
if i == K:
print("...")
break
print(s, end="")
print("")
| false | 65.384615 | [
"-\"\"\"",
"-問題文",
"-S: 文字列，英小文字",
"-条件１（長さK以下）→Sをそのまま出力",
"-条件２（長さK以上）→先頭K文字+'...'を出力",
"-アルゴリズム",
"-1. Sの文字数を取得(len(S))",
"-2. Sの文字数とKを比較",
"-2-a. if(len(S)<=K)Sを出力",
"-2-b. if(len(S)>K)先頭K文字+'...'を出力，for文を使って先頭K文字の配列を作り直して'...'を結合し出力．",
"-\"\"\"",
"-K = int(eval(input()))",
"-S = eval(input())",
"-if len(S) <= K:",
"- print(S)",
"-else:",
"- S_K = \"\"",
"- for i in range(K):",
"- S_K += S[i]",
"- print((S_K + \"...\"))",
"+K = int(input())",
"+S = input()",
"+for i, s in enumerate(S):",
"+ if i == K:",
"+ print(\"...\")",
"+ break",
"+ print(s, end=\"\")",
"+print(\"\")"
] | false | 0.037092 | 0.034993 | 1.059979 | [
"s692991008",
"s265992924"
] |
u037430802 | p02803 | python | s399271650 | s421627136 | 305 | 267 | 48,220 | 45,916 | Accepted | Accepted | 12.46 | from collections import deque
H,W = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
ans = 0
dyx = [(1,0), (0,1),(-1,0), (0,-1)]
for i in range(H):
for j in range(W):
if S[i][j] == "#": continue
dist = [[0 for _ in range(W)] for _ in range(H)]
visited = [[False for _ in range(W)] for _ in range(H)]
visited[i][j] = True
q = deque()
q.append((i,j))
while q:
y,x = q.popleft()
for dy,dx in dyx:
ny, nx = y+dy, x+dx
if not 0 <= ny <= H-1 or not 0 <= nx <= W-1 or visited[ny][nx] == True or S[ny][nx] == "#":
continue
q.append((ny, nx))
dist[ny][nx] = dist[y][x] + 1
visited[ny][nx] = True
ans = max(ans, max(max(row) for row in dist))
print(ans) | H,W = list(map(int,input().split()))
S = [eval(input()) for i in range(H)]
dxy = [(0,1),(1,0),(0,-1),(-1,0)]
from collections import deque
ans = 0
for y in range(H):
for x in range(W):
if S[y][x] == '#': continue
dist = [[0]*W for i in range(H)]
visited = [[0]*W for i in range(H)]
visited[y][x] = 1
q = deque([(x,y)])
while q:
x,y = q.popleft()
for dx,dy in dxy:
nx,ny = x+dx,y+dy
if not 0 <= nx < W: continue
if not 0 <= ny < H: continue
if visited[ny][nx]: continue
if S[ny][nx] == '#': continue
visited[ny][nx] = 1
dist[ny][nx] = dist[y][x] + 1
q.append((nx,ny))
for i in range(H):
ans = max(ans, max(dist[i]))
#ans = max(ans, max(max(row) for row in dist))
print(ans)
| 33 | 31 | 898 | 927 | from collections import deque
H, W = list(map(int, input().split()))
S = [eval(input()) for _ in range(H)]
ans = 0
dyx = [(1, 0), (0, 1), (-1, 0), (0, -1)]
for i in range(H):
for j in range(W):
if S[i][j] == "#":
continue
dist = [[0 for _ in range(W)] for _ in range(H)]
visited = [[False for _ in range(W)] for _ in range(H)]
visited[i][j] = True
q = deque()
q.append((i, j))
while q:
y, x = q.popleft()
for dy, dx in dyx:
ny, nx = y + dy, x + dx
if (
not 0 <= ny <= H - 1
or not 0 <= nx <= W - 1
or visited[ny][nx] == True
or S[ny][nx] == "#"
):
continue
q.append((ny, nx))
dist[ny][nx] = dist[y][x] + 1
visited[ny][nx] = True
ans = max(ans, max(max(row) for row in dist))
print(ans)
| H, W = list(map(int, input().split()))
S = [eval(input()) for i in range(H)]
dxy = [(0, 1), (1, 0), (0, -1), (-1, 0)]
from collections import deque
ans = 0
for y in range(H):
for x in range(W):
if S[y][x] == "#":
continue
dist = [[0] * W for i in range(H)]
visited = [[0] * W for i in range(H)]
visited[y][x] = 1
q = deque([(x, y)])
while q:
x, y = q.popleft()
for dx, dy in dxy:
nx, ny = x + dx, y + dy
if not 0 <= nx < W:
continue
if not 0 <= ny < H:
continue
if visited[ny][nx]:
continue
if S[ny][nx] == "#":
continue
visited[ny][nx] = 1
dist[ny][nx] = dist[y][x] + 1
q.append((nx, ny))
for i in range(H):
ans = max(ans, max(dist[i]))
# ans = max(ans, max(max(row) for row in dist))
print(ans)
| false | 6.060606 | [
"+H, W = list(map(int, input().split()))",
"+S = [eval(input()) for i in range(H)]",
"+dxy = [(0, 1), (1, 0), (0, -1), (-1, 0)]",
"-H, W = list(map(int, input().split()))",
"-S = [eval(input()) for _ in range(H)]",
"-dyx = [(1, 0), (0, 1), (-1, 0), (0, -1)]",
"-for i in range(H):",
"- for j in range(W):",
"- if S[i][j] == \"#\":",
"+for y in range(H):",
"+ for x in range(W):",
"+ if S[y][x] == \"#\":",
"- dist = [[0 for _ in range(W)] for _ in range(H)]",
"- visited = [[False for _ in range(W)] for _ in range(H)]",
"- visited[i][j] = True",
"- q = deque()",
"- q.append((i, j))",
"+ dist = [[0] * W for i in range(H)]",
"+ visited = [[0] * W for i in range(H)]",
"+ visited[y][x] = 1",
"+ q = deque([(x, y)])",
"- y, x = q.popleft()",
"- for dy, dx in dyx:",
"- ny, nx = y + dy, x + dx",
"- if (",
"- not 0 <= ny <= H - 1",
"- or not 0 <= nx <= W - 1",
"- or visited[ny][nx] == True",
"- or S[ny][nx] == \"#\"",
"- ):",
"+ x, y = q.popleft()",
"+ for dx, dy in dxy:",
"+ nx, ny = x + dx, y + dy",
"+ if not 0 <= nx < W:",
"- q.append((ny, nx))",
"+ if not 0 <= ny < H:",
"+ continue",
"+ if visited[ny][nx]:",
"+ continue",
"+ if S[ny][nx] == \"#\":",
"+ continue",
"+ visited[ny][nx] = 1",
"- visited[ny][nx] = True",
"- ans = max(ans, max(max(row) for row in dist))",
"+ q.append((nx, ny))",
"+ for i in range(H):",
"+ ans = max(ans, max(dist[i]))",
"+ # ans = max(ans, max(max(row) for row in dist))"
] | false | 0.089089 | 0.037121 | 2.399954 | [
"s399271650",
"s421627136"
] |
u531603069 | p02787 | python | s934388898 | s784635659 | 1,810 | 1,429 | 3,832 | 44,508 | Accepted | Accepted | 21.05 | import sys
h, n = list(map(int, input().split()))
# A = [0] * n
# B = [0] * n
# for i in range(n):
# A[i], B[i] = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(n)]
min_hp = h
max_hp = h + max(a for a, b in (AB))
dp = [sys.maxsize] * (max_hp + 1)
dp[0] = 0
for i in range(1, max_hp + 1):
# dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))
dp[i] = min(dp[i - a] + b for a, b in AB)
print((min(dp[h:])))
| import sys
h, n = list(map(int, input().split()))
A = [0] * n
B = [0] * n
for i in range(n):
A[i], B[i] = list(map(int, input().split()))
min_hp = h
max_hp = h + max(A)
dp = [sys.maxsize] * (max_hp + 1)
dp[0] = 0
for i in range(1, max_hp + 1):
dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))
print((min(dp[h:]))) | 17 | 15 | 458 | 327 | import sys
h, n = list(map(int, input().split()))
# A = [0] * n
# B = [0] * n
# for i in range(n):
# A[i], B[i] = map(int, input().split())
AB = [list(map(int, input().split())) for _ in range(n)]
min_hp = h
max_hp = h + max(a for a, b in (AB))
dp = [sys.maxsize] * (max_hp + 1)
dp[0] = 0
for i in range(1, max_hp + 1):
# dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))
dp[i] = min(dp[i - a] + b for a, b in AB)
print((min(dp[h:])))
| import sys
h, n = list(map(int, input().split()))
A = [0] * n
B = [0] * n
for i in range(n):
A[i], B[i] = list(map(int, input().split()))
min_hp = h
max_hp = h + max(A)
dp = [sys.maxsize] * (max_hp + 1)
dp[0] = 0
for i in range(1, max_hp + 1):
dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))
print((min(dp[h:])))
| false | 11.764706 | [
"-# A = [0] * n",
"-# B = [0] * n",
"-# for i in range(n):",
"-# A[i], B[i] = map(int, input().split())",
"-AB = [list(map(int, input().split())) for _ in range(n)]",
"+A = [0] * n",
"+B = [0] * n",
"+for i in range(n):",
"+ A[i], B[i] = list(map(int, input().split()))",
"-max_hp = h + max(a for a, b in (AB))",
"+max_hp = h + max(A)",
"- # dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))",
"- dp[i] = min(dp[i - a] + b for a, b in AB)",
"+ dp[i] = min(dp[i - A[j]] + B[j] for j in range(n))"
] | false | 0.081502 | 0.104137 | 0.782644 | [
"s934388898",
"s784635659"
] |
u816631826 | p02724 | python | s655753884 | s159090289 | 571 | 17 | 2,940 | 2,940 | Accepted | Accepted | 97.02 | n = int(eval(input()))
happy = 0
if n%500 == 0:
print((2*n))
else:
while n > 0:
if n == 0:
break
n-=500
if n<0:
n+=500
n-=5
if n<0:
n+=5
break
else:
happy+=5
else:
happy+=1000
print(happy)
| x = int(eval(input()))
total = 0
a = int(x / 500)
b = x % 500
c = int(b / 5)
total = a * 1000 + c *5
print(total) | 20 | 7 | 364 | 113 | n = int(eval(input()))
happy = 0
if n % 500 == 0:
print((2 * n))
else:
while n > 0:
if n == 0:
break
n -= 500
if n < 0:
n += 500
n -= 5
if n < 0:
n += 5
break
else:
happy += 5
else:
happy += 1000
print(happy)
| x = int(eval(input()))
total = 0
a = int(x / 500)
b = x % 500
c = int(b / 5)
total = a * 1000 + c * 5
print(total)
| false | 65 | [
"-n = int(eval(input()))",
"-happy = 0",
"-if n % 500 == 0:",
"- print((2 * n))",
"-else:",
"- while n > 0:",
"- if n == 0:",
"- break",
"- n -= 500",
"- if n < 0:",
"- n += 500",
"- n -= 5",
"- if n < 0:",
"- n += 5",
"- break",
"- else:",
"- happy += 5",
"- else:",
"- happy += 1000",
"- print(happy)",
"+x = int(eval(input()))",
"+total = 0",
"+a = int(x / 500)",
"+b = x % 500",
"+c = int(b / 5)",
"+total = a * 1000 + c * 5",
"+print(total)"
] | false | 0.103178 | 0.040789 | 2.529549 | [
"s655753884",
"s159090289"
] |
u033606236 | p03290 | python | s367076067 | s738073203 | 168 | 29 | 3,064 | 3,064 | Accepted | Accepted | 82.74 | d,g = list(map(int,input().split()))
a = [list(map(int,input().split())) for _ in range(d)]
s = set(range(d))
ans = float("Inf")
x = []
for i in zip(*a):
x.append(list(i))
c = []
for i in range(2**d):
b = []
for j in range(d):
if i>>j & 1:
b.append(j)
c.append(b)
for i in c:
d = 0
count = 0
for j in i:
d += (100*(j+1)) * a[j][0] + a[j][1]
count += a[j][0]
if d < g:
for x in sorted(s - set(i),reverse=True):
for y in range(a[x][0]):
if d >= g:
break
d += 100*(x+1)
count += 1
if d < g:continue
ans = min(ans,count)
print(ans) | d,g = list(map(int,input().split()))
ary = [list(map(int,input().split())) for _ in range(d)]
s = set(i for i in range(d))
ans = float("Inf")
for i in range(2**d):
a = []
total,count = 0,0
for j in range(d):
if i >> j & 1:
a.append(j)
for x in a:
total += 100*(x+1)*ary[x][0]+ary[x][1]
count += ary[x][0]
if total >= g:
ans = min(ans,count)
continue
for y in sorted(s - set(a),reverse=True):
if total + 100*(y+1)*(ary[y][0]-1) >= g:
count += -(-(g-total) // (100*(y+1)))
ans = min(ans,count)
break
total += 100*(y+1)*(ary[y][0]-1)
count += ary[y][0]-1
if total >= g:
ans = min(ans,count)
print(ans) | 30 | 26 | 720 | 765 | d, g = list(map(int, input().split()))
a = [list(map(int, input().split())) for _ in range(d)]
s = set(range(d))
ans = float("Inf")
x = []
for i in zip(*a):
x.append(list(i))
c = []
for i in range(2**d):
b = []
for j in range(d):
if i >> j & 1:
b.append(j)
c.append(b)
for i in c:
d = 0
count = 0
for j in i:
d += (100 * (j + 1)) * a[j][0] + a[j][1]
count += a[j][0]
if d < g:
for x in sorted(s - set(i), reverse=True):
for y in range(a[x][0]):
if d >= g:
break
d += 100 * (x + 1)
count += 1
if d < g:
continue
ans = min(ans, count)
print(ans)
| d, g = list(map(int, input().split()))
ary = [list(map(int, input().split())) for _ in range(d)]
s = set(i for i in range(d))
ans = float("Inf")
for i in range(2**d):
a = []
total, count = 0, 0
for j in range(d):
if i >> j & 1:
a.append(j)
for x in a:
total += 100 * (x + 1) * ary[x][0] + ary[x][1]
count += ary[x][0]
if total >= g:
ans = min(ans, count)
continue
for y in sorted(s - set(a), reverse=True):
if total + 100 * (y + 1) * (ary[y][0] - 1) >= g:
count += -(-(g - total) // (100 * (y + 1)))
ans = min(ans, count)
break
total += 100 * (y + 1) * (ary[y][0] - 1)
count += ary[y][0] - 1
if total >= g:
ans = min(ans, count)
print(ans)
| false | 13.333333 | [
"-a = [list(map(int, input().split())) for _ in range(d)]",
"-s = set(range(d))",
"+ary = [list(map(int, input().split())) for _ in range(d)]",
"+s = set(i for i in range(d))",
"-x = []",
"-for i in zip(*a):",
"- x.append(list(i))",
"-c = []",
"- b = []",
"+ a = []",
"+ total, count = 0, 0",
"- b.append(j)",
"- c.append(b)",
"-for i in c:",
"- d = 0",
"- count = 0",
"- for j in i:",
"- d += (100 * (j + 1)) * a[j][0] + a[j][1]",
"- count += a[j][0]",
"- if d < g:",
"- for x in sorted(s - set(i), reverse=True):",
"- for y in range(a[x][0]):",
"- if d >= g:",
"- break",
"- d += 100 * (x + 1)",
"- count += 1",
"- if d < g:",
"+ a.append(j)",
"+ for x in a:",
"+ total += 100 * (x + 1) * ary[x][0] + ary[x][1]",
"+ count += ary[x][0]",
"+ if total >= g:",
"+ ans = min(ans, count)",
"- ans = min(ans, count)",
"+ for y in sorted(s - set(a), reverse=True):",
"+ if total + 100 * (y + 1) * (ary[y][0] - 1) >= g:",
"+ count += -(-(g - total) // (100 * (y + 1)))",
"+ ans = min(ans, count)",
"+ break",
"+ total += 100 * (y + 1) * (ary[y][0] - 1)",
"+ count += ary[y][0] - 1",
"+ if total >= g:",
"+ ans = min(ans, count)"
] | false | 0.066377 | 0.038068 | 1.743664 | [
"s367076067",
"s738073203"
] |
u800704240 | p03268 | python | s445761071 | s119692471 | 93 | 39 | 3,060 | 5,332 | Accepted | Accepted | 58.06 | n,k = list(map(int,input().split()))
ans1 = 0
ans2 = 0
ans = 0
for x in range(1,n+1):
if x % k ==0:
ans1 +=1
if k % 2 == 0:
for y in range(1,n+1):
if y % k == k/2:
ans2 +=1
print((ans1**3+ans2**3)) | from decimal import Decimal, ROUND_HALF_UP
n,k = list(map(int,input().split()))
ans = 0
if k % 2 ==0:
p = Decimal(n/k).quantize(Decimal('0'),rounding=ROUND_HALF_UP)
ans = p**3 +(n//k)**3
else:
ans = (n // k)**3
print(ans) | 12 | 9 | 236 | 235 | n, k = list(map(int, input().split()))
ans1 = 0
ans2 = 0
ans = 0
for x in range(1, n + 1):
if x % k == 0:
ans1 += 1
if k % 2 == 0:
for y in range(1, n + 1):
if y % k == k / 2:
ans2 += 1
print((ans1**3 + ans2**3))
| from decimal import Decimal, ROUND_HALF_UP
n, k = list(map(int, input().split()))
ans = 0
if k % 2 == 0:
p = Decimal(n / k).quantize(Decimal("0"), rounding=ROUND_HALF_UP)
ans = p**3 + (n // k) ** 3
else:
ans = (n // k) ** 3
print(ans)
| false | 25 | [
"+from decimal import Decimal, ROUND_HALF_UP",
"+",
"-ans1 = 0",
"-ans2 = 0",
"-for x in range(1, n + 1):",
"- if x % k == 0:",
"- ans1 += 1",
"- for y in range(1, n + 1):",
"- if y % k == k / 2:",
"- ans2 += 1",
"-print((ans1**3 + ans2**3))",
"+ p = Decimal(n / k).quantize(Decimal(\"0\"), rounding=ROUND_HALF_UP)",
"+ ans = p**3 + (n // k) ** 3",
"+else:",
"+ ans = (n // k) ** 3",
"+print(ans)"
] | false | 0.03466 | 0.035863 | 0.966452 | [
"s445761071",
"s119692471"
] |
u034128150 | p02913 | python | s348135835 | s657337613 | 1,109 | 100 | 97,884 | 71,200 | Accepted | Accepted | 90.98 | class RollingHash:
def __init__(self, string, root, mod):
self.root = root
self.mod = mod
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
self.hs[i + 1] = self.hs[i] * self.root + ord(string[i]) % self.mod
self.pw[i + 1] = self.pw[i] * self.root % self.mod
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
return (self.hs[r] - self.hs[l] * self.pw[r - l]) % self.mod
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
RHMOD = 1 << 61 - 1
POSITIVIZER = RHMOD << 20
class RollingHashMOD61:
"""
MOD == 2 ** 61 - 1
参考: https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
"""
def __init__(self, string, root):
self.root = root
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
tmp = self.hs[i] * self.root + ord(string[i])
self.hs[i + 1] = tmp >> 61 + (tmp & RHMOD)
tmp = self.pw[i] * self.root
self.pw[i + 1] = tmp >> 61 + (tmp & RHMOD)
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
ret = (self.hs[r] - self.hs[l] * self.pw[r - l] + POSITIVIZER)
ret = ret >> 61 + (ret & RHMOD)
return ret
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
if __name__ == "__main__":
N = int(eval(input()))
S = eval(input())
MOD = 2 ** 61 - 1
root = 10000
rh = RollingHash(S, root, MOD)
ok = 0
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
hashes = dict()
flg = False
for i in range(N - mid + 1):
hashofsub = rh[i:i+mid]
if hashofsub in hashes:
if i >= hashes[hashofsub] + mid:
flg = True
break
else:
hashes[hashofsub] = i
if flg:
ok = mid
else:
ng = mid
print(ok)
| class RollingHash:
def __init__(self, string, root, mod):
self.root = root
self.mod = mod
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
self.hs[i + 1] = (self.hs[i] * self.root + ord(string[i])) % self.mod
self.pw[i + 1] = self.pw[i] * self.root % self.mod
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
return (self.hs[r] - self.hs[l] * self.pw[r - l]) % self.mod
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
RHMOD = 1 << 61 - 1
POSITIVIZER = RHMOD << 20
class RollingHashMOD61:
"""
MOD == 2 ** 61 - 1
参考: https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
"""
def __init__(self, string, root):
self.root = root
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
tmp = self.hs[i] * self.root + ord(string[i])
self.hs[i + 1] = tmp >> 61 + (tmp & RHMOD)
tmp = self.pw[i] * self.root
self.pw[i + 1] = tmp >> 61 + (tmp & RHMOD)
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
ret = (self.hs[r] - self.hs[l] * self.pw[r - l] + POSITIVIZER)
ret = ret >> 61 + (ret & RHMOD)
return ret
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
if __name__ == "__main__":
N = int(eval(input()))
S = eval(input())
MOD = 2 ** 61 - 1
root = 10000
rh = RollingHash(S, root, MOD)
ok = 0
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
hashes = dict()
flg = False
for i in range(N - mid + 1):
hashofsub = rh[i:i+mid]
if hashofsub in hashes:
if i >= hashes[hashofsub] + mid:
flg = True
break
else:
hashes[hashofsub] = i
if flg:
ok = mid
else:
ng = mid
print(ok)
| 83 | 83 | 2,364 | 2,366 | class RollingHash:
def __init__(self, string, root, mod):
self.root = root
self.mod = mod
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
self.hs[i + 1] = self.hs[i] * self.root + ord(string[i]) % self.mod
self.pw[i + 1] = self.pw[i] * self.root % self.mod
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
return (self.hs[r] - self.hs[l] * self.pw[r - l]) % self.mod
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
RHMOD = 1 << 61 - 1
POSITIVIZER = RHMOD << 20
class RollingHashMOD61:
"""
MOD == 2 ** 61 - 1
参考: https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
"""
def __init__(self, string, root):
self.root = root
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
tmp = self.hs[i] * self.root + ord(string[i])
self.hs[i + 1] = tmp >> 61 + (tmp & RHMOD)
tmp = self.pw[i] * self.root
self.pw[i + 1] = tmp >> 61 + (tmp & RHMOD)
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
ret = self.hs[r] - self.hs[l] * self.pw[r - l] + POSITIVIZER
ret = ret >> 61 + (ret & RHMOD)
return ret
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
if __name__ == "__main__":
N = int(eval(input()))
S = eval(input())
MOD = 2**61 - 1
root = 10000
rh = RollingHash(S, root, MOD)
ok = 0
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
hashes = dict()
flg = False
for i in range(N - mid + 1):
hashofsub = rh[i : i + mid]
if hashofsub in hashes:
if i >= hashes[hashofsub] + mid:
flg = True
break
else:
hashes[hashofsub] = i
if flg:
ok = mid
else:
ng = mid
print(ok)
| class RollingHash:
def __init__(self, string, root, mod):
self.root = root
self.mod = mod
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
self.hs[i + 1] = (self.hs[i] * self.root + ord(string[i])) % self.mod
self.pw[i + 1] = self.pw[i] * self.root % self.mod
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
return (self.hs[r] - self.hs[l] * self.pw[r - l]) % self.mod
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
RHMOD = 1 << 61 - 1
POSITIVIZER = RHMOD << 20
class RollingHashMOD61:
"""
MOD == 2 ** 61 - 1
参考: https://qiita.com/keymoon/items/11fac5627672a6d6a9f6
"""
def __init__(self, string, root):
self.root = root
self.hs = [0] * (len(string) + 1)
self.pw = [1] * (len(string) + 1)
for i in range(len(string)):
tmp = self.hs[i] * self.root + ord(string[i])
self.hs[i + 1] = tmp >> 61 + (tmp & RHMOD)
tmp = self.pw[i] * self.root
self.pw[i + 1] = tmp >> 61 + (tmp & RHMOD)
def get_hash(self, l, r):
"get the hash of s[l:r] (0 <= l <= r <= len(s))"
ret = self.hs[r] - self.hs[l] * self.pw[r - l] + POSITIVIZER
ret = ret >> 61 + (ret & RHMOD)
return ret
def __getitem__(self, index):
if isinstance(index, slice):
return self.get_hash(index.start, index.stop)
else:
return 0
if __name__ == "__main__":
N = int(eval(input()))
S = eval(input())
MOD = 2**61 - 1
root = 10000
rh = RollingHash(S, root, MOD)
ok = 0
ng = N
while ng - ok > 1:
mid = (ok + ng) // 2
hashes = dict()
flg = False
for i in range(N - mid + 1):
hashofsub = rh[i : i + mid]
if hashofsub in hashes:
if i >= hashes[hashofsub] + mid:
flg = True
break
else:
hashes[hashofsub] = i
if flg:
ok = mid
else:
ng = mid
print(ok)
| false | 0 | [
"- self.hs[i + 1] = self.hs[i] * self.root + ord(string[i]) % self.mod",
"+ self.hs[i + 1] = (self.hs[i] * self.root + ord(string[i])) % self.mod"
] | false | 0.12654 | 0.045231 | 2.797625 | [
"s348135835",
"s657337613"
] |
u623687794 | p02712 | python | s733671189 | s464692402 | 158 | 70 | 9,160 | 64,988 | Accepted | Accepted | 55.7 | n=int(eval(input()))
ans=0
for i in range(1,n+1):
if i%3 * i%5 != 0:ans+=i
print(ans) | n = int(eval(input()))
ans = 0
for i in range(n+1):
if i%3 != 0 and i%5 != 0:
ans = ans + i
print(ans) | 5 | 6 | 85 | 107 | n = int(eval(input()))
ans = 0
for i in range(1, n + 1):
if i % 3 * i % 5 != 0:
ans += i
print(ans)
| n = int(eval(input()))
ans = 0
for i in range(n + 1):
if i % 3 != 0 and i % 5 != 0:
ans = ans + i
print(ans)
| false | 16.666667 | [
"-for i in range(1, n + 1):",
"- if i % 3 * i % 5 != 0:",
"- ans += i",
"+for i in range(n + 1):",
"+ if i % 3 != 0 and i % 5 != 0:",
"+ ans = ans + i"
] | false | 0.166123 | 0.169016 | 0.982887 | [
"s733671189",
"s464692402"
] |
u533232830 | p03557 | python | s340517091 | s967621628 | 279 | 258 | 30,964 | 29,348 | Accepted | Accepted | 7.53 | from bisect import bisect_left
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
# print(A)
# print(B)
# print(C)
A_B = []
for i in range(n):
A_B.append(bisect_left(A, B[i]))
ruisekiwa = [A_B[0]]
for i in range(1, n):
ruisekiwa.append(ruisekiwa[-1] + A_B[i])
# print(A_B)
# print(ruisekiwa)
ans = 0
for i in range(n):
idx = bisect_left(B, C[i])
if idx:
ans += ruisekiwa[idx-1]
print(ans) | from bisect import bisect_left, bisect_right
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
C.sort()
ans = 0
for i in range(n):
ans += bisect_left(A, B[i]) * (n - bisect_right(C, B[i]))
print(ans)
| 35 | 16 | 557 | 308 | from bisect import bisect_left
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
B.sort()
C.sort()
# print(A)
# print(B)
# print(C)
A_B = []
for i in range(n):
A_B.append(bisect_left(A, B[i]))
ruisekiwa = [A_B[0]]
for i in range(1, n):
ruisekiwa.append(ruisekiwa[-1] + A_B[i])
# print(A_B)
# print(ruisekiwa)
ans = 0
for i in range(n):
idx = bisect_left(B, C[i])
if idx:
ans += ruisekiwa[idx - 1]
print(ans)
| from bisect import bisect_left, bisect_right
n = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
C = list(map(int, input().split()))
A.sort()
C.sort()
ans = 0
for i in range(n):
ans += bisect_left(A, B[i]) * (n - bisect_right(C, B[i]))
print(ans)
| false | 54.285714 | [
"-from bisect import bisect_left",
"+from bisect import bisect_left, bisect_right",
"-B.sort()",
"-# print(A)",
"-# print(B)",
"-# print(C)",
"-A_B = []",
"-for i in range(n):",
"- A_B.append(bisect_left(A, B[i]))",
"-ruisekiwa = [A_B[0]]",
"-for i in range(1, n):",
"- ruisekiwa.append(ruisekiwa[-1] + A_B[i])",
"-# print(A_B)",
"-# print(ruisekiwa)",
"- idx = bisect_left(B, C[i])",
"- if idx:",
"- ans += ruisekiwa[idx - 1]",
"+ ans += bisect_left(A, B[i]) * (n - bisect_right(C, B[i]))"
] | false | 0.049924 | 0.093937 | 0.531462 | [
"s340517091",
"s967621628"
] |
u546338822 | p02803 | python | s795015608 | s983459984 | 1,618 | 543 | 12,500 | 12,424 | Accepted | Accepted | 66.44 | def main():
import numpy as np
def bfs(S,s,h,w):
dist = np.ones((h,w))*-1
dist[s[0],s[1]]=0
que = [s]
while len(que)>0:
v = que.pop(0)
if v[0]+1<h:
if S[v[0]+1][v[1]]=='.' and dist[v[0]+1][v[1]] == -1:
dist[v[0]+1][v[1]]=dist[v[0]][v[1]]+1
que.append([v[0]+1,v[1]])
if v[0]-1>-1:
if S[v[0]-1][v[1]]=='.' and dist[v[0]-1][v[1]]==-1:
dist[v[0]-1][v[1]]=dist[v[0]][v[1]]+1
que.append([v[0]-1,v[1]])
if v[1]+1<w:
if S[v[0]][v[1]+1]=='.' and dist[v[0]][v[1]+1]==-1:
dist[v[0]][v[1]+1]=dist[v[0]][v[1]]+1
que.append([v[0],v[1]+1])
if v[1]-1>-1:
if S[v[0]][v[1]-1]=='.' and dist[v[0]][v[1]-1]==-1:
dist[v[0]][v[1]-1]=dist[v[0]][v[1]]+1
que.append([v[0],v[1]-1])
return np.max(dist)
h,w = list(map(int,input().split()))
S = []
for i in range(h):
S.append(eval(input()))
m = 0
spot = []
for i in range(h):
for j in range(w):
spot.append([i,j])
for i in range(len(spot)):
s = spot[i]
if S[s[0]][s[1]]=='#':
continue
d = bfs(S,s,h,w)
if m<d:
m = d
print((int(m)))
if __name__ == "__main__":
main() | def main():
import numpy as np
h,w = list(map(int,input().split()))
maize = []
for i in range(h):
s = eval(input())
maize.append(s)
ans = 0
for i in range(h):
for j in range(w):
que = [[i,j]]
if maize[i][j] == '.':
dis = [[-1 for i in range(w)] for i in range(h)]
dis[i][j] = 0
while len(que)>0:
q = que.pop(0)
if q[0]>0:
n = [q[0]-1,q[1]]
if maize[n[0]][n[1]]=='.':
if dis[n[0]][n[1]]==-1:
dis[n[0]][n[1]] = dis[q[0]][q[1]]+1
que.append(n)
if q[0] < h-1:
n = [q[0]+1,q[1]]
if maize[n[0]][n[1]]=='.':
if dis[n[0]][n[1]]==-1:
dis[n[0]][n[1]] = dis[q[0]][q[1]]+1
que.append(n)
if q[1] > 0:
n = [q[0],q[1]-1]
if maize[n[0]][n[1]]=='.':
if dis[n[0]][n[1]]==-1:
dis[n[0]][n[1]] = dis[q[0]][q[1]]+1
que.append(n)
if q[1] < w-1:
n = [q[0],q[1]+1]
if maize[n[0]][n[1]]=='.':
if dis[n[0]][n[1]]==-1:
dis[n[0]][n[1]] = dis[q[0]][q[1]]+1
que.append(n)
dis = np.array(dis)
if np.max(dis)>ans:
ans = np.max(dis)
print(ans)
if __name__ == "__main__":
main()
| 47 | 48 | 1,473 | 1,825 | def main():
import numpy as np
def bfs(S, s, h, w):
dist = np.ones((h, w)) * -1
dist[s[0], s[1]] = 0
que = [s]
while len(que) > 0:
v = que.pop(0)
if v[0] + 1 < h:
if S[v[0] + 1][v[1]] == "." and dist[v[0] + 1][v[1]] == -1:
dist[v[0] + 1][v[1]] = dist[v[0]][v[1]] + 1
que.append([v[0] + 1, v[1]])
if v[0] - 1 > -1:
if S[v[0] - 1][v[1]] == "." and dist[v[0] - 1][v[1]] == -1:
dist[v[0] - 1][v[1]] = dist[v[0]][v[1]] + 1
que.append([v[0] - 1, v[1]])
if v[1] + 1 < w:
if S[v[0]][v[1] + 1] == "." and dist[v[0]][v[1] + 1] == -1:
dist[v[0]][v[1] + 1] = dist[v[0]][v[1]] + 1
que.append([v[0], v[1] + 1])
if v[1] - 1 > -1:
if S[v[0]][v[1] - 1] == "." and dist[v[0]][v[1] - 1] == -1:
dist[v[0]][v[1] - 1] = dist[v[0]][v[1]] + 1
que.append([v[0], v[1] - 1])
return np.max(dist)
h, w = list(map(int, input().split()))
S = []
for i in range(h):
S.append(eval(input()))
m = 0
spot = []
for i in range(h):
for j in range(w):
spot.append([i, j])
for i in range(len(spot)):
s = spot[i]
if S[s[0]][s[1]] == "#":
continue
d = bfs(S, s, h, w)
if m < d:
m = d
print((int(m)))
if __name__ == "__main__":
main()
| def main():
import numpy as np
h, w = list(map(int, input().split()))
maize = []
for i in range(h):
s = eval(input())
maize.append(s)
ans = 0
for i in range(h):
for j in range(w):
que = [[i, j]]
if maize[i][j] == ".":
dis = [[-1 for i in range(w)] for i in range(h)]
dis[i][j] = 0
while len(que) > 0:
q = que.pop(0)
if q[0] > 0:
n = [q[0] - 1, q[1]]
if maize[n[0]][n[1]] == ".":
if dis[n[0]][n[1]] == -1:
dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1
que.append(n)
if q[0] < h - 1:
n = [q[0] + 1, q[1]]
if maize[n[0]][n[1]] == ".":
if dis[n[0]][n[1]] == -1:
dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1
que.append(n)
if q[1] > 0:
n = [q[0], q[1] - 1]
if maize[n[0]][n[1]] == ".":
if dis[n[0]][n[1]] == -1:
dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1
que.append(n)
if q[1] < w - 1:
n = [q[0], q[1] + 1]
if maize[n[0]][n[1]] == ".":
if dis[n[0]][n[1]] == -1:
dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1
que.append(n)
dis = np.array(dis)
if np.max(dis) > ans:
ans = np.max(dis)
print(ans)
if __name__ == "__main__":
main()
| false | 2.083333 | [
"- def bfs(S, s, h, w):",
"- dist = np.ones((h, w)) * -1",
"- dist[s[0], s[1]] = 0",
"- que = [s]",
"- while len(que) > 0:",
"- v = que.pop(0)",
"- if v[0] + 1 < h:",
"- if S[v[0] + 1][v[1]] == \".\" and dist[v[0] + 1][v[1]] == -1:",
"- dist[v[0] + 1][v[1]] = dist[v[0]][v[1]] + 1",
"- que.append([v[0] + 1, v[1]])",
"- if v[0] - 1 > -1:",
"- if S[v[0] - 1][v[1]] == \".\" and dist[v[0] - 1][v[1]] == -1:",
"- dist[v[0] - 1][v[1]] = dist[v[0]][v[1]] + 1",
"- que.append([v[0] - 1, v[1]])",
"- if v[1] + 1 < w:",
"- if S[v[0]][v[1] + 1] == \".\" and dist[v[0]][v[1] + 1] == -1:",
"- dist[v[0]][v[1] + 1] = dist[v[0]][v[1]] + 1",
"- que.append([v[0], v[1] + 1])",
"- if v[1] - 1 > -1:",
"- if S[v[0]][v[1] - 1] == \".\" and dist[v[0]][v[1] - 1] == -1:",
"- dist[v[0]][v[1] - 1] = dist[v[0]][v[1]] + 1",
"- que.append([v[0], v[1] - 1])",
"- return np.max(dist)",
"-",
"- S = []",
"+ maize = []",
"- S.append(eval(input()))",
"- m = 0",
"- spot = []",
"+ s = eval(input())",
"+ maize.append(s)",
"+ ans = 0",
"- spot.append([i, j])",
"- for i in range(len(spot)):",
"- s = spot[i]",
"- if S[s[0]][s[1]] == \"#\":",
"- continue",
"- d = bfs(S, s, h, w)",
"- if m < d:",
"- m = d",
"- print((int(m)))",
"+ que = [[i, j]]",
"+ if maize[i][j] == \".\":",
"+ dis = [[-1 for i in range(w)] for i in range(h)]",
"+ dis[i][j] = 0",
"+ while len(que) > 0:",
"+ q = que.pop(0)",
"+ if q[0] > 0:",
"+ n = [q[0] - 1, q[1]]",
"+ if maize[n[0]][n[1]] == \".\":",
"+ if dis[n[0]][n[1]] == -1:",
"+ dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1",
"+ que.append(n)",
"+ if q[0] < h - 1:",
"+ n = [q[0] + 1, q[1]]",
"+ if maize[n[0]][n[1]] == \".\":",
"+ if dis[n[0]][n[1]] == -1:",
"+ dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1",
"+ que.append(n)",
"+ if q[1] > 0:",
"+ n = [q[0], q[1] - 1]",
"+ if maize[n[0]][n[1]] == \".\":",
"+ if dis[n[0]][n[1]] == -1:",
"+ dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1",
"+ que.append(n)",
"+ if q[1] < w - 1:",
"+ n = [q[0], q[1] + 1]",
"+ if maize[n[0]][n[1]] == \".\":",
"+ if dis[n[0]][n[1]] == -1:",
"+ dis[n[0]][n[1]] = dis[q[0]][q[1]] + 1",
"+ que.append(n)",
"+ dis = np.array(dis)",
"+ if np.max(dis) > ans:",
"+ ans = np.max(dis)",
"+ print(ans)"
] | false | 0.212161 | 0.192321 | 1.103159 | [
"s795015608",
"s983459984"
] |
u706929073 | p03111 | python | s116427460 | s130657193 | 78 | 72 | 3,064 | 3,064 | Accepted | Accepted | 7.69 | n, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
inf = 10 ** 18
def dfs(i, a, b, c):
if i == n:
if a < 1 or b < 1 or c < 1:
return inf
return abs(A - a) + abs(B - b) + abs(C - c)
res = dfs(i + 1, a, b, c)
res = min([res, dfs(i + 1, a + l[i], b, c) + (10 if a > 0 else 0)])
res = min([res, dfs(i + 1, a, b + l[i], c) + (10 if b > 0 else 0)])
res = min([res, dfs(i + 1, a, b, c + l[i]) + (10 if c > 0 else 0)])
return res
print((dfs(0, 0, 0, 0)))
| n, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
def dfs(i, a, b, c):
if n == i:
if a < 1 or b < 1 or c < 1:
return 10 ** 18
return abs(A - a) + abs(B - b) + abs(C - c)
res = dfs(i + 1, a, b, c)
res = min([res, dfs(i + 1, a + l[i], b, c) + (10 if a > 0 else 0)])
res = min([res, dfs(i + 1, a, b + l[i], c) + (10 if b > 0 else 0)])
res = min([res, dfs(i + 1, a, b, c + l[i]) + (10 if c > 0 else 0)])
return res
print((dfs(0, 0, 0, 0)))
| 18 | 18 | 543 | 534 | n, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
inf = 10**18
def dfs(i, a, b, c):
if i == n:
if a < 1 or b < 1 or c < 1:
return inf
return abs(A - a) + abs(B - b) + abs(C - c)
res = dfs(i + 1, a, b, c)
res = min([res, dfs(i + 1, a + l[i], b, c) + (10 if a > 0 else 0)])
res = min([res, dfs(i + 1, a, b + l[i], c) + (10 if b > 0 else 0)])
res = min([res, dfs(i + 1, a, b, c + l[i]) + (10 if c > 0 else 0)])
return res
print((dfs(0, 0, 0, 0)))
| n, A, B, C = list(map(int, input().split()))
l = [int(eval(input())) for _ in range(n)]
def dfs(i, a, b, c):
if n == i:
if a < 1 or b < 1 or c < 1:
return 10**18
return abs(A - a) + abs(B - b) + abs(C - c)
res = dfs(i + 1, a, b, c)
res = min([res, dfs(i + 1, a + l[i], b, c) + (10 if a > 0 else 0)])
res = min([res, dfs(i + 1, a, b + l[i], c) + (10 if b > 0 else 0)])
res = min([res, dfs(i + 1, a, b, c + l[i]) + (10 if c > 0 else 0)])
return res
print((dfs(0, 0, 0, 0)))
| false | 0 | [
"-inf = 10**18",
"- if i == n:",
"+ if n == i:",
"- return inf",
"+ return 10**18"
] | false | 0.070895 | 0.070791 | 1.001476 | [
"s116427460",
"s130657193"
] |
u924691798 | p02793 | python | s229589102 | s223205999 | 1,898 | 861 | 6,112 | 4,852 | Accepted | Accepted | 54.64 | from fractions import gcd
MOD = 10**9+7
N = int(eval(input()))
A = list(map(int, input().split()))
now = A[0]
ans = 0
for i in range(1,N):
now = now//gcd(now, A[i])*A[i]
for i in range(N):
ans += now//A[i]
print((ans%MOD)) | from collections import defaultdict
def prime_factors(n):
d = defaultdict(int)
while n%2 == 0:
d[2] += 1
n //= 2
i = 3
while i*i <= n:
while n%i == 0:
d[i] += 1
n //= i
i += 2
if n > 2:
d[n] += 1
return d
MOD = 10**9+7
N = int(eval(input()))
A = list(map(int, input().split()))
G = defaultdict(int)
for a in A:
pf = prime_factors(a)
for k,v in list(pf.items()):
G[k] = max(G[k], v)
lcm = 1
for k,v in list(G.items()):
lcm *= pow(k, v, MOD)
lcm %= MOD
ans = 0
for a in A:
ans += lcm * pow(a, MOD-2, MOD) % MOD
ans %= MOD
print(ans) | 11 | 34 | 232 | 667 | from fractions import gcd
MOD = 10**9 + 7
N = int(eval(input()))
A = list(map(int, input().split()))
now = A[0]
ans = 0
for i in range(1, N):
now = now // gcd(now, A[i]) * A[i]
for i in range(N):
ans += now // A[i]
print((ans % MOD))
| from collections import defaultdict
def prime_factors(n):
d = defaultdict(int)
while n % 2 == 0:
d[2] += 1
n //= 2
i = 3
while i * i <= n:
while n % i == 0:
d[i] += 1
n //= i
i += 2
if n > 2:
d[n] += 1
return d
MOD = 10**9 + 7
N = int(eval(input()))
A = list(map(int, input().split()))
G = defaultdict(int)
for a in A:
pf = prime_factors(a)
for k, v in list(pf.items()):
G[k] = max(G[k], v)
lcm = 1
for k, v in list(G.items()):
lcm *= pow(k, v, MOD)
lcm %= MOD
ans = 0
for a in A:
ans += lcm * pow(a, MOD - 2, MOD) % MOD
ans %= MOD
print(ans)
| false | 67.647059 | [
"-from fractions import gcd",
"+from collections import defaultdict",
"+",
"+",
"+def prime_factors(n):",
"+ d = defaultdict(int)",
"+ while n % 2 == 0:",
"+ d[2] += 1",
"+ n //= 2",
"+ i = 3",
"+ while i * i <= n:",
"+ while n % i == 0:",
"+ d[i] += 1",
"+ n //= i",
"+ i += 2",
"+ if n > 2:",
"+ d[n] += 1",
"+ return d",
"+",
"-now = A[0]",
"+G = defaultdict(int)",
"+for a in A:",
"+ pf = prime_factors(a)",
"+ for k, v in list(pf.items()):",
"+ G[k] = max(G[k], v)",
"+lcm = 1",
"+for k, v in list(G.items()):",
"+ lcm *= pow(k, v, MOD)",
"+ lcm %= MOD",
"-for i in range(1, N):",
"- now = now // gcd(now, A[i]) * A[i]",
"-for i in range(N):",
"- ans += now // A[i]",
"-print((ans % MOD))",
"+for a in A:",
"+ ans += lcm * pow(a, MOD - 2, MOD) % MOD",
"+ ans %= MOD",
"+print(ans)"
] | false | 0.109145 | 0.159082 | 0.686096 | [
"s229589102",
"s223205999"
] |
u576432509 | p03495 | python | s668123140 | s787240477 | 360 | 128 | 31,396 | 25,376 | Accepted | Accepted | 64.44 | n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
s=[]
ai=a[0]
acnt=-1
for i in range(n):
if a[i]>ai:
s.append([acnt+1,ai])
acnt=0
ai=a[i]
else:
acnt=acnt+1
s.append([acnt+1,ai])
if len(s)<=k:
print((0))
else:
s.sort()
# print(s)
ssum=0
for i in range(len(s)-k):
ssum=ssum+s[i][0]
print(ssum)
| n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
c=[0]*(n+1)
for i in range(n):
c[a[i]]+=1
c.sort(reverse=True)
csum=0
for i in range(k):
csum+=c[i]
print((n-csum)) | 28 | 11 | 430 | 194 | n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
s = []
ai = a[0]
acnt = -1
for i in range(n):
if a[i] > ai:
s.append([acnt + 1, ai])
acnt = 0
ai = a[i]
else:
acnt = acnt + 1
s.append([acnt + 1, ai])
if len(s) <= k:
print((0))
else:
s.sort()
# print(s)
ssum = 0
for i in range(len(s) - k):
ssum = ssum + s[i][0]
print(ssum)
| n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
c = [0] * (n + 1)
for i in range(n):
c[a[i]] += 1
c.sort(reverse=True)
csum = 0
for i in range(k):
csum += c[i]
print((n - csum))
| false | 60.714286 | [
"-a.sort()",
"-s = []",
"-ai = a[0]",
"-acnt = -1",
"+c = [0] * (n + 1)",
"- if a[i] > ai:",
"- s.append([acnt + 1, ai])",
"- acnt = 0",
"- ai = a[i]",
"- else:",
"- acnt = acnt + 1",
"-s.append([acnt + 1, ai])",
"-if len(s) <= k:",
"- print((0))",
"-else:",
"- s.sort()",
"- # print(s)",
"- ssum = 0",
"- for i in range(len(s) - k):",
"- ssum = ssum + s[i][0]",
"- print(ssum)",
"+ c[a[i]] += 1",
"+c.sort(reverse=True)",
"+csum = 0",
"+for i in range(k):",
"+ csum += c[i]",
"+print((n - csum))"
] | false | 0.039453 | 0.038785 | 1.017246 | [
"s668123140",
"s787240477"
] |
u515740713 | p02613 | python | s688151368 | s138113265 | 70 | 48 | 9,256 | 16,564 | Accepted | Accepted | 31.43 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
cnt = [0]*4
for i in range(N):
S = readline().decode().rstrip()
if S == 'AC':
cnt[0] +=1
if S == 'WA':
cnt[1] +=1
if S == 'TLE':
cnt[2] +=1
if S == 'RE':
cnt[3] +=1
print(('AC x '+str(cnt[0])))
print(('WA x '+str(cnt[1])))
print(('TLE x '+str(cnt[2])))
print(('RE x '+str(cnt[3]))) | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
S = read().decode().rstrip().split()
for s in ['AC','WA','TLE','RE']:
print(("{0} x {1}".format(s,S.count(s)))) | 20 | 8 | 481 | 257 | import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
cnt = [0] * 4
for i in range(N):
S = readline().decode().rstrip()
if S == "AC":
cnt[0] += 1
if S == "WA":
cnt[1] += 1
if S == "TLE":
cnt[2] += 1
if S == "RE":
cnt[3] += 1
print(("AC x " + str(cnt[0])))
print(("WA x " + str(cnt[1])))
print(("TLE x " + str(cnt[2])))
print(("RE x " + str(cnt[3])))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
N = int(readline())
S = read().decode().rstrip().split()
for s in ["AC", "WA", "TLE", "RE"]:
print(("{0} x {1}".format(s, S.count(s))))
| false | 60 | [
"-cnt = [0] * 4",
"-for i in range(N):",
"- S = readline().decode().rstrip()",
"- if S == \"AC\":",
"- cnt[0] += 1",
"- if S == \"WA\":",
"- cnt[1] += 1",
"- if S == \"TLE\":",
"- cnt[2] += 1",
"- if S == \"RE\":",
"- cnt[3] += 1",
"-print((\"AC x \" + str(cnt[0])))",
"-print((\"WA x \" + str(cnt[1])))",
"-print((\"TLE x \" + str(cnt[2])))",
"-print((\"RE x \" + str(cnt[3])))",
"+S = read().decode().rstrip().split()",
"+for s in [\"AC\", \"WA\", \"TLE\", \"RE\"]:",
"+ print((\"{0} x {1}\".format(s, S.count(s))))"
] | false | 0.047123 | 0.047343 | 0.99534 | [
"s688151368",
"s138113265"
] |
u548303713 | p03835 | python | s088283550 | s059837918 | 1,970 | 240 | 3,060 | 40,940 | Accepted | Accepted | 87.82 | #ABC51-B
K,S=list(map(int,input().split()))
sum=0
count=0
for i in range(K+1):
sum+=i
a=sum
L=S-sum
#print(L)
LL=min(L,K)
for j in range(LL+1):
sum+=j
if S-sum>=0 and S-sum<=K :
count+=1
#print(str(i)+" "+str(j))
sum=a #jを足す前に戻す
sum=0
print(count) | k,s=list(map(int,input().split()))
ans=0
for i in range(k+1):
for j in range(k+1):
if 0<=s-(i+j)<=k:
ans+=1
print(ans) | 19 | 7 | 346 | 142 | # ABC51-B
K, S = list(map(int, input().split()))
sum = 0
count = 0
for i in range(K + 1):
sum += i
a = sum
L = S - sum
# print(L)
LL = min(L, K)
for j in range(LL + 1):
sum += j
if S - sum >= 0 and S - sum <= K:
count += 1
# print(str(i)+" "+str(j))
sum = a # jを足す前に戻す
sum = 0
print(count)
| k, s = list(map(int, input().split()))
ans = 0
for i in range(k + 1):
for j in range(k + 1):
if 0 <= s - (i + j) <= k:
ans += 1
print(ans)
| false | 63.157895 | [
"-# ABC51-B",
"-K, S = list(map(int, input().split()))",
"-sum = 0",
"-count = 0",
"-for i in range(K + 1):",
"- sum += i",
"- a = sum",
"- L = S - sum",
"- # print(L)",
"- LL = min(L, K)",
"- for j in range(LL + 1):",
"- sum += j",
"- if S - sum >= 0 and S - sum <= K:",
"- count += 1",
"- # print(str(i)+\" \"+str(j))",
"- sum = a # jを足す前に戻す",
"- sum = 0",
"-print(count)",
"+k, s = list(map(int, input().split()))",
"+ans = 0",
"+for i in range(k + 1):",
"+ for j in range(k + 1):",
"+ if 0 <= s - (i + j) <= k:",
"+ ans += 1",
"+print(ans)"
] | false | 0.036758 | 0.036957 | 0.994625 | [
"s088283550",
"s059837918"
] |
u780475861 | p02794 | python | s324254622 | s194848738 | 312 | 227 | 62,412 | 61,392 | Accepted | Accepted | 27.24 | # https://atcoder.jp/contests/abc152/submissions/9619555
import sys
readline = sys.stdin.readline
import numpy as np
N = int(readline())
AB = list(list(map(int, readline().split())) for _ in range(N - 1))
M = int(readline())
UV = list(list(map(int, readline().split())) for _ in range(M))
graph = [[] for _ in range(N + 1)]
for i, (a, b) in enumerate(AB):
graph[a].append((b, i))
graph[b].append((a, i))
def get_path(U, V):
INF = 100
visited = [False] * (N + 1)
pred = [None] * (N + 1)
stack = [U]
visited[U] = True
while stack:
v = stack.pop()
for w, i in graph[v]:
if visited[w]:
continue
visited[w] = True
pred[w] = (v, i)
stack.append(w)
path = 0
w = V
while w != U:
v, i = pred[w]
w = v
path += 1 << i
return path
condition_path = [get_path(u, v) for u, v in UV]
def popcnt(n):
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333)
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f0f0f0f0f)
c = (c & 0x00ff00ff00ff00ff) + ((c >> 8) & 0x00ff00ff00ff00ff)
c = (c & 0x0000ffff0000ffff) + ((c >> 16) & 0x0000ffff0000ffff)
c = (c & 0x00000000ffffffff) + ((c >> 32) & 0x00000000ffffffff)
return c
sgn = np.where(popcnt(np.arange(1 << M)) % 2, -1, 1)
S = np.zeros(1 << M, np.int64)
for i in range(M):
S[1 << i:1 << (i + 1)] = S[:1 << i] | condition_path[i]
n_edges = popcnt(S)
x = 1 << (N - 1 - n_edges)
answer = np.sum(x * sgn)
print(answer)
| # https://atcoder.jp/contests/abc152/submissions/9619555
import sys
readline = sys.stdin.readline
import numpy as np
N = int(readline())
AB = list(list(map(int, readline().split())) for _ in range(N - 1))
M = int(readline())
UV = list(list(map(int, readline().split())) for _ in range(M))
graph = [[] for _ in range(N + 1)]
for i, (a, b) in enumerate(AB):
graph[a].append((b, i))
graph[b].append((a, i))
def get_path(U, V):
INF = 100
visited = [False] * (N + 1)
pred = [None] * (N + 1)
stack = [U]
visited[U] = True
while stack:
v = stack.pop()
for w, i in graph[v]:
if visited[w]:
continue
visited[w] = True
pred[w] = (v, i)
stack.append(w)
path = 0
w = V
while w != U:
v, i = pred[w]
w = v
path += 1 << i
return path
condition_path = [get_path(u, v) for u, v in UV]
def popcnt(n):
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333)
c = (c & 0x0f0f0f0f0f0f0f0f) + ((c >> 4) & 0x0f0f0f0f0f0f0f0f)
c = (c & 0x00ff00ff00ff00ff) + ((c >> 8) & 0x00ff00ff00ff00ff)
c = (c & 0x0000ffff0000ffff) + ((c >> 16) & 0x0000ffff0000ffff)
c = (c & 0x00000000ffffffff) + ((c >> 32) & 0x00000000ffffffff)
return c
S = np.zeros(1 << M, np.int64)
sgn = np.ones(1 << M, np.int64)
for i in range(M):
S[1 << i:1 << (i + 1)] = S[:1 << i] | condition_path[i]
sgn[1 << i:1 << (i + 1)] = -sgn[:1 << i]
n_edges = popcnt(S)
x = 1 << (N - 1 - n_edges)
answer = (x * sgn).sum()
print(answer)
| 64 | 64 | 1,678 | 1,701 | # https://atcoder.jp/contests/abc152/submissions/9619555
import sys
readline = sys.stdin.readline
import numpy as np
N = int(readline())
AB = list(list(map(int, readline().split())) for _ in range(N - 1))
M = int(readline())
UV = list(list(map(int, readline().split())) for _ in range(M))
graph = [[] for _ in range(N + 1)]
for i, (a, b) in enumerate(AB):
graph[a].append((b, i))
graph[b].append((a, i))
def get_path(U, V):
INF = 100
visited = [False] * (N + 1)
pred = [None] * (N + 1)
stack = [U]
visited[U] = True
while stack:
v = stack.pop()
for w, i in graph[v]:
if visited[w]:
continue
visited[w] = True
pred[w] = (v, i)
stack.append(w)
path = 0
w = V
while w != U:
v, i = pred[w]
w = v
path += 1 << i
return path
condition_path = [get_path(u, v) for u, v in UV]
def popcnt(n):
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333)
c = (c & 0x0F0F0F0F0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F0F0F0F0F)
c = (c & 0x00FF00FF00FF00FF) + ((c >> 8) & 0x00FF00FF00FF00FF)
c = (c & 0x0000FFFF0000FFFF) + ((c >> 16) & 0x0000FFFF0000FFFF)
c = (c & 0x00000000FFFFFFFF) + ((c >> 32) & 0x00000000FFFFFFFF)
return c
sgn = np.where(popcnt(np.arange(1 << M)) % 2, -1, 1)
S = np.zeros(1 << M, np.int64)
for i in range(M):
S[1 << i : 1 << (i + 1)] = S[: 1 << i] | condition_path[i]
n_edges = popcnt(S)
x = 1 << (N - 1 - n_edges)
answer = np.sum(x * sgn)
print(answer)
| # https://atcoder.jp/contests/abc152/submissions/9619555
import sys
readline = sys.stdin.readline
import numpy as np
N = int(readline())
AB = list(list(map(int, readline().split())) for _ in range(N - 1))
M = int(readline())
UV = list(list(map(int, readline().split())) for _ in range(M))
graph = [[] for _ in range(N + 1)]
for i, (a, b) in enumerate(AB):
graph[a].append((b, i))
graph[b].append((a, i))
def get_path(U, V):
INF = 100
visited = [False] * (N + 1)
pred = [None] * (N + 1)
stack = [U]
visited[U] = True
while stack:
v = stack.pop()
for w, i in graph[v]:
if visited[w]:
continue
visited[w] = True
pred[w] = (v, i)
stack.append(w)
path = 0
w = V
while w != U:
v, i = pred[w]
w = v
path += 1 << i
return path
condition_path = [get_path(u, v) for u, v in UV]
def popcnt(n):
c = (n & 0x5555555555555555) + ((n >> 1) & 0x5555555555555555)
c = (c & 0x3333333333333333) + ((c >> 2) & 0x3333333333333333)
c = (c & 0x0F0F0F0F0F0F0F0F) + ((c >> 4) & 0x0F0F0F0F0F0F0F0F)
c = (c & 0x00FF00FF00FF00FF) + ((c >> 8) & 0x00FF00FF00FF00FF)
c = (c & 0x0000FFFF0000FFFF) + ((c >> 16) & 0x0000FFFF0000FFFF)
c = (c & 0x00000000FFFFFFFF) + ((c >> 32) & 0x00000000FFFFFFFF)
return c
S = np.zeros(1 << M, np.int64)
sgn = np.ones(1 << M, np.int64)
for i in range(M):
S[1 << i : 1 << (i + 1)] = S[: 1 << i] | condition_path[i]
sgn[1 << i : 1 << (i + 1)] = -sgn[: 1 << i]
n_edges = popcnt(S)
x = 1 << (N - 1 - n_edges)
answer = (x * sgn).sum()
print(answer)
| false | 0 | [
"-sgn = np.where(popcnt(np.arange(1 << M)) % 2, -1, 1)",
"+sgn = np.ones(1 << M, np.int64)",
"+ sgn[1 << i : 1 << (i + 1)] = -sgn[: 1 << i]",
"-answer = np.sum(x * sgn)",
"+answer = (x * sgn).sum()"
] | false | 0.293811 | 0.540176 | 0.543917 | [
"s324254622",
"s194848738"
] |
u814781830 | p02882 | python | s634747048 | s025084017 | 181 | 29 | 38,896 | 3,064 | Accepted | Accepted | 83.98 | import math
PI = math.pi
EPS = 0.0000000001
a, b, x = list(map(int, input().split()))
def f(a, b, theta):
# theta = pi/2-theta
if a * math.tan(theta) <= b:
return a * a * b - a * a * a * math.tan(theta) / 2
else:
return b * b / math.tan(theta) * a / 2
def solve():
ok = PI / 2
ng = 0.0
for _ in range(100000):
mid = (ok+ng) / 2
if f(a, b, mid) < x:
ok = mid
else:
ng = mid
print((ok/PI*180))
solve() | import math
a, b, x = list(map(int, input().split()))
x /= a
half = a * b // 2
# 引数の角度で入る水の量を計算する
def check(theta):
if x <= half:
theta = math.radians(theta)
return b ** 2 / 2 * math.tan(theta)
else:
theta = math.radians(90-theta)
return a * b - (0.5 * a ** 2 * math.tan(theta))
l, r = 0, 90
for _ in range(10000):
mid = (l+r) / 2
if check(mid) > x:
r = mid
else:
l = mid
print((90-l))
| 26 | 24 | 517 | 477 | import math
PI = math.pi
EPS = 0.0000000001
a, b, x = list(map(int, input().split()))
def f(a, b, theta):
# theta = pi/2-theta
if a * math.tan(theta) <= b:
return a * a * b - a * a * a * math.tan(theta) / 2
else:
return b * b / math.tan(theta) * a / 2
def solve():
ok = PI / 2
ng = 0.0
for _ in range(100000):
mid = (ok + ng) / 2
if f(a, b, mid) < x:
ok = mid
else:
ng = mid
print((ok / PI * 180))
solve()
| import math
a, b, x = list(map(int, input().split()))
x /= a
half = a * b // 2
# 引数の角度で入る水の量を計算する
def check(theta):
if x <= half:
theta = math.radians(theta)
return b**2 / 2 * math.tan(theta)
else:
theta = math.radians(90 - theta)
return a * b - (0.5 * a**2 * math.tan(theta))
l, r = 0, 90
for _ in range(10000):
mid = (l + r) / 2
if check(mid) > x:
r = mid
else:
l = mid
print((90 - l))
| false | 7.692308 | [
"-PI = math.pi",
"-EPS = 0.0000000001",
"+x /= a",
"+half = a * b // 2",
"+# 引数の角度で入る水の量を計算する",
"+def check(theta):",
"+ if x <= half:",
"+ theta = math.radians(theta)",
"+ return b**2 / 2 * math.tan(theta)",
"+ else:",
"+ theta = math.radians(90 - theta)",
"+ return a * b - (0.5 * a**2 * math.tan(theta))",
"-def f(a, b, theta):",
"- # theta = pi/2-theta",
"- if a * math.tan(theta) <= b:",
"- return a * a * b - a * a * a * math.tan(theta) / 2",
"+l, r = 0, 90",
"+for _ in range(10000):",
"+ mid = (l + r) / 2",
"+ if check(mid) > x:",
"+ r = mid",
"- return b * b / math.tan(theta) * a / 2",
"-",
"-",
"-def solve():",
"- ok = PI / 2",
"- ng = 0.0",
"- for _ in range(100000):",
"- mid = (ok + ng) / 2",
"- if f(a, b, mid) < x:",
"- ok = mid",
"- else:",
"- ng = mid",
"- print((ok / PI * 180))",
"-",
"-",
"-solve()",
"+ l = mid",
"+print((90 - l))"
] | false | 0.457113 | 0.047567 | 9.60987 | [
"s634747048",
"s025084017"
] |
u849334482 | p02659 | python | s704852155 | s535826693 | 28 | 21 | 10,076 | 9,096 | Accepted | Accepted | 25 | import math
from decimal import Decimal
A = input().split()
answer = Decimal(A[0]) * Decimal(A[1])
print((math.floor(answer))) | a, b = input().split()
a = int(a)
b = int(b.replace(".", ""))
ans = a * b // 100
print(ans) | 7 | 7 | 132 | 99 | import math
from decimal import Decimal
A = input().split()
answer = Decimal(A[0]) * Decimal(A[1])
print((math.floor(answer)))
| a, b = input().split()
a = int(a)
b = int(b.replace(".", ""))
ans = a * b // 100
print(ans)
| false | 0 | [
"-import math",
"-from decimal import Decimal",
"-",
"-A = input().split()",
"-answer = Decimal(A[0]) * Decimal(A[1])",
"-print((math.floor(answer)))",
"+a, b = input().split()",
"+a = int(a)",
"+b = int(b.replace(\".\", \"\"))",
"+ans = a * b // 100",
"+print(ans)"
] | false | 0.044996 | 0.06768 | 0.66483 | [
"s704852155",
"s535826693"
] |
u989345508 | p03127 | python | s071381928 | s691569152 | 184 | 158 | 14,224 | 14,252 | Accepted | Accepted | 14.13 | #priority_queueで管理
#普通にソートすればいいじゃん
n=int(eval(input()))
a=sorted([int(i) for i in input().split()])
#print(a)
while len(a)!=1:
b=a[0]
for i in range(1,n):
a[i]-=b*(a[i]//b)
a=sorted([i for i in a if i!=0])
n=len(a)
#print(a)
print((a[0]))
| n=int(eval(input()))
a=list(map(int,input().split()))
while len(a)>1:
l=len(a)
a.sort()
b=[a[0] if i==0 else a[i]%a[0] for i in range(l)]
a=[b[i] for i in range(l) if b[i]!=0]
print((a[0]))
| 14 | 8 | 273 | 205 | # priority_queueで管理
# 普通にソートすればいいじゃん
n = int(eval(input()))
a = sorted([int(i) for i in input().split()])
# print(a)
while len(a) != 1:
b = a[0]
for i in range(1, n):
a[i] -= b * (a[i] // b)
a = sorted([i for i in a if i != 0])
n = len(a)
# print(a)
print((a[0]))
| n = int(eval(input()))
a = list(map(int, input().split()))
while len(a) > 1:
l = len(a)
a.sort()
b = [a[0] if i == 0 else a[i] % a[0] for i in range(l)]
a = [b[i] for i in range(l) if b[i] != 0]
print((a[0]))
| false | 42.857143 | [
"-# priority_queueで管理",
"-# 普通にソートすればいいじゃん",
"-a = sorted([int(i) for i in input().split()])",
"-# print(a)",
"-while len(a) != 1:",
"- b = a[0]",
"- for i in range(1, n):",
"- a[i] -= b * (a[i] // b)",
"- a = sorted([i for i in a if i != 0])",
"- n = len(a)",
"- # print(a)",
"+a = list(map(int, input().split()))",
"+while len(a) > 1:",
"+ l = len(a)",
"+ a.sort()",
"+ b = [a[0] if i == 0 else a[i] % a[0] for i in range(l)]",
"+ a = [b[i] for i in range(l) if b[i] != 0]"
] | false | 0.070708 | 0.038906 | 1.817381 | [
"s071381928",
"s691569152"
] |
u969850098 | p03212 | python | s081838821 | s383417742 | 480 | 91 | 7,272 | 3,060 | Accepted | Accepted | 81.04 | import sys
readline = sys.stdin.readline
from collections import deque
def main():
N = int(readline())
que = []
for val in ['357', '375', '537', '573', '735', '753']:
if int(val) <= N:
que.append(val)
res = set(que)
que = deque(que)
while que:
pre = que.popleft()
for p in ['3', '5', '7']:
for i in range(len(pre)+1):
next = pre[:i] + p + pre[i:]
if int(next) <= N and next not in res:
que.append(next)
res.add(next)
print((len(res)))
if __name__ == '__main__':
main() | import sys
readline = sys.stdin.readline
N = int(readline())
def dfs(num):
if int(num) > N:
return 0
if all(num.count(n) > 0 for n in '753'):
res = 1
else:
res = 0
for n in '753':
res += dfs(num + n)
return res
def main():
print((dfs('0')))
if __name__ == '__main__':
main() | 25 | 23 | 645 | 368 | import sys
readline = sys.stdin.readline
from collections import deque
def main():
N = int(readline())
que = []
for val in ["357", "375", "537", "573", "735", "753"]:
if int(val) <= N:
que.append(val)
res = set(que)
que = deque(que)
while que:
pre = que.popleft()
for p in ["3", "5", "7"]:
for i in range(len(pre) + 1):
next = pre[:i] + p + pre[i:]
if int(next) <= N and next not in res:
que.append(next)
res.add(next)
print((len(res)))
if __name__ == "__main__":
main()
| import sys
readline = sys.stdin.readline
N = int(readline())
def dfs(num):
if int(num) > N:
return 0
if all(num.count(n) > 0 for n in "753"):
res = 1
else:
res = 0
for n in "753":
res += dfs(num + n)
return res
def main():
print((dfs("0")))
if __name__ == "__main__":
main()
| false | 8 | [
"-from collections import deque",
"+N = int(readline())",
"+",
"+",
"+def dfs(num):",
"+ if int(num) > N:",
"+ return 0",
"+ if all(num.count(n) > 0 for n in \"753\"):",
"+ res = 1",
"+ else:",
"+ res = 0",
"+ for n in \"753\":",
"+ res += dfs(num + n)",
"+ return res",
"- N = int(readline())",
"- que = []",
"- for val in [\"357\", \"375\", \"537\", \"573\", \"735\", \"753\"]:",
"- if int(val) <= N:",
"- que.append(val)",
"- res = set(que)",
"- que = deque(que)",
"- while que:",
"- pre = que.popleft()",
"- for p in [\"3\", \"5\", \"7\"]:",
"- for i in range(len(pre) + 1):",
"- next = pre[:i] + p + pre[i:]",
"- if int(next) <= N and next not in res:",
"- que.append(next)",
"- res.add(next)",
"- print((len(res)))",
"+ print((dfs(\"0\")))"
] | false | 0.392549 | 0.118104 | 3.323749 | [
"s081838821",
"s383417742"
] |
u501451051 | p03013 | python | s615101812 | s576318285 | 617 | 155 | 463,476 | 14,464 | Accepted | Accepted | 74.88 | n, m = list(map(int, input().split()))
mod = 10**9 + 7
no = [False] * (n+1)
for _ in range(m):
a = int(eval(input()))
no[a] = True
dp = [0] * (n+1)
dp[0] = 1
for i in range(n):
if (no[i]):
dp[i] = 0
if i + 1 <= n:
dp[i+1] += dp[i]
if i + 2 <= n:
dp[i+2] += dp[i]
print((dp[n] % mod))
| n , m = list(map(int, input().split()))
lis = [int(eval(input())) for _ in range(m)]
mod = 10**9+7
ans =[1] + [1] + [-1] * (n-1)
for i in lis:
ans[i] = 0
for i in range(2, n+1):
if ans[i] != 0:
ans[i] = (ans[i-1] + ans[i-2]) % mod
print((ans[n])) | 23 | 15 | 359 | 267 | n, m = list(map(int, input().split()))
mod = 10**9 + 7
no = [False] * (n + 1)
for _ in range(m):
a = int(eval(input()))
no[a] = True
dp = [0] * (n + 1)
dp[0] = 1
for i in range(n):
if no[i]:
dp[i] = 0
if i + 1 <= n:
dp[i + 1] += dp[i]
if i + 2 <= n:
dp[i + 2] += dp[i]
print((dp[n] % mod))
| n, m = list(map(int, input().split()))
lis = [int(eval(input())) for _ in range(m)]
mod = 10**9 + 7
ans = [1] + [1] + [-1] * (n - 1)
for i in lis:
ans[i] = 0
for i in range(2, n + 1):
if ans[i] != 0:
ans[i] = (ans[i - 1] + ans[i - 2]) % mod
print((ans[n]))
| false | 34.782609 | [
"+lis = [int(eval(input())) for _ in range(m)]",
"-no = [False] * (n + 1)",
"-for _ in range(m):",
"- a = int(eval(input()))",
"- no[a] = True",
"-dp = [0] * (n + 1)",
"-dp[0] = 1",
"-for i in range(n):",
"- if no[i]:",
"- dp[i] = 0",
"- if i + 1 <= n:",
"- dp[i + 1] += dp[i]",
"- if i + 2 <= n:",
"- dp[i + 2] += dp[i]",
"-print((dp[n] % mod))",
"+ans = [1] + [1] + [-1] * (n - 1)",
"+for i in lis:",
"+ ans[i] = 0",
"+for i in range(2, n + 1):",
"+ if ans[i] != 0:",
"+ ans[i] = (ans[i - 1] + ans[i - 2]) % mod",
"+print((ans[n]))"
] | false | 0.035195 | 0.034344 | 1.024781 | [
"s615101812",
"s576318285"
] |
u591589288 | p02577 | python | s241337512 | s322464600 | 80 | 70 | 74,500 | 73,772 | Accepted | Accepted | 12.5 | from functools import reduce
print(("Yes" if reduce(lambda a, b: (a+b)%9, list(map(int, eval(input()))), 0) == 0 else "No"))
| n = eval(input())
if (sum(map(int, n))) % 9 == 0:
print("Yes")
else:
print("No") | 3 | 6 | 114 | 89 | from functools import reduce
print(
(
"Yes"
if reduce(lambda a, b: (a + b) % 9, list(map(int, eval(input()))), 0) == 0
else "No"
)
)
| n = eval(input())
if (sum(map(int, n))) % 9 == 0:
print("Yes")
else:
print("No")
| false | 50 | [
"-from functools import reduce",
"-",
"-print(",
"- (",
"- \"Yes\"",
"- if reduce(lambda a, b: (a + b) % 9, list(map(int, eval(input()))), 0) == 0",
"- else \"No\"",
"- )",
"-)",
"+n = eval(input())",
"+if (sum(map(int, n))) % 9 == 0:",
"+ print(\"Yes\")",
"+else:",
"+ print(\"No\")"
] | false | 0.043343 | 0.044247 | 0.979584 | [
"s241337512",
"s322464600"
] |
u285891772 | p04021 | python | s199489240 | s336692905 | 180 | 149 | 26,888 | 25,988 | Accepted | Accepted | 17.22 | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
A = [[INT(), i] for i in range(N)]
A.sort(key = lambda x:x[0])
cnt = 0
for i, (x, idx) in enumerate(A):
if i%2 != idx%2:
cnt += 1
print((cnt//2)) | import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
def TUPLE(): return tuple(map(int, input().split()))
def ZIP(n): return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#mod = 998244353
from decimal import *
#import numpy as np
#decimal.getcontext().prec = 10
N = INT()
A = [INT() for _ in range(N)]
zipped = {x:i+1 for i, x in enumerate(sorted(A))}
A = [zipped[x] for x in A]
print((sum(x%2==0 for x in A[::2]))) | 35 | 31 | 1,170 | 1,160 | import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
log2,
gcd,
)
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def TUPLE():
return tuple(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
# mod = 998244353
from decimal import *
# import numpy as np
# decimal.getcontext().prec = 10
N = INT()
A = [[INT(), i] for i in range(N)]
A.sort(key=lambda x: x[0])
cnt = 0
for i, (x, idx) in enumerate(A):
if i % 2 != idx % 2:
cnt += 1
print((cnt // 2))
| import sys, re
from collections import deque, defaultdict, Counter
from math import (
ceil,
sqrt,
hypot,
factorial,
pi,
sin,
cos,
tan,
asin,
acos,
atan,
radians,
degrees,
log2,
gcd,
)
from itertools import (
accumulate,
permutations,
combinations,
combinations_with_replacement,
product,
groupby,
)
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input():
return sys.stdin.readline().strip()
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST():
return list(map(int, input().split()))
def TUPLE():
return tuple(map(int, input().split()))
def ZIP(n):
return list(zip(*(MAP() for _ in range(n))))
sys.setrecursionlimit(10**9)
INF = float("inf")
mod = 10**9 + 7
# mod = 998244353
from decimal import *
# import numpy as np
# decimal.getcontext().prec = 10
N = INT()
A = [INT() for _ in range(N)]
zipped = {x: i + 1 for i, x in enumerate(sorted(A))}
A = [zipped[x] for x in A]
print((sum(x % 2 == 0 for x in A[::2])))
| false | 11.428571 | [
"-A = [[INT(), i] for i in range(N)]",
"-A.sort(key=lambda x: x[0])",
"-cnt = 0",
"-for i, (x, idx) in enumerate(A):",
"- if i % 2 != idx % 2:",
"- cnt += 1",
"-print((cnt // 2))",
"+A = [INT() for _ in range(N)]",
"+zipped = {x: i + 1 for i, x in enumerate(sorted(A))}",
"+A = [zipped[x] for x in A]",
"+print((sum(x % 2 == 0 for x in A[::2])))"
] | false | 0.039787 | 0.03745 | 1.062397 | [
"s199489240",
"s336692905"
] |
u532966492 | p03574 | python | s922060515 | s792084477 | 24 | 22 | 3,444 | 3,188 | Accepted | Accepted | 8.33 | H,W=map(int,input().split())
S=["."]*(W+2)
S=[["."]*(W+2)] + [list("."+input()+".") for _ in range(H)] + [["."]*(W+2)]
for i in range(1,H+1):
for j in range(1,W+1):
if S[i][j] == "#":
print("#",end="")
else:
print((S[i-1][j-1]+S[i-1][j]+S[i-1][j+1]+S[i][j-1]+S[i][j+1]+S[i+1][j-1]+S[i+1][j]+S[i+1][j+1]).count("#"),end="")
print()
| H,W=map(int,input().split())
#H×Wのマス目入力の周りに"."を付け加える関数
def pixel_input(H,W,border="."):
pixel = [[border]*(W+2)] + \
[[border] + list(input()) + [border] for _ in range(H)] + \
[[border]*(W+2)]
return pixel
#マス目型2次元配列を出力する関数
def pixel_print(pixel):
for i in range(len(pixel)):
print("".join(pixel[i]))
S=pixel_input(H,W)
T=[["?" for _ in range(W)] for _ in range(H)]
for i in range(1,H+1):
for j in range(1,W+1):
if S[i][j]=="#":
T[i-1][j-1]="#"
else:
T[i-1][j-1]=str((S[i-1][j-1]+S[i-1][j]+S[i-1][j+1]+S[i][j-1]+S[i][j+1]+S[i+1][j-1]+S[i+1][j]+S[i+1][j+1]).count("#"))
pixel_print(T)
| 10 | 21 | 387 | 677 | H, W = map(int, input().split())
S = ["."] * (W + 2)
S = (
[["."] * (W + 2)]
+ [list("." + input() + ".") for _ in range(H)]
+ [["."] * (W + 2)]
)
for i in range(1, H + 1):
for j in range(1, W + 1):
if S[i][j] == "#":
print("#", end="")
else:
print(
(
S[i - 1][j - 1]
+ S[i - 1][j]
+ S[i - 1][j + 1]
+ S[i][j - 1]
+ S[i][j + 1]
+ S[i + 1][j - 1]
+ S[i + 1][j]
+ S[i + 1][j + 1]
).count("#"),
end="",
)
print()
| H, W = map(int, input().split())
# H×Wのマス目入力の周りに"."を付け加える関数
def pixel_input(H, W, border="."):
pixel = (
[[border] * (W + 2)]
+ [[border] + list(input()) + [border] for _ in range(H)]
+ [[border] * (W + 2)]
)
return pixel
# マス目型2次元配列を出力する関数
def pixel_print(pixel):
for i in range(len(pixel)):
print("".join(pixel[i]))
S = pixel_input(H, W)
T = [["?" for _ in range(W)] for _ in range(H)]
for i in range(1, H + 1):
for j in range(1, W + 1):
if S[i][j] == "#":
T[i - 1][j - 1] = "#"
else:
T[i - 1][j - 1] = str(
(
S[i - 1][j - 1]
+ S[i - 1][j]
+ S[i - 1][j + 1]
+ S[i][j - 1]
+ S[i][j + 1]
+ S[i + 1][j - 1]
+ S[i + 1][j]
+ S[i + 1][j + 1]
).count("#")
)
pixel_print(T)
| false | 52.380952 | [
"-S = [\".\"] * (W + 2)",
"-S = (",
"- [[\".\"] * (W + 2)]",
"- + [list(\".\" + input() + \".\") for _ in range(H)]",
"- + [[\".\"] * (W + 2)]",
"-)",
"+# H×Wのマス目入力の周りに\".\"を付け加える関数",
"+def pixel_input(H, W, border=\".\"):",
"+ pixel = (",
"+ [[border] * (W + 2)]",
"+ + [[border] + list(input()) + [border] for _ in range(H)]",
"+ + [[border] * (W + 2)]",
"+ )",
"+ return pixel",
"+",
"+",
"+# マス目型2次元配列を出力する関数",
"+def pixel_print(pixel):",
"+ for i in range(len(pixel)):",
"+ print(\"\".join(pixel[i]))",
"+",
"+",
"+S = pixel_input(H, W)",
"+T = [[\"?\" for _ in range(W)] for _ in range(H)]",
"- print(\"#\", end=\"\")",
"+ T[i - 1][j - 1] = \"#\"",
"- print(",
"+ T[i - 1][j - 1] = str(",
"- ).count(\"#\"),",
"- end=\"\",",
"+ ).count(\"#\")",
"- print()",
"+pixel_print(T)"
] | false | 0.031948 | 0.036563 | 0.873773 | [
"s922060515",
"s792084477"
] |
u434630332 | p03795 | python | s552344449 | s873353197 | 27 | 22 | 8,956 | 8,988 | Accepted | Accepted | 18.52 | n = int(eval(input()))
if n >= 15:
x = n * 800
y = ( n // 15 ) * 200
print((x - y))
else:
print((n * 800)) | n = int(eval(input()))
if n >= 15:
print((n * 800 - ( n // 15 ) * 200))
else:
print((n * 800)) | 8 | 6 | 120 | 98 | n = int(eval(input()))
if n >= 15:
x = n * 800
y = (n // 15) * 200
print((x - y))
else:
print((n * 800))
| n = int(eval(input()))
if n >= 15:
print((n * 800 - (n // 15) * 200))
else:
print((n * 800))
| false | 25 | [
"- x = n * 800",
"- y = (n // 15) * 200",
"- print((x - y))",
"+ print((n * 800 - (n // 15) * 200))"
] | false | 0.039161 | 0.038921 | 1.006149 | [
"s552344449",
"s873353197"
] |
u624475441 | p03341 | python | s097266482 | s298542166 | 154 | 120 | 3,700 | 3,700 | Accepted | Accepted | 22.08 | eval(input())
S = eval(input())
res = cnt = S.count('E')
for c in S:
cnt -= c == 'E'
res = min(res, cnt)
cnt += c == 'W'
print(res) | eval(input())
S = eval(input())
res = cnt = S.count('E')
for c in S:
if c == 'E':
cnt -= 1
res = min(res, cnt)
else:
cnt += 1
print(res) | 8 | 10 | 138 | 165 | eval(input())
S = eval(input())
res = cnt = S.count("E")
for c in S:
cnt -= c == "E"
res = min(res, cnt)
cnt += c == "W"
print(res)
| eval(input())
S = eval(input())
res = cnt = S.count("E")
for c in S:
if c == "E":
cnt -= 1
res = min(res, cnt)
else:
cnt += 1
print(res)
| false | 20 | [
"- cnt -= c == \"E\"",
"- res = min(res, cnt)",
"- cnt += c == \"W\"",
"+ if c == \"E\":",
"+ cnt -= 1",
"+ res = min(res, cnt)",
"+ else:",
"+ cnt += 1"
] | false | 0.036136 | 0.034798 | 1.038445 | [
"s097266482",
"s298542166"
] |
u600402037 | p03111 | python | s900253872 | s911034623 | 259 | 231 | 3,064 | 3,064 | Accepted | Accepted | 10.81 | # coding: utf-8
import sys
import itertools
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# N本の竹それぞれA, B, C, 使わないか
N, A, B, C = lr()
bamboo = [ir() for _ in range(N)]
answer = 10 ** 5
for pattern in itertools.product(list(range(4)), repeat=N):
mp = 0
Alist = []; Blist = []; Clist = []
for i, p in enumerate(pattern):
if p == 0:
Alist.append(bamboo[i])
elif p == 1:
Blist.append(bamboo[i])
elif p == 2:
Clist.append(bamboo[i])
if len(Alist) == 0 or len(Blist) == 0 or len(Clist) == 0:
continue
mp += 10 * (len(Alist) + len(Blist) + len(Clist) - 3)
mp += abs(A - sum(Alist)) + abs(B - sum(Blist)) + abs(C - sum(Clist))
if mp < answer:
answer = mp
print(answer)
# 04 | # coding: utf-8
import sys
import itertools
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# Nは最大8まで、Aに使う竹はどれ？
N, A, B, C = lr()
bamboo = [ir() for _ in range(N)]
answer = 10 ** 5
for pattern in itertools.product(list(range(4)), repeat=N):
use = [0] * 3
mp = 0
for p, bam in zip(pattern, bamboo):
if p == 3:
continue
if use[p] != 0:
mp += 10
use[p] += bam
if use.count(0) != 0:
continue
mp += abs(A-use[0]) + abs(B-use[1]) + abs(C-use[2])
if mp < answer:
answer = mp
print(answer)
# 23 | 31 | 29 | 858 | 659 | # coding: utf-8
import sys
import itertools
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# N本の竹それぞれA, B, C, 使わないか
N, A, B, C = lr()
bamboo = [ir() for _ in range(N)]
answer = 10**5
for pattern in itertools.product(list(range(4)), repeat=N):
mp = 0
Alist = []
Blist = []
Clist = []
for i, p in enumerate(pattern):
if p == 0:
Alist.append(bamboo[i])
elif p == 1:
Blist.append(bamboo[i])
elif p == 2:
Clist.append(bamboo[i])
if len(Alist) == 0 or len(Blist) == 0 or len(Clist) == 0:
continue
mp += 10 * (len(Alist) + len(Blist) + len(Clist) - 3)
mp += abs(A - sum(Alist)) + abs(B - sum(Blist)) + abs(C - sum(Clist))
if mp < answer:
answer = mp
print(answer)
# 04
| # coding: utf-8
import sys
import itertools
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
# Nは最大8まで、Aに使う竹はどれ？
N, A, B, C = lr()
bamboo = [ir() for _ in range(N)]
answer = 10**5
for pattern in itertools.product(list(range(4)), repeat=N):
use = [0] * 3
mp = 0
for p, bam in zip(pattern, bamboo):
if p == 3:
continue
if use[p] != 0:
mp += 10
use[p] += bam
if use.count(0) != 0:
continue
mp += abs(A - use[0]) + abs(B - use[1]) + abs(C - use[2])
if mp < answer:
answer = mp
print(answer)
# 23
| false | 6.451613 | [
"-# N本の竹それぞれA, B, C, 使わないか",
"+# Nは最大8まで、Aに使う竹はどれ？",
"+ use = [0] * 3",
"- Alist = []",
"- Blist = []",
"- Clist = []",
"- for i, p in enumerate(pattern):",
"- if p == 0:",
"- Alist.append(bamboo[i])",
"- elif p == 1:",
"- Blist.append(bamboo[i])",
"- elif p == 2:",
"- Clist.append(bamboo[i])",
"- if len(Alist) == 0 or len(Blist) == 0 or len(Clist) == 0:",
"+ for p, bam in zip(pattern, bamboo):",
"+ if p == 3:",
"+ continue",
"+ if use[p] != 0:",
"+ mp += 10",
"+ use[p] += bam",
"+ if use.count(0) != 0:",
"- mp += 10 * (len(Alist) + len(Blist) + len(Clist) - 3)",
"- mp += abs(A - sum(Alist)) + abs(B - sum(Blist)) + abs(C - sum(Clist))",
"+ mp += abs(A - use[0]) + abs(B - use[1]) + abs(C - use[2])",
"-# 04",
"+# 23"
] | false | 0.230147 | 0.24139 | 0.953424 | [
"s900253872",
"s911034623"
] |
u934442292 | p02973 | python | s896228209 | s405567166 | 1,686 | 96 | 13,580 | 16,908 | Accepted | Accepted | 94.31 | import sys
from bisect import bisect_left
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = int(eval(input()))
colors = []
for a in A:
idx = bisect_left(colors, a)
if idx == 0:
colors.insert(0, a)
else:
colors[idx - 1] = a
ans = len(colors)
print(ans)
if __name__ == "__main__":
main()
| import sys
from bisect import bisect_right
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = int(eval(input()))
A = [-a for a in A]
colors = []
for a in A:
idx = bisect_right(colors, a)
if idx == len(colors):
colors.append(a)
else:
colors[idx] = a
ans = len(colors)
print(ans)
if __name__ == "__main__":
main()
| 26 | 28 | 444 | 476 | import sys
from bisect import bisect_left
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = int(eval(input()))
colors = []
for a in A:
idx = bisect_left(colors, a)
if idx == 0:
colors.insert(0, a)
else:
colors[idx - 1] = a
ans = len(colors)
print(ans)
if __name__ == "__main__":
main()
| import sys
from bisect import bisect_right
input = sys.stdin.readline
def main():
N = int(eval(input()))
A = [0] * N
for i in range(N):
A[i] = int(eval(input()))
A = [-a for a in A]
colors = []
for a in A:
idx = bisect_right(colors, a)
if idx == len(colors):
colors.append(a)
else:
colors[idx] = a
ans = len(colors)
print(ans)
if __name__ == "__main__":
main()
| false | 7.142857 | [
"-from bisect import bisect_left",
"+from bisect import bisect_right",
"+ A = [-a for a in A]",
"- idx = bisect_left(colors, a)",
"- if idx == 0:",
"- colors.insert(0, a)",
"+ idx = bisect_right(colors, a)",
"+ if idx == len(colors):",
"+ colors.append(a)",
"- colors[idx - 1] = a",
"+ colors[idx] = a"
] | false | 0.076497 | 0.042082 | 1.817805 | [
"s896228209",
"s405567166"
] |
u644778646 | p02836 | python | s654676339 | s610325327 | 23 | 17 | 2,940 | 2,940 | Accepted | Accepted | 26.09 | s = eval(input())
ans = 0
for i in range(len(s)//2 + len(s)%2):
if s[i] != s[-i - 1]:
ans += 1
print(ans) | s = eval(input())
ans = 0
for i in range(len(s)//2):
if s[i] != s[-i - 1]:
ans += 1
print(ans) | 6 | 6 | 116 | 105 | s = eval(input())
ans = 0
for i in range(len(s) // 2 + len(s) % 2):
if s[i] != s[-i - 1]:
ans += 1
print(ans)
| s = eval(input())
ans = 0
for i in range(len(s) // 2):
if s[i] != s[-i - 1]:
ans += 1
print(ans)
| false | 0 | [
"-for i in range(len(s) // 2 + len(s) % 2):",
"+for i in range(len(s) // 2):"
] | false | 0.042051 | 0.0458 | 0.918138 | [
"s654676339",
"s610325327"
] |
u371763408 | p03221 | python | s456758214 | s048764725 | 802 | 738 | 32,832 | 43,160 | Accepted | Accepted | 7.98 | import bisect
n,m = map(int,input().split())
years = [[]for i in range(n)]
yearss = []
for i in range(m):
p,y = map(int,input().split())
years[p-1].append(y)
yearss.append([p,y])
for i in range(n):
years[i].sort()
for i in range(m):
print("{0:06d}".format(yearss[i][0]),"{0:06d}".format(bisect.bisect_right(years[yearss[i][0]-1],yearss[i][1])),sep="")
| from bisect import bisect_left
n,m=list(map(int,input().split()))
ls=[[] for i in range(n)]
py=[]
for i in range(m):
p,y=list(map(int,input().split()))
ls[p-1].append(y)
py.append([p,y])
ls=list([sorted(x) for x in ls])
for i in range(m):
p,y=py[i]
index= bisect_left(ls[p-1],y)
print((str(p).zfill(6)+str(index+1).zfill(6)))
| 17 | 13 | 383 | 339 | import bisect
n, m = map(int, input().split())
years = [[] for i in range(n)]
yearss = []
for i in range(m):
p, y = map(int, input().split())
years[p - 1].append(y)
yearss.append([p, y])
for i in range(n):
years[i].sort()
for i in range(m):
print(
"{0:06d}".format(yearss[i][0]),
"{0:06d}".format(bisect.bisect_right(years[yearss[i][0] - 1], yearss[i][1])),
sep="",
)
| from bisect import bisect_left
n, m = list(map(int, input().split()))
ls = [[] for i in range(n)]
py = []
for i in range(m):
p, y = list(map(int, input().split()))
ls[p - 1].append(y)
py.append([p, y])
ls = list([sorted(x) for x in ls])
for i in range(m):
p, y = py[i]
index = bisect_left(ls[p - 1], y)
print((str(p).zfill(6) + str(index + 1).zfill(6)))
| false | 23.529412 | [
"-import bisect",
"+from bisect import bisect_left",
"-n, m = map(int, input().split())",
"-years = [[] for i in range(n)]",
"-yearss = []",
"+n, m = list(map(int, input().split()))",
"+ls = [[] for i in range(n)]",
"+py = []",
"- p, y = map(int, input().split())",
"- years[p - 1].append(y)",
"- yearss.append([p, y])",
"-for i in range(n):",
"- years[i].sort()",
"+ p, y = list(map(int, input().split()))",
"+ ls[p - 1].append(y)",
"+ py.append([p, y])",
"+ls = list([sorted(x) for x in ls])",
"- print(",
"- \"{0:06d}\".format(yearss[i][0]),",
"- \"{0:06d}\".format(bisect.bisect_right(years[yearss[i][0] - 1], yearss[i][1])),",
"- sep=\"\",",
"- )",
"+ p, y = py[i]",
"+ index = bisect_left(ls[p - 1], y)",
"+ print((str(p).zfill(6) + str(index + 1).zfill(6)))"
] | false | 0.045918 | 0.044326 | 1.035908 | [
"s456758214",
"s048764725"
] |
u278855471 | p02773 | python | s673389499 | s729452349 | 540 | 404 | 49,380 | 38,720 | Accepted | Accepted | 25.19 | from collections import defaultdict
N = int(input())
s_counter = defaultdict(int)
for _ in range(N):
S = input()
s_counter[S] += 1
S_list = sorted(s_counter.items(), key=lambda x: x[1], reverse=True)
answer = []
for i in range(len(S_list)):
if S_list[0][1] != S_list[i][1]:
break
answer.append(S_list[i][0])
answer.sort()
[print(a) for a in answer]
| from collections import Counter
N = int(input())
counter = Counter([input() for _ in range(N)])
max_cnt = max(counter.values())
names = [name for name, cnt in counter.items() if cnt == max_cnt]
names.sort()
print(*names, sep='\n')
| 15 | 9 | 388 | 241 | from collections import defaultdict
N = int(input())
s_counter = defaultdict(int)
for _ in range(N):
S = input()
s_counter[S] += 1
S_list = sorted(s_counter.items(), key=lambda x: x[1], reverse=True)
answer = []
for i in range(len(S_list)):
if S_list[0][1] != S_list[i][1]:
break
answer.append(S_list[i][0])
answer.sort()
[print(a) for a in answer]
| from collections import Counter
N = int(input())
counter = Counter([input() for _ in range(N)])
max_cnt = max(counter.values())
names = [name for name, cnt in counter.items() if cnt == max_cnt]
names.sort()
print(*names, sep="\n")
| false | 40 | [
"-from collections import defaultdict",
"+from collections import Counter",
"-s_counter = defaultdict(int)",
"-for _ in range(N):",
"- S = input()",
"- s_counter[S] += 1",
"-S_list = sorted(s_counter.items(), key=lambda x: x[1], reverse=True)",
"-answer = []",
"-for i in range(len(S_list)):",
"- if S_list[0][1] != S_list[i][1]:",
"- break",
"- answer.append(S_list[i][0])",
"-answer.sort()",
"-[print(a) for a in answer]",
"+counter = Counter([input() for _ in range(N)])",
"+max_cnt = max(counter.values())",
"+names = [name for name, cnt in counter.items() if cnt == max_cnt]",
"+names.sort()",
"+print(*names, sep=\"\\n\")"
] | false | 0.042099 | 0.042792 | 0.983795 | [
"s673389499",
"s729452349"
] |
u729133443 | p03338 | python | s263061531 | s338571133 | 164 | 17 | 38,384 | 2,940 | Accepted | Accepted | 89.63 | eval(input());a=eval(input());print((max(len(set(a[:s])&set(a[s:]))for s in range(99)))) | _,a=open(0);print((max(len(set(a[:s])&set(a[s:]))for s in range(99)))) | 1 | 1 | 74 | 68 | eval(input())
a = eval(input())
print((max(len(set(a[:s]) & set(a[s:])) for s in range(99))))
| _, a = open(0)
print((max(len(set(a[:s]) & set(a[s:])) for s in range(99))))
| false | 0 | [
"-eval(input())",
"-a = eval(input())",
"+_, a = open(0)"
] | false | 0.103946 | 0.040955 | 2.538036 | [
"s263061531",
"s338571133"
] |
u774539708 | p02813 | python | s239238539 | s750972270 | 28 | 17 | 8,052 | 3,064 | Accepted | Accepted | 39.29 | import itertools as it
s=list(range(1,int(eval(input()))+1))
A=list(it.permutations(s))
P,Q=[tuple(map(int,input().split())) for i in range(2)]
print((abs(A.index(P)-A.index(Q)))) | import math
n=int(eval(input()))
A,B=[list(range(1,n+1)) for i in range(2)]
P,Q=[list(map(int,input().split())) for i in range(2)]
p=0
for i in range(n-1):
p+=(A.index(P[i]))*math.factorial(n-i-1)
A.remove(P[i])
q=0
for i in range(n-1):
q+=(B.index(Q[i]))*math.factorial(n-i-1)
B.remove(Q[i])
print((abs(p-q))) | 5 | 13 | 175 | 330 | import itertools as it
s = list(range(1, int(eval(input())) + 1))
A = list(it.permutations(s))
P, Q = [tuple(map(int, input().split())) for i in range(2)]
print((abs(A.index(P) - A.index(Q))))
| import math
n = int(eval(input()))
A, B = [list(range(1, n + 1)) for i in range(2)]
P, Q = [list(map(int, input().split())) for i in range(2)]
p = 0
for i in range(n - 1):
p += (A.index(P[i])) * math.factorial(n - i - 1)
A.remove(P[i])
q = 0
for i in range(n - 1):
q += (B.index(Q[i])) * math.factorial(n - i - 1)
B.remove(Q[i])
print((abs(p - q)))
| false | 61.538462 | [
"-import itertools as it",
"+import math",
"-s = list(range(1, int(eval(input())) + 1))",
"-A = list(it.permutations(s))",
"-P, Q = [tuple(map(int, input().split())) for i in range(2)]",
"-print((abs(A.index(P) - A.index(Q))))",
"+n = int(eval(input()))",
"+A, B = [list(range(1, n + 1)) for i in range(2)]",
"+P, Q = [list(map(int, input().split())) for i in range(2)]",
"+p = 0",
"+for i in range(n - 1):",
"+ p += (A.index(P[i])) * math.factorial(n - i - 1)",
"+ A.remove(P[i])",
"+q = 0",
"+for i in range(n - 1):",
"+ q += (B.index(Q[i])) * math.factorial(n - i - 1)",
"+ B.remove(Q[i])",
"+print((abs(p - q)))"
] | false | 0.203642 | 0.04506 | 4.519388 | [
"s239238539",
"s750972270"
] |
u241159583 | p02785 | python | s828368423 | s609445520 | 191 | 124 | 25,768 | 31,504 | Accepted | Accepted | 35.08 | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
for i in range(K):
if len(H) <= 0:
break
H.pop(-1)
print((sum(H) if len(H) > 0 else 0)) | n,k = list(map(int, input().split()))
H = sorted(list(map(int, input().split())))[::-1]
ans = 0
for h in H:
if k>0:
k -= 1
continue
ans += h
print(ans) | 8 | 9 | 178 | 177 | N, K = list(map(int, input().split()))
H = list(map(int, input().split()))
H.sort()
for i in range(K):
if len(H) <= 0:
break
H.pop(-1)
print((sum(H) if len(H) > 0 else 0))
| n, k = list(map(int, input().split()))
H = sorted(list(map(int, input().split())))[::-1]
ans = 0
for h in H:
if k > 0:
k -= 1
continue
ans += h
print(ans)
| false | 11.111111 | [
"-N, K = list(map(int, input().split()))",
"-H = list(map(int, input().split()))",
"-H.sort()",
"-for i in range(K):",
"- if len(H) <= 0:",
"- break",
"- H.pop(-1)",
"-print((sum(H) if len(H) > 0 else 0))",
"+n, k = list(map(int, input().split()))",
"+H = sorted(list(map(int, input().split())))[::-1]",
"+ans = 0",
"+for h in H:",
"+ if k > 0:",
"+ k -= 1",
"+ continue",
"+ ans += h",
"+print(ans)"
] | false | 0.057784 | 0.057742 | 1.000735 | [
"s828368423",
"s609445520"
] |
u374765578 | p02959 | python | s402934341 | s255930384 | 162 | 126 | 19,156 | 18,476 | Accepted | Accepted | 22.22 | n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = 0
for i in range(n):
if a[i] >= b[i]:
d += b[i]
else:
d += a[i]
b[i] = b[i] - a[i]
if a[i+1] - b[i] >= 0:
d += b[i]
a[i+1] = a[i+1] - b[i]
else:
d += a[i+1]
a[i+1] = 0
print(d) |
def main():
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = 0
for i in range(n):
if a[i] >= b[i]:
d += b[i]
else:
d += a[i]
b[i] = b[i] - a[i]
if a[i+1] - b[i] >= 0:
d += b[i]
a[i+1] = a[i+1] - b[i]
else:
d += a[i+1]
a[i+1] = 0
print(d)
if __name__ == '__main__':
main() | 24 | 31 | 369 | 442 | n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = 0
for i in range(n):
if a[i] >= b[i]:
d += b[i]
else:
d += a[i]
b[i] = b[i] - a[i]
if a[i + 1] - b[i] >= 0:
d += b[i]
a[i + 1] = a[i + 1] - b[i]
else:
d += a[i + 1]
a[i + 1] = 0
print(d)
| def main():
n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
d = 0
for i in range(n):
if a[i] >= b[i]:
d += b[i]
else:
d += a[i]
b[i] = b[i] - a[i]
if a[i + 1] - b[i] >= 0:
d += b[i]
a[i + 1] = a[i + 1] - b[i]
else:
d += a[i + 1]
a[i + 1] = 0
print(d)
if __name__ == "__main__":
main()
| false | 22.580645 | [
"-n = int(eval(input()))",
"-a = list(map(int, input().split()))",
"-b = list(map(int, input().split()))",
"-d = 0",
"-for i in range(n):",
"- if a[i] >= b[i]:",
"- d += b[i]",
"- else:",
"- d += a[i]",
"- b[i] = b[i] - a[i]",
"- if a[i + 1] - b[i] >= 0:",
"+def main():",
"+ n = int(eval(input()))",
"+ a = list(map(int, input().split()))",
"+ b = list(map(int, input().split()))",
"+ d = 0",
"+ for i in range(n):",
"+ if a[i] >= b[i]:",
"- a[i + 1] = a[i + 1] - b[i]",
"- d += a[i + 1]",
"- a[i + 1] = 0",
"-print(d)",
"+ d += a[i]",
"+ b[i] = b[i] - a[i]",
"+ if a[i + 1] - b[i] >= 0:",
"+ d += b[i]",
"+ a[i + 1] = a[i + 1] - b[i]",
"+ else:",
"+ d += a[i + 1]",
"+ a[i + 1] = 0",
"+ print(d)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.111474 | 0.053469 | 2.084816 | [
"s402934341",
"s255930384"
] |
u670180528 | p03354 | python | s863940086 | s076172327 | 473 | 418 | 35,324 | 35,324 | Accepted | Accepted | 11.63 | class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def isSame(self, x, y):
return self.find(x) == self.find(y)
n,m,*l=list(map(int,open(0).read().split()))
p=l[:n];xy=l[n:]
ids=[0]*(n+1)
for i in range(n):
ids[p[i]]=i+1
uf=UnionFind(n)
for x,y in zip(*[iter(xy)]*2):
uf.unite(x,y)
print((sum(uf.isSame(i,ids[i])or i==ids[i] for i in range(1,n+1)))) | class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1]*(n+1)
self.rank = [0]*(n+1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def isSame(self, x, y):
return self.find(x) == self.find(y) or x==y
def solve():
n,m,*l=list(map(int,open(0).read().split()))
p=l[:n];xy=l[n:]
ids=[0]*(n+1)
for i in range(n):ids[p[i]]=i+1
uf=UnionFind(n)
for x,y in zip(*[iter(xy)]*2):uf.unite(x,y)
print((sum(uf.isSame(i,ids[i])for i in range(1,n+1))))
if __name__=="__main__":solve() | 39 | 40 | 867 | 913 | class UnionFind:
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
self.rank = [0] * (n + 1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def isSame(self, x, y):
return self.find(x) == self.find(y)
n, m, *l = list(map(int, open(0).read().split()))
p = l[:n]
xy = l[n:]
ids = [0] * (n + 1)
for i in range(n):
ids[p[i]] = i + 1
uf = UnionFind(n)
for x, y in zip(*[iter(xy)] * 2):
uf.unite(x, y)
print((sum(uf.isSame(i, ids[i]) or i == ids[i] for i in range(1, n + 1))))
| class UnionFind:
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
self.rank = [0] * (n + 1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return 0
elif self.rank[x] > self.rank[y]:
self.root[x] += self.root[y]
self.root[y] = x
else:
self.root[y] += self.root[x]
self.root[x] = y
if self.rank[x] == self.rank[y]:
self.rank[y] += 1
def isSame(self, x, y):
return self.find(x) == self.find(y) or x == y
def solve():
n, m, *l = list(map(int, open(0).read().split()))
p = l[:n]
xy = l[n:]
ids = [0] * (n + 1)
for i in range(n):
ids[p[i]] = i + 1
uf = UnionFind(n)
for x, y in zip(*[iter(xy)] * 2):
uf.unite(x, y)
print((sum(uf.isSame(i, ids[i]) for i in range(1, n + 1))))
if __name__ == "__main__":
solve()
| false | 2.5 | [
"- return self.find(x) == self.find(y)",
"+ return self.find(x) == self.find(y) or x == y",
"-n, m, *l = list(map(int, open(0).read().split()))",
"-p = l[:n]",
"-xy = l[n:]",
"-ids = [0] * (n + 1)",
"-for i in range(n):",
"- ids[p[i]] = i + 1",
"-uf = UnionFind(n)",
"-for x, y in zip(*[iter(xy)] * 2):",
"- uf.unite(x, y)",
"-print((sum(uf.isSame(i, ids[i]) or i == ids[i] for i in range(1, n + 1))))",
"+def solve():",
"+ n, m, *l = list(map(int, open(0).read().split()))",
"+ p = l[:n]",
"+ xy = l[n:]",
"+ ids = [0] * (n + 1)",
"+ for i in range(n):",
"+ ids[p[i]] = i + 1",
"+ uf = UnionFind(n)",
"+ for x, y in zip(*[iter(xy)] * 2):",
"+ uf.unite(x, y)",
"+ print((sum(uf.isSame(i, ids[i]) for i in range(1, n + 1))))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ solve()"
] | false | 0.041419 | 0.046326 | 0.894085 | [
"s863940086",
"s076172327"
] |
u672220554 | p02915 | python | s327064916 | s535540842 | 168 | 19 | 38,256 | 3,060 | Accepted | Accepted | 88.69 | n = int(eval(input()))
print((n*n*n)) | n = int(eval(input()))
print((n**3)) | 2 | 2 | 30 | 29 | n = int(eval(input()))
print((n * n * n))
| n = int(eval(input()))
print((n**3))
| false | 0 | [
"-print((n * n * n))",
"+print((n**3))"
] | false | 0.046795 | 0.007593 | 6.163075 | [
"s327064916",
"s535540842"
] |
u798181098 | p03288 | python | s796535607 | s277761748 | 17 | 10 | 2,940 | 2,568 | Accepted | Accepted | 41.18 | print(('A'+'BRG'[int(eval(input()))//100+4>>4]+'C')) | print('A%sC'%'BRG'[eval(input())/100+4>>4]) | 1 | 1 | 44 | 35 | print(("A" + "BRG"[int(eval(input())) // 100 + 4 >> 4] + "C"))
| print("A%sC" % "BRG"[eval(input()) / 100 + 4 >> 4])
| false | 0 | [
"-print((\"A\" + \"BRG\"[int(eval(input())) // 100 + 4 >> 4] + \"C\"))",
"+print(\"A%sC\" % \"BRG\"[eval(input()) / 100 + 4 >> 4])"
] | false | 0.035958 | 0.068385 | 0.52582 | [
"s796535607",
"s277761748"
] |
u497952650 | p03721 | python | s695288646 | s841258472 | 517 | 206 | 27,872 | 11,720 | Accepted | Accepted | 60.15 | N,K = list(map(int,input().split()))
ans = 0
m = 0
ab = []
for i in range(N):
ab.append(list(map(int,input().split())))
ab.sort()
tmp = 0
for a,b in ab:
tmp += b
if tmp >= K:
print(a)
break | N,K = list(map(int,input().split()))
n = [0]*(int(1e5)+1)
for i in range(N):
a,b = list(map(int,input().split()))
n[a] += b
for i in range(int(1e5)+1):
K -= n[i]
if K <= 0:
print(i)
break | 16 | 12 | 229 | 220 | N, K = list(map(int, input().split()))
ans = 0
m = 0
ab = []
for i in range(N):
ab.append(list(map(int, input().split())))
ab.sort()
tmp = 0
for a, b in ab:
tmp += b
if tmp >= K:
print(a)
break
| N, K = list(map(int, input().split()))
n = [0] * (int(1e5) + 1)
for i in range(N):
a, b = list(map(int, input().split()))
n[a] += b
for i in range(int(1e5) + 1):
K -= n[i]
if K <= 0:
print(i)
break
| false | 25 | [
"-ans = 0",
"-m = 0",
"-ab = []",
"+n = [0] * (int(1e5) + 1)",
"- ab.append(list(map(int, input().split())))",
"-ab.sort()",
"-tmp = 0",
"-for a, b in ab:",
"- tmp += b",
"- if tmp >= K:",
"- print(a)",
"+ a, b = list(map(int, input().split()))",
"+ n[a] += b",
"+for i in range(int(1e5) + 1):",
"+ K -= n[i]",
"+ if K <= 0:",
"+ print(i)"
] | false | 0.039035 | 0.044271 | 0.881716 | [
"s695288646",
"s841258472"
] |
u588341295 | p02798 | python | s005633831 | s555365864 | 1,884 | 1,257 | 104,496 | 104,368 | Accepted | Accepted | 33.28 | # -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def pop_count(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
i = (i + (i >> 4)) & 0x0f0f0f0f
i = i + (i >> 8)
i = i + (i >> 16)
return i & 0x3f
N = INT()
cards = [[]] * 2
cards[0] = LIST()
cards[1] = LIST()
# dp[S][i] := 既に使用したカードの集合がSで、最後に使った(現在の右端の)カードがiの時の最小合計転倒数
dp = list2d(1<<N, N, INF)
for i in range(N):
# 一番左は何が来ても転倒数0
dp[1<<i][i] = 0
for S in range(1, 1<<N):
popcnt = pop_count(S)
# 各位置より元indexが右側にある出現済要素の個数(転倒数)を前計算しておく
acc = [0] * N
for i in range(N):
if S & 1<<i:
acc[i] = 1
# 後ろから累積和
acc = list(accumulate(acc[::-1]))[::-1]
for i in range(N):
if dp[S][i] == INF or not S & 1<<i:
continue
# 遷移元の右端カードの表裏を確定
cur = cards[(i%2)^(1-popcnt%2)][i]
for j in range(N):
if S & 1<<j:
continue
# 遷移先の右端カードの表裏を確定
nxt = cards[(j%2)^(popcnt%2)][j]
# 昇順が崩れないなら遷移させてOK
if cur <= nxt:
# 転倒数を追加して遷移
dp[S|1<<j][j] = min(dp[S|1<<j][j], dp[S][i] + acc[j])
ans = INF
for i in range(N):
ans = min(ans, dp[(1<<N)-1][i])
if ans == INF:
print((-1))
else:
print(ans)
| # -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def pop_count(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
i = (i + (i >> 4)) & 0x0f0f0f0f
i = i + (i >> 8)
i = i + (i >> 16)
return i & 0x3f
N = INT()
cards = [[]] * 2
cards[0] = LIST()
cards[1] = LIST()
# dp[S][i] := 既に使用したカードの集合がSで、最後に使った(現在の右端の)カードがiの時の最小合計転倒数
dp = list2d(1<<N, N, INF)
for i in range(N):
# 一番左は何が来ても転倒数0
dp[1<<i][i] = 0
for S in range(1, 1<<N):
popcnt = pop_count(S)
# 各位置より元indexが右側にある出現済要素の個数(転倒数)を前計算しておく
acc = [0] * N
for i in range(N):
if S & 1<<i:
acc[i] = 1
# 後ろから累積和
acc = list(accumulate(acc[::-1]))[::-1]
for i in range(N):
if dp[S][i] == INF or not S & 1<<i:
continue
# 遷移元の右端カードの表裏を確定
cur = cards[(i&1)^(1-(popcnt&1))][i]
for j in range(N):
if S & 1<<j:
continue
# 遷移先の右端カードの表裏を確定
nxt = cards[(j&1)^(popcnt&1)][j]
# 昇順が崩れないなら遷移させてOK
if cur <= nxt:
# 転倒数を追加して遷移
dp[S|1<<j][j] = min(dp[S|1<<j][j], dp[S][i] + acc[j])
ans = INF
for i in range(N):
ans = min(ans, dp[(1<<N)-1][i])
if ans == INF:
print((-1))
else:
print(ans)
| 69 | 69 | 2,012 | 2,014 | # -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
def pop_count(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
i = (i + (i >> 4)) & 0x0F0F0F0F
i = i + (i >> 8)
i = i + (i >> 16)
return i & 0x3F
N = INT()
cards = [[]] * 2
cards[0] = LIST()
cards[1] = LIST()
# dp[S][i] := 既に使用したカードの集合がSで、最後に使った(現在の右端の)カードがiの時の最小合計転倒数
dp = list2d(1 << N, N, INF)
for i in range(N):
# 一番左は何が来ても転倒数0
dp[1 << i][i] = 0
for S in range(1, 1 << N):
popcnt = pop_count(S)
# 各位置より元indexが右側にある出現済要素の個数(転倒数)を前計算しておく
acc = [0] * N
for i in range(N):
if S & 1 << i:
acc[i] = 1
# 後ろから累積和
acc = list(accumulate(acc[::-1]))[::-1]
for i in range(N):
if dp[S][i] == INF or not S & 1 << i:
continue
# 遷移元の右端カードの表裏を確定
cur = cards[(i % 2) ^ (1 - popcnt % 2)][i]
for j in range(N):
if S & 1 << j:
continue
# 遷移先の右端カードの表裏を確定
nxt = cards[(j % 2) ^ (popcnt % 2)][j]
# 昇順が崩れないなら遷移させてOK
if cur <= nxt:
# 転倒数を追加して遷移
dp[S | 1 << j][j] = min(dp[S | 1 << j][j], dp[S][i] + acc[j])
ans = INF
for i in range(N):
ans = min(ans, dp[(1 << N) - 1][i])
if ans == INF:
print((-1))
else:
print(ans)
| # -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
def pop_count(i):
i = i - ((i >> 1) & 0x55555555)
i = (i & 0x33333333) + ((i >> 2) & 0x33333333)
i = (i + (i >> 4)) & 0x0F0F0F0F
i = i + (i >> 8)
i = i + (i >> 16)
return i & 0x3F
N = INT()
cards = [[]] * 2
cards[0] = LIST()
cards[1] = LIST()
# dp[S][i] := 既に使用したカードの集合がSで、最後に使った(現在の右端の)カードがiの時の最小合計転倒数
dp = list2d(1 << N, N, INF)
for i in range(N):
# 一番左は何が来ても転倒数0
dp[1 << i][i] = 0
for S in range(1, 1 << N):
popcnt = pop_count(S)
# 各位置より元indexが右側にある出現済要素の個数(転倒数)を前計算しておく
acc = [0] * N
for i in range(N):
if S & 1 << i:
acc[i] = 1
# 後ろから累積和
acc = list(accumulate(acc[::-1]))[::-1]
for i in range(N):
if dp[S][i] == INF or not S & 1 << i:
continue
# 遷移元の右端カードの表裏を確定
cur = cards[(i & 1) ^ (1 - (popcnt & 1))][i]
for j in range(N):
if S & 1 << j:
continue
# 遷移先の右端カードの表裏を確定
nxt = cards[(j & 1) ^ (popcnt & 1)][j]
# 昇順が崩れないなら遷移させてOK
if cur <= nxt:
# 転倒数を追加して遷移
dp[S | 1 << j][j] = min(dp[S | 1 << j][j], dp[S][i] + acc[j])
ans = INF
for i in range(N):
ans = min(ans, dp[(1 << N) - 1][i])
if ans == INF:
print((-1))
else:
print(ans)
| false | 0 | [
"- cur = cards[(i % 2) ^ (1 - popcnt % 2)][i]",
"+ cur = cards[(i & 1) ^ (1 - (popcnt & 1))][i]",
"- nxt = cards[(j % 2) ^ (popcnt % 2)][j]",
"+ nxt = cards[(j & 1) ^ (popcnt & 1)][j]"
] | false | 0.050706 | 0.042191 | 1.201821 | [
"s005633831",
"s555365864"
] |
u096616343 | p03045 | python | s224681989 | s921014401 | 730 | 493 | 104,692 | 23,648 | Accepted | Accepted | 32.47 | import sys
sys.setrecursionlimit(10 ** 7)
def dfs(s):
if visited[s]:
return
visited[s] = 1
for to in t[s]:
if visited[to]:
continue
dfs(to)
N, M = list(map(int,input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int,input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(0, N):
if visited[i]:
continue
ans += 1
dfs(i)
print(ans) | N, M = list(map(int,input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int,input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(N):
if visited[i]:
continue
ans += 1
stack = [i]
while stack:
s = stack.pop()
for to in t[s]:
if visited[to]:
continue
visited[to] = 1
stack.append(to)
print(ans) | 28 | 23 | 516 | 494 | import sys
sys.setrecursionlimit(10**7)
def dfs(s):
if visited[s]:
return
visited[s] = 1
for to in t[s]:
if visited[to]:
continue
dfs(to)
N, M = list(map(int, input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(0, N):
if visited[i]:
continue
ans += 1
dfs(i)
print(ans)
| N, M = list(map(int, input().split()))
t = [[] for _ in range(N)]
visited = [0] * N
for _ in range(M):
X, Y, Z = list(map(int, input().split()))
X -= 1
Y -= 1
t[X].append(Y)
t[Y].append(X)
ans = 0
for i in range(N):
if visited[i]:
continue
ans += 1
stack = [i]
while stack:
s = stack.pop()
for to in t[s]:
if visited[to]:
continue
visited[to] = 1
stack.append(to)
print(ans)
| false | 17.857143 | [
"-import sys",
"-",
"-sys.setrecursionlimit(10**7)",
"-",
"-",
"-def dfs(s):",
"- if visited[s]:",
"- return",
"- visited[s] = 1",
"- for to in t[s]:",
"- if visited[to]:",
"- continue",
"- dfs(to)",
"-",
"-",
"-for i in range(0, N):",
"+for i in range(N):",
"- dfs(i)",
"+ stack = [i]",
"+ while stack:",
"+ s = stack.pop()",
"+ for to in t[s]:",
"+ if visited[to]:",
"+ continue",
"+ visited[to] = 1",
"+ stack.append(to)"
] | false | 0.046878 | 0.046656 | 1.004752 | [
"s224681989",
"s921014401"
] |
u189023301 | p03164 | python | s567416777 | s408016246 | 277 | 230 | 42,076 | 40,560 | Accepted | Accepted | 16.97 | n, m = list(map(int, input().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
| import sys
readline = sys.stdin.buffer.readline
def main():
n, m = list(map(int, readline().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
if __name__ == "__main__":
main() | 15 | 22 | 359 | 524 | n, m = list(map(int, input().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
| import sys
readline = sys.stdin.buffer.readline
def main():
n, m = list(map(int, readline().split()))
inf = 10**11
dp = [inf] * (1000 * n + 1)
dp[0] = 0
for i in range(n):
w, v = list(map(int, input().split()))
for j in range(1000 * n - v, -1, -1):
if dp[j] != inf:
dp[j + v] = min(dp[j + v], dp[j] + w)
ans = 0
for a, b in enumerate(dp):
if b <= m:
ans = max(ans, a)
print(ans)
if __name__ == "__main__":
main()
| false | 31.818182 | [
"-n, m = list(map(int, input().split()))",
"-inf = 10**11",
"-dp = [inf] * (1000 * n + 1)",
"-dp[0] = 0",
"-for i in range(n):",
"- w, v = list(map(int, input().split()))",
"- for j in range(1000 * n - v, -1, -1):",
"- if dp[j] != inf:",
"- dp[j + v] = min(dp[j + v], dp[j] + w)",
"-ans = 0",
"-for a, b in enumerate(dp):",
"- if b <= m:",
"- ans = max(ans, a)",
"-print(ans)",
"+import sys",
"+",
"+readline = sys.stdin.buffer.readline",
"+",
"+",
"+def main():",
"+ n, m = list(map(int, readline().split()))",
"+ inf = 10**11",
"+ dp = [inf] * (1000 * n + 1)",
"+ dp[0] = 0",
"+ for i in range(n):",
"+ w, v = list(map(int, input().split()))",
"+ for j in range(1000 * n - v, -1, -1):",
"+ if dp[j] != inf:",
"+ dp[j + v] = min(dp[j + v], dp[j] + w)",
"+ ans = 0",
"+ for a, b in enumerate(dp):",
"+ if b <= m:",
"+ ans = max(ans, a)",
"+ print(ans)",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 0.007416 | 0.046146 | 0.160709 | [
"s567416777",
"s408016246"
] |
u254871849 | p02843 | python | s397410908 | s033176911 | 1,079 | 43 | 13,252 | 3,828 | Accepted | Accepted | 96.01 | import sys
import numpy as np
def main():
x = int(sys.stdin.readline().rstrip())
if x < 100:
print((0))
sys.exit()
if 100 <= x <= 105:
print((1))
sys.exit()
dp = np.zeros_like(np.arange(x+1), dtype=bool)
dp[100:106] = True
for i in range(106, x+1):
dp[i] = np.any(dp[i-105:i-99])
print((dp[x] & 1))
if __name__ == '__main__':
main() | import sys
def main():
x = int(sys.stdin.readline().rstrip())
payable = [False] * (x + 1)
payable[0] = True
if x < 100:
print((0))
sys.exit()
if 100 <= x <= 105:
print((1))
sys.exit()
for i in range(100,106):
payable[i] = True
for i in range(106, x+1):
payable[i] = any(payable[i-105:i-99])
print((payable[x] & 1))
if __name__ == '__main__':
main() | 21 | 24 | 427 | 456 | import sys
import numpy as np
def main():
x = int(sys.stdin.readline().rstrip())
if x < 100:
print((0))
sys.exit()
if 100 <= x <= 105:
print((1))
sys.exit()
dp = np.zeros_like(np.arange(x + 1), dtype=bool)
dp[100:106] = True
for i in range(106, x + 1):
dp[i] = np.any(dp[i - 105 : i - 99])
print((dp[x] & 1))
if __name__ == "__main__":
main()
| import sys
def main():
x = int(sys.stdin.readline().rstrip())
payable = [False] * (x + 1)
payable[0] = True
if x < 100:
print((0))
sys.exit()
if 100 <= x <= 105:
print((1))
sys.exit()
for i in range(100, 106):
payable[i] = True
for i in range(106, x + 1):
payable[i] = any(payable[i - 105 : i - 99])
print((payable[x] & 1))
if __name__ == "__main__":
main()
| false | 12.5 | [
"-import numpy as np",
"+ payable = [False] * (x + 1)",
"+ payable[0] = True",
"- dp = np.zeros_like(np.arange(x + 1), dtype=bool)",
"- dp[100:106] = True",
"+ for i in range(100, 106):",
"+ payable[i] = True",
"- dp[i] = np.any(dp[i - 105 : i - 99])",
"- print((dp[x] & 1))",
"+ payable[i] = any(payable[i - 105 : i - 99])",
"+ print((payable[x] & 1))"
] | false | 0.525359 | 0.03571 | 14.711686 | [
"s397410908",
"s033176911"
] |
u761529120 | p03220 | python | s824526087 | s587622132 | 245 | 18 | 17,688 | 3,060 | Accepted | Accepted | 92.65 | import numpy as np
def getNearestValue(list, num):
"""
概要: リストからある値に最も近い値を返却する関数
@param list: データ配列
@param num: 対象値
@return 対象値に最も近い値
"""
# リスト要素と対象値の差分を計算し最小値のインデックスを取得
idx = np.abs(np.asarray(list) - num).argmin()
return list[idx]
num = int(eval(input()))
temperature = list(map(int, input().split(" ")))
height = list(map(int, input().split(" ")))
place_temperature = []
for i in range(num):
place_temperature.append(temperature[0] - height[i] * 0.006)
near_temperature = getNearestValue(place_temperature, temperature[1])
print((place_temperature.index(near_temperature) + 1)) | N = int(eval(input()))
T, A = list(map(int, input().split(" ")))
height = list(map(int, input().split(" ")))
place_temperature = 0
diff_A =[]
for i in range(N):
place_temperature= T - height[i] * 0.006
diff_A.append(abs(A - place_temperature))
print((diff_A.index(min(diff_A)) + 1)) | 25 | 11 | 643 | 294 | import numpy as np
def getNearestValue(list, num):
"""
概要: リストからある値に最も近い値を返却する関数
@param list: データ配列
@param num: 対象値
@return 対象値に最も近い値
"""
# リスト要素と対象値の差分を計算し最小値のインデックスを取得
idx = np.abs(np.asarray(list) - num).argmin()
return list[idx]
num = int(eval(input()))
temperature = list(map(int, input().split(" ")))
height = list(map(int, input().split(" ")))
place_temperature = []
for i in range(num):
place_temperature.append(temperature[0] - height[i] * 0.006)
near_temperature = getNearestValue(place_temperature, temperature[1])
print((place_temperature.index(near_temperature) + 1))
| N = int(eval(input()))
T, A = list(map(int, input().split(" ")))
height = list(map(int, input().split(" ")))
place_temperature = 0
diff_A = []
for i in range(N):
place_temperature = T - height[i] * 0.006
diff_A.append(abs(A - place_temperature))
print((diff_A.index(min(diff_A)) + 1))
| false | 56 | [
"-import numpy as np",
"-",
"-",
"-def getNearestValue(list, num):",
"- \"\"\"",
"- 概要: リストからある値に最も近い値を返却する関数",
"- @param list: データ配列",
"- @param num: 対象値",
"- @return 対象値に最も近い値",
"- \"\"\"",
"- # リスト要素と対象値の差分を計算し最小値のインデックスを取得",
"- idx = np.abs(np.asarray(list) - num).argmin()",
"- return list[idx]",
"-",
"-",
"-num = int(eval(input()))",
"-temperature = list(map(int, input().split(\" \")))",
"+N = int(eval(input()))",
"+T, A = list(map(int, input().split(\" \")))",
"-place_temperature = []",
"-for i in range(num):",
"- place_temperature.append(temperature[0] - height[i] * 0.006)",
"-near_temperature = getNearestValue(place_temperature, temperature[1])",
"-print((place_temperature.index(near_temperature) + 1))",
"+place_temperature = 0",
"+diff_A = []",
"+for i in range(N):",
"+ place_temperature = T - height[i] * 0.006",
"+ diff_A.append(abs(A - place_temperature))",
"+print((diff_A.index(min(diff_A)) + 1))"
] | false | 0.394324 | 0.037204 | 10.599083 | [
"s824526087",
"s587622132"
] |
u137693056 | p03435 | python | s832056056 | s916209831 | 52 | 17 | 3,064 | 3,064 | Accepted | Accepted | 67.31 | def calc(a1,c):
As=[a1]
Bs=[]
Bs.append(c[0][0]-As[0])
As.append(c[1][0]-Bs[0])
As.append(c[2][0]-Bs[0])
Bs.append(c[0][1]-As[0])
Bs.append(c[0][2]-As[0])
for a in range(3):
for b in range(3):
if As[a]+Bs[b]!=c[a][b]: return False
return True
c=[]
for i in range(3):
c.append(list(map(int,input().split())))
flag=False
for i in range(-int(1e4),100):
if (calc(i,c)):
print('Yes')
flag=True
break
if not flag: print('No') | def calc(a1,c):
As=[a1]
Bs=[]
Bs.append(c[0][0]-As[0])
As.append(c[1][0]-Bs[0])
As.append(c[2][0]-Bs[0])
Bs.append(c[0][1]-As[0])
Bs.append(c[0][2]-As[0])
for a in range(3):
for b in range(3):
if As[a]+Bs[b]!=c[a][b]: return False
return True
c=[]
for i in range(3):
c.append(list(map(int,input().split())))
flag=False
if (calc(0,c)):
print('Yes')
else: print('No') | 24 | 21 | 533 | 452 | def calc(a1, c):
As = [a1]
Bs = []
Bs.append(c[0][0] - As[0])
As.append(c[1][0] - Bs[0])
As.append(c[2][0] - Bs[0])
Bs.append(c[0][1] - As[0])
Bs.append(c[0][2] - As[0])
for a in range(3):
for b in range(3):
if As[a] + Bs[b] != c[a][b]:
return False
return True
c = []
for i in range(3):
c.append(list(map(int, input().split())))
flag = False
for i in range(-int(1e4), 100):
if calc(i, c):
print("Yes")
flag = True
break
if not flag:
print("No")
| def calc(a1, c):
As = [a1]
Bs = []
Bs.append(c[0][0] - As[0])
As.append(c[1][0] - Bs[0])
As.append(c[2][0] - Bs[0])
Bs.append(c[0][1] - As[0])
Bs.append(c[0][2] - As[0])
for a in range(3):
for b in range(3):
if As[a] + Bs[b] != c[a][b]:
return False
return True
c = []
for i in range(3):
c.append(list(map(int, input().split())))
flag = False
if calc(0, c):
print("Yes")
else:
print("No")
| false | 12.5 | [
"-for i in range(-int(1e4), 100):",
"- if calc(i, c):",
"- print(\"Yes\")",
"- flag = True",
"- break",
"-if not flag:",
"+if calc(0, c):",
"+ print(\"Yes\")",
"+else:"
] | false | 0.00777 | 0.040485 | 0.19192 | [
"s832056056",
"s916209831"
] |
u074220993 | p03425 | python | s975523121 | s378921961 | 140 | 69 | 9,884 | 17,164 | Accepted | Accepted | 50.71 | N = int(eval(input()))
Name = [input()[0] for _ in range(N)]
March = {x:Name.count(x) for x in 'MARCH' if Name.count(x) > 0}
import itertools
ans = 0
for x,y,z in itertools.combinations(list(March.values()), 3):
ans += x*y*z
print(ans) | from collections import Counter
from itertools import combinations, starmap
func = lambda x, y, z: x*y*z
def main():
with open(0) as f:
N, *S = f.read().split()
S = [s[0] for s in S if s[0] in list('MARCH')]
S = Counter(S)
ans = sum(starmap(func, combinations(list(S.values()), 3)))
print(ans)
main() | 9 | 13 | 236 | 336 | N = int(eval(input()))
Name = [input()[0] for _ in range(N)]
March = {x: Name.count(x) for x in "MARCH" if Name.count(x) > 0}
import itertools
ans = 0
for x, y, z in itertools.combinations(list(March.values()), 3):
ans += x * y * z
print(ans)
| from collections import Counter
from itertools import combinations, starmap
func = lambda x, y, z: x * y * z
def main():
with open(0) as f:
N, *S = f.read().split()
S = [s[0] for s in S if s[0] in list("MARCH")]
S = Counter(S)
ans = sum(starmap(func, combinations(list(S.values()), 3)))
print(ans)
main()
| false | 30.769231 | [
"-N = int(eval(input()))",
"-Name = [input()[0] for _ in range(N)]",
"-March = {x: Name.count(x) for x in \"MARCH\" if Name.count(x) > 0}",
"-import itertools",
"+from collections import Counter",
"+from itertools import combinations, starmap",
"-ans = 0",
"-for x, y, z in itertools.combinations(list(March.values()), 3):",
"- ans += x * y * z",
"-print(ans)",
"+func = lambda x, y, z: x * y * z",
"+",
"+",
"+def main():",
"+ with open(0) as f:",
"+ N, *S = f.read().split()",
"+ S = [s[0] for s in S if s[0] in list(\"MARCH\")]",
"+ S = Counter(S)",
"+ ans = sum(starmap(func, combinations(list(S.values()), 3)))",
"+ print(ans)",
"+",
"+",
"+main()"
] | false | 0.034328 | 0.037067 | 0.926103 | [
"s975523121",
"s378921961"
] |
u020373088 | p03309 | python | s531016204 | s675948336 | 212 | 194 | 26,836 | 26,128 | Accepted | Accepted | 8.49 | n = int(eval(input()))
a = list(map(int, input().split()))
a = [a[i] - (i+1) for i in range(len(a))]
import statistics
b = int(statistics.median(a))
ans = sum([abs(i-b) for i in a])
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
a = [a[i] - (i+1) for i in range(len(a))]
b = sorted(a)[int(n/2)]
print((sum([abs(i-b) for i in a]))) | 8 | 5 | 194 | 156 | n = int(eval(input()))
a = list(map(int, input().split()))
a = [a[i] - (i + 1) for i in range(len(a))]
import statistics
b = int(statistics.median(a))
ans = sum([abs(i - b) for i in a])
print(ans)
| n = int(eval(input()))
a = list(map(int, input().split()))
a = [a[i] - (i + 1) for i in range(len(a))]
b = sorted(a)[int(n / 2)]
print((sum([abs(i - b) for i in a])))
| false | 37.5 | [
"-import statistics",
"-",
"-b = int(statistics.median(a))",
"-ans = sum([abs(i - b) for i in a])",
"-print(ans)",
"+b = sorted(a)[int(n / 2)]",
"+print((sum([abs(i - b) for i in a])))"
] | false | 0.052777 | 0.062698 | 0.841765 | [
"s531016204",
"s675948336"
] |
u367130284 | p03212 | python | s981753453 | s901178910 | 90 | 76 | 2,940 | 3,060 | Accepted | Accepted | 15.56 | n=int(eval(input()))
def dfs(s):
if int(s)>n:
return 0
ret=1 if all(s.count(c)>0 for c in "753") else 0
for c in "753":
ret+=dfs(s+c)
return ret
print((dfs("0"))) | n=int(eval(input()))
def dfs(s):
if int(s)>n:
return 0
b=(all(map(s.count,"357")))
for c in "357":
b+=dfs(s+c)
return b
print((dfs("0"))) | 11 | 10 | 198 | 170 | n = int(eval(input()))
def dfs(s):
if int(s) > n:
return 0
ret = 1 if all(s.count(c) > 0 for c in "753") else 0
for c in "753":
ret += dfs(s + c)
return ret
print((dfs("0")))
| n = int(eval(input()))
def dfs(s):
if int(s) > n:
return 0
b = all(map(s.count, "357"))
for c in "357":
b += dfs(s + c)
return b
print((dfs("0")))
| false | 9.090909 | [
"- ret = 1 if all(s.count(c) > 0 for c in \"753\") else 0",
"- for c in \"753\":",
"- ret += dfs(s + c)",
"- return ret",
"+ b = all(map(s.count, \"357\"))",
"+ for c in \"357\":",
"+ b += dfs(s + c)",
"+ return b"
] | false | 0.049537 | 0.065581 | 0.755354 | [
"s981753453",
"s901178910"
] |
u367130284 | p03946 | python | s785368944 | s690335400 | 217 | 197 | 24,348 | 24,456 | Accepted | Accepted | 9.22 | from numpy import*;_,a=open(0);*a,=list(map(int,a.split()));c=array(a)-minimum.accumulate(a);print((list(c).count(max(c)))) | from numpy import*;_,a=open(0);*a,=list(map(int,a.split()));c=array(a)-minimum.accumulate(a);print((sum(c==max(c)))) | 1 | 1 | 115 | 108 | from numpy import *
_, a = open(0)
(*a,) = list(map(int, a.split()))
c = array(a) - minimum.accumulate(a)
print((list(c).count(max(c))))
| from numpy import *
_, a = open(0)
(*a,) = list(map(int, a.split()))
c = array(a) - minimum.accumulate(a)
print((sum(c == max(c))))
| false | 0 | [
"-print((list(c).count(max(c))))",
"+print((sum(c == max(c))))"
] | false | 0.186316 | 0.705702 | 0.264015 | [
"s785368944",
"s690335400"
] |
u353919145 | p03261 | python | s647868719 | s198254800 | 165 | 18 | 38,384 | 3,060 | Accepted | Accepted | 89.09 | def a():
n=int(eval(input()))
w=list()
for i in range(n):
z=eval(input())
w.append(z)
for i in range(1,n):
if w[i][0]!=w[i-1][len(w[i-1])-1]:
print("No")
return 0
w.sort()
for i in range(n-1):
if w[i]==w[i+1]:
print("No")
return 0
print("Yes")
return 0
a() | n=int(eval(input()))
x=[]
f_l_checker=True
x.append(eval(input()))
for i in range(1,n):
x.append(eval(input()))
if f_l_checker:
if x[i][0]==x[i-1][-1]:
for j in range(i):
if x[i]==x[j]:
f_l_checker=False
else:
f_l_checker=False
if f_l_checker:
print('Yes')
else:
print('No') | 18 | 17 | 373 | 364 | def a():
n = int(eval(input()))
w = list()
for i in range(n):
z = eval(input())
w.append(z)
for i in range(1, n):
if w[i][0] != w[i - 1][len(w[i - 1]) - 1]:
print("No")
return 0
w.sort()
for i in range(n - 1):
if w[i] == w[i + 1]:
print("No")
return 0
print("Yes")
return 0
a()
| n = int(eval(input()))
x = []
f_l_checker = True
x.append(eval(input()))
for i in range(1, n):
x.append(eval(input()))
if f_l_checker:
if x[i][0] == x[i - 1][-1]:
for j in range(i):
if x[i] == x[j]:
f_l_checker = False
else:
f_l_checker = False
if f_l_checker:
print("Yes")
else:
print("No")
| false | 5.555556 | [
"-def a():",
"- n = int(eval(input()))",
"- w = list()",
"- for i in range(n):",
"- z = eval(input())",
"- w.append(z)",
"- for i in range(1, n):",
"- if w[i][0] != w[i - 1][len(w[i - 1]) - 1]:",
"- print(\"No\")",
"- return 0",
"- w.sort()",
"- for i in range(n - 1):",
"- if w[i] == w[i + 1]:",
"- print(\"No\")",
"- return 0",
"+n = int(eval(input()))",
"+x = []",
"+f_l_checker = True",
"+x.append(eval(input()))",
"+for i in range(1, n):",
"+ x.append(eval(input()))",
"+ if f_l_checker:",
"+ if x[i][0] == x[i - 1][-1]:",
"+ for j in range(i):",
"+ if x[i] == x[j]:",
"+ f_l_checker = False",
"+ else:",
"+ f_l_checker = False",
"+if f_l_checker:",
"- return 0",
"-",
"-",
"-a()",
"+else:",
"+ print(\"No\")"
] | false | 0.040278 | 0.039445 | 1.021101 | [
"s647868719",
"s198254800"
] |
u655975843 | p03294 | python | s785536957 | s008591694 | 298 | 19 | 18,564 | 3,316 | Accepted | Accepted | 93.62 | import numpy as np
n = int(eval(input()))
a = list(map(int, input().split()))
f = 0
ans = np.cumsum(a) - n
print((ans[-1]))
| n = int(eval(input()))
a = list(map(int, input().split()))
f = 0
ans = 0
for i in range(n):
ans += a[i]
print((ans - n))
| 6 | 7 | 121 | 123 | import numpy as np
n = int(eval(input()))
a = list(map(int, input().split()))
f = 0
ans = np.cumsum(a) - n
print((ans[-1]))
| n = int(eval(input()))
a = list(map(int, input().split()))
f = 0
ans = 0
for i in range(n):
ans += a[i]
print((ans - n))
| false | 14.285714 | [
"-import numpy as np",
"-",
"-ans = np.cumsum(a) - n",
"-print((ans[-1]))",
"+ans = 0",
"+for i in range(n):",
"+ ans += a[i]",
"+print((ans - n))"
] | false | 0.388552 | 0.036259 | 10.716111 | [
"s785536957",
"s008591694"
] |
u296150111 | p02773 | python | s156421948 | s590589572 | 559 | 481 | 20,676 | 33,416 | Accepted | Accepted | 13.95 | import sys
input=sys.stdin.readline
n=int(eval(input()))
p=[]
for i in range(n):
s=input().rstrip()
p.append(s)
p.sort()
ans=0
cnt=1
for i in range(n-1):
if p[i]==p[i+1]:
cnt+=1
else:
ans=max(ans,cnt)
cnt=1
ans=max(ans,cnt)
q=[]
for i in range(n-ans+1):
if p[i]==p[i+ans-1]:
q.append(p[i])
q.sort()
for i in range(len(q)):
print((q[i]))
| table={}
import sys
input=sys.stdin.readline
n=int(eval(input()))
ss=[]
for i in range(n):
s=input().rstrip()
if s in table:
table[s]+=1
else:
table[s]=1
ss.append(s)
ans=[]
saidai=max(table.values())
for i in range(len(ss)):
if table[ss[i]]==saidai:
ans.append(ss[i])
ans.sort()
for x in ans:
print(x) | 24 | 20 | 366 | 328 | import sys
input = sys.stdin.readline
n = int(eval(input()))
p = []
for i in range(n):
s = input().rstrip()
p.append(s)
p.sort()
ans = 0
cnt = 1
for i in range(n - 1):
if p[i] == p[i + 1]:
cnt += 1
else:
ans = max(ans, cnt)
cnt = 1
ans = max(ans, cnt)
q = []
for i in range(n - ans + 1):
if p[i] == p[i + ans - 1]:
q.append(p[i])
q.sort()
for i in range(len(q)):
print((q[i]))
| table = {}
import sys
input = sys.stdin.readline
n = int(eval(input()))
ss = []
for i in range(n):
s = input().rstrip()
if s in table:
table[s] += 1
else:
table[s] = 1
ss.append(s)
ans = []
saidai = max(table.values())
for i in range(len(ss)):
if table[ss[i]] == saidai:
ans.append(ss[i])
ans.sort()
for x in ans:
print(x)
| false | 16.666667 | [
"+table = {}",
"-p = []",
"+ss = []",
"- p.append(s)",
"-p.sort()",
"-ans = 0",
"-cnt = 1",
"-for i in range(n - 1):",
"- if p[i] == p[i + 1]:",
"- cnt += 1",
"+ if s in table:",
"+ table[s] += 1",
"- ans = max(ans, cnt)",
"- cnt = 1",
"-ans = max(ans, cnt)",
"-q = []",
"-for i in range(n - ans + 1):",
"- if p[i] == p[i + ans - 1]:",
"- q.append(p[i])",
"-q.sort()",
"-for i in range(len(q)):",
"- print((q[i]))",
"+ table[s] = 1",
"+ ss.append(s)",
"+ans = []",
"+saidai = max(table.values())",
"+for i in range(len(ss)):",
"+ if table[ss[i]] == saidai:",
"+ ans.append(ss[i])",
"+ans.sort()",
"+for x in ans:",
"+ print(x)"
] | false | 0.0377 | 0.076208 | 0.4947 | [
"s156421948",
"s590589572"
] |
u057109575 | p02715 | python | s710781804 | s378317316 | 179 | 101 | 74,240 | 69,004 | Accepted | Accepted | 43.58 | N, K = list(map(int, input().split()))
def func(n):
r = n
for i in range(2, n + 1):
if i ** 2 > n:
break
if n % i == 0:
r -= r // i
while n % i == 0:
n //= i
if n > 1:
r -= r // n
return r
MOD = 10 ** 9 + 7
ans = 0
for i in range(1, K + 1):
ans += func(i) * pow(K // i, N, MOD)
print((ans % MOD))
| N, K = list(map(int, input().split()))
MOD = 10 ** 9 + 7
cnt = [0] * (K + 1)
ans = 0
for x in reversed(list(range(1, K + 1))):
cnt[x] += pow(K // x, N, MOD)
for n in range(2, K + 1):
if x * n > K:
break
cnt[x] -= cnt[x * n]
cnt[x] %= MOD
ans += x * cnt[x] % MOD
print((ans % MOD))
| 23 | 15 | 420 | 327 | N, K = list(map(int, input().split()))
def func(n):
r = n
for i in range(2, n + 1):
if i**2 > n:
break
if n % i == 0:
r -= r // i
while n % i == 0:
n //= i
if n > 1:
r -= r // n
return r
MOD = 10**9 + 7
ans = 0
for i in range(1, K + 1):
ans += func(i) * pow(K // i, N, MOD)
print((ans % MOD))
| N, K = list(map(int, input().split()))
MOD = 10**9 + 7
cnt = [0] * (K + 1)
ans = 0
for x in reversed(list(range(1, K + 1))):
cnt[x] += pow(K // x, N, MOD)
for n in range(2, K + 1):
if x * n > K:
break
cnt[x] -= cnt[x * n]
cnt[x] %= MOD
ans += x * cnt[x] % MOD
print((ans % MOD))
| false | 34.782609 | [
"-",
"-",
"-def func(n):",
"- r = n",
"- for i in range(2, n + 1):",
"- if i**2 > n:",
"+MOD = 10**9 + 7",
"+cnt = [0] * (K + 1)",
"+ans = 0",
"+for x in reversed(list(range(1, K + 1))):",
"+ cnt[x] += pow(K // x, N, MOD)",
"+ for n in range(2, K + 1):",
"+ if x * n > K:",
"- if n % i == 0:",
"- r -= r // i",
"- while n % i == 0:",
"- n //= i",
"- if n > 1:",
"- r -= r // n",
"- return r",
"-",
"-",
"-MOD = 10**9 + 7",
"-ans = 0",
"-for i in range(1, K + 1):",
"- ans += func(i) * pow(K // i, N, MOD)",
"+ cnt[x] -= cnt[x * n]",
"+ cnt[x] %= MOD",
"+ ans += x * cnt[x] % MOD"
] | false | 0.386817 | 0.133676 | 2.893683 | [
"s710781804",
"s378317316"
] |
u948524308 | p03239 | python | s680048762 | s587642909 | 20 | 17 | 2,940 | 2,940 | Accepted | Accepted | 15 | N, T = list(map(int, input().split()))
ans = 1001
for i in range(N):
c,t=list(map(int,input().split()))
if t<=T and c < ans:
ans = c
if ans >1000:
print("TLE")
else:
print(ans)
| N, T = list(map(int, input().split()))
c_ok=[]
for i in range(N):
c,t=list(map(int,input().split()))
if t<=T :
c_ok.append(c)
if c_ok==[]:
print("TLE")
else:
print((min(c_ok)))
| 12 | 12 | 202 | 200 | N, T = list(map(int, input().split()))
ans = 1001
for i in range(N):
c, t = list(map(int, input().split()))
if t <= T and c < ans:
ans = c
if ans > 1000:
print("TLE")
else:
print(ans)
| N, T = list(map(int, input().split()))
c_ok = []
for i in range(N):
c, t = list(map(int, input().split()))
if t <= T:
c_ok.append(c)
if c_ok == []:
print("TLE")
else:
print((min(c_ok)))
| false | 0 | [
"-ans = 1001",
"+c_ok = []",
"- if t <= T and c < ans:",
"- ans = c",
"-if ans > 1000:",
"+ if t <= T:",
"+ c_ok.append(c)",
"+if c_ok == []:",
"- print(ans)",
"+ print((min(c_ok)))"
] | false | 0.037117 | 0.077837 | 0.476857 | [
"s680048762",
"s587642909"
] |
u906501980 | p02660 | python | s965538090 | s415895864 | 91 | 72 | 9,468 | 65,844 | Accepted | Accepted | 20.88 | from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x%2:
out.append(2)
x //= 2
i = 3
while i*i <= x:
if not x%i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
primes = Counter(get_prime_factors(n))
ans = 0
for k, v in list(primes.items()):
num = 1
while v >= num:
ans += 1
v -= num
num += 1
print(ans)
if __name__ == "__main__":
main() | from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x%2:
out.append(2)
x //= 2
i = 3
while i*i <= x:
if not x%i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
ans = 0
primes = Counter(get_prime_factors(n))
for k, v in list(primes.items()):
num = 1
while v >= num:
v -= num
num += 1
ans += 1
print(ans)
if __name__ == "__main__":
main() | 35 | 35 | 659 | 663 | from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x % 2:
out.append(2)
x //= 2
i = 3
while i * i <= x:
if not x % i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
primes = Counter(get_prime_factors(n))
ans = 0
for k, v in list(primes.items()):
num = 1
while v >= num:
ans += 1
v -= num
num += 1
print(ans)
if __name__ == "__main__":
main()
| from collections import Counter
def get_prime_factors(x):
out = []
if x < 1:
return out
while not x % 2:
out.append(2)
x //= 2
i = 3
while i * i <= x:
if not x % i:
out.append(i)
x //= i
else:
i += 2
if x != 1:
out.append(x)
return out
def main():
n = int(eval(input()))
ans = 0
primes = Counter(get_prime_factors(n))
for k, v in list(primes.items()):
num = 1
while v >= num:
v -= num
num += 1
ans += 1
print(ans)
if __name__ == "__main__":
main()
| false | 0 | [
"+ ans = 0",
"- ans = 0",
"- ans += 1",
"+ ans += 1"
] | false | 0.038201 | 0.038371 | 0.995571 | [
"s965538090",
"s415895864"
] |
u282228874 | p03212 | python | s404259165 | s831361423 | 294 | 88 | 6,240 | 18,716 | Accepted | Accepted | 70.07 | from itertools import product
n = int(eval(input()))
num = ['','3','5','7']
A = set()
for i in product(num,repeat=9):
x = "".join(i)
if len(set(x)) == 3:
if (int(x) not in A) and (int(x) <= n):
A.add(int(x))
print((len(A))) | N = int(eval(input()))
num = ['3','5','7']
for i in range(len(str(N))-1):
num2 = []
for n in num:
num2.append(n+'3')
num2.append(n+'5')
num2.append(n+'7')
num2.append(n)
num = num2
cnt = 0
num = set(num)
for n in num:
if '3' in n and '5' in n and '7' in n:
if int(n) <= N:
cnt += 1
print(cnt) | 10 | 17 | 253 | 370 | from itertools import product
n = int(eval(input()))
num = ["", "3", "5", "7"]
A = set()
for i in product(num, repeat=9):
x = "".join(i)
if len(set(x)) == 3:
if (int(x) not in A) and (int(x) <= n):
A.add(int(x))
print((len(A)))
| N = int(eval(input()))
num = ["3", "5", "7"]
for i in range(len(str(N)) - 1):
num2 = []
for n in num:
num2.append(n + "3")
num2.append(n + "5")
num2.append(n + "7")
num2.append(n)
num = num2
cnt = 0
num = set(num)
for n in num:
if "3" in n and "5" in n and "7" in n:
if int(n) <= N:
cnt += 1
print(cnt)
| false | 41.176471 | [
"-from itertools import product",
"-",
"-n = int(eval(input()))",
"-num = [\"\", \"3\", \"5\", \"7\"]",
"-A = set()",
"-for i in product(num, repeat=9):",
"- x = \"\".join(i)",
"- if len(set(x)) == 3:",
"- if (int(x) not in A) and (int(x) <= n):",
"- A.add(int(x))",
"-print((len(A)))",
"+N = int(eval(input()))",
"+num = [\"3\", \"5\", \"7\"]",
"+for i in range(len(str(N)) - 1):",
"+ num2 = []",
"+ for n in num:",
"+ num2.append(n + \"3\")",
"+ num2.append(n + \"5\")",
"+ num2.append(n + \"7\")",
"+ num2.append(n)",
"+ num = num2",
"+cnt = 0",
"+num = set(num)",
"+for n in num:",
"+ if \"3\" in n and \"5\" in n and \"7\" in n:",
"+ if int(n) <= N:",
"+ cnt += 1",
"+print(cnt)"
] | false | 0.525449 | 0.061507 | 8.542925 | [
"s404259165",
"s831361423"
] |
u054514819 | p03045 | python | s289198279 | s201612755 | 495 | 228 | 7,856 | 81,204 | Accepted | Accepted | 53.94 | N, M = list(map(int, input().split()))
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
uf = UnionFind(N)
for i in range(M):
X, Y, Z = list(map(int, input().split()))
uf.union(X-1, Y-1)
print((len(uf.roots())))
| import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, M = mapint()
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
uf = UnionFind(N)
for _ in range(M):
x, y, z = mapint()
uf.union(x-1, y-1)
print((uf.group_count())) | 49 | 59 | 1,153 | 1,465 | N, M = list(map(int, input().split()))
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
uf = UnionFind(N)
for i in range(M):
X, Y, Z = list(map(int, input().split()))
uf.union(X - 1, Y - 1)
print((len(uf.roots())))
| import sys
def input():
return sys.stdin.readline().strip()
def mapint():
return list(map(int, input().split()))
sys.setrecursionlimit(10**9)
N, M = mapint()
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
uf = UnionFind(N)
for _ in range(M):
x, y, z = mapint()
uf.union(x - 1, y - 1)
print((uf.group_count()))
| false | 16.949153 | [
"-N, M = list(map(int, input().split()))",
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def mapint():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+sys.setrecursionlimit(10**9)",
"+N, M = mapint()",
"+ def all_group_members(self):",
"+ return {r: self.members(r) for r in self.roots()}",
"+",
"+ def __str__(self):",
"+ return \"\\n\".join(\"{}: {}\".format(r, self.members(r)) for r in self.roots())",
"+",
"-for i in range(M):",
"- X, Y, Z = list(map(int, input().split()))",
"- uf.union(X - 1, Y - 1)",
"-print((len(uf.roots())))",
"+for _ in range(M):",
"+ x, y, z = mapint()",
"+ uf.union(x - 1, y - 1)",
"+print((uf.group_count()))"
] | false | 0.038217 | 0.038143 | 1.001959 | [
"s289198279",
"s201612755"
] |
u994521204 | p02537 | python | s900236709 | s764499876 | 521 | 477 | 136,084 | 103,628 | Accepted | Accepted | 8.45 | import sys
input = sys.stdin.buffer.readline
class SegmentTree:
ele = 0
func = max
# SEG木は1-index
# Aに関しては0-index
def __init__(self, n): # Aは0-idx
self.n = n
self.num = 2 ** ((self.n - 1).bit_length())
self.SEG = [self.ele] * (2 * self.num)
def search(self, idx):
return self.SEG[idx + self.num]
def initialize(self, A):
for i in range(self.n):
self.SEG[i + self.num] = A[i]
for i in range(self.num - 1, 0, -1):
self.SEG[i] = self.func(self.SEG[2 * i], self.SEG[2 * i + 1])
# 1点更新
def set(self, idx, val):
idx += self.num
self.SEG[idx] = val
idx //= 2
while idx:
self.SEG[idx] = self.func(self.SEG[2 * idx], self.SEG[2 * idx + 1])
idx //= 2
# 区間取得
def query(self, left, right):
# 開区間
resleft = self.ele
resright = self.ele
left += self.num
right += self.num
while right - left > 0:
if left % 2 == 1:
resleft = self.func(resleft, self.SEG[left])
left += 1
if right % 2 == 1:
right -= 1
resright = self.func(resright, self.SEG[right])
left //= 2
right //= 2
return self.func(resleft, resright)
n, k = list(map(int, input().split()))
ans = 0
ST = SegmentTree(3000001)
for _ in range(n):
val = int(eval(input()))
lower = val - k
lower = max(lower, 0)
upper = val + k
upper = min(upper, 3000000)
temp = ST.query(lower, upper + 1) + 1
ST.set(val, temp)
ans = max(ans, temp)
print(ans)
| import sys
input = sys.stdin.buffer.readline
n, k = list(map(int, input().split()))
max_n = 300000
num = 2 ** ((max_n - 1).bit_length())
SEG = [0] * (2 * num)
func = max
ele = 0
def update(idx, val):
idx += num
SEG[idx] = val
while idx > 0:
idx //= 2
SEG[idx] = func(SEG[2 * idx], SEG[2 * idx + 1])
def query(left, right):
res_left = ele
res_right = ele
left += num
right += num
while right - left > 0:
if left & 1:
res_left = func(res_left, SEG[left])
left += 1
if right & 1:
right -= 1
res_right = func(SEG[right], res_right)
left //= 2
right //= 2
return func(res_left, res_right)
for _ in range(n):
val = int(eval(input()))
temp = query(max(0, val - k), min(max_n + 1, val + k + 1))
temp += 1
update(val, temp)
print((SEG[1]))
| 66 | 47 | 1,715 | 923 | import sys
input = sys.stdin.buffer.readline
class SegmentTree:
ele = 0
func = max
# SEG木は1-index
# Aに関しては0-index
def __init__(self, n): # Aは0-idx
self.n = n
self.num = 2 ** ((self.n - 1).bit_length())
self.SEG = [self.ele] * (2 * self.num)
def search(self, idx):
return self.SEG[idx + self.num]
def initialize(self, A):
for i in range(self.n):
self.SEG[i + self.num] = A[i]
for i in range(self.num - 1, 0, -1):
self.SEG[i] = self.func(self.SEG[2 * i], self.SEG[2 * i + 1])
# 1点更新
def set(self, idx, val):
idx += self.num
self.SEG[idx] = val
idx //= 2
while idx:
self.SEG[idx] = self.func(self.SEG[2 * idx], self.SEG[2 * idx + 1])
idx //= 2
# 区間取得
def query(self, left, right):
# 開区間
resleft = self.ele
resright = self.ele
left += self.num
right += self.num
while right - left > 0:
if left % 2 == 1:
resleft = self.func(resleft, self.SEG[left])
left += 1
if right % 2 == 1:
right -= 1
resright = self.func(resright, self.SEG[right])
left //= 2
right //= 2
return self.func(resleft, resright)
n, k = list(map(int, input().split()))
ans = 0
ST = SegmentTree(3000001)
for _ in range(n):
val = int(eval(input()))
lower = val - k
lower = max(lower, 0)
upper = val + k
upper = min(upper, 3000000)
temp = ST.query(lower, upper + 1) + 1
ST.set(val, temp)
ans = max(ans, temp)
print(ans)
| import sys
input = sys.stdin.buffer.readline
n, k = list(map(int, input().split()))
max_n = 300000
num = 2 ** ((max_n - 1).bit_length())
SEG = [0] * (2 * num)
func = max
ele = 0
def update(idx, val):
idx += num
SEG[idx] = val
while idx > 0:
idx //= 2
SEG[idx] = func(SEG[2 * idx], SEG[2 * idx + 1])
def query(left, right):
res_left = ele
res_right = ele
left += num
right += num
while right - left > 0:
if left & 1:
res_left = func(res_left, SEG[left])
left += 1
if right & 1:
right -= 1
res_right = func(SEG[right], res_right)
left //= 2
right //= 2
return func(res_left, res_right)
for _ in range(n):
val = int(eval(input()))
temp = query(max(0, val - k), min(max_n + 1, val + k + 1))
temp += 1
update(val, temp)
print((SEG[1]))
| false | 28.787879 | [
"+n, k = list(map(int, input().split()))",
"+max_n = 300000",
"+num = 2 ** ((max_n - 1).bit_length())",
"+SEG = [0] * (2 * num)",
"+func = max",
"+ele = 0",
"-class SegmentTree:",
"- ele = 0",
"- func = max",
"- # SEG木は1-index",
"- # Aに関しては0-index",
"- def __init__(self, n): # Aは0-idx",
"- self.n = n",
"- self.num = 2 ** ((self.n - 1).bit_length())",
"- self.SEG = [self.ele] * (2 * self.num)",
"-",
"- def search(self, idx):",
"- return self.SEG[idx + self.num]",
"-",
"- def initialize(self, A):",
"- for i in range(self.n):",
"- self.SEG[i + self.num] = A[i]",
"- for i in range(self.num - 1, 0, -1):",
"- self.SEG[i] = self.func(self.SEG[2 * i], self.SEG[2 * i + 1])",
"-",
"- # 1点更新",
"- def set(self, idx, val):",
"- idx += self.num",
"- self.SEG[idx] = val",
"+def update(idx, val):",
"+ idx += num",
"+ SEG[idx] = val",
"+ while idx > 0:",
"- while idx:",
"- self.SEG[idx] = self.func(self.SEG[2 * idx], self.SEG[2 * idx + 1])",
"- idx //= 2",
"-",
"- # 区間取得",
"- def query(self, left, right):",
"- # 開区間",
"- resleft = self.ele",
"- resright = self.ele",
"- left += self.num",
"- right += self.num",
"- while right - left > 0:",
"- if left % 2 == 1:",
"- resleft = self.func(resleft, self.SEG[left])",
"- left += 1",
"- if right % 2 == 1:",
"- right -= 1",
"- resright = self.func(resright, self.SEG[right])",
"- left //= 2",
"- right //= 2",
"- return self.func(resleft, resright)",
"+ SEG[idx] = func(SEG[2 * idx], SEG[2 * idx + 1])",
"-n, k = list(map(int, input().split()))",
"-ans = 0",
"-ST = SegmentTree(3000001)",
"+def query(left, right):",
"+ res_left = ele",
"+ res_right = ele",
"+ left += num",
"+ right += num",
"+ while right - left > 0:",
"+ if left & 1:",
"+ res_left = func(res_left, SEG[left])",
"+ left += 1",
"+ if right & 1:",
"+ right -= 1",
"+ res_right = func(SEG[right], res_right)",
"+ left //= 2",
"+ right //= 2",
"+ return func(res_left, res_right)",
"+",
"+",
"- lower = val - k",
"- lower = max(lower, 0)",
"- upper = val + k",
"- upper = min(upper, 3000000)",
"- temp = ST.query(lower, upper + 1) + 1",
"- ST.set(val, temp)",
"- ans = max(ans, temp)",
"-print(ans)",
"+ temp = query(max(0, val - k), min(max_n + 1, val + k + 1))",
"+ temp += 1",
"+ update(val, temp)",
"+print((SEG[1]))"
] | false | 0.336151 | 0.069051 | 4.868127 | [
"s900236709",
"s764499876"
] |
u156815136 | p03105 | python | s517167909 | s666582429 | 49 | 38 | 5,660 | 10,204 | Accepted | Accepted | 22.45 | from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def main():
a,b,c = readInts()
print((c if a*c <= b else b//a))
if __name__ == '__main__':
main()
| #from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate, product # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(eval(input()))
a,b,c = readInts()
print((min(c, b//a)))
| 30 | 31 | 661 | 773 | from statistics import median
# import collections
# aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int, input().split()))
def main():
a, b, c = readInts()
print((c if a * c <= b else b // a))
if __name__ == "__main__":
main()
| # from statistics import median
# import collections
# aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations, permutations, accumulate, product # (string,3) 3回
# from collections import deque
from collections import deque, defaultdict, Counter
import decimal
import re
# import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
# my_round_int = lambda x:np.round((x*2 + 1)//2)
# 四捨五入g
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
# mod = 9982443453
def readInts():
return list(map(int, input().split()))
def I():
return int(eval(input()))
a, b, c = readInts()
print((min(c, b // a)))
| false | 3.225806 | [
"-from statistics import median",
"-",
"+# from statistics import median",
"-from itertools import combinations # (string,3) 3回",
"-from collections import deque",
"-from collections import defaultdict",
"-import bisect",
"+from itertools import combinations, permutations, accumulate, product # (string,3) 3回",
"+# from collections import deque",
"+from collections import deque, defaultdict, Counter",
"+import decimal",
"+import re",
"+",
"+# import bisect",
"+# my_round_int = lambda x:np.round((x*2 + 1)//2)",
"+# 四捨五入g",
"-",
"-",
"+# mod = 9982443453",
"-def main():",
"- a, b, c = readInts()",
"- print((c if a * c <= b else b // a))",
"+def I():",
"+ return int(eval(input()))",
"-if __name__ == \"__main__\":",
"- main()",
"+a, b, c = readInts()",
"+print((min(c, b // a)))"
] | false | 0.044236 | 0.045191 | 0.978856 | [
"s517167909",
"s666582429"
] |
u996749146 | p03341 | python | s729590026 | s962921197 | 563 | 464 | 29,692 | 29,696 | Accepted | Accepted | 17.58 | # https://beta.atcoder.jp/contests/arc098/tasks/arc098_a
# C - Attention
# C_Attention.py
N = int(eval(input()))
S = eval(input())
e = [0 for i in range(N)]
w = [0 for i in range(N)]
d = [0 for i in range(N)]
# 累積和を求める
for i in range(N):
# そこからE側の人で、Wを向くべきなのにEを向いている人
if i > 0:
w[i] += w[i-1]
if i < N-1:
if S[i] == "W":
w[i+1] += 1
# そこからW側の人で、Eを向くべきなのにWを向いている人
if i > 0:
e[N-1-i] += e[N-1-(i-1)]
if i < N-1:
if S[N-1-i] == "E":
e[N-1-(i+1)] += 1
min = 10 ** 6
for i in range(N):
total = e[i] + w[i]
if total < min:
min = total
print(min)
| # https://beta.atcoder.jp/contests/arc098/tasks/arc098_a
# C - Attention
# C_Attention_beta.py
N = int(eval(input()))
S = eval(input())
e = [0 for i in range(N)]
w = [0 for i in range(N)]
d = [0 for i in range(N)]
# 累積和を求める
for i in range(N):
# そこからE側の人で、Wを向くべきなのにEを向いている人
if i > 0:
w[i] += w[i-1]
if i < N-1:
if S[i] == "W":
w[i+1] += 1
# そこからW側の人で、Eを向くべきなのにWを向いている人
for j in range(N):
i = N-1-j
if i < N-1:
e[i] += e[i+1]
if i > 0:
if S[i] == "E":
e[i-1] += 1
min = 10 ** 6
for i in range(N):
total = e[i] + w[i]
if total < min:
min = total
print(min)
| 33 | 38 | 661 | 683 | # https://beta.atcoder.jp/contests/arc098/tasks/arc098_a
# C - Attention
# C_Attention.py
N = int(eval(input()))
S = eval(input())
e = [0 for i in range(N)]
w = [0 for i in range(N)]
d = [0 for i in range(N)]
# 累積和を求める
for i in range(N):
# そこからE側の人で、Wを向くべきなのにEを向いている人
if i > 0:
w[i] += w[i - 1]
if i < N - 1:
if S[i] == "W":
w[i + 1] += 1
# そこからW側の人で、Eを向くべきなのにWを向いている人
if i > 0:
e[N - 1 - i] += e[N - 1 - (i - 1)]
if i < N - 1:
if S[N - 1 - i] == "E":
e[N - 1 - (i + 1)] += 1
min = 10**6
for i in range(N):
total = e[i] + w[i]
if total < min:
min = total
print(min)
| # https://beta.atcoder.jp/contests/arc098/tasks/arc098_a
# C - Attention
# C_Attention_beta.py
N = int(eval(input()))
S = eval(input())
e = [0 for i in range(N)]
w = [0 for i in range(N)]
d = [0 for i in range(N)]
# 累積和を求める
for i in range(N):
# そこからE側の人で、Wを向くべきなのにEを向いている人
if i > 0:
w[i] += w[i - 1]
if i < N - 1:
if S[i] == "W":
w[i + 1] += 1
# そこからW側の人で、Eを向くべきなのにWを向いている人
for j in range(N):
i = N - 1 - j
if i < N - 1:
e[i] += e[i + 1]
if i > 0:
if S[i] == "E":
e[i - 1] += 1
min = 10**6
for i in range(N):
total = e[i] + w[i]
if total < min:
min = total
print(min)
| false | 13.157895 | [
"-# C_Attention.py",
"+# C_Attention_beta.py",
"- # そこからW側の人で、Eを向くべきなのにWを向いている人",
"+# そこからW側の人で、Eを向くべきなのにWを向いている人",
"+for j in range(N):",
"+ i = N - 1 - j",
"+ if i < N - 1:",
"+ e[i] += e[i + 1]",
"- e[N - 1 - i] += e[N - 1 - (i - 1)]",
"- if i < N - 1:",
"- if S[N - 1 - i] == \"E\":",
"- e[N - 1 - (i + 1)] += 1",
"+ if S[i] == \"E\":",
"+ e[i - 1] += 1"
] | false | 0.037818 | 0.047588 | 0.794691 | [
"s729590026",
"s962921197"
] |
u347640436 | p03634 | python | s509510529 | s705440416 | 1,075 | 928 | 68,800 | 55,608 | Accepted | Accepted | 13.67 | from heapq import heappop, heappush
N = int(eval(input()))
costs = {}
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
costs.setdefault(a, {})
costs[a][b] = c
costs.setdefault(b, {})
costs[b][a] = c
Q, K = list(map(int, input().split()))
d = [float('inf')] * (N + 1)
d[K] = 0
#prev = [None] * (N + 1)
q = [(0, K)]
while q:
_, u = heappop(q)
for v in costs[u]:
alt = d[u] + costs[u][v]
if d[v] > alt:
d[v] = alt
#prev[v] = u
heappush(q, (alt, v))
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(('\n'.join(str(v) for v in result)))
| from collections import deque
N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float('inf')] * (N + 1)
d[K] = 0
q = deque([K])
while q:
i = q.popleft()
for j, c in links[i]:
if d[i] + c < d[j]:
d[j] = d[i] + c
q.append(j)
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(('\n'.join(str(v) for v in result)))
| 31 | 26 | 698 | 591 | from heapq import heappop, heappush
N = int(eval(input()))
costs = {}
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
costs.setdefault(a, {})
costs[a][b] = c
costs.setdefault(b, {})
costs[b][a] = c
Q, K = list(map(int, input().split()))
d = [float("inf")] * (N + 1)
d[K] = 0
# prev = [None] * (N + 1)
q = [(0, K)]
while q:
_, u = heappop(q)
for v in costs[u]:
alt = d[u] + costs[u][v]
if d[v] > alt:
d[v] = alt
# prev[v] = u
heappush(q, (alt, v))
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(("\n".join(str(v) for v in result)))
| from collections import deque
N = int(eval(input()))
links = [[] for _ in range(N + 1)]
for _ in range(N - 1):
a, b, c = list(map(int, input().split()))
links[a].append((b, c))
links[b].append((a, c))
Q, K = list(map(int, input().split()))
d = [float("inf")] * (N + 1)
d[K] = 0
q = deque([K])
while q:
i = q.popleft()
for j, c in links[i]:
if d[i] + c < d[j]:
d[j] = d[i] + c
q.append(j)
result = []
for _ in range(Q):
x, y = list(map(int, input().split()))
result.append(d[x] + d[y])
print(("\n".join(str(v) for v in result)))
| false | 16.129032 | [
"-from heapq import heappop, heappush",
"+from collections import deque",
"-costs = {}",
"+links = [[] for _ in range(N + 1)]",
"- costs.setdefault(a, {})",
"- costs[a][b] = c",
"- costs.setdefault(b, {})",
"- costs[b][a] = c",
"+ links[a].append((b, c))",
"+ links[b].append((a, c))",
"-# prev = [None] * (N + 1)",
"-q = [(0, K)]",
"+q = deque([K])",
"- _, u = heappop(q)",
"- for v in costs[u]:",
"- alt = d[u] + costs[u][v]",
"- if d[v] > alt:",
"- d[v] = alt",
"- # prev[v] = u",
"- heappush(q, (alt, v))",
"+ i = q.popleft()",
"+ for j, c in links[i]:",
"+ if d[i] + c < d[j]:",
"+ d[j] = d[i] + c",
"+ q.append(j)"
] | false | 0.074187 | 0.076477 | 0.970056 | [
"s509510529",
"s705440416"
] |
u992910889 | p03607 | python | s361359947 | s115368282 | 523 | 103 | 61,400 | 16,628 | Accepted | Accepted | 80.31 | from collections import Counter, deque
# from copy import copy, deepcopy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np
# from operator import xor
import sys
sys.setrecursionlimit(10 ** 5 + 10)
# input = sys.stdin.readline
def resolve():
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
AA=Counter(A)
cnt=0
for i in list(AA.values()):
if i%2==1:
cnt+=1
print(cnt)
resolve() | from collections import Counter, deque # https://note.nkmk.me/python-scipy-connected-components/
# from copy import copy, deepcopy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components # Pythonのみ！
# ↑cf. https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import string
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
N=int(eval(input()))
A=[int(eval(input())) for i in range(N)]
AA=Counter(A)
cnt=0
for i in list(AA.values()):
if i%2==1:
cnt+=1
print(cnt)
resolve() | 25 | 31 | 599 | 896 | from collections import Counter, deque
# from copy import copy, deepcopy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np
# from operator import xor
import sys
sys.setrecursionlimit(10**5 + 10)
# input = sys.stdin.readline
def resolve():
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
AA = Counter(A)
cnt = 0
for i in list(AA.values()):
if i % 2 == 1:
cnt += 1
print(cnt)
resolve()
| from collections import (
Counter,
deque,
) # https://note.nkmk.me/python-scipy-connected-components/
# from copy import copy, deepcopy
# from fractions import gcd
# from functools import reduce
# from itertools import accumulate, permutations, combinations, combinations_with_replacement, groupby, product
# import math
# import numpy as np # Pythonのみ！
# from operator import xor
# import re
# from scipy.sparse.csgraph import connected_components # Pythonのみ！
# ↑cf. https://note.nkmk.me/python-scipy-connected-components/
# from scipy.sparse import csr_matrix
# import string
import sys
sys.setrecursionlimit(10**5 + 10)
def input():
return sys.stdin.readline().strip()
def resolve():
N = int(eval(input()))
A = [int(eval(input())) for i in range(N)]
AA = Counter(A)
cnt = 0
for i in list(AA.values()):
if i % 2 == 1:
cnt += 1
print(cnt)
resolve()
| false | 19.354839 | [
"-from collections import Counter, deque",
"+from collections import (",
"+ Counter,",
"+ deque,",
"+) # https://note.nkmk.me/python-scipy-connected-components/",
"-# import numpy as np",
"+# import numpy as np # Pythonのみ！",
"+# import re",
"+# from scipy.sparse.csgraph import connected_components # Pythonのみ！",
"+# ↑cf. https://note.nkmk.me/python-scipy-connected-components/",
"+# from scipy.sparse import csr_matrix",
"+# import string",
"-# input = sys.stdin.readline",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+"
] | false | 0.034336 | 0.036058 | 0.952243 | [
"s361359947",
"s115368282"
] |
u764215612 | p02690 | python | s485414197 | s269841280 | 34 | 31 | 9,312 | 9,432 | Accepted | Accepted | 8.82 | import math
def main():
x = int(eval(input()))
for i in range(-120,120):
for j in range(-120,120):
if math.pow(i, 5) - math.pow(j, 5) == x:
print((str(i) + ' ' + str(j)))
return
main() | import math
def main():
x = int(eval(input()))
for i in range(-118,120):
for j in range(-119,129):
if math.pow(i, 5) - math.pow(j, 5) == x:
print((str(i) + ' ' + str(j)))
return
main() | 9 | 9 | 214 | 214 | import math
def main():
x = int(eval(input()))
for i in range(-120, 120):
for j in range(-120, 120):
if math.pow(i, 5) - math.pow(j, 5) == x:
print((str(i) + " " + str(j)))
return
main()
| import math
def main():
x = int(eval(input()))
for i in range(-118, 120):
for j in range(-119, 129):
if math.pow(i, 5) - math.pow(j, 5) == x:
print((str(i) + " " + str(j)))
return
main()
| false | 0 | [
"- for i in range(-120, 120):",
"- for j in range(-120, 120):",
"+ for i in range(-118, 120):",
"+ for j in range(-119, 129):"
] | false | 0.049708 | 0.062981 | 0.789264 | [
"s485414197",
"s269841280"
] |
u597455618 | p02572 | python | s679227055 | s059911106 | 149 | 136 | 29,124 | 29,120 | Accepted | Accepted | 8.72 | import sys
from itertools import accumulate
n = int(sys.stdin.buffer.readline())
a = list(map(int, sys.stdin.buffer.readline().split()))
aa = list(accumulate(a))
MOD = 10**9+7
ans = 0
for i in range(n):
ans += a[i]*(aa[n-1] - aa[i]) % MOD
print((ans%MOD))
| import sys
from itertools import accumulate
n = int(sys.stdin.buffer.readline())
a = list(map(int, sys.stdin.buffer.readline().split()))
aa = list(accumulate(a))
MOD = 10**9+7
ans = 0
for i in range(n):
ans += a[i]*(aa[n-1] - aa[i])
print((ans%MOD))
| 10 | 10 | 267 | 261 | import sys
from itertools import accumulate
n = int(sys.stdin.buffer.readline())
a = list(map(int, sys.stdin.buffer.readline().split()))
aa = list(accumulate(a))
MOD = 10**9 + 7
ans = 0
for i in range(n):
ans += a[i] * (aa[n - 1] - aa[i]) % MOD
print((ans % MOD))
| import sys
from itertools import accumulate
n = int(sys.stdin.buffer.readline())
a = list(map(int, sys.stdin.buffer.readline().split()))
aa = list(accumulate(a))
MOD = 10**9 + 7
ans = 0
for i in range(n):
ans += a[i] * (aa[n - 1] - aa[i])
print((ans % MOD))
| false | 0 | [
"- ans += a[i] * (aa[n - 1] - aa[i]) % MOD",
"+ ans += a[i] * (aa[n - 1] - aa[i])"
] | false | 0.036135 | 0.10293 | 0.351064 | [
"s679227055",
"s059911106"
] |
u780475861 | p03647 | python | s057655392 | s248350398 | 290 | 154 | 19,168 | 41,936 | Accepted | Accepted | 46.9 | import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
set1, setn = set(), set()
for _ in range(m):
i, j = list(map(int, sys.stdin.readline().split()))
if i == 1:
set1.add(j)
if j == n:
setn.add(i)
if set1 & setn:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
if __name__ == '__main__':
main() | import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
lst = list(map(int, sys.stdin.read().split()))
set1, setn = set(), set()
for i, j in zip(lst, lst):
if i == 1:
set1.add(j)
if j == n:
setn.add(i)
if set1 & setn:
print('POSSIBLE')
else:
print('IMPOSSIBLE')
if __name__ == '__main__':
main() | 20 | 20 | 366 | 367 | import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
set1, setn = set(), set()
for _ in range(m):
i, j = list(map(int, sys.stdin.readline().split()))
if i == 1:
set1.add(j)
if j == n:
setn.add(i)
if set1 & setn:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == "__main__":
main()
| import sys
def main():
n, m = list(map(int, sys.stdin.readline().split()))
lst = list(map(int, sys.stdin.read().split()))
set1, setn = set(), set()
for i, j in zip(lst, lst):
if i == 1:
set1.add(j)
if j == n:
setn.add(i)
if set1 & setn:
print("POSSIBLE")
else:
print("IMPOSSIBLE")
if __name__ == "__main__":
main()
| false | 0 | [
"+ lst = list(map(int, sys.stdin.read().split()))",
"- for _ in range(m):",
"- i, j = list(map(int, sys.stdin.readline().split()))",
"+ for i, j in zip(lst, lst):"
] | false | 0.040779 | 0.032709 | 1.246726 | [
"s057655392",
"s248350398"
] |
u279460955 | p03806 | python | s031878184 | s288537434 | 727 | 613 | 73,468 | 73,816 | Accepted | Accepted | 15.68 | n, ma, mb = (int(x) for x in input().split())
ABC = [tuple(int(x) for x in input().split()) for _ in range(n)]
m = n // 2
D = dict()
E = dict()
for bit in range(1, 1<<m):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(m):
if bit & 1<<i:
a, b, c = ABC[i]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in D:
D[s] = min(D[s], sum_c)
else:
D[s] = sum_c
k = n - m
for bit in range(1, 1<<k):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(k):
if bit & 1<<i:
a, b, c = ABC[m + i]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in E:
E[s] = min(E[s], sum_c)
else:
E[s] = sum_c
ans = 10**18
if 0 in D:
ans = min(ans, D[0])
if 0 in E:
ans = min(ans, E[0])
for s, c in list(D.items()):
if -s in E:
ans = min(ans, D[s] + E[-s])
if ans == 10**18:
print((-1))
else:
print(ans)
| n, ma, mb = (int(x) for x in input().split())
ABC = [tuple(int(x) for x in input().split()) for _ in range(n)]
D1 = dict()
D2 = dict()
for (m, D, j) in ((n // 2, D1, 0), (n - n // 2, D2, n // 2)):
for bit in range(1, 1<<m):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(m):
if bit & 1<<i:
a, b, c = ABC[i + j]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in D:
D[s] = min(D[s], sum_c)
else:
D[s] = sum_c
ans = 10**18
if 0 in D1:
ans = min(ans, D1[0])
if 0 in D2:
ans = min(ans, D2[0])
for s in D1:
if -s in D2:
ans = min(ans, D1[s] + D2[-s])
if ans == 10**18:
print((-1))
else:
print(ans)
| 50 | 32 | 1,069 | 826 | n, ma, mb = (int(x) for x in input().split())
ABC = [tuple(int(x) for x in input().split()) for _ in range(n)]
m = n // 2
D = dict()
E = dict()
for bit in range(1, 1 << m):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(m):
if bit & 1 << i:
a, b, c = ABC[i]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in D:
D[s] = min(D[s], sum_c)
else:
D[s] = sum_c
k = n - m
for bit in range(1, 1 << k):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(k):
if bit & 1 << i:
a, b, c = ABC[m + i]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in E:
E[s] = min(E[s], sum_c)
else:
E[s] = sum_c
ans = 10**18
if 0 in D:
ans = min(ans, D[0])
if 0 in E:
ans = min(ans, E[0])
for s, c in list(D.items()):
if -s in E:
ans = min(ans, D[s] + E[-s])
if ans == 10**18:
print((-1))
else:
print(ans)
| n, ma, mb = (int(x) for x in input().split())
ABC = [tuple(int(x) for x in input().split()) for _ in range(n)]
D1 = dict()
D2 = dict()
for (m, D, j) in ((n // 2, D1, 0), (n - n // 2, D2, n // 2)):
for bit in range(1, 1 << m):
sum_a = 0
sum_b = 0
sum_c = 0
for i in range(m):
if bit & 1 << i:
a, b, c = ABC[i + j]
sum_a += a
sum_b += b
sum_c += c
s = mb * sum_a - ma * sum_b
if s in D:
D[s] = min(D[s], sum_c)
else:
D[s] = sum_c
ans = 10**18
if 0 in D1:
ans = min(ans, D1[0])
if 0 in D2:
ans = min(ans, D2[0])
for s in D1:
if -s in D2:
ans = min(ans, D1[s] + D2[-s])
if ans == 10**18:
print((-1))
else:
print(ans)
| false | 36 | [
"-m = n // 2",
"-D = dict()",
"-E = dict()",
"-for bit in range(1, 1 << m):",
"- sum_a = 0",
"- sum_b = 0",
"- sum_c = 0",
"- for i in range(m):",
"- if bit & 1 << i:",
"- a, b, c = ABC[i]",
"- sum_a += a",
"- sum_b += b",
"- sum_c += c",
"- s = mb * sum_a - ma * sum_b",
"- if s in D:",
"- D[s] = min(D[s], sum_c)",
"- else:",
"- D[s] = sum_c",
"-k = n - m",
"-for bit in range(1, 1 << k):",
"- sum_a = 0",
"- sum_b = 0",
"- sum_c = 0",
"- for i in range(k):",
"- if bit & 1 << i:",
"- a, b, c = ABC[m + i]",
"- sum_a += a",
"- sum_b += b",
"- sum_c += c",
"- s = mb * sum_a - ma * sum_b",
"- if s in E:",
"- E[s] = min(E[s], sum_c)",
"- else:",
"- E[s] = sum_c",
"+D1 = dict()",
"+D2 = dict()",
"+for (m, D, j) in ((n // 2, D1, 0), (n - n // 2, D2, n // 2)):",
"+ for bit in range(1, 1 << m):",
"+ sum_a = 0",
"+ sum_b = 0",
"+ sum_c = 0",
"+ for i in range(m):",
"+ if bit & 1 << i:",
"+ a, b, c = ABC[i + j]",
"+ sum_a += a",
"+ sum_b += b",
"+ sum_c += c",
"+ s = mb * sum_a - ma * sum_b",
"+ if s in D:",
"+ D[s] = min(D[s], sum_c)",
"+ else:",
"+ D[s] = sum_c",
"-if 0 in D:",
"- ans = min(ans, D[0])",
"-if 0 in E:",
"- ans = min(ans, E[0])",
"-for s, c in list(D.items()):",
"- if -s in E:",
"- ans = min(ans, D[s] + E[-s])",
"+if 0 in D1:",
"+ ans = min(ans, D1[0])",
"+if 0 in D2:",
"+ ans = min(ans, D2[0])",
"+for s in D1:",
"+ if -s in D2:",
"+ ans = min(ans, D1[s] + D2[-s])"
] | false | 0.034824 | 0.039461 | 0.882494 | [
"s031878184",
"s288537434"
] |
u995004106 | p02659 | python | s068367071 | s335338496 | 133 | 104 | 72,616 | 72,692 | Accepted | Accepted | 21.8 | import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A,B=list(map(str,input().split()))
#print(A*B)
getcontext().prec=40
A=int(A)
#print(Decimal(A)*Decimal(B))
A=str(A)
A=list(map(int,A))
b=list(str(B))
B=[0]*3
#print(A,b)
N=len(A) #Aの桁数
table=[[0 for _ in range(len(A)+1)] for _ in range(10)]
for i in range(1,10):
career=0
for j in range(N,0,-1):
buf=A[j-1]*i+career
career=buf//10
table[i][j]=buf%10
table[i][0]=career
#print(table)
A=list(A)
A.insert(0,0)
A.insert(len(A),0)
A.insert(len(A),0)
#print(A)
ans=[0]*(len(A))
B=[int(b[0]),int(b[2]),int(b[3])]
#print(B)
#print(ans)
for i in range(2,-1,-1):
piv=B[i]
buf=[]
buf = table[piv]
#print(buf)
career=0
for j in range(N,-1,-1):
num=ans[j+i]+buf[j]+career
career=num//10
ans[j+i]=num%10
#print(ans)
#input()
ans=list(map(str,ans))
s="".join(ans)
print((int(s[:len(s)-2]))) | import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A,B=list(map(str,input().split()))
A=int(A)
B=str(B)
num=int(B[0])*100+int(B[2])*10+int(B[3])
#print(A,num)
print(((A*num)//100))
| 52 | 12 | 1,022 | 234 | import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A, B = list(map(str, input().split()))
# print(A*B)
getcontext().prec = 40
A = int(A)
# print(Decimal(A)*Decimal(B))
A = str(A)
A = list(map(int, A))
b = list(str(B))
B = [0] * 3
# print(A,b)
N = len(A) # Aの桁数
table = [[0 for _ in range(len(A) + 1)] for _ in range(10)]
for i in range(1, 10):
career = 0
for j in range(N, 0, -1):
buf = A[j - 1] * i + career
career = buf // 10
table[i][j] = buf % 10
table[i][0] = career
# print(table)
A = list(A)
A.insert(0, 0)
A.insert(len(A), 0)
A.insert(len(A), 0)
# print(A)
ans = [0] * (len(A))
B = [int(b[0]), int(b[2]), int(b[3])]
# print(B)
# print(ans)
for i in range(2, -1, -1):
piv = B[i]
buf = []
buf = table[piv]
# print(buf)
career = 0
for j in range(N, -1, -1):
num = ans[j + i] + buf[j] + career
career = num // 10
ans[j + i] = num % 10
# print(ans)
# input()
ans = list(map(str, ans))
s = "".join(ans)
print((int(s[: len(s) - 2])))
| import math
import pprint
import fractions
import collections
import itertools
from decimal import *
A, B = list(map(str, input().split()))
A = int(A)
B = str(B)
num = int(B[0]) * 100 + int(B[2]) * 10 + int(B[3])
# print(A,num)
print(((A * num) // 100))
| false | 76.923077 | [
"-# print(A*B)",
"-getcontext().prec = 40",
"-# print(Decimal(A)*Decimal(B))",
"-A = str(A)",
"-A = list(map(int, A))",
"-b = list(str(B))",
"-B = [0] * 3",
"-# print(A,b)",
"-N = len(A) # Aの桁数",
"-table = [[0 for _ in range(len(A) + 1)] for _ in range(10)]",
"-for i in range(1, 10):",
"- career = 0",
"- for j in range(N, 0, -1):",
"- buf = A[j - 1] * i + career",
"- career = buf // 10",
"- table[i][j] = buf % 10",
"- table[i][0] = career",
"-# print(table)",
"-A = list(A)",
"-A.insert(0, 0)",
"-A.insert(len(A), 0)",
"-A.insert(len(A), 0)",
"-# print(A)",
"-ans = [0] * (len(A))",
"-B = [int(b[0]), int(b[2]), int(b[3])]",
"-# print(B)",
"-# print(ans)",
"-for i in range(2, -1, -1):",
"- piv = B[i]",
"- buf = []",
"- buf = table[piv]",
"- # print(buf)",
"- career = 0",
"- for j in range(N, -1, -1):",
"- num = ans[j + i] + buf[j] + career",
"- career = num // 10",
"- ans[j + i] = num % 10",
"- # print(ans)",
"- # input()",
"-ans = list(map(str, ans))",
"-s = \"\".join(ans)",
"-print((int(s[: len(s) - 2])))",
"+B = str(B)",
"+num = int(B[0]) * 100 + int(B[2]) * 10 + int(B[3])",
"+# print(A,num)",
"+print(((A * num) // 100))"
] | false | 0.039452 | 0.035872 | 1.099794 | [
"s068367071",
"s335338496"
] |
u561083515 | p02861 | python | s670209569 | s181065958 | 498 | 406 | 8,180 | 7,972 | Accepted | Accepted | 18.47 | N = int(eval(input()))
xy = [[int(i) for i in input().split()] for _ in range(N)]
from itertools import permutations
states = list(permutations(list(range(N))))
ans = 0
for state in states:
dist = 0
for i,n in enumerate(state):
if i == 0:
prev = xy[n]
continue
now = xy[n]
dist += pow(pow(prev[0]-now[0], 2)+pow(prev[1]-now[1],2),.5)
prev = now
ans += dist
ans /= len(states)
print(ans) | N = int(eval(input()))
xy = [[int(i) for i in input().split()] for _ in range(N)]
from itertools import permutations
from math import sqrt
states = list(permutations(list(range(N))))
ans = 0
for state in states:
dist = 0
for i,n in enumerate(state):
if i == 0:
prev = xy[n]
continue
now = xy[n]
dist += sqrt((prev[0]-now[0]) ** 2+ (prev[1]-now[1]) ** 2)
prev = now
ans += dist
ans /= len(states)
print(ans) | 21 | 22 | 472 | 493 | N = int(eval(input()))
xy = [[int(i) for i in input().split()] for _ in range(N)]
from itertools import permutations
states = list(permutations(list(range(N))))
ans = 0
for state in states:
dist = 0
for i, n in enumerate(state):
if i == 0:
prev = xy[n]
continue
now = xy[n]
dist += pow(pow(prev[0] - now[0], 2) + pow(prev[1] - now[1], 2), 0.5)
prev = now
ans += dist
ans /= len(states)
print(ans)
| N = int(eval(input()))
xy = [[int(i) for i in input().split()] for _ in range(N)]
from itertools import permutations
from math import sqrt
states = list(permutations(list(range(N))))
ans = 0
for state in states:
dist = 0
for i, n in enumerate(state):
if i == 0:
prev = xy[n]
continue
now = xy[n]
dist += sqrt((prev[0] - now[0]) ** 2 + (prev[1] - now[1]) ** 2)
prev = now
ans += dist
ans /= len(states)
print(ans)
| false | 4.545455 | [
"+from math import sqrt",
"- dist += pow(pow(prev[0] - now[0], 2) + pow(prev[1] - now[1], 2), 0.5)",
"+ dist += sqrt((prev[0] - now[0]) ** 2 + (prev[1] - now[1]) ** 2)"
] | false | 0.044348 | 0.044621 | 0.993883 | [
"s670209569",
"s181065958"
] |
u644907318 | p03476 | python | s393145645 | s517104110 | 1,084 | 424 | 55,108 | 86,412 | Accepted | Accepted | 60.89 | INFTY = 10**5+1
P = [1 for _ in range(INFTY)]
P[0]=P[1]=0
for i in range(2,int(INFTY**0.5)+1):
for j in range(i*i,INFTY,i):
P[j] = 0
R = [0 for _ in range(INFTY)]
for i in range(INFTY):
if i%2==1:
if P[i]==1 and P[(i+1)//2]==1:
R[i] = 1
A = [0 for _ in range(INFTY+1)]
for i in range(INFTY):
A[i+1] = A[i]+R[i]
Q = int(eval(input()))
for _ in range(Q):
l,r = list(map(int,input().split()))
print((A[r+1]-A[l])) | P = [1 for _ in range(10**5)]
P[0]=0
P[1]=0
for i in range(2,int((10**5)**0.5)+1):
for j in range(i*i,10**5,i):
P[j]=0
Q = []
for i in range(3,10**5,2):
if P[i]==1 and P[(i+1)//2]==1:
Q.append(i)
A = [0 for _ in range(10**5+1)]
for q in Q:
A[q] = 1
for i in range(1,10**5+1):
A[i] += A[i-1]
Q = int(eval(input()))
for _ in range(Q):
l,r = list(map(int,input().split()))
print((A[r]-A[l-1])) | 18 | 19 | 461 | 434 | INFTY = 10**5 + 1
P = [1 for _ in range(INFTY)]
P[0] = P[1] = 0
for i in range(2, int(INFTY**0.5) + 1):
for j in range(i * i, INFTY, i):
P[j] = 0
R = [0 for _ in range(INFTY)]
for i in range(INFTY):
if i % 2 == 1:
if P[i] == 1 and P[(i + 1) // 2] == 1:
R[i] = 1
A = [0 for _ in range(INFTY + 1)]
for i in range(INFTY):
A[i + 1] = A[i] + R[i]
Q = int(eval(input()))
for _ in range(Q):
l, r = list(map(int, input().split()))
print((A[r + 1] - A[l]))
| P = [1 for _ in range(10**5)]
P[0] = 0
P[1] = 0
for i in range(2, int((10**5) ** 0.5) + 1):
for j in range(i * i, 10**5, i):
P[j] = 0
Q = []
for i in range(3, 10**5, 2):
if P[i] == 1 and P[(i + 1) // 2] == 1:
Q.append(i)
A = [0 for _ in range(10**5 + 1)]
for q in Q:
A[q] = 1
for i in range(1, 10**5 + 1):
A[i] += A[i - 1]
Q = int(eval(input()))
for _ in range(Q):
l, r = list(map(int, input().split()))
print((A[r] - A[l - 1]))
| false | 5.263158 | [
"-INFTY = 10**5 + 1",
"-P = [1 for _ in range(INFTY)]",
"-P[0] = P[1] = 0",
"-for i in range(2, int(INFTY**0.5) + 1):",
"- for j in range(i * i, INFTY, i):",
"+P = [1 for _ in range(10**5)]",
"+P[0] = 0",
"+P[1] = 0",
"+for i in range(2, int((10**5) ** 0.5) + 1):",
"+ for j in range(i * i, 10**5, i):",
"-R = [0 for _ in range(INFTY)]",
"-for i in range(INFTY):",
"- if i % 2 == 1:",
"- if P[i] == 1 and P[(i + 1) // 2] == 1:",
"- R[i] = 1",
"-A = [0 for _ in range(INFTY + 1)]",
"-for i in range(INFTY):",
"- A[i + 1] = A[i] + R[i]",
"+Q = []",
"+for i in range(3, 10**5, 2):",
"+ if P[i] == 1 and P[(i + 1) // 2] == 1:",
"+ Q.append(i)",
"+A = [0 for _ in range(10**5 + 1)]",
"+for q in Q:",
"+ A[q] = 1",
"+for i in range(1, 10**5 + 1):",
"+ A[i] += A[i - 1]",
"- print((A[r + 1] - A[l]))",
"+ print((A[r] - A[l - 1]))"
] | false | 0.226159 | 0.28054 | 0.806155 | [
"s393145645",
"s517104110"
] |
u532966492 | p02868 | python | s330849926 | s603100357 | 1,616 | 1,002 | 93,272 | 79,072 | Accepted | Accepted | 38 | def main():
class segtree():
def __init__(self,base,monoid,ini):#self,モノイド,元の配列
#ini：上限（下限）,base：元の配列,monoid：モノイド,tree：セグ木,depth：treeの深さ,
#basesize：baseの要素数,treesize：treeの要素数,num：treesize-basesize
# 初期値（上限とか下限）を決定
self.ini=ini
#セグ木の要素数（num）および深さ（depth）を計算
self.base=base
self.basesize=len(self.base)
self.num,self.depth=1,1
while self.num<self.basesize:
self.num*=2
self.depth+=1
self.num-=1
#関数（モノイド、今回はmin）を設定
self.monoid=monoid
#セグ木を構築
self.treesize=self.num+self.basesize
self.tree=[None]*self.treesize
#segtree[m]以降に代入したい配列を入力していく
for i in range(self.num, self.treesize):self.tree[i]=self.base[i-self.num]
#segtree[m]以降の情報を使って、0に向かってセグ木を構築していく
for i in range(self.num-1,-1,-1):
j=2*i+1
if j>=self.treesize:self.tree[i]=self.ini
else:self.tree[i]=self.monoid(self.tree[j],self.tree[min(j+1,self.treesize-1)])
#条件を満たす(サンプルの条件はs以下になること)最大のインデックスを返す関数
def max_index(self,index_func):
#探していく
i=0
while i<self.num:
k=2*i+1
if k+1<self.treesize:
if index_func(self.tree[k+1]):
i=k+1
continue
if k<self.treesize:
if index_func(self.tree[k]):
i=k
continue
return -1
return i-self.num
#条件を満たす(サンプルの条件はs以下になること)最小のインデックスを返す関数
def min_index(self,index_func):
#探していく
i=0
while i<self.num:
k=2*i+1
if k<self.treesize:
if index_func(self.tree[k]):
i=k
continue
if k+1<self.treesize:
if index_func(self.tree[k+1]):
i=k+1
continue
return -1
return i-self.num
#半開区間[lower,upper)の最小値（とか）を探す関数
def search(self,lower,upper):
q=[[0,1]] #インデックス、階層
#返り値を初期化
ret=self.ini
while q:
i,f=q.pop()
#popしたインデックスと階層から、求める下限と上限を算出する
#幅
width=pow(2,self.depth-f)
#下限と中央と上限
kagen=(i-pow(2,f-1)+1)*width
chuo=kagen+width//2
jogen=kagen+width
k=2*i+1
if lower<=kagen and jogen<=upper:
ret=self.monoid(ret,self.tree[i])
continue
if k<self.treesize:
if lower<=kagen and chuo<=upper:ret=self.monoid(ret,self.tree[k])
elif lower<=chuo:q.append([k,f+1])
if k+1<self.treesize:
if lower<=chuo and jogen<=upper:ret=self.monoid(ret,self.tree[k+1])
elif chuo<=upper:q.append([k+1,f+1])
return ret
#base[i]をsに更新したときにセグ木全体を更新する関数
def update(self,index,new_value):
i=index+self.num
self.tree[i]=new_value
temp=new_value
while i!=0:
k=(i-1)//2
if i%2==1:
temp=self.monoid(self.tree[min(i+1,self.treesize-1)],temp)
else:
temp=self.monoid(self.tree[i-1],temp)
if self.tree[k]!=temp:
self.tree[k]=temp
i=k
continue
break
n,m=list(map(int,input().split()))
lrc=[list(map(int,input().split())) for _ in [0]*m]
lrc.sort(key=lambda x:x[1])
t=segtree([10**15]*n,min,10**15)
t.update(0,0)
for l,r,c in lrc:
t.update(r-1,min(t.search(r-1,r),t.search(l-1,n)+c))
tt=t.search(n-1,n)
if tt==10**15:
print((-1))
return 0
print(tt)
main() | def main():
from sys import stdin
input = stdin.readline
import numpy as np
n, m = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in [0]*m]
g = [[] for _ in [0]*n]
[g[u-1].append([v-1, c]) for u, v, c in abc]
[g[i+1].append([i, 0]) for i in range(n-1)]
import heapq
yen = np.full(n, np.inf)
h = [(0, 0)]
heapq.heapify(h)
while h:
d, i = heapq.heappop(h)
if yen[i] == np.inf:
yen[i] = d
for x, y in g[i]:
heapq.heappush(h, (d+y, x))
if yen[n-1] == np.inf:
print((-1))
return 0
print((int(yen[n-1])))
main() | 119 | 29 | 4,269 | 690 | def main():
class segtree:
def __init__(self, base, monoid, ini): # self,モノイド,元の配列
# ini：上限（下限）,base：元の配列,monoid：モノイド,tree：セグ木,depth：treeの深さ,
# basesize：baseの要素数,treesize：treeの要素数,num：treesize-basesize
# 初期値（上限とか下限）を決定
self.ini = ini
# セグ木の要素数（num）および深さ（depth）を計算
self.base = base
self.basesize = len(self.base)
self.num, self.depth = 1, 1
while self.num < self.basesize:
self.num *= 2
self.depth += 1
self.num -= 1
# 関数（モノイド、今回はmin）を設定
self.monoid = monoid
# セグ木を構築
self.treesize = self.num + self.basesize
self.tree = [None] * self.treesize
# segtree[m]以降に代入したい配列を入力していく
for i in range(self.num, self.treesize):
self.tree[i] = self.base[i - self.num]
# segtree[m]以降の情報を使って、0に向かってセグ木を構築していく
for i in range(self.num - 1, -1, -1):
j = 2 * i + 1
if j >= self.treesize:
self.tree[i] = self.ini
else:
self.tree[i] = self.monoid(
self.tree[j], self.tree[min(j + 1, self.treesize - 1)]
)
# 条件を満たす(サンプルの条件はs以下になること)最大のインデックスを返す関数
def max_index(self, index_func):
# 探していく
i = 0
while i < self.num:
k = 2 * i + 1
if k + 1 < self.treesize:
if index_func(self.tree[k + 1]):
i = k + 1
continue
if k < self.treesize:
if index_func(self.tree[k]):
i = k
continue
return -1
return i - self.num
# 条件を満たす(サンプルの条件はs以下になること)最小のインデックスを返す関数
def min_index(self, index_func):
# 探していく
i = 0
while i < self.num:
k = 2 * i + 1
if k < self.treesize:
if index_func(self.tree[k]):
i = k
continue
if k + 1 < self.treesize:
if index_func(self.tree[k + 1]):
i = k + 1
continue
return -1
return i - self.num
# 半開区間[lower,upper)の最小値（とか）を探す関数
def search(self, lower, upper):
q = [[0, 1]] # インデックス、階層
# 返り値を初期化
ret = self.ini
while q:
i, f = q.pop()
# popしたインデックスと階層から、求める下限と上限を算出する
# 幅
width = pow(2, self.depth - f)
# 下限と中央と上限
kagen = (i - pow(2, f - 1) + 1) * width
chuo = kagen + width // 2
jogen = kagen + width
k = 2 * i + 1
if lower <= kagen and jogen <= upper:
ret = self.monoid(ret, self.tree[i])
continue
if k < self.treesize:
if lower <= kagen and chuo <= upper:
ret = self.monoid(ret, self.tree[k])
elif lower <= chuo:
q.append([k, f + 1])
if k + 1 < self.treesize:
if lower <= chuo and jogen <= upper:
ret = self.monoid(ret, self.tree[k + 1])
elif chuo <= upper:
q.append([k + 1, f + 1])
return ret
# base[i]をsに更新したときにセグ木全体を更新する関数
def update(self, index, new_value):
i = index + self.num
self.tree[i] = new_value
temp = new_value
while i != 0:
k = (i - 1) // 2
if i % 2 == 1:
temp = self.monoid(self.tree[min(i + 1, self.treesize - 1)], temp)
else:
temp = self.monoid(self.tree[i - 1], temp)
if self.tree[k] != temp:
self.tree[k] = temp
i = k
continue
break
n, m = list(map(int, input().split()))
lrc = [list(map(int, input().split())) for _ in [0] * m]
lrc.sort(key=lambda x: x[1])
t = segtree([10**15] * n, min, 10**15)
t.update(0, 0)
for l, r, c in lrc:
t.update(r - 1, min(t.search(r - 1, r), t.search(l - 1, n) + c))
tt = t.search(n - 1, n)
if tt == 10**15:
print((-1))
return 0
print(tt)
main()
| def main():
from sys import stdin
input = stdin.readline
import numpy as np
n, m = list(map(int, input().split()))
abc = [list(map(int, input().split())) for _ in [0] * m]
g = [[] for _ in [0] * n]
[g[u - 1].append([v - 1, c]) for u, v, c in abc]
[g[i + 1].append([i, 0]) for i in range(n - 1)]
import heapq
yen = np.full(n, np.inf)
h = [(0, 0)]
heapq.heapify(h)
while h:
d, i = heapq.heappop(h)
if yen[i] == np.inf:
yen[i] = d
for x, y in g[i]:
heapq.heappush(h, (d + y, x))
if yen[n - 1] == np.inf:
print((-1))
return 0
print((int(yen[n - 1])))
main()
| false | 75.630252 | [
"- class segtree:",
"- def __init__(self, base, monoid, ini): # self,モノイド,元の配列",
"- # ini：上限（下限）,base：元の配列,monoid：モノイド,tree：セグ木,depth：treeの深さ,",
"- # basesize：baseの要素数,treesize：treeの要素数,num：treesize-basesize",
"- # 初期値（上限とか下限）を決定",
"- self.ini = ini",
"- # セグ木の要素数（num）および深さ（depth）を計算",
"- self.base = base",
"- self.basesize = len(self.base)",
"- self.num, self.depth = 1, 1",
"- while self.num < self.basesize:",
"- self.num *= 2",
"- self.depth += 1",
"- self.num -= 1",
"- # 関数（モノイド、今回はmin）を設定",
"- self.monoid = monoid",
"- # セグ木を構築",
"- self.treesize = self.num + self.basesize",
"- self.tree = [None] * self.treesize",
"- # segtree[m]以降に代入したい配列を入力していく",
"- for i in range(self.num, self.treesize):",
"- self.tree[i] = self.base[i - self.num]",
"- # segtree[m]以降の情報を使って、0に向かってセグ木を構築していく",
"- for i in range(self.num - 1, -1, -1):",
"- j = 2 * i + 1",
"- if j >= self.treesize:",
"- self.tree[i] = self.ini",
"- else:",
"- self.tree[i] = self.monoid(",
"- self.tree[j], self.tree[min(j + 1, self.treesize - 1)]",
"- )",
"+ from sys import stdin",
"- # 条件を満たす(サンプルの条件はs以下になること)最大のインデックスを返す関数",
"- def max_index(self, index_func):",
"- # 探していく",
"- i = 0",
"- while i < self.num:",
"- k = 2 * i + 1",
"- if k + 1 < self.treesize:",
"- if index_func(self.tree[k + 1]):",
"- i = k + 1",
"- continue",
"- if k < self.treesize:",
"- if index_func(self.tree[k]):",
"- i = k",
"- continue",
"- return -1",
"- return i - self.num",
"-",
"- # 条件を満たす(サンプルの条件はs以下になること)最小のインデックスを返す関数",
"- def min_index(self, index_func):",
"- # 探していく",
"- i = 0",
"- while i < self.num:",
"- k = 2 * i + 1",
"- if k < self.treesize:",
"- if index_func(self.tree[k]):",
"- i = k",
"- continue",
"- if k + 1 < self.treesize:",
"- if index_func(self.tree[k + 1]):",
"- i = k + 1",
"- continue",
"- return -1",
"- return i - self.num",
"-",
"- # 半開区間[lower,upper)の最小値（とか）を探す関数",
"- def search(self, lower, upper):",
"- q = [[0, 1]] # インデックス、階層",
"- # 返り値を初期化",
"- ret = self.ini",
"- while q:",
"- i, f = q.pop()",
"- # popしたインデックスと階層から、求める下限と上限を算出する",
"- # 幅",
"- width = pow(2, self.depth - f)",
"- # 下限と中央と上限",
"- kagen = (i - pow(2, f - 1) + 1) * width",
"- chuo = kagen + width // 2",
"- jogen = kagen + width",
"- k = 2 * i + 1",
"- if lower <= kagen and jogen <= upper:",
"- ret = self.monoid(ret, self.tree[i])",
"- continue",
"- if k < self.treesize:",
"- if lower <= kagen and chuo <= upper:",
"- ret = self.monoid(ret, self.tree[k])",
"- elif lower <= chuo:",
"- q.append([k, f + 1])",
"- if k + 1 < self.treesize:",
"- if lower <= chuo and jogen <= upper:",
"- ret = self.monoid(ret, self.tree[k + 1])",
"- elif chuo <= upper:",
"- q.append([k + 1, f + 1])",
"- return ret",
"-",
"- # base[i]をsに更新したときにセグ木全体を更新する関数",
"- def update(self, index, new_value):",
"- i = index + self.num",
"- self.tree[i] = new_value",
"- temp = new_value",
"- while i != 0:",
"- k = (i - 1) // 2",
"- if i % 2 == 1:",
"- temp = self.monoid(self.tree[min(i + 1, self.treesize - 1)], temp)",
"- else:",
"- temp = self.monoid(self.tree[i - 1], temp)",
"- if self.tree[k] != temp:",
"- self.tree[k] = temp",
"- i = k",
"- continue",
"- break",
"+ input = stdin.readline",
"+ import numpy as np",
"- lrc = [list(map(int, input().split())) for _ in [0] * m]",
"- lrc.sort(key=lambda x: x[1])",
"- t = segtree([10**15] * n, min, 10**15)",
"- t.update(0, 0)",
"- for l, r, c in lrc:",
"- t.update(r - 1, min(t.search(r - 1, r), t.search(l - 1, n) + c))",
"- tt = t.search(n - 1, n)",
"- if tt == 10**15:",
"+ abc = [list(map(int, input().split())) for _ in [0] * m]",
"+ g = [[] for _ in [0] * n]",
"+ [g[u - 1].append([v - 1, c]) for u, v, c in abc]",
"+ [g[i + 1].append([i, 0]) for i in range(n - 1)]",
"+ import heapq",
"+",
"+ yen = np.full(n, np.inf)",
"+ h = [(0, 0)]",
"+ heapq.heapify(h)",
"+ while h:",
"+ d, i = heapq.heappop(h)",
"+ if yen[i] == np.inf:",
"+ yen[i] = d",
"+ for x, y in g[i]:",
"+ heapq.heappush(h, (d + y, x))",
"+ if yen[n - 1] == np.inf:",
"- print(tt)",
"+ print((int(yen[n - 1])))"
] | false | 0.039354 | 0.177309 | 0.221953 | [
"s330849926",
"s603100357"
] |
u367701763 | p02702 | python | s631340416 | s969408143 | 161 | 86 | 83,608 | 82,820 | Accepted | Accepted | 46.58 | # https://atcoder.jp/contests/abc164/tasks/abc164_d
from operator import mul
from functools import reduce
from collections import defaultdict
def combination(n, r):
if not 0 <= r <= n: return 0
r = min(r, n - r)
numer = reduce(mul, list(range(n, n - r, -1)), 1)
denom = reduce(mul, list(range(1, r + 1)), 1)
return numer // denom
S = eval(input())
res = 0
T = [0]
x = 0
L = len(S)
for i, s in zip(list(range(L)),reversed(S)):
""" 累積和 """
x = (int(s)*pow(10,i,2019) + x)%2019
T.append(x)
reminder = [0]*2019
for i in range(L+1):
reminder[T[i]%2019] += 1
for c in reminder:
res += combination(c,2)
print(res) | # https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
T = [0]
x = 0
p = 1
L = len(S)
MOD = 2019
for i, s in zip(list(range(L)),reversed(S)):
""" 累積和 """
x = (int(s)*p + x)%MOD
p = p*10%MOD
T.append(x)
reminder = [0]*2019
for i in range(L+1):
reminder[T[i]%MOD] += 1
for c in reminder:
res += c*(c-1)//2
print(res) | 33 | 29 | 662 | 432 | # https://atcoder.jp/contests/abc164/tasks/abc164_d
from operator import mul
from functools import reduce
from collections import defaultdict
def combination(n, r):
if not 0 <= r <= n:
return 0
r = min(r, n - r)
numer = reduce(mul, list(range(n, n - r, -1)), 1)
denom = reduce(mul, list(range(1, r + 1)), 1)
return numer // denom
S = eval(input())
res = 0
T = [0]
x = 0
L = len(S)
for i, s in zip(list(range(L)), reversed(S)):
"""累積和"""
x = (int(s) * pow(10, i, 2019) + x) % 2019
T.append(x)
reminder = [0] * 2019
for i in range(L + 1):
reminder[T[i] % 2019] += 1
for c in reminder:
res += combination(c, 2)
print(res)
| # https://atcoder.jp/contests/abc164/tasks/abc164_d
import sys
input = sys.stdin.readline
S = input().rstrip()
res = 0
T = [0]
x = 0
p = 1
L = len(S)
MOD = 2019
for i, s in zip(list(range(L)), reversed(S)):
"""累積和"""
x = (int(s) * p + x) % MOD
p = p * 10 % MOD
T.append(x)
reminder = [0] * 2019
for i in range(L + 1):
reminder[T[i] % MOD] += 1
for c in reminder:
res += c * (c - 1) // 2
print(res)
| false | 12.121212 | [
"-from operator import mul",
"-from functools import reduce",
"-from collections import defaultdict",
"+import sys",
"-",
"-def combination(n, r):",
"- if not 0 <= r <= n:",
"- return 0",
"- r = min(r, n - r)",
"- numer = reduce(mul, list(range(n, n - r, -1)), 1)",
"- denom = reduce(mul, list(range(1, r + 1)), 1)",
"- return numer // denom",
"-",
"-",
"-S = eval(input())",
"+input = sys.stdin.readline",
"+S = input().rstrip()",
"+p = 1",
"+MOD = 2019",
"- x = (int(s) * pow(10, i, 2019) + x) % 2019",
"+ x = (int(s) * p + x) % MOD",
"+ p = p * 10 % MOD",
"- reminder[T[i] % 2019] += 1",
"+ reminder[T[i] % MOD] += 1",
"- res += combination(c, 2)",
"+ res += c * (c - 1) // 2"
] | false | 0.034018 | 0.063813 | 0.533085 | [
"s631340416",
"s969408143"
] |
u788703383 | p03628 | python | s260706529 | s391315031 | 182 | 167 | 38,408 | 38,384 | Accepted | Accepted | 8.24 | MOD = 10**9+7
n = int(eval(input()))
s = eval(input())
p = eval(input())
ans = 0
f = 0
i = 0
while i < n:
if i > n:break
if s[i] == p[i]:
if i == 0:
ans = 3
else:
if f == 1:
ans *= 1
else:
ans *= 2
f = 0
else:
if i == 0:
ans = 6
else:
if f == 1:
ans *= 3
else:
ans *= 2
f = 1
i += 1
i += 1
ans %= MOD
print((ans%MOD))
| MOD = 10**9+7
n = int(eval(input()))
s = eval(input())
p = eval(input())
ans = 0
f = 0
i = 0
two = False
while i < n:
if i == 0:
if s[i] == p[i]:
ans = 3
else:
ans = 6
i += 1
two = True
i += 1
continue
if i >= n:break
if s[i] == p[i]:
if two:
pass
else:
ans *= 2
two = False
else:
if two:
ans *= 3
else:
ans *= 2
two = True
i += 1
i += 1
ans %= MOD
print(ans)
| 31 | 35 | 540 | 584 | MOD = 10**9 + 7
n = int(eval(input()))
s = eval(input())
p = eval(input())
ans = 0
f = 0
i = 0
while i < n:
if i > n:
break
if s[i] == p[i]:
if i == 0:
ans = 3
else:
if f == 1:
ans *= 1
else:
ans *= 2
f = 0
else:
if i == 0:
ans = 6
else:
if f == 1:
ans *= 3
else:
ans *= 2
f = 1
i += 1
i += 1
ans %= MOD
print((ans % MOD))
| MOD = 10**9 + 7
n = int(eval(input()))
s = eval(input())
p = eval(input())
ans = 0
f = 0
i = 0
two = False
while i < n:
if i == 0:
if s[i] == p[i]:
ans = 3
else:
ans = 6
i += 1
two = True
i += 1
continue
if i >= n:
break
if s[i] == p[i]:
if two:
pass
else:
ans *= 2
two = False
else:
if two:
ans *= 3
else:
ans *= 2
two = True
i += 1
i += 1
ans %= MOD
print(ans)
| false | 11.428571 | [
"+two = False",
"- if i > n:",
"+ if i == 0:",
"+ if s[i] == p[i]:",
"+ ans = 3",
"+ else:",
"+ ans = 6",
"+ i += 1",
"+ two = True",
"+ i += 1",
"+ continue",
"+ if i >= n:",
"- if i == 0:",
"- ans = 3",
"+ if two:",
"+ pass",
"- if f == 1:",
"- ans *= 1",
"- else:",
"- ans *= 2",
"- f = 0",
"+ ans *= 2",
"+ two = False",
"- if i == 0:",
"- ans = 6",
"+ if two:",
"+ ans *= 3",
"- if f == 1:",
"- ans *= 3",
"- else:",
"- ans *= 2",
"- f = 1",
"+ ans *= 2",
"+ two = True",
"-print((ans % MOD))",
"+print(ans)"
] | false | 0.037792 | 0.067794 | 0.557448 | [
"s260706529",
"s391315031"
] |
u124498235 | p03680 | python | s139764103 | s683686713 | 210 | 185 | 7,884 | 7,084 | Accepted | Accepted | 11.9 | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
chk = [False for i in range(n)]
c = 0
d = 0
while True:
if chk[c]:
print((-1))
exit()
else:
chk[c] = True
if c == 1:
print (d)
exit()
c = a[c]-1
d += 1 | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
c = a[0]
for i in range(n):
if c == 2:
print((i+1))
exit()
c = a[c-1]
print((-1)) | 17 | 10 | 239 | 149 | n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
chk = [False for i in range(n)]
c = 0
d = 0
while True:
if chk[c]:
print((-1))
exit()
else:
chk[c] = True
if c == 1:
print(d)
exit()
c = a[c] - 1
d += 1
| n = int(eval(input()))
a = [int(eval(input())) for i in range(n)]
c = a[0]
for i in range(n):
if c == 2:
print((i + 1))
exit()
c = a[c - 1]
print((-1))
| false | 41.176471 | [
"-chk = [False for i in range(n)]",
"-c = 0",
"-d = 0",
"-while True:",
"- if chk[c]:",
"- print((-1))",
"+c = a[0]",
"+for i in range(n):",
"+ if c == 2:",
"+ print((i + 1))",
"- else:",
"- chk[c] = True",
"- if c == 1:",
"- print(d)",
"- exit()",
"- c = a[c] - 1",
"- d += 1",
"+ c = a[c - 1]",
"+print((-1))"
] | false | 0.048161 | 0.04402 | 1.094061 | [
"s139764103",
"s683686713"
] |
u576917603 | p02813 | python | s288267979 | s337055716 | 57 | 33 | 15,092 | 8,052 | Accepted | Accepted | 42.11 | n=int(eval(input()))
a=list(map(int,input().split()))
b=list(map(int,input().split()))
aa=()
import itertools
c=list(itertools.permutations(list(range(1,n+1))))
cc=[]
for i in c:
cc.append(list(i))
for x,i in enumerate(cc):
if a==i:
aa=x
if b==i:
bb=x
print((abs(aa-bb))) | n=int(eval(input()))
a=tuple([int(x)-1 for x in input().split()])
b=tuple([int(x)-1 for x in input().split()])
import itertools as it
pe=list(it.permutations(list(range(n)),n))
x,y=0,0
for ind,i in enumerate(pe):
if i==a:
x=ind
if i==b:
y=ind
print((abs(x-y))) | 15 | 14 | 299 | 291 | n = int(eval(input()))
a = list(map(int, input().split()))
b = list(map(int, input().split()))
aa = ()
import itertools
c = list(itertools.permutations(list(range(1, n + 1))))
cc = []
for i in c:
cc.append(list(i))
for x, i in enumerate(cc):
if a == i:
aa = x
if b == i:
bb = x
print((abs(aa - bb)))
| n = int(eval(input()))
a = tuple([int(x) - 1 for x in input().split()])
b = tuple([int(x) - 1 for x in input().split()])
import itertools as it
pe = list(it.permutations(list(range(n)), n))
x, y = 0, 0
for ind, i in enumerate(pe):
if i == a:
x = ind
if i == b:
y = ind
print((abs(x - y)))
| false | 6.666667 | [
"-a = list(map(int, input().split()))",
"-b = list(map(int, input().split()))",
"-aa = ()",
"-import itertools",
"+a = tuple([int(x) - 1 for x in input().split()])",
"+b = tuple([int(x) - 1 for x in input().split()])",
"+import itertools as it",
"-c = list(itertools.permutations(list(range(1, n + 1))))",
"-cc = []",
"-for i in c:",
"- cc.append(list(i))",
"-for x, i in enumerate(cc):",
"- if a == i:",
"- aa = x",
"- if b == i:",
"- bb = x",
"-print((abs(aa - bb)))",
"+pe = list(it.permutations(list(range(n)), n))",
"+x, y = 0, 0",
"+for ind, i in enumerate(pe):",
"+ if i == a:",
"+ x = ind",
"+ if i == b:",
"+ y = ind",
"+print((abs(x - y)))"
] | false | 0.043869 | 0.034287 | 1.279456 | [
"s288267979",
"s337055716"
] |
u239917977 | p03160 | python | s498289036 | s373276350 | 246 | 156 | 52,028 | 13,868 | Accepted | Accepted | 36.59 | def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf]*N
dp[0] = 0
step1, step2 = inf, inf
for i in range(1, N):
step1 = abs(H[i-1]-H[i]) + dp[i-1]
if i >= 2:
step2 = abs(H[i-2]-H[i]) + dp[i-2]
step = min(step1, step2)
dp[i] = min(dp[i], step)
print((dp[-1]))
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf]*N
dp[0] = 0
for i in range(N-1):
dp[i+1] = min(dp[i+1], dp[i] + abs(H[i+1]-H[i]))
if i != N-2:
dp[i+2] = min(dp[i+2], dp[i] + abs(H[i+2]-H[i]))
print((dp[-1]))
if __name__ == "__main__":
main()
| 25 | 21 | 489 | 419 | def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf] * N
dp[0] = 0
step1, step2 = inf, inf
for i in range(1, N):
step1 = abs(H[i - 1] - H[i]) + dp[i - 1]
if i >= 2:
step2 = abs(H[i - 2] - H[i]) + dp[i - 2]
step = min(step1, step2)
dp[i] = min(dp[i], step)
print((dp[-1]))
if __name__ == "__main__":
main()
| def main():
import sys
input = sys.stdin.readline
N = int(eval(input()))
H = list(map(int, input().split()))
inf = float("inf")
dp = [inf] * N
dp[0] = 0
for i in range(N - 1):
dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i + 1] - H[i]))
if i != N - 2:
dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i + 2] - H[i]))
print((dp[-1]))
if __name__ == "__main__":
main()
| false | 16 | [
"- step1, step2 = inf, inf",
"- for i in range(1, N):",
"- step1 = abs(H[i - 1] - H[i]) + dp[i - 1]",
"- if i >= 2:",
"- step2 = abs(H[i - 2] - H[i]) + dp[i - 2]",
"- step = min(step1, step2)",
"- dp[i] = min(dp[i], step)",
"+ for i in range(N - 1):",
"+ dp[i + 1] = min(dp[i + 1], dp[i] + abs(H[i + 1] - H[i]))",
"+ if i != N - 2:",
"+ dp[i + 2] = min(dp[i + 2], dp[i] + abs(H[i + 2] - H[i]))"
] | false | 0.03599 | 0.041972 | 0.857465 | [
"s498289036",
"s373276350"
] |
u952656646 | p03031 | python | s326160391 | s222399413 | 156 | 37 | 12,396 | 9,140 | Accepted | Accepted | 76.28 | import numpy as np
N, M = list(map(int, input().split()))
D = [0]*M
for i in range(M):
temp = list(map(int, input().split()))
for j in temp[1:]:
D[i] += 2**(j-1)
p = list(map(int, input().split()))
ans = 0
for s in range(2**N):
temp = True
for i,d in enumerate(D):
temp &= bin(s&d).count('1')%2==p[i]
if temp:
ans += 1
print(ans) | N, M = list(map(int, input().split()))
S = [0]*M
for i in range(M):
s = list(map(int, input().split()))
for j in s[1:]:
S[i] += 2**(j-1)
p = list(map(int, input().split()))
ans = 0
for b in range(2**N):
tmp = True
for i, s in enumerate(S):
tmp &= bin(b&s).count('1')%2==p[i]
if tmp:
ans += 1
print(ans) | 16 | 15 | 383 | 354 | import numpy as np
N, M = list(map(int, input().split()))
D = [0] * M
for i in range(M):
temp = list(map(int, input().split()))
for j in temp[1:]:
D[i] += 2 ** (j - 1)
p = list(map(int, input().split()))
ans = 0
for s in range(2**N):
temp = True
for i, d in enumerate(D):
temp &= bin(s & d).count("1") % 2 == p[i]
if temp:
ans += 1
print(ans)
| N, M = list(map(int, input().split()))
S = [0] * M
for i in range(M):
s = list(map(int, input().split()))
for j in s[1:]:
S[i] += 2 ** (j - 1)
p = list(map(int, input().split()))
ans = 0
for b in range(2**N):
tmp = True
for i, s in enumerate(S):
tmp &= bin(b & s).count("1") % 2 == p[i]
if tmp:
ans += 1
print(ans)
| false | 6.25 | [
"-import numpy as np",
"-",
"-D = [0] * M",
"+S = [0] * M",
"- temp = list(map(int, input().split()))",
"- for j in temp[1:]:",
"- D[i] += 2 ** (j - 1)",
"+ s = list(map(int, input().split()))",
"+ for j in s[1:]:",
"+ S[i] += 2 ** (j - 1)",
"-for s in range(2**N):",
"- temp = True",
"- for i, d in enumerate(D):",
"- temp &= bin(s & d).count(\"1\") % 2 == p[i]",
"- if temp:",
"+for b in range(2**N):",
"+ tmp = True",
"+ for i, s in enumerate(S):",
"+ tmp &= bin(b & s).count(\"1\") % 2 == p[i]",
"+ if tmp:"
] | false | 0.047107 | 0.006732 | 6.997255 | [
"s326160391",
"s222399413"
] |
u357751375 | p03835 | python | s711399508 | s723106907 | 1,315 | 1,192 | 9,116 | 9,052 | Accepted | Accepted | 9.35 | k,s = list(map(int,input().split()))
t = 0
for i in range(k+1):
for j in range(k+1):
if k >= s - i - j and 0 <= s - i - j:
t += 1
print(t) | k,s = list(map(int,input().split()))
ans = 0
for x in range(k+1):
for y in range(k+1):
z = s - (x + y)
if 0 <= z <= k:
ans += 1
print(ans) | 9 | 8 | 166 | 171 | k, s = list(map(int, input().split()))
t = 0
for i in range(k + 1):
for j in range(k + 1):
if k >= s - i - j and 0 <= s - i - j:
t += 1
print(t)
| k, s = list(map(int, input().split()))
ans = 0
for x in range(k + 1):
for y in range(k + 1):
z = s - (x + y)
if 0 <= z <= k:
ans += 1
print(ans)
| false | 11.111111 | [
"-t = 0",
"-for i in range(k + 1):",
"- for j in range(k + 1):",
"- if k >= s - i - j and 0 <= s - i - j:",
"- t += 1",
"-print(t)",
"+ans = 0",
"+for x in range(k + 1):",
"+ for y in range(k + 1):",
"+ z = s - (x + y)",
"+ if 0 <= z <= k:",
"+ ans += 1",
"+print(ans)"
] | false | 0.113196 | 0.040837 | 2.771885 | [
"s711399508",
"s723106907"
] |
u554784585 | p02959 | python | s882749976 | s051147378 | 315 | 214 | 24,832 | 24,252 | Accepted | Accepted | 32.06 | N=int(eval(input()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
ans=0
for i in range(N):
if i%2==0:
if A[int(i/2)]>=B[int(i/2)]:
A[int(i/2)]-=B[int(i/2)]
ans+=B[int(i/2)]
B[int(i/2)]=0
else:
B[int(i/2)]-=A[int(i/2)]
ans+=A[int(i/2)]
A[int(i/2)]=0
if A[int(i/2)+1]>=B[int(i/2)]:
A[int(i/2)+1]-=B[int(i/2)]
ans+=B[int(i/2)]
B[int(i/2)]=0
else:
B[int(i/2)]-=A[int(i/2)+1]
ans+=A[int(i/2)+1]
A[int(i/2)+1]=0
else:
if A[N-int(i/2)]>=B[N-int(i/2)-1]:
A[N-int(i/2)]-=B[N-int(i/2)-1]
ans+=B[N-int(i/2)-1]
B[N-int(i/2)-1]=0
else:
B[N-int(i/2)-1]-=A[N-int(i/2)]
ans+=A[N-int(i/2)]
A[N-int(i/2)]=0
if A[N-int(i/2)-1]>=B[N-int(i/2)-1]:
A[N-int(i/2)-1]-=B[N-int(i/2)-1]
ans+=B[N-int(i/2)-1]
B[N-int(i/2)-1]=0
else:
B[N-int(i/2)-1]-=A[N-int(i/2)-1]
ans+=A[N-int(i/2)-1]
A[N-int(i/2)-1]=0
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
B=list(map(int,input().split()))
ans=0
for i in range(N):
if i%2==0:
if A[i//2]>=B[i//2]:
A[i//2]-=B[i//2]
ans+=B[i//2]
B[i//2]=0
else:
B[i//2]-=A[i//2]
ans+=A[i//2]
A[i//2]=0
if A[i//2+1]>=B[i//2]:
A[i//2+1]-=B[i//2]
ans+=B[i//2]
B[i//2]=0
else:
B[i//2]-=A[i//2+1]
ans+=A[i//2+1]
A[i//2+1]=0
else:
if A[N-i//2]>=B[N-i//2-1]:
A[N-i//2]-=B[N-i//2-1]
ans+=B[N-i//2-1]
B[N-i//2-1]=0
else:
B[N-i//2-1]-=A[N-i//2]
ans+=A[N-i//2]
A[N-i//2]=0
if A[N-i//2-1]>=B[N-i//2-1]:
A[N-i//2-1]-=B[N-i//2-1]
ans+=B[N-i//2-1]
B[N-i//2-1]=0
else:
B[N-i//2-1]-=A[N-i//2-1]
ans+=A[N-i//2-1]
A[N-i//2-1]=0
print(ans)
| 42 | 42 | 1,205 | 1,045 | N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = 0
for i in range(N):
if i % 2 == 0:
if A[int(i / 2)] >= B[int(i / 2)]:
A[int(i / 2)] -= B[int(i / 2)]
ans += B[int(i / 2)]
B[int(i / 2)] = 0
else:
B[int(i / 2)] -= A[int(i / 2)]
ans += A[int(i / 2)]
A[int(i / 2)] = 0
if A[int(i / 2) + 1] >= B[int(i / 2)]:
A[int(i / 2) + 1] -= B[int(i / 2)]
ans += B[int(i / 2)]
B[int(i / 2)] = 0
else:
B[int(i / 2)] -= A[int(i / 2) + 1]
ans += A[int(i / 2) + 1]
A[int(i / 2) + 1] = 0
else:
if A[N - int(i / 2)] >= B[N - int(i / 2) - 1]:
A[N - int(i / 2)] -= B[N - int(i / 2) - 1]
ans += B[N - int(i / 2) - 1]
B[N - int(i / 2) - 1] = 0
else:
B[N - int(i / 2) - 1] -= A[N - int(i / 2)]
ans += A[N - int(i / 2)]
A[N - int(i / 2)] = 0
if A[N - int(i / 2) - 1] >= B[N - int(i / 2) - 1]:
A[N - int(i / 2) - 1] -= B[N - int(i / 2) - 1]
ans += B[N - int(i / 2) - 1]
B[N - int(i / 2) - 1] = 0
else:
B[N - int(i / 2) - 1] -= A[N - int(i / 2) - 1]
ans += A[N - int(i / 2) - 1]
A[N - int(i / 2) - 1] = 0
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
ans = 0
for i in range(N):
if i % 2 == 0:
if A[i // 2] >= B[i // 2]:
A[i // 2] -= B[i // 2]
ans += B[i // 2]
B[i // 2] = 0
else:
B[i // 2] -= A[i // 2]
ans += A[i // 2]
A[i // 2] = 0
if A[i // 2 + 1] >= B[i // 2]:
A[i // 2 + 1] -= B[i // 2]
ans += B[i // 2]
B[i // 2] = 0
else:
B[i // 2] -= A[i // 2 + 1]
ans += A[i // 2 + 1]
A[i // 2 + 1] = 0
else:
if A[N - i // 2] >= B[N - i // 2 - 1]:
A[N - i // 2] -= B[N - i // 2 - 1]
ans += B[N - i // 2 - 1]
B[N - i // 2 - 1] = 0
else:
B[N - i // 2 - 1] -= A[N - i // 2]
ans += A[N - i // 2]
A[N - i // 2] = 0
if A[N - i // 2 - 1] >= B[N - i // 2 - 1]:
A[N - i // 2 - 1] -= B[N - i // 2 - 1]
ans += B[N - i // 2 - 1]
B[N - i // 2 - 1] = 0
else:
B[N - i // 2 - 1] -= A[N - i // 2 - 1]
ans += A[N - i // 2 - 1]
A[N - i // 2 - 1] = 0
print(ans)
| false | 0 | [
"- if A[int(i / 2)] >= B[int(i / 2)]:",
"- A[int(i / 2)] -= B[int(i / 2)]",
"- ans += B[int(i / 2)]",
"- B[int(i / 2)] = 0",
"+ if A[i // 2] >= B[i // 2]:",
"+ A[i // 2] -= B[i // 2]",
"+ ans += B[i // 2]",
"+ B[i // 2] = 0",
"- B[int(i / 2)] -= A[int(i / 2)]",
"- ans += A[int(i / 2)]",
"- A[int(i / 2)] = 0",
"- if A[int(i / 2) + 1] >= B[int(i / 2)]:",
"- A[int(i / 2) + 1] -= B[int(i / 2)]",
"- ans += B[int(i / 2)]",
"- B[int(i / 2)] = 0",
"+ B[i // 2] -= A[i // 2]",
"+ ans += A[i // 2]",
"+ A[i // 2] = 0",
"+ if A[i // 2 + 1] >= B[i // 2]:",
"+ A[i // 2 + 1] -= B[i // 2]",
"+ ans += B[i // 2]",
"+ B[i // 2] = 0",
"- B[int(i / 2)] -= A[int(i / 2) + 1]",
"- ans += A[int(i / 2) + 1]",
"- A[int(i / 2) + 1] = 0",
"+ B[i // 2] -= A[i // 2 + 1]",
"+ ans += A[i // 2 + 1]",
"+ A[i // 2 + 1] = 0",
"- if A[N - int(i / 2)] >= B[N - int(i / 2) - 1]:",
"- A[N - int(i / 2)] -= B[N - int(i / 2) - 1]",
"- ans += B[N - int(i / 2) - 1]",
"- B[N - int(i / 2) - 1] = 0",
"+ if A[N - i // 2] >= B[N - i // 2 - 1]:",
"+ A[N - i // 2] -= B[N - i // 2 - 1]",
"+ ans += B[N - i // 2 - 1]",
"+ B[N - i // 2 - 1] = 0",
"- B[N - int(i / 2) - 1] -= A[N - int(i / 2)]",
"- ans += A[N - int(i / 2)]",
"- A[N - int(i / 2)] = 0",
"- if A[N - int(i / 2) - 1] >= B[N - int(i / 2) - 1]:",
"- A[N - int(i / 2) - 1] -= B[N - int(i / 2) - 1]",
"- ans += B[N - int(i / 2) - 1]",
"- B[N - int(i / 2) - 1] = 0",
"+ B[N - i // 2 - 1] -= A[N - i // 2]",
"+ ans += A[N - i // 2]",
"+ A[N - i // 2] = 0",
"+ if A[N - i // 2 - 1] >= B[N - i // 2 - 1]:",
"+ A[N - i // 2 - 1] -= B[N - i // 2 - 1]",
"+ ans += B[N - i // 2 - 1]",
"+ B[N - i // 2 - 1] = 0",
"- B[N - int(i / 2) - 1] -= A[N - int(i / 2) - 1]",
"- ans += A[N - int(i / 2) - 1]",
"- A[N - int(i / 2) - 1] = 0",
"+ B[N - i // 2 - 1] -= A[N - i // 2 - 1]",
"+ ans += A[N - i // 2 - 1]",
"+ A[N - i // 2 - 1] = 0"
] | false | 0.036939 | 0.079295 | 0.465844 | [
"s882749976",
"s051147378"
] |
u588341295 | p03854 | python | s129159168 | s335794214 | 132 | 59 | 3,956 | 4,084 | Accepted | Accepted | 55.3 | # -*- coding: utf-8 -*-
""" 逆順使わないでDPでやる版 """
S = eval(input())
dp = [False] * (len(S)+1)
# 0文字地点は遡る用にTrueにしておく
dp[0] = True
for i in range(1, len(dp)):
if i-5 >= 0:
if S[i-5:i] == "dream" or S[i-5:i] == "erase":
# 条件に当てはまったら、文字数分遡って有効な文字列が続いているか確認
if dp[i-5]:
dp[i] = True
if i-6 >= 0:
if S[i-6:i] == "eraser":
if dp[i-6]:
dp[i] = True
if i-7 >= 0:
if S[i-7:i] == "dreamer":
if dp[i-7]:
dp[i] = True
if dp[len(S)]:
print("YES")
else:
print("NO") | # -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
S = eval(input())
N = len(S)
# dp[i] := i文字目までをS=Tとすることができるか
dp = [0] * (N + 9)
dp[0] = 1
for i in range(N):
if dp[i]:
if S[i:i+5] == 'dream':
dp[i+5] = 1
if S[i:i+7] == 'dreamer':
dp[i+7] = 1
if S[i:i+5] == 'erase':
dp[i+5] = 1
if S[i:i+6] == 'eraser':
dp[i+6] = 1
if dp[N]:
YES()
else:
NO()
| 29 | 40 | 613 | 1,096 | # -*- coding: utf-8 -*-
""" 逆順使わないでDPでやる版 """
S = eval(input())
dp = [False] * (len(S) + 1)
# 0文字地点は遡る用にTrueにしておく
dp[0] = True
for i in range(1, len(dp)):
if i - 5 >= 0:
if S[i - 5 : i] == "dream" or S[i - 5 : i] == "erase":
# 条件に当てはまったら、文字数分遡って有効な文字列が続いているか確認
if dp[i - 5]:
dp[i] = True
if i - 6 >= 0:
if S[i - 6 : i] == "eraser":
if dp[i - 6]:
dp[i] = True
if i - 7 >= 0:
if S[i - 7 : i] == "dreamer":
if dp[i - 7]:
dp[i] = True
if dp[len(S)]:
print("YES")
else:
print("NO")
| # -*- coding: utf-8 -*-
import sys
def input():
return sys.stdin.readline().strip()
def list2d(a, b, c):
return [[c] * b for i in range(a)]
def list3d(a, b, c, d):
return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e):
return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1):
return int(-(-x // y))
def INT():
return int(eval(input()))
def MAP():
return list(map(int, input().split()))
def LIST(N=None):
return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes():
print("Yes")
def No():
print("No")
def YES():
print("YES")
def NO():
print("NO")
sys.setrecursionlimit(10**9)
INF = 10**18
MOD = 10**9 + 7
S = eval(input())
N = len(S)
# dp[i] := i文字目までをS=Tとすることができるか
dp = [0] * (N + 9)
dp[0] = 1
for i in range(N):
if dp[i]:
if S[i : i + 5] == "dream":
dp[i + 5] = 1
if S[i : i + 7] == "dreamer":
dp[i + 7] = 1
if S[i : i + 5] == "erase":
dp[i + 5] = 1
if S[i : i + 6] == "eraser":
dp[i + 6] = 1
if dp[N]:
YES()
else:
NO()
| false | 27.5 | [
"-\"\"\" 逆順使わないでDPでやる版 \"\"\"",
"+import sys",
"+",
"+",
"+def input():",
"+ return sys.stdin.readline().strip()",
"+",
"+",
"+def list2d(a, b, c):",
"+ return [[c] * b for i in range(a)]",
"+",
"+",
"+def list3d(a, b, c, d):",
"+ return [[[d] * c for j in range(b)] for i in range(a)]",
"+",
"+",
"+def list4d(a, b, c, d, e):",
"+ return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]",
"+",
"+",
"+def ceil(x, y=1):",
"+ return int(-(-x // y))",
"+",
"+",
"+def INT():",
"+ return int(eval(input()))",
"+",
"+",
"+def MAP():",
"+ return list(map(int, input().split()))",
"+",
"+",
"+def LIST(N=None):",
"+ return list(MAP()) if N is None else [INT() for i in range(N)]",
"+",
"+",
"+def Yes():",
"+ print(\"Yes\")",
"+",
"+",
"+def No():",
"+ print(\"No\")",
"+",
"+",
"+def YES():",
"+ print(\"YES\")",
"+",
"+",
"+def NO():",
"+ print(\"NO\")",
"+",
"+",
"+sys.setrecursionlimit(10**9)",
"+INF = 10**18",
"+MOD = 10**9 + 7",
"-dp = [False] * (len(S) + 1)",
"-# 0文字地点は遡る用にTrueにしておく",
"-dp[0] = True",
"-for i in range(1, len(dp)):",
"- if i - 5 >= 0:",
"- if S[i - 5 : i] == \"dream\" or S[i - 5 : i] == \"erase\":",
"- # 条件に当てはまったら、文字数分遡って有効な文字列が続いているか確認",
"- if dp[i - 5]:",
"- dp[i] = True",
"- if i - 6 >= 0:",
"- if S[i - 6 : i] == \"eraser\":",
"- if dp[i - 6]:",
"- dp[i] = True",
"- if i - 7 >= 0:",
"- if S[i - 7 : i] == \"dreamer\":",
"- if dp[i - 7]:",
"- dp[i] = True",
"-if dp[len(S)]:",
"- print(\"YES\")",
"+N = len(S)",
"+# dp[i] := i文字目までをS=Tとすることができるか",
"+dp = [0] * (N + 9)",
"+dp[0] = 1",
"+for i in range(N):",
"+ if dp[i]:",
"+ if S[i : i + 5] == \"dream\":",
"+ dp[i + 5] = 1",
"+ if S[i : i + 7] == \"dreamer\":",
"+ dp[i + 7] = 1",
"+ if S[i : i + 5] == \"erase\":",
"+ dp[i + 5] = 1",
"+ if S[i : i + 6] == \"eraser\":",
"+ dp[i + 6] = 1",
"+if dp[N]:",
"+ YES()",
"- print(\"NO\")",
"+ NO()"
] | false | 0.046916 | 0.046021 | 1.019445 | [
"s129159168",
"s335794214"
] |
u586759271 | p02573 | python | s680056814 | s528955737 | 531 | 427 | 120,776 | 82,800 | Accepted | Accepted | 19.59 | N,M = list(map(int,input().split()))
AB = [None]*M
for i in range(M):
a,b = list(map(int,input().split()))
if a>b:
a,b=b,a
AB[i] = (a-1,b-1)
AB=set(AB)
tree=[[] for _ in range(N)]
for a,b in AB:
tree[a].append(b)
tree[b].append(a) #aがbの親、とかが保証されてれば不要。
from collections import deque
groups=[]
been=[0]*N
for i in range(N):
if been[i]==0:
group=[i]
been[i]=1
q = deque([(i,togo) for togo in tree[i]])
while q:
parent,x = q.popleft()
if been[x]==1:
continue
been[x]=1
group.append(x)
for y in tree[x]:
if y == parent:#親ノードを飛ばし
continue
q.append((x,y))#子ノードを追加
groups.append(group)
print((max( len(g) for g in groups))) | class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N,M = list(map(int,input().split()))
uf = UnionFind(N)
for i in range(M):
a,b = list(map(int,input().split()))
uf.union(a-1,b-1)
root = uf.roots()
print(( max(uf.size(r) for r in root) )) | 38 | 55 | 856 | 1,399 | N, M = list(map(int, input().split()))
AB = [None] * M
for i in range(M):
a, b = list(map(int, input().split()))
if a > b:
a, b = b, a
AB[i] = (a - 1, b - 1)
AB = set(AB)
tree = [[] for _ in range(N)]
for a, b in AB:
tree[a].append(b)
tree[b].append(a) # aがbの親、とかが保証されてれば不要。
from collections import deque
groups = []
been = [0] * N
for i in range(N):
if been[i] == 0:
group = [i]
been[i] = 1
q = deque([(i, togo) for togo in tree[i]])
while q:
parent, x = q.popleft()
if been[x] == 1:
continue
been[x] = 1
group.append(x)
for y in tree[x]:
if y == parent: # 親ノードを飛ばし
continue
q.append((x, y)) # 子ノードを追加
groups.append(group)
print((max(len(g) for g in groups)))
| class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
N, M = list(map(int, input().split()))
uf = UnionFind(N)
for i in range(M):
a, b = list(map(int, input().split()))
uf.union(a - 1, b - 1)
root = uf.roots()
print((max(uf.size(r) for r in root)))
| false | 30.909091 | [
"+class UnionFind:",
"+ def __init__(self, n):",
"+ self.n = n",
"+ self.parents = [-1] * n",
"+",
"+ def find(self, x):",
"+ if self.parents[x] < 0:",
"+ return x",
"+ else:",
"+ self.parents[x] = self.find(self.parents[x])",
"+ return self.parents[x]",
"+",
"+ def union(self, x, y):",
"+ x = self.find(x)",
"+ y = self.find(y)",
"+ if x == y:",
"+ return",
"+ if self.parents[x] > self.parents[y]:",
"+ x, y = y, x",
"+ self.parents[x] += self.parents[y]",
"+ self.parents[y] = x",
"+",
"+ def size(self, x):",
"+ return -self.parents[self.find(x)]",
"+",
"+ def same(self, x, y):",
"+ return self.find(x) == self.find(y)",
"+",
"+ def members(self, x):",
"+ root = self.find(x)",
"+ return [i for i in range(self.n) if self.find(i) == root]",
"+",
"+ def roots(self):",
"+ return [i for i, x in enumerate(self.parents) if x < 0]",
"+",
"+ def group_count(self):",
"+ return len(self.roots())",
"+",
"+ def all_group_members(self):",
"+ return {r: self.members(r) for r in self.roots()}",
"+",
"+ def __str__(self):",
"+ return \"\\n\".join(\"{}: {}\".format(r, self.members(r)) for r in self.roots())",
"+",
"+",
"-AB = [None] * M",
"+uf = UnionFind(N)",
"- if a > b:",
"- a, b = b, a",
"- AB[i] = (a - 1, b - 1)",
"-AB = set(AB)",
"-tree = [[] for _ in range(N)]",
"-for a, b in AB:",
"- tree[a].append(b)",
"- tree[b].append(a) # aがbの親、とかが保証されてれば不要。",
"-from collections import deque",
"-",
"-groups = []",
"-been = [0] * N",
"-for i in range(N):",
"- if been[i] == 0:",
"- group = [i]",
"- been[i] = 1",
"- q = deque([(i, togo) for togo in tree[i]])",
"- while q:",
"- parent, x = q.popleft()",
"- if been[x] == 1:",
"- continue",
"- been[x] = 1",
"- group.append(x)",
"- for y in tree[x]:",
"- if y == parent: # 親ノードを飛ばし",
"- continue",
"- q.append((x, y)) # 子ノードを追加",
"- groups.append(group)",
"-print((max(len(g) for g in groups)))",
"+ uf.union(a - 1, b - 1)",
"+root = uf.roots()",
"+print((max(uf.size(r) for r in root)))"
] | false | 0.079439 | 0.084124 | 0.944302 | [
"s680056814",
"s528955737"
] |
u535803878 | p02925 | python | s772166029 | s618529734 | 1,584 | 745 | 287,492 | 180,108 | Accepted | Accepted | 52.97 | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
a = [list([int(x)-1 for x in input().split()]) for _ in range(n)]
N = n*(n-1)//2
index = {}
ind = 0
from collections import defaultdict
ns = defaultdict(list)
for i in range(n):
for j in range(i+1,n):
index[i,j] = ind
index[j,i] = ind
ind += 1
for i in range(n):
for j in range(n-2):
u = index[i,a[i][j]]
v = index[i,a[i][j+1]]
ns[u].append(v)
### サイクル検出 cycle detection
seen = [False] * N
done = [False] * N
vals = [None] * N
def dfs(u):
s = [u]
while s:
u = s.pop()
if u>=0:
seen[u] = True
s.append(~u)
for v in ns[u]:
if done[v]:
continue
elif not seen[v]:
s.append(v)
else:
# 閉路発見
return True
else:
u = ~u
done[u] = True
# ここに帰りがけ処理を書く
val = 0
for v in ns[u]:
val = max(val, vals[v]+1)
vals[u] = val
return False
ans = -float("inf")
for u in range(N):
if seen[u]:
continue
pos = dfs(u)
if pos:
print((-1))
break
else:
print((max(vals)+1)) | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n = int(eval(input()))
a = [list([int(x)-1 for x in input().split()]) for _ in range(n)]
N = n*(n-1)//2
index = [[0]*(n) for i in range(n)]
ind = 0
from collections import defaultdict
ns = defaultdict(list)
for i in range(n):
for j in range(i+1,n):
index[i][j] = ind
index[j][i] = ind
ind += 1
for i in range(n):
for j in range(n-2):
u = index[i][a[i][j]]
v = index[i][a[i][j+1]]
ns[u].append(v)
### サイクル検出 cycle detection
seen = [False] * N
done = [False] * N
vals = [None] * N
def dfs(u):
s = [u]
while s:
u = s.pop()
if u>=0:
# 非負の値: 新しい頂点に到達
seen[u] = True
s.append(~u)
for v in ns[u]:
if done[v]:
continue
elif not seen[v]:
s.append(v)
else:
# 閉路発見
return True
else:
u = ~u
done[u] = True
# ここに帰りがけ処理を書く
val = 0
for v in ns[u]:
# uの子はすべて処理が終わっている
val = max(val, vals[v]+1)
vals[u] = val
return False
ans = -float("inf")
for u in range(N):
if seen[u]:
continue
pos = dfs(u)
if pos:
print((-1))
break
else:
print((max(vals)+1)) | 62 | 64 | 1,449 | 1,544 | import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
n = int(eval(input()))
a = [list([int(x) - 1 for x in input().split()]) for _ in range(n)]
N = n * (n - 1) // 2
index = {}
ind = 0
from collections import defaultdict
ns = defaultdict(list)
for i in range(n):
for j in range(i + 1, n):
index[i, j] = ind
index[j, i] = ind
ind += 1
for i in range(n):
for j in range(n - 2):
u = index[i, a[i][j]]
v = index[i, a[i][j + 1]]
ns[u].append(v)
### サイクル検出 cycle detection
seen = [False] * N
done = [False] * N
vals = [None] * N
def dfs(u):
s = [u]
while s:
u = s.pop()
if u >= 0:
seen[u] = True
s.append(~u)
for v in ns[u]:
if done[v]:
continue
elif not seen[v]:
s.append(v)
else:
# 閉路発見
return True
else:
u = ~u
done[u] = True
# ここに帰りがけ処理を書く
val = 0
for v in ns[u]:
val = max(val, vals[v] + 1)
vals[u] = val
return False
ans = -float("inf")
for u in range(N):
if seen[u]:
continue
pos = dfs(u)
if pos:
print((-1))
break
else:
print((max(vals) + 1))
| import sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x + "\n")
n = int(eval(input()))
a = [list([int(x) - 1 for x in input().split()]) for _ in range(n)]
N = n * (n - 1) // 2
index = [[0] * (n) for i in range(n)]
ind = 0
from collections import defaultdict
ns = defaultdict(list)
for i in range(n):
for j in range(i + 1, n):
index[i][j] = ind
index[j][i] = ind
ind += 1
for i in range(n):
for j in range(n - 2):
u = index[i][a[i][j]]
v = index[i][a[i][j + 1]]
ns[u].append(v)
### サイクル検出 cycle detection
seen = [False] * N
done = [False] * N
vals = [None] * N
def dfs(u):
s = [u]
while s:
u = s.pop()
if u >= 0:
# 非負の値: 新しい頂点に到達
seen[u] = True
s.append(~u)
for v in ns[u]:
if done[v]:
continue
elif not seen[v]:
s.append(v)
else:
# 閉路発見
return True
else:
u = ~u
done[u] = True
# ここに帰りがけ処理を書く
val = 0
for v in ns[u]:
# uの子はすべて処理が終わっている
val = max(val, vals[v] + 1)
vals[u] = val
return False
ans = -float("inf")
for u in range(N):
if seen[u]:
continue
pos = dfs(u)
if pos:
print((-1))
break
else:
print((max(vals) + 1))
| false | 3.125 | [
"-index = {}",
"+index = [[0] * (n) for i in range(n)]",
"- index[i, j] = ind",
"- index[j, i] = ind",
"+ index[i][j] = ind",
"+ index[j][i] = ind",
"- u = index[i, a[i][j]]",
"- v = index[i, a[i][j + 1]]",
"+ u = index[i][a[i][j]]",
"+ v = index[i][a[i][j + 1]]",
"+ # 非負の値: 新しい頂点に到達",
"+ # uの子はすべて処理が終わっている"
] | false | 0.056277 | 0.06892 | 0.816561 | [
"s772166029",
"s618529734"
] |
u185896732 | p02720 | python | s419323224 | s916523266 | 387 | 164 | 13,248 | 17,004 | Accepted | Accepted | 57.62 | import sys
from collections import deque
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
lunlun=deque()
def dfs(now):
if len(now)>10:return
lunlun.append(int(now))
l=now[-1]
if l!="0":
dfs(now+str(int(l)-1))
if l!="9":
dfs(now+str(int(l)+1))
dfs(now+l)
k=int(input().rstrip())
for i in range(1,10):
dfs(str(i))
print((sorted(lunlun)[k-1])) | import sys
from collections import deque
input=sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
k=int(input().rstrip())
lunlun=deque([str(i) for i in range(1,10)])
for _ in range(k-1):
now=lunlun.popleft()
last=now[-1]
if last!="0":
lunlun.append(now+str(int(last)-1))
lunlun.append(now+last)
if last!="9":
lunlun.append(now+str(int(last)+1))
print((lunlun[0]))
if __name__=="__main__":
main() | 24 | 21 | 420 | 517 | import sys
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
lunlun = deque()
def dfs(now):
if len(now) > 10:
return
lunlun.append(int(now))
l = now[-1]
if l != "0":
dfs(now + str(int(l) - 1))
if l != "9":
dfs(now + str(int(l) + 1))
dfs(now + l)
k = int(input().rstrip())
for i in range(1, 10):
dfs(str(i))
print((sorted(lunlun)[k - 1]))
| import sys
from collections import deque
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def main():
k = int(input().rstrip())
lunlun = deque([str(i) for i in range(1, 10)])
for _ in range(k - 1):
now = lunlun.popleft()
last = now[-1]
if last != "0":
lunlun.append(now + str(int(last) - 1))
lunlun.append(now + last)
if last != "9":
lunlun.append(now + str(int(last) + 1))
print((lunlun[0]))
if __name__ == "__main__":
main()
| false | 12.5 | [
"-lunlun = deque()",
"-def dfs(now):",
"- if len(now) > 10:",
"- return",
"- lunlun.append(int(now))",
"- l = now[-1]",
"- if l != \"0\":",
"- dfs(now + str(int(l) - 1))",
"- if l != \"9\":",
"- dfs(now + str(int(l) + 1))",
"- dfs(now + l)",
"+def main():",
"+ k = int(input().rstrip())",
"+ lunlun = deque([str(i) for i in range(1, 10)])",
"+ for _ in range(k - 1):",
"+ now = lunlun.popleft()",
"+ last = now[-1]",
"+ if last != \"0\":",
"+ lunlun.append(now + str(int(last) - 1))",
"+ lunlun.append(now + last)",
"+ if last != \"9\":",
"+ lunlun.append(now + str(int(last) + 1))",
"+ print((lunlun[0]))",
"-k = int(input().rstrip())",
"-for i in range(1, 10):",
"- dfs(str(i))",
"-print((sorted(lunlun)[k - 1]))",
"+if __name__ == \"__main__\":",
"+ main()"
] | false | 1.210903 | 0.07044 | 17.190604 | [
"s419323224",
"s916523266"
] |
u072717685 | p02580 | python | s920156138 | s918033118 | 604 | 310 | 280,916 | 181,800 | Accepted | Accepted | 48.68 | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
h, w, m = list(map(int, input().split()))
rows = defaultdict(int)
cols = defaultdict(int)
d1 = lambda :defaultdict(int)
d2 = defaultdict(d1)
m = list(map(int, read().split()))
ab = list(zip(m, m))
for a, b in ab:
rows[a-1] += 1
cols[b-1] += 1
d2[a-1][b-1] = 1
rm = max(rows.values())
cm = max(cols.values())
rs = [i for i, v in list(rows.items()) if v == rm]
cs = [i for i, v in list(cols.items()) if v == cm]
r = rm + cm
#p = set()
for rse in rs:
for cse in cs:
if d2[rse][cse] == 0:
print(r)
sys.exit()
print((r-1))
if __name__ == '__main__':
main() | import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
def main():
h, w, m = list(map(int, input().split()))
b_row = [0] * h
b_col = [0] * w
b_coor = set()
m = list(map(int, read().split()))
for a, b in zip(m, m):
a -= 1
b -= 1
b_row[a] += 1
b_col[b] += 1
b_coor.add((a, b))
row_max = max(b_row)
col_max = max(b_col)
rows = [i for i, v in enumerate(b_row) if v == row_max]
cols = [i for i, v in enumerate(b_col) if v == col_max]
for r in rows:
for c in cols:
if (r, c) not in b_coor:
print((row_max + col_max))
sys.exit()
print((row_max + col_max - 1))
if __name__ == '__main__':
main()
| 32 | 30 | 809 | 758 | import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
h, w, m = list(map(int, input().split()))
rows = defaultdict(int)
cols = defaultdict(int)
d1 = lambda: defaultdict(int)
d2 = defaultdict(d1)
m = list(map(int, read().split()))
ab = list(zip(m, m))
for a, b in ab:
rows[a - 1] += 1
cols[b - 1] += 1
d2[a - 1][b - 1] = 1
rm = max(rows.values())
cm = max(cols.values())
rs = [i for i, v in list(rows.items()) if v == rm]
cs = [i for i, v in list(cols.items()) if v == cm]
r = rm + cm
# p = set()
for rse in rs:
for cse in cs:
if d2[rse][cse] == 0:
print(r)
sys.exit()
print((r - 1))
if __name__ == "__main__":
main()
| import sys
read = sys.stdin.read
# readlines = sys.stdin.readlines
def main():
h, w, m = list(map(int, input().split()))
b_row = [0] * h
b_col = [0] * w
b_coor = set()
m = list(map(int, read().split()))
for a, b in zip(m, m):
a -= 1
b -= 1
b_row[a] += 1
b_col[b] += 1
b_coor.add((a, b))
row_max = max(b_row)
col_max = max(b_col)
rows = [i for i, v in enumerate(b_row) if v == row_max]
cols = [i for i, v in enumerate(b_col) if v == col_max]
for r in rows:
for c in cols:
if (r, c) not in b_coor:
print((row_max + col_max))
sys.exit()
print((row_max + col_max - 1))
if __name__ == "__main__":
main()
| false | 6.25 | [
"-readlines = sys.stdin.readlines",
"-from collections import defaultdict",
"-",
"-",
"+# readlines = sys.stdin.readlines",
"- rows = defaultdict(int)",
"- cols = defaultdict(int)",
"- d1 = lambda: defaultdict(int)",
"- d2 = defaultdict(d1)",
"+ b_row = [0] * h",
"+ b_col = [0] * w",
"+ b_coor = set()",
"- ab = list(zip(m, m))",
"- for a, b in ab:",
"- rows[a - 1] += 1",
"- cols[b - 1] += 1",
"- d2[a - 1][b - 1] = 1",
"- rm = max(rows.values())",
"- cm = max(cols.values())",
"- rs = [i for i, v in list(rows.items()) if v == rm]",
"- cs = [i for i, v in list(cols.items()) if v == cm]",
"- r = rm + cm",
"- # p = set()",
"- for rse in rs:",
"- for cse in cs:",
"- if d2[rse][cse] == 0:",
"- print(r)",
"+ for a, b in zip(m, m):",
"+ a -= 1",
"+ b -= 1",
"+ b_row[a] += 1",
"+ b_col[b] += 1",
"+ b_coor.add((a, b))",
"+ row_max = max(b_row)",
"+ col_max = max(b_col)",
"+ rows = [i for i, v in enumerate(b_row) if v == row_max]",
"+ cols = [i for i, v in enumerate(b_col) if v == col_max]",
"+ for r in rows:",
"+ for c in cols:",
"+ if (r, c) not in b_coor:",
"+ print((row_max + col_max))",
"- print((r - 1))",
"+ print((row_max + col_max - 1))"
] | false | 0.038552 | 0.037239 | 1.035276 | [
"s920156138",
"s918033118"
] |
u652907854 | p03852 | python | s956519090 | s315770789 | 72 | 65 | 61,784 | 61,484 | Accepted | Accepted | 9.72 | # li = sorted(list(map(int, input().split())))
# n, m = map(int, input().split())
c = input()
print("vowel") if c in "aeiou" else print("consonant")
| print("vowel") if input() in "aeiou" else print("consonant")
| 4 | 1 | 151 | 60 | # li = sorted(list(map(int, input().split())))
# n, m = map(int, input().split())
c = input()
print("vowel") if c in "aeiou" else print("consonant")
| print("vowel") if input() in "aeiou" else print("consonant")
| false | 75 | [
"-# li = sorted(list(map(int, input().split())))",
"-# n, m = map(int, input().split())",
"-c = input()",
"-print(\"vowel\") if c in \"aeiou\" else print(\"consonant\")",
"+print(\"vowel\") if input() in \"aeiou\" else print(\"consonant\")"
] | false | 0.095741 | 0.03795 | 2.522832 | [
"s956519090",
"s315770789"
] |
u046158516 | p04015 | python | s504080879 | s852360284 | 194 | 65 | 42,716 | 68,732 | Accepted | Accepted | 66.49 | n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
for i in range(n):
x[i]-=a
dp=[]
for i in range(n+1):
dp.append([])
for i in range(6000):
dp[-1].append(0)
dp[0][3000]=1
for i in range(n):
for j in range(6000):
if j+x[i]<6000 and j+x[i]>=0:
dp[i+1][j+x[i]]+=dp[i][j]
dp[i+1][j]+=dp[i][j]
print((dp[n][3000]-1))
| n,a=list(map(int,input().split()))
x=list(map(int,input().split()))
dic={}
dic2=dic.copy()
for i in range(n):
for j in dic:
if j+x[i]-a in dic2:
dic2[j+x[i]-a]+=dic[j]
else:
dic2[j+x[i]-a]=dic[j]
if x[i]-a in dic2:
dic2[x[i]-a]+=1
else:
dic2[x[i]-a]=1
dic=dic2.copy()
if 0 in dic:
print((dic[0]))
else:
print((0)) | 16 | 19 | 365 | 361 | n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
for i in range(n):
x[i] -= a
dp = []
for i in range(n + 1):
dp.append([])
for i in range(6000):
dp[-1].append(0)
dp[0][3000] = 1
for i in range(n):
for j in range(6000):
if j + x[i] < 6000 and j + x[i] >= 0:
dp[i + 1][j + x[i]] += dp[i][j]
dp[i + 1][j] += dp[i][j]
print((dp[n][3000] - 1))
| n, a = list(map(int, input().split()))
x = list(map(int, input().split()))
dic = {}
dic2 = dic.copy()
for i in range(n):
for j in dic:
if j + x[i] - a in dic2:
dic2[j + x[i] - a] += dic[j]
else:
dic2[j + x[i] - a] = dic[j]
if x[i] - a in dic2:
dic2[x[i] - a] += 1
else:
dic2[x[i] - a] = 1
dic = dic2.copy()
if 0 in dic:
print((dic[0]))
else:
print((0))
| false | 15.789474 | [
"+dic = {}",
"+dic2 = dic.copy()",
"- x[i] -= a",
"-dp = []",
"-for i in range(n + 1):",
"- dp.append([])",
"- for i in range(6000):",
"- dp[-1].append(0)",
"-dp[0][3000] = 1",
"-for i in range(n):",
"- for j in range(6000):",
"- if j + x[i] < 6000 and j + x[i] >= 0:",
"- dp[i + 1][j + x[i]] += dp[i][j]",
"- dp[i + 1][j] += dp[i][j]",
"-print((dp[n][3000] - 1))",
"+ for j in dic:",
"+ if j + x[i] - a in dic2:",
"+ dic2[j + x[i] - a] += dic[j]",
"+ else:",
"+ dic2[j + x[i] - a] = dic[j]",
"+ if x[i] - a in dic2:",
"+ dic2[x[i] - a] += 1",
"+ else:",
"+ dic2[x[i] - a] = 1",
"+ dic = dic2.copy()",
"+if 0 in dic:",
"+ print((dic[0]))",
"+else:",
"+ print((0))"
] | false | 0.441714 | 0.101314 | 4.359864 | [
"s504080879",
"s852360284"
] |
u965602776 | p03112 | python | s091775032 | s043633301 | 1,478 | 1,167 | 80,856 | 18,000 | Accepted | Accepted | 21.04 | import bisect
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect.bisect_left(S, x)
return [S[p-1], S[p]]
g = lambda x, s, t: abs(x-s)+abs(s-t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF]+I(a)+[INF], [-INF]+I(b)+[INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_) | from bisect import bisect_left
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect_left(S, x)
return [S[p-1], S[p]]
g = lambda x, s, t: abs(x-s)+abs(s-t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF]+I(a)+[INF], [-INF]+I(b)+[INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_) | 15 | 15 | 451 | 461 | import bisect
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect.bisect_left(S, x)
return [S[p - 1], S[p]]
g = lambda x, s, t: abs(x - s) + abs(s - t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF] + I(a) + [INF], [-INF] + I(b) + [INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_)
| from bisect import bisect_left
from itertools import product
I = lambda n: [int(eval(input())) for _ in range(n)]
def f(S, x):
p = bisect_left(S, x)
return [S[p - 1], S[p]]
g = lambda x, s, t: abs(x - s) + abs(s - t)
INF = 10**11
a, b, q = list(map(int, input().split()))
S, T, X = [-INF] + I(a) + [INF], [-INF] + I(b) + [INF], I(q)
for x in X:
min_ = INF
for s, t in product(f(S, x), f(T, x)):
min_ = min(min_, g(x, s, t), g(x, t, s))
print(min_)
| false | 0 | [
"-import bisect",
"+from bisect import bisect_left",
"- p = bisect.bisect_left(S, x)",
"+ p = bisect_left(S, x)"
] | false | 0.047455 | 0.048737 | 0.973701 | [
"s091775032",
"s043633301"
] |
u350997995 | p03672 | python | s314768356 | s033000234 | 26 | 18 | 3,060 | 3,060 | Accepted | Accepted | 30.77 | s = eval(input())
mmax = 0
n = len(s)
while(n>1):
s = s[0:n-1]
n = len(s)
if n<2:
break
if s[0:int(n/2)]==s[int(n/2):n]:
mmax = max(mmax, n)
print(mmax) | S = eval(input())
n = len(S)
for i in range(1,n):
if (n-i)%2 == 1:
continue
if S[0:int((n-i)/2)]==S[int((n-i)/2):n-i]:
print((len(S[0:n-i])))
exit() | 11 | 8 | 172 | 179 | s = eval(input())
mmax = 0
n = len(s)
while n > 1:
s = s[0 : n - 1]
n = len(s)
if n < 2:
break
if s[0 : int(n / 2)] == s[int(n / 2) : n]:
mmax = max(mmax, n)
print(mmax)
| S = eval(input())
n = len(S)
for i in range(1, n):
if (n - i) % 2 == 1:
continue
if S[0 : int((n - i) / 2)] == S[int((n - i) / 2) : n - i]:
print((len(S[0 : n - i])))
exit()
| false | 27.272727 | [
"-s = eval(input())",
"-mmax = 0",
"-n = len(s)",
"-while n > 1:",
"- s = s[0 : n - 1]",
"- n = len(s)",
"- if n < 2:",
"- break",
"- if s[0 : int(n / 2)] == s[int(n / 2) : n]:",
"- mmax = max(mmax, n)",
"-print(mmax)",
"+S = eval(input())",
"+n = len(S)",
"+for i in range(1, n):",
"+ if (n - i) % 2 == 1:",
"+ continue",
"+ if S[0 : int((n - i) / 2)] == S[int((n - i) / 2) : n - i]:",
"+ print((len(S[0 : n - i])))",
"+ exit()"
] | false | 0.036984 | 0.109887 | 0.336561 | [
"s314768356",
"s033000234"
] |
u567281053 | p02275 | python | s786219606 | s788102649 | 1,970 | 1,500 | 266,268 | 265,860 | Accepted | Accepted | 23.86 | import sys
def countingSort(A, B, k):
C = [0] * (k + 1)
for j in range(0, len(A)):
C[A[j]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
B = [0] * (max(C) + 1)
for j in range(len(A) - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
del B[0]
print(" ".join([str(b) for b in B]))
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
B = []
countingSort(A, B, max(A)) | import sys
'''
def countingSort(A, B, k):
C = [0] * (k + 1)
for j in range(len(A)):
C[A[j]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
B = [0] * (max(C) + 1)
for j in range(len(A) - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
del B[0]
print " ".join([str(b) for b in B])
'''
def countingSort(A, B, k):
C = [0] * (k + 1)
for i in range(len(A)):
C[A[i]] += 1
for i in range(len(C)):
for j in range(C[i]):
B.append(i)
print(" ".join([str(b) for b in B]))
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
B = []
countingSort(A, B, 10000) | 24 | 35 | 500 | 740 | import sys
def countingSort(A, B, k):
C = [0] * (k + 1)
for j in range(0, len(A)):
C[A[j]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
B = [0] * (max(C) + 1)
for j in range(len(A) - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
del B[0]
print(" ".join([str(b) for b in B]))
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
B = []
countingSort(A, B, max(A))
| import sys
"""
def countingSort(A, B, k):
C = [0] * (k + 1)
for j in range(len(A)):
C[A[j]] += 1
for i in range(1, k + 1):
C[i] += C[i - 1]
B = [0] * (max(C) + 1)
for j in range(len(A) - 1, -1, -1):
B[C[A[j]]] = A[j]
C[A[j]] -= 1
del B[0]
print " ".join([str(b) for b in B])
"""
def countingSort(A, B, k):
C = [0] * (k + 1)
for i in range(len(A)):
C[A[i]] += 1
for i in range(len(C)):
for j in range(C[i]):
B.append(i)
print(" ".join([str(b) for b in B]))
if __name__ == "__main__":
lines = sys.stdin.readlines()
A = list(map(int, lines[1].split()))
B = []
countingSort(A, B, 10000)
| false | 31.428571 | [
"-",
"+\"\"\"",
"- for j in range(0, len(A)):",
"+ for j in range(len(A)):",
"+ print \" \".join([str(b) for b in B])",
"+ \"\"\"",
"+",
"+",
"+def countingSort(A, B, k):",
"+ C = [0] * (k + 1)",
"+ for i in range(len(A)):",
"+ C[A[i]] += 1",
"+ for i in range(len(C)):",
"+ for j in range(C[i]):",
"+ B.append(i)",
"- countingSort(A, B, max(A))",
"+ countingSort(A, B, 10000)"
] | false | 0.083434 | 0.211845 | 0.393845 | [
"s786219606",
"s788102649"
] |
u408260374 | p02346 | python | s708353680 | s188202622 | 1,500 | 1,040 | 9,168 | 8,192 | Accepted | Accepted | 30.67 | import math
class FenwickTree:
"""
FenwickTree(Binary Indexed Tree)
total number: n
queries:
1. add(i, val): add val to i-th value
2. sum(n): sum(bit[0] + ... + bit[n-1])
complexity: O(log n)
Self-balancing binary search tree or Segment Tree can do the same, it takes longer to program and complexity also increases.
Thanks: http://hos.ac/slides/20140319_bit.pdf
used in ARC031 C, indeednow finalB E
"""
def __init__(self, a_list):
# 0-indexed
self.N = len(a_list)
self.bit = a_list[:]
for _ in range(N, 1<<(math.ceil(math.log(N, 2)))): self.bit.append(0)
for i in range(self.N-1):
self.bit[i | (i+1)] += self.bit[i]
def add(self, i, val):
while i < self.N:
self.bit[i] += val
i |= i + 1
def sum(self, n):
ret = 0
while n >= 0:
ret += self.bit[n]
n = (n & (n + 1)) - 1
return ret
N, Q = list(map(int, input().split()))
bit = FenwickTree([0]*N)
for _ in range(Q):
com, x, y = list(map(int, input().split()))
if com == 0:
bit.add(x-1, y)
elif com == 1:
print((bit.sum(y-1) - bit.sum(x-2))) | class FenwickTree:
"""FenwickTree (Binary Indexed Tree, 0-index)
Queries:
1. add(i, val): add val to i-th value
2. sum(n): sum(bit[0] + ... + bit[n-1])
complexity: O(log n)
See: http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, a_list):
self.N = len(a_list)
self.bit = a_list[:]
for _ in range(self.N, 1 << (self.N - 1).bit_length()):
self.bit.append(0)
for i in range(self.N-1):
self.bit[i | (i+1)] += self.bit[i]
def add(self, i, val):
while i < self.N:
self.bit[i] += val
i |= i + 1
def sum(self, n):
ret = 0
while n >= 0:
ret += self.bit[n]
n = (n & (n + 1)) - 1
return ret
def query(self, low, high):
return self.sum(high) - self.sum(low)
def yosupo():
# https://judge.yosupo.jp/problem/point_add_range_sum
N, Q = list(map(int, input().split()))
fwt = FenwickTree([int(x) for x in input().split()])
for _ in range(Q):
type_, l, r = list(map(int, input().split()))
print([fwt.sum(i) for i in range(N+1)])
if type_ == 0:
fwt.add(l, r)
else:
print((fwt.query(l, r)))
def aoj():
# https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_B
N, Q = list(map(int, input().split()))
fwt = FenwickTree([0] * N)
for _ in range(Q):
type_, l, r = list(map(int, input().split()))
if type_ == 0:
fwt.add(l-1, r)
else:
print((fwt.query(l-2, r-1)))
if __name__ == "__main__":
# yosupo()
aoj()
| 43 | 65 | 1,241 | 1,689 | import math
class FenwickTree:
"""
FenwickTree(Binary Indexed Tree)
total number: n
queries:
1. add(i, val): add val to i-th value
2. sum(n): sum(bit[0] + ... + bit[n-1])
complexity: O(log n)
Self-balancing binary search tree or Segment Tree can do the same, it takes longer to program and complexity also increases.
Thanks: http://hos.ac/slides/20140319_bit.pdf
used in ARC031 C, indeednow finalB E
"""
def __init__(self, a_list):
# 0-indexed
self.N = len(a_list)
self.bit = a_list[:]
for _ in range(N, 1 << (math.ceil(math.log(N, 2)))):
self.bit.append(0)
for i in range(self.N - 1):
self.bit[i | (i + 1)] += self.bit[i]
def add(self, i, val):
while i < self.N:
self.bit[i] += val
i |= i + 1
def sum(self, n):
ret = 0
while n >= 0:
ret += self.bit[n]
n = (n & (n + 1)) - 1
return ret
N, Q = list(map(int, input().split()))
bit = FenwickTree([0] * N)
for _ in range(Q):
com, x, y = list(map(int, input().split()))
if com == 0:
bit.add(x - 1, y)
elif com == 1:
print((bit.sum(y - 1) - bit.sum(x - 2)))
| class FenwickTree:
"""FenwickTree (Binary Indexed Tree, 0-index)
Queries:
1. add(i, val): add val to i-th value
2. sum(n): sum(bit[0] + ... + bit[n-1])
complexity: O(log n)
See: http://hos.ac/slides/20140319_bit.pdf
"""
def __init__(self, a_list):
self.N = len(a_list)
self.bit = a_list[:]
for _ in range(self.N, 1 << (self.N - 1).bit_length()):
self.bit.append(0)
for i in range(self.N - 1):
self.bit[i | (i + 1)] += self.bit[i]
def add(self, i, val):
while i < self.N:
self.bit[i] += val
i |= i + 1
def sum(self, n):
ret = 0
while n >= 0:
ret += self.bit[n]
n = (n & (n + 1)) - 1
return ret
def query(self, low, high):
return self.sum(high) - self.sum(low)
def yosupo():
# https://judge.yosupo.jp/problem/point_add_range_sum
N, Q = list(map(int, input().split()))
fwt = FenwickTree([int(x) for x in input().split()])
for _ in range(Q):
type_, l, r = list(map(int, input().split()))
print([fwt.sum(i) for i in range(N + 1)])
if type_ == 0:
fwt.add(l, r)
else:
print((fwt.query(l, r)))
def aoj():
# https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_B
N, Q = list(map(int, input().split()))
fwt = FenwickTree([0] * N)
for _ in range(Q):
type_, l, r = list(map(int, input().split()))
if type_ == 0:
fwt.add(l - 1, r)
else:
print((fwt.query(l - 2, r - 1)))
if __name__ == "__main__":
# yosupo()
aoj()
| false | 33.846154 | [
"-import math",
"-",
"-",
"- \"\"\"",
"- FenwickTree(Binary Indexed Tree)",
"- total number: n",
"- queries:",
"- 1. add(i, val): add val to i-th value",
"- 2. sum(n): sum(bit[0] + ... + bit[n-1])",
"+ \"\"\"FenwickTree (Binary Indexed Tree, 0-index)",
"+ Queries:",
"+ 1. add(i, val): add val to i-th value",
"+ 2. sum(n): sum(bit[0] + ... + bit[n-1])",
"- Self-balancing binary search tree or Segment Tree can do the same, it takes longer to program and complexity also increases.",
"- Thanks: http://hos.ac/slides/20140319_bit.pdf",
"- used in ARC031 C, indeednow finalB E",
"+ See: http://hos.ac/slides/20140319_bit.pdf",
"- # 0-indexed",
"- for _ in range(N, 1 << (math.ceil(math.log(N, 2)))):",
"+ for _ in range(self.N, 1 << (self.N - 1).bit_length()):",
"+ def query(self, low, high):",
"+ return self.sum(high) - self.sum(low)",
"-N, Q = list(map(int, input().split()))",
"-bit = FenwickTree([0] * N)",
"-for _ in range(Q):",
"- com, x, y = list(map(int, input().split()))",
"- if com == 0:",
"- bit.add(x - 1, y)",
"- elif com == 1:",
"- print((bit.sum(y - 1) - bit.sum(x - 2)))",
"+",
"+def yosupo():",
"+ # https://judge.yosupo.jp/problem/point_add_range_sum",
"+ N, Q = list(map(int, input().split()))",
"+ fwt = FenwickTree([int(x) for x in input().split()])",
"+ for _ in range(Q):",
"+ type_, l, r = list(map(int, input().split()))",
"+ print([fwt.sum(i) for i in range(N + 1)])",
"+ if type_ == 0:",
"+ fwt.add(l, r)",
"+ else:",
"+ print((fwt.query(l, r)))",
"+",
"+",
"+def aoj():",
"+ # https://onlinejudge.u-aizu.ac.jp/courses/library/3/DSL/2/DSL_2_B",
"+ N, Q = list(map(int, input().split()))",
"+ fwt = FenwickTree([0] * N)",
"+ for _ in range(Q):",
"+ type_, l, r = list(map(int, input().split()))",
"+ if type_ == 0:",
"+ fwt.add(l - 1, r)",
"+ else:",
"+ print((fwt.query(l - 2, r - 1)))",
"+",
"+",
"+if __name__ == \"__main__\":",
"+ # yosupo()",
"+ aoj()"
] | false | 0.034372 | 0.044808 | 0.767096 | [
"s708353680",
"s188202622"
] |
u716530146 | p02793 | python | s627153208 | s445753631 | 1,017 | 573 | 131,884 | 131,596 | Accepted | Accepted | 43.66 | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
n=int(eval(input()))
A=list(map(int,input().split()))
def gcd(a, b):
while(b != 0):
a, b = b, a % b
return a
def lcm(m,n):
return (m*n)//gcd(m,n)
class InverseTable:
__slots__ = ['In', 'fac', 'Ifac']
def __init__(self, mod, maxnum):
self.In = [0, 1]; self.fac = [1, 1]; self.Ifac = [1, 1]
for i in range( 2, maxnum + 1 ):
self.fac.append( ( self.fac[-1] * i ) % mod )
self.In.append( ( -self.In[mod % i] * (mod//i) ) % mod )
self.Ifac.append( (self.Ifac[-1] * self.In[-1]) % mod )
def cmb(self, n, r):
if ( r<0 or r>n ): return 0
r = min(r, n-r)
return self.fac[n] * self.Ifac[r] * self.Ifac[n-r] % mod
it = InverseTable(mod, 10**6)
for ai in A:
pro=lcm(pro,ai)
for ai in A:
ans+=it.In[ai]
ans%=mod
print(((pro*ans)%mod))
# pro2=1
# for ai in A:
# pro2=(pro2*ai)%mod
# pro=gcd(pro,ai)
# for ai in A:
# count+=pro//ai
# count%=mod
# print(count) | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode('utf-8')
inf = float('inf') ;mod = 10**9+7
mans = inf ;ans = 0 ;count = 0 ;pro = 1
class InverseTable:
__slots__ = ['In', 'fac', 'Ifac']
def __init__(self, mod, maxnum):
self.In = [0, 1]; self.fac = [1, 1]; self.Ifac = [1, 1]
for i in range( 2, maxnum + 1 ):
self.fac.append( ( self.fac[-1] * i ) % mod )
self.In.append( ( -self.In[mod % i] * (mod//i) ) % mod )
self.Ifac.append( (self.Ifac[-1] * self.In[-1]) % mod )
def cmb(self, n, r):
if ( r<0 or r>n ): return 0
r = min(r, n-r)
return self.fac[n] * self.Ifac[r] * self.Ifac[n-r] % mod
invt = InverseTable(mod, 10**6)
def prime_factor(n):
ass = []
for i in range(2,int(n**0.5)+1):
count=0
while n % i==0:
count+=1
n = n//i
if count!=0:
ass.append((i,count))
if n != 1:
ass.append((n,1))
return ass
n=int(eval(input()))
A=list(map(int,input().split()))
data=[0]*(10**6+10)
for ai in A:
arr=prime_factor(ai)
for ni,ci in arr:
data[ni]=max(data[ni],ci)
pro=1
for i in range(1,len(data)):
pro=pro*(i**data[i])
pro%=mod
for ai in A:
ans+=invt.In[ai]
print((ans*pro%mod)) | 50 | 51 | 1,258 | 1,408 | #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
n = int(eval(input()))
A = list(map(int, input().split()))
def gcd(a, b):
while b != 0:
a, b = b, a % b
return a
def lcm(m, n):
return (m * n) // gcd(m, n)
class InverseTable:
__slots__ = ["In", "fac", "Ifac"]
def __init__(self, mod, maxnum):
self.In = [0, 1]
self.fac = [1, 1]
self.Ifac = [1, 1]
for i in range(2, maxnum + 1):
self.fac.append((self.fac[-1] * i) % mod)
self.In.append((-self.In[mod % i] * (mod // i)) % mod)
self.Ifac.append((self.Ifac[-1] * self.In[-1]) % mod)
def cmb(self, n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return self.fac[n] * self.Ifac[r] * self.Ifac[n - r] % mod
it = InverseTable(mod, 10**6)
for ai in A:
pro = lcm(pro, ai)
for ai in A:
ans += it.In[ai]
ans %= mod
print(((pro * ans) % mod))
# pro2=1
# for ai in A:
# pro2=(pro2*ai)%mod
# pro=gcd(pro,ai)
# for ai in A:
# count+=pro//ai
# count%=mod
# print(count)
| #!/usr/bin/env python3
import sys, math, itertools, collections, bisect
input = lambda: sys.stdin.buffer.readline().rstrip().decode("utf-8")
inf = float("inf")
mod = 10**9 + 7
mans = inf
ans = 0
count = 0
pro = 1
class InverseTable:
__slots__ = ["In", "fac", "Ifac"]
def __init__(self, mod, maxnum):
self.In = [0, 1]
self.fac = [1, 1]
self.Ifac = [1, 1]
for i in range(2, maxnum + 1):
self.fac.append((self.fac[-1] * i) % mod)
self.In.append((-self.In[mod % i] * (mod // i)) % mod)
self.Ifac.append((self.Ifac[-1] * self.In[-1]) % mod)
def cmb(self, n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return self.fac[n] * self.Ifac[r] * self.Ifac[n - r] % mod
invt = InverseTable(mod, 10**6)
def prime_factor(n):
ass = []
for i in range(2, int(n**0.5) + 1):
count = 0
while n % i == 0:
count += 1
n = n // i
if count != 0:
ass.append((i, count))
if n != 1:
ass.append((n, 1))
return ass
n = int(eval(input()))
A = list(map(int, input().split()))
data = [0] * (10**6 + 10)
for ai in A:
arr = prime_factor(ai)
for ni, ci in arr:
data[ni] = max(data[ni], ci)
pro = 1
for i in range(1, len(data)):
pro = pro * (i ** data[i])
pro %= mod
for ai in A:
ans += invt.In[ai]
print((ans * pro % mod))
| false | 1.960784 | [
"-n = int(eval(input()))",
"-A = list(map(int, input().split()))",
"-",
"-",
"-def gcd(a, b):",
"- while b != 0:",
"- a, b = b, a % b",
"- return a",
"-",
"-",
"-def lcm(m, n):",
"- return (m * n) // gcd(m, n)",
"-it = InverseTable(mod, 10**6)",
"+invt = InverseTable(mod, 10**6)",
"+",
"+",
"+def prime_factor(n):",
"+ ass = []",
"+ for i in range(2, int(n**0.5) + 1):",
"+ count = 0",
"+ while n % i == 0:",
"+ count += 1",
"+ n = n // i",
"+ if count != 0:",
"+ ass.append((i, count))",
"+ if n != 1:",
"+ ass.append((n, 1))",
"+ return ass",
"+",
"+",
"+n = int(eval(input()))",
"+A = list(map(int, input().split()))",
"+data = [0] * (10**6 + 10)",
"- pro = lcm(pro, ai)",
"+ arr = prime_factor(ai)",
"+ for ni, ci in arr:",
"+ data[ni] = max(data[ni], ci)",
"+pro = 1",
"+for i in range(1, len(data)):",
"+ pro = pro * (i ** data[i])",
"+ pro %= mod",
"- ans += it.In[ai]",
"- ans %= mod",
"-print(((pro * ans) % mod))",
"-# pro2=1",
"-# for ai in A:",
"-# pro2=(pro2*ai)%mod",
"-# pro=gcd(pro,ai)",
"-# for ai in A:",
"-# count+=pro//ai",
"-# count%=mod",
"-# print(count)",
"+ ans += invt.In[ai]",
"+print((ans * pro % mod))"
] | false | 2.050101 | 2.766143 | 0.741141 | [
"s627153208",
"s445753631"
] |
u664907598 | p03161 | python | s208101262 | s372759030 | 1,831 | 454 | 23,116 | 52,448 | Accepted | Accepted | 75.2 | import numpy as np
N, K = (int(i) for i in input().split())
h = np.array([int(i) for i in input().split()])
dp = np.empty(N, dtype='int')
for i in range(N):
if i == 0:
dp[i] = 0
elif i - K < 0:
dp[i] = np.min(np.abs(h[i] - h[:i]) + dp[:i])
else:
dp[i] = np.min(np.abs(h[i] - h[i-K:i]) + dp[i-K:i])
print((dp[N-1])) |
n,k = list(map(int,input().split()))
h = list(map(int, input().split()))
dp = [0]*n
dp[0] = 0
dp[1] = abs(h[0]-h[1])
for i in range(2,n):
j = max(0,i-k)
dp[i] = min([dp[l]+abs(h[i]-h[l]) for l in range(j,i)])
print((int(dp[n-1])))
| 15 | 13 | 352 | 249 | import numpy as np
N, K = (int(i) for i in input().split())
h = np.array([int(i) for i in input().split()])
dp = np.empty(N, dtype="int")
for i in range(N):
if i == 0:
dp[i] = 0
elif i - K < 0:
dp[i] = np.min(np.abs(h[i] - h[:i]) + dp[:i])
else:
dp[i] = np.min(np.abs(h[i] - h[i - K : i]) + dp[i - K : i])
print((dp[N - 1]))
| n, k = list(map(int, input().split()))
h = list(map(int, input().split()))
dp = [0] * n
dp[0] = 0
dp[1] = abs(h[0] - h[1])
for i in range(2, n):
j = max(0, i - k)
dp[i] = min([dp[l] + abs(h[i] - h[l]) for l in range(j, i)])
print((int(dp[n - 1])))
| false | 13.333333 | [
"-import numpy as np",
"-",
"-N, K = (int(i) for i in input().split())",
"-h = np.array([int(i) for i in input().split()])",
"-dp = np.empty(N, dtype=\"int\")",
"-for i in range(N):",
"- if i == 0:",
"- dp[i] = 0",
"- elif i - K < 0:",
"- dp[i] = np.min(np.abs(h[i] - h[:i]) + dp[:i])",
"- else:",
"- dp[i] = np.min(np.abs(h[i] - h[i - K : i]) + dp[i - K : i])",
"-print((dp[N - 1]))",
"+n, k = list(map(int, input().split()))",
"+h = list(map(int, input().split()))",
"+dp = [0] * n",
"+dp[0] = 0",
"+dp[1] = abs(h[0] - h[1])",
"+for i in range(2, n):",
"+ j = max(0, i - k)",
"+ dp[i] = min([dp[l] + abs(h[i] - h[l]) for l in range(j, i)])",
"+print((int(dp[n - 1])))"
] | false | 0.231082 | 0.042527 | 5.43381 | [
"s208101262",
"s372759030"
] |
u698919163 | p02678 | python | s683770675 | s819186716 | 517 | 447 | 123,168 | 123,016 | Accepted | Accepted | 13.54 | N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(M)]
ans = [-1] * (N+1)
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N+1)
todo = deque([(1,0)])
while todo:
x,parent = deque.popleft(todo)
# ans[x] = parent
for y in graph[x]:
if y == parent:
continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y,x))
for i in range(2,N+1):
if ans[i] == -1:
print('No')
sys.exit()
print('Yes')
for i in range(2,N+1):
print((ans[i])) | N,M = list(map(int,input().split()))
AB = [list(map(int,input().split())) for i in range(M)]
ans = [-1] * (N+1)
graph = [[] for _ in range(N+1)]
for a,b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N+1)
todo = deque([(1,0)])
while todo:
x,parent = deque.popleft(todo)
# ans[x] = parent
for y in graph[x]:
if y == parent:
continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y,x))
if -1 in ans[2:]:
print('No')
else:
print('Yes')
for i in range(2,N+1):
print((ans[i])) | 34 | 32 | 707 | 665 | N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
ans = [-1] * (N + 1)
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N + 1)
todo = deque([(1, 0)])
while todo:
x, parent = deque.popleft(todo)
# ans[x] = parent
for y in graph[x]:
if y == parent:
continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y, x))
for i in range(2, N + 1):
if ans[i] == -1:
print("No")
sys.exit()
print("Yes")
for i in range(2, N + 1):
print((ans[i]))
| N, M = list(map(int, input().split()))
AB = [list(map(int, input().split())) for i in range(M)]
ans = [-1] * (N + 1)
graph = [[] for _ in range(N + 1)]
for a, b in AB:
graph[a].append(b)
graph[b].append(a)
from collections import deque
import sys
ans = [-1] * (N + 1)
todo = deque([(1, 0)])
while todo:
x, parent = deque.popleft(todo)
# ans[x] = parent
for y in graph[x]:
if y == parent:
continue
if ans[y] != -1:
continue
ans[y] = x
todo.append((y, x))
if -1 in ans[2:]:
print("No")
else:
print("Yes")
for i in range(2, N + 1):
print((ans[i]))
| false | 5.882353 | [
"-for i in range(2, N + 1):",
"- if ans[i] == -1:",
"- print(\"No\")",
"- sys.exit()",
"-print(\"Yes\")",
"-for i in range(2, N + 1):",
"- print((ans[i]))",
"+if -1 in ans[2:]:",
"+ print(\"No\")",
"+else:",
"+ print(\"Yes\")",
"+ for i in range(2, N + 1):",
"+ print((ans[i]))"
] | false | 0.042992 | 0.083442 | 0.515225 | [
"s683770675",
"s819186716"
] |
u169138653 | p02821 | python | s596717423 | s110548345 | 1,174 | 766 | 17,752 | 16,944 | Accepted | Accepted | 34.75 | from itertools import accumulate
n,m=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort(reverse=True)
b=[0]*(2*a[0]+1)
for i in range(n):
b[a[i]]+=1
b=list(accumulate(b[::-1]))[::-1]
s=list(accumulate([0]+a))
ok=0
ng=2*a[0]+1
while ng-ok>1:
mid=(ng+ok)//2
cnt=0
for i in range(n):
cnt+=b[max(0,mid-a[i])]
if cnt>=m:
ok=mid
else:
ng=mid
cnt=0
ans=0
for i in range(n):
t=min(b[max(0,ng-a[i])],m-cnt)
ans+=s[t]+a[i]*t
cnt+=t
ans+=(m-cnt)*ok
print(ans) | N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
LB = A[-1] * 2 # 一回の握手で上がる幸福度の下限は、左手も右手もパワーが一番低い人を握った場合
UB = A[0] * 2 # 一回の握手で上がる幸福度の上限は、左手も右手もパワーが一番高い人を握った場合
# cgs[i] は パワーがi以上のゲストの数
cgs = [0] * (UB + 1)
for a in A:
cgs[a] += 1
for i in range(UB, 0, -1):
cgs[i - 1] += cgs[i]
# 組み合わせの数がM以上になる一回で発生する幸福度の閾値を二分探索する
def is_ok(n):
m = 0
for a in A:
m += cgs[max(n - a, 0)]
return m >= M
ok = LB
ng = UB + 1
while ng - ok > 1:
m = (ok + ng) // 2
if is_ok(m):
ok = m
else:
ng = m
# cps[i] は A[0]～A[i] の累積和
cps = A[:]
for i in range(1, N):
cps[i] += cps[i - 1]
result = 0
for a in A:
t = cgs[max(ok - a, 0)]
if t != 0:
result += a * t + cps[t - 1]
M -= t
result += ok * M
print(result)
| 28 | 45 | 519 | 861 | from itertools import accumulate
n, m = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
b = [0] * (2 * a[0] + 1)
for i in range(n):
b[a[i]] += 1
b = list(accumulate(b[::-1]))[::-1]
s = list(accumulate([0] + a))
ok = 0
ng = 2 * a[0] + 1
while ng - ok > 1:
mid = (ng + ok) // 2
cnt = 0
for i in range(n):
cnt += b[max(0, mid - a[i])]
if cnt >= m:
ok = mid
else:
ng = mid
cnt = 0
ans = 0
for i in range(n):
t = min(b[max(0, ng - a[i])], m - cnt)
ans += s[t] + a[i] * t
cnt += t
ans += (m - cnt) * ok
print(ans)
| N, M = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort(reverse=True)
LB = A[-1] * 2 # 一回の握手で上がる幸福度の下限は、左手も右手もパワーが一番低い人を握った場合
UB = A[0] * 2 # 一回の握手で上がる幸福度の上限は、左手も右手もパワーが一番高い人を握った場合
# cgs[i] は パワーがi以上のゲストの数
cgs = [0] * (UB + 1)
for a in A:
cgs[a] += 1
for i in range(UB, 0, -1):
cgs[i - 1] += cgs[i]
# 組み合わせの数がM以上になる一回で発生する幸福度の閾値を二分探索する
def is_ok(n):
m = 0
for a in A:
m += cgs[max(n - a, 0)]
return m >= M
ok = LB
ng = UB + 1
while ng - ok > 1:
m = (ok + ng) // 2
if is_ok(m):
ok = m
else:
ng = m
# cps[i] は A[0]～A[i] の累積和
cps = A[:]
for i in range(1, N):
cps[i] += cps[i - 1]
result = 0
for a in A:
t = cgs[max(ok - a, 0)]
if t != 0:
result += a * t + cps[t - 1]
M -= t
result += ok * M
print(result)
| false | 37.777778 | [
"-from itertools import accumulate",
"+N, M = list(map(int, input().split()))",
"+A = list(map(int, input().split()))",
"+A.sort(reverse=True)",
"+LB = A[-1] * 2 # 一回の握手で上がる幸福度の下限は、左手も右手もパワーが一番低い人を握った場合",
"+UB = A[0] * 2 # 一回の握手で上がる幸福度の上限は、左手も右手もパワーが一番高い人を握った場合",
"+# cgs[i] は パワーがi以上のゲストの数",
"+cgs = [0] * (UB + 1)",
"+for a in A:",
"+ cgs[a] += 1",
"+for i in range(UB, 0, -1):",
"+ cgs[i - 1] += cgs[i]",
"+# 組み合わせの数がM以上になる一回で発生する幸福度の閾値を二分探索する",
"+def is_ok(n):",
"+ m = 0",
"+ for a in A:",
"+ m += cgs[max(n - a, 0)]",
"+ return m >= M",
"-n, m = list(map(int, input().split()))",
"-a = list(map(int, input().split()))",
"-a.sort(reverse=True)",
"-b = [0] * (2 * a[0] + 1)",
"-for i in range(n):",
"- b[a[i]] += 1",
"-b = list(accumulate(b[::-1]))[::-1]",
"-s = list(accumulate([0] + a))",
"-ok = 0",
"-ng = 2 * a[0] + 1",
"+",
"+ok = LB",
"+ng = UB + 1",
"- mid = (ng + ok) // 2",
"- cnt = 0",
"- for i in range(n):",
"- cnt += b[max(0, mid - a[i])]",
"- if cnt >= m:",
"- ok = mid",
"+ m = (ok + ng) // 2",
"+ if is_ok(m):",
"+ ok = m",
"- ng = mid",
"-cnt = 0",
"-ans = 0",
"-for i in range(n):",
"- t = min(b[max(0, ng - a[i])], m - cnt)",
"- ans += s[t] + a[i] * t",
"- cnt += t",
"-ans += (m - cnt) * ok",
"-print(ans)",
"+ ng = m",
"+# cps[i] は A[0]～A[i] の累積和",
"+cps = A[:]",
"+for i in range(1, N):",
"+ cps[i] += cps[i - 1]",
"+result = 0",
"+for a in A:",
"+ t = cgs[max(ok - a, 0)]",
"+ if t != 0:",
"+ result += a * t + cps[t - 1]",
"+ M -= t",
"+result += ok * M",
"+print(result)"
] | false | 0.08682 | 0.105244 | 0.824943 | [
"s596717423",
"s110548345"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.