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
|
|---|---|---|---|---|---|---|
K=int(input())
A,B=map(int,input().split())
print("OK" if B//K*K >= A else "NG") | k = int(input())
a, b=map(int, input().split())
c=0
for i in range(a, b+1):
if i%k == 0:
c += 1
else:
pass
if c == 0:
print("NG")
else:
print("OK") | 1 | 26,621,036,932,100 | null | 158 | 158 |
import math
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
import itertools
t=[i for i in range(1,n+1)]
a = list(itertools.permutations(t))
def num(b,t,n):
c = 0
for i in range(len(t)):
if list(t[i]) != b:
c += 1
else:
break
return(c)
x = num(p,a,n)
y = num(q,a,n)
print(abs(x-y)) | num, max_num = map(int, input().split())
x = []
y = []
count = 0
for i in range(num):
x1,y1 = map(int, input().split())
x.append(x1)
y.append(y1)
for i in range(len(x)):
temp = (x[i]**2 +y[i]**2)**(1/2)
if temp <= max_num:
count += 1
print(count)
| 0 | null | 53,094,653,908,900 | 246 | 96 |
s=input()
ans=""
if len(s)%2==1:
print("No")
else:
n=len(s)//2
ans="hi"*n
if ans==s:
print("Yes")
else:
print("No") | print('No' if input().replace('hi', '') else 'Yes') | 1 | 53,034,121,160,160 | null | 199 | 199 |
def I(): return int(input())
def MI(): return map(int, input().split())
def LI(): return list(map(int, input().split()))
def main():
mod=10**9+7
S=input()
if S[-1]=="s":
S+="es"
else:
S+="s"
print(S)
main()
| s = input()
ans = s
if s[-1] == "s":
ans += "e"
print(ans+"s") | 1 | 2,379,697,416,122 | null | 71 | 71 |
from collections import Counter
n = int(input())
A = list(map(int, input().split()))
X = Counter([i - a for i, a in enumerate(A)])
ans = 0
for i, a in enumerate(A):
X[i - a] -= 1
ans += X[i + a]
print(ans)
| def main():
N=int(input())
A=list(map(int,input().split()))
L={}
R={}
for i in range(N):
l=(i+1)+A[i]
r=(i+1)-A[i]
if (l in L.keys()):
L[l]+=1
else:
L[l]=1
if r in R.keys():
R[r]+=1
else:
R[r]=1
res=0
for key in L.keys():
if key in R.keys():
res+=R[key]*L[key]
print(res)
if __name__=="__main__":
main()
| 1 | 26,128,442,636,288 | null | 157 | 157 |
n=int(input())
A=list(map(int,input().split()) )
A.sort()
furui = [0] * (max(A) + 1)
for i in A:
if furui[i] >= 2:
continue
for j in range(i,len(furui),i):
furui[j] += 1
ans=0
for i in A:
if furui[i]==1:
ans+=1
print(ans) | n=int(input())
l=list(map(int,input().split()))
a=[0]*(10**6+1)
for i in range(n):
if(a[l[i]]==0):
for j in range(2*l[i],10**6+1,l[i]):
a[j]=2
a[l[i]]+=1
print(a.count(1))
| 1 | 14,475,873,108,994 | null | 129 | 129 |
N = int(input())
ans = []
if N <= 26:
print(chr(96 + N))
else:
while N != 0:
val = N % 26
if val == 0:
val = 26
N = N //26 - 1
else:
N //= 26
ans.append(chr(96 + val))
ans.reverse()
print(''.join(ans))
| chars = [chr(i) for i in range(ord('a'), ord('z') + 1)]
arr = []
x = int(input())
def get_len(n):
length = 1
t = 26
while True:
if n <= t:
return length
t += 26 ** (length + 1)
length += 1
if length > 1000000000000001:
raise
def get_ord(n):
st = 1
end = 26
ind = 1
while True:
if st <= n <= end:
return x - st
st = end + 1
end += 26 ** (ind + 1)
ind += 1
length = get_len(x)
order = get_ord(x)
# print(length)
for i in range(length):
s = order % 26
order = order // 26
arr.append(s)
# print(arr)
ans = ""
for ai in arr[::-1]:
ans += chars[ai]
print(ans) | 1 | 11,939,357,938,018 | null | 121 | 121 |
from collections import Counter
n = int(input())
s = [input() for _ in range(n)]
c = Counter(s)
csort = sorted(c.items(), key=lambda x:x[1],reverse=True)
maxc = csort[0][1]
ans = []
for s,v in csort:
if v == maxc:
ans.append(s)
anssort = sorted(ans)
for s in anssort:
print(s) | a, b, c, d = map(int, input().split())
print('Yes') if (a-1) // d >= (c-1) // b else print('No') | 0 | null | 49,700,014,070,560 | 218 | 164 |
K=int(input())
A,B=map(int,input().split())
ans=0
i=1
while K*i<=1000:
if A<=K*i and K*i<=B:
ans=1
break
i+=1
if ans==1:
print("OK")
else:
print("NG") | #
import sys
input=sys.stdin.readline
def main():
S=input().strip("\n")
Q=int(input())
sign=True
head=[]
tail=[]
for i in range(Q):
q=tuple(input().split())
if q[0]=="1":
sign^=True
else:
if (q[1]=="1" and sign==True) or (q[1]=="2" and sign==False):
head.append(q[2])
else:
tail.append(q[2])
if sign==True:
print("".join(head[::-1])+S+"".join(tail))
else:
print("".join(tail[::-1])+S[::-1]+"".join(head))
if __name__=="__main__":
main()
| 0 | null | 41,860,589,901,550 | 158 | 204 |
import math
H, W = map(int, input().split(' '))
if H == 1 or W == 1:
print(1)
exit()
res = math.ceil((H*W)/2)
print(res)
| H, W = map(int, input().split())
h_odd = 1 if H%2 == 1 else 0
if H == 1 or W == 1:
print("1")
else:
if h_odd == 1:
H += 1
print(W * H//2 - int(W//2 + 2**-1) * h_odd)
| 1 | 50,933,465,558,514 | null | 196 | 196 |
n, m, l = map(int, input().split())
a = [[int(num) for num in input().split()] for i in range(n)]
b = [[int(num) for num in input().split()] for i in range(m)]
c = [[0 for i in range(l)] for j in range(n)]
for i in range(l):
for j in range(n):
for k in range(m):
c[j][i] += a[j][k] * b[k][i]
for i in range(n):
for j in range(l):
if j == l - 1:
print(c[i][j])
else:
print("{0} ".format(c[i][j]), end = "") | if __name__ == '__main__':
n, m, l = [int(i) for i in input().split()]
A = [[int(i) for i in input().split()] for j in range(n)]
B = [[int(i) for i in input().split()] for j in range(m)]
B = list(map(list, zip(*B))) # trace
C = [[sum(map(lambda x,y: x*y, A[i], B[j])) for j in range(l)] for i in range(n)]
for i in C:
print(' '.join([str(x) for x in i])) | 1 | 1,418,591,396,768 | null | 60 | 60 |
n, m, l = map(int, input().split())
A = [[int(num) for num in input().split()] for i in range(n)]
B = [[int(num) for num in input().split()] for i in range(m)]
B = list(zip(*B)) # 列を行に置き換える
C = [[0 for i in range(l)] for j in range(n)]
for i, A_line in enumerate(A):
for j, B_line in enumerate(B):
for A_element, B_element in zip(A_line, B_line):
C[i][j] += A_element * B_element
for line in C:
for i, element in enumerate(line):
if i == l - 1:
print(element)
else:
print(element, end=' ')
| import re
import copy
pattern = r'([0-9])'
repatter = re.compile(pattern)
n = int(input())
text = input()
*lists, = text.split(" ")
lists2 = copy.copy(lists)
lists3 = copy.copy(lists)
# バブルソート
def bubble_sort(a):
flag = 1
i = 0
while flag:
flag = 0
for j in range(n-1, i, -1):
x = repatter.findall(a[j])
y = repatter.findall(a[j-1])
if x < y:
a[j], a[j-1] = a[j-1], a[j]
flag = 1
i += 1
print(*a)
print("Stable")
# 選択ソート
def select_sort(a):
for i in range(n):
min_j = i
for j in range(i+1, n):
x = repatter.findall(a[j])
y = repatter.findall(a[min_j])
if x < y:
min_j = j
a[i], a[min_j] = a[min_j], a[i]
print(*a)
def isStable(before, after):
flag = True
for i in range(n):
for j in range(i+1, n):
for a in range(n):
for b in range(a+1, n):
x = repatter.findall(before[i])
y = repatter.findall(before[j])
if x == y and before[i] == after[b] and before[j] == after[a]:
flag = False
if flag is True:
print("Stable")
else:
print("Not stable")
bubble_sort(lists)
select_sort(lists2)
isStable(lists3, lists2)
| 0 | null | 722,886,498,382 | 60 | 16 |
def insertion_sort(a, n, g, cnt):
for i in range(g,n,1):
v = a[i]
j = i - g #initial value
while j>=0 and a[j]>v:
a[j+g]=a[j]
j -= g
cnt += 1
a[j+g] = v
return a, cnt
def shell_sort(a,n,m,g):
cnt = 0
for i in range(m):
sorted_list, cnt = insertion_sort(a,n,g[i],cnt)
return sorted_list, cnt
def seqforshell(n):
seq = [1]
next_num = 3*seq[0] + 1
while next_num<n:
seq.insert(0, next_num)
next_num = 3*next_num + 1
return seq
if __name__ == "__main__":
a = []
n = int(input())
for i in range(n):
a.append(int(input()))
g = seqforshell(n)
m = len(g)
res, cnt = shell_sort(a,n,m,g)
print(m)
print(*g)
print(cnt)
for i in range(n):
print(res[i])
| #coding:utf-8
#1_4_C 2015.3.29
while True:
data = input()
if '?' in data:
break
print(eval(data.replace('/','//'))) | 0 | null | 356,270,646,128 | 17 | 47 |
N = int(input())
A = list(map(int,input().split()))
#t: 1, 2, 3,..., N
#A: A1,A2,A3,...,AN
#|t-s| = At+As となるt,sのペアの数は、
# t-s = At+As かつ t>s となるt,sのペアの数と等しく、
# t-At = s+As かつ t>s となるt,sのペアの数と等しい
ms = [0]*N
ps = [0]*N
for i in range(N):
ms[i],ps[i] = (i+1)-A[i],(i+1)+A[i]
msc,psc = {},{}
mi,pi = 0,0
out = 0
while mi<N:
msc[ms[mi]] = msc.get(ms[mi],0)+1
out += psc.get(ms[mi],0)
psc[ps[mi]] = psc.get(ps[pi],0)+1
mi+=1
pi+=1
print(out) | n =raw_input()
m =n.split(" ")
a = int(m[0])
b = int(m[1])
if a < b :print "a < b"
if a > b :print "a > b"
if a == b :print "a == b" | 0 | null | 13,115,092,902,252 | 157 | 38 |
import sys
input = sys.stdin.readline
S = input()
T = input()
S = S.replace('\n','')
T = T.replace('\n','')
s_list = list(S)
t_list = list(T)
itti = 0
min_count = 10**5
for i in range(len(s_list)):
if i + len(t_list) > len(s_list):
break
count = 0
for j in range(len(t_list)):
if not s_list[i+j] == t_list[j]:
count += 1
min_count = min(count,min_count)
print(min_count) | s = input()
t = input()
ans = 1e+9
for si in range(len(s)):
if si + len(t) > len(s):
continue
cnt = 0
for ti in range(len(t)):
if s[si+ti] != t[ti]:
cnt += 1
ans = min(ans, cnt)
print(ans) | 1 | 3,667,113,362,458 | null | 82 | 82 |
#!/usr/bin/env python3
import sys
from itertools import chain
# form bisect import bisect_left, bisect_right, insort_left, insort_right
# from collections import Counter
# import numpy as np
def solve(N: int, K: int, p: "List[int]"):
p = sorted(p)
return sum(p[:K])
def main():
tokens = chain(*(line.split() for line in sys.stdin))
# N, K, p = map(int, line.split())
N = int(next(tokens)) # type: int
K = int(next(tokens)) # type: int
p = [int(next(tokens)) for _ in range(N)] # type: "List[int]"
answer = solve(N, K, p)
print(answer)
if __name__ == "__main__":
main()
| n,k = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())))[::-1]
o = []
for a,f in zip(A,F):
o.append(a*f)
ok = max(o)
ng = -1
while ok - ng > 1:
mid = (ok+ng)//2
k1 = 0
for i in range(n):
k1 += max( 0 , A[i]- mid//F[i])
if k1<= k:
ok = mid
else:
ng = mid
print(ok)
| 0 | null | 87,949,782,771,872 | 120 | 290 |
(a,b)=[int(x) for x in input().split()]
(c,d)=[int(x) for x in input().split()]
if d == 1:
print(1)
else:
print(0) | m1,d1 = map(int,input().split())
m2,d2 = map(int,input().split())
print(1 if m1!=m2 else 0)
| 1 | 123,897,554,184,832 | null | 264 | 264 |
import math
n = int(input())
x = list(map(int,input().split()))
y = list(map(int,input().split()))
p1 = p2 = p3 = p = 0
for x,y in zip(x,y):
d = abs(x-y)
p1 += d
p2 += d**2
p3 += d**3
if d>p: p = d
print('{0:.5f}\n{1:.5f}\n{2:.5f}\n{3:.5f}'.format(p1,math.sqrt(p2),math.pow(p3,1/3),p))
| a,b=map(int,input().split())
List = list(map(int, input().split()))
wa = 0
for i in range(b):
wa += List[i]
res = a - wa
if res < 0:
res = -1
print(res) | 0 | null | 16,198,539,591,200 | 32 | 168 |
sec=int(input())
print(":".join(map(str, [int(sec/3600), int(sec/60)%60, sec%60]))) | S = input()
K = int(input())
length = len(S)
num_fixed = 0
pre_char = ''
count = 0
for i in range(length):
now_char = S[i]
if pre_char != now_char:
num_fixed += count//2
count = 0
count += 1
pre_char = now_char
# print("pre_char:{}, now_char:{}, count:{}".format(pre_char, now_char, count))
num_fixed += count//2
# print(num_fixed)
if S[0] == S[length - 1]:
head_length = 1
head_char = S[0]
for i in range(1, length):
now_char = S[i]
if now_char != head_char:
break
head_length += 1
tail_length = 1
tail_char = S[length - 1]
for i in range(1, length):
now_char = S[length - 1 - i]
if now_char != tail_char:
break
tail_length += 1
if length == head_length == tail_length:
ans = length * K // 2
else:
ans = K * num_fixed - (K - 1) * (head_length // 2 + tail_length // 2 - (head_length + tail_length) // 2)
else:
ans = num_fixed * K
print(ans)
| 0 | null | 87,917,695,249,440 | 37 | 296 |
n, k = map(int, input().split())
okashi = []
for _ in range(2 * k):
okashi.append(list(map(int, input().split())))
flag = [0] * n
for i in range(int(len(okashi) / 2)):
i = 2 * i + 1
for j in okashi[i]:
flag[j-1] = 1
count = 0
for i in flag:
if i == 0:
count += 1
print(count) | def main():
a, b, c, k = map(int, input().split())
if a + b >= k:
print(min(a, k))
else:
print(a-(k-a-b))
if __name__ == "__main__":
main() | 0 | null | 23,324,274,503,250 | 154 | 148 |
from decimal import Decimal
a,b,c=map(Decimal,input().split())
if (a.sqrt()+b.sqrt())<c.sqrt():
print("Yes")
else:
print("No") | import math
if __name__ == '__main__':
x1, y1, x2, y2 = [float(i) for i in input().split()]
d = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
print("{0:.5f}".format(d)) | 0 | null | 25,733,807,572,330 | 197 | 29 |
import sys
sys.setrecursionlimit(10 ** 6)
int1 = lambda x: int(x) - 1
p2D = lambda x: print(*x, sep="\n")
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def SI(): return sys.stdin.readline()[:-1]
def solve():
dp0 = [0] * (w + 1)
dp1 = [0] * (w + 1)
dp2 = [0] * (w + 1)
dp3 = [0] * (w + 1)
for i in range(h):
for j in range(w):
v = vv[i * w + j]
if v:
dp3[j] = max(dp3[j], dp2[j] + v)
dp2[j] = max(dp2[j], dp1[j] + v)
dp1[j] = max(dp1[j], dp0[j] + v)
dp3[j + 1] = max(dp3[j + 1], dp3[j])
dp2[j + 1] = max(dp2[j + 1], dp2[j])
dp1[j + 1] = max(dp1[j + 1], dp1[j])
dp0[j] = max(dp1[j], dp2[j], dp3[j])
print(dp0[-2])
h, w, k = MI()
vv = [0] * h * w
for _ in range(k):
i, j, v = MI()
i, j = i - 1, j - 1
vv[i * w + j] = v
solve()
| # -*- coding: utf-8 -*-
n = int(raw_input())
dic = set()
for i in range(n):
com, s = map(str, raw_input().split())
if com == "insert":
dic.add(s)
elif com == "find":
if s in dic:
print "yes"
else:
print "no" | 0 | null | 2,864,256,159,678 | 94 | 23 |
#!/usr/bin/env python3
import sys
def solve(S: str, T: str):
min_change = 100000000
S = [s for s in S]
T = [t for t in T]
for i, s in enumerate(S):
for j, t in enumerate(T):
if j == 0:
c = 0
if len(S) <= i + j:
break
if S[i+j] != t:
c += 1
if len(T) == j + 1:
min_change = min(min_change, c)
print(min_change)
return
# Generated by 1.1.7.1 https://github.com/kyuridenamida/atcoder-tools (tips: You use the default template now. You can remove this line by using your custom template)
def main():
def iterate_tokens():
for line in sys.stdin:
for word in line.split():
yield word
tokens = iterate_tokens()
S = next(tokens) # type: str
T = next(tokens) # type: str
solve(S, T)
if __name__ == '__main__':
main()
| N = int(input())
A = list(map(int, input().split()))
if len(A) > len(set(A)):
print("NO")
else:
print("YES") | 0 | null | 38,889,534,293,990 | 82 | 222 |
N=int(input())
*A,=map(int,input().split())
ans=0
p=A[0]
for i in range(1,N):
if A[i]<p:
ans+=p-A[i]
else:
p=A[i]
print(ans) | N = int(input())
S, T = input().split()
ans = ''
for s, t in zip(S, T):
ans += s
ans += t
print(ans)
| 0 | null | 58,361,261,937,608 | 88 | 255 |
N = int(input())
P = tuple(map(int, input().split()))
minp = P[0]
ans = 1
for i in range(1, N):
if P[i] <= minp:
ans += 1
minp = min(minp, P[i])
print(ans) | def main():
n = int(input())
p = [int(i) for i in input().split()]
Min = [10**9]
ans = 0
for i in range(n):
Min.append(min(Min[-1],p[i]))
for i in range(n):
if Min[i]>p[i]:
ans += 1
print(ans)
main() | 1 | 85,391,186,367,718 | null | 233 | 233 |
from math import sqrt as s
N = int(input())
x, y = [], []
for i in range(1, int(s(N))+1):
if N % i == 0:
x.append(i)
y.append(N // i)
ans, M = float("INF"), len(x)
for i in range(M):
ans = min(ans, x[i] + y[i] - 2)
print(ans) | s = input()
moji = len(s)
if moji % 2 == 0:
moji = int(moji/2)
else:
moji = int((moji-1)/2)
answer = 0
for i in range(moji):
if s[i] != s[len(s)-1-i]:
answer += 1
print(answer) | 0 | null | 140,392,856,472,390 | 288 | 261 |
#!/usr/bin/env python3
from functools import reduce
x, y = map(int, input().split())
mod = 10**9 + 7
def cmb(n, r, m):
def mul(a, b):
return a * b % m
r = min(n - r, r)
if r == 0:
return 1
over = reduce(mul, range(n, n - r, -1))
under = reduce(mul, range(1, r + 1))
return (over * pow(under, m - 2, m))%m
r = abs(x - y)
l = (min(x, y) - r) // 3
r += l
if (x+y)%3 < 1 and l >= 0:
print(cmb(r + l, l, mod))
else:
print(0)
| #####################################################
# 組み合わせを10**9+7で割った余り、を高速に求めるアルゴリズム
# https://drken1215.hatenablog.com/entry/2018/06/08/210000
# https://qiita.com/derodero24/items/91b6468e66923a87f39f
# 全然理解できていない
MOD = 10**9 + 7
def comb(n, r):
if (r < 0 and r > n):
return 0
r = min(r, n - r)
return g1[n] * g2[r] * g2[n - r] % MOD
N = 10**6
# 元テーブル
g1 = [1, 1]
# 逆元テーブル
g2 = [1, 1]
# 逆元テーブル計算用テーブル
inverse = [0, 1]
for i in range(2, N + 1):
g1.append((g1[-1] * i) % MOD)
inverse.append((-inverse[MOD % i] * (MOD // i)) % MOD)
g2.append((g2[-1] * inverse[-1]) % MOD)
#####################################################
X, Y = map(int, input().split())
# X+Yが3の倍数のマスしか通りえない
if not (X + Y) % 3:
# (1,2)移動をn回、(2,1)移動をm回したとする
# n+2m = X, 2n+m = Y
# → n+m = (X+Y)/3
# n = (2n+m)-(n+m) = X - (X+Y)/3 = (-X+2Y)/3
# mも同様
n = (2 * Y - X) // 3
m = (2 * X - Y) // 3
if n >= 0 and m >= 0:
print(comb(n + m, n))
else:
print(0)
# X+Yが3の倍数でない場合
else:
print(0)
| 1 | 149,945,778,369,930 | null | 281 | 281 |
S, T = input().split()
A, B = input().split()
U = input()
if S==U:
print(int(A)-1,end=" ")
print(int(B))
else:
print(int(A),end=" ")
print(int(B)-1) | 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)) | 1 | 71,583,640,101,650 | null | 220 | 220 |
n = int(input())
ai = list(map(int, input().split()))
# n=3
# ai = np.array([1, 2, 3])
# ai = ai[np.newaxis, :]
#
# ai2 = ai.T.dot(ai)
# ai2u = np.triu(ai2, k=1)
#
# s = ai2u.sum()
l = len(ai)
integ = [ai[0]] * len(ai)
for i in range(1, len(ai)):
integ[i] = integ[i-1] + ai[i]
s = 0
for j in range(l):
this_s = integ[-1] - integ[j]
s += ai[j] * this_s
ans = s % (1000000000 + 7)
print(ans)
| from bisect import bisect_left
n = int(input())
l = list(map(int, input().split()))
l.sort()
ans = 0
for i in range(n):
for j in range(i + 1, n):
k = l[i] + l[j]
pos = bisect_left(l, k)
ans += max(0, pos - j - 1)
print(ans) | 0 | null | 88,034,849,139,900 | 83 | 294 |
s = list(str(input()))
q = int(input())
flag = 1
from collections import deque
s = deque(s)
for i in range(q):
query = list(map(str, input().split()))
if len(query) == 1:
flag = 1-flag
else:
t, f, c = query
if f == '1':
if flag:
s.appendleft(c)
else:
s.append(c)
else:
if flag:
s.append(c)
else:
s.appendleft(c)
s = list(s)
if not flag:
s.reverse()
print(''.join(s))
| from math import pow
print(int(pow(int(input()),2))) | 0 | null | 100,759,676,245,190 | 204 | 278 |
s, t = map(str, input().split())
print('{}{}'.format(t, s)) | import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
s, t = input().split()
print(t, end="")
print(s)
main()
| 1 | 102,958,071,273,600 | null | 248 | 248 |
ini = lambda : int(input())
inm = lambda : map(int,input().split())
inl = lambda : list(map(int,input().split()))
gcd = lambda x,y : gcd(y,x%y) if x%y else y
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
def make_divisors(n):
divisors = []
for i in range(1, int(n**0.5)+1):
if n % i == 0:
divisors.append(i)
if i != n // i:
divisors.append(n//i)
divisors.sort()
return divisors
#code-------------------------------------------------
x = ini()
for b in range(-121,121):
for a in range(b,121):
if (a ** 5) - (b ** 5) == x:
break
else:
continue
break
print(a,b) | def divisor(n):
result = []
i = 1
while True:
if i * i > n:
break
if n % i == 0:
result.append(i)
if i != int(n / i):
result.append(int(n / i))
i += 1
return result
def calc(a, b):
return a * a * a * a * a - b * b * b * b * b
MX = 100000
INF = int(MX**6)
def main():
X = int(input())
drs = divisor(X)
for dr in drs:
right = MX - dr
left = -MX
while right - left > 8:
bp = int(left + (right - left) / 3)
bq = int(left + 2 * (right - left) / 3)
cp = calc(bp + dr, bp)
cq = calc(bq + dr, bq)
if cp > cq:
left = bp
else:
right = bq
mn = INF
mnb = -2 * MX
for bi in range(left - 64, right + 64):
c = calc(bi + dr, bi)
if mn > c:
mnb = bi
mn = c
left = mnb
right = MX - dr
while left <= right:
b = int((left + right) / 2)
c = calc(b + dr, b)
if c == X:
print(b + dr, b)
return
elif c < X:
left = b + 1
else:
right = b - 1
left = -MX
right = mnb
while left <= right:
b = int((left + right) / 2)
c = calc(b + dr, b)
if c == X:
print(b + dr, b)
return
elif c < X:
left = b + 1
else:
right = b - 1
main()
| 1 | 25,450,573,148,822 | null | 156 | 156 |
S, W = map(int, input().split())
print(["safe", "unsafe"][S <= W]) | S,W = map(int, input().split())
print('safe' if W < S else 'unsafe') | 1 | 29,119,719,279,738 | null | 163 | 163 |
import numpy as np
N,M,X = map(int,input().split())
C = []
A = []
for _ in range(N):
l = list(map(int,input().split()))
C.append(l[0])
A.append(np.array(l[1:]))
ans = 10**100
for i in range(2**N):
rikaido = np.zeros(M)
c = 0
for j in range(N):
if (i >> j) & 1:
c += C[j]
rikaido += A[j]
if all([x >= X for x in rikaido]):
ans = min(ans, c)
print(ans if ans != 10**100 else -1) |
def main():
n, m, x = map(int, input().split(" "))
ca =[]
a = []
c = []
INF = 1e7
ans = INF
for i in range(n):
ca.append(list(map(int, input().split(" "))))
for i in range(n):
c.append(ca[i][0])
a.append(ca[i][1:])
for i in range(1<<n):
a_sum = [0]*m
c_sum = 0
for j in range(n):
if i >> j & 1 == 1:
for k in range(m):
a_sum[k] += a[j][k]
c_sum += c[j]
if min(a_sum) >= x and c_sum < ans:
ans = c_sum
if ans == INF:
print(-1)
else:
print(ans)
if __name__ == "__main__":
main() | 1 | 22,239,066,072,960 | null | 149 | 149 |
n = int(input())/3
print(n*n*n) | # -*- coding: utf-8 -*-
L = int(input())
x = L * (10 ** 7) / 3
print(x**3 / (10 ** 21)) | 1 | 46,735,799,536,648 | null | 191 | 191 |
n = int(input())
cnt = 0
for i in range(1, n//2+1):
if i != n - i and n - i > 0:
cnt += 1
print(cnt)
| a=int(input())
print((a-1)//2) | 1 | 152,692,874,561,260 | null | 283 | 283 |
t = input()
ans = []
for i in range(len(t)):
if t[i] == '?':
ans.append('D')
else:
ans.append(t[i])
print(''.join(ans)) | s=input()
s=s.replace('?','D')
print(s)
| 1 | 18,511,619,619,464 | null | 140 | 140 |
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf
from itertools import accumulate,groupby,permutations,combinations,product,combinations_with_replacement
from collections import deque,defaultdict,Counter
from bisect import bisect_left,bisect_right
from operator import itemgetter
from heapq import heapify,heappop,heappush
from queue import Queue,LifoQueue,PriorityQueue
from copy import deepcopy
from time import time
from functools import reduce
import string
import sys
sys.setrecursionlimit(10 ** 7)
def input() : return sys.stdin.readline().strip()
def INT() : return int(input())
def MAP() : return map(int,input().split())
def MAP1() : return map(lambda x:int(x)-1,input().split())
def LIST() : return list(MAP())
class UnionFind():
def __init__(self, n):
self.n = n
self.parents = [-1] * n
def find(self, x):
if self.parents[x] < 0:
return x
else:
self.parents[x] = self.find(self.parents[x])
return self.parents[x]
def union(self, x, y):
x = self.find(x)
y = self.find(y)
if x == y:
return
if self.parents[x] > self.parents[y]:
x, y = y, x
self.parents[x] += self.parents[y]
self.parents[y] = x
def size(self, x):
return -self.parents[self.find(x)]
def same(self, x, y):
return self.find(x) == self.find(y)
def members(self, x):
root = self.find(x)
return [i for i in range(self.n) if self.find(i) == root]
def roots(self):
return [i for i, x in enumerate(self.parents) if x < 0]
def group_count(self):
return len(self.roots())
def all_group_members(self):
return {r: self.members(r) for r in self.roots()}
def __str__(self):
return '\n'.join('{}: {}'.format(r, self.members(r)) for r in self.roots())
def solve():
N, M, K = MAP()
F = [[] for _ in range(N)]
B = [[] for _ in range(N)]
uf = UnionFind(N) # 初期化
for i in range(M):
a, b = MAP()
F[a-1].append(b-1)
F[b-1].append(a-1)
uf.union(a-1, b-1) # グループを併合
for i in range(K):
c, d = MAP()
B[c-1].append(d-1)
B[d-1].append(c-1)
for i in range(N):
ans = uf.size(i) - len(F[i]) - 1
for x in B[i]:
if uf.same(i, x):
ans -= 1
print(ans)
if __name__ == '__main__':
solve() | n, m, k = map(int, input().split())
#Union-Find
def find(x):
if par[x] < 0:
return x
else:
par[x] = find(par[x])
return par[x]
def unite(x, y):
p = find(x)
q = find(y)
if p == q:
return None
if p > q:
p,q = q,p
par[p] += par[q]
par[q] = p
def same(x, y):
return find(x) == find(y)
def size(x):
return -par[find(x)]
par = [-1 for i in range(n)]
l = [0] * n
for i in range(m):
a, b = map(int, input().split())
unite(a-1, b-1)
l[a-1] += 1
l[b-1] += 1
for i in range(k):
c, d = map(int, input().split())
if same(c-1, d-1):
l[c-1] += 1
l[d-1] += 1
for i in range(n):
print(size(i) - l[i] - 1, end=" ") | 1 | 61,673,797,031,368 | null | 209 | 209 |
a,b=map(int,input().split())
m=min(a,b)
kouyakusuu=1
for i in range(1,m+1):
if a%i==0 and b%i==0:
kouyakusuu=i
print(a*b//kouyakusuu) | import math
def lcm(A, B):
return int((A * B) / math.gcd(A, B))
A, B = map(int, input().split())
print(lcm(A,B)) | 1 | 113,693,788,361,362 | null | 256 | 256 |
N, M = map(int, input().split())
S = input()
lst = []
i = N
while i > 0:
for j in range(min(i, M), 0, -1):
if S[i - j] == '0':
lst.append(j)
i -= j
break
else:
print(-1)
exit()
print(' '.join(map(str, reversed(lst))))
| from bisect import bisect_left
N, M = map(int, input().split())
s = input()
safe = []
cnt = 0
for i, m in enumerate(s):
if m=='1':
cnt += 1
if cnt==M:
print(-1)
break
else:
safe += [i]
cnt = 0
else:
ps = N
ans = []
while ps!=0:
ind = bisect_left(safe,ps-M)
ans += [ps-safe[ind]]
ps = safe[ind]
print(*ans[::-1])
| 1 | 139,406,260,433,708 | null | 274 | 274 |
import math
N = int(input())
# A = list(map(int, input().split()))
A = [int(x) for x in input().split(' ')]
a_max = [0] * (N+1)
a_min = [0] * (N+1)
a = [0] * (N+1)
#１．可・不可の判定
# 最下段からとりうる個数の範囲を考える
#0段目の範囲に１が含まれないならば”不可”(根＝１)
for i in range(N+1):
if i == 0:
a_max[N-i] = A[N-i]
a_min[N-i] = A[N-i]
else:
a_max[N-i] = a_max[N-i+1] + A[N-i]
a_min[N-i] = math.ceil(a_min[N-i+1]/2) + A[N-i]
#check print
# for i in range(N+1):
# print(str(i) + ':----')
# print(a_min[i],a_max[i])
#最上段から個数のカウント
for i in range(N+1):
if i == 0:
a[i] = 1
else:
a[i] = min((a[i-1] - A[i-1])*2 , a_max[i])
#不可は-1を、可は個数の合計を
if a_min[0] > 1:
print(-1)
else:
print(sum(a))
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from itertools import accumulate
n = int(readline())
a = list(map(int, readline().split()))
cumsum = list(accumulate(a[::-1]))
ans = 0
check = 1
for aa, v in zip(a, cumsum[::-1]):
if aa > check:
print(-1)
exit()
else:
ans += min(check, v)
check -= aa
check *= 2
print(ans)
| 1 | 18,936,583,465,402 | null | 141 | 141 |
from math import gcd
def lcm(a, b):
return a * b / gcd(a, b)
x = int(input())
ans = int(lcm(360, x) // x)
print(ans) | n = int(input())
a = [int(i) for i in input().split()]
summ = 0
for i in range(n):
summ += a[i]
a.sort()
print(str(a[0])+" "+str(a[n-1])+" "+str(summ)) | 0 | null | 6,928,838,069,088 | 125 | 48 |
k=int(input())
if k==1:
print('ACL')
elif k==2:
print('ACLACL')
elif k==3:
print('ACLACLACL')
elif k==4:
print('ACLACLACLACL')
elif k==5:
print('ACLACLACLACLACL') | from bisect import bisect_left
N = int(input())
L = list(map(int, input().split()))
L.sort()
ans = 0
for i in range(N):
for j in range(i + 1, N):
c = L[i] + L[j]
# a+bが入る場所を返す
idx = bisect_left(L, c)
ans += max(0, idx - (j + 1))
print(ans)
| 0 | null | 87,148,557,604,640 | 69 | 294 |
s=list(input().split())
a=[]
for x in s:
if x in ['+','-','*']:
c,b=str(a.pop()),str(a.pop())
b+=x+c
a+=[int(eval(b))]
else:a+=[int(x)]
print(a.pop()) | class Stack:
# ???????????????????????§??????top??????????????????????????????Max???isFull??¨????????????stack???????????????????????§???
def __init__(self):
self.top = 0
self.Max = 100
self.stack = [None]
def isEmpty(self):
return self.top == 0
def isFull(self):
return self.top >= self.Max
def push(self, x):
if self.isFull():
print("Stack overflow!")
else:
self.top += 1
self.stack.append(x)
def pop(self):
if self.isEmpty():
print("Stack underflow!")
else:
self.top -= 1
return self.stack.pop()
d_e = input().split()
accumlator = Stack()
for i in d_e:
if i in "+-*":
post_op = accumlator.pop()
pre_op = accumlator.pop()
ans = eval(pre_op + i + post_op)
accumlator.push(str(ans))
else:
accumlator.push(i)
print(int(accumlator.pop())) | 1 | 37,793,893,060 | null | 18 | 18 |
n=int(input())
alist=list(map(int,input().split()))
height=alist[0]
ans=0
for i in range(1,n):
if height>alist[i]:
ans+=height-alist[i]
else:
height=alist[i]
print(ans) | n=int(input())
a=[int(k) for k in input().split()]
sum=0;
max=a[0];
for aa in a:
if aa<max:
sum=sum+max-aa
else:
max=aa
print(sum) | 1 | 4,584,276,116,010 | null | 88 | 88 |
'''
Online Python Compiler.
Code, Compile, Run and Debug python program online.
Write your code in this editor and press "Run" button to execute it.
'''
ip=list(input())
sum=0
for i in ip:
sum+=int(i)
if sum%9==0:
print('Yes')
else:
print('No') | def main():
if sum(list(map(int, list(input())))) % 9:
print("No")
else:
print("Yes")
main()
| 1 | 4,375,286,421,632 | null | 87 | 87 |
n = int(input())
arr = list(map(int,input().split()))
addarr = [i+1+arr[i] for i in range(n)]
diffarr = [i+1-arr[i] for i in range(n)]
from collections import Counter
cnt = Counter([addarr[0]])
ans = 0
for i in range(1,n):
tmp = diffarr[i]
ans += cnt[tmp]
cnt.update([addarr[i]])
print(ans) | from collections import Counter
n=int(input())
a=list(map(int,input().split()))
i_l=[]
j_l=[]
for i in range(n):
i_l.append(i+a[i])
j_l.append(i-a[i])
ci=Counter(i_l)
cl=Counter(j_l)
ans=0
for k,v in ci.items():
ans+=v*cl[k]
print(ans) | 1 | 25,881,283,185,790 | null | 157 | 157 |
from sys import stdin
def main():
n, r = map(int, stdin.readline().split())
if n >= 10:
print(r)
else:
print(r + 100 * (10 - n))
if __name__ == "__main__":
main() | N,P=map(int, input().split())
if N<=9:
print(100*(10-N)+P)
else:
print(P) | 1 | 63,460,240,782,760 | null | 211 | 211 |
a = input().split()
if int(a[0])*500 < int(a[1]):
print("No")
else:
print("Yes") | import math
k, x = map(int, input().split(" "))
if 500 * k >= x:
print("Yes")
else:
print("No") | 1 | 98,140,412,907,942 | null | 244 | 244 |
if __name__ == "__main__":
inp = input()
a = []
ans = []
total = 0
for i in range(len(inp)):
if inp[i] == "\\":
a.append(i)
elif inp[i] == "/":
if len(a) != 0:
x = a.pop()
d = i - x
total += d
while len(ans) != 0 and ans[-1][0] > x:
d += ans[-1][1]
ans.pop()
ans.append([x, d])
print(total)
if total == 0:
print(0)
else:
print(str(len(ans))+" "+(" ".join(map(str, [x[1] for x in ans])))) | import bisect
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
max_books = 0
sum_a = []
sum_b = []
total = 0
for i in range(n):
total += a[i]
sum_a.append(total)
total = 0
for j in range(m):
total += b[j]
sum_b.append(total)
sum_a.insert(0, 0)
sum_b.insert(0, 0)
for i in range(n+1):
r = k - sum_a[i]
if r == 0:
books = i
elif r < 0:
books = 0
else:
book_b = bisect.bisect_right(sum_b, r)
books = i + book_b - 1
if books >= max_books:
max_books = books
print(max_books)
| 0 | null | 5,427,183,316,100 | 21 | 117 |
import math
alpha = []
while True:
n = float(raw_input())
if n == 0:
break
nums_str = raw_input().split()
nums = []
for s in nums_str:
nums.append(float(s))
ave = sum(nums)/n
n_sum = 0.0
for num in nums:
n_sum += (num-ave)**2
alpha.append(n_sum/n)
for a in alpha:
print math.sqrt(a) | alphabetlist=['a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z']
N=int(input())
S=[0 for i in range(0,N)]
string=''
for i in range(0,N):
string+='a'
print(string)
digit=N-1
while True:
if digit!=0:
if S[digit]==max(S[0:digit])+1:
digit-=1
else:
S[digit]+=1
for j in range(digit+1,N):
S[j]=0
digit=N-1
if S[0]==1:
break
string=[0 for i in range(0,N)]
for i in range(0,N):
string[i]=alphabetlist[S[i]]
print(''.join(string))
else:
break | 0 | null | 26,095,634,688,420 | 31 | 198 |
N = int(input())
S = 0
for i in range(1, N + 1):
if i % 15 == 0:
S += 0
elif i % 3 == 0:
S += 0
elif i % 5 == 0:
S += 0
else:
S += i
print(S)
| A,B = map(int,input().split())
def gcd(a, b):
if b==0:
return a
return gcd(b, a%b)
print(A*B//gcd(A,B)) | 0 | null | 74,022,830,590,836 | 173 | 256 |
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 16 18:45:04 2017
@author: syaga
"""
if __name__ == "__main__":
n = int(input())
a = []
for i in range(n):
a.append(int(input()))
max = a[1] - a[0]
mini = a[0]
for i in range(1, len(a)):
diff = a[i] - mini
if diff > max:
max = diff
if mini > a[i]:
mini = a[i]
print(max) | def maximumProfit(A, N):
minR = A[0]
minP = A[1] - A[0]
for i in range(1, N):
R = A[i] - minR
if R > minP:
minP = R
if A[i] < minR:
minR = A[i]
return minP
if __name__ == "__main__":
N = input()
A = []
for i in range(N):
A.append(input())
print maximumProfit(A, N) | 1 | 12,846,313,970 | null | 13 | 13 |
import math
a = raw_input()
for i, b in enumerate(a.split()):
if i==0:
W=int(b)
elif i==1:
H=int(b)
elif i==2:
x=int(b)
elif i==3:
y=int(b)
else:
r=int(b)
if r<=x<=W-r and r<=y<=H-r:
print 'Yes'
else:
print 'No' | n = int(input())
a = map(int,input().split())
if len(set(a)) == n:
print("YES")
else:
print("NO") | 0 | null | 37,364,308,658,544 | 41 | 222 |
H, W = map(int, input().split())
stage = []
scores = []
for _ in range(H):
stage.append(list(input()))
scores.append([float('inf')] * W)
if stage[0][0] == '#':
scores[0][0] = 1
else:
scores[0][0] = 0
move = [[0, 1], [1, 0]]
for y in range(H):
for x in range(W):
for dx, dy in move:
nx, ny = x + dx, y + dy
if H <= ny or W <= nx:
continue
if stage[ny][nx] == '#' and stage[y][x] == '.':
scores[ny][nx] = min(scores[ny][nx], scores[y][x] + 1)
else:
scores[ny][nx] = min(scores[ny][nx], scores[y][x])
# print(*scores, sep='\n')
print(scores[-1][-1]) | import sys
input = sys.stdin.readline
H, W = map(int, input().split())
s = [input().rstrip() for _ in range(H)]
dp = [[1000]*W for _ in range(H)]
if s[0][0] == '#': dp[0][0] = 1
else: dp[0][0] = 0
for j in range(W):
for i in range(H):
if i <= H - 2:
if s[i][j] == '.' and s[i+1][j] == '#':
dp[i+1][j] = min(dp[i+1][j], dp[i][j] + 1)
else: dp[i+1][j] = min(dp[i+1][j], dp[i][j])
if j <= W - 2:
if s[i][j] == '.' and s[i][j+1] == '#':
dp[i][j+1] = min(dp[i][j+1], dp[i][j] + 1)
else: dp[i][j+1] = min(dp[i][j+1], dp[i][j])
print(dp[H-1][W-1]) | 1 | 49,500,699,089,780 | null | 194 | 194 |
n=int(input())
s = [input() for i in range(n)]
s.sort()
ans=n
for i in range(1,n):
if s[i]==s[i-1]:
ans-=1
print(ans) | N = int(input())
s = set([])
for i in range(N):
str_ = input()
s.add(str_)
print(len(s))
| 1 | 30,225,075,773,078 | null | 165 | 165 |
n=int(input())
lis=[]
count=0
high=0
for _ in range(n):
lis.append(input().split())
lis.append([5,6])
for i in range(n+1):
if lis[i][0]==lis[i][1]:
count+=1
else:
if count>=high:
high=count
count=0
if high>=3:
print("Yes")
else:
print("No") | apple = [1, 2, 3]
apple.remove(int(input()))
apple.remove(int(input()))
print(apple[0]) | 0 | null | 56,333,792,939,072 | 72 | 254 |
import numpy as np
n,m,k = list(map(int, input().split()))
a_list = np.array(input().split()).astype(int)
b_list = np.array(input().split()).astype(int)
a_sum =[0]
b_sum=[0]
for i in range(n):
a_sum.append(a_sum[-1]+ a_list[i])
for i in range(m):
b_sum.append(b_sum[-1] + b_list[i])
#print(a_sum, b_sum)
total = 0
num = m
for i in range(n+1):
if a_sum[i] > k:
break
while (k - a_sum[i]) < b_sum[num]:
num -=1
#print(i, num)
if num == -1:
break
total = max(i+num, total)
print(total) | from bisect import bisect_right
def bisectsearch_right(L,a):
i=bisect_right(L,a)
return(i)
N,M,K= list(map(int, input().split()))
A= list(map(int, input().split()))
B= list(map(int, input().split()))
Asum=[0]*N
Bsum=[0]*M
Asum[0]=A[0]
Bsum[0]=B[0]
for i in range(1,N):
Asum[i]=Asum[i-1]+A[i]
for j in range(1,M):
Bsum[j]=Bsum[j-1]+B[j]
# print(Asum)
# print(Bsum)
ans=[0]*(N+1)
ans[0]=bisectsearch_right(Bsum,K)
# print(ans[0])
for i in range(1,N+1):
if Asum[i-1]>K:
continue
j=bisectsearch_right(Bsum,K-Asum[i-1])
# print(j)
ans[i]=i+j
# print(ans)
print(max(ans))
| 1 | 10,650,929,753,670 | null | 117 | 117 |
m1,d1 = map(int,input().split())
m2,d2 = map(int,input().split())
print(1 if m1!=m2 else 0)
| md1=list(map(int,input().split()))
md2=list(map(int,input().split()))
if md1[0]==md2[0]:
print(0)
else:
print(1) | 1 | 124,457,514,968,270 | null | 264 | 264 |
def main():
nums = list(map(int,input().split()))
for i,n in enumerate(nums):
if n == 0:
return i + 1
if __name__ == '__main__':
print(main()) | x = list(map(int, input().split()))
if x[0] == 0:
print('1')
elif x[1] == 0:
print('2')
elif x[2] == 0:
print('3')
elif x[3] == 0:
print('4')
else:
print('5') | 1 | 13,453,532,377,570 | null | 126 | 126 |
import math
import collections
import fractions
import itertools
import functools
import operator
import bisect
N = int(input())
def solve():
cnt = 0
for i in range(1, N):
cnt += (N-1)//i
print(cnt)
return 0
if __name__ == "__main__":
solve()
| import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
def main():
n = int(input())
r = 0
for i1 in range(1, n+1):
for i2 in range(1, n+1):
if i1 * i2 >= n:
break
else:
r += 1
print(r)
if __name__ == '__main__':
main()
| 1 | 2,576,551,966,794 | null | 73 | 73 |
M = 9
N = 9
def main():
for i in range(1,M+1,1):
for j in range(1,N+1,1):
mult = i * j
print(str(i) + "x" + str(j) + "=" + str(i * j))
main()
| for i in xrange(1, 10):
for j in xrange(1, 10):
print "%sx%s=%s" % (i,j, i*j) | 1 | 2,097,280 | null | 1 | 1 |
def main():
from sys import stdin
readline = stdin.readline
X = int(readline().rstrip())
if X >= 30:
print('Yes')
else:
print('No')
main() | a = int(input())
print('YNeos'[a<30::2])
| 1 | 5,687,389,185,960 | null | 95 | 95 |
N = int(input())
D = list(map(int, input().split()))
from itertools import combinations
ans = 0
for i , j in combinations(D,2):
ans += i*j
print(ans) | # Queue
class MyQueue:
def __init__(self):
self.queue = [] # list
self.top = 0
def isEmpty(self):
if self.top==0:
return True
return False
def isFull(self):
pass
def enqueue(self, x):
self.queue.append(x)
self.top += 1
def dequeue(self):
if self.top>0:
self.top -= 1
return self.queue.pop(0)
else:
print("there aren't enough values in Queue")
def main():
n, q = map(int, input().split())
A = [
list(map(lambda x: int(x) if x.isdigit() else x, input().split()))
for i in range(n)
]
A = [{'name': name, 'time': time} for name, time in A]
queue = MyQueue()
for a in A:
queue.enqueue(a)
elapsed = 0
while not queue.isEmpty():
job = queue.dequeue()
if job['time']>q:
elapsed += q
job['time'] = job['time'] - q
queue.enqueue(job)
else:
elapsed += job['time']
print(job['name']+ ' ' + str(elapsed))
main()
| 0 | null | 84,625,112,401,662 | 292 | 19 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
ans = 0
if N%2==1:
print(0)
exit(0)
for i in range(1, 40):
cnt = N//(5**i)
ans += cnt//2
print(ans) | N = int(input())
if N % 2 == 1:
print(0)
else:
i = 1
ans = 0
while 2*(5**i) <= N:
div = 2 * (5 ** i)
ans += int(N//div)
i += 1
print(ans) | 1 | 116,096,769,501,150 | null | 258 | 258 |
import sys
stdin = sys.stdin
inf = 1 << 60
mod = 1000000007
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()
from collections import defaultdict
n, p = na()
s = ns()
if 10 % p == 0:
ans = 0
for i in range(n - 1, -1, -1):
if int(s[i]) % p == 0:
ans += i + 1
print(ans)
exit(0)
c = [0] * (n + 1)
m = 1
for i in range(n - 1, -1, -1):
t = int(s[i]) * m % p
c[i] = (c[i + 1] + t) % p
m *= 10
m %= p
ans = 0
dic = defaultdict(int)
for i in range(n, -1, -1):
ans += dic[c[i]]
dic[c[i]] += 1
print(ans) | n,p=map(int,input().split())
s=list(map(int,list(input()[::-1])))
if p in [2,5]:
ans=0
for i in range(n):
if s[-i-1]%p==0:ans+=i+1
print(ans)
exit()
from collections import defaultdict
d=defaultdict(int)
t=0
d[t]+=1
m=1
for i in range(n):
t+=m*s[i]
t%=p
d[t]+=1
m*=10
m%=p
print(sum(d[i]*(d[i]-1)//2 for i in range(p))) | 1 | 58,476,135,886,308 | null | 205 | 205 |
#cやり直し
import numpy
n = int(input())
a = list(map(int, input().split()))
ans = 0
mod = 10**9 +7
before = a[-1]
for i in range(n-1,0,-1):
ans += (a[i-1]*before)%mod
before += a[i-1]
print(ans%mod) | import bisect, collections, copy, heapq, itertools, math, string, sys
input = lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**7)
INF = float('inf')
MOD = 10 ** 9 + 7
def I(): return int(input())
def F(): return float(input())
def SS(): return input()
def LI(): return [int(x) for x in input().split()]
def LI_(): return [int(x)-1 for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LSS(): return input().split()
def resolve():
N = I()
A = LI()
ans = (sum(A) ** 2 - sum([i ** 2 for i in A])) // 2 % MOD
print(ans)
if __name__ == '__main__':
resolve()
| 1 | 3,856,772,976,822 | null | 83 | 83 |
#!/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 list(map(list, input().split()))
def S(): return list(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 = float('INF')
#A
def A():
return
#B
def B():
return
#C
def C():
return
#D
def D():
return
#E
def E():
n, m, l = LI()
dist = [[inf] * n for i in range(n)]
for _ in range(m):
a, b, c = LI_()
c += 1
if c > l:
continue
dist[a][b] = c
dist[b][a] = c
supply = [[n] * n for i in range(n)]
for k in range(n):
distk = dist[k]
for i in range(n):
if i == k:
continue
disti = dist[i]
distik = dist[i][k]
for j in range(i + 1, n):
if distik + distk[j] < disti[j]:
disti[j] = distik + distk[j]
dist[j][i] = disti[j]
lis = [[] for i in range(n)]
for i in range(n):
for j in range(i + 1, n):
if dist[i][j] <= l:
supply[i][j] = 0
supply[j][i] = 0
lis[i].append(j)
lis[j].append(i)
for i in range(n):
q = []
for k in lis[i]:
heappush(q, (0, k))
supplyi = supply[i]
while q:
time, p = heappop(q)
for k in lis[p]:
if supplyi[k] > time + 1:
supplyi[k] = time + 1
heappush(q, (time + 1, k))
q = II()
for _ in range(q):
s, t = LI_()
if dist[s][t] == inf:
print(-1)
continue
else:
print(supply[s][t])
return
#F
def F():
return
#G
def G():
return
#H
def H():
return
#Solve
if __name__ == '__main__':
E()
| #!/usr/bin/env python3
# coding: utf-8
class Dice() :
mask = {'N':(1,5,2,3,0,4), 'E':(3,1,0,5,4,2),
'W':(2,1,5,0,4,3), 'S':(4,0,2,3,5,1)}
def __init__(self, data):
self.label = data
def move(self, data):
self.label = [self.label[idx] for idx in self.mask[data]]
def get_up(self):
return self.label[0]
dicedata = input().split()
orderdata = input()
newdice = Dice(dicedata)
[newdice.move(orderdata[idx]) for idx in range(0, len(orderdata))]
print(newdice.get_up())
| 0 | null | 86,627,672,684,252 | 295 | 33 |
a,b = map(int, input().split())
print(f'{a//b} {a%b} {(a/b):.6f}')
| n = int(input())
a = list(map(int,input().split()))
sa = sorted(a,reverse=True)
ans = sa[0]
i = 2
for v in sa[1:]:
if i >= n:
break
#print("i:{} ans:{}".format(i,ans))
ans += v
i += 1
if i >= n:
break
#print("i:{} ans:{}".format(i,ans))
ans += v
i += 1
print(ans)
| 0 | null | 4,892,933,127,588 | 45 | 111 |
n=int(input())
a=list(map(int, input().split()))
m=a[0]
ans=0
for i in range(n):
x=a[i]
if x<=m:
ans+=1
m=x
print(ans) | N=int(input())
L= list(map(int,input().split()))
L_sorted=sorted(L,reverse=False)#昇順
count=0
for i in range(N):
for j in range(i+1,N):
a=L_sorted[i]
b=L_sorted[j]
n=a+b
fin=N
sta=0
while sta+1<fin:
m=((fin-sta)//2)+sta
if L_sorted[m]<n:
sta=m
else:
fin=m
count+=sta-j
print(count) | 0 | null | 128,499,498,861,760 | 233 | 294 |
n, t = map(int, input().split())
lst = [0 for _ in range(t)]
ab = [list(map(int, input().split())) for _ in range(n)]
ab.sort()
ans = 0
for a, b in ab:
ans = max(ans, lst[-1] + b)
for i in range(t - 1, a - 1, -1):
lst[i] = max(lst[i], lst[i - a] + b)
print(ans) | import sys
import bisect
import itertools
import collections
import fractions
import heapq
import math
from operator import mul
from functools import reduce
from functools import lru_cache
def solve():
readline = sys.stdin.buffer.readline
mod = 10 ** 9 + 7
N, T = map(int, readline().split())
dishes = []
for _ in range(N):
A, B = map(int, readline().split())
dishes.append([A, B])
dp1 = [[0]*T for _ in range(N)] # i and less than i
dp2 = [[0]*T for _ in range(N+1)] # more than i
for i, dish in enumerate(dishes[:-1]):
a, b = dish
i = i + 1
for t in range(T):
if a > t:
dp1[i][t] = dp1[i-1][t]
else:
if dp1[i-1][t-a] + b > dp1[i-1][t]:
dp1[i][t] = dp1[i-1][t-a] + b
else:
dp1[i][t] = dp1[i-1][t]
for i, dish in enumerate(reversed(dishes[1:])):
a, b = dish
i = N - i - 1
for t in range(T):
if a > t:
dp2[i][t] = dp2[i+1][t]
else:
if dp2[i+1][t-a] + b > dp2[i+1][t]:
dp2[i][t] = dp2[i+1][t-a] + b
else:
dp2[i][t] = dp2[i+1][t]
ans = 0
for last in range(1, N+1):
for j in range(T):
a = dishes[last-1][1]
a += dp1[last-1][T-1-j] + dp2[last][j]
ans = a if ans < a else ans
print(ans)
if __name__ == '__main__':
solve() | 1 | 151,358,099,112,384 | null | 282 | 282 |
D = int(input())
cs = list(map(int, input().split()))
ss = [input().split() for l in range(D)]
ts = [int(input()) for i in range(D)]
ans=0
all_cs=sum(cs)
cs_last=[0]*26
def c0(d):
mainas=0
for i in range(26):
#print(cs[i]*(d-cs_last[i]))
mainas-=cs[i]*(d-cs_last[i])
return mainas
for i in range(D):
cs_last[ts[i]-1]=i+1
ans+=int(ss[i][ts[i]-1])+c0(i+1)
print(ans) | D = int(input())
C = list(map(int, input().split()))
S = [list(map(int, input().split())) for _ in range(D)]
T = [int(input()) for _ in range(D)]
v = 0
last = [0] * 26
for d in range(D):
# ct:current type
ct= T[d] - 1
last[ct] = d + 1
# 今回の満足度
v += S[d][ct]
# 不満度を引く
v -= sum([C[t] * (d + 1 - last[t]) for t in range(26)])
print(v) | 1 | 9,973,254,622,138 | null | 114 | 114 |
word = input()
start = 0
end = len(word)
while(True):
i = word.find('?', start, end)
if (i == -1):
break
elif (i == (end-1)):
word = word.replace('?', "D", 1)
elif (word[i-1] == 'P'):
word = word.replace('?', "D", 1)
elif ((word[i+1] == "?") or (word[i+1] == "D")):
word = word.replace('?', "P", 1)
else:
word = word.replace('?', "D", 1)
start = i + 1
print(word) | t = list(input())
tl = len(t)
for i in range(tl):
if t[i] != '?':
continue
if tl == 1:
t[i] = 'D'
elif i == tl - 1:
t[i] = 'D'
elif t[i-1] == 'P':
t[i] = 'D'
elif t[i+1] == '?':
t[i] = 'P'
elif t[i+1] == 'D':
t[i] = 'P'
else:
t[i] = 'D'
print(''.join(t))
| 1 | 18,560,446,527,688 | null | 140 | 140 |
import sys
def input(): return sys.stdin.readline().strip()
def mapint(): return map(int, input().split())
sys.setrecursionlimit(10**9)
N = int(input())
i = 1
ans = 0
while i**2<=N:
if N%i==0:
ans = (i+(N//i)-2)
i += 1
print(ans) | N,M = (int(x) for x in input().split())
AC = [False]*N
WA_count = [0]*N
AC_count = 0
for i in range(M):
p,S = (y for y in input().split())
if AC[int(p)-1] == False:
if S == 'AC':
AC[int(p)-1] = True
AC_count += 1
else:
WA_count[int(p)-1] += 1
for i in range(N):
if AC[i] == False:
WA_count[i] = 0
print(AC_count,sum(WA_count)) | 0 | null | 127,338,855,833,878 | 288 | 240 |
r = int(input())
print((r * 2) * 3.141592) | import math
n = int(input())
print(2 * n * math.pi) | 1 | 31,379,921,714,398 | null | 167 | 167 |
T=input()
for i in range(len(T)):
T=T.replace(T[i],'x')
print(T) | S = input()
N = len(S)
print("x" * N) | 1 | 72,661,101,845,760 | null | 221 | 221 |
N = int(input())
count = 0
for A in range(1, N):
N_ = (N - 1) // A
count += N_
print(count) | n=int(input())
s=input()
ans=0
r,g,b=0,0,0
for i in range(n):
if s[i]=="R":
r+=1
elif s[i]=="G":
g+=1
else:
b+=1
for i in range(1,n):
for j in range(i+1,n):
if (j-i)+j<=n:
k=(j-i)+j-1
if s[i-1]!=s[j-1] and s[j-1]!=s[k] and s[k]!=s[i-1]:
ans-=1
ans+=r*g*b
print(ans) | 0 | null | 19,274,969,861,072 | 73 | 175 |
from math import ceil
n = int(input())
a = list(map(int, input().split()))
a.reverse()
max_tree = [0] * (n+1)
min_tree = [0] * (n+1)
max_tree[0] = a[0]
min_tree[0] = a[0]
for i in range(1, n+1):
max_tree[i] = max_tree[i-1] + a[i]
min_tree[i] = ceil(min_tree[i-1]/2) + a[i]
max_tree.reverse()
min_tree.reverse()
if min_tree[0] > 1:
print(-1)
exit()
a.reverse()
possible = [0] * (n+1)
possible[0] = 1
for i in range(1, n+1):
possible[i] = min((possible[i-1]-a[i-1])*2, max_tree[i])
print(sum(possible))
| from collections import deque
S = deque(input())
Q = int(input())
is_reversed = False
for _ in range(Q):
Query = input().split()
if Query[0] == "1":
is_reversed = not is_reversed
else:
F, C = int(Query[1]), Query[2]
if is_reversed:
F = 3 - F
if F == 1:
S.appendleft(C)
else:
S.append(C)
if is_reversed:
S.reverse()
print("".join(S))
| 0 | null | 37,994,304,398,846 | 141 | 204 |
N, K, S = map(int, input().split())
ans = []
n = N-K
for i in range(K):
ans.append(S)
for i in range(n):
if S == 10**9:
ans.append(S-1)
else:
ans.append(S+1)
ans=[str(a) for a in ans]
ans=" ".join(ans)
print(ans) | X,Y=map(int,input().split());print((max((4-X),0)+max((4-Y),0)+((0,4)[X*Y==1]))*10**5) | 0 | null | 116,179,765,795,960 | 238 | 275 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
n, k = map(int, input().split())
nums = [i for i in range(n+1)]
sums = [0]
ans = 0
x = 10**9 + 7
for i in range(n):
sums.append(nums[i+1]+sums[i])
for j in range(k, len(nums)+1):
if j == len(nums):
ans += 1
else:
ans += sums[-1] - sums[-(1+j)] - sums[j-1] + 1
print(ans%x)
if __name__ == '__main__':
main() | n,k=map(int,input().split())
L=list(range(n+1))
cnt=0
ans=0
def calc(i):
smallest=(i-1)*i//2
largest=(2*n-i+1)*i//2
return largest-smallest+1
for i in range(k,n+2):
cnt+=calc(i)
cnt%=(10**9+7)
print(cnt) | 1 | 32,911,780,831,338 | null | 170 | 170 |
n,m = map(int,input().split())
coins = sorted(list(map(int,input().split())),reverse=True)
dp = [float("inf")]*50001
dp[0] = 0
for i in range(50001):
for coin in coins:
if i+coin > 50000:
continue
else:
dp[i+coin] = min(dp[i+coin], dp[i]+1)
print(dp[n])
| N,M = map(int, input().split())
C = list(map(int, input().split()))
C.sort()
DP = [i for i in range(N+1)]
for m in range(1,M):
coin = C[m]
for total in range(1, N+1):
if total - coin >= 0:
DP[total] = min(DP[total], DP[total - coin] + 1)
print(DP[-1])
| 1 | 139,160,336,058 | null | 28 | 28 |
import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
x = int(input())
tmp = [i ** 5 for i in range(ceil(x ** 0.25) + 1)]
res = 0
for a in range(len(tmp) - 1):
for b in range(a + 1, len(tmp)):
if tmp[a] - tmp[b] == x:
res = f"{a} {b}"
break
elif tmp[a] + tmp[b] == x:
res = f"{a} {-b}"
break
elif -tmp[a] + tmp[b] == x:
res = f"{-a} {-b}"
break
elif -tmp[a] - tmp[b] == x:
res = f"{-a} {b}"
break
print(res)
| def solve():
x = int(input())
for i in range(-150, 151):
for j in range(-150,i):
if i ** 5 - j ** 5 == x:
print(i,j)
return
if __name__ == '__main__':
solve() | 1 | 25,588,175,514,548 | null | 156 | 156 |
import sys
def main():
for line in sys.stdin:
print(int(line.strip())**3)
if __name__ == "__main__":
main() | i = raw_input().strip().split()
W = int(i[0])
H = int(i[1])
x = int(i[2])
y = int(i[3])
r = int(i[4])
flag = True
if x-r < 0 or x+r > W:
flag = False
elif y-r < 0 or y+r > H:
flag = False
if flag:
print "Yes"
else:
print "No" | 0 | null | 363,606,025,104 | 35 | 41 |
import itertools
import functools
import math
def OK():
N = int(input())
sum = 0
cnt = 0
for i in range(1,N+1):
for j in range(1,N+1):
chk = math.gcd(i,j)
for k in range(1,N+1):
sum += math.gcd(chk,k)
print(sum)
OK()
| icase=0
if icase==0:
r=int(input())
print(r*r)
| 0 | null | 90,332,375,116,412 | 174 | 278 |
s,t=[str(i)for i in input().split()]
print(t+s) | def judge(n,a):
table = {}
for i in range(n):
if a[i] in table.keys():
print('NO')
return
else:
table[a[i]] = 1
print('YES')
return
n = int(input())
a = list(map(int,input().split()))
judge(n,a) | 0 | null | 88,641,852,082,560 | 248 | 222 |
n = int(input())
line = []
for _ in range(n):
x, l = map(int, input().split())
s, g = x-l, x+l
line.append([g, s])
line.sort()
ans = 1
now_g = line[0][0]
for g, s in line[1:]:
if now_g <= s:
ans += 1
now_g = g
print(ans)
| import numpy as np
N = int(input())
X = [[] for _ in range(N)]
L = [[] for _ in range(N)]
for i in range(N):
X[i], L[i] = map(int, input().split())
def indexSort(L):
D = dict(zip(range(len(L)), L))
E = sorted(D.items(), key=lambda x: x[1])
F = [e[0] for e in E]
return F
L1 = [x-l for x, l in zip(X, L)]
L2 = [x+l for x, l in zip(X, L)]
Ind = np.argsort(L2)
Remain = [Ind[0]]
i = 0
while i < len(Ind)-1:
now = Remain[-1]
After = Ind[i+1:]
skip = 0
for after in After:
if L2[now] > L1[after]:
# print(L2[now], L1[after])
skip += 1
else:
# print(after)
Remain.append(after)
break
i += 1 + skip
print(len(Remain)) | 1 | 89,689,772,336,960 | null | 237 | 237 |
input()
S=input()
while True:
x=''
ans=''
for i in S:
if (x==''):
x=i
continue
if x!=i:
ans+=x
x=i
ans+=x
if ans==S:
break
else:
S=ans
print(len(ans)) | import itertools
n = int(input())
S = list(input())
L = [k for k, v in itertools.groupby(S)]
print(len(L)) | 1 | 169,538,926,826,500 | null | 293 | 293 |
import sys
def insertionSort( nums, n, g ):
cnt = 0
i = g
while i < n:
v = nums[i]
j = i - g
while 0 <= j and v < nums[j]:
nums[ j+g ] = nums[j]
j -= g
cnt += 1
nums[ j+g ] = v
i += 1
return cnt
def shellSort( nums, n ):
g = []
val =0
for i in range( n ):
val = 3*val+1
if n < val:
break
g.append( val )
g.reverse( )
m = len( g )
print( m )
print( " ".join( map( str, g ) ) )
cnt = 0
for i in range( m ):
cnt += insertionSort( nums, n, g[i] )
print( cnt )
n = int( sys.stdin.readline( ) )
nums = []
for i in range( n ):
nums.append( int( sys.stdin.readline( ) ) )
cnt = 0
shellSort( nums, n )
print( "\n".join( map( str, nums ) ) ) | 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]
| 1 | 28,082,291,300 | null | 17 | 17 |
import math
a,b,x=map(int,input().split())
h=x/a/a
A=h*a
if A<=b*a/2:
L=A/b*2
ans=math.degrees(math.atan(b/L))
else:
L=A*2/a-b
ans=math.degrees(math.atan((b-L)/a))
print(ans)
| n = int(input())
d = {}
for i in range(n):
cmd = input()
if cmd[0] == 'i':
d[cmd[7:]] = 0
else:
print('yes' if cmd[5:] in d else 'no') | 0 | null | 81,724,963,494,148 | 289 | 23 |
n=int(input())
a=[[[0 for _ in range(10)] for _ in range(3)] for _ in range(4)]
for _ in range(n):
b,f,r,v=map(int,input().split())
a[b-1][f-1][r-1]+=v
for c in range(4):
for d in range(3):print('',*a[c][d])
if c != 3:print('#' *20) | def f(n):
if n == 0:
return 0
return f(n % bin(n).count("1")) + 1
def solve():
N = int(input())
X = input()
p = X.count("1")
rem_plus = 0
rem_minus = 0
for i in range(N):
k = N - i - 1
if X[i] == "0":
continue
elif p > 1:
rem_minus = (rem_minus + pow(2, k, p - 1)) % (p - 1)
rem_plus = (rem_plus + pow(2, k, p + 1)) % (p + 1)
for i in range(N):
k = N - i - 1
if X[i] == "0":
print(f((rem_plus + pow(2, k, p + 1)) % (p + 1)) + 1)
elif p > 1:
print(f((rem_minus - pow(2, k, p - 1)) % (p - 1)) + 1)
else:
print(0)
if __name__ == "__main__":
solve() | 0 | null | 4,609,558,317,406 | 55 | 107 |
def gcd(a,b):
if a%b==0:
return b
else :
return gcd(b,a%b)
def main():
a,b=map(int,raw_input().split())
print(gcd(a,b))
if __name__=='__main__':
main() | import sys
import os
for line in sys.stdin:
H, W = map(int, line.split())
if H == 0 and W == 0:
break
print(('#' * W + '\n') * H)
| 0 | null | 382,121,928,770 | 11 | 49 |
N, K = map(int, input().split())
d = []
A = [[] for i in range(K)]
for i in range(K):
d.append(int(input()))
A[i] = list(map(int, input().split()))
hold = set()
for i in range(len(A)):
hold = hold | set(A[i])
print(N - len(hold)) | N, K = map(int, input().split())
have_sweets = []
for i in range(K):
d = int(input())
have_sweets += list(map(int, input().split()))
have_sweets = set(have_sweets)
print(len(list(set([i for i in range(1, N+1)])-have_sweets)))
| 1 | 24,657,859,328,532 | null | 154 | 154 |
def main():
n, k = map(int, input().split())
H = list(map(int, input().split()))
cnt = 0
for i in range(n):
if H[i] >= k:
cnt += 1
print(cnt)
if __name__ == "__main__":
main()
| N, K = map(int,input().split())
H = list(map(int,input().split()))
s = 0
for i in H:
if K <= i:
s += 1
print(s)
| 1 | 179,091,887,099,218 | null | 298 | 298 |
def merge(a, left, mid, right):
x = 0
l = a[left:mid] + [float("inf")]
r = a[mid:right] + [float("inf")]
i = 0
j = 0
for k in range(left,right):
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else :
a[k] = r[j]
j += 1
x += 1
return x
def mergeSort(a, left, right,x):
if left+1 < right:
mid = int((left + right)/2)
mergeSort(a, left, mid,x)
mergeSort(a, mid, right,x)
x[0] += merge(a, left, mid, right)
n = int(input())
s = list(map(int,input().split()))
x = [0]
mergeSort(s,0,n,x)
print(*s)
print(x[0])
| n,k = input().split()
k = int(k)
#print(n,k)
p = [int(s) for s in input().split()]
p.sort()
#print(p)
#print(k)
p2 = p[0:k]
#print(p2)
s = sum(p)
#print(s)
print(sum(p2)) | 0 | null | 5,875,099,020,898 | 26 | 120 |
a=input()
l=a.split(" ")
n=int(l[0])
k=int(l[1])
f=input()
fruits=f.split(" ")
for d in range(0, len(fruits)):
fruits[d]=int(fruits[d])
ans=0
b=0
while(b<k):
g=min(fruits)
ans+=g
fruits.remove(g)
b+=1
print(ans) | def insertion_sort(A, N):
yield A
for i in range(1, N):
v = A[i]
j = i - 1
while j >= 0 and A[j] > v:
# 右にずらす
A[j + 1] = A[j]
j -= 1
A[j + 1] = v
yield A
N = int(input())
A = list(map(int, input().split()))
for li in insertion_sort(A, N):
print(*li)
| 0 | null | 5,840,926,954,672 | 120 | 10 |
n=int(input())
s,t = map(str, input().split())
print(''.join([s[i] + t[i] for i in range(0,n)])) | N = int(input())
S, T = input().split()
mix = []
for i in range(N):
mix.append(S[i])
mix.append(T[i])
print(*mix, sep='') | 1 | 111,700,698,070,080 | null | 255 | 255 |
n,r = map(int, input().split())
if n>10: print(r)
else: print(int(100*(10-n)+r)) | integers=[]
i=0
j=0
while True:
num=int(input())
integers.append(num)
if integers[i]==0:
del integers[i]
break
i+=1
while j<i:
print('Case {}: {}'.format(j+1,integers[j]))
j+=1
| 0 | null | 31,915,930,200,950 | 211 | 42 |
import itertools
N = int(input())
c = []
d = 0
for i in range(N):
x1, y1 = map(int, input().split())
c.append((x1,y1))
cp = list(itertools.permutations(c))
x = len(cp)
for i in range(x):
for j in range(N-1):
d += ((cp[i][j][0]-cp[i][j+1][0])**2 + (cp[i][j][1] - cp[i][j+1][1])**2)**0.5
print(d/x) | import sys
import decimal # 10進法に変換，正確な計算
def input():
return sys.stdin.readline().strip()
def main():
n, k = map(int, input().split())
h = list(map(int, input().split()))
count = 0
for i in h:
if i >= k:
count += 1
print(count)
main() | 0 | null | 163,571,298,293,270 | 280 | 298 |
from collections import Counter
a = int(input())
num_list = list(map(int, input().split()))
D = Counter(num_list)
for i in range(a):
print(D[i+1]) | a,b,c = map(int, input().split())
print(str(c)+" "+str(a)+" "+str(b)) | 0 | null | 35,062,110,645,770 | 169 | 178 |
def bubbleSort(A, N):
ret = 0
flag = 1
while flag:
flag = 0
for j in range(N-1, 0, -1):
if A[j] < A[j-1]:
A[j], A[j-1] = A[j-1], A[j]
flag = 1
ret += 1
return ret
n = int(input())
a = list(map(int, input().split()))
count = bubbleSort(a, n)
print(" ".join(map(str, a)))
print(count) | def bubbleSort(A, N):
flag = 1
i = 0
swapnum = 0
while flag:
flag = 0
for j in range(N-1, i, -1):
if A[j] < A[j-1]:
temp = A[j-1]
A[j-1] = A[j]
A[j] = temp
swapnum += 1
flag = 1
i = i + 1
return swapnum
def showlist(A):
for i in range(len(A)):
if i==len(A)-1:
print(A[i])
else:
print(A[i], end=' ')
N = eval(input())
A = list(map(int, input().split()))
swapnum = bubbleSort(A, N)
showlist(A)
print(swapnum)
| 1 | 16,539,549,130 | null | 14 | 14 |
Subsets and Splits