code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
# 22-Math_Functions-Distance_II.py
# ??????????????????????????¢
# ???????????????????????????????????????????????????????????????????????¢??§??¬???????????????
# ????????????????????°???????????????????§?????????¨????????§????????????????????????
# ????????§??????????????? n ?¬????????????????
# x={x1,x2,...,xn} ??¨
# y={y1,y2,...,yn}
# ????????¢????¨????????????????????????????
# ????????????????????????????????¢?????¬???????¨?????????¨?????¨??????????¬??????????????????????????????¢?????\?????????????????????
# Dxy=(???{i=1n}|xi???yi|^p)1/p
# p=1 ?????¨???
# Dxy=|x1???y1|+|x2???y2|+...+|xn???yn|
# ??¨?????????????????????????????????????????¢??¨?????°????????????
# p=2 ?????¨???
# Dxy=(|x1???y1|)2+(|x2???y2|)2+...+(|xn???yn|)2?????????????????????????????????????????????????????????????????????????????????????????????????????????
# ??¨???????????????????????¬?????????????????????????????????????????¢??????????????????
# p=??? ?????¨???
# Dxy=maxni=1(|xi???yi|)
# ??¨???????????????????????§????????§????????¢??¨?????°????????????
# ????????? n ?¬???????????????????????????????????????§???
# p ??????????????? 1???2???3?????? ?????????????????????????????¢????±???????????????°????????????????????????????????????
# Input
# ??????????????´??° n ????????????????????????
# ???????????????????????? x ???????´? {x1,x2,...xn}{x1,x2,...xn}???
# ???????????????????????? y ???????´? {y1,y2,...yn}{y1,y2,...yn}
# ????????????????????§???????????????????????\?????????????????´??°?????§??????
# Output
# p ??????????????? 1???2???3?????? ??????????????????????????????????????¢??????????????????????????????
# ????????????0.00001 ??\????????????????????£????????????????????¨????????????
# Constraints
# 1???n???100
# 0???xi,yi???1000
# Sample Input
# 3
# 1 2 3
# 2 0 4
# Sample Output
# 4.000000
# 2.449490
# 2.154435
# 2.000000
n = int(input())
x = list( map(int, input().split()) )
y = list( map(int, input().split()) )
pp=[1.0, 2.0, 3.0, 500.0]
for p in pp:
if p==500.0:
print( "{0:.8f}".format( max( [abs(x[i]-y[i]) for i in range(n)] ) ))
else:
print( "{0:.8f}".format( sum( [abs(x[i]-y[i])**p for i in range(n)] )**(1./p) )) | def min_dist(x_b,y_b):
s=0
for x,y in zip(x_b,y_b):
s+=abs(x-y)
return s
def man_dist(x_b,y_b):
s=0
for x, y in zip(x_b,y_b):
s+=(abs(x-y))**2
return s**0.5
def che_dist(x_b,y_b):
s=0
for x,y in zip(x_b,y_b):
s+=(abs(x-y))**3
return s**(1/3)
def anf_dist(x_b,y_b):
s=[abs(x-y) for x,y in zip(x_b,y_b)]
return max(s)
n=int(input())
x_b=list(map(int,input().split()))
y_b=list(map(int,input().split()))
print(min_dist(x_b,y_b))
print(man_dist(x_b,y_b))
print(che_dist(x_b,y_b))
print(anf_dist(x_b,y_b)) | 1 | 205,532,692,792 | null | 32 | 32 |
#!/usr/bin/env python3
import math
def solver(visited, coord, depth = 0):
dists = []
if len(visited) == depth:
for i in range(1, len(visited)):
x1, y1 = coord[visited[i - 1]][0], coord[visited[i - 1]][1]
x2, y2 = coord[visited[i]][0], coord[visited[i]][1]
dists.append(math.sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2)))
return sum(dists)
for i in range(0, len(visited)):
if visited[i] != -1: continue
visited[i] = depth
dists.append(solver(visited, coord, depth + 1))
visited[i] = -1;
return sum(dists)
def main():
n = int(input())
coord = []
for i in range(0, n):
coord.append([int(c) for c in input().split()])
print(solver([-1 for i in range(0, n)], coord) / math.factorial(n))
if __name__ == "__main__":
main()
| #!/usr/bin/python3
#coding: utf-8
import math
N = int(input())
P = [[int(x) for x in input().split()] for _ in range(N)]
def calc(path):
r = 0
for i in range(len(path) - 1):
p1 = P[path[i-1]]
p2 = P[path[i]]
dx = p1[0] - p2[0]
dy = p1[1] - p2[1]
r += math.sqrt(dx*dx + dy*dy)
return r
ret = 0
numret = 0
def rec(path, rest):
if not rest:
global ret
global numret
ret += calc(path)
numret += 1
return
for i in range(len(rest)):
rec(path + [rest[i]], rest[:i] + rest[i+1:])
rec([], [i for i in range(N)])
print(ret/numret)
| 1 | 148,944,718,495,760 | null | 280 | 280 |
from itertools import accumulate
from bisect import bisect_right
N, M, K = map(int,input().split())
A = [0]+list(accumulate(map(int,input().split()), lambda x,y:x+y))
B = [0]+list(accumulate(map(int,input().split()), lambda x,y:x+y))
ans = 0
for i in range(N+1):
left = K-A[i]
if left < 0:
break
j = bisect_right(B, left)
ans = max(ans, i+j-1)
print(ans) | def COMinit():
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,max):
fac[i] = fac[i-1]*i%mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
def COM(n,k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return fac[n] * (finv[k]*finv[n-k]%mod)%mod
mod = 998244353
N,M,K = map(int,input().split())
max = max(N,2)
fac = [0] * max
finv = [0] * max
inv = [0] * max
COMinit()
ans = 0
for i in range(K+1):
c = COM(N-1,i)
m = pow(M-1,N-i-1,mod)
ans = (ans + ((c*m%mod)*M%mod))%mod
print(ans)
| 0 | null | 17,056,213,932,018 | 117 | 151 |
s = list(input())
t = list(input())
lt = len(t)
ans = lt
for i in range(len(s) - lt + 1):
s_ = s[i: i + lt]
diff = 0
for x, y in zip(s_, t):
if x != y:
diff += 1
ans = min(ans, diff)
print(ans) | S = list(str(input()))
T = list(str(input()))
i = 0
ans = []
len_s = len(S)
len_t = len(T)
while i < len_s-len_t+1:
cnt = 0
for ss, tt in zip(S[i:i+len_t], T):
if ss != tt:
cnt += 1
ans.append(cnt)
i += 1
print(min(ans)) | 1 | 3,674,731,479,872 | null | 82 | 82 |
from sys import stdin
from collections import deque
n = int(input())
d = [-1] * (n + 1)
G = [0] + [list(map(int, input().split()[2:])) for _ in range(n)]
d[1] = 0
dq = deque([1])
while len(dq) != 0:
v = dq.popleft()
for c in G[v]:
if d[c] == -1 :
d[c] = d[v] + 1
dq.append(c)
for i, x in enumerate(d[1:], start=1):
print(i, x) | n=int(input())
ne=[[] for _ in range(n+1)]
for _ in range(n):
u,k,*v=map(int,input().split())
ne[u]=v
dis=[-1]*(n+1)
dis[1]=0
q=[1]
while q:
p=q.pop(0)
for e in ne[p]:
if dis[e]==-1:
dis[e]=dis[p]+1
q.append(e)
for i in range(1,n+1):
print(i,dis[i])
| 1 | 4,110,682,422 | null | 9 | 9 |
import math
N,X,M = map(int, input().split())
MAP = [-1]*(M+1)
TMAP = [0]*(M+1)
ans = 0
for i in range(N):
if (X%M!=0):
X = X%M
ans += X
if MAP[X]==-1:
MAP[X] = i
TMAP[X] = ans
else:
loopcnt = i-MAP[X]
loopsum = ans-TMAP[X]
ans += (((N-MAP[X])//loopcnt)-1)*loopsum
jmax = N-(MAP[X]+((N-MAP[X])//loopcnt)*loopcnt)
ans -= X
for j in range(jmax):
X = X%M
ans += X
X = X**2
X=M
X = X**2
else:
break
print(ans)
| N,X,M = [int(a) for a in input().split()]
amari = [0]*M
i = 1
A = X
amari[A] = i
l = [X]
ichi = i
while i<=M:
i += 1
A = A**2 % M
if amari[A]: i += M
else:
amari[A] = i
l.append(A)
if i==N: i = M+1
else:
if i>M+1: ni = i-M - amari[A]
else: ni = 0
#for j in range(M):
# if amari[j]: print(j, amari[j])
#print(i,len(l))
ichi = len(l) - ni
#print(l)
if ni:
ni_times, san = divmod((N - ichi), ni)
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l[:ichi]) +
sum(l[ichi:])*ni_times +
sum(l[ichi:ichi+san]))
else:
#print(ichi, '%d*%d'%(ni,ni_times), san)
print(sum(l)) | 1 | 2,829,092,089,252 | null | 75 | 75 |
import math
def prime(num):
judge = True
for i in range(2, int(math.sqrt(num)+1)):
if num % i == 0:
judge = False
return judge
n = int(input())
cnt = 0
ns=[]
for i in range(n):
num = int(input())
if prime(num):
cnt += 1
print(cnt)
| n = int(input())
fib = [1]*(n+1)
for i in range(2,n+1):
fib[i] = fib[i-1]+fib[i-2]
print(fib[n]) | 0 | null | 6,793,209,132 | 12 | 7 |
import collections
import sys
n,q = map(int,input().split())
data = [[i for i in input().split()]for i in range(n)]
time = 0
while data:
task = data[0]
del data[0]
if int(task[1]) <= q:
time += int(task[1])
print(task[0],time)
else:
time += q
task[1] = str(int(task[1]) - q)
data.append(task) | #ALDS_3_B 16D8103010K Ko Okasaki
from collections import deque
n,q=map(int,input().split())
que=deque()
for i in range(n):
name,time=input().split()
time=int(time)
que.append([name,time])
t=0
while len(que)>0:
que_t=que.popleft()
if que_t[1]>q:
que_t[1]-=q
t+=q
que.append(que_t)
else:
t+=que_t[1]
print(que_t[0],t)
| 1 | 45,740,099,930 | null | 19 | 19 |
import fractions
A,B=map(int,input().split())
def lcm(x,y):
return int((x*y)/fractions.gcd(x,y))
print(lcm(A,B)) | h = int(input())
cnt = 1
if h == 1:
print(1)
exit()
while(True):
cnt += 1
h = int(h / 2)
if h == 1:
break
print(2 ** cnt - 1) | 0 | null | 96,477,011,180,192 | 256 | 228 |
S = input()
S_inv = S[-1::-1]
counter = 0
for i in range(len(S)//2):
if S[i]!=S_inv[i]:
counter +=1
print(counter)
| S=input()
N=len(S)
S=list(S)
ct=0
for i in range(N//2):
if S[i]!=S[-i-1]:
ct+=1
print(ct) | 1 | 119,493,328,927,250 | null | 261 | 261 |
X,Y = map(int,input().split())
M = max(X,Y)
m = min(X,Y)
mod = 10 ** 9 + 7
con = (X + Y) // 3
dif = M - m
n = (con - dif) // 2
if (X + Y) % 3 != 0 or n < 0:
print(0)
else:
def comb(n, r):
n += 1
over = 1
under = 1
for i in range(1,r + 1):
over = over * (n - i) % mod
under = under * i % mod
#powでunder ** (mod - 2) % modを実現、逆元を求めている
return over * pow(under,mod - 2,mod) % mod
ans = comb(con,n)
print(ans) | n = int(input())
h = {}
for i in range(n):
op, st = input().split()
if op == 'insert':
h[st] = 'yes'
else:
print (h.get(st, 'no')) | 0 | null | 75,004,968,494,720 | 281 | 23 |
N = int(input())
D = {i: [0] for i in range(100)}
for i in range(1, N+1):
if i % 10 != 0:
s = str(i)
D[int(s[0])*10+int(s[-1])][0] += 1
D[int(s[0])*10+int(s[-1])].append(i)
S = 0
for i in range(10):
for j in range(10):
S += D[i*10+j][0] * D[j*10+i][0]
print(S) | N = int(input())
count = [0,1]
if N == 1:
print(1)
exit()
for i in range(2,N+1):
digit = len(str(i))
head = int(str(i)[0])
tail = int(str(i)[-1])
plus = 0
if digit == 1:
plus=1
elif digit == 2:
if head == tail:
plus = 3
elif head>tail and tail>0:
plus = 2
elif tail>0:
for j in range(digit-2):
plus += 10**j*2
if head == tail:
mid = str(i)[1:-1]
while len(mid)>1 and mid[0]=='0':
mid = mid[1:]
mid = int(mid)
plus += 2*mid+1
plus += 2
elif head > tail:
plus += 10**(digit-2)*2
count.append(count[-1]+plus)
print(count[N])
| 1 | 86,724,093,262,688 | null | 234 | 234 |
import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N = input()
K = int(input())
lenN = len(N)
# has less number before
dp0 = [[0]*5 for _ in range(lenN+1)]
# not had yet
dp1 = [[0]*5 for _ in range(lenN+1)]
dp1[0][0] = 1
for i in range(lenN):
k = int(N[i])
for zero in range(4):
dp0[i+1][zero] += dp0[i][zero]
dp0[i+1][zero+1] += dp0[i][zero] * 9
if k != 0:
dp0[i+1][zero] += dp1[i][zero]
dp0[i+1][zero+1] += dp1[i][zero] * (k-1)
dp1[i+1][zero+1] += dp1[i][zero]
else:
dp1[i+1][zero] += dp1[i][zero]
ans = dp0[lenN][K] + dp1[lenN][K]
print(ans)
if __name__ == '__main__':
solve() | # https://atcoder.jp/contests/abc154/tasks/abc154_e
# 桁DPっぽいよなぁ => O
"""
memo
dp0[i][j]
上からi桁目まで決めて，0でない桁がj個あり
Nより小さいことが確定している (less)
dp1[i][j]
上からi桁目まで決めて，0でない桁がj個あり
Nより小さいことが確定していない (i桁目まで同じ)
通常の再帰
rec
"""
S = input()
K = int(input())
N = len(S)
def com(N, R):
if R < 0 or R > N:
return 0
if R == 1:
return N
elif R == 2:
return N * (N - 1) // 2
elif R == 3:
return N * (N - 1) * (N - 2) // 6
else:
raise NotImplementedError("NIE")
# 再帰呼出し
def rec(i, k, smaller):
if i == N:
return 1 if k == 0 else 0
if k == 0:
return 1
if smaller:
# 残っている桁数からk個を選び，それぞれ9^kのパターンがある
return com(N - i, k) * pow(9, k)
else:
if S[i] == '0':
return rec(i + 1, k , False)
else:
zero = rec(i + 1, k, True)
aida = rec(i + 1, k - 1, True) * (int(S[i]) - 1)
ichi = rec(i + 1, k - 1, False)
return zero + aida + ichi
ans = rec(0, K, False)
print(ans) | 1 | 75,856,550,656,458 | null | 224 | 224 |
def solve():
S = input()
T = input()
ans = float('inf')
for i in range(0,len(S)-len(T)+1):
cnt = 0
for j in range(len(T)):
if S[i+j] != T[j]:
cnt += 1
ans = min(cnt,ans)
print(ans)
if __name__ == '__main__':
solve()
| S =input()
T = input()
n = len(S)-len(T)+1
count = []
for i in range(n):
c =0
for p in range(len(T)):
if S[i+p] != T[p]:
c += 1
count.append(c)
print(min(count))
| 1 | 3,709,050,738,988 | null | 82 | 82 |
days = input()
consecutive_days = 0
max_days = 0
if 'R' in days:
max_days = 1
consecutive_days = 1
for weather in range(len(days) - 1):
if days[weather] == days[weather + 1] and days[weather] == 'R':
consecutive_days += 1
if consecutive_days > max_days:
max_days = consecutive_days
print(max_days) | from math import ceil, floor
def main():
a, b = map(int, input().split())
p8_l = ceil(a / 0.08)
p8_h = int((a+1) // 0.08)
p10_l = int(b / 0.10)
p10_h = int((b+1) / 0.10) - 1
if p8_h >= p10_h >= p8_l and p8_l >= p10_l:
print(p8_l)
elif p8_l <= p10_l <= p8_h and p8_l <= p10_l:
print(p10_l)
else:
print(-1)
if __name__ == '__main__':
main() | 0 | null | 30,651,824,804,942 | 90 | 203 |
n=int(input())
l=[list(input().split()) for _ in range(n)]
x=input()
ans=0
for i in range(n):
s,t=l[i]
t=int(t)
ans+=t
if s==x:
c=ans
print(ans-c)
| import bisect
n = int(input())
l = list(map(int, input().split()))
l.sort()
cnt = 0
for i in range(n):
for j in range(i+1, n):
if j == n-1:
continue
x = l[i] + l[j]
cnt += bisect.bisect_left(l[j+1:], x)
print(cnt) | 0 | null | 134,640,745,199,620 | 243 | 294 |
N = int(input())
S = input()
if N<4:
print(0)
else:
a = [0] * N
R, G, B = 0, 0, 0
for i in range(N):
if S[i] == "R":
a[i] = 1
R += 1
if S[i] == "G":
a[i] = 2
G += 1
if S[i] == "B":
a[i] = 4
B += 1
rgb = R * G * B
cnt = 0
for i in range(N-2):
for d in range(1, (N-i-1) // 2+1):
if a[i] + a[i+d] + a[i+2*d] == 7:
cnt += 1
print(rgb -cnt)
| # coding: utf-8
# input
n = int(input())
s = list(map(int,input().split()))
q = int(input())
t = list(map(int,input().split()))
cnt = 0
for i in t:
if i in s:
cnt += 1
print(cnt) | 0 | null | 18,032,213,201,172 | 175 | 22 |
A, B = map(str, input().split())
A=int(A)
B=int(B[0]+B[2]+B[3])
print(A*B//100) | import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
A, B = input().split()
B = int(''.join(B.split('.')))
print(int(A)*B//100) | 1 | 16,393,186,112,800 | null | 135 | 135 |
#!/usr/bin/env python3
def main():
N = int(input())
X = [None] * N
for i in range(N):
x, l = map(int, input().split())
X[i] = (x+l,x-l)
X.sort()
ans = 0
maxT = - 10**18
for i in range(N):
if maxT <= X[i][1]:
ans += 1
maxT = X[i][0]
print(ans)
if __name__ == "__main__":
main()
| M,a=-float("inf"),0
for X,L in sorted(zip(*[iter(map(int,open(0).read().split()[1:]))]*2),key=sum):
l,r=X-L,X+L
if M<=l:a+=1;M=r
print(a) | 1 | 90,224,776,306,070 | null | 237 | 237 |
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
def ddprint(x):
if DBG:
print(x)
def foo(n,x,y):
l = len(n)
sm = 0
if x==y and (l>1 or n[0]>=x):
sm = 1
if l==1:
return sm
for i in range(2,l):
sm += 10**(i-2)
if x==n[-1]:
sm += bar(n[:-1],y)
elif x<n[-1]:
sm += 10**(l-2)
#ddprint(f"foo {n=} {x=} {y=} {sm=}")
return sm
def bar(n,y):
l = len(n)
if l==1:
return 1 if n[0]>=y else 0
sm = (n[-1])*10**(l-2) + bar(n[:-1],y)
return sm
nn = inn()
nnn = nn
n = []
while nn>0:
n.append(nn%10)
nn //= 10
sm = 0
for a in range(1,nnn+1):
y = a%10
if y==0:
continue
aa = a
while aa>0:
x = aa
aa //= 10
sm += foo(n,y,x)
print(sm)
| n=int(input())
s=list(input())
rn=s.count('R')
gn=s.count('G')
bn=n-rn-gn
ans=bn*gn*rn
if n>2:
for x in range(n-2):
y=(n-1-x)//2
for i in range(1,y+1):
if (not s[x]==s[x+i]) & (not s[x]==s[x+i+i]) & (not s[x+i]==s[x+i+i]):
ans-=1
print(ans)
else:
print(0)
| 0 | null | 61,310,875,564,928 | 234 | 175 |
n=int(input())
a=list(map(int,input().split()))
import numpy as np
x = np.argsort(a)
for i in range(n):
print(x[i]+1)
| N = int(input())
c = input()
num_red = c.count('R')
print(num_red - c[:num_red].count('R')) | 0 | null | 93,896,623,593,504 | 299 | 98 |
n, k = map(int, input().split())
MOD = 10 ** 9 + 7
ans = 0
for i in range(k, n + 2):
mini = i * (i - 1) / 2
maxx = i * (2 * n - i + 1) / 2
ans += maxx - mini + 1
ans %= MOD
print(int(ans))
| h, w = map(int, input().split())
g = [[0] * w for _ in range(h)]#白が1、黒が０
for i in range(h):
s = list(input())
for j in range(w):
if s[j] == '.':
g[i][j] = 1
INF = 10**9
dp = [[INF] * w for _ in range(h)]
if g[0][0] == 0:
dp[0][0] = 1
else:
dp[0][0] = 0
for i in range(h):
for j in range(w):
for dx, dy in ((1, 0), (0, 1)):
nx = j + dx
ny = i + dy
if ny >= h or nx >= w:
continue
add = 0
if g[ny][nx] == 0 and g[i][j] == 1:
add = 1
dp[ny][nx] = min(dp[ny][nx], dp[i][j] + add)
print(dp[h-1][w-1])
| 0 | null | 41,343,407,187,962 | 170 | 194 |
import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → にn回ローテート
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations,product#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import reduce,lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printe(*x):print("## ",*x,file=sys.stderr)
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reverse=True) #二個目の要素で降順並び替え
N = int(input())
s = input()
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
def bin(x): return format(x, 'b')
def bitcount(x): #xは64bit整数
x= x - ((x >> 1) & 0x5555555555555555)
x= (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x= (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x+= (x >> 8); x+= (x >> 16); x+= (x >> 32)
return x & 0x7f
@lru_cache(None)
def r(n):
if n==0:
return 0
bc=bitcount(n)
return r(n%bc)+1
mod=s.count("1")
c1=0
c2=0
cur1=1%(mod+1)
if mod>1:
cur2=1%(mod-1)
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
c2+=cur2
c2%=(mod-1)
cur1=cur1*2%(mod+1)
cur2=cur2*2%(mod-1)
else:
for i in range(N):
if s[-1-i]=="1":
c1+=cur1
c1%=(mod+1)
cur1=cur1*2%(mod+1)
for i in range(N):
if s[i]=="1":
f=-1
cmod=mod-1
else:
f=1
cmod=mod+1
if cmod==0:
print(0)
continue
if f==1:
n=c1+pow(2,N-1-i,cmod)
n%=cmod
else:
n=c2-pow(2,N-1-i,cmod)
n%=cmod
print(1+r(n))
#printe(c1,c2)
if __name__ == "__main__":
main()
| import sys
input = sys.stdin.readline
def main():
N = int(input())
X = input()
popcount_X = X.count("1")
if popcount_X == 0:
ans = [1] * N
elif popcount_X == 1:
ans = [1] * N
ans[-1] = 2
ans[X.index("1")] = 0
else:
X_mod_popcount_X_p = int(X, 2) % (popcount_X + 1)
X_mod_popcount_X_m = int(X, 2) % (popcount_X - 1)
ans = [0] * N
for i in range(N):
if X[i] == "0":
Y = X_mod_popcount_X_p + pow(2, N - 1 - i, mod=popcount_X + 1)
Y = Y % (popcount_X + 1)
else:
Y = X_mod_popcount_X_m - pow(2, N - 1 - i, mod=popcount_X - 1)
Y = Y + (popcount_X - 1)
Y = Y % (popcount_X - 1)
count = 1
while Y > 0:
popcount = bin(Y).count("1")
Y = Y % popcount
count += 1
ans[i] = count
print("\n".join(map(str, ans)))
if __name__ == "__main__":
main()
| 1 | 8,177,500,188,662 | null | 107 | 107 |
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 = readInts()
print(a - b*2 if a - b*2 >= 0 else 0)
if __name__ == '__main__':
main()
| n=int(input())
l=[]
lis=[]
for _ in range(n):
a=int(input())
l.append(a)
li=[]
for _ in range(a):
c,d=map(int,input().split())
li.append([c,d])
lis.append(li)
ans=-1
for i in range(2**n-1,-1,-1):
mark=bin(i)[2:]
mark=(n-len(mark))*'0'+mark
s=0
record=[-1]*n
f=1
for j in range(n):
for k in range(l[j]):
number=lis[j][k][0]-1
hou=lis[j][k][1]
if int(mark[j])==1:
if record[number]==-1:
record[number]=hou
elif record[number]!=hou:f=0
if f==0:break
if f == 0: break
if f==1:
F=True
for i in range(n):
if record[i]!=-1:
if record[i]!=int(mark[i]):
F=False
break
if F==True:
print(mark.count('1'))
exit()
| 0 | null | 143,746,121,353,022 | 291 | 262 |
C = input()
alp = "abcdefghijklmnopqrstuvwxyz"
print(alp[alp.index(C)+1])
| # coding: utf-8
import math
#N, K, M = map(int,input().split())
alp = [chr(i) for i in range(97, 97+26)]
#print(alp)
#N = int(input())
#K = int(input())
c = input()
ans = 0
#l = list(map(int,input().split()))
#A = list(map(int,input().split()))
print(alp[alp.index(c)+1]) | 1 | 92,169,733,487,620 | null | 239 | 239 |
N, K = map(int, input().split())
H = list(map(int, input().split()))
print(len(list(filter(lambda x: x >= K, H)))) | v = sum(map(int,list(input().split())))
if(v > 21):
print('bust')
else:
print('win')
| 0 | null | 149,422,138,236,676 | 298 | 260 |
N = int(input())
A = list(map(int,input().split()))
ans = [ 0 for _ in range(N)]
for i in A:
ans[i-1] += 1
print(*ans,sep='\n') | import collections
n = int(input())
x = list(map(int, input().split()))
y = collections.Counter(x)
for i in range(1, len(x)+2):
print(y[i], end = "\n") | 1 | 32,644,936,936,422 | null | 169 | 169 |
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
#隣接リスト 1-order
def make_adjlist_d(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
res[edge[1]].append(edge[0])
return res
def make_adjlist_nond(n, edges):
res = [[] for _ in range(n + 1)]
for edge in edges:
res[edge[0]].append(edge[1])
return res
#nCr
def cmb(n, r):
return math.factorial(n) // math.factorial(r) // math.factorial(n - r)
def main():
X, Y, A, B, C = NMI()
P = NLI()
Q = NLI()
R = NLI()
reds = [[1, p] for p in P]
greens = [[2, q] for q in Q]
skels = [[0, r] for r in R]
apples = reds + greens + skels
apples.sort(key=lambda x: x[1], reverse=True)
colors = [0, 0, 0]
limits = [10**9, X, Y]
ans = 0
for color, a in apples:
if sum(colors) >= X + Y:
break
if colors[color] <= limits[color] - 1:
colors[color] += 1
ans += a
continue
print(ans)
if __name__ == "__main__":
main() | 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(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
def ZIP(n): return 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
X, Y, A, B, C = MAP()
p = deque(sorted(LIST(), reverse=True))
q = deque(sorted(LIST(), reverse=True))
r = deque(sorted(LIST(), reverse=True) + [0])
x = 0
y = 0
z = 0
ans = 0
while x+y+z < X+Y:
compare = (p[0], q[0], r[0])
if p[0] == max(compare):
x += 1
ans += p.popleft()
if x == X:
p = [0]
elif q[0] == max(compare):
y += 1
ans += q.popleft()
if y == Y:
q = [0]
else:
z += 1
ans += r.popleft()
print(ans)
| 1 | 44,818,148,495,450 | null | 188 | 188 |
from heapq import heappush,heappop,heapify
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
import math
import time
#import random
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def ItoS(nn):
return chr(nn+97)
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
l_alp=string.ascii_lowercase
u_alp=string.ascii_uppercase
ts=time.time()
#sys.setrecursionlimit(10**6)
input=lambda: sys.stdin.readline().rstrip()
show_flg=False
#show_flg=True
n,m=LI()
## Segment Tree ##
## Initializer Template ##
# Range Sum: sg=SegTree(n,0)
# Range Minimum: sg=SegTree(n,inf,min,inf)
class SegTree:
def __init__(self,n,init_val=0,function=lambda a,b:a+b,ide=0):
self.n=n
self.ide_ele=ide_ele=ide
self.num=num=2**(n-1).bit_length()
self.seg=seg=[self.ide_ele]*2*self.num
self.segfun=segfun=function
#set_val
for i in range(n):
self.seg[i+self.num-1]=init_val
#built
for i in range(self.num-2,-1,-1) :
self.seg[i]=self.segfun(self.seg[2*i+1],self.seg[2*i+2])
def update(self,k,x):
k += self.num-1
self.seg[k] = x
while k:
k = (k-1)//2
self.seg[k] = self.segfun(self.seg[k*2+1],self.seg[k*2+2])
def query(self,p,q):
if q<=p:
return self.ide_ele
p += self.num-1
q += self.num-2
res=self.ide_ele
while q-p>1:
if p&1 == 0:
res = self.segfun(res,self.seg[p])
if q&1 == 1:
res = self.segfun(res,self.seg[q])
q -= 1
p = p//2
q = (q-1)//2
if p == q:
res = self.segfun(res,self.seg[p])
else:
res = self.segfun(self.segfun(res,self.seg[p]),self.seg[q])
return res
def __str__(self):
# 生配列を表示
rt=self.seg[self.num-1:self.num-1+self.n]
return str(rt)
s=[int(i) for i in input()]
def dp(b,m): # N log (N)
N=len(b)-1
n=N+1
sg=SegTree(n,inf,min,inf)
sg.update(0,0)
dp=[0]+[inf]*(N)
for i in range(N):
if b[i+1]==1:
continue
dp[i+1]=sg.query(max(i-m+1,0),i+1)+1
sg.update(i+1,dp[i+1])
#show(seg)
show(sg)
return dp
dp1=dp(s,m)
step=dp1[n]
if step==inf:
print(-1)
exit()
dp2=dp(s[::-1],m)[::-1]
show(dp1,'dp1')
move=[0]
ans=[]
j=1
for i in range(step,0,-1): # N
while j<=n and dp2[j]!=i-1:
j+=1
move.append(j)
for i in range(len(move)-1):
ans.append(move[i+1]-move[i])
print(*ans)
| n,m=map(int,input().split())
s=list(map(int,list(input())))
ans=[]
i=n
while i>0:
j=max(0,m-i)
while s[i-(m-j)]!=0:
j+=1
if j==m:
print(-1)
exit(0)
ans.append(m-j)
i-=(m-j)
ans.reverse()
print(' '.join(map(str,ans)))
| 1 | 138,782,604,681,188 | null | 274 | 274 |
K = int(input())
A,B = map(int,input().split())
if (B//K *K)>=A:
print("OK")
else:
print("NG") | k = int(input())
a, b = map(int, input().split())
i = 1
ans = "NG"
while k*i <= b:
if a <= k*i:
ans = "OK"
break
i += 1
print(ans) | 1 | 26,612,372,049,982 | null | 158 | 158 |
def make_divisors(n):
lower_divisors , upper_divisors = [], []
i = 1
while i*i <= n:
if n % i == 0:
lower_divisors.append(i)
if i != n // i:
upper_divisors.append(n//i)
i += 1
return lower_divisors + upper_divisors[::-1]
n = int(input())
divisors = make_divisors(n)
#print(divisors)
if len(divisors)%2==1:
print(divisors[len(divisors)//2]*2-2)
else:
m = len(divisors)//2
print(divisors[m-1]+divisors[m]-2) | a=int(input())
ans=a+a**2+a**3
print(ans) | 0 | null | 85,851,290,587,348 | 288 | 115 |
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
a,b=sep()
for i in range(1,10005):
if (i*8)//100==a and (i*10)//100==b:
print(i)
quit()
print(-1) | [A, B] = [int(i) for i in input().split()]
a = []
b = []
if A%2 == 1:
s = 0
t = 1
else:
s = 1
t = 0
for i in range(int(A*12.5) + t, int((A+1)*12.5) + s):
a.append(i)
for i in range(10*B, 10*(B+1)):
b.append(i)
ans = -1
for i in range(len(a)):
if b[0] <= a[i] and a[i] <= b[-1]:
ans = a[i]
break
print(ans) | 1 | 56,450,401,015,140 | null | 203 | 203 |
round = int(input())
points =[0, 0]
for r in range(round):
taro, hanako = input().split(" ")
if taro == hanako:
points[0] += 1
points[1] += 1
elif taro > hanako:
points[0] += 3
elif taro < hanako:
points[1] += 3
print(*points) | n = int(input())
a = [[i for i in input().split()] for i in range(n)]
taroup = 0
hanakop = 0
for i in range(n):
array =[]
array.append(a[i][0])
array.append(a[i][1])
array.sort()
if array[1] == a[i][0] and array[1] != a[i][1]:
taroup += 3
elif array[1] == a[i][1] and array[1] != a[i][0]:
hanakop += 3
elif array[0] == array[1]:
taroup += 1
hanakop += 1
print(str(taroup)+" "+str(hanakop)) | 1 | 1,999,108,088,800 | null | 67 | 67 |
a,b=input().split()
a=int(a)
b=int(b)
if a%b==0:
print(int(a/b))
else:
print(int((a/b)+1)) | n = int(input())
X_MAX = 50001
for x in range(X_MAX):
if int(x * 1.08) == n:
print(x)
exit()
print(":(") | 0 | null | 101,424,547,508,732 | 225 | 265 |
n,ms = map(int, input().split())
a = [list(map(str, input().split())) for _ in range(n)]
total = 0
for i in a:
tmp = int(i[1]) - ms
if tmp <= 0:
total += ms + tmp
print("{} {}".format(i[0], total))
else:
total += ms
a.append([i[0], tmp])
| kazu = int(input())
kazu2 = (kazu % 100) % 10
if kazu2 == 3:
print("bon")
elif kazu2 == 0 or kazu2 == 1 or kazu2 == 6 or kazu2 == 8:
print("pon")
else:
print("hon") | 0 | null | 9,647,646,230,430 | 19 | 142 |
# -*- coding: utf-8 -*-
N,K=map(int,input().split())
MOD=998244353
D=[0]*(N+1)
D[1]=1
S=dict()
B=dict()
for i in range(K):
L,R=map(int,input().split())
S[i]=(L,R)
B[i]=0
for i in range(2,N+1):
for j in range(K):
L,R=S[j][0],S[j][1]
if i-L>0: B[j]+=D[i-L]
if i-R-1>0: B[j]-=D[i-R-1]
D[i]+=B[j]
D[i]%=998244353
print(D[N]) | n = int(input())
a = list(map(int,input().split()))
import sys
lim = [0]*(n+1)
aa = 0
for i in range(n+1):
aa += a[n-i]
lim[n-i] = aa
if n == 0:
if a[0] != 1:
print(-1)
sys.exit()
else:
print(1)
sys.exit()
if a[0] != 0:
print(-1)
sys.exit()
ha = [[0]*(n+1) for i in range(2)]
ha[0][0] = 1
ha[1][0] = 1
for i in range(n):
ha[1][i+1] = min(ha[0][i]*2 , lim[i+1])
ha[0][i+1] = ha[1][i+1] - a[i+1]
if ha[0][i+1] <= 0 and i != n-1:
print(-1)
sys.exit()
if ha[0][i+1] < 0 and i == n-1:
print(-1)
sys.exit()
print(sum(ha[1])) | 0 | null | 10,743,990,952,068 | 74 | 141 |
from itertools import accumulate
# k個選んだ時の最小値と最大値が分かれば、個数が分かる？？
n,k = list(map(int, input().split()))
cumsum = list(accumulate(range(n+1)))
cumsum_r = list(accumulate(range(n+1)[::-1]))
MOD = 10**9 + 7
ans = 0
for i in range(k, n+2):
_min, _max = cumsum[i-1], cumsum_r[i-1]
ans = (ans + _max - _min + 1) % MOD
print(ans) | from itertools import accumulate
import sys
input = sys.stdin.readline
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort(reverse=True)
lb = 0
ub = 2*10**5+1
while ub - lb > 1:
m = (lb + ub) // 2
cnt = 0
s, t = 0, N-1
while t >= 0:
while s < N and A[s] + A[t] >= m:
s += 1
cnt += s
t -= 1
if cnt >= M:
lb = m
else:
ub = m
accum = list(accumulate([0] + A))
ans = 0
cnt = 0
s, t = 0, N-1
while t >= 0:
while s < N and A[s] + A[t] >= lb:
s += 1
ans += accum[s] + s * A[t]
cnt += s
t -= 1
print(ans - (cnt-M) * lb)
| 0 | null | 70,873,131,227,062 | 170 | 252 |
def fibonacci(n, memo=None):
if memo==None:
memo = [None]*n
if n<=1:
return 1
else:
if memo[n-2]==None:
memo[n-2] = fibonacci(n-2, memo)
if memo[n-1]==None:
memo[n-1] = fibonacci(n-1, memo)
return memo[n-1] + memo[n-2]
n = int(input())
print(fibonacci(n)) | #coding:utf-8
n = int(input())
numbers = list(map(int, input().split()))
def selectionSort(ary):
count = 0
for i in range(len(ary)):
minj = i
for j in range(i, len(ary)):
if ary[minj] > ary[j]:
minj = j
if minj != i:
ary[minj], ary[i] = ary[i], ary[minj]
count += 1
return (ary, count)
result = selectionSort(numbers)
print(*result[0])
print(result[1]) | 0 | null | 10,689,564,640 | 7 | 15 |
import math, itertools
n = int(input())
X = list(list(map(int,input().split())) for _ in range(n))
L = list(itertools.permutations(range(n),n))
ans = 0
for l in L:
dist = 0
for i in range(n-1):
s,t = l[i],l[i+1]
vx = X[s][0] - X[t][0]
vy = X[s][1] - X[t][1]
dist += math.sqrt(vx**2 + vy**2)
ans += dist
print(ans/len(L)) | A, B, C = map(int, input().split())
K = int(input())
while B <= A and K:
B *= 2
K -= 1
while C <= B and K:
C *= 2
K -= 1
print('Yes' if A < B < C else 'No')
| 0 | null | 77,531,337,970,740 | 280 | 101 |
#初期定義
global result
global s_list
result = 0
#アルゴリズム：ソート
def merge(left, mid, right):
global result
n1 = mid - left
n2 = right - mid
inf = 10**9
L_list = s_list[left: mid] + [inf]
R_list = s_list[mid: right] + [inf]
i = 0
j = 0
for k in range(left, right):
result += 1
if L_list[i] <= R_list[j]:
s_list[k] = L_list[i]
i += 1
else:
s_list[k] = R_list[j]
j += 1
#アルゴリズム：マージソート
def mergeSort(left, right):
if (left + 1) < right:
mid = (left + right) // 2
mergeSort(left, mid)
mergeSort(mid, right)
merge(left, mid, right)
#初期値
n = int(input())
s_list = list(map(int, input().split()))
#処理の実行
mergeSort(0, n)
#結果の表示
print(" ".join(map(str, s_list)))
print(result)
| from sys import stdin, maxsize
def stdinput():
return stdin.readline().strip()
def main():
n = int(stdinput())
*A, = map(int, stdinput().split(' '))
o = mergeSort(A, 0, n)
print(*A)
print(o)
def merge(A, left, mid, right):
L = A[left:mid]
R = A[mid:right]
cap = maxsize
L.append(cap)
R.append(cap)
i = j = 0
for k in range(left, right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
return i + j
def mergeSort(A, left, right):
o = 0
if left + 1 < right:
mid = (left + right) // 2
o += mergeSort(A, left, mid)
o += mergeSort(A, mid, right)
o += merge(A, left, mid, right)
return o
if __name__ == '__main__':
main()
# import cProfile
# cProfile.run('main()')
| 1 | 109,614,104,588 | null | 26 | 26 |
N,K=map(int,input().split())
MOD = 998244353
dp = [0]*(N+1)
LR = []
for _ in range(K):
l, r = map(int, input().split())
LR.append((l,r))
LR.sort()
dp[1] = 1
dp_sum = [0]*(N+1) # dp[i]の累積和
dp_sum[1] = 1
for i in range(2, N+1):
for l, r in LR:
if i - l >= 1:
dp[i] += dp_sum[i-l] - dp_sum[max(0, i-r-1)]
dp[i] %= MOD
dp[i] %= MOD
dp_sum[i] = dp_sum[i-1] + dp[i]
print(dp[N]%MOD) | n = int(input())
a = list(map(int, input().split()))
a = a + [0]
state = a[0]
money = 1000
stock = 0
for i in range(1, n+1):
if state < a[i] and stock == 0:
stock += (money // state)
money %= state
elif state > a[i] and stock > 0:
money += (stock * state)
stock = 0
state = a[i]
print(money)
| 0 | null | 5,036,056,148,410 | 74 | 103 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
from collections import deque
import bisect
n, k = map(int, readline().split())
a = list(map(int, readline().split()))
a.sort()
que = deque()
if n == k:
que.extend(a)
elif a[-1] < 0 and k % 2 == 1:
que.extend(a)
for _ in range(n - k):
que.popleft()
else:
b = [[] for _ in range(n)]
for i in range(n):
b[i] = [abs(a[i]), a[i]]
b.sort(reverse=True)
b = deque(b)
que1 = deque()
que2 = deque()
sign = 1
for i in range(k):
val_abs, val = b.popleft()
if val > 0:
que1.append(val_abs)
elif val < 0:
que2.append(val_abs)
sign *= -1
else:
print(0)
return
if sign == -1:
add1, add2 = 0, 0
rmv1, rmv2 = 10 ** 19, 10 ** 19
if que1:
rmv1 = que1[-1]
for x_abs, x in b:
if x < 0:
add1 = x_abs
break
if que2:
rmv2 = que2[-1]
for x_abs, x in b:
if x > 0:
add2 = x_abs
break
if add1 == add2:
print(0)
return
if add1 * rmv2 > add2 * rmv1:
que2.append(add1)
que1.pop()
else:
que1.append(add2)
que2.pop()
que.extend(que1)
que.extend(que2)
while len(que) > 1:
que.append(que.popleft() * que.popleft())
print(que.popleft() % MOD)
if __name__ == '__main__':
main()
| from math import log10
n, k = map(int, input().split())
a = list(map(int, input().split()))
MOD = 10**9+7
a.sort()
cnt_neg = 0
cnt_pos = 0
for i in a:
if i <= 0:
cnt_neg += 1
else:
cnt_pos += 1
is_minus = False
k_tmp = k
while k_tmp > 0:
if k_tmp >= 2:
if cnt_neg >= 2:
cnt_neg -= 2
elif cnt_pos >= 2:
cnt_pos -= 2
else:
is_minus = True
break
k_tmp -= 2
else:
if cnt_pos > 0:
cnt_pos -= 1
k_tmp -= 1
else:
is_minus = True
break
k_1 = k
ans1 = 1
l = 0
r = n - 1
if k_1 % 2:
ans1 *= a[-1]
r -= 1
k_1 -= 1
while k_1 >= 2:
if a[l] * a[l+1] > a[r-1] * a[r]:
ans1 *= a[l] * a[l+1]
l += 2
else:
ans1 *= a[r-1] * a[r]
r -= 2
k_1 -= 2
ans1 %= MOD
a.sort(key=abs)
# print(a)
ans2 = 1
for i in a[:k]:
ans2 *= i
ans2 %= MOD
if is_minus:
print(ans2)
else:
print(ans1)
| 1 | 9,334,193,752,572 | null | 112 | 112 |
# coding: UTF-8
from collections import deque
dll = deque()
n = int(input())
for _ in range(n):
raw = input().split()
command = raw[0]
if command == 'delete':
value = raw[1]
try:
dll.remove(value)
except ValueError as err:
continue
elif command == 'insert':
value = raw[1]
dll.appendleft(value)
elif command == 'deleteFirst':
try:
dll.popleft()
except IndexError as err:
continue
elif command == 'deleteLast':
try:
dll.pop()
except IndexError as err:
continue
print(" ".join(dll))
| a, b, c =map(int, input().split())
d=(a-1)//c
e=b//c
ans=e-d
print(ans) | 0 | null | 3,772,546,833,096 | 20 | 104 |
def main():
n = int(input())
A = [int(x) for x in input().split()]
ans = 0
mod = 10 ** 9 + 7
for d in range(60):
# d桁目ごとに考える
x = 0
for a in A:
if (a >> d) & 1:
x += 1
ans += x * (n-x) * 2**d
ans %= mod
print(ans)
if __name__ == '__main__':
main() | n, m = map(int, input().split())
root = [-1]*n
def r(x):
if root[x] < 0:
return x
else:
root[x] = r(root[x])
return root[x]
def unite(x, y):
x = r(x)
y = r(y)
if x == y:
return
root[x] += root[y]
root[y] = x
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
unite(a, b)
ans = 0
for i in range(n):
ans = max(ans, -root[i])
print(ans)
| 0 | null | 63,507,521,418,782 | 263 | 84 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
i = 0
while True:
if x-i not in p:
print(x-i)
break
if x+i not in p:
print(x+i)
break
i += 1 | from collections import defaultdict as dd
from collections import deque
import bisect
import heapq
def ri():
return int(input())
def rl():
return list(map(int, input().split()))
def solve():
n = ri()
if n >= 30:
print ("Yes")
else:
print ("No")
mode = 's'
if mode == 'T':
t = ri()
for i in range(t):
solve()
else:
solve()
| 0 | null | 9,887,449,940,720 | 128 | 95 |
k = int(input())
a,b = map(int,input().split())
x = (b // k) * k
if a <= x <= b :
print('OK')
else :
print('NG') | N = int(input())
A = []
for i in range(N):
a = int(input())
xy = [list(map(int, input().split())) for _ in range(a)]
A.append([a, xy])
# print(A)
# 下からi桁目のbitが1->人iは正直
# 下からi桁目のbitが0->人iは不親切
# 不親切な人の証言は無視して良い
ans = 0
for i in range(2**N):
for j in range(N):
flag = 0
if (i >> j) & 1:
for k in range(A[j][0]):
l = A[j][1][k][0]
m=A[j][1][k][1]
# print(i,j,k,(l,m),(i >> (l-1)))
if not (i >> (l-1)) & 1 == A[j][1][k][1]:
flag = 1
break
if flag == 1:
break
else:
# print(bin(i))
ct = 0
for l in range(N):
ct += ((i >> l) & 1)
ans = max(ans, ct)
print(ans)
| 0 | null | 73,943,630,978,324 | 158 | 262 |
s = input()[::-1]
size = len(s)
s += "4"
ans = 0
bef = 0
for i in range(size):
v1 = int(s[i])
v2 = int(s[i+1])
if v1+bef>=6 or (v1+bef>=5 and v2>=5):
ans += 10-(v1+bef)
bef = 1
else:
ans += (v1+bef)
bef = 0
ans += bef
print(ans) | S = input()
L = len(S)
INF = float('inf')
dp = [[INF]*(L+1) for _ in range(2)]
dp[0][0] = 0
for i in range(L):
d = int(S[-1-i])
dp[0][i+1] = min(dp[0][i], dp[1][i]) + d
dp[1][i+1] = min(dp[0][i] + 10-d+1, dp[1][i] + 10-d-1)
print(min(dp[0][-1], dp[1][-1])) | 1 | 70,892,088,413,162 | null | 219 | 219 |
# -*- coding: utf-8 -*-
import sys
import math
import os
import itertools
import string
import heapq
import _collections
from collections import Counter
from collections import defaultdict
from collections import deque
from functools import lru_cache
import bisect
import re
import queue
import decimal
class Scanner():
@staticmethod
def int():
return int(sys.stdin.readline().rstrip())
@staticmethod
def string():
return sys.stdin.readline().rstrip()
@staticmethod
def map_int():
return [int(x) for x in Scanner.string().split()]
@staticmethod
def string_list(n):
return [Scanner.string() for i in range(n)]
@staticmethod
def int_list_list(n):
return [Scanner.map_int() for i in range(n)]
@staticmethod
def int_cols_list(n):
return [Scanner.int() for i in range(n)]
class Math():
@staticmethod
def gcd(a, b):
if b == 0:
return a
return Math.gcd(b, a % b)
@staticmethod
def lcm(a, b):
return (a * b) // Math.gcd(a, b)
@staticmethod
def divisor(n):
res = []
i = 1
for i in range(1, int(n ** 0.5) + 1):
if n % i == 0:
res.append(i)
if i != n // i:
res.append(n // i)
return res
@staticmethod
def round_up(a, b):
return -(-a // b)
@staticmethod
def is_prime(n):
if n < 2:
return False
if n == 2:
return True
if n % 2 == 0:
return False
d = int(n ** 0.5) + 1
for i in range(3, d + 1, 2):
if n % i == 0:
return False
return True
@staticmethod
def fact(N):
res = {}
tmp = N
for i in range(2, int(N ** 0.5 + 1) + 1):
cnt = 0
while tmp % i == 0:
cnt += 1
tmp //= i
if cnt > 0:
res[i] = cnt
if tmp != 1:
res[tmp] = 1
if res == {}:
res[N] = 1
return res
def pop_count(x):
x = x - ((x >> 1) & 0x5555555555555555)
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
x = x + (x >> 32)
return x & 0x0000007f
MOD = int(1e09) + 7
INF = int(1e15)
def modinv(a):
b = MOD
u = 1
v = 0
while b:
t = a // b
a -= t * b
a, b = b, a
u -= t * v
u, v = v, u
u %= MOD
if u < 0:
u += MOD
return u
def factorial(N):
if N == 0 or N == 1:
return 1
res = N
for i in range(N - 1, 1, -1):
res *= i
res %= MOD
return res
def solve():
X, Y = Scanner.map_int()
if (X + Y) % 3 != 0:
print(0)
return
B = (2 * Y - X) // 3
A = (2 * X - Y) // 3
if A < 0 or B < 0:
print(0)
return
n = factorial(A + B)
m = factorial(A)
l = factorial(B)
ans = n * modinv(m * l % MOD) % MOD
print(ans)
def main():
# sys.setrecursionlimit(1000000)
# sys.stdin = open("sample.txt")
# T = Scanner.int()
# for _ in range(T):
# solve()
# print('YNeos'[not solve()::2])
solve()
if __name__ == "__main__":
main()
| x,y = list(map(int, input().split()))
if (x+y) % 3 != 0:
print(0)
exit()
a = (2*x - y) // 3
b = (2*y - x) // 3
if a < 0 or b < 0:
# (x,y) = (1,5)とかは無理
print(0)
exit()
MOD = 10**9+7
def fact(x):
f = 1
for i in range(2, x+1):
f *= i
f %= MOD
return f
def fact_inv(x):
return pow(fact(x), MOD-2, MOD)
ans = fact(a+b) * fact_inv(a) * fact_inv(b) % MOD
print(ans) | 1 | 149,721,791,646,768 | null | 281 | 281 |
#coding: utf-8
import math
n = int(input())
x = [int(i) for i in input().split(" ")]
y = [int(i) for i in input().split(" ")]
d1 = d2 = d3 = di = 0
for i in range(n):
d1 += abs(x[i] - y[i])
d2 += abs(x[i] - y[i])**2
d3 += abs(x[i] - y[i])**3
if di < abs(x[i] - y[i]):
di = abs(x[i] - y[i])
print(d1)
print(math.pow(d2, 1.0/2.0))
print(math.pow(d3, 1.0/3.0))
print(di)
| s = str(input())
nikname = s[0:3]
print(nikname) | 0 | null | 7,540,507,990,912 | 32 | 130 |
#!/usr/bin/env python3
print("x"*len(input()))
| W = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
S = input()
print(len(W) - W.index(S))
| 0 | null | 102,685,361,607,422 | 221 | 270 |
# import itertools
# import math
import sys
sys.setrecursionlimit(500*500)
# import numpy as np
from collections import deque
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# A_B = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# edges = [list(map(int,input().split())) for _ in range(M)]
# tree = [[] for _ in range(N + 1)]
# for edge in edges:
# tree[edge[0]].append([edge[1], edge[2]])
# tree[edge[1]].append([edge[0], edge[2]])
# depth = [-1] * (N + 1)
# depth[1] = 0
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
# def factorization(n):
# arr = []
# temp = n
# for i in range(2, int(-(-n**0.5//1))+1):
# if temp%i==0:
# cnt=0
# while temp%i==0:
# cnt+=1
# temp //= i
# arr.append([i, cnt])
# if temp!=1:
# arr.append([temp, 1])
# if arr==[]:
# arr.append([n, 1])
# return arr
tree = [[] for _ in range(N + 1)]
edges = [list(map(int,input().split())) for _ in range(M)]
for edge in edges:
tree[edge[0]].append(edge[1])
tree[edge[1]].append(edge[0])
depth = [-1] * (N + 1)
depth[1] = 0
d = deque()
d.append(1)
ans = [0] * (N + 1)
while d:
v = d.popleft()
for i in tree[v]:
if depth[i] != -1:
continue
depth[i] = depth[v] + 1
ans[i] = v
d.append(i)
# ans = depth[2:]
print('Yes')
print(*ans[2:], sep="\n") | dict = {}
n = int(raw_input())
for _ in xrange(n):
com, word = raw_input().split()
if com == "insert":
dict[word] = True
else:
if word in dict:
print "yes"
else:
print "no" | 0 | null | 10,229,112,869,360 | 145 | 23 |
S = input()
T = input()
ans = ''
if len(T) != len(S) + 1:
ans = 'No'
else:
ans = 'Yes'
for i in range(len(S)):
if S[i] != T[i]:
ans = 'No'
print(ans) | a=input()
b=input()
if(a==b[0:len(b)-1] and len(b)-len(a)==1):
print('Yes')
else:
print('No') | 1 | 21,454,783,538,058 | null | 147 | 147 |
from collections import deque
def round_robin_scheduling(n, q, A):
sum = 0
while A:
head = A.popleft()
if head[1] <= q:
sum += head[1]
print(head[0], sum)
else:
sum += q
head[1] -= q
A.append(head)
if __name__ == '__main__':
n, q = map(int, input().split())
A = deque()
for i in range(n):
name, time = input().split()
A.append([name, int(time)])
round_robin_scheduling(n, q, A) | # 逆元を利用した組み合わせの計算
#############################################################
def cmb(n, r, mod):
if (r < 0 or r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % mod
mod = 10**9 + 7
NN = 10**6
g1 = [1, 1]
g2 = [1, 1]
inverse = [0, 1]
for i in range(2, NN + 1):
g1.append((g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
g2.append((g2[-1] * inverse[-1]) % mod)
#############################################################
N, K = map(int, input().split())
# M = 空き部屋数の最大値
M = min(N - 1, K)
"""
m = 0,1,2,...,M
N部屋から、空き部屋をm個選ぶ
-> N_C_m
残りの(N-m)部屋に、N人を配置する（空き部屋が出来てはいけない）
まず、(N-m)部屋に1人ずつ配置し、残ったm人を(N-m)部屋に配置する
これは、m個のボールと(N-m-1)本の仕切りの並び替えに相当する
-> (m+N-m-1)_C_m = N-1_C_m
"""
ans = 0
for m in range(0, M + 1):
ans += cmb(N, m, mod) * cmb(N - 1, m, mod)
ans %= mod
print(ans)
| 0 | null | 33,771,715,393,478 | 19 | 215 |
S = input()
ans = 'ARC' if S == 'ABC' else 'ABC'
print(ans) | n, k = map(int, input().split())
l = [0] * n
for i in range(k):
d = int(input())
a = list(map(int, input().split()))
for j in range(d):
l[a[j] - 1] += 1
count = 0
for i in range(n):
if l[i] == 0:
count += 1
print(count) | 0 | null | 24,461,801,533,440 | 153 | 154 |
N,K = map(int,input().split())
count = N//K
N = abs( N - count*K )
N_2 = abs( N - K )
print( N if N <= N_2 else N_2 ) | x, n = list(map(int, input().split()))
if n == 0:
print(x)
exit(0)
else:
arr = list(map(int, input().split()))
arr.sort()
if x in arr:
i = arr.index(x)
else:
print(x)
exit(0)
if not i and i != 0:
print(x)
exit(0)
j = 1
for _ in range(n):
row = i - j
high = i + j
if x - j not in arr:
print(x - j)
exit(0)
elif x + j not in arr:
print(x + j)
exit(0)
j += 1
print(x-1)
| 0 | null | 26,779,306,461,600 | 180 | 128 |
a= int(input())
b= int(input())
lista=[1, 2, 3]
for x in range(3):
if lista[x] != a and lista[x] != b:
print(lista[x]) |
n = list(map(int, list(input())))[::-1] + [0]
sum1 = sum(n)
for i in range(len(n)-1):
if n[i] > 5 or (n[i]==5 and n[i+1]>4):
n[i] = 10-n[i]
n[i+1] += 1
print(min(sum1, sum(n)))
| 0 | null | 90,885,007,361,732 | 254 | 219 |
import sys
sys.setrecursionlimit(10**6)
n, u, v = map(int, input().split())
u -= 1
v -= 1
graph = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(int, input().split())
graph[a-1].append(b-1)
graph[b-1].append(a-1)
pre = [None]*n
def dfs(node, p_node=-1):
for c_node in graph[node]:
if c_node==p_node:
continue
pre[c_node] = node
dfs(c_node, node)
dfs(u)
path = [v]
now = v
while now!=u:
now = pre[now]
path.append(now)
s1 = path[len(path)//2]
p1 = path[len(path)//2-1]
def dfs2(node, depth, p_node):
mx = depth
for c_node in graph[node]:
if c_node==p_node:
continue
mx = max(mx, dfs2(c_node, depth+1, node))
return mx
print(dfs2(s1, 0, p1)+len(path)//2-1) | import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
def main():
n, m = map(int , input().split())
print(n*(n-1)//2+m*(m-1)//2)
if __name__=="__main__":
main()
| 0 | null | 81,087,694,927,612 | 259 | 189 |
from bisect import bisect_right
N, D, A = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(N)]
X.sort()
place = []
hps = []
for x, h in X:
place.append(x)
hps.append(h)
buf = [0] * (N + 2)
ans = 0
for i in range(N):
# Update
buf[i + 1] += buf[i]
# Calc count
tmp = -(-max(0, hps[i] - buf[i + 1] * A) // A)
ans += tmp
# Calc range
j = bisect_right(place, place[i] + D * 2)
buf[i + 1] += tmp
buf[min(j + 1, N + 1)] -= tmp
print(ans)
| small = []
large = []
while True:
input_a, input_b = map(int, raw_input().split())
if input_a == 0 and input_b == 0:
break
else:
if input_a < input_b:
small.append(input_a)
large.append(input_b)
else:
small.append(input_b)
large.append(input_a)
for (n, m) in zip(small, large):
print n, m | 0 | null | 41,476,543,997,900 | 230 | 43 |
a,b,n = map(int, input().split())
if b == 1:
print (0)
exit()
else:
x = min(b-1,n)
ans = (a*x)//b-a*(x//b)
print (ans) | import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
A, B, N = MI()
if N < B:
x = N
else:
x = B - 1
print(floor(A * x / B))
if __name__ == '__main__':
solve()
| 1 | 28,096,728,603,930 | null | 161 | 161 |
from collections import defaultdict
d=defaultdict(int)
n=int(input())
a=list(map(int,input().split()))
ans=1
mod=10**9+7
d[-1]=3
for i in a:
ans*=d[i-1]
ans%=mod
d[i-1]-=1
d[i]+=1
print(ans) | height = [int(input()) for i in range(10)]
sort = sorted(height, reverse=True)
for i in range(3):
print(sort[i]) | 0 | null | 65,265,879,442,848 | 268 | 2 |
from collections import defaultdict, deque
import math
kMod = 1000000007
N = int(input())
key2count = defaultdict(lambda: [0, 0])
for _ in range(N):
a, b = map(int, input().split())
g = math.gcd(a, b)
if a < 0 or a == 0 and b < 0:
a, b = -a, -b
if g > 0:
a, b = a//g, b//g
idx = 0
if b <= 0:
idx = 1
a, b = -b, a
key2count[(a, b)][idx] += 1
ans = 1
for key, val in key2count.items():
if key == (0, 0):
continue
plus, minus = val
ans *= (pow(2, plus, kMod) + pow(2, minus, kMod)-1)
ans %= kMod
ans += sum(key2count[(0, 0)])
print((ans + kMod-1) % kMod) | n=int(input())
for i in range(50000):
if int(i*1.08)==n:
print(i)
exit()
if i*1.08>n:
break
print(":(") | 0 | null | 73,384,207,823,642 | 146 | 265 |
H,N = map(int,input().split())
A = list(map(int,input().split()))
All = sum(A)
if H - All > 0:
print("No")
else:
print("Yes") | h,n=map(int,input().split())
a=list(map(int,input().split()))
ans=0
if sum(a)>=h:
print('Yes')
else:
print('No') | 1 | 77,744,378,984,750 | null | 226 | 226 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
d = [[-1] * n for _ in range(70)]
for i in range(n):
d[0][i] = a[i] - 1
for i in range(1, 70):
for j in range(n):
d[i][j] = d[i - 1][d[i - 1][j]]
dst = 0
while k:
i = 70
while pow(2, i) & k <= 0:
i -= 1
dst = d[i][dst]
k -= pow(2, i)
print(dst + 1)
| N, K = [int(x) for x in input().split()]
l = []
while N > 0:
l.insert(0, N % K)
N = N // K
print(len(l))
| 0 | null | 43,439,029,083,748 | 150 | 212 |
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9
def main():
n = int(input())
s,t = input().split()
ans = ''
for i in range(n):
ans += s[i] + t[i]
print(ans)
if __name__ == '__main__':
main()
| N = int(input())
S,T = map(str,input().split())
slist = list(S)
tlist = list(T)
new = ''
for i in range(N):
new += slist[i]
new += tlist[i]
print(new) | 1 | 111,792,663,067,470 | null | 255 | 255 |
N = int(input())
mod = 10 ** 9 +7
x = (10**N)%mod
y = (2*(9**N))%mod
z = (8**N)%mod
print((x-y+z)%mod)
| n = int(input())
mod=10**9+7
if n==1:
print(0)
else:
print(((10**n)-(9**n)-(9**n)+(8**n))%mod)
| 1 | 3,199,121,148,310 | null | 78 | 78 |
ch = ord(input().rstrip())
print(chr(ch + 1))
| c = str( input() )
abc = [ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" ]
print( abc[ abc.index( c ) + 1 ] ) | 1 | 92,451,657,256,266 | null | 239 | 239 |
N = int(input())
S = input()
ans = 0
for i in range(10):
for j in range(10):
for k in range(10):
a = [i, j, k]
l = 0
for s in S:
if l < 3 and a[l] == int(s):
l += 1
if l == 3:
ans += 1
print(ans)
| n=int(input())
def f(i):
if n%i==0:
return n//i-1
else:
return n//i
sum=0
for i in range(1,n):
sum+=f(i)
print(sum) | 0 | null | 65,955,444,506,170 | 267 | 73 |
def f(N,K):
n=len(str(N))
if n==1:
if K==1:
return N
else:
return 0
elif n==2:
if K==1:
return 9+N//10
elif K==2:
return N-9-N//10
else:
return 0
elif n==3:
if K==1:
return 18+N//100
elif K==2:
return 81+18*((N//100)-1)+f(N%100,1)
else:
return 81*((N//100)-1)+f(N%100,2)
else:
if K==1:
return 9*(n-1)+N//(10**(n-1))
elif K==2:
return 81*(n-1)*(n-2)/2+9*(n-1)*((N//((10**(n-1))))-1)+f(N%(10**(n-1)),1)
else:
return 243*(n**3-6*(n**2)+11*n-6)/2+81*(n-1)*(n-2)*((N//(10**(n-1)))-1)/2+f(N%(10**(n-1)),2)
N=int(input())
K=int(input())
print(int(f(N,K))) | N=int(input())
p=0
for i in range(N+1):
if i%2==1:
p +=1
print(p/N) | 0 | null | 126,167,867,832,396 | 224 | 297 |
h, w = map(int,input().split())
maze = []
for i in range(h):
t = list(input())
maze.append(t)
dx = [1, 0]
dy = [0, 1]
dp = [[10000]*w for i in range(h)]
if maze[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
for x in range(w):
for y in range(h):
for dxi, dyi in zip(dx, dy):
if not (0<=x+dxi<w and 0<=y+dyi<h):
continue
dp[y+dyi][x+dxi] = min(dp[y+dyi][x+dxi], dp[y][x]+(maze[y][x]=="." and maze[y+dyi][x+dxi]=="#"))
#print(*dp)
print(dp[h-1][w-1]) | import sys
readline = sys.stdin.readline
inf = float('inf')
def main():
H, W = map(int, readline().split())
grid = []
grid.append(['*'] * (W+2))
for _ in range(H):
grid.append(['*'] + list(readline()[:-1]) + ['*'])
grid.append(['*']*(W+2))
DP = [[inf] * (W+2) for _ in range(H+2)]
DP[1][1] = (grid[1][1] == '#')*1
for i in range(1, H+1):
for j in range(1, W+1):
if i == 1 and j == 1:
continue
k = i
gridkj = grid[k][j]
if gridkj == '.':
DP[k][j] = min(DP[k][j-1], DP[k-1][j])
if gridkj == '#':
DP[k][j] = min(DP[k][j-1]+(grid[k][j-1] in ['.', '*']), DP[k-1][j] + (grid[k-1][j] in ['.', '*']))
ans = DP[H][W]
print(ans)
if __name__ == "__main__":
main()
| 1 | 49,498,123,430,592 | null | 194 | 194 |
n = int(input())
a = list(map(int, input().split()))
from collections import defaultdict
d = defaultdict(int)
ans=1
for num in a:
if num==0:
last_cnt=3
tmp = last_cnt - d[num]
else:
last_cnt=d[num-1]
tmp = last_cnt - d[num]
if tmp == 0:
# tmp=1
ans=0
ans*=tmp
ans%=1000000007
d[num]+=1
print(ans) | N = int(input())
a_list = list(map(int, input().split()))
MOD = 10**9 + 7
cnts = [0,0,0]
sames = 0
ind = -1
res = 1
for a in a_list:
for i, cnt in enumerate(cnts):
if cnt == a:
sames += 1
ind = i
res *= sames
res %= MOD
cnts[ind] += 1
sames = 0
print(res) | 1 | 130,260,013,502,272 | null | 268 | 268 |
n = int(input())
ns = [int(i) for i in input().split()]
ns.reverse()
if len(ns) > n:
del ns[:(len(ns) - n)]
for i in ns:
if i != ns[-1]:
print(i,end=' ')
else:
print(i,end='')
print() | def sub(strings, listseq):
for index in listseq:
strings = strings[index:] + strings[:index]
return strings
def main():
while True:
strings = input()
if strings == "-": break
times = int(input())
list1 = [int(input()) for i in range(times)]
print(sub(strings, list1))
main()
| 0 | null | 1,421,232,450,120 | 53 | 66 |
from collections import deque
N,u,v=map(int,input().split())
u-=1;v-=1
G=[[] for i in range(N)]
for i in range(N-1):
a,b=map(int,input().split())
a-=1;b-=1
G[a].append(b)
G[b].append(a)
if len(G[u])==1 and G[u][0]==v:
print(0)
exit()
distu=[-1 for i in range(N)]
q=deque([])
q.append(u)
while(len(q)>0):
r=q.pop()
for p in G[r]:
if distu[p]!=-1:
continue
distu[p]=distu[r]+1
q.append(p)
distv=[-1 for i in range(N)]
q=deque([])
q.append(v)
while(len(q)>0):
r=q.pop()
for p in G[r]:
if distv[p]!=-1:
continue
distv[p]=distv[r]+1
q.append(p)
dist=[distv[i] if distu[i]<=distv[i] else 0 for i in range(N)]
print(max(dist))
| import queue
N, U, V = map(int, input().rstrip().split())
U -= 1
V -= 1
v2e = [set() for _ in range(N)]
for _ in range(N-1):
a, b = map(lambda x: int(x)-1, input().rstrip().split())
v2e[a].add(b)
v2e[b].add(a)
q = queue.Queue()
q.put(U)
p = [-1] * N
p[U] = U
while True:
a = q.get()
if a == V:
break
for b in v2e[a]:
if p[b] == -1:
p[b] = a
q.put(b)
a = V
min_p = []
while True:
min_p.append(a)
if a == U:
break
a = p[a]
p = [-1] * N
p[min_p[(len(min_p)-1)//2-len(min_p)%2]] = min_p[(len(min_p)-1)//2-len(min_p)%2]
for a in v2e[min_p[(len(min_p)-1)//2-len(min_p)%2]]:
p[a] = a
p[min_p[-len(min_p)//2+len(min_p)%2]] = min_p[-len(min_p)//2+len(min_p)%2]
q = queue.Queue()
q.put((min_p[-len(min_p)//2+len(min_p)%2], 0))
while q.qsize() > 0:
a, d = q.get()
for b in v2e[a]:
if p[b] == -1:
p[b] = a
q.put((b, d + 1))
print(d + (len(min_p) - 2) // 2 + len(min_p) % 2) | 1 | 117,270,158,211,130 | null | 259 | 259 |
N = int(input())
dic = {}
for i in range(N):
s = str(input())
if s in dic:
dic[s] += 1
else:
dic[s] = 1
S = sorted(dic.values())
t = S[-1]
X = []
for key in dic:
if dic[key] == t:
X.append(key)
x = sorted(X)
for i in range(len(X)):
print(x[i]) | from collections import defaultdict
dic = defaultdict(int)
N = int(input())
for i in range(N):
temp = str(input())
dic[temp] += 1
MAX = max(dic.values())
ans = []
for x in dic.keys():
if dic[x] == MAX:
ans.append(x)
ans.sort()
print(*ans,sep="\n") | 1 | 69,678,587,948,128 | null | 218 | 218 |
import bisect,collections,copy,itertools,math,string
def I(): return int(input())
def S(): return input()
def LI(): return list(map(int,input().split()))
def LS(): return list(input().split())
##################################################
H,W = LI()
S = [S() for _ in range(H)]
dp = [[-1]*W for _ in range(H)]
for i in range(H):
for j in range(W):
judge = 1 if S[i][j]=='#' else 0
if i==0: #0行目
if j==0:
dp[0][0] = judge
else:
dp[0][j] = dp[0][j-1]+judge*(0 if S[0][j-1]=='#' else 1)
else: #0行目以外
if j==0:
dp[i][0] = dp[i-1][0]+judge*(0 if S[i-1][j]=='#' else 1)
else:
temp1 = dp[i][j-1]+judge*(0 if S[i][j-1]=='#' else 1)
temp2 = dp[i-1][j]+judge*(0 if S[i-1][j]=='#' else 1)
dp[i][j] = min(temp1,temp2)
print(dp[-1][-1])
| h,w = map(int,input().split())
B = [input() for _ in range(h)]
dp=[]
def ch(x1,y1,x2,y2):
if B[x1][y1]=='.' and B[x2][y2]=='#':
return 1
else:
return 0
dp = [[0 for j in range(w)] for i in range(h)]
for i in range(h):
for j in range(w):
if i==0 and j==0 and B[i][j]=='#':
dp[i][j]+=1
elif i==0:
dp[i][j] = dp[i][j-1]+ch(i,j-1,i,j)
elif j==0:
dp[i][j] = dp[i-1][j]+ch(i-1,j,i,j)
else:
dp[i][j] = min(dp[i][j-1]+ch(i,j-1,i,j),dp[i-1][j]+ch(i-1,j,i,j))
print(dp[h-1][w-1]) | 1 | 49,587,287,567,128 | null | 194 | 194 |
x=int(input())
X=x%100
Y=x//100
if X>5*Y:
print('0')
else:
print('1') | w,h,x,y,r=map(int,input().split())
print(['No','Yes'][r<=x<=w-r and r<=y<=h-r]) | 0 | null | 63,945,873,216,150 | 266 | 41 |
import math
a,b,C=map(int,input().split())
c=C/180*math.pi
d=math.sqrt(a**2+b**2-2*a*b*math.cos(c))
S=1/2*a*b*math.sin(c)
L=a+b+d
h=2*S/a
print("{:.8f}".format(S))
print("{:.8f}".format(L))
print("{:.8f}".format(h))
| n = int(input())
s,t = list(map(str,input().split()))
string = []
for i in range(len(s)):
string.append(s[i])
string.append(t[i])
print(''.join(string)) | 0 | null | 56,290,981,547,490 | 30 | 255 |
# 累積和
import numpy as np
from numba import njit
@njit(cache=True)
def loop(n, k, A):
for _ in [0] * k:
B = np.zeros(n + 1, dtype=np.int64)
for i in range(n):
left = max(0, i - A[i])
right = min(n, i + A[i] + 1)
B[left] += 1
B[right] -= 1
A = np.cumsum(B)[:-1]
#print(A)
if np.all(A == n):
return A
break
return A
def main():
n, k = map(int, input().split())
a = list(map(int, input().split()))
A = np.array(a, dtype=np.int64)
A = loop(n, k, A)
print(*A)
if __name__ == "__main__":
main()
| class Flood:
"""
begin : int
水たまりの始まる場所
area : int
水たまりの面積
"""
def __init__(self, begin, area):
self.begin = begin
self.area = area
down_index_stack = [] # \の場所
flood_stack = [] # (水たまりの始まる場所, 面積)
for i, c in enumerate(input()):
if c == '\\':
down_index_stack.append(i)
if c == '/':
if len(down_index_stack) >= 1: # 現在の/に対応する\が存在したら
l = down_index_stack.pop() # 現在の水たまりの始まる場所
area = i - l # 現在の水たまりの現在の高さの部分の面積はi-l
# 現在の水たまりが最後の水たまりを内包している間は
# (現在の水たまりの始まる場所が最後の水たまりの始まる場所より前にある間は)
while len(flood_stack) >= 1 and l < flood_stack[-1].begin:
# 最後の水たまりを現在の水たまりに取り込む
last_flood = flood_stack.pop()
area += last_flood.area
flood_stack.append(Flood(l, area)) # 現在の水たまりを最後の水たまりにして終了
area_list = [flood.area for flood in flood_stack]
print(sum(area_list))
print(' '.join(list(map(str, [len(area_list)] + area_list))))
| 0 | null | 7,675,978,575,980 | 132 | 21 |
s = input()
if s[len(s)-1] == 's':
s = s + 'es'
elif s[len(s)-1] != 's':
s = s + 's'
print(s)
| N = input()
if N.endswith('s'):
print(N + 'es')
else:
print(N + 's')
| 1 | 2,381,253,683,248 | null | 71 | 71 |
S = list(input())
N = len(S)
if S == S[::-1] and S[:(N - 1) // 2] == S[:(N - 1) // 2][::-1] and S[(N - 1) // 2 + 1:] == S[(N - 1) // 2 + 1:][::-1]:
print("Yes")
else:
print("No")
| s = list(input())
n = len(s)
if (
s[: (n - 1) // 2] == s[: (n - 1) // 2][::-1]
and s[(n + 1) // 2 :] == s[(n + 1) // 2 :][::-1]
and s == s[::-1]
):
print("Yes")
else:
print("No")
| 1 | 46,395,913,219,520 | null | 190 | 190 |
from collections import deque
N = int(input())
d = deque([])
for i in range(N):
a = input()
if a == "deleteFirst":
d.popleft()
elif a == "deleteLast":
d.pop()
else:
a, b = a.split()
if a == "insert":
d.appendleft(b)
else:
try:
d.remove(b)
except:
pass
print(*d)
| import collections
q = collections.deque()
n = int(input())
for i in range(n):
com = input().split()
if com[0] == 'insert':
q.appendleft(int(com[1]))
elif com[0] == 'delete':
try:
q.remove(int(com[1]))
except:
pass
elif com[0] == 'deleteFirst':
q.popleft()
elif com[0] == 'deleteLast':
q.pop()
print(*q) | 1 | 49,684,884,960 | null | 20 | 20 |
n = int(input())
rem = n%1000
if rem!=0:rem = 1000 - rem
print(rem) | n, k = map(int, input().split())
a = list(map(int, input().split()))
for i in range(k-1, n-1):
print("Yes" if a[i+1] > a[i-k+1] else "No") | 0 | null | 7,740,311,252,530 | 108 | 102 |
if int(input()) % 9 == 0:
print("Yes")
else:
print("No") | n=int(input())
s=0
for i in str(n):
s+=int(i)
if(s%9==0):
print("Yes")
else:
print("No") | 1 | 4,393,708,024,730 | null | 87 | 87 |
[a,b,c] = map(int,input().split())
n = 0
i = a
while i <= b:
if c % i == 0:
n += 1
i += 1
print(n) | a,b,c = list(map(int,input().split(" ")))
div=0
for i in range(a,b+1):
if c % i == 0:
div += 1
print(div) | 1 | 548,618,699,620 | null | 44 | 44 |
from collections import defaultdict
from collections import deque
from collections import OrderedDict
import itertools
from sys import stdin
input = stdin.readline
def main():
N = int(input())
set_ = set()
for i in range(N):
set_.add(input()[:-1])
print(len(set_))
if(__name__ == '__main__'):
main()
| n=int(input())
l=[]
for i in range(n):
s=str(input())
l.append(s)
k=set(l)
print(len(k)) | 1 | 30,312,991,309,370 | null | 165 | 165 |
from sys import stdin
from collections import deque
n = int(stdin.readline())
g = [None] * n
for _ in range(n):
u, _, *cs = [int(s) for s in stdin.readline().split()]
g[u-1] = [c - 1 for c in cs]
ds = [-1] * n
v = [False] * n
v[0] = True
q = deque([(0, 0)])
while len(q):
u, d = q.popleft()
ds[u] = d
for c in g[u]:
if not v[c]:
v[c] = True
q.append((c, d + 1))
for u, d in enumerate(ds):
print(u + 1, d) | #!/usr/bin/env python
from __future__ import division, print_function
from sys import stdin
from Queue import Queue
def main():
num = int(stdin.readline())
L = []
for _ in xrange(num):
L.append([int(s) for s in stdin.readline().split()[2:]])
d = [-1] * num
d[0] = 0
q = Queue(100)
q.put(0)
while not q.empty():
u = q.get()
for v in L[u]:
if d[v-1] < 0:
d[v-1] = d[u] + 1
q.put(v-1)
for i, v in enumerate(d):
print(i+1, v)
main() | 1 | 4,602,504,720 | null | 9 | 9 |
N = int(input())
S = set([input() for n in range(N)])
print(len(S)) | n,m = map(int,input().split())
s = input()
s = s[::-1]
tmp = 0
sum1 = 0
ans = []
while tmp < n:
for i in range(m, 0, -1):
flag = False
if tmp + i <= n:
if s[tmp+i] == '0':
tmp += i
flag = True
sum1 += 1
ans.append(i)
break
if not flag:
print(-1)
exit()
for i in ans[::-1]:
print(i, end = ' ')
| 0 | null | 84,921,743,216,810 | 165 | 274 |
N, X, M = map(int, input().split())
visited = [False] * M
tmp = X
total_sum = X
visited[tmp] = True
total_len = 1
while True:
tmp = (tmp ** 2) % M
if visited[tmp]:
loop_start_num = tmp
break
total_sum += tmp
visited[tmp] = True
total_len += 1
path_len = 0
tmp = X
path_sum = 0
while True:
if tmp == loop_start_num:
break
path_len += 1
path_sum += tmp
tmp = (tmp ** 2) % M
loop_len = total_len - path_len
loop_sum = total_sum - path_sum
result = 0
if N <= path_len:
tmp = X
for i in range(N):
result += X
tmp = (tmp ** 2) % M
print(result)
else:
result = path_sum
N -= path_len
loops_count = N // loop_len
loop_rem = N % loop_len
result += loop_sum * loops_count
tmp = loop_start_num
for i in range(loop_rem):
result += tmp
tmp = (tmp ** 2) % M
print(result)
# print("loop_start_num", loop_start_num)
# print("path_sum", path_sum)
# print("loop_sum", loop_sum)
| from fractions import gcd
n, m = [int(x) for x in input().split()]
a_list = [int(x) for x in input().split()]
a_h_list = [a // 2 for a in a_list]
count = set()
for a_h in a_h_list:
temp = bin(a_h)
count.add(len(temp) - temp.rfind("1"))
if len(count) == 1:
temp = 1
for a_h in a_h_list:
temp *= a_h // gcd(a_h, temp)
ans = (m // temp + 1) // 2
else:
ans = 0
print(ans) | 0 | null | 52,181,645,103,758 | 75 | 247 |
if __name__ == '__main__':
nums = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = [int(i) for i in input().split()]
nums[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(' ' + ' '.join([str(i) for i in nums[b][f]]))
if b == 3: break
print('#'*20) | # -*- coding: utf-8 -*-
class residence(object):
def __init__(self):
one = [0] * 10
two = [0] * 10
three = [0] * 10
self.all = [one, two, three]
residences = [ ]
for i in xrange(4):
residences.append(residence())
n = int(raw_input())
for i in xrange(n):
b, f, r, v = map(int, raw_input().split())
residences[b-1].all[f-1][r-1] += v
for i, residence in enumerate(residences):
for floor in residence.all:
print '',
for index, num in enumerate(floor):
if index == len(floor) - 1:
print num
else:
print num,
if i != len(residences) - 1:
print '####################' | 1 | 1,099,947,577,308 | null | 55 | 55 |
n, q = map(int, input().split())
process = []
for _ in range(n):
name, time = input().split()
process.append([name, int(time)])
process.append([])
def reduce(index):
left_time = process[index][1] - q
return [process[index][0], left_time]
head = 0
tail = n
quene_len = len(process)
elapsed_time = 0
while head != tail:
if process[head][1] > q:
process[tail] = reduce(head)
elapsed_time += q
head = (head+1)%quene_len
tail = (tail+1)%quene_len
else:
elapsed_time += process[head][1]
print(process[head][0], elapsed_time)
head = (head+1)%quene_len
| s=int(input())
h=s//3600
s-=h*3600
m=s//60
s-=m*60
print(str(h)+":"+str(m)+":"+str(s)) | 0 | null | 192,205,031,172 | 19 | 37 |
N = int(input())
print(0 if N%1000==0 else 1000-N%1000) | from decimal import Decimal as D
a,b=map(str,input().split())
print(int(D(a)*D(b))) | 0 | null | 12,427,374,213,752 | 108 | 135 |
a = input().lower()
cnt = 0
while 1:
c = input()
if c == 'END_OF_TEXT':
break
cnt += c.lower().split().count(a)
print(cnt)
| import sys
w = sys.stdin.readline().rstrip().lower()
cnt = 0
while True:
lines = sys.stdin.readline().rstrip()
if not lines:
break
words = lines.split( " " )
for i in range( len( words ) ):
if w == words[i].lower():
cnt += 1
print( cnt ) | 1 | 1,820,562,230,760 | null | 65 | 65 |
#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 # (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)
# 四捨五入
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
NUM = [0] * 500000
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
nya = x**2 + y**2 + z**2 + x*y + y*z + z*x
NUM[nya] += 1
n = I()
for i in range(1,n+1):
print(NUM[i])
| import math
N = int(input())
X = math.ceil(math.sqrt(N))
li = [0]*N
xyz = []
for i in range(X):
for j in range(X-i):
for k in range(X-i-j):
xyz1 = [i+1,j+i+1,k+j+i+1]
xyz1.sort()
if i+1 == j+i+1 == k+j+i+1:xyz1.append(1)
elif i+1 != j+i+1 and i+1 != k+j+i+1 and j+i+1 != k+j+i+1:xyz1.append(6)
else:xyz1.append(3)
xyz.append(xyz1)
xyz.sort()
for l in xyz:
n = l[0]**2 + l[1]**2 + l[2]**2 + l[0]*l[1] + l[1]*l[2] + l[2]*l[0]
try:
li[n-1] += l[3]
except:pass
for n in li[0:N:]:
print(n) | 1 | 8,013,715,712,590 | null | 106 | 106 |
a, b, c, d = map(int, input().split())
ac = a * c
ad = a * d
bc = b * c
bd = b * d
max_a = max(ac, ad)
max_b = max(bc, bd)
print(max(max_a, max_b))
| class UnionFind():
def __init__(self, n):
self.parents = [-1]*n
def root(self, x):
if self.parents[x] < 0:
return x
else:
return self.root(self.parents[x])
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return
else:
if x > y:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
return
n, m, k = map(int, input().split())
ab = [list(map(int, input().split())) for _ in range(m)]
cd = [list(map(int, input().split())) for _ in range(k)]
u = UnionFind(n)
f = [set() for _ in range(n)]
l = [set() for _ in range(n)]
for a, b in ab:
a, b = a-1, b-1
f[a].add(b)
f[b].add(a)
u.unite(a, b)
for c, d in cd:
c, d = c-1, d-1
l[c].add(d)
l[d].add(c)
ans = [0] * n
for i in range(n):
r = u.root(i)
bl = 0
for j in l[i]:
if u.root(j) == r:
bl += 1
ans[i] = -u.parents[r] - len(f[i]) - bl - 1
print(*ans) | 0 | null | 32,520,177,015,176 | 77 | 209 |
N = int(input())
memberlist = []
testinomylist = []
for _ in range(N):
A = int(input())
tmpmemberlist = []
tmptestinomylist = []
for i in range(A):
x, y = map(int, input().split())
tmpmemberlist.append(x)
tmptestinomylist.append(y)
memberlist.append(tmpmemberlist) # [[2,3],[1,3],[1]] こんな感じで人が収容
testinomylist.append(tmptestinomylist) # [[0,1],[1],[0]]
ans = 0
for i in range(2 ** N):
honestlist = []
liarlist = []
for j in range(N):
if ((i >> j) & 1):
#if true 条件を満たした人を正直物として考える.
honestlist.append(j+1)
else:
# if false の人は嘘つきものだと考える。
liarlist.append(j+1)
#正直な人だけを見ればいい。
Flag = 0
for honestnumber in honestlist: #bit全探索で得た正直な人の番号
for X,Y in zip(memberlist[honestnumber-1] , testinomylist[honestnumber-1]): # 正直な人だけの証言
if (Y == 0):
if X in liarlist: #正直者の証言が食い違ってないか
pass
else:
Flag = 1
elif (Y == 1):
if X in honestlist:
pass
else:
Flag = 1
if Flag == 1:
pass
else:
ans = max(ans,len(honestlist))
print(ans)
| n = int(input())
a = [int(x) for x in input().split()]
ans = [0] * n
for i in range(n):
ans[a[i]-1] = i+1
ans = [str(x) for x in ans]
print(" ".join(ans)) | 0 | null | 151,831,016,503,180 | 262 | 299 |
import sys
input = sys.stdin.readline
n, p = map(int, input().split())
s = list(input().strip())
if p == 2 or p == 5:
ans = 0
while s:
if p == 2 and int(s.pop()) % 2 == 0 or p == 5 and int(s.pop()) % 5 == 0:
ans += n
n -= 1
print(ans)
exit()
a = [0] * p
i = 1
k = 0
while s:
k = (k + int(s.pop()) * i) % p
a[k] += 1
i *= 10
i %= p
ans = a[0]
for i in a:
if i >= 2:
ans += i * (i - 1) // 2
print(ans)
| n,m = map(int,input().split())
#行列a、ベクトルb、行列積cの初期化
a = [0 for i in range(n)]
b = [0 for j in range(m)]
c = []
#a,bの読み込み
for i in range(n):
a[i] = input().split()
a[i] = [int(x) for x in a[i]]
for j in range(m):
b[j] = int(input())
#行列積計算
temp = 0
for i in range(n):
for j in range(m):
temp += a[i][j]*b[j]
c.append(temp)
temp = 0
#結果の表示
for num in c:print(num)
| 0 | null | 29,763,313,567,540 | 205 | 56 |
N = int(input())
A = list(map(int, input().split()))
if A[0] == 1:
if len(A) > 1:
print(-1)
exit()
else:
print(1)
exit()
elif A[0] > 1:
print(-1)
exit()
S = [0] * (N + 2)
for i in range(N, -1, -1):
S[i] = S[i + 1] + A[i]
sec = [0] * (N + 1)
sec[0] = 1
for i in range(1, N + 1):
a = A[i]
v = sec[i - 1] * 2
if v < a:
print(-1)
exit()
sec[i] = min(v - a, S[i + 1])
print(sum(A) + sum(sec[:-1]))
# print(sec)
# print(A) | A = int(input())
if A >= 30:
print('Yes')
else:
print('No') | 0 | null | 12,172,768,681,280 | 141 | 95 |
cnt = 0
def merge(array, left, middle, right):
n1 = middle - left
n2 = right - middle
L = array[left:left + n1] + [float("inf")]
R = array[middle:middle + n2] + [float("inf")]
i = 0
j = 0
for k in range(left, right):
global cnt
cnt += 1
if L[i] <= R[j]:
array[k] = L[i]
i += 1
else:
array[k] = R[j]
j += 1
def mergeSort(array, left, right):
if left + 1 < right:
middle = int((left + right) / 2.)
mergeSort(array, left, middle)
mergeSort(array, middle, right)
merge(array, left, middle, right)
n = int(input())
array = [int(x) for x in input().split()]
mergeSort(array, 0, len(array))
print(*array)
print(cnt)
| S=input()
Slist=list(S)
flag=True
for i, c in enumerate(S):
if i%2==0 and c!='h':
flag=False
break
if i%2==1 and c!='i':
flag=False
break
if flag and len(S)%2==0:
print('Yes')
else:
print('No') | 0 | null | 26,541,092,602,750 | 26 | 199 |
while True:
n, x = [int(a) for a in input().split()]
if n == x == 0:
break
cnt = 0
for i in range(1, n):
for j in range(i + 1, n):
flag = False
for k in range(j + 1, n + 1):
if flag:
break
if (i + j + k) == x:
cnt += 1
flag = True
print(cnt) | import math
def div(x, y): #x>y
A = 1
for i in range(1, int(math.sqrt(x))+1):
if x % i == 0 and y % i == 0:
A = max(A, i)
j = int(x/i)
if x % j == 0 and y % j == 0:
A = max(A, j)
return A
x, y = map(int, input().split(" "))
print(div(x,y))
| 0 | null | 640,838,014,964 | 58 | 11 |
from fractions import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations
def main():
X = int(input())
print('Yes') if X >= 30 else print('No')
if __name__ == '__main__':
main() | x = int(input())
if 30 <= x:
print("Yes")
else:
print("No") | 1 | 5,793,376,061,030 | null | 95 | 95 |
from math import atan, degrees
a,b,x = map(int,input().split())
o = 2 * x / (a*a) - b
if o < 0:
h = 2 * (x / a) / b
print(degrees(atan(b/h)))
else:
print(degrees(atan((b-o)/a)))
| #!/usr/bin/env python3
import math
def main():
a, b, x = map(int, input().split())
if a * a * b / 2 <= x:
ans = math.atan(2 * (a * a * b - x) / (a * a * a))
else:
ans = math.pi / 2 - math.atan(2 * x / (a * b * b))
print(math.degrees(ans))
if __name__ == "__main__":
main()
| 1 | 163,453,748,726,940 | null | 289 | 289 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.