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
|
|---|---|---|---|---|---|---|
S = input()
N = len(S)
ans = [0] * (N+1)
for i in range(N):
if S[i] == '<':
ans[i+1] = ans[i] + 1
for i in range(N-1, -1, -1):
if S[i] == '>' and ans[i] <= ans[i+1]:
ans[i] = ans[i+1]+1
print(sum(ans))
| s = input()
big = 0
small = 0
n = 0
big2 =0
for i in range(len(s)):
if s[i]=='<':
big += 1
n += big
small =0
big2 = big
else:
small += 1
n += small
if small<=big2:
n-=1
big =0
print(n) | 1 | 156,493,122,453,152 | null | 285 | 285 |
def main():
a = list(map(int,input().split()))
ans = 0
for i in range(5):
ans += a[i]
print(15 - ans)
main() | import itertools
N = int(input())
P = tuple(map(int, input().split()))
Q = tuple(map(int, input().split()))
A = list(itertools.permutations(range(1, N+1)))
for a in range(len(A)):
if A[a] == P:
p = a
if A[a] == Q:
q = a
print(abs(p - q))
| 0 | null | 57,322,701,059,328 | 126 | 246 |
(N,), *XL = [list(map(int, s.split())) for s in open(0)]
XL.sort(key=lambda x: x[0] + x[1])
curr = -float("inf")
ans = 0
for x, l in XL:
if x - l >= curr:
curr = x + l
ans += 1
print(ans)
| k = int(input())
start = 7 % k
ans = start
con = 1
if k % 2 == 0 or k % 5 == 0:
print("-1")
exit()
while True:
if ans == 0:
print(con)
break
else:
con += 1
ans = ans * 10 + 7
ans = ans % k
if ans == start:
print("-1")
break
| 0 | null | 48,067,838,124,332 | 237 | 97 |
import math
from math import gcd
INF = float("inf")
import sys
input=sys.stdin.readline
import itertools
from collections import Counter
def main():
ans = 0
n = int(input())
for j in range(1,n+1):
ans += j*(n//j)*(n//j + 1)//2
print(ans)
if __name__=="__main__":
main()
| n = int(input())
def cal(i):
s = (i + i*(n//i))*(n//i)*0.5
return s
ans = 0
for i in range(1, n+1):
ans += cal(i)
print(int(ans))
| 1 | 11,084,834,566,788 | null | 118 | 118 |
r,c = map(int,raw_input().split())
a = [map(int,raw_input().split()) for _ in range(r)]
b = [0 for _ in range(c)]
for i in range(r) :
s = 0
for j in range(c) :
s = s + a[i][j]
b[j] = b[j] + a[i][j]
a[i].append(s)
print ' '.join(map(str,a[i]))
b.append(sum(b))
print ' '.join(map(str,b)) | N=int(input())
A=list(map(int, input().split()))
A.sort()
if N==1:
print('YES')
exit()
for i in range(N-1):
if A[i]==A[i+1]:
print('NO')
exit()
else:
print('YES') | 0 | null | 37,454,808,399,920 | 59 | 222 |
N=int(input())
S,T=input().split()
for i in range(N):
print(S[i],T[i],sep='',end='')
print()
| import sys , math
from bisect import bisect
N=int(input())
alp="abcdefghijklmnopqrstuvwxyz"
R=[]
i=1
tot = 0
while tot < 1000000000000001:
tar = 26**i
tot+=tar
R.append(tot+1)
i+=1
keta = bisect(R , N)+1
if keta == 1:
print(alp[N-1])
sys.exit()
ans = ""
M = N - R[keta - 1]
for i in range(keta):
j = keta - i - 1
ind = M // (26**j)
M -= ind * (26**j)
ans+=alp[ind]
print(ans) | 0 | null | 62,182,122,504,832 | 255 | 121 |
# input here
_INPUT = """\
5 3
1 2
3 4
5 1
"""
"""
K = int(input())
H, W, K = map(int, input().split())
a = list(map(int, input().split()))
xy = [list(map(int, input().split())) for i in range(N)]
p = tuple(map(int,input().split()))
"""
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 main():
n, m = map(int, input().split())
xy = [list(map(int, input().split())) for i in range(m)]
uf = UnionFind(n)
for i in range(len(xy)):
uf.union(xy[i][0]-1,xy[i][1]-1)
print(-(min(uf.parents)))
if __name__ == '__main__':
import io
import sys
import math
import itertools
from collections import deque
# sys.stdin = io.StringIO(_INPUT)
main() | N,M = map(int, input().split())
A_list = [int(i) for i in input().split()]
playable_days = N - sum(A_list)
if playable_days >= 0:
print(playable_days)
else:
print("-1") | 0 | null | 18,093,725,284,020 | 84 | 168 |
import sys
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
def main():
MOD = 1000000007
N, *A = map(int, read().split())
ans = 1
C = [0] * (N + 1)
C[0] = 3
for a in A:
ans = ans * C[a] % MOD
C[a] -= 1
C[a + 1] += 1
print(ans)
return
if __name__ == '__main__':
main()
| #!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N = int(input())
A = list(map(int, input().split()))
p = 10**9+7
# check[i]:= Aの中のiが出てきた順番
check = [[] for _ in range(N)]
for i in range(N):
check[A[i]].append(i)
# print(check)
ans = 1
for i in range(len(check[0])):
ans *= (3-i)
for i in range(1,N):
if len(check[i-1]) < len(check[i]):
exit(print(0))
# check[i]がcheck[i-1]のなかで何番目か調べる
for j in range(len(check[i])):
d = bisect_right(check[i-1],check[i][j])
if d < j:
exit(print(0))
ans *= d-j
ans %= p
# print(ans)
print(ans)
if __name__ == "__main__":
main()
| 1 | 130,167,818,418,788 | null | 268 | 268 |
N = int(input())
L = list(map(int, input().split()))
count = 0
for i in range(N):
for j in range(i+1,N):
for k in range(j+1,N):
if L[i] != L[j] and L[j] != L[k] and L[i] != L[k] and max(L[i],L[j],L[k]) < sum([L[i],L[j],L[k]])/2:
count+=1
print(count) | from sys import stdin
input = stdin.readline
def main():
N, K = map(int, input().rstrip().split())
A = list(map(int, input().rstrip().split()))
F = list(map(int, input().rstrip().split()))
A.sort()
F.sort(reverse=True)
l = -1
r = 10 ** 12
while(r - l > 1):
c = (l + r) // 2
s = 0
for i in range(N):
d = A[i] - (c // F[i])
s += max(0, d)
if s <= K:
r = c
else:
l = c
print(r)
if __name__ == "__main__":
main()
| 0 | null | 84,556,147,618,460 | 91 | 290 |
def North(dice):
w = dice[0]
dice[0] = dice[1]
dice[1] = dice[5]
dice[5] = dice[4]
dice[4] = w
return dice
def East(dice):
w = Dice[1]
dice[1] = dice[2]
dice[2] = dice[4]
dice[4] = dice[3]
dice[3] = w
return dice
def West(dice):
w = dice[0]
dice[0] = dice[2]
dice[2] = dice[5]
dice[5] = dice[3]
dice[3] = w
return dice
maxloop = 4
Ncnt = 0
Ecnt = 0
Wcnt = 0
Dice = input().split()
q = int(input())
CopyDice = Dice
for i1 in range(q):
Nloop = True
Eloop = True
Wloop = True
Ncnt = 0
Ecnt = 0
Wcnt = 0
I = input().split()
top = I[0]
front = I[1]
while Eloop:
while Nloop:
while Wloop:
if Dice[0] == top and Dice[1] == front:
print(Dice[2])
Nloop = False
Eloop = False
Wloop = False
break
Dice = West(Dice)
Wcnt += 1
if Wcnt == maxloop:
Wloop = False
Dice = North(Dice)
Wcnt = 0
Wloop = True
Ncnt += 1
if Ncnt == maxloop:
Nloop = False
Dice = East(Dice)
Ncnt = 0
Nloop = True
Ecnt += 1
if Ecnt == maxloop:
Eloop = False
Dice = CopyDice | num=list(map(int,input().split()))
q=int(input())
def E(ls):
ls=[ls[3],ls[1],ls[0],ls[5],ls[4],ls[2]]
return ls
def N(ls):
ls=[ls[1],ls[5],ls[2],ls[3],ls[0],ls[4]]
return ls
def R(ls):
ls=[ls[0],ls[2],ls[4],ls[1],ls[3],ls[5]]
return ls
for i in range(q):
num0,num1=list(map(int,input().split()))
if num.index(num0) in [0,2,3,5]:
while num[0]!=num0:
num=E(num)
while num[1]!=num1:
num=R(num)
print(num[2])
else:
while num[0]!=num0:
num=N(num)
while num[1]!=num1:
num=R(num)
print(num[2])
| 1 | 257,774,400,830 | null | 34 | 34 |
a,b=input().split()
a=int(a)
b=int(b)
if a==b:
print("Yes")
else:
print("No") | import os, sys, re, math
(A, B) = [int(n) for n in input().split()]
print(max(A - B * 2, 0))
| 0 | null | 124,896,306,720,020 | 231 | 291 |
import statistics as st
while True:
n=int(input())
if n==0:
break
s=list(map(int,input().split()))
print(f'{st.pstdev(s):.5f}')
| import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
n = int(read())
lim = int(n ** 0.5)
fact = [1]
for i in range(2, lim + 1):
if (n % i == 0):
fact.append(i)
else:
pass
if (len(fact) == 1):
ans = n - 1
else:
tar = fact[-1]
ans = tar + int(n // tar) - 2
print(ans)
| 0 | null | 80,697,794,307,392 | 31 | 288 |
s = input()
s = s[::-1]
m = [0] * 2019
m[0] = 1
a = 0
d = 1
ans = 0
for si in s:
a = (a + int(si) * d) % 2019
d = (d * 10) % 2019
ans += m[a]
m[a] += 1
print(ans)
| s=input()
s=s[::-1]
l=[0]*2019
l[0]=1
prev=0
ans=0
mul=1
for i in range(len(s)):
now=(int(s[i])*mul)%2019
ans+=l[(prev+now)%2019]
l[(prev+now)%2019]+=1
prev=(prev+now)%2019
mul=(mul*10)%2019
print(ans) | 1 | 30,791,037,171,748 | null | 166 | 166 |
#coding:utf-8
#1_2_A
def bubble_sort(ary, n):
count = 0
flag = 1
i = 0
while flag:
flag = 0
for j in reversed(range(i+1, n)):
if ary[j] < ary[j-1]:
ary[j], ary[j-1] = ary[j-1], ary[j]
count += 1
flag = 1
i += 1
print(' '.join(map(str, ary)))
print(count)
n = int(input())
numbers = list(map(int, input().split()))
bubble_sort(numbers, n) | import math
from itertools import combinations
from itertools import combinations_with_replacement
from itertools import product
from collections import defaultdict
from collections import deque
from collections import Counter
import heapq
def input_li():
return list(map(int, input().split()))
N = int(input())
A_LI = input_li()
max_h = A_LI[0]
ans = 0
for i in range(1, N):
if A_LI[i] < max_h:
ans += max_h - A_LI[i]
else:
max_h = max(max_h, A_LI[i])
print(ans)
| 0 | null | 2,316,060,136,610 | 14 | 88 |
X,Y,Z=map(int,input().split())
print(str(Z)+' '+str(X)+' '+str(Y)) | x,y=map(int,input().split())
print(str(min(x,y))*max(x,y)) | 0 | null | 61,165,567,316,138 | 178 | 232 |
S=input()
if S.count('A')==1 or S.count('A')==2:
print('Yes')
else:
print('No') | H = int(input())
W = int(input())
N = int(input())
for i in range(min(H,W)):
N -= max(H, W)
if N <= 0:
print(i+1)
exit() | 0 | null | 72,144,431,876,960 | 201 | 236 |
N, K = [int(i) for i in input().split()]
mod = 10**9+7
result = 0
for i in range(K, N+2):
min_sum = ((i-1) * i) // 2
max_sum = ((N) * (N+1)) // 2 - ((N-i) * (N-i+1)) // 2
result += (max_sum - min_sum + 1) % mod
print(result%mod) | import math
def order(N,P):
value=0
N_ls=list(range(1,N+1))
score=0
for i in P:
score+=N_ls.index(i)*math.factorial(len(N_ls)-1)
N_ls.remove(i)
return score
N=int(input())
P=[int(x) for x in input().split()]
Q=[int(x) for x in input().split()]
print(abs(order(N,P)-order(N,Q))) | 0 | null | 66,535,980,798,606 | 170 | 246 |
counter = 0
while True:
n = int(input())
counter += 1
if(n == 0):break
print('Case {}: {}'.format(counter,n))
| X = int(input())
uresisa = (X // 500) * 1000 + ((X % 500) // 5) * 5
print(uresisa)
| 0 | null | 21,682,131,663,318 | 42 | 185 |
N, K = map(int, input().split())
p = list(map(int, input().split()))
# サイコロ（1...p）の期待値は(1+p)/2
cum_sum = [0]
for i in range(0, N):
cum_sum.append(cum_sum[i] + (1 + p[i]) / 2)
# print(cum_sum)
# 調べる区間は[1,...,K],...,[N-K+1,...N]
ans = 0
for i in range(1, N - K + 2):
temp = cum_sum[i + K - 1] - cum_sum[i - 1]
# print(temp)
ans = max(ans, temp)
print(ans)
| N,K=map(int,input().split())
p=list(map(int,input().split()))
exp0 = (sum(p[:K])+K)/2
MAX=exp0
old = exp0
for i in range(1,N-K+1):
new = old + (p[K+i-1]+1)/2 - (p[i-1]+1)/2
if new > MAX: MAX = new
old = new
print(MAX) | 1 | 75,126,963,171,468 | null | 223 | 223 |
#Code by Sounak, IIESTS
#------------------------------warmup----------------------------
import os
import sys
import math
from io import BytesIO, IOBase
from fractions import Fraction
import collections
from itertools import permutations
from collections import defaultdict
from collections import deque
import threading
threading.stack_size(10**8)
sys.setrecursionlimit(300000)
BUFSIZE = 8192
class FastIO(IOBase):
newlines = 0
def __init__(self, file):
self._fd = file.fileno()
self.buffer = BytesIO()
self.writable = "x" in file.mode or "r" not in file.mode
self.write = self.buffer.write if self.writable else None
def read(self):
while True:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
if not b:
break
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines = 0
return self.buffer.read()
def readline(self):
while self.newlines == 0:
b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
self.newlines = b.count(b"\n") + (not b)
ptr = self.buffer.tell()
self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
self.newlines -= 1
return self.buffer.readline()
def flush(self):
if self.writable:
os.write(self._fd, self.buffer.getvalue())
self.buffer.truncate(0), self.buffer.seek(0)
class IOWrapper(IOBase):
def __init__(self, file):
self.buffer = FastIO(file)
self.flush = self.buffer.flush
self.writable = self.buffer.writable
self.write = lambda s: self.buffer.write(s.encode("ascii"))
self.read = lambda: self.buffer.read().decode("ascii")
self.readline = lambda: self.buffer.readline().decode("ascii")
sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip("\r\n")
#-------------------game starts now-----------------------------------------------------
n=int(input())
ans=0
d=defaultdict(int)
d1=defaultdict(int)
m=-10**13
m1=-10**13
mi=10**13
mi1=10**13
for i in range(n):
a,b=map(int,input().split())
m=max(m,a+b)
mi=min(mi,a+b)
m1=max(m1,a-b)
mi1=min(mi1,a-b)
#print(mi,mi1,m,m1)
print(max(m-mi,m1-mi1)) | n = input()
p = [0] * 2
for i in range(n):
t, h = raw_input().split()
if(t > h):
p[0] += 3
elif(t < h):
p[1] += 3
else:
p[0] += 1
p[1] += 1
print("%d %d" %(p[0], p[1])) | 0 | null | 2,733,616,326,960 | 80 | 67 |
def max2(x,y):
return x if x > y else y
N = int(input())
D = []
for i, a in enumerate(map(int, input().split())):
D.append((a<<11) + i)
D.sort(reverse=True)
dp = [0]*(N+1)
for i, d in enumerate(D,start=1):
x, a = d%(1<<11),d>>11
for j in reversed(range(0, i+1)):
dp[j] = max2((dp[j-1]+a*(x-(j-1)))*(j-1>=0), (dp[j]+a*(N-(i-j)-x))*(j<=i-1))
print(max(dp)) | N = int(input())
A = sorted(map(lambda x: (int(x[1]), x[0]),
enumerate(input().split())), reverse=True)
V = [0]
for i in range(N-1):
a, p = A[i]
s = i+1
V2 = [None]*(s+1)
for t in range(s+1):
v = 0
if t > 0:
v = V[t-1] + a*abs(p-(t-1))
if t < s:
v = max(V[t] + a*abs(p-(N-s+t)), v)
V2[t] = v
V = V2
a, p = A[-1]
for i in range(N):
V[i] += a*abs(p-i)
print(max(V))
| 1 | 33,509,317,309,230 | null | 171 | 171 |
def solve():
N,M = [int(i) for i in input().split()]
A = [int(i) for i in input().split()]
total = sum(A)
threshold = float(total) / (4*M)
cnt = 0
for num in A:
if num >= threshold:
cnt += 1
if cnt >= M:
print("Yes")
else:
print("No")
if __name__ == "__main__":
solve() | n,m = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort(reverse = True)
s = sum(a)
res = "Yes"
for i in range(m):
if a[i] * 4 * m < s:
res = "No"
print(res) | 1 | 38,860,937,977,576 | null | 179 | 179 |
while True:
a = input()
b = a.split(' ')
H = int(b[0])
W = int(b[1])
if H == 0 and W ==0:
break
for i in range(H):
c = '#'*W
print(c)
print() | while True:
H,W = map(int,raw_input().split())
if H == 0 and W == 0:
break
a = "#"
for i in xrange(0,H):
print a * W
print "" | 1 | 757,919,921,996 | null | 49 | 49 |
from collections import Counter
N=int(input())
if N==1:
print(0)
exit()
def factorize(n):
out=[]
i = 2
while 1:
if n%i==0:
out.append(i)
n //= i
else:
i += 1
if n == 1:break
if i > int(n**.5+3):
out.append(n)
break
return out
c = Counter(factorize(N))
def n_unique(n):
out = 0
while 1:
if out*(out+1)//2 > n:
return out-1
out += 1
ans = 0
for k in c.keys():
ans += n_unique(c[k])
print(ans) | import sys
for i in sys.stdin:
scores = list(map(int, i.split()))
m = scores[0]
f = scores[1]
r = scores[2]
if m == f == r == -1:
break
elif (m == -1) or (f == -1):
print("F")
elif m + f >= 80:
print("A")
elif 65 <= (m + f) < 80:
print("B")
elif 50 <= (m + f) < 65:
print("C")
elif 30 <= (m + f) < 50:
if r >= 50:
print("C")
else:
print("D")
else:
print("F") | 0 | null | 9,035,928,078,550 | 136 | 57 |
S = int (input ())
print (S**2) | r = int(input())
ans = r * r
print(ans) | 1 | 145,221,830,981,092 | null | 278 | 278 |
a=int(input())
b=0
c=list(map(int,input().split()))
for i in range(a):
for k in range(a):
b=b+c[i]*c[k]
for u in range(a):
b=b-c[u]*c[u]
print(int(b/2)) | n = int(input())
l = [0 for _ in range(10**4)]
def fib(n):
if n==0:
l[0]=1
return 1
if n==1:
l[1]=1
return 1
if l[n]!=0:
return l[n]
else:
l[n]=fib(n-1)+fib(n-2)
return fib(n-1)+fib(n-2)
print(fib(n))
| 0 | null | 83,936,437,959,398 | 292 | 7 |
while 1:
h,w=map(int,raw_input().split())
if (h,w)==(0,0):
break
print ("#"*w+"\n")*h | class PrintARectangle:
def output(self, H, W):
s = ""
for w in range(W):
s += "#"
for h in range(H):
print s
print
if __name__ == "__main__":
pr = PrintARectangle()
while True:
h, w = map(int, raw_input().split())
if h == 0 and w == 0:
break
pr.output(h, w) | 1 | 773,097,377,352 | null | 49 | 49 |
A, B = map(int, input().split())
times = A * B
if A < B:
A, B = B, A
while B > 0:
temp = A % B
A = B
B = temp
print(int(times/A)) | from collections import Counter, deque
N, K = map(int, input().split())
A = list(map(int, input().split()))
INF = 10**18
cnt = Counter()
cnt[0] = 1
que = deque([0])
sumR = 0
ans = 0
for right, a in enumerate(A, start=1):
if len(que) >= K:
cnt[que.popleft()] -= 1
sumR = (a + sumR) % K
D = (sumR - right) % K
ans += cnt[D]
cnt[D] += 1
que.append(D)
print(ans)
| 0 | null | 125,173,044,181,472 | 256 | 273 |
print "\n".join(['%dx%d=%d'%(x,y,x*y) for x in range(1,10) for y in range(1,10)]) | if __name__ == '__main__':
for i in range(1,10):
for j in range(1,10):
print(str(i)+"x"+str(j)+"="+str(i*j)) | 1 | 786,462 | null | 1 | 1 |
N, M, K = list(map(int, input().split()))
A = list(map(int, input().split()))
B = list(map(int, input().split()))
A_sum = [0]
B_sum = [0]
A_now = 0
B_now = 0
for i in range(N):
A_now = A[i] + A_now
A_sum.append(A_now)
for i in range(M):
B_now = B[i] + B_now
B_sum.append(B_now)
ans = 0
for i in range(N+1):
book_count = i
remain_time = K - A_sum[i]
ok = 0
ng = M
if remain_time >= B_sum[M]:
ans = book_count + M
while ng - ok > 1:
mid = (ok+ng)//2
if remain_time >= B_sum[mid]:
ok = mid
else:
ng = mid
book_count += ok
if remain_time >= 0:
if book_count > ans:
ans = book_count
# print(mid,remain_time,B_sum[ok])
print(ans)
| #!/usr/bin/env python3
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
a = [0]
b = [0]
for i in range(N):
a.append(a[i] + A[i])
for i in range(M):
b.append(b[i] + B[i])
count = 0
j = M
for i in range(N+1):
if a[i] > K:
break
while b[j] > K - a[i]:
j -= 1
count = max(count, i+j)
print(count)
| 1 | 10,682,958,932,368 | null | 117 | 117 |
import sys
## io ##
def IS(): return sys.stdin.readline().rstrip()
def II(): return int(IS())
def MII(): return list(map(int, IS().split()))
def MIIZ(): return list(map(lambda x: x-1, MII()))
## dp ##
def DD2(d1,d2,init=0): return [[init]*d2 for _ in range(d1)]
def DD3(d1,d2,d3,init=0): return [DD2(d2,d3,init) for _ in range(d1)]
## math ##
def to_bin(x: int) -> str: return format(x, 'b') # rev => int(res, 2)
def to_oct(x: int) -> str: return format(x, 'o') # rev => int(res, 8)
def to_hex(x: int) -> str: return format(x, 'x') # rev => int(res, 16)
MOD=10**9+7
def divc(x,y) -> int: return -(-x//y)
def divf(x,y) -> int: return x//y
def gcd(x,y):
while y: x,y = y,x%y
return x
def lcm(x,y): return x*y//gcd(x,y)
def enumerate_divs(n):
"""Return a tuple list of divisor of n"""
return [(i,n//i) for i in range(1,int(n**0.5)+1) if n%i==0]
def get_primes(MAX_NUM=10**3):
"""Return a list of prime numbers n or less"""
is_prime = [True]*(MAX_NUM+1)
is_prime[0] = is_prime[1] = False
for i in range(2, int(MAX_NUM**0.5)+1):
if not is_prime[i]: continue
for j in range(i*2, MAX_NUM+1, i):
is_prime[j] = False
return [i for i in range(MAX_NUM+1) if is_prime[i]]
## libs ##
from itertools import accumulate as acc
from collections import deque, Counter
from heapq import heapify, heappop, heappush
from bisect import bisect_left
#======================================================#
def main():
a, b, m = MII()
aa = MII()
bb = MII()
q = [MII() for _ in range(m)]
minv = min(aa) + min(bb)
for x,y,c in q:
minv = min(minv, aa[x-1]+bb[y-1]-c)
print(minv)
if __name__ == '__main__':
main() | s = input()
if len(list(set(s))) == 1:
print('No')
else:
print('Yes') | 0 | null | 54,297,995,717,860 | 200 | 201 |
data = [
[[0 for k in range(10)] for j in range(3)] for i in range(4)
]
count = int(input())
for x in range(count):
(b,f,r,v) = [int(i) for i in input().split()]
data[b - 1][f - 1][r - 1] += v
for b in range(4):
for f in range(3):
print(' ',end='')
for r in range(10):
if r == 9:
print(data[b][f][r], end='')
else:
print(data[b][f][r], '', end='')
print()
if b == 3:
break
for x in range(20):
print('#',end='')
print() | data = []
for i in xrange(4):
tou = []
data.append(tou)
for j in xrange(3):
kai = [0 for k in xrange(10)]
tou.append(kai)
n = int(raw_input())
for i in xrange(n):
b,f,r,v = map(int, raw_input().split(" "))
data[b-1][f-1][r-1] = max(0, data[b-1][f-1][r-1] + v)
for tou in data:
if not tou is data[0]:
print "#" * 20
for kai in tou:
print " " + " ".join(map(str, kai)) | 1 | 1,099,132,826,788 | null | 55 | 55 |
a,b = map(int,input().split())
d = a // b
r = a % b
f = a / b
print(f"{d} {r} {f:.5f}")
| n = input()
if int(n)%1000 == 0:
print(0)
elif int(n) < 1000:
print(1000-int(n))
else:
print(1000-int(n[-3:])) | 0 | null | 4,483,049,348,452 | 45 | 108 |
k = int(input())
s = list(input())
an_lis = []
if len(s) <= k:
ans = "".join(s)
print(ans)
else:
for i in range(k):
an_lis.append(s[i])
an_lis.append("...")
ans = "".join(an_lis)
print(ans)
| n = int(input())
if n % 2 == 1:
print(0)
elif n % 2 == 0:
ans = 0
k = 10
while n >= k:
ans += n//k
k *= 5
print(ans) | 0 | null | 68,110,739,531,328 | 143 | 258 |
import sys
data = sys.stdin.read()
letters = 'abcdefghijklmnopqrstuvwxyz'
for letter in letters:
count = 0
for d in data:
if letter == d.lower():
count += 1
print(f'{letter} : {count}')
| def solve():
N = int(input())
ans = 0
for i in range(1, N+1):
d = N//i
ans += i * d * (d + 1) / 2
print(int(ans))
solve() | 0 | null | 6,396,133,897,100 | 63 | 118 |
n,m = map(int,input().split())
if(n % 2 == 0):
d = n // 2 - 1
c = 0
i = 1
while(d > 0):
print(i,i+d)
d -= 2
i += 1
c += 1
if(c == m):exit()
d = n // 2 - 2
i = n // 2 + 1
while(d > 0):
print(i,i+d)
d -= 2
i += 1
c += 1
if(c == m):exit()
else:
for i in range(m):
print(i+1,n-i)
| N,M = map(int,input().split())
home = list(map(int,input().split()))
if N - sum(home) < 0:
print("-1")
else:
print(N - sum(home)) | 0 | null | 30,337,662,046,792 | 162 | 168 |
import itertools
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 b in range(4):
for f in range(3):
for r in range(10):
print('', a[b][f][r], end="")
print()
if b < 3:
print("#"*20) | #!/usr/bin/env python
# -*- coding:utf-8 -*-
from __future__ import print_function,division
from itertools import combinations
import time
import sys
import io
import re
import math
start = time.clock()
i = 0
def enum_sum_numbers(sets, s_range, r):
for cmb in combinations(sets,r):
yield sum(cmb)
if r <=s_range:
for s in enum_sum_numbers(sets,s_range, r+1):
yield s
sys.stdin.readline()
a=[int(s) for s in sys.stdin.readline().split()]
sys.stdin.readline()
ms=[int(s) for s in sys.stdin.readline().split()]
sets={s for s in enum_sum_numbers(a,len(a),1)}
for m in ms:
print('yes' if m in sets else 'no') | 0 | null | 597,701,826,968 | 55 | 25 |
N,K = map(int,input().split())
S = []
d = {}
A = list(map(int,input().split()))
ans = 0
sum =0
for i in range(1,N+1):
sum += A[i-1] % K
s = (sum - i) % K
if i > K:
x = S.pop(0)
d[x] -= 1
elif i < K:
if s == 0:
ans += 1
if s not in d:
d[s] = 0
ans += d[s]
d[s] += 1
S.append(s)
print(ans)
| import math,string,itertools,fractions,heapq,collections,re,array,bisect,sys,random,time,copy,functools
from collections import deque
sys.setrecursionlimit(10**7)
inf = 10**20
mod = 10**9 + 7
DR = [1, -1, 0, 0]
DC = [0, 0, 1, -1]
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x)-1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def I(): return int(sys.stdin.readline())
def F(): return float(sys.stdin.readline())
def S(): return input()
def main():
N, K = LI()
A = LI()
cumsum = [0] * (N+1)
c = collections.defaultdict(list)
memo = [0] * (N+1)
c[0].append(0)
for i in range(N):
# cumsum[i] ... [0, i)
cumsum[i+1] = (cumsum[i] % K + A[i]) % K
val = (cumsum[i+1] - (i+1)) % K
memo[i+1] = val
c[val].append(i+1)
# print(cumsum)
# print(memo)
# print(c)
ans = 0
for i in range(N+1):
val = memo[i]
l_ix = bisect.bisect_right(c[val], i)
r_ix = bisect.bisect_right(c[val], i + (K-1))
# print('i: {}, memo[i]: {}, c[val]: {}, l_ix: {}, r_ix: {}'.format(i, memo[i], c[val], l_ix, r_ix))
ans += r_ix - l_ix
# for i in range(N):
# if A[i] % K == 1:
# ans += 1
print(ans)
main()
| 1 | 137,117,201,454,272 | null | 273 | 273 |
N, *A = map(int, open(0).read().split())
mod = 10 ** 9 + 7
ans = 0
for bit in range(60):
ctr = [0, 0]
for i in range(N):
ctr[A[i] >> bit & 1] += 1
ans += (1 << bit) * (ctr[0] * ctr[1])
ans %=mod
print(ans)
| import math
K = int(input())
Sum = 0
for A in range(1,K+1):
for B in range(1,K+1):
for C in range(1,K+1):
Sum = Sum+math.gcd(math.gcd(A,B),C)
print(Sum) | 0 | null | 79,219,898,206,340 | 263 | 174 |
while input()!='0':
l=list(map(float,input().split()))
m=sum(l)/len(l)
s=0
for i in range(len(l)):
s+=(l[i]-m)**2
print('%.8f'%((s/len(l))**.5)) | x = int(input())
rank = 8-(x-400)//200
print(rank) | 0 | null | 3,467,981,506,080 | 31 | 100 |
A,B,K = list(map(int,input().split()))
if A>= K:
print(str(A-K) + ' ' + str(B))
elif A < K :
print(str(0) + ' ' + str(max(B+A-K,0)))
| a, b, k = map(int, input().split())
if a==0 and b==0:
print(0, 0)
elif k>a:
if b-(k-a)>0:
print(0, b-(k-a))
else:
print(0, 0)
elif k<a:
print(a-k, b)
elif a==k:
print(0, b) | 1 | 104,003,578,958,098 | null | 249 | 249 |
X = int(input())
happy = 0
happy += (X // 500) * 1000
happy += ((X - X // 500 * 500) // 5) * 5
print(happy) | # coding: utf-8
import sys
import numpy as np
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
MOD = 998244353
N, S = lr()
A = lr()
dp = np.zeros(S+1, np.int64)
dp[0] = 1
for a in A:
prev = dp.copy()
dp[a:] += dp[:-a]
dp += prev
dp %= MOD
answer = dp[S]
print(answer%MOD)
| 0 | null | 30,164,359,034,172 | 185 | 138 |
N = int(input())
L = []
for _ in range(N):
L.append(list(map(int,input().split())))
ans = 0
for i in range(N-1):
for j in range(i + 1, N):
ans += ((L[i][0] - L[j][0]) ** 2 + (L[i][1] - L[j][1]) ** 2) ** 0.5
ans *= 2 / N
print(ans) | # coding: utf-8
# Your code here!
n = int(input())
ta = 0
ha = 0
for i in range(n):
a, b = list(input().split())
if a == b:
ta += 1
ha += 1
elif a > b:
ta += 3
else:
ha += 3
print(ta,ha)
| 0 | null | 75,100,390,275,042 | 280 | 67 |
n, x, m = map(int, input().split())
a = x
s = 0
h = []
h.append(a)
i = 0
fl = 0
while i < n:
s += a
a = (a*a) % m
if a == 0:
break
i += 1
if fl == 0 and a in h:
fl = 1
po = h.index(a)
ss = 0
for j in range(po):
ss += h[j]
s2 = s - ss
f = (n - po) // (i - po)
s2 *= f
s = s2 + ss
i2 = i - po
i2 *= f
i = i2 + po
else:
h.append(a)
print(s) | import sys
sys.setrecursionlimit(10 ** 7)
rl = sys.stdin.readline
def solve():
N, M, L = map(int, rl().split())
INF = 10 ** 18
dist = [[INF] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, rl().split())
a, b = a - 1, b - 1
dist[a][b] = dist[b][a] = c
for k in range(N):
for i in range(N):
for j in range(N):
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j])
cost = [[INF] * N for _ in range(N)]
for i in range(N):
for j in range(N):
if dist[i][j] <= L:
cost[i][j] = 1
for k in range(N):
for i in range(N):
for j in range(N):
cost[i][j] = min(cost[i][j], cost[i][k] + cost[k][j])
Q = int(rl())
st = [list(map(lambda n: int(n) - 1, rl().split())) for _ in range(Q)]
ans = [-1] * Q
for i, (s, t) in enumerate(st):
if cost[s][t] != INF:
ans[i] = cost[s][t] - 1
print(*ans, sep='\n')
if __name__ == '__main__':
solve()
| 0 | null | 88,524,024,642,810 | 75 | 295 |
lit = input()
length = len(lit)
times = 0
if length != 1:
for i in range(int(length/2)):
if lit[i] != lit[length-1-i]:
times += 1
print(times)
else:
print(times) | s=[]
p=[]
a=i=0
for c in input():
if"\\"==c:s+=[i]
elif"/"==c and s:
j=s.pop()
t=i-j
a+=t
while p and p[-1][0]>j:t+=p[-1][1];p.pop()
p+=[(j,t)]
i+=1
print(a)
if p:print(len(p),*list(zip(*p))[1])
else:print(0)
| 0 | null | 60,021,824,754,332 | 261 | 21 |
n,k = map(int,input().split(' '))
l = list(map(int,input().split(' ')))
count = 0
for i in l:
if i >= k:
count += 1
else:
continue
print(count) | n,k=map(int,input().split())
h=list(map(int,input().split()))
h.sort(reverse=1)
ans=0
for i in h:
if i>=k:ans+=1
print(ans)
| 1 | 178,713,239,366,350 | null | 298 | 298 |
N, R = [int(i) for i in input().split(' ')]
N = min(10,N)
print(R + 100*(10-N)) | n,r = (int(x) for x in input().split())
if n>=10:
print(r)
else:
print(r+(100*(10-n))) | 1 | 63,553,394,804,100 | null | 211 | 211 |
n, k = map(int, input().split())
p = list(map(int, input().split()))
for i, j in enumerate(p):
p[i] = (j*(j+1)/2) / j
t_sum = sum(p[:k])
ans = t_sum
for i in range(n-k):
t_sum = t_sum - p[i] + p[i+k]
if ans < t_sum:
ans = t_sum
print(ans) | import sys
L = int(input())
print((L / 3) ** 3) | 0 | null | 60,868,705,221,732 | 223 | 191 |
t = int(input())
h = int(t/3600)
m = int(t%3600/60)
s = int(t%3600%60)
print(str(h) + ":" + str(m) + ":" + str(s)) | import math;print(2**(int(math.log2(int(input())))+1)-1) | 0 | null | 40,206,670,642,982 | 37 | 228 |
from statistics import median
#import collections
#aa = collections.Counter(a) # list to list || .most_common(2)で最大の2個とりだせるお a[0][0]
from fractions import gcd
from itertools import combinations # (string,3) 3回
from collections import deque
from collections import defaultdict
import bisect
#
# d = m - k[i] - k[j]
# if kk[bisect.bisect_right(kk,d) - 1] == d:
#
#
#
# pythonで無理なときは、pypyでやると正解するかも！！
#
#
import sys
sys.setrecursionlimit(10000000)
mod = 10**9 + 7
def readInts():
return list(map(int,input().split()))
def I():
return int(input())
h = I()
w = I()
n = I()
if h < w:
for i in range(1,h+1):
if i * w >= n:
print(i)
exit()
else:
for i in range(1,w+1):
if i*h >= n:
print(i)
exit()
| import math
h=[int(input())for _ in range(2)]
n=int(input())
print(math.ceil(n/max(h))) | 1 | 88,460,946,796,420 | null | 236 | 236 |
import sys
def input(): return sys.stdin.readline().rstrip()
def main():
n = int(input())
ans = 0
for i in range(1, n+1):
ans += i*(1 + n//i)*(n//i)//2
print(ans)
if __name__=='__main__':
main() | N = int(input())
def calc(start, end):
n = end // start
return (n * (n+1) // 2) * start
ans = 0
for i in range(1, N+1):
ans += calc(i, N//i * i)
print(ans) | 1 | 11,053,880,354,178 | null | 118 | 118 |
n = input()[::-1]
dp = [[0, 0] for i in range(len(n) + 1)]
dp[0][1] = 1
for i in range(len(n)):
dp[i + 1][0] = min(dp[i][0] + int(n[i]), dp[i][1] - int(n[i]) + 10)
dp[i + 1][1] = min(dp[i][0] + int(n[i]) + 1, dp[i][1] - int(n[i]) + 9)
print(dp[len(n)][0]) | n,k = map(int, input().split())
a = list(map(int, input().split()))
gki = sum(a[0:k])
tmp = gki
rng = k
for i in range(k,n):
tmp = tmp-a[i-k]+a[i]
if tmp>gki:
gki = tmp
rng = i+1
E = 0
for i in a[rng-k:rng]:
E += (i+1)/2
print(E) | 0 | null | 72,703,863,625,120 | 219 | 223 |
import collections
n = int(input())
a = list(map(int,input().split()))
b = collections.Counter(a)
for d in range(n):
print(b[d+1]) | import sys
r=int(input())
print(r*r) | 0 | null | 89,053,304,274,450 | 169 | 278 |
from collections import deque
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
sl = []
flag = False
for i in range(h):
for j in range(w):
if s[i][j] == '.':
sl.append([i, j])
q = deque()
dire = [(0, 1), (0, -1), (1, 0), (-1, 0)]
ans = 0
for sh, sw in sl:
c = [[0]*w for _ in range(h)]
q.append((sh, sw, 0))
while q:
ph, pw, k = q.pop()
if c[ph][pw] == 0:
ans = max(ans, k)
c[ph][pw] = 1
for dh, dw in dire:
hdh, wdw = ph+dh, pw+dw
if 0 <= hdh < h and 0 <= wdw < w and c[hdh][wdw] == 0:
if s[hdh][wdw] == '.':
q.appendleft((hdh, wdw, k+1))
print(ans) | n = int(input())
a = [int(x) for x in input().split()]
for i in a:
if i%2==0:
if i%3!=0 and i%5!=0:
print("DENIED")
exit()
print("APPROVED") | 0 | null | 82,098,281,553,232 | 241 | 217 |
S = input()
ans = [0] * (len(S) + 1)
for i in range(len(S)):
if S[i] == '<':
ans[i + 1] = ans[i] + 1
for i in range(len(S) - 1, -1, -1):
if S[i] == '>':
ans[i] = max(ans[i], ans[i + 1] + 1)
print(sum(ans)) |
a,b,c,k = map(int,input().split())
ans = min(a,k)
k -= ans
if k == 0:
print(ans)
exit(0)
k -= min(b,k)
if k == 0:
print(ans)
exit(0)
ans -= min(c,k)
print(ans) | 0 | null | 89,572,699,886,862 | 285 | 148 |
def factorization(n):
if n==1:
return [[1,1]]
temp=n
ans=[]
for i in range(2, int(n**0.5+1.01)):
if temp % i ==0:
ct=0
while temp % i == 0:
temp //= i
ct += 1
ans.append([i, ct])
if temp != 1:
ans.append([temp, 1])
return ans
N=int(input())
L=factorization(N)
if N==1:
print(0)
exit()
ans=0
for l in L:
ct=0
fac=1
while fac<=l[1]:
ct+=1
fac+=ct+1
ans+=ct
print(ans) | X = int(input())
if X>=30:
res = 'Yes'
else:
res = 'No'
print(res) | 0 | null | 11,255,687,663,780 | 136 | 95 |
import sys
input = lambda: sys.stdin.readline().rstrip()
input_nums = lambda: list(map(int, input().split()))
K, X = input_nums()
if 500*K >= X:
print('Yes')
else:
print('No') | #!/usr/bin/env python3
あ, い, う, え = map(int, open(0).read().split())
if あ - う == 0:
print(0)
else:
print(1)
| 0 | null | 111,447,971,289,450 | 244 | 264 |
f=[1,1]
for _ in[0]*43:f+=[f[-2]+f[-1]]
print(f[int(input())])
| import sys
if __name__ == "__main__":
n = int(input())
if n == 0 or n == 1:
print(1)
sys.exit(0)
dp = [0] * (n + 1)
dp[0] = 1
dp[1] = 1
for i in range(2, n + 1):
dp[i] = dp[i - 1] + dp[i - 2]
print(dp[n])
| 1 | 1,604,856,540 | null | 7 | 7 |
n = int(input())
s, t = map(str, input().split())
ans = ''
for a, b in zip(s, t):
ans += a+b
print(ans) | n = input()
a, b = input().split(" ")
output = ""
for s, t in zip(a, b):
output += s
output += t
print(output) | 1 | 111,942,263,362,208 | null | 255 | 255 |
x = int(input())
print((1000 - x % 1000) % 1000) | N = int(input())
print(f"{-N % 1000}") | 1 | 8,480,293,346,030 | null | 108 | 108 |
n,k=map(int, input().split())
def cmb(n, r, p):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % p
p = 10 ** 9 + 7
N = 2*(10 ** 5 ) # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p) 階乗のmod
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, N + 1):
fact.append((fact[-1] * i) % p)
inv.append((-inv[p % i] * (p // i)) % p)
factinv.append((factinv[-1] * inv[-1]) % p)
#0の数がmin(n-1,k)
MAX=min(n-1,k)
dp=[0]*(MAX+1)
dp[0]=1
ans=1
for i in range(1,MAX+1):
ans+=cmb(n,i,p)*cmb(n-i+i-1,i,p)
ans%=p
#print(ans)
print(ans)
| n,k=map(int,input().split())
mod=10**9+7
def inv(x):
return pow(x,mod-2,mod)
N=2*10**5
Fact=[0 for i in range(N+1)]
Finv=[0 for i in range(N+1)]
Fact[0]=1
for i in range(N):
Fact[i+1]=(Fact[i]*(i+1))%mod
Finv[N]=inv(Fact[N])
for i in range(N-1,-1,-1):
Finv[i]=((i+1)*Finv[i+1])%mod
def C(a,b):
return (Fact[a]*(Finv[b]*Finv[a-b])%mod)%mod
ans=0
for i in range(min(n,k+1)):
ans+=(C(n,i)*C(n-1,i))%mod
ans%=mod
print(ans)
| 1 | 67,221,822,965,152 | null | 215 | 215 |
from copy import copy
C,R,K=map(int,input().split())
dp=[[0]*(R+1) for i1 in range(4)]
M=[[0]*R for i in range(C)]
for i in range(K):
r,c,v=map(int,input().split())
M[r-1][c-1]=v
for i,l in enumerate(M):
for num in range(1,4):
for j in range(R):
if num==1:
dp[num][j]= max(dp[num][j-1],dp[num-1][j-1]+M[i][j])
else:
dp[num][j]= max(dp[num][j-1],dp[num-1][j],dp[num-1][j-1]+M[i][j])
dp[0]=dp[-1][1:-1]+[0,dp[-1][0]]
print(dp[-1][-2]) | x, num_of_nums = map(int, input().split(' '))
if num_of_nums == 0:
print(x)
exit()
nums = set(map(int, input().split(' ')))
diff = 0
while True:
n1 = x - diff
n2 = x + diff
if n1 not in nums:
print(n1)
break
if n2 not in nums:
print(n2)
break
diff += 1 | 0 | null | 9,911,946,972,928 | 94 | 128 |
def main():
N = int(input())
A = list(map(int,input().split()))
buka_num = [0]*(N+1)
for i in range(N-1):
buka_num[A[i]] += 1
for i in range(1,N+1,1):
print(buka_num[i])
main()
|
from bisect import bisect_left
from itertools import accumulate
def resolve():
def getCount(x):
cnt = 0
for a in A:
# X未満の個数
idx = bisect_left(A, x - a)
# X以上の個数
cnt += N - idx
# X以上を使う！と決めた時、M個以上になるか
return cnt >= M
N, M = map(int, input().split())
A = sorted(map(int, input().split()))
ng = 10 ** 9
ok = 0
# X以上を使う！と決めるとX以上の個数が自明にわかる。
while ng - ok > 1:
mid = (ok + ng) // 2
if getCount(mid):
ok = mid
else:
ng = mid
# M個以上あることがわかれば、Mよりも余分な数(同じ値が複数ある場合)
# はすべてXである事がわかるため、差分だけ引けば良い。
B = [0] + list(accumulate(A))
ans = 0
cnt = 0
for i in range(N):
idx = bisect_left(A, ok - A[i])
ans += B[N] - B[idx] + A[i] * (N - idx)
cnt += N - idx
rest = (cnt - M) * ok
print(ans - rest)
if __name__ == "__main__":
resolve()
| 0 | null | 70,121,854,559,132 | 169 | 252 |
import math
def pow(p,n):
bin_n=bin(n)[2:][::-1]
tmp=p;pn=1
for i in range(len(bin_n)):
if bin_n[i]=="1": pn=(pn*tmp)%mod
tmp=tmp*tmp%mod
return pn
mod=10**9+7
n,k=map(int,input().split())
ans=[0]*(k+1)
for i in range(k,0,-1):
div=set()
for x in range(1,int(i**0.5)+1):
if i%x==0: div.add(x);div.add(i//x)
ans[i]=pow(k//i,n)-sum([ans[j*i] for j in range(k//i,1,-1)])
ans[i]%=mod
print(sum(ans[i]*i for i in range(k+1))%mod) | n=int(input())
a=list(map(int,input().split()))
for i in range(n):
a[i]=[a[i],i]
a.sort()
a.reverse()
dp=[[0 for i in range(n+1)] for j in range(n+1)]
for i in range(n):
for j in range(n):
if i+j<=n-1:
dp[i+1][j]=max(dp[i+1][j],dp[i][j]+a[i+j][0]*abs(a[i+j][1]-i))
dp[i][j+1]=max(dp[i][j+1],dp[i][j]+a[i+j][0]*abs(a[i+j][1]-(n-j-1)))
ans=[]
for i in range(n):
ans.append(dp[i][n-i])
print(max(ans)) | 0 | null | 35,469,410,597,110 | 176 | 171 |
N = input()
A=[]
for i in N:
A.append(i)
hon = ["2","4","5","7","9"]
pon = ["0","1","6","8"]
bon = ["3"]
if A[-1] in hon:
print("hon")
elif A[-1] in pon:
print("pon")
else:
print("bon") | def main():
n = input()
hon = ['2', '4', '5', '7', '9']
pon = ['0', '1', '6', '8']
bon = ['3']
if n[len(n)-1] in hon:
print('hon')
elif n[len(n)-1] in pon:
print('pon')
else:
print('bon')
if __name__ == "__main__":
main()
| 1 | 19,295,923,223,510 | null | 142 | 142 |
N=int(input())
c=0
for i in range(1,N+1):
if i%3!=0 and i%5!=0:c+=i
print(c) | N = int(input())
ans = 0
for i in range(N):
j = i + 1
if j % 3 != 0 and j % 5 != 0:
ans += j
print(ans) | 1 | 34,978,386,342,658 | null | 173 | 173 |
import sys
if __name__ == '__main__':
letter_counts = [0] * 26 # ?????¢????????????????????????????????° [0]???'a'???[25]???'z'??????????????°
for line in sys.stdin:
# ?°?????????¨??§??????????????\????????????
lower_text = line.lower()
# ??¢???????????????????????¨??????????????°???????¨?
for c in lower_text:
if 'a' <= c <= 'z':
letter_counts[ord(c)-ord('a')] += 1
# ????????? 'a : a????????°' ?????¢??§z?????§1????????¨?????????
for i, n in enumerate(letter_counts):
print('{0} : {1}'.format(chr(ord('a')+i), n)) | text = ''
while(True):
try:
text += input().lower()
except:
break
count = [0 for i in range(26)]
for c in text:
if c < 'a' or c > 'z':
continue
count[ord(c) - ord('a')] += 1
for i, c in enumerate(count):
print('{0} : {1}'.format(chr(i + ord('a')), c)) | 1 | 1,624,333,388,340 | null | 63 | 63 |
n, q = map(int, input().split(' '))
p = []
time = 0
counter = 0
for i in range(n):
tmp_n, tmp_p = input().split(' ')
tmp_p = int(tmp_p)
p.append((tmp_n, tmp_p))
while len(p) > 0:
task = p.pop(0)
tmp_p = task[1] - q
if( tmp_p > 0):
time += q
p.append((task[0], tmp_p))
elif( tmp_p <= 0):
time += task[1]
print('{} {}'.format(task[0], time))
| time = 0
n, q = map(int, input().split())
qname = list(range(n))
qtime = list(range(n))
ename = []
etime = []
for i in range(n):
inp = input().split()
qname[i], qtime[i] = inp[0], int(inp[1])
while len(qtime) > 0:
if qtime[0] <= q:
time += qtime.pop(0)
ename.append(qname.pop(0))
etime.append(time)
else:
time += q
qname.append(qname.pop(0))
qtime.append(qtime.pop(0)-q)
for (a, b) in zip(ename, etime):
print(a, b) | 1 | 44,981,098,660 | null | 19 | 19 |
n,m=input().split()
print(m+n) | # coding: utf-8
import sys
from functools import lru_cache
sys.setrecursionlimit(10 ** 9)
sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))
N = ir()
A = lr()
INF = 10 ** 17
@lru_cache(None)
def F(index, n):
if index >= N:
return -INF
if N - index < 2 * n - 1:
return -INF
if n == 0:
return 0
elif n == 1:
return max(A[index:])
ret = max(A[index] + F(index+2, n-1), F(index+1, n))
return ret
answer = F(0, N//2)
print(answer)
| 0 | null | 69,864,616,251,782 | 248 | 177 |
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# import heapq
# from collections import deque
# N = int(input())
S = input()
T = input()
# n, *a = map(int, open(0))
# N, M = map(int, input().split())
# A = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
# 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
ma = 0
s = len(S)
t = len(T)
for i in range(s - t + 1):
cnt = 0
for j in range(t):
if S[i + j] == T[j]:
cnt += 1
if cnt > ma:
ma = cnt
print(t - ma) | S=input()
T=input()
Slen=len(S)
Tlen=len(T)
ans=5000
for i in range(0,Slen-Tlen+1):
tans=0
for j in range(0,Tlen):
if S[i+j]!=T[j]:
tans+=1
if tans<ans:
ans=tans
print(ans)
| 1 | 3,685,596,001,760 | null | 82 | 82 |
class DoublyLinkedList:
def __init__(self):
self.nil = self.make_node(None)
self.nil['next'] = self.nil
self.nil['prev'] = self.nil
def make_node(self, k):
return {'key':k, 'next':None,'prev':None}
def insert(self, key):
x = self.make_node(key)
x['next'] = self.nil['next']
self.nil['next']['prev'] = x
self.nil['next'] = x
x['prev'] = self.nil
def listSearch(self,key):
cur = self.nil['next']
while cur['key'] != None and cur['key'] != key:
cur = cur['next']
return cur
def delete(self, k):
self.delete_node(self.listSearch(k))
def delete_node(self,x):
if x['key'] == None: return
x['prev']['next'] = x['next']
x['next']['prev'] = x['prev']
def deleteFirst(self):
self.delete_node(self.nil['next'])
def deleteLast(self):
self.delete_node(self.nil['prev'])
def printList(self):
x = self.nil['next']
while True:
if x['key'] == None:
break
else:
print x['key'],
x = x['next']
print
def main():
N = int(raw_input())
commands = []
for i in xrange(N):
commands.append(raw_input())
d = DoublyLinkedList()
for c in commands:
a = c[0]
if a == 'i':
d.insert(int(c[7:]))
else:
if c[6] == 'F':
d.deleteFirst()
elif c[6] == 'L':
d.deleteLast()
else:
d.delete(int(c[7:]))
d.printList()
return 0
main() | n = int(input())
import collections
d = collections.deque([])
for _ in range(n):
s = input().split()
if s[0] == "deleteFirst":
d.popleft()
elif s[0] == "deleteLast":
d.pop()
elif s[0] == "insert":
d.appendleft(s[1])
else:
try:
d.remove(s[1])
except:
pass
print(" ".join(d))
| 1 | 51,772,199,772 | null | 20 | 20 |
a,b,c=map(int,input().split())
list=[a,b,c]
list.sort()
print(list[0],list[1],list[2])
| a,b,c = map (int,input().split())
if b < a :
a , b = b , a
if c < a :
a , c = c , a
if c < b :
b , c = c , b
print(a,b,c)
| 1 | 413,093,840,710 | null | 40 | 40 |
#!/usr/bin/env python3
S = input()
print(len(S) * 'x')
| class Queue:
def __init__(self, n):
self.values = [None]*n
self.n = n
self.s = 0
self.t = 0
def next(self, p):
ret = p+1
if ret >= self.n:
ret = 0
return ret
def enqueue(self, x):
if self.next(self.s) == self.t:
raise Exception("Overflow")
self.values[self.s] = x
self.s = self.next(self.s)
def dequeue(self):
if self.s == self.t:
raise Exception("Underflow")
ret = self.values[self.t]
self.t = self.next(self.t)
return ret
n, q = map(int, raw_input().split(' '))
queue = Queue(n+1)
for _ in range(n):
name, time = raw_input().split(' ')
time = int(time)
queue.enqueue((name, time))
completed = []
cur = 0
while len(completed) < n:
name, time = queue.dequeue()
res = time-q
if res <= 0:
cur += time
completed.append((name, cur))
else:
cur += q
queue.enqueue((name, res))
for name, time in completed:
print name, time | 0 | null | 36,501,252,218,880 | 221 | 19 |
data = input()
x = []
x = data.split()
a = int(x[0])
b = int(x[1])
c = int(x[2])
if(a < b < c):
print('Yes')
else:
print("No") | a,b = map(int,input().split())
f = str(a)*b
n = str(b)*a
if f > n:
print(n)
else:
print(f) | 0 | null | 42,191,473,814,240 | 39 | 232 |
rad = int(input())
print (2*3.1415926*rad) | # -*- coding: utf-8 -*-
import math
a = int(input())
print(2*a*math.pi) | 1 | 31,376,272,941,900 | null | 167 | 167 |
from random import randint, random, seed
from math import exp
from time import time
import sys
input = sys.stdin.readline
INF = 9223372036854775808
def calc_score(D, C, S, T):
"""
開催日程Tを受け取ってそこまでのスコアを返す
コンテストi 0-indexed
d 0-indexed
"""
score = 0
last = [0]*26 # コンテストiを前回開催した日
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
return score
def update_score(D, C, S, T, score, ct, ci):
"""
ct日目のコンテストをコンテストciに変更する
スコアを差分更新する
ct: change t 変更日 0-indexed
ci: change i 変更コンテスト 0-indexed
"""
new_score = score
last = [0]*26 # コンテストiを前回開催した日
prei = T[ct] # 変更前に開催する予定だったコンテストi
for d, t in enumerate(T, start=1):
last[t] = d
new_score += (d - last[prei])*C[prei]
new_score += (d - last[ci])*C[ci]
last = [0]*26
for d, t in enumerate(T, start=1):
if d-1 == ct:
last[ci] = d
else:
last[t] = d
new_score -= (d - last[prei])*C[prei]
new_score -= (d - last[ci])*C[ci]
new_score -= S[ct][prei]
new_score += S[ct][ci]
return new_score
def evaluate(D, C, S, T, k):
"""
d日目終了時点での満足度を計算し，
d + k日目終了時点での満足度の減少も考慮する
"""
score = 0
last = [0]*26
for d, t in enumerate(T):
last[t] = d + 1
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
score += S[d][t]
for d in range(len(T), min(len(T) + k, D)):
for i in range(26):
score -= (d + 1 - last[i]) * C[i]
return score
def greedy(D, C, S):
Ts = []
for k in range(7, 9):
T = [] # 0-indexed
max_score = -INF
for d in range(D):
# d+k日目終了時点で満足度が一番高くなるようなコンテストiを開催する
max_score = -INF
best_i = 0
for i in range(26):
T.append(i)
score = evaluate(D, C, S, T, k)
if max_score < score:
max_score = score
best_i = i
T.pop()
T.append(best_i)
Ts.append((max_score, T))
return max(Ts, key=lambda pair: pair[0])
def local_search(D, C, S, score, T):
sTime = time()
T0 = 55e2
T1 = 9e2
TL = 1.96
Temp = T0
k = 0
e = 0
best_score = score
best_T = T
while e < 1.3:
if k % 100 == 0:
e = (time() - sTime)
if e > TL:
break
t = e / TL
Temp = pow(T0, 1-t) * pow(T1, t)
sel = randint(1, 2+k//10000)
if sel == 1:
# ct 日目のコンテストをciに変更
ct = randint(0, D-1)
ci = randint(0, 25)
new_score = update_score(D, C, S, T, score, ct, ci)
if score < new_score or \
(new_score > 4*10**6 + k*10000 and
exp((score - new_score)/Temp) > 0.5):
T[ct] = ci
score = new_score
else:
# ct1 日目と ct2 日目のコンテストをswap
ct1 = randint(0, D-1)
ct2 = randint(0, D-1)
ci1 = T[ct1]
ci2 = T[ct2]
new_score = update_score(D, C, S, T, score, ct1, ci2)
new_score = update_score(D, C, S, T, new_score, ct2, ci1)
if score < new_score or \
(new_score > 4*10**6 + k*10000 and
exp((score - new_score)/Temp) > 0.5):
score = new_score
T[ct1] = ci2
T[ct2] = ci1
if best_score < score:
best_score = score
best_T = T
k += 1
return best_T
if __name__ == '__main__':
seed(1)
D = int(input())
C = [int(i) for i in input().split()]
S = [[int(i) for i in input().split()] for j in range(D)]
init_score, T = greedy(D, C, S)
T = local_search(D, C, S, init_score, T)
for t in T:
print(t+1)
| if __name__ == '__main__':
key_in = input()
data = key_in.split(' ')
a = int(data[0])
b = int(data[1])
c = int(data[2])
if a < b < c:
print('Yes')
else:
print('No') | 0 | null | 5,075,009,364,480 | 113 | 39 |
S = str(input())
n = len(S)
m = n//2
ans = 0
for i in range(m):
if S[i] != S[-1-i]:
ans +=1
print(ans)
| import sys
input = sys.stdin.readline
def read():
S = input().strip()
return S,
def solve(S):
N = len(S)
ans = 0
for i in range(N//2):
if S[i] != S[N-i-1]:
ans += 1
return ans
if __name__ == '__main__':
inputs = read()
print(solve(*inputs))
| 1 | 119,911,100,681,020 | null | 261 | 261 |
n, m = map(int, input().split())
A = list(map(int, input().split()))
s = 0
for i in range(m):
s += A[i]
if s > n:
print(-1)
elif s <= n:
print(n - s) | N = int(input())
A = N%10
B = [2,4,5,7,9]
C = [0,1,6,8]
if A in B:
print('hon')
elif A in C:
print('pon')
else:
print('bon') | 0 | null | 25,587,213,542,300 | 168 | 142 |
from bisect import*
n, *l = map(int, open(0).read().split())
l.sort()
print(sum(max(0, bisect_left(l, l[i] + l[j]) - j - 1) for i in range(n) for j in range(i+1, n))) | def resolve():
n=int(input())
a=list(map(int,input().split()))
q=int(input())
m=list(map(int,input().split()))
sa=[0]*100000
for i in range(2**n):
s=0
for j in range(n):
if i>>j&1:
s+=a[j]
sa[s]=1
for i in m:
if sa[i]==0:
print('no')
else:
print('yes')
if __name__ == '__main__':
resolve()
| 0 | null | 85,991,557,313,192 | 294 | 25 |
N =int(input())
S =set(input() for i in range(N))
print(len(S))
|
from functools import reduce
def comb(n, max_k, mod):
"""
(n,k) := n個からk個選ぶ組み合わせ
k = 0~max_Kまでを計算して返す
"""
res = [1]*(max_k+1)
t = 1
for i in range(max_k+1):
res[i] *= t
t *= n-i
t %= mod
n = reduce(lambda x,y: (x*y)%mod, range(1,max_k+1), 1)
n = pow(n, mod-2, mod)
for i in reversed(range(max_k+1)):
res[i] *= n
res[i] %= mod
n *= i
n %= mod
return res
X,Y = map(int,input().split())
d = X+Y
if d%3 != 0:
print(0)
else:
n = d//3
if X < n or 2*n < X:
res = 0
else:
res = comb(n,X-n, 10**9+7)[X-n]
print(res)
| 0 | null | 89,724,137,432,932 | 165 | 281 |
def GCD(a,b):
while (a % b) != 0:
a,b = b, a%b
return b
def LCM(a,b):
return a * b / GCD(a,b)
while True:
try:
a,b =map(int,raw_input().split())
print GCD(a,b),LCM(a,b)
except:
break | import sys
def gcd(x, y):
if y == 0:
return x
else:
return gcd(y, x%y)
def lcm(x, y):
return x * y //gcd(x,y)
for line in sys.stdin:
x, y = map(int, line.split())
print(gcd(x, y), lcm(x,y)) | 1 | 694,126,368 | null | 5 | 5 |
X=int(input())
A=X//200
print(10-A) | import sys
from collections import deque
N, M = map(int, input().split())
edge = [[] for _ in range(N)]
for s in sys.stdin.readlines():
a, b = map(lambda x: int(x) - 1, s.split())
edge[a].append(b)
edge[b].append(a)
path = [0] * N
cnt = 0
for i in range(N):
if path[i] == 0:
cnt += 1
q = deque()
path[i] = 1
q.append(i)
while q:
p = q.popleft()
for np in edge[p]:
if path[np] == 0:
path[np] = 1
q.append(np)
print(cnt - 1)
| 0 | null | 4,464,302,718,700 | 100 | 70 |
s = input()
MOD = 2019
d = [0] * MOD
d[0] = 1
r = 0
t = 1
for i in reversed(s):
r += int(i) * t
r %= MOD
t *= 10
t %= MOD
d[r] += 1
print(sum(i * (i - 1) // 2 for i in d)) | s = input()
n = len(s)
m = 2019
a = [0] * (n + 1)
b = [0] * (n + 1)
b[0] = 1
for i in range(1, n + 1):
b[i] = b[i - 1] * 10 % m
c = [0] * m
c[0] += 1
ans = 0
for i in range(n - 1, -1, -1):
w = (a[i + 1] + (ord(s[i]) - ord('0')) * b[n - 1 - i]) % m
ans += c[w]
c[w] += 1
a[i] = w
print(ans) | 1 | 30,789,159,157,262 | null | 166 | 166 |
n = int(input())
list = [i for i in input().split()]
list.reverse()
print(" ".join(list)) | a = []
for i in range(0,2):
l = list(map(int,input().split()))
a.append(l)
d = a[1][::-1]
print(' '.join(map(str,d))) | 1 | 970,818,324,782 | null | 53 | 53 |
n,k = map(int,input().split())
a = list(map(int,input().split()))
f = list(map(int,input().split()))
lim = sum(a) -k
if(lim <= 0):
print(0)
exit()
min_ = 0
max_ = 10**12+1
a.sort()
a = tuple(a)
f.sort(reverse=True)
f = tuple(f)
for i in range(100):
tmp = (max_ + min_)//2
tmp_sum = 0
for j in range(n):
tmp_sum += max(0, a[j] - tmp//f[j])
if(tmp_sum <= k):
max_ = tmp
else:
min_ = tmp
if(max_ - min_ == 1):
break
print(max_) | N,K=map(int, input().split())
A=list(map(int, input().split()))
F=list(map(int, input().split()))
A=sorted(A)
F=sorted(F)[::-1]
import numpy as np
a=np.array(A)
f=np.array(F)
low=-1
high=10**18
while high-low>1:
d=(high+low)//2
#0かa-d//fの大きい値を採用するnp.maximum
if np.maximum(0,a-d//f).sum()<=K:
high=d
else:
low=d
print(high) | 1 | 164,972,354,676,350 | null | 290 | 290 |
N, *A = map(int, open(0).read().split())
mod = 10**9 + 7
ans = 0
for i in range(60):
mask = 1 << i
cnt = 0
for a in A:
if a & mask:
cnt += 1
x = cnt * (N-cnt)
x *= mask % mod
ans += x
ans %= mod
print(ans)
| import sys
for line in sys.stdin:
m, f, r = map(int, line.split())
if m == f == r == -1:
break
if m == -1 or f == -1:
print('F')
elif (m + f) >= 80:
print('A')
elif (m + f) >= 65:
print('B')
elif (m + f) >= 50:
print('C')
elif (m + f) >= 30:
if r >= 50:
print('C')
else:
print('D')
else:
print('F') | 0 | null | 62,406,671,921,188 | 263 | 57 |
s = input()
ans = s[0:3]
print(ans) | mountain = [int(input()) for _ in range(10)]
mountain.sort()
for _ in -1, -2, -3 : print(mountain[_]) | 0 | null | 7,427,448,129,184 | 130 | 2 |
K = int(input())
tmp = 1
ans = -1
if K % 7 == 0:
L = 9 * K // 7
else:
L = 9 * K
for i in range(10 ** 7):
tmp *= 10
tmp = tmp % L
if tmp == 1:
ans = i + 1
break
print(ans) | import sys
input = sys.stdin.readline
import numpy as np
from numba import njit
def read():
D = int(input().strip())
C = np.fromstring(input().strip(), dtype=np.int32, sep=" ")
S = np.empty((D, 26), dtype=np.int32)
for i in range(D):
s = np.fromstring(input().strip(), dtype=np.int32, sep=" ")
S[i, :] = s[:]
T = np.array([int(input().strip()) for i in range(D)], dtype=np.int32)
return D, C, S, T
@njit
def satisfaction(d, C, S, T, last):
v = 0
v += S[d, T[d]-1]
last[T[d]-1] = d+1
for i in range(26):
v -= C[i] * ((d+1) - last[i])
return v
@njit
def solve(D, C, S, T):
last = np.zeros(26, dtype=np.int32)
cumsat = 0
for i in range(D):
sat = satisfaction(i, C, S, T, last)
cumsat += sat
print(cumsat)
if __name__ == '__main__':
inputs = read()
outputs = solve(*inputs)
if outputs is not None:
print("%s" % str(outputs))
| 0 | null | 8,091,945,967,040 | 97 | 114 |
import itertools
n,m,q = map(int,input().split())
abcd = [list(map(int,input().split())) for _ in range(q)]
maxpt = 0
for lis in itertools.combinations_with_replacement(range(1, m+1), n):
forpt = 0
for i in range(q):
if lis[abcd[i][1]-1] - lis[abcd[i][0]-1] == abcd[i][2]:
forpt += abcd[i][3]
maxpt = max(maxpt,forpt)
print(maxpt) | import sys
sys.setrecursionlimit(10 ** 7)
f_inf = float('inf')
mod = 10 ** 9 + 7
res = 0
def resolve():
def dfs(v, A):
global res
if len(A) == n:
total = 0
for a, b, c, d in query:
if A[b - 1] - A[a - 1] == c:
total += d
res = max(res, total)
else:
for i in range(v, m + 1):
A.append(i)
dfs(i, A)
A.pop()
n, m, q = map(int, input().split())
query = [list(map(int, input().split())) for _ in range(q)]
dfs(1, [])
print(res)
if __name__ == '__main__':
resolve()
| 1 | 27,396,496,016,822 | null | 160 | 160 |
import math
N = int(input())
for i in range(N+1):
if math.floor(1.08 * i) == N:
print(i)
exit()
print(":(")
| 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)
| 0 | null | 65,866,825,620,780 | 265 | 96 |
N = int(input())
print(max(N//2, (N+1)//2)) | N = int(input())
S = input()
ans = 0
for n in range(N-2):
if S[n:n+3] == "ABC":
ans += 1
print(ans) | 0 | null | 79,190,120,755,228 | 206 | 245 |
n,k=map(int,input().split());n,c=set(range(1,n+1)),set()
for i in range(k):
input();c|=set(map(int,input().split()))
print(len(n^c)) | s=input()
rs=s[::-1]
ans=0
for i in range (len(s)):
if s[i] != rs[i]:
ans+=1
print(ans//2)
| 0 | null | 72,716,264,498,084 | 154 | 261 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def main():
s, t = input().split()
print(t+s)
if __name__ == '__main__':
main() | import sys
S,T = input().split()
if not ( S.islower() and T.islower() ): sys.exit()
if not ( 1 <= len(S) <= 100 and 1 <= len(S) <= 100 ): sys.exit()
print(T,S,sep='') | 1 | 103,099,914,671,738 | null | 248 | 248 |
import math
n=input()
m=10**2
for i in range(n):
m=m*1.05
m=math.ceil(m)
print int(m*(10**3)) | n = int(input())
debt = 100000
for i in range(n):
debt = debt * 1.05
round = debt % 1000
if round != 0:
debt = (debt // 1000 + 1) * 1000
print(int(debt)) | 1 | 1,219,622,432 | null | 6 | 6 |
H, N = list(map(int, input().split()))
A = [[0]*2 for _ in range(N)]
for _ in range(N):
A[_][0], A[_][1] = list(map(int, input().split()))
# print(A)
# A.sort(key=lambda x: x[1])
INF = float('inf')
dp = [INF]*(H+1)
dp[0] = 0
for i in range(H):
if dp[i] == INF:
continue
for j in range(N):
a = A[j][0]
b = A[j][1]
if i+a >= H:
dp[H] = min(dp[H], dp[i]+b)
else:
dp[i+a] = min(dp[i+a], dp[i]+b)
print(dp[H]) | h,n= map(int, input().split())
p = [list(map(int, input().split())) for _ in range(n)]
m = 10**4
dp = [0]*(h+m+1)
for i in range(m+1,h+m+1):
dp[i] = min(dp[i-a] + b for a,b in p)
print(dp[h+m]) | 1 | 80,710,747,757,562 | null | 229 | 229 |
M,D=map(int, input().split())
MM,DD=map(int, input().split())
if MM-1==M or (MM-1==0 and M==12):
print(1)
else:
print(0) | a,b=input().split()
c,d=input().split()
b=int(b)
d=int(d)
if d-b==1:
print("0")
else:
print("1")
| 1 | 124,584,458,248,250 | null | 264 | 264 |
A,B,C,K=map(int,input().split())
R=A+B
if K<A:
print(K)
elif K<=R:
print(A)
else:
T=K-R
print(A-T)
| a, b, c, k = map(int, input().split())
ans = 0
ans += min(a, k)
k -= min(a, k)
k -= min(b, k)
ans -= min(c, k)
print(ans)
| 1 | 21,839,370,791,942 | null | 148 | 148 |
n = int(input())
rooms = [[[0 for i in range(10)] for j in range(3)] for k in range(4)]
for rec in range(n):
b, f, r, v = map(int, input().split())
rooms[b-1][f-1][r-1] += v
for i, b in enumerate(rooms):
for f in b:
print("",*f)
if i != 3:
print("####################") | s = input()
ans = 0
if 'RRR' in s:
ans = 3
elif 'RR' in s:
ans = 2
elif 'R' in s:
ans = 1
print(ans) | 0 | null | 3,009,777,918,878 | 55 | 90 |
from math import gcd
N = int(input())
A = list(map(int,input().split()))
g = A[0]
for i in range(1,N):
g = gcd(g,A[i])
if g>1:
print("not coprime")
exit()
MAXN = 10**6 + 9
D = [i for i in range(MAXN+1)]
p = 2
while(p*p <=MAXN):
if D[p]==p:
for q in range(2*p,MAXN+1,p):
if D[q]==q:
D[q]=p
p+=1
st = set()
for a in A:
tmp = set()
while(a>1):
tmp.add(D[a])
a //=D[a]
for p in tmp:
if p in st:
print("setwise coprime")
exit()
st.add(p)
print("pairwise coprime")
| # 回答を読んで作成
# 全体の半分に到達可能、ただし１行もしくは１列の時は動けない
h,w = map(int, input().split())
if h==1 or w==1:
ans = 1
else:
ch = (h*w)/2
ans = (ch//1)+((h*w)%2)
print(int(ans)) | 0 | null | 27,489,248,203,638 | 85 | 196 |
import sys
N = int(input())
A = list(map(int, input().split()))
LA = len(A)
ans = A[0]
for j in range(LA):
if A[j] == 0:
print('0')
sys.exit()
for i in range(LA-1):
ans = ans*A[i+1]
if ans > 10**18:
print('-1')
sys.exit()
print(ans)
| x,y = map(int,input().split())
#xをベースに
r = 0 #→2 ↑1
u = x #→1 ↑2
while y != r + u*2:
u -= 2
r += 1
if u < 0: #到達する方法がない
print(0)
exit()
#modありのコンビネーション計算
def cmb(n, r, mod):
if ( r<0 or r>n ):
return 0
r = min(r, n-r)
return g1[n] * g2[r] * g2[n-r] % mod
mod = 10**9 + 7
N = u+r+1 #必要な数
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 )
print(cmb(u+r,r,mod))
| 0 | null | 82,752,673,601,950 | 134 | 281 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.