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
|
|---|---|---|---|---|---|---|
S = int(input())
if S % 9 == 0:
W = 'Yes'
else:
W = 'No'
print(W)
|
MOD = 10**9 + 7
k = int(input())
s = input()
n = len(s)
MAX = 2 * 10**6 + 5
fact = [1] * (MAX + 1) # i!
finv = [1] * (MAX + 1) # (i!)^{-1}
iinv = [1] * (MAX + 1) # i^{-1}
for i in range(2, MAX + 1):
fact[i] = fact[i - 1] * i % MOD
iinv[i] = MOD - iinv[MOD % i] * (MOD // i) % MOD
finv[i] = finv[i - 1] * iinv[i] % MOD
def comb(n: int, k: int) -> int:
if n < k or n < 0 or k < 0:
return 0
return (fact[n] * finv[k] % MOD) * finv[n - k] % MOD
ans = 0
for i in range(k + 1):
ans += comb(n + k - i - 1, k - i) * pow(25, k - i, MOD) % MOD * pow(
26, i, MOD) % MOD
ans %= MOD
print(ans)
| 0 | null | 8,673,214,970,780 | 87 | 124 |
#16D8101012J 伊藤惇 dj Python3
def Greatest_Common_Divisor(x,y):
if y>x:
x,y=y,x
if x>=y and y>0:
return Greatest_Common_Divisor(y,x%y)
return x
if __name__ == "__main__":
x=list(map(int,input().split()))
print(Greatest_Common_Divisor(x[0],x[1]))
|
import math
h=int(input())
print(2**(math.floor(math.log2(h))+1)-1)
| 0 | null | 40,071,899,442,556 | 11 | 228 |
import sys
import math
a = []
for line in sys.stdin:
a.append(line)
for n in a:
inl=n.split()
num1=int(inl[0])
check=1
list=[]
while check<=math.sqrt(num1):
if num1%check==0:
list.append(check)
list.append(num1/check)
check+=1
list.sort()
list.reverse()
num2=int(inl[1])
for i in list:
if num2%i==0:
gud=i
break
lcm=num1*num2/gud
print gud,lcm
|
import sys
def gcd(a,b):
if b != 0:
return gcd(b,a%b)
else:
return a
def lcm(a,b,g):
return b / g * a
for s in sys.stdin:
ls = map(int,s.split(' '))
print "%d %d" % (gcd(ls[0],ls[1]),lcm(ls[0],ls[1],gcd(ls[0],ls[1])))
| 1 | 693,614,780 | null | 5 | 5 |
n,m,l = map(int,input().split())
a = [list(map(int,input().split())) for _ in range(n)]
b = [list(map(int,input().split())) for _ in range(m)]
c = [[0 for _ in range(l)] for __ in range(n)]
for i in range(n):
for j in range(l):
c[i][j] = sum([a[i][k]*b[k][j] for k in range(m)])
for ci in c:
print(*ci)
|
A, B = input().split()
A = int(A)
B = int(B.replace('.',''))
print(f'{A*B//100}')
| 0 | null | 8,900,338,326,140 | 60 | 135 |
S = input()
if S[-1] != "s":
print(S+"s")
else:
print(S+"es")
|
def main():
n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
s = sum(a)
ans = 0
for i in range(n):
s -= a[i]
ans = (ans + a[i] * s) % mod
print(ans)
main()
| 0 | null | 3,066,193,419,228 | 71 | 83 |
n=int(input())
a=list(map(int,input().split()))
if n//2==1:
print(max(a))
exit()
if n%2==0:
#iは桁数、jはそれまでに余計に飛ばした数
#dp[i][j]
dp=[[-10**9]*2 for _ in range(n)]
for i in range(n):
if i<2:
dp[i][0]=a[i]
if i>=2:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:
dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
#print(dp)
print(max([dp[-1][1],dp[-1][0],dp[n-2][0]]))
else:
#iは桁数、jはそれまでに余計に飛ばした数
#dp[i][j]
dp=[[-10**9]*3 for _ in range(n)]
for i in range(n):
if i<2:
dp[i][0]=a[i]
if i>=2:
dp[i][0]=dp[i-2][0]+a[i]
if i>=3:
dp[i][1]=max(dp[i-2][1]+a[i],dp[i-3][0]+a[i])
if i>=4:
dp[i][2]=max([dp[i-2][2]+a[i],dp[i-3][1]+a[i],dp[i-4][0]+a[i]])
#print(dp)
print(max([dp[-1][2],dp[-1][1],dp[-1][0]-a[0],dp[-1][0]-a[-1]]))
|
kuku = [i * j for i in range(1,10) for j in range(1,10)]
N = int(input())
print('Yes' if N in kuku else 'No')
| 0 | null | 98,527,338,730,160 | 177 | 287 |
import collections
N=int(input())
S=[]
for i in range(N):
s=input()
S.append(s)
l=collections.Counter(S)
keys=l.keys()
k=max(l.values())
ans=[]
for i in keys:
if l[i]==k:
ans.append(i)
ans.sort()
n=len(ans)
for i in range(n):
print(ans[i])
|
import math
a = raw_input()
for i, b in enumerate(a.split()):
if i==0:
W=int(b)
elif i==1:
H=int(b)
elif i==2:
x=int(b)
elif i==3:
y=int(b)
else:
r=int(b)
if r<=x<=W-r and r<=y<=H-r:
print 'Yes'
else:
print 'No'
| 0 | null | 35,171,229,075,514 | 218 | 41 |
n = int(input())
p = []
for i in range(n):
x,y = map(int,input().split())
p.append([x,y])
q = []
r = []
for i in range(n):
q.append(p[i][0]+p[i][1])
r.append(p[i][0]-p[i][1])
q.sort()
r.sort()
ans = max(abs(q[-1]-q[0]),abs(r[-1]-r[0]))
print(ans)
|
N=int(input())
A=[]
B=[]
for _ in range(N):
x,y=map(int, input().split())
A.append(x+y)
B.append(x-y)
A=sorted(A)
B=sorted(B)
print(max(A[-1]-A[0],B[-1]-A[0],A[-1]-A[0],B[-1]-B[0]))
| 1 | 3,409,315,652,848 | null | 80 | 80 |
import numpy as np
N = int(input())
X = []
L = []
for _ in range(N):
Xi, Li = map(int, input().split())
X.append(Xi)
L.append(Li)
begins = []
ends = []
for i in range(N):
begins.append(X[i] - L[i])
ends.append(X[i] + L[i])
b = []
e = []
for i in np.argsort(ends):
b.append(begins[i])
e.append(ends[i])
begins = b
ends = e
now = -1e9
cnt = 0
for i in range(N):
if now <= begins[i]:
cnt += 1
now = ends[i]
print(cnt)
|
N=int(input())
xl=[list(map(int,input().split()))for _ in range(N)]
arms={}
for x,l in xl:
arms[x-l]=0
arms[x+l]=0
for x,l in xl:
arms[x-l]+=1
arms[x+l]-=1
point={}
for x,l in xl:
point[x-l]=[]
point[x+l]=[]
for x,l in xl:
point[x-l].append(x+l)
ans=N
K=sorted(arms.keys())
now=0
count=[]
for k in K:
now+=arms[k]
for kk in point[k]:
count.append(kk)
for i in range(count.count(k)):
count.remove(k)
if now>=2:
ans-=now-1
now=1
C=sorted(count)[::-1]
for c in C[:-1]:
arms[c]+=1
count.remove(c)
print(ans)
| 1 | 89,939,986,627,484 | null | 237 | 237 |
n = int(input())
x = list(map(int, input().split()))
ans = 2000000000
for i in range(1,101):
sum = 0
for j in x:
sum += (i-j)**2
ans = min(sum, ans)
print(ans)
|
N,K = list(map(int,input().split()))
snacker = set()
for i in range(K):
dummy=input()
for j in [int(k) for k in input().split()]:
snacker.add(j)
print(N-len(snacker))
| 0 | null | 44,697,550,938,940 | 213 | 154 |
S = list(input())
for i in range(len(S)):
S[i] = "x"
print(''.join(S))
|
string = input()
replaced_string = ''
while len(replaced_string) < len(string):
replaced_string += 'x'
print(replaced_string)
| 1 | 72,938,382,223,188 | null | 221 | 221 |
x = int(input())
while True:
flag =0
for i in range(2,x//2):
if x%i==0:
flag =1
break
if flag ==0:
print(x)
exit()
x = x+1
|
X = int(input())
def Sosuu_not(n):
for p in range(2, n):
if n % p == 0:
return False
else:
return True
while True:
if Sosuu_not(X) == True:
print(X)
break
X += 1
| 1 | 105,717,853,590,010 | null | 250 | 250 |
x, y = map(int,input().split())
min = 2 * x
gap = y - min
if gap < 0 or gap > min:
print("No")
else:
if gap % 2 == 0:
print("Yes")
else:
print("No")
|
N = int(input())
ans = [0]*10050
for i in range(1,105):
for j in range(1,105):
for k in range(1,105):
v = (i+j+k)**2-(i*j+i*k+j*k)
if v < len(ans):
ans[v] += 1
for x in range(1,N+1):
print(ans[x])
| 0 | null | 10,818,789,557,968 | 127 | 106 |
def resolve():
A, B = list(map(int, input().split()))
if A >= 10 or B >= 10:
print(-1)
else:
print(A*B)
if '__main__' == __name__:
resolve()
|
A,B = map(int,input().split())
answer = -1
if A<=9 and B<=9:
answer= A*B
print(answer)
| 1 | 158,173,501,530,912 | null | 286 | 286 |
import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n = int(input())
res = 0
for i in range(1, (n + 1) // 2):
if i != n - i:
res += 1
print(res)
if __name__ == '__main__':
resolve()
|
N = int(input())
if N % 2 != 0:
print((N + 1) // 2 - 1)
else:
print(N//2 -1)
| 1 | 153,352,597,675,838 | null | 283 | 283 |
N = int(input())
A = []
for i in range(N):
a = int(input())
Alst = []
for j in range(a):
x,y = map(int,input().split())
Alst.append([x-1,y])
A.append(Alst)
honest = 0
for i in range(2**N):
flag = 0
for j in range(N):
if (i>>j)&1:
for x,y in A[j]:
if (i>>x)&1 != y: # j番目は正直だが矛盾を発見
flag = 1
break
if flag == 0: # 矛盾がある場合はflag == 1になる
honest = max(honest, bin(i)[2:].count('1')) # 1の数をカウントし最大となるものを選択
print(honest)
|
X, Y = map(int, input().split())
print("{}".format(X*Y))
| 0 | null | 68,806,686,169,560 | 262 | 133 |
from bisect import bisect
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
SA = [0] * (N + 1)
SB = [0] * (M + 1)
for i in range(N):
SA[i+1] = SA[i] + A[i]
for i in range(M):
SB[i+1] = SB[i] + B[i]
result = 0
y = M
for x in range(N+1):
if SA[x] > K:
break
while y >= 0 and SA[x] + SB[y] > K:
y -= 1
result = max(result, x + y)
print(result)
|
n=int(input())
s,t=map(str, input().split())
a=[]
for i in range(n):
a.append(s[i]+t[i])
a = "".join(a)
print(a)
| 0 | null | 61,475,297,903,810 | 117 | 255 |
n,k=map(int,input().split())
a=list(map(lambda x:(int(x)-1)%k,input().split()))
s=[0]
for i in a:
s.append((s[-1]+i)%k)
mp={}
ans=0
for i in range(len(s)):
if i-k>=0:
mp[s[i-k]]-=1
if s[i] in mp:
ans+=mp[s[i]]
mp[s[i]]+=1
else:
mp[s[i]]=1
print(ans)
|
from collections import defaultdict
n, k = map(int, input().split())
a = list(map(lambda x: int(x) - 1, input().split()))
s = [0] * (n + 1)
for i in range(n):
s[i + 1] = (s[i] + a[i]) % k
mp = defaultdict(int)
ans = 0
for i in range(n + 1):
ans += mp[s[i]]
mp[s[i]] += 1
if i >= k - 1:
mp[s[i - k + 1]] -= 1
print(ans)
| 1 | 137,882,514,330,360 | null | 273 | 273 |
n = list(input())
for i in range(len(n)) :
n[i] = int(n[i])
if sum(n)%9==0 :
print("Yes")
else :
print("No")
|
while True:
string = input()
if string == "-":
break
else:
s = 0
for i in range(int(input())):
s += int(input())
s = s % len(string)
print(string[s:] + string[:s])
| 0 | null | 3,175,509,273,372 | 87 | 66 |
n=int(input())
wl={}
for i in range(n):
w=input()
if w not in wl:
wl[w]=0
wl[w]+=1
wm=max(wl.values())
wl3=sorted(wl.items())
for i in range(len(wl3)):
if wl3[i][1]==wm:
print(wl3[i][0])
|
from bisect import bisect_left, bisect_right
N = int(input())
S = list(input())
Q = int(input())
D = {chr(ord('a') + i): [] for i in range(26)}
for i, s in enumerate(S):
D[s].append(i)
for q in range(Q):
query = list(input().split())
if query[0] == '1':
i, x = int(query[1]), query[2]
i -= 1
s = S[i]
if s == x:
continue
D[s].remove(i)
next_i = bisect_left(D[x], i)
D[x].insert(next_i, i)
S[i] = x
if query[0] == '2':
l, r = int(query[1]), int(query[2])
l, r = l - 1, r - 1
ans = 0
for i in range(26):
s = chr(ord('a') + i)
li = bisect_left(D[s], l)
ri = bisect_right(D[s], r)
if ri - li > 0:
ans += 1
print(ans)
| 0 | null | 66,168,643,485,440 | 218 | 210 |
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(input())
def MI(): return map(int, input().split())
def MI1(): return map(int1, input().split())
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(input())
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print(k.join(list(map(str, lst))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N, M = MI()
A = LI()
ans = N - sum(A)
print(-1 if ans < 0 else ans)
if __name__ == '__main__':
solve()
|
n, m = map(int,input().split())
a = list(map(int,input().split()))
b = 0
for i in a:
b = b + i
if n >= b:
print(n - b)
if n < b:
print( -1 )
| 1 | 31,928,067,892,748 | null | 168 | 168 |
#!/usr/bin/env python
# coding: utf-8
# In[9]:
A,B,M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
mylist = []
for _ in range(M):
mylist.append(list(map(int, input().split())))
# In[11]:
ans = min(a)+min(b)
for i in range(M):
cost = a[mylist[i][0]-1] + b[mylist[i][1]-1] - mylist[i][2]
if cost < ans:
ans = cost
print(ans)
# In[ ]:
|
a, b, c, d = map(int, input().split(" "))
while True:
c -= b
if c <= 0:
print("Yes")
break
a -= d
if a <= 0:
print("No")
break
| 0 | null | 41,995,354,547,284 | 200 | 164 |
l=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
c=input('')
for a in range(25):
if l[a]==c:
print(l[a+1])
|
s = str(input())
sm = 0
for c in s:
sm += int(c)
if sm % 9 == 0:
print('Yes')
else:
print('No')
| 0 | null | 48,125,723,409,950 | 239 | 87 |
N,M=map(int,input().split())
A=list(map(int,input().split()))
sum=0
for i in range(M):
sum+=A[i]
if N<sum:
print(-1)
else:
print(N-sum)
|
S=list(input())
P=0
M=2019
D=[0]*M
D[0]=1
X,Y=0,1
for i in range(len(S)):
X+=Y*int(S[-i-1])
X%=M
P+=D[X]
D[X]+=1
Y=Y*10%M
print(P)
| 0 | null | 31,621,727,808,228 | 168 | 166 |
def main():
## IMPORT MODULE
#import sys
#sys.setrecursionlimit(100000)
#input=lambda :sys.stdin.readline().rstrip()
#f_inf=float("inf")
#MOD=10**9+7
if 'get_ipython' in globals():
## SAMPLE INPUT
n = 4
S = ['((()))', '((((((', '))))))', '()()()']
else:
## INPUT
n = int(input())
#a, b = map(int, input().split())
S = [input() for _ in range(n)]
## SUBMITION CODES HERE
def CNT(A):
tmp, Min = 0, 0
for a in A:
if a == '(': tmp += 1
else: tmp -= 1
Min = min(Min, tmp)
return (-Min, tmp-Min)
T = [CNT(s) for s in S]
pls = []
mis = []
for l, r in T:
if l <= r: pls.append((l, r))
else: mis.append((l, r))
pls.sort(key=lambda a: a[0])
mis.sort(key=lambda a: a[1], reverse=True)
total = pls + mis
levl = 0
for l, r in total:
levl -= l
if levl < 0:
print('No')
exit()
levl += r
print('Yes' if levl == 0 else 'No')
main()
|
N = int(input())
for i in range(1, 10):
if N % i == 0 and 1 <= N / i <= 9:
print('Yes')
exit()
print('No')
| 0 | null | 91,422,514,402,478 | 152 | 287 |
cnt = 0
while True:
a = input()
if a == '0':
break
cnt += 1
print('Case {0}: {1}'.format(cnt,a))
|
# coding: UTF-8
from collections import deque
queue = deque()
ftime = deque()
n,quantum = map(int,input().split())
for i in range(n):
name,time = input().split()
time = int(time)
queue.append((name,time))
t = 0
while queue:
name,time = queue.popleft()
if time <= quantum:
t += time
ftime.append(name + " " + str(t))
else:
t += quantum
queue.append((name,time-quantum))
while ftime:
print(ftime.popleft())
| 0 | null | 266,350,612,462 | 42 | 19 |
def main():
S, W = map(int, input().split())
print("safe" if W < S else "unsafe")
return
main()
|
hitsuji, okami = map(int, input().split())
if hitsuji <= okami:
print('unsafe')
else:
print('safe')
| 1 | 29,193,471,666,916 | null | 163 | 163 |
s = input()
res = 0
if s == "SUN":
res = 7
elif s == "MON":
res = 6
elif s == "TUE":
res = 5
elif s == "WED":
res = 4
elif s == "THU":
res = 3
elif s == "FRI":
res = 2
elif s == "SAT":
res = 1
print(res)
|
S = input()
week = ["SUN","MON","TUE","WED","THU","FRI","SAT"]
if S == week[0]:
print(7)
elif S == week[1]:
print(6)
elif S == week[2]:
print(5)
elif S == week[3]:
print(4)
elif S == week[4]:
print(3)
elif S == week[5]:
print(2)
else:
print(1)
| 1 | 133,200,217,128,948 | null | 270 | 270 |
import math
r = float(input())
#r = (float(x) for x in input().split())
d = r * r * math.pi
R = 2 * r * math.pi
print ("{0:.6f} {1:.6f}".format(d,R))
|
import math
r = input()
print "%.6f %.6f" % (math.pi * r * r, math.pi * 2 * r)
| 1 | 651,473,289,522 | null | 46 | 46 |
# -*- coding: utf-8 -*-
import sys
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
def bisearch_max(mn, mx, func):
""" 条件を満たす最大値を見つける二分探索 """
ok = mn
ng = mx
while ok+1 < ng:
mid = (ok+ng) // 2
if func(mid):
# 上を探しに行く
ok = mid
else:
# 下を探しに行く
ng = mid
return ok
T1, T2 = MAP()
A1, A2 = MAP()
B1, B2 = MAP()
# a,bの状態からT1,T2の操作を行った後のa,bと、この操作での交差回数を返す
def calc(a, b):
cnt = 0
a1 = a + T1 * A1
b1 = b + T1 * B1
if a > b and a1 <= b1 or a < b and a1 >= b1:
cnt += 1
a2 = a1 + T2 * A2
b2 = b1 + T2 * B2
if a1 > b1 and a2 <= b2 or a1 < b1 and a2 >= b2:
cnt += 1
return a2, b2, cnt
# x+1回目の操作でまだ交差するか
def check(x):
a = (T1 * A1 + T2 * A2) * x
b = (T1 * B1 + T2 * B2) * x
_, _, cnt = calc(a, b)
return cnt >= 1
# 初回で同値に飛んだらその先もずっと繰り返す
a, b, cnt = calc(0, 0)
if a == b:
print('infinity')
exit()
# 最後に交差する直前までの操作回数を調べる
res = bisearch_max(-1, 10**18, check)
# 初回でも交差しなければ0
if res == -1:
print(0)
exit()
# 直前までの操作では、初回は1回、以降は2回ずつ交差する
ans = max(0, res * 2 - 1)
# 最後に交差する直前までa,bを移動させる
a = (T1 * A1 + T2 * A2) * res
b = (T1 * B1 + T2 * B2) * res
# 最後が1回か2回か確認
_, _, cnt = calc(a, b)
ans += cnt
print(ans)
|
import sys
readline = sys.stdin.buffer.readline
def even(n): return 1 if n%2==0 else 0
T1,T2 = map(int,readline().split())
A1,A2 = map(int,readline().split())
B1,B2 = map(int,readline().split())
P = (A1 - B1) * T1
Q = (A2 - B2) * T2
if P > 0:
P *= -1
Q *= -1
if P + Q < 0:
print(0)
elif P + Q == 0:
print("infinity")
else:
S = (-P) // (P + Q)
T = (-P) % (P + Q)
if T != 0:
print(S * 2 + 1)
else:
print(S * 2)
| 1 | 132,010,934,896,418 | null | 269 | 269 |
a = int(input())
n = 1
while True:
if a*n % 360 == 0:
break
else:
n += 1
print(n)
|
N = int(input())
X = [int(x) for x in list(input().split())]
max_x = max(X)
min_x = min(X)
d = max_x - min_x
middle = (d//2)
P = middle + min_x
ans = 0
for i in range(N):
ans += (max_x-X[i])**2
for i in range(d):
n_ans = 0
P = min_x + i
for j in range(N):
n_ans += (P-X[j])**2
if (n_ans < ans):
ans = n_ans
print(int(ans))
| 0 | null | 39,004,397,674,752 | 125 | 213 |
S = input()
l = len(S) // 2
former = S[:l]
latter = S[l+1:]
print("Yes" if S == S[::-1] and former == former[::-1] and latter == latter[::-1] else "No")
|
N=int(input())
print(sum((N-1)//a for a in range(1,N+1)))
| 0 | null | 24,279,605,580,790 | 190 | 73 |
# 27
N, A, B = map(int, input().split(' '))
ans = 0
if (A + B) != 0:
taple = divmod(N, A + B)
ans = taple[0] * A
if B == 0: ans = N
elif taple[1] > A: ans += A
else: ans += taple[1]
print(ans)
|
s = input()
st = []
leftn = 0
def pushv(s, x):
tmp = s.pop()
tmpsum = 0
while tmp[0] != 'left':
tmpsum += tmp[1]
tmp = s.pop()
else:
tmpsum += x - tmp[1]
s.append(('v', tmpsum))
for x in range(len(s)):
if s[x] == '\\':
st.append(('left', x))
leftn += 1
elif s[x] == '/':
if leftn != 0:
pushv(st, x)
leftn -= 1
st = [x[1] for x in st if x[0] == 'v']
if len(st) != 0:
print(sum(st))
print(len(st), ' '.join([str(x) for x in st]))
else:
print(0)
print(0)
| 0 | null | 27,963,556,440,480 | 202 | 21 |
# ΣnCiが高速に計算できればいいがNがでかい -> なんかΣncrでググったら高速化できるらしい?
# なんかi=0 -> i=nで2^nになるらしい。これは繰り返し二乗法でいけそう
# 最終的にΣnCi(i=1, i<=n) - nCa - nCaができればいい
# なぜか手持ちのライブラリがことごとくダメ
n, a, b = map(int, input().split())
mod = 10**9 + 7
def rep(i, n):
if n == 0:
return 1
if n % 2 == 0:
tmp = rep(i, n // 2) % mod
return tmp * tmp % mod
else:
return i * rep(i, n - 1) % mod
# なぜかうまくいかない
# def ncr(n, r):
# res = 1
# for i in range(1, r + 1):
# res = res * (n - i + 1) // i
# res %= mod
# for i in range(2, r + 1):
# res *= rep(i, mod - 2)
# res %= mod
# return res
# なぜかうまくいかない
# def cmb(n, r, mod):
# if (r < 0 or r > n):
# return 0
# g1 = [1, 1] # 元テーブル
# g2 = [1, 1] #逆元テーブル
# inverse = [0, 1] #逆元テーブル計算用テーブル
# N = 10**6 # なんでだろうね
# 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)
# return g1[n] * g2[r] * g2[n - r] % mod
# なぜかうまくいく
def nCrMod(n, r, p):
ret = 1
# 分子
for i in range(n - r + 1, n + 1):
ret *= i
ret %= p
# 分母
for i in range(2, r + 1):
# ret //= i なんかこれがおかしい（なんでだろうね）
ret *= rep(i, p - 2) # なぜかここでやらないと駄目だった
ret %= p
# ret = repMod(ret, p - 2, p) # なぜかここでやると駄目だった
return ret % p
ans = (rep(2, n) - 1 - nCrMod(n, a, mod) - nCrMod(n, b, mod)) % mod # なぜかうまくいく
# ans = (rep(2, n) - 1 - ncr(n, a) - ncr(n, b)) % mod なぜかうまくいかない
# ans = (rep(2, n) - 1 - cmb(n, a, mod) - cmb(n, b, mod)) % mod なぜかうまくいかない
while ans < 0:
ans += mod
print(ans)
|
n=int(input())
dic={}
a=[]
b=[]
for i in range(n):
tmp1,tmp2=input().split()
a.append(tmp1)
b.append(tmp2)
for i in range(n):
if a[i]=='insert':
dic[b[i]]=1
else:
if b[i] in dic:
print("yes")
else:
print("no")
| 0 | null | 33,327,981,121,930 | 214 | 23 |
import sys, re
from collections import deque, defaultdict, Counter
from math import ceil, sqrt, hypot, factorial, pi, sin, cos, tan, asin, acos, atan, radians, degrees, log2, gcd
from itertools import accumulate, permutations, combinations, combinations_with_replacement, product, groupby
from operator import itemgetter, mul
from copy import deepcopy
from string import ascii_lowercase, ascii_uppercase, digits
from bisect import bisect, bisect_left, insort, insort_left
from heapq import heappush, heappop
from functools import reduce
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(str, input().split()))
def ZIP(n): return zip(*(MAP() for _ in range(n)))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
mod = 10 ** 9 + 7
#import numpy as np
from decimal import *
K = INT()
q = deque(list(range(1, 10)))
for i in range(K):
n = q.popleft()
r = n%10
if r != 0:
q.append(10*n + r-1)
q.append(10*n + r)
if r != 9:
q.append(10*n + r+1)
print(n)
|
from itertools import accumulate
N, *A = map(int, open(0).read().split())
A_acc = list(accumulate(A, initial=0))
min_diff = float("inf")
for i in range(1, N):
left, right = A_acc[i], A_acc[N] - A_acc[i]
min_diff = min(min_diff, abs(right - left))
print(min_diff)
| 0 | null | 91,042,830,609,508 | 181 | 276 |
S = input()
N = len(S)
S1 = S[:(N - 1) // 2]
S2 = S[(N + 3) // 2 - 1:]
def check(s):
#print(s)
i = 0
j = len(s) - 1
while j > i:
if s[j] != s[i]:
return False
j -= 1
i += 1
return True
if check(S) and check(S1) and check(S2):
print("Yes")
else:
print("No")
|
x,y=map(int,input().split())
d={3:100000,2:200000,1:300000}
r=0
if x<=3:
r+=d[x]
if y<=3:
r+=d[y]
if x+y==2:
r+=400000
print(r)
| 0 | null | 93,776,507,081,492 | 190 | 275 |
def solve():
num_lines = int(raw_input())
s = set()
for i in xrange(num_lines):
command, target = raw_input().split(" ")
if command[0] == "i":# insert
s.add(target)
continue
if target in s:
print "yes"
else:
print "no"
if __name__ == "__main__":
solve()
|
dict = {}
def insert(word):
global dict
dict[word] = 0
def find(word):
global dict
if word in dict:
print('yes')
else:
print('no')
def main():
N = int(input())
order = [list(input().split()) for _ in range(N)]
for i in range(N):
if order[i][0] == 'insert':
insert(order[i][1])
elif order[i][0] == 'find':
find(order[i][1])
main()
| 1 | 74,364,225,900 | null | 23 | 23 |
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():
H, A = map(int, read().split())
print((H + A - 1) // A)
return
if __name__ == '__main__':
main()
|
H, A = map(int, input().split())
ans = -(-H // A)
print(ans)
| 1 | 76,825,323,827,388 | null | 225 | 225 |
import math
N = int(input())
a = 0
for i in range(1, int(math.sqrt(N) // 1) + 1):
a = max(a, math.gcd(i, N))
print(a + N // a - 2)
|
import sys
from collections import deque
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
n, d, a = map(int, input().split())
XH = sorted([list(map(int, input().split())) for _ in range(n)])
res = 0
tt_dmg = 0
que = deque()
for x, h in XH:
while que and que[0][1] < x:
dmg, rng = que.popleft()
tt_dmg -= dmg
if tt_dmg < h:
h -= tt_dmg
cnt = (h + a - 1) // a
res += cnt
dmg = cnt * a
tt_dmg += dmg
que.append((dmg, x + d * 2))
print(res)
if __name__ == '__main__':
resolve()
| 0 | null | 121,784,066,192,530 | 288 | 230 |
N,A,B = map(int,input().split())
if (B-A)%2 == 0:
print((B-A)//2)
else:
s = (A-1) + (B-A+1)//2
ss = (N-B) + (B-A+1)//2
print(min(s,ss))
|
# coding: utf-8
n = int(input())
A = list(map(int, input().split()))
mini = 1
c = 0
for i in range(n):
mini = i
for j in range(i, n):
if A[j] < A[mini]:
mini = j
A[i], A[mini] = A[mini], A[i]
if mini != i:
c += 1
print(" ".join(map(str, A)))
print(c)
| 0 | null | 54,471,070,195,278 | 253 | 15 |
import numpy as np
N,K=map(int, input().split())
A=np.array(list(map(int, input().split())))
for i in range(K,N):
if A[i]/A[i-K]>1:
print('Yes')
else:
print('No')
|
def marge_ponds(lx, area_of_pond):
global ponds
if ponds:
lp = ponds.pop()
if lp[0] > lx:
return marge_ponds(lx, area_of_pond + lp[1])
else:
ponds.append(lp)
return area_of_pond
terrains = input().strip()
x, last_x, ponds = 0, [], []
for terrain in terrains:
if terrain == '\\':
last_x.append(x)
elif terrain == '/':
if last_x:
lx = last_x.pop()
area_of_pond = marge_ponds(lx, x - lx)
ponds.append((lx, area_of_pond))
x += 1
print(sum(pond[1] for pond in ponds))
ponds.insert(0, (0, len(ponds)))
print(' '.join(map(str, [pond[1] for pond in ponds])))
| 0 | null | 3,543,976,450,848 | 102 | 21 |
N=int(input())
se=set(input() for _ in range(N))
print(len(se))
|
lx = [int(w) for w in input().split()]
for i, x in enumerate(lx):
if x == 0:
print(i+1)
exit()
| 0 | null | 21,821,022,879,990 | 165 | 126 |
# 多次元リストの sort に使える
from operator import itemgetter
n = int(input())
x = [0] * n
l = [0] * n
for i in range(n):
x[i], l[i] = map(int, input().split())
st = sorted([(x[i] - l[i], x[i] + l[i]) for i in range(n)], key = itemgetter(1))
ans = 0
# 最後に選んだ仕事の終了時間
last = - 10 ** 10
for i in range(n):
if last <= st[i][0]:
ans += 1
last = st[i][1]
print(ans)
|
N = int(input())
R = sorted([list(map(int, input().split())) for i in range(N)])
T = []
for i in range(N):
T.append([R[i][0] + R[i][1], R[i][0] - R[i][1]])
T.sort(reverse=True)
while len(T) - 1 > 0:
t = T.pop()
i = 1
while len(T) and t[0] > T[-1][1]:
N -= 1
i += 1
T.pop()
print(N)
| 1 | 89,962,703,291,000 | null | 237 | 237 |
while 1:
m,f,r=map(int,input().split());s=m+f
if m==f==r==-1:break
if m==-1 or f==-1 or s<30:print('F')
elif s>79:print('A')
elif s>64:print('B')
elif s>49 or r>49:print('C')
else:print('D')
|
import sys
#DEBUG=True
DEBUG=False
if DEBUG:
f=open("202007_2nd/B_input.txt")
else:
f=sys.stdin
N=int(f.readline().strip())
A=list(map(int,f.readline().split()))
ans=0
for _ in range(N):
ans=ans+1 if (_+1)%2 and (A[_]%2) else ans
print(ans)
f.close()
| 0 | null | 4,554,290,126,848 | 57 | 105 |
import math
a,b,c,d = map(int,input().split())
print('Yes' if math.ceil(c/b) <= math.ceil(a/d) else 'No')
|
N, A, B = [int(_) for _ in input().split()]
MOD = 10 ** 9 + 7
var1 = pow(2, N, MOD) - 1
def f(x):
f1 = 1
for i in range(N - x + 1, N + 1):
f1 = (f1 * i) % MOD
# 逆元
f2 = 1
for i in range(2, x + 1):
f2 = (f2*i)%MOD
f2 = pow(f2, MOD - 2, MOD)
return (f1 * f2) % MOD
ans = var1 - f(A) - f(B)
print(ans % MOD)
| 0 | null | 47,806,331,504,188 | 164 | 214 |
MOD = 10 ** 9 + 7
N, K = map(int, input().split())
lst = [0] * (K + 1)
ans = 0
for i in range(K, 0, -1):
tmp = K // i
tmp = pow(tmp, N, MOD)
for j in range(2 * i, K + 1, i):
tmp -= lst[j]
ans += (i * tmp)
ans %= MOD
lst[i] = tmp
print (ans)
|
n, k = map(int, input().split())
a = list(map(int, input().split()))
inf = 1
sup = max(a)
while inf < sup:
x = (inf + sup) // 2
cut = 0
for a_i in a:
cut += (a_i - 1) // x
if cut <= k:
sup = x
else:
inf = x + 1
print(sup)
| 0 | null | 21,556,478,141,280 | 176 | 99 |
n = int(input())
slimes = input()
fusion = [slimes[0]]
cnt = 0
for i in range(1,n):
if fusion[cnt] != slimes[i]:
fusion.append(slimes[i])
cnt += 1
print(cnt+1)
|
n, k = [int(i) for i in input().split()]
cnt = 0
if n == 0:
print(1)
exit()
while n != 0:
n = n // k
cnt += 1
print(cnt)
| 0 | null | 116,985,355,862,880 | 293 | 212 |
n,k=map(int,input().split())
a=sorted(list(map(int,input().split())))
mod=10**9+7
fac=[1]*n
finv=[1]*n
inv=[0]*n
inv[1]=1
for i in range(2,n):
fac[i]=fac[i-1]*i%mod
inv[i]=mod-inv[mod%i]*(mod//i)%mod
finv[i]=finv[i-1]*inv[i]%mod
def comb(n,k):
if n<k:
return 0
if n<0 or k<0:
return 0
return fac[n]*(finv[k]*finv[n-k]%mod)%mod
ans=0
for i in range(n-k+1):
ans-=a[i]*comb(n-i-1,k-1)%mod
ans%=mod
a=a[::-1]
for i in range(n-k+1):
ans+=a[i]*comb(n-i-1,k-1)%mod
ans%=mod
print(ans%mod)
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
?????????????????????Merge Sort??????????????±??????????????\??????????????¢?????´???????????§???
?¬?????????????????£????????????¨?????§????????????
merge(A, left, mid, right)
n1 = mid - left;
n2 = right - mid;
L[0...n1], R[0...n2] ?????????
for i = 0 to n1-1
L[i] = A[left + i]
for i = 0 to n2-1
R[i] = A[mid + i]
L[n1] = INFTY
R[n2] = INFTY
i = 0
j = 0
for k = left to right-1
if L[i] <= R[j]
A[k] = L[i]
i = i + 1
else
A[k] = R[j]
j = j + 1
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 ????????´??°???????????°??? S ????????????????????????????????£???????????????????????§
???????????´?????????????????°????????????????????????????????????
?????????merge???????????????????????°????????°?????±????????????????????????
"""
MAX = 1000000001
def merge(A, left, mid, right, cnt):
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(MAX)
R.append(MAX)
# print("l:{} m:{} r:{} cnt:{} n1:{} n2:{}".format(left,mid,right,cnt,n1,n2))
# print("left:{} right:{}".format(L,R))
i = 0
j = 0
for k in range(left, right):
# print("k:{} i:{} j:{}".format(k,i,j))
if L[i] <= R[j]:
A[k] = L[i]
i = i + 1
else:
A[k] = R[j]
j = j + 1
cnt += 1
return cnt
def mergeSort(A, left, right, cnt):
if left + 1 < right:
mid = int((left + right) / 2)
cnt = mergeSort(A, left, mid, cnt)
cnt = mergeSort(A, mid, right, cnt)
cnt = merge(A, left, mid, right, cnt)
return cnt
def main():
""" ????????? """
n = int(input())
S = list(map(int,input().split()))
cnt = mergeSort(S, 0, n, 0)
print(" ".join(map(str,S)))
print(cnt)
if __name__ == '__main__':
main()
| 0 | null | 48,014,237,543,658 | 242 | 26 |
s = list(input())
if s[2] == s[3]:
if s[4] == s[5]:
print("Yes")
else:
print("No")
exit
else:
print("No")
exit
|
s = input()
n = []
for i in s:
n.append(i)
if n[2] == n[3] and n[4] == n[5]:
print('Yes')
else:
print('No')
| 1 | 42,174,974,735,420 | null | 184 | 184 |
n = int(input())
A = []
B = []
for i in range(n):
a, b = map(int, input().split())
z = a + b
w = a - b
A.append(z)
B.append(w)
P = abs(max(A) - min(A))
Q = abs(max(B) - min(B))
print(max(P, Q))
|
n = int(input())
xs = []
ys = []
for _ in range(n):
x, y = map(int, input().split())
xs.append(x + y)
ys.append(x - y)
xs.sort()
ys.sort()
ans = max(xs[-1] - xs[0], ys[-1] - ys[0])
print(ans)
| 1 | 3,444,796,370,030 | null | 80 | 80 |
from collections import defaultdict
N = int(input())
A = list(map(int, input().split()))
A = sorted(A)
divisible = [False for _ in range(int(1e6+1))]
cnt = defaultdict(int)
for a in A:
cnt[a] += 1
if divisible[a] == False and cnt[a] <= 1:
for i in range(a+a, len(divisible), a):
divisible[i] = True
ans = 0
for a in A:
if divisible[a] is False and cnt[a] <= 1:
ans += 1
print(ans)
|
# AtCoder Beginner Contest 146
# E - Rem of Sum is Num
# https://atcoder.jp/contests/abc146/tasks/abc146_e
from collections import defaultdict
N, K = map(int, input().split())
*A, = map(int, input().split())
A = [0]+A
d = []
c = defaultdict(int)
x = 0
ans = 0
for i, a in enumerate(A):
x += a - 1
x %= K
d.append(x)
if i-K >= 0:
c[d[i-K]] -= 1
ans += c[x]
c[x] += 1
print(ans)
| 0 | null | 75,883,126,223,362 | 129 | 273 |
X = int(input())
r = X%100
x5 = r//5
r5 = r%5
if r5:
x5+=1
if x5*100 <= X:
print(1)
else:
print(0)
|
#from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations,permutations,accumulate # (string,3) 3回
#from collections import deque
from collections import deque,defaultdict,Counter
import decimal
import re
#import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
#mod = 9982443453
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
dp = [False] * 100001
dp[0] = True
food = [100,101,102,103,104,105]
for i in range(1,100001):
for j in range(len(food)):
if i - food[j] >= 0:
dp[i] |= dp[i - food[j]]
X = I()
print('1' if dp[X] else '0')
| 1 | 127,190,522,651,708 | null | 266 | 266 |
M = 1000000007
n = int(input())
a = list(map(int,input().split()))
S = [0]
for i in range(n):
S.append((S[-1]+a[i])%M)
sum = 0
for i in range(n-1):
sum += (a[i]*(S[n]-S[i+1]))%M
print(sum%M)
|
n = int(input())
s = [input() for _ in range(n)]
l = 0
r = 0
m = []
def fin():
print("No")
exit()
for word in s:
stack = []
for e in word:
if stack and stack[-1] == "(" and e == ")":
stack.pop()
else:
stack.append(e)
if stack:
if stack[0] == ")" and stack[-1] == "(":
m.append(stack)
elif stack[0] == ")":
r += len(stack)
else:
l += len(stack)
ml = []
mm = 0
mr = []
for word in m:
ll = word.index("(")
rr = len(word) - ll
if ll > rr:
mr.append([ll, rr])
elif ll < rr:
ml.append([ll, rr])
else:
mm = max(mm, ll)
ml.sort()
for ll, rr in ml:
l -= ll
if l < 0:
fin()
l += rr
mr.sort(key=lambda x: x[1])
for ll, rr in mr:
r -= rr
if r < 0:
fin()
r += ll
if mm <= l or mm <= r:
if l == r:
print("Yes")
exit()
fin()
| 0 | null | 13,851,718,712,360 | 83 | 152 |
n = int(input())
d = []
z = 0
for i in range(n):
d1, d2 = map(int, input().split())
z = z+1 if d1==d2 else 0
d.append(z)
ans = 'Yes' if max(d)>=3 else 'No'
print(ans)
|
import collections
MOD = 998244353
def main():
N = int(input())
D = [int(_) for _ in input().split()]
Dmax = max(D)
cc = collections.Counter(D)
if D[0] != 0: return 0
if cc[0] != 1: return 0
for i in range(Dmax+1):
if cc[i] == 0: return 0
output = 1
for i in sorted(cc.keys()):
if i in (0, 1): continue
output *= pow(cc[i-1], cc[i], MOD)
output %= MOD
return output
if __name__ == '__main__':
print(main())
| 0 | null | 78,547,961,987,430 | 72 | 284 |
s = input()
t = input()
def f(k):
c = 0
for i in range(len(t)):
if s[k + i] == t[i]:
c += 1
return c
maxi = f(0)
for i in range(len(s) - len(t) + 1):
if f(i) > maxi:
maxi = f(i)
print(len(t) - maxi)
|
n, m, k = map(int, input().split())
class UnionFind():
def __init__(self, n):
self.n = n
self.par = [-1 for i in range(self.n)]
def find(self, x):
if self.par[x] < 0:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def unite(self, x, y):
p = self.find(x)
q = self.find(y)
if p == q:
return None
if p > q:
p, q = q, p
self.par[p] += self.par[q]
self.par[q] = p
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.par[self.find(x)]
UF = UnionFind(n)
f_or_b = [0] * n
for i in range(m):
a, b = map(int, input().split())
UF.unite(a - 1, b - 1)
f_or_b[a - 1] += 1
f_or_b[b - 1] += 1
for i in range(k):
c, d = map(int, input().split())
if UF.same(c - 1, d - 1):
f_or_b[c - 1] += 1
f_or_b[d - 1] += 1
for i in range(n):
print(UF.size(i) - f_or_b[i] - 1, end=" ")
| 0 | null | 32,584,237,887,740 | 82 | 209 |
N, M, K = map(int, input().split())
ans = 0
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 998244353
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
for i in range(K+1):
res_i = (M * pow(M-1, N-i-1, p)) % p
res_i = (res_i * cmb(N-1, i, p)) % p
ans = (ans + res_i) % p
print(ans)
|
S=list(input())
N=len(S)
x=0
for i in range(int((N-1)/2)):
if S[i]!=S[-(i+1)]:
print("No")
break
elif i==int((N-1)/2)-1:
x+=1
import math
if x==1:
S_l=S[:int((N-1)/2)]
for i in range(int(math.ceil(len(S_l)/2))):
if S_l[i]!=S_l[-(i+1)]:
print("No")
break
elif i==int(math.ceil(len(S_l)/2))-1:
x+=1
if x==2:
S_m=S[int((N+3)/2)-1:N]
for i in range(int(math.ceil(len(S_m)/2))):
if S_m[i]!=S_m[-(i+1)]:
print("No")
break
elif i==int(math.ceil(len(S_m)/2))-1:
print("Yes")
| 0 | null | 34,833,935,978,172 | 151 | 190 |
n, m = map(int, raw_input().split())
a, b, result = list(), list(), list()
for _ in range(n):
a.append(map(int, raw_input().split()))
for _ in range(m):
b.append(int(raw_input()))
for i in range(n):
temp = 0
for j in range(m):
temp += a[i][j] * b[j]
result.append(temp)
for i in result:
print(i)
|
n, m = map(int, input().split())
a = [[] for i in range(n)]
for i in range(n):
a[i] = list(map(int, input().split()))
b = [0] * m
for i in range(m):
b[i] = int(input())
for ai in a:
cnt = 0
for j, bj in enumerate(b):
cnt += ai[j] * bj
print(cnt)
| 1 | 1,162,958,408,990 | null | 56 | 56 |
# http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=ALDS1_10_A&lang=ja
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
def main():
n = int(readline())
dp = [0] * (n+1)
dp[0] = 1
dp[1] = 1
for i in range(2,n+1):
dp[i] = dp[i-1] + dp[i-2]
print(dp[n])
if __name__ == "__main__":
main()
|
def fib(n):
if n==0 or n==1:
return 1
else:
if f[n]!=0:
return f[n]
else:
f[n]=fib(n-1)+fib(n-2)
return f[n]
f=[0]*45
n=int(input())
print(fib(n))
| 1 | 1,959,304,088 | null | 7 | 7 |
N,K = map(int,input().split())
have = [0] * N
for i in range(K):
d = int(input())
As = list(map(int,input().split()))
for j in range(d):
have[As[j]-1] += 1
ans = 0
for i in range(N):
if have[i] == 0:
ans += 1
print(ans)
|
def resolve():
N, K = list(map(int, input().split()))
snacks = [0 for _ in range(N)]
for i in range(K):
d = int(input())
A = list(map(int, input().split()))
for a in A:
snacks[a-1] += 1
cnt = 0
for s in snacks:
if s == 0:
cnt += 1
print(cnt)
if '__main__' == __name__:
resolve()
| 1 | 24,644,784,617,630 | null | 154 | 154 |
n = int(input())
a = list(map(int,input().split()))
p = 0
for i in range(n)[::2]:
if a[i] % 2 != 0:
p += 1
print(p)
|
N = int(input())
an = x = [int(i) for i in input().split()]
count = 0
for i in range(len(an)):
if ((i + 1) % 2 == 0):
continue
if (an[i] % 2 != 0):
count = count + 1
print(count)
| 1 | 7,789,448,797,140 | null | 105 | 105 |
from collections import deque
n = int(input())
queue = deque([[1],[2],[3],[4],[5],[6],[7],[8],[9]]) # 初期化_ここでは正の一桁整数として'1'～'9'を設置
ptns = [] # パターン候補の器_初期化
while queue: # queueが空になるまでループ
tmp = queue.popleft() # パターンの候補を popleft
if len(ptns) < n: # ptnsの要素数が'n'個未満ならば append
ptns.append(tmp)
else:
break
# 以下、tmpに各々tmp[-1]-1、tmp[-1]、tmp[-1]+1をappendするための条件
if tmp[-1] != 0:
queue.append(tmp + [tmp[-1] -1])
queue.append(tmp + [tmp[-1]])
if tmp[-1] != 9:
queue.append(tmp + [tmp[-1] +1])
# リスト = map(str, リスト) ← intのリストからstrのmapオブジェクトへ変換
print(''.join(map(str, ptns[-1])))
|
import sys, bisect, math, itertools, string, queue, copy
import numpy as np
import scipy
from collections import Counter,defaultdict,deque
from itertools import permutations, combinations
from heapq import heappop, heappush
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
k = inp()
runrun = [["1","2","3","4","5","6","7","8","9"]]
runrun_int = []
for j in range(2,11):
tmp = []
for i in range(len(runrun[j - 2])):
if runrun[j-2][i][j-2] == "0":
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) + 1))
elif runrun[j-2][i][j-2] in ["1","2","3","4","5","6","7","8"]:
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) - 1))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) + 1))
elif runrun[j-2][i][j-2] == "9":
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2]) - 1))
tmp.append(runrun[j-2][i] + str(int(runrun[j-2][i][j-2])))
runrun.append(tmp)
ans = []
for i in range(len(runrun)):
for j in range(len(runrun[i])):
ans.append(int(runrun[i][j]))
ans.sort()
print(ans[k - 1])
| 1 | 39,886,652,914,590 | null | 181 | 181 |
s = input()
count = 0
for i in range(len(s)):
if s[i] == "R":
count += 1
if i + 1 >= 3:
break
elif s[i+1] == "S":
break
print(count)
|
def main():
n, k = map(int, input().split())
a = 1
b = 0
while True:
a *= k
if a > n:
break
b += 1
ans = b + 1
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 34,604,016,931,800 | 90 | 212 |
input()
line = input().split()
line.reverse()
print(' '.join(line))
|
#!/usr/bin/env python3
import sys
import numpy as np
def input():
return sys.stdin.readline().rstrip()
def main():
# n, k = map(int, sys.stdin.buffer.readline().split())
n, k = map(int, input().split())
# warps = list(map(int, sys.stdin.buffer.readline().split()))
warps = list(map(int, input().split()))
warps = [0] + warps
warps = np.array(warps, dtype=int)
dp = np.zeros((k.bit_length() + 1, n + 1), dtype=int)
dp[0, :] = warps
for h in range(1, len(dp)):
dp[h] = dp[h - 1][dp[h - 1]]
node = 1
# for i in reversed(range(k.bit_length())):
for i in range(k.bit_length(), -1, -1):
if k >> i & 1:
node = dp[i][node]
print(node)
main()
| 0 | null | 11,815,396,372,340 | 53 | 150 |
#coding:utf-8
H,W=map(int,input().split())
while not(H==0 and W==0):
for i in range(0,H):
for j in range(0,W):
if i==0 or j==0 or i==H-1 or j==W-1:
print("#",end="")
else:
print(".",end="")
print("")
print("")
H,W=map(int,input().split())
|
S = input()
length = len(S)
print("x"*length)
| 0 | null | 36,876,462,571,736 | 50 | 221 |
n = int(input())
A = list(map(int, input().split()))
l = []
for a in A:
if a % 2 == 0:
l.append(a)
if all([i % 3 ==0 or i % 5 ==0 for i in l]):
print('APPROVED')
else:
print('DENIED')
|
s = input()
p = input()
found = False
for i in range(len(s)):
ring = s[i:] + s[:i]
if p in ring:
print('Yes')
found = True
break
if not found:
print('No')
| 0 | null | 35,227,878,048,900 | 217 | 64 |
n,m,l = map(int,input().split())
g = [[float('inf')]*n for _ in range(n)]
for _ in range(m):
a,b,c = map(int,input().split())
a-=1
b-=1
g[a][b] = c
g[b][a] = c
for k in range(n):
for i in range(n):
for j in range(n):
g[i][j] = min(g[i][j],g[i][k] + g[k][j])
h = [[float('inf')]*n for _ in range(n)]
for i in range(n):
for j in range(n):
if g[i][j]<=l:
h[i][j] = 1
for k in range(n):
for i in range(n):
for j in range(n):
h[i][j] = min(h[i][j],h[i][k] + h[k][j])
Q = int(input())
for _ in range(Q):
s,t = map(int,input().split())
s -=1
t-=1
if h[s][t] ==float('inf'):
print(-1)
else:
print(h[s][t]-1)
|
def resolve():
from scipy.sparse.csgraph import floyd_warshall
import numpy as np
import sys
input = sys.stdin.readline
n, m, l = map(int, input().split())
inf = 10 ** 20
ar = [[0] * n for _ in range(n)]
for _ in range(m):
a, b, c = map(int, input().split())
ar[a - 1][b - 1] = c
ar[b - 1][a - 1] = c
x = floyd_warshall(ar)
br = [[0] * n for _ in range(n)]
for i in range(n):
for j in range(i + 1, n):
if x[i, j] <= l:
br[i][j] = 1
br[j][i] = 1
y = floyd_warshall(br)
q = int(input())
for _ in range(q):
s, t = map(int, input().split())
p = y[s - 1, t - 1]
print(int(p) - 1 if p < inf else -1)
if __name__ == "__main__":
resolve()
| 1 | 173,482,542,718,650 | null | 295 | 295 |
s= input()
x = "x" * len(s)
print(x)
|
print('x' * len(input()))
| 1 | 73,374,070,397,472 | null | 221 | 221 |
n = int(input())
arr = list(map(int,input().split()))
addarr = [i+1+arr[i] for i in range(n)]
diffarr = [i+1-arr[i] for i in range(n)]
from collections import Counter
cnt = Counter([addarr[0]])
ans = 0
for i in range(1,n):
tmp = diffarr[i]
ans += cnt[tmp]
cnt.update([addarr[i]])
print(ans)
|
import collections
cnt = collections.defaultdict(int)
N = int(input())
ans = 0
height = list(map(int, input().split()))
for n in range(1, N+1):
ans += cnt[n - height[n-1]]
cnt[n+height[n-1]] += 1
print(ans)
| 1 | 26,045,825,558,620 | null | 157 | 157 |
x, n = map(int, input().split())
p = list(map(int,input().split()))
if x not in p:
y = x
else:
i = 1
y = x
while y == x:
if x - i not in p:
y = x - i
elif x + i not in p:
y = x + i
i += 1
print(y)
|
s = input()
p = input()
s += s
if s.count(p):
print("Yes")
else:
print("No")
| 0 | null | 7,949,916,718,012 | 128 | 64 |
import Queue
n,q=map(int,raw_input().strip().split())
name=[]
time=[]
qu=Queue.Queue()
class task:
def __init__(self,name,time):
self.name=name
self.time=time
self.total=0
for i in xrange(n):
inp=raw_input().strip().split()
qu.put(task(inp[0],int(inp[1])))
curtime=0
while not qu.empty():
tmp=qu.get()
if tmp.time>q:
tmp.time-=q
curtime+=q
qu.put(tmp)
else:
curtime+=tmp.time
ed='' if qu.qsize()==0 else '\n'
print tmp.name,curtime
# print curtime
|
# coding: utf-8
# Here your code !
import collections
p,q=map(int,input().split())
count =0
deq = collections.deque()
finished=[]
while 1:
try:
deq.append(input().split())
except EOFError:
break
while deq:
d = deq.popleft()
d[1]=int(d[1])
if d[1]<=q:
count+=d[1]
d[1]=count
finished.append(map(str,d))
elif d[1]>q:
d[1]-=q
count+=q
deq.append(d)
for f in finished:
print(" ".join(f))
| 1 | 42,952,058,112 | null | 19 | 19 |
s = str(input())
p = str(input())
s = s + s
if p in s:
print("Yes")
else:
print("No")
|
import sys
s1=raw_input()
s2=raw_input()
def check(s1_top, s1, s2):
for s2_idx, c in enumerate(s2):
if c != s1[(s1_top + s2_idx) % len(s1)]:
return False
return True
l=[]
for i, c in enumerate(s1):
if c == s2[0]:
if check(i, s1, s2):
print "Yes"
sys.exit(0)
print "No"
| 1 | 1,769,766,154,520 | null | 64 | 64 |
def main():
N = input()
L = len(N)
K = int(input())
dp = [[0 for _ in range(L + 1)] for _ in range(K + 1)]
dpp = [[0 for _ in range(L + 1)] for _ in range(K + 1)]
dpp[0][0] = 1
for i in range(1, L + 1):
n = int(N[i - 1])
for k in range(K + 1):
# from dpp
kk = k + (1 if n > 0 else 0)
if kk <= K:
dpp[kk][i] = dpp[k][i - 1]
if n > 0:
dp[k][i] += dpp[k][i - 1]
if k + 1 <= K:
dp[k + 1][i] += (n - 1) * dpp[k][i - 1]
# from dp
dp[k][i] += dp[k][i - 1]
if k + 1 <= K:
dp[k + 1][i] += 9 * dp[k][i - 1]
print(dp[K][L] + dpp[K][L])
if __name__ == '__main__':
main()
|
N=int(input())
K=int(input())
string = str(N)
digits = len(string)
#dp[i][j][k]=と同じ桁数の整数で上からi桁目までで0でない数字がj個あるものの個数
#k=0: i桁目まで見てN未満が確定, k=1: 未確定
dp = [[[0]*2 for _ in range(K+1)] for __ in range(digits+1)]
#初期状態
dp[0][0][1] = 1
for i in range(digits):
d = int(string[i])
ni = i+1
for j in range(K+1):
for k in range(2):
for nd in range(10):
nk = 1 if k == 1 and nd == d else 0
if k == 1 and nd > d: break
nj = j + (1 if nd != 0 else 0)
if nj > K: continue
dp[ni][nj][nk] += dp[i][j][k]
print(dp[digits][K][0] + dp[digits][K][1])
| 1 | 75,862,836,569,542 | null | 224 | 224 |
N=int(input())
S=list(input() for _ in range(N))
from collections import Counter
cnt=Counter(S)
max_cnt=cnt.most_common()[0][1]
ans=[name for name, cnt in cnt.items() if cnt==max_cnt]
print(*sorted(ans), sep="\n")
|
S,W = map(int,input().split())
print('safe' if S > W else 'unsafe')
| 0 | null | 49,622,571,543,288 | 218 | 163 |
N=int(input());M=10**9+7
print((pow(10,N,M)-2*pow(9,N,M)+pow(8,N,M))%M)
|
A, B, N = map(int, input().split())
if(N >= B):
x = B - 1
else:
x = N
'''
print(x)
'''
print((A * x) // B - A * (x//B))
| 0 | null | 15,524,509,286,998 | 78 | 161 |
N = int(input())
A = list(map(int,input().split()))
buka = [0]*N
for p in range(N-1):
buka[A[p] -1] += 1
for q in range(N):
print(buka[q])
|
n=int(input())
alist=list(map(int,input().split()))
counter = 0
for i , a in enumerate(alist):
if (i+1)%2 == 1 and a % 2 == 1:
counter += 1
print(counter)
| 0 | null | 20,182,003,878,708 | 169 | 105 |
n,k = map(int,input().split())
mod = 10**9 +7
sum1 = 0
for i in range(k,n+2):
sum1 +=(-i*(i-1)//2 + i*(2*n-i+1)//2+1)%mod
print(sum1%mod)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
def inp():
return int(input())
def inps():
return input().rstrip()
def inpl():
return list(map(int, input().split()))
def _debug(obj):
print(obj, file=sys.stderr)
# import decimal
# from decimal import Decimal
# decimal.getcontext().prec = 10
# from heapq import heappush, heappop, heapify
# import math
# from math import gcd
# import itertools as it
# import collections
# from collections import deque
# ---------------------------------------
mod = 10**9 +7
N, K = inpl()
ans = 0
for i in range(K, N + 2):
ans += (N + 1 - i) * i + 1
ans %= mod
print(ans)
| 1 | 32,903,990,089,198 | null | 170 | 170 |
from itertools import accumulate
N, K = map(int, input().split())
A = list(map(int, input().split()))
for k in range(min(50, K)):
B = [0]*N
for i in range(N):
B[max(0, i-A[i])] += 1
r = i+A[i]+1
if r < N:
B[r] -= 1
A = list(accumulate(B))
print(*A)
|
def main() :
s = input()
t = input()
if (t in s) :
print(0)
return
difference = 99999999
for offset in range(0,len(s) - len(t)+1):
s2 = s[offset:offset+len(t)]
diff = 0
for i in range(len(t)) :
if (s2[i] != t[i]) :
diff += 1
if (difference > diff) :
difference = diff
print(difference)
main()
| 0 | null | 9,612,433,826,922 | 132 | 82 |
S=input()
T=input()
N=len(S)
c=0
for i in range(N):
if S[i]!=T[i]:
c=c+1
print(c)
|
# -*- coding:utf-8 -*-
import sys
def allcation(truck, baggage, limit):
t = 1
cap = 0
for weight in baggage:
if weight <= limit:
if cap + weight <= limit:
cap += weight
else:
cap = weight
t += 1
if t > truck:
return False
else:
return False
return True
def bin_search(truck, baggage):
small = 0
big = 10000 * 100000
minimum = 0
while small < big:
mid = (small + big) >> 1
if allcation(truck, baggage, mid):
big = mid
minimum = mid
else:
small = mid + 1
return minimum
if __name__ == "__main__":
n = [int(val) for val in input().split()]
lst = [int(val) for val in sys.stdin.read().splitlines()]
print(bin_search(n[1], lst))
| 0 | null | 5,324,714,060,192 | 116 | 24 |
print('Yes') if int(input())>=30 else print('No')
|
N=int(input());S,T=map(str,input().split())
for i in range(N):print(S[i],end='');print(T[i],end='')
| 0 | null | 58,977,667,159,308 | 95 | 255 |
a,b = [int(x) for x in input().split()]
def gcd(x,y):
if y == 0:
return x
return gcd(y,x%y)
print(a*b//gcd(a,b))
|
W, H, x, y, r = map(int, input().split())
if r <= x <= W - r and r <= y <= H - r:
print("Yes")
else:
print("No")
| 0 | null | 56,789,074,605,440 | 256 | 41 |
a, b = map(int,input().split())
print(sorted([str(a)*b,str(b)*a])[0])
|
def resolve():
rate = int(input())
if rate < 600:
print('8')
elif rate < 800:
print('7')
elif rate < 1000:
print('6')
elif rate < 1200:
print('5')
elif rate < 1400:
print('4')
elif rate < 1600:
print('3')
elif rate < 1800:
print('2')
else:
print('1')
if __name__ == "__main__":
resolve()
| 0 | null | 45,477,733,176,092 | 232 | 100 |
x = int(input())
if x == 0:
print(1)
else:
print(0)
|
if int(input())==1:print(0)
else:print(1)
| 1 | 2,917,331,372,098 | null | 76 | 76 |
n = input().split()
a = int(n[0])
b = int(n[1])
c = int(n[2])
counta = 0
if a == b:
if c % a == 0:
counta += 1
else:
for i in range(a,b+1):
if c % i == 0:
counta += 1
print(counta)
|
import math
a=int(input())
b=int(input())
x=int(input())
print(math.ceil(x/max(a,b)))
| 0 | null | 44,924,759,205,696 | 44 | 236 |
#!/usr/bin/env python3
YES = "Yes" # type: str
NO = "No" # type: str
def solve(A: int, B: int, C: int, D: int):
while True:
# 高橋
C -= B
if C <= 0:
return YES
# 青木
A -= D
if A <= 0:
return NO
def main():
A, B, C, D = map(int, input().split())
answer = solve(A, B, C, D)
print(answer)
if __name__ == "__main__":
main()
|
X = list(map(int,input().split()))
for i in [0,1]:
if X.count(X[i]) == 2:
print('Yes')
exit()
print('No')
| 0 | null | 49,051,896,928,030 | 164 | 216 |
a = 0
a += int(input())
a += int(input())
print(6 - a)
|
while True:
x,y = map(int,input().split())
if x == 0 and y == 0:
break
if x > y:
print(f"{y} {x}")
elif x <= y:
print(f"{x} {y}")
| 0 | null | 55,524,312,136,650 | 254 | 43 |
import math
n = int(input())
if n==0:
a=100000
else:
c = int(100)
for i in range(n):
num = c*1.05
c = math.ceil(num)
a = c*1000
print(a)
|
N, K = list(map(int, input().rstrip().split()))
r = 0
while 0 < N:
r += 1
N = int(N / K)
print(r)
| 0 | null | 32,097,373,794,150 | 6 | 212 |
# A - Takahashikun, The Strider
x = int(input())
i = 1
while True:
if 360 * i % x == 0:
print(360 * i // x)
break
else:
i += 1
|
import math
n=input()
S=100000
for i in range(n):
S*=1.05
S=int( math.ceil(S/1000)*1000 )
print S
| 0 | null | 6,505,134,070,290 | 125 | 6 |
import sys
from bisect import bisect_right, bisect_left
from itertools import accumulate
sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7
def resolve():
def meguru_bisect(ok, ng):
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if is_ok(mid):
ok = mid
else:
ng = mid
return ok
def is_ok(x):
cnt = 0
for a in A:
t = x - a
idx = bisect_right(A, t)
cnt += n - idx
return cnt < m
n, m = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
ng, ok = 0, 10 ** 15 + 1
mth = meguru_bisect(ok, ng)
R = [0] + list(accumulate(A))
res = 0
cnt = 0
for a in A:
s = mth - a
left = bisect_left(A, s)
res += (n - left) * a + R[-1] - R[left]
cnt += n - left
print(res - mth * (cnt - m))
if __name__ == '__main__':
resolve()
|
from bisect import bisect_left
N, M = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
def doesOver(k):
cnt = 0
for a in A:
cnt += N - bisect_left(A, k - a)
return cnt >= M
overEq = 0
less = A[-1] * 2 + 100
while less - overEq > 1:
mid = (less + overEq) // 2
if doesOver(mid):
overEq = mid
else:
less = mid
accA = [0] * (N + 1)
for i in range(1, N + 1):
accA[i] = accA[i - 1] + A[i - 1]
ans = 0
cnt = 0
for a in A:
left = bisect_left(A, overEq - a)
ans += accA[N] - accA[left]
ans += (N - left) * a
cnt += N - left
ans -= (cnt - M) * overEq
print(ans)
| 1 | 108,114,643,128,260 | null | 252 | 252 |
n = int(input())
s = input()
A = list(map(int,s.split()))
flag = 1
cnt = 0
#####################################
for i in range(0,n):
minj = i
for j in range(i,n):
if A[j] < A[minj]:
minj = j
if(A[i] != A[minj]):
tmp = A[i]
A[i] = A[minj]
A[minj] = tmp
cnt += 1
#####################################
for k in range(0,len(A)-1):
print(A[k],end=" ")
print(A[len(A)-1])
print (cnt)
|
def main():
A, B = input().split()
A = int(A)
B100 = int(B[0] + B[2:])
print(A*B100//100)
if __name__ == "__main__":
main()
| 0 | null | 8,375,988,139,878 | 15 | 135 |
import collections
import sys
n,q = map(int,input().split())
data = [[i for i in input().split()]for i in range(n)]
time = 0
while data:
task = data[0]
del data[0]
if int(task[1]) <= q:
time += int(task[1])
print(task[0],time)
else:
time += q
task[1] = str(int(task[1]) - q)
data.append(task)
|
while True:
a = input()
b = a.split(' ')
b.sort(key=int)
if int(b[0]) == 0 and int(b[1]) == 0:
break
print('%s %s' % (b[0],b[1]))
| 0 | null | 275,269,767,410 | 19 | 43 |
n = int(input())
a = []
for i in range(n):
s = str(input())
a.append(s)
b = set(a)
print(len(b))
|
import collections
N = int(input())
S = []
for i in range(N):
s = input()
S.append(s)
c = collections.Counter(S)
values, counts = zip(*c.most_common())
print(len(values))
| 1 | 30,263,782,358,720 | null | 165 | 165 |
import math
def fact(n):
ans = 1
for i in range(2, n+1):
ans*= i
return ans
def comb(n, c):
return fact(n)//(fact(n-c)*c)
N,M=map(int,input().split())
if M%2==0:
for i in range(M//2):
print(i+1,M-i)
for i in range(M//2):
print(M+i+1,2*M-i+1)
else:
for i in range(M//2):
print(i+1,M-i)
for i in range(M//2+1):
print(M+i+1,2*M-i+1)
|
N=int(input())
r=[0]*10000
for i in range(1,101):
for j in range(1,101):
for k in range(1,101):
v = i*i + j*j + k*k + i*j + i*k + k*j
if v <= 10000:
r[v-1] += 1
for i in range(N):
print(r[i])
| 0 | null | 18,301,516,670,948 | 162 | 106 |
n = 0
while True:
x = input()
if x==0:
break
n+=1
print 'Case %d: %d' %(n, x)
|
case_num = 1
while True:
tmp_num = int(input())
if tmp_num == 0:
break
else:
print("Case %d: %d" % (case_num,tmp_num))
case_num += 1
| 1 | 488,996,880,892 | null | 42 | 42 |
import math
from functools import reduce
from copy import deepcopy
n,m = map(int,input().split())
A = list(map(int,input().split()))
def lcm_base(x, y):
return (x * y) // math.gcd(x, y)
def lcm_list(numbers):
return reduce(lcm_base, numbers, 1)
Acopy = deepcopy(A)
flag = -1
for i in range(n):
cnt = 0
while True:
if Acopy[i] % 2 == 1:
break
else:
Acopy[i] //= 2
cnt += 1
if i == 0:
flag = cnt
else:
if flag != cnt:
print(0)
break
else:
A = [a//2 for a in A]
lcm = lcm_list(A)
print((lcm+m)//2//lcm)
|
import sys
read = sys.stdin.read
def gcd(a, b):
while b:
a, b = b, a % b
return a
def lcm(a, b):
return a * b // gcd(a, b)
def main():
N, M, *A = map(int, read().split())
G = A.copy()
while not any(x % 2 for x in G):
G = [i // 2 for i in G]
if not all(x % 2 for x in G):
print(0)
exit(0)
total = 1
for x in A:
total = lcm(total, x // 2)
print((M // total + 1) // 2)
if __name__ == '__main__':
main()
| 1 | 102,059,461,330,852 | null | 247 | 247 |
import math
import itertools
N=int(input())
P=list(map(int,input().split()))
Q=list(map(int,input().split()))
ls=[]
for i in range(1,N+1):
ls.append(i)
ls2 = list(itertools.permutations(ls,N))
#print(ls2)
cnt1 = 0
cnt2 = 0
for j in range(math.factorial(N)):
for i in range(N):
#print(j,i,P[i],ls2[j][i])
if P[i] == ls2[j][i]:
cnt1 += 1
if Q[i] == ls2[j][i]:
cnt2 += 1
#print("cnt1",cnt1,"cnt2",cnt2)
if cnt1 == N:
a = j
if cnt2 == N:
b = j
cnt1 = 0
cnt2 = 0
#print(a,b)
print(abs(a-b))
|
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
from collections import deque
class Graph():
def __init__(self, v):
from heapq import heappop, heappush
self.v = v
self.graph = [[] for _ in range(v)]
self.INF = 10 ** 9
def addEdge(self, start, end, edge):
self.graph[start].append((end, edge))
self.graph[end].append((start, edge))
def do():
n=INT()
g=Graph(n)
for i in range(n-1):
a,b=INTM()
a-=1
b-=1
g.addEdge(a,b,i)
que=deque()
check=[True]*n
clrs=[0]*(n-1)
que.append([0,0])
check[0]=False
while que:
clr=1
now,clr_f=que.popleft()
if clr_f==1:
clr=2
for next,i in g.graph[now]:
if check[next]:
check[next]=False
que.append([next,clr])
clrs[i]=clr
clr+=1
if clr==clr_f:
clr+=1
print(max(clrs))
for i in range(n-1):
print(clrs[i])
if __name__=='__main__':
do()
| 0 | null | 118,558,683,490,420 | 246 | 272 |
def dictionary():
n = int(input())
s = set()
for i in range(n):
command, value = input().split()
if command == 'insert':
s.add(value)
elif command == 'find':
if value in s:
print('yes')
else:
print('no')
if __name__ == '__main__':
dictionary()
|
# coding=utf-8
n = int(input())
dic = set()
for i in range(n):
cmd = input().split()
if cmd[0] == 'insert':
dic.add(cmd[1])
else:
if cmd[1] in dic:
print('yes')
else:
print('no')
| 1 | 76,716,402,410 | null | 23 | 23 |
def main():
numbers = input().split()
a, b, c = map(int, numbers)
a_to_b = list(range(a, b + 1)) #a to b
result = [x for x in a_to_b if c % x == 0]
#約数検索
count = int(len(result))
print(count)
if __name__=="__main__":
main()
|
a, b, c = map(int, raw_input().split(' '))
num = 0
for i in range(a,b+1):
if c % i == 0:
num = num + 1
print(num)
| 1 | 554,754,710,422 | null | 44 | 44 |
N = int(input())
A = list(map(int,input().split()))
SUM = sum(A)
half = SUM//2
acc = 0;dif = SUM
for i in range(N):
acc += A[i]
dif = min(dif,abs(SUM-2*acc))
print(dif)
|
N=int(input())
A=list(map(int, input().split()))
dp = [[0 for i in range(2)] for j in range(N+1)]
if N in [2, 3]: print(max(A))
else:
dp[2][0] = A[1]
dp[2][1] = A[0]
dp[3][0] = A[2]
dp[3][1] = max(A[1], A[0])
for i in range(4, N+1):
if i % 2 == 0:
dp[i][0] = max(max(dp[i-2][0], dp[i-2][1])+A[i-1], dp[i-1][1]+A[i-1])
dp[i][1] = dp[i-2][1]+A[i-2]
else:
dp[i][0] = max(dp[i-2][0], dp[i-2][1])+A[i-1]
dp[i][1] = max(dp[i-1][0], dp[i-1][1])
print(max(dp[-1][0], dp[-1][1]))
| 0 | null | 90,016,772,210,430 | 276 | 177 |
import sys
sys.setrecursionlimit(500000)
N = int(input())
#道を双方向に記録する。
g = [[] for _ in range(N)]
for i in range(N-1): #木の辺の数はN-1
#iが辺のID
a,b = map(int,input().split())
a -= 1; b -= 1 #ここで引いて頂点を0スタートにしないとオーバーフロー
g[a].append((b,i))
g[b].append((a,i))
#これが答え。
ans = [-1 for _ in range(N-1)]
#vという頂点からpという親にcolorという色で繋がっている。
def dfs(v, color, p):
k = 1 #色の初期値
for i in range(len(g[v])): #vから繋がっている頂点をtoとして探す
TO = g[v][i][0]
ID = g[v][i][1]
if TO == p: #親は一つでそれ以外は子。親の時だけ無視すればよい。
continue
if k == color: #親から繋がっている色と被ったらダメ。
k += 1
ans[ID] = k
k += 1 #ここで足す1をしないとこのfor loopの中の辺で色が被る。
dfs(TO,ans[ID],v)
dfs(0,0,-1) #根を0として、仮想親の-1から仮想色0で繋がっている。
print(max(ans))
for i in ans:
print(i)
|
# ALDS_11_C - 幅優先探索
import sys
import heapq
N = int(input())
G = []
for _ in range(N):
u, k, *v = map(int, sys.stdin.readline().strip().split())
v = [i - 1 for i in v]
G.append(v)
distance = [-1] * N
q = []
fp = [True] * N # 探索可能か記録する
heapq.heapify(q)
heapq.heappush(q, (0, 0))
fp[0] = False
while q:
dist, u = heapq.heappop(q)
distance[u] = dist
for v in G[u]:
if fp[v] is True:
heapq.heappush(q, (dist + 1, v))
fp[v] = False
for i, d in enumerate(distance):
print(i + 1, d)
| 0 | null | 68,364,512,718,468 | 272 | 9 |
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
xyc = [list(map(int, input().split())) for _ in range(M)]
ans_kouho = [min(a)+min(b)] + [a[x-1]+b[y-1]-c for x, y, c in xyc]
print(min(ans_kouho))
|
a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
ans = 123456789012345
for i in range(m):
x,y,c=map(int,input().split())
ans = min(ans, a[x-1]+b[y-1]-c)
a.sort()
b.sort()
ans = min(ans,a[0]+b[0])
print(ans)
| 1 | 54,129,807,530,640 | null | 200 | 200 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.