code1
stringlengths 16
24.5k
| code2
stringlengths 16
24.5k
| similar
int64 0
1
| pair_id
int64 2
181,637B
⌀ | question_pair_id
float64 3.71M
180,628B
⌀ | code1_group
int64 1
299
| code2_group
int64 1
299
|
|---|---|---|---|---|---|---|
k=int(input())
s=list(input())
n=len(s)
def cmb(n, r, mod):
if (r < 0) or (n < r):
return 0
r = min(r, n - r)
return fact[n] * factinv[r] * factinv[n-r] % mod
def p(n,r,mod):
return fact[n]*factinv[n-r] % mod
mod = 10 ** 9 + 7
maxi = 2*10 ** 6 + 1 # N は必要分だけ用意する
fact = [1, 1] # fact[n] = (n! mod p)
factinv = [1, 1] # factinv[n] = ((n!)^(-1) mod p)
inv = [0, 1] # factinv 計算用
for i in range(2, maxi + 1):
fact.append((fact[-1] * i) % mod)
inv.append((-inv[mod % i] * (mod // i)) % mod)
factinv.append((factinv[-1] * inv[-1]) % mod)
array_5=[1]
array_6=[1]
for i in range(k):
array_5.append(25*array_5[-1]%mod)
array_6.append(26*array_6[-1]%mod)
ans=0
for i in range(n,n+k+1): #iはS_Nの固定した位置を表す。
x=cmb(i-1,n-1,mod)
y=array_5[i-n]*array_6[n+k-i]
ans += x*y%mod
ans %=mod
print(ans) | from collections import deque
N = int(input())
nodes = []
G ={}
is_visited = {}
q = deque()
for _ in range(N):
lst = list(map(int, input().split()))
idx = lst[0]
nodes.append(idx)
is_visited[idx] = False
degree = lst[1]
if degree > 0:
G[idx] = lst[2:]
else:
G[idx] = []
INF = 10**12
costs = [INF]*N
# bfs
# 初期queue
que = deque() # 必要なものはnodeidと原点からの距離
que.append(1)
costs[0] = 0
while que:
node_id = que.popleft() # 先入れ先出し
cost = costs[node_id-1]
for next_id in G[node_id]:
if (costs[next_id-1] == INF):
que.append(next_id)
costs[next_id-1] = cost + 1
for i in range(N):
if costs[i] != INF:
print(i+1, costs[i])
else:
print(i+1, -1)
| 0 | null | 6,342,894,550,628 | 124 | 9 |
H, N = map(int, input().split())
special_move = input().split()
def answer(H: int, N: int, special_move: list) -> str:
damage = 0
for i in range(0, N):
damage += int(special_move[i])
if damage >= H:
return 'Yes'
else:
return 'No'
print(answer(H, N, special_move)) | n,t = map(int,input().split())
L = []
for i in range(n):
a,b = map(int,input().split())
L.append([a,b])
dp1 = [[0 for i in range(t)] for i in range(n+1)]
dp2 = [[0 for i in range(t)] for i in range(n+1)]
for i in range(n):
a = L[i][0]
b = L[i][1]
for j in range(t):
if j-a >= 0:
dp1[i+1][j] = max(dp1[i][j], dp1[i][j-a]+b, dp1[i+1][j])
else:
dp1[i+1][j] = max(dp1[i][j],dp1[i+1][j])
for i in range(n):
a = L[n-i-1][0]
b = L[n-i-1][1]
if i == 0:
for j in range(a, t):
dp2[n-i-1][j] = b
else:
for j in range(t):
if j-a >= 0:
dp2[n-i-1][j] = max(dp2[n-i][j], dp2[n-i][j-a]+b,dp2[n-i-1][j])
else:
dp2[n-i-1][j] = max(dp2[n-i-1][j], dp2[n-i][j])
ans = 0
for i in range(1,n+1):
for j in range(t):
ans = max(ans, dp1[i-1][j]+dp2[i][t-1-j]+L[i-1][1])
print(ans)
| 0 | null | 114,956,727,033,342 | 226 | 282 |
import sys
input = lambda: sys.stdin.readline().rstrip()
n = int(input())
a = [int(x) for x in input().split()]
from itertools import accumulate
a_csum = list(accumulate(a))
ans = 10**10
for i in range(n - 1):
ans = min(ans, abs(a_csum[i] - (a_csum[-1] - a_csum[i])))
print(ans) | import sys
n = int(input())
a = list(map(int, input().split()))
cnt = 0
ave = sum(a)/2
for i in range(n):
cnt += a[i]
if cnt == ave:
print(0)
sys.exit()
elif cnt > ave:
x = ave -cnt +a[i]
if x >= cnt -ave:
x = cnt -ave
break
print(int(x*2)) | 1 | 142,637,078,858,560 | null | 276 | 276 |
import sys
sys.setrecursionlimit(10**7)
INTMAX = 9223372036854775807
INTMIN = -9223372036854775808
DVSR = 1000000007
def POW(x, y): return pow(x, y, DVSR)
def INV(x, d=DVSR): return pow(x, d - 2, d)
def DIV(x, y, d=DVSR): return (x * INV(y, d)) % d
def LI(): return [int(x) for x in input().split()]
def LF(): return [float(x) for x in input().split()]
def LS(): return input().split()
def II(): return int(input())
N=II()
LSTP=[]
LSTN=[]
for i in range(N):
cnt = 0
cntMin = 0
s = input()
for c in s:
if c == "(":
cnt += 1
else:
cnt -= 1
cntMin = min(cntMin, cnt)
# print(cntMin)
if cnt >= 0:
LSTP.append((cntMin, cnt))
else:
LSTN.append((-(cnt-cntMin), -cnt))
LSTP.sort(reverse=True)
LSTN.sort(reverse=True)
res = 0
for cntMin, cnt in LSTP:
if res + cntMin < 0:
print("No")
exit(0)
res += cnt
res2 = 0
for cntMin, cnt in LSTN:
if res2 + cntMin < 0:
print("No")
exit(0)
res2 += cnt
if res - res2 == 0:
print("Yes")
else:
print("No")
| N = int(input())
print('Yes' if N >= 30 else 'No') | 0 | null | 14,730,668,742,870 | 152 | 95 |
import sys
sys.setrecursionlimit(4100000)
import math
INF = 10**9
def main():
n = int(input())
S = input()
if n%2 == 0:
if S[:n//2] == S[n//2:]:
print('Yes')
return
print('No')
if __name__ == '__main__':
main()
| import sys,queue,math,copy,itertools,bisect,collections,heapq
def main():
sys.setrecursionlimit(10**7)
INF = 10**18
MOD = 10**9 + 7
LI = lambda : [int(x) for x in sys.stdin.readline().split()]
NI = lambda : int(sys.stdin.readline())
N = NI()
N0 = 2**(N.bit_length())
st = [0] * (N0*2)
def gindex(l, r):
L = l + N0; R = r + N0
lm = (L // (L & -L)) // 2
rm = (R // (R & -R)) // 2
while L < R:
if R <= rm:
yield R - 1
if L <= lm:
yield L - 1
L //= 2; R //= 2
while L > 0:
yield L - 1
L //= 2
def update(i,s):
x = 2 ** (ord(s) - ord('a'))
i += N0-1
st[i] = x
while i > 0:
i = (i-1) // 2
st[i] = st[i*2+1] | st[i*2+2]
def query(l,r):
l += N0
r += N0
ret = 0
while l < r:
if l % 2:
ret |= st[l-1]
l += 1
if r % 2:
r -= 1
ret |= st[r-1]
l //= 2 ; r //= 2
return ret
for i,s in enumerate(sys.stdin.readline().rstrip()):
update(i+1,s)
Q = NI()
for _ in range(Q):
c,a,b = sys.stdin.readline().split()
if c == '1':
update(int(a),b)
else:
ret = query(int(a),int(b)+1)
cnt = 0
b = 1
for i in range(26):
cnt += (b & ret) > 0
b <<= 1
print(cnt)
if __name__ == '__main__':
main() | 0 | null | 104,470,586,189,788 | 279 | 210 |
def main():
N = int(input())
NN = [[0]*10 for _ in range(11)]
for i in range(11,100):
As = str(i)[0]
Ae = str(i)[-1]
cnt = 0
for j in range(1,N+1):
if str(j)[-1]== As and str(j)[0] == Ae:
cnt +=1
NN[int(As)][int(Ae)] = cnt
ans = 0
for i in range(1,N+1):
ans += NN[int(str(i)[0])][int(str(i)[-1])]
print(ans)
if __name__ == '__main__':
main()
| import sys
sys.setrecursionlimit(10**7) #再帰関数の上限,10**5以上の場合python
import math
from copy import copy, deepcopy
from copy import deepcopy as dcp
from operator import itemgetter
from bisect import bisect_left, bisect, bisect_right#2分探索
#bisect_left(l,x), bisect(l,x)#aはソート済みである必要あり。aの中からx未満の要素数を返す。rightだと以下
from collections import deque
#deque(l), pop(), append(x), popleft(), appendleft(x)
##listでqueの代用をするとO(N)の計算量がかかってしまうので注意
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate,combinations,permutations#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
#import fractions#古いatcoderコンテストの場合GCDなどはここからimportする
from functools import lru_cache#pypyでもうごく
#@lru_cache(maxsize = None)#maxsizeは保存するデータ数の最大値、2**nが最も高効率
from decimal import Decimal
def input():
x=sys.stdin.readline()
return x[:-1] if x[-1]=="\n" else x
def printl(li): _=print(*li, sep="\n") if li else None
def argsort(s, return_sorted=False):
inds=sorted(range(len(s)), key=lambda k: s[k])
if return_sorted: return inds, [s[i] for i in inds]
return inds
def alp2num(c,cap=False): return ord(c)-97 if not cap else ord(c)-65
def num2alp(i,cap=False): return chr(i+97) if not cap else chr(i+65)
def matmat(A,B):
K,N,M=len(B),len(A),len(B[0])
return [[sum([(A[i][k]*B[k][j]) for k in range(K)]) for j in range(M)] for i in range(N)]
def matvec(M,v):
N,size=len(v),len(M)
return [sum([M[i][j]*v[j] for j in range(N)]) for i in range(size)]
def T(M):
n,m=len(M),len(M[0])
return [[M[j][i] for j in range(n)] for i in range(m)]
def main():
mod = 1000000007
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
count=[[0]*10 for i in range(10)]
for i in range(1,N+1):
si=str(i)
head=int(si[0])
tail=int(si[-1])
count[head][tail]+=1
ans=0
for a in range(1,10):
for b in range(1,10):
ans+=count[a][b]*count[b][a]
print(ans)
if __name__ == "__main__":
main() | 1 | 86,506,514,928,670 | null | 234 | 234 |
A, B, M = map(int,input().split())
A = [a for a in map(int,input().split())]
B = [b for b in map(int,input().split())]
C = []
for m in range(M):
C.append([c for c in map(int,input().split())])
ans = min(A) + min(B)
for c in C:
if (A[c[0]-1]+B[c[1]-1]-c[2])<ans:
ans = A[c[0]-1]+B[c[1]-1]-c[2]
print(ans) | a, b, m = map(int, input().split())
a_p = list(map(int, input().split()))
b_p = list(map(int, input().split()))
min_price = min(a_p) + min(b_p)
for i in range(m):
x, y, c = map(int, input().split())
min_price = min(min_price, a_p[x-1] + b_p[y-1] - c)
print(min_price) | 1 | 53,800,447,097,732 | null | 200 | 200 |
sheep, wolves = map(int, input().split())
if sheep > wolves:
print("safe")
elif sheep <= wolves:
print("unsafe") | #!/usr/bin/env python3
import sys
import collections as cl
def II(): return int(sys.stdin.readline())
def MI(): return map(int, sys.stdin.readline().split())
def LI(): return list(map(int, sys.stdin.readline().split()))
def main():
N = II()
A = LI()
count = [0] * (N + 1)
for a in A:
count[a] += 1
total = 0
for idx in range(N+1):
total += count[idx] * (count[idx] - 1) / 2
for a in A:
a_count = count[a]
print(int(total - (a_count * (a_count - 1) /
2) + ((a_count - 1)*(a_count - 2)/2)))
main()
| 0 | null | 38,232,090,084,060 | 163 | 192 |
#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 itertools
n = int(input())
A = list(map(int,input().split()))
A.sort()
def binary_search(l,r,v):
while r >= l:
h = (l+r) // 2
if A[h] < v:
l = h+1
else:
r = h-1
return r
ans = 0
for i in range(n-2):
for j in range(i+1,n-1):
a = binary_search(j,n-1,A[i]+A[j])
ans += a-j
print(ans) | 0 | null | 86,282,960,901,410 | 14 | 294 |
N = int(input())
A = list(map(int, input().split()))
L = 1000000007
state = [0,0,0]
M = [0,0,0]
for a in A:
t = None
n = 0
for i,s in enumerate(state):
if s == a:
t = i
n += 1
if n == 0:
break
M[n-1] += 1
state[t] += 1
if n > 0:
x = 2**30 % L
y = 3**19 % L
k = M[1] % x
l = M[2] % y
r = 2**k * 3**l % L
print(r)
else:
print(0)
| N = int(input())
A = list(map(int, input().split()))
MOD = 10**9 + 7
# N = 6
# A = [0, 1, 0, 0, 1, 2]
xyz = [[0]*(N+1) for _ in range(3)]
for i in range(N):
is_added = False
for j in range(3):
if xyz[j][i] == A[i] and not is_added:
xyz[j][i+1] = xyz[j][i] + 1
is_added = True
else:
xyz[j][i+1] = xyz[j][i]
# for i in range(3):
# print(xyz[i])
ans = 1
for i in range(N):
cnt = 0
for j in range(3):
if xyz[j][i] == A[i]:
cnt += 1
ans = ans*cnt % MOD
print(ans)
| 1 | 129,998,399,241,382 | null | 268 | 268 |
memo = [1, 1]
def fib(n):
if (n < len(memo)):
return memo[n]
memo.append(fib(n-1) + fib(n-2))
return memo[n]
N = int(input())
print(fib(N))
| N = int(input())
A = [list(map(int, (input().split(' ')))) for i in range(N)]
hoge = [sum(a) for a in A]
fuga = [a[0] - a[1] for a in A]
print(max(max(hoge) - min(hoge), max(fuga) - min(fuga)))
| 0 | null | 1,719,317,783,260 | 7 | 80 |
L = []
m, f, r = map(int, input().split())
while not(m == -1 and f == -1 and r == -1):
L.append([m, f, r])
m, f, r = map(int, input().split())
for i in L:
if i[0] == -1 or i[1] == -1:
print("F")
elif i[0] + i[1] >= 80:
print("A")
elif i[0] + i[1] >= 65:
print("B")
elif i[0] + i[1] >= 50:
print("C")
elif i[0] + i[1] >= 30 and i[2] >=50:
print("C")
elif i[0] + i[1] >= 30:
print("D")
else:
print("F") | def get_score(medium, final, retry):
medium_final = medium + final
if medium == -1 or final == -1:
return 'F'
elif 80 <= medium_final:
return 'A'
elif 65 <= medium_final:
return 'B'
elif 50 <= medium_final:
return 'C'
elif 30 <= medium_final:
if 50 <= retry:
return 'C'
else:
return 'D'
else:
return 'F'
data = []
while True:
[medium, final, retry] = [int(x) for x in raw_input().split()]
if [medium, final, retry] == [-1, -1, -1]:
break
data.append(get_score(medium, final, retry))
for n in data:
print(n) | 1 | 1,226,104,179,740 | null | 57 | 57 |
n = int(input())
print(sum(filter(lambda x : x % 3 != 0 and x % 5 != 0, range(1, n+1)))) |
from fractions import Fraction
from collections import defaultdict
def resolve():
# A1*A2 + B1*B2 = 0 式変形 A1/B1 = -(B2/A2)
# a, b の0がある条件を考える
MOD = 1000000007
N = int(input())
zeroes = 0
hash1 = defaultdict(int) #
hash2 = defaultdict(str) #中の悪い相手を記入
for _ in range(N):
a, b = map(int, input().split())
if a==0 and b==0:
zeroes += 1
elif b == 0:
hash1["1/0"] += 1
hash2["1/0"] = "0/1"
elif a == 0:
hash1["0/1"] += 1
hash2["0/1"] = "1/0"
else: # a, bが0以外
rat1 = Fraction(a, b)
rat2 = Fraction(-b, a)
hash1[str(rat1)] += 1
hash2[str(rat1)] = str(rat2) # 相手を入れる
confirmed = set()
ans = 1
for k, v in hash1.items():
if k in confirmed: # 確認済みを数えないようにする
continue
bad = hash1.get(hash2[k], 0) # 中の悪い相手, キーがなかったら0を出力
cnt1 = pow(2, v, MOD) - 1
cnt2 = pow(2, bad, MOD) - 1
ans = (ans * (cnt1 + cnt2 + 1)) % MOD
# 確認済みにする
confirmed.add(k)
confirmed.add(hash2[k])
# ※ ループ中に値を変更したらエラー
# hash1[k] = -1
ans = (ans + zeroes + MOD -1) % MOD
print(ans)
if __name__ == "__main__":
resolve() | 0 | null | 27,797,650,519,552 | 173 | 146 |
#import numpy as np
import sys, math
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial#, gcd
from bisect import bisect_left, bisect_right #bisect_left(list, value)
sys.setrecursionlimit(10**7)
enu = enumerate
MOD = 10**9+7
def input(): return sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep='\n')
N = int(input())
A = list(map(int, input().split()))
A.sort()
C = Counter(A)
S = set(A)
maxA = A[-1]
chk = [0] * (maxA+1)
for s in S:
for i in range(s, maxA+1, s):
chk[i] += 1
res = [s for s in S if chk[s] == 1 and C[s] == 1]
# print(res)
print(len(res)) | #!/usr/bin/env python
# -*- coding: utf-8 -*-
a, b, c = map(int, input().split())
ret = [i for i in range(a, b+1) if c%i == 0]
print(len(ret)) | 0 | null | 7,579,501,952,958 | 129 | 44 |
H,W,s=list(map(int,input().split()))
l=[list(input()) for i in range(H)]
l_h=[0]*H
for i in range(H):
if "#" in set(l[i]):
l_h[i]=1
cnt=0
bor=sum(l_h)-1
for i in range(H):
if cnt==bor:
break
if l_h[i]==1:
l_h[i]=-1
cnt+=1
cnt=1
import numpy as np
tmp=[]
st=0
ans=np.zeros((H,W))
for i in range(H):
tmp.append(l[i])
if l_h[i]==-1:
n_tmp=np.array(tmp)
s_count=np.count_nonzero(n_tmp=="#")-1
for j in range(W):
ans[st:i+1,j]=cnt
if "#" in n_tmp[:,j] and s_count>0:
cnt+=1
s_count-=1
st=i+1
cnt+=1
tmp=[]
n_tmp=np.array(tmp)
s_count=np.count_nonzero(n_tmp=="#")-1
for j in range(W):
ans[st:i+1,j]=cnt
if "#" in n_tmp[:,j] and s_count>0:
cnt+=1
s_count-=1
for i in ans:
print(*list(map(int,i))) | from sys import stdin
import math
import re
import queue
input = stdin.readline
MOD = 1000000007
INF = 122337203685477580
def solve():
str = (input().rstrip())
str = str.replace("hi","")
if(len(str) == 0):
print("Yes")
else:
print("No")
if __name__ == '__main__':
solve()
| 0 | null | 98,748,156,591,630 | 277 | 199 |
class Dice(object):
def __init__(self, top, south, east, west, north, bottom):
self.top = top
self.south = south
self.east = east
self.west = west
self.north = north
self.bottom = bottom
def get_top(self):
return self.top
def rotate(self, directions):
for direction in directions:
if direction == 'S':
self.prev_top = self.top
self.top = self.north
self.north = self.bottom
self.bottom = self.south
self.south = self.prev_top
elif direction == 'E':
self.prev_top = self.top
self.top = self.west
self.west = self.bottom
self.bottom = self.east
self.east = self.prev_top
elif direction == 'W':
self.prev_top = self.top
self.top = self.east
self.east = self.bottom
self.bottom = self.west
self.west = self.prev_top
elif direction == 'N':
self.prev_top = self.top
self.top = self.south
self.south = self.bottom
self.bottom = self.north
self.north = self.prev_top
dice = Dice(*map(int, input().split()))
dice.rotate(input())
print(dice.get_top()) | class Dice:
def __init__(self, labels):
self.labels = labels
def north(self):
self.change([2, 6, 3, 4, 1, 5])
def south(self):
self.change([5, 1, 3, 4, 6, 2])
def east(self):
self.change([4, 2, 1, 6, 5, 3])
def west(self):
self.change([3, 2, 6, 1, 5, 4])
def change(self, convert):
result = []
for i in range(6):
result.append(self.labels[convert[i] - 1])
self.labels = result
dice = Dice(list(map(int, input().split())))
for direction in input():
if direction == 'N':
dice.north()
if direction == 'S':
dice.south()
if direction == 'E':
dice.east()
if direction == 'W':
dice.west()
print(dice.labels[0]) | 1 | 233,505,727,850 | null | 33 | 33 |
from decimal import Decimal
a, b = [Decimal(i) for i in input().split()]
print(int(a * b))
| class Dice:
def __init__(self, d1, d2, d3, d4, d5, d6):
self.d1 = d1
self.d2 = d2
self.d3 = d3
self.d4 = d4
self.d5 = d5
self.d6 = d6
def S(self):
tmp = self.d1
self.d1 = self.d5
self.d5 = self.d6
self.d6 = self.d2
self.d2 = tmp
def N(self):
tmp = self.d1
self.d1 = self.d2
self.d2 = self.d6
self.d6 = self.d5
self.d5 = tmp
def E(self):
tmp = self.d1
self.d1 = self.d4
self.d4 = self.d6
self.d6 = self.d3
self.d3 = tmp
def W(self):
tmp = self.d1
self.d1 = self.d3
self.d3 = self.d6
self.d6 = self.d4
self.d4 = tmp
def output(self):
print(self.d1)
d1, d2, d3, d4, d5, d6 = map(int, input().split())
dice = Dice(d1, d2, d3, d4, d5, d6)
M = input()
for i in range(len(M)):
if M[i] == 'S':
dice.S()
elif M[i] == 'N':
dice.N()
elif M[i] == 'E':
dice.E()
elif M[i] == 'W':
dice.W()
dice.output()
| 0 | null | 8,433,068,440,458 | 135 | 33 |
import sys
# import re
import math
import collections
# import decimal
import bisect
import itertools
import fractions
# import functools
import copy
# import heapq
import decimal
# import statistics
import queue
# import numpy as np
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
# MOD = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
eps = 10 ** (-9)
def main():
n = ni()
a = na()
seta = set(a)
cnta = collections.Counter(a)
lista = list(seta)
lista.sort()
table = [True for _ in range(10 ** 6 + 1)]
ans = 0
for ai in lista:
if table[ai]:
if cnta[ai] == 1:
ans += 1
for i in range(ai, 10 ** 6 + 1, ai):
table[i] = False
print(ans)
if __name__ == '__main__':
main()
| import copy
# a = get_int()
def get_int():
return int(input())
# a = get_string()
def get_string():
return input()
# a_list = get_int_list()
def get_int_list():
return [int(x) for x in input().split()]
# a_list = get_string_list():
def get_string_list():
return input().split()
# a, b = get_int_multi()
def get_int_multi(): # a, b = get_int_multi()
return map(int, input().split())
# a_list = get_string_char_list()
def get_string_char_list():
return list(str(input()))
# print("{} {}".format(a, b))
# for num in range(0, a):
# a_list[idx]
# a_list = [0] * a
'''
while (idx < n) and ():
idx += 1
'''
def main():
m = get_int()
ret = 0
if m < 600:
ret = 8
elif m < 800:
ret = 7
elif m < 1000:
ret = 6
elif m < 1200:
ret = 5
elif m < 1400:
ret = 4
elif m < 1600:
ret = 3
elif m < 1800:
ret = 2
elif m < 2000:
ret = 1
print(ret)
if __name__ == '__main__':
main()
| 0 | null | 10,588,604,386,790 | 129 | 100 |
import math
def caracal_vs_monster():
"""
2**0 個 5
/ \
2**1 個 2.5 2.5
/ \ / \
2**2 個 1.25 1.25 1.25 1.25
/ \ / \ / \ / \
2**3 個 0.625 0.625 ...
"""
# 入力
H = int(input())
# H / 2 の何回目で1になるか
count = int(math.log2(H))
# 攻撃回数
attack_count = 0
for i in range(count+1):
attack_count += 2 ** i
return attack_count
result = caracal_vs_monster()
print(result) | print(2**(len(bin(int(input())))-2)-1) | 1 | 79,807,066,905,848 | null | 228 | 228 |
def one_int():
return int(input())
N=one_int()
num=int(N/100)
amari = N % 100
if num*5 < amari:
print(0)
else:
print(1) | x = int(input())
price = [100, 101, 102, 103, 104, 105]
dp = [False for _ in range(x + 1)]
dp[0] = True
for i in range(1, x + 1):
for j in range(6):
if i - price[j] >= 0:
if dp[i - price[j]]:
dp[i] = True
break
else:
dp[i] = False
if dp[x]:
print(1)
else:
print(0) | 1 | 126,842,203,487,286 | null | 266 | 266 |
N = int(input())
a_lst = list(map(int, input().split()))
print(sum((i + 1) % 2 == 1 and a % 2 == 1 for i, a in enumerate(a_lst)))
| from math import gcd
print(360//gcd(360,int(input()))) | 0 | null | 10,416,209,269,310 | 105 | 125 |
def kakeru(x):
for i in range(1,10):
a = x * i
print(str(x) + 'x' +str(i) + '=' + str(a))
for i in range (1,10):
kakeru(i) | a = 1
while a<10:
b=1
while b<10:
print(str(a)+'x'+str(b)+'='+str(a*b))
b=b+1
a=a+1 | 1 | 1,879,822 | null | 1 | 1 |
from sys import stdin
def main():
s = stdin.readline()[:-1]
print('Yes') if s[2] == s[3] and s[4] == s[5] else print('No')
if __name__ == "__main__":
main()
| import sys
(a, b ,c) = [int(i) for i in input().split(' ')]
x = a
cnt = 0
while x <= b:
if (c % x == 0) : cnt+=1
x += 1
else:
print(cnt) | 0 | null | 21,262,790,494,748 | 184 | 44 |
import math
n=int(input())
D={}
for _ in range(n):
a,b=map(int, input().split())
if a==0 and b==0:
key=(0,0)
elif a==0:
key=(0,1)
elif b==0:
key=(1,0)
else:
if a<0:
a=-a
b=-b
g=math.gcd(a, abs(b))
key=(a//g, b//g)
if key not in D:
D[key]=0
D[key]+=1
mod=10**9+7
ans=1
zz=0
for k1, v1 in D.items():
if v1==0:
continue
if k1==(0,0):
zz+=v1
continue
if k1[1]>0:
k2=(k1[1], -k1[0])
else:
k2=(-k1[1], k1[0])
if k2 not in D:
ans=ans*pow(2, v1, mod)%mod
else:
v2=D[k2]
m=(pow(2, v1, mod)+pow(2, v2, mod)-1)%mod
ans=ans*m%mod
D[k2]=0
print((ans+zz-1)%mod)
| from math import sqrt
x = int(input())
while True:
f = 1
s = int(sqrt(x))
for i in range(2, s+1):
if x % i == 0:
f = 0
break
if f == 1:
print(x)
break
x += 1 | 0 | null | 63,337,257,382,938 | 146 | 250 |
s, w = map(int, input().split())
print('safe') if s > w else print('unsafe') | S, W = map(int, input().split())
print("unsafe" if W >= S else "safe" )
| 1 | 29,164,544,850,980 | null | 163 | 163 |
import sys
n,k=map(int,input().split())
a=list(map(int,input().split()))
a.sort()
MOD=10**9+7
plus=[]
minus=[]
zero=[]
for i in range(n):
if a[i]>0:
plus.append(a[i])
if a[i]<0:
minus.append(a[i])
if a[i]==0:
zero.append(a[i])
if k==n:
ans=1
for i in range(k):
ans=(ans*a[i])%MOD
print(ans)
sys.exit()
if len(plus)==0:
if k%2!=0:
a.reverse()
ans=1
for i in range(k):
ans=(ans*a[i])%MOD
print(ans)
sys.exit()
if len(plus)+len(minus)<k:
print(0)
sys.exit()
m=len(minus)
minus.sort()
plus.reverse()
plpointer=k
if k>len(plus):
plpointer=2*(len(plus)//2)
if k%2==1:
if plpointer+1<=len(plus):
plpointer+=1
else:
plpointer-=1
mnpointer=k-plpointer
while mnpointer<m-1 and plpointer>=2 and minus[mnpointer]*minus[mnpointer+1]>plus[plpointer-1]*plus[plpointer-2]:
mnpointer+=2
plpointer-=2
ans=1
for i in range(mnpointer):
ans=(ans*minus[i])%MOD
for i in range(plpointer):
ans=(ans*plus[i])%MOD
print(ans)
| MOD = 10**9 + 7
N, K = map(int, input().split())
A = sorted([int(i) for i in input().split()])
B = []
plus, zero, minus = 0, 0, 0
for i in range(N):
if A[i] >= 0:
B.append((A[i], 1))
plus += 1
elif A[i] == 0:
B.append((0, 0))
zero += 1
else:
B.append((-A[i], -1))
minus += 1
if plus >= K-(min(K, minus)//2*2):
B = sorted(B, key=lambda x: x[0], reverse=True)
c = 1
for i in range(K):
c *= B[i][1]
if c == 1:
ans = 1
for i in range(K):
ans *= B[i][0]
ans %= MOD
else:
ap, an = 1, 1
skip = []
for i in range(K-1, -1, -1):
if B[i][1] == 1:
ap *= B[i][0]
skip.append(i)
break
else:
skip.append(K-1)
an = 0
for i in range(K-1, -1, -1):
if B[i][1] == -1:
an *= B[i][0]
skip.append(i)
break
else:
skip.append(K-1)
ap = 0
for i in range(K, N):
if B[i][1] == 1:
ap *= B[i][0]
break
for i in range(K, N):
if B[i][1] == -1:
an *= B[i][0]
break
a = max(ap, an)
ans = 1
for i in range(K):
if i not in skip:
ans *= B[i][0]
ans %= MOD
ans *= a
ans %= MOD
elif zero >= K-(min(K, minus)//2*2):
print(0)
exit()
else:
B = sorted(B, key=lambda x: x[0], reverse=False)
ans = 1
for i in range(K):
ans *= B[i][0]*B[i][1]
ans %= MOD
print(ans)
| 1 | 9,482,451,836,572 | null | 112 | 112 |
from itertools import permutations
from bisect import bisect
n = int(input())
p = tuple(map(int, input().split()))
q = tuple(map(int, input().split()))
l = tuple(permutations(range(1, n + 1), n))
print(abs(bisect(l, p) - bisect(l, q))) | A=[]
b=[]
n=list(map(int,input().split()))
for i in range(n[0]):
A.append(list(map(int,input().split())))
for i in range(n[1]):
b.append(int(input()))
for i in range(n[0]):
num=0
for j in range(n[1]):
num=num+A[i][j]*b[j]
print(num)
| 0 | null | 50,740,878,684,482 | 246 | 56 |
r=int(input())
print(2*r*3.14159265358979) | N = int(input())
l = []
for _ in range(N):
A, B = map(int, input().split())
l.append((A, B))
t = N//2
tl = sorted(l)
tr = sorted(l, key=lambda x:-x[1])
if N%2:
print(tr[t][1]-tl[t][0]+1)
else:
a1, a2 = tl[t-1][0], tr[t][1]
a3, a4 = tl[t][0], tr[t-1][1]
print(a4-a3+a2-a1+1)
| 0 | null | 24,306,960,370,528 | 167 | 137 |
#!/usr/bin/env python3
def main():
import time
N = int(input())
A = [int(x) for x in input().split()]
num_lst = [0] * (N + 1)
for a in A:
num_lst[a] += 1
ans = 0
for num in num_lst:
# ans += comb(num, 2, exact=True)
ans += num * (num - 1) // 2
start = time.time()
for a in A:
print(ans - (num_lst[a] - 1))
end = time.time() - start
# print(f'{end:6f}', 's')
if __name__ == '__main__':
main()
| # -*- coding: utf-8 -*-
"""
Created on Mon Sep 7 22:04:16 2020
@author: liang
"""
N = int(input())
A = [int(x) for x in input().split()]
d = [0]*N
for a in A:
d[a-1] += 1
#print(d)
score = 0
for a in d:
score += a*(a-1)//2
#print(score)
for a in A:
print(score - d[a-1] + 1)
| 1 | 47,614,335,918,380 | null | 192 | 192 |
# import numpy as np
import sys, math, heapq
from itertools import permutations, combinations
from collections import defaultdict, Counter, deque
from math import factorial, gcd
from bisect import bisect_left, bisect_right
sys.setrecursionlimit(10 ** 7)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline()[:-1]
pl = lambda x: print(*x, sep="\n")
H, W, M = map(int, input().split())
hw = [list(map(int, input().split())) for _ in range(M)]
hb = defaultdict(int)
wb = defaultdict(int)
bomb = defaultdict(int)
for hwi in hw:
h, w = hwi
hb[h] += 1
wb[w] += 1
bomb[(h, w)] += 1
# print(hb, wb)
mhb = max(hb.values())
mwb = max(wb.values())
maxh = [key for key, val in hb.items() if val == mhb]
maxw = [key for key, val in wb.items() if val == mwb]
# print(maxh, maxw)
for h in maxh:
for w in maxw:
if bomb[(h, w)] == 0:
print(mhb + mwb)
exit()
print(mhb + mwb - 1)
| H, W, M = map(int, input().split())
HW = []
for _ in range(M):
HW.append(list(map(int, input().split())))
A = [0] * (H + 1)
B = [0] * (W + 1)
for h, w in HW:
A[h] += 1
B[w] += 1
a = max(A)
b = max(B)
cnt = A.count(a) * B.count(b) - len([0 for h, w in HW if A[h] == a and B[w] == b])
print(a + b - (cnt == 0)) | 1 | 4,679,437,132,748 | null | 89 | 89 |
N,M=map(int,input().split())
x=max(N//0.08+1,M//0.1+1)
y=min((N+1)//0.08, (M+1)//0.1)
print( -1 if y<x else int(x)) | n = int(input())
lis = list(map(int, input().split()))
m = 0
for a in lis:
m = m ^ a
for a in lis:
print(m ^ a, end=" ")
| 0 | null | 34,663,067,673,726 | 203 | 123 |
N=int(input())
a=[0]*10**4
for j in range(1,101):
for k in range(1,101):
for h in range(1,101):
tmp=h**2+j**2+k**2+h*j+j*k+k*h
if tmp<=10000:
a[tmp-1]+=1
for i in range(N):
print(a[i])
| S=input()
if S.islower():
print('a')
else:
print('A') | 0 | null | 9,576,476,908,288 | 106 | 119 |
import math
a,b,c,d = map(float, input().split())
t = pow(a-c,2) + pow(b-d,2)
print(math.sqrt(t)) | #coding:utf-8
import math
datas = [float(x) for x in input().split()]
p1 = (datas[0], datas[1])
p2 = (datas[2], datas[3])
print(math.sqrt(math.pow(p1[0]-p2[0], 2)+math.pow(p1[1]-p2[1],2))) | 1 | 164,060,404,420 | null | 29 | 29 |
T1,T2,A1,A2,B1,B2=map(int,open(0).read().split())
D1,D2=(A1-B1)*T1,(A1-B1)*T1+(A2-B2)*T2
if D1*D2>0:print(0)
elif D2==0:print("infinity")
else:print(-D1//D2*2+1-(-D1%D2==0)) | x = int(input())
t = False
if x >= 30:
t = True
if t == True:
print('Yes')
else:
print('No') | 0 | null | 68,718,657,124,820 | 269 | 95 |
n,K=input(),int(input())
m=len(n)
DP=[[[0]*(K+2) for _ in range(2)] for _ in range(m+1)]
DP[0][0][0]=1
for i in range(1,m+1):
for flag in range(2):
num=9 if flag else int(n[i-1])
for j in range(K+1):
for k in range(num+1):
if k!=0:DP[i][flag or k<num][j+1] +=DP[i-1][flag][j]
else:DP[i][flag or k<num][j] +=DP[i-1][flag][j]
print(DP[m][0][K]+DP[m][1][K]) | #!/usr/bin/python3
# -*- coding:utf-8 -*-
def main():
h, w = map(int, input().split())
grid = []
for _ in range(h):
grid.append(list(input().strip()))
dp = [[0]*(w) for _ in range(h)]
def cals_score(i, j):
score = 10**9 + 7
if i >= 1:
score = dp[i-1][j] + (1 if grid[i-1][j]!=grid[i][j] else 0)
if j >= 1:
score = min(score, dp[i][j-1] + (1 if grid[i][j-1]!=grid[i][j] else 0))
return score
dp[0][0] = 1
for i in range(1, w):
dp[0][i] = cals_score(0, i)
for i in range(1, h):
dp[i][0] = cals_score(i, 0)
for i in range(1, h):
for j in range(1, w):
dp[i][j] = cals_score(i, j)
print(dp[-1][-1]//2 + dp[-1][-1]%2 * (grid[0][0]=='#'))
if __name__=='__main__':
main()
| 0 | null | 62,842,356,923,488 | 224 | 194 |
def main():
n, k = map(int, input().split())
h_lst = list(map(int, input().split()))
ans = 0
for h in h_lst:
if h >= k:
ans += 1
print(ans)
if __name__ == "__main__":
main()
| n,k=map(int,input().split())
l=list(map(int,input().split()))
ans=sum(x>=k for x in l)
print(ans) | 1 | 178,689,255,846,410 | null | 298 | 298 |
N,M=map(int,input().split())
H=[0]+list(map(int,input().split()))
check=[0]+[1]*N
for _ in range(M):
a,b=map(int,input().split())
if H[a]>=H[b]:
check[b]=0
if H[b]>=H[a]:
check[a]=0
print(sum(check))
| N = int(input())
for i in range(1,int(N**(1/2)) + 1)[::-1]:
if N%i == 0:
print(i + N//i - 2)
exit() | 0 | null | 93,634,606,845,402 | 155 | 288 |
a=input()
print a+a**2+a**3 | n = int(input())
m = list(map(int, input().split()))
count = 0
flag = 1
while flag:
flag = 0
for j in range(n-1, 0, -1):
if m[j] < m[j-1]:
m[j], m[j-1] = m[j-1], m[j]
count += 1
flag = 1
print(" ".join(str(x) for x in m))
print(count) | 0 | null | 5,099,261,171,480 | 115 | 14 |
N,K = map(int,input().split())
MOD = pow(10,9)+7
ans = 0
for i in range(K,N+2): #KからN+1
MAX = i*(2*N-i+1)//2
MIN = i*(i-1)//2
#print(i,MIN,MAX)
ans += (MAX-MIN+1)%MOD
print(ans%MOD) | # 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()
# n, *a = map(int, open(0))
N, K = 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)
# 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
A = [i for i in range(N + 1)]
A = np.array(A)
cum_A = np.cumsum(A)
cnt = 0
for i in range(K, N + 1):
cnt += (cum_A[N] - cum_A[N - i]) - cum_A[i - 1] + 1
print((cnt + 1) % (10**9 + 7)) | 1 | 33,038,119,780,600 | null | 170 | 170 |
from collections import defaultdict
n = int(input())
dic = defaultdict(lambda: 0)
for _ in range(n):
com = input().split(' ')
if com[0]=='insert':
dic[com[1]] = 1
else:
if com[1] in dic:
print('yes')
else:
print('no') | # -*- coding: utf-8 -*-
def main():
dictionary = {}
input_num = int(raw_input())
counter = 0
while counter < input_num:
command, key = raw_input().split(' ')
if command == 'insert':
dictionary[key] = True
else:
if key in dictionary:
print 'yes'
else:
print 'no'
counter += 1
if __name__ == '__main__':
main() | 1 | 77,409,824,910 | null | 23 | 23 |
#!/usr/bin/env python3
import sys
YES = "Yes" # type: str
NO = "No" # type: str
def solve(s: str):
if s[2] == s[3] and s[4] == s[5]:
print(YES)
else:
print(NO)
return
def main():
s = sys.stdin.readline().strip() # type: str
solve(s)
if __name__ == '__main__':
main()
| N = int(input())
slist = []
for i in range(N):
slist.append(input())
print (len(set(slist))) | 0 | null | 36,310,526,173,490 | 184 | 165 |
import sys
while 1:
H,W = map(int,sys.stdin.readline().split())
if H == W == 0:
break
print(('#'*W + '\n')*H) | while True:
line = input()
data = line.split()
h = int(data[0])
w = int(data[1])
if h == 0 and w == 0:
break
for i in range(h):
for j in range(w):
print("#", end="")
print("")
print("")
| 1 | 786,102,782,450 | null | 49 | 49 |
n = input()
if n.isupper():
print("A")
else:
print("a") | N = input()
A, a = 0, 0
for i in range(65, 91):
if i==ord(N):
A += 1
for i in range(97, 123):
if i==ord(N):
a += 1
if A==1:
print('A')
if a==1:
print('a') | 1 | 11,260,506,021,420 | null | 119 | 119 |
N=int(input())
A=list(map(int,input().split()))
aA_n=[0]
for i in range (N):
aA_n.append(A[i]+aA_n[-1])
aA_n=aA_n[1:]
rA=A[::-1]
aA_r=[0]
for i in range (N):
aA_r.append(rA[i]+aA_r[-1])
aA_r=aA_r[1:]
aA_r=aA_r[::-1]
ans=aA_n[-1]
for i in range (N-1):
_tempans=abs(aA_n[i]-aA_r[i+1])
if _tempans<ans:
ans=_tempans
print(ans)
| #!/usr/bin/env python3
#%% for atcoder uniittest use
import sys
input= lambda: sys.stdin.readline().rstrip()
sys.setrecursionlimit(10**9)
def pin(type=int):return map(type,input().split())
def tupin(t=int):return tuple(pin(t))
def lispin(t=int):return list(pin(t))
#%%code
def resolve():
N,=pin()
A=lispin()
temp=0
sumA=[0]*N
sumA[0]=A[0]
for j in range(1,N):
sumA[j]=sumA[j-1]+A[j]
#print(sumA)
ans=2**32-1
t=sumA[-1]
for i in range(N):
ans=min(ans,abs(t-sumA[i]*2))
print(ans)
#%%submit!
resolve()
| 1 | 142,219,579,688,788 | null | 276 | 276 |
h,w,K = map(int,input().split())
sij = [input() for j in range(h)]
num = 2**(h-1)
hon = 10**18
for i in range(num):
tmp = format(i,'0'+str(h)+'b')
#print(tmp,tmp,tmp,tmp)
yoko_hon = sum(list(map(int,tmp)))+1
blk = [0]*(yoko_hon)
#blk_num = 0
tmp_col = 0
tmp_hon = yoko_hon-1
flag = True
ok_flag = True
for j in range(w):
tmp_blk = [0]*(yoko_hon)
blk_num = 0
for k in range(h):
if tmp[k] == str(1):
blk_num += 1
#print(blk_num,tmp_blk)
tmp_blk[blk_num] += int(sij[k][j])
#print(blk[blk_num] , tmp_blk[blk_num],k)
if blk[blk_num] + tmp_blk[blk_num] > K:
flag = False
continue
#print(ok_flag,flag,tmp_blk,blk)
if flag == False:
for l in range(yoko_hon):
if tmp_blk[l] > K:
ok_flag = False
break
blk[l] = tmp_blk[l]
tmp_hon += 1
tmp_col = 0
flag = True
else:
for l in range(yoko_hon):
blk[l] += tmp_blk[l]
tmp_col += 1
if ok_flag == False:
break
#print(ok_flag)
if ok_flag == False:
ok_flag = True
continue
#exit()
hon = min(tmp_hon,hon)
print(hon) | H,W,K=map(int,input().split())
S=[[int(s) for s in input()] for i in range(H)]
ans=1000000
for i in range(2**(H-1)):
tmp=0
L=[]
for j in range(H-1):
if i>>j&1:
L.append(j)
tmp+=len(L)
L.append(H-1)
c=[0]*len(L)
for k in range(W):
h=0
c1=[0]*len(L)
for l in range(len(L)):
for m in range(h,L[l]+1):
c1[l]+=S[m][k]
h=L[l]+1
p=0
for l in range(len(L)):
if c1[l]>K:
p=2
break
elif c[l]+c1[l]>K:
p=1
else:
c[l]+=c1[l]
if p==2:
break
elif p==1:
c=[i for i in c1]
tmp+=1
else:
ans=min(ans,tmp)
print(ans) | 1 | 48,644,747,460,868 | null | 193 | 193 |
n = int(input())
a = []
for _ in range(n):
a.append([list(map(int,input().split())) for __ in range(int(input()))])
l = []
for i in range(2**n):
flag2 = 0
for j in range(n):
if i >> j & 1 == 1:
flag1 = 0
for k in a[j]:
if i >> (k[0]-1) & 1 != k[1]:
flag1 = 1
flag2 += 1
break
if flag1 : break
if flag2 == 0 :l.append(list(bin(i)).count('1'))
print(max(l)) | def north(d):
return [d[1], d[5], d[2], d[3], d[0], d[4]]
def east(d):
return [d[3], d[1], d[0], d[5], d[4], d[2]]
def south(d):
return [d[4], d[0], d[2], d[3], d[5], d[1]]
def west(d):
return [d[2], d[1], d[5], d[0], d[4], d[3]]
numbers = list(map(int, input().split()))
directions = list(input())
for d in directions:
if d == "N":
numbers = north(numbers)
elif d == "E":
numbers = east(numbers)
elif d == "S":
numbers = south(numbers)
elif d == "W":
numbers = west(numbers)
print(numbers[0]) | 0 | null | 61,230,086,306,818 | 262 | 33 |
# 2020/08/08
# AtCoder Beginner Contest 174 - A
# Input
n, a, b = map(int,input().split())
# Calc
sa = abs(b - a)
if sa % 2 == 0:
ans = sa // 2
else:
# B go Right and 1 lose
bgr = n - b + 1
bgra = a + bgr
rans = (n - bgra) // 2 + bgr
# A go Left and 1 lose
agl = a - 1 + 1
aglb = b - agl
lans = (aglb - 1) // 2 + agl
ans = min(rans, lans)
# Output
print(ans)
| s=list(input())
k=0
bef="x"
n=[]
ans=0
def kai(n):
if n==0:
return 0
ret=0
for i in range(1,n+1):
ret+=i
return ret
for i in s:
if bef!=i:
if bef=="x":
st=i
bef=i
k+=1
continue
bef=i
n.append(k)
k=0
k+=1
n.append(k)
n.reverse()
if st==">":
ans+=kai(n.pop())
while len(n)!=0:
if len(n)==1:
ans+=kai(n.pop())
else:
f=n.pop()
s=n.pop()
if f>s:
ans+=kai(f)+kai(s-1)
else:
ans+=kai(f-1)+kai(s)
#print("{} {}".format(f,s))
print(ans) | 0 | null | 133,458,924,624,212 | 253 | 285 |
bingo=[]
for i in range(3):
a=list(map(int,input().split()))
bingo.append(a)
n=int(input())
for i in range(n):
b=int(input())
for j in range(3):
if b in bingo[j]:
bingo[j][bingo[j].index(b)]=0
def hantei(l):
for i in range(3):
if all([l[i][j]==0 for j in range(3)]):
return 'Yes'
elif all([l[j][i]==0 for j in range(3)]):
return 'Yes'
elif l[0][0]==0 and l[1][1]==0 and l[2][2]==0:
return 'Yes'
elif l[0][2]==0 and l[1][1]==0 and l[2][0]==0:
return 'Yes'
else:
continue
return 'No'
#print(bingo)
print(hantei(bingo)) | from collections import deque
N = int(input())
c = [chr(ord("a") + i) for i in range(26)]
q = deque("a")
ans = []
while q:
s = q.pop()
if len(s) == N:
ans.append(s)
continue
for x in c[:c.index(max(s)) + 2]:
q.append(s + x)
[print(a) for a in sorted(ans)] | 0 | null | 56,101,147,499,190 | 207 | 198 |
N=int(input())
playlist={}
time=0
for i in range(N):
s,t=input().split()
time+=int(t)
playlist[s]=time
X=input()
print(time-playlist[X]) | n = int(input())
s = []
t = []
for i in range(n):
s_, t_ = map(str, input().split())
s.append(s_)
t.append(int(t_))
x = input()
for i in range(n):
if s[i] == x:
break
ans = 0
for j in range(n-1, i, -1):
ans += t[j]
print(ans) | 1 | 97,326,258,600,626 | null | 243 | 243 |
def counts(num):
countlist.append(len(str(num[0] + num[1])))
countlist = []
flag = True
while flag :
try:
counts(map(int, raw_input().split()))
except:
flag = False
for x in countlist:
print x | import math
def main():
data = []
while 1:
try:
n = input().split()
a = int(n[0])
b = int(n[1])
ans = int(math.log10(a+b)+1)
data.append(ans)
except EOFError:
break
for i in data:
print(i)
if __name__ == "__main__":
main() | 1 | 61,115,000 | null | 3 | 3 |
import itertools
import sys
from collections import Counter
sys.setrecursionlimit(10 ** 9)
M = 1000000007
N = int(sys.stdin.readline())
left = list(map(int, sys.stdin.read().split()))
counter = Counter(left)
def dp(t, ns):
cached = t.get(ns)
if cached is not None:
return cached
remaining = sum(ns)
assert remaining > 0
last_cnt = left[remaining - 1] + 1
n1, n2, n3 = ns
res = 0
if last_cnt == n1:
res += dp(t, tuple(sorted([n1 - 1, n2, n3])))
res %= M
if last_cnt == n2:
res += dp(t, tuple(sorted([n1, n2 - 1, n3])))
res %= M
if last_cnt == n3:
res += dp(t, tuple(sorted([n1, n2, n3 - 1])))
res %= M
# print(f"{remaining}: ({n1},{n2},{n3}) => {res}")
t[ns] = res
return res
def solve():
h = [0, 0, 0]
for i in range(N):
k = counter[i]
if k == 3:
h[0] = h[1] = h[2] = i + 1
elif k == 2:
h[0] = h[1] = i + 1
elif k == 1:
h[0] = i + 1
else:
break
if sum(h) != N:
return 0
t = dict()
t[0, 0, 0] = 1
res = dp(t, tuple(sorted(h)))
return (res * len(set(itertools.permutations(h)))) % M
print(solve())
| n = int(input())
s = input()
ans = 0
for i in range(1000):
i = '0' * (3 - len(str(i))) + str(i)
keep = 0
for j in range(n):
if s[j] == i[keep]:
keep += 1
if keep == 3:
ans += 1
break
print(ans)
| 0 | null | 129,394,278,292,950 | 268 | 267 |
N = int(input())
amari = N % 1000
if amari == 0:
change = 0
else:
change = 1000 - amari
print(change) | n = int(input())
for i in range(11):
if 1000*i >= n:
print(1000*i - n)
exit()
| 1 | 8,528,276,720,560 | null | 108 | 108 |
moji="abcdefghijklmnopqrstuvwxyz"
C=input()
x=[]
for i in range(26):
x.append(moji[i])
print(x[x.index(C)+1]) | C = input()
A = list("abcdefghijklmnopqrstuvwxyz")
A1 = A.index(C)
print(A[A1+1]) | 1 | 92,204,464,721,500 | null | 239 | 239 |
s=input()
l=set(s)
if(len(l)==1):
print("No")
else:
print("Yes")
| n, m, l = map(int, raw_input().split())
A = [map(int, raw_input().split()) for i in xrange(n)]
B = [map(int, raw_input().split()) for i in xrange(m)]
C = [[0] * l for i in xrange(n)]
for i in xrange(n):
for j in xrange(l):
C[i][j] = sum(A[i][k] * B[k][j] for k in xrange(m))
for c in C:
print " ".join(map(str, c)) | 0 | null | 28,020,677,831,608 | 201 | 60 |
#E問題
N, M, K = map(int, input().split())
MOD = 998244353
P = MOD
Y = max(N, M)
inv_t = [0]+[1]
for i in range(2, Y):
inv_t += [inv_t[P % i] * (P - int(P / i)) % P]
#print(inv_t)
if K == N - 1:
ans = 1
for i in range(N):
ans = ans * M % MOD
print(ans % MOD)
quit()
#if M == 1:
#if
#print("1")
# quit()
# M * ((M - 1) ** (N - L - 1)) * combination(N-1, L)のLを0からKまで足した総和が答え
B = [1] * N
ans1 = 1
for i in range(1, N):
ans1 = (ans1 * (M - 1)) % MOD
B[i] = (ans1 * M) % MOD
ans = 0
ans2 = 1
#X = 1
for i in range(K + 1):
if i == 0:
X = 1
else:
X = (X * (N - i) * inv_t[i]) % MOD
ans2 = X * B[N - 1 - i] % MOD
ans += ans2
ans = ans % MOD
print(ans)
| n =int(input().split()[0])
m = map(int, input().split())
c = [ i for i in range(n+1) ]
coins = []
for coin in m:
if coin <= n:
c[coin] = 1
coins.append(coin)
for p in range(2,n+1):
minc = c[p]
if minc <= 2:
continue
for coin in coins:
if p > coin:
if minc > c[p-coin]+1:
minc = c[p-coin]+1
c[p] = minc
print(c[n]) | 0 | null | 11,601,789,359,160 | 151 | 28 |
N, K = map(int, input().split())
if N < K:
print(min(abs(N - K), N))
else:
div, mod = divmod(N, K)
print(min(abs(mod-K), mod))
| # -*- coding: utf-8 -*-
N, K = map(int, input().split())
remainder = N % K
if remainder > K / 2:
print(abs(remainder - K))
else:
print(remainder) | 1 | 39,366,127,062,000 | null | 180 | 180 |
N = int(input())
A = list(map(int, input().split()))
B = []
b = 0
e = 10 ** 9 + 7
for i in range(N - 1):
b += A[N - 1 - i]
b = b % e
B.append(b)
result = 0
for i in range(N - 1):
result += A[i] * B[N - 2 - i]
result = result % e
print(result) | import sys
n = input()
a = []
flag = {}
for j in range(1, 14):
flag[('S',j)] = 0
flag[('H',j)] = 0
flag[('C',j)] = 0
flag[('D',j)] = 0
for i in range(n):
temp = map(str, raw_input().split())
a.append((temp[0],temp[1]))
#print a[i][0]
#print a[i][1]
card = ['S', 'H', 'C', 'D']
#print card
for egara in card:
for i in range(n):
if(a[i][0] == egara):
for j in range(1,14):
if(int(a[i][1]) == j):
flag[(egara, j)] = 1
for egara in card:
for j in range(1,14):
if(flag[(egara, j)] == 0):
sys.stdout.write(egara)
sys.stdout.write(' ')
sys.stdout.write(str(j))
print
exit(0) | 0 | null | 2,459,797,549,038 | 83 | 54 |
n, k = list(map(int, input().split()))
max_len = 2 * n - 1 # 適宜変更する
mod = 10**9 + 7
def modinv(x):
'''
xの逆元を求める。フェルマーの小定理より、 x の逆元は x ^ (mod - 2) に等しい。計算時間はO(log(mod))程度。
Python標準のpowは割った余りを出すことも可能。
'''
return pow(x, mod-2, mod)
# 二項係数の左側の数字の最大値を max_len とする。nとかだと他の変数と被りそうなので。
# factori_table = [1, 1, 2, 6, 24, 120, ...] 要は factori_table[n] = n!
# 計算時間はO(max_len * log(mod))
modinv_table = [-1] * (max_len + 1)
modinv_table[0] = None # 万が一使っていたときにできるだけ早期に原因特定できるようにしたいので、Noneにしておく。
factori_table = [1] * (max_len + 1)
factori_inv_table = [1] * (max_len + 1)
for i in range(1, max_len + 1):
factori_table[i] = factori_table[i-1] * (i) % mod
modinv_table[1] = 1
for i in range(2, max_len + 1):
modinv_table[i] = (-modinv_table[mod % i] * (mod // i)) % mod
factori_inv_table[i] = factori_inv_table[i-1] * modinv_table[i] % mod
def binomial_coefficients(n, k):
'''
n! / (k! * (n-k)! )
0 <= k <= nを満たさないときは変な値を返してしまうので、先にNoneを返すことにする。
場合によっては0のほうが適切かもしれない。
'''
if not 0 <= k <= n:
return None
return (factori_table[n] * factori_inv_table[k] * factori_inv_table[n-k]) % mod
def binomial_coefficients2(n, k):
'''
(n * (n-1) * ... * (n-k+1)) / (1 * 2 * ... * k)
'''
ans = 1
for i in range(k):
ans *= n-i
ans *= modinv_table[i + 1]
ans %= mod
return ans
if k >= n-1:
# nHn = 2n-1 C n
print(binomial_coefficients(2 * n - 1, n))
else:
# 移動がk回←→ 人数0の部屋がk個以下
# 人数0の部屋がちょうどj個のものは
# nCj(人数0の部屋の選び方) * jH(n-j) (余剰のj人を残りの部屋に入れる)
ans = 0
for j in range(k+1):
if j == 0:
ans += 1
else:
ans += binomial_coefficients(n, j) * binomial_coefficients(n-1, j)
ans %= mod
print(ans)
| N,M=map(int,input().split())
par=[i for i in range(N+1)]
size=[1 for i in range(N+1)]
def find(x):
if x!=par[x]:
par[x]=find(par[x])
return par[x]
def union(x,y):
if find(x)!=find(y):
x, y = par[x], par[y]
par[y] = par[x]
size[x] += size[y]
res=N
for i in range(M):
s,e=map(int,input().split())
union(s,e)
print(max(size)) | 0 | null | 35,369,781,845,672 | 215 | 84 |
import sys
sys.setrecursionlimit(10**8)
n = int(input())
x = list(input())
bit_cnt = x.count('1')
# bitを一つ増やす場合
pos = [0] * n
pos_total = 0
# bitを一つ減らす場合
neg = [0] * n
neg_total = 0
base = 1
for i in range(n):
pos[-i-1] = base%(bit_cnt+1)
if x[-i-1] == '1':
# 同時にmod(bit_cnt+1)の法でトータルを作成
pos_total = (pos_total + base) % (bit_cnt+1)
base = (base*2) % (bit_cnt+1)
base = 1
if bit_cnt == 1:
# mod取れない
pass
else:
for i in range(n):
neg[-i-1] = base%(bit_cnt-1)
if x[-i-1] == '1':
# 同時にmod(bit_cnt-1)の法でトータルを作成
neg_total = (neg_total + base) % (bit_cnt-1)
base = (base*2) % (bit_cnt-1)
def popcount(n):
s = list(bin(n)[2:])
return s.count('1')
memo = {}
memo[0] = 0
def dfs(n, depth=0):
if n in memo:
return depth + memo[n]
else:
ret = dfs(n%popcount(n), depth+1)
# memo[n] = ret
return ret
ans = []
for i in range(n):
if x[i] == '0':
st = (pos_total + pos[i]) % (bit_cnt+1)
print(dfs(st, depth=1))
elif bit_cnt == 1:
# コーナーケース：すべてのbitが0となる
print(0)
else:
st = (neg_total - neg[i]) % (bit_cnt-1)
print(dfs(st, depth=1))
| N = int(input())
X = input()
cnt = X.count('1')
if cnt == 1:
for x in X[:-1]:
if x == '0':
print(1)
else:
print(0)
if X[-1] == '1':
print(0)
else:
print(2)
exit()
M = 0
for x in X:
M <<= 1
if x == '1':
M += 1
def solve(n):
ret = 1
while n > 0:
ret += 1
n %= bin(n).count('1')
return ret
ans = []
p = M % (cnt + 1)
m = M % (cnt - 1)
for i in range(N):
if X[i] == '0':
ans.append(solve((p + pow(2, N - i - 1, cnt + 1)) % (cnt + 1)))
else:
ans.append(solve((m - pow(2, N - i - 1, cnt - 1)) % (cnt - 1)))
print(*ans, sep='\n')
| 1 | 8,225,840,920,640 | null | 107 | 107 |
"""
気付き
１、float('inf')はちょい遅いみたい
２、input()よりもinput = sys.stdin.readlineの方が爆速らしい（知らんがな）
"""
import sys
inf = 10 ** 15
input = sys.stdin.readline
N, M, L = map(int, input().split())
dp = [[inf] * N for _ in range(N)]
for _ in range(M):
a, b, c = map(int, input().split())
dp[a-1][b-1] = c
dp[b-1][a-1] = c
for i in range(N):
dp[i][i] = 0
for k in range(N):
for i in range(N):
for j in range(N):
dp[i][j] = min(dp[i][j], dp[i][k] + dp[k][j])
#print('distance={}'.format(dp))
dp2 = [[inf] * N for _ in range(N)]
for a in range(N - 1):
for b in range(a+1, N):
if dp[a][b] <= L:
dp2[a][b] = 1
dp2[b][a] = 1
for k in range(N):
for i in range(N):
for j in range(N):
dp2[i][j] = min(dp2[i][j], dp2[i][k] + dp2[k][j])
#print('times={}'.format(dp2))
Q = int(input())
for _ in range(Q):
s, t = map(int, input().split())
cost = dp2[s-1][t-1]
if cost != inf:
print(cost - 1)
else:
print(-1)
| #a,b,c = map(int,input().split())
a = int(input())
b = input()
c = b[:a//2]
d = b[a//2:a]
print("Yes" if c == d else "No") | 0 | null | 160,295,191,721,874 | 295 | 279 |
import sys
T1, T2, A1, A2, B1, B2 = map(int, sys.stdin.read().split())
a1, b1 = T1*A1, T1*B1
a2, b2 = T2*A2, T2*B2
sa, sb = a1+a2, b1+b2
if sa==sb:
print("infinity")
exit()
if sa < sb:
a1, a2, b1, b2, sa, sb = b1, b2, a1, a2, sb, sa
# 2*n-1 回以上出会うか
ok = 0
ng = 10**1800
a = 0
while ok+1 < ng:
c = (ok+ng)//2
if (c-1)*sa+a1 <= (c-1)*sb+b1:
if (c - 1) * sa + a1 == (c - 1) * sb + b1:
a = -1
ok = c
else:
ng = c
if ok > 10**1799:
print("a")
print("infinity")
else:
print(max(ok*2-1+a, 0))
| ls = []
while True:
try:
n = int(raw_input())
except EOFError:
break
ls.append(n)
ls.sort(reverse=True)
print ls[0]
print ls[1]
print ls[2] | 0 | null | 66,007,857,983,736 | 269 | 2 |
S, T = input().split()
A, B = input().split()
U = input()
if S==U:
print(int(A)-1,end=" ")
print(int(B))
else:
print(int(A),end=" ")
print(int(B)-1) | from sys import stdin
N = int(stdin.readline().rstrip())
A = [int(x) for x in stdin.readline().rstrip().split()]
max_node = [0] * (N+1)
for i in range(N-1,-1,-1):
max_node[i] = max_node[i+1]+A[i+1]
ans = 1
node = 1
for i in range(N+1):
node -= A[i]
if (i < N and node <= 0) or node < 0:
print(-1)
exit(0)
node = min(node*2,max_node[i])
ans += node
print(ans) | 0 | null | 45,180,025,838,998 | 220 | 141 |
X, N = map(int, input().split())
if N>0:
p = [int(i) for i in input().split()]
else:
p = [-1]
p = sorted(p)
#print(p)
try:
idx=p.index(X)
flag=False
for i in range(X+1):
for o in [-1,+1]:
if idx+(i*o) < 0 or idx + (i*o) >= N:
print(X+(i*o))
flag=True
break
elif X+(i*o)!=p[idx+(i*o)]:
print(X+(i*o))
flag=True
break
if flag:
break
except:
print(X) | import sys
from collections import deque, defaultdict, Counter
from itertools import accumulate, product, permutations, combinations
from operator import itemgetter
from bisect import bisect_left, bisect_right
from heapq import heappop, heappush
from math import ceil, floor, sqrt, gcd, inf
from copy import deepcopy
import numpy as np
import scipy as sp
INF = inf
MOD = 1000000007
x, n = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
tmp = 0
res = 0
P = np.array(P) - x
while True:
if not -res in P:
res *= -1
break
if not res in P:
break
res += 1
res += x
print(res)
| 1 | 14,015,881,463,110 | null | 128 | 128 |
n=int(input())
a=list(map(int,input().split()))
xor=0
for i in a:
xor ^= i
pop=0 #xorのpopにする
while(xor >> pop >=1):
pop += 1
sum_xor=xor #各猫の排他的論理和
ans=[]
for i in a:
x=i^sum_xor
ans.append(x)
print(" ".join(map(str, ans))) | N = int(input())
As = list(map(int,input().split()))
array = []
B = 0
for i in range(N):
B ^= As[i]
ans_array = []
for i in range(N):
ans_array.append(B^As[i])
print(*ans_array) | 1 | 12,526,243,840,282 | null | 123 | 123 |
MOD = 998244353
N, M, K = map(int, input().split())
fac = [1] * N
for i in range(1, N):
fac[i] = (fac[i - 1] * i) % MOD
pow_mmm = [1] * N
for i in range(1, N):
pow_mmm[i] = (pow_mmm[i - 1] * (M - 1)) % MOD
ans = 0
for i in range(K + 1):
t = (M * pow_mmm[N - 1 - i]) % MOD
comb = (fac[N - 1] * pow(fac[N - 1 - i], MOD - 2, MOD) * pow(fac[i], MOD - 2, MOD)) % MOD
t = (t * comb) % MOD
ans = (ans + t) % MOD
print(ans) | N, M, K = map(int, input().split())
MOD = 998244353
invmod = [pow(i, MOD-2, MOD) for i in range(200002)]
if N == 1:
print(M)
exit()
if M == 1:
if K == N-1:
print(1)
else:
print(0)
exit()
now = M * pow(M-1, N-1, MOD)
ans = now
if K == 0:
print(ans % MOD)
exit()
for ki in range(1, K+1):
now = now * invmod[M-1] * (N-ki) * invmod[ki] % MOD
ans += now
print(ans % MOD)
| 1 | 23,167,964,453,816 | null | 151 | 151 |
n = int(input())
d = []
z = 0
for i in range(n):
d1, d2 = map(int, input().split())
z = z+1 if d1==d2 else 0
d.append(z)
ans = 'Yes' if max(d)>=3 else 'No'
print(ans)
| N = int(input())
A = list(map(int,input().split()))
odds_or_even = N%2+2
inf = -float("inf")
dp = [[inf for _ in range(N+1)] for _ in range(odds_or_even)]
dp[0][0] = 0
for i in range(N):
dp[0][i+1] = dp[0][i]+A[i]*((i+1)%2)
for j in range(1,odds_or_even):
for i in range(N):
dp[j][i+1] = max(dp[j-1][i],dp[j][i]+A[i]*((i+j+1)%2))
print(dp[odds_or_even-1][N]) | 0 | null | 19,970,679,036,210 | 72 | 177 |
import math
a, b, n = list(map(int, input().split()))
x = min(n, b - 1)
ans = math.floor((a * x) / b) - a * math.floor(x / b)
print(ans)
| A, B, N = map(int, input().split())
m = B - 1 if N >= B else N
print(A * m // B)
| 1 | 28,128,447,428,832 | null | 161 | 161 |
n = int(input())
tenant = [
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ],
[ [0]*10, [0]*10, [0]*10, ]
]
for i in range(n):
b,f,r,nu = map(int, input().split())
tenant[b-1][f-1][r-1] += nu
for b in range(4):
for f in range(3):
print(' ', end='')
print(' '.join(map(str,tenant[b][f])))
if b < 3:
print('#'*20) | a = [[[0 for r in range(10)] for f in range(3)] for b in range(4)]
n = int(input())
for i in range(n):
b, f, r, v = map(int, input().strip().split())
a[b - 1][f - 1][r - 1] += v
for b in range(4):
for f in range(3):
print(''.join(' {}'.format(a[b][f][r]) for r in range(10)))
if b < 3:
print('#'*20) | 1 | 1,085,948,857,852 | null | 55 | 55 |
i = 1
a = input()
while a != 0:
print "Case %d: %d" % (i, a)
i = i + 1
a = input() | import math
h,w = map(int,input().split())
ans = 0
if h == 1 or w ==1 :
ans += 1
else:
#奇数行目+偶数行目
ans += math.ceil(h/2)*math.ceil(w/2)+(h//2)*(w//2)
print(ans) | 0 | null | 25,520,562,665,792 | 42 | 196 |
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の数
zeros=min(K, N-1)
ans=1
for i in range(1,zeros+1):
ans+=(cmb(N,i,p)*cmb(i+N-i-1, i, p))%p
#print(pow(N-i, i, p))
ans%=p
print(ans) | n = int(input())
stone = list(input())
l = 0
r = n-1
ans = 0
while l < r:
if stone[l]=='W':
if stone[r]=='R':
ans += 1
l += 1
r -= 1
else:
r -= 1
else:
l += 1
if stone[r]=='W':
r -= 1
print(ans) | 0 | null | 36,864,631,548,642 | 215 | 98 |
n=int(input())
a=1
ans=n
while a*a<=n:
if n%a==0:
ans=min(a+n//a-2,ans)
a+=1
print(ans) | n = int(input())
root = int(n**0.5)
a = 0
for i in range(root, 0, -1):
if n % i == 0:
a = i
break
b = n // a
print(a+b - 2)
| 1 | 162,101,269,015,740 | null | 288 | 288 |
n = int(input())
A = list(map(int, input().split()))
mod = 10**9+7
ans = 0
for i in range(61):
cnt0 = 0
cnt1 = 0
for a in A:
if (a>>i) & 1 == 0:
cnt0 += 1
else:
cnt1 += 1
ans += cnt0 * cnt1 * (2 ** i)
ans %= mod
print(ans) | b=int(input())
a=list(map(int,input().split()))
ans=""
total=0
for i in a:
total^=i
for i in a:
ans+=str(total^i)+" "
print(ans) | 0 | null | 67,406,225,599,452 | 263 | 123 |
import sys
sys.setrecursionlimit(10000000)
MOD = 10 ** 9 + 7
INF = 10 ** 15
def main():
S = input()
pair = []
stack = [('%',-1)]
for j,s in enumerate(S):
if s == '/':
if stack[-1][0] == '\\':
i = stack[-1][1]
stack.pop()
pair.append((i,j))
elif s == '_':
continue
else:
stack.append((s,j))
pond = []
tot = 0
k = len(pair) - 1
while k >= 0:
fin = pair[k][0] - 1
area = 0
while k >= 0 and fin < pair[k][0]:
area += pair[k][1] - pair[k][0]
k -= 1
pond.append(area)
tot += area
pond.append(len(pond))
print(tot)
print(*pond[::-1])
if __name__ == '__main__':
main()
| val = input().split()
sheep = int(val[0])
wolf = int(val[1])
if (wolf - sheep) >= 0:
print("unsafe")
else:
print("safe") | 0 | null | 14,690,819,906,948 | 21 | 163 |
def run():
X, N = [int(v) for v in input().rstrip().split()]
p = []
if N > 0:
p = [int(v) for v in input().rstrip().split()]
i = -1
try:
i = p.index(X)
except ValueError:
pass
if i == -1:
# not contained
return X
d1 = {}
for k in range(0, 102):
d1[k] = k
for v in p:
del d1[v]
l2 = sorted(list(d1.keys()))
l2.append(X)
l2.sort()
i = l2.index(X)
r = 0
if i == 0:
r = l2[1]
elif (i + 1) == len(l2):
r = l2[-2]
else:
v1 = l2[i + 1] - X
v2 = X - l2[i - 1]
if v1 < v2 :
r = l2[i + 1]
elif v1 > v2 :
r = l2[i - 1]
else:
# v1 == v2
r = l2[i - 1]
return r
r = run()
print(r)
| x, n = map(int, input().split())
p = list(map(int, input().split()))
for i in range(x+1):
for j in [-1, 1]:
ans = x + i*j
if not p.count(ans):
print(ans)
exit(0)
| 1 | 14,055,520,459,468 | null | 128 | 128 |
mf = 0
while True:
m,f,r = [int(i) for i in input().strip().split()]
if m==f==r==-1 : break
mf = m+f
if m*f<0 or mf<30 : print("F")
elif mf<50 and r<50 : print("D")
elif mf<65 : print("C")
elif mf<80 : print("B")
elif mf>=80 : print("A")
else: print("F") | import sys
# import re
# import math
import collections
# import decimal
# import bisect
# import itertools
# import fractions
# import functools
import copy
# import heapq
# import decimal
# import statistics
import queue
sys.setrecursionlimit(10000001)
INF = 10 ** 16
MOD = 10 ** 9 + 7
MOD2 = 998244353
ni = lambda: int(sys.stdin.readline())
ns = lambda: map(int, sys.stdin.readline().split())
na = lambda: list(map(int, sys.stdin.readline().split()))
# ===CODE===
def main():
n = ni()
d = na()
c = collections.Counter(d)
lim = max(c)
flg = False
if d[0] != 0:
flg = True
if c[0] != 1:
flg = True
for i in range(lim + 1):
if i not in c.keys():
flg = True
break
if flg:
print(0)
exit(0)
ans = 1
for i in range(2, lim + 1):
ans *= pow(c[i - 1], c[i], MOD2)
ans %= MOD2
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 77,755,300,321,838 | 57 | 284 |
N = input()
inpa = input().split(" ")
count =0
for x in range(0,int(N),2):
if int(inpa[x])%2==1:
count = count + 1
print(count) | #-*-coding:utf-8-*-
import sys
input=sys.stdin.readline
import collections
def main():
bosses=[]
count={}
n = int(input())
bosses=list(map(int,input().split()))
ans=[0]*n
for i in bosses:
ans[i-1]+=1
for a in ans:
print(a)
if __name__=="__main__":
main() | 0 | null | 20,168,411,232,760 | 105 | 169 |
while True:
cards=input()
if cards=='-': break
for _ in range(int(input())):
h = int(input())
cards=cards[h:]+cards[:h]
print(cards) | while 1:
a = input()
if a == '-':
break
n = int(input())
for i in range(n):
h = int(input())
a = a[h:] + a[:h]
print(a)
| 1 | 1,937,659,263,910 | null | 66 | 66 |
h,w,m=map(int,input().split())
item=[list(map(int,input().split())) for i in range(m)]
row=[0]*h
col=[0]*w
for i in range(m):
x,y=item[i]
row[x-1]+=1
col[y-1]+=1
mr,mc=max(row),max(col)
xr=set([i for i in range(h) if row[i]==mr])
xc=set([i for i in range(w) if col[i]==mc])
check=len(xr)*len(xc)
for i in range(m):
r,c=item[i]
if r-1 in xr and c-1 in xc:
check-=1
print(mr+mc if check>0 else mr+mc-1) | def p_has_value_x(p:list, x:int):
for item in p:
if int(item) == x:
return True
return False
def solve(p: list, x:int) -> int:
if not p_has_value_x(p, x):
return x
pos = 1
while True:
aim_value = x - pos
if aim_value <= 0:
return aim_value
if not p_has_value_x(p, aim_value):
return aim_value
aim_value = x + pos
if not p_has_value_x(p, aim_value):
return aim_value
pos += 1
x, n = map(int, input().split())
if n == 0:
print(x)
else:
p = input().split()
print(solve(p, x))
| 0 | null | 9,418,587,708,712 | 89 | 128 |
hitsuji, okami = map(int, input().split())
if hitsuji <= okami:
print('unsafe')
else:
print('safe')
| a,b,c,d=map(int,input().split())
for i in range(1001):
if i%2==0:
c-=b
if c<=0:
print("Yes")
exit(0)
else:
a-=d
if a<=0:
print("No")
exit(0)
| 0 | null | 29,419,478,482,048 | 163 | 164 |
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
# combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce
mod = int(1e9+7)
# mod = 998244353
INF = 1<<50
def readInt():
return list(map(int,input().split()))
def main():
n,k = readInt()
r,s,p = readInt()
rsp = {"s":r,"p":s,"r":p}
t = input()
ans = 0
u = []
for i in range(n):
if i<k:
ans += rsp[t[i]]
u.append(t[i])
else:
if t[i]!=u[i-k]:
ans += rsp[t[i]]
u.append(t[i])
else:
u.append("f")
print(ans)
return
if __name__=='__main__':
main()
| h,w,n = [int(input()) for i in range(3)]
print((n-1)//max(h,w)+1) | 0 | null | 98,093,066,211,060 | 251 | 236 |
n = int(input())
g = [[] for _ in range(n)]
for i in range(n):
a = int(input())
for j in range(a):
x, y = map(int, input().split())
x -= 1
g[i].append((x, y))
ans = 0
for i in range(2**n):
temp = [-1]*n
for j in range(n):
if (i >> j) & 1:
temp[j] = 1
else:
temp[j] = 0
flag = True
for j in range(n):
if temp[j] == 1:
for x, y in g[j]:
if temp[x] != y:
flag = False
if flag:
ans = max(ans, sum(temp))
print(ans)
| def main():
n = int(input())
xy = []
for i in range(n):
a = int(input())
xy.append([tuple(map(int, input().split())) for _ in range(a)])
c = 0
for i in range(1 << n):
popcnt = bin(i).count('1')
if popcnt <= c:
continue
all_honest = True
for j in range(n):
if (1 << j) & i != 0:
for x, y in xy[j]:
x -= 1 # 人の番号をひとつずらす
if ((1 << x) & i) >> x != y:
all_honest = False
break
if not all_honest:
break
if all_honest:
c = popcnt
print(c)
if __name__ == '__main__':
main()
| 1 | 121,239,467,804,740 | null | 262 | 262 |
N,K = map(int,input().split())
L = []
for _ in range(K):
l,r = map(int,input().split())
L.append((l,r))
DP = [0] * N
DP[0] = 1
con = [0] * (N + 1)
con[1] = 1
for i in range(1 , N):
s = 0
for l,r in L:
s += con[max(0 , i - l + 1)] - con[max(0 , i - r)]
DP[i] = s
con[i + 1] = (con[i] + DP[i]) % 998244353
print(DP[N - 1] % 998244353)
| n,k=map(int,input().split())
l=[0]*k
r=[0]*k
mod=998244353
for i in range(k):
l[i],r[i]=map(int,input().split())
dp=[0]*n
sum_dp=[0]*n
dp[0]=1
sum_dp[0]=1
for i in range(1,n):
for j in range(k):
if (i-l[j]>=0):
dp[i]+=sum_dp[i-l[j]]
dp[i]%=mod
if (i-r[j]-1>=0):
dp[i]-=sum_dp[i-r[j]-1]
dp[i]+=mod
dp[i]%=mod
sum_dp[i]=sum_dp[i-1]+dp[i]
sum_dp[i]%=mod
print(dp[n-1]) | 1 | 2,694,889,740,260 | null | 74 | 74 |
H = int(input())
seen = {}
seen[1] = 1
def count(n):
if n in seen.keys():
return seen[n]
else:
return 2 * count(n//2) + 1
print(count(H))
| class Dice:
arr = []
tmpArr = []
def __init__(self, arr):
self.arr = arr
def move(self, pos):
if pos == 'E':
self.eastMove()
elif pos == 'N':
self.northMove()
elif pos == 'S':
self.sorthMove()
elif pos == 'W':
self.westMove()
def out(self):
return self.arr[0]
def eastMove(self):
self.changeArr(3, 6)
self.changeArr(3, 4)
self.changeArr(3, 1)
def northMove(self):
self.changeArr(5, 6)
self.changeArr(5, 2)
self.changeArr(5, 1)
def sorthMove(self):
self.changeArr(2, 6)
self.changeArr(2, 5)
self.changeArr(2, 1)
def westMove(self):
self.changeArr(4, 6)
self.changeArr(4, 3)
self.changeArr(4, 1)
def changeArr(self, f, t):
tmp = self.arr[f - 1]
self.arr[f - 1] = self.arr[t - 1]
self.arr[t - 1] = tmp
diceNum = list(map(int, input().split(' ')))
dice = Dice(diceNum)
posAction = input()
for pos in posAction:
dice.move(pos)
print(dice.out())
| 0 | null | 40,000,230,692,690 | 228 | 33 |
import string
from itertools import zip_longest
turn = int(input())
dic = {s: i for i, s in enumerate(string.ascii_lowercase)}
t_s, h_s = 0, 0
for _ in range(turn):
t, h = input().split()
if t == h:
t_s += 1
h_s += 1
for t_c, h_c in zip_longest(t, h, fillvalue='a'):
if dic[t_c] > dic[h_c]:
t_s += 3
break
elif dic[t_c] < dic[h_c]:
h_s += 3
break
print(t_s, h_s)
| n = int(input())
t_count = 0
h_count = 0
for i in range(n):
t_animal,h_animal = map(str,input().split())
if t_animal < h_animal:
h_count+=3
elif t_animal > h_animal:
t_count+=3
else:
t_count+=1
h_count+=1
print("{} {}".format(t_count,h_count))
| 1 | 1,991,623,518,020 | null | 67 | 67 |
[W,H,x,y,r] = raw_input().split(' ')
W = int(W)
H = int(H)
x = int(x)
y = int(y)
r = int(r)
h = False
if x - r >= 0:
if x + r <= W:
if y - r >= 0:
if y + r <= H:
h = True
if h:
print 'Yes'
else:
print 'No' | w,h,x,y,r=map(int,input().split())
if (r<=x<=(w-r))and(r<=y<=(h-r)):
print("Yes")
else:
print("No") | 1 | 458,229,073,892 | null | 41 | 41 |
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
ng=-1
ok=A[-1]*2+1
B=[[0]*n for k in range(2)]
ii=0
while ok-ng>1:
mid=(ok+ng)//2
d=0
for i in range(n):
c=n-bisect.bisect_right(A,mid-A[i],lo=0,hi=len(A))
B[ii][i]=c
d=d+c
if d<m:
ok=mid
ii=(ii+1)%2
else:
ng=mid
D=[0]
for i in range(n):
D.append(D[-1]+A[n-i-1])
ans=0
for i in range(n):
x=B[(ii+1)%2][i]
ans=ans+A[i]*x+D[x]
ans=ans+(m-sum(B[(ii+1)%2]))*ok
print(ans) | import sys
read = sys.stdin.buffer.read
input = sys.stdin.buffer.readline
inputs = sys.stdin.buffer.readlines
import bisect
n,m=map(int,input().split())
A=list(map(int,input().split()))
A.sort()
def hand(x):
cnt=0
for i in range(n):
p=x-A[i]
cnt+=n-bisect.bisect_left(A,p)
return cnt
def main():
l=0
h=2*10**5+1
mid=(l+h)//2
while l+1<h:
mid=(l+h)//2
if hand(mid)<m:
h=mid
else:
l=mid
B=A[::-1]
for i in range(n-1):
B[i+1]+=B[i]
B=B[::-1]
ans=0
cnt=0
for i in range(n):
y=l-A[i]+1
index=bisect.bisect_left(A,y)
if n==index:
continue
else:
ans+=(n-index)*A[i]+B[index]
cnt+=(n-index)
ans+=(m-cnt)*l
print(ans)
if __name__ == "__main__":
main()
| 1 | 108,256,625,125,220 | null | 252 | 252 |
num = list(map(int,input()))
if num[-1] == 3:
print("bon")
elif num[-1] in (0, 1, 6, 8):
print("pon")
else:
print("hon")
| # 10^100のクソデカ数値がクソデカすぎるため、+0,+1..+Nが束になってもいたくも痒くもない
# なのでもはや無視していい
# 最初の例でいうと、2つ選ぶのは[0,1,2,3]からなので、和のバリエーションは最小値1~最大値5の5つ
# 3つ選ぶのは最小値3~最大値6の4つ
# 4つ選ぶのは1つ
# 毎回最大値と最小値を計算して差+1を加えてやるとできあがり
# 計算には数列の和を使う
n, k = map(int, input().split())
mod = 10**9 + 7
ans = 1
for i in range(k, n + 1):
# 初項0,公差1,末項i-1までの和
min_s = i * (i - 1) // 2
# 初項n+1-i, 公差1, 末項i-1までの和
max_s = i * (2 * (n + 1 - i) + (i - 1)) // 2
ans += max_s - min_s + 1
ans %= mod
print(ans)
| 0 | null | 26,301,926,304,820 | 142 | 170 |
k=0
n=input()
n=n.lower()
s=input()
while s!='END_OF_TEXT':
s=s.lower()
S=s.split()
#print(S)
for i in range(len(S)):
if n==S[i]:
k+=1
s=input()
print(k)
| a = int(input())
sum = a + a*a +a*a*a
print(sum) | 0 | null | 6,048,359,045,780 | 65 | 115 |
import sys
x, y = map(int, input().split())
ans = 0
for i in range(x+1):
if y == i*2 + (x - i)* 4:
ans = 1
break
if ans == 1:
print("Yes")
else:
print("No") | base = input().split()
print(base[1],end="")
print(base[0]) | 0 | null | 58,556,908,602,042 | 127 | 248 |
import math
def LI():
return list(map(int, input().split()))
L, R, d = LI()
Ld = (L-1)//d
Rd = R//d
ans = Rd-Ld
print(ans)
| # coding: utf-8
import sys
from collections import deque
n, q = map(int, input().split())
total_time = 0
tasks = deque(map(lambda x: x.split(), sys.stdin.readlines()))
for task in tasks:
task[1] = int(task[1])
try:
while True:
t = tasks.popleft()
if t[1] - q <= 0:
total_time += t[1]
print(t[0], total_time)
else:
t[1] = t[1] - q
total_time += q
tasks.append(t)
except Exception:
pass | 0 | null | 3,789,522,167,364 | 104 | 19 |
from collections import defaultdict
H, W, M = map(int, input().split())
row_bom_cnt = defaultdict(int)
col_bom_cnt = defaultdict(int)
row_max = 0
col_max = 0
boms = [list(map(int, input().split())) for _ in range(M)]
for rm, cm in boms:
row_bom_cnt[rm] += 1
col_bom_cnt[cm] += 1
row_max = max(row_max, row_bom_cnt[rm])
col_max = max(col_max, col_bom_cnt[cm])
target_row = set()
for r, val in row_bom_cnt.items():
if val == row_max:
target_row.add(r)
target_col = set()
for c, val in col_bom_cnt.items():
if val == col_max:
target_col.add(c)
cnt = 0
for rm, cm in boms:
if rm in target_row and cm in target_col:
cnt += 1
if len(target_row) * len(target_col) == cnt:
print(row_max + col_max - 1)
else:
print(row_max + col_max)
| def main():
a, b = input().split()
if a < b:
ans = a * int(b)
else:
ans = b * int(a)
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 44,591,357,826,982 | 89 | 232 |
n = int(input())
tbl = [[0]*10 for _ in [0]*10]
k = 10
for i in range(1, n+1):
if i // k: k *= 10
l = i*10//k
r = i%10
tbl[l][r] += 1
ans = 0
for l, _t in enumerate(tbl):
for r, t in enumerate(_t):
if l == r:
ans += t*t
else:
ans += t*tbl[r][l]
print(ans) | n = int(input())
# cs = ['W' for i in range(200000)]
cs = input()
w_count = 0
for c in cs:
if c == 'W':
w_count += 1
if w_count == 0:
print(0)
exit()
rest = cs[-w_count:]
answer = 0
for c in rest:
if c == 'R':
answer += 1
print(answer)
| 0 | null | 46,161,707,575,748 | 234 | 98 |
S = input()
Sx = ""
for _ in range(len(S)):
Sx += "x"
S = Sx
print(S) | S = input()
L = len(S)
for i in range(L):
print("x",end='') | 1 | 72,856,067,100,952 | null | 221 | 221 |
N, K = list(map(int, input().split()))
ans = min(N % K, K - (N % K))
print(ans) | N, K = map(int, input().split())
def f(x):
return( N-x*K )
def test(x):
return( f(x) >= 0 )
left = - 1 # return = right = (取り得る値の最小値) の可能性を排除しないために、-1 が必要
right = 10**18
while right - left > 1: # 最終的に (right, left, mid) = (最小値, 最小値 - 1, 最小値 - 1) に収束するため、差が 1 になったときに終了すればよい
mid = (left+right)//2
if test(mid):
left = mid
else:
right = mid
print(min(abs(N-left*K), abs(N-right*K))) | 1 | 39,311,554,428,550 | null | 180 | 180 |
from sys import stdin,stdout #
import math #
import heapq #
#
t = 1 #
def aint(): #
return int(input().strip()) #
def lint(): #
return list(map(int,input().split())) #
def fint(): #
return list(map(int,stdin.readline().split())) #
#
########################################################
def f(n):
if n==0:
return 0
# print(n)
N=n
cnt=0
while(N):
cnt+=N&1
N>>=1
return f(n%cnt)+1
def main():
n=aint()
x=input()
c=x.count("1")
if(c==0):
for i in range(n):
print("1")
return
elif(c==1):
for i in range(n):
if(x[i]=="1"):
print(0)
elif x[i]=="0":
if x[n-1]=="1"or i==(n-1):
print("2")
else:
print(1)
return
mod1=c+1
mod2=c-1
mul1=1
mul2=1
rem1=0
rem2=0
for i in range(n-1,-1,-1):
if(x[i]=='1'):
rem1=(rem1+mul1)%mod1
rem2=(rem2+mul2)%mod2
mul1=(2*mul1)%mod1
mul2=(2*mul2)%mod2
ans=[]
mul1=1
mul2=1
# print(mod1,mod2)
# print(rem1,rem2)
for i in range(n-1,-1,-1):
if(x[i]=='0'):
# print("At index",i,"val",(rem1+mul1)%mod1)
ans.append(f((rem1+mul1)%mod1)+1)
else:
# print("At index",i,"val",(rem2-mul2)%mod2)
ans.append(f((rem2-mul2)%mod2)+1)
mul1=(2*mul1)%mod1
mul2=(2*mul2)%mod2
# print("Ans:")
for i in range(n-1,-1,-1):
print(ans[i])
return
#t=int(input())
########################################################
for i in range(t): #
#print("Case #"+str(i+1)+":",end=" ") #
main() # | A = 100
X = int(input())
cnt = 0
while X > A:
cnt += 1
A += A // 100
print(cnt) | 0 | null | 17,704,943,785,034 | 107 | 159 |
def main():
n, a, b = map(int, input().split())
ab_diff = abs(a-b)
if ab_diff%2 == 0:
print(ab_diff//2)
return
a_edge_diff = min(abs(a-1),abs(n-a))
b_edge_diff = min(abs(b-1),abs(n-b))
# near_diff = min(a_edge_diff, b_edge_diff)
if a_edge_diff <= b_edge_diff:
print(a_edge_diff+1+ (ab_diff-1)//2)
else:
print(b_edge_diff+1+ (ab_diff-1)//2)
if __name__ == "__main__":
main() | # -*- coding: utf-8 -*-
def judge(m, f, r):
if m==-1 or f==-1: return "F"
ttl = m + f
if ttl >= 80: return "A"
elif ttl >= 65: return "B"
elif ttl >= 50: return "C"
elif ttl >= 30:
return "C" if r>=50 else "D"
else: return "F"
if __name__ == "__main__":
while True:
m, f, r = map(int, raw_input().split())
if m==-1 and f==-1 and r==-1: break
print judge(m, f, r) | 0 | null | 55,556,565,403,040 | 253 | 57 |
H1, M1, H2, M2, K = map(int, input().split())
ans = H2*60 + M2 - H1*60 - M1 - K
print(ans) | import math
import re
import copy
h1,m1,h2,m2,k = map(int,input().split())
w1 = h1*60 + m1
w2 = h2 * 60 + m2
w3 = (w2-w1+24*60)%(24*60)
w3 = w3 - k
print(w3)
| 1 | 18,133,145,587,232 | null | 139 | 139 |
h1,m1,h2,m2,k =(int(x) for x in input().split())
hrtom= (h2-h1)
if (m2-m1 < 0) and (h2-h1 >=0) :
min = (h2-h1)*60 + (m2-m1) - k
print(min)
elif (m2-m1 >= 0) and (h2-h1 >=0 ):
min = (h2-h1)*60 + (m2-m1) - k
print(min)
else:
print('0') | H1, M1, H2, M2, K = map(int, input().split())
print(60 * (H2 - H1) + M2 - M1 - K) | 1 | 17,922,685,606,478 | null | 139 | 139 |
import sys
readline = sys.stdin.readline
MOD = 10 ** 9 + 7
INF = float('INF')
sys.setrecursionlimit(10 ** 5)
def main():
n = int(input())
a = list(map(int, readline().split()))
dp = [[0] * (n + 1) for _ in range(n + 1)]
for i in range(n):
val = max(a)
idx = a.index(val)
a[idx] = 0
for j in range(i + 1):
left = j
right = i - j
prev = dp[left][right]
dp[left + 1][right] = max(dp[left + 1][right], prev + val * (idx - left))
dp[left][right + 1] = max(dp[left][right + 1], prev + val * ((n - 1 - right) - idx))
ans = 0
for i in range(n):
ans = max(ans, dp[i][n - i])
print(ans)
if __name__ == '__main__':
main()
| from collections import deque
from heapq import heapify,heappop,heappush,heappushpop
from copy import copy,deepcopy
from itertools import permutations,combinations
from collections import defaultdict,Counter
# from math import gcd,ceil,floor,factorial
# from fractions import gcd
from functools import reduce
from pprint import pprint
def myinput():
return map(int,input().split())
def mylistinput(n):
return [ list(myinput()) for _ in range(n) ]
def mycol(data,col):
return [ row[col] for row in data ]
def mysort(data,col,reverse_flag):
data.sort(key=lambda x:x[col],reverse=reverse_flag)
return data
def mymax(data):
M = -1*float("inf")
for i in range(len(data)):
m = max(data[i])
M = max(M,m)
return M
def mymin(data):
m = float("inf")
for i in range(len(data)):
M = min(data[i])
m = min(m,M)
return m
def myoutput(ls,space=True):
if space:
if len(ls)==0:
print(" ")
elif type(ls[0])==str:
print(" ".join(ls))
elif type(ls[0])==int:
print(" ".join(map(str,ls)))
else:
print("Output Error")
else:
if len(ls)==0:
print("")
elif type(ls[0])==str:
print("".join(ls))
elif type(ls[0])==int:
print("".join(map(str,ls)))
else:
print("Output Error")
n = int(input())
a = list(myinput())
ls = []
for i in range(n):
ls.append([ i,a[i] ])
ls = mysort(ls,1,True)
# print(ls)
dp = [ [0]*(n+1) for _ in range(n+1) ]
# dp[i][l]: Aが大きい方からi番目まで決め，左へ移動した個数がl個である時の，スコアの最大値
for i in range(n):
f = ls[i][0]
A = ls[i][1]
for l in range(i+1):
#
# 【このi番目を右へ寄せる場合（左へ寄せない場合）】
# 移動先t
t = n - i + l - 1
# スコア
s = A*abs(t-f)
# dpテーブルの要素としての更新候補
dp1 = dp[i][l] + s
# 既に入っている値より大きければ更新
if dp1 > dp[i+1][l]:
dp[i+1][l] = dp1
#
# 【このi番目を左へ寄せる場合】
# 移動先t
t = l
# スコア
s = A*abs(t-f)
# dpテーブルの要素としての更新候補
dp2 = dp[i][l] + s
#
# 既に入っている値より大きければ更新
if dp2 > dp[i+1][l+1]:
dp[i+1][l+1] = dp2
# pprint(dp)
print(max(dp[n])) | 1 | 33,735,908,060,828 | null | 171 | 171 |
n,k = map(int,input().split())
A = sorted(list(map(int,input().split())))
F = sorted(list(map(int,input().split())))[::-1]
o = []
for a,f in zip(A,F):
o.append(a*f)
ok = max(o)
ng = -1
while ok - ng > 1:
mid = (ok+ng)//2
k1 = 0
for i in range(n):
k1 += max( 0 , A[i]- mid//F[i])
if k1<= k:
ok = mid
else:
ng = mid
print(ok)
| import sys
input = sys.stdin.buffer.readline
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]
left = -1
right = max(A) * max(F)
while left + 1 < right:
mid = (left + right) // 2
tmp = 0
for i in range(N):
a, f = A[i], F[i]
if a * f > mid:
tmp += -(-(a * f - mid) // f)
if tmp <= K:
right = mid
else:
left = mid
print(right) | 1 | 164,359,141,793,852 | null | 290 | 290 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.