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
|
|---|---|---|---|---|---|---|
n = input()
numbers = input().split(" ")
numbers.reverse()
numbers = " ".join(numbers)
print(numbers)
|
S = input()
n = len(S)+1
lr = []
num = []
a = S[0]
cnt = 0
for s in S:
if s == a:
cnt += 1
else:
num.append(cnt)
if a == '<':
lr.append(1)
else:
lr.append(0)
a = s
cnt = 1
num.append(cnt)
if a == '<':
lr.append(1)
else:
lr.append(0)
ans = 0
if (len(lr) == 1 and lr[0] == 0) or (len(lr) > 1 and lr[0] == 0):
ans += (num[0]*(num[0]+1))//2
lr, num = lr[1:], num[1:]
if (len(lr) == 1 and lr[0] == 1) or (len(lr) > 1 and lr[-1] == 1):
ans += (num[-1]*(num[-1]+1))//2
lr.pop()
num.pop()
if not lr:
print(ans)
exit()
for i in range(0, len(lr), 2):
if num[i] == num[i+1]:
b = num[i]
c = num[i]
elif num[i] < num[i+1]:
b = num[i+1]
c = num[i]
else:
b = num[i]
c = num[i+1]
ans += (b*(b+1))//2 + ((c-1)*c)//2
print(ans)
| 0 | null | 78,841,303,817,952 | 53 | 285 |
a = int(input())
n = 3.141592
print((a + a) * n)
|
dict = {}
S, T = input().split(' ')
dict[S], dict[T] = map(int, input().split(' '))
U = input()
dict[U] -= 1
print(dict[S], dict[T])
| 0 | null | 51,555,813,145,860 | 167 | 220 |
X,Y=map(int,input().split())
mod = 10**9+7
if 2*X < Y or 2*Y < X:print(0)
elif (X+Y) % 3 != 0:print(0)
else:
n = (X+Y) // 3
X,Y=X-n,Y-n
factorial=[1 for i in range(X+Y+1)]
for i in range(1,X+Y+1):
if i==1:factorial[i]=1
else:factorial[i] = factorial[i-1]*i % mod
print(factorial[X+Y]*pow(factorial[X]*factorial[Y],-1,mod)%mod)
|
from math import*
A,B,H,M = map(int, input().split())
print((A*A+B*B-2*A*B*cos((M*11/360-H/6)*pi))**.5)
| 0 | null | 84,919,841,885,828 | 281 | 144 |
S = input()
result = 0
# 入力例1なら3文字目まで
for i in range(len(S) // 2):
# sの1(2番目)がsの最後尾と一緒ならカウント
if S[i] != S[-(i + 1)]:
result += 1
print(result)
|
H1,M1,H2,M2,K = map(int,input().split())
M_all = (H2 *60 + M2) - (H1 *60 + M1) - K
if M_all <= 0:
print('0')
else:
print(M_all)
| 0 | null | 69,472,606,308,482 | 261 | 139 |
n = input()
n2 = n * 2
x = input()
if x in n2:
print('Yes')
else: print('No')
|
s=input()
p=input()
s2=s*2
ren=s2.count(p)
if ren==0:
print('No')
else:
print('Yes')
| 1 | 1,760,368,006,230 | null | 64 | 64 |
import math
h1,m1,h2,m2,k=map(int,input().split())
start=60*h1+m1
end=60*h2+m2
print(end-start-k)
"""
a=[]
temp=input().split()
for i in range(n):
a.append(int(temp[i])-1)
routetemp=[]
routetemp.append(0)
while True:
if a[routetemp[-1]] in routetemp:
roop=len(routetemp)-routetemp.index(a[routetemp[-1]])
pre=routetemp.index(a[routetemp[-1]])
break
routetemp.append(a[routetemp[-1]])
#print(routetemp)
#print(a)
#print(roop)
#print(pre)
num=(k-pre)%roop
#print(num)
print(routetemp[pre+num]+1)
"""
|
h1, m1, h2, m2, k = map(int, input().split())
if m1 <= m2:
h = h2 - h1
m = m2 - m1
else:
h = h2 - h1 - 1
m = m2 - m1 + 60
m += 60 * h
print(m - k)
| 1 | 17,916,187,854,970 | null | 139 | 139 |
def solve(n):
import math
m = 26
nn = n - 1
for i in range(1, m + 1):
p = m ** i
if p > nn:
break
nn -= p
s = ''
for j in range(1, i + 1):
p = m ** (i - j)
x, nn = divmod(nn, p)
s += chr(x + ord('a'))
return s
def main(istr, ostr):
n, = list(map(int, istr.readline().strip().split()))
result = solve(n)
print(result, file=ostr)
if __name__ == "__main__":
import sys
main(sys.stdin, sys.stdout)
|
x, y = map(int,input().split())
print((max(4-x, 0) + max(4-y, 0) + 4*max(3-x-y, 0)) * 100000)
| 0 | null | 76,184,210,590,980 | 121 | 275 |
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
# ある経路をきめる.
# そのとき(白マスから黒マスに移動する回数)＝(その経路がいい経路にするための操作回数）
dp = [[float("inf")]*w for _ in range(h)]
if s[0][0] == "#":
dp[0][0] = 1
else:
dp[0][0] = 0
# dp[i][j]は00からijに行くときに白マスから黒マスに移動する回数の最小値
for i in range(h):
for j in range(w):
if i+1 < h:
count1 = dp[i][j]
if s[i][j] == "." and s[i+1][j] == "#":
count1 += 1
dp[i+1][j] = min(dp[i+1][j], count1)
if j+1 < w:
count2 = dp[i][j]
if s[i][j] == "." and s[i][j+1] == "#":
count2 += 1
dp[i][j+1] = min(dp[i][j+1], count2)
print(dp[h-1][w-1])
|
from itertools import product
from collections import deque
class ZeroOneBFS:
def __init__(self, N):
self.N = N # #vertices
self.E = [[] for _ in range(N)]
def add_edge(self, init, end, weight, undirected=False):
assert weight in [0, 1]
self.E[init].append((end, weight))
if undirected: self.E[end].append((init, weight))
def distance(self, s):
INF = float('inf')
E, N = self.E, self.N
dist = [INF] * N # the distance of each vertex from s
prev = [-1] * N # the previous vertex of each vertex on a shortest path from s
dist[s] = 0
dq = deque([(0, s)]) # (dist, vertex)
n_visited = 0 # #(visited vertices)
while dq:
d, v = dq.popleft()
if dist[v] < d: continue # (s,v)-shortest path is already calculated
for u, c in E[v]:
temp = d + c
if dist[u] > temp:
dist[u] = temp; prev[u] = v
if c == 0: dq.appendleft((temp, u))
else: dq.append((temp, u))
n_visited += 1
if n_visited == N: break
self.dist, self.prev = dist, prev
return dist
def shortest_path(self, t):
P = []
prev = self.prev
while True:
P.append(t)
t = prev[t]
if t == -1: break
return P[::-1]
H, W = map(int, input().split())
zobfs = ZeroOneBFS(H * W)
def vtx(i, j): return i*W + j
def coord(n): return divmod(n, W)
grid = [input() for _ in range(H)] # |string| = W
E = [[] for _ in range(H * W)]
ans = 0 if grid[0][0] == '.' else 1
for i, j in product(range(H), range(W)):
v = vtx(i, j)
check = [vtx(i+dx, j+dy) for dx, dy in [(1, 0), (0, 1)] if i+dx <= H-1 and j+dy <= W-1]
for u in check:
x, y = coord(u)
if grid[i][j] == '.' and grid[x][y] == '#':
zobfs.add_edge(v, u, 1)
else:
zobfs.add_edge(v, u, 0)
dist = zobfs.distance(0)
ans += dist[vtx(H-1, W-1)]
print(ans)
| 1 | 49,147,297,246,212 | null | 194 | 194 |
s=input()
t=input()
ans=len(t)
for i in range(len(s)):
if i+len(t)>len(s):break
anss=0
for j in range(len(t)):
if t[j]!=s[i+j]:anss+=1
ans=min(ans,anss)
print(ans)
|
number = int(input())
score = list(map(int,input().split()))
kiroku = 10**10
for i in range(100):
answer = 0
for j in range(number):
answer += (score[j] - i-1)**2
if answer < kiroku:
kiroku = answer
print(kiroku)
| 0 | null | 34,493,501,525,152 | 82 | 213 |
import math
a,b,C = map(float,input().split())
rad = math.radians(C)
h = b*math.sin(rad)
S = a*h/2
L = a+b+math.sqrt(a**2+b**2-2*a*b*math.cos(rad))
print("%.5f\n%.5f\n%.5f" % (S,L,h))
|
from math import sin,cos,pi,sqrt
a,b,d=map(float,input().split())
S=a*b*sin(d*pi/180)/2
c=sqrt(a**2+b**2-2*a*b*cos(d*pi/180))
h=2*S/a
print(S)
print(a+b+c)
print(h)
| 1 | 176,024,649,360 | null | 30 | 30 |
def run():
for i in range(1,10):
for j in range(1,10):
print('{0}x{1}={2}'.format(i,j,i*j))
if __name__ == '__main__':
run()
|
S = input()
S_size = len(S)
S_hi = S.count('hi')
if S_size == S_hi*2:
print('Yes')
else:
print('No')
| 0 | null | 26,508,909,004,160 | 1 | 199 |
N = int(input())
ans=[0]*N
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
F=x**2 + y**2 + z**2 + x*y + y*z + z*x
if(N>=F):
ans[F-1] += 1
for i in ans:
print(i)
|
def foo(x,y,z):
return x**2 + y**2 + z**2 + x*y + y*z + z*x
N = int(input())
A = [0 for i in range(10050)]
for i in range(1,105):
for j in range(1,105):
for k in range(1,105):
tmp = foo(i,j,k)
if tmp < 10050:
A[tmp] += 1
for i in range(1,N+1):
print(A[i])
| 1 | 7,917,117,323,070 | null | 106 | 106 |
alpha = input()
print("a" if alpha.islower() else "A")
|
alp = 'abcdefghijklmnopqrstuvwxyz'
if input() in alp:
print('a')
else:
print('A')
| 1 | 11,307,218,798,678 | null | 119 | 119 |
mod = pow(10, 9) + 7
N = int(input())
# 制約が a<2**60 なので
L = 60
A = map(int, input().split())
counter = [0] * L
for a in A:
for i in range(L):
counter[i] += a & 1
a >>= 1
tmp = 0
for i in range(L):
tmp += counter[i] * (N - counter[i]) * (2 ** i)
tmp %= mod
print(tmp)
|
# AOJ ITP1_9_A
# ※大文字と小文字を区別しないので注意！！！！
# 全部大文字にしちゃえ。
def main():
W = input().upper() # 大文字にする
line = ""
count = 0
while True:
line = input().split(" ")
if line[0] == "END_OF_TEXT": break
for i in range(len(line)):
word = line[i].upper()
if W == word: count += 1
print(count)
if __name__ == "__main__":
main()
# Accepted.
| 0 | null | 62,279,386,866,898 | 263 | 65 |
def main():
from collections import deque
N, M = (int(i) for i in input().split())
if N % 2 == 0:
A = deque([i+1 for i in range(N)])
for i in range(1, M+1):
if (N-i)-i > N//2:
print(A[i], A[N-i])
else:
print(A[i], A[N-i-1])
else:
A = deque([i for i in range(N)])
for i in range(1, M+1):
print(A[i], A[N-i])
if __name__ == '__main__':
main()
|
N,M = map(int,input().split())
if N%2:
for i in range(M):
print(i+1, M*2-i)
else:
b = M//2
a = M - b
for i in range(a):
print(i+1, a*2-i)
for i in range(b):
print(a*2+1+i, M*2+1-i)
| 1 | 28,599,020,896,640 | null | 162 | 162 |
#coding:UTF-8
x = input()
a = x/3600
b = (x%3600)/60
c = (x%3600)%60
print str(a)+":"+str(b)+":"+str(c)
|
sec = int(input())
m, s = divmod(sec, 60)
h, m = divmod(m, 60)
print('%d:%d:%d' % (h, m, s))
| 1 | 323,428,452,288 | null | 37 | 37 |
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)
|
n,k=map(int,input().split())
a=0
b=n
while b>=k:
b=b//k
a+=1
print(a+1)
| 0 | null | 45,698,793,168,292 | 158 | 212 |
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n = int(input())
now = 0
for _ in range(n):
x, y = map(int, input().split())
if x == y:
now += 1
else:
now = 0
if now == 3:
print("Yes")
return
print("No")
resolve()
|
def main():
s = input()
if s[2]==s[3] and s[4]==s[5]:
print("Yes")
else:
print("No")
if __name__ == "__main__":
main()
| 0 | null | 22,224,957,414,680 | 72 | 184 |
N,K=map(int,input().split())
List = list(map(int, input().split()))
INF = 10000000000
expList = [INF]*1001
def expectationF(num):
if expList[num] == INF:
exp = 0
for i in range(1,num+1):
exp += i/num
expList[num] = exp
return expList[num]
res = 0
mid = 0
midList=[]
for i in range(N):
if i>=1:
midList.append(expectationF(List[i])+midList[i-1])
else:
midList.append(expectationF(List[i]))
m=K-1
for j in range(N-m):
if j == 0:
mid = midList[j+m]
else:
mid = midList[j+m]- midList[j-1]
res = max(res,mid)
print(res)
|
from itertools import accumulate
N, K = map(int, input().split())
P = list(map(int, input().split()))
Q = list(map(lambda x: (x+1)/2, P))
Q_cum = list(accumulate([0] + Q))
res = 0
for i in range(N-K+1):
temp = Q_cum[i+K]- Q_cum[i]
res = max(res, temp)
print(res)
| 1 | 74,549,586,811,342 | null | 223 | 223 |
import math
a, b, x = map(int, input().split())
v = a*a*b
if v == x:
print(0)
elif v/2 <= x < v:
h = 2*(v-x)/a**2
ans = math.atan(h/a)
print(math.degrees(ans))
else:
h = 2*x/(b*a)
ans = math.atan(h/b)
print(90-math.degrees(ans))
|
from math import tan, pi, degrees
a, b, x = map(int, input().split())
def solve(isOK):
ng, ok = pi/2, 0
while abs(ok-ng) > 10**-12:
mid = (ng+ok) / 2
if isOK(mid):
ok = mid
else:
ng = mid
# print('ok:', ok)
print(degrees(ok))
def isOK1(theta):
return a*a*tan(theta)/2 + x/a <= a*b
def isOK2(theta):
return b*b/tan(theta)/2 >= x/a
if x/a >= a*b/2:
solve(isOK1)
else:
solve(isOK2)
| 1 | 163,555,181,322,342 | null | 289 | 289 |
X,N = map(int,input().split())
p = list(map(int,input().split()))
for i in range(X+1):
for j in [-1,1]:
a = X + i*j
if p.count(a) == 0:
print(a)
exit(0)
|
from collections import deque
T = input()
A = deque()
d = 0
s = 0
for i, token in enumerate(T):
if token == "\\":
s += d + 0.5
if not d:
l = i
d += 1
elif token == "/":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
A.append((l, s))
s = 0
else:
s += d
B = deque()
d = 0
s = 0
for i in range(len(T) - 1, -1, -1):
token = T[i]
if token == "/":
s += d + 0.5
d += 1
elif token == "\\":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
B.appendleft((i, s))
s = 0
else:
s += d
S = set(A) | set(B)
S = list(S)
S.sort()
S = [round(s[1]) for s in S]
print(sum(S))
print(len(S), *S)
| 0 | null | 7,145,676,675,462 | 128 | 21 |
n,m = map(int,input().split())
if 0 < n and n < 10 and 0 < m and m < 10:
print(n*m)
else:
print(-1)
|
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
A,B=pin()
if A>9 or B>9:print(-1);return
print(A*B)
#%%submit!
resolve()
| 1 | 158,559,913,695,260 | null | 286 | 286 |
def main():
l = []
for _ in range(10):
l.append(int(input()))
l = sorted(l, reverse=True)
for i in range(3):
print(l[i])
return None
if __name__ == '__main__':
main()
|
N = int(input())
sum = N + N**2 + N**3
print(sum)
| 0 | null | 5,129,390,409,432 | 2 | 115 |
# アライグマはモンスターと戦っています。モンスターの体力はHです。
# アライグマはN種類の必殺技を使うことができ、i番目の必殺技を使うとモンスターの体力を Ai
# 減らすことができます。 必殺技を使う以外の方法でモンスターの体力を減らすことはできません。
# モンスターの体力を0以下にすればアライグマの勝ちです。
# アライグマが同じ必殺技を2度以上使うことなくモンスターに勝つことができるなら Yes を、
# できないなら No を出力してください。
H, N = map(int, input().split())
damege = map(int, input().split())
total_damege = sum(damege)
if H - total_damege <= 0:
print('Yes')
else:
print('No')
|
hp, count_skills = map(int, input().split())
a = map(int, input().split())
skills_list = list(a)
for skill in skills_list:
hp -= skill
if hp <= 0:
print('Yes')
break
if hp >= 1:
print('No')
| 1 | 77,709,844,561,740 | null | 226 | 226 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, K = mapint()
As = list(mapint())
mod = 10**9+7
pos = []
neg = []
for a in As:
if a>=0:
pos.append(a)
else:
neg.append(a)
pos.sort(reverse=True)
neg.sort()
ans = 1
lenp, lenn = len(pos), len(neg)
if (lenp+lenn)==K:
for a in As:
ans *= a
ans %= mod
print(ans)
elif lenn==0:
for i in range(K):
ans *= pos[i]
ans %= mod
print(ans)
elif lenp==0:
if K%2==0:
for i in range(K):
ans *= neg[i]
ans %= mod
print(ans)
else:
neg = neg[::-1]
for i in range(K):
ans *= neg[i]
ans %= mod
print(ans)
else:
p, n = 0, 0
while p+n+1<K:
if p+2<=lenp and n+2<=lenn:
if pos[p]*pos[p+1]>=neg[n]*neg[n+1]:
ans *= pos[p]
p += 1
else:
ans *= neg[n]*neg[n+1]
n += 2
elif n+2<=lenn:
ans *= neg[n]*neg[n+1]
n += 2
else:
ans *= pos[p]
p += 1
ans %= mod
if p+n<K:
ans *= pos[p]
ans %= mod
print(ans)
|
def modinv(a,m):
b, u, v = m, 1, 0
while b:
t = a//b
a -= t*b
a,b = b,a
u -= t * v
u,v = v,u
u %= m
return u
n, k = map(int, input().split())
al = list(map(int, input().split()))
al_abs = []
al_p = []
al_m = []
zero_cnt = 0
MOD = 10**9+7
for a in al:
if a == 0:
zero_cnt+=1
elif a > 0:
al_abs.append((abs(a),1))
al_p.append(a)
else:
al_abs.append((abs(a),-1))
al_abs.sort(reverse=True)
if n == k:
ans = 1
for a in al:
ans *= a
ans %= MOD
print(ans)
exit()
if len(al_abs) < k:
print(0)
exit()
if not al_p:
if k%2 == 1 and zero_cnt > 0:
print(0)
else:
if k%2 == 1:
al_abs.sort()
ans = 1
for a,s in al_abs[:k]:
ans *= (a*(-1))
ans %= MOD
print(ans)
exit()
val = 1
m_cnt = 0
last_m = 0
last_p = 0
for i in range(k):
v,sig = al_abs[i]
val *= v
val %= MOD
if sig == -1:
m_cnt += 1
last_m = v
else:
last_p = v
if m_cnt %2 == 0:
print(val)
exit()
# minus -> plus
## search next p
next_p = 0
for i in range(k,len(al_abs)):
v,sig = al_abs[i]
if sig == 1:
next_p = v
break
## search next m
next_m = 0
for i in range(k,len(al_abs)):
v,sig = al_abs[i]
if sig == -1:
next_m = v
break
if next_p == 0 and next_m == 0:
print(0)
exit()
# last_m -> next_p
if next_p*last_p >= next_m*last_m or last_p == 0:
ans = val*modinv(last_m%MOD,MOD)*next_p
ans %= MOD
print(ans)
else:
ans = val*modinv(last_p%MOD,MOD)*next_m
ans %= MOD
print(ans)
| 1 | 9,416,074,138,160 | null | 112 | 112 |
N, K = map(int, input().split())
ans = min(N - K*(N//K), K - (N - K*(N//K)))
print(ans)
|
N,K = map(int, input().split())
if N % K == 0:
print(0)
elif N > K:
hako1 = N%K
hako2 = abs(hako1-K)
if hako1 > hako2:
print(hako2)
else:
print(hako1)
else:
if N >= abs(N-K):
print(abs(N-K))
else:
print(N)
| 1 | 39,346,913,195,982 | null | 180 | 180 |
import sys
X, K, D = map(int, input().split())
X = abs(X)
if X // D >= K:
print(X - K*D)
sys.exit()
K = K - (X // D)
A = X - X//D*D
if K % 2 == 0:
print(A)
else:
print(abs(A - D))
|
length0 = input()
#print(length0)
length = length0.split()
a = int(length[0])
b = int(length[1])
#print(str(a)+" "+str(b))
area = a*b
per = 2*a+2*b
print(str(area)+" "+str(per))
| 0 | null | 2,793,390,180,042 | 92 | 36 |
n=int(input())
s=input()
mid=n//2
if(s[:mid]==s[mid:]):
print("Yes")
else:
print("No")
|
n = int(input())
list_s = list(input())
if n % 2 != 0: print("No")
elif "".join(list_s[: (n // 2)]) == "".join(list_s[(n // 2):]): print("Yes")
else: print("No")
| 1 | 146,305,314,206,830 | null | 279 | 279 |
def insertion_sort(A, N):
for i in range(N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
print(' '.join(map(str, A)))
def main():
N = int(input().rstrip())
A = list(map(int, input().rstrip().split()))
insertion_sort(A, N)
if __name__ == '__main__':
main()
|
a = []
def outputList(a):
for i in range(len(a)):
if i != len(a)-1:
print("%d"%a[i],end=' ')
else:
print("%d"%a[i],end='\n')
n = int(input().strip())
for i in input().split():
a.append(int(i))
if len(a)==n:
break
for i in range(1,len(a)):
outputList(a)
key = a[i]
j = i - 1
while j >= 0 and a[j] > key:
a[j+1] = a[j]
j -= 1
a[j+1] = key
outputList(a)
| 1 | 6,480,748,538 | null | 10 | 10 |
X,Y=map(int,input().split())
b=0
for i in range(X+1):
if 4*(i)+2*(X-i)==Y:
b+=1
if not b==0:
print("Yes")
else:
print("No")
|
s=input()
l=len(s)
x=0
for i in range(l):
x=x+int(s[i])
if x%9==0:
print("Yes")
else:
print("No")
| 0 | null | 9,042,589,478,370 | 127 | 87 |
import math
n = int(input())
xn_list = list(map(int, input().split()))
ans = float('inf')
for i in range(1, 100):
temp = 0
for j in xn_list:
temp += (j-i)**2
ans = min(ans, temp)
print(ans)
|
h, w = map(int, input().split())
M = [list(input()) for _ in range(h)]
count = [[int(1e18) for _ in range(w)] for _ in range(h)]
count[0][0] = 1 if M[0][0] == '#' else 0
# 同じ色かどうかを見る
for i in range(h):
for j in range(w):
if i + 1 < h:
v = 1 if M[i][j] != M[i + 1][j] else 0
count[i + 1][j] = min(count[i + 1][j], count[i][j] + v)
if j + 1 < w:
v = 1 if M[i][j] != M[i][j + 1] else 0
count[i][j + 1] = min(count[i][j + 1], count[i][j] + v)
print((count[h - 1][w - 1] + 1) // 2)
| 0 | null | 57,423,959,481,500 | 213 | 194 |
import sys
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
s = str(readline().rstrip().decode('utf-8'))
if s == "RRR":
print(3)
elif s == "RRS" or s == "SRR":
print(2)
elif s.count("R") == 0:
print(0)
else:
print(1)
if __name__ == '__main__':
solve()
|
import math
x = int(input())
print(math.ceil(x/2))
| 0 | null | 32,048,571,342,228 | 90 | 206 |
from collections import deque,defaultdict,Counter
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import product,permutations,combinations,combinations_with_replacement
from bisect import bisect_left,bisect_right
from math import sqrt,gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
from statistics import mean,median,mode
import sys
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col,reverse=False):
data.sort(key=lambda x:x[col],reverse=revese)
return data
def mymax(data):
M = -1*float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M,m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m,M)
return m
def mycount(ls,x):
# lsはソート済みであること
l = bisect_left(ls,x)
r = bisect_right(ls,x)
return (r-l)
def mydictvaluesort(dictionary):
return sorted( dictionary.items(), key=lambda x:x[1] )
def mydictkeysort(dictionary):
return sorted( dictionary.items(), key=lambda x:x[0] )
def myoutput(ls,space=True):
if space:
if len(ls)==0:
print(" ")
elif type(ls[0])==str:
print(" ".join(ls))
elif type(ls[0])==int:
print(" ".join(map(str,ls)))
else:
print("Output Error")
else:
if len(ls)==0:
print("")
elif type(ls[0])==str:
print("".join(ls))
elif type(ls[0])==int:
print("".join(map(str,ls)))
else:
print("Output Error")
def I():
return int(input())
def MI():
return map(int,input().split())
def RI():
return list(map(int,input().split()))
def CI(n):
return [ int(input()) for _ in range(n) ]
def LI(n):
return [ list(map(int,input().split())) for _ in range(n) ]
def S():
return input()
def MS():
return input().split()
def RS():
return list(input())
def CS(n):
return [ input() for _ in range(n) ]
def LS(n):
return [ list(input()) for _ in range(n) ]
# ddict = defaultdict(lambda: 0)
# ddict = defaultdict(lambda: 1)
# ddict = defaultdict(lambda: int())
# ddict = defaultdict(lambda: list())
# ddict = defaultdict(lambda: float())
n,k = MI()
a = RI()
L = max(a)
def mycheck(l):
count = 0
for i in range(n):
count += a[i]//l
return count <= k
lb = 0
ub = L
for i in range(100):
# print(ub,lb)
mid = (lb+ub)/2
# print(mid)
flag = mycheck(mid)
# print(flag)
if flag:
ub = mid
else:
lb = mid
ans = ceil(lb)
print(ans)
|
'''
Date : 2020-08-09 00:46:52
Author : ssyze
Description :
'''
n, k = map(int, input().split())
a = list(map(int, input().split()))
def check(m):
sum = 0
for i in range(len(a)):
sum += (a[i] - 1) // m
if sum > k:
return False
else:
return True
l = 1
r = 10**9
ans = 10**9
while l < r:
mid = (l + r) // 2
if check(mid) == 1:
r = mid
ans = mid
else:
l = mid + 1
print(ans)
| 1 | 6,531,688,414,440 | null | 99 | 99 |
#coding:utf-8
n = int(input())
numbers = list(map(int,input().split()))
for i in range(n):
tmp = numbers[i]
j = i - 1
while j >= 0 and numbers[j] > tmp:
numbers[j+1] = numbers[j]
j -= 1
numbers[j+1] = tmp
print(*numbers)
|
from collections import deque
def bfs(s):
q = deque()
q.append([s, 0])
while q:
x, y = q.popleft()
for g in G[x]:
if color[g[1]] == -1:
color[g[1]] = y + 1
y += 1
y %= k
q.append([g[0], y])
return
n = int(input())
G = [[] for _ in range(n)]
for i in range(n - 1):
a, b = map(int, input().split())
a -= 1
b -= 1
G[a].append([b, i])
G[b].append([a, i])
k = 0
for g in G:
k = max(k, len(g))
color = [-1] * (n - 1)
bfs(0)
print(k)
for i in color:
print(i)
| 0 | null | 68,035,564,934,240 | 10 | 272 |
import sys
N = int(input())
if not ( 1 <= N <= 100 ):sys.exit()
print(1-(int(N/2)/N))
|
n = int(input())
from math import sqrt, ceil
for i in range(1, ceil(sqrt(n)) + 1):
if n % i == 0:
ans = i
print(ans-1 + (n//ans)-1)
| 0 | null | 169,563,864,160,362 | 297 | 288 |
N = int(raw_input())
taro_point = 0
hanako_point = 0
for n in range(N):
str_card = raw_input().split()
if str_card[0] > str_card[1]:
taro_point += 3
elif str_card[0] < str_card[1]:
hanako_point += 3
else:
taro_point += 1
hanako_point += 1
print '%d %d' % (taro_point, hanako_point)
|
# -*- coding: utf-8 -*-
def main():
n = int(input())
keihin_set = set()
for i in range(n):
s = input()
if not s in keihin_set:
keihin_set.add(s)
print(len(keihin_set))
if __name__ == "__main__":
main()
| 0 | null | 15,997,476,048,542 | 67 | 165 |
ele_and_tar = []
rs = []
flag1 = 1
flag2 = 0
while flag1:
data = [int(x) for x in input().split()]
if data == [0,0]:
flag1 = 0
else:
ele_and_tar.append(data)
for i in range(len(ele_and_tar)):
rs.append(0)
for math in ele_and_tar:
for i in range(1,math[0]+1):
for j in range(i+1,math[0]+1):
for k in range(j+1,math[0]+1):
if (i + j + k) == math[1]:
rs[flag2] = rs[flag2] + 1
flag2 = flag2 + 1
for out in rs:
print(out)
|
# -*- coding: utf-8 -*-
while True:
n, x = map(int, raw_input().split())
if n == x == 0:
break
count = 0
for a in range(1, n+1):
for b in range(a+1, n+1):
for c in range(b+1, n+1):
if a+b+c == x:
count += 1
break
print count
| 1 | 1,294,059,314,970 | null | 58 | 58 |
a = [list(map(int, input().split())) for i in range(3)]
n =int(input())
for k in range(n):
b = int(input())
for i in range(3):
for j in range(3):
if a[i][j] == b:
a[i][j] = 0
row0 = a[0] == [0, 0, 0]
row1 = a[1] == [0, 0, 0]
row2 = a[2] == [0, 0, 0]
colum0 = [a[0][0], a[1][0], a[2][0]] == [0, 0, 0]
colum1 = [a[0][1], a[1][1], a[2][1]] == [0, 0, 0]
colum2 = [a[0][2], a[1][2], a[2][2]] == [0, 0, 0]
diag0 = [a[0][0], a[1][1], a[2][2]] == [0, 0, 0]
diag1 = [a[2][0], a[1][1], a[0][2]] == [0, 0, 0]
if row0 or row1 or row2 or colum0 or colum1 or colum2 or diag0 or diag1:
print('Yes')
break
else:
print('No')
|
X = int(input())
def is_prime(n):
if n == 2: return True
if n < 2 or n%2 == 0: return False
m = 3
while m*m <= n:
if n%m == 0: return False
m += 2
return True
while 1:
if is_prime(X):
print(X)
exit()
X += 1
| 0 | null | 82,628,767,929,408 | 207 | 250 |
# AGC 043 A
H,W = map(int, input().split())
table = [input() for _ in range(H)]
inf = 10**9
dp = [[inf] * (W+1) for _ in range(H+1)]
dp[0][0] = 0 if table[0][0] == "." else 1
for h in range(H):
for w in range(W):
flg = table[h][w] == "." and (table[h][w+1] == "#" if w < W-1 else True)
dp[h][w+1] = min(dp[h][w+1], dp[h][w] + 1 if flg else dp[h][w])
flg = table[h][w] == "." and (table[h+1][w] == "#" if h < H-1 else True)
dp[h+1][w] = dp[h][w] + 1 if flg else dp[h][w]
print(dp[H-1][W-1])
|
import math
H,N = map(int,input().split())
print("Yes" if sum(list(map(int,input().split())))>=H else "No")
| 0 | null | 63,433,812,550,728 | 194 | 226 |
S=input()
N=len(S)+1
LEFT=[0]
RIGHT=[0]
left=0
right=0
for i in range(N-1):
if S[i]==">":
left=0
else:
left+=1
LEFT+=[left]
for i in range(N-2,-1,-1):
if S[i]=="<":
right=0
else:
right+=1
RIGHT+=[right]
ans=0
for i in range(N):
ans+=max(LEFT[i],RIGHT[N-1-i])
print(ans)
|
S = input()
ans = 0
l, r = 0, 0
i = 0
while i < len(S):
while i < len(S) and S[i] == "<":
l += 1
i += 1
while i < len(S) and S[i] == ">":
r += 1
i += 1
ans += l * (l + 1) // 2
ans += r * (r + 1) // 2
ans -= min(l, r)
l, r = 0, 0
print(ans)
| 1 | 156,393,955,691,600 | null | 285 | 285 |
# -*- coding: utf-8 -*-
import sys
N=input()
bit=[ [ 0 for _ in range(N+1) ] for __ in range(27) ]
def add(i,a,w):
while a<=N:
bit[i][a]+=w
a+=a&-a
def sum(i,a):
ret=0
while 0<a:
ret+=bit[i][a]
a-=a&-a
return ret
S=sys.stdin.readline().strip()
S=[None]+list(S) #1-indexed
for j,x in enumerate(S):
if j==0: continue
i=ord(x)-96
add(i,j,1)
Q=input()
for _ in range(Q):
q1,q2,q3=sys.stdin.readline().split()
if q1=="1":
q1=int(q1)
q2=int(q2)
current_s=q3
former_s=S[q2]
former_s=ord(former_s)-96 #1-indexed
S[q2]=current_s #文字列で更新された1文字を置き換える
current_s=ord(current_s)-96
add(current_s,q2,1)
add(former_s,q2,-1)
if q1=="2":
q2=int(q2)
q3=int(q3)
begin,end=q2,q3
cnt=0
for i in range(1,27):
if 0<sum(i,end)-sum(i,begin-1):
cnt+=1
print cnt
|
#!/usr/bin/python
import sys
def gcd(a,b):
if b == 0:
return a
else:
return gcd(b, a%b)
def lcm(a,b):
return a / gcd(a,b) * b
for l in sys.stdin:
a = [int(s) for s in l.split()]
print str(gcd(a[0],a[1]))+" "+str(lcm(a[0],a[1]))
| 0 | null | 31,297,983,217,940 | 210 | 5 |
# -*- coding: utf-8 -*-
N = int(input())
if N % 2 == 1:
N += 1
print(N // 2 - 1)
|
N = int(input())
alp = {"a":1, "b":2, "c":3, "d":4, "e":5, "f":6, "g":7, "h":8, "i":9, "j":10}
alp2 = "abcdefghij"
def solve(N):
ans = []
if N == 1:
ans.append("a")
else:
pre = solve(N-1)
for i in range(len(pre)):
tmp = sorted(pre[i])
num = alp[tmp[len(tmp)-1]]
for j in range(num+1):
ans.append(pre[i]+alp2[j])
return ans
f_ans = solve(N)
f_ans.sort()
for i in range(len(f_ans)):
print(f_ans[i])
| 0 | null | 103,037,874,053,092 | 283 | 198 |
import sys
input = sys.stdin.readline
def main():
N, M = map(int, input().split())
H = [None]
H.extend(list(map(int, input().split())))
bad = set([])
for _ in range(M):
A, B = map(int, input().split())
if H[A] > H[B]:
bad.add(B)
elif H[A] < H[B]:
bad.add(A)
else:
bad.add(A)
bad.add(B)
print(N - len(bad))
if __name__ == '__main__':
main()
|
N,M=map(int, input().split())
peaks=list(map(int, input().split()))
flag=[1]*N
a=0
b=0
for i in range(M):
a,b=map(int,input().split())
a-=1
b-=1
if peaks[a]<=peaks[b]:
flag[a]=0
if peaks[a]>=peaks[b]:
flag[b]=0
ans=0
for i in flag:
ans+=i
print(ans)
| 1 | 25,142,745,308,768 | null | 155 | 155 |
class UnionFind():
def __init__(self,n):
self.n=n
self.root=[-1]*(n+1)
self.rank=[0]*(n+1)
def FindRoot(self,x):
if self.root[x]<0:
return x
else:
self.root[x]=self.FindRoot(self.root[x])
return self.root[x]
def Unite(self,x,y):
x=self.FindRoot(x)
y=self.FindRoot(y)
if x==y:
return
else:
if self.rank[x]>self.rank[y]:
self.root[x]+=self.root[y]
self.root[y]=x
elif self.rank[x]<=self.rank[y]:
self.root[y]+=self.root[x]
self.root[x]=y
if self.rank[x]==self.rank[y]:
self.rank[y]+=1
def isSameGroup(self,x,y):
return self.FindRoot(x)==self.FindRoot(y)
def Count(self,x):
return -self.root[self.FindRoot(x)]
n,m=map(int,input().split())
uf=UnionFind(n+1)
for _ in range(m):
a,b=map(int,input().split())
uf.Unite(a,b)
s=set()
for i in range(1,n+1):
s.add(uf.FindRoot(i))
print(len(s)-1)
|
summer_vacation, amount_of_homework = map(int, input().split())
a = map(int, input().split())
homework_list = list(a)
total_days = 0
for i in homework_list:
total_days += i
if summer_vacation >= total_days:
print(summer_vacation - total_days)
else:
print(-1)
| 0 | null | 17,088,706,508,988 | 70 | 168 |
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, log
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 fractions import gcd
from heapq import heappush, heappop
from functools import reduce
from decimal import Decimal
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
from decimal import *
#階乗#
lim = 10**6 #必要そうな階乗の限界を入力
fact = [1] * (lim+1)
for n in range(1, lim+1):
fact[n] = n * fact[n-1] % mod
#階乗の逆元#
fact_inv = [1]*(lim+1)
fact_inv[lim] = pow(fact[lim], mod-2, mod)
for n in range(lim, 0, -1):
fact_inv[n-1] = n*fact_inv[n]%mod
def C(n, r):
return (fact[n]*fact_inv[r]%mod)*fact_inv[n-r]%mod
X, Y = MAP()
a = (2*X - Y)/3
b = (2*Y - X)/3
if a%1 == b%1 == 0 and 0 <= a and 0 <= b:
print(C(int(a+b), int(a)))
else:
print(0)
|
#####################################################
# 組み合わせを10**9+7で割った余り、を高速に求めるアルゴリズム
# https://drken1215.hatenablog.com/entry/2018/06/08/210000
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
# 全然理解できていない
MOD = 10**9 + 7
def comb(n, r):
if (r < 0 and r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % MOD
N = 10**6
# 元テーブル
g1 = [1, 1]
# 逆元テーブル
g2 = [1, 1]
# 逆元テーブル計算用テーブル
inverse = [0, 1]
for i in range(2, N + 1):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
#####################################################
X, Y = map(int, input().split())
# X+Yが3の倍数のマスしか通りえない
if not (X + Y) % 3:
# (1,2)移動をn回、(2,1)移動をm回したとする
# n+2m = X, 2n+m = Y
# → n+m = (X+Y)/3
# n = (2n+m)-(n+m) = X - (X+Y)/3 = (-X+2Y)/3
# mも同様
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n >= 0 and m >= 0:
print(comb(n + m, n))
else:
print(0)
# X+Yが3の倍数でない場合
else:
print(0)
| 1 | 150,270,908,057,732 | null | 281 | 281 |
n=int(input())
a=[]
b=[0]*n
t_sum=0
for i in range(n):
s,t=input().split()
tt=int(t)
t_sum+=tt
a.append(s)
b[i]=t_sum
x=input()
print(t_sum-b[a.index(x)])
|
N = int(input())
x = []
for i in range(N):
s, t = input().split()
x.append([s, int(t)])
X = input()
count = False
ans = 0
for i in range(N):
if count:
ans += x[i][1]
if x[i][0] == X:
count = True
print(ans)
| 1 | 96,847,229,875,130 | null | 243 | 243 |
while True:
n, x = map(int, input().split())
if n == x == 0:
break
count = 0
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
if (i < j < k):
if i+j+k == x:
count += 1
print(count)
|
if __name__ == '__main__':
from sys import stdin
from itertools import combinations
while True:
n, x = (int(n) for n in stdin.readline().rstrip().split())
if n == x == 0:
break
a = range(1, n + 1)
l = tuple(filter(lambda _: sum(_) == x, combinations(a, 3)))
print(len(l))
| 1 | 1,293,467,072,910 | null | 58 | 58 |
import numpy as np
a = int(input())
print(int( np.ceil((2000-a)/200)))
|
X = int(input())
if X <= 599:
print(8)
elif X <= 799:
print(7)
elif X <= 999:
print(6)
elif X <= 1199:
print(5)
elif X <= 1399:
print(4)
elif X <= 1599:
print(3)
elif X <= 1799:
print(2)
elif X <= 1999:
print(1)
| 1 | 6,725,233,822,492 | null | 100 | 100 |
#!usr/bin/env python3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
mod = 1000000007
def solve():
n = I()
a = [input() for i in range(n)]
sp,sm = [],[]
for i in range(n):
p = 0
m = 0
for j in a[i]:
if j == "(":
p += 1
else:
p -= 1
if p < m:
m = p
if p > 0:
sp.append((m,p))
else:
sm.append((m,p))
sp.sort(reverse = True)
sm.sort(key = lambda x:x[0]-x[1])
k = 0
for m,p in sp:
if k+m < 0:
print("No")
return
k += p
for m,p in sm:
if k+m < 0:
print("No")
return
k += p
if k != 0:
print("No")
else:
print("Yes")
return
#Solve
if __name__ == "__main__":
solve()
|
def readinput():
n=int(input())
l=list(map(int,input().split()))
return n,l
def main(n,a):
MOD=10**9+7
hist=[0]*61
bs=[]
for i in range(n):
# s=list(reversed(bin(a[i])[2:]))
# for j in range(len(s)):
# if s[j]=='1':
# hist[j]+=1
# bs.append(s)
s=bin(a[i])[2:]
for j in range(len(s)):
if s[j]=='1':
hist[len(s)-j-1]+=1
# j=0
# ai=a[i]
# while ai>0:
# if ai&1==1:
# hist[j]+=1
# ai = ai >> 1
# j+=1
#print(bs)
#print(hist)
#print(hist)
sum=0
# for i in range(n-1):
# s=bs[i]
# b=1
# for j in range(len(s)):
# if s[j]=='0':
# sum=(sum+hist[j]*b)%MOD
# else:
# sum=(sum+( n-i-hist[j] )*b)%MOD
# hist[j]-=1
# b*=2
# for j in range(len(s),61):
# sum=(sum+hist[j]*b)%MOD
# b*=2
b=1
for j in range(61):
sum=(sum+( hist[j]*(n-hist[j])*b )%MOD )%MOD
b*=2
return sum
if __name__=='__main__':
n,l=readinput()
ans=main(n,l)
print(ans)
| 0 | null | 73,428,220,593,988 | 152 | 263 |
N, K = list(map(int,input().split()))
def sum_(i, j):
return (a[i] + a[j]) * (j - i + 1) // 2
a = [i for i in range(N + 1)]
ans = 0
for i in range(K, N + 2):
min_ = sum_(0, i - 1)
max_ = sum_(N - i + 1, N)
ans += (max_ - min_ + 1)
ans %= 10 ** 9 + 7
print(ans)
|
n, k = map(int, input().split(" "))
MOD = (10**9) + 7
def dSum(s, e):
s -= 1
_s = s * (s + 1) // 2
_e = e * (e + 1) // 2
return _e - _s
ans = 0
for i in range(k, n + 1):
# _sum = dSum(n - i - 1, n) - dSum(0, i - 1) + 1
ans += dSum(i, n) - dSum(0, n - i) + 1
print((ans + 1) % MOD)
| 1 | 33,104,280,471,330 | null | 170 | 170 |
n, k = map(int, input().split())
alst = list(map(int, input().split()))
MOD = 10 ** 9 + 7
N = n + 10
fact = [0 for _ in range(N)]
invfact = [0 for _ in range(N)]
fact[0] = 1
for i in range(1, N):
fact[i] = fact[i - 1] * i % MOD
invfact[N - 1] = pow(fact[N - 1], MOD - 2, MOD)
for i in range(N - 2, -1, -1):
invfact[i] = invfact[i + 1] * (i + 1) % MOD
def nCk(n, k):
if k < 0 or n < k:
return 0
else:
return fact[n] * invfact[k] * invfact[n - k] % MOD
alst.sort()
ans = 0
for i, num in enumerate(alst):
ans -= num * nCk(n - 1 - i, k - 1)
ans %= MOD
for i, num in enumerate(alst[::-1]):
ans += num * nCk(n - 1 - i, k - 1)
ans %= MOD
print(ans)
|
L=list(map(int,input().split()))
a=L[0]
b=L[1]
c=L[2]
d=L[3]
print(max(a*c,b*d,a*d,b*c))
| 0 | null | 49,670,758,757,890 | 242 | 77 |
X,Y = map(int,input().split())
for i in range(X+1):
a = i*2 + (X-i)*4
if a == Y:
print("Yes")
break
if a != Y:
print("No")
|
N = int(input().strip())
l = [chr(i) for i in range(97, 97+26)]
ans = ""
if N <= 26:
ans = l[N-1]
else:
for i in range(1,11):
st = 0
for k in range(i):
st = st + 26**(k+1)
nd = st + 26**(i+1)
if st < N <= nd:
N = N - st
for j in range(i+1):
r = N % 26
N = N // 26
if r != 0:
N += 1
ans = l[r-1] + ans
if r == 0:
ans = "z" + ans
break
print(ans)
| 0 | null | 12,780,306,333,658 | 127 | 121 |
S = input()
T = input()
lens = len(S)
lent = len(T)
ans = lent
for i in range(lens - lent + 1):
count = 0
for j in range(lent):
if S[i+j] != T[j]:
count = count + 1
if count < ans:
ans = count
print(ans)
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
minus = []
for i in a:
if i > 0: plus.append(i)
if i < 0: minus.append(i)
ans = 1
if k > len(plus) + len(minus):
ans = 0
elif len(minus) == 0:
plus.sort(reverse=True)
for i in range(k):
ans = (ans * plus[i]) % mod
elif len(plus) == 0:
if k % 2 == 0:
minus.sort()
for i in range(k):
ans = (ans * minus[i]) % mod
else:
if n != len(minus):
ans = 0
else:
minus.sort(reverse=True)
for i in range(k):
ans = (ans * minus[i]) % mod
elif k == len(plus) + len(minus) and (len(minus) % 2) == 1:
if n != len(plus) + len(minus):
ans = 0
else:
for x in plus:
ans = (ans * x) % mod
for y in minus:
ans = (ans * y) % mod
else:
plus.sort(reverse=True)
minus.sort()
i, j = 0, 0
if k % 2 == 1:
ans = plus[0]
i = 1
while i + j < k:
tmp_p = plus[i] * plus[i + 1] if i <= len(plus) - 2 else 1
tmp_m = minus[j] * minus[j + 1] if j <= len(minus) - 2 else 1
if tmp_p >= tmp_m:
ans = (ans * (tmp_p % mod)) % mod
i += 2
else:
ans = (ans * (tmp_m % mod)) % mod
j += 2
print(ans)
| 0 | null | 6,522,264,279,740 | 82 | 112 |
from collections import Counter
s=input()
n=len(s)
M=[0]
mod=2019
for i in range(n):
m=(M[-1]+int(s[n-1-i])%mod*pow(10,i,mod))%mod
M.append(m)
MC=Counter(M)
r=0
for v in MC.values():
if v>1:
r+=v*(v-1)//2
print(r)
|
N = str(input())
n,mods = 0,[1]+[0]*2018
d = 1
for i in reversed(N):
n = (n+int(i)*d)%2019
mods[n] += 1
d = (d*10)%2019
print(sum([i*(i-1)//2 for i in mods]))
| 1 | 30,825,096,907,180 | null | 166 | 166 |
import math
R = int(input())
p = math.pi
print(2 * p * R)
|
import sys
import math
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
r = int(readline())
print(r * 2 * math.pi)
if __name__ == '__main__':
solve()
| 1 | 31,449,197,101,602 | null | 167 | 167 |
from heapq import heappop, heappush
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
def dijkstra(graph, n, s):
d = [float("inf")] * n
d[s] = 0
q = []
heappush(q, (0, s))
while q:
dist, v = heappop(q)
if d[v] < dist: continue
for nv, cost in graph[v]:
if d[nv] > d[v] + cost:
d[nv] = d[v] + cost
heappush(q, (d[nv], nv))
return d
n = h*w+1
g = [list() for _ in range(n)]
for i in range(h):
for j in range(w-1):
cid = i*w + j
g[cid].append((cid+1, int(s[i][j] == "." and s[i][j+1] == "#")))
for i in range(h-1):
for j in range(w):
cid = i*w + j
g[cid].append((cid+w, int(s[i][j] == "." and s[i+1][j] == "#")))
g[n-1].append((0, int(s[0][0] == "#")))
print(dijkstra(g, n, n-1)[n-2])
|
h,w = map(int, input().split())
L = [input() for i in range(h)]
dp = [[10**9]*w for i in range(h)]
if L[0][0] == ".":
dp[0][0] = 0
else:
dp[0][0] = 1
li = ((1,0),(0,1))
for i in range(h):
for j in range(w):
for dy,dx in li:
ny,nx = i+dy,j+dx
if ny >= h or nx >= w:
continue
plus = 0
if L[i][j] == "." and L[ny][nx] == "#":
plus =1
dp[ny][nx] = min(dp[i][j]+plus,dp[ny][nx])
print(dp[h-1][w-1])
| 1 | 49,343,110,537,996 | null | 194 | 194 |
n,k = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9 + 7
A.sort(key = lambda x:abs(x),reverse = True)
ans = 1
last = -1
lastp = -1
cnt = 0
for a in A:
if a >= 0:break
else:
if k&1:
for i in range(k):
ans *= A[n-i-1]
ans %= mod
else:
for i in range(k):
ans *= A[i]
ans %= mod
print(ans)
exit()
for i in range(k):
ans *= A[i]
ans %= mod
if A[i] < 0:
last = i
cnt += 1
if A[i] > 0:
lastp = i
if n == k:
print(ans%mod)
exit()
if cnt&1:
first = 0
firstp = 0
for a in A[k:]:
if a > 0 and firstp == 0:
firstp = a
if a < 0 and first == 0:
first = a
if first == 0 and firstp == 0:
ans = 0
elif first == 0 or lastp == -1:
ans *= pow(A[last],mod-2,mod)*firstp%mod
ans %= mod
elif firstp == 0:
ans *= pow(A[lastp],mod-2,mod)*first%mod
ans %= mod
else:
if A[lastp]*firstp <= A[last]*first:
ans *= pow(A[lastp],mod-2,mod)*first%mod
ans %= mod
else:
ans *= pow(A[last],mod-2,mod)*firstp%mod
ans %= mod
print(ans%mod)
|
mod = 1000000007
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))
A.sort()
ans = 1
# 負になってしまう時
if A[-1] < 0 and K%2 == 1:
for i in range(K):
ans = ans * (A[-i-1]%mod) % mod
else:
n = 0
p = -1
# Kが奇数の時、正の候補の最大値をあらかじめ消費しておき、偶数の時と同様に処理できるようにする。
if K%2 == 1:
ans = ans * (A[p]%mod) % mod
p -= 1
# 正/負の候補から２つずつ消費していく
for _ in range(K//2):
if A[n]*A[n+1] > A[p]*A[p-1]:
ans = ans * (A[n]%mod) % mod
ans = ans * (A[n+1]%mod) % mod
n += 2
else:
ans = ans * (A[p]%mod) % mod
ans = ans * (A[p-1]%mod) % mod
p -= 2
print(ans)
| 1 | 9,412,621,374,240 | null | 112 | 112 |
l, r, d = [int(x) for x in input().rstrip().split(" ")]
print(r//d-l//d + (l%d==0))
|
#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
#R = 998244353
def ddprint(x):
if DBG:
print(x)
l,r,d = inm()
sm = 0
for i in range(l,r+1):
if i%d==0:
sm += 1
print(sm)
| 1 | 7,539,778,475,878 | null | 104 | 104 |
x=input()
l=(x/60)
h=(l/60)
m=(l-h*60)
s=x-m*60-h*60*60
print str(h)+":"+str(m)+":"+str(s)
|
n,m,k = map(int,input().split())
ans = 0
mod = 998244353
p = [0 for i in range(n)]
p[0] = 1
for i in range(n-1):
p[i+1] = p[i]*(i+2)%mod
p.append(1)
for i in range(k+1):
u = pow(m-1,n-1-i,mod)
s = p[n-2]*pow(p[i-1],mod-2,mod)*pow(p[n-i-2],mod-2,mod)
ans = (ans + m*u*s)%mod
print(ans)
| 0 | null | 11,730,118,187,360 | 37 | 151 |
N, K, C = map(int, input().split())
S = input()
left = []
right = []
i, j = 0, N-1
while len(left) <= K-1:
if S[i] == "o":
left.append(i)
i += C+1
else:
i += 1
while len(right) <= K-1:
if S[j] == "o":
right.append(j)
j -= C+1
else:
j -= 1
right.sort()
for n in range(K):
if left[n] == right[n]:
print(left[n] + 1)
|
x = int(input())
for i in range(8):
if (400 + 200 * i) <= x <= (599 + 200 * i):
print(8 - i)
exit(0)
| 0 | null | 23,825,227,198,652 | 182 | 100 |
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 = input()
t = input()
def f(k):
c = 0
for i in range(len(t)):
if s[k + i] == t[i]:
c += 1
return c
maxi = f(0)
for i in range(len(s) - len(t) + 1):
if f(i) > maxi:
maxi = f(i)
print(len(t) - maxi)
| 1 | 3,676,533,112,000 | null | 82 | 82 |
N,P = map(int, input().split())
S = input()
"""
たとえばSが 123456789 だとすると
3456 = (3456789 - 789) // 1000
と表せる。
これがPで割り切れる場合、基本的には 3456789 と 789 がPで割り切れるとよい。
これはPと 10**x が互いに素の場合。
なので、10**x とPが互いに素の場合は、
・S[l:]をPで割った時余りがXXXになるものが何個、という情報を、Sの右端から集めていく。ただし、
・あるindexのlのS[l:]を見ているときに、その部分をPで割って余りがKになるなら、そのlに対してlより右にあるrについて、
S[r:]をPで割った余りがKになるようにrを選んでS[l:r]を作ると、Pで割り切れる数字が得られる。その時点でのmod P = Kの個数に対応する。
ただし、rに何も選ばない場合（lから端までを数字にする場合）もあるので、これも考慮に入れる。
Pが10と互いに素でない場合は、2と5がありうる。
これについて、それぞれ末尾が2の倍数か5の倍数であれば割り切れるので、
Sを左から見ていって、その数字が見つかれば、そのindexをふくむ左の位置で数字を作ればPで割れる数字ができる
"""
ans = 0
if P in [2, 5]:
for i in range(N):
if int(S[i]) % P == 0:
ans += i+1
else:
mod_P = [0] * P
mod_P[0] += 1
# Sを右端から何個かまで見てできる数字をPで割ってできる余り。
# 数字のまま持っておいて、都度mod P をとるとTLEになるので。
# 3543 で 3543 % P = (3000 + 543) % P のような感じで右から左にSを見ていく
curr = 0
for i in range(N):
curr = curr + int(S[N-1-i]) * pow(10, i, P)
curr %= P
ans += mod_P[curr]
mod_P[curr] += 1
print(ans)
|
A,B = map(str,input().split())
print(B+A)
| 0 | null | 80,464,599,116,880 | 205 | 248 |
a, b, c, k = map(int, input().split())
ans = 0
if k <= a:
ans = k
elif k <= a+b:
ans = a
else:
ans = 2*a +b - k
print(ans)
|
N, K = map(int, input().split())
X = list(map(int, input().split()))
MOD = 10 ** 9 + 7
pos = sorted(v for v in X if v >= 0)
neg = sorted(-v for v in X if v < 0)
if N == K:
ans = 1
for x in X:
ans *= x
ans %= MOD
print(ans % MOD)
exit()
ok = False # True: ans>=0, False: ans<0
if pos:
#正の数があるとき
ok = True
else:
#全部負-> Kが奇数なら負にならざるをえない。
ok = (K % 2 == 0)
ans = 1
if ok:
# ans >= 0
if K % 2 == 1:
#Kが奇数の場合初めに1つ正の数を掛けておく
#こうすれば後に非負でも負でも2つずつのペアで
#考えられる
ans = ans * pos.pop() % MOD
# 答えは非負になる→二つの数の積は必ず非負になる．
cand = []
while len(pos) >= 2:
x = pos.pop() * pos.pop()
cand.append(x)
while len(neg) >= 2:
x = neg.pop() * neg.pop()
cand.append(x)
cand.sort(reverse=True) # ペアの積が格納されているので必ず非負
# ペア毎に掛けていく
for i in range(K // 2):
ans = ans * cand[i] % MOD
else:
# ans <= 0
cand = sorted(X, key=lambda x: abs(x))
for i in range(K):
ans = ans * cand[i] % MOD
print(ans)
| 0 | null | 15,578,219,246,056 | 148 | 112 |
alpha = [chr(i + 97) for i in range(26)]
N = int(input())
name = ''
while N >= 1:
N -= 1
_ = N % 26
name += alpha[_]
N //= 26
print(name[-1::-1])
|
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30
def main():
t = input().strip()
s = []
# A = 0
ans = []
prevA = 0
for i in range(len(t)):
if t[i] == '\\':
s.append(i)
elif len(s) > 0 and t[i] == '/':
p = s.pop()
k = i - p
ans.append((p, k))
q = 0
while len(ans) > 0:
# print(ans)
g, h = ans[-1]
if g >= p:
q += h
ans.pop()
else:
break
# for j in range(len(ans) - len(s)):
# print('i: ', i)
# print('j: ', j)
# print('ans: ', ans)
# q += ans.pop()
# print('q: ', q)
if q != 0:
ans.append((p, q))
# elif len(s) > 0 and t[i] == '_':
# A += 1
v = 0
for i in range(len(ans)):
v += ans[i][1]
print(v)
print(len(ans), end='')
for i in range(len(ans)):
print(' {}'.format(ans[i][1]), end='')
print('')
if __name__ == '__main__':
main()
| 0 | null | 5,957,974,337,270 | 121 | 21 |
string = []
while 1:
s = input()
if s == "-":
break
try:
n = int(s)
for i in range(n):
m = int(input())
string = string[m:] + string[:m]
output = "".join(string)
print(output)
except ValueError:
string = list(s)
continue
|
n = int(input())
odd = 0
even = 0
for i in range(1,n+1):
if i % 2 == 0:
even += 1
else:
odd += 1
print(odd/n)
| 0 | null | 89,159,882,171,080 | 66 | 297 |
x=int(input())
A=int(x//500)
B=int((x%500)//5)
ans=0
ans=A*1000+B*5
print(ans)
|
import sys
x = int(sys.stdin.read())
c500, x = divmod(x, 500)
c5 = x // 5
print(c500 * 1000 + c5 * 5)
| 1 | 42,660,353,920,132 | null | 185 | 185 |
import sys
import math
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
N,K=nm()
A=nl()
imos_l=[0]*(N+1)
for i in range(K):
imos_l=[0]*(N+1)
for j in range(len(A)):
imos_l[max(j-A[j],0)]+=1
imos_l[min(j+A[j]+1,N)]-=1
for j in range(len(imos_l)-1):
imos_l[j+1]=imos_l[j]+imos_l[j+1]
for j in range(len(A)):
A[j]=imos_l[j]
flag=True
for j in range(len(A)):
if(A[j]<N):
flag=False
if(flag):
print(*A)
sys.exit(0)
print(*A)
|
n,k=map(int,input().split())
a=list(map(int,input().split()))
for j in range(k):
b=[0]*n
for i in range(0,n):
l=max(0,i-a[i])
r=min(n-1,i+a[i])
b[l]+=1
if(r+1<n):
b[r+1]-=1
for i in range(1,n,1):
b[i]+=b[i-1]
if a==b:
break
a=b
print(' '.join(map(str,a)))
| 1 | 15,541,465,178,788 | null | 132 | 132 |
from collections import deque
n, u, v = map(int, input().split())
u -= 1
v -= 1
tree = [[] for _ in range(n)]
for _ in range(n-1):
a, b = map(lambda x : int(x) - 1, input().split())
tree[a].append(b)
tree[b].append(a)
q = deque()
q.append((u, 0))
depth = [0] * n
visited = set()
while q:
p, d = q.popleft()
depth[p] = d
visited.add(p)
for x in tree[p]:
if not x in visited:
q.append((x, d+1))
q.append((v, 0))
visited.clear()
max_case = max(depth[v] - 1, 0)
while q:
p, d = q.popleft()
visited.add(p)
is_leaf = True
for x in tree[p]:
if not x in visited:
q.append((x, d+1))
is_leaf = False
if is_leaf and depth[p] < d:
max_case = max(max_case, d - 1)
print(max_case)
|
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()}
N, M = map(int, input().split())
uf = UnionFind(N)
for i in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
uf.union(a, b)
ans = 0
for r in uf.roots():
ans = max(ans, uf.size(r))
print(ans)
| 0 | null | 61,041,944,499,360 | 259 | 84 |
a,b=1,0
for c in map(int,input()):a,b=min(a+10-c-1,b+c+1),min(a+10-c,b+c)
print(b)
|
import sys
input = sys.stdin.readline
def solve(N):
res = 0
flg = 0
for n in reversed(N):
if flg == 2:
if n >= 5:
flg = 1
else:
flg = 0
m = flg + n
if m == 5:
res += 5
flg = 2
elif m < 5:
res += m
flg = 0
else:
res += (10 - m)
flg = 1
return res + flg%2
N = list(map(int, input().strip()))
print(solve(N))
# N = 1
# q = 0
# while True:
# p = solve(list(map(int, str(N))))
# if abs(p-q) > 1:
# print(N, "OK")
# exit()
# q = p
# N += 1
| 1 | 70,668,903,450,392 | null | 219 | 219 |
data = []
while 1:
H, W = map(int, raw_input().split())
if H == 0 and W == 0:
break
data.append([H, W])
for h, w in data:
for i in xrange(h):
print '#' * w
print
|
import math
def kochcurve(n,p1x,p1y,p2x,p2y):
if n==0:
print("%5f %5f"%(p2x,p2y))
return
sx=(p2x-p1x)/3.0+p1x
sy=(p2y-p1y)/3.0+p1y
tx=(p2x-p1x)*2.0/3+p1x
ty=(p2y-p1y)*2.0/3+p1y
ux=math.cos(math.pi/3)*(tx-sx)-math.sin(math.pi/3)*(ty-sy)+sx
uy=math.sin(math.pi/3)*(tx-sx)+math.cos(math.pi/3)*(ty-sy)+sy
kochcurve(n-1,p1x,p1y,sx,sy)
kochcurve(n-1,sx,sy,ux,uy)
kochcurve(n-1,ux,uy,tx,ty)
kochcurve(n-1,tx,ty,p2x,p2y)
n=input()
p1x=0.0
p1y=0.0
p2x=100.0
p2y=0.0
print("%5f %5f"%(p1x,p1y))
kochcurve(n,p1x,p1y,p2x,p2y)
| 0 | null | 444,834,091,140 | 49 | 27 |
#http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_2_A&lang=jp
#??????????????????
#?????????????´?????¢????????????£????????????????????????????????¨???????¢?????????¨
#?????°??¢??°???????¨???????????¢????????????????
def bubble_sort(target_list):
list_length = len(target_list)
flag = True
change_count = 0
top_index = 1
while flag:
flag = False
for i in range(top_index, list_length)[::-1]:
if target_list[i] < target_list[i - 1]:
tmp = target_list[i]
target_list[i] = target_list[i - 1]
target_list[i - 1] = tmp
change_count += 1
flag = True
top_index += 1
return change_count
def main():
n_list = int(input())
target_list = [int(n) for n in input().split()]
cc = bubble_sort(target_list)
print(*target_list)
print(cc)
if __name__ == "__main__":
main()
|
from sys import stdin
input = stdin.buffer.readline
n, k = map(int, input().split())
*a, = map(int, input().split())
for i in range(k, n):
if a[i] > a[i - k]:
print('Yes')
else:
print('No')
| 0 | null | 3,566,332,655,420 | 14 | 102 |
# coding: utf-8
n, k = map(int, input().rstrip().split())
w = [0 for _ in range(n)]
for i in range(n):
w[i] = int(input())
# from random import randint
# n = 100000
# k = 10000
# w = [0 for _ in range(n)]
# for i in range(n):
# w[i] = randint(1, 10000)
# print(w)
count = 0
def check(P):
m = 0
ik = 1
for i in range(n):
global count
count += 1
new = m + w[i]
if new > P:
m = w[i]
ik += 1
if ik > k:
return False
else:
m = new
return True
s = max(sum(w)//k, max(w))
e = sum(w)
while True:
P = (s + e)//2
# print("s:{}, e:{}, P:{}".format(s, e, P))
if s == e:
break
if check(P):
e = P
else:
s = P + 1
print(P)
# print(count)
|
n = int(input())
p = str(tuple(map(int, input().split())))
q = str(tuple(map(int, input().split())))
import itertools
n_l = [ i+1 for i in range(n) ]
d = {}
for i, v in enumerate(itertools.permutations(n_l)):
d[str(v)] = i
print(abs(d[p]-d[q]))
| 0 | null | 50,632,434,468,448 | 24 | 246 |
N = int(input())
ans = []
for n in range(1, int(N ** 0.5) + 1):
if (N - 1) % n == 0:
ans.append(n)
ans.append((N - 1) // n)
for k in range(2, int(N ** 0.5) + 1):
if N % k != 0:
continue
x = N
while x % k == 0:
x //= k
if x % k == 1:
ans.append(k)
print(len(set(ans)))
|
import numpy as np
def divisors(N):
return sorted(sum((list({n, N // n}) for n in range(1, int(N ** 0.5) + 1) if not N % n), []))
def prime_factorize_dict(n):
d = dict()
while not n & 1:
d[2] = d.get(2, 0) + 1
n >>= 1
f = 3
while f * f <= n:
if not n % f:
d[f] = d.get(f, 0) + 1
n //= f
else:
f += 2
if n != 1:
d[n] = d.get(n, 0) + 1
return d
N = int(input())
count = 0
for n in divisors(N)[1:]:
M = N
while not M % n:
M //= n
count += M % n == 1
fact_Nm1 = np.array(list(prime_factorize_dict(N - 1).values()), dtype=np.int32)
print(count + np.prod(fact_Nm1 + 1) - 1)
| 1 | 41,243,487,057,010 | null | 183 | 183 |
import sys
inf = 1<<30
def solve():
n, m = map(int, input().split())
c = [int(i) for i in input().split()]
c.sort()
dp = [inf] * (n + 1)
dp[0] = 0
for i in range(1, n + 1):
for cj in c:
if i - cj < 0:
break
dp[i] = min(dp[i], dp[i - cj] + 1)
ans = dp[n]
print(ans)
if __name__ == '__main__':
solve()
|
def f(num):
mn = 20000
for y in c:
if y > num/2:
break
mn = min(mn, yen[y]+yen[num-y])
return mn
n, m = map(int, input().split())
c = list(map(int, input().split()))
c = sorted(c)
yen = [0 for i in range(n+1)]
yen[1] = 1
for num in range(2, n+1):
if num in c:
yen[num] = 1
else:
yen[num] = min(yen[num-1]+1,f(num))
print(yen[n])
| 1 | 139,469,339,938 | null | 28 | 28 |
print("Yes") if (input()*2).find(input())>-1 else print("No")
|
import sys
from collections import deque
n = int(input())
q = deque()
for i in range(n):
c = sys.stdin.readline()[:-1]
if c[0] == 'i':
q.appendleft(c[7:])
elif c[6] == ' ':
try:
q.remove(c[7:])
except:
pass
elif c[6] == 'F':
q.popleft()
else:
q.pop()
print(*q)
| 0 | null | 890,659,626,520 | 64 | 20 |
import math
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()))
dp = [0]*(H+1)
dp[0] = 0
for i in range(1,H+1):
dp_min = math.inf
for j in range(N):
dp_min = min(dp_min, dp[max(0,i-A[j])] + B[j])
dp[i] = dp_min
print(dp[H])
|
H,W,M = map(int,input().split())
Hmax_temp = [0]*(H+1)
Wmax_temp = [0]*(W+1)
Hmax = 0
Wmax = 0
Bomb = dict()
for i in range(M):
H_M,W_M = map(int,input().split())
Hmax_temp[H_M] += 1
Wmax_temp[W_M] += 1
Bomb[(H_M,W_M)] = 1
Hmax = max(Hmax_temp)
Wmax = max(Wmax_temp)
#H方向の走査
y_max = []
for i in range(H+1):
if Hmax == Hmax_temp[i]:
y_max.append(i)
#W方向の走査
x_max = []
for j in range(W+1):
if Wmax == Wmax_temp[j]:
x_max.append(j)
#爆弾設置位置に対象が存在するか？
flag = False
for i in y_max:
for j in x_max:
if (i,j) not in Bomb:
flag = True
break
if flag:
break
#答えのセット
if flag:
ans = Wmax + Hmax
else:
ans = Wmax + Hmax - 1
print(ans)
| 0 | null | 43,083,113,712,350 | 229 | 89 |
N = int(input())
S = str(input())
R = S[::-1]
ans = 0
for i in range(1000):
z = str(i).zfill(3)
right = -1
left = -1
if z[2] in R:
r = R.index(z[2]) + 1
right = N-r
else:
continue
if z[0] in S:
left = S.index(z[0]) + 1
else:
continue
if z[1] in S[left:right]:
ans += 1
print(ans)
|
def input_li():
return list(map(int, input().split()))
def input_int():
return int(input())
N = input_int()
S = input()
ans = 0
for i in range(1000):
str_i = str(i)
s = '0' * (3 - len(str_i)) + str_i
idx = 0
for j in range(N):
if S[j] == s[idx]:
idx += 1
if idx == 3:
ans += 1
break
print(ans)
| 1 | 128,875,650,607,100 | null | 267 | 267 |
line = input()
num_query = int(input())
for loop in range(num_query):
input_str = list(input().split())
if input_str[0] == 'replace':
left = int(input_str[1])
right = int(input_str[2])
right += 1
line = line[:left] + input_str[3] + line[right:]
elif input_str[0] == 'reverse':
left = int(input_str[1])
right = int(input_str[2])
right += 1
line = line[:left] + line[left:right][::-1] + line[right:]
else: # print
left = int(input_str[1])
right = int(input_str[2])
right += 1
for i in range(left, right):
print(line[i], end="")
print()
|
S = input()
q = int(input())
for i in range(q):
cmd = input().split()
a = int(cmd[1])
b = int(cmd[2])
if cmd[0] == "print":
print(S[a:b+1])
elif cmd[0] == "replace":
S = S[0:a] + cmd[3] + S[b+1:len(S)]
elif cmd[0] == "reverse":
r = S[a:b+1]
S = S[0:a] + r[::-1] + S[b+1:len(S)]
| 1 | 2,082,139,548,580 | null | 68 | 68 |
S = input()
flg = True
for i in range(len(S)):
if flg == True and S[i] == "h":
flg = False
continue
elif flg == False and S[i] == "i":
flg = True
continue
else:
print("No")
break
else:
if flg == False:
print("No")
else:
print("Yes")
|
N = int(input())
a500 = N //500
N = N - 500 *a500
a5 = N//5
res = 1000*a500 +5*a5
print(res)
| 0 | null | 48,101,657,085,468 | 199 | 185 |
a, b = (int(x) for x in input().split())
ans=0
if a==b:
for i in range(a):
ans+=a*pow(10,i)
elif a>b:
for i in range(a):
ans+=b*pow(10,i)
else:
for i in range(b):
ans+=a*pow(10,i)
print(ans)
|
alpha = input()
if(alpha.isupper()):
print("A")
else:
print("a")
| 0 | null | 47,757,661,164,070 | 232 | 119 |
#!/usr/bin/env python3
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(2147483647)
from heapq import heappush, heappop,heappushpop
from collections import defaultdict
from itertools import accumulate
from collections import Counter
from collections import deque
from operator import itemgetter
from itertools import permutations
mod = 10**9 + 7
inf = float('inf')
def I(): return int(sys.stdin.readline())
def LI(): return list(map(int,sys.stdin.readline().split()))
a = LI()
s = sum(a)
if s >= 22:
print('bust')
else:
print('win')
|
print("bust") if sum(list(map(int,input().split()))) > 21 else print("win")
| 1 | 119,195,681,225,698 | null | 260 | 260 |
N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort()
F.sort(reverse=True)
ng = -1
ok = 10**12+100
while ok - ng > 1:
mid = (ok + ng) // 2
c = 0
for a,f in zip(A,F):
c += max(0,a-mid//f)
if c <= K:
ok = mid
else:
ng = mid
print(ok)
|
N, K = map(int, input().split())
A = sorted(list(map(int, input().split())))
F = sorted(list(map(int, input().split())), reverse=True)
# にぶたん := N人のメンバーそれぞれが完食にかかる時間のうち最大値をxに以下にできるか？
ok, ng = 10 ** 12 + 1, -1
while ok - ng > 1:
x = (ok + ng) // 2
need_training = 0
for a, f in zip(A, F):
need_training += max(0, a - x // f)
if need_training > K:
ng = x
break
else:
ok = x
print(ok)
| 1 | 165,171,329,058,648 | null | 290 | 290 |
print("win" if sum(list(map(int,input().split())))<=21 else "bust")
|
class cmbs(object):
def __init__(self, mod):
self.mod = mod
self.g1 = [1, 1]
self.g2 = [1, 1]
inverse = [0, 1]
for i in range(2, 2 * (10 ** 6) + 1):
self.g1.append((self.g1[-1] * i) % mod)
inverse.append((-inverse[mod % i] * (mod // i)) % mod)
self.g2.append((self.g2[-1] * inverse[-1]) % mod)
def cmb(self, n, r):
if n > 2 * (10 ** 6):
return self.cmbl(n, r)
return self.cmbr(n, r)
def cmbr(self, n, r):
if r < 0 or r > n:
return 0
r = min(r, n - r)
return self.g1[n] * self.g2[r] * self.g2[n-r] % self.mod
def cmbl(self, n, r):
t = 1
r = min(r, n-r)
for i in range(n - r + 1, n + 1):
t = t * i % self.mod
return t * self.g2[r] % self.mod
def main():
K = int(input())
S = input()
l = len(S)
mod = 10**9 + 7
c = cmbs(mod)
r = 0
x25 = 1
x26 = pow(26, K, mod)
inv26 = pow(26, mod-2, mod)
for i in range(K+1):
r = (r + c.cmb(l+i-1, i) * x25 * x26) % mod
x25 = x25 * 25 % mod
x26 = x26 * inv26 % mod
return r % mod
print(main())
| 0 | null | 65,884,041,506,052 | 260 | 124 |
from bisect import *
N = int(input())
L = sorted(map(int,input().split()))
a = 0
for i in range(N):
for j in range(i+1,N):
a+=bisect_left(L,L[i]+L[j])-(j+1)
print(a)
|
import bisect
def main():
n = int(input())
l = sorted(list(int(i) for i in input().split()))
cnt = 0
for i in range(n - 2):
a = l[i]
for j in range(i + 1, n-1):
b = l[j]
cnt += bisect.bisect_left(l, a+b)-(j+1)
print(cnt)
if __name__ == "__main__":
main()
| 1 | 172,163,238,386,436 | null | 294 | 294 |
n, k = map(int, input().split())
lst = [int(i) for i in input().split()]
tele_lst = []
town_set = set()
town = 1
while True:
if town not in town_set:
tele_lst.append(town)
town_set.add(town)
else:
break
town = lst[town - 1]
ind = tele_lst.index(town)
length = len(town_set)
circle = length - ind
#print(ind, length)
#print(tele_lst)
if k < ind:
town = tele_lst[k]
print(town)
else:
k -= ind
k %= circle
#print(k)
town = tele_lst[ind + k]
print(town)
|
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors[1:]
n = int(input())
a = make_divisors(n-1)
b = make_divisors(n)
count = 0
for kk in b:
mom = n
while mom % kk == 0:
mom //= kk
if mom % kk == 1:
count +=1
print(len(a) + count)
| 0 | null | 31,954,259,793,600 | 150 | 183 |
from collections import defaultdict, Counter
MOD = 10**9+7
n, K = map(int, input().split())
cnt = Counter(map(int, input().split()))
keys = sorted(cnt.keys())
key_to_idx = defaultdict(int)
for i, k in enumerate(keys):
key_to_idx[k] = i
Acum = [0]
for k in keys:
Acum.append(Acum[-1]+cnt[k])
U = n
fact = [0]*(U+1)
fact[0] = 1
for i in range(1, U+1):
fact[i] = fact[i-1]*i % MOD
invfact = [0]*(U+1)
invfact[U] = pow(fact[U], MOD-2, MOD)
for i in reversed(range(U)):
invfact[i] = invfact[i+1]*(i+1) % MOD
def nCr(n, r):
if r < 0 or n < r:
return 0
return fact[n]*invfact[r]*invfact[n-r]
ans = 0
for k in keys:
x = Acum[key_to_idx[k]+1]
y = Acum[key_to_idx[k]]
cmax = nCr(x, K) - nCr(y, K)
cmin = nCr(n-y, K) - nCr(n-x, K)
ans += k*(cmax-cmin)
ans %= MOD
print(ans)
|
def cmb(a,b,c):
b = min(b,a-b)
num = 1
for i in range(b):
num = num*(a-i) % c
den = 1
for i in range(b):
den = den*(i+1) % c
return num * pow(den,c-2,c) % c
mod = 10**9+7
n,k = map(int,input().split())
a = list(map(int,input().split()))
a.sort()
ans = 0
c = cmb(n-1,k-1,mod)
if k == 1:
print(0)
exit()
for i in range(n-k+1):
ans -= a[i] * c
ans += a[-i-1] * c
ans %= mod
c = (c * (n-k-i) * pow(n-i-1,mod-2,mod)) % mod
if ans < 0:
ans += mod
print(ans)
| 1 | 95,463,018,501,138 | null | 242 | 242 |
n=int(input())
a=0
for i in range(1,n+1):
a+=(i%2)
print(a/n)
|
import math
from itertools import permutations
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
ls = permutations(range(1, N+1), N)
Ns = []
for l in ls:
s = ''.join([str(n) for n in l])
Ns.append(int(s))
p = ''.join(map(str, P))
q = ''.join(map(str, Q))
a = Ns.index(int(p)) + 1
b = Ns.index(int(q)) + 1
print(abs(a-b))
| 0 | null | 139,061,122,016,448 | 297 | 246 |
from heapq import heappush, heappop, heapify
from collections import deque, defaultdict, Counter
import itertools
from itertools import permutations, combinations, accumulate, product, combinations_with_replacement
import sys
import bisect
import string
import math
import time
def I(): return int(input())
def S(): return input()
def MI(): return map(int, input().split())
def MS(): return map(str, 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 input(): return sys.stdin.readline().rstrip()
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 print_matrix(mat):
for i in range(len(mat)):
print(*['IINF' if v == IINF else "{:0=4}".format(v) for v in mat[i]])
yn = {False: 'No', True: 'Yes'}
YN = {False: 'NO', True: 'YES'}
MOD = 10**9+7
inf = float('inf')
IINF = 10**19
l_alp = string.ascii_lowercase
u_alp = string.ascii_uppercase
ts = time.time()
sys.setrecursionlimit(10**6)
nums = ['1', '2', '3', '4', '5', '6', '7', '8', '9', '10']
show_flg = False
# show_flg = True
def main():
N = I()
X = S()
bit_cnt = X.count('1')
one_inv_cnt = bit_cnt - 1
zero_inv_cnt = bit_cnt + 1
MAX = 2 * 10 ** 5 + 1
# 大きい数の余り
# 繰り返し２乗法の発展？
zero_mod = 0
one_mod = 0
for i in range(0, len(X)):
b = int(X[i])
if one_inv_cnt != 0:
one_mod = (one_mod * 2 + b) % one_inv_cnt
zero_mod = (zero_mod * 2 + b) % zero_inv_cnt
f = [0] * MAX
for i in range(1, MAX):
f[i] = f[i % str(bin(i)).count('1')] + 1
for i in range(len(X)-1, -1, -1):
if X[N-1-i] == '1':
if one_inv_cnt != 0:
nxt = one_mod
nxt -= pow(2, i, one_inv_cnt)
nxt %= one_inv_cnt
print(f[nxt] + 1)
else:
print(0)
else:
nxt = zero_mod
nxt += pow(2, i, zero_inv_cnt)
nxt %= zero_inv_cnt
print(f[nxt] + 1)
if __name__ == '__main__':
main()
|
def main():
N = int(input())
X = input()
def popcount(x):
'''xの立っているビット数をカウントする関数
(xは64bit整数)'''
# 2bitごとの組に分け、立っているビット数を2bitで表現する
x = x - ((x >> 1) & 0x5555555555555555)
# 4bit整数に 上位2bit + 下位2bit を計算した値を入れる
x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333)
x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f # 8bitごと
x = x + (x >> 8) # 16bitごと
x = x + (x >> 16) # 32bitごと
x = x + (x >> 32) # 64bitごと = 全部の合計
return x & 0x0000007f
ans = []
f = [0] * N
# preprocess 1
for i in range(1, N):
pc = popcount(i)
j = i % pc
f[i] = f[j] + 1
# preprocess 2
X_COUNT = X.count("1")
X = tuple(map(int, tuple(X)))
rem_plus = [0] * N
rem_minus = [0] * N
two_factor = 1
for i in range(N):
rem_plus[i] = two_factor
two_factor *= 2
two_factor %= (X_COUNT+1)
if X_COUNT > 1:
two_factor = 1
for i in range(N):
rem_minus[i] = two_factor
two_factor *= 2
two_factor %= (X_COUNT-1)
X_rem_plus = 0
X_rem_minus = 0
two_factor = 1
for c in X[::-1]:
X_rem_plus += two_factor*c
X_rem_plus %= (X_COUNT+1)
two_factor *= 2
two_factor %= (X_COUNT+1)
if X_COUNT > 1:
two_factor = 1
for c in X[::-1]:
X_rem_minus += two_factor*c
X_rem_minus %= (X_COUNT-1)
two_factor *= 2
two_factor %= (X_COUNT-1)
for i, c in enumerate(X):
if c:
if X_COUNT > 1:
rem = X_rem_minus - rem_minus[N-1-i]
rem %= (X_COUNT-1)
ans.append(f[rem]+1)
elif X_COUNT == 1:
ans.append(0)
else:
ans.append(0)
else:
rem = X_rem_plus + rem_plus[N-1-i]
rem %= (X_COUNT+1)
ans.append(f[rem]+1)
print(*ans, sep="\n")
if __name__ == "__main__":
main()
| 1 | 8,159,022,329,468 | null | 107 | 107 |
N,A,B = map(int,input().split())
a = N//(A+B)
b = N%(A+B)
if b>A:
print(a*A+A)
else:
print(a*A+b)
|
n,a,b = map(int,input().split())
mod = n%(a+b)
if mod > a :
ans = a
else:
ans = mod
ans += (n//(a+b))*a
print(ans)
| 1 | 55,314,633,901,350 | null | 202 | 202 |
def readinput():
n=int(input())
l=list(map(int,input().split()))
return n,l
def main(n,a):
MOD=10**9+7
hist=[0]*61
bs=[]
for i in range(n):
# s=list(reversed(bin(a[i])[2:]))
# for j in range(len(s)):
# if s[j]=='1':
# hist[j]+=1
# bs.append(s)
s=bin(a[i])[2:]
for j in range(len(s)):
if s[j]=='1':
hist[len(s)-j-1]+=1
# j=0
# ai=a[i]
# while ai>0:
# if ai&1==1:
# hist[j]+=1
# ai = ai >> 1
# j+=1
#print(bs)
#print(hist)
#print(hist)
sum=0
# for i in range(n-1):
# s=bs[i]
# b=1
# for j in range(len(s)):
# if s[j]=='0':
# sum=(sum+hist[j]*b)%MOD
# else:
# sum=(sum+( n-i-hist[j] )*b)%MOD
# hist[j]-=1
# b*=2
# for j in range(len(s),61):
# sum=(sum+hist[j]*b)%MOD
# b*=2
b=1
for j in range(61):
sum=(sum+( hist[j]*(n-hist[j])*b )%MOD )%MOD
b*=2
return sum
if __name__=='__main__':
n,l=readinput()
ans=main(n,l)
print(ans)
|
import sys
N = int(sys.stdin.readline().rstrip())
A = list(map(int, sys.stdin.readline().rstrip().split()))
mod = 10**9 + 7
cnt_one = [0] * 60
cnt_zero = [0] * 60
def count_bin(a):
base = 1
for i in range(60):
if a % (base * 2) > 0:
cnt_one[i] += 1
a -= base
else:
cnt_zero[i] += 1
base *= 2
for a in A:
count_bin(a)
base = 1
ans = 0
for one, zero in zip(cnt_one, cnt_zero):
ans += one * zero * base
ans %= mod
base *= 2
base %= mod
print(ans)
| 1 | 123,489,262,457,230 | null | 263 | 263 |
from math import sqrt
n=int(input())
x=list(map(int,input().split()))
y=list(map(int,input().split()))
p1=0;p2=0;p3=0;p=[]
for i in range(n):
a=abs(x[i]-y[i])
p1+=a
p2+=a**2
p3+=a**3
p.append(a)
print(p1)
print(sqrt(p2))
print(p3**(1/3))
print(max(p))
|
# Dice I
class Dice:
def __init__(self, a1, a2, a3, a4, a5, a6):
# サイコロを縦横にたどると書いてある数字(index1は真上、index3は真下の数字)
self.v = [a5, a1, a2, a6] # 縦方向
self.h = [a4, a1, a3, a6] # 横方向
# print(self.v, self.h)
# サイコロの上面の数字を表示
def top(self):
return self.v[1]
# サイコロを北方向に倒す
def north(self):
newV = [self.v[1], self.v[2], self.v[3], self.v[0]]
self.v = newV
self.h[1] = self.v[1]
self.h[3] = self.v[3]
return self.v, self.h
# サイコロを南方向に倒す
def south(self):
newV = [self.v[3], self.v[0], self.v[1], self.v[2]]
self.v = newV
self.h[1] = self.v[1]
self.h[3] = self.v[3]
return self.v, self.h
# サイコロを東方向に倒す
def east(self):
newH = [self.h[3], self.h[0], self.h[1], self.h[2]]
self.h = newH
self.v[1] = self.h[1]
self.v[3] = self.h[3]
return self.v, self.h
# サイコロを西方向に倒す
def west(self):
newH = [self.h[1], self.h[2], self.h[3], self.h[0]]
self.h = newH
self.v[1] = self.h[1]
self.v[3] = self.h[3]
return self.v, self.h
d = input().rstrip().split()
dice1 = Dice(d[0], d[1], d[2], d[3], d[4], d[5])
command = list(input().rstrip())
# print(command)
for i, a in enumerate(command):
if a == 'N':
dice1.north()
elif a == 'S':
dice1.south()
elif a == 'E':
dice1.east()
elif a == 'W':
dice1.west()
print(dice1.top())
| 0 | null | 220,795,452,540 | 32 | 33 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
for _ in range(k):
b = [0] * (n + 1)
for i in range(n):
b[max(0, i - a[i])] += 1
b[min(n, i + a[i] + 1)] -= 1
a[0] = b[0]
for i in range(1, n):
a[i] = b[i] + a[i - 1]
if sum(a) == pow(n, 2):
break
print(*a)
|
n=int(input())
c=0
a=list(map(int,input().split()))
for i in range(n):
m=i
for j in range(i,n):
if a[m]>a[j]:m=j
if i!=m:a[m],a[i]=a[i],a[m];c+=1
print(*a)
print(c)
| 0 | null | 7,712,483,825,970 | 132 | 15 |
import math
a=input()
a=float(a)
p=math.pi
b= a*a*p
c= a*2*p
print('%03.7f' % b,'%03.7f' % c)
|
l=list(map(int,input().split()))
a=l[0]
b=l[1]
if(a>9 or a<1 or b>9 or b<1):
print(-1)
else:
print(a*b)
| 0 | null | 79,204,826,052,242 | 46 | 286 |
charge, n_coin = map(int,input().split())
coin_ls = list(map(int, input().split()))
coin_ls = [0] + coin_ls
dp = [[float('inf')] * (charge+1) for _ in range(n_coin+1)]
dp[0][0] = 0
for coin_i in range(1,n_coin+1):
for now_charge in range(0,charge+1):
if now_charge - coin_ls[coin_i] >= 0:
dp[coin_i][now_charge] = min(dp[coin_i][now_charge], dp[coin_i][now_charge-coin_ls[coin_i]]+1)
dp[coin_i][now_charge] = min(dp[coin_i-1][now_charge], dp[coin_i][now_charge])
print(dp[n_coin][charge])
|
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
N0 = 2**(N.bit_length())
st = [0] * (N0*2)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) // 2
rm = (R // (R & -R)) // 2
while L < R:
if R <= rm:
yield R - 1
if L <= lm:
yield L - 1
L //= 2; R //= 2
while L > 0:
yield L - 1
L //= 2
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += N0-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += N0
r += N0
ret = 0
while l < r:
if l % 2:
ret |= st[l-1]
l += 1
if r % 2:
r -= 1
ret |= st[r-1]
l //= 2 ; r //= 2
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main()
| 0 | null | 31,406,966,073,948 | 28 | 210 |
A,B=map(int,input().split())
N = list(map(int,input().split()))
c=0
for i in range(A):
if N[i] >= B:
c+=1
else:
pass
i+=1
print(c)
|
from sys import stdin
def stdinput():
return stdin.readline().strip()
from collections import deque
def main():
n ,q = map(int, stdinput().split())
ps = deque()
for _ in range(n):
p, t = stdinput().split()
t = int(t)
ps.append([p, t])
ctime = 0
while len(ps) > 0:
p = ps.popleft()
if p[1] <= q:
ctime += p[1]
print(f'{p[0]} {ctime}')
else:
ctime += q
p[1] -= q
ps.append(p)
if __name__ == '__main__':
main()
| 0 | null | 89,048,300,152,170 | 298 | 19 |
import os, sys, re, math
S = input()
count = 0
for i in range(len(S) // 2):
if S[i] != S[-i - 1]:
count += 1
print(count)
|
s=input()
rs=s[::-1]
ans=0
for i in range (len(s)):
if s[i] != rs[i]:
ans+=1
print(ans//2)
| 1 | 120,105,182,156,080 | null | 261 | 261 |
import os
import sys
from atexit import register
from io import BytesIO
sys.stdin = BytesIO(os.read(0, os.fstat(0).st_size))
sys.stdout = BytesIO()
register(lambda: os.write(1, sys.stdout.getvalue()))
input = lambda: sys.stdin.readline().rstrip('\r\n')
raw_input = lambda: sys.stdin.readline().rstrip('\r\n')
x = int(input())
print(int(x!=1))
|
#!/usr/bin/env python
def f(x: int) -> int:
"""
>>> f(0)
1
>>> f(1)
0
"""
if x == 1:
return 0
else:
return 1
if __name__ == '__main__':
x = int(input())
print(f(x))
| 1 | 2,914,251,535,812 | null | 76 | 76 |
import math
n,k = map(int,input().split())
s = n//k
if n-k*s>abs(n-k*s-k):
print(abs(n-k*s-k))
else:
print(n-k*s)
|
s = input()
s += s
key = input()
if s.find(key) != -1: print("Yes")
else: print("No")
| 0 | null | 20,462,268,685,440 | 180 | 64 |
k,n = map(int, input().split())
arr = list(map(int, input().split()))
prev = 0
m = 0
for i in arr:
m = max(m, abs(prev-i))
prev = i
m = max(m, k+arr[0]-arr[n-1])
ans = k-m
print(ans)
|
import sys
dic = set()
L = sys.stdin.readlines()
for Ins in L[1:]:
ins, op = Ins.split()
if ins == 'insert':
dic.add(op)
if ins == 'find':
print('yes' if op in dic else 'no')
| 0 | null | 21,769,349,892,652 | 186 | 23 |
n = int(input())
m = n
primes = {}
for i in range(2, int(n**0.5+2)):
while m % i == 0:
m //= i
if i not in primes:
primes[i] = 1
else:
primes[i] += 1
if i > m:
break
if m != 1:
primes[m] = 1
cnt = 0
num = 0
flag = True
while flag == True:
num += 1
flag = False
for i in primes:
if 0 < primes[i] <= num*2:
cnt += 1
primes[i] = 0
elif primes[i] > num*2:
cnt += 1
flag = True
primes[i] -= num
print(cnt)
|
import math
def factorization(n):
arr=[]
temp=n
for i in range(2,int(math.sqrt(n))):
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
n=int(input())
if n==1:
print(0)
exit()
ans=0
for i in factorization(n):
if i[1]>=3:
cnt=1
while i[1]-cnt>cnt:
ans+=1
i[1]-=cnt
cnt+=1
if i[1]!=0:
ans+=1
else:
ans+=1
print(ans)
| 1 | 16,974,374,264,092 | null | 136 | 136 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.