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
|
|---|---|---|---|---|---|---|
from collections import Counter
N,*D = map(int, open(0).read().split())
MOD = 998244353
c = Counter(D)
cnt = 1
M = max(c.keys())
ans = 1
if D[0]!=0 or c[0]!=1:
print(0)
import sys
sys.exit()
while cnt<=M:
ans *= c[cnt-1]**c[cnt]
ans %= MOD
cnt += 1
print(ans) | from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
from collections import Counter
n=int(input())
d=lnii()
mod=998244353
c=Counter(d)
max_key=max(d)
if d[0]!=0 or c[0]!=1:
print(0)
exit()
ans=1
patterns=1
for i in range(max_key+1):
p_num=c[i]
ans*=patterns**p_num
ans%=mod
patterns=p_num
print(ans) | 1 | 154,704,863,292,032 | null | 284 | 284 |
def ncr(n, r):
num, den = 1, 1
if n - r < r:
r = n - r
for i in range(1, r + 1):
num *= n - i + 1
num %= MOD
den *= i
den %= MOD
return num * pow(den, MOD - 2, MOD) % MOD
MOD = 10 ** 9 + 7
X, Y = map(int, input().split())
Z = X + Y
if Z % 3 or Y > 2 * X or Y < X // 2:
print(0)
else:
print(ncr(Z // 3, X - Z // 3))
| data=list(map(int,input().split()))
if data[0]/data[1]<=data[2]:
print('Yes')
else:
print('No') | 0 | null | 77,020,802,686,730 | 281 | 81 |
n,m=map(int,input().split())
a=list(map(int,input().split()))
ans=0
for i in range(m) :
ans = ans+a[i]
day=n-ans
#if day>=0 :
# print(day)
#else :
# print(-1)
print(day if day >= 0 else "-1") | N, M = map(int, input().split())
A = list(map(int, input().split()))
ans = N-sum(A)
if ans < 0:
ans = -1
print(ans) | 1 | 31,899,856,217,768 | null | 168 | 168 |
from scipy.sparse import*
_,*s=open(0)
*g,=eval('[0]*500,'*500)
i=-1
for t in s:
i+=1;j=0
for u in t:k=i*20+j;g[k][k+1]=u>'#'<t[j+1];g[k][k+20]=u>'#'<(s+['#'*20])[i+1][j];j+=1
a=csgraph.johnson(csr_matrix(g),0)
print(int(max(a[a<999]))) | h,w=[int(x) for x in input().rstrip().split()]
l=[list(input()) for i in range(h)]
move=[[1,0],[-1,0],[0,-1],[0,1]]
def bfs(x,y):
stack=[[x,y]]
done=[[False]*w for i in range(h)]
dist=[[0]*w for i in range(h)]
max_val=0
while(stack):
nx,ny=stack.pop(0)
done[ny][nx]=True
for dx,dy in move:
mx=nx+dx
my=ny+dy
if not(0<=mx<=w-1) or not(0<=my<=h-1) or done[my][mx]==True or l[my][mx]=="#":
continue
done[my][mx]=True
dist[my][mx]=dist[ny][nx]+1
max_val=max(max_val,dist[my][mx])
stack.append([mx,my])
return max_val
ans=0
for i in range(w):
for j in range(h):
if l[j][i]!="#":
now=bfs(i,j)
ans=max(ans,now)
print(ans) | 1 | 94,836,653,412,420 | null | 241 | 241 |
def inpl(): return list(map(int, input().split()))
X = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(X[int(input())-1]) | #!/usr/bin/env python3
import collections
import itertools as it
import math
import numpy as np
# A = input()
A = int(input())
# A = map(int, input().split())
# A = list(map(int, input().split()))
# A = [int(input()) for i in range(N)]
#
# c = collections.Counter()
li = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
print(li[A-1]) | 1 | 49,927,383,700,800 | null | 195 | 195 |
import heapq
x,y,a,b,c = map(int,input().split())
P = list(map(int,input().split()))
Q = list(map(int,input().split()))
R = list(map(int,input().split()))
P.sort(reverse=True)
Q.sort(reverse=True)
R.sort(reverse=True)
x_tmp = P[:x]
y_tmp = Q[:y]
tmp_li = x_tmp+y_tmp
heapq.heapify(tmp_li)
for i in range(c):
if R[i]>tmp_li[0]:
heapq.heapreplace(tmp_li,R[i])
print(sum(tmp_li)) | x, y, a, b, c = map(int, input().split())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
r = list(map(int, input().split()))
p.sort(reverse=True)
q.sort(reverse=True)
r.sort(reverse=True)
s = p[:x] + q[:y]
s.sort()
ans = sum(s)
for si, ri in zip(s, r):
if si < ri:
ans += ri - si
print(ans) | 1 | 45,026,047,253,546 | null | 188 | 188 |
n,k = map(int, input().split())
scores = list(map(int, input().split()))
for i in range(k, n):
a = scores[i]
b = scores[i-k]
if a > b:
print('Yes')
else:
print('No') | N,K = map(int,input().split())
A = [int(a) for a in input().split()]
n = 0
for i in range(K,N):
if A[i] > A[n] :
print("Yes")
else:
print("No")
n+=1
| 1 | 7,168,850,883,520 | null | 102 | 102 |
n = int(input())
s = list(map(int,input().split()))
q = int(input())
r = list(map(int,input().split()))
cou = 0
for i in range(q):
for j in range(n):
if(s[j] == r[i]):
cou += 1
break
print(cou)
| import bisect,collections,copy,itertools,math,string
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
def main():
n = I()
a = LI()
lst = [0 for _ in range(10**6+1)]
a.sort()
cnt = 0
st = set()
for i in a:
if lst[i] == -1:
pass
elif lst[i] == 0:
cnt += 1
lst[i] = 1
time = 10**6//i
for j in range(2,time+1):
lst[i*j] = -1
elif lst[i] == 1:
st.add(i)
ans = cnt - len(st)
print(ans)
main()
| 0 | null | 7,281,365,891,322 | 22 | 129 |
n = int(input())
a = [set() for i in range(n)]
e = []
for i in range(n-1):
b, c = map(int, input().split())
b -= 1
c -= 1
a[b].add(c)
a[c].add(b)
e.append(c)
col = [0 for i in range(n)]
visited = [False for i in range(n)]
visited[0] = True
v = [0]
while v:
d = v.pop(0)
k = 1
for i in a[d]:
if visited[i] == False:
if col[d] == k:
k += 1
col[i] = k
visited[i] = True
v.append(i)
k += 1
print (max(col))
for i in e:
print (col[i]) | # import sys
# sys.setrecursionlimit(10 ** 6)
# import bisect
from collections import deque
# from decorator import stop_watch
#
#
# @stop_watch
def solve(N, ABs):
tree_top = [[] for _ in range(N + 1)]
for i in range(N - 1):
tree_top[ABs[i][0]].append(i)
tree_top[ABs[i][1]].append(i)
max_color = 0
for tt in tree_top:
max_color = max(max_color, len(tt))
ans = [0 for _ in range(N - 1)]
for tt in tree_top:
colored = []
for i in tt:
if ans[i] != 0:
colored.append(ans[i])
colored.sort()
now_color = 1
colored_point = 0
for i in tt:
if ans[i] != 0:
continue
if colored_point < len(colored) \
and now_color == colored[colored_point]:
now_color += 1
colored_point += 1
ans[i] = now_color
now_color += 1
print(max_color)
for a in ans:
print(a)
if __name__ == '__main__':
# S = input()
N = int(input())
# N, M = map(int, input().split())
# As = [int(i) for i in input().split()]
# Bs = [int(i) for i in input().split()]
ABs = [[int(i) for i in input().split()] for _ in range(N - 1)]
solve(N, ABs)
| 1 | 135,945,260,664,734 | null | 272 | 272 |
X, N = map(int, input().split())
if N:
lst = list(map(int, input().split()))
for i in range(100):
if X-i not in lst:
print(X-i)
break
if X+i not in lst:
print(X+i)
break
else:
print(X) | X, N = map(int, input().split())
if not N == 0:
p_l = list(map(int, input().split()))
if N == 0:
print(X)
exit()
a = b = X
if not a in p_l:
if not b in p_l:
if a > b:
print(b)
exit()
else:
print(a)
exit()
print(a)
exit()
elif not b in p_l:
if not a in p_l:
if a > b:
print(b)
exit()
else:
print(a)
exit()
print(b)
while True:
a += 1
if b > 0:
b -= 1
if a in p_l and b in p_l:
continue
if not a in p_l:
if not b in p_l:
if a > b:
print(b)
# print("A")
exit()
else:
# print("B")
print(a)
exit()
# print("C")
print(a)
exit()
elif not b in p_l:
if not a in p_l:
if a > b:
print(b)
# print("D")
exit()
else:
print(a)
# print("E")
exit()
# print("F")
print(b)
exit() | 1 | 14,127,182,607,230 | null | 128 | 128 |
if __name__ == '__main__':
try:
s = str(input())
s.lower()
if s[len(s)-1] != 's':
s += 's'
print(s)
else:
s += 'es'
print(s)
except Exception:
pass | x = input().split()
a,b = int(x[0]),int(x[1])
print("%d %d" %(a*b,2*a+2*b))
| 0 | null | 1,360,816,029,662 | 71 | 36 |
print('1' if int(input()) == 0 else '0')
| s=input()
a=s[:len(s)//2+1//2]
b=s[len(s)//2+1:]
if s==s[::-1] and a==a[::-1] and b==b[::-1]:
print("Yes")
else:
print("No") | 0 | null | 24,589,221,494,862 | 76 | 190 |
# coding: utf-8
from math import sqrt
def isPrime(n):
if n == 2:
return True
elif n < 2 or n % 2 == 0:
return False
else:
i = 3
while i <= sqrt(n):
if n % i == 0:
return False
i += 2
return True
def main():
n = input()
print sum([1 if isPrime(x) else 0 for x in [input() for _ in xrange(n)]])
if __name__ == '__main__':
main() | t1, t2 = map(int, input().split())
a1, a2 = map(int, input().split())
b1, b2 = map(int, input().split())
c1 = t1*(a1-b1)
c2 = t2*(a2-b2)
d = c1 + c2
if d == 0:
print("infinity")
elif c1*c2 > 0 or c1*d > 0:
print(0)
else:
if abs(c1)%abs(d)==0:
print((abs(c1)//abs(d))*2)
else:
print((abs(c1)//abs(d))*2+1) | 0 | null | 65,485,180,134,712 | 12 | 269 |
n=int(input())
a=list(map(int,input().strip().split()))[:n]
counter=0
for i in range (0,n,2):
if(a[i]%2==1):
counter+=1
print(counter) | t,h=0,0
for _ in range(int(input())):
a,b=input().split()
if a>b:t+=3
if a<b:h+=3
if a==b:t+=1;h+=1
print(t,h) | 0 | null | 4,877,010,585,290 | 105 | 67 |
N = int(input())
if str(N)[-1] == str(3):
print('bon')
elif str(N)[-1] in list(map(str, [0, 1, 6, 8])):
print('pon')
else:
print('hon') | N= int(input())
N1=N%10
if N1 in (2,4,5,7,9):
print("hon")
elif N1 in (0,1,6,8):
print("pon")
else:
print("bon") | 1 | 19,282,456,829,580 | null | 142 | 142 |
# E - All-you-can-eat
n,t=map(int,input().split())
a,b=[],[]
for i in range(n):
aa,bb=map(int,input().split())
a.append(aa)
b.append(bb)
dp1=[[0]*t for _ in range(n+1)] # 前から
dp2=[[0]*t for _ in range(n+1)] # 後ろから
arev=a[::-1]
brev=b[::-1]
for i in range(1,n+1):
for j in range(t):
if j-a[i-1]>=0:
dp1[i][j]=max(dp1[i-1][j-a[i-1]]+b[i-1],dp1[i-1][j])
else:
dp1[i][j]=dp1[i-1][j]
for i in range(1,n+1):
for j in range(t):
if j-arev[i-1]>=0:
dp2[i][j]=max(dp2[i-1][j-arev[i-1]]+brev[i-1],dp2[i-1][j])
else:
dp2[i][j]=dp2[i-1][j]
ans=-1
for i in range(1,n+1):
for j in range(t):
ans=max(ans,dp1[i-1][j]+dp2[n-i][t-1-j]+b[i-1])
print(ans)
| import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N, T, *AB = map(int, read().split())
A = AB[::2]
B = AB[1::2]
dp1 = [[0] * T for _ in range(N + 1)]
for i in range(N):
for t in range(T):
if 0 <= t - A[i]:
dp1[i + 1][t] = dp1[i][t - A[i]] + B[i]
if dp1[i + 1][t] < dp1[i][t]:
dp1[i + 1][t] = dp1[i][t]
dp2 = [[0] * T for _ in range(N + 1)]
for i in range(N - 1, -1, -1):
for t in range(T):
if 0 <= t - A[i]:
dp2[i][t] = dp2[i + 1][t - A[i]] + B[i]
if dp2[i][t] < dp2[i + 1][t]:
dp2[i][t] = dp2[i + 1][t]
ans = 0
for i in range(N):
tmp = max(dp1[i][t] + dp2[i + 1][T - t - 1] for t in range(T)) + B[i]
if ans < tmp:
ans = tmp
print(ans)
return
if __name__ == '__main__':
main()
| 1 | 151,954,413,588,900 | null | 282 | 282 |
x = input()
if x == "1": print(0)
else: print(1)
| N = int(input())
A = list(map(int,input().split())) + [0]
kabu = 0
money = 1000
for p in range(N):
#株がない時
if A[p] < A[p+1]:
kabu += money//A[p]
money -= (money//A[p])*A[p]
#株があるとき
if A[p] > A[p+1]:
money += kabu*A[p]
kabu = 0
#print(str(p+1) + "日目" + str(money) + " " +str(kabu))
print(money) | 0 | null | 5,150,315,146,118 | 76 | 103 |
str1 = input()
str2 = input()
count = 0
for i in range(len(str1)):
if str1[i] != str2[i]:
count += 1
print(count) | N, K = map(int, input().split())
ans = min(N % K, K - N % K)
print(ans) | 0 | null | 24,822,044,319,160 | 116 | 180 |
from collections import deque
mod = int(1e9+7)
def add(a, b):
c = a + b
if c >= mod:
c -= mod
return c
def main():
n, m = map(int,raw_input().split())
adj_list = [[] for _ in range(n+5)]
q = deque()
ans = [-1] * (n+5)
failed = False
for _ in range(m):
a, b = map(int,raw_input().split())
adj_list[a].append(b)
adj_list[b].append(a)
q.append(1)
#print(adj_list)
visited = set()
visited.add(1)
while len(q):
sz = len(q)
for _ in range(sz):
cur = q.popleft()
for nei in adj_list[cur]:
if nei not in visited:
ans[nei] = cur
q.append(nei)
visited.add(nei)
print('Yes')
for i in range(2, n+1):
print(ans[i])
main() | from collections import deque
N, M = map(int, input().split())
G = [[] for _ in range(N+1)]
for _ in range(M):
a, b = map(int, input().split())
G[a].append(b)
G[b].append(a)
q = deque([1])
closed = [False] * (N+1)
closed[1] = True
Ans = [0] * (N+1)
while q:
v = q.popleft()
for u in G[v]:
if not closed[u]:
closed[u] = True
q.append(u)
Ans[u] = v
print("Yes")
print("\n".join(map(str, Ans[2:])))
| 1 | 20,442,386,752,512 | null | 145 | 145 |
a,b = map(int,input().split())
# 8% -> [a,a+1)
# 10% -> [b,b+1)
# max(a*100/8, b*10) <= 元の価格 < min((a+1)*100/8, (b+1)*10)
min8 = a*(100/8)
max8 = (a+1)*(100/8)
min10 = b*10
max10 = (b+1)*10
mi = int(max(min8, min10) - 0.001) + 1
ma = int(min(max8, max10) - 0.001)
if mi > ma:
ans = -1
else:
ans = mi
print(ans) | N, K = map(int, input().split())
heights = list(map(int, input().split()))
result = 0
for h in heights:
if h >= K:
result += 1
print(result) | 0 | null | 117,144,486,445,492 | 203 | 298 |
#AC
from collections import deque
n=int(input())
G=[[]]
for i in range(n):
G.append(list(map(int,input().split()))[2:])
#bfs(木でないかも)
L=[-1]*(n+1)
q=deque()
L[1]=0
q.append(1)
while q:
now=q.popleft()
L.append(now)
for next in G[now]:
#探索済み
if L[next]>=0:
continue
#探索予定(なくて良い)
#if next in q:
# continue
q.append(next)
L[next]=L[now]+1
for i in range(1,n+1):
print(i,L[i])
| from sys import stdin
from collections import deque
n = int(stdin.readline())
d = [-1] * (n + 1)
def bfs(G):
d[1] = 0
dq = deque([1])
while len(dq) > 0:
v = dq.popleft()
for c in G[v]:
if d[c] < 0:
d[c] = d[v] + 1
dq.append(c)
for i, x in enumerate(d[1:], start=1):
print(i, x)
G = [0]
for i in range(n):
G.append(list(map(int, stdin.readline().split()[2:])))
bfs(G) | 1 | 4,297,685,300 | null | 9 | 9 |
import pprint
N = int(input())
A = list(map(int, input().split()))
def student_sorting(N, A):
student_list = [0] * N
for initial_pos, activity in enumerate(A):
student_list[initial_pos] = (activity, initial_pos)
return sorted(student_list, reverse = True)
def DP(N, student_list):
DP_map = list(list(0 for row in range(N + 1 - column)) for column in range(N + 1))
ans_list = []
ans = 0
for left in range(N): #初期値設定 right = 0
activity = student_list[left][0]
distance_l = abs(left - student_list[left][1])
DP_map[left + 1][0] = DP_map[left][0] + activity * distance_l
for right in range(N): #初期値設定 left = 0
activity = student_list[right][0]
distance_r = abs((N - 1 - right) - student_list[right][1])
DP_map[0][right + 1] = DP_map[0][right] + activity * distance_r
for left in range(1, N + 1):
for right in range(1, N - left + 1):
activity = student_list[left + right - 1][0]
distance_l = abs((left - 1) - student_list[left + right - 1][1])
distance_r = abs((N - right) - student_list[left + right - 1][1])
score_if_appended_to_left = DP_map[left - 1][right] + activity * distance_l
score_if_appended_to_right = DP_map[left][right - 1] + activity * distance_r
DP_map[left][right] = max(score_if_appended_to_left, score_if_appended_to_right)
for left in range(N + 1):
row = N - left
column = left
ans_list.append(DP_map[column][row])
ans = max(ans_list)
return ans
student_list = student_sorting(N, A)
ans = DP(N, student_list)
print(ans)
| N=input()
dp0=[0]*(len(N)+1)
dp1=[0]*(len(N)+1)
dp1[0]=1
for i in range(len(N)):
n=int(N[i])
dp0[i+1]=min(dp0[i]+n, dp1[i]+(10-n))
n+=1
dp1[i+1]=min(dp0[i]+n, dp1[i]+(10-n))
#print(dp0)
#print(dp1)
print(dp0[-1])
| 0 | null | 52,643,419,033,084 | 171 | 219 |
from queue import Queue
def isSafe(row, col):
return row >= 0 and col >= 0 and row<h and col<w and mat[row][col] != '#'
def bfs(row, col):
visited = [[False]*w for _ in range(h)]
que = Queue()
dst = 0
que.put([row, col, 0])
visited[row][col] = True
moves = [[-1, 0],[1, 0], [0, -1], [0, 1]]
while not que.empty():
root = que.get()
row, col, dst = root
for nrow, ncol in moves:
row2 = row + nrow
col2 = col + ncol
if isSafe(row2, col2) is True and visited[row2][col2] is False:
visited[row2][col2] = True
que.put([row2, col2, dst+1])
return dst
h, w = map(int, input().split())
mat = [input() for _ in range(h)]
ans = 0
for row in range(h):
for col in range(w):
if mat[row][col] == '.':
ans = max(ans, bfs(row, col))
print(ans)
| import sys
from io import StringIO
import unittest
import os
from collections import deque
# 再帰処理上限(dfs作成時に設定するのが面倒なので限度近い値を組み込む)
sys.setrecursionlimit(999999999)
# 実装を行う関数
def resolve(test_def_name=""):
# 数値取得サンプル
# 1行1項目 n = int(input())
# 1行2項目 h, w = map(int, input().split())
# 1行N項目 x = list(map(int, input().split()))
# N行1項目 x = [int(input()) for i in range(n)]
# N行N項目 x = [list(map(int, input().split())) for i in range(n)]
# 文字取得サンプル
# 1行1項目 x = input()
# 1行1項目(1文字ずつリストに入れる場合) x = list(input())
h, w = map(int, input().split())
maze = [list(input()) for i in range(h)]
start_list = []
for i_len, i in enumerate(range(h)):
for j_len, j in enumerate(range(w)):
route = 4
# 自分が壁なら対象外
if maze[i][j] == "#":
continue
# 上下端なら-1
route -= 1 if i_len == 0 else 0
route -= 1 if i_len + 1 == h else 0
# 上下が壁なら-1
route -= 1 if not i_len == 0 and maze[i - 1][j] == "#" else 0
route -= 1 if not i_len + 1 == h and maze[i + 1][j] == "#" else 0
# 左右端なら-1
route -= 1 if j_len == 0 else 0
route -= 1 if j_len + 1 == w else 0
# 左右が壁なら-1
route -= 1 if not j_len == 0 and maze[i][j - 1] == "#" else 0
route -= 1 if not j_len + 1 == w and maze[i][j + 1] == "#" else 0
if route <= 2:
start_list.append((i, j))
ans = 0
que = deque()
for start in start_list:
que.appendleft(start)
ed_list = [[-1 for i in range(w)] for j in range(h)]
ed_list[start[0]][start[1]] = 0
# BFS開始
while len(que) is not 0:
now = que.pop()
# 各方向に移動
for i, j in [(1, 0), (0, 1), (0, -1), (-1, 0)]:
# 処理対象の座標
target = [now[0] + i, now[1] + j]
# 処理対象のチェック
# 外なら何もしない
if not 0 <= target[0] < h or not 0 <= target[1] < w:
continue
# 距離が設定されているなら何もしない
if ed_list[target[0]][target[1]] != -1:
continue
# 壁なら何もしない
if maze[target[0]][target[1]] == "#":
continue
# 処理対象に対する処理
# キューに追加(先頭に追加するのでappendleft())
que.appendleft(target)
# 距離を設定(現在の距離+1)
ed_list[target[0]][target[1]] = ed_list[now[0]][now[1]] + 1
ans = max(ans, ed_list[target[0]][target[1]])
print(ans)
# テストクラス
class TestClass(unittest.TestCase):
def assertIO(self, assert_input, output):
stdout, sat_in = sys.stdout, sys.stdin
sys.stdout, sys.stdin = StringIO(), StringIO(assert_input)
resolve(sys._getframe().f_back.f_code.co_name)
sys.stdout.seek(0)
out = sys.stdout.read()[:-1]
sys.stdout, sys.stdin = stdout, sat_in
self.assertEqual(out, output)
def test_input_1(self):
test_input = """3 3
...
...
..."""
output = """4"""
self.assertIO(test_input, output)
def test_input_2(self):
test_input = """3 5
...#.
.#.#.
.#..."""
output = """10"""
self.assertIO(test_input, output)
# 自作テストパターンのひな形(利用時は「tes_t」のアンダーバーを削除すること
def test_1original_1(self):
test_input = """1 2
.."""
output = """1"""
self.assertIO(test_input, output)
# 実装orテストの呼び出し
if __name__ == "__main__":
if os.environ.get("USERNAME") is None:
# AtCoder提出時の場合
resolve()
else:
# 自PCの場合
unittest.main()
| 1 | 94,683,673,464,048 | null | 241 | 241 |
N = int(input())
A = list(map(int,input().split()))
DP = [0,0,0]
m = N//2*2
if N%2 == 0:
for i in range(0,m,2):
DP[0] += A[i]
DP[1] += A[i+1]
DP[1] = max(DP[0],DP[1])
print(DP[1])
else:
for i in range(0,m,2):
DP[0] += A[i]
DP[1] += A[i+1]
DP[2] += A[i+2]
DP[1] = max(DP[0],DP[1])
DP[2] = max(DP[1],DP[2])
print(DP[2])
| # coding: utf-8
import sys
from collections import deque
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
def main():
# 左からgreedyに
N, D, A = lr()
monsters = []
for _ in range(N):
x, h = lr()
monsters.append((x, h))
monsters.sort()
bomb = deque()
answer = 0
attack = 0
for x, h in monsters:
while bomb:
if bomb[0][0] + D < x:
attack -= bomb[0][1]
bomb.popleft()
else:
break
h -= attack
if h > 0:
t = -(-h//A)
answer += t
bomb.append((x + D, A * t))
attack += A * t
print(answer)
if __name__ == '__main__':
main()
| 0 | null | 59,859,173,107,776 | 177 | 230 |
# #
# author : samars_diary #
# 13-09-2020 │ 11:26:57 #
# #
import sys, os.path
#if(os.path.exists('input.txt')):
#sys.stdin = open('input.txt',"r")
#sys.stdout = open('output.txt',"w")
sys.setrecursionlimit(10 ** 5)
def i(): return sys.stdin.readline().strip()
def ii(): return int(sys.stdin.readline())
def li(): return list(sys.stdin.readline().strip())
def mii(): return map(int, sys.stdin.readline().split())
def lii(): return list(map(int, sys.stdin.readline().strip().split()))
#print=sys.stdout.write
def solve():
d,t,s=mii()
if d/s<=t:
print('Yes')
else: print('No')
solve() | # import numpy as np
import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
D, T, S = map(int, input().split())
if D / S > T:
print("No")
else:
print("Yes")
| 1 | 3,552,577,680,892 | null | 81 | 81 |
x,y = map(int,input().split())
s = max(0,(4-x)*100000)+max(0,(4-y)*100000)
print(s if s!=600000 else s+400000) | import math
a, b, h, m = map(int, input().split())
x = 6 * m
y = 30 * h + 0.5 * m
C = max(x, y) - min(x, y)
C = min(C, 360 - C)
print(math.sqrt(a**2 + b**2 - 2*a*b*math.cos(math.radians(C))))
| 0 | null | 80,784,578,199,652 | 275 | 144 |
N = int(input())
A = [0]*(N)
for i in input().split():
A[int(i)-1] = A[int(i)-1]+1
for i in A:
print(i)
| #!/usr/bin/env python3
def main():
N = int(input())
A = [int(x) for x in input().split()]
lst = [0] * (N + 1)
for a in A:
lst[a] += 1
for i in lst[1:]:
print(i)
if __name__ == '__main__':
main()
| 1 | 32,627,370,829,428 | null | 169 | 169 |
import sys
import bisect
from functools import lru_cache
from collections import defaultdict
from collections import deque
inf = float('inf')
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10**6)
def input(): return sys.stdin.readline().rstrip()
def read():
return int(readline())
def reads():
return map(int, readline().split())
s=input()
n=len(s)
ten=[1]
mod=2019
for i in range(n-1):
ten.append((ten[i]*10)%mod)
modls=[0]*n
modls[n-1]=int(s[n-1])
dic=defaultdict(int)
dic[modls[n-1]]+=1
dic[0]=1
for i in range(n-2,-1,-1):
modls[i]=int(s[i])*ten[n-1-i]+modls[i+1]
modls[i]%=mod
dic[modls[i]]+=1
ans=0
#print(dic)
for num in dic.values():
ans+=num*(num-1)//2
#ans+=dic[0]
print(ans) | #!/usr/bin/env python3
import sys
from itertools import chain
def cut_count(A, m):
"""最長の長さ(切り上げ)がm以下になるような切断回数"""
total = 0
for a in A:
n = (a - 1) // m
total += n
return total
def solve(N: int, K: int, A: "List[int]"):
r = max(A)
l = 0
while l + 1 < r:
m = (r + l) // 2
if cut_count(A, m) <= K:
r = m # r は K回以下の切断回数で到達できる長さ
else:
l = m # l は K回より多いの切断回数で到達できる長さ
# print(l, r)
return r
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K, A = map(int, line.split())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
A = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, K, A)
print(answer)
if __name__ == "__main__":
main()
| 0 | null | 18,729,190,959,040 | 166 | 99 |
n = int(input())
print(len(set([input() for i in range(n)]))) | def GCD(a,b):
while (a % b) != 0:
a,b = b, a%b
return b
def LCM(a,b):
return a * b / GCD(a,b)
while True:
try:
a,b =map(int,raw_input().split())
print GCD(a,b),LCM(a,b)
except:
break | 0 | null | 15,194,337,385,118 | 165 | 5 |
class Dice():
def __init__(self, spots):
self.spots = [spots[i] for i in range(6)]
def roll(self, direction):
if direction == 0:
self.spots = [self.spots[i] for i in [1, 5, 2, 3, 0, 4]]
elif direction == 1:
self.spots = [self.spots[i] for i in [3, 1, 0, 5, 4, 2]]
elif direction == 2:
self.spots = [self.spots[i] for i in [4, 0, 2, 3, 5, 1]]
elif direction == 3:
self.spots = [self.spots[i] for i in [2, 1, 5, 0, 4, 3]]
spots = list(map(int, input().split()))
moves = input()
my_dice = Dice(spots=spots)
for move in moves:
if move == 'N':
my_dice.roll(0)
elif move == 'E':
my_dice.roll(1)
elif move == 'S':
my_dice.roll(2)
elif move == 'W':
my_dice.roll(3)
print(my_dice.spots[0])
| # -*- coding: utf-8 -*-
from sys import stdin
class Dice:
def __init__(self,dicelist):
self.dice_list = dicelist
def roll(self, direction):
work = list(self.dice_list)
if (direction == 'N'):
self.dice_list[0] = work[1]
self.dice_list[1] = work[5]
self.dice_list[2] = work[2]
self.dice_list[3] = work[3]
self.dice_list[4] = work[0]
self.dice_list[5] = work[4]
elif (direction == 'E'):
self.dice_list[0] = work[3]
self.dice_list[1] = work[1]
self.dice_list[2] = work[0]
self.dice_list[3] = work[5]
self.dice_list[4] = work[4]
self.dice_list[5] = work[2]
elif (direction == 'S'):
self.dice_list[0] = work[4]
self.dice_list[1] = work[0]
self.dice_list[2] = work[2]
self.dice_list[3] = work[3]
self.dice_list[4] = work[5]
self.dice_list[5] = work[1]
elif (direction == 'W'):
self.dice_list[0] = work[2]
self.dice_list[1] = work[1]
self.dice_list[2] = work[5]
self.dice_list[3] = work[0]
self.dice_list[4] = work[4]
self.dice_list[5] = work[3]
def getTop(self):
return self.dice_list[0]
dice_list = list(map(int, stdin.readline().rstrip().split()))
dice = Dice(dice_list)
rolls = stdin.readline().rstrip()
for roll in rolls:
dice.roll(roll)
else:
print(dice.getTop())
| 1 | 235,950,119,668 | null | 33 | 33 |
N,K = map(int,input().split())
import numpy as np
A = np.array(input().split(),np.int64)
B = np.array(input().split(),np.int64)
A.sort() ; B.sort()
B=B[::-1]
right = max(A*B) #時間の可能集合の端点
left = -1 #時間の不可能集合の端点
def test(t):
C = A-t//B
D= np.where(C<0,0,C)
return D.sum()<=K
while left+1<right:
mid = (left+right)//2
if test(mid):
right=mid
else:
left = mid
print(right) | n = int(input())
s = input()
freq = {'R': 0, 'G': 0, 'B': 0}
for x in s:
freq[x] += 1
ans = freq['R'] * freq['G'] * freq['B']
for i in range(n-2):
for j in range(i+1, n-1):
k = j + (j-i)
if k < n and s[i] != s[j] and s[i] != s[k] and s[j] != s[k]:
ans -= 1
print(ans)
| 0 | null | 100,322,646,695,412 | 290 | 175 |
a, b = map(int, input().split())
print(str(a*b)) | N = int(input())
C = list(input())
Rn = C.count('R')
print(C[:Rn].count('W')) | 0 | null | 11,116,479,484,210 | 133 | 98 |
import math
R = float(input())
print(float(2*R*math.pi)) | import math
R = int(input())
circum = R * 2 * math.pi
print(circum) | 1 | 31,475,642,125,480 | null | 167 | 167 |
# author: Taichicchi
# created: 15.09.2020 21:22:26
import sys
X, K, D = map(int, input().split())
X = abs(X)
if X >= K * D:
print(X - (K * D))
else:
k = K - X // D
x = X - D * (X // D)
if k % 2:
print(abs(x - D))
else:
print(x)
| X,K,D = map(int,input().split())
dist = abs(X)
rem = K
count = min(dist//D,K)
dist -= count*D
rem -= count
if rem % 2 == 1:
dist -= D
print(abs(dist))
| 1 | 5,240,771,709,810 | null | 92 | 92 |
from typing import Dict
def main():
n: int = int(input())
d: Dict[str, bool] = {}
for _ in range(n):
command = input().split()
if command[0] == "insert":
d[f"{command[1]}"] = True
else:
if command[1] in d:
print("yes")
else:
print("no")
if __name__ == "__main__":
main()
| from sys import stdin
def main():
a = set()
_ = int(stdin.readline())
for command,value in (line.split() for line in stdin.readlines()):
if command == "insert":
a.add(value)
else:
print("yes" if value in a else "no")
main()
| 1 | 78,619,352,630 | null | 23 | 23 |
N = int(input())
S,T=input().split()
retsu = ""
for i in range(0,N):
mozi = S[i]+T[i]
retsu += mozi
print(retsu) | n = int(input())
cou = 0
ans = False
for i in range(n):
da, db = map(int, input().split())
if da == db:
cou += 1
else:
cou = 0
if cou == 3:
ans = True
if ans:
print('Yes')
else:
print('No') | 0 | null | 57,248,706,713,588 | 255 | 72 |
def common_raccoon_vs_monster():
# 入力
H, N = map(int, input().split())
A = list(map(int, input().split()))
# 必殺技の合計攻撃力
sum_A = 0 # 必殺技の攻撃力の合計
for i in range(len(A)):
sum_A += A[i]
# 比較
if H > sum_A:
return 'No'
else:
return 'Yes'
result = common_raccoon_vs_monster()
print(result) | H, N = map(int, input().split())
A = map(int, input().split())
print("Yes" if H <= sum(A) else "No") | 1 | 78,213,312,326,422 | null | 226 | 226 |
import math
n=int(input())
ans=-1
for x in range(0,50000):
if n==math.floor(x*1.08):
ans=x
break
if ans==-1:
print(":(")
else:
print(ans) | n=int(input())
ans=':('
for i in range(1,n+1):
if int((i*1.08)//1)==n:
ans=i
break
print(ans)
| 1 | 125,763,091,487,108 | null | 265 | 265 |
N = int(input())
A = [int(i) for i in input().split(" ")]
Min = float("inf")
index = 0
L = 0
R = sum(A)
for i in range(0,len(A)):
L+=A[i]
R-=A[i]
diff = abs(L - R)
if diff < Min:
Min = diff
print(Min) | n = int(input())
a = list(map(int,input().split()))
a_cumsum = [0]*(n+1)
for i in range(n):
a_cumsum[i+1] = a_cumsum[i] + a[i]
ans = 10**18
for i in range(n):
ans = min(ans, abs(a_cumsum[-1] - a_cumsum[i]*2))
print(ans) | 1 | 141,489,540,265,010 | null | 276 | 276 |
import sys
read=sys.stdin.read
h,w,n=map(int, read().split())
m=max(h,w)
print(n//m+(n%m!=0)) | h = int(input())
w = int(input())
n = int(input())
lines = 0
act = 0
if h <= w:
# print('w long')
lines = h
act = w
else:
# print('h long')
lines = w
act = h
# print(lines)
# print(act)
draw = 0
for i in range(lines):
if n <= (i + 1) * act:
print(i + 1)
break | 1 | 89,013,806,252,560 | null | 236 | 236 |
n,d,a=[int(j) for j in input().split()]
xh=[[int(j) for j in input().split()] for i in range(n)]
xh.sort()
from collections import deque
q=deque()
ans=0
dmg=0
for x,h in xh:
while q and q[0][0]<x:
i,j=q.popleft()
dmg-=j
r=h-dmg
if r<=0:
continue
p=-(-r//a)
dmg+=p*a
ans+=p
q.append((x+2*d,p*a))
print(ans)
| s = input()
t = input()
counter = 0
for index, character in enumerate(s):
if t[index] != character:
counter += 1
print(counter) | 0 | null | 46,507,480,568,798 | 230 | 116 |
n,k=map(int, input().split())
w=[0]*n
for i in range(n):
w[i]=int(input())
def delivable(m):
loading=0
track_num=1
for i in range(n):
if w[i] > m:
return False
break
else:
loading += w[i]
if loading > m:
loading=w[i]
track_num += 1
if track_num <= k:
return True
else:
return False
r=1000000000
l=min(w)-1
while r-l > 1:
m=(r+l)//2
if delivable(m):
r=m
else:
l=m
print(r)
| n = int(input())
A = list(map(int,input().split()))
count = 0
for i in range(n):
minj = i
for j in range(i,n):
if A[j] < A[minj]:
minj = j
if minj != i:
count += 1
a = A[i]
A[i] = A[minj]
A[minj] = a
print(' '.join(map(str,A)))
print(count)
| 0 | null | 54,390,359,382 | 24 | 15 |
n=int(input())
a=list(map(int,input().split()))
l=[]
for i,x in enumerate(a):
l.append([x,i])
l.sort(reverse=True)
cnt=1
dp=[[0]*(n+1) for _ in range(n+1)]
for i,j in l:
for x in range(cnt+1):
if x==0:
dp[x][cnt-x]=dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j)
elif x==cnt:
dp[x][cnt-x]=dp[x-1][cnt-x]+i*(j-x+1)
else:
dp[x][cnt-x]=max(dp[x-1][cnt-x]+i*(j-x+1),dp[x][cnt-x-1]+i*(n-1-(cnt-x-1)-j))
cnt+=1
ans=0
for i in range(n+1):
ans=max(ans,dp[i][n-i])
print(ans) | # -*- coding: utf-8 -*-
import sys
N=int(sys.stdin.readline().strip())
A=map(int, sys.stdin.readline().split())
AA=[]
for i,val in enumerate(A):
AA.append((val,i+1))
AA.append((float("inf"),None)) #1-indexedにする
AA.sort(reverse=True)
dp=[ [ 0 for r in range(N+1) ] for l in range(N+1) ]
dp[0][0]=0
l=0
for l in range(N):
for r in range(N-l):
val,idx=AA[l+r+1][0],AA[l+r+1][1]
dp[l+1][r]=max( dp[l+1][r], dp[l][r]+abs(val*(idx-l-1)) )
dp[l][r+1]=max( dp[l][r+1], dp[l][r]+abs(val*(N-r-idx)) )
ans=float("-inf")
for l in dp:
ans=max(ans,max(l))
print ans | 1 | 33,726,133,745,050 | null | 171 | 171 |
S = input()
if S == "hi" * (len(S)//2):
print("Yes")
else:
print("No") | h = int(input())
w = int(input())
n = int(input())
if h >= w:
larger = h
else:
larger = w
if n % larger == 0:
print(n // larger)
else:
print(n // larger + 1) | 0 | null | 70,840,370,728,182 | 199 | 236 |
n=int(input())
for i in range(46298):
if int(i*1.08)==n:
print(i)
break
else:
print(":(") | def readinput():
n=int(input())
return n
def main(n):
x7=int(n/1.07)+1
x9=int(n/1.09)-1
n100=n*100
for x in range(max(1,x9),x7+1):
xx=x*108//100
#print(x,xx)
if xx==n:
print(x)
break
else:
print(':(')
if __name__=='__main__':
n=readinput()
main(n)
| 1 | 125,392,355,143,550 | null | 265 | 265 |
#!/usr/bin/env python3
# Generated by https://github.com/kyuridenamida/atcoder-tools
from typing import *
import collections
import functools
import itertools
import math
import sys
INF = float('inf')
def solve(A: int, B: int):
for i in range(1000 + 1):
if int(i * 0.08) == A and int(i * 0.1) == B:
return i
return -1
def main():
sys.setrecursionlimit(10 ** 6)
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
print(f'{solve(A, B)}')
if __name__ == '__main__':
main()
| #57
import decimal
a,b = map(int,input().split())
for i in range(1,10001):
num1 = int(i*decimal.Decimal("0.08"))
num2 = int(i*decimal.Decimal("0.1"))
if num1 == a and num2 == b:
print(i)
break
if int(i*decimal.Decimal("0.08")) > a:
print("-1")
break | 1 | 56,494,909,778,660 | null | 203 | 203 |
N = input()
if N.endswith('2') == True or N.endswith('4') == True or N.endswith('5') == True or N.endswith('7') == True or N.endswith('9') == True:
print('hon')
elif N.endswith('0') == True or N.endswith('1') == True or N.endswith('6') == True or N.endswith('8') == True:
print('pon')
else:
print('bon') | H, N = map(int, input().split())
A_list = []
for i in range(1, N+1):
A_list.append("A_" + str(i))
A_list = map(int, input().split())
A_total = sum(A_list)
if A_total >= H:
print("Yes")
else:
print("No") | 0 | null | 48,606,988,528,560 | 142 | 226 |
X=int(input())
ans=1000*(X//500)+5*((X-(X//500*500))//5)
print(ans) | x = int(input())
q, r = divmod(x, 500)
ans = q*1000
ans += (r//5)*5
print(ans)
| 1 | 42,699,237,981,710 | null | 185 | 185 |
N = int(input())
A = list(map(int,input().split()))
ans = 0
l = [0]*N
u = [0]*N
for i in range(N):
b = i - A[i]
c = i + A[i]
if 0 < b < N:
l[b] += 1
if 0 < c < N:
u[c] += 1
for i in range(N):
ans += l[i]*u[i]
print(ans) | def main():
N=int(input())
A=list(map(int,input().split()))
L={}
R={}
for i in range(N):
l=(i+1)+A[i]
r=(i+1)-A[i]
if (l in L.keys()):
L[l]+=1
else:
L[l]=1
if r in R.keys():
R[r]+=1
else:
R[r]=1
res=0
for key in L.keys():
if key in R.keys():
res+=R[key]*L[key]
print(res)
if __name__=="__main__":
main()
| 1 | 26,062,037,191,128 | null | 157 | 157 |
# UnionFind: https://note.nkmk.me/python-union-find/
class UnionFind():
def __init__(self, n):
self.n = n
self.root = [-1] * (n + 1)
def find(self, x):
if self.root[x] < 0:
return x
else:
self.root[x] = self.find(self.root[x])
return self.root[x]
def unite(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return False
if self.root[x] > self.root[y]:
x, y = y, x
self.root[x] += self.root[y]
self.root[y] = x
def is_same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.root[self.find(x)]
n, m = map(int, input().split())
friends = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
friends.unite(a, b)
print(max(friends.size(i) for i in range(n))) | n, k = map(int, input().split())
MOD = 1000000007
ans = 0
c = {}
for i in range(k, 0, -1):
t = pow(k // i, n, MOD)
m = 2
while i * m <= k:
t -= c[i * m]
m += 1
c[i] = t % MOD
print(sum([k * v for k, v in c.items()]) % MOD)
| 0 | null | 20,481,421,025,182 | 84 | 176 |
N = int(input().rstrip())
r = (N + 1) / 2
print(int(r))
| N = int(input())
print(max(N//2, (N+1)//2)) | 1 | 59,230,970,354,766 | null | 206 | 206 |
import sys,math,collections,itertools,heapq
input = sys.stdin.readline
def f(n):
return -1*int(n)
x,y,a,b,c=list(map(int,input().split()))
p=sorted(list(map(int,input().split())),reverse=1)[:x]
q=sorted(list(map(int,input().split())),reverse=1)[:y]
r=list(map(f,input().split()))
p = collections.deque(p)
q = collections.deque(q)
heapq.heapify(r)
tmp = -1*heapq.heappop(r)
while tmp > p[-1]:
p.appendleft(tmp)
tmp = p.pop()
tmp = -1* heapq.heappushpop(r,-1*tmp)
while tmp > q[-1]:
q.appendleft(tmp)
tmp = q.pop()
tmp = -1 * heapq.heappushpop(r,-1*tmp)
print(sum(p)+sum(q))
| n, m = map(int, input().split())
from collections import deque
l = deque([i for i in range(1, n + 1)])
if n % 2 ==0:
for i in range(1, m + 1):
a, b = l.popleft(), l.pop()
if (b - a) == n / 2 or (len(l) < n // 2 and (b-a) % 2 == 1):
b = l.pop()
print(a, b)
else:
for i in range(1, m + 1):
print(i, n - i) | 0 | null | 36,894,998,817,312 | 188 | 162 |
n=int(input())
s=input()
r=s.count('R')
g=s.count('G')
b=s.count('B')
cnt=0
for i in range(n-1):
for j in range(1, min(i+1, n-i)):
if (s[i] != s[i-j]) and (s[i] != s[i+j]) and (s[i-j] != s[i+j]):
cnt += 1
print(r*g*b-cnt) | K = int(input())
A, B = [int(i) for i in input().split(' ')]
for i in range(A, B+1):
if i % K == 0:
print('OK')
exit()
print('NG')
| 0 | null | 31,346,617,910,332 | 175 | 158 |
n = int(input())
l = [list(map(int, input().split())) for i in range(n)]
#print(l[0][0])
#print(l[0][1])
ans = n-2
ans1 = 0
for m in range(ans):
if l[m][0] == l[m][1] and l[m+1][0] == l[m+1][1] and l[m+2][0] == l[m+2][1]:
ans1 += 1
if ans1 >= 1:
print("Yes")
else:
print("No") | N, M = map(int, input().split())
ans = []
n = M // 2
m = 2 * n + 1
l = 2 * M + 1
for i in range(n):
ans.append([i + 1, m - i])
for i in range(M - n):
ans.append([m + i + 1, l - i])
for v in ans:
print(*v)
| 0 | null | 15,652,663,979,900 | 72 | 162 |
print(0--int(input())//2) | n= int(input())
ans=(n+1)//2
print(ans) | 1 | 58,661,340,245,398 | null | 206 | 206 |
from collections import Counter, defaultdict, deque
import bisect
from sys import stdin, stdout
from itertools import repeat
import math
import random
# sys.stdin = open('input')
def inp():
re = map(int, raw_input().split())
if len(re) == 1:
return re[0]
return re
def inst():
return raw_input().strip()
def gcd(x, y):
while(y):
x, y = y, x % y
return x
def my_main():
n, k, c = inp()
st = inst()
front, end = [], []
def get(now, ans):
while now < n:
if len(ans) == k:
return
for i in range(now, n):
if st[i]=='o':
ans.append(i+1)
now = i+c+1
break
else:
break
get(0, front)
st = st[::-1]
get(0, end)
for i in range(len(end)):
end[i] = n-end[i]+1
end.sort()
if len(front)!=k or len(end)!=k:
return
ans = []
# print front, end
for i in range(k):
if front[i] == end[i]:
ans.append(front[i])
if ans:
print '\n'.join(map(str, ans))
my_main()
| n = input()
n2 = n * 2
x = input()
if x in n2:
print('Yes')
else: print('No')
| 0 | null | 21,192,972,890,892 | 182 | 64 |
import sys, math
from pprint import pprint
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mod = 10**9 + 7
A = rl()
if sum(A) >= 22:
print('bust')
else:
print('win')
| import math
a, b, x = map(int, input().split())
if a*a*b == x:
print(0)
elif a*a*b <= 2*x:
print(90-math.degrees(math.atan(a*a*a/(2*a*a*b-2*x))))
else:
print(90-math.degrees(math.atan(2*x/(a*b*b))))
| 0 | null | 140,654,413,792,828 | 260 | 289 |
n, t = map(int, input().split())
dp = [0] * (t + 1)
ab = [tuple(map(int, input().split())) for _ in range(n)]
ab.sort()
max_b = [0] * n
max_b[-1] = ab[-1][1]
for i in range(n - 1, 0, -1):
max_b[i - 1] = max(ab[i - 1][1], max_b[i])
for i in range(n - 1):
a, b = ab[i]
for j in range(t - 1, a-1, -1):
dp[j] = max(dp[j - a] + b, dp[j])
dp[t] = max(dp[t], dp[t-1] + max_b[i + 1])
print(max(dp))
| def ints():
return [int(x) for x in input().split()]
def ii():
return int(input())
N, T = ints()
dp = [[0]*T for j in range(N+1)]
F = sorted([ints() for i in range(N)])
for i in range(N):
a, b = F[i]
for t in range(T):
dp[i+1][t] = max(dp[i+1][t], dp[i][t])
nt = t+a
if nt<T:
dp[i+1][nt] = max(dp[i+1][nt], dp[i][t]+b)
w = max([F[i][1] + dp[i][T-1] for i in range(1, N)])
print(w)
| 1 | 151,825,559,678,688 | null | 282 | 282 |
[r,c] = raw_input().split()
r = int(r)
c = int(c)
M = []
V = []
for y in range(0,r):
s = raw_input().split()
k = []
for x in range(0,c):
v = int(s[x])
k.append(v)
M.append(k)
for y in range(0,c):
s = int(raw_input())
V.append(s)
for y in range(0,r):
ss = 0
for x in range(0,c):
ss = ss + M[y][x] * V[x]
print ss | def resolve():
n = int(input())
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
divisors = make_divisors(n)
min_pair = 10**19
for i in divisors:
pair_i = n//i
min_pair = min(min_pair, ((i-1)+(pair_i-1)))
print(min_pair)
resolve() | 0 | null | 81,409,618,094,240 | 56 | 288 |
h,w,k = map(int, input().split())
s = [[int(c) for c in input()] for i in range(h)]
ans = 114514893
for bit in range(1 << (h-1)):
cut = [-1]
for i in range(h-1):
if bit & (1 << i) : cut.append(i)
cut.append(h-1)
l = len(cut)-1
count = l-1
suml = [0 for i in range(l)]
ok = True
for i in range(w):
sumtemp = [0 for ii in range(l)]
flag2 = True #kを超えないかどうか
for j in range(l):
for kk in range(cut[j]+1,cut[j+1]+1):
sumtemp[j] = sumtemp[j] + s[kk][i]
if sumtemp[j] > k:
ok = False
break
if not ok : break
for j in range(l):
if suml[j]+sumtemp[j] > k:flag2 = False
if flag2:
for j in range(l):
suml[j] = suml[j]+sumtemp[j]
else:
count += 1
suml = sumtemp[:]
if not ok:continue
ans = min(ans,count)
print(ans) | import sys
def input(): return sys.stdin.readline().rstrip()
def main():
H, W, K = map(int, input().split())
S = [tuple(map(int, list(input()))) for _ in range(H)]
ans = 10 ** 9
for bit in range(1 << (H-1)):
canSolve = True
order = [0] * (H + 1)
tmp_ans = 0
for i in range(H):
if bit & 1 << i:
order[i+1] = order[i] + 1
tmp_ans += 1
else:
order[i+1] = order[i]
sum_block = [0] * (H + 1)
for w in range(W):
one_block = [0] * (H + 1)
overK = False
for h in range(H):
h_index = order[h]
one_block[h_index] += S[h][w]
sum_block[h_index] += S[h][w]
if one_block[h_index] > K:
canSolve = False
if sum_block[h_index] > K:
overK = True
if not canSolve:
break
if overK:
tmp_ans += 1
sum_block = one_block
if tmp_ans >= ans:
canSolve = False
break
if canSolve:
ans = tmp_ans
print(ans)
if __name__ == '__main__':
main()
| 1 | 48,669,722,959,524 | null | 193 | 193 |
s = list(input())
s = list(set(s))
print('Yes') if len(s) >1 else print('No') | s = input()
if s.count('B') == 3 or s.count("A") == 3:
print("No")
else:
print("Yes")
| 1 | 54,732,635,529,180 | null | 201 | 201 |
n, q = map(int, input().split())
p = [input().split() for _ in range(n)]
t = i = 0
while n:
i = i % n
if int(p[i][1]) <= q:
t += int(p[i][1])
print(p[i][0], t)
del p[i]
n -= 1
else:
p[i][1] = int(p[i][1]) - q
t += q
i += 1 | import math
def koch(n, a, b):
if n == 0: return
s, t, u = [0, 0], [0, 0], [0, 0];
th = math.pi * 60.0 / 180.0;
s[0] = (2.0 * a[0] + 1.0 * b[0]) / 3.0
s[1] = (2.0 * a[1] + 1.0 * b[1]) / 3.0
t[0] = (1.0 * a[0] + 2.0 * b[0]) / 3.0
t[1] = (1.0 * a[1] + 2.0 * b[1]) / 3.0
u[0] = (t[0] - s[0]) * math.cos(th) - (t[1] - s[1]) * math.sin(th) + s[0]
u[1] = (t[0] - s[0]) * math.sin(th) + (t[1] - s[1]) * math.cos(th) + s[1]
koch(n - 1, a, s)
print "%.8f %.8f" % (s[0], s[1])
koch(n - 1, s, u);
print "%.8f %.8f" % (u[0], u[1])
koch(n - 1, u, t)
print "%.8f %.8f" % (t[0], t[1])
koch(n - 1, t, b);
def main():
a, b = [0, 0], [0, 0]
n = int(raw_input())
a[0], a[1] = 0, 0
b[0], b[1] = 100, 0;
print "%.8f %.8f" % (a[0], a[1])
koch(n, a, b);
print "%.8f %.8f" % (b[0], b[1])
main() | 0 | null | 83,531,056,050 | 19 | 27 |
import sys
input = sys.stdin.readline
def main():
n, k = map(int, input().split())
products = [int(input()) for _ in range(n)]
left = 1
right = 10000 * 100000 # 最大重量 × 最大貨物数
while left < right:
mid = (left + right) // 2
# print("left:{}".format(left))
# print("right:{}".format(right))
# print("mid:{}".format(mid))
v = allocate(mid, k, products)
# print("count:{}".format(v))
if n <= v:
right = mid
else:
left = mid + 1
print(right)
def allocate(capacity, truckNum, products):
# print("===== start allocation capacity:{}======".format(capacity))
v = 0
tmp = 0
truckNum -= 1
while len(products) > v:
product = products[v]
# print("tmp weight:{}".format(tmp))
# print("product weight:{}".format(product))
if product > capacity:
# print("capacity over")
# そもそも１個も乗らない時避け
return 0
if tmp + product <= capacity:
# 同じトラックに積み続ける
tmp += product
else:
# 新しいトラックがまだあればつむ
if truckNum > 0:
# print("new truck")
truckNum -= 1
tmp = product
else:
return v
v += 1
return v
if __name__ == '__main__':
main()
| def main():
def check(p):
# 積めた荷物の数
i = 0
# トラックの数だけ試行
for _ in range(k):
# 現在のトラックの重量
s = 0
while s + w[i] <= p:
# 積める場合は積んで次の荷物へ
# 積めない場合は次のトラックへ
s += w[i]
i += 1
if i == n:
return n
return i
def solve():
left, right = 0, 100000 * 10000 + 1
while left < right:
mid = (left + right) // 2
if n <= check(mid):
right = mid
else:
left = mid + 1
return left
n, k = [int(i) for i in input().split()]
w = [int(input()) for _ in range(n)]
ans = solve()
print(ans)
if __name__ == '__main__':
main()
| 1 | 85,686,689,092 | null | 24 | 24 |
def main():
N, M = map(int, input().split())
if N & 1:
gen = ((i+1, N-i) for i in range(M))
else:
gen = ((i+1, N-i) if 2*i < N/2-1 else (i+1, N-i-1) for i in range(M))
[print(*s) for s in gen]
if __name__ == "__main__":
main()
| N, M = map(int, input().split())
cnt = 0
l = 0
k = M
while cnt < M and k > 0:
print(l + 1, l + k + 1)
cnt += 1
l += 1
k -= 2
l = M + 1
k = M - 1
while cnt < M:
print(l + 1, l + k + 1)
cnt += 1
l += 1
k -= 2
| 1 | 28,751,180,033,820 | null | 162 | 162 |
import sys
stdin = sys.stdin
def ns(): return stdin.readline().rstrip()
def ni(): return int(stdin.readline().rstrip())
def nm(): return map(int, stdin.readline().split())
def nl(): return list(map(int, stdin.readline().split()))
def main():
n = ni()
A = nl()
mod = 10 ** 9 + 7
s = sum(A)
q = sum([a ** 2 for a in A])
ans = (((s * s) - q)) // 2
print(int(ans % mod))
if __name__ == '__main__':
main()
| N, M = map(int, input().split())
A = list(map(int, input().split()))
def answer(N: int, M: int, A: list) -> int:
homework_days = 0
for i in range(0, M):
homework_days += int(A[i])
i += 1
if homework_days <= N:
return N - homework_days
else:
return -1
print(answer(N, M, A)) | 0 | null | 17,988,060,678,760 | 83 | 168 |
y=x=int(input())
while y%360:y+=x
print(y//x) | S = int(input())
a = (S // 2) + (S % 2)
print(int(a)) | 0 | null | 36,238,018,956,478 | 125 | 206 |
import sys
sys.setrecursionlimit(10 ** 6)
# input = sys.stdin.readline ####
int1 = lambda x: 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)]
INF = float('inf')
def solve():
n = II()
print((n + 1) // 2)
if __name__ == '__main__':
solve() | page = int(input())
print(-(-page // 2)) | 1 | 59,222,371,601,250 | null | 206 | 206 |
# -*-coding:utf-8-*-
def get_input():
while True:
try:
yield "".join(input())
except EOFError:
break
if __name__=="__main__":
array = list(get_input())
for i in range(len(array)):
temp = array[i].split()
a = int(temp[0])
b = int(temp[1])
ans = a + b
print(len(str(ans))) | import sys
[print(len(str(sum([int(y) for y in x.split(" ")])))) for x in sys.stdin] | 1 | 70,603,666 | null | 3 | 3 |
import itertools
import math
N = int(input())
XY = [list(map(int, input().split())) for i in range(N)]
n = [i for i in range(N)]
dist = 0
cnt = 0
for target_list in list(itertools.permutations(n)):
for i in range(len(target_list)):
if i == 0:
continue
dist += math.sqrt((XY[target_list[i]][0] - XY[target_list[i-1]][0]) ** 2 + (XY[target_list[i]][1] - XY[target_list[i-1]][1]) ** 2)
cnt += 1
print(dist / cnt) | def abc145c_average_length():
import itertools
import math
n = int(input())
x = []
y = []
for _ in range(n):
a, b = map(int, input().split())
x.append(a)
y.append(b)
result = 0
cnt = 0
for p in itertools.permutations(range(n)):
total = 0
for i in range(n-1):
total += math.sqrt(pow(x[p[i]]-x[p[i+1]], 2)+pow(y[p[i]]-y[p[i+1]], 2))
result += total
cnt += 1
print(result/cnt)
abc145c_average_length() | 1 | 148,541,494,073,922 | null | 280 | 280 |
import sys
input = sys.stdin.readline
from itertools import accumulate
n = int(input())
A = list(map(int, input().split()))
if n == 0:
if A[0] == 1:
print(1)
else:
print(-1)
exit()
C = list(accumulate(A[::-1]))[::-1] + [0]
B = [-1]*(n+1)
B[0] = 1 - A[0]
for i in range(1, n+1):
B[i] = min(C[i+1], 2*B[i-1]-A[i])
if B[i] < 0 or B[i] < B[i-1] - A[i]:
print(-1)
exit()
ans = sum(A) + sum(B)
print(ans) | N = int(input())
A_list = list(map(int, input().split()))
if A_list[0] > 1:
print(-1)
exit()
elif A_list[0] == 1:
if N == 0:
print(1)
else:
print(-1)
exit()
sumA = sum(A_list)
node = 1
count = 1
for i in range(len(A_list) - 1):
temp = min([node * 2, sumA])
count += temp
node = temp - A_list[i + 1]
if node < 0:
print(-1)
exit()
sumA -= A_list[i + 1]
print(count) | 1 | 18,729,228,420,828 | null | 141 | 141 |
# import numpy as np
import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
H, W, M = map(int, input().split())
hw = [list(map(int, input().split())) for _ in range(M)]
hb = defaultdict(int)
wb = defaultdict(int)
bomb = defaultdict(int)
for hwi in hw:
h, w = hwi
hb[h] += 1
wb[w] += 1
bomb[(h, w)] += 1
# print(hb, wb)
mhb = max(hb.values())
mwb = max(wb.values())
maxh = [key for key, val in hb.items() if val == mhb]
maxw = [key for key, val in wb.items() if val == mwb]
# print(maxh, maxw)
for h in maxh:
for w in maxw:
if bomb[(h, w)] == 0:
print(mhb + mwb)
exit()
print(mhb + mwb - 1)
| ac = input()
acc ='abcdefghijklmnopqrstuvwxyz'
print(acc[acc.index(ac) + 1]) | 0 | null | 48,429,299,296,928 | 89 | 239 |
x,y=map(int,input().split())
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
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 )
if (-x+2*y)%3!=0:
ans=0
else:
a=(-x+2*y)//3
b=(2*x-y)//3
ans=cmb(a+b,a,mod)
print(ans) | k = input().split()
num = len(k)
for i in range(num):
if k[i] == "0":
print(i+1) | 0 | null | 81,957,244,258,122 | 281 | 126 |
import math
x1, y1, x2, y2 = list(map(float, input().split()))
x = x2 - x1
y = y2 - y1
ans = math.sqrt(pow(x, 2) + pow(y, 2))
print(ans)
| # -*- coding: utf-8 -*-
# ITP1_10_A
import math
pos = list(map(float, input().split()))
x = abs(pos[2] - pos[0])
y = abs(pos[3] - pos[1])
print(math.sqrt(x**2 + y**2))
| 1 | 161,086,130,448 | null | 29 | 29 |
s = input()
n = len(s)
mod = 2019
t = [0]*n
dp = [0]*2020
t[0] = int(s[-1])
dp[t[0]] += 1
for i in range(n-1):
t[i+1] = t[i] + int(s[-2-i])*pow(10, i+1, mod)
t[i+1] %= mod
dp[t[i+1]] += 1
ans = 0
for D in dp[1:]:
ans += D*(D-1)//2
print(ans+(dp[0]+1)*(dp[0])//2)
| def main():
s = input()
mod = 2019
mod_count = {i: 0 for i in range(mod)}
now_num = 0
base = 1
for i in range(len(s) - 1, -1, -1):
mod_count[now_num] += 1
now_num += base * int(s[i])
now_num %= mod
base *= 10
base %= mod
ans = 0
mod_count[now_num % mod] += 1
for i in range(mod):
ans += mod_count[i] * (mod_count[i] - 1) // 2
print(ans)
if __name__ == '__main__':
main()
| 1 | 30,874,638,393,292 | null | 166 | 166 |
#import sys
#input = sys.stdin.readline
import math
from collections import defaultdict,deque
ml=lambda:map(int,input().split())
ll=lambda:list(map(int,input().split()))
ii=lambda:int(input())
ip=lambda:list(input())
ips=lambda:input().split()
"""========main code==============="""
t=1
for _ in range(t):
l,r,d=ml()
ans=0
for i in range(l,r+1):
if(i%d==0):
ans+=1
print(ans) | l,R, d = map(int, input().split())
a =0
for i in range(l,R+1):
if i % d == 0:
a = a+1
print(a)
| 1 | 7,631,600,500,822 | null | 104 | 104 |
from bisect import bisect_left
N=int(input())
A=sorted(list(map(int,input().split())))
cnt=0
for i in range(N-1):
for j in range(i+1,N):
a=bisect_left(A,A[i]+A[j])
if j<a:
cnt+=a-j-1
print(cnt) | import bisect,collections,copy,heapq,itertools,math,string
import numpy as np
import sys
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
L = LI()
# L = np.array(_L)
#C = np.zeros(N + 1)
# def test(a,b,c):
# if a<b+c and b<c+a and c<a+b:
# return True
# return False
# count = 0
# for pair in itertools.combinations(L, 3):
# # print(pair)
# if test(*pair):
# count += 1
# print(count)
# for i in range(N):
# for j in range(i+1,N):
from numba import njit
@njit
def f(A):
count = 0
for i in range(N):
for j in range(i + 1, N):
for k in range(j + 1, N):
count += (A[k] < A[i] + A[j])
return count
A = np.array(L)
A.sort()
print(f(A))
| 1 | 171,883,035,660,480 | null | 294 | 294 |
#!/usr/bin/env python3
s = input()
n = len(s)
t = s[:(n - 1) // 2]
u = s[(n + 1) // 2:]
print("YNeos"[any([s != s[::-1], t != t[::-1], u != u[::-1]])::2])
| def isKaibun(ss):
return ss==ss[::-1]
s = input()
ans=True
n=len(s)
if not isKaibun(s):
ans=False
if not isKaibun(s[:((n-1)//2)]):
ans=False
if ans:
print("Yes")
else:
print("No")
| 1 | 45,979,781,203,952 | null | 190 | 190 |
n = int(input())
d = {}
for i in range(n):
order = input().split()
if order[0] == 'insert':
d[order[1]] = i
else:
if order[1] in d:
print("yes")
else:
print("no") | import math
a, b, x = map(int, input().split())
if a*a*b >= 2*x:
print(math.degrees(math.atan2(a*b*b,2*x)))
else:
print(math.degrees(math.atan2(2*(a*a*b-x),a**3))) | 0 | null | 81,464,455,068,288 | 23 | 289 |
import sys
from collections import deque
from bisect import bisect_left, bisect_right, insort_left, insort_right #func(リスト,値)
from heapq import heapify, heappop, heappush
sys.setrecursionlimit(10**6)
INF = 10**20
def mint():
return map(int,input().split())
def lint():
return map(int,input().split())
def judge(x, l=['Yes', 'No']):
print(l[0] if x else l[1])
S = input()
N = len(S)+1
L = [0]*N
R = [0]*N
for i in range(N-1):
L[i+1] = L[i]+1 if S[i]=='<' else 0
for i in range(N-2,-1,-1):
R[i] = R[i+1]+1 if S[i]=='>' else 0
ans = [max(l,r) for l,r in zip(L,R)]
print(sum(ans)) | from math import factorial as fac
x,y=map(int,input().split())
a=(2*y-x)/3
b=(2*x-y)/3
mod=10**9+7
if a>=0 and b>=0 and a==int(a) and b==int(b):
a=int(a)
b=int(b)
a1=1
a2=1
n3=10**9+7
for i in range(a):
a1*=a+b-i
a2*=i+1
a1%=n3
a2%=n3
a2=pow(a2,n3-2,n3)
print((a1*a2)%n3)
else:
print(0) | 0 | null | 152,740,984,511,300 | 285 | 281 |
n, x, m = map(int, input().split())
amr = []
for i in range(n):
if i == 0:
x %= m
amr.append(x)
continue
x = pow(x, 2, m)
if x in amr:
break
if x == 0:
break
amr.append(x)
if x == 0:
print(sum(amr[:n]))
else:
idx = amr.index(x)
loop = sum(amr[idx:])
l = len(amr[idx:])
if n >= idx:
cnt = (n-idx)//l
print(cnt*loop + sum(amr[:idx]) + sum(amr[idx:idx+n-idx-cnt*l:]))
else:
print(sum(amr[:n]))
| def resolve():
N, X, M = map(int,input().split())
A_list = [X]
preA = X
A_set = set(A_list)
for i in range(N-1):
A = preA**2%M
if A == 0:
answer = sum(A_list)
break
elif A in A_set:
finished_count = len(A_list)
# 何番目か確認
same_A_index = A_list.index(A)
one_loop = A_list[same_A_index:]
loop_count, part_loop = divmod(N-finished_count, len(one_loop))
answer = sum(A_list) + sum(one_loop)*loop_count + sum(one_loop[:part_loop])
break
A_list.append(A)
A_set.add(A)
preA = A
else:
answer = sum(A_list)
print(answer)
resolve() | 1 | 2,795,657,659,260 | null | 75 | 75 |
from collections import deque
n, q = map(int, input().split())
Q = deque()
for i in range(n):
name,time = input().split()
Q.append([name, int(time)])
sum =0
while Q:
qt = Q.popleft()
if qt[1] <= q:
sum += qt[1]
print(qt[0], sum)
else:
sum += q
qt[1] -= q
Q.append(qt) | import time as ti
class MyQueue(object):
"""
My Queue class
Attributes:
queue: queue
head
tail
"""
def __init__(self):
"""Constructor
"""
self.length = 50010
self.queue = [0] * self.length
# counter = 0
# while counter < self.length:
# self.queue.append(Process())
# counter += 1
self.head = 0
self.tail = 0
# def enqueue(self, name, time):
def enqueue(self, process):
"""enqueue method
Args:
name: enqueued process name
time: enqueued process time
Returns:
None
"""
self.queue[self.tail] = process
# self.queue[self.tail].name = name
# self.queue[self.tail].time = time
self.tail = (self.tail + 1) % self.length
def dequeue(self):
"""dequeue method
Returns:
None
"""
# self.queue[self.head].name = ""
# self.queue[self.head].time = 0
self.queue[self.head] = 0
self.head = (self.head + 1) % self.length
def is_empty(self):
"""check queue is empty or not
Returns:
Bool
"""
if self.head == self.tail:
return True
else:
return False
def is_full(self):
"""chech whether queue is full or not"""
if self.tail - self.head >= len(self.queue):
return True
else:
return False
class Process(object):
"""process class
"""
def __init__(self, name="", time=0):
"""constructor
Args:
name: name
time: time
"""
self.name = name
self.time = time
def forward_time(self, time):
"""time forward method
Args:
time: forward time interval
Returns:
remain time
"""
self.time -= time
return self.time
def time_forward(my_queue, interval, current_time,):
"""
Args:
my_queue: queue
interval: time step interval
current_time: current time
"""
value = my_queue.queue[my_queue.head].forward_time(interval)
if value <= 0:
current_time += (interval + value)
print my_queue.queue[my_queue.head].name, current_time
my_queue.dequeue()
elif value > 0:
current_time += interval
# name, time = my_queue.queue[my_queue.head].name, \
# my_queue.queue[my_queue.head].time
my_queue.enqueue(my_queue.queue[my_queue.head])
my_queue.dequeue()
return current_time
my_queue = MyQueue()
n, q = [int(x) for x in raw_input().split()]
counter = 0
while counter < n:
name, time = raw_input().split()
my_queue.enqueue(Process(name, int(time)))
counter += 1
# end_time_list = []
current_time = 0
while not my_queue.is_empty():
current_time = time_forward(my_queue, q, current_time) | 1 | 43,552,489,030 | null | 19 | 19 |
a = int(input())
if a == 1:
print("0")
else:
print("1") | n = int(input())
if n == 0:
print(1)
if n == 1:
print(0) | 1 | 2,977,546,065,980 | null | 76 | 76 |
N = int(input())
a = list(map(int,input().split()))
loc = round(sum(a) / N)
print(sum(map(lambda x: (x - loc) ** 2,a))) | import sys
N, M = map(int, input().split())
S = input()
tmp = 0
for i in range(N+1):
if S[i] == '1':
tmp += 1
if tmp == M:
print(-1)
sys.exit()
else:
tmp = 0
ans = []
i = N
while i > M:
ind = S[i-M:i].find('0')
ans.append(M-ind)
i -= M - ind
ans.append(i)
print(*ans[::-1]) | 0 | null | 102,319,930,079,710 | 213 | 274 |
W = input().rstrip()
lst = []
while True:
line = input().rstrip()
if line == "END_OF_TEXT":
break
lst += line.lower().split()
print(lst.count(W))
| S = str(input())
l = len(S)
if l % 2 == 0:
A = S[:(l//2)]
B = S[(l//2):]
else:
A = S[:(l//2)]
B = S[(l//2+1):]
B = B[::-1]
ans = 0
for i in range(l//2):
if A[i] != B[i]:
ans += 1
print(ans) | 0 | null | 60,912,186,409,348 | 65 | 261 |
# coding: utf-8
# 二分探索（応用）
def loading(pack_list, k, q):
truck = 0
idx = 0
for pack in pack_list:
if pack > q:
return False
if truck + pack > q:
idx += 1
truck = 0
truck += pack
if truck > 0:
idx += 1
return False if idx > k else True
if __name__ == "__main__":
n, k = [int(i) for i in input().split()]
pack = []
for _ in range(n):
pack.append(int(input()))
min = 0
max = int(1E20)
# min = sum(pack) // n
# max = sum(pack)
q = (max + min) // 2
res = loading(pack, k, q)
while min + 1 != max:
min, max = [min, q] if res else [q, max]
q = (max + min) // 2
res = loading(pack, k, q)
print(max)
| def binary_search(n, k, lw):
left = 0
right = max(lw) * n
while left < right:
mid = (left + right)//2
if is_underweight(n, k, lw, p=mid):
right = mid
else:
left = mid + 1
return left
def is_underweight(n, k, lw, p):
i = 0
w = 0
ck = 1
while i < n:
if lw[i] > p:
return False
rest = p - w
if lw[i] <= rest:
w += lw[i]
i += 1
else:
w = 0
ck += 1
return ck <= k
def main():
n, k = map(int, input().split())
lw = []
for _ in range(n):
lw.append(int(input()))
p = binary_search(n, k, lw)
print(p)
if __name__ == '__main__':
main()
| 1 | 91,026,353,460 | null | 24 | 24 |
from collections import deque
def run():
n = int(input())
dq = deque()
for _ in range(n):
order = input()
if order[0] == 'i':
dq.appendleft(order[7:])
elif order[6] == ' ':
key = order.split()[1]
if not key in dq:
continue
for i in range(len(dq)):
if dq[i] == key:
dq.remove(key)
break
elif order[6] == 'F':
dq.popleft()
elif order[6] == 'L':
dq.pop()
print(' '.join(dq))
if __name__ == '__main__':
run()
| from collections import deque
deq = deque()
n = int(input())
for _ in range(n):
operation = input()
if operation == "deleteFirst":
deq.popleft()
elif operation == "deleteLast":
deq.pop()
else:
command, value = operation.split()
if command == "insert":
deq.appendleft(int(value))
elif command == "delete":
try:
deq.remove(int(value))
except ValueError:
pass
print(*deq)
| 1 | 51,396,369,100 | null | 20 | 20 |
a = int(input())
if a % 2 == 0 :
print((a - a / 2 ) / a)
else:
print((a - a // 2) / a)
# 5 ,4 ,3 ,2 ,1
# 3 /5 | # import math
# import statistics
# import itertools
# a=int(input())
# b,c=int(input()),int(input())
# c=[]
# for i in a:
# c.append(int(i))
A,B= map(int,input().split())
f = list(map(int,input().split()))
# g = [input().split for _ in range(a)]
# h = []
# for i in range(a):
# h.append(list(map(int,input().split())))
# a = [[0] for _ in range(H)]#nizigen
kyori=[]
for i in range(len(f)-1):
an=f[i+1]-f[i]
kyori.append(an)
an2=A-f[-1]+f[0]
ans=max(max(kyori),an2)
print(A-ans) | 0 | null | 109,867,245,946,888 | 297 | 186 |
from sys import exit
S = input()
if S[2] == S[3] and S[4] == S[5]:
print('Yes')
exit()
print('No')
| (A, B, M), aa, bb, *xyc = [list(map(int, s.split())) for s in open(0)]
ans = min(aa)+min(bb)
for x, y, c in xyc:
ans = min(ans, aa[x-1]+bb[y-1]-c)
print(ans) | 0 | null | 48,043,035,140,248 | 184 | 200 |
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
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#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 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 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),reversed=True) #二個目の要素で降順並び替え
N = input()
K= int(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)) #改行行列
keta=100+1
dp=[[0]*(keta+1) for _ in range(keta+1)]
dp[0][0]=1
for i in range(1,keta+1):
for j in range(0,i+1):
dp[i][j]+=dp[i-1][j]+dp[i-1][j-1]*9
l=len(N)
cur0=0
tot=0
for i,si in enumerate(N):
n=int(si)
if n!=0:
tot+=(n-1)*dp[l-1-i][K-i-1+cur0]+dp[l-1-i][K-i+cur0]
else:
cur0+=1
ic=0
for s in N:
if s!='0':ic+=1
if ic==K:tot+=1
print(tot)
if __name__ == "__main__":
main() | X=int(input())
ans=1000*(X//500)+5*((X-(X//500*500))//5)
print(ans) | 0 | null | 59,237,960,686,412 | 224 | 185 |
n=int(input())
a=[]
for i in range(1,int(n**(1/2))+1):
if n%i==0:
a.append(i)
a.append(int(n/i))
print(a[-1]+a[-2]-2 if len(a)%2==0 else a[-1]*2-2) | N = int(input())
num = set()
for n in range(2, 10**7):
if N % n == 0:
num.add(tuple(sorted([n, N//n])))
if N == n:
break
ans = (10**12, 10**12)
if not num:
print(N - 1)
else:
for s in num:
if s[0]+s[1] < ans[0]+ans[1]:
ans = s
print(ans[0] + ans[1] - 2) | 1 | 162,011,406,222,688 | null | 288 | 288 |
N, K = map(int, input().split(' '))
print(min(N % K, abs(N % K - K))) | s=list(input())
t=list(input())
x=0
for i in range(len(s)):
if s[i]!=t[i]:
x+=1
else:
pass
print(x) | 0 | null | 24,945,413,603,268 | 180 | 116 |
[X,Y] = list(map(int,input().split()))
n = (-1*X+2*Y)//3
m = (2*X-Y)//3
if (X+Y)%3 !=0:
print(0)
elif n<0 or m<0:
print(0)
else:
MAXN = (10**6)+10
MOD = 10**9 + 7
f = [1]
for i in range(MAXN):
f.append(f[-1] * (i+1) % MOD)
def nCr(n, r, mod=MOD):
return f[n] * pow(f[r], mod-2, mod) * pow(f[n-r], mod-2, mod) % mod
print(nCr(n+m,n,10**9 + 7))
| n = input()
if n >= 'A' and n <= 'Z':
print('A')
if n >= 'a' and n <= 'z':
print('a') | 0 | null | 80,611,346,741,220 | 281 | 119 |
#coding: utf-8
s = input()
q = int(input())
for i in range(q):
order = input().split(" ")
if order[0] == "print":
print(s[int(order[1]) : int(order[2])+1])
elif order[0] == "reverse":
r = s[int(order[1]) : int(order[2])+1]
r = r[::-1]
s = s[:int(order[1])] + r + s[int(order[2])+1:]
elif order[0] == "replace":
s = s[:int(order[1])] + order[3] + s[int(order[2])+1:]
| h,w=map(int, input().split())
cnt=(w//2)*h
if w%2==1:
cnt+=h//2+h%2
if h==1 or w==1:
cnt=1
print(cnt) | 0 | null | 26,269,877,013,210 | 68 | 196 |
a = list(map(int,input().split()))
A = list(map(int,input().split()))
N = a[0]
K = a[1]
for i in range(K,N):
if A[i] > A[i-K]:
print('Yes')
else:
print('No') | N=int(input())
A=list(map(int, input().split()))
A.append(0)
L=[0]*N
L[0]=1000
# dpしろ
for i in range(1,N):
B=[0]*(i+1)
for j in range(i):
t=L[j]//A[j]
B[j]=L[j]%A[j] + t*A[i]
B[i]=L[i-1]
L[i]=max(B)
print(L[N-1]) | 0 | null | 7,199,625,405,192 | 102 | 103 |
n, k = map(int, input().split())
A = tuple(map(int, input().split()))
A = sorted(A, reverse=True)
l = 0
r = max(A)+1
def cut(l, k):
# 長さlの丸太を最大とすることができるかどうかを返す
for a in A:
if a > l:
k -= (-(-a//l) - 1)
return k >= 0
while r-l > 1:
mid = (r+l)//2
if cut(mid, k):
r = mid
else:
l = mid
print(r) | n=int(input());l=list(map(int,input().split()));p=[0]*n;d=[0]*n
for i in range(n):p[i]=l[i]+p[i-2];d[i]=max(p[i-1]if i&1else d[i-1],l[i]+d[i-2])
print(d[-1]) | 0 | null | 22,001,692,714,068 | 99 | 177 |
s=str("ACL")
n=int(input())
print(s*n) | k=int(input())
if k==1:
print('ACL')
elif k==2:
print('ACLACL')
elif k==3:
print('ACLACLACL')
elif k==4:
print('ACLACLACLACL')
elif k==5:
print('ACLACLACLACLACL') | 1 | 2,188,322,314,432 | null | 69 | 69 |
n = int(input())
MOD = int(1e9 + 7)
a, b, c = 1, 1, 1
for i in range(n):
a *= 10;
b *= 9;
c *= 8;
a %= MOD;
b %= MOD;
c %= MOD;
print((a - 2 * b + c) % MOD); | # 入力
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
# ライブラリ
import itertools
l = [i+1 for i in range(n)]
perms = itertools.permutations(l, n)
# 処理
a = 0
b = 0
for i, perm in enumerate(perms):
perm = list(perm)
if perm == p:
a = i
if perm == q:
b = i
import numpy as np
print(np.abs(a-b)) | 0 | null | 51,732,728,517,800 | 78 | 246 |
s = input()
t = input()
count = 0
for i in range(len(s)):
if s[i] != t[i]:
count = count + 1
print(count) | S=input()
T=input()
cnt=0
for idx in range(len(S)):
if S[idx]==T[idx]:
cnt=cnt
else:
cnt=cnt+1
print(cnt) | 1 | 10,501,763,894,258 | null | 116 | 116 |
import collections
N, X, Y = [int(x) for x in input().split()]
c = collections.Counter()
for i in range(1, N + 1):
for j in range(i, N + 1):
if (i == X and j == Y) or (i == Y and j == X):
c[1] += 1
else:
c[min([j - i, abs(X - i) + 1 + abs(Y - j), abs(X - j) + 1 + abs(Y - i)])] += 1
for i in range(1, N):
print(c[i])
| H = int(input())
def attack(h):
if h == 1:
return 0
r = 2
h //= 2
ans = 2
while h > 1:
h //= 2
r *= 2
ans += r
return ans
print(1 + attack(H))
| 0 | null | 61,722,098,807,302 | 187 | 228 |
def merge(a, left, mid, right):
L = a[left:mid] + [INF]
R = a[mid:right] + [INF]
i = 0
j = 0
for k in range(left, right):
global idx
idx += 1
if( L[i] <= R[j] ):
a[k] = L[i]
i += 1
else:
a[k] = R[j]
j += 1
def merge_sort(a, left, right):
if( left + 1 < right ):
mid = (left + right) // 2
merge_sort(a, left, mid)
merge_sort(a, mid, right)
merge(a, left, mid, right)
INF = 1000000000
idx = 0
n = int(input())
a = [int(i) for i in input().split()]
merge_sort(a,0,len(a))
print(*a)
print(idx)
| from itertools import combinations
h,w,k = map(int,input().split())
mat = [input() for i in range(h)]
r = [0 for i in range(h)]
c = [0 for i in range(w)]
black = 0
for i in range(h):
for j in range(w):
if mat[i][j]=="#":
r[i] += 1
c[j] += 1
black += 1
ans = 0
for i in range(h):
for combr in combinations(range(h),i):
for j in range(w):
for combc in combinations(range(w),j):
temp = 0
for x in combr:
temp += r[x]
for y in combc:
temp += c[y]
overlap = 0
for x in combr:
for y in combc:
if mat[x][y]=="#":
overlap += 1
if black+overlap-temp==k:
ans += 1
print(ans)
| 0 | null | 4,578,542,018,680 | 26 | 110 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.