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
|
|---|---|---|---|---|---|---|
# -*- coding: utf-8 -*-
N = int(input())
X = list(map(int, input().split()))
min_x = X[0]
max_x = X[0]
for i in range(N):
if X[i] > max_x: max_x = X[i]
if X[i] < min_x: min_x = X[i]
ans = 10000000
for p in range(min_x, max_x+1):
ans_p = 0
for x in X:
ans_p += (x-p)**2
if ans > ans_p: ans = ans_p
print(ans)
|
a,b,c = map(int, input().split())
print("Yes") if b * c >= a else print("No")
| 0 | null | 34,218,752,238,110 | 213 | 81 |
#!usr/bin/env python3
def string_two_numbers_spliter():
a, b, c = [int(i) for i in input().split()]
return a, b, c
def count_nums_of_divisors_of_c_in_a_and_b(a, b, c):
count = 0
for i in range(1, c+1):
if (c % i == 0):
if i >= a and i <= b:
count += 1
return count
def main():
a, b, c = string_two_numbers_spliter()
print(count_nums_of_divisors_of_c_in_a_and_b(a, b, c))
if __name__ == '__main__':
main()
|
a,b,c = map(int, input().split())
p = 0
for j in range(a,b + 1):
if c%j==0:
p = p+1
print(p)
| 1 | 569,131,447,740 | null | 44 | 44 |
s=input()
n=len(s)
from collections import Counter
c=Counter()
m=0
c[m]+=1
d=1
s=s[::-1]
for i in range(n):
m+=int(s[i])*d
m%=2019
d*=10
d%=2019
c[m]+=1
ans=0
for v in c.values():
ans+=v*(v-1)//2
print(ans)
|
n = int(raw_input().strip())
commands = []
for i in range(n):
commands.append(raw_input().strip())
d = [False]*67108870
def hash(s):
ret = 0
i = 0
for dg in s:
if dg == 'A':
ret += 0 * 4**i
elif dg == 'C':
ret += 1 * 4**i
elif dg == 'G':
ret += 2 * 4**i
elif dg == 'T':
ret += 3 * 4**i
i += 1
return ret
def insert(d,s):
h = hash(s)
d[h] = True
def find(d,s):
h = hash(s)
if d[h]: print 'yes'
else: print 'no'
for c in commands:
c += 'C'
if c[0] == 'i':
insert(d,c[7:])
else:
find(d,c[5:])
| 0 | null | 15,475,777,108,440 | 166 | 23 |
K = int ( input().strip() ) ;
print ( "ACL" * K ) ;
|
A1, A2, A3 = map(int, input().split())
print('bust') if A1 + A2 + A3 >= 22 else print('win')
| 0 | null | 60,556,476,462,940 | 69 | 260 |
import sys
from collections import namedtuple, defaultdict
from math import gcd
input = sys.stdin.readline
class Point:
def __init__(self, x, y):
g = gcd(abs(x), abs(y))
x //= g
y //= g
if x < 0:
x *= -1
y *= -1
elif x == 0 and y < 0:
y *= -1
self.x = x
self.y = y
def __eq__(self, other):
return self.x == other.x and self.y == other.y
def __hash__(self):
return hash((self.x, self.y))
def __repr__(self):
return f'({self.x}, {self.y})'
def main():
n = int(input())
p = []
d = defaultdict(lambda: 0)
zeros = 0
for _ in range(n):
x, y = map(int, input().split())
if x == 0 and y == 0:
n -= 1
zeros += 1
continue
p.append(Point(x, y))
d[p[-1]] += 1
MOD = 10 ** 9 + 7
pw = [ pow(2, i, MOD) for i in range(n + 1) ]
ans = 1
tot = 0
for x in d.keys():
if x.x > 0 and x.y >= 0 and Point(-x.y, x.x) in d:
s = d[x]
t = d[Point(-x.y, x.x)]
tot += s + t
value = (pw[s] + pw[t] - 1 + MOD) % MOD
ans = ans * value % MOD
ans = ans * pw[n - tot] % MOD
ans = (ans - 1 + MOD + zeros) % MOD
print(ans)
main()
|
import sys, math
from collections import defaultdict
from fractions import gcd
input = sys.stdin.readline
sys.setrecursionlimit(10**8)
mod = 10**9+7
def main():
n = int(input())
dic = defaultdict(int)
dic1 = defaultdict(int)
for _ in range(n):
a,b = map(int,input().split())
if a != 0 and b == 0:
a = 1
elif a == 0 and b != 0:
b = 1
else:
if not (a==0 and b==0):
m = gcd(a,b)
a //= m
b //= m
if a < 0 and b < 0:
a = -a
b = -b
if a < 0 and b > 0:
a = -a
b = -b
index = ' '.join([str(a),str(b)])
dic[index] += 1
dic1[index] += 1
ans = 1
dic2 = defaultdict(int)
for e in dic:
a,b = map(int,e.split())
if a == 0 and b == 0:
continue
flag = 0
if a == 0 and b == 1:
rev = ' '.join([str(1),str(0)])
elif a == 1 and b == 0:
rev = ' '.join([str(0),str(1)])
elif a > 0 and b > 0:
rev = ' '.join([str(b),str(-a)])
else:
rev = ' '.join([str(-b),str(a)])
if dic1[rev] > 0 and dic2[rev] == 0:
dic2[rev] = 1
dic2[e] = 1
flag = 1
if flag:
continue
n1 = pow(2,dic[e],mod)
n2 = pow(2,dic1[rev],mod)
ans *= (n1+n2-1)
ans %= mod
print((ans-1+dic['0 0'])%mod)
if __name__ == "__main__":
main()
| 1 | 21,128,022,365,472 | null | 146 | 146 |
import numpy as np
h, a = map(int, input().split())
print(int(np.ceil(h / a)))
|
n = int(input())
a = list(map(int,input().split()))
ans = [0]*(n-1)
for i in range(n-1):
ans[a[i]-1] += 1
for i in range(n-1):
print(ans[i])
print(0)
| 0 | null | 54,934,952,842,700 | 225 | 169 |
N,M=map(int,input().split())
S=input()
S=S[::-1]
now = 0
ok=1
history = []
while True:
for i in range(min(M, N-now),0,-1):
if S[now+i] == '0':
now += i
history.append(str(i))
break
if i==1:
print(-1)
ok=0
break
if ok==0:break
if now == N:break
if ok==1:print(' '.join(history[::-1]))
|
def check(s, p):
for i in range(len(s)):
count = 0
for j in range(len(p)):
if s[(i+j) % len(s)] != p[j]:
break
count += 1
if count == len(p):
return True
return False
s = raw_input()
p = raw_input()
flag = check(s, p)
if flag:
print("Yes")
else:
print("No")
| 0 | null | 70,320,669,131,360 | 274 | 64 |
[N, M] = [int(i) for i in input().split()]
H = [int(i) for i in input().split()]
dic = {}
for i in range(M):
[a, b] = [int(i) for i in input().split()]
if a in dic:
dic[a].append(b)
else:
dic[a] = [b]
if b in dic:
dic[b].append(a)
else:
dic[b] = [a]
ans = 0
for i in range(1, N+1):
s = H[i-1]
t = 0
if i in dic:
for j in range(len(dic[i])):
if s <= H[dic[i][j]-1]:
t += 1
break
if t == 0:
ans += 1
else:
ans += 1
print(ans)
|
N=int(input())%10
if N==3 :print('bon')
elif N==0 or N==1 or N==6 or N==8:print('pon')
else:print('hon')
| 0 | null | 22,083,326,844,472 | 155 | 142 |
N=int(input())
K=[int(n) for n in input().split()]
S=sum(K)
total=0
for i in range(N):
S-=K[i]
total+=K[i]*S
print(total %(10**9+7))
|
R = int(input())
L = 2*R*3.141592
print(L)
| 0 | null | 17,701,352,043,218 | 83 | 167 |
a = sorted([int(input()) for i in range(10)])
a.reverse()
for i in range(3):
print(a[i])
|
a=[]
for i in range(1,11):
b=int(input())
a.append(b)
a.sort(reverse=True)
for i in range(3):
print(a[i])
| 1 | 23,282,068 | null | 2 | 2 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
S = input()
l = len(S)
print("x" * l)
if __name__ == '__main__':
main()
|
score = input()
leng = len(score)
answer = 'x'*leng
print(answer)
| 1 | 72,499,805,064,448 | null | 221 | 221 |
s=input()
print('YNeos'[(s[2]!=s[3])|(s[4]!=s[5])::2])
|
import copy
H, W, K = list(map(int, input().split()))
c = [0]*H
for i in range(H):
char = input()
c[i] = []
for j in range(W):
if char[j] == "#":
c[i].append(1)
else:
c[i].append(0)
count = 0
for i in range(2**H):
for j in range(2**W):
d = copy.deepcopy(c)
i2 = i
j2 = j
for k in range(H):
if i2 & 1:
d[k] = [0]*W
i2 >>= 1
for l in range(W):
if j2 & 1:
for m in range(H):
d[m][l] = 0
j2 >>= 1
s = sum(map(sum, d))
if s == K:
count += 1
print(count)
| 0 | null | 25,598,671,371,460 | 184 | 110 |
from sys import stdin
import numpy as np
def main():
#入力
readline=stdin.readline
n,k=map(int,readline().split())
A=np.array(list(map(int,readline().split())),dtype=np.int64)
A=np.sort(A)[::-1]
F=np.array(list(map(int,readline().split())),dtype=np.int64)
F=np.sort(F)
l=-1
r=10**12
while l<r-1:
x=(l+r)//2
A_after=np.minimum(x//F,A)
cnt=(A-A_after).sum()
if cnt<=k: r=x
else: l=x
print(r)
if __name__=="__main__":
main()
|
N, K = map(int, input().split())
*A, = map(int, input().split())
*F, = map(int, input().split())
A.sort()
F.sort(reverse=True)
def f(x):
ans = 0
for i,j in zip(A, F):
ans += (i*j-x+j-1)//j if i*j-x>=0 else 0
return ans<=K
l, r = -1, 10**18+1
while r-l>1:
mid = (r+l)//2
if f(mid):
r = mid
else:
l = mid
print(r)
| 1 | 164,376,120,519,968 | null | 290 | 290 |
n,m=map(int,input().split())
h=list(map(int,input().split()))
c=0
d=[0]*n
for i in range(m):
a,b=map(int,input().split())
d[a-1]=max(d[a-1],h[b-1])
d[b-1]=max(d[b-1],h[a-1])
for i in range(n):
if h[i]>d[i]:
c+=1
print(c)
|
N, M = [int(_) for _ in input().split()]
l = 1
r = N
ans = []
for _ in range(M - M // 2):
ans += [l, r]
l += 1
r -= 1
if (r - l) % 2 == (l + N - r) % 2:
r -= 1
for _ in range(M // 2):
ans += [l, r]
l += 1
r -= 1
ans = ans[:2 * M]
print('\n'.join(f'{a} {b}' for a, b in zip(ans[::2], ans[1::2])))
| 0 | null | 26,847,022,312,010 | 155 | 162 |
# -*- coding: utf-8 -*-
import math
errerN=1
while errerN:
try:
a=list(map(int, input().split()))
gcdN=math.gcd(a[0],a[1])
print(gcdN, int(a[0]*a[1]/gcdN))
except :
errerN=0
|
n = int(input())
x = list(map(int, input().split()))
ret = 1000000
for p in range(1, 101):
ret = min(ret, sum((x - p) ** 2 for x in x))
print(ret)
| 0 | null | 32,572,099,418,472 | 5 | 213 |
n = int(input())
a = list(map(int, input().split())) + [0]
buy, sell = [], []
for i in range(n):
if a[i] < a[i+1] and len(buy) - len(sell) == 0:
buy.append(i)
if len(buy) - len(sell) == 1 and a[i] > a[i+1]:
sell.append(i)
cash = 1000
for i, j in zip(buy, sell):
stock, rest = divmod(cash, a[i])
cash = stock * a[j] + rest
print(cash)
|
from bisect import *
n,m,k = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
# Aの累積和を保存しておく
# 各Aの要素について、Bが何冊読めるか二分探索する。
# 計算量: AlogB
A.insert(0, 0)
for i in range(1,len(A)):
A[i] += A[i-1]
for i in range(1, len(B)):
B[i] += B[i-1]
ans = 0
for i in range(len(A)):
rest_time = k - A[i]
if rest_time >= 0:
numb = bisect_right(B, rest_time)
anstmp = i + numb
ans = max(ans, anstmp)
print(ans)
| 0 | null | 8,976,816,942,300 | 103 | 117 |
t=int(input())
taro=0
hanako=0
for i in range(t):
S=input().split()
if S[0]==S[1]:
taro+=1
hanako+=1
elif S[0]>S[1]:
taro+=3
else:
hanako+=3
print(taro,hanako)
|
def main():
TaroScore = HanaScore = 0
n = int(input())
for _ in range(n):
[Taro, Hana] = list(input().lower().split())
lenT = len(Taro)
lenH = len(Hana)
lenMin = min(lenT, lenH)
if Taro == Hana:
TaroScore += 1
HanaScore += 1
else:
for i in range(lenMin+1):
if Taro == '':
HanaScore += 3
break
elif Hana == '':
TaroScore += 3
break
elif ord(Taro[0]) > ord(Hana[0]):
TaroScore += 3
break
elif ord(Taro[0]) < ord(Hana[0]):
HanaScore += 3
break
else:
Taro = Taro[1:]
Hana = Hana[1:]
print(TaroScore, HanaScore)
if __name__ == '__main__':
main()
| 1 | 2,003,117,738,340 | null | 67 | 67 |
# -*- 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()
|
def main():
n = int(input())
if n == 0:
print("Yes")
return
slup = []
sldown = []
for i in range(n):
height, mi = 0, 0
for si in input():
if si == "(":
height += 1
else:
height -= 1
mi = min(mi, height)
if height >= 0:
slup.append([mi, height])
else:
sldown.append([mi-height, -height])
slup.sort(key = lambda x: -x[0])
sldown.sort(key = lambda x: -x[0])
if sum([si[1] for si in slup]) + sum([-si[1] for si in sldown]):
print("No")
return
h = 0
for si in slup:
if h+si[0] < 0:
print("No")
return
h += si[1]
h = 0
for si in sldown:
if h+si[0] < 0:
print("No")
return
h += si[1]
print("Yes")
if __name__ == "__main__":
main()
| 1 | 23,572,413,122,140 | null | 152 | 152 |
while 1:
tmp = map(int, raw_input().split())
if tmp[0] == tmp[1] == 0:
break
else:
print " ".join(map(str, sorted(tmp)))
|
v=input()
v=int(v)
print(v**3)
| 0 | null | 398,943,084,178 | 43 | 35 |
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N, K = map(int,input().split())
As = list(map(int,input().split()))
As.sort()
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
rlt = 0
for i in range(N-K+1):
rlt += (As[-i-1] - As[i])*cmb(N-i-1,K-1,p)
rlt %= p
print(rlt)
|
n,k=map(int,input().split())
A=list(map(int,input().split()))
MOD=10**9+7
ans=0
L=[1]*(n+1)
Linv=[1]*(n+1)
inv=[0]+[1]*n
for i in range(2,n+1):
L[i]=(L[i-1]*i)%MOD
inv[i]=(MOD-inv[MOD%i]*(MOD//i))%MOD
Linv[i]=(Linv[i-1]*inv[i])%MOD
def cmb(n,k):
return (((L[n]*Linv[k])%MOD)*Linv[n-k])%MOD
A.sort()
for j in range(n-k+1):
ans+=((A[-1-j]-A[j])*cmb(n-1-j,k-1))%MOD
if ans>=0:
print(ans%MOD)
else:
print(MOD+ans)
| 1 | 95,977,302,062,612 | null | 242 | 242 |
days = ["MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"]
S = input()
if S == "SUN":
print(7)
else:
print(days.index("SUN") - days.index(S))
|
s = input()
day = ['SAT','FRI','THU','WED','TUE','MON','SUN']
for i in range(7):
if s == day[i]:
print(i + 1)
exit()
| 1 | 133,481,258,996,958 | null | 270 | 270 |
import numpy as np
a, b, c, d = map(int, input().split())
x = np.array([a, b])
y = np.array([c, d])
z = np.outer(x, y)
print(z.max())
|
a,b,c,d = map(int, input().split())
if a >=0:
if c > 0:
print(b * d)
elif d < 0:
print(a * d)
else:
print(b*d)
elif a < 0 and b >= 0:
if c >= 0:
print(b * d)
elif d <= 0:
print(a * c)
else:
ac = a * c
bd = b * d
if ac >= bd:
print(ac)
else:
print(bd)
else:
if c >= 0:
print(b * c)
elif d <= 0:
print(a * c)
else:
print(a * c)
| 1 | 3,034,753,726,174 | null | 77 | 77 |
#!/usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
from bisect import bisect_left, bisect_right
import sys, random, itertools, math
sys.setrecursionlimit(10**5)
input = sys.stdin.readline
sqrt = math.sqrt
def LI(): return list(map(int, input().split()))
def LF(): return list(map(float, input().split()))
def LI_(): return list(map(lambda x: int(x)-1, input().split()))
def II(): return int(input())
def IF(): return float(input())
def LS(): return input().split()
def S(): return input().rstrip()
def IR(n): return [II() for _ in range(n)]
def LIR(n): return [LI() for _ in range(n)]
def FR(n): return [IF() for _ in range(n)]
def LFR(n): return [LI() for _ in range(n)]
def LIR_(n): return [LI_() for _ in range(n)]
def SR(n): return [S() for _ in range(n)]
def LSR(n): return [LS() for _ in range(n)]
mod = 1000000007
inf = 1e10
#solve
def solve():
n = II()
st = LSR(n)
x = S()
ans = 0
te = 0
for s, t in st:
if te:
ans += int(t)
if s == x:
te = 1
print(ans)
return
#main
if __name__ == '__main__':
solve()
|
n = int(input())
S = []
T = []
for _ in range(n):
s, t = input().split()
S.append(s)
T.append(int(t))
x = input()
index = S.index(x)
if index == n - 1:
print(0)
else:
print(sum(T[index+1:]))
| 1 | 97,418,208,929,802 | null | 243 | 243 |
S = list(map(str, input()))
T = list(map(str, input()))
ans = 0
for i in range(len(S)):
if S[i]!=T[i]:
ans += 1
print(ans)
|
s=str(input())
t=str(input())
n=len(s)
count=0
for i in range(n):
if s[i]==t[i]:
count+=1
else:
continue
print(n-count)
| 1 | 10,433,053,657,350 | null | 116 | 116 |
arr = [[[0 for i1 in range(10)] for i2 in range(3)] for i3 in range(4)]
count=input()
for l in range(int(count)):
b,f,r,v=input().split()
arr[int(b)-1][int(f)-1][int(r)-1]+=int(v)
first_b = arr[0]
second_b = arr[1]
third_b = arr[2]
fourth_b= arr[3]
for m in range(3):
for n in range(10):
print(" "+str(first_b[m][n]),end="")
print()
print("#"*20)
for m in range(3):
for n in range(10):
print(" "+str(second_b[m][n]),end="")
print()
print("#"*20)
for m in range(3):
for n in range(10):
print(" "+str(third_b[m][n]),end="")
print()
print("#"*20)
for m in range(3):
for n in range(10):
print(" "+str(fourth_b[m][n]),end="")
print()
|
import sys
def gcd(a, b):
return gcd(b, a % b) if a % b else b
def lcm(a, b):
return a * b / gcd(a, b)
for line in sys.stdin:
data = map(int, line.split())
a, b = data
print "%d %d" % (gcd(a, b), lcm(a, b))
| 0 | null | 556,392,289,468 | 55 | 5 |
print('x'*len(input()))
|
n = int(input())
S = [int(x) for x in input().split()]
q = int(input())
T = [int(x) for x in input().split()]
res = 0
for num in T:
if num in S:
res += 1
print(res)
| 0 | null | 36,462,542,893,062 | 221 | 22 |
line = input()
for _ in range(int(input())):
x = input().split()
order = x[0]
a = int(x[1])
b = int(x[2])+1
if order == "print":
print(line[a:b])
elif order == "reverse":
line = line[:a] + line[a:b][::-1] + line[b:]
elif order == "replace":
line = line[:a] + x[3] + line[b:]
|
letters = input()
q = int(input())
for _ in range(q):
words = input().split()
command = words[0]
a, b = map(int, words[1:3])
if command == 'replace':
letters = ''.join([letters[:a], words[3], letters[b+1:]])
elif command == 'reverse':
letters = ''.join([letters[:a ], letters[a:b+1][::-1], letters[b+1:]])
elif command == 'print':
print(letters[a:b+1])
| 1 | 2,092,962,931,370 | null | 68 | 68 |
n = int(input())
arrey = [int(i) for i in input().split()]
count = 0
for i in range(len(arrey)):
minj = i
change = False
for j in range(i+1, len(arrey)):
if arrey[minj] > arrey[j]:
minj = j
change = True
if change:
arrey[i], arrey[minj] = arrey[minj], arrey[i]
count += 1
for i in range(len(arrey)):
print(str(arrey[i])+' ',end='') if i != len(arrey)-1 else print(arrey[i])
print(count)
|
def selectionSort(a):
count = 0
for i in range(len(a)):
mini = i
for j in range(i,len(a)):
if a[j] < a[mini]:
mini = j
if i != mini:
ret = a[i]
a[i] = a[mini]
a[mini] = ret
count += 1
print(" ".join(map(str,a)))
print(count)
n = int(input())
a = list(map(int,input().split()))
selectionSort(a)
| 1 | 20,460,704,320 | null | 15 | 15 |
def main():
while True:
cards = input();
if cards == '-':
break
n = int(input())
for _ in range(n):
s = int(input())
cards = (cards*2)[s:s+len(cards)]
print(cards)
if __name__ == '__main__':
main()
|
def division(n):
if n < 2:
return []
prime_fac = []
for i in range(2,int(n**0.5)+1):
cnt = 0
while n % i == 0:
n //= i
cnt += 1
if cnt!=0:prime_fac.append((i,cnt))
if n > 1:
prime_fac.append((n,1))
return prime_fac
n = int(input())
div = division(n)
ans = 0
for i,e in div:
b = 1
while b <= e:
e -= b
b += 1
ans += 1
print(ans)
| 0 | null | 9,463,580,189,340 | 66 | 136 |
# coding: utf-8
n = int(input())
R = [ int(input()) for i in range(n)]
MIN = R[0]
MAXdiff = R[1]-R[0]
for i in range(1,n):
MAXdiff = max(MAXdiff,R[i]-MIN)
MIN = min(MIN,R[i])
print(MAXdiff)
|
n=input()
min = None
max = None
cand=None
for x in xrange(n):
v = input()
# print "#### %s %s %s %s" % (str(max), str(min), str(cand), str(v))
if min is None:
min = v
# print "min is None"
continue
if min > v:
# print "min > v"
if (cand is None) or (cand < v-min):
# print "cand None"
cand = v-min
min = v
max = None
continue
elif (max is None) or (max < v):
# print "max is None"
max = v
if cand < max - min:
cand = max - min
continue
print cand
| 1 | 13,798,296,378 | null | 13 | 13 |
name = input()
print(name[:3])
|
import sys
sys.setrecursionlimit(10 ** 5 + 10)
def input(): return sys.stdin.readline().strip()
def resolve():
s=str(input())
print(s[:3])
resolve()
| 1 | 14,808,145,548,910 | null | 130 | 130 |
alpha = input()
if(alpha.isupper()):
print("A")
else:
print("a")
|
A = input()
ans = 'A' if A.isupper() else 'a'
print(ans)
| 1 | 11,410,234,796,870 | null | 119 | 119 |
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x % y)
x, y = [int(n) for n in input().split()]
print(gcd(x, y))
|
a, b, c = map(int, input().split())
l = []
for i in range(1, c+1):
if c%i==0:
l.append(i)
res = 0
for i in range(a, b+1):
if i in l:
res+=1
print(res)
| 0 | null | 293,143,511,832 | 11 | 44 |
A,B,C = map(str, input().split())
l = str(C)+str(' ')+str(A)+str(' ')+str(B)
print(l)
|
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
x, y, z = inm()
print(z, x, y)
| 1 | 38,006,450,738,678 | null | 178 | 178 |
n = int(input())
s = input().rstrip()
i=0
j=n-1
c= 0
while i!=j:
while s[j]!='R' and j>i:
j-=1
while s[i]=='R' and j>i:
i+=1
if i!=j:
c+= 1
i+= 1
j-=1
if i>=j:
break
print(c)
|
x=list(map(int,input().split()))
print(sum([1,2,3,4,5])-sum(x))
| 0 | null | 9,904,823,010,908 | 98 | 126 |
import abc
class AdjacentGraph:
"""Implementation adjacency-list Graph.
Beware ids are between 1 and size.
"""
def __init__(self, size):
self.size = size
self._nodes = [[0] * (size+1) for _ in range(size+1)]
def set_adj_node(self, id_, adj_id):
self._nodes[id_][adj_id] = 1
def __iter__(self):
self._id = 0
return self
def __next__(self):
if self._id < self.size:
self._id += 1
return (self._id, self._nodes[self._id][1:])
raise StopIteration()
def dfs(self, handler=None):
def find_first():
try:
return visited.index(0) + 1
except ValueError:
return None
visited = [0] * self.size
first = 1
while first is not None:
stack = [(first, 0, 0)]
while len(stack) > 0:
i, depth, j = stack.pop()
if j == 0:
if handler:
handler.visit(i, depth)
visited[i-1] = 1
yield i
try:
j = self._nodes[i].index(1, j+1)
stack.append((i, depth, j))
if visited[j-1] == 0:
stack.append((j, depth+1, 0))
except ValueError:
if handler:
handler.leave(i)
first = find_first()
def bfs(self, handler=None):
def find_first():
try:
return visited.index(0) + 1
except ValueError:
return None
visited = [0] * self.size
first = 1
while first is not None:
queue = [(first, 0)]
while len(queue) > 0:
(i, depth), *queue = queue
if visited[i-1] == 0:
if handler:
handler.visit(i, depth)
visited[i-1] = 1
yield i
try:
j = 0
while j < self.size:
j = self._nodes[i].index(1, j+1)
if visited[j-1] == 0:
queue.append((j, depth+1))
except ValueError:
pass
if handler:
handler.leave(i)
first = find_first()
class EventHandler(abc.ABC):
@abc.abstractmethod
def visit(self, i, depth):
pass
@abc.abstractmethod
def leave(self, i):
pass
class Logger(EventHandler):
def __init__(self, n):
self.log = [(0, 0)] * n
self.step = 0
def visit(self, i, depth):
self.step += 1
self.log[i-1] = (self.step, depth, 0)
def leave(self, i):
self.step += 1
self.log[i-1] = (self.log[i-1][0], self.log[i-1][1], self.step)
def by_node(self):
i = 1
for discover, depth, finish in self.log:
yield (i, discover, depth, finish)
i += 1
def run():
n = int(input())
g = AdjacentGraph(n)
log = Logger(n)
for i in range(n):
id_, c, *links = [int(x) for x in input().split()]
for n in links:
g.set_adj_node(id_, n)
for i in g.bfs(log):
pass
reachable = None
for node in log.by_node():
id_, find, dep, exit = node
if id_ > 1 and dep == 0:
reachable = find - 1
if reachable is not None and find > reachable:
dep = -1
print("{} {}".format(id_, dep))
if __name__ == '__main__':
run()
|
def BFS(s = 0):
Q.pop(0)
color[s] = 2
for j in range(len(color)):
if A[s][j] == 1 and color[j] == 0:
Q.append(j)
color[j] = 1
d[j] = d[s] + 1
if len(Q) != 0:
BFS(Q[0])
n = int(raw_input())
A = [0] * n
for i in range(n):
A[i] = [0] * n
for i in range(n):
value = map(int, raw_input().split())
u = value[0] - 1
k = value[1]
nodes = value[2:]
for j in range(k):
v = nodes[j] - 1
A[u][v] = 1
color = [0] * n
Q = [0]
d = [-1] * n
d[0] = 0
BFS(0)
for i in range(n):
print(str(i + 1) + " " + str(d[i]))
| 1 | 3,767,574,980 | null | 9 | 9 |
A,B = map(int,input().split())
if A < 10 and B < 10:
answer = A * B
print(answer)
else:
print('-1')
|
n = list(map(int,input().split()))
if max(n)>9:
print(-1)
else:
print(n[0]*n[1])
| 1 | 158,316,105,709,732 | null | 286 | 286 |
n=int(input())
def factorization(n):
arr = []
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
arr.append([i, cnt])
if temp!=1:
arr.append([temp, 1])
if arr==[]:
arr.append([n, 1])
return arr
ans=0
l=len(factorization(n))
s=factorization(n)
for i in range(l):
for j in range(1,1000):
if s[i][1]>=j:
ans+=1
s[i][1]-=j
else:
break
if n==1:
print(0)
else:
print(ans)
|
import numpy as np
import math
from decimal import *
#from numba import njit
def getVar():
return map(int, input().split())
def getArray():
return list(map(int, input().split()))
def getNumpy():
return np.array(list(map(int, input().split())), dtype='int64')
def factorization(n):
d = {}
temp = n
for i in range(2, int(-(-n**0.5//1))+1):
if temp%i==0:
cnt=0
while temp%i==0:
cnt+=1
temp //= i
d.update({i: cnt})
if temp!=1:
d.update({temp: 1})
if d==[]:
d.update({n:1})
return d
def main():
N = int(input())
d = factorization(N)
count = 0
for v in d.values():
i = 1
while(v >= i):
v -= i
i += 1
count += 1
print(count)
main()
| 1 | 16,794,024,782,678 | null | 136 | 136 |
A = [input().split() for _ in range(3)]
N = int(input())
c = [[False]*3 for _ in range(3)]
for _ in range(N):
B = input()
for i in range(3):
if B in A[i]:
c[i][A[i].index(B)] = True
def solve(c):
y = "Yes"
n = "No"
for i in range(3):
if c[i][0] and c[i][1] and c[i][2]:
return y
if c[0][i] and c[1][i] and c[2][i]:
return y
if c[0][0] and c[1][1] and c[2][2]:
return y
if c[0][2] and c[1][1] and c[2][0]:
return y
return n
print(solve(c))
|
a,b,c,d = map(int,input().split())
answers = []
one = a*c
two = a*d
three = b*c
four = b*d
answers.append(one)
answers.append(two)
answers.append(three)
answers.append(four)
print(max(answers))
| 0 | null | 31,633,559,781,318 | 207 | 77 |
import sys
from collections import Counter
def ep(*params):
print(*params,file=sys.stderr)
(N,P) = list(map(int,input().split()))
S = input().rstrip()
if 10%P == 0:
ans = 0
for i in range(N):
if int(S[i])%P == 0:
ans += i+1
print(ans)
sys.exit()
ans = 0
d = [0]*(N+1)
cnt = [0]*P
ten = 1
for i in range(N-1,-1,-1):
a = int(S[i]) * ten % P
d[i] = (d[i+1]+a) % P
ten *= 10
ten %= P
#ep(d)
for i in range(N,-1,-1):
ans += cnt[d[i]]
cnt[d[i]] += 1;
#ep(i,ans,cnt)
#ep(cnt)
print(ans)
|
n,p=map(int,input().split())
s=input()
if p==2 or p==5:
ans=0
for i in range(n):
if int(s[i])%p==0:
ans+=i+1
print(ans)
else:
t=[]
ti=0
for i in range(n):
ti+=int(s[-i-1])*pow(10,i,p)
ti%=p
t.append(ti)
from collections import Counter
tc=Counter(t)
ans=0
for v in tc.values():
ans+=(v*(v-1))//2
if 0 in tc:
ans+=tc[0]
print(ans)
| 1 | 57,871,719,149,592 | null | 205 | 205 |
ans = list(map(int,input().split()))
print(15-sum(ans))
|
x=list(map(int,input().split()))
for k in range(5):
if x[k]==0:
print(k+1)
else:
continue
| 1 | 13,571,260,809,032 | null | 126 | 126 |
num = int(input())
data = list()
for i in range(1,10):
for j in range(1, 10):
data.append(i*j)
if num in data:
print('Yes')
else:
print('No')
|
num = int(input())
i = 1
while i <= 9:
j = 1
while j <= 9:
if (i * j) / num == 1:
print("Yes")
exit()
else:
j += 1
i += 1
print("No")
| 1 | 159,280,404,979,840 | null | 287 | 287 |
X, Y = map(int, input().split(' '))
print('Yes' if (X * 2 <= Y <= X * 4) and (Y % 2 == 0) else 'No')
|
n = int(input())
def solve1(n: int) -> str:
k = 0
for i in range(len(n)):
k += int(n[i])
if k % 9 == 0:
return "Yes"
else:
return "No"
def solve2(n: int) -> str:
if n % 9 == 0:
return "Yes"
else:
return "No"
print(solve2(n))
| 0 | null | 8,991,185,332,220 | 127 | 87 |
a=input('').split()
a=list(map(int,a))
b=(a[0])
c=(a[1])
d=(a[2])
e=(a[3])
f=b*d
g=b*e
h=c*d
i=c*e
if f>g:
if h>f:
if i>h:
print(i)
else:
print(h)
else:
if i>f:
print(i)
else:
print(f)
else:
if h>g:
if i>h:
print(i)
else:
print(h)
else:
if i>g:
print(i)
else:
print(g)
|
a=[int(x) for x in input().split()]
b=[a[0]*a[2],a[0]*a[3],a[1]*a[2],a[1]*a[3]]
print(max(b))
| 1 | 3,041,765,548,000 | null | 77 | 77 |
v, e = map(int,input().split())
par = [i for i in range(v+1)]
def find(x):
if par[x] == x:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x, y):
x = find(x)
y = find(y)
if x == y:
return 0
par[x] = y
for i in range(e):
a, b = map(int, input().split())
unite(a, b)
cnt = 0
for i in range(v+1):
if i == par[i]:
cnt += 1
print(cnt-2)
|
class UnionFind:
def __init__(self, num):
self.parent = [-1] * num
def find(self, node):
if self.parent[node] < 0:
return node
self.parent[node] = self.find(self.parent[node])
return self.parent[node]
def union(self, node1, node2):
node1 = self.find(node1)
node2 = self.find(node2)
if node1 == node2:
return
if self.parent[node1] > self.parent[node2]:
node1, node2 = node2, node1
self.parent[node1] += self.parent[node2]
self.parent[node2] = node1
return
def same(self, node1, node2):
return self.find(node1) == self.find(node2)
def size(self, x):
return -self.parent[self.find(x)]
def roots(self):
return [i for i, x in enumerate(self.parent) if x < 0]
def group_count(self):
return len(self.roots())
n, m = map(int, input().split())
uf = UnionFind(n)
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
uf.union(a, b)
print(uf.group_count() - 1)
| 1 | 2,257,532,088,992 | null | 70 | 70 |
a=list(map(int,input().split()))
print(*[a[2],a[0],a[1]],sep=' ')
|
N=2*10**5+1
mod=10**9+7
f=[None]*N
fi=[None]*N
f[0]=1
for i in range(1,N):
f[i]=i*f[i-1]%mod
for i in range(N):
fi[i]=pow(f[i],mod-2,mod)
def com(n,k):
return f[n]*fi[n-k]%mod*fi[k]%mod
def hcom(n,k):
return com(n+k-1,n-1)
n,k=map(int,input().split())
ans=1
for i in range(1,min(k+1,n)):
ans=(ans+com(n,i)*hcom(n-i,i)%mod)%mod
print(ans)
| 0 | null | 52,688,958,692,572 | 178 | 215 |
X,K,D = map(int, input().split())
X = abs(X)
if X//D > K:
print(X-(D*K))
exit()
if (K-X//D)%2:
print(D-X%D)
else:
print(X%D)
|
import sys
import time
import math
def inpl():
return list(map(int, input().split()))
st = time.perf_counter()
# ------------------------------
S = input()
T = S[::-1]
ans = 0
for i in range(len(S)//2):
if S[i] != T[i]:
ans += 1
print(ans)
# ------------------------------
ed = time.perf_counter()
print('time:', ed-st, file=sys.stderr)
| 0 | null | 62,642,869,767,620 | 92 | 261 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
sys.setrecursionlimit(10**7)
ni = lambda: int(ns())
nin = lambda y: [ni() for _ in range(y)]
na = lambda: list(map(int, stdin.readline().split()))
nan = lambda y: [na() for _ in range(y)]
nf = lambda: float(ns())
nfn = lambda y: [nf() for _ in range(y)]
nfa = lambda: list(map(float, stdin.readline().split()))
nfan = lambda y: [nfa() for _ in range(y)]
ns = lambda: stdin.readline().rstrip()
nsn = lambda y: [ns() for _ in range(y)]
ncl = lambda y: [list(ns()) for _ in range(y)]
nas = lambda: stdin.readline().split()
def modpow(n, p, m):
if p == 0:
return 1
if p % 2 == 0:
t = modpow(n, p // 2, m)
return t * t % m
return n * modpow(n, p - 1, m) % m
n = ni()
A = modpow(9, n, mod)
B = A
C = modpow(8, n, mod)
D = modpow(10, n, mod)
ans = (D - A - B + C) % mod
print(ans)
|
N = int(input())
A = list(map(int, input().split()))
ans = float('inf')
sum_A = sum(A)
hoge = 0
for i in range(N-1):
hoge = hoge + A[i]
ans = min(ans,abs(sum_A - (hoge*2)))
print(ans)
| 0 | null | 72,920,580,762,972 | 78 | 276 |
n = int(input())
s = []
t = []
for i in range(n):
ss,tt = map(str,input().split())
s.append(ss)
t.append(tt)
x = input()
ans = 0
for i in range(n-1):
if ans != 0:
ans += int(t[i+1])
elif s[i] == x:
ans += int(t[i+1])
print(ans)
|
while True:
H, W = map(int, input().split())
if H == 0 and W == 0:
break
else:
if W % 2 == 0:
i = H//2
while i > 0:
print("#."*(W//2))
print(".#"*(W//2))
i -= 1
if H % 2 == 1:
print("#."*(W//2))
else:
i = H // 2
while i > 0:
print("#."*(W//2)+"#")
print(".#"*(W//2)+".")
i -= 1
if H % 2 == 1:
print("#."*(W//2)+"#")
print("")
| 0 | null | 49,163,827,336,960 | 243 | 51 |
from collections import Counter
N = int(input())
S = input()
dic = Counter(S)
cnt = 0
for i in range(0,N-2):
for j in range(i+1,N-1):
if S[i] == S[j]:
continue
elif 2*j - i < N:
if S[i] != S[2*j-i] and S[j] != S[2*j-i]:
cnt += 1
print(dic["R"]*dic["B"]*dic["G"]-cnt)
|
def main():
n, m = map(int, input().split())
if n%2:
for i in range(m):
print(i+1, n-i)
else:
for i in range(m):
if n-2*i-1 > n//2:
print(i+1, n-i)
else:
print(i+1, n-i-1)
if __name__ == "__main__":
main()
| 0 | null | 32,508,754,371,592 | 175 | 162 |
import sys
input = sys.stdin.readline
mod = 10**9 + 7
def main():
n = int(input())
A = list(map(int, input().split()))
candidates = [0] * (n+1)
candidates[0] = 3
ans = 1
for a in A:
ans *= candidates[a]
ans %= mod
candidates[a] -= 1
candidates[a+1] += 1
print(ans)
if __name__ == "__main__":
main()
|
#!/usr/bin python3
# -*- coding: utf-8 -*-
def main():
mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
C = [0] * 3
ret = 1
for i in range(N):
ret *= C.count(A[i])
ret %= mod
for j in range(3):
if C[j]==A[i]:
C[j]+=1
break
print(ret)
if __name__ == '__main__':
main()
| 1 | 129,774,538,220,480 | null | 268 | 268 |
h = int(input())
w = int(input())
n = int(input())
m = max(w,h)
if n > n //m * m:
ans = n // m + 1
else:
ans = n // m
print(ans)
|
h = int(input())
w = int(input())
n = int(input())
total = h*w
kesu = max(h, w)
if n%kesu==0:
print(n//kesu)
else:
print(n // kesu + 1)
| 1 | 88,704,989,820,080 | null | 236 | 236 |
S, T = input().split()
A, B = map(int, input().split())
U = input()
if S == U :
print(str(A - 1) + ' ' + str(B))
elif T == U :
print(str(A) + ' ' + str(B - 1))
|
s=input()
for i in range(len(s)):
print('x',end='')
| 0 | null | 72,044,804,430,368 | 220 | 221 |
import numpy as np
N, M = map(int, input().split())
A = []
A = map(int, input().split())
dif = N - sum(A)
if dif >= 0:
print(dif)
else:
print('-1')
|
x,y = list(input().split())
x = int(x)
y = int(y[0]+y[2]+y[3])
print(x*y//100)
| 0 | null | 24,309,044,165,760 | 168 | 135 |
N=int(input())
ans=0
for a in range(1,N):
ans+=int((N-1)//a)
print(ans)
|
import math
N=int(input())
def era(n):
prime=[]
furui=list(range(2,n+1))
while furui[0]<math.sqrt(n):
prime.append(furui[0])
furui=[i for i in furui if i%furui[0]!=0]
return prime+furui
furui=era(10**6+7)
minfac=list(range(10**6+8))
for i in furui:
for j in range(i,(10**6+7)//i+1):
if minfac[i*j]==i*j:
minfac[i*j]=i
ans=0
for i in range(1,N):
temp=1
temp2=1
l=1
while i != 1:
if minfac[i]!=l:
temp*=temp2
temp2=2
else:
temp2+=1
l=minfac[i]
i//=l
temp*=temp2
ans+=temp
print(ans)
| 1 | 2,569,089,183,540 | null | 73 | 73 |
x = int(input())
num = x // 100
sur = x % 100
if sur <= num * 5:
print(1)
else:
print(0)
|
n = int(input())
s = list(str(n))
r = list(reversed(s))
if r[0] in ["2","4","5","7","9"]:
print("hon")
elif r[0] in ["0","1","6","8"]:
print("pon")
else:
print("bon")
| 0 | null | 73,456,411,953,038 | 266 | 142 |
#active infants
n=int(input())
lists=list(map(int,input().split()))
data=[]
for i in range(n):
data.append((lists[i],i+1))
data=sorted(data,key=lambda x:-x[0])
#dp[K][i]=始めのKつまで考えてそのうちプラスの個数がiこの方法で最大のあたい(0<=i<=K)
#求める値はmax(dp[N][i] for i in range(N+1))で与えられる
#dp[N][N]まで考えればいい
#計算量0(N**2)
dp=[[0 for i in range(n+1)] for j in range(n+1)]
dp[1][1]=n*(data[0][0])-data[0][0]*data[0][1]
dp[1][0]=data[0][0]*data[0][1]-data[0][0]
for i in range(2,n+1):
#dp[i]について考える
for j in range(i+1):
x=data[i-1][0]
y=data[i-1][1]
#j=0,1,,,,,iまで
#dp[i][j]-> 直前は i-1,j-1, or i-1 j のどちらか
if i>j>=1:
dp[i][j]=max(dp[i-1][j-1]+x*(n+1-j)-x*y,dp[i-1][j]-(i-j)*x+x*y)
elif j==0:
dp[i][j]=dp[i-1][0]-i*x+x*y
elif j==i:
dp[i][j]=dp[i-1][i-1]+x*(n+1-j)-x*y
K=0
for i in range(n+1):
K=max(K,dp[n][i])
print(K)
|
N = int(input())
A = sorted([(int(a), i) for i, a in enumerate(input().split())], key = lambda x: x[0])[::-1]
X = [0] + [-1<<100] * (N + 5)
for k, (a, i) in enumerate(A):
X = [max(X[j] + abs(N - (k - j) - 1 - i) * a, X[j-1] + abs(j - 1- i) * a if j else 0) for j in range(N + 5)]
print(max(X))
| 1 | 33,783,236,732,852 | null | 171 | 171 |
import sys
i=1
while True:
x=sys.stdin.readline().strip()
if x=="0":
break;
print("Case %d: %s"%(i,x))
i+=1
|
H, A = map(int, input().split())
if H % A == 0:
count_e = H//A
print(count_e)
elif H < A:
count_u = 1
print(count_u)
elif H % A != 0:
count_o = H // A + 1
print(count_o)
| 0 | null | 38,896,796,203,680 | 42 | 225 |
n = int(input())
S = [False for i in range(13)]
D = [False for i in range(13)]
C = [False for i in range(13)]
H = [False for i in range(13)]
for i in range(n):
a,b = input().split()
b = int(b)
if a == "S":
S[b-1] = True
elif a == "D":
D[b-1] = True
elif a == "C":
C[b-1] = True
elif a == "H":
H[b-1] = True
for i in range(13):
if S[i] == False:
print("S "+str(i+1))
for i in range(13):
if H[i] == False:
print("H "+str(i+1))
for i in range(13):
if C[i] == False:
print("C "+str(i+1))
for i in range(13):
if D[i] == False:
print("D "+str(i+1))
|
N = int(input())
A = [0]*N
B = [0]*N
for n in range(N):
A[n],B[n] = map(int,input().split())
A.sort()
B.sort()
if N % 2 == 1:
print(B[N//2]-A[N//2]+1)
else:
Am = (A[N//2]+A[N//2-1])/2
Bm = (B[N//2]+B[N//2-1])/2
print(int((Bm-Am)*2)+1)
| 0 | null | 9,193,618,849,228 | 54 | 137 |
A, B = input().split()
print(int(A)*int(B) if len(A) == len(B) == 1 else -1)
|
#!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
A,B=pin()
if A>9 or B>9:print(-1);return
print(A*B)
#%%submit!
resolve()
| 1 | 158,261,822,831,648 | null | 286 | 286 |
n, k = list(map(int, input().split()))
max_len = 2 * n - 1 # 適宜変更する
mod = 10**9 + 7
def modinv(x):
'''
xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
Python標準のpowは割った余りを出すことも可能。
'''
return pow(x, mod-2, mod)
# 二項係数の左側の数字の最大値を max_len とする。nとかだと他の変数と被りそうなので。
# factori_table = [1, 1, 2, 6, 24, 120, ...] 要は factori_table[n] = n!
# 計算時間はO(max_len * log(mod))
modinv_table = [-1] * (max_len + 1)
modinv_table[0] = None # 万が一使っていたときにできるだけ早期に原因特定できるようにしたいので、Noneにしておく。
factori_table = [1] * (max_len + 1)
factori_inv_table = [1] * (max_len + 1)
for i in range(1, max_len + 1):
factori_table[i] = factori_table[i-1] * (i) % mod
modinv_table[1] = 1
for i in range(2, max_len + 1):
modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod
factori_inv_table[i] = factori_inv_table[i-1] * modinv_table[i] % mod
def binomial_coefficients(n, k):
'''
n! / (k! * (n-k)! )
0 <= k <= nを満たさないときは変な値を返してしまうので、先にNoneを返すことにする。
場合によっては0のほうが適切かもしれない。
'''
if not 0 <= k <= n:
return None
return (factori_table[n] * factori_inv_table[k] * factori_inv_table[n-k]) % mod
def binomial_coefficients2(n, k):
'''
(n * (n-1) * ... * (n-k+1)) / (1 * 2 * ... * k)
'''
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i + 1]
ans %= mod
return ans
if k >= n-1:
# nHn = 2n-1 C n
print(binomial_coefficients(2 * n - 1, n))
else:
# 移動がk回←→ 人数0の部屋がk個以下
# 人数0の部屋がちょうどj個のものは
# nCj(人数0の部屋の選び方) * jH(n-j) (余剰のj人を残りの部屋に入れる)
ans = 0
for j in range(k+1):
if j == 0:
ans += 1
else:
ans += binomial_coefficients(n, j) * binomial_coefficients(n-1, j)
ans %= mod
print(ans)
|
n, k = map(int, input().split())
k = min(n - 1, k)
mod = 10 ** 9 + 7
fact = [1] * (n + 1)
ifact = [1] * (n + 1)
for i in range(n):
fact[i + 1] = fact[i] * (i + 1) % mod
ifact[i + 1] = pow(fact[i + 1], mod - 2, mod)
def comb(x, y):
if y < 0 or y > x:
return 0
return (fact[x] * ifact[x - y] * ifact[y]) % mod
ans = 0
for i in range(k + 1):
ans += comb(n, i) * comb(n - 1, n - i - 1) % mod
ans %= mod
print(ans)
| 1 | 66,847,183,326,472 | null | 215 | 215 |
n=int(input())
c=0
for _ in range(n):
x=int(input())
if x==2:c+=1
elif pow(2,x-1,x)==1:c+=1
print(c)
|
import math
def isPrime(n):
for i in range(2, int(math.sqrt(n))+1):
if n % i == 0:
return False
return True
N = int(input())
nums = [int(input()) for i in range(N)]
print(sum([isPrime(n) for n in nums]))
| 1 | 9,957,982,910 | null | 12 | 12 |
import math
import sys
import collections
import bisect
readline = sys.stdin.readline
def main():
n = int(readline().rstrip())
s = readline().rstrip()
cnt = 0
for i in range(1000):
x = str(i).zfill(3)
a = s[:-1].find(x[0])
if a != -1:
b = s[a + 1: -1].find(x[1])
if b != -1:
c = s[a + b + 2:].find(x[2])
if c != -1:
cnt += 1
print(cnt)
if __name__ == '__main__':
main()
|
n=int(input())
s=input()
ans=0
for i in range(10):
for j in range(10):
for k in range(10):
tar=str(i)+str(j)+str(k)
now=0
for l in range(n):
if tar[0+now]==s[l]:now+=1
if now==3:
ans+=1
break
print(ans)
| 1 | 129,165,233,974,748 | null | 267 | 267 |
# -*- coding: utf-8 -*-
import sys
def top_k_sort(data, k=3, reverse=True):
data.sort(reverse=True)
return data[:k]
def main():
data = []
for line in sys.stdin:
data.append(int(line))
for h in top_k_sort(data):
print(h)
if __name__ == '__main__':
main()
|
def main():
altitude_lis = []
for i in range(10):
input_line = raw_input()
altitude = int(input_line)
altitude_lis.append(altitude)
altitude_lis.sort()
altitude_lis.reverse()
for i in range(3):
print(altitude_lis[i])
if __name__ == '__main__':
main()
| 1 | 21,283,150 | null | 2 | 2 |
from collections import deque
T = input()
A = deque()
d = 0
s = 0
for i, token in enumerate(T):
if token == "\\":
s += d + 0.5
if not d:
l = i
d += 1
elif token == "/":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
A.append((l, s))
s = 0
else:
s += d
B = deque()
d = 0
s = 0
for i in range(len(T) - 1, -1, -1):
token = T[i]
if token == "/":
s += d + 0.5
d += 1
elif token == "\\":
if not d:
continue
d -= 1
s += d + 0.5
if not d:
B.appendleft((i, s))
s = 0
else:
s += d
S = set(A) | set(B)
S = list(S)
S.sort()
S = [round(s[1]) for s in S]
print(sum(S))
print(len(S), *S)
|
# -*- coding: utf-8 -*-
def selection_sort(n, a):
cnt = 0
for i in range(n):
minj = i
for j in range(i, n):
if a[j] < a[minj]:
minj = j
if i != minj:
tmp = a[minj]
a[minj] = a[i]
a[i] = tmp
cnt += 1
return a, cnt
if __name__ == '__main__':
n = int(input())
a = [int(n) for n in input().split()]
ans, cnt = selection_sort(n, a)
print(' '.join(map(str, ans)))
print(cnt)
| 0 | null | 38,680,057,508 | 21 | 15 |
n= int(input())
table=[[[0]*10 for i in range(0,3)]for j in range(0,4)]
for k in range(n):
b,f,r,v = map(int,input().split())
table[b-1][f-1][r-1] +=v
x=0
for i in range(4):
if x !=0:
print("#"*20)
x =x+1
for a in range(3):
for b in range(10):
print(" %d"%(table[i][a][b]),end="")
print()
|
if __name__ == '__main__':
nums = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = [int(i) for i in input().split()]
nums[b-1][f-1][r-1] += v
for b in range(4):
for f in range(3):
print(' ' + ' '.join([str(i) for i in nums[b][f]]))
if b == 3: break
print('#'*20)
| 1 | 1,084,687,709,980 | null | 55 | 55 |
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]))
|
N = int(input())
A = list(map(int, input().split()))
INF = 10**18
dp0 = [-INF] * (N + 2)
dp1 = [-INF] * (N + 2)
dp2 = [-INF] * (N + 2)
dp0[0] = 0
dp0[1] = 0
dp1[0] = 0
dp1[1] = 0
for i, a in enumerate(A, start=2):
dp0[i] = dp0[i - 2] + a
dp1[i] = max(dp1[i - 2] + a, dp0[i - 1])
dp2[i] = max(dp2[i - 2] + a, dp1[i - 1], dp0[i - 2])
if N % 2 == 1:
print(dp2[-1])
else:
print(max(dp1[-1], dp0[-1]))
| 1 | 37,326,818,773,948 | null | 177 | 177 |
n = input()
n = n[::-1] + '0'
inf = 10 ** 9
dp = [[inf for _ in range(2)] for _ in range(len(n) + 1)]
dp[0][0] = 0
dp[0][1] = 2
for i in range(len(n)):
n_i = int(n[i])
dp[i + 1][0] = min(dp[i][0] + n_i, dp[i][1] + n_i)
dp[i + 1][1] = min(dp[i][0] + 11 - n_i, dp[i][1] + 9 - n_i)
print(min(dp[-1][0], dp[-1][1]))
|
N = input()
dp = [0, 1]
for n in N:
n = int(n)
dp[0], dp[1] = min(dp[0]+n, dp[1]+10-n), min(dp[0]+n+1, dp[1]+10-(n+1))
print(dp[0])
| 1 | 71,080,023,507,868 | null | 219 | 219 |
H, W, K = map(int, input().split())
m = []
for h in range(H):
m.append(list(map(int, list(input()))))
ans = float('inf')
for hb in range(2**(H-1)):
hl = []
for i in range(H-1):
if hb & (1 << i) > 0:
hl.append(i+1)
t = len(hl)
hl = [0]+hl+[H]
w, pw = 0, 0
wl = [0]*len(hl)
while w < W:
ok = True
for i in range(len(hl)-1):
sh, eh = hl[i], hl[i+1]
for h in range(sh, eh):
wl[i] += m[h][w]
if wl[i] > K:
ok = False
break
if not ok:
break
if not ok:
if pw == w:
t = float('inf')
break
pw, w = w, w
t += 1
wl = [0]*len(hl)
else:
w += 1
ans = min(t, ans)
print(ans)
|
A,B=input().split()
A=int(A)
B=int(100*float(B)+0.5)
print(int(A*B/100))
| 0 | null | 32,107,334,696,640 | 193 | 133 |
H,N = map(int,input().split())
i = map(int,input().split())
if sum(i) >= H :
print("Yes")
else :
print("No")
|
h, n = map(int,input().split())
a = list(map(int,input().split()))
hitpoint=h
atack = a[:]
for e in atack:
hitpoint -= e
if hitpoint <= 0:
break
if hitpoint <= 0:
print("Yes")
else:
print("No")
| 1 | 78,072,203,477,010 | null | 226 | 226 |
a,b,c=input().split()
if a==b and a!=c:
print("Yes")
elif a==c and a!=b:
print("Yes")
elif b==c and a!=b:
print("Yes")
else:
print("No")
|
now = int(input())
if now <30:
print("No")
else:
print("Yes")
| 0 | null | 36,810,491,477,640 | 216 | 95 |
'''
問題：
高橋君と青木君がモンスターを闘わせます。
高橋君のモンスターは体力が A で攻撃力が B です。
青木君のモンスターは体力が C で攻撃力が D です。
高橋君→青木君→高橋君→青木君→... の順に攻撃を行います。
攻撃とは、相手のモンスターの体力の値を自分のモンスターの攻撃力のぶんだけ減らすことをいいます。
このことをどちらかのモンスターの体力が 0 以下になるまで続けたとき、
先に自分のモンスターの体力が 0 以下になった方の負け、そうでない方の勝ちです。
高橋君が勝つなら Yes、負けるなら No を出力してください。
'''
'''
制約：
1 ≦ A, B, C, D ≦ 100
入力は全て整数である
'''
class Monster:
def __init__(self, hp, power):
self.hp = hp
self.power = power
def fight(self, power) -> int:
self.hp -= power
return self.hp
def is_loser(self) -> bool:
return self.hp <= 0
# 標準入力から A, B, C, D を取得する
a, b, c, d = map(int, input().split())
takahashi_monster = Monster(a, b) # 高橋モンスター
aoki_monster = Monster(c, d) # 青木モンスター
result = "ret"
while True:
aoki_monster.fight(b) # 高橋の攻撃
if aoki_monster.is_loser():
result = "Yes"
break
takahashi_monster.fight(d) # 青木の攻撃
if takahashi_monster.is_loser():
result = "No"
break
print(result)
|
A, B, C, D = map(int, input().split())
print('No' if -A // D > -C // B else 'Yes')
| 1 | 29,614,473,333,088 | null | 164 | 164 |
n = int(input())
numbers = list(map(int, input().split()))
print(' '.join(str(x) for x in numbers))
for i in range(1, n):
key = numbers[i]
j = i - 1
while 0 <= j and key < numbers[j]:
numbers[j+1] = numbers[j]
j -= 1
numbers[j+1] = key
print(' '.join(str(x) for x in numbers))
|
def insertion_sort(A):
n = len(A)
print(*A)
for i in range(1, n):
item = A[i]
cur_idx = i - 1
while cur_idx >= 0 and A[cur_idx] > item:
A[cur_idx], A[cur_idx + 1] = A[cur_idx + 1], A[cur_idx]
cur_idx -= 1
print(*A)
if __name__ == "__main__":
N = int(input())
A = [int(elem) for elem in input().split()]
insertion_sort(A)
| 1 | 5,206,878,222 | null | 10 | 10 |
n=int(input())
a=list(map(int,input().split()))
money=1000
kabu=0
for i in range(n-1):
if a[i]<a[i+1] and a[i]<=money:
kabu+=money//a[i]
money-=kabu*a[i]
if a[i]>a[i+1] and kabu>0:
money+=kabu*a[i]
kabu=0
if kabu>0:
money+=kabu*a[-1]
print(money)
|
import sys
input = sys.stdin.readline
N = int(input())
A = list(map(int, input().split()))
dp = [0]*(N+1)
dp[0] = 1000
for i in range(1, N+1):
dp[i] = dp[i-1]
for j in range(i):
dp[i] = max(dp[i], dp[j]//A[j]*A[i-1]+dp[j]%A[j])
print(dp[N])
| 1 | 7,327,523,377,088 | null | 103 | 103 |
X, K, D=(map(int, input().split()))
X=abs(X)
N=int(X/D)
if N==0:
if K%2==0:
print(X)
else:
print(D-X)
else:
if N>K:
print(X-K*D)
elif (K-N)%2==0:
print(X-N*D)
else:
print((N+1)*D-X)
|
X, K, D = map(int, input().split())
value = abs(X)
if (value / D) >= K:
print(value - D * K)
else:
min_count = value // D
mod_value = K - min_count
if mod_value % 2 == 0:
print(value % D)
else:
print(abs(value % D - D))
| 1 | 5,223,124,646,140 | null | 92 | 92 |
N = int(input())
dic = {}
for i in range(N):
s = str(input())
if s in dic:
dic[s] += 1
else:
dic[s] = 1
S = sorted(dic.values())
t = S[-1]
X = []
for key in dic:
if dic[key] == t:
X.append(key)
x = sorted(X)
for i in range(len(X)):
print(x[i])
|
#!/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())
d = defaultdict(int)
maxi = 0
for _ in range(N):
S = input()
d[S] += 1
maxi = max(maxi, d[S])
ans = []
for k, v in d.items():
if v == maxi:
ans.append(k)
for a in sorted(ans):
print(a)
def main():
solve()
if __name__ == '__main__':
main()
| 1 | 69,531,350,632,100 | null | 218 | 218 |
from collections import defaultdict
n = int(input())
A = list(map(int, input().split()))
cnt = defaultdict(int)
ans = 0
for i, a in enumerate(A):
ans += cnt[i+1 - a]
cnt[i+1 + a] += 1
print(ans)
|
while True:
m,f,r = [int(x) for x in input().split()]
if (m,f,r)==(-1,-1,-1): break
s_mf = m + f
if m < 0 or f < 0: mark = 'F'
elif s_mf < 30: mark = 'F'
elif s_mf >= 80: mark = 'A'
elif s_mf >= 65: mark = 'B'
elif s_mf >= 50: mark = 'C'
elif r >= 50: mark = 'C'
else: mark = 'D'
print(mark)
| 0 | null | 13,607,633,562,710 | 157 | 57 |
x = int(input())
y=100
c=0
while 1:
if y>=x :
break
y=y*101//100
c+=1
print(c)
|
n = int(input())
def divGame(N=n):
if N == 1:
return 0
if N == 2:
return 1
factors = []
for i in range(2, int(N**0.5 + 1)):
count = 0
while N % i == 0:
N /= i
count += 1
if count != 0:
factors.append(count)
if N != 1:
factors.append(1)
factors.sort()
answer = 0
accum = 1
count = 1
for i in range(len(factors)):
while factors[i] >= accum:
count += 1
accum += count
answer += count - 1
return answer
print(divGame())
| 0 | null | 22,127,083,240,090 | 159 | 136 |
c=input().split(" ")
print(c[1]+c[0])
|
base = input().split()
print(base[1],end="")
print(base[0])
| 1 | 103,124,221,571,360 | null | 248 | 248 |
A, B = map(int, input().split())
a = [i for i in range(int((A-1)*100/8 ), int((A+1)*100/8 ))]
b = [i for i in range(int((B-1)*100/10), int((B+1)*100/10))]
a = [i for i in a if int(i*0.08) == A]
b = [i for i in b if int(i*0.10) == B]
ans = list(set(a) & set(b))
if ans and min(ans) > 0:
print(min(ans))
else:
print(-1)
|
A,B = map(int, input().split())
for i in range(1001):
if i*8//100 == A and i//10 == B:
print(i)
exit()
print(-1)
| 1 | 56,689,471,652,980 | null | 203 | 203 |
# -*- coding: utf-8 -*-
#https://mathtrain.jp/tyohukuc
n, m, k = map(int,input().split())
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 998244353
N = n+1 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
ans = 0
beki = [1,m-1]
for i in range(2,N+1):
beki.append(((beki[-1]*(m-1)) % p))
for x in range(k+1):
ans += m * beki[n-x-1] %p * cmb(n-1,x,p) %p
ans = ans % p
print(ans)
|
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)
count = 0
for k in range(K + 1):
current = pow(M - 1, N - k - 1, mod) * M % mod
rev = pow(fact[k] * fact[N - 1 - k] % mod, mod - 2, mod)
current = (current * fact[N - 1] % mod) * rev % mod
count = (count + current) % mod
return count
if __name__ == "__main__":
print(main())
| 1 | 23,224,591,936,210 | null | 151 | 151 |
#全点対間最短経路を求めるアルゴリズム
def warshall_floyd(d):
#d[i][j]:iからjに行く最短経路
for k in range(1,n+1):
for i in range(1,n+1):
for j in range(1,n+1):
d[i][j] = min(d[i][j], d[i][k] + d[k][j])
return d
import sys
input = sys.stdin.buffer.readline
sys.setrecursionlimit(10**9)
n, m , l = map(int, input().split())
INF = 10 ** 11
d = [[INF]*(n+1) for _ in range(n+1)]
for i in range(m):
x, y, z = map(int, input().split())
if z <= l:
d[x][y] = z
d[y][x] = z #無向グラフならつける
for i in range(1,n+1):
d[i][i] = 0
ss = warshall_floyd(d)
for i in range(1,n+1):
for j in range(1,n+1):
if ss[i][j] <= l:
ss[i][j] = 1
#補給回数
vv = warshall_floyd(ss)
for i in range(1,n+1):
for j in range(1,n+1):
if vv[i][j] == INF:
vv[i][j] = -1
q = int(input())
for _ in range(q):
x, y = map(int, input().split())
if vv[x][y] != -1:
print(vv[x][y]-1)
else:
print(vv[x][y])
|
import sys
input = sys.stdin.readline
n, m = [int(x) for x in input().split()]
s = input().rstrip()[::-1]
ans = []
left, right = 0, 0 + m
while True:
if right >= n:
ans.append(n - left)
break
for i in range(right, left, -1):
flag = 1
if s[i] == "0":
ans.append(i - left)
flag = 0
break
if flag:
print(-1)
sys.exit()
else:
left = i
right = left + m
print(*ans[::-1])
| 0 | null | 156,646,061,678,920 | 295 | 274 |
h1,m1,h2,m2,K = map(int,input().split() )
H=h2-h1
M=m2-m1
if(M<0):
M += 60
H -= 1
if(H<0):
H += 24
M += H*60
ans =M - K
print(ans)
|
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def k(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0
inf = float("inf")
a = l()
a = list(set(a))
if len(a) == 2:
print("Yes")
else:
print("No")
| 0 | null | 42,914,583,267,308 | 139 | 216 |
def some():
n = int(input())
for i in range(9, 0, -1):
for j in range(9, 0, -1):
if i* j == n:
print("Yes")
exit()
print("No")
some()
|
n = int(input())
num = [1, 2, 3, 4, 5, 6, 7, 8, 9]
ans = 'No'
for i in range(len(num)):
for s in range(len(num)):
if num[i] * num[s] == n:
ans = 'Yes'
break
print(ans)
| 1 | 159,841,943,695,658 | null | 287 | 287 |
n=int(input())
if n%2==1:
print(0)
else:
cnt=1
ans=0
while 2*5**cnt<=n:
ans+=n//(2*5**cnt)
cnt+=1
print(ans)
|
import sys
input = sys.stdin.readline
ins = lambda: input().rstrip()
ini = lambda: int(input().rstrip())
inm = lambda: map(int, input().split())
inl = lambda: list(map(int, input().split()))
out = lambda x: print('\n'.join(map(str, x)))
n = ini()
s = list(ins())
n = s.count("R")
t = sorted(s)
ans = 0
for i in range(n):
if s[i] != t[i]:
ans += 1
print(ans)
| 0 | null | 61,298,889,885,312 | 258 | 98 |
N,M=map(int,input().split())
a=N//2
b=a+1
print(a,b)
if M==1:
exit(0)
c=1
d=N-1
print(c,d)
for i in range(M-2):
if i%2==0:
a,b=a-1,b+1
print(a,b)
else:
c,d=c+1,d-1
print(c,d)
|
import sys
sys.setrecursionlimit(10 ** 8)
input = sys.stdin.readline
def main():
N, M = [int(x) for x in input().split()]
ans = [[] for j in range(M)]
if N % 2:
for i in range(M):
ans[i].append(i + 1)
ans[i].append(N - i - 1)
else:
memo = 0
f = False
for i in range(M):
memo = i
if (i + 1) * 4 >= N:
f = True
break
ans[i].append(i + 1)
ans[i].append(N - i - 1)
if f:
for j in range(memo, M):
ans[j].append(j + 1)
ans[j].append(N - j - 2)
for a in ans:
print(*a)
if __name__ == '__main__':
main()
| 1 | 28,609,332,953,150 | null | 162 | 162 |
n,k = map(int,input().split())
print((n%k) if (n%k) < (k-(n%k)) else (k-(n%k)))
|
#!/usr/bin/python
# -*- coding: utf-8 -*-
# def
def int_mtx(N):
x = []
for _ in range(N):
x.append(list(map(int,input().split())))
return np.array(x)
def str_mtx(N):
x = []
for _ in range(N):
x.append(list(input()))
return np.array(x)
def int_map():
return map(int,input().split())
def int_list():
return list(map(int,input().split()))
def print_space(l):
return print(" ".join([str(x) for x in l]))
# import
import numpy as np
import collections as col
from scipy.sparse.csgraph import connected_components
from scipy.sparse import csr_matrix
# main
N,M =int_map()
AB = int_mtx(M)
n, _ = connected_components(csr_matrix(([1]*M, (AB[:,0]-1, AB[:,1]-1)),(N,N)))
print(n-1)
| 0 | null | 20,657,809,076,630 | 180 | 70 |
from collections import defaultdict
N,p = map(int,input().split())
S = input()
S = S[::-1]
d = defaultdict(lambda:0)
r = 0
for i in range(N):
r += int(S[i])*pow(10,i,p)
r %= p
d[r] += 1
ans = 0
for r in d:
ans += d[r]*(d[r]-1)//2
ans += d[0]
if p==2 or p==5:
S = S[::-1]
ans = 0
for i in range(N):
if int(S[i])%p==0:
ans += i+1
print(ans)
|
## coding: UTF-8
N, P = map(int,input().split())
S = input()[::-1]
remainder = [0] * P
tmp = 0
rad = 1 #10**(i) % P
'''
if(P == 2 or P == 5):
for i in range(N):
r = int(S[i])
tmp += r * rad
tmp %= P
remainder[tmp] += 1
rad *= 10
'''
if(P == 2):
ans = 0
for i in range(N):
r = int(S[i])
if(r % 2 == 0):
ans += N-i
print(ans)
elif(P == 5):
ans = 0
for i in range(N):
r = int(S[i])
if(r % 5 == 0):
ans += N-i
print(ans)
else:
for i in range(N):
r = int(S[i])
tmp += r * rad
tmp %= P
remainder[tmp] += 1
rad *= 10
rad %= P
remainder[0] += 1
#print(remainder)
ans = 0
for i in range(P):
e = remainder[i]
ans += e*(e-1)/2
print(int(ans))
| 1 | 57,982,089,707,520 | null | 205 | 205 |
def solve():
S, W = map(int, input().split())
if S <= W:
print('unsafe')
else:
print('safe')
if __name__ == '__main__':
solve()
|
score = list(map(int,input().split()))
if score[0] <= score[1]:
print('unsafe')
else:
print('safe')
| 1 | 29,270,609,284,578 | null | 163 | 163 |
S = input()
T = input()
if T.startswith(S):
if len(T)-len(S)==1:
print("Yes")
else:
print("No")
else:
print("No")
|
import sys
readline = sys.stdin.readline
X = int(readline())
limit = 600
rank = 8
for i in range(8):
if X < limit:
print(rank)
break
limit += 200
rank -= 1
| 0 | null | 13,998,434,711,950 | 147 | 100 |
import sys
N = int(input())
if N % 2 != 0:
print(0)
sys.exit()
N //= 2
ans = 0
while N != 0:
ans += N//5
N //= 5
print(ans)
|
def solve():
import numpy as np
from sys import stdin
f_i = stdin
N, T = map(int, f_i.readline().split())
AB = [tuple(map(int, f_i.readline().split())) for i in range(N)]
AB.sort()
max_Ai = AB[-1][0]
dp = [[0] * T for i in range(N + 1)]
dp = np.zeros(max_Ai + T, dtype=int)
for A_i, B_i in AB:
dp[A_i:A_i+T] = np.maximum(dp[A_i:A_i+T], dp[:T] + B_i)
print(max(dp))
solve()
| 0 | null | 134,224,328,075,250 | 258 | 282 |
n, a, b = map( int, input().split() )
mod = 10 ** 9 + 7
N = pow( 2, n, mod ) - 1
def comb( n, r ):
c = 1
m = 1
r = min( n - r, r )
for i in range( r ):
c = c * ( n - i ) % mod
m = m * ( i + 1 ) % mod
return c * pow( m, mod - 2, mod ) % mod
A = comb( n, a )
B = comb( n, b )
print( ( N - A - B ) % mod )
|
'''
pow(base, exp[, mod])
base の exp 乗を返します;
mod があれば、base の exp 乗に対する mod の剰余を返します
(pow(base, exp) % mod より効率よく計算されます)。
二引数の形式 pow(base, exp) は、冪乗演算子を使った base**exp と等価です。
'''
url = 'https://tane-no-blog.com/976/'
# pow を実装したコード
# def pow(x,n):
# res = 1
# while n > 0:
# if n&1 == 1:
# res *= x
# x *= x
# n >>= 1
# return res
n,a,b = map(int,input().split())
# pow を用いた組み合わせ計算の高速化
mod = 10**9 + 7
def comb(N,x):
numerator = 1
for i in range(N-x+1,N+1):
numerator = numerator * i % mod
denominator = 1
for j in range(1,x+1):
denominator = denominator * j % mod
d = pow(denominator,mod-2,mod)
return numerator * d
A = comb(n,a)
B = comb(n,b)
print((pow(2,n,mod)-1-A-B) % mod)
| 1 | 66,338,293,321,440 | null | 214 | 214 |
s=input()
for i in range(1,6):
if s=='hi'*i:
print('Yes')
quit()
print('No')
|
S=input();
if(S=="hi" or S=="hihi" or S=="hihihi" or S=="hihihihi" or S=="hihihihihi"):
print("Yes");
else:
print("No");
| 1 | 53,411,056,946,598 | null | 199 | 199 |
from collections import deque
K = int(input())
q = deque([i for i in range(1, 10)])
for _ in range(K - 1):
# 13print(q)
num = q.popleft()
for i in range(-1,2):
if 0 <= int(str(num)[-1]) + i <= 9:
q.append(num * 10 + int(str(num)[-1]) + i)
print(q[0])
|
from bisect import bisect_left
n = int(input())
L = list(map(int, input().split()))
L.sort()
cnt = 0
for a in range(n-2):
for b in range(a+1, n-1):
cnt += bisect_left(L,L[a]+L[b])-(b+1)
print(cnt)
| 0 | null | 105,880,745,621,380 | 181 | 294 |
a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(m)]
ans=min(a)+min(b)
for x,y,c in l:
ans=min(ans,a[x-1]+b[y-1]-c)
print(ans)
|
A, B, M = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
result = min(a) + min(b)
for _ in range(M):
x, y, c = map(int, input().split())
discount = a[x-1] + b[y-1] - c
result = min(result, discount)
print(result)
| 1 | 53,878,886,185,740 | null | 200 | 200 |
class dictionary:
def __init__(self):
self._d = set()
def insert(self, s):
self._d.add(s)
def find(self, s):
if s in self._d:
print("yes")
else:
print("no")
if __name__ == '__main__':
dd = dictionary()
n = int(input())
for _ in range(n):
args = input().split()
if args[0] == "insert":
dd.insert(args[1])
elif args[0] == "find":
dd.find(args[1])
|
x, k, d = map(int, input().split())
x = abs(x)
if x//d >= k:
print(x-k*d)
else:
k -= x//d
x -= d*(x//d)
if k%2==0:
print(abs(x))
else:
print(abs(x-d))
| 0 | null | 2,646,865,588,092 | 23 | 92 |
import fractions
while True:
try:
(a, b) = map(int, raw_input().split())
c = fractions.gcd(a, b)
print c, ((a*b)/c)
except EOFError:
break
|
S = input()
if(S == 'RRR'):
print(3)
elif(S=='RRS' or S=='SRR'):
print(2)
elif(S == 'SSS'):
print(0)
else:
print(1)
| 0 | null | 2,448,051,522,820 | 5 | 90 |
mod=998244353
n=int(input())
from collections import Counter as co
j=list(map(int,input().split()))
l=co(j)
ll=len(l)
for i in range(ll):
if i not in l:print(0);exit()
if l[0]>=2 or j[0]!=0:print(0);exit()
ans=1
pre=1
for k,v in sorted(l.items()):
ans*=pow(pre,v,mod)
ans%=mod
pre=v
print(ans%mod)
|
from math import floor
n = int(input())
def debt(week):
debt = 100000
for i in range(1,n+1):
debt *= 1.05
amari = debt % 1000
if amari:
debt += 1000 - amari
return int(debt)
print(debt(n))
| 0 | null | 77,211,485,743,440 | 284 | 6 |
class Dice:
def __init__(self,u,s,e,w,n,d):
self.n = n
self.e = e
self.s = s
self.w = w
self.u = u
self.d = d
def roll(self,dir):
if (dir == "N"):
tmp = self.n
self.n = self.u
self.u = self.s
self.s = self.d
self.d = tmp
elif (dir == "E"):
tmp = self.e
self.e = self.u
self.u = self.w
self.w = self.d
self.d = tmp
elif (dir == "S"):
tmp = self.s
self.s = self.u
self.u = self.n
self.n = self.d
self.d = tmp
elif (dir == "W"):
tmp = self.w
self.w = self.u
self.u = self.e
self.e = self.d
self.d = tmp
spots = raw_input().split()
operations = raw_input()
dice = Dice(*spots)
for i in operations:
dice.roll(i)
print dice.u
|
n = int(input())
al = list(map(int,input().split()))
lst = [[] for _ in range(n)]
for i in range(1,n+1):
lst[al[i-1]-1] = i
print(*lst)
| 0 | null | 90,513,334,262,678 | 33 | 299 |
a, b, m = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
AB = []
for _ in range(m):
x, y, c = map(int, input().split())
x -= 1
y -= 1
AB.append(A[x]+B[y]-c)
AB.sort()
A.sort()
B.sort()
print(min(AB[0], A[0]+B[0]))
|
list = []
while 1:
n,x = map(int,input().split())
if n==0 and x==0:
break
else:
cnt = 0
for i in range(1,n+1):
for j in range(i+1,n+1):
for k in range(j+1,n+1):
if i+j+k==x:
cnt += 1
list.append(cnt)
for i in list:
print(i)
| 0 | null | 27,846,610,454,080 | 200 | 58 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.