code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
from decimal import *
x,y,z = map(int,input().split())
a=Decimal(x)
b=Decimal(y)
c=Decimal(z)
if Decimal((c-a-b)**Decimal(2)) > Decimal(Decimal(4)*a*b) and c-a-b > 0:
print('Yes')
else:
print('No')
|
import collections
n = int(input())
d = list(map(int,input().split()))
mod = 998244353
ans = 0
c = collections.Counter(d)
if c[0] == 1 and d[0] == 0:
ans = 1
for i in range(1,max(d)+1):
if c[i] == 0:
ans = 0
break
ans *= pow(c[i-1],c[i],mod)
ans %= mod
print(ans%mod)
| 0 | null | 103,207,450,013,382 | 197 | 284 |
import sys
sys.stdin.readline() # ?????????
data = sys.stdin.readline().strip().split(' ')
data.reverse()
print(' '.join(data))
|
n = input()
a = list(map(lambda x : int(x), input().split(" ")))
for i, a_ in enumerate(reversed(a)):
if i == 0:
print("%d" % a_, end="")
else:
print(" %d" % a_, end="")
print()
| 1 | 977,962,835,148 | null | 53 | 53 |
h, a = map(int,input().split())
print(h//a + min(h%a,1))
|
def main():
num = list(map(int,input().split()))
if num[0]%num[1]==0:
print(int(num[0]/num[1]))
else:
print(int(num[0]/num[1])+1)
main()
| 1 | 76,944,887,668,114 | null | 225 | 225 |
N,D = map(int,input().split())
cnt = 0
for i in range(N):
if sum(map(lambda x:x**2,map(int,input().split())))**0.5 <= D:
cnt += 1
print(cnt)
|
n,d=map(int,input().split());print(sum([d**2>=a**2+b**2 for a,b in [list(map(int,input().split())) for _ in range(n)]]))
| 1 | 5,916,174,985,710 | null | 96 | 96 |
# coding=utf-8
class Dice(object):
def __init__(self, label):
self.label = label
def _rotateS(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s5, s1, s3, s4, s6, s2]
def _rotateN(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s2, s6, s3, s4, s1, s5]
def _rotateE(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s4, s2, s1, s6, s5, s3]
def _rotateW(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s3, s2, s6, s1, s5, s4]
def _spinPos(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s4, s2, s5, s3, s6]
def _spinNeg(self):
s1, s2, s3, s4, s5, s6 = self.label
self.label = [s1, s3, s5, s2, s4, s6]
def rotate(self, r):
if r == 'S':
self._rotateS()
elif r == 'N':
self._rotateN()
elif r == 'E':
self._rotateE()
elif r == 'W':
self._rotateW()
elif r == 'SP':
self._spinPos()
elif r == 'SN':
self._spinNeg()
elif r == '2S':
self._rotateS()
self._rotateS()
elif r == '2SP':
self._spinPos()
self._spinPos()
def getLabel(self, i):
return self.label[i - 1]
def match(self, top, front):
iTop = self.label.index(top) + 1
topRot = {1: '', 2: 'N', 3: 'W', 4: 'E', 5: 'S', 6: '2S'}
self.rotate(topRot[iTop])
iFront = self.label.index(front) + 1
frontRot = {2: '', 3: 'SN', 4: 'SP', 5: '2SP'}
self.rotate(frontRot[iFront])
def main():
d = Dice(map(int, raw_input().split()))
n = input()
for _ in xrange(n):
top, front = map(int, raw_input().split())
d.match(top, front)
print d.getLabel(3)
if __name__ == '__main__':
main()
|
# Take the input K
# Take the inpus S
#Compare the length of S with K and put in in length
#If length<=K... print all
#If length>K... print some of the character
K = int(input()) # 0(1)
S = input() #0(1)
second_answer = [] #0(1)
x = 0 #0(1)
length = len(S) #0(1)
if length <= K :
print(S) #0(1)
else:
while x<K : #0(K)
print(S[x], end= (""))
x += 1
print("...")
| 0 | null | 9,952,098,813,410 | 34 | 143 |
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
k = int(input())
tmp = 0
res = ""
for i in range(k):
res += "ACL"
print(res)
|
_str = ""
_k = int(input())
for _i in range(_k):
_str += "ACL"
print(_str)
| 1 | 2,157,250,578,300 | null | 69 | 69 |
s = input()
k = int(input())
c = s[0]
l = 1
a = []
for i in range(1, len(s)):
if s[i] == c:
l += 1
else:
a.append(l)
c = s[i]
l = 1
a.append(l)
ans = 0
if len(a) == 1:
# s consists of one character
ans += (a[0] * k) // 2
elif s[0] == s[-1]:
ans += a[0] // 2
ans += ((a[0] + a[-1]) // 2) * (k - 1)
for i in range(1, len(a) - 1):
ans += (a[i] // 2) * k
ans += a[-1] // 2
else:
for i in range(len(a)):
ans += (a[i] // 2) * k
print(ans)
|
def W(d):
#d[i][j]: iからjへの最短距離
for k in range(n):
for i in range(n):
for j in range(n):
d[i][j] = min(d[i][j],d[i][k] + d[k][j])
return d
##############################
n,w,l= map(int,input().split()) #n:頂点数 w:辺の数
d = [[10**14]*n for i in range(n)]
#d[u][v] : 辺uvのコスト(存在しないときはinf)
for i in range(w):
x,y,z = map(int,input().split())
if z>l:
continue
x=x-1
y=y-1
d[x][y] = z
d[y][x] = z
for i in range(n):
d[i][i] = 0 #自身のところに行くコストは０
D=W(d)
G=[[10**4]*n for i in range(n)]
for i in range(n):
for j in range(n):
if D[i][j]>l:
continue
G[i][j]=1
WW=W(G)
for i in range(int(input())):
a,b=map(int,input().split())
a=a-1
b=b-1
if WW[a][b]>=10**4:
print(-1)
else:
print(WW[a][b]-1)
| 0 | null | 173,772,626,614,340 | 296 | 295 |
n,m,l=map(int,input().split())
a = [[0 for i in range(m)] for j in range(n)]
#print(a)
b = [[0 for i in range(1)] for j in range(m)]
#print(b)
A=[]
B=[]
for j in range (n):
a = [int(x) for x in input().split()]
A.append(a)
#print(A)
for i in range(m):
b = [int(y) for y in input().split()]
B.append(b)
#print(B)
#print(A[1][1])
for j in range (0,n):
F=[]
#print(j)
for k in range (0,l):
S=0
for i in range (0,m):
B1=B[i][k]
A1=A[j][i]
#print(A1)
#print(A1,B1,sep=" ")
S=S+int(A1)*int(B1)
F.append(S)
#print(S,end='')
#rint('@',end='')
print(*F)
|
n, m, l = map(int, input().split())
A = []
B = []
for line in range(n):
A.append(list(map(int, input().split())))
for line in range(m):
B.append(list(map(int, input().split())))
C = []
for lines in range(n):
C.append([sum([A[lines][i] * B[i][j] for i in range(m)]) for j in range(l)])
print(" ".join(map(str, C[lines])))
| 1 | 1,434,342,006,162 | null | 60 | 60 |
k = int(input())
a = 7 % k
count = 1
for i in range(1,k+1):
if a == 0:
print(count)
break
else:
a = (10 * a + 7) % k
count += 1
if i == k:
print(-1)
|
moji = input()
if moji.isupper():
print('A')
else:
print('a')
| 0 | null | 8,709,411,572,150 | 97 | 119 |
import sys
n, k = map(int, input().split())
mod = 998244353
dp = [0] * (n+1)
dp[1] = 1
r = [tuple(map(int, input().split())) for _ in range(k)]
s = [0 for _ in range(k)]
for i in range(2, n + 1):
sums = 0
for j in range(k):
s[j] += dp[max(0, i - r[j][0])] - dp[max(0, i - r[j][1] - 1)]
s[j] %= mod
sums = (sums + s[j]) % mod
dp[i] = sums
print(dp[n])
|
#n回,m回 X =n + 2*m Y = 2*n + m
X,Y = map(int,input().split())
import numpy as np
from functools import reduce
import math
a = [[1, 2], [2, 1]]
#次に逆行列を求めます。
mod = pow(10,9)+7
b = np.linalg.inv(a)
Z = np.array([[X],[Y]])
n,m=np.dot(b,Z)
p,q = *n,*m
def comb(n,k,p):
if k==0:
return 1
A = reduce(lambda x,y:x*y%p ,[n-k+1+i for i in range(k)])
B = reduce(lambda x,y:x*y%p ,[i+1 for i in range(k)])
return A*pow(B,p-2,p)%p
if p<0 or q<0:
print(0)
elif not abs(p-round(p))<pow(10,-3) or not abs(q-round(q))<pow(10,-3):
print(0)
elif p==0 and q==0:
print(0)
elif p==0:
print(1)
elif q==0:
print(1)
else:
n = int(round(p))
m = int(round(q))
ans = comb(n+m,m,mod)
print(ans%mod)
| 0 | null | 76,706,428,835,972 | 74 | 281 |
x,k,d = map(int, input().split())
if x == 0:
if k % 2 == 1:
x = d
elif x > 0:
if x >= k*d:
x -= k*d
else:
n = x//d
x -= n*d
k -= n
if k%2 ==1:
x -= d
else:
if x <= -(k*d):
x += k*d
else:
n = abs(x)//d
x += n*d
k -= n
if k%2 ==1:
x += d
print(abs(x))
|
x,y,z=map(int,input().split())
x,y=y,x
x,z=z,x
print(x,y,z,sep=" ")
| 0 | null | 21,696,682,947,548 | 92 | 178 |
while True:
first_string=input()
if first_string=="-":
break
lst=list(first_string)
m=int(input())
for i in range(m):
h=int(input())
for l in range(1,h+1):
letter=lst.pop(0)
lst.insert(len(lst),letter)
answer_string=''
for m in lst:
answer_string+=m
print(answer_string)
|
f=n=0
while 1:
a=input()
if a.isdigit():
if n==1:s=s[int(a):]
n=1
else:
if f==1:print(s[:l])
if'-'==a:break
f=1
n=0
l=len(a)
s=a*100
| 1 | 1,880,944,507,180 | null | 66 | 66 |
N,K,S = map(int,input().split())
ANS = [S] * K
if S != 10 ** 9:
ANS += [S+1] * (N-K)
else:
ANS += [S-1] * (N-K)
print(" ".join(map(str,ANS)))
|
from sys import stdin
a, b, c = (int(n) for n in stdin.readline().rsplit())
answer = "Yes" if a < b < c else "No"
print(answer)
| 0 | null | 45,646,295,235,872 | 238 | 39 |
from collections import Counter
N = int(input())
A = [int(i) for i in input().split()]
num = set(A)
count = Counter(A)
dp = [True] * (10**6 + 1)
for a in num:
for n in range(a+a, 10**6+1, a):
dp[n] = False
ans = 0
for a in num:
if count[a] == 1 and dp[a] == True:
ans += 1
print(ans)
|
from heapq import heappush, heappop
from collections import deque,defaultdict,Counter
import itertools
from itertools import permutations,combinations
import sys
import bisect
import string
#import math
#import time
#import random # randome is not available at Codeforces
def I():
return int(input())
def MI():
return map(int,input().split())
def LI():
return [int(i) for i in input().split()]
def LI_():
return [int(i)-1 for i in input().split()]
def StoI():
return [ord(i)-97 for i in input()]
def show(*inp,end='\n'):
if show_flg:
print(*inp,end=end)
YN=['Yes','No']
mo=10**9+7
inf=float('inf')
#eps=10**(-10)
#ts=time.time()
#sys.setrecursionlimit(10**6)
input=lambda: sys.stdin.readline().rstrip()
show_flg=False
show_flg=True
def wf(d):
n=len(d)
for k in range(n):# // 経由する頂点
for i in range(n):# // 始点
for j in range(n):# // 終点
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
n,m,l=MI()
d=[[inf]*n for _ in range(n)]
for i in range(m):
a,b,c=LI_()
d[a][b]=c+1
d[b][a]=c+1
d=wf(d)
g=[[inf]*n for i in range(n)]
for i in range(n):
for j in range(i+1,n):
if d[i][j]<=l:
g[i][j]=1
g[j][i]=1
g=wf(g)
q=I()
for _ in range(q):
s,t=LI_()
if g[s][t]==inf:
ans=-1
else:
ans=g[s][t]-1
print(ans)
| 0 | null | 93,941,713,294,542 | 129 | 295 |
from collections import deque
n = int(input())
l = list(map(int,input().split()))
l.sort()
largest = l[-1]
que = deque(l)
cnt = n
ans = 0
while cnt > 0:
x = que.pop()
ans += x
cnt -= 1
if cnt != 0:
ans += x
cnt -= 1
print(ans-largest)
|
n = int(input())
p_list = input().split()
p_list = map(int,p_list)
p_list = sorted(p_list,reverse=True)
ans_list = []
ans = 0
for i in range(0,len(p_list)):
if i!=0:
ans_list.append(p_list[i])
ans_list.append(p_list[i])
else:
ans_list.append(p_list[i])
for i in range(0,n-1):
ans += int(ans_list[i])
print(ans)
| 1 | 9,224,871,923,708 | null | 111 | 111 |
n = int(input())
a = sorted(list(map(int, input().split())))
ans = a.pop()
if n % 2:
for i in range((n - 2) // 2):
ans += a.pop() * 2
ans += a.pop()
print(ans)
else:
for i in range((n - 2) // 2):
ans += a.pop() * 2
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse=True)
cnt = 0
for i in range(len(A)):
if i == 0:
continue
cnt += A[int(i/2)]
print(cnt)
| 1 | 9,062,066,876,710 | null | 111 | 111 |
#!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
import numpy as np
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
n,m = MI()
graph = [[] for _ in range(n+1)]
for i in range(m):
a,b = MI()
graph[a].append(b)
graph[b].append(a)
dist = [-1]*(n+1)
dist[0] = 0
dist[1] = 0
d = deque()
d.append(1)
ans = [0]*(n+1)
while d:
v = d.popleft()
for i in graph[v]:
if dist[i] != -1:
continue
ans[i] = v
dist[i] = 0
d.append(i)
print("Yes")
for i in ans[2:]:
print(i)
|
from collections import deque
n, m = map(int, input().split())
links = [[] for _ in range(n)]
for _ in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
links[a].append(b)
links[b].append(a)
ans = [-1] * n
ans[0] = 0
q = deque([(0, 0)])
while q:
room, prev = q.popleft()
for next_ in links[room]:
if ans[next_] < 0:
ans[next_] = room
q.append((next_, room))
print('Yes')
for i in range(1, n):
print(ans[i] + 1)
| 1 | 20,392,930,413,140 | null | 145 | 145 |
import sys
input = sys.stdin.readline
from operator import itemgetter
sys.setrecursionlimit(10000000)
INF = 10**30
def main():
n, m = list(map(int, input().strip().split()))
c = [0] + sorted(list(map(int, input().strip().split())))
dp = [[0] * (n+1) for _ in range(m+1)]
dp[0] = [INF] * (n+1)
dp[0][0] = 0
for i in range(1, m+1):
for j in range(n+1):
if j-c[i] < 0:
dp[i][j] = dp[i-1][j]
else:
dp[i][j] = min(dp[i-1][j], dp[i][j-c[i]]+1)
print(dp[m][n])
if __name__ == '__main__':
main()
|
n,m = map(int,input().split())
coins = sorted(list(map(int,input().split())),reverse=True)
dp = [float("inf")]*50001
dp[0] = 0
for i in range(50001):
for coin in coins:
if i+coin > 50000:
continue
else:
dp[i+coin] = min(dp[i+coin], dp[i]+1)
print(dp[n])
| 1 | 137,741,394,142 | null | 28 | 28 |
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
A = list(map(int, input().split()))
ans = 0
d = defaultdict(int)
for a in A:
d[a] += 1
ans += a
Q = int(input())
for i in range(Q):
B, C = map(int, input().split())
if d[B] != 0:
ans -= B * d[B]
ans += C * d[B]
d[C] += d[B]
d[B] = 0
print(ans)
def main():
solve()
if __name__ == '__main__':
main()
|
import numpy as np
from collections import Counter
N=int(input())
Alist=list(map(int,input().split()))
Q=int(input())
bc=[]
for _ in range(Q):
bc.append(list(map(int,input().split())))
count=Counter(Alist)
result=0
for key,value in count.items():
result+=key*value
for i in range(Q):
if bc[i][0] in count.keys():
result+=(bc[i][1]-bc[i][0])*count[bc[i][0]]
count[bc[i][1]]+=count[bc[i][0]]
count[bc[i][0]]=0
print(result)
| 1 | 12,157,781,842,788 | null | 122 | 122 |
class UnionFind:
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return "\n".join("{}: {}".format(r, self.members(r)) for r in self.roots())
n, m, k = map(int, input().split())
friends = UnionFind(n)
direct_friends = [0] * n
enemies = [[] for _ in range(n)]
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
direct_friends[a] += 1
direct_friends[b] += 1
friends.union(a, b)
for i in range(k):
c, d = map(int, input().split())
c -= 1
d -= 1
enemies[c].append(d)
enemies[d].append(c)
ans = []
for i in range(n):
num = friends.size(i) - 1 - direct_friends[i]
for enm in enemies[i]:
if friends.same(i, enm):
num -= 1
ans.append(num)
print(*ans)
|
#!/usr/bin/env python3
import sys
from collections import deque
sys.setrecursionlimit(1000000)
class UnionFind:
def __init__(self, num):
self.par = list(range(1,num+1))
self.size = [1]*num
def root(self, n):
if self.par[n-1] != n:
self.par[n-1] = self.root(self.par[n-1])
return self.par[n-1]
def unite(self, a, b):
a=self.root(a)
b=self.root(b)
if a!=b:
self.par[b-1]=a
self.size[a-1] += self.size[b-1]
return
def get_size(self, n):
return self.size[self.root(n)-1]
def solve(N: int, M: int, K: int, A: "List[int]", B: "List[int]", C: "List[int]", D: "List[int]"):
fris = [0]*N
blos = [0]*N
union = UnionFind(N)
for ai, bi in zip(A, B):
union.unite(ai,bi)
fris[ai-1]+=1
fris[bi-1]+=1
for ci, di in zip(C, D):
if union.root(ci) == union.root(di):
blos[ci-1]+=1
blos[di-1]+=1
ans = [0]*N
for i in range(1,N+1):
s = union.get_size(i)
s -= fris[i-1]
s -= blos[i-1]
s -= 1
ans[i-1] = s
print(*ans)
return
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
N = int(next(tokens)) # type: int
M = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
A = [int()] * (M) # type: "List[int]"
B = [int()] * (M) # type: "List[int]"
for i in range(M):
A[i] = int(next(tokens))
B[i] = int(next(tokens))
C = [int()] * (K) # type: "List[int]"
D = [int()] * (K) # type: "List[int]"
for i in range(K):
C[i] = int(next(tokens))
D[i] = int(next(tokens))
solve(N, M, K, A, B, C, D)
if __name__ == '__main__':
main()
| 1 | 61,346,257,218,652 | null | 209 | 209 |
n,k=list(map(int,input().split()))
prices=list(map(int , input().split()))
prices.sort()
amount=0
for i in range(0,k):
amount+=prices[i]
print(amount)
|
N, K = [int(v) for v in input().split()]
P = [int(v) for v in input().split()]
print(sum(sorted(P)[:K]))
| 1 | 11,541,072,393,646 | null | 120 | 120 |
import sys
from scipy.sparse.csgraph import csgraph_from_dense
from scipy.sparse.csgraph import floyd_warshall
input = sys.stdin.readline
n, m, energy = map(int, input().split())
edges = [[float('INF')]*n for _ in range(n)]
for i in range(m):
a, b, c = map(int, input().split())
edges[a-1][b-1] = c
edges[b-1][a-1] = c
G = csgraph_from_dense(edges, null_value=float('INF'))
dist = floyd_warshall(G) # dist[i][j] = min_distance between i and j
L_edges = [[0]*n for _ in range(n)]
for i in range(n-1):
for j in range(i, n):
if dist[i][j] <= energy:
L_edges[i][j] = 1
L_edges[j][i] = 1
G = csgraph_from_dense(L_edges, null_value=0)
answers = floyd_warshall(G)
for i in range(n):
for j in range(n):
if answers[i][j] == float('INF'):
answers[i][j] = 0
answers[j][i] = 0
Q = int(input())
for i in range(Q):
s, t = map(int, input().split())
ans = answers[s-1][t-1] - 1
print(int(ans))
|
import collections
N, M = map(int, input().split())
ways = collections.defaultdict(set)
for _ in range(M):
a, b = map(int, input().split())
a -= 1
b -= 1
ways[a].add(b)
ways[b].add(a)
dist = [-1] * N
q = collections.deque()
dist[0] = True
q.append(0)
while q:
n = q.popleft()
for adjacent in ways[n]:
if dist[adjacent] != -1:
continue
dist[adjacent] = dist[n] + 1
q.append(adjacent)
if -1 in dist:
print('No')
else:
print('Yes')
for n, d in enumerate(dist):
if n == 0:
continue
for adjacent in ways[n]:
if d - 1 == dist[adjacent]:
print(adjacent + 1)
break
| 0 | null | 97,112,239,172,640 | 295 | 145 |
import sys
input = sys.stdin.readline
from collections import Counter, defaultdict
def read():
H, W, M = map(int, input().strip().split())
HW = []
for i in range(M):
h, w = map(int, input().strip().split())
HW.append((h, w))
return H, W, M, HW
def solve(H, W, M, HW):
hcount = Counter()
wcount = Counter()
for h, w in HW:
hcount[h] += 1
wcount[w] += 1
hm = hcount.most_common()
wm = wcount.most_common()
hmax = hm[0][1]
wmax = wm[0][1]
hn = len([1 for k, v in hcount.items() if v == hmax])
wn = len([1 for k, v in wcount.items() if v == wmax])
m = hn * wn
for h, w in HW:
if hcount[h] == hmax and wcount[w] == wmax:
m -= 1
if m == 0:
return hmax + wmax - 1
return hmax + wmax
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print("%s" % str(outputs))
|
from collections import defaultdict as ddict
h,w,m=map(int,input().split())
xs=[0]*w
ys=[0]*h
xsmx=ysmx=0
pts=set()
for _ in range(m):
y,x=map(int,input().split())
x,y=x-1,y-1
xs[x]+=1
ys[y]+=1
pts.add((x,y))
xsmx=max(xsmx,xs[x])
ysmx=max(ysmx,ys[y])
xsc=[x for x in range(w) if xs[x]==xsmx]
ysc=[y for y in range(h) if ys[y]==ysmx]
ans=xsmx+ysmx-1
ok=False
for y in ysc:
for x in xsc:
if (x,y) not in pts:
ans+=1
ok=True
break
if ok:
break
print(ans)
| 1 | 4,721,244,044,380 | null | 89 | 89 |
from collections import Counter,defaultdict,deque
from heapq import heappop,heappush,heapify
import sys,bisect,math,itertools,fractions
sys.setrecursionlimit(10**8)
mod = 10**9+7
INF = float('inf')
def inp(): return int(sys.stdin.readline())
def inpl(): return list(map(int, sys.stdin.readline().split()))
n,k = inpl()
now = inpl()
for _ in range(k):
pre = now[::]
cnt = [0] * (n+1)
for i in range(n):
l = max(0, i - pre[i])
r = min(n, i + pre[i] + 1)
cnt[l] += 1
cnt[r] -= 1
# print(cnt)
now = [0] * n
now[0] = cnt[0]
for i in range(1,n):
now[i] = now[i-1] + cnt[i]
if min(now) == n:
break
print(*now)
|
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b,a%b)
a,b = map(int, input().split())
print(a*b//gcd(a,b))
| 0 | null | 64,427,168,174,888 | 132 | 256 |
s = input(); n = len(s)
dp = [ [0,1<<32] for i in range(2) ]
for i in range(n):
d = ord(s[i])-ord('0')
dp[(i+1)%2][0] = min(dp[i%2][0], dp[i%2][1])+d
dp[(i+1)%2][1] = min(dp[i%2][0], dp[i%2][1]-2)+11-d
print(min(dp[n%2][0],dp[n%2][1]))
|
import sys
n=sys.stdin.readline().rstrip()[::-1]
to=0
m=0
n+="0"
num=len(n)
for i in range(num):
k=int(n[i])
k+=m
if k==5:
if int(n[i+1])>=5:
to+=10-k
m=1
else:
to+=k
m=0
if k<5:
to+=k
m=0
elif k>5:
to+=10-k
m=1
print(to+m)
| 1 | 70,781,962,278,528 | null | 219 | 219 |
import sys
while True:
n, x = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
if 0 == n and 0 == x:
break
cnt = 0
goto = False
for i in range( 1, n-1 ):
if x < 3*(i+1):
break
for j in range( i+1, n ):
if x <= ( i+j ):
break
for k in range( j+1, n+1 ):
s = ( i + j + k )
if x == s:
cnt += 1
break
elif x < s:
goto = True
break
goto = False
print( cnt )
|
from itertools import combinations as comb
def get_ans(m, n):
ans = sum(1 for nums in comb(range(1, min(m+1,n-2)), 2) if ((n-sum(nums)>0) and (n-sum(nums) > max(nums)) and (n-sum(nums)<=m)))
return ans
while True:
m, n = (int(x) for x in input().split())
if m==0 and n==0:
quit()
ans = get_ans(m, n)
print(ans)
| 1 | 1,294,869,677,232 | null | 58 | 58 |
n = int(input())
k = 1000000007
if n == 1:
print(0)
else:
print(((10**n)%k - (2* 9**n)%k+(8**n)%k)%k)
|
# B - Bingo
A = [0]*101
for i in range(3):
tmp = list(map(int,input().split()))
for j in range(3):
A[tmp[j]] = 3*i+j+1
N = int(input())
S = set()
for _ in range(N):
b = int(input())
S.add(A[b])
def bingo(l):
ans = False
for x,y,z in l:
if x in S and y in S and z in S:
ans = True
break
return ans
if bingo([(1,2,3),(4,5,6),(7,8,9),(1,4,7),(2,5,8),(3,6,9),(1,5,9),(3,5,7)]):
print('Yes')
else:
print('No')
| 0 | null | 31,721,558,358,240 | 78 | 207 |
from sys import stdin
import sys
import math
from functools import reduce
import functools
import itertools
from collections import deque
from operator import mul
from functools import reduce
n = int(input())
m = 0
for i in range(1,n+1):
a = n // i
m += a*(a+1)*i//2
print(m)
|
import numpy as np
def main():
n,s=map(int,input().split())
A=list(map(int,input().split()))
dp=np.array([0 for i in range(s+1)])
dp[0]=1
for ai in A:
tmp=dp[:-ai].copy()
#print(tmp)
dp*=2
dp[ai:]+=tmp
dp%=998244353
print(dp[s])
if __name__=="__main__":
main()
| 0 | null | 14,341,691,326,578 | 118 | 138 |
l,r,d=map(int,input().split())
count=0
for i in range(d,r+1,d):
if l<=i<=r:
count+=1
print(count)
|
L,R,d = list(map(int, input().split()))
count = 0
for i in range(L,R+1):
count += (i%d == 0)
print(count)
| 1 | 7,595,842,686,752 | null | 104 | 104 |
n = int(input())
a, b = map(int, input().split())
i = 0
ans = "NG"
while i <= b:
if i >= a and i % n == 0:
ans = "OK"
i += n
print(ans)
|
s = input()
start, count, end = 0, 0, len(s)-1
while(start < end):
if (s[start] != s[end]):
count += 1
start += 1; end -= 1
else:
start += 1; end -= 1
else:
print(count)
| 0 | null | 72,971,656,065,280 | 158 | 261 |
N,K= map(int, input().split())
p = 10**9+7
f=[1]
for i in range(1,N+1):
f.append(f[-1]*i % p)
def nCk(n,k):
return f[n]*pow(f[n-k], p-2, p)*pow(f[k], p-2, p)
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in range(N-K+1):
ans -= (a[i] * nCk(N-i-1, K-1)) % p
ans += (a[N-i-1] * nCk(N-i-1, K-1)) % p
print(ans % p)
|
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
A = list(map(int, input().split()))
if A[0] != 0:
if N == 0 and A[0] == 1:
print('1')
exit()
else:
print('-1')
exit()
if N == 0:
print('1')
exit()
v = [0 for _ in range(N + 1)]
v[N] = A[N]
for i in range(N - 1, -1, -1):
up = min(2 ** i, v[i + 1] + A[i])
v[i] = up
# print(v)
for i in range(N):
up = min(v[i + 1], (v[i] - A[i]) * 2)
v[i + 1] = up
# print(v)
ans = 0
for i in range(N + 1):
if v[i] < A[i]:
print('-1')
exit()
ans += v[i]
# print(v)
print(ans)
if __name__ == '__main__':
solve()
| 0 | null | 57,399,282,746,382 | 242 | 141 |
n,k,s=map(int,input().split())
if s==1000000000:
x=[s]*k+[1]*(n-k)
else:
x=[s]*k+[s+1]*(n-k)
print(*x)
|
N, K, S = map(int, input().split())
if S == 10**9:
Ans = [S for _ in range(K)] + [1 for _ in range(N-K)]
else:
Ans = [S for _ in range(K)] + [S+1 for _ in range(N-K)]
for ans in Ans:
print(ans, end=' ')
| 1 | 91,573,312,504,950 | null | 238 | 238 |
while True:
a,op,b=input().split()
a,b=int(a),int(b)
if op=="+":
print(a+b)
elif op=="-":
print(a-b)
elif op=="*":
print(a*b)
elif op=="/":
print(a//b)
else:
break
|
import sys
stdin=sys.stdin
ns = lambda:stdin.readline().rstrip()
ni = lambda:int(stdin.readline().rstrip())
nm = lambda:map(int,stdin.readline().split())
nl = lambda:list(map(int,stdin.readline().split()))
p=998244353
N,M,K=nm()
fact=[1,1]
factinv=[1,1]
inv=[0,1]
for i in range(2,N):
fact.append((fact[-1]*i)%p)
inv.append((-inv[p%i]*(p//i))%p)
factinv.append(factinv[-1]*inv[-1]%p)
def comb(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
mod_M=[1,(M-1)%p]
for i in range(2,N):
mod_M.append((mod_M[i-1]*(M-1))%p)
ans=0
ans+=(M*mod_M[N-1])%p
if(K>0):
for i in range(1,K+1):
ans+=(M*mod_M[N-i-1]%p)*comb(N-1,i,p)
ans%=p
print(ans)
| 0 | null | 11,889,420,204,270 | 47 | 151 |
i=0
a=list(map(int,input().split()))
for x in range(a[0],a[1]+1):
if(a[2]%x==0):
i+=1
print(i)
|
if __name__ == "__main__":
input()
lis = [ int(i) for i in input().split()]
print("%d %d %d"%(min(lis),max(lis),sum(lis)))
| 0 | null | 649,310,205,600 | 44 | 48 |
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 j <= i:
continue
k = x-(i+j)
if k > j and k <= n:
ans += 1
print(ans)
|
from collections import deque
u = int(input())
g = [[i for i in map(int, input().split())] for _ in range(u)]
graph = [[] for _ in range(u)]
ans = [-1] * u
for i in range(u):
for j in range(g[i][1]):
graph[i].append(g[i][2 + j] - 1)
que = deque()
que.append(0)
ans[0] = 0
while que:
v = que.popleft()
for nv in graph[v]:
if ans[nv] != -1:
continue
ans[nv] = ans[v] + 1
que.append(nv)
for i in range(u):
print(i+1, ans[i])
| 0 | null | 640,884,434,134 | 58 | 9 |
from sys import stdin
n = int(stdin.readline())
ans = 0
dp = [0]*(n+1)
for i in range(1,n+1):
j = i
while j <= n:
dp[j] += 1
j += i
for i in range(1,n+1):
ans += dp[i]*i
print(ans)
|
import math
n = int(input())
from collections import defaultdict
d = defaultdict(list)
s = set()
zc = 0
for i in range(n):
a,b = map(int, input().split())
g = math.gcd(a,b)
if g!=0:
a //= g; b //= g
if a<0:
a,b = -a, -b
elif a==0 and b<0:
b *= -1
d[a,b].append(i)
if a==b==0:
zc += 1
v = 1
s = set()
M = 10**9+7
for (a,b),val in d.items():
aa,bb = b,-a
if aa<0:
aa,bb = -aa, -bb
elif aa==0 and bb<0:
bb *= -1
if (a,b) in s or (aa,bb) in s:
continue
if (aa,bb) in d.keys():
v *= (pow(2, len(val), M) + pow(2, len(d[aa,bb]), M) - 1)
else:
v *= pow(2, len(val), M)
v %= M
s.add((a,b))
s.add((aa,bb))
v -= 1
v += zc
print(v%M)
| 0 | null | 15,855,020,407,912 | 118 | 146 |
n, p = map(int, input().split())
s = input()
res = 0
if p == 2 or p == 5:
for i in range(n):
if int(s[i]) % p == 0:
res += i + 1
else:
s = s[::-1]
cnt = {0: 1}
now = 0
d = 1
for i in range(n):
now = (now + int(s[i]) * d) % p
res += cnt.get(now, 0)
d = (d * 10) % p
cnt[now] = cnt.get(now, 0) + 1
print(res)
|
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
def main():
n, m = map(int , input().split())
print(n*(n-1)//2+m*(m-1)//2)
if __name__=="__main__":
main()
| 0 | null | 51,902,780,660,624 | 205 | 189 |
N=int(input())
from collections import Counter
if max(Counter([int(x) for x in input().split()]).values())==1:
print("YES")
else:
print("NO")
|
N = int(input())
A = list(map(int, input().split()))
sum_A = sum(A)
sum_now = 0
cost = 99999999999
for a in A:
sum_now += a
cost = min(cost, abs(sum_now - (sum_A - sum_now)))
print(cost)
| 0 | null | 108,365,089,486,476 | 222 | 276 |
s, t = input().split()
a, b = map(int, input().split())
if s == input():
a -= 1
else:
b -= 1
print("{} {}".format(a, b))
|
word = 'ACL'
a = int(input())
word = word *a
print(word)
| 0 | null | 37,290,871,823,712 | 220 | 69 |
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)
|
length = int(input())
targ = [int(n) for n in input().split(' ')]
ans = 0
for l in range(length):
value = l
for init in range(l + 1,length):
if targ[value] > targ[init]:
value = init
if value != l:
disp = targ[l]
targ[l] = targ[value]
targ[value] = disp
ans += 1
print(' '.join([str(n) for n in targ]))
print(ans)
| 1 | 21,906,245,048 | null | 15 | 15 |
# coding: utf-8
# Your code here!
# coding: utf-8
# 自分の得意な言語で
# Let's チャレンジ！！
S=input()
if "7" in S:
print("Yes")
else:
print("No")
|
n = input()
print('Yes' if '7' in n else 'No')
| 1 | 34,369,189,982,932 | null | 172 | 172 |
X,N=map(int,input().split())
p=list(map(int,input().split()))
ans=0
for i in range(1,102):
if i not in p:
if abs(X-i)<abs(X-ans):
ans=i
print(ans)
|
x, N = map(int, input().split())
p = list(map(int, input().split()))
min =10000
temp = 0
num = 10000
for i in range(-1000, 1000):
temp = abs(x- i)
if temp < min and i not in p:
min = temp
num = i
print(num)
| 1 | 14,040,189,060,030 | null | 128 | 128 |
print([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][int(input())-1])
|
from sys import stdin
input = stdin.readline
from fractions import gcd
mod = 10**9+7
n = int(input())
a = list(map(int,input().split()))
d = 1
for i in range(n):
d *= a[i] // gcd(a[i],d)
ans = 0
for i in range(n):
ans += d//a[i]
print(ans%mod)
| 0 | null | 69,121,300,329,664 | 195 | 235 |
D,T,S = map(int,input().split())
if D <= T*S:
print("Yes")
else:print("No")
|
def set1():
N,M = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
set_N = set([i for i in range(1, N+1)])
for i in range(M):
A,B = [int(i) for i in input().split()]
if H[A-1] < H[B-1]:
if A in set_N:
set_N.remove(A)
elif H[B-1] < H[A-1]:
if B in set_N:
set_N.remove(B)
else:
if A in set_N:
set_N.remove(A)
if B in set_N:
set_N.remove(B)
print(len(set_N))
if __name__ == "__main__":
set1()
| 0 | null | 14,240,832,455,022 | 81 | 155 |
n = int(input())
a = list(map(int,input().split()))
a.sort()
a.insert(0,0)
ans = 0
z = a[-1]
for i in range(1,n):
ans += a[n - (i // 2)]
print(ans)
|
length = int(input())
nums = input().split()
print(" ".join(nums[::-1]))
| 0 | null | 5,088,597,563,810 | 111 | 53 |
import string
text = ''
while True:
try:
text += input().lower()
except EOFError:
break
for chr in string.ascii_lowercase:
print('{} : {}'.format(chr, text.count(chr)))
|
import fileinput
a_dict = {chr(c): 0 for c in range(97, 123)}
for line in fileinput.input():
line = line.lower()
for c in line:
if c in a_dict:
a_dict[c] += 1
for k, v in a_dict.items():
print('{0} : {1}'.format(k, v))
| 1 | 1,667,879,074,050 | null | 63 | 63 |
s,t = map(int,input().split())
if t >= s:
print("unsafe")
else:
print("safe")
|
s,w = map(int, input().split())
ans = "NG"
# for i in range(a,b+1):
# print(i)
if s<=w:
print("unsafe")
else:
print("safe")
| 1 | 29,186,161,503,842 | null | 163 | 163 |
# import math
# import fractions
n = int(input())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
def prime_factorize(n):
a = {}
while n % 2 == 0:
if 2 not in a:
a[2] = 0
a[2] += 1
n //= 2
f = 3
while f * f <= n:
if n % f == 0:
if f not in a:
a[f] = 0
a[f] += 1
n //= f
else:
f += 2
if n != 1:
if n not in a:
a[n] = 0
a[n] += 1
return a
# 最小公倍数を素因数分解した形で持つ
l = prime_factorize(a[0])
# print(l)
# xs = {}
# xs[a[0]] = prime_factorize(a[0])
for i in range(1, n):
ps = prime_factorize(a[i])
# print(ps)
# xs[a[i]] = ps
for k, v in ps.items():
if k in l:
l[k] = max(v, l[k])
else:
l[k] = v
# print(l)
# print(xs)
L = 1
for k, v in l.items():
L = L * pow(k, v, mod) % mod
answer = 0
for x in a:
answer = (answer + L * pow(x, mod - 2, mod)) % mod
print(answer)
|
from itertools import groupby
def fast_prime_factorization_many(lst):
# 素因数分解（ロー法、複数）
from subprocess import Popen, PIPE
res = Popen(["factor"] + list(map(str, lst)), stdout=PIPE).communicate()[0].split(b"\n")[:-1]
return [list(map(int, r.split()[1:])) for r in res]
def main():
N = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
max_factor = [0] * (1010101)
lcm = 1
Factors = fast_prime_factorization_many(A)
for factors in Factors:
for prime, group in groupby(factors):
n = len(list(group))
n_old = max_factor[prime]
if n_old < n:
for i in range(n - n_old):
lcm = lcm * prime % mod
max_factor[prime] = n
ans = 0
for a in A:
ans += pow(a, mod-2, mod)
ans = ans * lcm % mod
print(ans)
main()
| 1 | 87,534,103,690,524 | null | 235 | 235 |
from sys import stdin
nii=lambda:map(int,stdin.readline().split())
lnii=lambda:list(map(int,stdin.readline().split()))
n,m=nii()
l=[lnii() for i in range(m)]
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def same(self, x, y):
return self.find(x) == self.find(y)
def size(self, x):
return -self.parents[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
uf=UnionFind(n)
for a,b, in l:
a-=1
b-=1
if uf.same(a,b)==False:
uf.union(a,b)
ans=0
roots=uf.roots()
for i in uf.roots():
ans=max(ans,uf.size(i))
print(ans)
|
# -*- coding: utf-8 -*-
from sys import stdin
input = stdin.readline
s = input()
print(s[0:3])
| 0 | null | 9,444,857,462,950 | 84 | 130 |
import sys
from collections import Counter
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007
def main():
N = int(readline())
S = readline().strip()
counter = Counter(S)
ans = counter['R'] * counter['G'] * counter['B']
for i in range(N):
for j in range(i + 1, (N + i + 1) // 2):
if 2 * j - i >= N:
break
if S[i] != S[j] and S[i] != S[2 * j - i] and S[j] != S[2 * j - i]:
ans -= 1
print(ans)
return
if __name__ == '__main__':
main()
|
n = int(input())
s = list(input())
r = s.count('R')
g = s.count('G')
b = n - r - g
ans = r*g*b
for i in range(n-2):
for j in range(i+1,i+((n-i-1)//2)+1):
if s[i] != s[j] and s[i] != s[2*j - i] and s[j] != s[2*j - i]:
ans -= 1
print(ans)
| 1 | 36,192,626,289,100 | null | 175 | 175 |
N,P=map(int, input().split())
if N<=9:
print(100*(10-N)+P)
else:
print(P)
|
n, p = map(int, input().split())
s = [int(i) for i in input()]
p_cnt = 0
if p == 2 or p == 5:
for i in range(n):
if s[i] % p == 0:
p_cnt += i+1
else:
s = s[::-1]
div_dic = dict(zip(range(p), [0] * p))
tmp = 0
for i in range(n):
tmp += s[i] * pow(10, i, p)
tmp %= p
div_dic[tmp] += 1
for v in div_dic.values():
p_cnt += v * (v - 1)
p_cnt //= 2
p_cnt += div_dic.get(0)
print(p_cnt)
| 0 | null | 60,740,878,117,360 | 211 | 205 |
n = int(input())
arrey = [int(i) for i in input().split()]
for i in range(n):
v = arrey[i]
j = i - 1
while j >= 0 and arrey[j] > v:
arrey[j+1] = arrey[j]
j = j - 1
arrey[j+1] = v
for k in range(n):
print(arrey[k]) if k == n-1 else print(str(arrey[k])+' ',end='')
|
# -*- coding: utf-8 -*-
def insertionSort(A, N):
for i in range(1, N):
print(" ".join(map(str, A)))
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
return A
if __name__ == '__main__':
N = int(input())
A = [ int(a) for a in input().split(" ")]
A = insertionSort(A, N)
print(" ".join(map(str, A)))
| 1 | 5,326,874,784 | null | 10 | 10 |
import collections
N = int(input())
A = list(map(int,input().split()))
#index,h
pp =[]
pm = []
all_set = set()
for i in range(N):
pp.append(i + A[i])
pm.append( i - A[i])
count = 0
c = collections.Counter(pp)
#print(c)
for i in range(N):
count += c[pm[i]]
#print(c[pm[i]])
#count += pp.count(pm[i])
#count += pm.count(pp[i])
print(count)
|
a, b = [int(input()) for _ in range(2)]
c = [1, 2, 3]
c.remove(a)
c.remove(b)
print(*c)
| 0 | null | 68,556,679,409,680 | 157 | 254 |
import bisect
N,M,K=map(int,input().split())
arr1=list(map(int,input().split()))
arr2=list(map(int,input().split()))
A=[0]
for i in range(N):
A.append(arr1[i]+A[-1])
B=[0]
for i in range(M):
B.append(arr2[i]+B[-1])
ans=0
for i in range(N+1):
if A[i]>K:
break
j=bisect.bisect_right(B,K-A[i])-1
ans=max(ans,i+j)
print(ans)
|
import itertools
import bisect
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
a_acc = [0] + list(itertools.accumulate(a))
b_acc = [0] + list(itertools.accumulate(b))
ans = 0
for i in range(n+1):
if k - a_acc[i] >= 0:
ans = max(ans, i + bisect.bisect(b_acc, k - a_acc[i])-1)
print(ans)
| 1 | 10,798,954,055,500 | null | 117 | 117 |
while True:
L = map(int,raw_input().split())
H = (L[0])
W = (L[1])
if H == 0 and W == 0:break
if W % 2 == 1:
for x in range(0,H):
if x % 2 == 0:
print "{}#".format("#."* (W / 2))
else:
print "{}.".format(".#"* (W / 2))
else:
for x in range(0,H):
if x % 2 == 0:
print "#." * (W / 2)
else:
print ".#" * (W / 2)
print ""
|
while True:
data = map(int, raw_input().split())
if data[0] == 0 and data[1] == 0:
break
else:
for i in range(data[0]):
if i % 2 == 0:
if data[1] % 2 == 0:
print "#." * (data[1] / 2)
else :
print "#." * (data[1] / 2) + "#"
elif i % 2 == 1:
if data[1] % 2 == 0:
print ".#" * (data[1] / 2)
else :
print ".#" * (data[1] / 2) + "."
print
| 1 | 863,016,741,832 | null | 51 | 51 |
h, w, k = map(int, input().split())
A =[]
for i in range(h):
a = input()
A.append([a[i] == "#" for i in range(w)])
ans = 0
for bit in range(1 << h):
for tib in range(1 << w):
now = 0
for i in range(h):
for j in range(w):
if(bit >> i) & 1 == 0 and (tib >> j) & 1 == 0 and A[i][j] == True: now += 1
if now == k: ans += 1
print(ans)
|
X = int(input())
flag = 0
if X == 2 or X == 3:
flag = 1
print(X)
while flag == 0 :
for i in range(2,int(X**0.5)+1):
if X%i == 0:
X += 1
break
else:
if i == int(X**0.5):
flag = 1
print(X)
| 0 | null | 57,109,962,690,170 | 110 | 250 |
while True:
H,W = (int(x) for x in input().split())
if H == 0 and W == 0:
break
for i in range(H):
for j in range(W):
if (i % 2 == 1 and j % 2 == 1) or (i % 2 == 0 and j % 2 == 0):
print ('#', end='')
else:
print ('.', end='')
print ('')
print ('')
|
while True:
h,w = map(int, input().split())
if h == 0 and w == 0: break
for j in range(h):
for i in range(w):
if (i + j)%2 == 0:
print("#", end="")
else:
print(".", end="")
print()
print()
| 1 | 857,001,026,910 | null | 51 | 51 |
M1,D1 = list(map(int,input().split()))
M2,D2 = list(map(int,input().split()))
if (M1 != M2 and M2>M1) or M2 == 1 and M2<M1:
print(1)
else:
print(0)
|
import sys
s = sys.stdin.readlines()
for i in s:
a, op, b = i.split()
a, b = int(a), int(b)
if op == '?':
break
elif op == '+':
print(a + b)
elif op == '-':
print(a - b)
elif op == '*':
print(a * b)
elif op == '/':
print(a // b)
| 0 | null | 62,224,953,278,668 | 264 | 47 |
##未完成
N = int(input())
K = str(N)
l = len(str(N))
ans = 0
def tp(i,j,p):
tmp = 0
if p >= 2:
if l == p:
if i == int(K[0]):
if j > int(K[l-1]):
tmp = (N-int(K[0])*10**(l-1)-int(K[l-1]))//10
else:
tmp = (N-int(K[0])*10**(l-1)-int(K[l-1]))//10+1
elif i >= int(K[0]):
tmp = 0
else:
tmp = 10**(p-2)
elif l > p:
tmp = 10**(p-2)
return tmp
else:
if i == j and i <= N:
return 1
else:
return 0
for i in range(1,10):
for j in range(1,10):
for p in range(1,l+1):
for q in range(1,l+1):
ans += tp(i,j,p)*tp(j,i,q)
print(ans)
|
n = int(input())
s = input()
table = {x: 2**i for i, x in enumerate(map(chr, range(97, 123)))}
SEG_LEN = n
SEG = [0]*(SEG_LEN*2)
def update(i, x):
i += SEG_LEN
SEG[i] = table[x]
while i > 0:
i //= 2
SEG[i] = SEG[i*2] | SEG[i*2+1]
def find(left, right):
left += SEG_LEN
right += SEG_LEN
ans = 0
while left < right:
if left % 2 == 1:
ans = SEG[left] | ans
left += 1
left //= 2
if right % 2 == 1:
ans = SEG[right-1] | ans
right -= 1
right //= 2
return format(ans, 'b').count('1')
for i, c in enumerate(s):
update(i, c)
q = int(input())
for _ in range(q):
com, *query = input().split()
if com == '1':
idx, x = query
update(int(idx)-1, x)
else:
L, R = map(int, query)
print(find(L-1, R))
| 0 | null | 74,647,380,657,934 | 234 | 210 |
import sys
n = input()
for _ in range(int(n)):
a, b, c = sorted(map(int, sys.stdin.readline().split()))
if a * a + b*b == c* c:
print("YES")
else:
print("NO")
|
N = int(input())
for i in range(N):
a,b,c = map(int,input().split())
if a*a + b*b == c*c or b*b+c*c == a*a or a*a+c*c == b*b:
print("YES")
else:
print("NO")
| 1 | 294,321,790 | null | 4 | 4 |
import sys
input = sys.stdin.readline
n,k = map(int,input().split())
A = list(map(int,input().split()))
mod = 10**9 + 7
# from random import randint
# n = 10
# k = 4
# A = []
# for i in range(10):
# A.append(randint(-20,20))
# anss=0
# for i in range(n):
# for j in range(i+1,n):
# for ii in range(j+1,n):
# for jj in range(ii+1,n):
# anss = max(anss, A[i]*A[j]*A[ii]*A[jj])
# print(anss)
# print(A)
B = [[], []]
for i in range(n):
if A[i] >= 0:
B[0].append(A[i])
else:
B[1].append(A[i])
B[0].sort(reverse=True)
B[1].sort()
if k % 2 == 1 and len(B[0]) == 0:
ans = 1
ind = len(B[1])-1
for i in range(k):
ans = (ans * B[1][ind]) % mod
ind -= 1
print(ans)
elif k == n and len(B[1]) % 2 == 1:
ans = 1
for i in range(n):
ans = (ans * A[i]) % mod
print(ans)
else:
k0 = min(len(B[0]), k)
k1 = k-k0
if k1%2==1:
k0 -= 1
k1 += 1
# print(B,k0,k1)
while k1+1 < len(B[1]) and k0-2 >= 0 and B[1][k1]*B[1][k1+1] > B[0][k0-1]*B[0][k0-2]:
k1 += 2
k0 -= 2
# print(k0,k1)
# print(k1+1 < len(B[1]),B[1][k1]*B[1][k1+1] , B[0][k0-1]*B[0][k0-2])
ans = 1
for i in range(k0):
ans = (ans * B[0][i]) % mod
for i in range(k1):
ans = (ans * B[1][i]) % mod
print(ans)
|
m = 100000
n = int(input())
while n > 0:
n -= 1
m = m + (m * 5 // 100)
m = ((m-1) // 1000 + 1) * 1000
print(m)
| 0 | null | 4,766,874,281,026 | 112 | 6 |
from math import gcd
def lcm(a, b):
return a * b // gcd(a, b)
A, B = map(int, input().split())
print(lcm(A, B))
|
#coding: UTF-8
def isPrime(n):
if n == 1:
return False
import math
m = math.floor(math.sqrt(n))
for i in range(2,m+1):
if n % i == 0:
return False
return True
n = int(input())
count = 0
for j in range(n):
m = int(input())
if isPrime(m):
count += 1
print(count)
| 0 | null | 56,707,483,886,460 | 256 | 12 |
print('ACL'*int(input()))
|
k = int(input())
for i in range(k):print("ACL",end="")
| 1 | 2,195,189,881,390 | null | 69 | 69 |
#B問題
ans = 0
n, k = map(int, input().split())
P = list(map(int, input().split()))
for i in range(k):
ans += min(P)
P.remove(min(P))
print(ans)
|
n, k = list(map(int, input().split()))
p = list(map(int, input().split()))
ps = sorted(p)
print(sum(ps[:k]))
| 1 | 11,650,501,074,938 | null | 120 | 120 |
X = int(input())
if ((2000-X)%200) == 0:
print((2000-X)//200)
else:
print((2000-X)//200+1)
|
import sys
sys.setrecursionlimit(10**8)
input = sys.stdin.readline
X = int(input())
ans = min(8, 10-X//200)
print(ans)
| 1 | 6,735,186,908,242 | null | 100 | 100 |
while True:
a, op, b = map(str, input().split(" "))
if op == "?":
break
a, b = int(a), int(b)
if op == "+":
c = a + b
elif op == "-":
c = a - b
elif op == "*":
c = a * b
else:
c = a // b
print(c)
|
while True:
inputs = input().split(' ')
a = int(inputs[0])
op = inputs[1]
b = int(inputs[2])
if op == "?":
break
elif op == "+": # (和)
print(a + b)
elif op == "-": # (差)
print(a - b)
elif op == "*": #(積)
print(a * b)
else: # "/"(商)
print(a // b)
| 1 | 668,803,969,724 | null | 47 | 47 |
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])
|
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
S = input()
N = len(S)
if S != S[::-1]:
return False
t = S[:(N - 1) // 2]
if t != t[::-1]:
return False
t = S[(N + 3) // 2 - 1:]
if t != t[::-1]:
return False
return True
def main():
if solve():
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 0 | null | 68,919,132,468,482 | 239 | 190 |
from collections import Counter
N = int(input())
C = list(input())
cnt = Counter(C)
ans1 = min(cnt["R"], cnt["W"])
ans2 = 0
l, r = 0, N-1
while l < r:
if C[l] == "W" and C[r] == "R":
ans2 += 1
l += 1
r -= 1
else:
if C[l] == "R":
l += 1
if C[r] == "W":
r -= 1
ans = min(ans1, ans2)
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
j=0
for i in range(N):
if A[i]==j+1:
j+=1
if j == 0:
print(-1)
else:
print(N-j)
| 0 | null | 60,140,028,793,072 | 98 | 257 |
N = int(input())
i = 1
while True:
M = 1000*i
if M >= N:
break
i += 1
ans = M-N
print(ans)
|
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 7 01:24:25 2020
@author: saito
"""
# %% import phase
# %% define phase
# %% input phase
N = int(input())
# %% process phase
answer = 1000-((N-1)%1000+1)
# %%output phase
print(answer)
| 1 | 8,437,097,215,392 | null | 108 | 108 |
n, m = map(int, input().split())
def check_ans(list_pairs):
dict_people = {i: i for i in range(1, n+1)}
for i in range(n):
for k in range(m):
val1 = dict_people[list_pairs[k][0]]
val2 = dict_people[list_pairs[k][1]]
if val1>val2:
print(val2, val1, end=" / ")
else:
print(val1, val2, end=" / ")
print("")
for j in range(1, n+1):
dict_people[j] = (dict_people[j]+1)%n
if dict_people[j] == 0: dict_people[j] = n
ans = list()
if n%2 == 1:
for i in range(m):
node1 = (1-i)%n
if node1 == 0: node1 = n
node2 = 2+i
ans.append((node1, node2))
else:
distance = -1
node2 = 1
for i in range(m):
node1 = (1-i)%n
if node1 == 0: node1 = n
node2 = node2+1
distance += 2
if distance == n//2 or distance == n//2 + 1:
node2 += 1
ans.append((node1, node2))
[print(str(values[0])+" "+str(values[1])) for values in ans]
# check_ans(ans)
|
n,m=map(int,input().split())
oddflag=True
for i in range(1,m+1):
mid=(1+n)//2
if oddflag:
oddflag = False
print(i//2 + 1 , n - i//2)
else:
oddflag = True
print(mid + i//2, mid - i//2)
| 1 | 28,786,678,510,450 | null | 162 | 162 |
#!/usr/bin/env python3
import sys
from itertools import chain
def solve(A: int, B: int):
answer = 6 - A - B
return answer
def main():
tokens = chain(*(line.split() for line in sys.stdin))
A = int(next(tokens)) # type: int
B = int(next(tokens)) # type: int
answer = solve(A, B)
print(answer)
if __name__ == "__main__":
main()
|
n = int(input())
numList = map(int,input().split())
numList = list(numList)
multiplyList = []
start = 0
for i in range(n+1):
start += 1
for j in range(start, n):
multiplyList.append(numList[i] * numList[j])
print(sum(multiplyList))
| 0 | null | 139,400,006,978,990 | 254 | 292 |
import sys
input = sys.stdin.readline
from collections import *
def bfs():
q = deque([0])
pre = [-1]*N
pre[0] = 0
while q:
v = q.popleft()
for nv in G[v]:
if pre[nv]==-1:
pre[nv] = v
q.append(nv)
return pre
N, M = map(int, input().split())
G = [[] for _ in range(N)]
for _ in range(M):
A, B = map(int, input().split())
G[A-1].append(B-1)
G[B-1].append(A-1)
pre = bfs()
print('Yes')
for pre_i in pre[1:]:
print(pre_i+1)
|
from collections import deque
n,m=map(int,input().split())
adj=[[] for _ in range(n)]
for _ in range(m):
a,b =map(int,input().split())
a-=1
b-=1
adj[a].append(b)
adj[b].append(a)
ans=[0]*n
que=deque([])
que.append(0)
while que:
e=que.popleft()
for i in adj[e]:
if ans[i]!=0:
continue
ans[i]=e+1
que.append(i)
print("Yes")
for i in range(1,n):
print(ans[i])
| 1 | 20,412,749,199,450 | null | 145 | 145 |
def nCr(n, r, mod):
x, y = 1, 1
for r_ in range(1, r+1):
x = x*(n+1-r_)%mod
y = y*r_%mod
return x*pow(y, mod-2, mod)%mod
x, y = map(int, input().split())
mod = 10**9+7
if (x+y)%3 or 2*x<y or 2*y<x:
print(0)
else:
print(nCr((x+y)//3,(2*x-y)//3, mod))
|
from math import factorial as F
def comInit(mx=510000, mod=pow(10,9)+7):
fac = [0]*mx
finv = [0]*mx
inv = [0]*mx
fac[0] = fac[1] = 1
finv[0] = finv[1] = 1
inv[1] = 1
for i in range(2,mx):
fac[i] = fac[i-1]*i%mod
inv[i] = mod - inv[mod%i]*(mod//i)%mod
finv[i] = finv[i-1]*inv[i]%mod
return fac, finv
def com(fac, finv, 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
x, y = map(int, input().split())
mod = pow(10,9)+7
if (x+y)%3!=0:
print(0)
else:
w = (2*y-x)//3
h = (2*x-y)//3
if w<0 or h<0:
print(0)
else:
fac, finv = comInit(w+h+1)
print(com(fac, finv, w+h,w))
| 1 | 149,561,576,972,328 | null | 281 | 281 |
s=[int(_) for _ in input()]
m = [0 for i in range(2019)]
d=0
m[d]+=1
p=1
for i in range(len(s)):
d=(d+s[-i-1]*p)%2019
m[d]+=1
p=(p*10)%2019
#print(d)
ans=0
for i in range(2019):
ans+=m[i]*(m[i]-1)//2
print(ans)
|
def abc164_d():
# 解説放送
s = str(input())
n = len(s)
m = 2019
srev = s[::-1] # 下の位から先に見ていくために反転する
x = 1 # 10^i ??
total = 0 # 累積和 (mod 2019 における累積和)
cnt = [0] * m # cnt[k] : 累積和がkのものが何個あるか
ans = 0
for i in range(n):
cnt[total] += 1
total += int(srev[i]) * x
total %= m
ans += cnt[total]
x = x*10 % m
print(ans)
abc164_d()
| 1 | 30,744,721,120,448 | null | 166 | 166 |
def main():
from string import ascii_lowercase
c = input()
ind = ascii_lowercase.index(c)
ind += 1
print(ascii_lowercase[ind])
if __name__ == '__main__':
main()
|
S = input()
# ■のマスは2, ▲のマスは1でカウントする
def scan_forward(F:list, S):
depth = 0 # 深さ（開始点を基準）
start = 0 # 「池」が始まった高さ
is_pond = True # 池が始まっているか？
for s in S:
if s == '\\': # 下り
if not is_pond:
is_pond = True
start = depth
depth -= 1
F.append(2*(start - depth) - 1)
continue
if s == "/": # 上り
depth += 1
if start < depth: # 池の開始位置より高くなった場合
is_pond = False
F.append(0)
continue
else:
F.append(2*(start - depth) + 1)
if s == "_":
if is_pond:
F.append(2*(start - depth))
else:
F.append(0)
def scan_backward(B:list, S):
depth = 0 # 深さ（開始点を基準）
start = 0 # 「池」が始まった高さ
is_pond = True # 池が始まっているか？
for s in S:
if s == '/': # 下り
if not is_pond:
is_pond = True
start = depth
depth -= 1
B.append(2*(start - depth) - 1)
continue
if s == "\\": # 上り
depth += 1
if start < depth: # 現在地が池の開始位置より高い場合
is_pond = False # 「池」終了
B.append(0)
continue
B.append(2*(start - depth) + 1)
if s == "_":
if is_pond:
B.append(2*(start - depth))
else:
B.append(0)
def count_pond(FB):
P = []
is_pond = False
count = 0
amount = 0
all_amount = 0
for i in range(len(FB)):
all_amount += FB[i]
if is_pond: # 池の途中
amount += FB[i]
if FB[i] == 1:
is_pond = False # ここで一旦終了
P.append(amount//2)
else: # 池でなくなった場合
if FB[i] == 0: continue
count += 1
is_pond = True
amount = FB[i]
return all_amount//2, count, P
F = []
scan_forward(F, S)
B = []
scan_backward(B, reversed(S))
B.reverse()
# print(F) # 順方向にスキャンした結果
# print(B) # 逆方向にスキャンした結果
FB = [0]*len(F)
# print(len(F), len(B))
for i in range(len(F)):
FB[i] = min(F[i], B[i])
# print(FB) # 水量
aa, k, P = count_pond(FB)
print(aa)
if k == 0:
print(k)
else:
print(k, " ".join(list(map(str, P))))
| 0 | null | 46,413,162,195,620 | 239 | 21 |
def main(S):
rains = S.split('S')
return max([len(r) for r in rains])
if __name__ == '__main__':
S = input()
ans = main(S)
print(ans)
|
import math
import collections
import itertools
def resolve():
S=input()
if("RRR" in S):
print(3)
elif("RR" in S):
print(2)
elif("R" in S):
print(1)
else:
print(0)
resolve()
| 1 | 4,861,395,531,628 | null | 90 | 90 |
a,b = map(int,raw_input().split())
d = a/b
r = a%b
f = round(a*1.0/b, 7)
print d,r,f
|
n = list(map(int, input().split()))
a = n[0]
b = n[1]
d = a // b
r = a % b
f = a / b
print('{} {} {:.5f}'.format(d, r, f))
| 1 | 606,844,253,818 | null | 45 | 45 |
n = int(input())
ans = [0 for x in range(10001)]
for i in range(1, 100):
for j in range(1, 100):
for k in range(1, 100):
v = i*i + j*j + k*k + i*j + i*k + j*k
if v < 10001:
ans[v] += 1
for i in range(n):
print(ans[i+1])
|
h, w, k = map(int, input().split())
s = [list(input()) for _ in range(h)]
g = 1
for i in range(h):
for j in range(w):
if s[i][j] != '#':
continue
s[i][j] = g
k = j - 1
while k >= 0 and s[i][k]=='.':
s[i][k] = g
k -= 1
k = j + 1
while k < w and s[i][k] == '.':
s[i][k] = g
k += 1
g += 1
for i in range(h - 2)[::-1]:
if s[i][0]=='.':
for j in range(w):
s[i][j] = s[i + 1][j]
for i in range(h):
if s[i][0] == '.':
for j in range(w):
s[i][j] = s[i - 1][j]
for t in s:
print(*t)
| 0 | null | 75,876,595,077,542 | 106 | 277 |
a, b = input().split()
a = int(a)
b = int(b)
if a > b:
print('a > b')
elif a < b:
print('a < b')
else:
print('a == b')
|
x, y = map(int,raw_input().split())
if(x>y):
print "a > b"
elif(x<y):
print "a < b"
else:
print "a == b"
| 1 | 365,158,552,092 | null | 38 | 38 |
x = int(input())
ans = x*x*x
print(ans)
|
input_number = int(raw_input())
answer = input_number * input_number * input_number
print answer
| 1 | 275,107,014,272 | null | 35 | 35 |
S = input()
T = input()
if T.startswith(S):
print('Yes')
else:
print('No')
|
n = int(input())
dic_A = set()
dic_C = set()
dic_G = set()
dic_T = set()
for i in range(n) :
p, string = input().split()
if p == 'insert' :
if string[0] == 'A' :
dic_A.add(string)
elif string[0] == 'C' :
dic_C.add(string)
elif string[0] == 'G' :
dic_G.add(string)
else :
dic_T.add(string)
else :
if string[0] == 'A' :
if string in dic_A :
print('yes')
else :
print('no')
elif string[0] == 'C' :
if string in dic_C :
print('yes')
else :
print('no')
elif string[0] == 'G' :
if string in dic_G :
print('yes')
else :
print('no')
else :
if string in dic_T :
print('yes')
else :
print('no')
| 0 | null | 10,733,616,987,872 | 147 | 23 |
n=int(input())
d=list(map(int,input().split()))
if d[0]!=0:
print(0)
exit()
del d[0]
for i in range(n-1):
if d[i]==0:
print(0)
exit()
dcnt=[0]*(n)
for i in range(n-1):
dcnt[d[i]]+=1
for j in range(n-1,-1,-1):
if dcnt[j]==0:
del dcnt[j]
else:
break
if len(dcnt)==0:
print(0)
exit()
dcnt[0]=1
sum=1
for i in range(1,len(dcnt)):
sum*=pow(dcnt[i-1],dcnt[i])
sum%=998244353
print(sum)
|
a = input()
a = a.split()
x=int(a[0])
y=int(a[1])
if x>y:
print("safe")
else:
print("unsafe")
| 0 | null | 92,414,732,298,008 | 284 | 163 |
a = []
for i in range(3):
a.append(list(map(int, input().split())))
n = int(input())
for i in range(n):
b = int(input())
for j in range(3):
for k in range(3):
if a[j][k] == b:
a[j][k] = 0
for i in range(3):
if sum(a[i]) == 0:
print("Yes")
exit()
for i in range(3):
if sum([a[0][i], a[1][i], a[2][i]]) == 0:
print("Yes")
exit()
if sum([a[0][0], a[1][1], a[2][2]]) == 0 or sum([a[0][2], a[1][1], a[2][0]]) == 0:
print("Yes")
exit()
print("No")
|
n,m = (int(i) for i in input().split())
print("Yes" if n==m else"No")
| 0 | null | 71,498,190,688,038 | 207 | 231 |
import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
MOD = 10**9 + 7
NI = lambda : int(sys.stdin.readline())
SI = lambda : sys.stdin.readline().rstrip()
K = NI()
S = SI()
LS = len(S)
f = [0] * (K+LS)
r = [0] * (K+LS)
f[0] = 1
r[0] = 1
c = 1
for i in range(1, K + LS):
c = (c * i) % MOD
f[i] = c
r[i] = pow(c, MOD - 2, MOD)
def comb(n, k):
return (f[n] * r[k] * r[n - k]) % MOD
ans = 0
for i in range(K+1):
ans = (ans + pow(25,i,MOD) * pow(26,K-i,MOD) * comb(i+LS-1,LS-1)) % MOD
print(ans)
if __name__ == '__main__':
main()
|
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
MAX = 2 * 10**6 + 10
MOD = 10**9+7
fac = [1] * MAX
f_inv = [1] * MAX
def prepare(n, mod):
for i in range(1, n+1):
fac[i] = (fac[i-1] * i) % mod
f_inv[n] = pow(fac[n], -1, MOD)
for i in range(n-1, 0, -1):
f_inv[i] = (f_inv[i+1] * (i+1)) % MOD
def modcmb(n, r, mod):
if n < 0 or r < 0:
return 0
if r > n:
return 0
return fac[n] * f_inv[r] * f_inv[n-r] % mod
def main():
K = int(readline())
S = readline().strip()
N = len(S)
prepare(N + K + 5, MOD)
inv26 = pow(26, -1, MOD)
pow26 = pow(26, K, MOD)
pow25 = 1
ans = 0
for i in range(K+1):
ans += (modcmb(N-1+i, i, MOD) * pow25 * pow26) % MOD
ans %= MOD
pow25 *= 25
pow25 %= MOD
pow26 *= inv26
pow26 %= MOD
print(ans)
if __name__ == "__main__":
main()
| 1 | 12,771,671,832,230 | null | 124 | 124 |
import sys
n = int(input())
a = list(map(int,input().split()))
ans = 1
if 0 in a:
print(0)
sys.exit()
for i in range(n):
ans = ans * a[i]
if ans > 1000000000000000000:
print(-1)
sys.exit()
print(ans)
|
a,b=map(int,input().split())
if a>b:print('a > b')
elif a<b:print('a < b')
else:print('a == b')
| 0 | null | 8,196,530,278,762 | 134 | 38 |
import sys
import numpy as np
from math import ceil as C, floor as F, sqrt
from collections import defaultdict as D, Counter as CNT
from functools import reduce as R
import heapq as HQ
class Heap:
def __init__(self, data, reverse=False):
self.reverse = -1 if reverse else 1
self.data = [self.reverse * d for d in data]
HQ.heapify(self.data)
def push(self, x): return HQ.heappush(self.data, self.reverse * x)
def pop(self): return self.reverse * HQ.heappop(self.data)
ALP = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
alp = 'abcdefghijklmnopqrstuvwxyz'
def _X(): return sys.stdin.readline().rstrip().split(' ')
def _S(ss): return tuple(ss) if len(ss) > 1 else ss[0]
def S(): return _S(_X())
def Ss(): return list(S())
def _I(ss): return tuple([int(s) for s in ss]) if isinstance(ss, tuple) else int(ss)
def I(): return _I(S())
def _Is(ss): return list(ss) if isinstance(ss, tuple) else [ss]
def Is(): return _Is(I())
n = I()
xs = Is()
ans = 0
now = xs[0]
for x in xs[1:]:
if x < now:
ans += (now - x)
now = max(x, now)
print(ans)
|
n = int(input())
l = list(map(int,input().split()))
p=l[0]
s=0
for i in l[1:]:
s+= max(0,p-i)
p=max(p,i)
print(s)
| 1 | 4,489,492,576,128 | null | 88 | 88 |
s = input()
n = len(s)
flg = True
for i in range(n//2):
if s[i] != s[n-1-i]:
flg = False
for i in range(n//4):
if s[i] != s[n//2-1-i]:
flg = False
print('Yes') if flg else print('No')
|
import math
a, b, c = map(float, input().split())
c = math.radians(c)
S = 0.5 * a * b * math.sin(c)
L = (a ** 2 + b ** 2 - 2 * a * b * math.cos(c)) ** 0.5 + a + b
h = S / a * 2
print(S)
print(L)
print(h)
| 0 | null | 23,338,146,264,020 | 190 | 30 |
import sys
readline = sys.stdin.readline
N,X,Y = map(int,readline().split())
X -= 1
Y -= 1
ans = [0] * N
for i in range(N - 1):
for j in range(i + 1, N):
val = min(abs(i - j),abs(i - X) + 1 + abs(j - Y), abs(i - Y) + 1 + abs(j - X))
ans[val] += 1
for i in range(1, len(ans)):
print(ans[i])
|
def main():
n, k = map(int, input().split())
arr = list(map(int, input().split()))
L, R = 0, max(arr)
while L+1 < R:
P = (L+R+1)//2
cnt = 0
for a in arr:
if P < a:
if a % P == 0:
cnt += a//P - 1
else:
cnt += a//P
if cnt <= k:
R = P
else:
L = P
print(R)
if __name__ == "__main__":
main()
| 0 | null | 25,429,553,620,438 | 187 | 99 |
import math
def insertion_sort(A, N, g, cnt):
for i in range(g, N):
v = A[i]
j = i - g
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
return cnt
def shell_sort(A, N, cnt):
G = []
g = 1
m = 0
while g <= N:
G.append(g)
m += 1
g = 3 * g + 1
G.reverse()
m = len(G)
print(m)
print(' '.join(map(str, G)))
for g in G:
cnt = insertion_sort(A, N, g, cnt)
return cnt
if __name__ == "__main__":
N = int(input())
A = []
for i in range(N):
A.append(int(input()))
cnt = 0
cnt = shell_sort(A, N, cnt)
print(cnt)
for a in A:
print(a)
|
# -*- coding:utf-8 -*-
import math
def insertion_sort(num_list, length, interval):
cnt = 0
for i in range(interval, length):
v = num_list[i]
j = i - interval
while j >= 0 and num_list[j] > v:
num_list[j+interval] = num_list[j]
j = j - interval
cnt = cnt + 1
num_list[j+interval] = v
return cnt
def shell_sort(num_list, length):
cnt = 0
h = 4
intervals = [1,]
while length > h:
intervals.append(h)
h = 3 * h + 1
for i in reversed(range(len(intervals))):
cnt = cnt + insertion_sort(num_list, length, intervals[i])
print(len(intervals))
print(*reversed(intervals))
print(cnt)
input_num = int(input())
input_list = list()
for i in range(input_num):
input_list.append(int(input()))
shell_sort(input_list, input_num)
for num in input_list:
print(num)
| 1 | 32,083,254,788 | null | 17 | 17 |
n=int(input())
arr=list(map(int,input().split()))
if n<=3:
print(max(arr))
exit()
lim=n%2+2
dp=[[0]*lim for _ in range(n+1)]
for i in range(n):
dp[i+1][0]=dp[i-1][0]+arr[i]
dp[i+1][1]=max(dp[i-1][1]+arr[i],dp[i-2][0]+arr[i])
if lim==3:
dp[i+1][2]=max(dp[i-1][2]+arr[i],dp[i-2][1]+arr[i],dp[i-3][0]+arr[i])
print(max(dp[-1][:lim]))
|
from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
m = n//2
INF = 10**18
dp = [defaultdict(lambda: -INF) for _ in range(n+1)]
for i in range(1, n+1):
for j in range(i//2-1, (i+1)//2+1):
if j == 1:
dp[i][j] = max(dp[i-1][j], A[i-1])
elif 0 <= i-2 and 0 <= j <= m:
dp[i][j] = max(dp[i-1][j], dp[i-2][j-1]+A[i-1])
print(dp[-1][m])
| 1 | 37,379,684,474,148 | null | 177 | 177 |
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [input() for _ in range(n)]
n = int(input())
p = list(map(int, input().split()))
ans = 1
minVal = p[0]
for i in range(1, n):
if minVal > p[i]:
ans += 1
minVal = p[i]
print(ans)
|
N = int(input())
li = list(map(int, input().split()))
minL = 2 * (10**6)
count = 0
for l in li:
if (minL >= l):
count += 1
minL = l
print(count)
| 1 | 85,298,801,632,004 | null | 233 | 233 |
while 1 :
a,op,b=raw_input().split()
ai=int(a)
bi=int(b)
if op=='?':break
elif op=='+':print ai+bi
elif op=='-':print ai-bi
elif op=='*':print ai*bi
elif op=='/':print ai/bi
|
def main():
a, b, c, d = (int(i) for i in input().split())
print(max(a*c, b*d, a*d, b*c))
if __name__ == '__main__':
main()
| 0 | null | 1,869,822,731,072 | 47 | 77 |
#from collections import deque,defaultdict
printn = lambda x: print(x,end='')
inn = lambda : int(input())
inl = lambda: list(map(int, input().split()))
inm = lambda: map(int, input().split())
ins = lambda : input().strip()
DBG = True # and False
BIG = 10**18
R = 10**9 + 7
#R = 998244353
def ddprint(x):
if DBG:
print(x)
n = inn()
a = inl()
acc = [0]*(n+1)
for i in range(n-1,-1,-1):
acc[i] = acc[i+1]+a[i]
#ddprint(acc)
x = 0
for i in range(n-1):
#ddprint(f"{x=} {i=} {acc[i+1]}")
x = (x+a[i]*acc[i+1])%R
print(x)
|
n = int(input())
a = list(map(int, input().split()))
b = [x*x for x in a]
#print(a)
#print(b)
s = sum(a)
s = s * s - sum(b)
s = s // 2
s = s % 1000000007
print(s)
# (a+b+c)^2 = a^2 + b^2 + c^2 + 2ab + 2ac + 2bc
| 1 | 3,814,349,308,010 | null | 83 | 83 |
import math
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
a = I()
ans = a * (1+a+a**2)
print(ans)
|
import math,itertools,fractions,heapq,collections,bisect,sys,queue,copy
sys.setrecursionlimit(10**7)
inf=10**20
mod=10**9+7
dd=[(-1,0),(0,1),(1,0),(0,-1)]
ddn=[(-1,0),(-1,1),(0,1),(1,1),(1,0),(1,-1),(0,-1),(-1,-1)]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS(): return sys.stdin.readline().split()
def S(): return input()
def main():
a,b,c=LI()
if c-a-b<=0:
return 'No'
if 4*a*b<(c-a-b)**2:
return 'Yes'
return 'No'
# main()
print(main())
| 0 | null | 30,803,223,397,700 | 115 | 197 |
while True:
a,op,b=raw_input().split()
if op == "?":break
if op == "+":print int(a) + int(b)
if op == "-":print int(a) - int(b)
if op == "*":print int(a) * int(b)
if op == "/":print int(a) / int(b)
|
n = int(input())
A = list(map(int,input().split()))
smallest = A[0]
ans = 0
for x in range(len(A)-1):
if A[x] > A[x+1]:
ans += A[x] - A[x+1]
A[x+1] = A[x]
print(ans)
| 0 | null | 2,597,226,137,030 | 47 | 88 |
n = int(input())
a = list(map(int,input().split()))
flag = 1
i = 0
count = 0
while flag:
flag = 0
for j in range(n-1,i,-1):
if a[j] < a[j-1]:
a[j],a[j-1] = a[j-1],a[j]
count += 1
flag = 1
i += 1
for w in range(n):
if w != n-1:
print(a[w],end=" ")
else:
print(a[w])
print(count)
|
D = int(input())
c = list(map(int, input().split()))
s = [[]]
for _ in range(D):
s.append(list(map(int, input().split())))
lasts = [0 for i in range(len(c))]
ans = 0
for d in range(1, D+1):
t = int(input()) - 1
lasts[t] = d
ans += s[d][t]
for i in range(len(c)):
ans -= c[i] * (d - lasts[i])
print(ans)
| 0 | null | 5,014,738,652,690 | 14 | 114 |
n=int(input())
a=list(map(int,input().split()))
l=0
r=sum(a)
ans=20202020200
for i in range(n):
l+=a[i]
r-=a[i]
ans=min(ans,abs(l-r))
print(ans)
|
n = int(input())
lis = list(map(int, input().split()))
left = 0
right = sum(lis)
ans = 1001001001001
for i in range(n):
left += lis[i]
right -= lis[i]
ans = min(ans, abs(left-right))
print(ans)
| 1 | 142,060,661,078,816 | null | 276 | 276 |
import sys
import math
import fractions
from collections import defaultdict
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
N,K=nm()
A=nl()
imos_l=[0]*(N+1)
for i in range(K):
imos_l=[0]*(N+1)
for j in range(len(A)):
imos_l[max(j-A[j],0)]+=1
imos_l[min(j+A[j]+1,N)]-=1
for j in range(len(imos_l)-1):
imos_l[j+1]=imos_l[j]+imos_l[j+1]
for j in range(len(A)):
A[j]=imos_l[j]
flag=True
for j in range(len(A)):
if(A[j]<N):
flag=False
if(flag):
print(*A)
sys.exit(0)
print(*A)
|
N, K = map(int, input().split())
A_list = list(map(int, input().split()))
for _ in range(K):
count_list = [0] * N
for i, v in enumerate(A_list):
count_list[i - v if i - v > 0 else 0] += 1
if i + v + 1 < N:
count_list[i + v + 1] -= 1
temp = 0
flag = True
for i in range(len(A_list)):
temp += count_list[i]
if temp != N:
flag = False
A_list[i] = temp
if flag:
break
print(*A_list)
| 1 | 15,456,673,212,100 | null | 132 | 132 |
S = input()
T = input()
def d(s,t):
return sum([1 if i!=j else 0 for i,j in zip(s,t)])
print(min([d(S[i:], T) for i in range(len(S)-len(T) + 1)]))
|
S = input()
N = len(S)+1
x = [0 for _ in range(N)]
l = 0
while(l<N-1):
r = l+1
while(r<N-1 and S[r]==S[l]):
r += 1
if S[l]=='<':
x[l] = 0
for i in range(l+1, r+1):
x[i] = max(x[i], x[i-1]+1)
else:
x[r] = 0
for i in range(r-1, l-1, -1):
x[i] = max(x[i], x[i+1]+1)
l = r
print(sum(x))
| 0 | null | 80,421,159,471,840 | 82 | 285 |
S=input()
A=[0]*(len(S)+1)
for i in range(len(S)):
if S[i]=='<':
A[i+1]=max(A[i+1],A[i]+1)
for i in range(len(S)-1,-1,-1):
if S[i]=='>':
A[i]=max(A[i],A[i+1]+1)
print(sum(A))
|
s = list(input())
n = len(s) + 1
left = [0]*n
right = [0]*n
for i in range(n-1):
if s[i] == '<':
left[i+1] = left[i] + 1
for i in range(n-2, -1, -1):
if s[i] == '>':
right[i] = right[i+1] + 1
a = [0]*n
for i in range(n):
a[i] = max(left[i], right[i])
ans = sum(a)
print(ans)
| 1 | 156,371,837,126,880 | null | 285 | 285 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.