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
|
|---|---|---|---|---|---|---|
x = int(raw_input())
h = x / 3600
m = (x % 3600) / 60
s = x % 60
print u"%d:%d:%d" % (h,m,s)
|
in_sec = int(raw_input())
sec = in_sec%60
in_sec = (in_sec-sec)/60
min = in_sec%60
h = (in_sec-min)/60
print str(h) + ":" + str(min) + ":" + str(sec)
| 1 | 321,978,672,640 | null | 37 | 37 |
a,b=map(int,raw_input().split())
men=a*b
syuu=(a+b)*2
print men,syuu
|
n = list(map(int, list(input())))
while len(n) > 1:
tmp = sum(n)
n = list(map(int, list(str(tmp))))
if n[0] % 9 == 0:
print("Yes")
else:
print("No")
| 0 | null | 2,369,629,842,020 | 36 | 87 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import deque
from copy import deepcopy
def main():
n, m = map(int, input().split())
edges = {e:[] for e in range(n + 1)}
for _ in range(m):
a, b = map(int, input().split())
edges[a].append(b)
edges[b].append(a)
res = [0] * (n + 1)
dist = 1
distroom = [n + 1] * (n + 1)
distroom[1] = 0
q1 = deque()
q2 = deque()
q1.append(1)
while q1:
for q1e in q1:
for adj in edges[q1e]:
if distroom[adj] > dist:
res[adj] = q1e
distroom[adj] = dist
q2.append(adj)
dist += 1
q1 = deepcopy(q2)
q2 = deque()
print('Yes')
print(*res[2:],sep='\n')
if __name__ == '__main__':
main()
|
n,m = map(int,input().split())
import heapq
def dijkstra(s):
d = 1
hq = [(0, s)]
heapq.heapify(hq) # リストを優先度付きキューに変換
cost = [float('inf')] * n # 行ったことのないところはinf
cost[s] = 0 # 開始地点は0
while hq:
c, v = heapq.heappop(hq)
if c > cost[v]: # コストが現在のコストよりも高ければスルー
continue
for u in e[v]:
tmp = 1 + cost[v]
if tmp < cost[u]:
cost[u] = tmp
heapq.heappush(hq, (tmp, u))
return cost
e = [[] for _ in range(n)]
for _ in range(m):
a,b = map(int,input().split())
a,b = a-1, b-1
e[a].append(b)
e[b].append(a) # 有向グラフでは削除
d = dijkstra(0)
# print(d)
# print(e)
ans = [0]*(n)
for i in range(1,n):
for j in e[i]:
# print(i,j)
if d[j] == d[i] - 1:
ans[i] = j + 1
continue
print("Yes")
print(*ans[1:], sep="\n")
| 1 | 20,537,181,370,028 | null | 145 | 145 |
n = int(input())
arr = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for i in range(n):
s = input().split(" ")
nums = list(map(int, s))
arr[nums[0]-1][nums[1]-1][nums[2]-1] += nums[3]
for k in range(4):
for j in range(3):
for i in range(10):
print(" {0}".format(arr[k][j][i]),end="")
print("")
if k < 3:
for l in range(20):
print("#",end="")
print("")
|
while True:
x = input()
if x == '0':
break
print(sum(int(c) for c in str(x)))
| 0 | null | 1,332,459,467,350 | 55 | 62 |
def main():
k = int(input())
for _ in range(k):
print("ACL",end='')
print()
if __name__ == "__main__":
main()
|
#List of Top 3 Hills
set = []
a = 9
for i in range(10):
n = int(input())
set.append(n)
set.sort()
while a >= 7:
print(set[a])
a -= 1
| 0 | null | 1,077,535,482,410 | 69 | 2 |
def main():
s = input()
n = int(input())
for i in range(n):
cmds = input().split(' ')
if 'reverse' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
s = s[:a]+''.join(reversed(s[a:b]))+s[b:]
if 'replace' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
res = cmds[3]
s = s[:a]+res+s[b:]
if 'print' == cmds[0]:
a = int(cmds[1])
b = int(cmds[2])+1
print(s[a:b])
if __name__ == '__main__': main()
|
from collections import Counter
N = int(input())
C = Counter([input() for _ in range(N)])
# print(f'{list(C)=}')
max_value = max([value for value in C.values()])
# print(f'{max_value=}')
S = [key for key, value in zip(C.keys(), C.values()) if value == max_value]
# print(f'{S=}')
for s in sorted(S):
print(s)
| 0 | null | 35,828,540,396,050 | 68 | 218 |
import math
A, B, H, M = map(int, input().split())
h_rad = (H / 12 + M / 12 / 60)* 2 * math.pi
m_rad = M / 60 * 2 * math.pi
dif_rad = abs(h_rad - m_rad)
ans = math.sqrt(A**2 + B**2 - 2 * A * B * math.cos(dif_rad))
print(ans)
|
a,b,h,m = map(int, input().split())
import math
print((a**2+b**2-2*a*b*math.cos(math.radians((360*h/12+30*m/60)-360*m/60)))**(1/2))
| 1 | 20,103,904,646,692 | null | 144 | 144 |
n,q = map(int,input().split())
queue = []
for i in range(n):
p,t = map(str,(input().split()))
t = int(t)
queue.append([p,t])
total_time = 0
while len(queue) > 0:
x = queue.pop(0)
if x[1] > q :
total_time += q
x[1] -= q
queue.append(x)
else:
total_time += x[1]
print(x[0],total_time)
|
class Process_Queue:
class Process:
def __init__(self, name, r_time, link = None):
self.name = name
self.r_time = r_time
self.link = link
def __init__(self, q):
self.size = 0
self.e_time = 0
self.q = q
self.front = None
self.rear = None
def enqueue(self, name, r_time):
if self.size == 0:
self.front = self.rear = Process_Queue.Process(name, r_time)
elif self.size == 100000:
raise Exception("queue overflow")
else:
new_process = Process_Queue.Process(name, r_time)
self.rear.link = new_process
self.rear = new_process
self.size += 1
def dequeue(self):
if self.size == 0:
raise Exception("queue underflow")
elif self.front.r_time > self.q:
self.enqueue(self.front.name, self.front.r_time - self.q)
self.front = self.front.link
self.e_time += self.q
elif self.front.r_time <= self.q:
p_name = self.front.name
self.e_time += self.front.r_time
print(p_name, self.e_time)
self.front = self.front.link
self.size -= 1
if self.size == 0:
self.rear = None
def isEmpty(self):
return self.size == 0
def isFull(self):
return self.size == 100000
n, q = map(int, input().split())
p_queue = Process_Queue(q)
for i in range(n):
p = input().split()
p_queue.enqueue(p[0], int(p[1]))
while not p_queue.isEmpty():
p_queue.dequeue()
| 1 | 43,428,774,050 | null | 19 | 19 |
s = str(input())
t = str(input())
num = 0
for i in range(len(s)):
if s[i] != t[i]:
num += 1
print(num)
|
a,b,c,d=list(map(int, input().split()))
prod=[]
prod.append(a*c)
prod.append(a*d)
prod.append(b*c)
prod.append(b*d)
print(max(prod))
| 0 | null | 6,805,367,172,198 | 116 | 77 |
def solve():
N, M = map(int, input().split())
S = list(input())[::-1]
ans_l = []
i = 0
while i < N:
for j in range(M, 0, -1):
if i + j > N:
continue
if int(S[i+j]) == 0:
ans_l.append(j)
i += j
break
if j == 1:
print(-1)
exit()
ans_l = ans_l[::-1]
print(' '.join(map(str, ans_l)))
if __name__ == '__main__':
solve()
|
mod = 10 ** 9 + 7
n, k = map(int, input().split())
otv = 0
D = [0] * (k + 1)
for i in range(1, k + 1):
D[i] = pow(k // i, n, mod)
for i in range(k // 2, 0, -1):
for j in range(i * 2, k + 1, i):
D[i] -= D[j]
for i in range(1, k + 1):
otv = (otv + D[i] * i) % mod
print(otv)
| 0 | null | 88,057,616,238,710 | 274 | 176 |
N,K = map(int,input().split())
scores = list(map(int,input().split()))
for i in range(N-K):
#print(scores[K-K+i:K+i+1],scores[K-K + i],scores[K+i])
if scores[K-K + i ] >= scores[K+i]:
print("No")
else:
print("Yes")
|
N, K = map(int, input().split())
q, r = divmod(N, K)
ans = 1
while q > 0:
q, r = divmod(q, K)
ans += 1
print(ans)
| 0 | null | 35,689,053,789,710 | 102 | 212 |
y=100000
n = int(input())
for i in range(n):
y=y*1.05
if y%1000==0:
pass
else:
y=y//1000
y=y+1
y=y*1000
print(f"{y:.0f}")
|
import sys
for line in sys.stdin:
l = map(int, line.split())
print len(str(l[0]+l[1]))
| 0 | null | 696,359,324 | 6 | 3 |
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
n = ini()
ans = n % 1000
print(0 if ans == 0 else 1000 - ans)
|
""" 逆元を利用し、nCrを高速で求めるクラス """
class Cmb:
def __init__(self, N=10**5, mod=10**9+7):
self.fact = [1,1]
self.fact_inv = [1,1]
self.inv = [0,1]
""" 階乗を保存する配列を作成 """
for i in range(2, N+1):
self.fact.append((self.fact[-1]*i) % mod)
self.inv.append((-self.inv[mod%i] * (mod//i))%mod)
self.fact_inv.append((self.fact_inv[-1]*self.inv[i])%mod)
""" 関数として使えるように、callで定義 """
def __call__(self, n, r, mod=10**9+7):
if (r<0) or (n<r):
return 0
r = min(r, n-r)
return self.fact[n] * self.fact_inv[r] * self.fact_inv[n-r] % mod
N,K = map(int,input().split())
A = list(map(int,input().split()))
mod=10**9+7
A.sort()
A_rev = A[::-1]
f_max, f_min = 0, 0
cmb = Cmb(mod=mod)
for i, num in enumerate(A):
f_max += num*cmb(i, K-1) if i >= K-1 else 0
for i, num in enumerate(A_rev):
f_min += num*cmb(i, K-1) if i >= K-1 else 0
print((f_max - f_min)%mod)
| 0 | null | 51,872,905,882,342 | 108 | 242 |
n,k,c = map(int,input().split())
S = list(input())
L = [0]*k
nx = -1
cnt = 0
for i,s in enumerate(S):
if i <=nx: continue
if s =='o':
L[cnt] = i
nx = i + c
cnt += 1
if cnt ==k: break
R = [0]*k
nx = -1
cnt = 0
for i,s in enumerate(S[::-1]):
if i <=nx: continue
if s =='o':
R[cnt] = n-i-1
nx = i + c
cnt += 1
if cnt ==k: break
for l,r in zip(L,R[::-1]):
if l ==r:print(l+1)
|
N, K, C = map(int, input().split())
S = input()
right, left = [0 for _ in range(N)], [0 for _ in range(N)]
cnt = 0
work = 0
while True:
if work == K:
break
if S[cnt] != "x":
right[cnt] += 1
work += 1
cnt += C+1
else:
cnt += 1
S = list(reversed(S))
cnt = 0
work = 0
while True:
if work == K:
break
if S[cnt] != "x":
left[cnt] += 1
work += 1
cnt += C+1
else:
cnt += 1
left.reverse()
# print(right)
# print(left)
cnt1 = 0
cnt2 = 0
for i in range(N):
if right[i] == 1:
cnt1 += 1
if left[i] == 1:
cnt2 += 1
if right[i] == left[i] == 1 and cnt1 == cnt2:
print(i+1)
| 1 | 40,451,850,661,920 | null | 182 | 182 |
N = int(raw_input())
A = map(int, raw_input().split())
count = 0
for i in xrange(N):
minj = i
for j in xrange(i, N):
if A[j] < A[minj]:
minj = j
if minj != i:
A[i], A[minj] = A[minj], A[i]
count += 1
print ' '.join(map(str, A))
print count
|
import sys
def input(): return sys.stdin.readline().rstrip()
from bisect import bisect_left,bisect
def main():
h, w, m = map(int,input().split())
h_lis = [0] * (h+1)
w_lis = [0] * (w+1)
bombs = set([tuple(map(int,input().split())) for i in range(m)])
for hh, ww in bombs:
h_lis[hh] += 1
w_lis[ww] += 1
max_h = max(h_lis)
max_w = max(w_lis)
h_max_index = [i for i, h in enumerate(h_lis) if h == max_h]
w_max_index = [i for i, w in enumerate(w_lis) if w == max_w]
for h_i in h_max_index:
for w_i in w_max_index:
if not (h_i, w_i) in bombs:
print(h_lis[h_i] + w_lis[w_i])
sys.exit()
else:
print(h_lis[h_i] + w_lis[w_i] - 1)
if __name__=='__main__':
main()
| 0 | null | 2,380,117,126,468 | 15 | 89 |
def solve():
s=input()
if(len(s)%2==0):
print("No")
return
else :
n=len(s)//2
str1=s[:n]
str2=s[n+1:]
# print(str1,str2)
if(str1==str2):
print("Yes")
else:
print("No")
if __name__ == "__main__":
solve()
|
s = input()
n = len(s)
ans = "No"
cnt = 0
if s[::1] == s[::-1]:
cnt += 1
if s[:int((n-1)/2):1] == s[int((n-1)/2)-1::-1]:
cnt += 1
if s[int((n+1)/2)::1] == s[:int((n-1)/2):-1]:
cnt += 1
if cnt == 3:
ans = "Yes"
print(ans)
| 1 | 46,252,613,787,178 | null | 190 | 190 |
import math
def main():
A, B = map(int, input().split())
a_min = int(math.ceil(A / 0.08))
a_max = int(math.floor((A+1) / 0.08)) - 1
b_min = 10 * B
b_max = 10 * (B+1) - 1
if a_max < b_min or b_max < a_min:
print(-1)
else:
print(max([a_min, b_min]))
if __name__ == '__main__':
main()
|
a, b = map(int, input().split())
ans = 1001
for n in range(1001):
if n * 8 // 100 == a and n * 10 // 100 == b:
ans = min(ans, n)
if ans < 1001:
print(ans)
else:
print(-1)
| 1 | 56,653,333,565,960 | null | 203 | 203 |
#!/usr/bin/env python3
#ABC146 F
import sys
import math
from bisect import bisect_right as br
from bisect import bisect_left as bl
sys.setrecursionlimit(1000000)
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()))
n,m = LI()
s = input()
i = 0
cnt = 0
M = 0
while i < n+1:
if s[i] == '1':
cnt += 1
M = max(M,cnt)
else:
cnt = 0
i += 1
if M >= m:
print(-1)
quit()
lst = []
now = n
while now > 0:
if now - m <= 0:
lst.append(now)
now -= m
else:
for j in range(1,m+1)[::-1]:
if s[now-j] == '0':
lst.append(j)
now -= j
break
print(*lst[::-1])
|
a = [int(x) for x in input()[::-1]] + [0]
n = len(a)
dp = [[0] * 2 for _ in range(n)]
dp[0][0], dp[0][1] = a[0], 10-a[0]
for i in range(n-1):
dp[i+1][0] = min(a[i+1]+dp[i][0], a[i+1]+dp[i][1]+1)
dp[i+1][1] = min(10-a[i+1]+dp[i][0], 10-(a[i+1]+1)+dp[i][1])
print(min(dp[n-1]))
| 0 | null | 104,764,206,141,188 | 274 | 219 |
#ABC156B
n,k = map(int,input().split())
ans = 0
while n > 0 :
n = n // k
ans = ans + 1
print(ans)
|
def answer(n: int, k: int) -> int:
digits = 0
while 0 < n:
n //= k
digits += 1
return digits
def main():
n, k = map(int, input().split())
print(answer(n, k))
if __name__ == '__main__':
main()
| 1 | 63,912,226,336,228 | null | 212 | 212 |
def main():
N, M = map( int, input().split())
S = [ int(s) for s in input()][::-1]
ANS = []
t = 0
while t < N:
for i in range( min(M, N-t),0,-1):
if S[t+i] == 0:
ANS.append(i)
t += i
break
else:
print(-1)
return
if sum(ANS) == N:
print( " ".join( map( str,ANS[::-1])))
else:
print(-1)
if __name__ == '__main__':
main()
|
import sys
sys.setrecursionlimit(2147483647)
INF=float("inf")
MOD=10**9+7
input=lambda:sys.stdin.readline().rstrip()
class SWAG(object):
def __init__(self,dot):
self.__front=[]; self.__back=[]; self.__dot=dot
def __bool__(self):
return bool(self.__front or self.__back)
def __len__(self):
return len(self.__front)+len(self.__back)
def append(self,x):
back=self.__back
if(not back): back.append((x,x))
else: back.append((x,self.__dot(back[-1][1],x)))
def popleft(self):
assert(self)
front=self.__front; back=self.__back
if(not front):
front.append((back[-1][0],back[-1][0]))
back.pop()
while(back):
front.append((back[-1][0],self.__dot(back[-1][0],front[-1][1])))
back.pop()
return front.pop()[0]
def sum(self):
assert(self)
front=self.__front; back=self.__back
if(not front): return back[-1][1]
elif(not back): return front[-1][1]
else: return self.__dot(front[-1][1],back[-1][1])
def resolve():
n,m=map(int,input().split())
S=list(map(int,input()))
dp=[INF]*(n+1) # dp[i] : i から何手でゴールできるか
dp[-1]=0
swag=SWAG(min)
for i in range(n-1,-1,-1):
swag.append(dp[i+1])
if(len(swag)>m): swag.popleft()
if(S[i]==1): continue
dp[i]=swag.sum()+1
if(dp[0]==INF):
print(-1)
return
ans=[]
now=0
turn=dp[0]
for i in range(1,n+1):
if(dp[i]==INF): continue
if(turn>dp[i]):
ans.append(i-now)
now=i
turn=dp[i]
print(*ans)
resolve()
| 1 | 139,223,441,794,460 | null | 274 | 274 |
s = input()
t = input()
ss = len(s)
tt = len(t)
min = tt
for i in range(ss - tt + 1):
count = 0
for j in range(tt):
if s[i+j] != t[j]:
count += 1
if min > count:
min = count
print(min)
|
S=input()
T=input()
s=len(S)
t=len(T)
A=[]
for i in range(s-t+1):
word=S[i:i+t]
a=0
for j in range(t):
if word[j]==T[j]:
a+=1
else:
a+=0
A.append(t-a)
print(min(A))
| 1 | 3,671,799,650,388 | null | 82 | 82 |
#coding: utf-8
for i in range(9):
for k in range(9):
print str(i+1) + 'x' + str(k+1) + '=' + str((i+1) * (k+1))
|
n,k = map(int,input().split())
L = list(map(int,input().split()))
ok = 0
ng = 10**9
while abs(ok-ng) > 1:
mid = (ok+ng)//2
cur = 0
for i in range(n):
cur += L[i]//mid
if cur > k:
ok = mid
elif cur <= k:
ng = mid
K = [mid-1, mid, mid+1]
P = []
for i in range(3):
res = 0
if K[i] > 0:
for j in range(n):
res += (L[j]-1)//K[i]
if res <= k:
P.append(K[i])
print(min(P))
| 0 | null | 3,286,683,199,940 | 1 | 99 |
import sys
n = sys.stdin.readline().rstrip()
def main():
dp = [0, 1]
for d in n:
d = int(d)
dp[0], dp[1] = min(dp[0]+d, dp[1]+10-d), min(dp[0]+d+1, dp[1]+10-d-1)
return dp[0]
if __name__ == '__main__':
ans = main()
print(ans)
|
N = input()
dp = [[0]*2 for _ in range(1001000)]
dp[0][1] = 1
for i in range(len(N)):
d = int(N[i])
dp[i+1][0] = min(dp[i][0] + d, dp[i][1] + 10-d)
dp[i+1][1] = min(dp[i][0] + d + 1, dp[i][1] + 10-d-1) # もらいすぎている状態を維持する
ans = dp[len(N)][0]
print(ans)
| 1 | 71,264,811,502,456 | null | 219 | 219 |
N = int(input())
A = [int(x) for x in input().split()]
cnt = 0
for i in range(N):
mini = i
for j in range(i, N):
if A[j] < A[mini]:
mini = j
if i != mini:
A[i], A[mini] = A[mini], A[i]
cnt +=1
print(" ".join(map(str, A)))
print(cnt)
|
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 a[i] != a[minj]:
a[minj], a[i] = a[i], a[minj]
count += 1
print(*a)
print(count)
| 1 | 20,438,505,220 | null | 15 | 15 |
# E - Rem of Sum is Num
import queue
N, K = map(int, input().split())
A = list(map(int, input().split()))
S = [0] * (N + 1)
for i in range(N):
S[i + 1] = (S[i] + A[i] - 1) % K
v_set = set(S)
mp = {v: 0 for v in v_set}
ans = 0
q = queue.Queue()
for i in range(N + 1):
ans += mp[S[i]]
mp[S[i]] += 1
q.put(S[i])
if q.qsize() == K:
mp[q.get()] -= 1
print(ans)
|
n = int(input())
cnt = [0] * 11000
for x in range(1, 101):
for y in range(1, 101):
for z in range(1, 101):
value = x*x + y*y + z*z + x*y + y*z + z*x
if value <= n:
cnt[value] += 1
for i in range(1,n+1):
print(cnt[i])
| 0 | null | 72,400,329,980,098 | 273 | 106 |
X=int(input())
ans=1000*(X//500)+5*((X-(X//500*500))//5)
print(ans)
|
#C - Traveling Salesman around Lake WA(ヒント)
K,N = map(int,input().split())
A = list(map(int, input().split()))
A[N+1:] = [A[0] + K]#Aを二回繰り返して円を表現
distance_list = []
for i in range(N):
distance = abs(A[i] - A[i+1])
distance_list.append(distance)
distance_list.remove(max(distance_list))
print(sum(distance_list))
| 0 | null | 42,931,173,639,310 | 185 | 186 |
N, K = map(int,input().split())
As = list(map(int,input().split()))
visited = [0] * N
path = []
now_town = 1
while(True):
visited[now_town-1] = 1
path.append(now_town)
now_town = As[now_town-1]
if visited[now_town-1] == 1:
break
index = path.index(now_town)
loop = path[index:len(path)]
loop_len = len(loop)
if index < K:
k = K - index
r = k % loop_len
print(loop[r])
else:
print(path[K])
|
from collections import defaultdict
N, K = map(int, input().split())
A = list(map(int, input().split()))
visited = [0] * N
current = 0
i = 1
while i <= K:
current = A[current] - 1
if visited[current] == 0:
visited[current] = i
else:
loop = i - visited[current]
num_loop = (K - i) // loop
i += loop * num_loop
i += 1
ans = current + 1
print(ans)
| 1 | 22,883,157,907,808 | null | 150 | 150 |
# -*- coding: utf-8 -*-
list = map(int, raw_input().split())
W = list[0]
H = list[1]
x = list[2]
y = list[3]
r = list[4]
if (x-r) >= 0 and (y-r) >= 0 and (x+r) <= W and (y+r) <= H:
print "Yes"
else:
print "No"
|
w,h,x,y,r=map(int,raw_input().split())
f=0
if x+r>w:
f=1
if y+r>h:
f=1
if r>x:
f=1
if r>y:
f=1
if f==0:
print "Yes"
else:
print "No"
| 1 | 454,855,674,560 | null | 41 | 41 |
N=int(input())
S=input()
l=[]
for i in range(N-1):
if S[i]!=S[i+1]:
l.append(S[i])
l.append(S[N-1])
print(len(l))
|
def main():
n = int(input())
s = list(input())
cnt = 1
for i in range(1, n):
if s[i] == s[i-1]:
continue
else:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
| 1 | 170,165,447,535,970 | null | 293 | 293 |
def POW(x, n, mod): #xのn乗をmodで割った際の余りの高速計算
ans = 1
while n > 0:
if n % 2 == 1:
ans *= x%mod
x = (x*x)%mod
n >>= 1 #ビットシフト
return ans
if __name__ == '__main__':
N, K = map(int, input().split())
lst = [0] * (K+1)
mod = 10 ** 9 + 7
ans = 0
for i in range(K):
k = K - i
n = K // k
v = POW(n,N,mod)
m = 2
while(m * k <= K):
v -= lst[m*k]
if v < 0:
v += mod
m += 1
lst[k] = v
v = (k * v)%mod
ans = (ans+v)%mod
print(int(ans))
|
# -*- coding: utf-8 -*-
def selection_sort(a, n):
count = 0
for i in range(n):
minj = i
for j in range(i+1, n):
if a[j] < a[minj]:
minj = j
a[i], a[minj] = a[minj], a[i]
if a[i] != a[minj]:
count += 1
return a, count
def main():
input_num = int(input())
input_list = [int(i) for i in input().split()]
ans_list, count = selection_sort(input_list, input_num)
for i in range(input_num):
if i != 0:
print(" ", end="")
print(ans_list[i], end='')
print()
print(count)
if __name__ == '__main__':
main()
| 0 | null | 18,397,293,298,820 | 176 | 15 |
A,B = list(map(int, input().split()))
list_A = []
list_B = []
for i in range(A):
a = list(map(int, input().split()))
list_A.append(a)
for i in range(B):
b = int(input())
list_B.append(b)
for i in list_A:
output = []
for (y,z) in zip(i,list_B):
op = y*z
output.append(op)
sum_op = sum(output)
print(sum_op)
|
A = []
b = []
row, col = (int(x) for x in input().split())
for i in range(row):
A.append([int(x) for x in input().split()])
for i in range(col):
b.append(int(input()))
for i in range(row):
print(sum(A[i][j]*b[j] for j in range(col)))
| 1 | 1,170,683,439,730 | null | 56 | 56 |
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
n, m = map(int, input().split())
a = list(map(int, input().split()))
l = a[0] // 2
for i in range(n):
a[i] //= 2
l = lcm(l, a[i])
c = 0
while True:
for i in range(n):
if a[i] % 2 == 1:
c += 1
else:
a[i] //= 2
if not c == 0:
break
print(((m // l) + 1) // 2 if c == n else 0)
|
n = int(input())
dic = {}
for i in range(1,50000):
dic[int(i * 1.08)] = i
if n in dic:
print(dic[n])
else:
print(':(')
| 0 | null | 113,956,270,230,348 | 247 | 265 |
A,B,N = map(int,input().split())
if N >= B:
N = B - 1
ans = int(A * N / B) - A * int(N / B)
print(ans)
|
import sys
import math
def resolve(in_):
a, b, n = map(int, next(in_).split())
x = min(b - 1, n)
return math.floor(a * x / b) - a * math.floor(x / b)
def main():
answer = resolve(sys.stdin.buffer)
print(answer)
if __name__ == '__main__':
main()
| 1 | 28,236,316,998,556 | null | 161 | 161 |
import sys
read = sys.stdin.buffer.read
input = sys.stdin.readline
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(input())
def MI(): return map(int,input().split())
def MF(): return map(float,input().split())
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode('utf-8')
#import numpy as np
def main():
x,y,a,b,c=MI()
p=LI()
q=LI()
r=LI()
p.sort()
q.sort()
r.sort()
p=p[a-x:]
q=q[b-y:]
li=p+q+r
li.sort()
li=li[len(li)-x-y:]
print(sum(li))
if __name__ == "__main__":
main()
|
def sep():
return map(int,input().strip().split(" "))
def lis():
return list(sep())
import sys
sys.setrecursionlimit(10**6)
x,y,a,b,c=sep()
red=lis()
green=lis()
colorless=lis()
red.sort(reverse=True)
green.sort(reverse=True)
colorless.sort()
red=red[:x][::-1]
green=green[:y][::-1]
i=0
j=0
while(colorless):
if j>=y and i>=x:
break
elif j<y and i>=x:
if colorless[-1]>green[j]:
green[j]=colorless[-1]
colorless.pop()
j+=1
else:
break
elif i<x and j>=y:
if colorless[-1]>red[i]:
red[i]=colorless[-1]
colorless.pop()
i+=1
else:
break
elif red[i]<=green[j]:
if colorless[-1]>red[i]:
red[i]=colorless[-1]
colorless.pop()
i+=1
else:
break
else:
if colorless[-1]>green[j]:
green[j]=colorless[-1]
colorless.pop()
j+=1
else:
break
#print(red,green)
print(sum(red) + sum(green))
| 1 | 44,939,911,712,720 | null | 188 | 188 |
import sys,collections as cl,bisect as bs
Max = 10**18
def l(): #intのlist
return list(map(int,input().split()))
def m(): #複数文字
return map(int,input().split())
def onem(): #Nとかの取得
return int(input())
def wa(d):
for k in range(len(d)):
for i in range(len(d)):
for j in range(len(d)):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
return d
def on():
N,M,L = m()
e = [[Max for i in range(N)]for j in range(N)]
for i in range(M):
a,b,c = m()
e[a-1][b-1] = c
e[b-1][a-1] = c
for i in range(N):
e[i][i] = 0
d = wa(e)
E = [[Max for i in range(N)]for j in range(N)]
for i in range(N):
for j in range(N):
if d[i][j] <= L:
E[i][j] = 1
for i in range(N):
E[i][i] = 0
E = wa(E)
q = onem()
for i in range(q):
s,t = m()
if E[s-1][t-1] == Max:
print(-1)
else:
print(E[s-1][t-1]-1)
if __name__ == "__main__":
on()
|
import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
n,m,l = list(map(int, input().split()))
from collections import defaultdict
ns = defaultdict(set)
for i in range(m):
a,b,c = map(int, input().split())
a-=1
b-=1
if c<=l:
ns[a].add((c,b))
ns[b].add((c,a))
def wf(ns):
"""全頂点間距離
"""
d = [[float("inf")]*n for _ in range(n)]
for i in range(n):
for t,j in ns[i]:
d[i][j] = t
d[i][i] = 0
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j], d[i][k]+d[k][j])
return d
dist = wf(ns)
ns2 = defaultdict(set)
for i in range(n):
for j in range(i+1,n):
if dist[i][j]<=l:
ns2[i].add((1,j))
ns2[j].add((1,i))
ddist = wf(ns2)
q = int(input())
ans = [None]*q
for i in range(q):
s,t = map(int, input().split())
s-=1
t-=1
if dist[s][t]==float("inf"):
ans[i] = -1
else:
ans[i] = ddist[s][t] - 1
write("\n".join(map(str, ans)))
| 1 | 174,271,380,994,438 | null | 295 | 295 |
N=int(input())
L=list(map(int, input().split()))
L=sorted(L)
import bisect
ans=0
for i in range(N-1):
for j in range(i+1,N):
a=L[i]
b=L[j]
upper = bisect.bisect_left(L,a+b)
lower=max(j+1, bisect.bisect_right(L, a-b), bisect.bisect_right(L, b-a))
#print(upper, lower)
ans+=max(0, upper-lower)
print(ans)
|
import bisect
n = int(input())
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n-1):
b = l[:i]
c = l[i+1:]
for j in b:
ans += bisect.bisect_left(c, l[i] + j)#2番目の棒より短く(left), 一定以上の長さを持つ([i+1:])
print(ans)
| 1 | 171,643,598,176,790 | null | 294 | 294 |
health1, strength1, health2, strength2 = map(int, input().split())
while health1 > 0 and health2 > 0:
health2 -= strength1
if health2 <= 0:
print("Yes")
break
health1 -= strength2
if health1 <= 0:
print("No")
break
|
k=int(input())
a,b=map(int,input().split())
print("OK" if a//k < b//k or a%k==0 or b%k==0 else "NG")
| 0 | null | 28,139,196,782,982 | 164 | 158 |
# Coding is about expressing your feeling, and
# there is always a better way to express your feeling_feelme
import sys
import math
# sys.stdin=open('input.txt','r')
# sys.stdout=open('output2.txt','w')
from sys import stdin,stdout
from collections import deque,defaultdict
from math import ceil,floor,inf,sqrt,factorial,gcd,log2
from copy import deepcopy
ii1=lambda:int(stdin.readline().strip())
is1=lambda:stdin.readline().strip()
iia=lambda:list(map(int,stdin.readline().strip().split()))
isa=lambda:stdin.readline().strip().split()
mod=int(1e9 + 7)
n,h=iia()
arr=iia()
count=0
for i in range(n):
if arr[i]>=h:
count+=1
print(count)
|
from collections import defaultdict
N, X, Y = map(int, input().split())
INF = 10**20
ans = {i:0 for i in range(N)}
d = defaultdict(list)
for i in range(1, N):
d[i].append(i+1)
d[i+1].append(i)
d[X].append(Y)
d[Y].append(X)
for i in range(1, N+1):
dist = [-1]*(N+1)
q = [i]
dist[i] = 0
while q:
a = q.pop()
for b in d[a]:
if dist[b]==-1 or dist[b] > dist[a]+1:
dist[b] = dist[a] + 1
q.append(b)
for j in range(i+1, N+1):
ans[dist[j]] += 1
for i in range(1,N):
print(ans[i])
| 0 | null | 111,623,629,006,970 | 298 | 187 |
A,B,C,D,E=map(int,input().split())
if A==0 :
print(1)
elif B==0:
print(2)
elif C==0:
print(3)
elif D==0:
print(4)
else :
print(5)
|
x = input().split()
print(x.index('0') + 1)
| 1 | 13,336,078,143,840 | null | 126 | 126 |
from math import ceil
A, B, C, D = map(int, input().split())
time_A, time_C = ceil(A/D), ceil(C/B)
print('Yes') if time_A >= time_C else print('No')
|
a, b, c, d = map(int,input().split())
flag = True
while a > 0 and c > 0:
c -= b
if c <= 0:
flag = True
break
a -= d
if a <= 0:
flag = False
break
if flag:
print('Yes')
else:
print('No')
| 1 | 29,773,957,066,800 | null | 164 | 164 |
import sys
input = sys.stdin.readline
n, u, v = [int(x) for x in input().split()]
import heapq
def dijkstra_heap(s):
#始点sから各頂点への最短距離
d = [float("inf")] * n
used = [True] * n #True:未確定
d[s] = 0
used[s] = False
edgelist = []
for e in edge[s]:
heapq.heappush(edgelist,e)
while len(edgelist):
minedge = heapq.heappop(edgelist)
#まだ使われてない頂点の中から最小の距離のものを探す
if not used[minedge[1]]:
continue
v = minedge[1]
d[v] = minedge[0]
used[v] = False
for e in edge[v]:
if used[e[1]]:
heapq.heappush(edgelist,[e[0]+d[v],e[1]])
return d
################################
n, w = n, n - 1 #n:頂点数 w:辺の数
edge = [[] for i in range(n)]
#edge[i] : iから出る道の[重み,行先]の配列
for i in range(w):
x,y = map(int,input().split())
z = 1
edge[x - 1].append([z,y - 1])
edge[y - 1].append([z,x - 1])
takahashi = dijkstra_heap(u - 1)
aoki = dijkstra_heap(v - 1)
ans = -1
for i, j in zip(takahashi, aoki):
if j - i > 0:
ans = max(ans, j - 1)
print(ans)
|
n, r0, g0 = map(int, input().split())
edges = [tuple(map(int, input().split())) for _ in range(n-1)]
connects = [[] for i in range(n+1)]
for e in edges:
connects[e[0]].append(e[1])
connects[e[1]].append(e[0])
rL, gL = [-1]*(n+1), [-1]*(n+1)
rL[r0], gL[g0] = 0, 0
from collections import deque
rQ, gQ = deque([r0]), deque([g0])
for L, Q in [(rL, rQ), (gL, gQ)]:
while Q:
node = Q.popleft()
for ni in connects[node]:
if L[ni] == -1:
L[ni] = L[node] + 1
### print((node, L[node]), (ni, L[ni]))
Q.append(ni)
print(max(gL[i] for i in range(1, n+1) if rL[i] < gL[i]) - 1)
| 1 | 117,379,532,764,042 | null | 259 | 259 |
def main():
a = list(map(int, input().split()))
D = a[0]
T = a[1]
S = a[2]
time = D / S
print("Yes" if time <= T else "No")
if __name__ == '__main__':
main()
|
print((1999-int(input()))//200+1)
| 0 | null | 5,097,669,393,208 | 81 | 100 |
ans = list(map(int,input().split()))
print(ans[2],ans[0],ans[1])
|
x,y,z = map(int,input().split())
temp = x
x = y
y = temp
temp = x
x = z
z = temp
print(x,y,z)
| 1 | 37,842,096,083,062 | null | 178 | 178 |
n = int(input())
a = list(map(int, input().split()))
mod = 10**9 + 7
ans = 0
for keta in range(61):
now = 0
for x in a:
if x & (1 << keta):
now += 1
ans += (now*(n-now))*2**keta
ans %= mod
print(ans)
|
N = int(input())
C = 10**9+7
A = list(map(int, input().split()))
ans = 0
for i in range(60):
L = [(A[j] >> i) & 1 for j in range(N)]
# print(L)
a = L.count(0)
b = L.count(1)
ans += a*b*pow(2, i, C)
print(ans % C)
| 1 | 123,049,816,665,890 | null | 263 | 263 |
n= int(input())
table=[[[0]*10 for i in range(0,3)]for j in range(0,4)]
for k in range(n):
b,f,r,v = map(int,input().split())
table[b-1][f-1][r-1] +=v
x=0
for i in range(4):
if x !=0:
print("#"*20)
x =x+1
for a in range(3):
for b in range(10):
print(" %d"%(table[i][a][b]),end="")
print()
|
# coding:utf-8
import sys
n = input()
array = []
for i in range(n):
array.append(map(int, raw_input().split()))
array.sort()
result = [[0 for i in range(4)] for j in range(n)]
index = 0
result[index] = array[0][0:4]
for i in range(1,n):
if result[index][0:3] == array[i][0:3]:
result[index][3] += array[i][3]
elif result[index][0:3] != array[i][0:3]:
index += 1
result[index] = array[i][0:]
index = 0
for i in range(4):
for j in range(3):
for k in range(10):
sys.stdout.write(' ')
if(i == result[index][0] - 1 and j == result[index][1] - 1 and k == result[index][2] - 1):
print result[index][3],
if index != len(result) - 1:
index += 1
else:
print 0,
else:
print
else:
if(i != 3):
print "####################"
| 1 | 1,094,754,070,880 | null | 55 | 55 |
import sys, os, math, bisect, itertools, collections, heapq, queue, copy, array
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
# from decimal import Decimal
# from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
visited = [-1] * N
G = [[False] * N for _ in range(N)]
for n in range(N):
u, k, *V = il()
for v in V:
G[n][v - 1] = True
que = queue.Queue()
que.put(0)
visited[0] = 0
while not que.empty():
now = que.get()
for n in range(N):
if G[now][n] and visited[n] == -1:
visited[n] = visited[now] + 1
que.put(n)
for n in range(N):
print(n + 1, visited[n])
if __name__ == '__main__':
main()
|
n = int(input())
adj = [None]
for i in range(n):
adji = list(map(int, input().split()[2:]))
adj.append(adji)
isSearched = [None] + [False] * n
distance = [None] + [-1] * n
def BFS(u):
d = 0
isSearched[u] = True
distance[u] = d
edge = [u]
while edge:
q = list(edge)
edge = []
d += 1
for ce in q:
for ne in adj[ce]:
if not isSearched[ne]:
isSearched[ne] = True
edge.append(ne)
distance[ne] = d
BFS(1)
for i, x in enumerate(distance[1:], start=1):
print(i, x)
| 1 | 4,526,702,250 | null | 9 | 9 |
def LI():
return list(map(int, input().split()))
X = int(input())
ans = X//500*1000
X = X % 500
ans += X//5*5
print(ans)
|
X = int(input())
ans=0
if X < 500:
print((X // 5) * 5)
else:
ans += (X // 500)*1000
X -= (X//500)*500
ans += (X//5)*5
print(ans)
| 1 | 42,441,150,126,612 | null | 185 | 185 |
import numpy as np
from scipy.sparse.csgraph import floyd_warshall
from scipy.sparse import csr_matrix
n, m, l = map(int, input().split())
F = np.zeros((n, n))
for _ in range(m):
a, b, c = map(int, input().split())
a -= 1
b -= 1
F[a, b] = c
F[b, a] = c
csr = csr_matrix(F)
A = floyd_warshall(csr)
G = np.zeros((n, n))
for i in range(n-1):
for j in range(i+1, n):
if A[i][j] <= l:
G[i, j] = 1
G[j, i] = 1
ncsr = csr_matrix(G)
B = floyd_warshall(ncsr)
q = int(input())
for _ in range(q):
s, t = map(int, input().split())
k = B[s-1][t-1]
if k == float("inf"):
print(-1)
else:
print(int(k)-1)
|
import sys
input = sys.stdin.readline
N,M,L = map(int,input().split())
ABC = [list(map(int,input().split())) for _ in [0]*M]
Q = int(input())
ST = [list(map(int,input().split())) for _ in [0]*Q]
INF = (L+1)*N
d = [[INF]*N for _ in [0]*N]
for i in range(N):
d[i][i] = 0
for a,b,c in ABC:
a-=1;b-=1
d[a][b] = c
d[b][a] = c
def Warshall_Floyd(d,N=None):
if N==None : N = len(d)
for k in range(N):
for i in range(N):
for j in range(N):
d[i][j] = min(d[i][j],d[i][k]+d[k][j])
Warshall_Floyd(d,N)
d2 = [None]*N
for i,row in enumerate(d):
d2[i] = [1 if e<=L else INF for e in row]
d2[i][i] = 0
Warshall_Floyd(d2,N)
for s,t in ST:
s-=1;t-=1
ans = (d2[s][t]%INF)-1
print(ans)
| 1 | 173,523,657,116,060 | null | 295 | 295 |
N, M, K = map(int, input().split())
class UnionFind:
def __init__(self, n):
self.table = [-1 for _ in range(n)]
self.size = [1]*n
def _root(self, x):
if self.table[x] < 0:
return x
else:
self.table[x] = self._root(self.table[x])
return self.table[x]
def find(self, x, y):
return self._root(x) == self._root(y)
def union(self, x, y):
r1 = self._root(x)
r2 = self._root(y)
if r1 == r2:
return
d1 = self.table[r1]
d2 = self.table[r2]
if d1 <= d2:
self.table[r2] = r1
self.size[r1] += self.size[r2]
if d1 == d2:
self.table[r1] -= 1
else:
self.table[r1] = r2
self.size[r2] += self.size[r1]
def group_size(self, x):
return self.size[self._root(x)]
Friends = [list(map(int, input().split())) for _ in range(M)]
Blocks = [list(map(int, input().split())) for _ in range(K)]
Friendship = UnionFind(N)
Cant = [0]*N
for a in Friends:
Friendship.union(a[0]-1, a[1]-1)
for b in Friends:
if Friendship.find(b[0]-1, b[1]-1):
Cant[b[0]-1] += 1; Cant[b[1]-1] += 1
for c in Blocks:
if Friendship.find(c[0]-1, c[1]-1):
Cant[c[0]-1] += 1; Cant[c[1]-1] += 1
print(*[Friendship.group_size(i)-Cant[i]-1 for i in range(N)])
|
counter = [0 for i in range(10**6+1)]
n = int(input())
a = sorted(list(map(int,input().split())))
for i in a:
counter[i] += 1
l = [0 for i in range(10**6+1)]
cou = 0
for i in range(n):
b = a[i]
if l[b]==0:
cou += 1
for j in range(b,10**6+1,b):
l[j] = 1
if counter[b]>=2:
cou -=1
print(cou)
| 0 | null | 38,089,792,079,472 | 209 | 129 |
def odd(num):
return num//2+num%2
N=int(input())
num = odd(N)/N
print("{:.10f}".format(num))
|
s = input()
print(s+'es') if s.endswith('s') else print(s+'s')
| 0 | null | 89,346,668,181,468 | 297 | 71 |
a = [x + 1 for x in range(9)]
for i in a:
for j in a:
print('{}x{}={}'.format(i, j, i * j))
|
def exe():
for i in range(1,10):
for j in range(1,10):
print(str(i)+'x'+str(j)+'='+str(i*j))
if __name__ == '__main__':
exe()
| 1 | 977,260 | null | 1 | 1 |
import sys
# import math
# import bisect
# import numpy as np
# from decimal import Decimal
# from numba import njit, i8, u1, b1 #JIT compiler
# from itertools import combinations, product
# from collections import Counter, deque, defaultdict
# sys.setrecursionlimit(10 ** 6)
MOD = 10 ** 9 + 7
INF = 10 ** 9
PI = 3.14159265358979323846
def read_str(): return sys.stdin.readline().strip()
def read_int(): return int(sys.stdin.readline().strip())
def read_ints(): return map(int, sys.stdin.readline().strip().split())
def read_ints2(x): return map(lambda num: int(num) - x, sys.stdin.readline().strip().split())
def read_str_list(): return list(sys.stdin.readline().strip().split())
def read_int_list(): return list(map(int, sys.stdin.readline().strip().split()))
def GCD(a: int, b: int) -> int: return b if a%b==0 else GCD(b, a%b)
def LCM(a: int, b: int) -> int: return (a * b) // GCD(a, b)
def Main():
n = read_int()
a = read_int_list()
ans = 1
cnt = [3] + [0] * n
for x in a:
ans = ans * cnt[x] % MOD
cnt[x] -= 1
cnt[x + 1] += 1
print(ans)
if __name__ == '__main__':
Main()
|
import math
def make_stu(p1, p2):
s = [(2 * p1[0] + p2[0]) / 3, (2 * p1[1] + p2[1]) / 3]
t = [(p1[0] + 2 * p2[0]) / 3, (p1[1] + 2 * p2[1]) / 3]
u = [s[0] + (t[0] - s[0]) / 2 - math.sqrt(3) * (t[1] - s[1]) / 2,
s[1] + (t[1] - s[1]) / 2 + math.sqrt(3) * (t[0] - s[0]) / 2]
return s, t, u
def koch_curve(n, p1, p2):
if n >= 1:
s, t, u = make_stu(p1, p2)
if n == 1:
print(s[0], s[1])
print(u[0], u[1])
print(t[0], t[1])
else:
koch_curve(n - 1, p1, s)
print(s[0], s[1])
koch_curve(n - 1, s, u)
print(u[0], u[1])
koch_curve(n - 1, u, t)
print(t[0], t[1])
koch_curve(n - 1, t, p2)
n = int(input())
print(0.0, 0.0)
koch_curve(n, [0.0, 0.0], [100.0, 0.0])
print(100.0, 0.0)
| 0 | null | 64,992,756,609,752 | 268 | 27 |
a1,a2,a3=map(int,input().split())
ans=a1+a2+a3
if ans>=22:
print("bust")
else:
print("win")
|
import math
def solve():
N = int(input())
A = [int(i) for i in input().split()]
S = sum(A)
l = A[0]
I = 0
m = math.ceil(S / 2)
for i in range(1, N):
if (l + A[i]) <= m:
l += A[i]
else:
I = i - 1
break
if l == S / 2:
print(0)
exit()
c = A[I + 1]
r = S - l - c
ans1 = abs(r - (l + c))
ans2 = abs(l - (r + c))
print(min(ans1, ans2))
if __name__ == "__main__":
solve()
| 0 | null | 130,429,372,801,628 | 260 | 276 |
N=int(input())
L=list(map(int,input().split()))
L.sort()
from bisect import bisect_left
ans = 0
for i1 in range(N-2):
for i2 in range(i1+1,N-1):
l1,l2 = L[i1],L[i2]
#th = bisect_left(L[i2+1:],l1+l2)
#print(l1,l2,L[i2+1:],(l2-l1+1)*(-1),th)
th = bisect_left(L,l1+l2)
ans += max(th-i2-1,0)
print(ans)
|
import bisect
def main():
n = int(input())
l_lst = list(map(int, input().split()))
l_lst.sort()
count = 0
for i in range(n - 1):
for j in range(i + 1, n):
a = l_lst[i]
b = l_lst[j]
tmp = bisect.bisect_left(l_lst, a + b)
tmp -= j + 1
tmp = max(0, tmp)
count += tmp
print(count)
if __name__ == '__main__':
main()
| 1 | 172,526,060,113,180 | null | 294 | 294 |
import random
S = input()
rand = random.randrange(0, len(S) - 2)
print(S[rand] + S[rand + 1] + S[rand + 2])
|
s = str(input())
nikname = s[0:3]
print(nikname)
| 1 | 14,784,363,298,240 | null | 130 | 130 |
n = int(input())
inf = 10 ** 10
buy = inf
ans = -inf
for i in range(n):
price = int(input())
ans = max(ans, price - buy)
buy = min(buy, price)
print(ans)
|
print('abcdefghijklmnopqrstuvwxyz'['abcdefghijklmnopqrstuvwxyz'.index(input())+1])
| 0 | null | 46,032,089,030,000 | 13 | 239 |
import sys
N = int(input()) + 1
ans = N // 2
print(ans)
|
H, N = map(int, input().split())
A = [int(x) for x in input().split()]
AA = sum(A)
if AA >= H:
print("Yes")
else:
print("No")
| 0 | null | 68,908,222,857,992 | 206 | 226 |
X=int(input())
if X<=599:
k=8
elif 600<=X<=799:
k=7
elif 800<=X<=999:
k=6
elif 1000<=X<=1199:
k=5
elif 1200<=X<=1399:
k=4
elif 1400<=X<=1599:
k=3
elif 1600<=X<=1799:
k=2
else:
k=1
print(k)
|
X= int(input())
if(X>=400 and X<=599):
print(8)
elif(X>599 and X<800):
print(7)
elif(X>=800 and X<1000):
print(6)
elif(X>=1000 and X<1200):
print(5)
elif(X>=1200 and X<1400):
print(4)
elif(X>=1400 and X<1600):
print(3)
elif(X>=1600 and X<1800):
print(2)
elif(X>=1800 and X<2000):
print(1)
| 1 | 6,700,174,575,068 | null | 100 | 100 |
S, W = map(int, input().split())
print(["safe", "unsafe"][S <= W])
|
import math
loopnum = int(input())
cnt = 0
for i in range(loopnum):
chknum = int(input())
rootnum = int(math.sqrt(chknum))
for j in range(2,rootnum+1):
if chknum % j == 0:
break
else:
cnt += 1
# TLE
#for j in range(2,chknum):
# if chknum % j == 0:
# break
#else:
# cnt += 1
print(cnt)
| 0 | null | 14,545,869,968,262 | 163 | 12 |
n = int(input())
r_min = int(input())
r_t = int(input())
g_max = r_t - r_min
r_min = min(r_t,r_min)
for _ in range(n-2):
r_t = int(input())
g_max = max(g_max, r_t-r_min)
r_min = min(r_t,r_min)
print(g_max)
|
n = int(raw_input())
x = map(int,raw_input().split())
i = n-1
while i != -1:
print "%d" %x[i] ,
i = i-1
| 0 | null | 498,295,026,820 | 13 | 53 |
s = input()
l = [0,'SAT','FRI','THU','WED','TUE','MON','SUN']
print(l.index(s))
|
s=input()
dict1={7:'SUN',6:'MON',5:'TUE',4:'WED',3:'THU',2:'FRI',1:'SAT'}
keys = [k for k, v in dict1.items() if v == s]
print(keys[0])
| 1 | 133,387,488,123,838 | null | 270 | 270 |
n, k = map(int, input().split())
l = [0 for i in range(k + 1)]
ans = 0
mod = 1000000007
for i in range(k, 0, -1):
l[i] = pow(k // i, n, mod)
tmp = 2 * i
while tmp <= k:
l[i] -= l[tmp]
tmp += i
for i in range(k + 1):
ans += i * l[i]
ans %= mod
print(ans)
|
import sys, bisect, math, itertools, heapq, collections
from operator import itemgetter
# a.sort(key=itemgetter(i)) # i番目要素でsort
from functools import lru_cache
# @lru_cache(maxsize=None)
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
INF = float('inf')
mod = 10**9+7
eps = 10**-7
def inp():
'''
一つの整数
'''
return int(input())
def inpl():
'''
一行に複数の整数
'''
return list(map(int, input().split()))
n, k = inpl()
ans = [0] * (k+1)
for i in range(k, 0, -1):
ans[i] = pow(k // i, n, mod)
for j in range(2, k+1):
if i * j > k:
break
ans[i] -= ans[i * j]
# print(ans)
print(sum([ans[i]*i%mod for i in range(1,k+1)])%mod)
'''
1以上K以下の整数からなる長さNの数列{A_1,...A_N}を考える。
K^N個考えられる数列のgcd(A_1,...A_N)の和を求め、10^9+7で割った余りを出力せよ。
term:
2<=N<=10**5
1<=K<=10**5
input:
3 2
output:
9
'''
'''
K^N個の数列すべてに対してgcdを計算しているとO((K^N)*(N+logK))になり間に合わない。
そこで、問題を
「1<=X<=Kに対してgcd(A_1,...A_N)=Xとなる数列A_iがいくつあるか」
という問題に読み替える。
Xが最大公約数であるためには{A_1,...A_N}がすべてXの倍数でなければならない。
K以下でXの倍数である数の個数はK//Xで求められる。
これらによって構成される数列は(K//X)^N種類ある。
しかしgcdがXの倍数であるものも含まれてしまうのでそれを包除原理で除く。
ex)
K=4,N=3のとき(4,4,4)はすべて2の倍数だがgcdは4。
したがって{(4//2)^3-(4//(2*2))^3}%modとする。
'''
| 1 | 36,762,105,885,990 | null | 176 | 176 |
a, b, c, k = (int(i) for i in input().split())
res = 1 * min(a, k) + 0 * min(b, max(0, k - a)) + -1 * min(c, max(0, k - a - b))
print(res)
|
A, B, C, K = list(map(lambda x : int(x), input().split(" ")))
if A >= K:
print(K)
elif A + B >= K:
print(A)
else:
print(2 * A + B - K)
| 1 | 21,972,411,364,448 | null | 148 | 148 |
while True :
num = map(int,input())
s = sum(num)
if s == 0: break
else:
print(s)
|
n = int(input())
tbl = [[0 for i in range(n)] for j in range(5)]
for i in range(2):
a = list(map(int,input().split()))
for j in range(n):
tbl[i][j] = a[j]
D_1 = 0
d_2 = 0
d_3 = 0
for k in range(n):
tbl[2][k] = abs(tbl[0][k]-tbl[1][k])
tbl[3][k] = (abs(tbl[0][k]-tbl[1][k]))**2
tbl[4][k] = (abs(tbl[0][k]-tbl[1][k]))**3
D_1 += tbl[2][k]
d_2 += tbl[3][k]
d_3 += tbl[4][k]
M = max(tbl[2])
print(f'{D_1:.6f}')
print(f'{(d_2)**(1/2):.6f}')
print(f'{(d_3)**(1/3):.6f}')
print(f'{M:.6f}')
| 0 | null | 888,676,512,398 | 62 | 32 |
x = int(input())
x_ = divmod(x, 100)
if 5*x_[0] >= x_[1]:
print(1)
else:
print(0)
|
X = int(input())
for i in range(100000//100 +1):
if X >= i*100 and X<= i*105:
print(1)
exit()
print(0)
| 1 | 126,713,137,411,638 | null | 266 | 266 |
s = input()
n = len(s)
print("x"*n)
|
string = input()
replaced_string = ''
while len(replaced_string) < len(string):
replaced_string += 'x'
print(replaced_string)
| 1 | 72,928,520,243,622 | null | 221 | 221 |
# Begin Header {{{
from math import gcd
from collections import Counter, deque, defaultdict
from heapq import heappush, heappop, heappushpop, heapify, heapreplace, merge
from bisect import bisect_left, bisect_right, bisect, insort_left, insort_right, insort
from itertools import accumulate, product, permutations, combinations, combinations_with_replacement
# }}} End Header
# _________コーディングはここから！！___________
mod = 10**9+7
n = int(input())
ans=0
ans+=pow(10, n, mod)
ans-=pow(9, n, mod)*2
ans+=pow(8, n, mod)
print(ans%mod)
|
import math
a, b, x = map(int, input().split())
if a**2 * b <= 2 * x:
h = (a**2 * b - x) / a**2 * 2
theta = h / (a**2 + h**2)**0.5
ans = math.degrees(math.asin(theta))
else:
h = 2 * x / a / b
theta = h / (b**2 + h**2)**0.5
ans = math.degrees(math.acos(theta))
print(ans)
| 0 | null | 83,031,479,905,464 | 78 | 289 |
a=list(input())
ans=0
for i in range(len(a)):
ans+=int(a[i])
if ans%9==0:
print("Yes")
else:
print("No")
|
def main():
n = int(input())
A = list(map(int,input().split()))
ans = n
A.sort()
table = [True]*(A[-1]+1)
for k,a in enumerate(A):
if table[a]:
if k+1<n and A[k+1]==a:
ans-=1
for i in range(a,A[-1]+1,a):
table[i] = False
else:
ans-=1
print(ans)
main()
| 0 | null | 9,437,014,590,608 | 87 | 129 |
#! python3
# greatest_common_divisor.py
def greatest_common_divisor(x, y):
r = None
if x >= y:
r = x%y
if r == 0: return y
else:
r = y%x
if r == 0: return x
return greatest_common_divisor(y, r)
x, y = [int(n) for n in input().split(' ')]
print(greatest_common_divisor(x, y))
|
s=[int(x) for x in list(input())]
for c in range(len(s)-1,-1,-1):
if c==len(s)-1:
continue
s[c]=(pow(10,len(s)-c-1,2019)*s[c]+s[c+1])%2019
s.append(0)
s.sort()
h=[1]
d=s[0]
for c in range(1,len(s)):
if s[c]!=d:
h.append(1)
d=s[c]
else:
h[-1]+=1
k=[(x*(x-1))//2 for x in h]
print(sum(k))
| 0 | null | 15,512,900,591,188 | 11 | 166 |
from math import ceil
debt=100000
bigets=1000
interest_rate=1.05
def calc_debt(n):
d=debt//bigets
while n>0:
d=ceil(d*interest_rate)
n -= 1
return d*bigets
n=int(input())
print(calc_debt(n))
|
import math
n=input()
m=10**2
for i in range(n):
m=m*1.05
m=math.ceil(m)
print int(m*(10**3))
| 1 | 1,069,182,180 | null | 6 | 6 |
from itertools import *
H, W, K = map(int, input().split())
S = [list(map(int, input())) for i in range(H)]
cut_min = H+W-2
for r_cut in range(H):
if cut_min <= r_cut:
continue
for r_pos in combinations(range(1, H), r_cut):
r_pos = (None,)+r_pos+(None,)
r_blocks = [slice(*r_pos[i:i+2]) for i in range(len(r_pos)-1)]
cut = r_cut
prev_sum = [0] * len(r_blocks)
for col in zip(*S):
curr_sum = [sum(col[b]) for b in r_blocks]
if any(map(K.__lt__, curr_sum)):
break
next_sum = [x+y for x,y in zip(prev_sum, curr_sum)]
if any(map(K.__lt__, next_sum)):
cut += 1
if cut_min <= cut:
break
prev_sum = curr_sum
else:
prev_sum = next_sum
else:
cut_min = cut
print(cut_min)
|
H,W,K=map(int,input().split())
S=[[int(s) for s in input()] for i in range(H)]
ans=1000000
for i in range(2**(H-1)):
tmp=0
L=[]
for j in range(H-1):
if i>>j&1:
L.append(j)
tmp+=len(L)
L.append(H-1)
c=[0]*len(L)
for k in range(W):
h=0
c1=[0]*len(L)
for l in range(len(L)):
for m in range(h,L[l]+1):
c1[l]+=S[m][k]
h=L[l]+1
p=0
for l in range(len(L)):
if c1[l]>K:
p=2
break
elif c[l]+c1[l]>K:
p=1
else:
c[l]+=c1[l]
if p==2:
break
elif p==1:
c=[i for i in c1]
tmp+=1
else:
ans=min(ans,tmp)
print(ans)
| 1 | 48,760,421,611,200 | null | 193 | 193 |
def resolve():
import math
from math import gcd
MOD=10**9+7
n=int(input())
zero=0
cnt={}
for i in range(n):
a,b=map(int,input().split())
if a==0 and b==0:
zero+=1
continue
g=gcd(a,b)
a//=g
b//=g
if b<0:
a*=-1
b*=-1
if b==0 and a<0:
a*=-1
if a<=0:
a,b=b,-a
if (a,b) in cnt:
cnt[(a,b)][0]+=1
else:
cnt[(a,b)]=[1,0]
else:
if (a,b) in cnt:
cnt[(a,b)][1]+=1
else:
cnt[(a,b)]=[0,1]
ans=1
for i,v in cnt.items():
ans*=pow(2,v[0],MOD)+pow(2,v[1],MOD)-1
ans%=MOD
print((zero-1+ans)%MOD)
if __name__ == '__main__':
resolve()
|
S,T = input().split()
N,M = list(map(int, input().split()))
U = input()
if U == S:
N = N - 1
if U == T:
M = M - 1
print(N, M)
| 0 | null | 46,398,941,846,608 | 146 | 220 |
n = input().split()
x = int(n[0])
y = int(n[1])
if x < y:
bf = x
x = y
y = bf
while y > 0:
r = x % y
x = y
y = r
print(str(x))
|
A,B = list(map(int,input().split()))
print(int(A*B))
| 0 | null | 7,884,850,549,520 | 11 | 133 |
def merge(A,left,mid,right):
global cnt
n1 = mid - left
n2 = right - mid
cnt += n1+n2
L = [A[left+i] for i in range(n1)]
R = [A[mid+i] for i in range(n2)]
L.append(float("inf"))
R.append(float("inf"))
i = 0
j = 0
for k in range(left,right):
if L[i] <= R[j]:
A[k] = L[i]
i += 1
else:
A[k] = R[j]
j += 1
def mergesort(A,left,right):
if left +1 < right:
mid = int((left+right)/2)
mergesort(A,left,mid)
mergesort(A,mid,right)
merge(A,left,mid,right)
n = int(input())
A = list(map(int,input().split()))
cnt = 0
mergesort(A,0,n)
print(" ".join(map(str,A)))
print(cnt)
|
def merge(A, left, mid, right):
global count
n1 = mid - left
n2 = right - mid
L=[]
R=[]
# for i in range(n1):
# L.append(A[left + i])
# for i in range(n2):
# R.append(A[mid + i])
L=A[left:mid]
R=A[mid:right]
L.append(10e10)
R.append(10e10)
i = 0
j = 0
for k in range(left , right):
count +=1
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
def mergeSort(A, left, right):
if left+1 < right:
mid = (left + right)//2
mergeSort(A, left, mid)
mergeSort(A, mid, right)
merge(A, left, mid, right)
n = int(input())
A = list(map(int, input().split()))
count = 0
mergeSort(A, 0, n)
print(*A)
print(count)
| 1 | 114,578,718,630 | null | 26 | 26 |
n = int(input())
MOD = 10 ** 9 + 7
ans = (pow(10, n, MOD) - 2 * pow(9, n, MOD) + pow(8, n, MOD))%MOD
print(ans)
|
MOD = 10**9+7
def solve(n):
"""
0: {}
1: {0}
2: {9}
3: {0,9}
"""
dp = [[0]*4 for i in range(n+1)]
dp[0][0] = 1
x = [1,0,0,0]
for i in range(n):
x = [
(8*x[0]) % MOD,
(9*x[1] + x[0]) % MOD,
(9*x[2] + x[0]) % MOD,
(10*x[3] + x[2] + x[1]) % MOD
]
return x[3]
n = int(input())
print(solve(n))
| 1 | 3,198,804,256,592 | null | 78 | 78 |
a,b,c = map(int, input().split())
a_b = a==b
b_c = b==c
a_c = a==c
if a_b and b_c and a_c:
print("No")
elif a_b or b_c or a_c:
print("Yes")
else:
print("No")
|
h, w, k = map(int, input().split())
cake = [input() for _ in range(h)]
cnt = 1
ans = [[0]*w for _ in range(h)]
for i in range(h):
cnt_berry = 0
for j in range(w):
if cake[i][j] == '#':
cnt_berry += 1
if 2 <= cnt_berry:
cnt += 1
ans[i][j] = cnt
if cnt_berry != 0:
cnt += 1
else:
for j in range(w):
ans[i][j] = ans[i-1][j]
cnt = 0
for row in ans:
if row[0] == 0:
cnt += 1
continue
break
for i in range(cnt-1, -1, -1):
for j in range(w):
ans[i][j] = ans[i+1][j]
for row in ans:
print(*row)
| 0 | null | 105,965,667,717,536 | 216 | 277 |
s = input()
if s == "ABC" :
print("ARC")
elif s == "ARC" :
print("ABC")
|
def readinput():
s=input()
return s
def main(s):
if s=='ABC':
return 'ARC'
elif s=='ARC':
return 'ABC'
ans=''
return ans
if __name__=='__main__':
s=readinput()
ans=main(s)
print(ans)
| 1 | 24,124,042,382,268 | null | 153 | 153 |
n = int(input()) - 1
a = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
j = 0
for i in range( n, j, -1 ):
if a[i] < a[i-1]:
t = a[i]
a[i] = a[i-1]
a[i-1] = t
count += 1
flag = 1
j += 1
print(*a)
print(count)
|
n, k, c = map(int, input().split())
s = input()
left = [-1 for _ in range(k)]
right = [-1 for _ in range(k)]
bef = -10 ** 10
cnt = 0
for i, ss in enumerate(s):
if ss == "o" and i - bef > c:
if cnt == k:
exit()
left[cnt] = i
bef = i
cnt += 1
cnt = 0
bef = -10 ** 10
for i, ss in enumerate(s[::-1]):
if ss == "o" and i - bef > c:
if cnt == k:
exit()
right[k - 1 - cnt] = n - 1 - i
bef = i
cnt += 1
for ll, rr in zip(left, right):
if ll == rr:
print(ll + 1)
| 0 | null | 20,339,397,690,752 | 14 | 182 |
N = int(input())
t = ""
while N > 0:
t += chr((N-1)%26 + 97)
N = (N-1)//26
print(t[::-1])
|
import sys
sys.setrecursionlimit(10 ** 5)
n, u, v = map(int, input().split())
u -= 1
v -= 1
es = [[] for i in range(n)]
for i in range(n-1):
a, b = map(int, input().split())
es[a-1].append(b-1)
es[b-1].append(a-1)
def dfs(v, dist, p=-1, d=0):
dist[v] = d
for nv in es[v]:
if nv == p:
continue
dfs(nv, dist, v, d+1)
def calc_dist(x):
dist = [-1] * n
dfs(x, dist)
return dist
dist_t = calc_dist(u)
dist_a = calc_dist(v)
mx = 0
for i in range(n):
if dist_t[i] < dist_a[i]:
mx = max(mx, dist_a[i])
ans = mx - 1
print(ans)
| 0 | null | 64,758,625,868,160 | 121 | 259 |
x = raw_input()
print int(x) ** 3
|
A=[list(map(int, input().split())) for _ in range(3)]
N=int(input())
B=[0]*N
for _ in range(N):
B[_]=int(input())
G=[['.']*3 for _ in range(3)]
for i in range(3):
for j in range(3):
if A[i][j] in B:
G[i][j]='#'
# print(G)
if any(all(G[i][j]=='#' for i in range(3)) for j in range(3)) or \
any(all(G[i][j]=='#' for j in range(3)) for i in range(3)) or \
all(G[i][2-i]=='#' for i in range(3)) or \
all(G[i][i]=='#' for i in range(3)):
print('Yes')
else:
print('No')
| 0 | null | 30,102,452,003,812 | 35 | 207 |
import math
n = int(input())
x = [int(num) for num in input().split()]
y = [int(num) for num in input().split()]
D1 = 0
D2 = 0
D3 = 0
D4 = []
for i, j in zip(x, y):
D1 += abs(i - j)
print(D1)
for i, j in zip(x, y):
D2 += (abs(i - j))**2
print(math.sqrt(D2))
for i, j in zip(x, y):
D3 += (abs(i - j))**3
print(math.pow(D3, 1.0/3.0))
for i, j in zip(x, y):
D4.append(abs(i - j))
print(max(D4))
|
n,k = map(int,input().split())
class Combination(): # nCr mod MOD など
"""
O(n+log(mod))の前計算を1回行うことで，O(1)でnCr mod mを求められる
n_max = 10**6のとき前処理は約950ms (PyPyなら約340ms, 10**7で約1800ms)
使用例：
C = Combination(10**6)
print(C.combi_mod(5, 3)) # 10
"""
def __init__(self, n_max, mod=10**9+7): # O(n+log(mod))
self.mod = mod
self.fac, self.facinv = self.prepare(n_max)
#self.modinv = self.make_modinv_list(n_max) ##なくても問題ないので、必要な時のみ使う
def prepare(self,n): # O(n+log(mod))
# 前処理(コンストラクタで自動的に実行)
# 1! ~ n! の計算
factorials = [1] # 0!の分
for m in range(1, n+1):
factorials.append(factorials[m-1]*m%self.mod)
# n!^-1 ~ 1!^-1 の計算
invs = [1] * (n+1)
invs[n] = pow(factorials[n], self.mod-2, self.mod)
for m in range(n, 1, -1):
invs[m-1] = invs[m]*m%self.mod
return factorials, invs # list
def make_modinv_list(self, n): # O(n)
# 0からnまでのmod逆元のリストを返す O(n)
modinv = [0] * (n+1)
modinv[1] = 1
for i in range(2, n+1):
# 整数aのMを法とした時の逆元a^-1は、(0<=a<=M-1)
# a == qM+rであるとき(qは商,rは余り)、
# a^-1 == -qr^-1 % M で与えられる。
modinv[i] = (self.mod - self.mod//i)*modinv[self.mod%i] % self.mod
return modinv
def perm_mod(self,n,r): # nPr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (self.fac[n] * self.facinv[n-r]) % self.mod
def combi_mod(self,n,r): # nCr % self.mod
if n < r:
return 0
if (n < 0 or r < 0):
return 0
return (((self.fac[n] * self.facinv[r]) % self.mod) * self.facinv[n-r]) % self.mod
def repeated_permutation(self,n,deno): # 重複順列
# n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
## n:int(分子),deno:分母のlist
if n < max(deno):
return 0
if (n < 0 or min(deno) < 0):
return 0
D = 1
for i in range(len(deno)):
D = D*self.facinv[deno[i]] % self.mod
return self.fac*D % self.mod # int ## == n!/(deno[0]!*deno[1]!*...*deno[len(deno)-1]) % MOD
def H(self,n,r): # 重複組合せ nHr % self.mod
now_n = len(self.fac)
if now_n < n+r-1: # もしself.facの長さが足りなかったら追加
for i in range(now_n+1, n+r-1+1):
self.fac.append(self.fac[i-1]*i%self.mod)
return self.combi_mod(n+r-1,r)
mod = 10**9+7
C = Combination(n,mod)
ans = 0
for i in range(min(k+1,n+1)):
ans += C.combi_mod(n,i)*C.H(n-i,i)
ans %= mod
print(ans)
| 0 | null | 33,771,428,703,830 | 32 | 215 |
ma = lambda :map(int,input().split())
lma = lambda :list(map(int,input().split()))
tma = lambda :tuple(map(int,input().split()))
ni = lambda:int(input())
yn = lambda fl:print("Yes") if fl else print("No")
import collections
import math
import itertools
import heapq as hq
n,m,l = ma()
INF=10**15
cost = [[INF]*n for i in range(n)]
for i in range(m):
a,b,c = ma();a-=1;b-=1
cost[a][b]=c
cost[b][a]=c
def wf(cost):
l = len(cost[0])
for k in range(l):
for i in range(l):
for j in range(l):
cost[i][j] = min(cost[i][j],cost[i][k] + cost[k][j])
wf(cost)
rest = [[INF]*n for i in range(n)]
for i in range(n):
for j in range(n):
if cost[i][j]<=l:
rest[i][j]=1
wf(rest)
q = ni()
for i in range(q):
s,t = ma();s-=1;t-=1
print(rest[s][t] -1) if rest[s][t] !=INF else print(-1)
|
import copy
h, w = map(int,input().split())
maze = [[9]*(w+2)]
for i in range(h):
s = input()
tmp = [9]
for j in s:
if j == "#":
tmp.append(9)
else:
tmp.append(0)
tmp.append(9)
maze.append(tmp)
maze.append([9]*(w+2))
#print(maze)
def bfs(start):
maze2 = copy.deepcopy(maze)
#print(maze2)
pos = [start]
max_depth = 0
maze2[start[0]][start[1]] = 2
while len(pos):
x, y, depth = pos.pop(0)
max_depth = max(depth, max_depth)
if maze2[x-1][y] < 2:
pos.append([x-1,y,depth + 1])
maze2[x-1][y] = 2
if maze2[x+1][y] < 2:
pos.append([x+1,y,depth + 1])
maze2[x+1][y] = 2
if maze2[x][y-1] < 2:
pos.append([x,y-1,depth +1])
maze2[x][y-1] = 2
if maze2[x][y+1] < 2:
pos.append([x,y+1,depth +1])
maze2[x][y+1] = 2
return max_depth
ans = 0
for i in range(h):
for j in range(w):
start = [i+1,j+1,0]
maze2 = maze
if maze[i+1][j+1] != 9:
#print(bfs(start))
ans = max(ans,bfs(start))
print(ans)
| 0 | null | 133,625,789,014,048 | 295 | 241 |
def lcm(x, y):
if x > y:
greater = x
else:
greater = y
while(True):
if((greater % x == 0) and (greater % y == 0)):
lcm = greater
break
greater += 1
return lcm
num1 = int(input())
a=lcm(num1,360)
b=a/num1
print(int(b))
|
from math import gcd
def lcm(a,b):
return a*b//gcd(a,b)
X=int(input())
from math import ceil
print(lcm(360,X)//X)
| 1 | 13,113,117,919,990 | null | 125 | 125 |
def solve():
def combis(n, k, mod):
from math import factorial
numerator = 1
denominator = 1
for i in range(k):
numerator = numerator * (n-i) % mod
denominator = denominator * (i+1) % mod
return numerator * pow(denominator, mod-2, mod) % mod
n,a,b = [int(i) for i in input().split()]
mod = 10**9 + 7
ans = pow(2, n, mod) - 1 - combis(n, a, mod) - combis(n, b, mod)
print(ans % mod)
if __name__ == "__main__":
solve()
|
from functools import reduce
n, a, b = map(int, input().split())
mod = 10**9 + 7
def f(A):
bunsi = reduce(lambda x, y: x*y%mod, range(n, n-A, -1))
bunbo = reduce(lambda x, y: x*y%mod, range(1, A+1))
return bunsi * pow(bunbo, mod-2, mod) % mod
ans = pow(2, n, mod) - f(a) -f(b) - 1
ans %= mod
print(ans)
| 1 | 66,177,139,933,120 | null | 214 | 214 |
#import sys
#input = sys.stdin.buffer.readline
#input = sys.stdin.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
def main():
n=int(input())
s=[]
t=[]
for i in range(n):
a,b=input().split()
s.append(a)
t.append(int(b))
x=input()
for i in range(n):
if x==s[i]:
ans=sum(t[i+1:])
print(ans)
exit(0)
if __name__ == "__main__":
main()
|
n=int(input())
slist=[]
tlist=[]
ans=0
yn=0
for i in range(n):
s,t=input().split()
slist.append(s)
tlist.append(int(t))
x=input()
for i in range(n):
if yn==1:
ans+=tlist[i]
if x==slist[i]:
yn=1
print(ans)
| 1 | 96,922,912,657,480 | null | 243 | 243 |
import sys
input = sys.stdin.readline
from collections import deque
class Graph:
def __init__(self, n, directed=False, decrement=True, destroy=False, edges=[]):
self.n = n
self.directed = directed
self.decrement = decrement
self.destroy = destroy
self.edges = [set() for _ in range(self.n)]
self.parent = [-1]*self.n
self.info = [-1]*self.n
for x, y in edges:
self.add_edge(x,y)
def add_edge(self, x, y):
if self.decrement:
x -= 1
y -= 1
self.edges[x].add(y)
if self.directed == False:
self.edges[y].add(x)
def add_adjacent_list(self, i, adjacent_list):
if self.decrement:
self.edges[i] = set(map(lambda x: x - 1, adjacent_list))
else:
self.edges[i] = set(adjacent_list)
def bfs(self, start=1, goal=-1, time=0, save=False):
"""
:param start: スタート地点
:param goal: ゴール地点
:param save: True = 前回の探索結果を保持する
:return: （ループがあっても）最短距離。存在しなければ -1
"""
if self.decrement:
start -= 1
goal -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, time
self.parent[p] = -2
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
if q == goal:
return t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return -1
def connection_counter(self):
"""
:return: 連結成分の個数。有効グラフではあまり意味がない。
"""
cnt = 0
self.parent = [-1] * self.n
for start in range(self.n):
if self.parent[start] == -1:
cnt += 1
self.bfs(start + self.decrement, save=True)
return cnt
def distance_list(self, start=1, save=False):
"""
:param start: スタート地点
:return: スタート地点から各点への距離のリスト
"""
dist = [-1]*self.n
if self.decrement:
start -= 1
if not save:
self.parent = [-1] * self.n
p, t = start, 0
self.parent[p] = -2
dist[p] = 0
next_set = deque([(p, t)])
while next_set:
p, t = next_set.popleft()
for q in self.edges[p]:
if self.parent[q] != -1:
continue
dist[q] = t + 1
self.parent[q] = p
next_set.append((q, t + 1))
return dist
def path_list(self, start=1):
"""
:return: スタート地点から最短経路で進んだ時の、各頂点の一個前に訪問する頂点番号
訪問しない場合は -1 を返す
"""
self.distance_list(start)
if self.decrement:
start -= 1
return list(p + self.decrement for p in self.parent[1:])
##################################################################################################
N, M = map(int, input().split())
graph = Graph(N, directed=False, decrement=True, destroy=False)
for _ in range(M):
x, y = map(int, input().split())
graph.add_edge(x, y)
res = graph.path_list()
if -1 in res:
print("No")
else:
print("Yes")
print(*res, sep="\n")
|
from collections import deque
N, M = map(int, input().split())
G = [[] for i in range(N)]
for i in range(M):
a, b = map(int, input().split())
G[a-1].append(b-1)
G[b-1].append(a-1)
ls = deque([0])
ans = [-1] * N
ans[0] = 0
while len(ls) > 0:
v = ls.popleft()
for next_v in G[v]:
if ans[next_v] != -1:
continue
ans[next_v] = v
ls.append(next_v)
if -1 in ans:
print("No")
else:
print("Yes")
for i in range(1, N):
print(ans[i]+1)
| 1 | 20,412,669,548,262 | null | 145 | 145 |
l = list("abcdefghijklmnopqrstuvwxyz")
C = input()
i = l.index(C)
print(l[i+1])
|
import sys
def main():
a, b = sys.stdin.readline().split(" ")
a, b = int(a), int(b)
print("{0} {1}".format(a*b, a*2 + b*2))
return
if __name__ == '__main__':
main()
| 0 | null | 46,518,424,515,138 | 239 | 36 |
import itertools
n = int(input())
p = tuple([int(i) for i in input().split()])
q = tuple([int(i) for i in input().split()])
lst = list(itertools.permutations(list(range(1, n + 1))))
print(abs(lst.index(p) - lst.index(q)))
|
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
from collections import Counter
N, P = map(int, readline().split())
S = list(map(int, read().rstrip().decode()))
def solve_2(S):
ind = (i for i, x in enumerate(S, 1) if x % 2 == 0)
return sum(ind)
def solve_5(S):
ind = (i for i, x in enumerate(S, 1) if x % 5 == 0)
return sum(ind)
def solve(S,P):
if P == 2:
return solve_2(S)
if P == 5:
return solve_5(S)
S = S[::-1]
T = [0] * len(S)
T[0] = S[0] % P
power = 1
for i in range(1, len(S)):
power *= 10
power %= P
T[i] = T[i-1] + power * S[i]
T[i] %= P
counter = Counter(T)
return sum(x * (x - 1) // 2 for x in counter.values()) + counter[0]
print(solve(S,P))
| 0 | null | 79,358,118,307,620 | 246 | 205 |
import math
n=int(input())
a = []
b = []
ans = 0
def z(p,q,r,s):
return ((p-r)**2+(q-s)**2)**0.5
for i in range(n):
x,y=map(int,input().split())
a.append(x)
b.append(y)
for i in range(n):
for j in range(i+1,n):
ans += 2*z(a[i],b[i],a[j],b[j])
ans /= n
print(ans)
|
from itertools import permutations as P
from math import sqrt as r
N = int(input())
xy = [list(map(int, input().split())) for _ in range(N)]
ans_sum = 0
town = list(P(list(range(N)), N))
Q = len(town)
for town in town:
d = 0
for i in range(N - 1):
X = xy[town[i]][0] - xy[town[i + 1]][0]
Y = xy[town[i]][1] - xy[town[i + 1]][1]
d += r(X**2 + Y**2)
#print(d)
ans_sum += d
print(ans_sum/Q)
| 1 | 148,472,841,202,168 | null | 280 | 280 |
while True:
[a,b] = raw_input().split()
a = int(a)
b = int(b)
if a == 0 and b == 0:
break
if a < b:
print a,b
else:
print b,a
|
A = int(input())
B = int(input())
for i in range(1, 4):
if i in [A, B]:
continue
else:
print(i)
break
| 0 | null | 55,413,490,269,592 | 43 | 254 |
def main():
N = int(input())
A = [[i for i in input().split()] for j in range(N)]
X = input()
ans = 0
flag = False
for a, b in A:
if a == X:
flag = True
continue
if flag:
ans += int(b)
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
p_list = []
for i in range(N):
s = input().split(' ')
p_list.append(s)
X = input()
flg = False
time = 0
count = 0
for sound in p_list:
if sound[0] == X:
time = int(sound[1])
flg = True
if flg:
count += int(sound[1])
print(count-time)
| 1 | 96,488,939,752,736 | null | 243 | 243 |
n = int(input())
flag = False
for x in (range(1,10)):
for y in (range(1,10)):
if x * y == n:
flag = True
else:
continue
break
if flag:
print("Yes")
else:
print("No")
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
4
1 2 2 4
2 1 4
3 0
4 1 3
output:
1 0
2 1
3 2
4 1
"""
import sys
from collections import deque
UNVISITED, VISITED_IN_QUEUE, POPPED_OUT = 0, 1, 2
def graph_bfs(v_init):
queue = deque()
status[v_init] = VISITED_IN_QUEUE
distance[v_init] = 0
queue.appendleft(v_init)
while queue:
current = queue.popleft()
for adj in adj_table[current]:
if status[adj] is UNVISITED:
status[adj] = VISITED_IN_QUEUE
distance[adj] = distance[current] + 1
queue.append(adj)
status[current] = POPPED_OUT
return None
if __name__ == '__main__':
_input = sys.stdin.readlines()
v_num = int(_input[0])
vertices = list(map(lambda x: x.split(), _input[1:]))
# assert len(vertex_info) == vertex_num
status = [UNVISITED] * (v_num + 1)
distance = [-1] * (v_num + 1)
adj_table = tuple([] for _ in range(v_num + 1))
for v_info in vertices:
v_index, adj_num, *adj_list = map(int, v_info)
# assert len(adj_list) == adj_num
adj_table[v_index].extend(adj_list)
graph_bfs(v_init=1)
for index, v in enumerate(distance[1:], 1):
print(index, v)
| 0 | null | 79,931,317,963,312 | 287 | 9 |
def SelectionSort(A, n):
sw = 0
for i in xrange(n):
minj = i
for j in xrange(i, n):
if A[j] < A[minj]:
minj = j
temp = A[minj]
A[minj] = A[i]
A[i] = temp
if i != minj:
sw += 1
return sw
def printArray(A, n):
for i in xrange(n):
if i < n-1:
print A[i],
else:
print A[i]
n = input()
arr = map(int, raw_input().split())
cnt = SelectionSort(arr, n)
printArray(arr, n)
print cnt
|
a,b = input().split(" ")
a = int(a)
b = int(b)
print(a*b)
| 0 | null | 7,869,186,067,952 | 15 | 133 |
n = int(input())
s = input()
q = int(input())
# セグ木
#使う操作
#####segfunc#####
def segfunc1(x, y):
return x | y
#################
#####ide_ele#####
ide_ele1 = set()
#################
class SegTree:
"""
init(init_val, ide_ele): 配列init_valで初期化 O(N)
update(k, x): k番目の値をxに更新 O(logN)
query(l, r): 区間[l, r)をsegfuncしたものを返す O(logN)
"""
def __init__(self, init_val, segfunc, ide_ele):
"""
init_val: 配列の初期値
segfunc: 区間にしたい操作
ide_ele: 単位元
n: 要素数
num: n以上の最小の2のべき乗
tree: セグメント木(1-index)
"""
n = len(init_val)
self.segfunc = segfunc
self.ide_ele = ide_ele
self.num = 1 << (n - 1).bit_length()
self.tree = [ide_ele] * 2 * self.num
# 配列の値を葉にセット
for i in range(n):
self.tree[self.num + i] = init_val[i]
# 構築していく
for i in range(self.num - 1, 0, -1):
self.tree[i] = self.segfunc(self.tree[2 * i], self.tree[2 * i + 1])
def update(self, k, x):
"""
k番目の値をxに更新
k: index(0-index)
x: update value
"""
k += self.num
self.tree[k] = x
while k > 1:
self.tree[k >> 1] = self.segfunc(self.tree[k], self.tree[k ^ 1])
k >>= 1
def query(self, l, r):
"""
[l, r)のsegfuncしたものを得る
l: index(0-index)
r: index(0-index)
"""
res = self.ide_ele
l += self.num
r += self.num
while l < r:
if l & 1:
res = self.segfunc(res, self.tree[l])
l += 1
if r & 1:
res = self.segfunc(res, self.tree[r - 1])
l >>= 1
r >>= 1
return res
al = [{s[i]} for i in range(n)]
seg = SegTree(al, segfunc1, ide_ele1)
for i in range(q):
x,y,z = input().split()
y = int(y) - 1
if x == "1":
seg.update(y, {z})
if x == "2":
ans = len(seg.query(y, int(z)))
print(ans)
|
n = int(input())
S = input()
s = []
for i in range(n):
s.append(S[i])
q = int(input())
BIT = []
for i in range(26):
B = [0]*(n+1) #1-indexed
BIT.append(B)
def sum_of_1_to_i(i, LIST):
z = 0
while i > 0:
z += LIST[i]
i -= i & (-i)
return z
def update(i, j, LIST):
while i <= n:
LIST[i] += j
i += i & (-i)
for i in range(n):
k = ord(s[i])-97
update(i+1, 1, BIT[k])
ans = []
for i in range(q):
a,b,c = input().split()
a = int(a)
b = int(b)
if a == 1:
temp = s[b-1]
if temp == c:
None
else:
update(b, -1, BIT[ord(temp)-97])
update(b, 1, BIT[ord(c)-97])
s[b-1] = c
else:
c = int(c)
cur = 0
for j in range(26):
if sum_of_1_to_i(c, BIT[j])-sum_of_1_to_i(b-1, BIT[j]) != 0:
cur += 1
ans.append(cur)
for i in range(len(ans)):
print(ans[i])
| 1 | 62,270,994,576,402 | null | 210 | 210 |
import sys
from collections import defaultdict, deque, Counter
import math
# import copy
from bisect import bisect_left, bisect_right
import heapq
# sys.setrecursionlimit(1000000)
# input aliases
input = sys.stdin.readline
getS = lambda: input().strip()
getN = lambda: int(input())
getList = lambda: list(map(int, input().split()))
getZList = lambda: [int(x) - 1 for x in input().split()]
INF = 10 ** 20
MOD = 10**9 + 7
divide = lambda x: pow(x, MOD-2, MOD)
def nck(n, k, kaijyo):
return (npk(n, k, kaijyo) * divide(kaijyo[k])) % MOD
def npk(n, k, kaijyo):
if k == 0 or k == n:
return n % MOD
return (kaijyo[n] * divide(kaijyo[n-k])) % MOD
def kaijyo(n):
ret = [1]
for i in range(1, n + 1):
ret.append((ret[-1] * i)% MOD)
return ret
def solve():
n = getN()
nums = getList()
keta = [[0, 0] for i in range(62)]
for num in nums:
tmp = num
for i in range(62):
if tmp % 2 == 1:
keta[i][1] += 1
else:
keta[i][0] += 1
tmp //= 2
ans = 0
dig = 0
for k1, k2 in keta:
ans += ((k1 * k2) * (2**dig)) % MOD
dig += 1
print(ans % MOD)
def main():
n = getN()
for _ in range(n):
solve()
if __name__ == "__main__":
# main()
solve()
|
m = 100000
rate = 0.05
n = int(input())
for i in range(n):
m += m*rate
x = m%1000
m -= x
while(x % 1000 != 0):
x += 1
m += x
print(str(int(m)))
| 0 | null | 61,822,465,106,432 | 263 | 6 |
x = list(map(int, input().split(" ")))
h1 = x[0]
m1 = x[1]
h2 = x[2]
m2 = x[3]
s = x[4]
h = (h2-h1)*60
m = m2-m1
print((h+m)-s)
|
a, b, c, d, e = map(int, input().split())
f = (c - a) * 60
f += (d - b)
print(f - e)
| 1 | 18,084,933,844,980 | null | 139 | 139 |
N = int(input())
ST = [list(map(str, input().split())) for _ in range(N)]
X = str(input())
ans = 0
flag = False
for s, t in ST:
if flag:
ans += int(t)
else:
if s == X:
flag = True
print (ans)
|
class Stack:
def __init__(self, full_idx=10):
self.stack = [None] * full_idx
self.top = 0
self.MAX = full_idx
def is_empty(self):
return self.top == 0
def is_full(self):
return self.top >= self.MAX - 1
def push(self, x):
if self.is_full():
raise IndexError
self.top += 1
self.stack[self.top] = x
def pop(self):
if self.is_empty():
raise IndexError
self.top -= 1
return self.stack[self.top+1]
def main():
s = input()
s1, s2 = Stack(20000), Stack(20000)
pond = [0]
area = 0
for i in range(len(s)):
if s[i] == "\\":
s1.push(i)
s2.push([i, 0])
elif s[i] == "/":
if not s1.is_empty():
area += i - s1.pop()
if not s2.is_empty():
tup = s2.pop()
area2 = 0
while tup[1] != 0:
tup2 = s2.pop()
tup, tup2 = tup2, tup
area2 += tup2[1]
tup[1] = i - tup[0] + area2
if s2.is_empty():
pond.append(tup[1])
else:
s2.push(tup)
s3 = Stack(20000)
while not s2.is_empty():
ss = s2.pop()
if ss[1] != 0:
s3.push(ss)
while not s3.is_empty():
pond.append(s3.pop()[1])
pond[0] = len(pond) - 1
print(area)
print(" ".join([str(i) for i in pond]))
if __name__ == '__main__':
main()
| 0 | null | 48,224,570,114,710 | 243 | 21 |
s = input()
p = input()
s *= 2
if p in s:
print('Yes')
else:
print('No')
|
from math import ceil
from collections import deque
n, d, a = map(int, input().split())
m = sorted([list(map(int, input().split())) for _ in range(n)])
m = [[x, ceil(h / a)] for x, h in m]
acc_damage = 0
que = deque()
ans = 0
for x, h in m:
while que and x > que[0][0]:
limit, damage = que.popleft()
acc_damage -= damage
rest_h = max(0, h - acc_damage)
ans += rest_h
acc_damage += rest_h
if rest_h:
que.append([x + 2 * d, rest_h])
print(ans)
| 0 | null | 42,010,476,830,660 | 64 | 230 |
s=raw_input().strip()
print s+('es' if s[-1]=='s' else 's')
|
S = list(input())
if S[-1] != "s":
S.append("s")
else:
S.append("es")
print(*S, sep="")
| 1 | 2,381,202,937,630 | null | 71 | 71 |
H, W = [int(x) for x in input().split(" ")]
if H > W:
H, W = W, H
if H == 1:
print(1)
elif H % 2 == 0:
print(W * (H // 2))
else:
if W % 2 == 0:
print(W * H // 2)
else:
print(((W - 1) * H // 2) + H // 2 + 1)
|
a,b = map(int,input().split())
ans = 0
if a == 1 or b == 1:
print(1)
elif a*b % 2 == 0:
print(int(a*b/2))
else:
print(int((a*b-1)/2 + 1))
| 1 | 50,622,486,108,234 | null | 196 | 196 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.