code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 6.82M
181,637B
⌀ | question_pair_id
float64 101M
180,471B
⌀ | code1_group
int64 2
299
| code2_group
int64 2
299
|
|---|---|---|---|---|---|---|
n = int(input())
a = [int(i) for i in input().split()]
print(min(a), max(a), sum(a))
|
n = input()
lis = map(int, raw_input().split())
mn = lis[0]
mx = lis[0]
for t in lis:
if mn > t:
mn = t
if mx < t:
mx = t
print mn, mx, sum(lis)
| 1 | 725,277,779,844 | null | 48 | 48 |
A,V = map(int,input().split())
B,W = map(int,input().split())
T = int(input())
dist = abs(A-B)
diff = V-W
if dist > diff * T:
print("NO")
else:
print("YES")
|
K = int(input())
cnt=1
Num=7%K
while cnt<=K:
if K%2==0:
print('-1')
break
if Num%K==0:
print(cnt)
break
else:
Num = (10*Num + 7)%K
cnt+=1
else:
print('-1')
| 0 | null | 10,616,957,292,828 | 131 | 97 |
import sys
n = int(input())
dic = set()
for i in range(n):
cmd = sys.stdin.readline().split()
if cmd[0] == "insert":
dic.add(cmd[1])
else:
print("yes" if cmd[1] in dic else "no")
|
if __name__ == '__main__':
from collections import deque
n = int(input())
dic = {}
for i in range(n):
x = input().split()
if x[0] == "insert":
dic[x[1]] = 1
if x[0] == "find":
if x[1] in dic:
print('yes')
else:
print('no')
| 1 | 74,018,784,010 | null | 23 | 23 |
import re
if re.match('[A-Z]', input()):
print('A')
else:
print('a')
|
import sys
alpha = input()
text = 'abcdefghijklmnopqrstuvwxyz'
for k in range(26):
if text[k] == alpha:
print('a')
sys.exit()
else:
if k == 25:
print('A')
| 1 | 11,333,164,469,792 | null | 119 | 119 |
from collections import deque
X, K, D = map(int, input().split())
# まずは何回目で符号が逆転するかを算出
num_reverse = abs(X) // D + 1
if num_reverse > K:
print(abs(X) - (K * D))
else:
K -= num_reverse
ans = abs(X) - (num_reverse * D)
if K % 2 == 0:
print(abs(ans))
else:
print(abs(abs(ans) - D))
|
s = list(input())
n = len(s)
m = n//2
s_f = []
s_l = []
for i in range(m):
s_f.append(s[i])
for i in range(1,m + 1):
s_l.append(s[-i])
s_r = list(reversed(s))
s_f_r = list(reversed(s_f))
s_l_r = list(reversed(s_l))
if s_r == s:
if s_f_r == s_f and s_l_r == s_l:
print("Yes")
else:
print("No")
else:
print("No")
| 0 | null | 25,633,016,626,270 | 92 | 190 |
s = input()
t = input()
c = 0
for i in range(len(s)):
if s[i]==t[i] and len(t)==len(s)+1:
c+=1
if c==len(s):
print("Yes")
else:
print("No")
|
from collections import deque
dq = deque()
for _ in [None]*int(input()):
s = input()
if s == "deleteFirst":
dq.popleft()
elif s == "deleteLast":
dq.pop()
else:
a, b = s.split()
if a == "insert":
dq.appendleft(b)
else:
if b in dq:
dq.remove(b)
print(" ".join(dq))
| 0 | null | 10,798,193,363,228 | 147 | 20 |
import sys
def main():
input = sys.stdin.readline
n, k = map(int, input().split())
a = [int(x) for x in input().split()]
f = [int(x) for x in input().split()]
a.sort(reverse=True)
f.sort()
l, r = -1, pow(10, 12)+1
while r-l > 1:
judge = (r+l)//2
sub = 0
for i in range(n):
if a[i]*f[i] <= judge:
continue
sub += a[i]-judge//f[i]
if sub <= k:
r = judge
else:
l = judge
print(r)
if __name__ == "__main__":
main()
|
N,K=map(int,input().split())
P=list(map(int,input().split()))
P.sort()
b=0
for i in range(K):
b+=P[i]
print(b)
| 0 | null | 88,008,577,726,302 | 290 | 120 |
X, K, D = map(int, input().split())
if X - K * D >= 0:
ans = abs(X - K * D)
elif X + K * D <= 0:
ans = abs(X + K * D)
else:
n = int(abs(X - K * D) / (2 * D))
ans = min(abs(X - K * D + n * 2 * D), abs(X - K * D + (n + 1) * 2 * D))
print(ans)
|
print(1 if int(input()) == 0 else 0)
| 0 | null | 4,072,032,117,720 | 92 | 76 |
inputStr = input()
numList = inputStr.split(' ')
numList = [int(x) for x in numList]
#print('a: ',numList[0])
#print('b: ',numList[1])
if numList[0]==numList[1]:
print('a == b')
elif numList[0]>numList[1]:
print('a > b')
elif numList[0]<numList[1]:
print('a < b')
|
N = int(input())
dmin = N+N
for i in range(1,int(N**0.5)+1):
if N%i==0:
dmin = min(dmin,i+N//i-2)
print(dmin)
| 0 | null | 80,665,674,727,980 | 38 | 288 |
a,b,h,w=map(int,input().split())
import math
theta=math.radians(abs((h+w/60)*360/12-w*360/60))
c=(a**2+b**2-2*a*b*math.cos(theta))**0.5
print(c)
|
#!python3
import sys
from collections import defaultdict
from math import gcd
iim = lambda: map(int, input().rstrip().split())
def resolve():
N = input()
it = map(int, sys.stdin.read().split())
mod = 10**9 + 7
d1 = [defaultdict(int), defaultdict(int)]
z0 = za = zb = 0
for ai, bi in zip(it, it):
t = ai * bi
if t == 0:
if ai != 0:
za += 1
elif bi != 0:
zb += 1
else:
z0 += 1
continue
ci = gcd(ai, bi)
ai, bi = ai // ci, bi // ci
t = t < 0
if ai < 0:
ai, bi = -ai ,-bi
d1[t][(ai, bi)] += 1
a1, a2 = d1
ans = 1
z1 = 0
for (ai, bi), v in a1.items():
k2 = (bi, -ai)
if k2 in a2:
v2 = a2[k2]
ans *= pow(2, v, mod) + pow(2, v2, mod) - 1
ans %= mod
else:
z1 += v
for (ai, bi), v in a2.items():
k2 = (-bi, ai)
if k2 in a1: continue
z1 += v
ans *= pow(2, za, mod) + pow(2, zb, mod) - 1
ans %= mod
ans *= pow(2, z1, mod)
print((ans-1+z0) % mod)
if __name__ == "__main__":
resolve()
| 0 | null | 20,536,212,246,190 | 144 | 146 |
a=input()
print("a") if a.islower() else print("A")
|
alp=input()
if alp==alp.upper():
print("A")
elif alp==alp.lower():
print("a")
| 1 | 11,350,965,830,650 | null | 119 | 119 |
M=998244353
n,m,k=map(int,input().split())
a,c=0,1
for i in range(k+1):
a+=c*m*pow(m-1,n+~i,M)
c=c*(n+~i)*pow(i+1,-1,M)%M
print(a%M)
|
a, b = map(int, input().split())
if a == b:
print('a == b')
exit()
print('a < b' if a < b else 'a > b')
| 0 | null | 11,770,255,943,238 | 151 | 38 |
x = raw_input().split()
m = map(int,x)
a = m[0]
b = m[1]
if a > b:
print "a > b"
elif a < b:
print "a < b"
else:
print "a == b"
|
import sys
# A - Don't be late
D, T, S = map(int, input().split())
if S * T >= D:
print('Yes')
else:
print('No')
| 0 | null | 1,980,719,160,520 | 38 | 81 |
a,b = map(int,input().split())
if(a-(2*b)<0):
print(0)
else:
print(a-(2*b))
|
あ,い=map(int,input().split())
print(max(0,あ-い*2))
| 1 | 166,563,905,084,060 | null | 291 | 291 |
n,m = map(int,input().split())
mat = list()
vec = list()
ans = [0 for _ in range(n)]
for _ in range(n):
mat.append(list(map(int,input().split())))
for _ in range(m):
vec.append(int(input()))
for i in range(n):
for j in range(m):
ans[i] += mat[i][j]*vec[j]
for k in ans :
print(k)
|
N = int(input())
a = list(input())
count=0
for i in range(N):
if a[i] == 'A' and i<len(a)-2:
if a[i+1]=='B' :
if a[i+2]=='C':
count+=1
print(count)
| 0 | null | 50,485,550,581,554 | 56 | 245 |
def main():
import sys
asa = sys.stdin.readline
n = int(input())
s = list(map(int, asa().split()))
q = int(input())
t = list(map(int, asa().split()))
c = 0
s.append(0)
for i in t: # tの中のiを探索
j = 0
s[n] = i
while s[j] != i:
j += 1
if j < n:
c += 1
print(c)
if __name__ == '__main__':
main()
|
# -*- coding: utf-8 -*-
"""
Created on Sat Sep 19 22:03:19 2020
@author: liang
"""
N, X, M = map(int,input().split())
mod_set = {X}
mod_lis = [X]
A = [0]*(10**6+1)
A[0] = X
flag = False
#for i in range(1,N):
i = 1
for i in range(1,min(10**6,N)):
tmp = A[i-1]**2%M
if tmp in mod_set:
flag = True
break
A[i] = tmp
mod_set.add(tmp)
mod_lis.append(tmp)
if flag:
j = mod_lis.index(tmp)
else:
j = i
T = i - j
ans = 0
if T != 0:
#print("A")
ans += sum(mod_lis[:j])
T_sum = sum(mod_lis[j:])
"""
【切り捨て演算は必ず()をつけて先に計算】
"""
ans += T_sum * ((N-j)//T)
#print((N-j)//T, T_sum)
T_lis = mod_lis[j:i]
ans += sum(T_lis[:(N-j)%T])
else:
#print("B")
ans = sum(mod_lis)
# print(mod_lis)
#print(T_lis)
#print((N-j)%T)
#print(T_lis[:10])
print(ans)
#print(T_sum)
#print(sum(T_lis))
| 0 | null | 1,451,241,425,928 | 22 | 75 |
S = str(input())
if S[-1] == "s":
print(S+"es")
else:
print(S+"s")
|
import string
S = list(string.ascii_lowercase)
n = S.index(input())
print(S[n+1])
| 0 | null | 47,035,496,461,398 | 71 | 239 |
z=list(map(int,input().split()))
z.sort()
a=0
while True:
if z[1]==z[0]:
break
a=z[1]-z[0]
if z[0]%a==0:
z[1] = z[0]
z[0] = a
z.sort()
break
z[1]=z[0]
z[0]=a
z.sort()
print(z[0])
|
def Euclidean(input_list):
# print input_list
x = input_list[1]
y = input_list[0]
r = x % y
if r != 0:
list = [r, y]
list.sort()
return Euclidean(list)
else:
return y
list = map(int, raw_input().split(" "))
list.sort()
print Euclidean(list)
| 1 | 8,088,776,100 | null | 11 | 11 |
#!usr/bin/env pypy3
from collections import defaultdict, deque
from heapq import heappush, heappop
from itertools import permutations, accumulate
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
res = list(sys.stdin.readline())
if res[-1] == "\n":
return res[:-1]
return res
def IR(n):
return [I() for i in range(n)]
def LIR(n):
return [LI() for i in range(n)]
def SR(n):
return [S() for i in range(n)]
def LSR(n):
return [LS() for i in range(n)]
sys.setrecursionlimit(1000000)
def main():
N = I()
s = S()
R = s.count("R")
G = s.count("G")
B = s.count("B")
dup = 0
for i in range(N):
for k in range(i+1, N):
if (i + k) % 2 == 0:
j = (i + k) // 2
if s[i] != s[j] and s[j] != s[k] and s[k] != s[i]:
dup += 1
print(R * G * B - dup)
main()
|
from collections import defaultdict
N,K = map(int,input().split())
A = list(map(int,input().split()))
S = [0]
for i in range(N):
S.append((S[-1]+A[i]-1)%K)
D = defaultdict(int)
count = 0
for i in range(N+1):
count += D[S[i]]
D[S[i]] += 1
if i-K+1 >= 0:
D[S[i-K+1]] -= 1
print(count)
| 0 | null | 87,176,934,471,562 | 175 | 273 |
S=raw_input()
T=raw_input()
ans=0
for s,t in zip(S,T):
if s!=t:
ans+=1
print ans
|
i = str(input())
w =''
for let in i:
if(let == let.upper()):
w = w + let.lower()
elif(let == let.lower()):
w = w + let.upper()
else:
w = w + let
print(w)
| 0 | null | 5,944,333,160,992 | 116 | 61 |
n = int(input())
L = []
for _ in range(n):
x, l = map(int, input().split())
left = x - l
right = x + l
L.append((left, right))
L = sorted(L, key=lambda x: x[1])
ans = 0
prev = -float('inf')
for r in L:
if r[0] >= prev:
ans += 1
prev = r[1]
print(ans)
|
N = int(input())
X = [list(map(int, input().split())) for i in range(N)]
LR = [[x[0]-x[1], x[0] + x[1]] for x in X]
LR.sort(key=lambda x:x[1])
A = 1
right = LR[0][1]
for i in range(1, N):
if right <= LR[i][0]:
A += 1
right = LR[i][1]
print(A)
| 1 | 90,004,937,737,638 | null | 237 | 237 |
N, X, M = map(int, input().split())
ans = 0
C = [0]
Xd = [-1] * (M+1)
for i in range(N):
x = X if i==0 else x**2 % M
if Xd[x] > -1:
break
Xd[x] = i
ans += x
C.append(ans)
loop_len = i - Xd[x]
if loop_len > 0:
S = C[i] - C[Xd[x]]
loop_num = (N - i) // loop_len
ans += loop_num * S
m = N - loop_num * loop_len - i
ans += C[Xd[x]+m] - C[Xd[x]]
print(ans)
|
import sys
input = sys.stdin.readline
#n = int(input())
#l = list(map(int, input().split()))
'''
a=[]
b=[]
for i in range():
A, B = map(int, input().split())
a.append(A)
b.append(B)'''
n=int(input())
a=list(map(int,input().split()))
a.sort()
#print(a)
ans=0
from math import floor
for i in range(1,n):
ans+=a[n-1-floor(i/2)]
#print(ans)
print(ans)
| 0 | null | 6,066,019,660,558 | 75 | 111 |
import sys
counts = [0] * 26
s = sys.stdin.read()
for c in s:
o = ord(c)
if o >= 65 and o <= 90:
counts[o - 65] += 1
elif o >= 97 and o <= 122:
counts[o - 97] += 1
for i in range(len(counts)):
print(chr(i + 97) + ' : ' + str(counts[i]))
|
#!/usr/bin/env python
#coding: UTF-8
import sys
a = sys.stdin.readlines()
b = []
for i in a:
for j in i:
b.append(j.lower())
for i in range(97, 97+26):
print chr(i)+" : "+str(b.count(chr(i)))
| 1 | 1,664,784,080,202 | null | 63 | 63 |
num = list(map(int,input().split()))
if(num[0] < num[1] and num[1] < num[2] and num[0] < num[2]): print("Yes")
else: print("No")
|
#k = int(input())
#s = input()
#a, b = map(int, input().split())
#s, t = map(str, input().split())
#l = list(map(int, input().split()))
#l = [list(map(int,input().split())) for i in range(n)]
#a = [input() for _ in range(n)]
import itertools
n = int(input())
p = list(map(int, input().split()))
q = list(map(int, input().split()))
if (p == q):
print(0)
exit()
seq = []
for i in range(1,n+1):
seq.append(i)
t = list(itertools.permutations(seq))
ans = []
for i in range(len(t)):
if list(t[i]) == p or list(t[i]) == q:
ans.append(i)
print(ans[1]-ans[0])
| 0 | null | 50,702,124,525,638 | 39 | 246 |
N = int(input())
A = list(map(int,input().split()))
for i in range(N):
if A[i] % 2 ==0:
if A[i] % 3 ==0 or A[i] % 5 ==0:
pass
if i == N-1:
print('APPROVED')
else:
pass
else:
print('DENIED')
break
else:
if i == N-1:
print('APPROVED')
else:
pass
|
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from collections import defaultdict
def main():
n, x, y = map(int, input().split())
x -= 1
y -= 1
dis = defaultdict(int)
for i1 in range(n):
for i2 in range(i1+1, n):
d = min(abs(i2-i1), abs(x-i1)+abs(y-i2)+1, abs(x-i2)+abs(y-i1)+1)
dis[d] += 1
for k1 in range(1, n):
print(dis[k1])
if __name__ == '__main__':
main()
| 0 | null | 56,868,832,112,850 | 217 | 187 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007
from fractions import *
def inverse(f):
# return Fraction(f.denominator,f.numerator)
return 1 / f
def combmod(n, k, mod=MOD):
ret = 1
for i in range(n - k + 1, n + 1):
ret *= i
ret %= mod
for i in range(1, k + 1):
ret *= pow(i, mod - 2, mod)
ret %= mod
return ret
def bunsu(n):
ret = []
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
tmp = 0
while (True):
if n % i == 0:
tmp += 1
n //= i
else:
break
ret.append((i, tmp))
ret.append((n, 1))
return ret
MOD = 998244353
def solve():
n, k = getList()
nums = getList()
dp = [0 for i in range(k+1)]
dp[0] = 1
for i, num in enumerate(nums):
new = [0 for i in range(k+1)]
for j, d in enumerate(dp):
new[j] += d * 2
if (j + num) <= k:
new[j+num] += d
dp = [ne%MOD for ne in new]
print(dp[-1])
def main():
# n = getN()
# for _ in range(n):
solve()
if __name__ == "__main__":
solve()
|
def main():
n = int(input())
inlis = list(map(int, input().split()))
anslis = [0] * n
for i in range(n):
num = inlis[i]
anslis[num-1] = i+1
print(*anslis)
if __name__ == "__main__":
main()
| 0 | null | 99,549,348,163,802 | 138 | 299 |
import math
a, b, c = map(int, input().split())
c = math.radians(c)
s = a * b * math.sin(c) / 2
d = math.sqrt(a**2 + b**2 - 2*(a * b * math.cos(c)))
h = b * math.sin(c)
for i in (s, a+b+d, h):
print(i)
|
import math
a, b, c = map(float, input().split())
c = math.radians(c)
S = 0.5 * a * b * math.sin(c)
L = (a ** 2 + b ** 2 - 2 * a * b * math.cos(c)) ** 0.5 + a + b
h = S / a * 2
print(S)
print(L)
print(h)
| 1 | 171,420,773,660 | null | 30 | 30 |
rad = int(input())
print (2*3.1415926*rad)
|
a = int(input())
print(2*a*3.14)
| 1 | 31,370,608,046,400 | null | 167 | 167 |
import math
N, D = map(int, input().split())
XY = []
for _ in range(N):
x, y = map(int, input().split())
XY.append([x,y])
cnt = 0
for xy in XY:
if math.sqrt(pow(xy[0], 2) + pow(xy[1], 2)) <= D:
cnt += 1
print(cnt)
|
n, k, s = map(int,input().split())
x = s + 1 if s < 10 ** 9 else 1
a = [x] * n
for i in range(k):
a[i] = s
print(*a, sep=' ')
| 0 | null | 48,283,766,405,472 | 96 | 238 |
a,b=map(int,input().split())
print('%d %d %.10f' % (a//b,a%b,a/b))
|
# https://atcoder.jp/contests/nikkei2019-2-qual/tasks/nikkei2019_2_qual_b
# まず、本当に木を構築するモノではないだろう
from collections import Counter
n = int(input())
nums = [int(i) for i in input().split()]
mod = 998244353
MAX = max(nums)
c = Counter(nums)
if nums[0] != 0 or nums.count(0) != 1:
ans = 0
else:
ans = 1
for i in range(1, MAX + 1):
ans = ans * pow(c.get(i - 1, 0), c.get(i, 0), mod) % mod
ans %= mod
print(ans)
| 0 | null | 77,744,626,052,104 | 45 | 284 |
def solve(a,b,k):
if k <= a: return a - k, b
elif k <= a + b: return 0, b - (k - a)
else: return 0, 0
a,b,k = map(int,input().split())
ans_1, ans_2 = solve(a,b,k)
print(f"{ans_1} {ans_2}")
|
def resolve():
import math
print(2*math.pi*int(input()))
if '__main__' == __name__:
resolve()
| 0 | null | 68,029,839,933,790 | 249 | 167 |
ele_and_tar = []
rs = []
flag1 = 1
flag2 = 0
while flag1:
data = [int(x) for x in input().split()]
if data == [0,0]:
flag1 = 0
else:
ele_and_tar.append(data)
for i in range(len(ele_and_tar)):
rs.append(0)
for math in ele_and_tar:
for i in range(1,math[0]+1):
for j in range(i+1,math[0]+1):
for k in range(j+1,math[0]+1):
if (i + j + k) == math[1]:
rs[flag2] = rs[flag2] + 1
flag2 = flag2 + 1
for out in rs:
print(out)
|
while 1:
ans=0
n,x=map(int,raw_input().split())
if n:
for i in range(1,n-1):
for j in range(i+1,n):
for k in range(j+1,n+1):
if i+j+k==x:ans+=1
else:break
print ans
| 1 | 1,289,540,851,910 | null | 58 | 58 |
print(' ' + ' '.join(str(i) for i in range(1, int(input()) + 1) if i % 3 == 0 or '3' in str(i)))
|
n = int(input())
A = list(map(int,input().split()))
ans = 0
for i in range(n-1):
if A[i] >= A[i+1]:
ans += A[i]-A[i+1]
A[i+1] = A[i]
print(ans)
| 0 | null | 2,725,825,926,140 | 52 | 88 |
N = int(input())
S, T = input().split()
ans = ''
for s, t in zip(S, T):
ans += s
ans += t
print(ans)
|
n = int(input())
s = input()
if n % 2 == 1:
print('No')
exit()
mid= int(len(s)/2)
if s[:mid] == s[mid:]:
print('Yes')
else:
print('No')
| 0 | null | 129,368,882,800,608 | 255 | 279 |
import math
a,b,c = [float(s) for s in input().split()]
r = c * math.pi / 180
h = math.sin(r) * b
s = a * h / 2
x1 = a
y1 = 0
if c == 90:
x2 = 0
else:
x2 = math.cos(r) * b
y2 = h
d = math.sqrt((math.fabs(x1 - x2) ** 2) + (math.fabs(y1 - y2) ** 2))
l = a + b + d
print(s)
print(l)
print(h)
|
import sys
a, b = sys.stdin.readline().split()
print(b+a)
| 0 | null | 51,791,239,413,300 | 30 | 248 |
a = raw_input().split()
W = int(a[0])
H = int(a[1])
x = int(a[2])
y = int(a[3])
r = int(a[4])
if x - r >= 0 and x + r <= W and y - r >= 0 and y + r <= H :
print "Yes"
else :
print "No"
|
import sys
x, k, d = map(int,input().split())
x = abs(x)
ans = 0
if k <= x // d:
ans = x - k*d
print(ans)
sys.exit()
if (k - (x // d)) % 2 == 0:
print(x % d)
else:
print(abs(x % d - d))
| 0 | null | 2,828,737,973,230 | 41 | 92 |
while True:
try:
r,c = map(int,raw_input().split())
if r == c == 0:
break
except EOFError:
break
array = []
for i in range(r):
array.append(map(int,raw_input().split()))
# column sum
# add a new sum-row
c_sum_row = [0 for ii in range(c)]
for k in range(c):
for j in range(r):
c_sum_row[k] += array[j][k]
array.append(c_sum_row)
# row sum
# append sum item to end of each row
for k in range(r+1):
array[k].append(sum(array[k]))
for k in range(r+1):
print ' '.join(map(str,array[k]))
|
import sys
import math
from collections import deque
sys.setrecursionlimit(1000000)
MOD = 10 ** 9 + 7
input = lambda: sys.stdin.readline().strip()
NI = lambda: int(input())
NMI = lambda: map(int, input().split())
NLI = lambda: list(NMI())
SI = lambda: input()
def make_grid(h, w, num): return [[int(num)] * w for _ in range(h)]
def main():
N, K = NMI()
A = NLI()
F = NLI()
A.sort()
F.sort(reverse=True)
ok = 10**13
ng = 0
for i in range(100):
mid = (ok+ng) // 2
limits = [mid//f for f in F]
ks = [max(a-l, 0) for a, l in zip(A, limits)]
if sum(ks) <= K:
ok = mid
else:
ng = mid
print(ok)
if __name__ == "__main__":
main()
| 0 | null | 82,905,536,027,300 | 59 | 290 |
from math import factorial
n, m = map(int, input().split())
ans = n*(n-1)//2 + m*(m-1)//2
print(ans)
|
from collections import deque
s=deque(input())
q=int(input())
flag=0
for i in range(q):
query=input()
if len(query)==1:
flag+=1
else:
if query[2]=="1" and flag%2==0 or query[2]=="2" and flag%2==1:
s.appendleft(query[4])
else:
s.append(query[4])
if flag%2==1:
s.reverse()
print("".join(s))
| 0 | null | 51,557,917,650,864 | 189 | 204 |
s=input()
for i in range(int(input())):
sou_com=input().split()
if sou_com[0]=='print':
print(s[int(sou_com[1]):int(sou_com[2])+1])
elif sou_com[0]=='reverse':
s=s[:int(sou_com[1])]\
+s[int(sou_com[1]):int(sou_com[2])+1][::-1]\
+s[int(sou_com[2])+1:]
elif sou_com[0]=='replace':
s=s[:int(sou_com[1])]\
+sou_com[3]\
+s[int(sou_com[2])+1:]
|
import math, itertools
n = int(input())
X = list(list(map(int,input().split())) for _ in range(n))
L = list(itertools.permutations(range(n),n))
ans = 0
for l in L:
dist = 0
for i in range(n-1):
s,t = l[i],l[i+1]
vx = X[s][0] - X[t][0]
vy = X[s][1] - X[t][1]
dist += math.sqrt(vx**2 + vy**2)
ans += dist
print(ans/len(L))
| 0 | null | 75,179,716,597,954 | 68 | 280 |
s = raw_input()
p = raw_input()
slen = len(s)
plen = len(p)
flag = False
for i in xrange(len(s)):
j = 0
while(j < plen and s[(i+j)%slen] == p[j]):
j += 1
if (j == plen):
flag = True
if(flag):
print "Yes"
else:
print "No"
|
def main():
x = int(input())
for a in range(-120, 121):
for b in range(-120, 121):
if a**5 - b**5 == x:
print(a, b)
return
if __name__ == "__main__":
main()
| 0 | null | 13,612,831,072,830 | 64 | 156 |
from collections import deque
n,p=map(int ,input().split())
que=deque([])
for i in range(n):
name,time=input().split()
time=int(time)
que.append([name,time])
t=0
while len(que)>0:
atop=que.popleft()
spend=min(atop[1],p)
atop[1]-=spend
t+=spend
if(atop[1]==0):
print(atop[0],t)
else:
que.append(atop)
|
a, b, c, k = map(int,input().split())
if k <= a:
print(k)
elif a < k <= a + b:
print(a)
elif a + b <= k:
print(a*2 - k + b)
| 0 | null | 10,847,962,794,640 | 19 | 148 |
N,K=map(int, input().split())
d=list(map(int,input().split()))
ans=0
for i in range(N):
if d[i]>=K:
ans=ans+1
print(ans)
|
import sys
sys.setrecursionlimit(10**7)
input = sys.stdin.readline
n,k = map(int, input().split())
m = n % k
m = 0 if m == 0 else abs(m - k)
print(min(n, m))
| 0 | null | 109,347,400,079,582 | 298 | 180 |
import numpy as np
from collections import deque
h, w = map(int, input().split())
s = [list(input()) for _ in range(h)]
ans = 0
for i in range(len(s)):
for j in range(len(s[0])):
if s[i][j] == '#':
continue
pre = 0
p = np.full((h, w), -1)
p[i][j] = 0
check = deque([((i, j), 0)])#(from,now, dist)
while check:
now, d = check.popleft()
pre = max(pre, d)
for k, l in [(1,0), (-1,0),(0,1), (0,-1)]:
b = now[0] + k
c = now[1] + l
if b < 0 or c < 0 or b >= h or c >= w:
continue
elif p[b][c] == -1 and s[b][c] != '#':
check.append(((b, c), d + 1))
p[b][c] = d + 1
ans = max(ans, pre)
print(ans)
|
h,w=map(int,input().split())
g=[[*input()] for _ in range(h)]
from collections import *
a=0
for sx in range(h):
for sy in range(w):
if g[sx][sy]=='#': continue
d=[[-1]*w for _ in range(h)]
d[sx][sy]=0
q=deque([(sx,sy)])
while q:
x,y=q.popleft()
t=d[x][y]+1
for dx,dy in [(1,0),(0,1),(-1,0),(0,-1)]:
nx,ny=x+dx,y+dy
if 0<=nx<h and 0<=ny<w and g[nx][ny]=='.' and d[nx][ny]<0:
d[nx][ny]=t
q.append((nx,ny))
a=max(a,t)
print(a)
| 1 | 94,483,686,740,700 | null | 241 | 241 |
def solve(n, k, s):
a = [1 if s == 10**9 else s+1] * n
for i in range(k):
a[i] = s
return " ".join(map(str, a))
n, k, s = map(int, input().split())
print(solve(n, k, s))
|
S = str(input())
T = str(input())
if S == T[:-1]:
print("Yes")
else:
print("No")
| 0 | null | 56,541,377,198,710 | 238 | 147 |
while True:
a,op,b = input().split()
a = int(a)
b = int(b)
if op == "?":
break
else:
if op == "+":
ans = a + b
elif op == "-":
ans = a-b
elif op == "*":
ans = a * b
elif op == "/":
rem = a%b
if rem == 0:
ans = int(a/b)
else:
ans = int(a/b)
print(ans)
|
import sys
for line in sys.stdin:
if line.find("?") != -1:
break
print(int(eval(line)))
| 1 | 676,491,074,040 | null | 47 | 47 |
r,c,k = list(map(int, input().split()))
import copy
dp=[[[0]*4 for _ in range(c)] for _ in range(2)]
F = [[0]*c for _ in range(r)]
for _ in range(k):
x,y,v = list(map(int, input().split()))
x-=1
y-=1
F[x][y] = v
for nn in range(r):
for j in range(c):
i = 1
val = F[nn][j]
mxv = max(dp[i-1][j][0], dp[i-1][j][1], dp[i-1][j][2], dp[i-1][j][3])
dp[i][j][3] = max(dp[i][j-1][3], dp[i][j-1][2] + val)
dp[i][j][2] = max(dp[i][j-1][2], dp[i][j-1][1] + val)
dp[i][j][1] = max(dp[i][j-1][1], dp[i][j-1][0] + val, mxv + val)
dp[i][j][0] = mxv
dp[0] = dp[1]
dp[1] = [[0]*4 for _ in range(c)]
best = 0
for k in range(4):
best = max(best, dp[0][c-1][k])
print(best)
|
K, N = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
ans = 0
del_A = []
for i in range(N):
if(i==(N-1)):
del_A.append(A[0]+K-A[i])
else:
del_A.append(A[i+1]-A[i])
print(sum(del_A)-max(del_A))
| 0 | null | 24,688,539,691,592 | 94 | 186 |
A,B,C = input().split()
A = int(A)
B = int(B)
C = int(C)
if A == B == C :
print('No')
elif A == B :
print('Yes')
elif B == C :
print('Yes')
elif C == A :
print('Yes')
elif A == B == C :
print('No')
else :
print('No')
|
S = list(map(int, list(input())))[::-1]
N = len(S)
CNT = [0]*2019
CNT[0] = 1
num = 0
d = 0
for i in range(N):
num += S[i]*pow(10, d, 2019)
num %= 2019
CNT[num] += 1
d += 1
ans = 0
for cnt in CNT:
ans += (cnt*(cnt - 1)) // 2
print(ans)
| 0 | null | 49,489,987,320,660 | 216 | 166 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
def getArray(intn):
return [int(input()) for i in range(intn)]
def input():
return sys.stdin.readline().rstrip()
def rand_N(ran1, ran2):
return random.randint(ran1, ran2)
def rand_List(ran1, ran2, rantime):
return [random.randint(ran1, ran2) for i in range(rantime)]
def rand_ints_nodup(ran1, ran2, rantime):
ns = []
while len(ns) < rantime:
n = random.randint(ran1, ran2)
if not n in ns:
ns.append(n)
return sorted(ns)
def rand_query(ran1, ran2, rantime):
r_query = []
while len(r_query) < rantime:
n_q = rand_ints_nodup(ran1, ran2, 2)
if not n_q in r_query:
r_query.append(n_q)
return sorted(r_query)
from collections import defaultdict, deque, Counter
from sys import exit
from decimal import *
import heapq
import math
from fractions import gcd
import random
import string
import copy
from itertools import combinations, permutations, product
from operator import mul
from functools import reduce
from bisect import bisect_left, bisect_right
import sys
sys.setrecursionlimit(1000000000)
mod = 10 ** 9 + 7
#############
# Main Code #
#############
X, Y, A, B, C = getNM()
P = getList()
Q = getList()
R = getList()
P.sort()
Q.sort()
lista = P[-X:] + Q[-Y:] + R
lista.sort()
print(sum(lista[-(X + Y):]))
|
''' 1.降序排列，选出x个红苹果，y个绿苹果
2.使用c个无色苹果去更新这x+y个苹果中的小值，直到最小也比无色苹果的大为止'''
nums = [int(i) for i in input().split()]
x = nums[0]
y = nums[1]
a = nums[2]
b = nums[3]
c = nums[4]
redApples = [int(i) for i in input().split()]
greenApples = [int(i) for i in input().split()]
colorless = [int(i) for i in input().split()]
redApples.sort(reverse=True)
greenApples.sort(reverse=True)
colorless.sort(reverse=True)
redApples = redApples[:x]
greenApples = greenApples[:y]
res = redApples+greenApples
res.sort(reverse=True)
currIndex = len(res)-1
for i in range(len(colorless)):
if colorless[i] <= res[currIndex]:
break
res[currIndex] = colorless[i]
currIndex -= 1
if currIndex < 0:
break
print(sum(res))
| 1 | 44,720,464,627,660 | null | 188 | 188 |
n = int(input());print(n//2 if n%2==1 else n//2 -1)
|
while 1:
a,b = sorted(map(int,raw_input().split()))
if a==b==0:
break
print ('{} {}'.format(a,b))
| 0 | null | 76,987,758,984,890 | 283 | 43 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
# import decimal
# from decimal import Decimal
# decimal.getcontext().prec = 10
# from heapq import heappush, heappop, heapify
# import math
# from math import gcd
# import itertools as it
# import collections
# from collections import deque
def inp():
return int(input())
def inps():
return input().rstrip()
def inpl():
return list(map(int, input().split()))
def _debug(obj):
print(obj, file=sys.stderr)
# ---------------------------------------
X = inp()
for i in range(-120, 120):
for j in range(-120, 120):
if i**5 - j**5 == X:
print(i, j)
sys.exit()
|
from collections import defaultdict
import math
import sys
input = sys.stdin.readline
def select_num(a, b, mod=1000000007):
sum = pow(2, a, mod) + pow(2, b, mod) - 1
return sum % mod
def dict_count(d, a, b):
this = a / b
pair = b / a
if not d.get(this, False):
d[this] = {"num": 0, "pair": pair}
d[this]["num"] += 1
def main():
MOD = 1000000007
n = int(input())
d = defaultdict(lambda: [0] * 2)
zero = 0
for i in range(n):
a, b = map(int, input().split())
if a == 0 or b == 0:
if a == b == 0:
n -= 1
zero += 1
elif a == 0:
d[0][True] += 1
elif b == 0:
d[0][False] += 1
else:
gcd = math.gcd(a, b)
a //= gcd
b //= gcd
if b < 0:
a, b = -a, -b
rot = False
if a < 0:
b, a = -a, b
rot = True
d[(a, b)][rot] += 1
ans = 1
for k, v in d.items():
ans *= select_num(v[0], v[1], MOD)
ans %= MOD
ans += zero - 1
ans %= MOD
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 23,194,582,369,690 | 156 | 146 |
from collections import deque
H, W = map(int, input().split())
S=[]
for _ in range(H):
S.append(input())
vx = [1, 0, -1, 0]
vy = [0, 1, 0, -1]
ans = 0
def func(si, sj):
queue = deque([si, sj])
seen = [[-1]*W for _ in range(H)]
seen[si][sj] = 0
while queue:
x = queue.popleft()
y = queue.popleft()
for i in range(4):
nx = x + vx[i]
ny = y + vy[i]
if nx<0 or nx>=H or ny<0 or ny>=W:
continue
if S[nx][ny]=="#" or seen[nx][ny]>=0:
continue
seen[nx][ny]=seen[x][y]+1
queue.append(nx)
queue.append(ny)
return seen[x][y]
ans = 0
for i in range(H):
for j in range(W):
if S[i][j]==".":
ans = max(ans, func(i, j))
print(ans)
|
import sys
import itertools
sys.setrecursionlimit(1000000000)
from heapq import heapify,heappop,heappush,heappushpop
import math
import collections
import copy
INF = 10**9
def ok(l):
cnt = 0
for L in a:
cnt += L//l
if L%l != 0:
cnt+=1
cnt-=1
return cnt <= k
if __name__ == "__main__":
n,k = map(int,input().split())
a = list(map(int,input().split()))
left = 0
right = max(a)
#最大値の最小値は二分探索
while right - left > 1:
mid = (right+left)//2
if ok(mid):
right = mid
else:
left = mid
print(right)
| 0 | null | 50,423,354,895,506 | 241 | 99 |
M1, D1 = [int(_) for _ in input().split(" ")]
M2, D2 = [int(_) for _ in input().split(" ")]
if M1 == M2:
print (0)
else:
print (1)
|
n, k = map(int, input().split())
if n == k:
print(0)
elif n < k:
print(min(n, k - n))
else:
n = n % k
print(min(n, k - n))
| 0 | null | 81,818,259,772,480 | 264 | 180 |
N,A,B=map(int,input().split())
if (A+B)%2==0:
P=(B-A)//2
else:
P=float("inf")
if (A+B)%2==1:
Q=A
Q+=(B-Q-(B-Q+1)//2)
else:
Q=float("inf")
if (A+B)%2==1:
R=N-B+1
B=N
A+=R
R+=B-(A+B)//2
else:
R=float("inf")
print(min(P,Q,R))
|
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
from collections import deque
import copy
import heapq
from bisect import bisect, bisect_left, bisect_right
MOD = 10 ** 9 + 7
INF = float('inf')
input = lambda: sys.stdin.readline().strip()
sys.setrecursionlimit(10 ** 8)
N, A, B = map(int, input().split())
dis = B - A - 1
if dis % 2 == 0:
print(min((N - max(A, B) + 1) + (N - min(A, B) - (N - max(A, B) + 1)) // 2,
min(A, B) + ((max(A, B) - min(A, B) - 1) // 2)))
else:
print((dis + 1) // 2)
| 1 | 109,878,347,373,688 | null | 253 | 253 |
a,b,m=map(int,input().split())
a=list(map(int,input().split()))
b=list(map(int,input().split()))
l=[list(map(int,input().split())) for _ in range(m)]
ans=min(a)+min(b)
for x,y,c in l:
ans=min(ans,a[x-1]+b[y-1]-c)
print(ans)
|
a,b,m = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
xyc = [list(map(int,input().split())) for nesya in range(m)]
cheap = min(a)+min(b)
for hoge in xyc:
ch = a[hoge[0]-1]+b[hoge[1]-1]-hoge[2]
cheap = min(ch,cheap)
print(cheap)
| 1 | 53,749,337,992,860 | null | 200 | 200 |
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)
|
import numpy as np
import sys
input = sys.stdin.readline
A,B,M = map(int,input().split())
a = list(map(int,input().split()))
b = list(map(int,input().split()))
res = np.min(a) + np.min(b)
for i in range(M):
x,y,c = map(int,input().split())
x-=1
y-=1
res = min(res,(a[x]+b[y]-c))
print(res)
| 1 | 53,875,941,300,292 | null | 200 | 200 |
import sys
import numpy as np
import numba
from numba import njit, b1, i4, i8, f8
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
uf_t = numba.types.UniTuple(i8[:], 2)
@njit((uf_t, i8), cache=True)
def find_root(uf, x):
root = uf[0]
while root[x] != x:
root[x] = root[root[x]]
x = root[x]
return x
@njit((uf_t, i8, i8), cache=True)
def merge(uf, x, y):
root, size = uf
x, y = find_root(uf, x), find_root(uf, y)
if x == y:
return False
if size[x] < size[y]:
x, y = y, x
size[x] += size[y]
root[y] = root[x]
return True
@njit((i8, i8, i8[:]), cache=True)
def main(N, M, AB):
ans = N - 1
root = np.arange(N + 1, dtype=np.int64)
size = np.ones_like(root)
uf = (root, size)
for i in range(0, len(AB), 2):
a, b = AB[i:i + 2]
if merge(uf, a, b):
ans -= 1
return ans
N, M = map(int, readline().split())
AB = np.array(read().split(), np.int64)
print(main(N, M, AB))
|
#abc167_e
n = int(input())
pos = []
neg = []
for _ in range(n):
s = input()
low_pos = 0
increase= 0
for v in s:
if v=="(":
increase += 1
else:
increase -= 1
low_pos = min(low_pos, increase)
if increase >= 0:
pos.append((low_pos, increase))
else:
#reverse left from right
low_pos, increase = low_pos - increase, -increase
neg.append((low_pos, increase))
pos.sort()
pos.reverse() #lowが高い順にする.
neg.sort()
neg.reverse() #lowが高い順にする.
now_pos = 0
for low_pos, increase in pos:
if now_pos + low_pos < 0:
print("No") #impossible
exit()
else:
now_pos += increase
right_pos = 0
for low_pos, increase in neg:
if right_pos + low_pos < 0:
print("No") #impossible
exit()
else:
right_pos += increase
if right_pos != now_pos:
print("No")
exit()
else:
print("Yes")
| 0 | null | 12,900,182,288,640 | 70 | 152 |
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) #二個目の要素で降順並び替え
K = 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)) #改行行列
s=input()
ls=len(s)
tot=pow(26,ls+K,mod)
def extgcd1(a0,b0):#計算量log(b0),フェルマーの小定理より早い
u,v,a,b=1,0,a0,b0
while b:
t=a//b; a-=t*b; a,b=b,a; u,v=v,u-t*v
if a!=1: return -1#互いに素じゃない
return u%b0
N=ls+K
fact=[0]*(N+1)#NはnCrの最大のn
ifact=[0]*(N+1)
fact[0],fact[1],ifact[0],ifact[1]=1,1,1,1
for i in range(2,N+1):
x=(fact[i-1]*i)%mod
fact[i]=x
ifact[i]=extgcd1(x,mod)
pows=[1]*(N+1)
for i in range(1,N+1):
pows[i]=pows[i-1]*25%mod
def comb(n,r): return (fact[n]*ifact[r]%mod)*ifact[n-r]%mod
for i in range(0,ls):
tot-=comb(ls+K,i)*pows[ls+K-i]
tot%=mod
print(tot)
if __name__ == "__main__":
main()
|
n = int(input())
dic = {}
time = []
for i in range(n):
s, t = map(str, input().split())
dic[s] = i + 1
time.append(int(t))
ans = 0
song = input()
ans = sum(time[dic[song]:])
print(ans)
| 0 | null | 55,148,059,546,920 | 124 | 243 |
import sys
n = int(input())
minv = int(input())
v = int(input())
maxv = v-minv
if v < minv: minv = v
for r in map(int,sys.stdin.readlines()):
m = r-minv
if maxv < m < 0:
maxv = m
minv = r
elif maxv < m:
maxv = m
elif m < 0:
minv = r
print(maxv)
|
N = int(input())
R = [int(input()) for _ in range(N)]
maxv = -2000000000
minv = R[0]
for i in range(1,N):
maxv = max([maxv, R[i] - minv ])
minv = min([minv, R[i]])
print(maxv)
| 1 | 13,806,471,392 | null | 13 | 13 |
L = int(input())
A = L/3
B = (L-A)/2
C = L - A - B
print(A * B * C)
|
import itertools,sys
def S(): return sys.stdin.readline().rstrip()
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
H,W = LI()
S = [S() for _ in range(H)]
dp = [[float('INF')]*W for _ in range(H)]
for i,j in itertools.product(range(H),range(W)):
if i==0:
if j==0:
dp[i][j] = 1 if S[i][j]=='#' else 0
else:
dp[i][j] = dp[i][j-1]+(1 if S[i][j]=='#' and S[i][j-1]=='.' else 0)
else:
if i==0:
dp[i][j] = dp[i-1][j]+(1 if S[i][j]=='#' and S[i-1][j]=='.' else 0)
else:
dp[i][j] = min(dp[i][j],dp[i][j-1]+(1 if S[i][j]=='#' and S[i][j-1]=='.' else 0))
dp[i][j] = min(dp[i][j],dp[i-1][j]+(1 if S[i][j]=='#' and S[i-1][j]=='.' else 0))
print(dp[-1][-1])
| 0 | null | 48,201,002,003,920 | 191 | 194 |
n = int(input())
person = [[0 for _ in range(10)] for _ in range(12)]
for _ in range(n):
b, f, r, v = [int(m) for m in input().split()]
person[3*(b-1)+f-1][r-1] += v
for index, p in enumerate(person):
print(" "+" ".join([str(m) for m in p]))
if (index+1)%3 == 0 and index < len(person)-1:
print("####################")
|
#ITP1_6_C
A=[[[0 for k in range(10)]for j in range(3)]for i in range(4)]
format(A)
n=int(input())
for m in range(n):
b,f,r,v=map(int,input().split())
S=A[b-1][f-1][r-1]+v
A[b-1][f-1][r-1]=S
for i in range(4):
for j in range(3):
for k in range(10):
print ("",A[i][j][k],end='')
print("")
if i<3:
print("####################")
| 1 | 1,114,886,710,780 | null | 55 | 55 |
n = int(input())
total = 0
for i in range(n):
a,b = map(int, input().split())
if a == b:
total += 1
if total == 3:
break
else:
total = 0
if total == 3:
print('Yes')
else:
print('No')
|
N = int(input())
check = [0, 0, 0]
for i in range(N):
str = input().split()
check[i%3] = 1 if str[0] == str[1] else 0
if sum(check) == 3:
break
print('Yes') if sum(check) == 3 else print('No')
| 1 | 2,460,441,604,220 | null | 72 | 72 |
str = input() # sを取得し、strに値を入れる
if str[len(str)-1] == 's':
#str = str[:len(str)-1]
print(str + 'es')
else:
print(str + 's')
|
def aizu003():
xs = map(int,raw_input().split())
xs.sort()
for i in range(0,3):
print xs[i],
aizu003()
| 0 | null | 1,411,477,812,260 | 71 | 40 |
import sys
def lcm(a,b):
return a*b//gcd(a,b)
def gcd(a,b):
while True:
a,b = b,a%b
if b==0:
return a
for line in sys.stdin:
a,b = map(int, line.split())
print("{} {}".format(gcd(a,b),lcm(a,b)))
|
import sys
#from collections import deque
#from functools import *
#from fractions import Fraction as f
from copy import *
from bisect import *
#from heapq import *
from math import gcd,ceil,sqrt
from itertools import permutations as prm,product
def eprint(*args):
print(*args, file=sys.stderr)
zz=1
#sys.setrecursionlimit(10**6)
if zz:
input=sys.stdin.readline
else:
sys.stdin=open('input.txt', 'r')
sys.stdout=open('all.txt','w')
di=[[-1,0],[1,0],[0,1],[0,-1]]
def inc(d,c,x=1):
d[c]=d[c]+x if c in d else x
def bo(i):
return ord(i)-ord('A')
def li():
return [int(xx) for xx in input().split()]
def fli():
return [float(x) for x in input().split()]
def comp(a,b):
if(a>b):
return 2
return 2 if a==b else 0
def gi():
return [xx for xx in input().split()]
def fi():
return int(input())
def pro(a):
return reduce(lambda a,b:a*b,a)
def swap(a,i,j):
a[i],a[j]=a[j],a[i]
def si():
return list(input().rstrip())
def mi():
return map(int,input().split())
def gh():
sys.stdout.flush()
def isvalid(i,j):
return 0<=i<n and 0<=j<m and a[i][j]!="."
def bo(i):
return ord(i)-ord('a')
def graph(n,m):
for i in range(m):
x,y=mi()
a[x].append(y)
a[y].append(x)
t=1
mod=998244353
while t>0:
t-=1
n,k,m=mi()
vis={}
cycle=[]
i=ans=0
while k not in vis:
cycle.append(k)
vis[k]=i
i+=1
ans+=k
if i==n:
print(ans)
exit(0)
k=(k**2)%m
if k in vis:
cycle=cycle[vis[k]:]
n-=i
s=sum(cycle)
p=n%len(cycle)
z=len(cycle)
print(ans+(n//z)*s+sum(cycle[:p]))
| 0 | null | 1,408,660,614,238 | 5 | 75 |
import sys
input = sys.stdin.buffer.readline
import numpy as np
D = int(input())
c = np.array(input().split(), dtype=np.int32)
s = np.array([input().split() for _ in range(D)], dtype=np.int32)
last = np.zeros(26, dtype=np.int32)
ans = []
point = 0
for i in range(D):
down = (i+1-last)*c
loss = down * 3 + s[i,:]
idx = np.argmax(loss)
ans.append(idx+1)
point += s[i, idx] - down.sum()
last[idx] = i+1
for i in range(D):
print(ans[i])
|
sample_string = input()
test_string = input()
if test_string in sample_string * 2:
print("Yes")
else:
print("No")
| 0 | null | 5,701,903,463,590 | 113 | 64 |
s = input()
de_num = 0
le_num = 0
ans = [0]*(len(s)+1)
for i in range(len(s)):
if s[i] == "<":
de_num += 1
else:
de_num = 0
ans[i+1] = de_num
s = s[::-1]
ans.reverse()
for i in range(len(s)):
if s[i] == ">":
le_num += 1
else:
le_num = 0
ans[i+1] = max(le_num,ans[i+1])
print(sum(ans))
|
W = raw_input().lower()
s = []
ans = 0
while True:
T = map(str, raw_input().split())
if(T[0] == "END_OF_TEXT"):
break
else:
for i in range(len(T)):
if(W == T[i].lower()):
ans += 1
print(ans)
| 0 | null | 79,512,277,926,048 | 285 | 65 |
str = input()
while int(str[0]):
sum = 0
for char in str:
sum += int(char)
print(sum)
str = input()
|
# Aizu Problem ITP_1_8_B: Sum of Numbers
#
import sys, math, os
# read input:
PYDEV = os.environ.get('PYDEV')
if PYDEV=="True":
sys.stdin = open("sample-input.txt", "rt")
def digit_sum(n):
s = 0
while n > 0:
s += n % 10
n //= 10
return s
while True:
n = int(input())
if n == 0:
break
print(digit_sum(n))
| 1 | 1,565,526,435,840 | null | 62 | 62 |
def main():
a, b, c, d = map(int, input().split())
ans = max(max(a*c, a*d), max(b*c, b*d))
print(ans)
if __name__ == '__main__':
main()
|
a,b,c,d = map(int,input().split(' '))
matrix = []
matrix.append(a*c)
matrix.append(a*d)
matrix.append(b*d)
matrix.append(b*c)
matrix = sorted(matrix, reverse=True)
print(str(matrix[0]))
| 1 | 3,040,445,873,828 | null | 77 | 77 |
from itertools import accumulate
N, K = map(int, input().split())
mod = 998244353
Move = [list(map(int, input().split())) for _ in range(K)]
DP = [0] * N
DP[0] = 1
DP[1] = -1
cnt = 0
for i in range(N):
DP[i] += cnt
DP[i] %= mod
cnt = DP[i]
for l, r in Move:
if i + l < N:
DP[i+l] += DP[i]
if i + r + 1 < N:
DP[i + r + 1] -= DP[i]
print(DP[-1])
|
import sys
def main():
N = int(input())
P = list(map(int, input().split()))
min_so_far = sys.maxsize
ans = 0
for p in P:
if p <= min_so_far:
ans += 1
min_so_far = p
print(ans)
if __name__ == '__main__':
main()
| 0 | null | 44,228,328,631,612 | 74 | 233 |
import sys
sys.setrecursionlimit(2147483647)
INF = 1 << 60
MOD = 10**9 + 7 # 998244353
input = lambda:sys.stdin.readline().rstrip()
class LazySegmentTree(object):
def __init__(self, A, dot, unit, compose, identity, act):
# A : array of monoid (M, dot, unit)
# (S, compose, identity) : sub monoid of End(M)
# compose : (f, g) -> fg (f, g in S)
# act : (f, x) -> f(x) (f in S, x in M)
logn = (len(A) - 1).bit_length()
n = 1 << logn
tree = [unit] * (2 * n)
for i, v in enumerate(A):
tree[i + n] = v
for i in range(n - 1, 0, -1):
tree[i] = dot(tree[i << 1], tree[i << 1 | 1])
self._n, self._logn, self._tree, self._lazy = n, logn, tree, [identity] * (2 * n)
self._dot, self._unit, self._compose, self._identity, self._act = dot, unit, compose, identity, act
def _ascend(self, i):
tree, lazy, dot, act = self._tree, self._lazy, self._dot, self._act
while i > 1:
i >>= 1
tree[i] = act(lazy[i], dot(tree[i << 1], tree[i << 1 | 1]))
def _descend(self, i):
tree, lazy, identity, compose, act = self._tree, self._lazy, self._identity, self._compose, self._act
for k in range(self._logn, 0, -1):
p = i >> k
f = lazy[p]
tree[p << 1], lazy[p << 1] = act(f, tree[p << 1]), compose(f, lazy[p << 1])
tree[p << 1 | 1], lazy[p << 1 | 1] = act(f, tree[p << 1 | 1]), compose(f, lazy[p << 1 | 1])
lazy[p] = identity
# A[i] <- f(A[i]) for all i in [l, r)
def range_act(self, l, r, f):
l += self._n
r += self._n
# propagation isn't necessary if S is commutative
# self._descend(l)
# self._descend(r - 1)
l0, r0 = l, r
tree, lazy, act, compose = self._tree, self._lazy, self._act, self._compose
while l < r:
if l & 1:
tree[l], lazy[l] = act(f, tree[l]), compose(f, lazy[l])
l += 1
if r & 1:
r -= 1
tree[r], lazy[r] = act(f, tree[r]), compose(f, lazy[r])
l >>= 1
r >>= 1
self._ascend(l0)
self._ascend(r0 - 1)
# calculate product of A[l:r]
def sum(self, l, r):
l += self._n
r += self._n
self._descend(l)
self._descend(r - 1)
l_val = r_val = self._unit
tree, dot = self._tree, self._dot
while l < r:
if l & 1:
l_val = dot(l_val, tree[l])
l += 1
if r & 1:
r -= 1
r_val = dot(tree[r], r_val)
l >>= 1
r >>= 1
return dot(l_val, r_val)
from operator import add
def resolve():
n, d, a = map(int, input().split())
XH = [None] * n
coordinates = set() # for coordinates compression
for i in range(n):
x, h = map(int, input().split())
XH[i] = [x, (h - 1) // a + 1] # 初めから何回減らすかだけ持てばよい
coordinates.add(x)
coordinates.add(x + 2 * d + 1) # [x, x + 2d + 1) に減らす
XH.sort()
compress = {v : i for i, v in enumerate(sorted(coordinates))}
n = len(compress)
A = [0] * n
for i in range(len(XH)):
A[compress[XH[i][0]]] = XH[i][1]
res = 0
tree = LazySegmentTree(A, max, 0, add, 0, add) # 区間 add, 1点取得ができればよいので、区間拡張しなくてよい max にしておく
for x, h in XH:
# もし x が生き残っていたら、[x, x + 2d + 1) から hp を引く
hp = tree.sum(compress[x], compress[x] + 1)
if hp <= 0:
continue
res += hp
tree.range_act(compress[x], compress[x + 2 * d + 1], -hp)
print(res)
resolve()
|
N,K=map(int,input().split())
l=list(map(int,input().split()))
import math
def f(n):
A=0
for i in l:
A+=math.ceil(i/n)-1
return A<=K
def bis(ng,ok):
while abs(ok-ng)>1:
mid=(ok+ng)//2
if f(mid):
ok=mid
else:
ng=mid
return ok
print(bis(0,max(l)))
| 0 | null | 44,571,097,612,716 | 230 | 99 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10000000)
from collections import defaultdict
from bisect import *
mod = 10**9+7
N = int(input())
A = list(map(int, input().split()))
cnt = [0]*3
ans = 1
for i, x in enumerate(A):
T = len([c for c in cnt if c == x])
for i, c in enumerate(cnt):
if c == x:
cnt[i] += 1
break
ans = ans * T % mod
print(ans)
|
from collections import deque
N, M = [int(x) for x in input().split()]
conn = [[] for _ in range(N + 1)]
for i in range(M):
A, B = [int(x) for x in input().split()]
conn[A].append(B)
conn[B].append(A)
q = deque([1])
signpost = [0] * (N + 1)
while q:
v = q.popleft()
for w in conn[v]:
if signpost[w] == 0:
signpost[w] = v
q.append(w)
print('Yes')
for i in range(2, N + 1):
print(signpost[i])
| 0 | null | 74,994,158,419,398 | 268 | 145 |
a,b=(map(int,input().split()))
c=0
if a<=b:
print(0)
elif a>b:
c=a-b*2
if c>0:
print(c)
elif c<=0:
print(0)
|
N, K, C = map(int, input().split())
S = input().strip("\n")
L = [-1] * N
R = [10 ** 10] * N
l = 1
r = K
li = 0
ri = N-1
while li < N:
if S[li] == "o":
L[li] = l
l += 1
li += C + 1
else: li += 1
while ri >= 0:
if S[ri] == "o":
R[ri] = r
r -= 1
ri -= C + 1
else: ri -= 1
for i in range(N):
if L[i] == R[i]: print(i + 1)
| 0 | null | 103,615,743,708,282 | 291 | 182 |
while True:
x = input()
if x == '-' :
break
m = int(input())
for i in range(m):
h = int(input())
y = x[0:h]
z = x[h:len(x)+1]
x = list(z+y)
x = ''.join(x)
print(x)
|
def I(): return int(input())
N = I()
S = input()
ans = 0
for i in range(1000):
num = str(i).zfill(3)
if S.find(num[0])==-1:
continue
S1 = S[S.find(num[0])+1:]
if S1.find(num[1])==-1:
continue
S2 = S1[S1.find(num[1])+1:]
if S2.find(num[2])==-1:
continue
ans += 1
print(ans)
| 0 | null | 64,908,081,181,188 | 66 | 267 |
import sys
import bisect
import math
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
from operator import itemgetter
n,s=map(int,readline().split())
a=list(map(int,readline().split()))
mod=998244353
dp=[[0 for j in range(s+1)] for i in range(n+1)]
dp[0][0]=1
for i in range(n):
for j in range(s+1):
dp[i+1][j]+=2*dp[i][j]
dp[i+1][j]%=mod
if j+a[i]<=s:
dp[i+1][j+a[i]]+=dp[i][j]
dp[i+1][j+a[i]]%=mod
print(dp[n][s])
|
n,s=map(int,input().split())
a=list(map(int,input().split()))
d=[[0]*(s+1) for _ in range(n+1)]
d[0][0]=1
for j in range(0,s+1):
for i in range(1,n+1):
d[i][j]=2*d[i-1][j]
if a[i-1]<=j:
d[i][j]+=d[i-1][j-a[i-1]]
d[i][j]=d[i][j]%998244353
print(d[n][s])
| 1 | 17,734,344,782,368 | null | 138 | 138 |
import math
A, B, H, M = map(int, input().split())
H = math.radians((H*60 + M)/2)
M = math.radians(M*6)
Ax = A*math.cos(H)
Ay = A*math.sin(H)
Bx = B*math.cos(M)
By = B*math.sin(M)
l = math.sqrt((Ax - Bx)**2 + (Ay - By)**2)
print(l)
|
def main():
S = input()
K = int(input())
l = []
t = 1
m = S[0]
if len(S) == 1:
print(K//2)
return
if len(S) == 2:
if S[0] == S[1]:
print(K)
return
else:
print(0)
return
if len(S) == 3:
if S[0] == S[1] == S[2]:
print(3*K//2)
return
elif S[0] == S[1] or S[1] == S[2]:
print(K)
return
elif S[0] == S[2]:
print(K-1)
return
else:
print(0)
return
for v in S[1:]:
if v == m:
t += 1
elif t != 1:
l.append(t)
t = 1
m = v
if t != 1:
l.append(t)
ls = 0
lsm = 0
lsu = 0
if S[0] == S[-1]:
if len(l) == 1 and l[0] == len(S):
print(l[0] * K//2)
return
elif len(l) == 1:
print(((l[0] + 1)//2) *(K-1) + (l[0] // 2))
return
if S[0] == S[1] == S[-2]:
ls = l[-1] + l[0]
lsm = l[0]
lsu = l[-1]
l = l[1:-1]
elif S[-1] == S[-2]:
ls = l[-1] + 1
lsu = l[-1]
l = l[:-1]
elif S[0] == S[1]:
ls = l[0] + 1
lsm = l[0]
l = l[1:]
else:
ls = 2
r = 0
for i in l:
r += i // 2
r *= K
r += (K-1) * (ls // 2)
r += (lsm // 2) + (lsu // 2)
print(r)
main()
| 0 | null | 98,091,600,436,580 | 144 | 296 |
n = input()
R = [input() for i in xrange(n)]
m = R[0]
ans = -1e10
for r in R[1:]:
ans = max(ans, r - m)
m = min(m, r)
print ans
|
N = int(input())
list_price = [int(input()) for i in range(N)]
minv = list_price[0]
maxv = list_price[1] - list_price[0]
for x in list_price[1:]:
maxv = max(maxv, x - minv)
minv = min(minv, x)
print(maxv)
| 1 | 12,745,849,536 | null | 13 | 13 |
import sys
input = sys.stdin.readline
from collections import deque
def main():
N, D, A = map(int, input().split())
monsters = sorted([list(map(int, input().split())) for _ in range(N)])
for i in range(N):
monsters[i][1] = (monsters[i][1] + A - 1) // A
attacks = deque([]) # [(有効範囲, 攻撃回数)]
ans = 0
atk = 0
for i in range(N):
atk_this = monsters[i][1]
while attacks and monsters[i][0] > attacks[0][0]:
_, atk_ = attacks.popleft()
atk -= atk_
if atk_this - atk > 0:
ans += atk_this - atk
attacks.append((monsters[i][0]+2*D, atk_this-atk))
atk += atk_this - atk
print(ans)
if __name__ == '__main__':
main()
|
from math import ceil
import bisect
N, D, A = map(int, input().split())
L = [list(map(int, input().split())) for _ in range(N)]
L = [[pos, ceil(hp/A)] for pos, hp in L]
L = sorted(L, key=lambda pos: pos[0])
POS = [v[0] for v in L]
ES = [0]*(N+1)
ans, c = 0, 0
for i in range(N):
c -= ES[i]
if L[i][1] > c:
t = L[i][1]-c
ans += t
c += t
ES[bisect.bisect_right(POS, POS[i]+2*D)] += t
print(ans)
| 1 | 82,263,199,712,356 | null | 230 | 230 |
import sys
for i in sys.stdin:
i = int(i)
if i == 0:
break
(a,b) = divmod(i, 10)
sum = b
while a != 0:
(a,b) = divmod(a,10)
sum += b
print(sum)
|
while True:
num = raw_input()
if num == "0":
break
output = 0
for i in num:
output += int(i)
print output
| 1 | 1,600,720,070,548 | null | 62 | 62 |
n = int(input())
S = set(list(map(int,input().split())))
q = int(input())
T = list(map(int,input().split()))
ans = 0
for t in T:
if t in S:
ans += 1
print(ans)
|
def solve(n):
if n <= 1:
print(1)
return
a, b = 1, 1
for _ in range(2, n + 1):
c = a + b
b = a
a = c
print(c)
if __name__ == "__main__":
n = int(input())
solve(n)
| 0 | null | 35,630,687,840 | 22 | 7 |
N = int(input())
n = N % 10
if n == 3:
ans = 'bon'
elif n == 0 or n == 1 or n == 6 or n == 8:
ans = 'pon'
else:
ans = 'hon'
print(ans)
|
def main():
S = input()
N = len(S)+1
a = [0]*(N)
#右側からみていく
for i in range(N-1):
if S[i] == '<':
a[i+1] = max(a[i]+1,a[i+1])
#print(a)
#左側から見ていく
for i in range(N-2,-1,-1):
#print(i)
if S[i] == '>':
a[i] = max(a[i+1]+1,a[i])
ans = 0
#print(a)
for i in range(N):
ans += a[i]
return ans
print(main())
| 0 | null | 88,072,791,052,218 | 142 | 285 |
import math
from functools import reduce
from collections import deque
import sys
sys.setrecursionlimit(10**7)
from heapq import heappush, heappop
def input():
return sys.stdin.readline().strip()
# スペース区切りの入力を読み込んで数値リストにして返します。
def get_nums_l():
return [ int(s) for s in input().split(" ")]
# 改行区切りの入力をn行読み込んで数値リストにして返します。
def get_nums_n(n):
return [ int(input()) for _ in range(n)]
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
def rangeI(it, l, r):
for i, e in enumerate(it):
if l <= i < r:
yield e
elif l >= r:
break
def log(*args):
print("DEBUG:", *args, file=sys.stderr)
INF = 999999999999999999999999
MOD = 10**9+7
n = int(input())
S = [ input() for _ in range(n)]
left = 0
right = 0
l_ok = [False] * n
r_ok = [False] * n
LMR = [0] * n
MIN_LMR = [0] * n
for i,s in enumerate(S):
l = 0
r = 0
lok = True
for j,c in enumerate(s):
if c == "(":
l += 1
else:
r += 1
if r > l:
lok = False
MIN_LMR[i] = min(MIN_LMR[i], l-r)
LMR[i] = l - r
l = 0
r = 0
rok = True
for j in range(len(s)-1, -1, -1):
if s[j] == "(":
l += 1
if l > r:
rok = False
break
else:
r += 1
left += s.count("(")
right += s.count(")")
l_ok[i] = lok
r_ok[i] = rok
# log(l_ok)
# log(r_ok)
if left != right:
print("No")
exit()
positives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x > 0 ]
zeros = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x == 0 ]
negatives = [ (MIN_LMR[i], LMR[i]) for i,x in enumerate(LMR) if x < 0]
for i in range(len(negatives)):
min_lmr, lmr = negatives[i]
min_lmr = min_lmr - lmr
lmr = -1 * lmr
negatives[i] = (min_lmr, lmr)
positives.sort(reverse=True)
negatives.sort(reverse=True)
h = 0
for min_lmr, lmr in positives + zeros:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
h = 0
for min_lmr, lmr in negatives:
if h+min_lmr < 0:
print("No")
exit()
h += lmr
print("Yes")
|
allst = list(input().split())
stk = []
ans = 0
for i in range(0, len(allst)):
if allst[i] == '+':
stk[len(stk)-2] = stk[len(stk)-2] + stk[len(stk)-1]
del stk[len(stk)-1]
elif allst[i] == '-':
stk[len(stk)-2] = stk[len(stk)-2] - stk[len(stk)-1]
del stk[len(stk)-1]
elif allst[i] == '*':
stk[len(stk)-2] = stk[len(stk)-2] * stk[len(stk)-1]
del stk[len(stk)-1]
else:
stk.append(int(allst[i]))
print(stk[len(stk)-1])
| 0 | null | 11,788,495,773,538 | 152 | 18 |
N = int(input())
List = [list(map(str, input().split())) for i in range(0,N)]
X = str(input())
yoroshiosu = 0
samu = 0
for i in range (0, N):
if X == List[i][0]:
yoroshiosu =1
elif yoroshiosu == 0:
continue
else:
samu+=int(List[i][1])
print(samu)
|
N=int(input())
s=[]
t=[]
for i in range(N):
x,y=input().split()
s.append(x)
t.append(int(y))
X=input()
begin_idx=s.index(X)+1
print(sum(t[begin_idx:]))
| 1 | 96,739,825,219,388 | null | 243 | 243 |
def getN():
return int(input())
def getNM():
return map(int, input().split())
def getList():
return list(map(int, input().split()))
from collections import defaultdict, deque
from sys import exit
import math
import copy
from bisect import bisect_left, bisect_right
from heapq import *
import sys
# sys.setrecursionlimit(1000000)
INF = 10 ** 17
MOD = 1000000007
from fractions import *
def inverse(f):
# return Fraction(f.denominator,f.numerator)
return 1 / f
def combmod(n, k, mod=MOD):
ret = 1
for i in range(n - k + 1, n + 1):
ret *= i
ret %= mod
for i in range(1, k + 1):
ret *= pow(i, mod - 2, mod)
ret %= mod
return ret
def bunsu(n):
ret = []
for i in range(2, int(math.sqrt(n)) + 1):
if n % i == 0:
tmp = 0
while (True):
if n % i == 0:
tmp += 1
n //= i
else:
break
ret.append((i, tmp))
ret.append((n, 1))
return ret
MOD = 998244353
def solve():
n, k = getList()
nums = getList()
dp = [0 for i in range(k+1)]
dp[0] = 1
for i, num in enumerate(nums):
new = [0 for i in range(k+1)]
for j, d in enumerate(dp):
new[j] += d * 2
if (j + num) <= k:
new[j+num] += d
dp = [ne%MOD for ne in new]
print(dp[-1])
def main():
# n = getN()
# for _ in range(n):
solve()
if __name__ == "__main__":
solve()
|
from heapq import *
import sys
from collections import *
from itertools import *
from decimal import *
import copy
from bisect import *
import math
sys.setrecursionlimit(4100000)
def gcd(a,b):
if(a%b==0):return(b)
return (gcd(b,a%b))
input=lambda :sys.stdin.readline().rstrip()
N,S=map(int,input().split())
A=list(map(int,input().split()))
mod=998244353
gyaku=pow(2,mod-2,mod)
N2=pow(2,N-1,mod)
dp=[0 for n in range(3001)]
for n in range(N):
a=A[n]
for s in range(0,S+1)[::-1]:
if s+a<=S:
dp[s+a]+=dp[s]*gyaku%mod
dp[s+a]%=mod
dp[a]+=N2
dp[a]%=mod
print(dp[S])
| 1 | 17,684,884,886,818 | null | 138 | 138 |
from collections import deque
s,q=deque([*input()]),int(input())
judge=False
for i in range(q):
t=input().split()
if len(t)==1:
judge = not judge
else:
t,f,c=t
if not judge and f=='1': s.appendleft(c)
elif not judge and f=='2': s.append(c)
elif judge and f=='1': s.append(c)
else: s.appendleft(c)
if judge: s.reverse()
print(*s,sep='')
|
n=int(input())
li = input().split()
a=''
for i in range(n):
a+=li[0][i]+li[1][i]
print(a)
| 0 | null | 84,811,573,553,004 | 204 | 255 |
n = int(input())
l = list(map(int,input().split()))
h = 0
sum = 0
for i in range(n):
if l[i] <= h:
sum += h - l[i]
else:
h = l[i]
print(sum)
|
def main():
N = int(input())
A = list(map(int, input().split()))
ans = 0
h = A[0]
for i in range(1, N):
ans += max(0, h - A[i])
h = max(h, A[i])
print(ans)
if __name__ == '__main__':
main()
| 1 | 4,532,889,447,828 | null | 88 | 88 |
def solve(h, w):
odd_line = '#.' * (w // 2)
even_line = '.#' * (w // 2)
if w%2:
odd_line = odd_line + '#'
even_line = even_line + '.'
two_lines = odd_line + '\n' + even_line + '\n'
print(two_lines * (h // 2), end='')
if h%2:
print(odd_line)
print()
if __name__ == '__main__':
while True:
h, w = [int(i) for i in input().split()]
if h == w == 0: break
solve(h, w)
|
N=int(input())
d=[]
for x in range(N):
S=input()
d.append(S)
print(len(set(d)))
| 0 | null | 15,468,259,503,808 | 51 | 165 |
N = int(input())
S = input()
ans = ""
for i in range(len(S)):
ans += chr(int(ord("A"))+(int(ord(S[i])+N)-int(ord("A")))%26)
print(ans)
|
N = int(input())
S = list(input())
M = len(S)
A = [""]*M
for i in range(M):
ref = 65 + (ord(S[i]) + N - 65) % 26
A[i] = chr(ref)
ans = "".join(A)
print(ans)
| 1 | 134,932,820,930,908 | null | 271 | 271 |
def getDivisor(a,b,c):
l = 0
for i in range(a, b+1):
if (c % i == 0):
l += 1
return l
a, b, c = map(int, input().split())
print(getDivisor(a,b,c))
|
l = [int(i) for i in input().split()]
a = l[0]
b = l[1]
c = l[2]
yaku = 0
for i in range(b-a+1):
if c % (i+a) == 0:
yaku = yaku + 1
print(yaku)
| 1 | 552,191,999,670 | null | 44 | 44 |
X,K,D = map(int,input().split())
X = abs(X)
if X >= K*D:
ans = X - K*D
else:
k = X // D
if (K - k) % 2 == 0:
ans = X - k*D
else:
ans = abs(X-(k+1)*D)
print(ans)
|
import collections,sys
def s():
d = collections.deque()
input()
for e in sys.stdin:
if "i"==e[0]: d.appendleft(e[7:-1])
else:
if " "==e[6]:
m = e[7:0-1]
if m in d: d.remove(m)
elif "i"==e[7]: d.popleft()
else: d.pop()
print(*d)
s()
| 0 | null | 2,673,822,335,828 | 92 | 20 |
N=int(input())
A=list(map(int,input().split()))
A.sort(reverse=True)
ans=A[0]
if N%2==1:
n=int((N-1)/2)
ans+=A[n]
for i in range(1,n):
ans+=2*A[i]
elif N==2:
ans+=0
elif N%2==0 and N>2:
n=int((N-2)/2)
for i in range(1,n+1):
ans+=2*A[i]
print(ans)
|
N = int(input())
A = sorted(list(map(int,input().split())),reverse=True)
if N%2==0:
cnt = A[0]
for i in range(1,N//2):
cnt += 2*A[i]
print(cnt)
else:
cnt = A[0]
for i in range(1,N//2):
cnt += 2*A[i]
cnt += A[N//2]
print(cnt)
| 1 | 9,158,538,197,344 | null | 111 | 111 |
n = int(input())
al = list(map(int, input().split()))
if n == 1 and al[0] == 1:
print(0)
else:
i, j, num, ans = 0, 0, 1, 0
while i < n:
if al[i] != num:
i += 1
else:
ans += i-j
j = i+1
num += 1
i += 1
# print(i, j, ans)
if num != 1 and j != n:
ans += i-j
if num == 1:
print(-1)
else:
print(ans)
|
n = int(input())
a = list(map(int, input().split()))
ans = 0
cnt = 0
for i in a:
if i == cnt+1:
cnt += 1
else:
ans += 1
print(ans if cnt else -1)
| 1 | 114,493,858,001,728 | null | 257 | 257 |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
n, k, c = map(int, input().split())
S = [1 if a == "o" else 0 for a in input()]
count = 0
X = [0] * n
Y = [0] * n
i = 0
while i < n:
if S[i]:
count += 1
X[i] = 1
i += c + 1
else:
i += 1
if count > k:
exit()
i = n - 1
while i >= 0:
if S[i]:
Y[i] = 1
i -= c + 1
else:
i -= 1
for i in range(0, n):
if X[i] and Y[i]:
print(i + 1)
|
N, K, C = map(int, input().split())
S = input()
mae = [0] * (2 * N)
ato = [0] * (2 * N)
cnt = 0
n = 0 - N - 100
for i in range(N):
if i - n <= C:
continue
if S[i] == 'o':
mae[cnt] = i
cnt += 1
n = i
cnt = K - 1
n = 2 * N + 100
for i in range(N-1, -1, -1):
if n - i <= C:
continue
if S[i] == 'o':
ato[cnt] = i
cnt -= 1
n = i
for i in range(K):
if mae[i] == ato[i]:
print(mae[i]+1)
| 1 | 40,683,933,159,508 | null | 182 | 182 |
import sys
N, M = map(int, input().split())
if N==1 and M == 0:
print('0')
sys.exit()
d={}
ans = 0
for i in range(M):
s, c = map(int, input().split())
if s == 1 and c == 0 and N == 1:
ans = -2
elif s == 1 and c == 0:
ans = -1
elif s in d and c != d[s]:
ans = -1
else:
d[s] = c
if ans == -1:
print(ans)
elif ans == -2:
print('0')
else:
for i in range(N):
if i+1 in d:
print(d[i+1], end='')
elif i+1 == 1:
print('1', end='')
else:
print('0', end='')
|
n = int(input())
AC,WA,TLE,RE = 0,0,0,0
for x in range(n):
s = input()
if s == 'AC':
AC = AC + 1
elif s == 'WA':
WA = WA + 1
elif s == 'TLE':
TLE = TLE + 1
elif s == 'RE':
RE = RE + 1
print('AC x ' + str(AC))
print('WA x ' + str(WA))
print('TLE x ' + str(TLE))
print('RE x ' + str(RE))
| 0 | null | 34,530,862,746,754 | 208 | 109 |
n = int(input())
a = [int(i) for i in input().split()]
print(min(a), max(a), sum(a))
|
l = [1, 2, 3]
for i in range(2): l.remove(int(input()))
print(l[0])
| 0 | null | 56,035,390,278,212 | 48 | 254 |
D, T, S = list(map(int, input().split()))
if D / S <= T: print('Yes')
else: print('No')
|
def main():
d,t,s = map(int, input().split())
if s*t >= d:
print("Yes")
else:
print("No")
if __name__ == '__main__':
main()
| 1 | 3,591,667,773,980 | null | 81 | 81 |
from numba import njit
from sys import maxsize
@njit
def solve(n, k, p, c):
used = [0] * n
ss = []
for i in range(n):
if used[i]:
continue
now = i
s = []
while not used[now]:
used[now] = 1
s.append(c[now])
now = p[now]
ss.append(s)
res = -maxsize
for s in ss:
s_len = len(s)
cumsum = [0]
# 2周分の累積和
for i in range(2*s_len):
cumsum.append(cumsum[-1] + s[i%s_len])
max_sum = [-maxsize] * s_len
for i in range(s_len):
for j in range(s_len):
max_sum[j] = max(max_sum[j], cumsum[i+j] - cumsum[i])
for i in range(s_len):
if i > k:
continue
v = (k - i) // s_len
if i == 0 and v == 0:
continue
if cumsum[s_len] > 0:
res = max(res, max_sum[i] + cumsum[s_len] * v)
elif i > 0:
res = max(res, max_sum[i])
print(res)
if __name__ == '__main__':
n, k = map(int, input().split())
p = list(map(lambda x: int(x)-1, input().split()))
c = list(map(int, input().split()))
solve(n, k, p, c)
|
N, K = map(int, input().split())
P = list(map(lambda x:int(x) - 1,input().split()))
C = list(map(int, input().split()))
ans = -10**9
for i in range(N):
tmp_max = [-10**9]*(N+1)
total = 0
current_block = P[i]
for j in range(1, N + 1):
total += C[current_block]
tmp_max[j] = max(tmp_max[j-1], total)
if current_block == i:
break
current_block = P[current_block]
if total <= 0:
ans = max(ans, tmp_max[j])
else:
n = K // j
r = K % j
if r == 0:
ans = max(ans, total*(n-1) + tmp_max[j])
else:
ans = max(ans, total*n + tmp_max[r])
print(ans)
| 1 | 5,387,047,017,550 | null | 93 | 93 |
N=int(input())
def struct(s,i,n,ma):
if i==n:
print(s)
else:
for j in range(0,ma+2):
struct(s+chr(ord('a')+j),i+1,n,max(j,ma))
struct('a',1,N,0)
|
N=int(input())
alpha=[chr(ord('a') + i) for i in range(26)]
l=[]
def ans(le,alp):
s=len(set(alp))
if le==N:
l.append(alp)
return
for i in range(s+1):
ans(le+1,alp+alpha[i])
ans(1,"a")
for i in l:
print(i)
| 1 | 52,629,502,900,832 | null | 198 | 198 |
X = int(input())
money = 100
answer = 0
while money < X:
money += (money//100)
answer += 1
print(answer)
|
N = int(input())
A = list(map(int, input().split()))
MOD = 10**9+7
num_one_for_digit = [0]*61
for i in range(N):
b = bin(A[i])[2:].zfill(61)
for d in range(61):
if b[d] == "1":
num_one_for_digit[d] += 1
ans = 0
t = 1
for d in range(60, -1, -1):
n_1 = num_one_for_digit[d]
ans += n_1 * (N - n_1) * t % MOD
ans %= MOD
t *= 2
print(ans%MOD)
| 0 | null | 74,989,872,114,212 | 159 | 263 |
import sys
n = int(sys.stdin.readline())
lines = sys.stdin.readlines()
#n = int(input())
#import collections
#dll = collections.deque()
class Node:
def __init__(self,v):
self.val = v
self.prev = None
self.next = None
class DLL():
def __init__(self):
self.tail = Node(None)
self.tail.next = self.tail
self.tail.prev = self.tail
def insert(self,x):
n = Node(x)
pre = self.tail.next
n.next = pre
n.prev = self.tail
pre.prev = n
self.tail.next = n
def delete(self,x):
node = self.tail.next
while node != self.tail:
if node.val == x:
p = node.prev
n = node.next
p.next = n
n.prev = p
return
node = node.next
def deleteFirst(self):
pre = self.tail.next
if pre == self.tail:
return
node = self.tail.next
p = node.prev
n = node.next
p.next = n
n.prev = p
def deleteLast(self):
if self.tail.next == self.tail:
return
node = self.tail.prev
p = node.prev
n = node.next
p.next = n
n.prev = p
def inspect(self):
node = self.tail.next
ret = []
while node != self.tail:
ret.append(str(node.val))
node = node.next
print(" ".join(ret))
dll=DLL()
for i in range(n):
q = lines[i]
if q[0] == "i":
dll.insert(int(q.split()[1]))
elif q[6] == " ":
dll.delete(int(q.split()[1]))
elif q[6] == "L":
dll.deleteLast()
elif q[6] == "F":
dll.deleteFirst()
dll.inspect()
#print(" ".join(map(str,dll)))
|
from collections import deque
n = int(input())
dll = deque([])
for _ in range(n):
p = input().split()
if p[0] == "insert":
dll.appendleft(p[1])
elif p[0] == "delete":
try:
dll.remove(p[1])
except:
pass
elif p[0] == "deleteFirst":
dll.popleft()
else:
dll.pop()
print(" ".join(dll))
| 1 | 53,034,971,388 | null | 20 | 20 |
import math
def solve():
N = int(input())
A = list(map(int, input().split()))
A.sort(reverse = True)
A_half = math.ceil(N/2)
A_pre = A[:A_half]
A_post = A[A_half:]
ret = sum(A_pre)
for i in range(len(A_post)-1):
ret += min(A_pre[i],A_pre[(i+1)%A_half])
print(ret)
solve()
|
n=int(input())
a=[int(i) for i in input().split()]
a.sort(reverse=True)
if n%2:
print(sum(a[:(n+1)//2])*2-a[0]-a[n//2])
else:
print(sum(a[:n//2])*2-a[0])
| 1 | 9,194,476,218,120 | null | 111 | 111 |
N=int(input())
list1 = list(map(int, input().split()))
list2=[]
for i in list1:
if i%2==0:
list2.append(i)
else:
continue
list3=[]
for j in list2:
if j%3==0 or j%5==0:
list3.append(j)
else:
continue
x=len(list2)
y=len(list3)
if x==y:
print('APPROVED')
else:
print('DENIED')
|
d,t,s = map(int,input().split())
T = d/s
if(t>=T):
print("Yes")
else:
print("No")
| 0 | null | 36,341,856,197,198 | 217 | 81 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.