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
|
|---|---|---|---|---|---|---|
from math import ceil,floor,factorial,gcd,sqrt,log2,cos,sin,tan,acos,asin,atan,degrees,radians,pi,inf,comb
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
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 LIST() : return list(MAP())
n = INT()
x = [[0]*2 for i in range(n)]
for i in range(n):
x[i][0], x[i][1] = MAP()
x.sort()
tmp = -inf
ans = n
for i in range(n):
if tmp > x[i][0] - x[i][1]:
ans -= 1
tmp = min(tmp, x[i][0] + x[i][1])
else:
tmp = x[i][0] + x[i][1]
print(ans) | def FizzBuzz_sum():
# 入力
N = int(input())
# 初期処理
N = [i for i in range(1,N+1)]
sum = 0
# 比較処理
for i in N:
if i % 3 == 0 and i % 5 == 0:
pass
elif i % 3 == 0:
pass
elif i % 5 == 0:
pass
else:
sum += i
return sum
result = FizzBuzz_sum()
print(result) | 0 | null | 62,279,800,989,692 | 237 | 173 |
import sys
#input = sys.stdin.buffer.readline
# mod=10**9+7
# rstrip().decode('utf-8')
# map(int,input().split())
# import numpy as np
def main():
n=int(input())
s=[]
t=[]
for i in range(n):
a,b=input().split()
s.append(a)
t.append(int(b))
x=input()
for i in range(n):
if x==s[i]:
print(sum(t[i+1:]))
if __name__ == "__main__":
main()
| N = int(input())
music = []
time = []
for i in range(N):
m,t = input().split()
music.append(m)
time.append(int(t))
S = input()
ans = 0
ans += sum(time[music.index(S)+1:])
print(ans) | 1 | 97,146,581,380,202 | null | 243 | 243 |
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, T = LI()
AB = []
for i in range(N):
_a, _b = LI()
AB.append((_a, _b))
AB = sorted(AB, key=lambda x: (x[0], x[1]))
a = [elem[0] for elem in AB]
b = [elem[1] for elem in AB]
dp = [[0 for _ in range(T + 3001)] for _ in range(N+1)]
for i in range(N):
for t in range(T):
dp[i+1][t+a[i]] = max(dp[i+1][t+a[i]], dp[i][t] + b[i])
dp[i+1][t] = max(dp[i+1][t], dp[i][t])
ans = 0
for i in range(N+1):
for j in range(T + 3001):
ans = max(dp[i][j], ans)
print(ans)
main()
| import sys
input = sys.stdin.readline
from collections import defaultdict, deque
n, s = int(input()), list(map(int, input().split()))
res = [0 for i in range(n)]
for i in range(n): res[s[i]-1] = i + 1
print(' '.join(str(i) for i in res)) | 0 | null | 166,078,886,112,260 | 282 | 299 |
N = int(input())
a = []
for i in range(N):
a.append(input())
a = sorted(a)
count = 0
count_list=[]
b = []
for i,k in enumerate(a):
if i == 0:
continue
if k == a[i-1]:
count+=1
else:
count_list.append(count)
b.append(a[i-1])
count = 0
if i==N-1:
count_list.append(count)
b.append(a[i])
maxi = 0
maxi_list =[]
for i,k in enumerate(count_list):
if maxi <k:
maxi_list.clear()
maxi_list.append(b[i])
maxi = k
elif maxi == k:
maxi_list.append(b[i])
else:
continue
for i in maxi_list:
print(i)
| import sys
stdin = sys.stdin
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
nn = lambda: list(stdin.readline().split())
ns = lambda: stdin.readline().rstrip()
n,r = na()
print(r+max(0,100*(10-n))) | 0 | null | 66,923,689,248,790 | 218 | 211 |
import sys
input = sys.stdin.readline
N=int(input())
L=list(map(int,input().split()))
Q=int(input())
R=[0]*(10**5)
for i in L:
R[i-1]+=1
ans=sum(L)
for i in range(Q):
a,b=map(int,input().split())
R[b-1]+=R[a-1]
ans+=(b-a)*R[a-1]
R[a-1]=0
print(ans) | #template
def inputlist(): return [int(j) for j in input().split()]
#template
"""
H,W = inputlist()
st = inputlist()
gl = inputlist()
maze = ['0']*H
for i in range(H):
maze[i] = list(input())
table = [[10**9+7]*W for _ in range(H)]
"""
D,T,S = inputlist()
time = D//S + int(D%S != 0)
if time <= T:
print("Yes")
else:
print("No")
| 0 | null | 7,920,048,575,168 | 122 | 81 |
import bisect
import itertools
import numpy as np
def search_cut(N, M, A):
high_cut = A[-1] * 2
low_cut = A[0] * 2
while high_cut > low_cut + 1:
mid = (high_cut + low_cut) // 2
count = (N - np.searchsorted(A, mid - A, side = 'left')).sum()
if count > M:
low_cut = mid
else:
high_cut = mid
return low_cut, high_cut
def happiness(N, M, A, low_cut, high_cut):
A_sum = np.zeros(N + 1)
A_sum[1:] = np.cumsum(A)
X = np.searchsorted(A, high_cut - A, side = 'left')
happiness = (A_sum[-1] - A_sum[X]).sum()
happiness += ((N - X) * A).sum()
happiness += (M - (N - X).sum()) * low_cut
return int(happiness)
N, M = map(int, input().split())
A = np.array(list(map(int, input().split())))
A = np.sort(A)
low_cut, high_cut = search_cut(N, M, A)
ans = happiness(N, M, A, low_cut, high_cut)
print(ans)
| import statistics
while True:
n = int(input())
if n == 0:
break
scores = list((int(x) for x in input().split()))
std = statistics.pstdev(scores)
print("{0:.8f}" . format(round(std,8)))
| 0 | null | 54,126,939,148,360 | 252 | 31 |
w,h,x,y,r=map(int,raw_input().split())
f=0
if x+r>w:
f=1
if y+r>h:
f=1
if r>x:
f=1
if r>y:
f=1
if f==0:
print "Yes"
else:
print "No" | w, h, x, y, r = map(int, input().split())
if x - r < 0:
print('No')
elif x + r > w:
print('No')
elif y - r < 0:
print('No')
elif y + r > h:
print('No')
else:
print('Yes')
| 1 | 461,626,192,640 | null | 41 | 41 |
while True:
x = input().split()
if x[1] == '+':
y = int(x[0])+int(x[2])
print(y)
elif x[1] == '-':
y = int(x[0])-int(x[2])
print(y)
elif x[1] == '*':
y = int(x[0])*int(x[2])
print(y)
elif x[1] == '/':
y = int(x[0])//int(x[2])
print(y)
elif x[1] == '?':
break | while True:
s = raw_input().split()
if '?' == s[1]:
break
if '+' == s[1]:
print int(s[0])+int(s[2])
if '-' == s[1]:
print int(s[0])-int(s[2])
if '*' == s[1]:
print int(s[0])*int(s[2])
if '/' == s[1]:
print int(s[0])/int(s[2]) | 1 | 672,855,257,230 | null | 47 | 47 |
def resolve():
N, M, Q = list(map(int, input().split()))
Q = [list(map(int, input().split())) for _ in range(Q)]
import itertools
maxpoint = 0
for seq in itertools.combinations_with_replacement(range(1, M+1), N):
point = 0
for a, b, c, d in Q:
if seq[b-1] - seq[a-1] == c:
point += d
maxpoint = max(maxpoint, point)
print(maxpoint)
if '__main__' == __name__:
resolve() | from collections import deque
N, M, Q = map(int, input().split())
A = [list(map(int, input().split())) for i in range(Q)]
def calc(x):
ans = 0
for a, b, c, d in A:
if int(x[b-1]) - int(x[a-1]) == c:
ans += d
return ans
q = deque([[1]])
ans = 0
while q:
tmp = q.popleft()
if len(tmp) == N:
ans = max(ans, calc(tmp))
else:
for i in range(tmp[-1], M+1):
q.append(tmp+[i])
print(ans) | 1 | 27,645,012,028,502 | null | 160 | 160 |
n = int(input())
A = list(map(int, input().split(' ')))
q = int(input())
M = list(map(int, input().split(' ')))
# 上限と下限でフィルター
max_A = 0
min_A = float('inf')
for num in A:
max_A += num
if num < min_A:
min_A = num
def rec(i, m):
if m < 0:
return False
elif m == 0:
return True
if i >= n:
return False
rst = rec(i+1, m - A[i]) or rec(i+1, m)
return rst
for m in M:
if m < min_A or max_A < m:
print('no')
elif rec(0, m):
print('yes')
else:
print('no')
| N = int(input())
AB = [list(map(int, input().split())) for _ in range(N)]
A = [a for a, b in AB]
B = [b for a, b in AB]
A.sort()
B.sort()
if N % 2:
ma = B[N // 2]
mi = A[N // 2]
else:
ma = B[N // 2 - 1] + B[N // 2]
mi = A[N // 2 - 1] + A[N // 2]
print(ma - mi + 1) | 0 | null | 8,617,373,646,798 | 25 | 137 |
import sys
input = sys.stdin.readline
a,b=map(int,input().split())
if a>b:
print(str(b)*a)
else:
print(str(a)*b)
| a,b=input().split()
A=int(a)
B=int(b)
aa=a
bb=b
for i in range(B-1):
aa+=a
for j in range(A-1):
bb+=b
if aa >= bb:
print(bb)
else:
print(aa) | 1 | 84,655,905,903,382 | null | 232 | 232 |
def main():
N, D = map(int, input().split())
A = [list(map(int, input().split())) for _ in range(N)]
cnt = 0
for a in A:
if (a[0]**2 + a[1]**2)**0.5 <= D:
cnt += 1
print(cnt)
if __name__ == '__main__':
main() | N = int(input())
S = [int(i) for i in input().split()]
q = int(input())
T = [int(i) for i in input().split()]
count = 0
for t in T:
S.append(t)
i = 0
while t != S[i]:
i += 1
if i != (len(S) - 1):
count += 1
S.pop()
print(count)
| 0 | null | 3,034,392,511,660 | 96 | 22 |
import sys
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
sys.setrecursionlimit(2147483647)
input = lambda:sys.stdin.readline().rstrip()
def resolve():
n, k = map(int, input().split())
P = list(map(lambda x : int(x) - 1, input().split()))
C = list(map(int, input().split()))
# doubling table
nexts = [P]
vals = [C]
totals = [C]
for _ in range(60):
next, val, total = nexts[-1], vals[-1], totals[-1]
nnext, nval, ntotal = [0] * n, [0] * n, [0] * n
for i in range(n):
nnext[i] = next[next[i]]
nval[i] = val[i] + val[next[i]]
ntotal[i] = max(total[i], val[i] + total[next[i]])
nexts.append(nnext)
vals.append(nval)
totals.append(ntotal)
# answer
ans = -INF
for now in range(n):
score = 0
for d in range(59, -1, -1):
if k >> d & 1:
ans = max(ans, score + totals[d][now])
score += vals[d][now]
now = nexts[d][now]
print(ans)
resolve() | n, k = map(int, input().split())
p = [int(x) for x in input().split()]
c = [int(x) for x in input().split()]
p_flag = [0 for _ in range(len(p))]
loop_max = []
loop_len = []
S = []
S_max = []
ans = []
for i in range(len(p)):
# if p_flag[i] == 1:
# continue
now = i
temp_len = 0
temp_s = 0
S_max = - (10**9 + 1)
temp_l = []
while True:
now = p[now] - 1
temp_len += 1
temp_s += c[now]
temp_l.append(temp_s)
p_flag[now] = 1
# 最初に戻ってきたら
if now == i:
break
loop_len.append(temp_len)
loop_max.append(temp_l)
S.append(temp_s)
for i in range(len(S)):
mod = k % loop_len[i] if k % loop_len[i] != 0 else loop_len[i]
if S[i] > 0:
if max(loop_max[i][:mod]) > 0:
ans.append(((k-1)//loop_len[i])*S[i] + max(loop_max[i][:mod]))
else:
ans.append(((k - 1) // loop_len[i]) * S[i])
else:
ans.append(max(loop_max[i]))
# print(loop_max)
# print(ans)
print(max(ans))
| 1 | 5,396,223,430,140 | null | 93 | 93 |
from sys import stdin
w = input()
n = 0
for line in stdin:
line = line.rstrip()
if 'END_OF_TEXT' == line:
break
n += len(list(filter(lambda x: w.lower() == x.lower(), line.split(' '))))
print(n) | n=int(input())
s=input()
rcnt=s.count("R")
wcnt=s[:rcnt].count("W")
print(wcnt) | 0 | null | 4,027,900,473,168 | 65 | 98 |
n=int(input())
L=list(map(int,input().split()))
a=0
for i in range(n-2):
for j in range(i+1,n-1):
if L[i]!=L[j]:
for k in range(j+1,n):
if L[i]!=L[k] and L[j]!=L[k] and L[i]<L[j]+L[k] and L[j]<L[i]+L[k] and L[k]<L[j]+L[i]:
a+=1
print(a) | # coding: utf-8
num = int(input())
count = 0
str = input().split()
table = [int(i) for i in str]
#全探索
for j in range(num): #ループ1
for k in range(j+1, num): #ループ2
for l in range(k+1, num): #ループ3
if table[j] != table[k] and table[k] != table[l] and table[j] != table[l]:
len = table[j] + table[k] + table[l] #周の長さ
ma = max(table[j], max(table[k], table[l])) #一番長い辺
rest = len - ma #残りの2辺の合計
if ma < rest: #最大の辺が残り2辺より小さければ三角形は成立する
count += 1
print(count)
| 1 | 5,007,170,726,480 | null | 91 | 91 |
import numpy as np
import sys
x, y = map(int, input().split())
if (x + y) % 3 != 0 or x > 2 * y or y > 2 * x:
print(0)
sys.exit()
# 手数
n = (x + y) // 3
x -= n
y -= n
MOD = 10**9 + 7
# モジュラ逆数戦法
def prepare(n, MOD):
f = 1
for m in range(1, n + 1):
f *= m
f %= MOD
fn = f
inv = pow(f, MOD - 2, MOD)
invs = [1] * (n + 1)
invs[n] = inv
for m in range(n, 1, -1):
inv *= m
inv %= MOD
invs[m - 1] = inv
return fn, invs
fact, invs = prepare(n, MOD)
print(fact * invs[x] * invs[y] % MOD) | X, Y = map(int, input().split())
MOD = 10**9+7
def mod_pow(n, m):
res = 1
while m > 0:
if m & 1:
res = (res*n)%MOD
n = (n*n)%MOD
m >>= 1
return res
if (2*Y-X)%3 != 0 or (2*X-Y)%3 != 0 or 2*Y < X or 2*X < Y:
print(0)
else:
A = (2*X-Y)//3
B = (2*Y-X)//3
m = 1
n = 1
for i in range(A):
m = (m*(A+B-i))%MOD
n = (n*(A-i))%MOD
inverse_n = mod_pow(n, MOD-2)
print((m*inverse_n)%MOD) | 1 | 149,946,097,148,670 | null | 281 | 281 |
n, m = map(int,input().split())
a = list(map(int,input().split()))
a.sort(reverse=True)
total = sum(a)
flg = True
for i in range(m):
if a[i] * 4 * m < total:
flg = False
print('Yes') if flg else print('No') | import sys
input = sys.stdin.readline
N, M = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse = True)
sm = sum(a)
for i in range(M):
if a[i] < sm / 4 / M:
print("No")
break
else: print("Yes") | 1 | 38,422,300,056,360 | null | 179 | 179 |
n = int(input())
print((n - (n+1)%2)//2) | s = input()[::-1]
l = [0 for i in range(2019)]
l[0] = 1
a, b = 0, 1
ans = 0
for i in s:
a += int(i) * b
a %= 2019
b *= 10
b %= 2019
l[a] += 1
for i in l:
ans += i * (i - 1) // 2
print(ans) | 0 | null | 92,485,717,890,464 | 283 | 166 |
N=int(input())
A=[int(i) for i in input().split()]
A.sort(reverse=True)
if N%2==1:
if N==3:
ans=A[0]+A[1]
else:
ans=A[0]
for i in range(1,N//2):
ans+=A[i]*2
ans+=A[N//2]
else:
ans=A[0]
for i in range(1,N//2):
ans+=A[i]*2
print(ans)
| X,Y,Z=map(int,input().split())
l=[X,Y,Z]
l[0],l[1]=l[1],l[0]
l[0],l[2]=l[2],l[0]
print(*l)
| 0 | null | 23,682,605,334,310 | 111 | 178 |
A = input()
B = input()
se = set(["1","2","3"])
a = se-set([A,B])
print(a.pop()) | n=int(input())
s = input()
ans = 0
if n%2 != 0:
print('No')
if n%2 == 0:
for i in range(n//2):
if s[i] == s[i+n//2]:
ans += 1
if ans == n//2:
print('Yes')
if ans != n//2:
print('No') | 0 | null | 128,166,205,982,698 | 254 | 279 |
from collections import deque
import copy
H,W=map(int,input().split())
inf=1000000000
field=[]
for i in range(H):
row=list(input())
for j in range(len(row)):
if row[j]=='#':row[j]=-1
else:row[j]=inf
field.append(row)
ans=inf
def isIn(x,y):
if x<0 or x>=W:return False
if y<0 or y>=H:return False
return True
vector=[[0,1],[0,-1],[1,0],[-1,0]]
ans=0
for i in range(H):
for j in range(W):
if field[i][j]==-1:continue
l=deque([[j,i]])
f=copy.deepcopy(field)
f[i][j]=0
tmp=0
#print('--start--')
while l:
x,y=l.popleft()
#print(x,y)
#i,jを訪問
for v in vector:
if not isIn(x+v[1],y+v[0]):continue
if f[y+v[0]][x+v[1]]<=tmp:continue
f[y+v[0]][x+v[1]]=f[y][x]+1
l.append([x+v[1],y+v[0]])
tmp=max(f[y+v[0]][x+v[1]],tmp)
ans=max(ans,tmp)
print(ans) | #!/usr/bin/env python3
import sys
sys.setrecursionlimit(10**7)
import bisect
import heapq
import itertools
import math
from collections import Counter, defaultdict, deque
from copy import deepcopy
from decimal import Decimal
from math import gcd
from operator import add, itemgetter, mul, xor
def cmb(n,r,mod):
bunshi=1
bunbo=1
for i in range(r):
bunbo = bunbo*(i+1)%mod
bunshi = bunshi*(n-i)%mod
return (bunshi*pow(bunbo,mod-2,mod))%mod
mod = 10**9+7
def I(): return int(input())
def LI(): return list(map(int,input().split()))
def MI(): return map(int,input().split())
def LLI(n): return [list(map(int, input().split())) for _ in range(n)]
#bisect.bisect_left(list,key)はlistのなかでkey未満の数字がいくつあるかを返す
#つまりlist[i] < x となる i の個数
#bisect.bisect_right(list, key)はlistのなかでkey以下の数字がいくつあるかを返す
#つまりlist[i] <= x となる i の個数
#これを応用することで
#len(list) - bisect.bisect_left(list,key)はlistのなかでkey以上の数字がいくつあるかを返す
#len(list) - bisect.bisect_right(list,key)はlistのなかでkeyより大きい数字がいくつあるかを返す
#これらを使うときはあらかじめlistをソートしておくこと！
def maze_solve(S_1,S_2,maze_list):
d = deque()
d.append([S_1,S_2])
dx = [0,0,1,-1]
dy = [1,-1,0,0]
while d:
v = d.popleft()
x = v[0]
y = v[1]
for i in range(4):
nx = x + dx[i]
ny = y + dy[i]
if nx < 0 or nx >= h or ny < 0 or ny >= w:
continue
if dist[nx][ny] == -1:
dist[nx][ny] = dist[x][y] + 1
d.append([nx,ny])
return max(list(map(lambda x: max(x), dist)))
h,w = MI()
if h==1 and w == 2:
print(1)
elif h == 2 and w == 1:
print(1)
else:
ans = 0
maze = [list(input()) for _ in range(h)]
dist = [[-1]*w for _ in range(h)]
start_list = []
for i in range(h):
for j in range(w):
if maze[i][j] == "#":
dist[i][j] = 0
else:
start_list.append([i,j])
dist_copy = deepcopy(dist)
for k in start_list:
dist = deepcopy(dist_copy)
ans = max(ans,maze_solve(k[0],k[1],maze))
print(ans+1) | 1 | 94,883,805,812,004 | null | 241 | 241 |
#!/usr/bin/env python3
from collections import defaultdict, Counter
from itertools import product, groupby, count, permutations, combinations
from math import pi, sqrt
from collections import deque
from bisect import bisect, bisect_left, bisect_right
from string import ascii_lowercase
from functools import lru_cache
import sys
sys.setrecursionlimit(10000)
INF = float("inf")
YES, Yes, yes, NO, No, no = "YES", "Yes", "yes", "NO", "No", "no"
dy4, dx4 = [0, 1, 0, -1], [1, 0, -1, 0]
dy8, dx8 = [0, -1, 0, 1, 1, -1, -1, 1], [1, 0, -1, 0, 1, 1, -1, -1]
def inside(y, x, H, W):
return 0 <= y < H and 0 <= x < W
def ceil(a, b):
return (a + b - 1) // b
def sum_of_arithmetic_progression(s, d, n):
return n * (2 * s + (n - 1) * d) // 2
def gcd(a, b):
if b == 0:
return a
return gcd(b, a % b)
def lcm(a, b):
g = gcd(a, b)
return a / g * b
def solve():
N = int(input())
P = list(map(int, input().split()))
Q = list(map(int, input().split()))
p = 0
q = 0
for i, v in enumerate(permutations(range(1, N + 1)), start=1):
p_ok = True
q_ok = True
for j in range(N):
p_ok &= v[j] == P[j]
q_ok &= v[j] == Q[j]
if p_ok:
p = i
if q_ok:
q = i
print(abs(p - q))
def main():
solve()
if __name__ == '__main__':
main()
| import sys
R, C, K = map(int, sys.stdin.readline().split())
grid = [[0 for _ in range(C)] for _ in range(R)]
for _ in range(K):
r, c, v = map(int, sys.stdin.readline().split())
grid[r-1][c-1] = v
# r行目、c列目にいるときに、その行でアイテムをi個取得している場合の最大価値
dp0 = [[0 for _ in range(C+1)] for _ in range(R+1)]
dp1 = [[0 for _ in range(C+1)] for _ in range(R+1)]
dp2 = [[0 for _ in range(C+1)] for _ in range(R+1)]
dp3 = [[0 for _ in range(C+1)] for _ in range(R+1)]
# print(dp)
for r in range(R):
for c in range(C):
# 取らない
dp0[r+1][c] = max((dp0[r][c], dp1[r][c], dp2[r][c], dp3[r][c]))
dp1[r][c+1] = max(dp1[r][c], dp1[r][c])
dp2[r][c+1] = max(dp2[r][c], dp2[r][c])
dp3[r][c+1] = max(dp3[r][c], dp3[r][c])
if grid[r][c] == 0:
continue
# 取る
dp0[r+1][c] = max(dp0[r][c] + grid[r][c], dp0[r+1][c])
dp0[r+1][c] = max(dp1[r][c] + grid[r][c], dp0[r+1][c])
dp0[r+1][c] = max(dp2[r][c] + grid[r][c], dp0[r+1][c])
dp1[r][c+1] = max(dp0[r][c] + grid[r][c], dp1[r][c+1])
dp2[r][c+1] = max(dp1[r][c] + grid[r][c], dp2[r][c+1])
dp3[r][c+1] = max(dp2[r][c] + grid[r][c], dp3[r][c+1])
# print(dp0)
# print(dp1)
# print(dp2)
# print(dp3)
# print(max((dp0[R][C], dp1[R][C], dp2[R][C], dp3[R][C])))
print(dp0[R][C-1]) | 0 | null | 53,328,937,986,420 | 246 | 94 |
def prime_factors(n):
d = {}
while n%2 == 0:
d[2] = d.get(2, 0) + 1
n //= 2
i = 3
while i*i <= n:
while n%i == 0:
d[i] = d.get(i, 0) + 1
n //= i
i += 2
if n > 2:
d[n] = d.get(n, 0) + 1
return d
MOD = 10**9+7
N = int(input())
A = list(map(int, input().split()))
G = {}
for a in A:
pf = prime_factors(a)
for k,v in pf.items():
G[k] = max(G.get(k, 0), v)
lcm = 1
for k,v in G.items():
lcm *= pow(k, v, MOD)
lcm %= MOD
ans = 0
for a in A:
ans += lcm * pow(a, MOD-2, MOD) % MOD
ans %= MOD
print(ans)
| import math
N = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
def lcm(x, y):
return (x // math.gcd(x, y)) * y
LCM = A[0]
for i in range(N-1):
LCM = lcm(LCM, A[i+1])
#LCM %= mod
ans = 0
for a in A:
ans += LCM * pow(a, mod-2, mod) % mod
ans %= mod
print(ans) | 1 | 87,783,753,704,102 | null | 235 | 235 |
A,B,K = list(map(int, input().split()))
if A > K:
A -= K
else:
K -= A
A = 0
if B > K:
B -= K
else:
B = 0
print(A,B)
A -= min(A, K)
| n=int(input())
if n%2!=0:
print(0)
else:
ans=0
t=10
while True:
ans=ans+n//t
t=t*5
if n//t==0:
break
print(ans) | 0 | null | 110,034,702,548,420 | 249 | 258 |
import sys
n = int(input())
if n == 1:
G = [1]
else:
G = [g for g in [1, 4, 10, 23, 57, 132, 301, 701] if g < n]
while True:
g = int(2.25 * G[-1])
if g > n:
break
G.append(g)
G.reverse()
A = list(map(int, sys.stdin))
cnt = 0
for g in G:
for j, v in enumerate(A[g:]):
while j >= 0 and A[j] > v:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
print(len(G))
print(*G)
print(cnt)
for a in A:
print(a)
| n=int(input())
ev=[]
for i in range(n):
a=int(input())
ev.append([list(map(int,input().split())) for _ in range(a)])
ans=0
for i in range(2**n):
bit=(bin(i)[2:].zfill(n))
flag=1
for j in range(n):
if bit[j]=="0":
continue
for e in ev[j]:
if int(bit[e[0]-1])!=e[1]:
flag=0
if flag:
ans=max(ans,bit.count("1"))
print(ans) | 0 | null | 61,099,604,454,620 | 17 | 262 |
a,b,c = list(map(int,input().split(" ")))
div=0
for i in range(a,b+1):
if c % i == 0:
div += 1
print(div) | import math
a,b,c = map(float,input().split())
rad = math.radians(c)
x = (a**2+b**2-2*a*b*math.cos(rad))**(1/2)
L = a+b+x
S = a*b*math.sin(rad)/2
h = 2*S/a
print("{:.8f}\n{:.8f}\n{:.8f}".format(S,L,h))
| 0 | null | 363,975,784,590 | 44 | 30 |
N,M = map(int,input().split())
if N > M:
ans = str(M)*N
else:
ans = str(N)*M
print(ans) | a, b = input().split()
c = a
a = a*int(b)
b = b*int(c)
for i in range(len(a)):
if a[i]<b[i]:
print(a)
break
elif a==b:
print(a)
break
else:
print(b)
break
| 1 | 83,950,974,005,238 | null | 232 | 232 |
n = int(input())
s = "abcdefghij"
def func(a):
if len(a) == n:
print(a)
else:
for i in range(len(set(a))+1):
func(a+s[i])
func("a") | n=int(input())
lis=[[[1,"a"]]]
for i in range(n-1):
lisi=[]
for j in lis[i]:
for k in range(j[0]):
lisi.append([j[0],j[1]+chr(ord("a")+k)])
lisi.append([j[0]+1,j[1]+chr(ord("a")+j[0])])
lis.append(lisi)
for i in lis[n-1]:
print(i[1]) | 1 | 52,550,065,032,836 | null | 198 | 198 |
s=[0,0]
for i in range(int(input())):
r=input().split()
if r[0]<r[1]:
s[1]+=3
elif r[1]<r[0]:
s[0]+=3
else:
s[0]+=1
s[1]+=1
print(str(s[0])+' '+str(s[1]))
| n = input()
taro = 0
hanako = 0
for i in xrange(n):
t_card, h_card = raw_input().split(" ")
if t_card < h_card:
hanako += 3
elif t_card > h_card:
taro += 3
elif t_card == h_card:
taro += 1
hanako += 1
print taro, hanako | 1 | 2,021,097,689,820 | null | 67 | 67 |
S = input()
days = ['SUN','MON','TUE','WED','THU','FRI','SAT']
i = days.index(S)
print (7-i) | import sys
input = sys.stdin.readline
def solve(N):
res = 0
flg = 0
for n in reversed(N):
if flg == 2:
if n >= 5:
flg = 1
else:
flg = 0
m = flg + n
if m == 5:
res += 5
flg = 2
elif m < 5:
res += m
flg = 0
else:
res += (10 - m)
flg = 1
return res + flg%2
N = list(map(int, input().strip()))
print(solve(N))
# N = 1
# q = 0
# while True:
# p = solve(list(map(int, str(N))))
# if abs(p-q) > 1:
# print(N, "OK")
# exit()
# q = p
# N += 1 | 0 | null | 102,216,505,067,040 | 270 | 219 |
n = int(input())
a = list(map(int, input().split()))
ans = 0
tmp = a[0]
for i in range(1,n):
tmp = max(a[i], tmp)
ans += tmp - a[i]
print(ans) | num = input()
list = input().split()
ans = 0
for i in range(int(num) - 1):
n1 = int(list[i])
n2 = int(list[i+1])
if n1 > n2 :
ans += (n1 - n2)
list[i+1] = list[i]
else:
ans += 0
print(ans) | 1 | 4,584,329,910,810 | null | 88 | 88 |
while True:
h, w = map(int, input().split())
if h == w == 0: break
for i in range(0, h):
print(''.join(['#' for x in range(0, w)]))
print('') | while True:
s = input().split(" ")
H = int(s[0])
W = int(s[1])
if H == 0 and W == 0:
break
for i in range(H):
for j in range(W):
if j == W-1:
print("#")
else:
print("#",end="")
print("") | 1 | 768,022,185,658 | null | 49 | 49 |
import math
# one = 1000000000000001
dict={1:"a",2:"b",3:"c",4:"d",5:"e",6:"f",7:"g",8:"h",9:"i",10:"j",
11:"k",12:"l",13:"m",14:"n",15:"o",16:"p",17:"q",18:"r",19:"s",20:"t",
21:"u",22:"v",23:"w",24:"x",25:"y",26:"z"}
n=int(input())
ans = ""
while n:
ans = str(dict[(n-1)%26+1]) + ans
n=(n-1)//26
print(ans)
| X, Y = map(int, input().split(" "))
print(100000 * max(4 - X, 0) + 100000 * max(4 - Y, 0) + (400000 if X == 1 and Y == 1 else 0)) | 0 | null | 76,129,416,170,148 | 121 | 275 |
from decimal import Decimal as d
a,b,c=input().split()
print('Yes'if d(a)**d('0.5')+d(b)**d('0.5')<d(c)**d('0.5')else'No') | input()
xs = list(map(int, input().split()))
print(' '.join(map(str,[f(xs) for f in [min,max,sum]]))) | 0 | null | 26,123,385,772,740 | 197 | 48 |
a = [i for i in input().split()]
b = []
for i in range(len(a)):
b.append(a.pop(a.index(min(a))))
print(" ".join([str(i) for i in b])) | N = list(map(int, input().split(' ')))
N.sort()
print('%d %d %d' % (N[0], N[1], N[2])) | 1 | 424,499,809,570 | null | 40 | 40 |
import sys
h,w,m = map(int,input().split())
h_lst = [[0,i] for i in range(h)]
w_lst = [[0,i] for i in range(w)]
memo = []
for i in range(m):
x,y = map(int,input().split())
h_lst[x-1][0] += 1
w_lst[y-1][0] += 1
memo.append((x-1,y-1))
h_lst.sort(reverse = True)
w_lst.sort(reverse = True)
Max_h = h_lst[0][0]
Max_w = w_lst[0][0]
h_ans = [h_lst[0][1]]
w_ans = [w_lst[0][1]]
if h != 1:
s = 1
while s < h and h_lst[s][0] == Max_h:
h_ans.append(h_lst[s][1])
s+= 1
if w!= 1:
t=1
while t < w and w_lst[t][0] == Max_w:
w_ans.append(w_lst[t][1])
t += 1
memo = set(memo)
#探索するリストは、最大を取るものの集合でなければ計算量はO(m)にはならない！
for j in h_ans:
for k in w_ans:
if (j,k) not in memo:
print(Max_h+Max_w)
sys.exit()
print((Max_h+Max_w)-1)
| h,w,m = map(int,input().split())
row = [0]*(h+1)
col = [0]*(w+1)
bombs = set([])
for i in range(m):
a,b = map(int,input().split())
row[a] += 1
col[b] += 1
bombs.add((a,b))
r,c = max(row),max(col)
rcnt,ccnt = 0,0
for v in row:
if v==r:
rcnt += 1
for v in col:
if v==c:
ccnt += 1
doubled = 0
for i,j in bombs:
if row[i]==r and col[j]==c:
doubled += 1
if doubled==rcnt*ccnt:
print(r+c-1)
else:
print(r+c) | 1 | 4,742,600,697,660 | null | 89 | 89 |
import sys
import math
import itertools
import bisect
from copy import copy
from collections import deque,Counter
from decimal import Decimal
def s(): return input()
def i(): return int(input())
def S(): return input().split()
def I(): return map(int,input().split())
def X(): return list(input())
def L(): return list(input().split())
def l(): return list(map(int,input().split()))
def lcm(a,b): return a*b//math.gcd(a,b)
def gcd(*numbers): reduce(math.gcd, numbers)
sys.setrecursionlimit(10 ** 9)
mod = 10**9+7
count = 0
ans = 0
N = i()
S = s()
if N % 2 != 0:
print("No")
else:
a = N // 2
if S[:a] == S[a:N]:
print("Yes")
else:
print("No")
| S=int(input())
T=list(input())
t=S//2
p=0
for i in range(t):
if S%2==1:
p=-1
break
elif T[i]!=T[i+t]:
p=-1
break
if p==-1 or t==0:
print("No")
elif p==0:
print("Yes")
| 1 | 147,009,776,174,558 | null | 279 | 279 |
n,m = map(int,input().split())
v1 = [ input().split() for _ in range(n) ]
v2 = [ int(input()) for _ in range(m) ]
l = [sum(map(lambda x,y:int(x)*y,v,v2)) for v in v1 ]
print(*l,sep="\n") | n, m = map(int, input().split())
A = [[int(e) for e in input().split()] for i in range(n)]
b = []
for i in range(m):
e = int(input())
b.append(e)
for i in range(n):
p = 0
for j in range(m):
p += A[i][j] * b[j]
print(p) | 1 | 1,160,651,936,318 | null | 56 | 56 |
n = int(input())
added_strings = set()
for i in range(n):
com, s = input().split()
if com == 'insert':
added_strings.add(s)
elif com == 'find':
print('yes' if (s in added_strings) else 'no')
| import sys
n = int(input())
dic = set()
input_ = [x.split() for x in sys.stdin.readlines()]
for c, s in input_:
if c == 'insert':
dic.add(s)
else:
if s in dic:
print('yes')
else:
print('no') | 1 | 76,548,929,920 | null | 23 | 23 |
# coding: utf-8
from collections import defaultdict
def main():
N = int(input())
dic = defaultdict(int)
max_p = 0
for i in range(N):
dic[input()] += 1
d = dict(dic)
l = []
for key, value in d.items():
l.append([key, value])
if max_p < value: max_p = value
l.sort(key=lambda x: (-x[1], x[0]), reverse=False)
for i, j in l:
if j == max_p:
print(i)
else:
break
if __name__ == "__main__":
main()
| import math
N, D = map(int,input().split())
XY = list(list(map(int,input().split())) for _ in range(N))
count = 0
for i in range(N):
if math.sqrt(XY[i][0] ** 2 + XY[i][1] ** 2) <= D: count += 1
print(count) | 0 | null | 37,920,569,792,040 | 218 | 96 |
import sys
def input():
return sys.stdin.readline()[:-1]
def main():
X = int(input())
if X >= 1800:
print(1)
elif X >= 1600:
print(2)
elif X >= 1400:
print(3)
elif X >= 1200:
print(4)
elif X >= 1000:
print(5)
elif X >= 800:
print(6)
elif X >= 600:
print(7)
else:
print(8)
if __name__ == "__main__":
main()
| import sys
def main():
N, K = map(int, sys.stdin.readline().rstrip().split())
L = [0] * 10
R = [0] * 10
for i in range(K):
l, r = map(int, sys.stdin.readline().rstrip().split())
L[i], R[i] = l, r
dp = [0] * (N + 1)
up = [0] * (N + 1)
up[0] = 1
up[1] = -1
for i in range(1, N + 1):
dp[i] = dp[i - 1] + up[i - 1]
for j in range(K):
if i + (L[j] - 1) < N + 1:
up[i + (L[j] - 1)] += dp[i]
if i + R[j] < N + 1:
up[i + R[j]] -= dp[i]
dp[i] %= 998244353
print(dp[N])
main()
| 0 | null | 4,742,321,424,512 | 100 | 74 |
import sys
input = sys.stdin.readline
A = int(input())
B = int(input())
print(list({1,2,3}-{A,B})[0])
| choise = {1, 2, 3}
for i in range(2):
choise.remove(int(input()))
print(list(choise)[0]) | 1 | 110,269,055,069,332 | null | 254 | 254 |
X,Y = map(int,input().split())
money = [3*10**5,2*10**5,10**5]
ans = 0
if X == 1 and Y == 1:
ans = 2*money[0] + 4*10**5
print(ans)
else:
if X <= 3:
ans += money[X-1]
if Y <= 3:
ans += money[Y-1]
print(ans)
| XY= list(map(int,input().split()))
X=XY[0]
Y=XY[1]
if X==1:
syokinx=300000
elif X==2:
syokinx=200000
elif X==3:
syokinx=100000
else:
syokinx=0
if Y==1:
syokiny=300000
elif Y==2:
syokiny=200000
elif Y==3:
syokiny=100000
else:
syokiny=0
if X==1 and Y==1:
syokinz=400000
else:
syokinz=0
print(syokinx+syokiny+syokinz)
| 1 | 140,977,163,342,508 | null | 275 | 275 |
s = list(input())
q = int(input())
rvs = []
i = 0
j = 0
p = []
order = []
for i in range(q):
order.append(input().split())
if order[i][0] == "replace":
p = []
p = list(order[i][3])
for j in range(int(order[i][1]), int(order[i][2]) + 1):
s[j] = p[j - int(order[i][1])]
elif order[i][0] == "reverse":
ss = "".join(s[int(order[i][1]):int(order[i][2]) + 1])
rvs = list(ss)
rvs.reverse()
for j in range(int(order[i][1]), int(order[i][2]) + 1):
s[j] = rvs[j - int(order[i][1])]
# temp = s[int(order[i][1])]
# s[int(order[i][1])] = s[int(order[i][2])]
# s[int(order[i][2])] = temp
elif order[i][0] == "print":
ss = "".join(s)
print("%s" % ss[int(order[i][1]):int(order[i][2]) + 1])
| code = input()
n = int(input())
for i in range(n):
lst = list(input().split())
a = int(lst[1])
b = int(lst[2])
if lst[0] == 'replace':
t1 = code[0:a]
t2 = code[a:b+1]
t3 = code[b+1:len(code)]
code = t1 + lst[3] + t3
elif lst[0] == 'reverse':
s = code[a:b+1]
ss = ''.join(list(reversed(s)))
t1 = code[0:a]
t2 = code[a:b+1]
t3 = code[b+1:len(code)]
code = t1 + ss + t3
elif lst[0] == 'print':
print(code[a:b+1])
| 1 | 2,055,414,922,360 | null | 68 | 68 |
n, m = map(int, input().split())
a = input().split()
a_sum = 0
for b in a:
a_sum += int(b)
if a_sum > n:
print(-1)
else:
print(n - a_sum) | N, M = map(int, input().split())
C = list(map(int, input().split()))
hw = 0
for i in range(M):
hw += C[i]
d = N - hw
if d >= 0:
print(d)
else:
print('-1') | 1 | 32,152,943,038,804 | null | 168 | 168 |
n = int(input())
s = [list(input()) for i in range(n)]
r = []
l = []
ans = 0
for i in s:
now = 0
c = 0
for j in i:
if j =="(":
now += 1
else:
now -= 1
c = min(c,now)
if c == 0:
ans += now
elif now >= 0:
l.append([c,now])
else:
r.append([c-now,now])
l.sort(reverse =True)
r.sort()
for i,j in l:
if ans + i < 0:
print("No")
exit()
else:
ans += j
for i,j in r:
if ans +i+j < 0:
print("No")
exit()
else:
ans += j
if ans == 0:
print("Yes")
else:
print("No")
| #!/usr/bin/env python3
import sys
input = sys.stdin.readline
n = int(input())
increasing = []
decreasing = []
dec_special = []
for _ in range(n):
s = input().rstrip()
minima = 0
fin = 0
for ch in s:
if ch == ")":
fin -= 1
if fin < minima:
minima = fin
else:
fin += 1
if fin >= 0:
increasing.append((minima, fin))
elif minima < fin:
dec_special.append((minima, fin))
else:
decreasing.append((minima, fin))
increasing.sort(reverse=True)
decreasing.sort()
dec_special.sort()
current = 0
for minima, diff in increasing:
if current + minima < 0:
print("No")
exit()
current += diff
for minima, diff in dec_special:
if current + minima < 0:
print("No")
exit()
current += diff
for minima, diff in decreasing:
if current + minima < 0:
print("No")
exit()
current += diff
if current != 0:
print("No")
else:
print("Yes")
| 1 | 23,773,400,249,632 | null | 152 | 152 |
s,t = map(int,input().split())
k,l = map(int,input().split())
m,n = map(int,input().split())
a = (k-m)*s
b = (l-n)*t
if a+b == 0:
print("infinity")
elif a>0 and a+b>0:
print(0)
elif a<0 and a+b<0:
print(0)
else:
div = abs(a) // abs(a+b)
if div == abs(a) / abs(a+b):
print(div*2)
else:
print(div*2+1) | from itertools import accumulate
N,K = map(int,input().split())
acc = list(accumulate(range(N+1), lambda x,y:x+y))
ans = 0
mod = 10**9+7
for i in range(K, N+1):
r = acc[N] - acc[N-i]
l = acc[i-1]
ans = (ans+r-l+1) % mod
ans += 1
print(ans % mod) | 0 | null | 82,369,683,883,580 | 269 | 170 |
K=int(input())
S=input()
N=len(S)
if N<=K:
print(S)
else:
ans=[]
for i in range(K):
ans.append(S[i])
print(''.join(ans)+'...') | inp = input()
a = inp.split()
a[0] = int(a[0])
a[1] = int(a[1])
a[2] = int(a[2])
c = 0
for i in range(a[0],a[1]+1):
if a[2] % i == 0:
c += 1
print(c)
| 0 | null | 10,074,045,221,920 | 143 | 44 |
S = int(input())
h = S // 3600
m = S % 3600 // 60
s = (S % 3600) - (m * 60)
print(h,m,s,sep=':') | s = int(input())
sec = s%60
min = s//60 # may be more than 60
hr = min//60
min = min%60
print(hr, min, sec, sep=':')
| 1 | 333,919,518,880 | null | 37 | 37 |
# -*- coding: utf-8 -*-
def bubble_sort(c):
c = list(c)
for i in range(len(c)):
for j in range(len(c)-1, i, -1):
if int(c[j][1]) < int(c[j-1][1]):
c[j], c[j-1] = c[j-1], c[j]
return c
def selection_sort(c):
c = list(c)
for i in range(len(c)):
minj = i
for j in range(i+1, len(c)):
if int(c[j][1]) < int(c[minj][1]):
minj = j
c[i], c[minj] = c[minj], c[i]
return c
input_num = int(input())
input_list = input().split()
bubble_list = bubble_sort(input_list)
selection_list = selection_sort(input_list)
for c in bubble_list:
print(c, end='')
if c != bubble_list[len(bubble_list)-1]:
print(' ', end='')
print("\nStable")
stable_flg = True
for i in range(len(input_list)):
if bubble_list[i] != selection_list[i]:
stable_flg = False
print(selection_list[i], end='')
if i < len(input_list)-1:
print(" ", end='')
if stable_flg:
print("\nStable")
else:
print("\nNot stable") | import copy
n = int(input())
c = input().split()
c_sel = copy.deepcopy(c)
# check stability of default array
ord_dict_def = {}
for i in range(n) :
if int(c[i][1]) in ord_dict_def.keys() :
ord_dict_def[int(c[i][1])] += c[i][0]
else :
ord_dict_def[int(c[i][1])] = c[i][0]
# do bubble
for i in range(n) :
for j in range(n - 1, i, -1) :
if int(c[j - 1][1]) > int(c[j][1]) :
c[j - 1], c[j] = c[j], c[j - 1]
# check stability for bubble
ord_dict_bubble = {}
for i in range(n) :
if int(c[i][1]) in ord_dict_bubble.keys() :
ord_dict_bubble[int(c[i][1])] += c[i][0]
else :
ord_dict_bubble[int(c[i][1])] = c[i][0]
# do selection
for i in range(n) :
cmin = i
for j in range(i + 1, n) :
if int(c_sel[j][1]) < int(c_sel[cmin][1]) :
cmin = j
if i != cmin :
c_sel[i], c_sel[cmin] = c_sel[cmin], c_sel[i]
# check stability for selection
ord_dict_selection = {}
for i in range(n) :
if int(c_sel[i][1]) in ord_dict_selection.keys() :
ord_dict_selection[int(c_sel[i][1])] += c_sel[i][0]
else :
ord_dict_selection[int(c_sel[i][1])] = c_sel[i][0]
stability_bubble = "Stable"
stability_selection = "Stable"
for i in ord_dict_bubble.keys() :
if ord_dict_def[i] != ord_dict_bubble[i] :
stability_bubble = "Not stable"
if ord_dict_def[i] != ord_dict_selection[i] :
stability_selection = "Not stable"
print(" ".join(c))
print(stability_bubble)
print(" ".join(c_sel))
print(stability_selection)
| 1 | 26,475,328,878 | null | 16 | 16 |
from math import gcd
def main():
N = int(input())
A = list([int(x) for x in input().split()])
max_a = max(A)
before = 0
result = [0 for _ in range(max_a + 1)]
for i in A:
before = gcd(before, i)
result[i] += 1
is_pairwise = True
for i in range(2, max_a + 1):
cnt = 0
for j in range(i, max_a + 1, i):
cnt += result[j]
if cnt > 1:
is_pairwise = False
break
if is_pairwise:
print('pairwise coprime')
exit()
if before == 1:
print('setwise coprime')
else:
print('not coprime')
if __name__ == '__main__':
main()
| from math import gcd
from functools import reduce
from collections import defaultdict
n=int(input())
a=list(map(int,input().split()))
g=reduce(gcd,a)
if g!=1:
print("not coprime")
exit()
def isPrimeMR(n):
d = n - 1
d = d // (d & -d)
L = [2]
for a in L:
t = d
y = pow(a, t, n)
if y == 1: continue
while y != n - 1:
y = (y * y) % n
if y == 1 or t == n - 1: return 0
t <<= 1
return 1
def findFactorRho(n):
m = 1 << n.bit_length() // 8
for c in range(1, 99):
f = lambda x: (x * x + c) % n
y, r, q, g = 2, 1, 1, 1
while g == 1:
x = y
for i in range(r):
y = f(y)
k = 0
while k < r and g == 1:
ys = y
for i in range(min(m, r - k)):
y = f(y)
q = q * abs(x - y) % n
g = gcd(q, n)
k += m
r <<= 1
if g == n:
g = 1
while g == 1:
ys = f(ys)
g = gcd(abs(x - ys), n)
if g < n:
if isPrimeMR(g): return g
elif isPrimeMR(n // g): return n // g
return findFactorRho(g)
def primeFactor(n):
i = 2
ret = {}
rhoFlg = 0
while i*i <= n:
k = 0
while n % i == 0:
n //= i
k += 1
if k: ret[i] = k
i += 1 + i % 2
if i == 101 and n >= 2 ** 20:
while n > 1:
if isPrimeMR(n):
ret[n], n = 1, 1
else:
rhoFlg = 1
j = findFactorRho(n)
k = 0
while n % j == 0:
n //= j
k += 1
ret[j] = k
if n > 1: ret[n] = 1
if rhoFlg: ret = {x: ret[x] for x in sorted(ret)}
return ret
def primes(x):
ret=[]
for i in range(1,int(x**0.5)+1):
if x%i==0:
ret.append(i)
if x//i!=i:
ret.append(x//i)
ret.sort()
return ret[1:]
d=defaultdict(int)
for q in a:
#p=primeFactor(q)
p=primes(q)
for j in p:
if d[j]==1:
print("setwise coprime")
exit()
d[j]+=1
print("pairwise coprime") | 1 | 4,122,602,607,566 | null | 85 | 85 |
X = int(input())
q, r = divmod(X, 500)
H = q * 1000 + ((r // 5) * 5)
print(H) | a,b=map(int,input().split())
def ans152(a:int, b:int):
listab=[str(a)*b,str(b)*a]
listab.sort()
return int(listab[0])
print(ans152(a,b)) | 0 | null | 63,337,300,652,960 | 185 | 232 |
import typing
def binary_serch(x:int, b_sum:list):
l = 0
r = len(b_sum) - 1
mid = (l + r + 1) // 2
res = mid
while True:
if x == b_sum[mid]:
return mid
elif x < b_sum[mid]:
res = mid - 1
r = mid
mid = (l + r + 1) // 2
elif b_sum[mid] < x:
res = mid
l = mid
mid = (l + r + 1) // 2
if l + 1 == r:
return res
n, m, k = map(int, input().split())
a = list(map(int, input().split()))
b = list(map(int, input().split()))
b_sum = [0] * (m + 2)
for i in range(m):
b_sum[i + 1] = b[i] + b_sum[i]
b_sum[-1] = 10 ** 9 + 1
a = [0] + a
pass_k = 0
ans = 0
for i in range(n + 1):
if pass_k + a[i] <= k:
pass_k += a[i]
book = i
book += binary_serch(k - pass_k, b_sum)
ans = max(ans, book)
else:
break
print(ans) | N=int(input())
S=input()
ans=""
for i in range(len(S)):
ans+=chr(ord("A")+(ord(S[i])-ord("A")+N)%26)
print(ans) | 0 | null | 72,467,270,408,960 | 117 | 271 |
a, b, c = map(int, input().split())
if a > b:
tmp = b
b = a
a = tmp
if b > c:
tmp = c
c = b
b = tmp
if a > b:
tmp = b
b = a
a = tmp
print(a,b,c)
# sortを使って解く -> Presentation error となってしまう。。
"""
A = list(map(int, input().split()))
A.sort()
for a in A:
print(a, end=' ')
"""
| dice = list(map(int,input().split()))
kaisuu = int(input())
lastlist = []
frlist = []
for i in range(kaisuu):
up,front = list(map(int,input().split()))
if up == dice[0] :
frlist = [1,2,4,3,1]
if up == dice[1]:
frlist = [0,3,5,2,0]
if up == dice[2]:
frlist = [0,1,5,4,0]
if up == dice[3]:
frlist = [0,4,5,1,0]
if up == dice[4]:
frlist = [0,2,5,3,0]
if up == dice[5] :
frlist = [1,3,4,2,1]
k = dice.index(int(front))
for n in frlist[0:4] :
if n == k :
l = frlist.index(int(n))
m = l + 1
lastlist.append(dice[frlist[m]])
for g in lastlist :
print(g)
| 0 | null | 348,054,581,952 | 40 | 34 |
s = input()
n = int(input())
for _ in range(n):
in_s= input().split()
command = str(in_s[0])
a, b = int(in_s[1]), int(in_s[2])
if(command == "print"):
print(s[a:b+1])
elif(command == "reverse"):
s = s[:a] + s[a:b+1][::-1] + s[b+1:]
else:
p = str(in_s[3])
s = s[:a] + p + s[b+1:] | teki, hissatsu = list(map(int, input().split(' ')))
l = sorted(list(map(int, input().split(' '))))[:max(0, teki-hissatsu)]
print(sum(l)) | 0 | null | 40,669,211,373,550 | 68 | 227 |
S =input()
T = input()
n = len(S)-len(T)+1
count = []
for i in range(n):
c =0
for p in range(len(T)):
if S[i+p] != T[p]:
c += 1
count.append(c)
print(min(count))
| n,k=list(map(int, input("").split()))
d=[]
a=[]
t=[]
for i in range(k):
d.append(int(input()))
a.append(list(map(int, input("").split())))
for i in range(n):
t.append(True)
for i in range(k):
for j in a[i]:
if t[j-1]:
t[j-1]=False
out=0
for i in t:
if i:
out+=1
print(out)
| 0 | null | 14,093,735,233,020 | 82 | 154 |
N = int(input())
A_list = list(map(int, input().split()))
MOD = 10**9 + 7
zeros = [0] * 61
ones = [0] * 61
for a in A_list:
for i, b in enumerate([1 if (a >> j & 1) else 0 for j in range(61)]):
if b == 1:
ones[i] += 1
else:
zeros[i] += 1
res = 0
for a in A_list:
twice = 1
for i, b in enumerate([1 if (a >> j & 1) else 0 for j in range(61)]):
if b == 1:
cnt = zeros[i]
ones[i] -= 1
else:
cnt = ones[i]
zeros[i] -= 1
res += twice * cnt
twice *= 2
res %= MOD
print(res) | n=int(input())
p=10**9+7
A=list(map(int,input().split()))
binA=[]
for i in range(n):
binA.append(format(A[i],"060b"))
exp=[1]
for i in range(60):
exp.append((exp[i]*2)%p)
ans=0
for i in range(60):
num0=0
num1=0
for j in range(n):
if binA[j][i]=="0":
num0+=1
else:
num1+=1
ans=(ans+num0*num1*exp[59-i])%p
print(ans)
| 1 | 122,941,761,624,640 | null | 263 | 263 |
n = int(input())
a = 10 - n // 200
print(a) | def main():
x = int(input())
grade = 0
for i in range(8):
if (400 + 200 * i) <= x < (400 + 200 * (i + 1)):
grade = 8 - i
print(grade)
if __name__ == "__main__":
main() | 1 | 6,742,650,827,852 | null | 100 | 100 |
n,k=map(int,input().split())
ar=list(map(int,input().split()))
for i in range(k,n):
print("Yes" if ar[i]>ar[i-k] else "No")
| def main():
n, k = [int(x) for x in input().split()]
scores = [int(x) for x in input().split()]
for old, new in zip(scores, scores[k:]):
if old < new:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 1 | 7,058,390,814,300 | null | 102 | 102 |
N = int(input())
X = int(N/1.08)
for i in [-1, 0, 1]:
X_ = int((X+i)*1.08)
if(X_ == N):
print(X+i)
exit()
print(':(') | N = int(input())
X = input()
def f(x):
ret = 0
c = bin(x).count("1")
while c > 0:
x %= c
c = bin(x).count("1")
ret += 1
return ret
MOD = 10 ** 9 + 7
origin_pop = X.count("1")
one_pop = origin_pop - 1
zero_pop = origin_pop + 1
one_mod = 0
zero_mod = 0
for i in X:
if one_pop > 0:
one_mod = one_mod * 2 + int(i)
one_mod %= one_pop
zero_mod = zero_mod * 2 + int(i)
zero_mod %= zero_pop
for i, x in enumerate(X):
if x == "0":
tmp = zero_mod + pow(2, N-1-i, zero_pop)
tmp %= zero_pop
print(f(tmp)+1)
else:
if one_pop == 0:
print(0)
else:
tmp = one_mod - pow(2, N-1-i, one_pop)
tmp = (tmp + one_pop) % one_pop
print(f(tmp)+1)
| 0 | null | 66,894,576,620,420 | 265 | 107 |
a = [2, 4, 5, 7, 9]
b = [0, 1, 6, 8]
n = input()
if int(n[-1]) in a:
print("hon")
elif int(n[-1]) in b:
print("pon")
else:
print("bon") | def main():
n = input()
m = int(n[-1])
hon = [2, 4, 5, 7, 9]
pon = [0, 1, 6, 8]
if m in hon:
print('hon')
elif m in pon:
print('pon')
else:
print('bon')
if __name__ == '__main__':
main() | 1 | 19,244,326,684,450 | null | 142 | 142 |
H, W = map(int, input().split())
if H > 1 and W > 1:
if H*W % 2 == 0:
s = (H * W) // 2
elif H*W % 2 != 0:
s = (H * W + 1) // 2
elif H == 1 or W == 1:
s = 1
print(s) | H, W = map(int, input().split())
ans = 0
x = H * W
if H == 1 or W == 1:
ans = 1
elif x % 2 == 0:
ans = x // 2
else:
ans = (x // 2) + 1
print(ans) | 1 | 51,118,003,698,856 | null | 196 | 196 |
k = int(input())
mod = 7 % k
counter = 1
memo = 1
mod_map = set()
mod_map.add(mod)
while mod != 0:
mod = ((mod * 10) % k + 7) % k
if mod not in mod_map:
mod_map.add(mod)
else:
counter = -1
break
counter += 1
if mod == 0:
break
print(counter)
| def main():
K = int(input())
v = 7 % K
for i in range(K+5):
if v == 0:
print(i+1)
return
v = v * 10 + 7
v %= K
print(-1)
if __name__ == '__main__':
main()
| 1 | 6,188,538,526,840 | null | 97 | 97 |
import itertools
import math
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
arr = [i for i in itertools.permutations([i for i in range(1, n+1)])]
a = arr.index(p)
b = arr.index(q)
print(abs(a-b))
| import heapq
H, N = map(int, input().split())
A = [] #W
B = [] #V
for i in range(N):
ai, bi = map(int, input().split())
A += [ai]
B += [bi]
maxA = max(A)
dp = [[0 for j in range(H+maxA+1)]for i in range(N+1)]
for j in range(1, H+maxA+1):
dp[0][j] = float('inf')
for i in range(N):
for j in range(H+maxA+1):
if j - A[i] < 0:
dp[i+1][j] = dp[i][j]
else:
dp[i+1][j] = min(dp[i][j], dp[i+1][j-A[i]] + B[i])
ans = float('inf')
for j in range(H, H+maxA+1):
ans = min(ans, dp[N][j])
print(ans) | 0 | null | 90,774,632,562,168 | 246 | 229 |
from itertools import accumulate
n=int(input())
d=list(map(int,input().split()))
ans=0
for i in range(n):
ans+=(list(accumulate(d))[-1]-d[i])*d[i]
print(ans//2) | X = int(input())
answer = (X // 500) * 1000
X %= 500
answer += (X // 5) * 5
print(answer) | 0 | null | 105,836,420,006,688 | 292 | 185 |
import sys
x,k,d=map(int,input().split())
x=abs(x)
a=x//d
if a>=k:
ans=x-k*d
elif (k-a)%2==0:
ans=x-d*a
else:
ans=x-d*a-d
print(abs(ans)) | x, k, d = map(int, input().split())
# k回 dだけ変化
n=abs(x)//d
if k>=n:
k=k-n
else:
n=k
k=0
if k%2 == 0:
x=abs(x)-d*n
else:
x=abs(x)-d*(n+1)
print(abs(x)) | 1 | 5,206,766,577,552 | null | 92 | 92 |
import math
import collections
import itertools
def YesNo(Bool):
if(Bool):
print("Yes")
else:
print("No")
return
def resolve():
N=int(input())
L=list(map(int,input().split()))
cnt=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[i]!=L[k] and L[j]!=L[k] )and (L[i]<L[j]+L[k])and (L[j]<L[i]+L[k])and (L[k]<L[j]+L[i])):
cnt+=1
print(cnt)
resolve()
| import sys
inp = [int(x) for x in sys.stdin.read().split()]; ii = 0
class SegmentTree:
def __init__(self, data, default=0, func=max):
"""initialize the segment tree with data"""
self._default = default
self._func = func
self._len = len(data)
self._size = _size = 1 << (self._len - 1).bit_length()
self.data = [default] * (2 * _size)
self.data[_size:_size + self._len] = data
for i in reversed(range(_size)):
self.data[i] = func(self.data[i + i], self.data[i + i + 1])
def __delitem__(self, idx):
self[idx] = self._default
def __getitem__(self, idx):
return self.data[idx + self._size]
def __setitem__(self, idx, value):
idx += self._size
self.data[idx] = value
idx >>= 1
while idx:
self.data[idx] = self._func(self.data[2 * idx], self.data[2 * idx + 1])
idx >>= 1
def __len__(self):
return self._len
def query(self, start, stop):
"""func of data[start, stop)"""
start += self._size
stop += self._size
res_left = res_right = self._default
while start < stop:
if start & 1:
res_left = self._func(res_left, self.data[start])
start += 1
if stop & 1:
stop -= 1
res_right = self._func(self.data[stop], res_right)
start >>= 1
stop >>= 1
return self._func(res_left, res_right)
def __repr__(self):
return "SegmentTree({0})".format(self.data)
shift = int(10**9 + 1)
rows, cols, k = inp[ii:ii+3]; ii += 3
items = [[] for _ in range(rows+1)]
best = [0]*(cols+1)
for _ in range(k):
r, c, v = inp[ii:ii+3]; ii += 3
items[r].append(c*shift+v)
for i in range(rows+1):
items[i].sort()
S = SegmentTree(best)
ans = 0
for r in range(1, rows+1):
dp = []
best1, best2 = 0, 0
Row = items[r]
for X in Row:
c, v = X//shift, X%shift
v1 = S.query(1, c+1) + v
v2 = best1 + v
v3 = best2 + v
V = v1
if V < v2:
V = v2
if V < v3:
V = v3
dp.append(V)
if v1 > best1:
best1 = v1
if v2 > best2:
best2 = v2
if ans < V:
ans = V
for j in range(len(dp)):
c = Row[j]//shift
if S[c] < dp[j]:
S[c] = dp[j]
print(ans)
| 0 | null | 5,279,717,996,072 | 91 | 94 |
H, N = map(int, input().split(' '))
A_ls = map(int, input().split(' '))
if sum(A_ls) >= H:
print('Yes')
else:
print('No') | H, N = map(int, input().split())
lst = list(map(int, input().split()))
for i in range (0, N):
H -= lst[i]
if H <= 0:
print("Yes")
else:
print("No") | 1 | 78,223,792,572,082 | null | 226 | 226 |
N = int(input())
S = input()
R = set()
G = set()
B = set()
for i, s in enumerate(S):
if s == 'R':
R.add(i)
elif s == 'G':
G.add(i)
elif s == 'B':
B.add(i)
ans = 0
for r in R:
for g in G:
ans += len(B)
d = abs(r-g)
if (r+g) % 2 == 0 and (r+g)//2 in B:
ans -= 1
if r+d in B or g+d in B:
ans -= 1
if r-d in B or g-d in B:
ans -= 1
print(ans)
| [n, m] = [int(x) for x in raw_input().split()]
A = []
counter = 0
while counter < n:
A.append([int(x) for x in raw_input().split()])
counter += 1
B = [int(raw_input()) for j in range(m)]
counter = 0
while counter < n:
result = 0
for j in range(m):
result += A[counter][j] * B[j]
print(result)
counter += 1 | 0 | null | 18,781,701,690,540 | 175 | 56 |
N, K = map(int, input().split())
R, S, P = map(int, input().split())
T = input()
scores = {'r': P, 's': R, 'p': S, 'default': 0}
win_flag = [False]*(N+1)
ans = 0
# Kの剰余で別々に考えていい
for i_k in range(K):
prev = 'default'
for i_n in range(i_k, N, K):
# K個前と違う手 もしくは K個前で勝たないことにした 場合
# => 点がもらえる
if (T[i_n] != prev) or (not win_flag[i_n-K]):
win_flag[i_n] = True
ans += scores[T[i_n]]
prev = T[i_n]
print(ans) | import sys
N = int(sys.stdin.readline().rstrip())
sec = []
for _ in range(N):
x, l = map(int, sys.stdin.readline().rstrip().split())
sec.append((x - l, x + l))
sec = sorted(sec, key=lambda x: x[1])
r = -float("inf")
ans = 0
for s, t in sec:
if r <= s:
ans += 1
r = t
print(ans) | 0 | null | 98,054,022,616,260 | 251 | 237 |
X = int(input())
price = 100
year = 0
while price<X:
price += price//100
year += 1
print(year) | x = int(input())
cnt = 0
dep = 100
while True:
dep = dep * 101 // 100
cnt+= 1
if dep >= x:
print(cnt)
break | 1 | 27,281,610,820,194 | null | 159 | 159 |
import sys, math
from collections import defaultdict, deque, Counter
from bisect import bisect_left, bisect_right
from itertools import combinations, permutations, product
from heapq import heappush, heappop
from functools import lru_cache
input = sys.stdin.readline
rs = lambda: input().strip()
ri = lambda: int(input())
rl = lambda: list(map(int, input().split()))
mat = lambda x, y, v: [[v]*y for _ in range(x)]
ten = lambda x, y, z, v: [mat(y, z, v) for _ in range(x)]
mod = 1000000007
sys.setrecursionlimit(1000000)
mod = 998244353
N, K = rl()
lr = []
for i in range(K):
l, r = rl()
lr.append((l,r))
lr.sort()
dp = [0] * (N+1)
dp[1] = 1
dp[2] = -1
ans = 0
s = 0
flags = [1] * K
for i in range(1, N+1):
s += dp[i]
s %= mod
for k in range(K):
if flags[k] == 0:
break
l, r = lr[k]
if i+l <= N:
dp[i+l] += s
if i+r+1 <= N:
dp[i+r+1] -= s
else:
ans += s
ans %= mod
break
else:
flags[k] = 0
break
print(ans)
| n, k = map(int, input().split())
s = [list(map(int, input().split())) for _ in range(k)]
dp = [0]*(n+1)
dp[1] = 1
mod = 998244353
dpsum = [0]*(n+1)
dpsum[1] = 1
for i in range(2, n+1):
for j in range(k):
li = max(i-s[j][1], 1)
ri = i-s[j][0]
if ri < 0:
continue
dp[i] += dpsum[ri]-dpsum[li-1]
dp[i] %= mod
dpsum[i] = dpsum[i-1]+dp[i]
print(dp[n])
| 1 | 2,677,338,693,650 | null | 74 | 74 |
N,M=map(int,input().split())
a=M//2
b=M-a
c=1
d=2*a+1
for i in range(a):
print(c,d)
c+=1
d-=1
e=2*a+2
f=2*M+1
for i in range(b):
print(e,f)
e+=1
f-=1 | H, W = map(int, input().split())
S = [[i for i in input()] for j in range(H)]
dp = [[0 for i in range(W)] for j in range(H)]
if S[0][0] == "#":
dp[0][0] = 1
for i in range(1, H):
if S[i-1][0] == "." and S[i][0] == "#":
dp[i][0] = dp[i-1][0] + 1
else:
dp[i][0] = dp[i-1][0]
for j in range(1, W):
if S[0][j-1] == "." and S[0][j] == "#":
dp[0][j] = dp[0][j-1] + 1
else:
dp[0][j] = dp[0][j-1]
for h in range(1, H):
for w in range(1, W):
if S[h][w] == "#":
if S[h-1][w] == ".":
c1 = dp[h-1][w] + 1
else:
c1 = dp[h-1][w]
if S[h][w-1] == ".":
c2 = dp[h][w-1] + 1
else:
c2 = dp[h][w-1]
dp[h][w] = min(c1, c2)
else:
dp[h][w] = min(dp[h-1][w], dp[h][w-1])
print(dp[H-1][W-1]) | 0 | null | 39,056,205,965,950 | 162 | 194 |
# coding=UTF-8
from collections import deque
from operator import itemgetter
from bisect import bisect_left, bisect
import itertools
import sys
import math
import numpy as np
import time
sys.setrecursionlimit(10**6)
input = sys.stdin.readline
def ev(n):
return 0.5*(n+1)
def main():
n, k = map(int, input().split())
p = list(map(int, input().split()))
p_ev = list(map(ev, p))
s = np.cumsum(p_ev)
s = np.insert(s, 0, 0)
ans = []
for i in range(n - k+1):
ans.append(s[i + k] - s[i])
print(max(ans))
if __name__ == '__main__':
main()
| import sys
input = sys.stdin.readline
(n, k), s, res, sm = map(int, input().split()), list(map(lambda x: (int(x) + 1) / 2, input().split())), 0, 0
for i in range(n):
if i < k: sm += s[i]
else: sm += s[i]; sm -= s[i-k]
res = max(res, sm)
print(f'{res:.10f}')
# print(f'{max([sum(s[i:i+k]) for i in range(n - k + 1)]):.10f}') | 1 | 74,888,151,216,230 | null | 223 | 223 |
a = [int(s) for s in input().split()]
N = a[0]
bks = a[1]
bd = a[2]
s = [input().split() for i in range(N)]
anslist = []
for i in range(2**N):
templist = []
for t in range(bks+1):
templist.append(int(0))
for j in range(N):
if (i >> j) & 1 == 1:
for k in range(bks + 1):
templist[k] += int(s[j][k])
anslist.append(templist)
ans = int(-1)
flag = int(0)
for i in range(2**N):
flag = 0
for j in range(1, bks+1):
if anslist[i][j] < bd:
flag = 1
break
else:
pass
if flag == 0:
if anslist[i][0] < ans or ans == -1:
ans = anslist[i][0]
print(ans) | import numpy as np
N, M, X = map(int, input().split())
C = [list(map(int, input().split())) for _ in range(N)]
cost = float("inf")
for i in range(2**N):
tmp = np.array([0 for _ in range(M+1)])
for j in range(N):
if (i>>j) & 1:
tmp += np.array(C[j])
if min(tmp[1:]) >= X:
cost = min(cost, tmp[0])
print(-1 if cost == float("inf") else cost) | 1 | 22,204,537,660,598 | null | 149 | 149 |
S = input()
l_s = len(S)
cnt = 0
for i in range(0,l_s//2):
if S[i] != S[-i-1]:
cnt += 1
print(cnt) | l = raw_input()
print l.swapcase()
| 0 | null | 60,618,459,257,172 | 261 | 61 |
import itertools
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
l = []
for i in range(1, n+1):
l.append(i)
m = []
for j in itertools.permutations(l, n):
m.append(list(j))
for a in range(9*8*7*6*5*4*3*2):
if p == m[a]:
x = a
break
for b in range(9*8*7*6*5*4*3*2):
if q == m[b]:
y = b
break
print(abs(x-y)) | x,y,z,k=map(int,input().split())
s=min(k,x)
k=k-s
if(k>0):
k=k-min(k,y)
if(k>0):
f=min(k,z)
s=s-f
print(s)
| 0 | null | 61,016,021,040,528 | 246 | 148 |
n = int(input())
p = n % 2 + n // 2
print(p) | a=list(map(int,input().split()))
c=0
for i in range(a[0],a[1]+1):
if i%a[2]==0:
c+=1
print(c) | 0 | null | 33,469,169,169,056 | 206 | 104 |
import sys
l = sys.stdin.readlines()
for i in l:
if "?" in i:
break
else:
str = i.replace('/','//')
print(eval(str)) | while 1 :
a,op,b=raw_input().split()
ai=int(a)
bi=int(b)
if op=='?':break
elif op=='+':print ai+bi
elif op=='-':print ai-bi
elif op=='*':print ai*bi
elif op=='/':print ai/bi | 1 | 673,442,567,298 | null | 47 | 47 |
N = int(input())
if N % 2 == 1:
print(0)
else:
n = 0
i = 1
while True:
if N < 2*5**i:
break
n += (N // 5**i // 2)
i += 1
print(n)
| input();print(input().count('ABC')) | 0 | null | 107,707,322,943,330 | 258 | 245 |
K = int(input())
A, B = map(int, input().split())
print("NOGK"[-(-A//K)*K <= B::2]) | K = int(input())
A, B = map(int, input().split())
if B // K * K >= A:
print('OK')
else:
print('NG')
| 1 | 26,803,123,347,578 | null | 158 | 158 |
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)
def check(mid):
cnt = 0
for i in range(N):
tmp = mid // F[i]
cnt += max(A[i] - tmp, 0)
return cnt <= K
check(2)
l, r = -1, 10**30
while r-l > 1:
mid = (l+r)//2
if check(mid):
r = mid
else:
l = mid
print(r)
| a = int(input())
if a == 1:
print("ACL")
elif a == 2:
print("ACLACL")
elif a == 3:
print("ACLACLACL")
elif a == 4:
print("ACLACLACLACL")
else:
print("ACLACLACLACLACL") | 0 | null | 83,956,361,357,528 | 290 | 69 |
H, W, K = map(int, input().split())
S = [list(map(int, list(input()))) for _ in range(H)]
ans = H*W
def countWhite(ytop, ybottom, xleft, xright):
ret = sum([sum(s[xleft:xright]) for s in S[ytop:ybottom]])
return ret
for h_div in range(1 << H-1):
count = 0
cut = [0]
for i in range(H):
if h_div >> i & 1:
cut.append(i+1)
count += 1
cut.append(H)
if count > ans:
continue
left = 0
# ここどんなふうに縦に切っても条件を満たさない場合がある
for right in range(1, W+1):
white = 0
for i in range(len(cut)-1):
white = max(white, countWhite(cut[i], cut[i+1], left, right))
if white > K:
if left == right - 1: # 条件を満たす縦の切り方がなかった場合
break
left = right - 1
count += 1
if count > ans:
break
else:
if count < ans:
ans = count
print(ans) | # coding: utf-8
n = int(input())
x = [float(i) for i in input().split()]
y = [float(i) for i in input().split()]
dl = [abs(i - j) for (i,j) in zip(x,y)]
for p in range(1,4):
d = sum([i ** p for i in dl]) ** (1/p)
print("{:.8f}".format(d))
print("{:.8f}".format(max(dl))) | 0 | null | 24,257,908,691,300 | 193 | 32 |
N = int(input())
A = list(map(int,input().split()))
x = True
for i in range(N):
if A[i] % 2 != 0:
continue
if not (A[i]%3==0 or A[i]%5==0):
x = False
if x:
print("APPROVED")
else:
print("DENIED") | n = int(input())
A = list(map(int, input().split()))
ans = 'APPROVED'
for a in A:
if a%2 == 0:
if a%3 != 0 and a%5 != 0:
ans = 'DENIED'
print(ans) | 1 | 69,129,813,549,482 | null | 217 | 217 |
W = raw_input().upper()
T = []
while True:
txt = raw_input()
if txt == "END_OF_TEXT":
break
T += txt.upper().split()
print T.count(W) | W = input()
cnt = 0
while True:
t = input()
if t == 'END_OF_TEXT':
break
else:
cnt += t.lower().split().count(W)
print(cnt)
| 1 | 1,826,372,258,632 | null | 65 | 65 |
import math
x_1, y_1, x_2, y_2 = map(float, input().split())
l = math.sqrt((x_1 - x_2)**2 + (y_1 - y_2)**2)
print(l)
| poi = [0,0]
for mak in range(int(input())) :
tem = input().split()
if tem[0] == tem[1] :
poi[0] += 1
poi[1] += 1
else :
che = sorted(tem)
if tem[0] != che[0] : poi[0] += 3
else : poi[1] += 3
print(poi[0],poi[1]) | 0 | null | 1,059,781,949,636 | 29 | 67 |
def solve(n,s):
cnt = 0
for i in range(len(s)-2):
if "ABC" == s[i:i+3]:
cnt+=1
return cnt
n = int(input())
s = input()
ans = solve(n,s)
print(ans) | def resolve():
import sys
input = sys.stdin.readline
# 整数 1 つ
n = int(input())
s = input()
# 整数複数個
# a, b = map(int, input().split())
# 整数 N 個 (改行区切り)
# N = [int(input()) for i in range(N)]
# 整数 N 個 (スペース区切り)
# N = list(map(int, input().split()))
# 整数 (縦 H 横 W の行列)
# A = [list(map(int, input().split())) for i in range(H)]
cnt = 0
for i in range(n-2):
if s[i]+s[i+1]+s[i+2] == "ABC":
cnt += 1
print(cnt)
resolve() | 1 | 99,469,068,028,150 | null | 245 | 245 |
N, X, T = map(int, input().split())
times = N // X
if N % X != 0:
times += 1
print(T * times)
| import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
from math import ceil
def main():
n, x, t = map(int, input().split())
print(ceil(n / x) * t)
if __name__ == '__main__':
main()
| 1 | 4,205,623,469,346 | null | 86 | 86 |
K = int(input())
for _ in range(K):
print("ACL", end = "")
print() | K=int(input())
ans=[]
for i in range(K):
ans.extend("ACL")
print("".join(ans)) | 1 | 2,209,773,820,548 | null | 69 | 69 |
N,M=map(int,input().split())
sc=[]
for i in range(M):
sc.append(list(map(int,input().split())))
ans=-1
cnt=10**(N-1)
if cnt==1:cnt-=1
while True:
if len(str(cnt))>N:break
if len(str(cnt))!=N:continue
ret=True
for i in range(M):
if str(cnt)[sc[i][0]-1]!=str(sc[i][1]):
ret=False
break
if ret:
ans=cnt
break
cnt+=1
print(ans) | # C - Guess The Number
N, M = map(int, input().split())
SC = [list(map(int, input().split())) for _ in range(M)]
ans = [0,0,0]
# 条件だけで不適がわかるものは弾く
for i in range(M):
for j in range(i+1,M):
if (SC[i][0] == SC[j][0]) and (SC[i][1] != SC[j][1]):
print(-1)
quit()
# 各桁を指定をする
for k in range(M):
ans[SC[k][0]-(N-2)] = str(SC[k][1])
# 頭の桁が0で指定されると不適(str型かどうかで判定する)
if (ans[3-N] == "0") and (N == 1):
print(0)
quit()
elif ans[3-N] == "0":
print(-1)
quit()
# N桁の文字列にする
ans = [str(ans[i]) for i in range(3)]
res = "".join(ans)
res = res[(3-N):4]
# 頭の桁が指定無しの0だったら1に変える
if (res[0] == "0") and (N == 1):
res = "0"
elif res[0] == "0":
ref = list(res)
ref[0] = "1"
res = "".join(ref)
print(res)
| 1 | 60,871,525,700,512 | null | 208 | 208 |
n=int(input())
adj=[]
for i in range(n):
adj.append(list(map(int, input().split())))
edge=[[0 for i2 in range(n)]for i1 in range(n)]
#??£??\???????????????
for i in range(n):
for j in range(adj[i][1]):
edge[i][adj[i][j+2]-1]=1
time=1
discover=[0 for i in range(n)]
final=[0 for i in range(n)]
stack=[]
def dfs(id,time):
for i in range(n):
c=0
if edge[id][i]==1 and discover[i]==0:
stack.append(id)
discover[i]=time
c+=1
#print(discover,final,i,stack)
dfs(i,time+1)
else:
pass
if c==0:
if len(stack)>0:
if final[id]==0:
final[id] = time
#print("back",discover,final,id,stack)
dfs(stack.pop(), time + 1)
else:
#print("back", discover, final, id, stack)
dfs(stack.pop(),time)
discover[0]=time
stack.append(0)
dfs(0,time+1)
for i in range(n):
if discover[i]==0:
discover[i]=final[0]+1
stack.append(i)
dfs(i,final[0]+2)
break
for i in range(n):
print(i+1,discover[i],final[i]) | N = int(input())
G = [[0] * N for _ in range(N)]
time = 0
times = [{'s': 0, 'f': 0} for _ in range(N)]
for _ in range(N):
u, n, *K = map(int, input().split())
for k in K:
G[u - 1][k - 1] = 1
def dfs(u):
global time
time += 1
times[u]['s'] = time
for i in range(N):
if G[u][i] == 1 and times[i]['s'] == 0:
dfs(i)
else:
time += 1
times[u]['f'] = time
for i in range(N):
if times[i]['s'] == 0:
dfs(i)
for i, time in enumerate(times):
print(i + 1, *time.values())
| 1 | 2,830,682,618 | null | 8 | 8 |
for j in range(1,10,1):
for k in range(1,10,1):
print("{}x{}={}".format(j,k,j*k))
| n,k=list(map(int,input().split()))
mod=10**9+7
def modinv(x):
return pow(x,mod-2,mod)
ans=1
comb1=1
comb2=1
for i in range(1,min(n-1,k)+1):
comb1*=(n-i+1)*modinv(i)
comb2*=(n-i)*modinv(i)
comb1%=mod
comb2%=mod
ans+=comb1*comb2
ans%=mod
print(ans) | 0 | null | 33,358,262,819,212 | 1 | 215 |
n = input()
maxv = - 1 * pow(10, 9)
minv = input()
for _ in xrange(1, n):
Rj = input()
maxv = max(maxv, Rj - minv)
minv = min(minv, Rj)
print maxv | from collections import deque
import sys
deq = deque()
q = int(input())
for _ in range(q):
s = input()
if s == 'deleteFirst':
deq.popleft()
elif s == 'deleteLast':
deq.pop()
else:
ss, num = s.split()
if ss == 'insert':
deq.appendleft(num)
else:
try:
deq.remove(num)
except:
pass
print(" ".join(deq))
| 0 | null | 32,577,745,498 | 13 | 20 |
in_sec = int(raw_input())
sec = in_sec%60
in_sec = (in_sec-sec)/60
min = in_sec%60
h = (in_sec-min)/60
print str(h) + ":" + str(min) + ":" + str(sec) | i = count = 0
a = b = c = ''
line = input()
while line[i] != ' ':
a = a + line[i]
i += 1
i += 1
while line[i] != ' ':
b = b + line[i]
i += 1
i += 1
while i < len(line):
c = c + line[i]
i += 1
a = int(a)
b = int(b)
c = int(c)
while a <= b:
if c%a == 0:
count += 1
a += 1
print(count) | 0 | null | 449,929,409,888 | 37 | 44 |
import sys
N, K = map(int, sys.stdin.readline().rstrip().split())
P = [int(x) for x in sys.stdin.readline().rstrip().split()]
# 目が 1 ... p のときの期待値
def kitaichi(p):
return (p + 1) / 2
goukei = 0
for i in range(K):
goukei += kitaichi(P[i])
gmax = goukei
for i in range(N - K):
goukei = goukei + kitaichi(P[K + i]) - kitaichi(P[i]) # 次の区間の合計
gmax = max(goukei, gmax)
print(gmax)
| import math
H,W,N = [int(input()) for i in range(3)]
print(min(math.ceil(N/H),math.ceil(N/W))) | 0 | null | 81,765,830,283,992 | 223 | 236 |
n = int(input())
s = input()
if n%2==1:
print("No")
else:
s1 = ""
s2 = ""
for i in range(0, n//2):
s1+=s[i]
s2+=s[n//2 + i]
if(s1 == s2):
print("Yes")
else:
print("No")
| n = int(input())
s = input()
if n % 2 == 1:
print('No')
else:
head = s[:n // 2]
tail = s[n // 2:]
if head == tail:
print('Yes')
else:
print('No')
| 1 | 146,168,897,524,452 | null | 279 | 279 |
num = map(int, raw_input().split())
for i in range(0,2):
for j in range(0,2):
if num[j] > num[j+1]:
tmp_box = num[j]
num[j] = num[j+1]
num[j+1] = tmp_box
sort = map(str, num)
print sort[0] + " " + sort[1] + " " + sort[2] | a = list(map(int, input().split()))
for i in range(1,len(a)):
v = a[i]
j = i - 1
while j >= 0 and a[j] > v:
a[j+1] = a[j]
j -= 1
a[j+1] = v
print("{} {} {}".format(a[0],a[1],a[2]))
| 1 | 411,504,341,218 | null | 40 | 40 |
while True:
try:
a=input().split()
except:
break
b=int(a[0])+int(a[1])
print(len(str(b))) | N, M, K = map(int, input().split())
A = list(map(int, input().split()))
B = list(map(int, input().split()))
max_num = 0
j = 0
j_max = M
A_sums=[0]
B_sums=[0]
for i in range(N):
A_sums.append(A_sums[i]+A[i])
for i in range(M):
B_sums.append(B_sums[i]+B[i])
for i in range(N + 1):
j = 0
if A_sums[i]>K:
break
while A_sums[i]+B_sums[j_max] > K:
j_max -=1
max_num = max(max_num, i + j_max)
print(max_num)
| 0 | null | 5,431,399,184,400 | 3 | 117 |
n, k = map(int, input().split())
arr = list(map(int, input().split()))
expected = []
cumsum = []
for x in arr:
sum = (x * (x + 1)) // 2
ex = sum / x
expected.append(ex)
sum = 0
maxi = 0
taken = 0
bad = 0
for x in expected:
sum += x
taken += 1
if taken == k:
maxi = max(maxi, sum)
elif taken > k:
sum -= expected[bad]
bad += 1
maxi = max(maxi, sum)
print(maxi) | s = input()
if(s == 'hi'):
print('Yes')
elif(s == 'hihi'):
print('Yes')
elif(s == 'hihihi'):
print('Yes')
elif(s == 'hihihihi'):
print('Yes')
elif(s == 'hihihihihi'):
print('Yes')
else:
print('No')
| 0 | null | 63,919,332,368,632 | 223 | 199 |
N = int(input())
P = list(map(int, input().split()))
temp = P[0]
res = 1
for i in range(1,N):
if P[i] <= temp:
temp = P[i]
res += 1
print(res) | print('Yes' if '7' in input() else 'No')
| 0 | null | 60,012,592,572,550 | 233 | 172 |
Subsets and Splits