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
|
|---|---|---|---|---|---|---|
i = 0
while i < 9:
i = i + 1
j = 0
while j < 9:
j = j + 1
print (str(i) + 'x' + str(j) + '=' + str(i*j))
|
"""
何回足されるかで考えればよい。
真っ二つに切っていく。
各項は必ずM未満。
M項以内に必ずループが現れる。
"""
N,X,M = map(int,input().split())
memo1 = set()
memo2 = []
ans = 0
a = X
flag = True
rest = N
while rest > 0:
if a in memo1 and flag:
flag = False
for i in range(len(memo2)):
if memo2[i] == a:
loopStart = i
setSum = 0
for i in range(loopStart,len(memo2)):
setSum += memo2[i]**2 % M
loopStep = len(memo2)-loopStart
loopCount = rest // loopStep
ans += loopCount*setSum
rest -= loopCount*loopStep
else:
memo1.add(a)
memo2.append(a)
ans += a
a = a**2%M
rest -= 1
print(ans)
| 0 | null | 1,428,392,111,420 | 1 | 75 |
n = int(input())
a = map(int,input().split())
boss = [[] for _ in range(n)]
for i,j in enumerate(a):
boss[j-1].append(i)
for i in boss:
print(len(i))
|
N = int(input())
A = list(map(int, input().split()))
A.sort()
A.append(N + 1)
ans = [0] * (N+1)
count = [0, 0]
for i in range(N):
if count[0] == A[i]:
count[1] += 1
else:
ans[count[0]] = count[1]
count[0] = A[i]
count[1] = 1
for j in range(1, N+1):
print(ans[j])
| 1 | 32,679,422,430,318 | null | 169 | 169 |
from collections import Counter
class union_find():
def __init__(self,n):
self.n=n
##親要素のノード番号を格納。par[x]==xのときそのノードは根
##親とはその上にノードなし！！
self.par=[-1 for i in range(n)]
self.rank=[0]*(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 union(self,x,y):
x=self.find(x)
y=self.find(y)
##木の高さを比較し、低い方から高い方へ辺をはる
if x==y:
return
if self.par[x]>self.par[y]:
x,y=y,x
self.par[x]+=self.par[y]
self.par[y]=x
def same(self,x,y):
return self.find(x) == self.find(y)
def size(self,x):
return -self.par[self.find(x)]
def members(self,x):
root=self.find(x)
return [i for i in range(self.n) if self.find(i)==root]
def roots(self):
return [i for i, x in enumerate(self.par) if x<0]
def all_group_member(self):
return {r:self.members(r) for r in self.roots()}
n,m,k=map(int,input().split())
uf=union_find(n)
good=[0 for _ in range(n)]
for _ in range(m):
a,b=map(int,input().split())
uf.union(a-1,b-1)
good[a-1]+=1
good[b-1]+=1
ans=[0 for _ in range(n)]
bad=[0 for _ in range(n)]
for _ in range(k):
p,q=map(int,input().split())
if uf.same(p-1,q-1):
bad[p-1]+=1
bad[q-1]+=1
ans1=[]
for u in range(n):
C=uf.size(u)
ans1.append(str(C-1-bad[u]-good[u]))
print(' '.join(ans1))
|
def gcd(a,b):
while a!=0 and b!=0:
if a>b:
c = a
a = b
b = c
b %= a
return max(a,b)
a,b = map(int,input().split())
print(a*b//gcd(a,b))
| 0 | null | 87,725,377,425,238 | 209 | 256 |
# i>j とする.
# |i-j|=Ai+Aj
# i-j = Ai+Aj
N=int(input())
A=list(map(int,input().split()))
cnt=[0]*300000
ans=0
for i in range(N):
if i-A[i]>=0:
ans=ans+cnt[i-A[i]]
if i+A[i]<len(cnt):
cnt[i+A[i]]=cnt[i+A[i]]+1
print(ans)
|
import numpy as np
R = int(input())
l = R * 2 * np.pi
print(str(l))
| 0 | null | 28,688,597,078,500 | 157 | 167 |
n=int(input(''))
p=0
for i in range(n-1):
a=i+1
p=p+(n-1)//a
print(p)
|
from collections import defaultdict
import math
def main():
n = int(input())
mod = 1000000007
zeroes = 0
counter1 = defaultdict(int)
counter2 = defaultdict(int)
for _ in range(n):
x, y = [int(x) for x in input().split()]
if x == y == 0:
zeroes += 1
continue
denominator = math.gcd(x, y)
x, y = x // denominator, y // denominator
if y < 0:
# quadrant III, IV -> I, II
x, y = -x, -y
if x <= 0:
# round 90° from quadrant II to I
x, y = y, -x
counter2[(x, y)] += 1
counter1[(x, y)] += 0
else:
counter1[(x, y)] += 1
counter2[(x, y)] += 0
ans = 1
for k, v in counter1.items():
now = 1
now += pow(2, v, mod) - 1
now += pow(2, counter2[k], mod) - 1
ans = ans * now % mod
ans += zeroes
ans -= 1 # choose no fish
return ans % mod
if __name__ == '__main__':
print(main())
| 0 | null | 11,845,409,585,740 | 73 | 146 |
h = int(input())
w = int(input())
n = int(input())
a = 0
b = 0
c = 0
d = 0
for i in range(h):
a += w
b += 1
if a >= n:
break
for i in range(w):
c += h
d += 1
if c >= n:
break
if b > d:
print(d)
else:
print(b)
|
h = int(input())
w = int(input())
n = int(input())
n_push = []
for n_h in range(h+1):
for n_w in range(w+1):
n_tmp = (n_h)*w + (n_w)*h - ((n_h)*(n_w))
if n_tmp>=n:
n_push.append(n_h + n_w)
print(min(n_push))
| 1 | 88,833,681,653,068 | null | 236 | 236 |
import sys
a,b,c=map(int,input().split())
if a==b and b!=c:
print("Yes")
sys.exit()
elif c==b and b!=a:
print("Yes")
sys.exit()
elif a==c and b!=c:
print("Yes")
sys.exit()
else:
print("No")
sys.exit()
|
import math
a, b, ca = map(float, input().split())
ca = math.radians(ca)
s = a * b * math.sin(ca) / 2
c = (a ** 2 + b ** 2 - 2 * a * b * math.cos(ca)) ** 0.5
h = b * math.sin(ca)
print("{:.5f}".format(s))
print("{:.5f}".format(a + b + c))
print("{:.5f}".format(h))
| 0 | null | 34,044,225,358,388 | 216 | 30 |
mod=1000000007
n,k=map(int, input().split())
lst=list(map(int, input().split()))
lst=sorted(lst)
p=1
if lst[-1]==0 and k%2!=0:
print(0)
elif lst[-1]<0 and k%2!=0:
for i in range(n-1,n-k-1,-1):
#print(p)
p=(p%mod*lst[i]%mod)%mod
#print(p)
print(p%mod)
else:
j=n-1
if k%2!=0:
p*=lst[j]
k-=1
j-=1
k=k//2
i=0
for x in range(k):
if lst[i]*lst[i+1]>lst[j]*lst[j-1]:
p=(p%mod*lst[i]%mod*lst[i+1]%mod)%mod
i+=2
else:
p=(p%mod*lst[j]%mod*lst[j-1]%mod)%mod
j-=2
#print(p)
print(p%mod)
|
import sys
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
MOD=10**9+7
plus=[]
minus=[]
zero=[]
for i in range(n):
if a[i]>0:
plus.append(a[i])
if a[i]<0:
minus.append(a[i])
if a[i]==0:
zero.append(a[i])
if k==n:
ans=1
for i in range(k):
ans=(ans*a[i])%MOD
print(ans)
sys.exit()
if len(plus)==0:
if k%2!=0:
a.reverse()
ans=1
for i in range(k):
ans=(ans*a[i])%MOD
print(ans)
sys.exit()
if len(plus)+len(minus)<k:
print(0)
sys.exit()
m=len(minus)
minus.sort()
plus.reverse()
plpointer=k
if k>len(plus):
plpointer=2*(len(plus)//2)
if k%2==1:
if plpointer+1<=len(plus):
plpointer+=1
else:
plpointer-=1
mnpointer=k-plpointer
while mnpointer<m-1 and plpointer>=2 and minus[mnpointer]*minus[mnpointer+1]>plus[plpointer-1]*plus[plpointer-2]:
mnpointer+=2
plpointer-=2
ans=1
for i in range(mnpointer):
ans=(ans*minus[i])%MOD
for i in range(plpointer):
ans=(ans*plus[i])%MOD
print(ans)
| 1 | 9,395,586,866,912 | null | 112 | 112 |
N, K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort(reverse=True)
F.sort()
U = 10**12
L = -1
while U - L > 1:
x = (U+L)//2
cnt = 0
for i in range(N):
if x//F[i] < A[i]:
cnt += A[i] - x//F[i]
if cnt > K:
L = x
else:
U = x
print(U)
|
import sys
import numpy as np
n, k = map(int,input().split())
a = np.array(sorted(list(map(int, input().split()))))
f = np.array(sorted(list(map(int, input().split())), reverse=True))
asum = a.sum()
l,r = 0, 10**13
while l != r:
mid = (l+r)//2
can = (asum - np.minimum(mid//f, a).sum()) <= k
if can:
r = mid
else:
l = mid +1
print(l)
| 1 | 164,592,049,220,298 | null | 290 | 290 |
a = input()
b = 0
c = 0
i = 0
while i < len(a) :
if a[i] == "A" :
b = b + 1
if a[i] == "B" :
c = c + 1
i = i + 1
if (b > 0) and (c > 0) :
print("Yes")
else:
print("No")
|
S = len(set(input()))
if S == 2:
print('Yes')
else:
print('No')
| 1 | 54,931,830,179,210 | null | 201 | 201 |
import sys
sys.setrecursionlimit(2**20)
n, m, k = map(int, input().split())
ab = []
for _ in range(m):
ab.append([int(x)-1 for x in input().split()])
cd = []
for _ in range(k):
cd.append([int(x)-1 for x in input().split()])
group = [-1 for _ in range(n)]
lis = [[] for _ in range(n)]
for x in ab:
a = x[0]
b = x[1]
lis[a].append(b)
lis[b].append(a)
g_n = 0
def dfs(now):
global g_n
group[now] = g_n
global group_len_n
group_len_n += 1
for i in lis[now]:
if group[i] == -1:
dfs(i)
group_len = []
for i in range(n):
if group[i] == -1:
group_len_n = 0
dfs(i)
group_len.append(group_len_n)
g_n += 1
friend = [0 for _ in range(n)]
block = [0 for _ in range(n)]
for x in ab:
a = x[0]
b = x[1]
if group[a] == group[b]:
friend[a] += 1
friend[b] += 1
for x in cd:
c = x[0]
d = x[1]
if group[c] == group[d]:
block[c] += 1
block[d] += 1
ans = []
for i in range(n):
ans.append(str(group_len[group[i]] - friend[i] - block[i] -1))
print(" ".join(ans))
|
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):#要素xが属するグループの根を返す
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):#要素xが属するグループと要素yが属するグループとを併合する
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):#要素xが属するグループのサイズ（要素数）を返す
return -self.parents[self.find(x)]
def same(self, x, y):#要素x, yが同じグループに属するかどうかを返す
return self.find(x) == self.find(y)
def members(self, x):#要素xが属するグループに属する要素をリストで返す
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):#すべての根の要素をリストで返す
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):#グループの数を返す
return len(self.roots())
def all_group_members(self):#{ルート要素: [そのグループに含まれる要素のリスト], ...}の辞書を返す
return {r: self.members(r) for r in self.roots()}
def __str__(self):#print()での表示用 ルート要素: [そのグループに含まれる要素のリスト]を文字列で返す
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
N, M, K = map(int, input().split())
uf = UnionFind(N)
edge1 = []
edge2 = []
for i in range(M):
a,b = map(int,input().split())
edge1.append((a-1,b-1))
for i in range(K):
c,d = map(int,input().split())
edge2.append((c-1,d-1))
for a,b in edge1:
uf.union(a,b)
#同じグループに属する人数（自分を除く）
ans = [uf.size(i)-1 for i in range(0,N)]
for a,b in edge1:#すでに友達なら削る
ans[a] -= 1
ans[b] -= 1
for c,d in edge2:
if uf.same(c,d): #ブロック関係かつ同じグループに属しているなら
ans[c] -= 1
ans[d] -= 1
print(*ans)
| 1 | 61,608,416,278,130 | null | 209 | 209 |
n, m = map(int, input().split())
total = sum(list(map(int, input().split())))
if n - total >= 0:
print(n-total)
else:
print("-1")
|
N,M = map(int, input().split())
A_list = [int(i) for i in input().split()]
playable_days = N - sum(A_list)
if playable_days >= 0:
print(playable_days)
else:
print("-1")
| 1 | 31,983,779,220,900 | null | 168 | 168 |
n=int(input())
MAX=(10**4)
cntl=[0]*(MAX+1)
for x in range(1,101):
for y in range(1,101):
for z in range(1,101):
if x**2+y**2+z**2+x*y+y*z+x*z>MAX:
break
cntl[x**2+y**2+z**2+x*y+y*z+x*z]+=1
for i in range(1,n+1):
print(cntl[i])
|
def solve(n):
D = {k: 0 for k in range(1, n+1)}
m = int(n**0.5)
for x in range(1, m+1):
for y in range(1, m+1):
for z in range(1, m+1):
k = x**2 + y**2 + z**2 + x*y + y*z + z*x
if k <= n:
D[k] += 1
else:
break
for k in range(1, n+1):
print(D[k])
n = int(input())
solve(n)
| 1 | 8,029,502,495,728 | null | 106 | 106 |
A, B, M = map(int,input().split())
A = [a for a in map(int,input().split())]
B = [b for b in map(int,input().split())]
C = []
for m in range(M):
C.append([c for c in map(int,input().split())])
ans = min(A) + min(B)
for c in C:
if (A[c[0]-1]+B[c[1]-1]-c[2])<ans:
ans = A[c[0]-1]+B[c[1]-1]-c[2]
print(ans)
|
A,B,M = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
X = []
Y = []
C = []
for _ in range(M):
x,y,c = map(int,input().split())
X.append(x)
Y.append(y)
C.append(c)
ans = min(a) + min(b)
for i in range(M):
ans = min(ans,a[X[i]-1] + b[Y[i] - 1] - C[i])
print(ans)
| 1 | 53,827,393,124,992 | null | 200 | 200 |
num_a = [1, 2, 3, 4, 5, 6, 7, 8, 9]
for i in num_a:
for j in num_a:
print(i, 'x', j, '=', i*j, sep='')
|
i=[1,2,3,4,5,6,7,8,9]
j=[1,2,3,4,5,6,7,8,9]
for i1 in i:
for j1 in j:
answer=i1*j1
print(str(i1)+"x"+str(j1)+"="+str(answer))
| 1 | 156,950 | null | 1 | 1 |
n = input()
R = [input() for i in xrange(n)]
m = R[0]
ans = -1e10
for r in R[1:]:
ans = max(ans, r - m)
m = min(m, r)
print ans
|
#!/usr/bin/env python
# -*- coding: utf-8 -*-
def main():
values = []
total = 0
open_chars = 0
close_chars = 0
for _ in range(int(input())):
s = input().strip()
open_required = len(s)
close_required = len(s)
open_close = 0
for i, c in enumerate(s):
if c == '(':
open_required = min(i, open_required)
open_close += 1
else:
close_required = min(len(s) - i - 1, close_required)
open_close -= 1
if open_required == 0 and close_required == 0 and open_close == 0:
continue
elif open_close == len(s):
open_chars += len(s)
continue
elif -open_close == len(s):
close_chars += len(s)
continue
total += open_close
values.append([open_required, close_required, open_close, 0])
if total + open_chars - close_chars != 0:
print('No')
return
fvals = values.copy()
bvals = values
fvals.sort(key=lambda x: (x[0], -x[2]))
bvals.sort(key=lambda x: (x[1], x[2]))
findex = 0
bindex = 0
while True:
while findex < len(fvals) and fvals[findex][3] != 0:
findex += 1
while bindex < len(bvals) and bvals[bindex][3] != 0:
bindex += 1
if findex >= len(fvals) and bindex >= len(bvals):
break
fvals[findex][3] = 1
bvals[bindex][3] = -1
values = [v for v in fvals if v[3] == 1] + [v for v in bvals if v[3] == -1][::-1]
open_close_f = 0
open_close_b = 0
for (oreq_f, _, ocval_f, _), (_, creq_b, ocval_b, _) in zip(values, values[::-1]):
if oreq_f > open_close_f + open_chars:
print('No')
return
if creq_b > open_close_b + close_chars:
print('No')
return
open_close_f += ocval_f
open_close_b -= ocval_b
print('Yes')
if __name__ == '__main__':
main()
| 0 | null | 11,902,393,595,278 | 13 | 152 |
arr = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for _ in range(n):
b, f, r, v = map(int, input().split())
arr[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(' '+' '.join(str(x) for x in arr[b][f]))
if(b < 3):
print('#' * 20)
|
house = [[[0 for col in range(10)]for row in range(3)]for layer in range(4)]
n = int(raw_input())
for i in range(n):
input_line = raw_input().split()
house[int(input_line[0])-1][int(input_line[1])-1][int(input_line[2])-1] += int(input_line[3])
for i in range(0,4):
if i != 0:
print "#"*20
for j in range(0,3):
buf = ""
for k in range(0,10):
buf += " " + str(house[i][j][k])
print buf
| 1 | 1,097,535,416,718 | null | 55 | 55 |
while True:
try:
(h,w)=map(int,raw_input().split())
if h==0 and w==0: break
for i in xrange(h):
print ''.join(['#' for j in xrange(w)])
print
except EOFError: break
|
while True:
a = list(map(lambda x : int(x), input().split(" ")))
if a[0] == 0 and a[1] == 0:
break
for i in range(a[0]):
for j in range(a[1]):
print("#", end="")
print()
print()
| 1 | 755,867,710,140 | null | 49 | 49 |
a=1
b=1
c=[]
n=int(input())
c.append(a)
c.append(b)
for i in range(n):
c.append(a+b)
d=b
b+=a
a=d
print(c[n])
|
_fib = [0] * 45
def fib(n):
if n < 2:
return 1
if _fib[n] > 0:
return _fib[n]
_fib[n] = fib(n-1) + fib(n-2)
return _fib[n]
n = int(input())
print(fib(n))
| 1 | 1,664,846,612 | null | 7 | 7 |
a_b_c=input().split()
a=int(a_b_c[0])
b=int(a_b_c[1])
c=int(a_b_c[2])
count=0
yakusuu_list=[]
for i in range(1,c+1):
if c%i==0:
yakusuu_list.append(i)
for i in yakusuu_list:
if i in range(a,b+1):
count+=1
print(count)
|
n = int(input())
li_a = list(map(int, input().split()))
dic_a = {}
for a in li_a:
dic_a[a] = dic_a.get(a, 0) + 1
q = int(input())
li_bc = list()
for i in range(q):
li_bc.append(tuple(map(int, input().split())))
answer = sum(li_a)
for l in li_bc:
b = l[0]
c = l[1]
diff = (c - b) * dic_a.get(b, 0)
if b in dic_a.keys():
dic_a[c] = dic_a.get(c, 0) + dic_a.get(b, 0)
dic_a[b] = 0
answer += diff
else:
pass
print(answer)
| 0 | null | 6,445,151,660,520 | 44 | 122 |
def readinput():
n=int(input())
a=list(map(int,input().split()))
return n,a
def main(n,a):
aa=[]
for i in range(n):
aa.append((i+1,a[i]))
aa.sort(key=lambda x:x[1])
b=[]
for i in range(n):
b.append(aa[i][0])
return b
if __name__=='__main__':
n,a=readinput()
ans=main(n,a)
print(' '.join(map(str,ans)))
|
A = input()
B = input()
candidate = set(('1', '2', '3'))
exclude = set((A, B))
print((candidate - exclude).pop())
| 0 | null | 145,354,493,190,120 | 299 | 254 |
if __name__ == '__main__':
n = int(input())
if n % 2 == 0:
print(int(n/2 - 1))
else:
print(int((n-1)/2))
|
N = int(input())-1
print(N//2)
| 1 | 153,249,721,079,712 | null | 283 | 283 |
# Bingo
A = []
for _ in range(3):
A += list(map(int, input().split()))
N = int(input())
for _ in range(N):
b = int(input())
if b in A:
A[A.index(b)] = -1
# check
diag = (sum(A[0::4]) == -3) | (sum(A[2:8:2]) == -3)
rows = (sum(A[:3]) == -3) | (sum(A[3:6]) == -3) | (sum(A[6:]) == -3)
cols = (sum(A[:7:3]) == -3) | (sum(A[1:8:3]) == -3) | (sum(A[2::3]) == -3)
ans = diag | rows | cols
print(['No', 'Yes'][ans])
|
A11, A12, A13 = map(int, input().split())
A21, A22, A23 = map(int, input().split())
A31, A32, A33 = map(int, input().split())
N = int(input())
B = {int(input()) for _ in range(N)}
h1 = {A11, A12, A13}
h2 = {A21, A22, A23}
h3 = {A31, A32, A33}
v1 = {A11, A21, A31}
v2 = {A12, A22, A32}
v3 = {A13, A23, A33}
c1 = {A11, A22, A33}
c2 = {A13, A22, A31}
if len(h1 & B)==3 or len(h2 & B)==3 or len(h3 & B)==3 or len(v1 & B)==3 or len(v2 & B)==3 or len(v3 & B)==3 or len(c1 & B)==3 or len(c2 & B)==3:
print("Yes")
else:
print("No")
| 1 | 59,657,012,015,858 | null | 207 | 207 |
N = int(input())
X = input().split()
distance = 0
min_distance = float('Inf')
for i in range(1,101):
for j in range(N):
distance += (int(X[j]) - i) ** 2
min_distance = min(min_distance, distance)
distance = 0
print(min_distance)
|
N = int(input())
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
# divisors.sort()
return divisors
C = set(make_divisors(N) + make_divisors(N-1))
C.discard(1)
def f(x, k):
if x % k == 0:
return x//k
else:
return x % k
ans = 0
for i in C:
x = N
c = 0
while x >= i:
c += 1
x = f(x, i)
if x == 1:
ans += 1
print(ans)
| 0 | null | 53,247,474,675,112 | 213 | 183 |
def main():
n = int(input())
if n % 2 == 0 and n >= 10:
m = n // 2
k = 5
m5 = 0
while k <= m:
m5 += m // k
k *= 5
else:
m5 = 0
print(m5)
if __name__ == '__main__':
main()
|
n = int(input())
if n % 2 == 1:
print(0)
elif n % 2 == 0:
ans = 0
k = 10
while n >= k:
ans += n//k
k *= 5
print(ans)
| 1 | 116,569,421,003,592 | null | 258 | 258 |
n,k=map(int, input().split())
list=list(map(int, input().split()))
count = 0
elem=0
for i in list :
if i >=k:
count +=1
elem+=1
print(count)
|
n,k = map(int,input().split())
count=0
l= list(map(int,input().split()))
for i in range(len(l)):
if l[i]>=k:
count=count+1
print(count)
| 1 | 178,311,746,193,818 | null | 298 | 298 |
S = input()
a = "RRR"
b = "RR"
c = "R"
if a == S:
print(3)
elif b in S:
print(2)
elif c in S:
print(1)
else:
print(0)
|
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])
| 0 | null | 22,440,145,492,470 | 90 | 181 |
# Papers, Please
N = int(input())
A = list(map(int, input().split()))
for Ai in A:
if Ai % 2 == 1:
continue
else:
if Ai % 3 != 0 and Ai % 5 != 0:
print("DENIED")
exit()
print("APPROVED")
|
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')
| 1 | 68,630,918,977,920 | null | 217 | 217 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(2147483647)
class Edge:
def __init__(self, to, id):
self.to = to
self.id = id
N = int(input())
graph = {}
ans = [0] * (N-1)
def dfs(v, c=-1, p=-1):
global graph, ans
k = 1
for edge in graph[v]:
nv = edge.to
if nv == p:continue
if k == c:k += 1
ans[edge.id] = k
dfs(nv, k, v)
k += 1
def main():
global N, graph, ans
for i in range(N):
graph[i] = set()
for i in range(N-1):
a, b = map(int, input().split())
graph[a-1].add(Edge(b-1, i))
graph[b-1].add(Edge(a-1, i))
color_count = 0
for i in range(N):
color_count = max(color_count, len(graph[i]))
dfs(0, 0, -1)
print(color_count)
for x in ans:
print(x)
if __name__ == "__main__":
main()
|
import sys
for i, x in enumerate(iter(sys.stdin.readline, '0\n'), 1):
print(f'Case {i}: {x[:-1]}')
| 0 | null | 68,062,533,734,912 | 272 | 42 |
mod = 1000000007
def ff(a, b):
ans = 1
while b:
if b & 1: ans = ans * a % mod
b >>= 1
a = a * a % mod
return ans
n=int(input())
print(((ff(10,n)-2*ff(9,n)+ff(8,n))%mod+mod)%mod)
|
N = int(input())
MOD = 10**9+7
a10 = 10**N
a9 = 9**N
a8 = 8**N
print((a10-a9-a9+a8) % MOD)
| 1 | 3,204,477,305,760 | null | 78 | 78 |
a = input()
if a == 'SUN':
print(7)
elif a == 'MON':
print(6)
elif a == 'TUE':
print(5)
elif a == 'WED':
print(4)
elif a == 'THU':
print(3)
elif a == 'FRI':
print(2)
else:
print(1)
|
n = int(input())
my_dict = {}
for i in range(n):
order, key = input().split(' ')
if order == 'insert':
my_dict[key] = True
elif order== 'find':
if key in my_dict.keys():
print('yes')
else:
print('no')
| 0 | null | 66,501,769,058,160 | 270 | 23 |
print('NYoe s'[len(set(map(int,input().split())))==2::2])
|
#!/usr/bin/env python3
a = list(map(int, input().split()))
if len(a) - len(set(a)) == 1:
print('Yes')
else:
print('No')
| 1 | 68,185,808,848,428 | null | 216 | 216 |
def main():
n, m = map(int, input().split())
h_lst = list(map(int, input().split()))
ab_dict = dict() # 展望台i : [展望台iに隣接する展望台の標高]
for _ in range(m):
a, b = map(int, input().split())
if a not in ab_dict:
ab_dict[a] = [h_lst[b - 1]]
else:
ab_dict[a].append(h_lst[b - 1])
if b not in ab_dict:
ab_dict[b] = [h_lst[a - 1]]
else:
ab_dict[b].append(h_lst[a - 1])
cnt = 0
ab_dict_keys = ab_dict.keys()
for i in range(1, n + 1):
if i not in ab_dict_keys:
cnt += 1
continue
if h_lst[i - 1] > max(ab_dict[i]):
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
|
n=int(input())
def m_div(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
def check(num,k):
if k==1:
return False
while num>=k:
if num%k==0:
num=num//k
else:
break
num%=k
return num==1
n1divs = m_div(n-1)
ndivs = m_div(n)
ans=[]
for num in n1divs:
if check(n,num):
ans.append(num)
for num in ndivs:
if check(n,num):
ans.append(num)
print(len(set(ans)))
| 0 | null | 33,223,413,754,998 | 155 | 183 |
s = input()
map = {'SSS': 0, 'SSR': 1, 'SRS': 1, 'RSS': 1, 'SRR': 2, 'RSR': 1, 'RRS': 2, 'RRR': 3}
for key in map.keys():
if s == key:
print(map[key])
break
|
flag = True
count = 0
l = []
for s in input():
if flag:
if s == "R":
count += 1
l.append(count)
else:
l.append(0)
count = 0
print(max(l))
| 1 | 4,866,039,805,802 | null | 90 | 90 |
a = list(map(int, input().split()))
HP = a[0]
x = []
for i in range(a[1]):
x1, y1 = [int(i) for i in input().split()]
x.append((x1, y1))
max_tup = max(x, key=lambda x: x[0])
max_a = max_tup[0]
dp = [0] * (HP + max_a)
for i in range(1, len(dp)):
dp[i] = min(dp[i - a] + b for a, b in x)
print(dp[HP])
|
n,m,k = map(int,input().split())
import collections
par = []
for i in range(n):
par.append(i) #初期親
rank = [1 for i in range(n)] #初期ランク
flist = [[] for i in range(n)]
blist = [[] for i in range(n)]
cut = []
def find(n): #親検索andランク短縮
global cut
if par[n] == n:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
return n
else:
cut.append(n)
find(par[n])
return find(par[n])
def shorten(n): # ランクを2にする
global cut
if par[n] == n:
for i in range(len(cut)):
par[cut[i]] = n
cut = []
else:
cut.append(n)
shorten(par[n])
def unite(a,b): #グループ併合
x = find(a)
y = find(b) #根っこ同士をくっつける
if x == y:
return #既に同一ユニオンなら何もしない
if rank[x] < rank[y]:
par[x] = y
elif rank[x] == rank[y]:
par[y] = x
rank[x] += 1
else:
par[y] = x
for i in range(m):
a,b = map(int,input().split())
a -= 1
b -= 1
flist[a].append(b)
flist[b].append(a)
unite(a,b)
for i in range(n):
shorten(i)
for i in range(k):
a,b = map(int,input().split())
a -= 1
b -= 1
if par[a] == par[b]:
blist[a].append(b)
blist[b].append(a)
c = collections.Counter(par)
for i in range(n):
ans = c[par[i]] -len(flist[i])-len(blist[i])-1
print(ans,end = ' ')
| 0 | null | 71,425,024,933,554 | 229 | 209 |
N,K = map(int, input().split())
A = list(map(int, input().split()))
S = [0 for i in range(N+1)]
for i in range(1,N+1):
S[i] = S[i-1] + A[i-1]
cnt = 0
dict1 = {}
dict1[0] = 1
for j in range(1,N+1):
if j-K >= 0:
dict1[(S[j-K]-j+K)%K] -= 1
if (S[j]-j)%K in dict1:
cnt += dict1[(S[j]-j)%K]
dict1[(S[j]-j)%K] += 1
else:
dict1[(S[j]-j)%K] = 1
print (cnt)
|
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque,Counter,defaultdict
from operator import mul
import copy
# ! /usr/bin/env python
# -*- coding: utf-8 -*-
import heapq
sys.setrecursionlimit(10**6)
INF = float("inf")
import bisect
N, K = list(map(int, input().split()))
a = [0] + list(map(int, input().split()))
s = list(itertools.accumulate(a))
# print(s)
for i in range(0, N+1):
s[i] = (s[i] - i) % K
# print(s)
d = defaultdict(int)
count = 0
for j in range(1,N+1):
d[s[j-1]] += 1
if j-K >= 0:
d[s[j-K]] -= 1
# print(j,s[j],d)
count += d[s[j]]
# print(d)
print(count)
| 1 | 137,862,197,667,220 | null | 273 | 273 |
from collections import defaultdict
from math import gcd as g
n = int(input())
mod = 10**9+7
sardines = set()
Ddic = defaultdict(int)
ans = 1
zcount = 0
for i in range(n):
a,b = map(int,input().split())
if a == 0 and b == 0:
zcount += 1
continue
if a == 0:
Ddic[(0,1)] += 1
sardines.add((0,1))
continue
if b == 0:
sardines.add((1,0))
Ddic[(1,0)] += 1
continue
A,B = abs(a),abs(b)
G = g(A,B)
a //= G
b //= G
if b < 0:
a = -a
b = -b
Ddic[(a,b)] += 1
sardines.add((a,b))
for i in sardines:
if i == (0,0) or (i[0] <= 0 and Ddic[(i[1],-i[0])] != 0):continue
if i[0] <= 0:
ans *= (2**Ddic[i] + 2**(Ddic[(i[1],-i[0])]))-1
else:
ans *= (2**Ddic[i] + 2**(Ddic[(-i[1],i[0])]))-1
ans %= mod
print((ans+zcount-1)%mod)
|
def main():
H1,M1,H2,M2,K = map(int,input().split())
time1 = H1*60 + M1
time2 = H2*60 + M2
time = time2-time1
ans = time-K
return ans
print(main())
| 0 | null | 19,554,765,683,232 | 146 | 139 |
# -*- coding: utf-8 -*-
import sys
from bisect import bisect_left,bisect_right
from collections import defaultdict
sys.setrecursionlimit(10**9)
INF=10**18
MOD=10**9+7
input=lambda: sys.stdin.readline().rstrip()
YesNo=lambda b: bool([print('Yes')] if b else print('No'))
YESNO=lambda b: bool([print('YES')] if b else print('NO'))
int1=lambda x:int(x)-1
def main():
class SegmentTree:
def __init__(self,n,segfunc,ide_ele):
self.segfunc=segfunc
self.ide_ele=ide_ele
self.num=2**(n-1).bit_length()
self.dat=[ide_ele]*2*self.num
def init(self,iter):
for i in range(len(iter)):
self.dat[i+self.num]=iter[i]
for i in range(self.num-1,0,-1):
self.dat[i]=self.segfunc(self.dat[i*2],self.dat[i*2+1])
def update(self,k,x):
k+=self.num
self.dat[k]=x
while k:
k//=2
self.dat[k]=self.segfunc(self.dat[k*2],self.dat[k*2+1])
def query(self,p,q):
if q<=p:
return self.ide_ele
p+=self.num
q+=self.num-1
res=self.ide_ele
while q-p>1:
if p&1==1:
res=self.segfunc(res,self.dat[p])
if q&1==0:
res=self.segfunc(res,self.dat[q])
q-=1
p=(p+1)//2
q=q//2
if p==q:
res=self.segfunc(res,self.dat[p])
else:
res=self.segfunc(self.segfunc(res,self.dat[p]),self.dat[q])
return res
N=int(input())
S=[input() for i in range(N)]
P=0
M=0
c=0
Seg=SegmentTree(10**6+1,lambda a,b:max(a,b),-INF)
l_PM=defaultdict(list)
stack=defaultdict(list)
minus=set()
for i,s in enumerate(S):
p=0
m=0
for x in s:
if x=='(':
p+=1
else:
if p>0:
p-=1
else:
m+=1
if m==0 and p>0:
P+=p
elif p==0 and m>0:
M+=m
elif p>0 and m>0:
c+=1
minus.add(m)
stack[m].append(p-m)
minus=list(minus)
minus.sort()
for x in minus:
stack[x].sort()
if x<=P:
while stack[x]:
y=stack[x].pop()
if y>=0:
c-=1
P+=y
else:
Seg.update(x,y)
l_PM[y].append(x)
break
else:
y=stack[x].pop()
Seg.update(x,y)
l_PM[y].append(x)
for _ in range(c):
x=Seg.query(0,P+1)
if x==-INF or P+x<0:
print('No')
exit()
l_PM[x].sort()
res=bisect_right(l_PM[x],P)-1
index=l_PM[x][res]
del l_PM[x][res]
if stack[index]:
y=stack[index].pop()
Seg.update(index,y)
l_PM[y].append(index)
else:
Seg.update(index,-INF)
P+=x
P-=M
YesNo(P==0)
if __name__ == '__main__':
main()
|
import sys
input=sys.stdin.readline
def count(s):
m=0
e=0
for t in s:
if t=='(':
e+=1
else:
e-=1
m=min(m,e)
return (e,m)
def count_reverse(s):
m=0
e=0
for t in s[::-1]:
if t==')':
e+=1
else:
e-=1
m=min(m,e)
return (e,m)
def main():
n=int(input())
S=[input().strip() for _ in range(n)]
P,M=[],[]
Z=[0]
for s in S:
e,m=count(s)
if e>0:
P.append((m,e))
elif e<0:
e,m=count_reverse(s)
M.append((m,e))
else:
Z.append(m)
P.sort(reverse=True); M.sort(reverse=True)
s_p,s_m=0,0
for m,e in P:
if s_p+m<0:
return 'No'
s_p+=e
for m,e in M:
if s_m+m<0:
return 'No'
s_m+=e
if s_p==s_m and s_p+min(Z)>=0:
return 'Yes'
return 'No'
if __name__=='__main__':
print(main())
| 1 | 23,706,684,987,242 | null | 152 | 152 |
import sys,math,copy,queue,itertools,bisect
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
_LI = lambda : [int(x)-1 for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
MOD = 10**9 + 7
INF = 10**15
N = NI()
A = LI()
ans = 0
if N % 2 == 0:
for i in range(1,N,2):
ans += A[i]
x = ans
for i in range(0,N,2):
x = x + A[i] - A[i+1]
ans = max(ans,x)
else:
dp = [0 for _ in range(3)]
for i in range(N):
ai = A[i]
if i % 2 == 0:
dp[1] = max(dp[0],dp[1])
dp[0] = dp[0] + ai
if i % 2 == 1:
dp[2] = max(dp[1],dp[2])
dp[1] += ai
if i % 2 == 0 and i > 0:
dp[2] += ai
ans = max(dp[1],dp[2])
print (ans)
|
n,m = map(int,input().split())
h = list(map(int,input().split()))
nf = [1] * n
for i in range(m):
a,b = map(int,input().split())
a -= 1
b -= 1
if h[a] > h[b]:
nf[b] = 0
elif h[a] < h[b]:
nf[a] = 0
else:
nf[a] = 0
nf[b] = 0
print(nf.count(1))
| 0 | null | 31,260,161,628,086 | 177 | 155 |
# ABC149
# A Blackjack
A = list(map(int, input().split()))
a = sum(A)
if a > 21:
print("bust")
else:
print("win")
|
def main():
a, b, c = map(int, input().split())
if 21 < (a + b + c):
print('bust')
else:
print('win')
main()
| 1 | 118,971,551,511,782 | null | 260 | 260 |
from collections import Counter
N = int(input())
A = list(map(int,input().split()))
S1 = Counter()
S2 = Counter()
for i,a in enumerate(A):
S1[i+1+a] += 1
S2[(i+1)-a] += 1
res = 0
for k,v in S1.items():
if S2[k] > 0:
res += v*S2[k]
print(res)
|
n = int(input())
a = list(map(int,input().split()))
import collections
p = []
q = []
d = collections.defaultdict(int)
e = collections.defaultdict(int)
for i in range(n):
p.append(a[i]+i+1)
for i in range(n):
q.append(-a[i]+i+1)
ans = 0
for i in range(n):
d[p[i]] += 1
e[q[i]] += 1
for i in d.keys():
ans += d[i]*e[i]
print(ans)
| 1 | 26,133,485,570,768 | null | 157 | 157 |
A, B, C, K = [int(_) for _ in input().split()]
print(K if K <= A else A if K <= A + B else A - (K - A - B))
|
A,B,C,K = map(int,input().split())
SCO = 0
if A>K:
SCO+=K
else:
SCO+=A
if B<=(K-A):
if C<=(K-A-B):
SCO-=C
else:
SCO-=K-A-B
print(SCO)
| 1 | 21,907,291,178,038 | null | 148 | 148 |
#!/usr/bin/env python3
def main():
import numpy as np
N = int(input())
testimony = np.zeros((N, N), dtype=np.int64)
for i in range(N):
A = int(input())
INF = 10 ** 10
for _ in range(A):
x, y = map(int, input().split())
testimony[i, x - 1] += 1 if y else -INF
# 正直者のパターンをbit全探索
ans = 0
for bit in range(1 << N):
honest = set()
pick = np.zeros(N, dtype=np.int64)
for i in range(N):
if bit & (1 << i):
honest.add(i)
pick += testimony[i, :]
flag = True
for j in range(N):
value = pick[j]
# 下記3つの内1つでも満たしたら，仮定が間違っていると分かる.
if (0
or (j in honest and value < 0) # 正直者なのに嘘つきと言われる
or (j not in honest and value > 0) # 嘘つきなのに正直者と言われる
or (value < 0 and value % INF != 0)): # 正直とも嘘つきとも言われる
flag = False
break
if flag:
ans = max(ans, len(honest))
print(ans)
if __name__ == '__main__':
main()
|
z=list(map(int,input().split()))
z.sort()
a=0
while True:
if z[1]==z[0]:
break
a=z[1]-z[0]
if z[0]%a==0:
z[1] = z[0]
z[0] = a
z.sort()
break
z[1]=z[0]
z[0]=a
z.sort()
print(z[0])
| 0 | null | 60,767,240,851,548 | 262 | 11 |
n = input()
t = len(n)+1
dp1 = [0] * t
dp2 = [0]*t
dp2[0] = 1
for i in range(t-1):
x = int(n[i])
dp1[i + 1] = min(dp1[i] + x, dp2[i] + 10 - x)
x += 1
dp2[i+1] = min(dp1[i]+x, dp2[i]+10-x)
print(dp1[-1])
|
"""
f(n) , f(n+1)の値を求める
f(3456)を求める時
f(0) = 0, f(1) = 1 とする
f(3) = min
(
f(0) + 3
f(1) + 7
)
f(4) = min
(
f(0) + 4
f(1) + 6
)
f(34) = min
(
f(3) + 4
f(4) + 6
)
f(35) = min
(
f(3) + 5
f(4) + 5
)
f(345) = min
(
f(34) + 5
f(35) + 5
)
f(346) = min
(
f(34) + 4
f(35) + 6
)
f(3456) = min
(
f(345) + 6
f(346) + 4
)
"""
N = input()
n = [int(i) for i in N]
f0 = 0
f1 = 1
dp = f0, f1
# 桁DP
for i in n:
# 支払い枚数を考える
fn_0 = min(dp[0] + i, dp[1] + 10 - i)
fn_1 = min(dp[0] + (i+1), dp[1] + 10 - (i+1))
dp = fn_0, fn_1
print(dp[0])
| 1 | 70,710,810,516,988 | null | 219 | 219 |
import itertools
import math
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
arr = [i for i in itertools.permutations([i for i in range(1, n+1)])]
a = arr.index(p)
b = arr.index(q)
print(abs(a-b))
|
import itertools
N = int(input())
P = tuple(map(int, input().split(' ')))
Q = tuple(map(int, input().split(' ')))
ls = [ x for x in itertools.permutations(range(1, N + 1)) ]
a = [ key for key, val in enumerate(ls) if P == val ][0] + 1
b = [ key for key, val in enumerate(ls) if Q == val][0] + 1
print(abs(a - b))
| 1 | 100,474,859,030,100 | null | 246 | 246 |
def judge():
if m == -1 or f == -1:
print("F")
elif m + f >= 80:
print("A")
elif m + f >= 65:
print("B")
elif m + f >= 50:
print("C")
elif m + f >= 30:
if r >= 50:
print("C")
else:
print("D")
else:
print("F")
while True:
m, f, r = map(int, input().split())
if m == f == r == -1:
break
judge()
|
data = []
while True:
in_line = raw_input().split()
m = int(in_line[0])
f = int(in_line[1])
r = int(in_line[2])
if m == -1 and f == -1 and r == -1:
break
if m == -1 or f == -1:
data.append("F")
elif m + f >= 80:
data.append("A")
elif m + f >= 65:
data.append("B")
elif m + f >= 50:
data.append("C")
elif m + f >= 30:
if r >= 50:
data.append("C")
else:
data.append("D")
else:
data.append("F")
for n in data:
print n
| 1 | 1,218,091,528,770 | null | 57 | 57 |
#coding: UTF-8
while True:
N, X = map(int, input().split())
if N == 0 and X == 0:
break
ans = 0
for i in range(1, N+1):
for j in range(1, N+1):
if i >= j:
continue
c = X - (i + j)
if c > j and c <= N:
ans += 1
print("%d"%(ans))
|
# coding:utf-8
while True:
cnt = 0
n,x = map(int, raw_input().split())
if n == 0 and x == 0:
break
for i in range(1,n+1):
for j in range(1,n+1):
for k in range(1,n+1):
if i < j and j < k and i + j + k == x:
cnt += 1
print cnt
| 1 | 1,296,400,510,172 | null | 58 | 58 |
X = int(input())
for x in range(1, 361):
if x * X % 360 == 0:
print(x)
exit()
|
N = int(input())
print((N //2 + N % 2) / N)
| 0 | null | 95,143,789,214,530 | 125 | 297 |
p = 10**9+7
N = int(input())
A = list(input().split())
B = [0 for _ in range(N)]
for i in range(N):
a = A[i]
b = bin(int(a))[2:]
b = "0"*(60-len(b))+b
B[i] = b
C = {i:0 for i in range(60)}
for j in range(60):
cnt = 0
for i in range(N):
if B[i][j]=="1":
cnt += 1
C[j] = cnt
tot = 0
for j in range(60):
n = C[j]
k = (N*(N-1))//2-(n*(n-1))//2-((N-n)*(N-n-1))//2
tot = (tot+k*(2**(60-1-j)))%p
print(tot)
|
import sys
input = sys.stdin.readline
MOD = pow(10, 9) + 7
n = int(input())
a = list(map(int, input().split()))
m = max(a)
num = [0] * 61
for x in a:
for j in range(61):
if (x >> j) & 1:
num[j] += 1
s = 0
#print(num)
for i in range(61):
s += (n - num[i]) * num[i] * pow(2, i, MOD) % MOD
print(s % MOD)
| 1 | 123,030,548,881,770 | null | 263 | 263 |
n,k=map(int,input().split())
lst=[list(map(int,input().split())) for i in range(k)]
mod=998244353
dp=[0]*(2*n+10)
dp[0]=1
dp[1]=-1
for i in range(n):
for l,r in lst:
dp[i+l]+=dp[i]
dp[i+r+1]-=dp[i]
dp[i+1]+=dp[i]
dp[i+1]%=mod
print(dp[n-1])
|
N, K = map(int, input().split())
X = [list(map(int, input().split())) for _ in range(K)]
MOD = 998244353
dp = [0] * N
sdp = [0] * (N + 1)
dp[0] = 1
sdp[1] = 1
for i in range(1, N):
for l, r in X:
dp[i] += sdp[max(0, i - l + 1)] - sdp[max(0, i - r)]
dp[i] %= MOD
sdp[i + 1] = sdp[i] + dp[i]
sdp[i + 1] %= MOD
print(dp[-1])
| 1 | 2,742,301,419,740 | null | 74 | 74 |
def atc_153b(a: str, b: str) -> str:
HN = a.split(" ")
H = int(HN[0])
N = int(HN[1])
A = b.split(" ")
A_int = [int(ai) for ai in A]
damage = sum(A_int)
if (H - damage) <= 0:
return "Yes"
else:
return "No"
a = input()
b = input()
print(atc_153b(a, b))
|
H, N = map(int, input().split())
A = list(map(int, input().split()))
if H - sum(A) <= 0:
print("Yes")
else:
print("No")
| 1 | 78,082,212,674,400 | null | 226 | 226 |
N = int(input())
A = [int(x) for x in input().split()]
B = [0]*(N+1)
if N == 0:
if A[0] != 1:
print(-1)
exit()
else:
print(1)
exit()
if A[0] != 0:
print(-1)
exit()
else:
B[0] = 1
C = [0]*(N+1)
C[0] = 1
for i in range(1,N+1):
C[i] = 2*(C[i-1] - A[i-1])
if C[i] < A[i]:
print(-1)
exit()
#print(C)
for i in range(N, 0, -1):
if i == N:
B[i] = A[i]
else:
B[i] = min(A[i]+B[i+1], C[i])
print(sum(B))
|
#E
N,K = map(int,input().split())
A = list(map(int,input().split()))
F = list(map(int,input().split()))
A.sort(reverse=True)
F.sort()
left = 0
right = 10**12
while True:
mid = (left+right)//2
if right - left <= 1:
count = 0
for i in range(N):
a = left//F[i]
count+=max(0,A[i]-a)
if count <= K:
ans = left
else:
ans = right
break
count = 0
for i in range(N):
a = mid//F[i]
count+=max(0,A[i]-a)
if count <= K:
right = mid
else:
left = mid
print(ans)
| 0 | null | 92,246,058,906,784 | 141 | 290 |
H = int(input())
ans = 1
if H != 1:
h = H
for i in range(1, 40):
if int(h/2) >= 2:
# print(i, ans, h, 'a')
ans += 2**i
h = int(h/2)
else:
# print(i, ans, h, 'b')
ans += 2**i
break
print(ans)
|
a,b,n = map(int,input().split())
if n < b:
print(a*n//b)
else:
print(a*(b-1)//b)
| 0 | null | 54,030,543,200,318 | 228 | 161 |
import math
a,b,c,d = map(float,input().split())
print(math.sqrt(((c-a)**2) + ((d-b)**2)))
|
n, m = map(int, input().split())
a = list()
for i in range(n):
a.append(list(map(int, input().split())))
b = list()
for i in range(m):
b.append(int(input()))
for i in range(n):
ans = 0
for j in range(m):
ans += a[i][j] * b[j]
print(ans)
| 0 | null | 652,632,736,848 | 29 | 56 |
def solve():
MOD = 10**9 + 7
INF = 10**10
N, K = map(int, input().split())
As = list(map(int, input().split()))
if K == N:
ans = 1
for A in As:
ans *= A
ans %= MOD
print(ans)
return
As.sort(key=lambda x: abs(x))
if max(As) < 0 and K%2 != 0:
ans = 1
for A in As[:K]:
ans *= A
ans %= MOD
print(ans)
return
As.reverse()
ans = 1
sgn = 1
for A in As[:K]:
ans *= A
ans %= MOD
if A < 0:
sgn *= -1
elif A == 0:
sgn = 0
if sgn >= 0:
print(ans)
return
maxNeg, maxNotNeg = -INF, -INF
minNeg, minPos = INF, INF
for A in As[:K]:
if A < 0:
maxNeg = max(maxNeg, A)
if A > 0:
minPos = min(minPos, A)
for A in As[K:]:
if A < 0:
minNeg = min(minNeg, A)
if A >= 0:
maxNotNeg = max(maxNotNeg, A)
if maxNeg == -INF or maxNotNeg == -INF:
ans *= pow(minPos, MOD-2, MOD) * minNeg
ans %= MOD
elif minNeg == INF or minPos == INF:
ans *= pow(maxNeg, MOD-2, MOD) * maxNotNeg
ans %= MOD
else:
if abs(maxNeg)*abs(minNeg) >= abs(minPos)*abs(maxNotNeg):
ans *= pow(minPos, MOD-2, MOD) * minNeg
ans %= MOD
else:
ans *= pow(maxNeg, MOD-2, MOD) * maxNotNeg
ans %= MOD
print(ans)
solve()
|
X, N = map(int, input().split())
p = list(map(int, input().split()))
ans = None
diff = 1000
if X not in p:
ans = X
else:
for i in range(-1, max(max(p), X)+2):
if i in p:continue
if abs(X - i) < diff:
diff = abs(X - i)
ans = i
print(ans)
| 0 | null | 11,836,973,146,102 | 112 | 128 |
a,b=map(int,input().split())
print((a//b)+1 if a%b!=0 else a//b)
|
import math
h, a = map(int, input().split())
print(math.ceil(h/a))
| 1 | 76,705,750,503,620 | null | 225 | 225 |
n=int(input())
ps=[0 for j in range(n+1)]
for i in range(n):
p,d,*vs=[int(j) for j in input().split()]
ps[p]=vs
dist=[-1 for i in range(n+1)]
d=0
queue=[1]
while queue:
pos=queue.pop(0)
if dist[pos] == -1:
dist[pos]=d
for i in ps[pos]:
if dist[i]==-1:
queue.append(i)
dist[i]=dist[pos]+1
for i in range(1,n+1):
print(i,dist[i])
|
def main():
n = int(input())
A = [0]*n
B = [0]*n
for i in range(n):
a,b = map(int,input().split())
A[i] = a
B[i] = b
A.sort()
B.sort()
if n%2 == 0:
m1 = (A[n//2-1]+A[n//2])/2
m2 = (B[n//2-1]+B[n//2])/2
print(int(2*(m2-m1))+1)
else:
print(B[(n+1)//2-1]-A[(n+1)//2-1]+1)
main()
| 0 | null | 8,667,546,304,830 | 9 | 137 |
import itertools
N = int(input())
P = tuple(map(int,input().split()))
Q = tuple(map(int,input().split()))
l = []
for i in range(1,N+1):
l.append(i)
tmp = sorted(list(itertools.permutations(l)))
p = tmp.index(P)
q = tmp.index(Q)
print(abs(p-q))
|
import math
def resolve():
import sys
input = sys.stdin.readline
r = int(input().rstrip())
print(r * 2 * math.pi)
if __name__ == "__main__":
resolve()
| 0 | null | 65,771,582,131,750 | 246 | 167 |
a,b = map(int,input().split())
ans=a*b
print(ans)
|
import sys
def log(s):
# print("| " + str(s), file=sys.stderr)
pass
def output(x):
print(x, flush=True)
def input_ints():
return list(map(int, input().split()))
def main():
f = input_ints()
print(f[0] * f[1])
main()
| 1 | 15,950,883,089,242 | null | 133 | 133 |
while True:
N, x = map(int,input().split())
if N == 0 and x == 0:
break
ctr = 0
for i in range(1, N+1):
for j in range(i+1, N+1):
k = x - i -j
if k <= j:
break
elif k <= N and j < k:
ctr += 1
#print("{} {} {}".format(i, j, k))
print(ctr)
|
def get_num(n, x):
ans = 0
for n3 in xrange(min(n, x - 3), (x + 2) / 3, -1):
for n2 in xrange(min(n3 - 1, x - n3 - 1), (x - n3 + 1) / 2 - 1, -1):
for n1 in xrange(min(n2 - 1, x - n3 - n2), 0, -1):
if n3 == x - n1 - n2:
ans += 1
break
return ans
data = []
while True:
[n, x] = [int(m) for m in raw_input().split()]
if [n, x] == [0, 0]:
break
if x < 3:
# print(0)
data.append(0)
else:
# print(get_num(n, x))
data.append(get_num(n, x))
for n in data:
print(n)
| 1 | 1,293,572,285,072 | null | 58 | 58 |
SW = input()
SW = [int(i) for i in list(SW.split())]
if SW[0]<=SW[1]:
print('unsafe')
else:
print('safe')
|
n,m,l = map(int,input().split())
A = []
for i in range(n):
a = [int(j) for j in input().split()]
A.append(a)
B = []
for j in range(m):
b = [int(k) for k in input().split()]
B.append(b)
for i in range(n):
c = []
for k in range(l):
x = 0
for j in range(m):
x += A[i][j]*B[j][k]
c.append(str(x))
print(" ".join(c))
| 0 | null | 15,285,186,257,208 | 163 | 60 |
x = int(input())
print(1-x)
|
print(int(not int(input())))
| 1 | 2,960,806,867,602 | null | 76 | 76 |
import itertools
import math
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
arr = [i for i in itertools.permutations([i for i in range(1, n+1)])]
a = arr.index(p)
b = arr.index(q)
print(abs(a-b))
|
import itertools
n = int(input())
p = list(map(int,input().split()))
q = list(map(int,input().split()))
l = [int(x) for x in range(1,n+1)]
i = 0
p_i = 0
q_i = 0
for v in itertools.permutations(l, len(l)):
i += 1
if p==list(v):
p_i = i
#print(list(v))
if q==list(v):
q_i = i
#print(i,list(v))
print(abs(p_i-q_i))
| 1 | 100,327,669,610,388 | null | 246 | 246 |
n, m = list(map(int,input().split()))
array = [list(map(int,input().split())) for i in range(n)]
b = [int(input()) for i in range(m)]
array_2 = [[0 for i in range(m)] for j in range(n)]
for i in range(n):
d = 0
for j in range(m):
c = array[i][j]*b[j]
d += c
print(d)
|
n,m = map(int,input().split())
v1 = [ map(int,input().split()) for i in range(n) ]
v2 = [ int(input()) for i in range(m) ]
for v in v1:
print(sum(map(lambda x,y:x*y,v,v2)))
| 1 | 1,154,981,380,030 | null | 56 | 56 |
# 171 A
X = input()
print('a') if X.islower() else print('A')
|
n,m = map(int,input().split())
D = list(map(int,input().split()))
INF = 10**5
dp = [INF for i in range(n+1)]
dp[0] = 0
for i in range(n+1):
for d in D:
if i+d <= n:
dp[i+d] = min(dp[i+d],dp[i]+1)
print(dp[n])
| 0 | null | 5,670,383,697,440 | 119 | 28 |
# -*- coding:utf-8 -*-
import sys
class Hash(object):
def __init__(self, size):
self._array = [None] * size
self._size = size
def _hash(self, key):
return key % self._size
def insert(self, key, value):
j = self._hash(key)
if self._array[j] is None:
self._array[j] = [value]
else:
self._array[j].append(value)
def find(self, key, value):
j = self._hash(key)
if self._array[j] is None:
return False
elif value in self._array[j]:
return True
else:
return False
def stoi(s):
ret = 0
p = 1
ctoi = {"A": 1, "C": 2, "G": 3, "T": 4}
for c in s:
ret += ctoi[c] * p
p *= 7
return ret
def dictionary(lst):
h = Hash(1046527)
ret = []
for val in lst:
if val[0] == "insert":
h.insert(stoi(val[1]), val[1])
elif val[0] == "find":
if h.find(stoi(val[1]), val[1]):
ret.append("yes")
else:
ret.append("no")
else:
raise ValueError
return ret
if __name__ == "__main__":
lst = [val.split() for val in sys.stdin.read().splitlines()]
n = int(lst.pop(0)[0])
print("\n".join(dictionary(lst)))
|
from itertools import permutations
import math
n = int(input())
x,y = [],[]
for _ in range(n):
x_, y_ =map(int,input().split())
x.append(x_)
y.append(y_)
c = list(permutations([i for i in range(1,n+1)],n))
g = [[-1]*(n+1) for _ in range(n+1)]
sum = 0
for ci in (c):
tmp = 0
for i in range(len(ci)-1):
if g[ci[i]][ci[i+1]] == -1:
tmp += math.sqrt((x[ci[i]-1]-x[ci[i+1]-1])**2
+ (y[ci[i]-1]-y[ci[i+1]-1])**2)
else:
tmp += g[ci[i]][ci[i+1]]
sum += tmp
print(sum/len(c))
| 0 | null | 74,400,218,549,250 | 23 | 280 |
A = input().split()
B = sorted(A)
C = map(str, B)
print(' '.join(C))
|
a,b,c=map(int,input().split())
if a>b:
a,b = b,a
if c<a:
a,b,c = c,a,b
if c<b:
a,b,c = a,c,b
print(a,b,c)
| 1 | 428,559,287,552 | null | 40 | 40 |
import sys
num = []
for i in sys.stdin:
H, W = i.split()
if H == W == '0':
break
num.append((int(H), int(W)))
for cnt in range(len(num)):
output = []
for h in range(num[cnt][0]):
before = '#'
for w in range(num[cnt][1]):
if h == 0:
if before == '.':
before = '#'
elif before == '#':
before = '.'
output.append(before)
for z in range(num[cnt][1]):
if output[z] == '#':
output[z] = '.'
elif output[z] == '.':
output[z] = '#'
for y in range(num[cnt][1]):
print(output[y],end='')
print()
print()
|
n, k = map(int, input().split())
mod = 10**9+7
def power(a, n, mod):
bi=str(format(n,"b")) #2進数
res=1
for i in range(len(bi)):
res=(res*res) %mod
if bi[i]=="1":
res=(res*a) %mod
return res
D = [0]*(k+1)
ans = 0
for i in reversed(range(1, k+1)):
a = k//i
d = power(a, n, mod)
j = 1
while i*j <= k:
d -= D[i*j]
j += 1
D[i] = d
ans += (d*i)%mod
print(ans%mod)
| 0 | null | 18,925,318,352,892 | 51 | 176 |
x, n = map(int, input().split())
p = list(map(int, input().split()))
i = 0
while True:
if x-i not in p:
print(x-i)
break
if x+i not in p:
print(x+i)
break
i += 1
|
# Σ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)
| 0 | null | 40,273,303,171,530 | 128 | 214 |
a=int(input())
asd=(a)+(a*a)+(a*a*a)
print(asd)
|
time = int(input())
hour = int(time / 3600)
minute = int(time % 3600/60)
second = int(time % 60 % 60)
print("%d:%d:%d" % (hour, minute, second))
| 0 | null | 5,251,487,810,510 | 115 | 37 |
x,y=map(int,input().split())
k=[1,2,3]
l=[0,300000,200000,100000]
p=0
if x in k:
p+=l[x]
if y in k:
p+=l[y]
if x==1 and y==1:
p+=400000
print(p)
|
N = int(input())
lst = list(map(int, input().split()))
c = True
for i in lst:
if i%2 ==0:
if i%3 != 0 and i%5 != 0:
c = False
break
if c:
print('APPROVED')
else:
print('DENIED')
| 0 | null | 104,975,130,359,232 | 275 | 217 |
A, B, C = map(int, input().split())
temp = B
B = A
A = temp
temp = C
C = A
A = temp
print(str(A) + " " + str(B) + " " + str(C))
|
#!/usr/bin/python3
def countpars(s):
lc = 0
rc = 0
for ch in s:
if ch == '(':
lc += 1
else:
if lc > 0:
lc -= 1
else:
rc += 1
return (lc, rc)
n = int(input())
ssl = []
ssr = []
for i in range(n):
(clc, crc) = countpars(input())
if clc >= crc:
ssl.append((clc, crc))
else:
ssr.append((clc, crc))
ssl.sort(key=lambda x: x[1])
ssr.sort(reverse=True)
lc = 0
rc = 0
for (clc, crc) in ssl:
lc -= crc
if lc < 0:
print('No')
exit()
lc += clc
for (clc, crc) in ssr:
lc -= crc
if lc < 0:
print('No')
exit()
lc += clc
if lc == 0:
print('Yes')
else:
print('No')
| 0 | null | 30,816,681,852,548 | 178 | 152 |
import sys
n, k = map(int, sys.stdin.buffer.read().split())
rem = n % k
print(min(rem, k - rem))
|
N, K = map(int, input().split())
N = N - (N // K)*K
ans = min(N, K-N)
print(ans)
| 1 | 39,403,430,959,840 | null | 180 | 180 |
def inner_prod(v0, v1):
ans = 0
for x0, x1 in zip(v0, v1):
ans += x0 * x1
return ans
def vector_add(v0, v1):
return [x0 + x1 for x0, x1 in zip(v0, v1)]
def vector_mul(vector, scaler):
return [scaler * x for x in vector]
def matrix_mul(matrix, vector):
ans = []
for row in matrix:
ans.append(inner_prod(row, vector))
return ans
def koch(p0, p1, max_depth, depth=0):
from math import sin, cos, pi
if depth == max_depth:
return []
R = [[cos(pi / 3), -sin(pi / 3)], [sin(pi / 3), cos(pi / 3)]]
p2 = vector_add(vector_mul(p0, 2 / 3), vector_mul(p1, 1 / 3))
p3 = vector_add(vector_mul(p0, 1 / 3), vector_mul(p1, 2 / 3))
p4 = vector_add(p2, matrix_mul(R, vector_add(p3, vector_mul(p2, -1))))
return [
koch(p0, p2, max_depth, depth + 1),
p2,
koch(p2, p4, max_depth, depth + 1),
p4,
koch(p4, p3, max_depth, depth + 1),
p3,
koch(p3, p1, max_depth, depth + 1),
]
def dfs_print(array):
if not array:
return
if isinstance(array[0], int) or isinstance(array[0], float):
print(*array)
else:
for child in array:
dfs_print(child)
n = int(input())
result = [[0, 0], koch([0, 0], [100, 0], n), [100, 0]]
dfs_print(result)
|
import math
n = int(input())
edge_s = (0.0, 0.0)
edge_e = (100.0, 0.0)
def print_tuple(tup):
print("%.8f %.8f"%(tup[0],tup[1]))
def koch(start, end, n):
if(n == 0):
return
s = ((2*start[0] + end[0]) / 3, (2*start[1] + end[1])/3)
t = ((start[0] + 2*end[0]) / 3, (start[1] + 2*end[1])/3)
u = (s[0] + (t[0]-s[0])*math.cos(math.pi/3)-(t[1]-s[1])*math.sin(math.pi/3), s[1] + (t[0]-s[0]) * math.sin(math.pi/3) + (t[1]-s[1]) * math.cos(math.pi/3))
n -= 1
koch(start, s, n)
print_tuple(s)
koch(s, u, n)
print_tuple(u)
koch(u, t, n)
print_tuple(t)
koch(t, end, n)
print_tuple(edge_s)
koch(edge_s, edge_e, n)
print_tuple(edge_e)
| 1 | 128,349,567,690 | null | 27 | 27 |
def selectionSort(A,N,cnt=0):
for i in range(N):
minj = i
for j in range(i,N):
if A[j] < A[minj]:
minj = j
A[i] , A[minj] = A[minj] , A[i]
if A[i] != A[minj]:
cnt += 1
return A , cnt
N = int(input())
A = list(map(int,input().split()))
X , cnt = selectionSort(A,N)
print(*X)
print(cnt)
|
# coding: utf-8
# Here your code !
def func():
try:
line = input()
except:
print("input error")
return -1
marks = ("S","H","C","D")
cards = []
while(True):
try:
line = input().rstrip()
elements = line.split(" ")
if(elements[0] in marks):
elements[1]=int(elements[1])
cards.append(elements)
else:
print("1input error")
return -1
except EOFError:
break
except :
print("input error")
return -1
result=""
for mark in marks:
for i in range(1,14):
if([mark,i] not in cards):
result += mark+" "+str(i)+"\n"
if(len(result)>0):
print(result.rstrip())
func()
| 0 | null | 533,303,331,510 | 15 | 54 |
import math
a,b,c = map(float, input().split())
cc = math.radians(c)
h = b * math.sin(cc)
S = a * h / 2
L = a + b + math.sqrt(h**2 + (a-b*math.cos(cc))**2)
print("{0:.10f}\n{1:.10f}\n{2:.10f}\n".format(S, L, h))
|
import math
A,B=map(int, input().split())
for i in range(1,1001):
if math.floor(i*0.08)==A and math.floor(i*0.1)==B:
print(i)
break
if i==1000:
print(-1)
| 0 | null | 28,450,041,788,438 | 30 | 203 |
N = int(input())
A = list(map(int,input().split()))
Q = int(input())
S = [list(map(int, input().split())) for l in range(Q)]
l = [0] * 10**6
tot = 0
for i in range(N) :
l[A[i]]+=1
tot += A[i]
for i in range(Q):
s0 = S[i][0]
s1 = S[i][1]
tot += s1 * (l[s0] + l[s1]) - (s0 * l[s0] + s1*l[s1])
l[s1] += l[s0]
l[s0] = 0
print(tot)
|
n=int(input())
a=list(map(int,input().split()))
cnt=[0]*(10**5+1)
for i in a:
cnt[i]+=1
xxx=sum(a)
q=int(input())
for i in range(q):
l,r=map(int,input().split())
pin=cnt[l]
cnt[r]+=pin
cnt[l]=0
xxx+=(r-l)*pin
print(xxx)
| 1 | 12,235,917,945,612 | null | 122 | 122 |
def main():
N = int(input())
l = []
for i in range(N):
l.append(str(input()))
s_l = set(l)
print(len(s_l))
main()
|
from collections import deque
d = deque()
for _ in range(int(input())):
a = input()
if "i" == a[0]: d.appendleft(int(a[7:]))
elif "F" == a[6]: d.popleft()
elif "L" == a[6]: d.pop()
else:
try: d.remove(int(a[7:]))
except: pass
print(*d)
| 0 | null | 15,057,766,062,508 | 165 | 20 |
n = int(input())
a = list(map(int, input().split()))
cnt = [0] * (10 ** 6 + 1)
for i in range(n):
cnt[a[i]] += 1
a_uniq = []
for i in range(10 ** 6 + 1):
if cnt[i] == 1:
a_uniq.append(i)
cnt = [0] * (10 ** 6 + 1)
for i in list(set(a)):
for j in range(2 * i, 10 ** 6 + 1, i):
cnt[j] = 1
ans = 0
for i in a_uniq:
if cnt[i] == 0:
ans += 1
print(ans)
|
N = int(input())
A = sorted(list(map(int,input().split())))
B = (10**6+1)*[0]
for a in A:
B[a]+=1
if B[a]==1:
for n in range(2*a,10**6+1,a):
B[n]+=2
print(B.count(1))
| 1 | 14,417,728,321,040 | null | 129 | 129 |
def modpow(a, x, mod):
if x == 0:
return 1
elif x % 2 == 0:
return modpow((a * a) % mod, x // 2, mod)
else:
return (modpow((a * a) % mod, x // 2, mod) * a) % mod
N, M, K = map(int, input().split(' '))
max_K = 3 * 10 ** 5
mod = 998244353
inv = [0 for i in range(max_K + 1)]
inv[0] = 1
inv[1] = 1
for i in range(2, K + 1):
inv[i] = modpow(i, mod - 2, mod)
choose = [0 for i in range(K + 1)]
choose[0] = 1
for i in range(1, K + 1):
choose[i] = choose[i - 1] * (((N - i) * inv[i]) % mod)
choose[i] %= mod
ans = 0
for i in range(N - 1 - K, N):
ans += modpow((M - 1), i, mod) * choose[N - i - 1]
ans %= mod
print((ans * M) % mod)
|
def main():
N, M, K = [int(x) for x in input().split()]
if M == 1:
if K == N - 1:
return 1
else:
return 0
if N == 1:
return M
mod = 998244353
fact = [1]
for i in range(1, N):
fact.append(fact[-1] * i % mod)
fact_inv = [pow(fact[-1], mod - 2, mod)]
for n in range(N - 1, 0, -1):
fact_inv.append(fact_inv[-1] * n % mod)
fact_inv = fact_inv[::-1]
m_1_pow = [1]
for _ in range(N):
m_1_pow.append(m_1_pow[-1] * (M - 1) % mod)
count = 0
for k in range(K + 1):
current = ((((m_1_pow[N - k - 1] * M) % mod) * fact[N - 1] % mod) * fact_inv[k] % mod) * fact_inv[N - 1 - k] % mod
count = (count + current) % mod
return count
if __name__ == "__main__":
print(main())
| 1 | 23,232,246,039,170 | null | 151 | 151 |
while(True):
H,W=list(map(int,input().split()))
if H==0 and W==0:
break
l1=""
for i in range(W):
if i%2==0:
l1+="#"
else:
l1+="."
l1+="\n"
l2=""
for i in range(W):
if i%2==0:
l2+="."
else:
l2+="#"
l2+="\n"
l=""
for i in range(H):
if i%2==0:
l+=l1
else:
l+=l2
print(l)
|
import sys
for i in sys.stdin.readlines()[:-1]:
h,w = map(int,i.strip().split())
for i in range(h):
for j in range(w):
if (i+j) % 2 == 0:
print('#',end='')
else:
print('.',end='')
print()
print()
| 1 | 896,975,405,802 | null | 51 | 51 |
import bisect
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
r=a[n-1]*2+1
l=0
while r-l>=2:
mid=(l+r)//2
#mid以上はいくつあるか
#答えはl以上r未満
cnt=0
for i in range(n):
cnt+=n-bisect.bisect_left(a,mid-a[i])
if cnt>=k:
l=mid
else:
r=mid
#lだとk個以上 rだとk個未満
ans,p,=0,0
b=[0]
for i in range(n):
p+=a[i]
b.append(p)
for i in range(n):
q=bisect.bisect_left(a,r-a[i])
ans+=b[n]-b[q]
ans+=a[i]*(n-q)
k-=n-q
ans+=l*k
print(ans)
|
n = int(input())
if n%2 == 0:
t=(n//2)/n
else:
t=(n//2+1)/n
print('{:.10f}'.format(t))
| 0 | null | 142,768,361,323,512 | 252 | 297 |
a,b = [int(i) for i in input().split()]
print(a*b,2*(a+b))
|
def bubble(A, N):
c = 0
flag = True
while flag:
flag = False
for j in range(N-1, 0, -1):
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
c += 1
flag = True
return A, c
if __name__ == "__main__":
N = int(input())
A = [int(i) for i in input().split()]
A, c = bubble(A, N)
print (*A)
print (c)
| 0 | null | 163,136,196,732 | 36 | 14 |
def main():
n = int(input())
s = input()
if n < 4:
print(0)
return
ans = s.count("R") * s.count("G") * s.count("B")
for i, si in enumerate(s[:-2]):
for j, sj in enumerate(s[i+1:-1]):
if si == sj:
continue
if i + 2*j+2 < n and si != s[i + 2*j+2] != sj:
ans -= 1
print(ans)
if __name__ == '__main__':
main()
|
N = int(input())
S = input()
R = set()
G = set()
B = set()
for i, s in enumerate(S):
if s == 'R':
R.add(i)
elif s == 'G':
G.add(i)
elif s == 'B':
B.add(i)
ans = 0
for r in R:
for g in G:
ans += len(B)
d = abs(r-g)
if (r+g) % 2 == 0 and (r+g)//2 in B:
ans -= 1
if r+d in B or g+d in B:
ans -= 1
if r-d in B or g-d in B:
ans -= 1
print(ans)
| 1 | 36,242,223,784,324 | null | 175 | 175 |
def main():
H = int(input())
W = int(input())
N = int(input())
print((N-1)//max(H,W) + 1)
if __name__ == '__main__':
main()
|
Alp = input()
if Alp.isupper() == True :
print('A')
else:
print('a')
| 0 | null | 49,760,608,949,788 | 236 | 119 |
class UnionFind:
def __init__(self, n):
self.par = [i for i in range(n+1)]
self.rank = [0]*(n+1)
def find(self, x):
if self.par[x] == x:
return x
else:
self.par[x] = self.find(self.par[x])
return self.par[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if self.rank[x] < self.rank[y]:
self.par[x] = y
else:
self.par[y] = x
if self.rank[x] == self.rank[y]:
self.rank[x] += 1
def same_check(self, x, y):
return self.find(x) == self.find(y)
N, M = map(int, input().split())
A = [0]*M
B = [0]*M
uf = UnionFind(N)
for i in range(M):
A[i], B[i] = map(int, input().split())
uf.union(A[i], B[i])
cnt = 0 #新しく作った橋の数
for j in range(1,N):
if uf.same_check(j, j+1) == False:
uf.union(j,j+1)
cnt+=1
print(cnt)
#print(uf.par[1:])
#print(uf.rank[1:])
|
import sys
def GcdLCM():
for line in sys.stdin:
x,y=map(int,line.split())
if x==None:
break
gcd = Gcd(x,y)
lcm = int(x*y/gcd)
print("{} {}".format(gcd,lcm))
def Gcd(x,y):
while x!=0:
x,y=y%x,x
return y
GcdLCM()
| 0 | null | 1,140,895,287,150 | 70 | 5 |
import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
A = list(itertools.permutations(range(1, N+1)))
for a in range(len(A)):
if A[a] == P:
p = a
if A[a] == Q:
q = a
print(abs(p - q))
|
import sys
import itertools
# import numpy as np
import time
import math
import heapq
sys.setrecursionlimit(10 ** 7)
from collections import defaultdict
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
# map(int, input().split())
# list(map(int, input().split()))
n = int(input())
adj = [[] for i in range(n)]
for i in range(n):
line = list(map(int, input().split()))
u = line[0]
for j in range(line[1]):
v = line[2 + j]
adj[u - 1].append(v - 1)
# BFS
import queue
q = queue.Queue()
visited = [False] * n
dist = [-1] * n
visited[0] = True
dist[0] = 0
q.put(0)
while not q.empty():
v = q.get()
for u in adj[v]:
if visited[u]:
continue
visited[u] = True
dist[u] = dist[v] + 1
q.put(u)
for i in range(n):
val = dist[i]
print(i + 1, val)
| 0 | null | 50,584,980,284,608 | 246 | 9 |
import math
import fractions
import collections
import itertools
from collections import deque
S=input()
N=len(S)
cnt=0
l=[]
"""
cnt=0
p=10**9+7
for i in range(K,N+2):
cnt=(cnt+((N-i+1)*i)+1)%p
#print(((N-i+1)*i)+1)
print(cnt)
"""
amari=[0]*(N+1)
num=0
for i in range(N):
num=num+pow(10,i,2019)*int(S[N-1-i])
amari[i+1]=num%2019
#print(amari)
c=collections.Counter(amari)
values=list(c.values()) #aのCollectionのvalue値のリスト(n_1こ、n_2こ…)
key=list(c.keys()) #先のvalue値に相当する要素のリスト(要素1,要素2,…)
#for i in range(len(key)):
# l.append([key[i],values[i]])#lは[要素i,n_i]の情報を詰めたmatrix
#xprint(l)
for i in range(len(values)):
cnt=cnt+(values[i]*(values[i]-1))//2
print(cnt)
|
import sys
input = sys.stdin.readline
P = 2019
def main():
S = input().rstrip()
N = len(S)
count = [0] * P
count[0] += 1
T = 0
for i in range(N):
T = (T + int(S[(N - 1) - i]) * pow(10, i, mod=P)) % P
count[T] += 1
ans = 0
for k in count:
ans = (ans + k * (k - 1) // 2)
print(ans)
if __name__ == "__main__":
main()
| 1 | 30,808,428,560,560 | null | 166 | 166 |
import sys
input = sys.stdin.readline
N = int(input())
ans = 0
for i in range(1,N+1):
if i%3 != 0 and i%5 !=0:
ans += i
print(ans)
|
Lists = [1, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
x = int(input())
print(Lists[x])
| 0 | null | 42,407,952,164,930 | 173 | 195 |
from sys import stdin
rs = lambda : stdin.readline().strip()
ri = lambda : int(rs())
ril = lambda : list(map(int, rs().split()))
def gcd(a, b):
if a % b == 0:
return b
else:
return gcd(b, a % b)
def main():
X = ri()
K = 360 // gcd(360, X)
print(K)
if __name__ == '__main__':
main()
|
from sys import stdin
from math import sqrt
x1, y1, x2, y2 = [float(x) for x in stdin.readline().rstrip().split()]
print(sqrt((x2-x1)**2 + (y2-y1)**2))
| 0 | null | 6,608,832,747,270 | 125 | 29 |
n = int(input())
d = {}
for i in range(n):
cmd = input()
if cmd[0] == 'i':
d[cmd[7:]] = 0
else:
print('yes' if cmd[5:] in d else 'no')
|
from collections import deque
D = set()
N = int(input())
for i in range(N):
c, s = input().split()
if c == "insert":
D.add(s)
elif c == "find":
if (s in D):
print("yes")
else:
print("no")
| 1 | 81,843,602,720 | null | 23 | 23 |
import sys
input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return input().rstrip().decode()
def II(): return int(input())
def FI(): return float(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()
from heapq import *
def main():
n,d,a=MI()
Q=[]
heapify(Q)
for _ in range(n):
x=LI()
heappush(Q,x)
ans=0
now=0
li=[[10**10,0]]
heapify(li)
while Q:
#print(Q,li,ans,now)
if Q[0][0]<li[0][0]:
x,h=heappop(Q)
if h-now>0:
k=(h-now-1)//a+1
ans+=k
now+=k*a
heappush(li,[x+2*d+1,-k*a])
else:
x,h=heappop(li)
now+=h
print(ans)
if __name__ == "__main__":
main()
|
from bisect import *
from math import *
N,D,A=map(int,input().split())
monsters=[list(map(int,input().split())) for _ in range(N)]
monsters.sort(key=lambda x:x[0])
killingrange=[0]*N
monsterspoint=[]
monstershp=[]
imos=[0]*N
for i in range(N):
monsterspoint.append(monsters[i][0])
monstershp.append(monsters[i][1])
for i in range(N):
ind=bisect(monsterspoint,monsterspoint[i]+2*D)
killingrange[i]=ind
#print(killingrange)
cnt=0
for i in range(N):
monstershp[i]=monstershp[i]+imos[i]
if (monstershp[i]>0):
cnt=cnt+ceil(monstershp[i]/A)
imos[i]=imos[i]-A*ceil(monstershp[i]/A)
if killingrange[i]<N:
imos[killingrange[i]]=imos[killingrange[i]]+A*ceil(monstershp[i]/A)
monstershp[i]=monstershp[i]-A*ceil(monstershp[i]/A)
if i<N-1:
imos[i+1]=imos[i]+imos[i+1]
#print(monstershp,imos)
print(cnt)
| 1 | 82,299,438,339,552 | null | 230 | 230 |
n = int(input())
numlist = map(int, input().split())
numarr = list(numlist)
isevenList = [i for i in numarr if i % 2 == 0]
answerList = []
for i in isevenList:
if i % 3 == 0 or i % 5 == 0:
answerList.append("APPROVED")
else:
answerList.append("DENIED")
if "DENIED" in answerList:
print("DENIED")
else:
print("APPROVED")
|
N = int(input())
A = list(map(int, input().split()))
is_approved = True
for i in range(N):
if A[i] % 2 != 0:
continue
if A[i] % 3 != 0 and A[i] % 5 != 0:
is_approved = False
break
if is_approved:
print("APPROVED")
else:
print("DENIED")
| 1 | 68,882,015,209,130 | null | 217 | 217 |
a, b = input().split()
na = int(a)
nb = int(b)
sa = a * nb
sb = b * na
print(sa if sa < sb else sb)
|
a, b = list(map(int, input().split()))
ret = (str(a) * b)
if a > b:
ret = (str(b) * a)
print("{}".format(ret))
| 1 | 84,794,397,029,648 | null | 232 | 232 |
import math
N = int(input())
oturi = math.ceil(N/1000)*1000-N
print(oturi)
|
n,k = map(int,input().split())
a = (n-k+2)*(((k+n+1)*(n+1))+2)//2
b = (((n+1)*(n+2)))*(2*n+3)//6
c = (((k-1)*k))*(2*k-1)//6
print((a-b+c)%(10**9+7))
| 0 | null | 20,770,342,746,650 | 108 | 170 |
n,m,k = map(int, input().split())
# ---------------------------------------
# nCr(n, r, m) テンプレ
mod = 998244353
fac = [1,1] # 階乗 n!
inv = [0,1] # 逆元 1/n
finv = [1,1] # 逆元の階乗 (n^-1)! = (1/n)!
for i in range(2, n+1):
fac.append( (fac[-1] * i ) % mod )
inv.append( (-inv[mod%i] * (mod//i)) % mod )
finv.append( (finv[-1] * inv[-1]) % mod )
def nCr(n, r, m):
if (n<0 or r<0 or n<r): return 0
r = min(r, n-r)
return fac[n] * finv[n-r] * finv[r] % m
# ---------------------------------------
ans = 0
colors = m
for p in range(n-1, -1, -1):
if p <= k: ans += colors * nCr(n-1, p, mod) % mod
colors = colors * (m - 1) % mod
ans %= mod
print(ans)
|
N, M, K = map(int, input().split())
mod = 998244353
inv = [0,1]
for i in range(2, N):
inv.append((-inv[mod%i]*(mod//i))%mod)
if N == 1:
print(M)
exit()
m = [1]
s = 1
for _ in range(N-1):
s = s*(M-1)%mod
m.append(s)
ncombi = [1]
c = 1
for k in range(K):
c = c*(N-1-k)*inv[k+1]
c %= mod
ncombi.append(c)
ans = 0
for k in range(K+1):
ans = ans + m[-k -1]*ncombi[k]
ans %= mod
ans = ans*M%mod
print(ans)
| 1 | 23,266,103,085,280 | null | 151 | 151 |
class tree:
def __init__(self,n):
self.edge = [set() for i in range(n)]
def add_edge_dual(self,f,e):
self.edge[f].add(e)
self.edge[e].add(f)
def add_edge_single(self,f,e):
self.edge[f].add(e)
def connected(self,node):
return self.edge(node)
def dfs(graph,s):
visited = [False for i in range(len(graph.edge))]
distance = [-1 for i in range(len(visited))]
visited[s] = True
distance[s] = 0
buf = [[s]]
now = s
while len(buf) != 0:
nexts = buf[0]
buf = buf[1:]
temp = []
for nex in nexts:
for child in graph.edge[nex]:
if visited[child] == False:
distance[child] = distance[nex]+1
temp.append(child)
visited[child] = True
else:
continue
if len(temp) == 0:
continue
else:
buf.append(temp)
return distance
n,u,v = map(int,input().split())
t = tree(n)
for i in range(n-1):
a,b = map(int,input().split())
t.add_edge_dual(a-1,b-1)
taka = dfs(t,u-1)
aoki = dfs(t,v-1)
aofar = -1
for i in range(n):
if taka[i] < aoki[i]:
if aoki[i] > aofar:
aofar = aoki[i]
print(aofar-1)
# print(sorted(taka,key=lambda x:-x))
# print(sorted(aoki,key=lambda x:-x))
#
# print()
# print(far,aofar)
|
def main():
n,p = map(int,input().split())
s = input()
if p == 2 or p == 5:
ans = 0
for i in range(n-1,-1,-1):
if int(s[i]) % p == 0:
ans += i+1
print(ans)
exit()
l = [0]*p
l[0] += 1
s1 = s[::-1]
ten = 1
mod = 0
for i in range(n):
mod += int(s1[i])*ten%p
mod %= p
ten = ten*10%p
l[mod] += 1
ans = 0
for i in l:
ans += (i-1)*i//2
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 87,863,910,826,172 | 259 | 205 |
n,m = map(int,input().split())
a = [1]*(n+1)
b = [0]*(n+1)
for i in range(m):
x,y = map(int,input().split())
u = x
while a[u]==0:
u = b[u]
v = y
while a[v]==0:
v = b[v]
if u!=v:
b[v] = u
b[y] = u
b[x] = u
a[u] += a[v]
a[v] = 0
print(max(a))
|
N = int(input())
A = [int(i) for i in input().split()]
if N == 0 and A[0] != 1:
print(-1)
exit()
nodes = [0] * (N+1)
nodes[0] = 1
for i in range(1, N+1):
node = (nodes[i-1]-A[i-1])*2
if node < A[i]:
print(-1)
exit()
nodes[i] = node
#print(nodes)
nodes[-1] = A[-1]
for i in range(N-1, -1, -1):
nodes[i] = min(nodes[i], nodes[i+1]+A[i])
#print(nodes)
print(sum(nodes))
| 0 | null | 11,418,166,130,580 | 84 | 141 |
a=input()
if a==a.upper():
print("A")
else:
print("a")
|
a=input()
if 65<=ord(a)<=90:
print('A')
else:
print('a')
| 1 | 11,324,254,191,434 | null | 119 | 119 |
import sys
S = input()
T = input()
if not ( 1 <= len(S) <= 2*10**5 ): sys.exit()
if not ( len(S) == len(T) ): sys.exit()
if not ( S.islower() and T.islower() ): sys.exit()
count = 0
for I in range(len(S)):
if S[I] != T[I]:
count += 1
print(count)
|
S = input()
T = input()
list_s = []
list_t = []
counter = 0
for i in range(0, len(S)):
list_s.append(S[i])
list_t.append(T[i])
if S[i] != T[i]:
list_s[i] = list_t[i]
counter += 1
print(counter)
| 1 | 10,500,696,734,700 | null | 116 | 116 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.