code1
stringlengths 17
427k
| code2
stringlengths 17
427k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.7M
180,677B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
---|---|---|---|---|---|---|
import bisect,collections,copy,heapq,itertools,math,string
import sys
def S(): return sys.stdin.readline().rstrip()
def M(): return map(int,sys.stdin.readline().rstrip().split())
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def LS(): return list(sys.stdin.readline().rstrip().split())
x = I()
ans = 0
wa = 0
cont = True
while cont:
wa += x
ans += 1
if wa % 360 == 0:
cont = False
print(ans) | matrix = []
vector = []
n, m = [int(x) for x in input().split()]
for i in range(n):
matrix.append([int(x) for x in input().split()])
for i in range(m):
vector.append(int(input()))
for i in range(n):
sum = 0
for j in range(m):
sum += matrix[i][j] * vector[j]
print(sum) | 0 | null | 7,096,240,662,780 | 125 | 56 |
n = int(input())
s = []
for i in range(n):
s.append(input())
s.sort()
# print(s)
m = 1
cnt = [1]
ans = []
for i in range(1,n):
if s[i] == s[i-1]:
cnt[-1] += 1
else:
if cnt[-1] > m:
ans = [s[i-1]]
elif cnt[-1] == m:
ans.append(s[i-1])
m = max(m, cnt[-1])
cnt.append(1)
if i == n-1 and cnt[-1] > m:
ans = [s[i]]
elif i == n-1 and cnt[-1] == m:
ans.append(s[i])
print('\n'.join(ans)) | import math
import statistics
import collections
a=int(input())
#b,c=int(input()),int(input())
# c=[]
# for i in b:
# c.append(i)
#e1,e2 = map(int,input().split())
# f = list(map(int,input().split()))
g = [input() for _ in range(a)]
# h = []
# for i in range(e1):
# h.append(list(map(int,input().split())))
g.sort()
ma=0
count=1
#最大値求める
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
ma=max(ma,count)
count=1
ma=max(ma,count)
count=1
ans=[]
#最大値の位置
for i in range(a-1):
if g[i]==g[i+1]:
count+=1
else:
if count==ma:
ans.append(g[i])
count=1
if count==ma:
ans.append(g[-1])
for i in ans:
print(i)
| 1 | 70,317,236,873,520 | null | 218 | 218 |
n, m = map(int, input().split())
l = list(map(int, input().split()))
l.sort(reverse=True)
n_vote = sum(l)
if l[m-1] >= n_vote/(4*m):
print('Yes')
else:
print('No') | N=int(input())
A=0
W=0
T=0
R=0
for i in range(N):
st=input()
if st=="AC":
A+=1
elif st=="WA":
W+=1
elif st=="TLE":
T+=1
else:
R+=1
print("AC x "+str(A))
print("WA x "+str(W))
print("TLE x "+str(T))
print("RE x "+str(R)) | 0 | null | 23,628,977,101,170 | 179 | 109 |
a, b = map(int,input().split())
def main(x,y):
print(x*y)
main(a,b) | print(eval(input().strip().replace(' ','*'))) | 1 | 15,823,057,425,408 | null | 133 | 133 |
#!/usr/bin/env python3
def solve(S: str):
return sum([a != b for a, b in zip(S, reversed(S))]) // 2
def main():
S = input().strip()
answer = solve(S)
print(answer)
if __name__ == "__main__":
main()
| S = input()
n = len(S)
c = 0
for i in range(n // 2):
if S[i] != S[n - i - 1]:
c += 1
print(c) | 1 | 120,256,056,684,610 | null | 261 | 261 |
S = input()
T = input()
min_change = 10**9
for posi_1 in range(len(S)-len(T)+1):
tmp = 0
for posi_2 in range(len(T)):
if S[posi_1+posi_2] != T[posi_2]:
tmp += 1
min_change = min(tmp, min_change)
print(min_change) | S = input()
T = input()
min = 10000000
for i in range(len(S)- len(T) + 1):
x = 0
for j in range(len(T)):
if S[i+j] != T[j]:
x += 1
if x < min:
min = x
print(min) | 1 | 3,646,925,331,082 | null | 82 | 82 |
n = int(input())
s,t = input().split()
res = ""
for i in range(0,n):
res += s[i]
res += t[i]
print(res) | import math
K = int(input())
result = 0
for a in range(1, K+1):
for b in range(1, K+1):
r = math.gcd(a, b)
for c in range(1, K+1):
result += math.gcd(r, c)
print(result)
| 0 | null | 74,163,318,949,020 | 255 | 174 |
a,b,c = map(int,input().split())
if a + b + c >= 22:
print('bust')
if a + b + c <= 21:
print('win')
| a,b = input().split()
A = (a*int(b))
B = (b*int(a))
if A < B:
print(A)
else:
print(B) | 0 | null | 101,554,676,576,544 | 260 | 232 |
n,t = map(int,input().split())
dish = []
for _ in range(n):
a,b = map(int,input().split())
dish.append([a,b])
dish.sort()
now = [0 for _ in range(t+1)]
for i in range(n):
a,b = dish[i]
for d in range(t)[::-1]:
if d + a < t:
now[d+a] = max(now[d+a],now[d]+b)
else:
now[-1] = max(now[-1],now[d]+b)
#print(now)
print(now[-1]) | def solve():
ans = 0
N, T = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
A.sort()
dp = [[0]*(T+A[-1][0]) for _ in range(N+1)]
for i in range(1,N+1):
for t in range(1,T+A[-1][0]):
if t<A[i-1][0] or t>=T+A[i-1][0]:
dp[i][t] = max(dp[i-1][t],dp[i][t-1])
else:
dp[i][t] = max([dp[i-1][t],dp[i][t-1],dp[i-1][t-A[i-1][0]]+A[i-1][1]])
ans = max(dp[-1])
return ans
print(solve()) | 1 | 151,454,553,290,160 | null | 282 | 282 |
s=len(input());print('x'*s) | import sys
input = sys.stdin.readline
def main():
n = int(input())
a = []
b = []
for i in range(n):
s = input()
c1, c2 = 0, 0
for i in range(len(s)):
if s[i] == "(":
c2 += 1
if s[i] == ")":
if c2:
c2 -= 1
else:
c1 += 1
if c1 >= c2:
b.append((c2, c1))
else:
a.append((c1, c2))
a.sort()
b.sort(reverse=True)
ans = False
sub = 0
for value in a:
k1, k2 = value[0], value[1]
if sub < k1:
ans = True
break
sub += k2-k1
for value in b:
k2, k1 = value[0], value[1]
if ans or sub < k1:
ans = True
break
sub += k2-k1
print("No" if ans or sub else "Yes")
if __name__ == "__main__":
main() | 0 | null | 48,599,051,953,412 | 221 | 152 |
a,b,c=map(int,input().split())
if a>b:
(a,b)=(b,a)
if b>c:
(b,c)=(c,b)
if a>b:
(a,b)=(b,a)
elif b>c:
(b,c)=(c,b)
if b>c:
(b,c)=(c,b)
print(a,b,c) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
15 6
1 2 7 8 12 50
output:
2
"""
import sys
def solve():
rec[0] = 0
for i in range(c_num):
for j in range(coins[i], money + 1):
rec[j] = min(rec[j], rec[j - coins[i]] + 1)
return rec
if __name__ == '__main__':
_input = sys.stdin.readlines()
money, c_num = map(int, _input[0].split())
coins = list(map(int, _input[1].split()))
# assert len(coins) == c_num
rec = [float('inf')] * (money + 1)
ans = solve()
print(ans.pop()) | 0 | null | 276,766,174,100 | 40 | 28 |
s = input()
n = len(s)
end = s[n-1]
if end=='s':
print(s+'es')
else:
print(s+'s') | import sys
input = lambda : sys.stdin.readline().rstrip()
sys.setrecursionlimit(max(1000, 10**9))
write = lambda x: sys.stdout.write(x+"\n")
s = input()
if s[-1]=="s":
s += "es"
else:
s += "s"
print(s) | 1 | 2,379,613,335,720 | null | 71 | 71 |
def main():
n = int(input())
a = [0,0]
for i in range(1, n+1):
a[0] += 1
a[1] = a[1] + 1 if i % 2 != 0 else a[1]
print(a[1] / a[0])
if __name__ == '__main__':
main() | from collections import deque
n,q=map(int,raw_input().split())
l=deque([raw_input().split()for _ in range(n)])
t=0
while len(l):
a,b=l.popleft()
b=int(b)
if q<b: t+=q;l.append([a,b-q])
else: t+=b;print a,t | 0 | null | 88,504,827,348,544 | 297 | 19 |
#親要素を示す
par = {}
sum_union = {}
len_union = {}
# 初期化 -- すべての要素が根である --
def init(n):
for i in range(n):
par[i] = i
sum_union[i] = Cs[i]
len_union[i] = 1
return
# 根を求める
def root(x):
if par[x] == x:
return x
else:
#根の直下にxを置く
par[x] = root(par[x])
return par[x]
# 同じ集合に属するかどうかは根が同じかで判定
def same(x, y):
return root(x) == root(y)
# 別々のUnion同士を融合する
def unite(x, y):
rx = root(x)
ry = root(y)
if rx == ry:
return
else:
par[rx] = ry
tmp_sum = sum_union[rx] + sum_union[ry]
tmp_len = len_union[rx] + len_union[ry]
sum_union[ry] = tmp_sum
len_union[ry] = tmp_len
return
N, K = map(int, input().split())
Ps = list(map(lambda x: int(x) - 1, input().split()))
Cs = list(map(int, input().split()))
init(N)
# 結合
for i in range(N):
unite(i, Ps[i])
max_result = -(10**9+1)
for i in range(N):
ri = root(i)
if sum_union[ri] <= 0:
partial_range = min(K, len_union[ri])
roop_sum = 0
elif K < len_union[ri]:
partial_range = K
roop_sum = 0
else:
partial_range = (K % len_union[ri]) + len_union[ri]
roop_sum = sum_union[ri] * ((K // len_union[ri])-1)
pc = i
sum_list = []
sum_c = 0
for _ in range(partial_range):
pn = Ps[pc]
sum_c += Cs[pn]
sum_list.append(sum_c)
pc = pn
max_result = max(max_result, roop_sum + max(sum_list))
print(max_result)
| N,K = map(int,input().split())
P = list(map(int,input().split()))
C = list(map(int,input().split()))
ans = -1*float('inf')
for i in range(N):
k = i
Cc = []
Ct = 0
while 1:
k = P[k]-1
Cc.append(C[k])
if i == k:
break
l = len(Cc)
Ct = sum(Cc)
t = 0
for j in range(l):
t += Cc[j]
if j >= K:break
now = t
if Ct > 0:
e = (K-j-1)//l
now += Ct*e
ans = max(ans,now)
print(ans) | 1 | 5,370,763,519,718 | null | 93 | 93 |
def insertionSort(a):
for i,v in enumerate(a):
j=i-1
while j>=0 and a[j]>v:
a[j+1]=a[j]
j-=1
a[j+1]=v
print(*a)
n = int(input())
a = list(map(int,input().split()))
insertionSort(a) | from collections import Counter
S = input()
L = len(list(S))
dp = [0] * L
dp[0] = 1
T = [0] * L
T[0] = int(S[-1])
for i in range(1, L):
dp[i] = dp[i - 1] * 10
dp[i] %= 2019
T[i] = int(S[-(i+1)]) * dp[i] + T[i - 1]
T[i] %= 2019
ans = 0
for k, v in Counter(T).items():
if k == 0:
ans += v
ans += v * (v - 1) // 2
else:
ans += v * (v - 1) // 2
print(ans)
| 0 | null | 15,472,914,594,112 | 10 | 166 |
from collections import Counter as Ct
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
n=INT()
dic=[]
for i in range(n):
s=STR()
dic.append(s)
ctd=Ct(dic)
ctm=max(ctd.values())
ans=[]
for key,value in ctd.items():
if value==ctm:
ans.append(key)
ans=sorted(ans)
for i in ans:
print(i)
if __name__=='__main__':
do() | import collections
N = int(input())
S_list = []
for i in range(N):
s = input()
S_list.append(s)
c = collections.Counter(S_list)
c_max = c.most_common()
max_num = c.most_common()[0][1]
ans_list = []
ans_list.append(c.most_common()[0][0])
for i in range(1, len(c_max)):
if c_max[i][1] != max_num:
break
else:
ans_list.append(c_max[i][0])
print(*sorted(ans_list), sep='\n')
| 1 | 70,410,639,542,980 | null | 218 | 218 |
x = int(input())
print(1000*(x//500)+5*((x-(500*(x//500)))//5)) | n,m=map(int,input().split())
l=[0]*n
w=0
c=0
ac=set()
for i in range(m):
p,s=map(str,input().split())
p=int(p)
if s=='WA':
l[p-1]+=1
else:
if p not in ac:
c+=1
w+=l[p-1]
ac.add(p)
print(c,w)
| 0 | null | 67,721,802,352,826 | 185 | 240 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N, M = mapint()
S = list(input())
def solve():
now = N
choice = []
while 1:
if now==0:
return choice[::-1]
for m in range(M, 0, -1):
nx = now-m
if nx<0: continue
if S[nx]=='1': continue
now = nx
choice.append(m)
break
else:
return [-1]
print(*solve()) | from collections import deque
N, M = map(int, input().split())
S = input()[::-1] +'1'*M
if M >= N:
print(N)
exit()
q = deque([])
i = 0
j = 0
while i < N:
f = 0
for k in range(i+M,j,-1):
if S[k] == '0':
f = 1
break
j = i + M
q.appendleft(k-i)
i = k
if f == 0:
print(-1)
exit()
print(' '.join(map(str, q))) | 1 | 138,919,055,341,652 | null | 274 | 274 |
N = int(input())
P = list(map(int, input().split()))
pj = P[0]
cnt = 1
for pi in P[1:]:
if pi < pj:
cnt += 1
pj = pi
print(cnt) | #!/usr/bin/env python3
a, b, c = map(int, input().split())
k = int(input())
for _ in range(k):
if a >= b:
b *= 2
elif b >= c:
c *= 2
print(["No", "Yes"][a < b < c])
| 0 | null | 46,248,299,704,640 | 233 | 101 |
import sys
def input(): return sys.stdin.readline().strip()
def resolve():
n,r=map(int, input().split())
if n>=10:
print(r)
else:
print(r+100*(10-n))
resolve() | """
タグ:区間
"""
import sys
input = sys.stdin.readline
N, P = map(int, input().split())
S = input().strip()
if P == 5:
res = 0
i = 0
for s in reversed(S):
if int(s)%5==0:
res += N-i
i += 1
print(res)
elif P == 2:
res = 0
i = 0
for s in reversed(S):
if int(s)%2==0:
res += N-i
i += 1
print(res)
else:
T = [0]
p = 1
for s in reversed(S):
T.append(int(s)*p + T[-1])
p = p*10%P
cnt = [0]*P
for i in range(N+1):
cnt[T[i]%P] += 1
res = 0
for c in cnt:
res += c*(c-1)//2
print(res) | 0 | null | 60,475,302,031,352 | 211 | 205 |
A,B = map(int,input().split())
print(A*B if A<= 9 and B <=9 else "-1")
| s = raw_input()
s = s.split(' ')
a, b = int(s[0]), int(s[1])
if 1 <= a <= 9 and 1 <= b <= 9:
print a*b
else:
print -1
| 1 | 158,172,799,723,512 | null | 286 | 286 |
r, c = map(int, input().split())
a, btm = [], []
for i in range(r):
a.append(list(map(int, input().split())))
a[i].append(sum(a[i]))
print(*a[i])
rotate = list(zip(*a))
for i in range(len(rotate)):
btm.append(sum(rotate[i]))
print(*btm)
| #! python3
# spreadsheet.py
r, c = [int(x) for x in input().split(' ')]
sheet = [[int(x) for x in input().split(' ')] for i in range(r)]
for i in range(r):
sheet[i].append(0)
sheet.append([0 for i in range(c+1)])
for i in range(r):
for j in range(c):
sheet[i][c] += sheet[i][j]
sheet[r][j] += sheet[i][j]
sheet[r][c] += sheet[i][j]
for i in range(r+1):
print(' '.join([str(x) for x in sheet[i]]))
| 1 | 1,351,828,308,304 | null | 59 | 59 |
n=int(input())
R=[]
for _ in range(n):
x,l=map(int,input().split())
R.append([x-l,x+l])
R=sorted(R,key=lambda x:x[1])
ans=n
for i in range(1,n):
if R[i][0]<R[i-1][1]:
ans-=1
R[i][1]=R[i-1][1]
print(ans) | def main():
import sys
input = sys.stdin.readline
N = int(input())
arms = []
for i in range(N):
x, l = map(int,input().split())
t = min(x+l,10**9)
s = max(x-l,0)
arms.append((t,s))
arms.sort()
ans = 0
tmp = -1
for t,s in arms:
if s >= tmp:
tmp = t
ans += 1
print(ans)
main() | 1 | 89,455,093,258,762 | null | 237 | 237 |
ans = []
for s in open(0).readlines():
if "?" in s:
break
ans.append(eval(s.strip().replace("/", "//")))
print(*ans, sep='\n')
| import re
S = input()
print(re.sub('[a-z]', 'x',S)) | 0 | null | 36,721,030,191,248 | 47 | 221 |
K = int(input())
if K%2 == 0 or K%5 == 0:
print(-1)
elif K%7 == 0:
x = -1
b = 9*K/7
c = 10%b
for i in range(1,K+1):
if c ==1:
x = i
break
c = (c*10)%b
print(x)
else:
x = -1
b = 9*K
c = 10%b
for i in range(1,K+1):
if c ==1:
x = i
break
c = (c*10)%b
#print(c)
print(x) | N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
idx_B = M-1
m = sum(B)
an = M
ans = 0
for a in [0] + A:
m += a
while idx_B >= 0 and m > K:
m -= B[idx_B]
idx_B -= 1
an -= 1
if m > K:
break
if an > ans:
ans = an
an += 1
print(ans)
| 0 | null | 8,480,819,197,928 | 97 | 117 |
a,b,c = map(int,input().split())
if a>= c:
print(a-c,b)
elif a+b<=c:
print("0 0")
elif a < c and c < a+b:
print("0",a+b-c) | def main():
a, b, k = map(int, input().split())
if k >= a and b >= k-a:
print(0, b-(k-a))
elif k >= a and b < k-a:
print(0, 0)
else:
print(a-k, b)
if __name__ == '__main__':
main()
| 1 | 104,610,679,489,248 | null | 249 | 249 |
tgtstr = list(raw_input())
n = int(raw_input())
for i in range(n):
cmd_list = raw_input().split(" ")
if cmd_list[0] == "replace":
for idx in range(int(cmd_list[1]), int(cmd_list[2])+1):
tgtstr[idx] = cmd_list[3][idx - int(cmd_list[1])]
elif cmd_list[0] == "reverse":
start = int(cmd_list[1])
end = int(cmd_list[2])
while True:
tmp = str(tgtstr[start])
tgtstr[start] = str(tgtstr[end])
tgtstr[end] = tmp
start += 1
end -= 1
if start >= end:
break
elif cmd_list[0] == "print":
print "".join(tgtstr[int(cmd_list[1]):int(cmd_list[2])+1]) | n = int(input())
min_price = int(input())
max_diff = -1e9
for _ in range(n - 1):
p = int(input())
max_diff = max(p - min_price, max_diff)
min_price = min(p, min_price)
print(max_diff) | 0 | null | 1,070,694,750,540 | 68 | 13 |
import sys, bisect, math, itertools, string, queue, copy
#import numpy as np
#import scipy
from collections import Counter,defaultdict,deque
# from itertools import permutations, combinations
# from heapq import heappop, heappush
# from fractions import gcd
# input = sys.stdin.readline
# sys.setrecursionlimit(10**8)
# mod = 10**9+7
def inp(): return int(input())
def inpm(): return map(int,input().split())
def inpl(): return list(map(int, input().split()))
def inpls(): return list(input().split())
def inplm(n): return list(int(input()) for _ in range(n))
def inplL(n): return [list(input()) for _ in range(n)]
def inplT(n): return [tuple(input()) for _ in range(n)]
def inpll(n): return [list(map(int, input().split())) for _ in range(n)]
def inplls(n): return sorted([list(map(int, input().split())) for _ in range(n)])
s = input()
q = int(input())
ql = [input().split() for i in range(q)]
ans = deque(s)
isrev=False
for i in range(q):
if ql[i][0] == '1':
isrev = not isrev
continue
if (ql[i][1] == '2') == isrev:
ans.appendleft(ql[i][2])
else:
ans.append(ql[i][2])
if isrev:
ans.reverse()
s = ''.join(ans)
print(s)
| from collections import deque
import sys
input = sys.stdin.readline
n = int(input())
doubly_linked_list = deque()
for _ in range(n):
command = input().split()
if command[0] == "insert":
doubly_linked_list.appendleft(command[1])
elif command[0] == "delete":
try:
doubly_linked_list.remove(command[1])
except:
pass
elif command[0] == "deleteFirst":
doubly_linked_list.popleft()
elif command[0] == "deleteLast":
doubly_linked_list.pop()
print(" ".join(doubly_linked_list))
| 0 | null | 28,856,462,787,328 | 204 | 20 |
def bubble_sort(a,n):
m=0
flag=True
while(flag):
flag=False
for i in range(n-1,0,-1):
if(a[i-1] > a[i]):
tmp=a[i-1]
a[i-1]=a[i]
m+=1
a[i]=tmp
flag=True
b=list(map(str,a))
print(" ".join(b))
print(m)
a=[]
n=int(input())
s=input()
a=list(map(int,s.split()))
bubble_sort(a,n) | N = int(input())
A = list(map(int,input().split()))
flag = True
ans = 0
for i in range(N):
flag = False
for j in range(N-1,i,-1):
if A[j] < A[j-1]:
A[j],A[j-1] = A[j-1],A[j]
flag = True
ans += 1
if not flag:
break
print(*A)
print(ans)
| 1 | 17,488,580,120 | null | 14 | 14 |
A,B = map(int, input().split())
print(A-min(A,B*2)) | import itertools
##print(ord("A"))
a,b,= map(int,input().split())
ans= a-b*2
if ans <=0:
print(0)
else:
print(ans) | 1 | 166,500,520,212,532 | null | 291 | 291 |
import sys
input = sys.stdin.readline
import math
a,b,x = (int(i) for i in input().rstrip('\n').split())
if b*(a**2)<2*x:
S=2*(b*(a**2)-x)
res = math.atan2(S,a**3)
res2 = math.degrees(res)
print(res2)
else:
res = math.atan2(2*x,a*(b**2))
res2 = math.degrees(res)
print(90-res2) | N, M = map(int, input().split())
SC = [tuple(map(int, input().split())) for _ in range(M)]
for num in range(1000):
if len(str(num)) != N: continue
for s, c in SC:
s -= 1
if str(num)[s] != str(c):
break
else:
print(num)
exit()
print(-1) | 0 | null | 112,124,639,249,610 | 289 | 208 |
(r, c) = [int(i) for i in input().split()]
table = [[0 for j in range(c + 1)]for i in range(r + 1)]
for i in range(r):
tmp = [int(x) for x in input().split()]
for j in range(c + 1):
if not j == c:
table[i][j] = tmp[j]
table[i][c] += table[i][j]
table[r][j] += table[i][j]
for i in range(r + 1):
for j in range(c + 1):
if j == c:
print(table[i][j], end='')
else:
print(table[i][j], '', end='')
print() | import sys
n=int(input())
d=[]
cnt=0
for i in range(n):
D=[int(x) for x in input().split()]
d.append(D)
for d1,d2 in d:
if d1==d2:
cnt+=1
else:
cnt=0
if 3<=cnt:
print("Yes")
sys.exit()
print("No") | 0 | null | 1,922,729,759,808 | 59 | 72 |
n = int(input())
L = []
for _ in range(n):
x, l = map(int, input().split())
left = x - l
right = x + l
L.append((left, right))
L = sorted(L, key=lambda x: x[1])
ans = 0
prev = -float('inf')
for r in L:
if r[0] >= prev:
ans += 1
prev = r[1]
print(ans)
| n = int(input())
lst = []
for i in range(n):
x, l = map(int, input().split())
left = x - l
right = x + l
lst.append([left, right])
lst = sorted(lst, key=lambda x: x[1])
ans = 1
limit = lst[0][1]
for i in range(n):
if lst[i][0] >= limit:
ans += 1
limit = lst[i][1]
print(ans) | 1 | 89,765,507,550,432 | null | 237 | 237 |
mountain = [int(input()) for _ in range(10)]
mountain.sort()
for _ in -1, -2, -3 : print(mountain[_]) | def mult(num):
print(int(num[0])*int(num[1]))
num = input().split()
mult(num) | 0 | null | 7,960,483,103,872 | 2 | 133 |
from sys import stdin
input = stdin.readline
def main():
N = int(input())
A = list(map(int, input().split()))
order = sorted(range(1, N+1), key=lambda i: A[i-1])
print(*order, sep=' ')
if(__name__ == '__main__'):
main()
| n=int(input())
s=list(map(int,input().split()))
p=[0]*n
for i in range(n):
p[s[i]-1]=i+1
print(*p) | 1 | 180,512,204,094,872 | null | 299 | 299 |
N = int(input())
def sum(n):
return (n + 1) * n // 2
print(sum(N) - sum(N // 3) * 3 - sum(N // 5) * 5 + sum(N // 15) * 15)
| import sys
from itertools import combinations
input = lambda: sys.stdin.readline().rstrip()
mod = 10**9 + 7
n = int(input())
a = list(map(int, input().split()))
dp = [0 for _ in range(n)]
dp[0] = a[0]
# 累積和の計算
for i in range(1, n):
dp[i] = (a[i] + dp[i - 1]) % mod
ans = 0
for i in range(n):
ans += a[i] * (dp[n - 1] - dp[i])
ans %= mod
print(ans)
| 0 | null | 19,283,983,612,042 | 173 | 83 |
x = input()
x = int(x)
x = x * x
print(x) | import sys
INF = 10**60
inint = lambda: int(sys.stdin.readline())
inintm = lambda: map(int, sys.stdin.readline().split())
inintl = lambda: list(inm())
instr = lambda: sys.stdin.readline()
instrm = lambda: map(str, sys.stdin.readline().split())
instrl = lambda: list(instrm())
n = inint()
min_sum = INF
i = 0
j = 0
for k in range(1,n):
if k > n**0.5:
break
if n/k % 1 != 0:
continue
i = k
j = n/k
if i+j < min_sum:
min_sum = i+j
print(int(min_sum - 2))
| 0 | null | 153,440,342,627,612 | 278 | 288 |
def input_list():
return list(map(int, input().split()))
def main():
s = list(input())
k = int(input())
if len(set(s)) == 1:
print(int(len(s)*(k/2)))
exit()
sw = [s[0]]
num = 0
numbers = [num]
for i in range(1, len(s)):
if s[i-1] != s[i]:
num += 1
numbers.append(num)
if num == 0 and sw[0] == s[i]:
sw.append(s[i])
num = 0
end_w = s[-1]
ew = []
for i in range(len(s)-1, -1, -1):
if end_w != s[i]:
num += 1
if num == 0 and end_w == s[i]:
ew.append(s[i])
nc = collections.Counter(numbers)
a = 0
for n,c in nc.items():
if c == 1:
continue
if c % 2 == 0:
a += c // 2
else:
a += (c-1)//2
ans = a * k
b = 0
if ew[0] == sw[0]:
haji = len(sw) + len(ew)
if haji % 2 == 0:
print(a * k + (k-1))
exit()
print(ans - b)
import math
import fractions
import collections
import itertools
from functools import reduce
main() | from itertools import groupby
# RUN LENGTH ENCODING str -> tuple
def run_length_encode(S: str):
"""
'AAAABBBCCDAABBB' -> [('A', 4), ('B', 3), ('C', 2), ('D', 1), ('A', 2), ('B', 3)]
"""
grouped = groupby(S)
res = []
for k, v in grouped:
res.append((k, len(list(v))))
return res
S = input()
K = int(input())
if len(set(list(S))) == 1:
print((len(S) * K) // 2)
else:
rle = run_length_encode(S)
cnt = 0
for w, length in rle:
if length > 1:
cnt += length // 2
ans = cnt * K
if S[0] == S[-1]:
a = rle[0][1]
b = rle[-1][1]
ans -= (a // 2 + b // 2 - (a + b) // 2) * (K - 1)
print(ans)
| 1 | 175,324,250,976,720 | null | 296 | 296 |
from sys import stdin
w = str(input()).lower()
t = stdin.read().split()
counter = 0
for i in t:
i = i.lower()
if i == w:
counter += 1
print(counter)
| import sys
s=input().split()
n=int(s[0]);m=int(s[1]);l=int(s[2])
a=[[0 for j in range(m)]for i in range(n)]
b=[[0 for j in range(l)]for i in range(m)]
c=[[0 for j in range(l)]for i in range(n)]
for i in range(n):
t=input().split()
for j in range(m):
a[i][j]=int(t[j])
for i in range(m):
t=input().split()
for j in range(l):
b[i][j]=int(t[j])
for i in range(n):
for j in range(l):
for k in range(m):
c[i][j]+=a[i][k]*b[k][j]
sys.stdout.write("{0}".format(c[i][j]))
if j==l-1:
sys.stdout.write("\n")
else:
sys.stdout.write(" ") | 0 | null | 1,653,335,082,168 | 65 | 60 |
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10 ** 9)
def input(): return sys.stdin.readline().strip()
def INT(): return int(input())
def MAP(): return map(int, input().split())
def LIST(): return list(map(int, input().split()))
INF=float('inf')
N=INT()
nodes=[[] for i in range(N)]
for i in range(N):
l=LIST()
u=l[0]
l=l[2:]
for v in l:
nodes[u-1].append(v-1)
nodes[u-1].sort()
ans=[[0]*2 for i in range(N)]
visited=[False]*N
time=0
def rec(u):
if visited[u]:
return
visited[u]=True
global time
time+=1
ans[u][0]=time
for v in nodes[u]:
rec(v)
time+=1
ans[u][1]=time
for i in range(N):
rec(i)
for i in range(N):
d,f=ans[i]
print(i+1, d, f)
| def MAIN():
n = int(input())
ans = [[i, 0, 0] for i in range((n + 1))]
G = [[] for _ in range((n + 1))]
for _ in range(n):
u, k, *v = map(int, input().split())
G[u] = v
cnt = 1
def dfs(u):
nonlocal ans
if ans[u][1] != 0:
return
nonlocal cnt
ans[u][1] = cnt
cnt += 1
for v in G[u]:
dfs(v)
ans[u][2] = cnt
cnt += 1
for i in range(1, n + 1):
if ans[i][1] == 0:
dfs(i)
for i in range(1, n + 1):
print(" ".join(map(str, ans[i])))
MAIN()
| 1 | 2,817,807,612 | null | 8 | 8 |
S = int(input())
h = S // 3600
m = (S // 60) % 60
s = S % 60
print("%d:%d:%d" % (h, m, s))
| S = int(input())
a = S//(60*60)
b = (S-(a*60*60))//60
c = S-(a*60*60 + b*60)
print(a, ':', b, ':', c, sep='')
| 1 | 336,877,403,980 | null | 37 | 37 |
from collections import deque
class SegmentTree():
def __init__(self,n,ide_ele,merge_func,init_val):
self.n=n
self.ide_ele=ide_ele
self.merge_func=merge_func
self.val=[0 for i in range(1<<n)]
self.merge=[0 for i in range(1<<n)]
self.parent=[-1 for i in range(1<<n)]
deq=deque([1<<(n-1)])
res=[]
while deq:
v=deq.popleft()
res.append(v)
if not v&1:
gap=(v&-v)//2
self.parent[v-gap]=v
deq.append(v-gap)
self.parent[v+gap]=v
deq.append(v+gap)
for v in res[::-1]:
if v-1<len(init_val):
self.val[v-1]=init_val[v-1]
self.merge[v-1]=self.val[v-1]
if not v&1:
gap=(v&-v)//2
self.merge[v-1]=self.merge_func(self.merge[v-1],self.merge[v-gap-1],self.merge[v+gap-1])
def update(self,id,x):
self.val[id]=x
pos=id+1
while pos!=-1:
if pos&1:
self.merge[pos-1]=self.val[pos-1]
else:
gap=(pos&-pos)//2
self.merge[pos-1]=self.merge_func(self.val[pos-1],self.merge[pos+gap-1],self.merge[pos-gap-1])
pos=self.parent[pos]
def cnt(self,k):
lsb=(k)&(-k)
return (lsb<<1)-1
def lower_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(l)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
id=r
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[l-1])
return res
else:
id=l
else:
res=self.merge_func(res,self.val[id-1])
return res
def upper_kth_merge(self,nd,k):
res=self.ide_ele
id=nd
if k==-1:
return res
while True:
if not id%2:
gap=((id)&(-id))//2
l=id-gap
r=id+gap
cnt=self.cnt(r)
if cnt<k:
k-=cnt+1
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
id=l
elif cnt==k:
res=self.merge_func(res,self.val[id-1],self.merge[r-1])
return res
else:
id=r
else:
res=self.merge_func(res,self.val[id-1])
return res
def query(self,l,r):
id=1<<(self.n-1)
while True:
if id-1<l:
id+=((id)&(-id))//2
elif id-1>r:
id-=((id)&(-id))//2
else:
res=self.val[id-1]
if id%2:
return res
gap=((id)&(-id))//2
L,R=id-gap,id+gap
#print(l,r,id,L,R)
left=self.upper_kth_merge(L,id-1-l-1)
right=self.lower_kth_merge(R,r-id)
return self.merge_func(res,left,right)
ide_ele=0
def seg_func(*args):
res=ide_ele
for val in args:
res|=val
return res
def popcount(x):
x = x - ((x >> 1) & 0x55555555)
x = (x & 0x33333333) + ((x >> 2) & 0x33333333)
x = (x + (x >> 4)) & 0x0f0f0f0f
x = x + (x >> 8)
x = x + (x >> 16)
return x & 0x0000007f
import sys
input=sys.stdin.readline
N=int(input())
S=input().rstrip()
init_val=[1<<(ord(S[i])-97) for i in range(N)]
test=SegmentTree(19,ide_ele,seg_func,init_val)
for _ in range(int(input())):
t,l,r=input().split()
t,l=int(t),int(l)
if t==1:
val=ord(r)-97
test.update(l-1,1<<val)
else:
r=int(r)
res=test.query(l-1,r-1)
print(popcount(res)) | while True:
exp = input()
if '?' in exp: break
print('%d' % (int(eval(exp)))) | 0 | null | 31,599,739,402,532 | 210 | 47 |
[a, b, c] = [int(number) for number in input().split()];
count = 0;
for i in range(a, b + 1):
if (c % i == 0):
count += 1;
print(count); | import sys
data = sys.stdin.readline().strip().split(' ')
a = int(data[0])
b = int(data[1])
c = int(data[2])
cnt = 0
for i in range(a, b+1):
if c % i == 0:
cnt += 1
print(cnt) | 1 | 567,270,211,860 | null | 44 | 44 |
import math
K=int(input())
ans=0
for a in range(1,K+1):
for b in range(1,K+1):
g=math.gcd(a,b)
for c in range(1,K+1):
ans+=math.gcd(g,c)
print(ans) | from collections import deque
import math
N, D, A = map(int, input().split())
monster = [list(map(int, input().split())) for _ in range(N)]
monster.sort(key=lambda x:x[0])
bomb = deque()
s = 0
ans = 0
for i in range(N):
x, h = monster[i]
while len(bomb) > 0 and bomb[0][1] < x:
s -= bomb.popleft()[2]
h -= s
if h > 0:
cnt = math.ceil(h/A)
damage = cnt*A
bomb.append([x, x+2*D, damage])
s += damage
ans += cnt
print(ans) | 0 | null | 58,856,084,856,482 | 174 | 230 |
d, t, s = map(int, input().split())
if t * s >= d:
print('Yes')
quit()
print('No')
| x,y = map(int,input().split())
if 2*x <= y and y <= 4*x and (4*x - y) % 2 == 0:
print("Yes")
else:
print("No") | 0 | null | 8,726,946,689,508 | 81 | 127 |
def p(n):
if n == 1:
return 300000
elif n == 2:
return 200000
elif n == 3:
return 100000
else:
return 0
x, y = map(int, input().split())
ans = 0
if x == y == 1:
ans += 400000
ans += p(x) + p(y)
print(ans)
| num1 = int(input())
print(num1 **3)
| 0 | null | 70,418,207,363,830 | 275 | 35 |
n = input()
taro = 0
hanako = 0
for i in xrange(n):
t_card, h_card = raw_input().split(" ")
if t_card < h_card:
hanako += 3
elif t_card > h_card:
taro += 3
elif t_card == h_card:
taro += 1
hanako += 1
print taro, hanako | n=int(input())
T=0
H=0
for i in range(n):
t,h=list(input().split())
if t==h:
T+=1
H+=1
elif t>h:
T+=3
elif t<h:
H+=3
print(T,H) | 1 | 2,039,260,108,380 | null | 67 | 67 |
while True:
n = list(map(int,input().split()))
if(n[0] == n[1] == 0):break
print(" ".join(map(str,sorted(n)))) | while 1:
a,b=map(int,input().split())
if a+b==0:
break
elif a>b:
print(b,a)
continue
print(a,b) | 1 | 530,759,441,268 | null | 43 | 43 |
n= int(input())
A = list(map(int, input().split()))
q = int(input())
Mi = map(int, input().split())
PS={}
def solve(i,m):
if m == 0:
return True
if (i,m) in PS:
return PS[(i,m)]
if i >= n:
return False
res = solve(i+1, m) or solve(i + 1, m - A[i])
PS[(i,m)] = res
return res
for m in Mi:
if solve(0, m):
print("yes")
else:
print("no") | def solve(n, A, q, m):
memo = dict()
for i in range(2**n):
tmp = 0
for j in range(n):
if i >> j & 1:
tmp += A[j]
memo[tmp] = 1
for val in m:
print("yes" if val in memo else "no")
if __name__ == "__main__":
n = int(input())
A = list(map(int, input().split()))
q = int(input())
m = list(map(int, input().split()))
solve(n, A, q, m)
| 1 | 98,377,996,960 | null | 25 | 25 |
import numpy as np
import scipy.sparse as sps
import scipy.misc as spm
import collections as col
import functools as func
import itertools as ite
import fractions as frac
import math as ma
from math import cos,sin,tan,sqrt
import cmath as cma
import copy as cp
import sys
import re
sys.setrecursionlimit(10**7)
EPS = sys.float_info.epsilon
PI = np.pi; EXP = np.e; INF = np.inf
MOD = 10**9 + 7
def sinput(): return sys.stdin.readline().strip()
def iinput(): return int(sinput())
def imap(): return map(int, sinput().split())
def fmap(): return map(float, sinput().split())
def iarr(n=0):
if n: return [0 for _ in range(n)]
else: return list(imap())
def farr(): return list(fmap())
def sarr(n=0):
if n: return ["" for _ in range(n)]
else: return sinput().split()
def adj(n): return [[] for _ in range(n)]
class unionfind():
def __init__(self, n):
self.n = n
# 中身が負の数なら根であり、数字の絶対値はグループ数
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0: return x
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x,y = self.find(x), 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())
n,m,k = imap()
uf = unionfind(n)
f,ng,anss = iarr(n),iarr(n),iarr(n)
for i in range(m):
a,b = imap()
a,b = a-1,b-1
f[a] += 1
f[b] += 1
uf.union(a,b)
for i in range(n):
anss[i] = uf.size(i) - f[i] - 1
for i in range(k):
c,d = imap()
c,d = c-1,d-1
if uf.same(c,d):
anss[c] -= 1
anss[d] -= 1
print(*anss)
| class UnionFind:
def __init__(self, n):
self.par = [-1] * n
def unite(self, x, y):
x = self.root(x)
y = self.root(y)
if x == y:
return False
if self.par[x] > self.par[y]:
x, y = y, x
self.par[x] += self.par[y]
self.par[y] = x
return True
def root(self, x):
path = []
while self.par[x] >= 0:
path.append(x)
x = self.par[x]
for y in path:
self.par[y] = x
return x
def same(self, x, y):
return self.root(x) == self.root(y)
def size(self, x):
return -self.par[self.root(x)]
n, m, k = map(int, input().split())
friends = [[] for _ in range(n)]
for i in range(m):
a, b = map(int, input().split())
a -= 1
b -= 1
friends[a].append(b)
friends[b].append(a)
blocks = [[] for _ in range(n)]
for i in range(k):
c, d = map(int, input().split())
c -= 1
d -= 1
blocks[c].append(d)
blocks[d].append(c)
uni = UnionFind(n)
for i, v in enumerate(friends):
for j in v:
uni.unite(i, j)
for i in range(n):
ans = uni.size(i) - len(friends[i]) - 1
for block in blocks[i]:
if uni.same(i, block):
ans -= 1
print(ans, end=' ') | 1 | 61,841,632,718,212 | null | 209 | 209 |
n, m, x = map(int, input().split())
c = [0] * n
a = [[]] * n
for i in range(n):
c[i], *a[i] = map(int, input().split())
ans = 2**32
for mask in range(1 << n):
res = [0] * m
cost = 0
for i in range(n):
if mask >> i & 1:
cost += c[i]
for j in range(m):
res[j] += a[i][j]
if all(v >= x for v in res):
ans = min(ans, cost)
print(ans if ans != 2**32 else -1) | MOD = 10**9 + 7
def main():
N = int(input())
A = [int(i) for i in input().split()]
B = [0]*N
ans = 3
for a in A:
if a == 0:
if B[a] == 1:
ans *= 2
else:
ans *= B[a-1] - B[a]
B[a] += 1
if 3 < B[a] or (a != 0 and B[a-1] < B[a]):
ans = 0
break
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 76,268,276,171,072 | 149 | 268 |
a = float(input())
print("{:.12f}".format((a/3)**3)) | s = input().split('S')
m = 0
for i in s:
if len(i) > m:
m = len(i)
print(m)
| 0 | null | 26,086,133,846,200 | 191 | 90 |
from math import gcd
def snack(a, b):
icm = (a*b // gcd(a, b))
return icm
def main():
a, b = map(int, input().split())
print(snack(a, b))
if __name__ == '__main__':
main() | from collections import Counter
n = int(input())
a1, a2 = [], []
for idx, ai in enumerate(map(int, input().split())):
a1.append(ai+idx)
a2.append(idx-ai)
cnt = Counter(a2)
res = 0
for idx, i in enumerate(a1):
cnt[a2[idx]] -= 1
res += cnt[i]
print(res) | 0 | null | 69,575,029,659,388 | 256 | 157 |
import math
#n個からr個とるときの組み合わせの数
def combinations_count(n, r):
return math.factorial(n) // (math.factorial(n - r) * math.factorial(r))
S = int(input())
ans = 0
mod = 10 ** 9 + 7
for i in range(1,S // 3 + 1): #長さiの数列のとき
x = S - 3 * i #3を分配後の余り
ans += (combinations_count(x + i - 1, i - 1)) % mod #重複組み合わせを足す
ans %= mod
print(ans)
| from sys import stdin
def solve():
s = int(stdin.readline())
mod = 10**9+7
if s < 3: return 0
dp = [0]*(s+1)
dp[0] = 1
for i in range(3,s+1):
dp[i] = dp[i-1] + dp[i-3]
return dp[s]%mod
print(solve()) | 1 | 3,260,658,247,592 | null | 79 | 79 |
n = int(input())
i = 0
while (i < n):
L = map(int, raw_input().split())
L.sort(reverse = True)
if (pow(L[0], 2) == pow(L[1], 2) + pow(L[2], 2)):
print "YES"
else:
print "NO"
i += 1 | # -*- coding: utf-8 -*-
# C
import sys
from collections import defaultdict, deque
from heapq import heappush, heappop
import math
import bisect
input = sys.stdin.readline
# 再起回数上限変更
# sys.setrecursionlimit(1000000)
import math
a, b, c = map(int, input().split())
a1 = a + b - c
if a1 >0:
print('No')
sys.exit()
if a1**2 - 4 * a * b > 0:
print('Yes')
else:
print('No') | 0 | null | 25,803,277,782,898 | 4 | 197 |
n = int(input())
my_dict = {}
for i in range(n):
order, key = input().split(' ')
if order == 'insert':
my_dict[key] = True
elif order== 'find':
if key in my_dict.keys():
print('yes')
else:
print('no')
| import random as random
s=input()
s_=s[:-2]
s1=random.choice(s_)
l=s_.index(s1)
s2=s[l+1]
s3=s[l+2]
s4=s1+s2+s3
print(s4) | 0 | null | 7,481,766,896,912 | 23 | 130 |
#!/usr/bin/env python3
from itertools import count, takewhile
def prime():
prime = []
def _isPrime(n):
for d in takewhile(lambda x: x * x <= n, prime):
if n % d == 0:
return False
return True
for i in count(2):
if _isPrime(i):
prime.append(i)
yield(i)
def is_prime(primes, i):
for p in takewhile(lambda x: x * x <= i, sorted(primes)):
if i % p == 0:
return False
return True
primes = list(takewhile(lambda x: x < 10000, prime()))
n = int(input())
c = 0
for _ in range(n):
i = int(input())
if is_prime(primes, i):
c += 1
print(c) | import math
N = int(input())
count = 0
for _ in range(N):
m = int(input())
rm = int(math.sqrt(m))
flag = 0
for i in range(2,rm+1):
if m %i ==0:
flag = 1
break
if flag ==0 :count=count +1
print(count) | 1 | 10,140,134,492 | null | 12 | 12 |
from collections import defaultdict
from math import sqrt
def main():
n = int(input())
wi = 2
cnt = 0
d = defaultdict(lambda:0)
fi = int(sqrt(1e12)+1)
for i in range(2, fi):
while n % i == 0:
d[i] += 1
n //= i
if n != 1:
d[n] = 1
for val in d.values():
x = val
wi = 1
while(x >= wi):
x -= wi
wi += 1
cnt += 1
print(cnt)
if __name__ == "__main__":
main() | n = int(input())
mod = 10**9 + 7
ans = (10**n - 9**n - 9**n + 8**n) % mod
print(ans)
| 0 | null | 10,050,753,844,656 | 136 | 78 |
import copy
n = int(input())
l = list(input().split())
C1 = []
for v in l:
s = v[0]
m = int(v[1])
C1.append((s, m))
C2 = copy.deepcopy(C1)
for i in range(n):
for j in range(n-1, i, -1):
if C1[j][1] < C1[j-1][1]:
C1[j], C1[j-1] = C1[j-1], C1[j]
for i in range(n):
minj = i
for j in range(i,n):
if C2[j][1] < C2[minj][1]:
minj = j
C2[i], C2[minj] = C2[minj], C2[i]
result1 = [t[0]+str(t[1]) for t in C1]
result2 = [t[0]+str(t[1]) for t in C2]
print(" ".join(result1))
print("Stable")
print(" ".join(result2))
if result1 == result2:
print("Stable")
else:
print("Not stable")
| N = int(input())
A = input().split(" ")
def bubble_sort(A):
N = len(A)
for i in range(N):
for j in range(N - 1, i, -1):
if int(A[j][1]) < int(A[j - 1][1]):
A[j - 1], A[j] = A[j], A[j - 1]
return A
def selection_sort(A):
N = len(A)
for i in range(N):
mini = i
for j in range(i + 1, N):
if int(A[j][1]) < int(A[mini][1]):
mini = j
if mini != i:
A[mini], A[i] = A[i], A[mini]
return A
def is_stable(A, B):
map_a = {}
map_b = {}
for i in range(len(A)):
s_a = A[i][0]
s_b = B[i][0]
v_a = A[i][1]
v_b = B[i][1]
if v_a in map_a:
map_a[v_a].append(s_a)
else:
map_a[v_a] = [s_a]
if v_b in map_b:
map_b[v_b].append(s_b)
else:
map_b[v_b] = [s_b]
result = True
for k in map_a:
if len(map_a[k]) > 1:
result = result and (map_a[k] == map_b[k])
return result
A_sorted = bubble_sort(A[:])
print(" ".join(A_sorted))
print("Stable") if is_stable(A, A_sorted) else print("Not stable")
A_sorted = selection_sort(A[:])
print(" ".join(A_sorted))
print("Stable") if is_stable(A, A_sorted) else print("Not stable") | 1 | 23,846,332,902 | null | 16 | 16 |
n,k=map(int,input().split())
cnt=[0]*(k+1)
mod=10**9+7
for i in range(1,k+1):
cnt[i]=pow(k//i,n,mod)
#print(cnt)
for i in range(k):
baisu=k//(k-i)
for j in range(2,baisu+1):
cnt[k-i]=(cnt[k-i]-cnt[(k-i)*j]+mod)%mod
ans=0
for i in range(1,k+1):
ans+=i*cnt[i]
ans%=mod
print(ans) | n,k=map(int,input().split())
l=[i for i in range(1,k+1)][::-1]
mod=10**9+7
m=[0]*(k+1)
for i in l:
a=k//i
m[i]=pow(a,n,mod)
for j in range(i*2,k+1,i):
m[i]-=m[j]
ans=0
for i in range(k+1):
ans+=m[i]*i
ans%=mod
print(ans%mod) | 1 | 36,818,342,489,868 | null | 176 | 176 |
N = int(input())
D = []
for i in range(N):
s, t = input().split()
D.append([s, int(t)])
m = input()
n = 0
for i in range(N):
if m in D[i]:
n = i
break
print(sum([d[1] for d in D[n + 1:]]))
| H = int(input())
cnt = 1
while(H > 0):
cnt *= 2
H //= 2
print(cnt - 1) | 0 | null | 88,803,749,740,862 | 243 | 228 |
S, T = input().split()
A, B = map(int, input().split())
U = input()
print(A-1 if S==U else A)
print(B if S==U else B-1) | N = int(raw_input())
min = int(raw_input())
max = int(raw_input())
dif = max - min
if max < min:
min = max
for i in range(N - 2):
R = int(raw_input())
if R - min > dif:
dif = R - min
if R < min:
min = R
print dif | 0 | null | 35,970,066,556,842 | 220 | 13 |
import numpy as np
N = int(input())
S = [[] for I in range(0,N)]
for T in range(0,N):
A = int(input())
S[T] = np.zeros((A,2),dtype=int)
for TT in range(0,A):
S[T][TT,:] = np.array([int(X) for X in input().split()])
MAX = 0
for P in range(pow(2,N)-1,-1,-1):
Bin = [int(X) for X in list(('{:0'+str(N)+'b}').format(P,'b'))]
BIndex = [I for I,N in enumerate(Bin) if N==1]
Flag = True
for PT in BIndex:
for PTB in range(0,S[PT].shape[0]):
if S[PT][PTB,1]==0 and (S[PT][PTB,0]-1) in BIndex:
Flag = False
break
if S[PT][PTB,1]==1 and (S[PT][PTB,0]-1) not in BIndex:
Flag = False
break
if not Flag:
break
if Flag:
MAX = len(BIndex)
break
print(MAX) | N = int(input())
testimony = [[] for _ in range(N)]
for i in range(N):
num = int(input())
for j in range(num):
person, state = map(int, input().split())
testimony[i].append([person-1, state])
honest = 0
for i in range(2**N):
flag = 0
for j in range(N):
if (i>>j)&1 == 1: # j番目は正直と仮定
for x,y in testimony[j]:
if (i>>x)&1 != y: # j番目は正直だが矛盾を発見
flag = 1
break
if flag == 0: # 矛盾がある場合はflag == 1になる
honest = max(honest, bin(i)[2:].count('1')) # 1の数をカウントし最大となるものを選択
print(honest) | 1 | 121,512,792,452,750 | null | 262 | 262 |
import sys
from collections import deque
sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7
def input():
return sys.stdin.readline().strip()
def main():
N, D, A = map(int, input().split())
monster = {}
X = []
for _ in range(N):
x, h = map(int, input().split())
monster[x] = h
X.append(x)
X.sort()
# x, damage
q = deque([])
acc_damage = 0
ans = 0
for i in range(N):
x = X[i]
h = monster[x]
while q and q[0][0] < x:
p, damage = q.popleft()
acc_damage -= damage
if h - acc_damage <= 0:
continue
cnt = (h - acc_damage + A - 1) // A
ans += cnt
acc_damage += cnt * A
q.append((x + 2 * D, cnt * A))
print(ans)
if __name__ == "__main__":
main()
| n = int(input())
c = input()
left, right = 0, n - 1
cnt = 0
while left <= right:
while left < n and c[left] == 'R':
left += 1
while right > -1 and c[right] == 'W':
right -= 1
if left == n or right == -1 or left >= right: break
left += 1
right -= 1
cnt += 1
print(cnt) | 0 | null | 44,502,013,053,892 | 230 | 98 |
# 17-Character-Counting_Characters.py
# ?????????????????????
# ?????????????????±??????????????????????????¢???????????????????????°?????°??????????????°?????????????????????????????????
# ??????????°?????????¨??§??????????????\???????????????
# Input
# ?????°????????????????????????????????±???????????????????????????
# Output
# ?????????????????±???????????????????????¢???????????????????????°?????\??????????????¢?????§????????????????????????
# a : a????????°
# b : b????????°
# c : c????????°
# .
# .
# z : z????????°
# Constraints
# ??±???????????????????????° < 1200
# Sample Input
# This is a pen.
# Sample Output
# a : 1
# b : 0
# c : 0
# d : 0
# e : 1
# f : 0
# g : 0
# h : 1
# i : 2
# j : 0
# k : 0
# l : 0
# m : 0
# n : 1
# o : 0
# p : 1
# q : 0
# r : 0
# s : 2
# t : 1
# u : 0
# v : 0
# w : 0
# x : 0
# y : 0
# z : 0
import sys
s = str()
alphabet = "abcdefghijklmnopqrstuvwxyz"
for line in sys.stdin:
s += line.lower()
# print(list(s))
for c in alphabet:
print("{} : {}".format(c, s.count(c)) ) | import sys
from collections import Counter
S = ""
for s in sys.stdin:
s = s.strip().lower()
if not s:
break
S += s
for i in 'abcdefghijklmnopqrstuvwxyz':
print(i, ":", S.count(i))
| 1 | 1,660,278,498,080 | null | 63 | 63 |
a = []
while True:
d = list(map(int, input().split()))
if d == [0,0]:
break
d.sort()
a.append(d)
for x in a:
print('{} {}'.format(x[0],x[1])) | from scipy.special import comb
S = int(input())
ans = 0
mod = 10**9+7
for i in range(3, S+1, 3):
ans = (ans +comb(S-2*(i//3)-1, i//3-1, exact=True)) % mod
print(ans)
| 0 | null | 1,886,220,163,520 | 43 | 79 |
# -*- coding: utf-8
s = list(map(str,input().split()))
sum = 0
for i in range(len(s)):
sum += (int) (s[i])
if sum %9 == 0:
print("Yes")
else:
print("No") | s = input()
rs = s[::-1]
ans = 0
for i in range(len(s)//2):
ans += (s[i] != rs[i])
print(ans) | 0 | null | 62,431,174,329,348 | 87 | 261 |
a = 1; b = 1
while True:
print(a,"x",b,"=",a*b,sep="")
b += 1
if b == 10:
a += 1; b = 1
if a == 10:
break
| x = 0
y = 0
for i in range(1,10):
x += 1
y = 0
for j in range(1,10):
y += 1
print("{}x{}={}".format(x,y,x*y))
| 1 | 994,816 | null | 1 | 1 |
N,K=map(int,input().split())
List = list(map(int, input().split()))
INF = 10000000000
expList = [INF]*1001
def expectationF(num):
if expList[num] == INF:
exp = 0
for i in range(1,num+1):
exp += i/num
expList[num] = exp
return expList[num]
res = 0
mid = 0
midList=[]
for i in range(N):
if i>=1:
midList.append(expectationF(List[i])+midList[i-1])
else:
midList.append(expectationF(List[i]))
m=K-1
for j in range(N-m):
if j == 0:
mid = midList[j+m]
else:
mid = midList[j+m]- midList[j-1]
res = max(res,mid)
print(res) | N = int(input())
E = [[] for _ in range(N+1)]
for _ in range(N):
tmp = list(map(int, input().split()))
if tmp[1] == 0:
continue
E[tmp[0]] = tmp[2:]
cnt = [0 for _ in range(N+1)]
q = [1]
while q:
cp = q.pop(0)
for np in E[cp]:
if cnt[np] != 0:
continue
cnt[np] = cnt[cp] + 1
q.append(np)
for ind, cost in enumerate(cnt):
if ind == 0:
continue
if ind == 1:
print(ind, 0)
else:
if cost == 0:
print(ind, -1)
else:
print(ind, cost)
| 0 | null | 37,221,573,000,170 | 223 | 9 |
import math
r = input()
print '%.10f %.10f' %(r*r*math.pi , r*2*math.pi) | import math
r = float(input())
s = r*r*math.pi
l = 2*r*math.pi
print(s,l)
| 1 | 628,602,931,996 | null | 46 | 46 |
n, d = map(int, input().split())
cnt = 0
for i in range(n):
Z = list(map(int, input().split()))
X = Z[0]
Y = Z[1]
if X**2 + Y**2 <= d**2:
cnt += 1
print(cnt)
| n,d=map(int, input().split())
xy=[]
ans = 0
for i in range(n):
x,y = map(int, input().split())
xy.append([x,y])
if d**2>=x**2+y**2:
ans += 1
print(ans)
| 1 | 5,947,986,711,048 | null | 96 | 96 |
x = int(input())
y = x - 400
print(8 - y//200) | n = int(input())
d = {}
t = 0
for i in range(n):
s = input()
d[s] = d.get(s, 0) + 1
t = max(t, d[s])
for key in sorted(d):
if d[key] == t:
print(key) | 0 | null | 38,459,608,839,128 | 100 | 218 |
def main():
n, k = map(int, input().split())
h_list = list(map(int, input().split()))
h_list.sort(reverse=True)
if n <= k:
ans = 0
else:
ans = sum(h_list[k:])
print(ans)
if __name__ == "__main__":
main()
| #153
def main():
N, K = map(int,input().split())
H = list(map(int,input().split()))
H.sort()
H.reverse()
H = H[K:]
cost = 0
for i in H:
cost+=i
print(cost)
main() | 1 | 79,059,705,787,620 | null | 227 | 227 |
# -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 17:11:27 2020
@author: liang
"""
N, M = map(int, input().split())
ans = [-1]*N
res = 0
for i in range(M):
s, c = map(int, input().split())
if s == 1 and c == 0 and N != 1:
print(-1)
break
if ans[s-1] == -1 or ans[s-1] == c:
ans[s-1] = c
else:
print(-1)
break
else:
if ans[0] == -1:
ans[0] = 1
if M == 0 and N == 1:
ans[0] = 0
ans = [0 if a == -1 else a for a in ans]
#print(ans)
for i in range(N):
res += ans[-(i+1)]*10**i
print(res) | n, m = map(int, input().split())
sc = [list(map(int, input().split())) for _ in range(m)]
for i in range(10 ** (n - 1) - (n == 1), 10 ** n):
is_ok = True
for s, c in sc:
s -= 1
if int(str(i)[s]) != c:
is_ok = False
if is_ok:
print(i)
exit()
print(-1) | 1 | 60,801,460,385,920 | null | 208 | 208 |
N = int(input())
S = input()
ans = S.count("R") * S.count("G") * S.count("B")
for i in range(N-2):
r = S[i]
for j in range(i+1,N-1):
g = S[j]
if r == g:
continue
k = 2*j - i
if k >= N:
continue
b = S[k]
if r != b and g != b:
ans -= 1
print(ans) | N=int(input())
S=input()
R=0;G=1;B=2
C=["R","G","B"]
X=[[[0 for i in range(N+1)]for x in range(2)] for c in range(3)]
for c in range(3):
for i in range(N):
if S[i]==C[c]:
X[c][0][i+1]=X[c][0][i]+1
else:
X[c][0][i+1]=X[c][0][i]
for i in range(N-1,-1,-1):
if S[i]==C[c]:
X[c][1][i]=X[c][1][i+1]+1
else:
X[c][1][i]=X[c][1][i+1]
ans=0
for i in range(N):
c=-1
for cc in range(3):
if C[cc]==S[i]:
c=cc
break
for seq in [((c+1)%3,(c+2)%3),((c+2)%3,(c+1)%3)]:
x,y=seq
ans+=X[x][0][i]*X[y][1][i]
for i in range(N):
x=0
while(i+2*x<N):
j=i+x
k=i+2*x
if len({S[i],S[j],S[k]})==3:
ans-=1
x+=1
print(ans)
| 1 | 36,122,379,820,130 | null | 175 | 175 |
n, k = map(int, input().split())
k = min(k, n - 1)
MOD = 1000000007
fact = [1] * (n + 1)
ifact = [0] * (n + 1)
for i in range(1, n + 1):
fact[i] = fact[i - 1] * i % MOD
ifact[n] = pow(fact[n], MOD - 2, MOD)
for i in range(n, 0, -1):
ifact[i - 1] = ifact[i] * i % MOD
def comb(n, k):
if k < 0 or k > n:
return 0
return fact[n] * ifact[k] * ifact[n - k] % MOD
ans = 0
for i in range(k + 1):
ans += comb(n, i) * comb(n - 1, i)
ans %= MOD
print(ans)
| import bisect
n = int(input().strip())
S = list(input().strip())
L=[[] for _ in range(26)]
for i,s in enumerate(S):
L[ord(s)-ord("a")].append(i)
q = int(input().strip())
for _ in range(q):
query=input().strip().split()
if query[0]=="1":
i=int(query[1])
i-=1
c=query[2]
if S[i]!=c:
delInd=bisect.bisect_left(L[ord(S[i])-ord("a")],i)
del L[ord(S[i])-ord("a")][delInd]
bisect.insort(L[ord(c)-ord("a")], i)
S[i]=c
else:
l,r=map(int,[query[1],query[2]])
l-=1; r-=1
ans=0
for j in range(26):
ind=bisect.bisect_left(L[j],l)
if ind<len(L[j]) and L[j][ind]<=r:
ans+=1
print(ans) | 0 | null | 65,029,368,813,418 | 215 | 210 |
s1,s2=map(str,input().split(' '))
print(s2+s1) | import numpy as np
a, b, x = map(int, input().split())
ans = 0
if (a*a*b/2) <= x:
ans = np.rad2deg(np.arctan((2*(a*a*b-x))/(a*a*a)))
else:
ans = np.rad2deg(np.arctan((a*b*b)/(2*x)))
print('{:.10f}'.format(ans))
| 0 | null | 132,692,939,668,888 | 248 | 289 |
N=int(input())
A = list(map(int,input().split()))
h = 0
for i in range(N-1):
if max(A[i], A[i+1]) == A[i]:
h += A[i] - A[i+1]
A[i+1] = A[i]
print(h) | n = int(input())
a = [int(x) for x in input().split()]
res = 0
for i in range(1,n):
if a[i] > a[i-1]:
continue
else:
res += a[i-1] - a[i]
a[i] = a[i-1]
print(res) | 1 | 4,543,714,870,464 | null | 88 | 88 |
N = int(input())
ab = [list(map(int, input().split())) for i in range(N)]
al = []
bl = []
for a,b in ab:
al.append(a)
bl.append(b)
al.sort()
bl.sort()
if N%2 == 0:
ans = (bl[N//2] + bl[N//2 -1]) - (al[N//2] + al[N//2 -1]) +1
else:
ans = bl[N//2] - al[N//2] +1
print(ans) | cnt = 0
def insertionSort(A, n, g):
global 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 = j - g
cnt += 1
A[j + g] = v
def shellSort(A, n):
G = [1]
for i in range(1, 100):
G.append(G[i - 1] * 3 + 1)
G = list(reversed([g for g in G if g <= n]))
m = len(G)
print(m)
if G:
print(*G)
for i in range(m):
insertionSort(A, n, G[i])
print(cnt)
n = int(input())
A = [int(input()) for _ in range(n)]
shellSort(A, n)
[print(a) for a in A]
| 0 | null | 8,710,132,523,066 | 137 | 17 |
#! python3
# greatest_common_divisor.py
def greatest_common_divisor(x, y):
r = None
if x >= y:
r = x%y
if r == 0: return y
else:
r = y%x
if r == 0: return x
return greatest_common_divisor(y, r)
x, y = [int(n) for n in input().split(' ')]
print(greatest_common_divisor(x, y))
| s, w = map(int, input().split())
ans = "safe" if s > w else 'unsafe'
print(ans)
| 0 | null | 14,516,362,573,258 | 11 | 163 |
# https://atcoder.jp/contests/abc168/tasks/abc168_a
N = int(input())
last_num = int(str(N)[-1])
if last_num in {2, 4, 5, 7, 9}:
print('hon')
elif last_num in {0, 1, 6, 8}:
print('pon')
else:
print('bon') | n = int(input()[-1])
if n in [2, 4, 5, 7, 9]:
print("hon")
elif n == 3:
print("bon")
else:
print("pon") | 1 | 19,256,863,312,192 | null | 142 | 142 |
mt = []
for i in range(10):
mt.append(int(input()))
mt.sort()
print( mt[9] )
print( mt[8] )
print( mt[7] ) | height = [int(input()) for i in range(10)]
sort = sorted(height, reverse=True)
for i in range(3):
print(sort[i]) | 1 | 27,580,960 | null | 2 | 2 |
from sys import stdin
int3 = sorted([int(x) for x in stdin.readline().rstrip().split()])
print(*int3)
| l = [int(i) for i in input().split()]
l.sort()
print(str(l[0])+' '+str(l[1])+' '+str(l[2])) | 1 | 410,880,373,420 | null | 40 | 40 |
n = int(input())
x = 0
y = 0
for _ in range(n):
a,b=input().split()
if a < b:
y+=3
elif a ==b:
x+=1
y+=1
else:
x+=3
print (x,y)
| taro, hanako = 0, 0
n = int(input())
for _ in range(n):
a, b = input().split()
if a > b:
taro += 3
elif a < b:
hanako += 3
else:
taro += 1
hanako += 1
print(taro, hanako) | 1 | 2,013,530,432,860 | null | 67 | 67 |
n, k, c = map(int, input().split())
s = input()
l = len(s) - 1
i = 0
lb = []
le = []
while i < len(s) and len(lb) < k:
if s[i] == 'o':
lb.append(i)
i += c + 1
continue
i += 1
while l > -1 and len(le) < k:
if s[l] == 'o':
le.append(l)
l -= (c + 1)
continue
l -= 1
le.sort()
for j in range(0, len(lb)):
if lb[j] == le[j]:
print(lb[j]+1) | n=int(input())
ans =0
for i in range(2,int(n**0.5)+5):
cnt = 0
while n%i==0:
n//=i
cnt += 1
s=1
while cnt-s>=0:
cnt -= s
s +=1
ans += 1
if n!=1:ans+=1
print(ans)
| 0 | null | 28,733,751,095,068 | 182 | 136 |
x,y,z=map(int,input().split())
print(y//z-(x-1)//z) | n = int(input())
c = list(input())
r = 0
w = 0
for i in range(len(c)):
if(c[i]=="R"):
r += 1
ans = max(r,w)
for i in range(len(c)):
if(c[i]=="R"):
r -= 1
else:
w += 1
now = max(r,w)
ans = min(ans,now)
print(ans) | 0 | null | 6,971,235,007,100 | 104 | 98 |
import sys
input = sys.stdin.readline
INF = 99999#1001001001
from collections import deque
def linput(ty=int, cvt=list):
return cvt(map(ty,input().split()))
def pad(mxy, wall="#"):
w = len(mxy[0])
gp = wall*(w+2)
re = [gp,]
re_app = re.append
for vx in mxy:
re_app(wall+vx+wall)
re_app(gp)
return re
vD = [(0,1),(1,0)]
vQ = deque([])
vQ_app, vQ_popl = vQ.append, vQ.popleft
def main():
H,W = linput()
mM = [input().rstrip() for _ in [0,]*H]
mM = pad(mM, "$")
res = 0
cnt = 0
for sr in range(1,1+1):
for sc in range(1,1+1):
if mM[sr][sc]=="#":
res += 1
mV = [[INF,]*(W+2) for _ in [INF,]*(H+2)]
mV[sr][sc] = res
vQ_app((sr,sc))
while vQ:
r,c = vQ_popl()
now_cost = mV[r][c]
now_s = mM[r][c]
for dr,dc in vD:
nr,nc = r+dr, c+dc
if mM[nr][nc]=="$":
continue
next = now_s=="."!=mM[nr][nc]
new_cost = now_cost + next
if new_cost < mV[nr][nc]:
vQ_app((nr,nc))
mV[nr][nc] = new_cost
cnt += 1
#print(res,cnt,X,Y,H)
if cnt>999999: break
#print(*mV,sep="\n")###
res = mV[H][W]
print(res)
if __name__ == "__main__":
main()
| import math
N, D = map(int, input().split())
p = [list(map(int, input().split())) for _ in range(N)]
cnt = 0
for x, y in p:
if D >= math.sqrt(x**2 + y**2):
cnt += 1
print(cnt)
| 0 | null | 27,598,879,060,532 | 194 | 96 |
x, y = map(int, input().split())
mod = 10 ** 9 + 7
if (x + y) % 3 != 0:
ans = 0
else:
n, m = (2 * x - y) / 3, (2 * y - x) / 3
ans = 0
if n >= 0 and m >= 0:
n, m = int(n), int(m)
ans = 1
for i in range(min(m, n)):
ans = ans * (n + m - i) % mod
ans *= pow(i + 1, mod - 2, mod)
print(ans % mod) | import sys
X, Y = map(int, input().split())
# たどりつけない時
if ((X+Y) % 3 != 0) or (min(X, Y)*2 < max(X, Y)):
print(0)
sys.exit()
# 目的地までの移動回数
n = (X+Y)//3
# 少ない方の使用回数
r = 2*n-max(X, Y)
# n個の中からr個選ぶ組み合わせ
mod = pow(10, 9)+7
bunshi = 1
bunbo = 1
for i in range(r):
bunshi = (bunshi*(n-i)) % mod
bunbo = (bunbo*(i+1)) % mod
ans = (bunshi*pow(bunbo, -1, mod)) % mod
print(ans)
| 1 | 150,121,956,314,340 | null | 281 | 281 |
import sys
input = sys.stdin.readline
from collections import defaultdict, deque
n, s, res, MOD = int(input()), list(map(int, input().split())), 0, int(1e9) + 7
for i in range(61):
x, c = int(pow(2, i, MOD)), [0, 0]
for j in range(n): c[1 if s[j] & 1 << i else 0] += 1
x = (x * c[0]) % MOD; x = (x * c[1]) % MOD; res = (res + x) % MOD
print(res) | N=int(input())
S=list(input())
S.insert(0,0)
R=S.count("R")
G=S.count("G")
B=S.count("B")
ans=R*G*B
for i in range(1,N-1):
for j in range(i+1,N):
k=2*j-i
if k<N+1 and S[i]!=S[j] and S[j]!=S[k] and S[k]!=S[i]:
ans-=1
print(ans)
| 0 | null | 79,363,299,906,176 | 263 | 175 |
str = input()
n = int(len(str) / 2)
cnt = 0
for i in range(n):
if str[i] != str[-1-i]:
cnt += 1
print(cnt) | from math import pi
r = float(input())
z = r*r*pi
l = 2*r*pi
print('{} {}'.format(z,l)) | 0 | null | 60,598,932,539,360 | 261 | 46 |
import math
def is_prime(n):
global primes
if n == 1:
return False
if n == 2:
return True
if n % 2 == 0:
return False
s = int(math.sqrt(n))
for x in range(3, s + 1, 2):
if n % x == 0:
return False
else:
return True
N = int(input())
d = [int(input()) for _ in range(N)]
d.sort()
print([is_prime(x) for x in d].count(True)) | n = int(input())
x = input()
x_popcnt = x.count('1')
one_popcnt = x_popcnt - 1
zero_popcnt = x_popcnt + 1
one_mod = 0
zero_mod = 0
for b in x:
if one_popcnt != 0:
one_mod = (one_mod*2 + int(b)) % one_popcnt
zero_mod = (zero_mod*2 + int(b)) % zero_popcnt
f = [0]*220000
popcnt = [0]*220000
for i in range(1, 220000):
popcnt[i] = popcnt[i//2] + i % 2
f[i] = f[i % popcnt[i]] + 1
for i in range(n-1, -1, -1):
if x[n-1-i] == '1':
if one_popcnt != 0:
nxt = one_mod
nxt -= pow(2, i, one_popcnt)
nxt %= one_popcnt
print(f[nxt]+1)
else:
print(0)
if x[n-1-i] == '0':
nxt = zero_mod
nxt += pow(2, i, zero_popcnt)
nxt %= zero_popcnt
print(f[nxt]+1)
| 0 | null | 4,128,326,026,982 | 12 | 107 |
h = int(input())
ans = 1
while h > 0:
h //= 2
ans *= 2
print(ans-1) | H = int(input())
num = 1
ans = 0
while H > 0:
H //= 2
ans += num
num *= 2
print(ans) | 1 | 79,751,052,150,120 | null | 228 | 228 |
import sys
import math
from collections import defaultdict
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10**7)
def input():
return sys.stdin.readline()[:-1]
mod = 10**9 + 7
def I(): return int(input())
def LI(): return list(map(int, input().split()))
def LIR(row,col):
if row <= 0:
return [[] for _ in range(col)]
elif col == 1:
return [I() for _ in range(row)]
else:
read_all = [LI() for _ in range(row)]
return map(list, zip(*read_all))
#################
def floor(a,b):
return a//b
N,X,M = LI()
# 繰り返しの1回目が終わるまで
used = [-1]*M
end_index = -1
A = [X]
sum_ = 0
for i in range(N):
if i == 0:
sum_ += A[0]
else:
val = pow(A[i-1],2,M)
A.append(val)
if used[val] == -1:
used[val] = i
sum_ += val
else:
end_index = i
start_val = val
start_index = used[val]
break
if end_index == -1:
print(sum_)
exit()
else:
ans = sum_
# 繰り返し全体が終わるまで
n = floor(N-start_index,end_index-start_index)
sum_ = 0
A2 = [start_val]
for j in range(end_index-start_index):
if j == 0:
val2 = start_val
sum_ += val2
else:
val2 = pow(A2[j-1],2,M)
A2.append(val2)
sum_ += val2
ans += (n-1)*sum_
# 残りの部分
sum_ = 0
A2 = [start_val]
for j in range(N-n*end_index+(n-1)*start_index):
if j == 0:
val2 = start_val
sum_ += val2
else:
val2 = pow(A2[j-1],2,M)
A2.append(val2)
sum_ += val2
ans += sum_
print(ans) | n, x, m = map(int, input().split())
mn = min(n, m)
S = set()
A = []
sum_9 = 0 # sum of pre + cycle
for _ in range(mn):
if x in S: break
S.add(x)
A.append(x)
sum_9 += x
x = x*x % m
if len(A) >= mn:
print(sum_9)
exit()
pre_len = A.index(x)
cyc_len = len(A) - pre_len
nxt_len = (n - pre_len) % cyc_len
cyc_num = (n - pre_len) // cyc_len
pre = sum(A[:pre_len])
cyc = sum_9 - pre
nxt = sum(A[pre_len: pre_len + nxt_len])
print(pre + cyc * cyc_num + nxt)
| 1 | 2,791,832,414,800 | null | 75 | 75 |
import collections
N=int(input())
A=list(map(int,input().split()))
A=sorted(A)
c=collections.Counter(A)
if __name__=="__main__":
if 1 in A:
if c[1]==1:
print(1)
else:
print(0)
else:
A=[]
dp=[True for _ in range(10**6+10)]
for key,value in c.items():
if value==1:
A.append(key)
else:
if dp[key]:
i=2
while i*key<=10**6:
dp[i*key]=False
i+=1
if len(A)==0:
print(0)
else:
for a in A:
if dp[a]:
i=2
while i*a<=10**6:
dp[i*a]=False
i+=1
ans=0
for a in A:
if dp[a]:
ans+=1
print(ans)
| n = int(input())
a = [int(x) for x in input().split()]
m = [0]*(max(a)+1)
lm = len(m)
cnt = 0
for i in a:
j = 1
while i*j < lm:
m[i*j] += 1
j += 1
for i in a:
if m[i] == 1:
cnt += 1
print(cnt) | 1 | 14,445,273,935,380 | null | 129 | 129 |
def get_cusum(lst):
cusum = [0] + lst
for i in range(1, len(cusum)):
cusum[i] = cusum[i] + cusum[i-1]
return cusum
def main():
n, m, k = map(int, input().split(" "))
book_a = get_cusum(list(map(int, input().split(" "))))
book_b = get_cusum(list(map(int, input().split(" "))))
ans = 0
top = m
# print(book_a)
# print(book_b)
for i in range(n + 1):
if book_a[i] > k:
break
while book_b[top] > k - book_a[i]:
top -= 1
ans = max(ans, i+top)
print(ans)
main()
| # coding: utf-8
import sys
import math
import collections
import itertools
INF = 10 ** 13
MOD = 10 ** 9 + 7
def input() : return sys.stdin.readline().strip()
def lcm(x, y) : return (x * y) // math.gcd(x, y)
def I() : return int(input())
def LI() : return [int(x) for x in input().split()]
def RI(N) : return [int(input()) for _ in range(N)]
def LRI(N) : return [[int(x) for x in input().split()] for _ in range(N)]
def LS() : return input().split()
def RS(N) : return [input() for _ in range(N)]
def LRS(N) : return [input().split() for _ in range(N)]
def PL(L) : print(*L, sep="\n")
def YesNo(B) : print("Yes" if B else "No")
def YESNO(B) : print("YES" if B else "NO")
N = I()
A = LI()
A = sorted([[a, i] for i, a in enumerate(A)], reverse=True, key=lambda x : x[0])
dp = [[0] * (N+1) for _ in range(N+1)]
for i in range(N):
for j in range(N-i):
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + A[i+j][0] * (A[i+j][1] - i))
dp[i][j+1] = max(dp[i][j+1], dp[i][j] + A[i+j][0] * ((N-j-1) - A[i+j][1]))
res = 0
for i in range(N):
res = max(res, dp[i][N-i])
print(res)
| 0 | null | 22,381,679,794,942 | 117 | 171 |
if __name__ == '__main__':
n = int(input())
A = list(map(int,input().split()))
cnt = 0
for i in A:
if i % 2 == 0:
if i % 3 == 0 or i % 5 == 0:
cnt += 1
else:
cnt += 1
if cnt == n:
print("APPROVED")
else:
print("DENIED")
| a=int(input())
b=list(map(int,input().split()))
c=0
for i in range(a):
if b[i]%2==0:
if b[i]%3==0 or b[i]%5==0:
c=c+1
else:
c=c+1
if c==a:
print("APPROVED")
else:
print("DENIED") | 1 | 69,133,129,559,350 | null | 217 | 217 |
INT = lambda: int(input())
INTM = lambda: map(int,input().split())
STRM = lambda: map(str,input().split())
STR = lambda: str(input())
LIST = lambda: list(map(int,input().split()))
LISTS = lambda: list(map(str,input().split()))
def do():
n=INT()
p=LIST()
tm=10**9
ct=0
for i in range(n):
if tm>=p[i]:
ct+=1
tm=min(tm,p[i])
print(ct)
if __name__=='__main__':
do() | n = int(input())
P = list(map(int, input().split()))
ans = 0
m = 200002
for p in P:
if p <= m:
m = p
ans += 1
print(ans) | 1 | 85,119,527,581,440 | null | 233 | 233 |
for i in range(1, 10):
for j in range(1, 10):
print "{0}x{1}={2}".format(i, j, i*j) | # Aizu Problem 0000: QQ
#
import sys, math, os
# read input:
#PYDEV = os.environ.get('PYDEV')
#if PYDEV=="True":
# sys.stdin = open("sample-input2.txt", "rt")
for i in range(1, 10):
for j in range(1, 10):
print("%dx%d=%d" % (i, j, i*j)) | 1 | 1,521,120 | null | 1 | 1 |
# 数列生成
from itertools import combinations
N, M, Q = map(int, input().split())
ls = []
for i in range(Q):
ls.append([int(j) for j in input().split()])
V = [[] for i in range(N+1)]
for i in range(1, M+1):
V[1].append([i])
for i in range(1, N):
for v in V[i]:
b = v[-1]
for x in range(b, M+1):
V[i+1].append(v + [x])
ans = 0
for x in V[-1]:
cur = 0
for z in ls:
if x[z[1]-1] - x[z[0]-1] == z[2]:
cur += z[3]
ans = max(ans, cur)
print(ans) | a, b, m = map(int, input().split())
reizo = list(map(int, input().split()))
renji = list(map(int, input().split()))
p = [list(map(int,input().split())) for i in range(m)]
ans = []
for i in range(m):
cost = reizo[p[i][0] - 1] + renji[p[i][1] - 1] - p[i][2]
ans.append(cost)
ans.append(min(reizo) + min(renji))
print(min(ans)) | 0 | null | 40,981,126,474,072 | 160 | 200 |
K=int(input())
s =input()
x = len(s)
if x<=K:
print(s)
else:
print(s[:K]+'...') | x=int(input())
n=100
ans=0
while True:
ans+=1
n+=n//100
if n>=x:
print(ans)
break | 0 | null | 23,401,517,324,410 | 143 | 159 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.