code1
stringlengths 16
427k
| code2
stringlengths 16
427k
| similar
int64 0
1
| pair_id
int64 2
178,025B
⌀ | question_pair_id
float64 27.1M
177,113B
⌀ | code1_group
int64 1
297
| code2_group
int64 1
297
|
|---|---|---|---|---|---|---|
import sys
def input() : return sys.stdin.readline().strip()
def main():
N = int(input())
A = tuple(map(int, input().split()))
left_sum = [0] * N # [0, i]
right_sum = [0] * N # [i, N-1]
left_sum[0] = A[0]
right_sum[-1] = A[-1]
for i in range(1, N):
left_sum[i] = left_sum[i-1] + A[i]
right_sum[(N-1)-i] = right_sum[(N-1)-(i-1)] + A[(N-1)-i]
ans = 10 ** 18
for i in range(N-1):
diff = abs(left_sum[i] - right_sum[i+1])
ans = min(ans, diff)
print(ans)
if __name__ == "__main__":
main()
|
a,b,c=list(map(int,input().split()))
print(c,a,b)
| 0 | null | 90,039,824,399,568 | 276 | 178 |
a=str(input())
b=''
for i in range(len(a)):
if a[i].isupper():
b+=a[i].lower()
elif a[i].islower:
b+=a[i].upper()
print(b)
|
a,b,c=map(int,input().split())
x="Yes" if a<b and a<c and b<c else "No"
print(x)
| 0 | null | 960,321,697,038 | 61 | 39 |
#!/usr/bin/env python3
s = input()
n = len(s)
t = s[:(n - 1) // 2]
u = s[(n + 1) // 2:]
print("YNeos"[any([s != s[::-1], t != t[::-1], u != u[::-1]])::2])
|
x = int(input())
n = 1
while 360 * n % x != 0:
n += 1
print(n * 360 // x)
| 0 | null | 29,526,326,747,732 | 190 | 125 |
import sys
while True:
n, x = [ int( val ) for val in sys.stdin.readline().split( " " ) ]
if 0 == n and 0 == x:
break
cnt = 0
goto = False
for i in range( 1, n-1 ):
if x < 3*(i+1):
break
for j in range( i+1, n ):
if x <= ( i+j ):
break
for k in range( j+1, n+1 ):
s = ( i + j + k )
if x == s:
cnt += 1
break
elif x < s:
goto = True
break
goto = False
print( cnt )
|
while(1):
n, x = map(int, input().split())
if n == 0 and x == 0:
break
count = 0
for i in range(1, n-1):
if i*3 >= x:
break
for j in range(i+1, n):
if i+2*j >= x:
break
if x-i-j <= n:
count += 1
print(count)
| 1 | 1,283,992,828,272 | null | 58 | 58 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
sys.setrecursionlimit(10**7)
from pprint import pprint as pp
from pprint import pformat as pf
# @pysnooper.snoop()
#import pysnooper # debug
import math
#from sortedcontainers import SortedList, SortedDict, SortedSet # no in atcoder
import bisect
class Solver:
def __init__(self, n, a_s):
self.n = n
self.a_s = a_s
self.extra = 1 if self.n % 2 == 0 else 2
self.dp = self.prepare_dp()
def prepare_dp(self):
dp = [None] * (self.n + 1)
for i, _ in enumerate(dp):
dp[i] = [-1 * math.inf] * (1 + self.extra)
dp[0][0] = 0
return dp
def run(self):
extra = 1 + self.n % 2
for i, a in enumerate(self.a_s):
for j in range(self.extra):
self.dp[i + 1][j + 1] = self.dp[i][j]
for j in range(self.extra + 1):
v = self.dp[i][j]
if (i + j) % 2 == 0:
v += a
self.dp[i + 1][j] = max(self.dp[i + 1][j], v)
#print('self.dp') # debug
#print(self.dp) # debug
return self.dp[n][extra]
if __name__ == '__main__':
n = int(input())
a_s = list(map(int, input().split()))
ans = Solver(n, a_s).run()
#print('ans') # debug
print(ans)
#print('\33[32m' + 'end' + '\033[0m') # debug
|
import sys
import numpy as np
def input(): return sys.stdin.readline().rstrip()
def odd(A):
oddi=np.array(A[::2],dtype=np.int64)
eveni=np.array(A[1::2],dtype=np.int64)
left=np.cumsum(oddi[:-1]-eveni)
left=np.insert(left,0,0)
right=np.cumsum(oddi[:0:-1]-eveni[::-1])[::-1]
right=np.append(right,0)
tmp=np.max(np.maximum.accumulate(left)+right)
return tmp+np.sum(eveni)
def even(A):
left=np.array([0]+A[::2],dtype=np.int64)
right=np.array(A[1::2]+[0],dtype=np.int64)[::-1]
return np.max(left.cumsum()+right.cumsum()[::-1])
def main():
n=int(input())
A=list(map(int, input().split()))
if n%2==1:
print(odd(A))
else:
print(even(A))
if __name__ == '__main__':
main()
| 1 | 37,504,453,351,930 | null | 177 | 177 |
#encoding=utf-8
import sys
num = []
ans = []
def prime(q):
q = abs(q)
if q == 2: return True
if q < 2 or q&1 == 0: return False
return pow(2, q-1, q) == 1
for i in sys.stdin:
inp = map(int , i.split())
if prime(inp[0]):
num.append(inp)
num.sort()
for i in xrange(1, len(num)):
if num[i - 1] != num[i]:
ans.append(num[i][0])
print len(ans) + 1
|
i = input().split(" ")
a = int(i[0])
b = int(i[1])
if a > b:
print("a > b")
elif a < b:
print("a < b")
else:
print('a == b')
| 0 | null | 184,355,663,180 | 12 | 38 |
def resolve():
A, B, C, K = map(int, input().split())
if K < A:
ans = K
elif (A + B) >= K:
ans = A
else:
ans = A - (K - A - B)
print(ans)
if __name__ == "__main__":
resolve()
|
h,a=map(int,input().split())
i=0
while True:
i+=1
h-=a
if h<=0:
break
print(i)
| 0 | null | 49,119,140,895,210 | 148 | 225 |
import sys
read = sys.stdin.read
readlines = sys.stdin.readlines
from math import ceil
def main():
n, k, *a = map(int, read().split())
def isOK(x):
kaisu = 0
for ae in a:
kaisu += ceil(ae / x) - 1
if kaisu <= k:
return True
else:
return False
ng = 0
ok = max(a)
while abs(ok - ng) > 1:
mid = (ok + ng) // 2
if isOK(mid):
ok = mid
else:
ng = mid
print(ok)
if __name__ == '__main__':
main()
|
print(int(not int(input())))
| 0 | null | 4,701,589,377,632 | 99 | 76 |
MOD = 10**9+7
n,a,b=map(int, input().split())
ca = 1
cb = 1
for i in range(n-a+1,n+1):
ca *= i
ca%=MOD
for i in range(1,a+1):
ca *= (pow(i,MOD-2,MOD))
ca%=MOD
for i in range(n-b+1,n+1):
cb *= i
cb%=MOD
for i in range(1,b+1):
cb*=(pow(i,MOD-2,MOD))
cb%=MOD
print((pow(2,n,MOD)-1-ca-cb)%MOD)
|
def comb_mod(n,r):
mod = 10**9+7
ans = 1
for i in range(r):
ans *= n-i
ans %= mod
for i in range(1,r+1):
ans *= pow(i,-1,mod)
ans %= mod
return ans
def solve():
n, a, b = map(int, input().split())
mod = 10**9+7
ans = pow(2,n,mod)-comb_mod(n,a)-comb_mod(n,b)-1
ans %= mod
return ans
print(solve())
| 1 | 66,196,256,769,988 | null | 214 | 214 |
print(input().split().index('0')+1)
|
string = input()
a,b = map(int,string.split(' '))
print(a*b, 2*(a+b))
| 0 | null | 6,897,640,292,362 | 126 | 36 |
a = ["SUN", "MON", "TUE", "WED", "THU", "FRI", "SAT"]
a = a * 2
c = 0
z = input()
for i in range(0,7):
if z == a[i]:
for j in range(i + 1, 14):
if a[j] == "SUN":
print(j - i )
|
s=input()
ans=(6-(["MON","TUE","WED","THU","FRI","SAT","SUN"].index(s)))
if ans==0:
print(7)
else:
print(ans)
| 1 | 132,934,107,143,310 | null | 270 | 270 |
def combination_mod(n, k, mod=10 ** 9 + 7):
if k > n:
return 1
nu, de = 1, 1
for i in range(k):
nu = nu * (n - i) % mod
de = de * (i + 1) % mod
return nu * pow(de, mod - 2, mod) % mod
n, a, b = map(int, input().split())
mod = 10 ** 9 + 7
ans = pow(2, n, mod) - 1
ans -= combination_mod(n, a)
ans = (ans + mod) % mod
ans -= combination_mod(n, b)
ans = (ans + mod) % mod
print(ans)
|
N = int(input())
S = input()
ans = S.count("R")*S.count("G")*S.count("B")
for i in range(N):
for j in range(i+1,N):
k = 2*j-i
if k<N and S[i]!=S[j]!=S[k]!=S[i]:
ans-=1
print(ans)
| 0 | null | 51,016,630,505,440 | 214 | 175 |
# 改行またはスペース区切りの入力をすべて読み込んでイテレータを返します。
def get_all_int():
return map(int, open(0).read().split())
n,*A = get_all_int()
# dp[i][j] = 活発度高い順のi人目まで処理し、左にjに置いた場合のうれしさの最大
dp = [ [0] * (n+1) for _ in range(n+1) ]
AA = list(enumerate(A))
AA.sort(key=(lambda t: t[1]), reverse=True)
for i, t in enumerate(AA):
# k 移動前の位置
# a 活発度
k,a = t
for j in range(i+1):
# 左に置く (すでに左端にj人居る)
move = abs(k - j)
dp[i+1][j+1] = max(dp[i+1][j+1], dp[i][j] + a*move)
# 右に置く (すでに右端にi-j人居る)
move = abs(k - (n-(i-j)-1))
dp[i+1][j] = max(dp[i+1][j], dp[i][j] + a*move)
ans = 0
for j in range(n+1):
ans = max(ans, dp[n][j])
print(ans)
|
def main():
import sys
input=sys.stdin.readline
n=int(input())
A=list(map(int,input().split()))
A_=[]
for i in range(n):
A_.append([A[i],i])
A_sorted=sorted(A_)[::-1]
dp=[[0]*(n+1) for _ in range(n+1)]
ans=0
for xy in range(1,n+1):
for x in range(xy+1):
m=-float("INF")
a=A_sorted[xy-1][0]
a_i=A_sorted[xy-1][1]
if x!=0 and x<=a_i+1:
m=max(m,dp[x-1][xy-x]+a*(a_i+1-x))
if x!=xy and n-xy+x>=a_i:
m=max(m,dp[x][xy-x-1]+a*(n-xy+x-a_i))
dp[x][xy-x]=m
if xy==n:
ans=max(ans,m)
print(ans)
if __name__ == '__main__':
main()
| 1 | 33,460,149,270,928 | null | 171 | 171 |
def merge(a, left, mid, right):
x = 0
l = a[left:mid] + [float("inf")]
r = a[mid:right] + [float("inf")]
i = 0
j = 0
for k in range(left,right):
if l[i] <= r[j]:
a[k] = l[i]
i += 1
else :
a[k] = r[j]
j += 1
x += 1
return x
def mergeSort(a, left, right,x):
if left+1 < right:
mid = int((left + right)/2)
mergeSort(a, left, mid,x)
mergeSort(a, mid, right,x)
x[0] += merge(a, left, mid, right)
n = int(input())
s = list(map(int,input().split()))
x = [0]
mergeSort(s,0,n,x)
print(*s)
print(x[0])
|
N = int(input())
DG = {}
node_ls = []
is_visited = {}
#有効グラフをdictで管理することにする
for _ in range(N):
tmp = input().split()
node_id = tmp[0]
node_ls.append(node_id)
is_visited[node_id] = False
adj_num = int(tmp[1])#各頂点の次元が入っている
if adj_num != 0:
DG[node_id] = tmp[2:]
else:
DG[node_id] = []
d = {}#最初に発見したときの時刻を記録
f = {}#隣接リストを調べ終えたときの完了時刻を記録
t = 1
def dfs(node):
global t
#終了条件
if is_visited[node]:
return
is_visited[node] = True
d[node] = t
t += 1
for no in DG[node]:
dfs(no)
f[node] = t
t += 1
for node in node_ls:
dfs(node)
#print(d,f)
for node in node_ls:
print(node, d[node], f[node])
| 0 | null | 60,347,961,742 | 26 | 8 |
from collections import deque
k = int(input())
# 23から232(A),233(B),234(C)が作れる
# 20からは200(B),201(C)しか作れない
# 29からは298(A),299(B)しか作れない
queue = deque([1, 2, 3, 4, 5, 6, 7, 8, 9])
for i in range(k):
x = queue.popleft()
#print(x)
# (A)の場合
if x % 10 != 0:
queue.append(10 * x + (x % 10) - 1)
# (B)の場合
queue.append(10 * x + x % 10)
# (C)の場合
if x % 10 != 9:
queue.append(10 * x + x % 10 + 1)
print(x)
|
import math
in_week = int(input().rstrip())
tmp_debt = 100000
for i in range(in_week):
tmp_debt = int(math.ceil( (tmp_debt*1.05)/1000.0 )) * 1000
print(str(tmp_debt))
| 0 | null | 19,949,450,776,542 | 181 | 6 |
import bisect
n = int(input())
s = list(input())
q = int(input())
pos = [[] for i in range(26)]
alp = "abcdefghijklmnopqrstuvwxyz"
atoi = {}
for i in range(26):
atoi[alp[i]] = i
for i in range(n):
pos[atoi[s[i]]].append(i)
for i in range(q):
a, b, c = input().split()
if a == "1":
b = int(b)-1
if c == s[b]:
continue
index = bisect.bisect_left(pos[atoi[s[b]]], b)
del pos[atoi[s[b]]][index]
bisect.insort_left(pos[atoi[c]], b)
s[b] = c
else:
l, r = int(b)-1, int(c)
ans = 0
for i in range(26):
cnt = bisect.bisect_left(pos[i], r) - bisect.bisect_left(pos[i], l)
if cnt > 0:
ans += 1
print(ans)
|
import sys
input=sys.stdin.readline
N=int(input())
S=input()
Q=int(input())
D={}
A=["a","b","c","d","e","f","g","h","i","j","k","l","m","n","o","p","q","r","s","t","u","v","w","x","y","z"]
for i in range(26):
D[A[i]]=i
n=1
while n<N:
n*=2
seg=[0 for i in range(n*2)]
#print(seg)
for i in range(N):
seg[n-1+i]=1<<D[S[i]]
k=n-1+i
while k>0:
k=(k-1)//2
seg[k]=(seg[k*2+1]|seg[k*2+2])
#print(list(bin(seg[0])).count("1"))
#0indexでa番目の値をbに変更
def update(a,b):
a+=n-1
seg[a]=1<<D[b]
while a>0:
a=(a-1)//2
seg[a]=(seg[a*2+1]|seg[a*2+2])
#print(seg)
#A～B-1(0-index)までの累積和を求める
#1～2までの累積和なら(1,3,0,0,n)
#Kは接点番号？L,Rはその接点が[L,R)に対応づいていることを表す？
#外部からはquery(A,B,0,0,n)として呼び出す
def query(A,B,K,L,R):
if K>=len(seg):
return 0
if R<=A or B<=L:
return 0
elif A<=L and R<=B:
return seg[K]
else:
vl=query(A,B,K*2+1,L,(L+R)//2)
vr=query(A,B,K*2+2,(L+R)//2,R)
#print(vl,vr)
return vl|vr
#print(n,len(seg))
#print("P",query(2,4,0,0,n),len(query(2,4,0,0,n)))
#update(3,"a")
#print(seg)
#print(query(2,4,0,0,n))
for i in range(Q):
x,y,z=list(input().split())
if x=="1":
update(int(y)-1,z)
else:
print(list(bin(query(int(y)-1,int(z),0,0,n))).count("1"))
| 1 | 62,321,733,626,200 | null | 210 | 210 |
import math
a, b, x = map(int, input().split())
if a**2 * b <= 2 * x:
h = (a**2 * b - x) / a**2 * 2
theta = h / (a**2 + h**2)**0.5
ans = math.degrees(math.asin(theta))
else:
h = 2 * x / a / b
theta = h / (b**2 + h**2)**0.5
ans = math.degrees(math.acos(theta))
print(ans)
|
a, b, x = map(int, input().split())
if x >= a**2*b/2:
t = 2*(b*a**2-x)/(a**3)
else:
t = (a*b**2)/(2*x)
import math
p = math.atan(t)
p = math.degrees(p)
print(p)
| 1 | 163,086,580,811,432 | null | 289 | 289 |
import collections
K = int(input())
l = collections.deque([1,2,3,4,5,6,7,8,9])
cnt = 0
while True:
n = l.popleft()
cnt +=1
if cnt ==K:
print(n)
exit()
if n%10 != 0:
l.append(10*n+n%10-1)
l.append(10*n+n%10)
if n%10 != 9:
l.append(10*n+n%10+1)
|
from sys import stdin
from collections import deque
def main():
#入力
readline=stdin.readline
k=int(readline())
lunlun_number=[]
d=deque(map(str,range(1,10)))
cnt=0
while cnt<k:
now=d.popleft()
lunlun_number.append(now)
cnt+=1
if now[-1]=="0":
nex=("0","1")
elif now[-1]=="9":
nex=("8","9")
else:
last=int(now[-1])
nex=(str(last-1),str(last),str(last+1))
for x in nex:
d.append(now+x)
print(lunlun_number[k-1])
if __name__=="__main__":
main()
| 1 | 40,070,206,642,480 | null | 181 | 181 |
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
plus = []
minus = []
for i in a:
if i > 0: plus.append(i)
if i < 0: minus.append(i)
ans = 1
if k > len(plus) + len(minus):
ans = 0
elif len(minus) == 0:
plus.sort(reverse=True)
for i in range(k):
ans = (ans * plus[i]) % mod
elif len(plus) == 0:
if k % 2 == 0:
minus.sort()
for i in range(k):
ans = (ans * minus[i]) % mod
else:
if n != len(minus):
ans = 0
else:
minus.sort(reverse=True)
for i in range(k):
ans = (ans * minus[i]) % mod
elif k == len(plus) + len(minus) and (len(minus) % 2) == 1:
if n != len(plus) + len(minus):
ans = 0
else:
for x in plus:
ans = (ans * x) % mod
for y in minus:
ans = (ans * y) % mod
else:
plus.sort(reverse=True)
minus.sort()
i, j = 0, 0
if k % 2 == 1:
ans = plus[0]
i = 1
while i + j < k:
tmp_p = plus[i] * plus[i + 1] if i <= len(plus) - 2 else 1
tmp_m = minus[j] * minus[j + 1] if j <= len(minus) - 2 else 1
if tmp_p >= tmp_m:
ans = (ans * (tmp_p % mod)) % mod
i += 2
else:
ans = (ans * (tmp_m % mod)) % mod
j += 2
print(ans)
|
def solver(n ,m, coins):
dp = [[100000] * (n + 1) for i in range(m + 1)]
for i in range(m + 1): dp[i][0] = 0
for r in range(1, m + 1):
for c in range(1, n + 1):
if 0 > c - coins[r - 1]:
dp[r][c] = dp[r - 1][c]
else:
dp[r][c] = min(dp[r - 1][c], dp[r][c - coins[r - 1]] + 1)
print(dp[m][n])
n, m = map(int, input().split())
coins = sorted(list(map(int, input().split())))
solver(n, m, coins)
| 0 | null | 4,771,780,141,680 | 112 | 28 |
from collections import Counter
def main():
n=int(input())
s=input()
d=Counter(s)
a=d["R"]*d["G"]*d["B"]
for i in range(n):
t=min(n-i-1, i)
for j in range(t+1):
if s[i-j] != s[i] and s[i-j] != s[i+j] and s[i] != s[i+j]:
a-=1
print(a)
if __name__ == "__main__":
main()
|
import sys
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def S(): return sys.stdin.readline().rstrip()
N,T = map(int,S().split())
A = [0]
B = [0]
for i in range(N):
a,b = LI()
A.append(a)
B.append(b)
dp1 = [[0]*(T+1) for i in range(N+1)]
# dp[i][j] = 1~i番目から選んでT分以内に食べるときの美味しさの和の最大値
dp2 = [[0]*(T+1) for i in range(N+2)]
# dp[i][j] = i~N番目から選んでT分以内に食べるときの美味しさの和の最大値
for i in range(1,N+1):
for j in range(T+1):
if j >= A[i]:
dp1[i][j] = max(dp1[i-1][j],dp1[i-1][j-A[i]]+B[i])
else:
dp1[i][j] = dp1[i-1][j]
for i in range(N,0,-1):
for j in range(T+1):
if j >= A[i]:
dp2[i][j] = max(dp2[i+1][j],dp2[i+1][j-A[i]]+B[i])
else:
dp2[i][j] = dp2[i+1][j]
ans = dp1[N][T]
for i in range(1,N+1): # 最後にi番目の料理を食べる
for j in range(T):
ans = max(ans,dp1[i-1][j]+dp2[i+1][T-1-j]+B[i])
print(ans)
| 0 | null | 93,643,157,709,620 | 175 | 282 |
import numpy as np
import sys
K = int(input())
A, B = list(map(int, input().split()))
array = np.arange(A, B+1)
for _ in array:
if(_%K == 0):
print("OK")
sys.exit(0)
print("NG")
|
a=input()
a=int(a)
b=input()
b=b.split()
import numpy as np
c=np.arange(int(b[0]),int(b[1])+1)
z=0
for x in c:
if x%a==0:
z=z+1
if z==0:
print("NG")
else:
print("OK")
| 1 | 26,595,714,946,220 | null | 158 | 158 |
#!/usr/bin/env python
# coding: utf-8
def ri():
return int(input())
def rl():
return list(input().split())
def rli():
return list(map(int, input().split()))
def main():
h1, m1, h2, m2, k = rli()
mins = (h2-h1)*60+m2-m1
print(mins-k)
if __name__ == '__main__':
main()
|
from collections import deque
N,M=map(int,input().split())
S=input()
j=N
ans=deque()
while j>0:
for i in range(M,0,-1):
if j-i==0:
ans.appendleft(i)
print(*ans)
elif j-i<0:
continue
if S[j-i]=="0":
ans.appendleft(i)
j-=i
break
if i==1 and S[j-i]=="1":
print(-1)
exit()
| 0 | null | 78,312,172,132,660 | 139 | 274 |
import sys
def lower(word):
Word = ''
str = list(word)
for i in range(len(str)):
if str[i].isupper(): Word += str[i].lower()
else: Word += str[i]
return Word
a = []
for line in sys.stdin:
a.extend(list(line))
count = [0] * 26
for i in range(len(a)):
a[i] = lower(a[i])
if 97 <= ord(a[i]) and ord(a[i]) < 123:
count[ord(a[i]) - 97] += 1
for i in range(26):
print(chr(i + 97) + ' : ' + str(count[i]))
|
n = 6
a = int(input())
b = int(input())
print(n - a - b)
| 0 | null | 56,413,758,316,532 | 63 | 254 |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
input:
15 6
1 2 7 8 12 50
output:
2
"""
import sys
def solve():
rec[0] = 0
for i in range(c_num):
for j in range(money - coins[i] + 1):
rec[j + coins[i]] = min(rec[j + coins[i]], rec[j] + 1)
return rec
if __name__ == '__main__':
_input = sys.stdin.readlines()
money, c_num = map(int, _input[0].split())
coins = list(map(int, _input[1].split()))
assert len(coins) == c_num
rec = [float('inf')] * (money + 1)
ans = solve()
print(ans[-1])
|
x = input()
s = 0
for i in range(len(x)):
s = s + int(x[i])
if s % 9 == 0:
print("Yes")
else:
print("No")
| 0 | null | 2,273,583,073,892 | 28 | 87 |
n = int(input())
lst = []
for i in range(n):
tmp = input().split()
lst.append(tmp)
d = {}
for i in range(n):
if lst[i][0] == 'insert':
d[lst[i][1]] = d.get(lst[i][1], 0) + 1
elif lst[i][0] == 'find':
print('yes') if lst[i][1] in d else print('no')
|
n = int(input())
d = {}
for i in range(n):
order = input().split()
if order[0] == 'insert':
d[order[1]] = i
else:
if order[1] in d:
print("yes")
else:
print("no")
| 1 | 76,876,657,678 | null | 23 | 23 |
N = int(input())
print(-(-N//1000)*1000 - N)
|
pay = int(input())
if pay % 1000 == 0:
print(0)
else:
print(1000 - pay % 1000)
| 1 | 8,457,846,136,708 | null | 108 | 108 |
x=[]
y=[]
n=list(map(int,input().split()))
for i in range(n[0]):
x.append(list(map(int,input().split())))
for i in range(n[1]):
y.append(list(map(int,input().split())))
for i in range(n[0]):
a=[]
for j in range(n[2]):
b=0
for k in range(n[1]):
f=x[i][k]*y[k][j]
b+=f
a.append(b)
print(' '.join(list(map(str,a))))
|
n, m, l = [int(i) for i in input().split()]
A = []
B = []
C = []
for ni in range(n):
A.append([int(i) for i in input().split()])
for mi in range(m):
B.append([int(i) for i in input().split()])
for i in range(n):
C.append([])
for j in range(l):
C[i].append(0)
for k in range(m):
C[i][j] += A[i][k] * B[k][j]
for li in range(n):
print(" ".join([str(s) for s in C[li]]))
| 1 | 1,430,956,445,152 | null | 60 | 60 |
letter = input()
if letter == letter.upper():
print("A")
else:
print("a")
|
a = input()
if a.isupper() == True:
print("A")
else:
print("a")
| 1 | 11,206,483,934,922 | null | 119 | 119 |
s = str(input())
cnt = s.count("R")
if cnt == 0:
print(0)
elif cnt == 1:
print(1)
elif cnt == 2:
if s[1] == "S":
print(1)
else:
print(2)
elif cnt == 3:
print(3)
|
X = input()
X = int(X)
if X >= 400 and X <= 599:
print('8')
elif X >= 600 and X <= 799:
print('7')
elif X >= 800 and X <= 999:
print('6')
elif X >= 1000 and X <= 1199:
print('5')
elif X >= 1200 and X <= 1399:
print('4')
elif X >= 1400 and X <= 1599:
print('3')
elif X >= 1600 and X <= 1799:
print('2')
elif X >= 1800 and X <= 1999:
print('1')
| 0 | null | 5,772,325,600,778 | 90 | 100 |
X, N = map(int,input().split())
p_n = list(map(int,input().split()))
p = list(range(102))
for i in p_n:
for j in range(len(p)):
if p[j] == i:
p.pop(j)
break
p_X = list(map(lambda x: x - X, p))
p_abs = list(map(abs,p_X))
print(p[p_abs.index(min(p_abs))])
|
x, n = map(int,input().split())
l = list(map(int,input().split()))
a = 0
ab = 0
for i in range(100):
if x - i not in l:
ans = x - i
a = i + 1
break
for i in range(100):
if x + i not in l:
ansb = x + i
ab = i + 1
break
if a > ab:
print(ansb)
else:
print(ans)
| 1 | 14,074,173,290,948 | null | 128 | 128 |
n, k = map(int, input().split())
w = []
for i in range(n):
w.append(int(input()))
def check(p):
i = 0
for _ in range(k):
wight = 0
while wight+w[i] <= p:
wight += w[i]
i += 1
if i == n:
return n
return i
if __name__ == '__main__':
left = 0
right = 100000 * 10000
mid = 0
while right - left > 1:
mid = (left+right)//2
v = check(mid)
if v >= n:
right = mid
else:
left = mid
print(right)
|
H, A = map(int, input().split())
print(H//A + 1 if H%A else H//A)
| 0 | null | 38,328,742,618,240 | 24 | 225 |
square = []
while True:
data = [int(e) for e in input().split()]
if data[0]==0 and data[1]==0:
break
square.append(data)
for i in range(len(square)):
for j in range(square[i][0]):
for k in range(square[i][1]):
print("#", end="")
print()
print()
|
c = []
def listcreate():
global c
c = []
for y in range(a[0]):
b = []
for x in range(a[1]):
b.append("#")
c.append(b)
return
def listdraw():
global c
for y in range(len(c)):
for x in range(len(c[0])):
print(c[y][x], end='')
print()
return
for i in range(10000):
a = list(map(int,input().split()))
if sum(a)==0:
break
listcreate()
listdraw()
print()
| 1 | 772,816,379,314 | null | 49 | 49 |
X,Y=map(int,input().split())
for i in range(100):
for j in range(100):
if i+j==X and 2*i+4*j==Y:
print("Yes")
break
else:
continue
break
else:
print("No")
|
X,Y=list(map(int,input().split()))
judge=False
for i in range(0,X+1):
if i*2+(X-i)*4==Y:
judge=True
if judge:
print("Yes")
else:
print("No")
| 1 | 13,884,375,359,710 | null | 127 | 127 |
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)
|
import math
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
N = I()
A = LI()
A.sort(reverse=True)
# print(A)
# half = math.ceil(len(A)/2)
q, mod = divmod(len(A),2)
if mod == 0:
ans = A[0]
for i in range(1,q):
ans += 2 * A[i]
else:
ans = A[0]
for i in range(1,q):
ans += 2 * A[i]
ans += A[q]
print(ans)
| 1 | 9,207,432,909,332 | null | 111 | 111 |
n = int(input())
a = list(map(int, input().split()))
a.sort()
def main(a):
if 0 in a:
ans = 0
else:
ans = 1
for item in a:
ans *= item
if ans > 1000000000000000000:
ans = -1
break
return ans
ans = main(a)
print(ans)
|
n = int(input())
alst = list(map(int, input().split()))
if 0 in alst:
print(0)
exit()
else:
ans = 1
for i in range(n):
ans *= alst[i]
if ans > 10**18:
print('-1')
exit()
print(ans)
| 1 | 16,155,538,203,158 | null | 134 | 134 |
import sys
input = lambda: sys.stdin.readline().rstrip()
def solve():
N = int(input())
if N % 2 == 1 or N < 10:
print(0)
exit()
ans = 0
div = 10
while div <= N:
ans += N // div
div *= 5
print(ans)
if __name__ == '__main__':
solve()
|
import sys
read = sys.stdin.read
#readlines = sys.stdin.readlines
from math import ceil
def main():
n = tuple(map(int, tuple(input())))
if sum(n) % 9 == 0:
print('Yes')
else:
print('No')
if __name__ == '__main__':
main()
| 0 | null | 60,313,181,854,090 | 258 | 87 |
data =[1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
line =int(input())
print(data[line -1])
|
def main():
A = [1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14,
1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51]
K = int(input())
print(A[K-1])
if __name__ == '__main__':
main()
| 1 | 49,812,087,192,918 | null | 195 | 195 |
# ????????? n ?¬?????????????????????????p ??????????????? 1???2???3????????? ?????????????????????????????¢????±???????????????°??????
import math
# ?¬??????°n????¨??????\???????????????
n = int(input())
# ????????????x????¨??????\???????????????
x = list(input())
x = "".join(x).split()
# ????????????y????¨??????\???????????????
y = list(input())
y = "".join(y).split()
# p=1,2,????????§???????????????????????????????????¢???????´?????????????
# ?????????????????????
dxy = [0 for i in range(4)]
# p=1???????????????????????????????????¢????¨????
for i in range(0, n):
dxy[0] += math.fabs(int(x[i]) - int(y[i]))
# p=2
for i in range(0, n):
dxy[1] += (math.fabs(int(x[i]) - int(y[i]))) ** 2
dxy[1] = math.sqrt(dxy[1])
# p=3
for i in range(0, n):
dxy[2] += (math.fabs(int(x[i]) - int(y[i]))) ** 3
dxy[2] = math.pow(dxy[2], 1.0 / 3.0)
# p=????????§
dxy[3] = math.fabs(int(x[0]) - int(y[0]))
for i in range(1, n):
if dxy[3] < math.fabs(int(x[i]) - int(y[i])):
dxy[3] = math.fabs(int(x[i]) - int(y[i]))
# ??????
for i in range(0, 4):
print("{0}".format(dxy[i]))
|
n = int(input())
x = list(map(int, input().split()))
y = list(map(int, input().split()))
for p in range(3):
print(sum(abs(x[i] - y[i]) ** (p+1) for i in range(n)) ** (1/(p+1)))
print(max(abs(x[i] - y[i]) for i in range(n)))
| 1 | 208,480,920,128 | null | 32 | 32 |
class Dice:
def __init__(self,t,f,r,l,b,u):
self.t = t
self.f = f
self.r = r
self.l = l
self.b = b
self.u = u
self.a=[t,f,r,l,b,u]
self.direction={'S':(4,0,2,3,5,1),'N':(1,5,2,3,0,4),'E':(3,1,0,5,4,2),'W':(2,1,5,0,4,3),'Y':(0,3,1,4,2,5)}
def roll(self,d):
self.a=[self.a[i] for i in self.direction[d]]
self.t = self.a[0]
self.f = self.a[1]
self.r = self.a[2]
self.l = self.a[3]
self.b = self.a[4]
self.u = self.a[5]
t,f,r,l,b,u=map(int,input().split())
dice=Dice(t,f,r,l,b,u)
n=int(input())
s='SSSEWW'
yw='YYY'
for j in range(n):
t,f=map(int,input().split())
for d in s:
if dice.t==t:
break
dice.roll(d)
for t in yw:
if dice.f==f:
break
dice.roll(t)
print(dice.r)
|
class Dice:
def __init__(self, U, S, E, W, N, D):
self.u, self.d = U, D
self.e, self.w = E, W
self.s, self.n = S, N
def roll(self, commmand):
if command == 'E':
self.e, self.u, self.w, self.d = self.u, self.w, self.d, self.e
elif command == 'W':
self.e, self.u, self.w, self.d = self.d, self.e, self.u, self.w
elif command == 'S':
self.s, self.u, self.n, self.d = self.u, self.n, self.d, self.s
else:
self.s, self.u, self.n, self.d = self.d, self.s, self.u, self.n
def rightside(self, upside, forward):
self.structure = {self.u:{self.w: self.s, self.s: self.e, self.e: self.n, self.n: self.w},
self.d:{self.n: self.e, self.e: self.s, self.s: self.w, self.w: self.n},
self.e:{self.u: self.s, self.s: self.d, self.d: self.n, self.n: self.u},
self.s:{self.u: self.w, self.w: self.d, self.d: self.e, self.e: self.u},
self.w:{self.u: self.n, self.n: self.d, self.d: self.s, self.s: self.u},
self.n:{self.u: self.e, self.e: self.d, self.d: self.w, self.w: self.u}}
print(self.structure[upside][forward])
U, S, E, W, N, D = [int(i) for i in input().split()]
turns = int(input())
dice1 = Dice(U, S, E, W, N, D)
for i in range(turns):
upside, forward = [int(k) for k in input().split()]
dice1.rightside(upside, forward)
| 1 | 252,859,069,678 | null | 34 | 34 |
N = int(input())
A = list(map(int, input().split()))
from collections import defaultdict, Counter
counted_a = Counter(A)
total = 0
for key, v in counted_a.items():
total += v * (v-1) // 2
ans = []
for a in A:
v = counted_a[a]
t = total - v * (v-1) // 2 + (v-1) * (v-2) // 2
ans.append(t)
print(*ans, sep='\n')
|
n = int(input())
aas = list(map(int, input().split()))
cnts = [0]*(n+1)
for i in range(n):
cnts[aas[i]] += 1
t = 0
for i in range(1,n+1):
tmp = cnts[i]
t += tmp*(tmp-1)//2
for i in range(n):
tmp = cnts[aas[i]]
print(int(t-tmp*(tmp-1)/2*(1-1/tmp*(tmp-2))))
| 1 | 47,746,689,298,692 | null | 192 | 192 |
N, M, X = map(int,input().split())
CA = list(list(map(int,input().split())) for _ in range(N))
cost = (10 ** 5) * 12
for i in range(2 ** N):
total, a = 0, [0] * M
for j in range(N):
if i >> j & 1:
total += CA[j][0]
for k in range(M): a[k] += CA[j][k + 1]
for j in range(M):
if a[j] < X:
if i == 2 ** N - 1: cost = -1
break
else: cost = min(cost, total)
print(cost)
|
while True:
H,W=map(int,raw_input().split())
if H==W==0:
break
elif H!=0 or W!=0:
print (('#'*W +'\n')*H)
| 0 | null | 11,512,878,164,508 | 149 | 49 |
H, N = map(int, input().split())
magic = [list(map(int, input().split())) for _ in range(N)]
dp = [10**9 for _ in range(H+10**4+1)]
dp[0] = 0
for a, b in magic:
for j in range(H+1):
if dp[j+a] > dp[j] + b:
dp[j+a] = dp[j] + b
print(min(dp[H:]))
|
N = list(map(int, list(input())))
dp=[[-1,-1] for i in range(len(N)+1)]
dp[0]=[0,1]
b=0
N.insert(0,0)
for i in range(1,len(N)):
up = 10-N[i]
dp[i][0]=min(dp[i-1][0]+N[i],dp[i-1][1]+up)
dp[i][1] = min(dp[i-1][0]+N[i]+1, dp[i-1][1]+up-1)
print(dp[-1][0])
| 0 | null | 76,422,018,827,110 | 229 | 219 |
#coding:UTF-8
def IS(N,A):
for i in range(int(N)):
v=A[i]
j=i-1
while j>=0 and A[j]>v:
A[j+1]=A[j]
j=j-1
A[j+1]=v
ans=""
for k in range(len(A)):
ans+=str(A[k])+" "
print(ans[:-1])
if __name__=="__main__":
N=input()
a=input()
A=a.split(" ")
for i in range(len(A)):
A[i]=int(A[i])
IS(N,A)
|
from __future__ import division, print_function, unicode_literals
from future_builtins import *
N = int(raw_input())
A = list(map(int, raw_input().split()))
print(" ".join(map(str, A)))
for i in xrange(1,N):
j, p = i-1, A[i]
while j >= 0 and A[j] > p:
A[j+1] = A[j]
j -= 1
A[j+1] = p
print(" ".join(map(str, A)))
| 1 | 5,292,898,662 | null | 10 | 10 |
n = int(input())
if n % 2 == 0:
print(f'{(n/2) / n:.10f}')
else:
print(f'{(n//2 + 1) / n:.10f}')
|
from string import ascii_lowercase, ascii_uppercase
s = open(0).read()
ans = [0]*26
for c in s:
i = ascii_lowercase.find(c)
if i > -1:
ans[i] += 1
i = ascii_uppercase.find(c)
if i > -1:
ans[i] += 1
for c, t in zip(ascii_lowercase, ans):
print("%s : %d" % (c, t))
| 0 | null | 89,541,297,399,180 | 297 | 63 |
#!/usr/bin/env python3
n = int(input())
s = input()
s = [int(i) for i in s]
c = 0
for i in range(10):
for j in range(10):
if i in s:
t = s[s.index(i) + 1:]
if j in t:
c += len(set(t[t.index(j) + 1:]))
print(c)
|
# -*- coding: utf-8 -*-
def get_input() -> tuple:
"""
標準入力を取得する.
Returns:\n
tuple: 標準入力
"""
N = int(input())
S = input()
return N, S
def main(N: int, S: str) -> None:
"""
メイン処理.
Args:\n
N (int): 桁数(4 <= N <= 30000)
S (str): ラッキーナンバー(半角数字からなる長さNの文字列)
"""
# 求解処理
ans = 0
S_i_list = []
for i in range(N - 2):
S_i = S[i]
if S_i in S_i_list:
continue
S_j_list = []
for j in range(i + 1, N - 1):
S_j = S[j]
if S_j in S_j_list:
continue
ans += len(set(S[j + 1: N]))
S_j_list.append(S_j)
S_i_list.append(S_i)
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N, S = get_input()
# メイン処理
main(N, S)
| 1 | 128,846,938,053,488 | null | 267 | 267 |
N, K = map(int, input().split())
n = N%K
m = K - n
print(min(abs(n), abs(m)))
|
N,K = map(int,input().split())
count = N//K
N = abs( N - count*K )
N_2 = abs( N - K )
print( N if N <= N_2 else N_2 )
| 1 | 39,309,311,157,380 | null | 180 | 180 |
num = list(map(int,input().split()))
sum = 500*num[0]
if num[1] <= sum:
print("Yes")
else:
print("No")
|
import sys
stdin = sys.stdin
ns = lambda: stdin.readline().rstrip()
ni = lambda: int(stdin.readline().rstrip())
nm = lambda: map(int, stdin.readline().split())
nl = lambda: list(map(int, stdin.readline().split()))
K,X=nm()
print('Yes' if X<=500*K else 'No')
| 1 | 97,750,707,154,912 | null | 244 | 244 |
h = int(input())
w = int(input())
n = int(input())
if h >= w:
m = h
else:
m = w
if n%m == 0:
ans = n//m
else:
ans = n//m +1
print(ans)
|
N = int(input())
S = input()
if len(S) % 2 != 0:
print("No")
exit()
else:
l = len(S)
if S[0:l//2] == S[l//2:l]:
print("Yes")
else:
print("No")
| 0 | null | 117,946,046,699,804 | 236 | 279 |
a, b = map(int, input().split())
print('a ', end='')
if a < b:
print('<', end='')
elif a > b:
print('>', end='')
elif a == b:
print('==', end='')
print(' b')
|
a,b=[int(x) for x in input().split()]
if a < b :
print('a < b')
elif a > b :
print('a > b')
else:
print('a == b')
| 1 | 360,878,426,718 | null | 38 | 38 |
S, T = input().split()
A, B = map(int, input().split())
U = input()
if (U == T):
print(str(A)+" "+str(B-1))
else:
print(str(A-1)+" "+str(B))
|
S,T=map(str,input().split())
A,B=map(int,input().split())
U=str(input())
if S==U:
print(str(A-1)+" "+str(B))
else:
print(str(A)+" "+str(B-1))
| 1 | 71,871,481,989,652 | null | 220 | 220 |
def allocate(n,w,k,p):
t=0
c=1
for i in range(n):
if t + w[i] > p:
t=0
c+=1
if c > k:
return -1
t+=w[i]
return 0
n,k=map(int,input().split())
w=[0]*n
m=(1<<30)*-1
s=0
for i in range(n):
w[i]=int(input())
m=max(m,w[i])
s+=w[i]
i=m
j=s
while (i<=j):
guess = int(i+(j-i)/2)
if allocate(n,w,k,guess) < 0:
i = guess + 1
else:
j = guess - 1
print(i)
|
def is_leq_S(A, lim, K):
S = [0] * K
ai = 0
si = 0
while ai < len(A):
if S[si] + A[ai] <= lim:
S[si] += A[ai]
ai += 1
else:
si += 1
if si == K:
return False
return True
def main():
N, K = [int(_) for _ in input().split()]
A = []
for _ in range(N):
A.append(int(input()))
l = 0
r = 100000 * 100000
while l + 1 < r:
m = (l + r) // 2
if is_leq_S(A, m, K):
S = m
r = m
else:
l = m
print(S)
main()
| 1 | 92,034,973,164 | null | 24 | 24 |
n=int(input())
a = list(map(int, input().split()))
ans = 0
temp = a[0]
for i in a[1:]:
if temp > i:
ans += (temp - i)
temp = max(temp, i)
print(ans)
|
def Is_ToPut(p,w,k):
count =1
temp =p
for i in w:
if temp >= i:
temp -=i
elif i > p :
return 0
else:
count +=1
temp =p-i
if count <= k:return 1
else:return 0
n,k = list(map(int,input().split(' ')))
w =[]
for _ in range(n):
w.append(int(input()))
ans =100000*10000
left = 0
right = 100000*10000
while left < right:
p = (left+right)//2
if Is_ToPut(p,w,k):
if ans > p:ans =p
right=p
else:
left = p +1
print(ans)
| 0 | null | 2,331,399,495,100 | 88 | 24 |
from collections import Counter as C
n=int(input())
S=list(input())
a=1
L=C(S).most_common(3)
for l in L:
a*=l[1]
for i in range(1,n):
for j in range(n-2*i):
if len(set((S[j],S[j+i],S[j+2*i])))==3:
a-=1
print(a if len(L)>2 else 0)
|
n = int(input())
s = input()
ans = s.count('R') * s.count('G') * s.count('B')
for i in range(n-2):
for j in range(i+1, n-1):
k = 2*j-i
if k < n:
if s[k] != s[i] and s[k] != s[j] and s[i] != s[j]:
ans -= 1
else:
break
print(ans)
| 1 | 35,856,312,332,510 | null | 175 | 175 |
INF = 10**9
def solve(h, w, s):
dp = [[INF] * w for r in range(h)]
dp[0][0] = int(s[0][0] == "#")
for r in range(h):
for c in range(w):
for dr, dc in [(-1, 0), (0, -1)]:
nr, nc = r+dr, c+dc
if (0 <= nr < h) and (0 <= nc < w):
dp[r][c] = min(dp[r][c], dp[nr][nc] + (s[r][c] != s[nr][nc]))
return (dp[h-1][w-1] + 1) // 2
h, w = map(int, input().split())
s = [input() for r in range(h)]
print(solve(h, w, s))
|
from queue import deque
h,w = map(int,input().split())
li = [input() for _ in range(h)]
inf = 10**10
dx = [1,0]
dy = [0,1]
que = deque()
#そのマスにたどり着くまでに色が変わった最小の回数を保存するリスト
flip_count = [[inf for i in range(w)]for j in range(h)]
if li[0][0] == "#":
flip_count[0][0] = 1
else:
flip_count[0][0] = 0
que.append([0,0])
while que:
k = que.popleft()
x = k[0]
y = k[1]
for i,j in zip(dx,dy):
nx = x + i
ny = y + j
if nx >= w or ny >= h:
continue
if flip_count[ny][nx] == inf:
que.append([nx,ny])
if li[ny][nx] != li[y][x]:
flip_count[ny][nx] = min(flip_count[ny][nx],flip_count[y][x]+1)
else:
flip_count[ny][nx] = min(flip_count[ny][nx],flip_count[y][x])
if li[-1][-1] == "#":
flip_count[-1][-1] += 1
print(flip_count[-1][-1]//2)
| 1 | 49,350,423,448,732 | null | 194 | 194 |
N,X,M = map(int,input().split())
ans = X
A = X
TF = True
srt = 1000000
retu = [X]
d = dict()
d[X] = 0
loop = X
flag = False
for i in range(N-1):
if TF:
A = A**2 % M
if d.get(A) != None:
srt = d[A]
goal = i
TF = False
if TF:
retu.append(A)
d[A] = i + 1
loop += A
else:
flag = True
break
if flag:
n = (N-srt)//(goal-srt+1)
saisyo = sum(retu[:srt])
loop -= saisyo
print(saisyo + loop*n + sum(retu[srt:N-n*(goal-srt+1)]))
else:
print(sum(retu[:N]))
|
n, x, m = map(int, input().split())
ans = 0
a = [0]
id = [0]*(m+1)
l = 1
while id[x] == 0:
a.append(x)
id[x] = l
ans += x
l += 1
x = x**2 % m
c = l - id[x]
s=0
for i in range(id[x],l):
s += a[i]
if n <= l-1:
ans = 0
for i in range(1,n+1):
ans += a[i]
else:
n -= l
n += 1
ans += s*(n//c)
n %= c
for i in range(n):
ans += a[id[x] + i]
print(ans)
| 1 | 2,792,226,604,416 | null | 75 | 75 |
a,b,c,d = (int(x) for x in input().split())
ans = max(a*c,a*d,b*c,b*d)
print(ans)
|
# B
a, b, c, d = list(map(int, input().split(" ")))
numlist = [a*c, a*d, b*c, b*d]
maxnum = max(numlist)
print(maxnum)
| 1 | 3,084,837,214,432 | null | 77 | 77 |
input()
A = list(map(int, input().split()))
sum = 0
for i in range(1, len(A)):
if A[i] < A[i-1]:
sum += A[i-1] - A[i]
A[i] = A[i-1]
print(sum)
|
T=str(input())
T2=list(T)
if T2[0]=="?":
T2[0]="D"
if T2[len(T)-1]=="?":
T2[len(T)-1]="D"
for i in range(1,len(T2)-1):
if T2[i]=="?":
if T2[i-1]=="D" and T2[i+1]!="P":
T2[i]="P"
else:
T2[i]="D"
ans="".join(T2)
print(ans)
| 0 | null | 11,425,601,652,540 | 88 | 140 |
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
|
x = int(input())
A = [0]*(2*10**5)
for i in range(2,len(A)):
if A[i]==0:
for j in range(2*i,len(A),i):
A[j]=1
for i in range(x,len(A)):
if A[i]==0:
print(i);exit()
| 1 | 105,709,448,969,808 | null | 250 | 250 |
a = list(map(int,input().split()))
print(15-sum(a))
|
str = input().split()
print(str.index('0')+1)
| 1 | 13,532,611,303,316 | null | 126 | 126 |
n, k = map(int, input().split())
wlist = []
for i in range(n):
wlist.append(int(input()))
ma = sum(wlist) + 1
mi = max(wlist) - 1
while (ma - mi > 1):
mid = (ma + mi)//2
truck = [0for i in range(k)] ## k개
i = 0
gobigger = 0
for w in wlist:
if(truck[i] + w <= mid):
truck[i] = truck[i] + w
else:
i = i+1
if (i == k):
gobigger = 1
break
truck[i] = truck[i] + w
if (gobigger == 1):
mi = mid
else:
ma = mid
print(ma)
|
# coding:utf-8
n, k = map(int,raw_input().split())
ws = []
for _ in xrange(n):
ws.append(int(raw_input()))
def possible_put_p(p):
# P??\?????????????????????????????????
current = 1
weight = 0
for w in ws:
if weight + w <= p:
weight += w
else:
current += 1
if current > k:
return False
weight = w
if current <= k:
return True
else:
return False
low = max(ws)
high = sum(ws)
while(high - low > 0):
mid = (low + high) / 2
if(possible_put_p(mid)):
high = mid
else:
low = mid + 1
print high
| 1 | 88,917,628,540 | null | 24 | 24 |
def main():
n, m = map(int, input().split())
a_lst = list(map(int, input().split()))
total = sum(a_lst)
cnt = 0
for a in a_lst:
if a * 4 * m >= total:
cnt += 1
if cnt >= m:
ans = "Yes"
else:
ans = "No"
print(ans)
if __name__ == "__main__":
main()
|
k=int(input())
if k==4 or k==6 or k==9 or k==10 or k==14 or k==21 or k==22 or k==25 or k==26:
print(2)
elif k==8 or k==12 or k==18 or k==20 or k==27:
print(5)
elif k==16:
print(14)
elif k==24:
print(15)
elif k==32:
print(51)
elif k==28 or k==30:
print(4)
else:
print(1)
| 0 | null | 44,263,172,482,096 | 179 | 195 |
N = int(input())
A = list(map(int,input().split()))
chk = []
for i in range(N-1):
if A[i+1] > A[i]:
chk.append(1)
else:
chk.append(0)
ans = 1000
for i in range(N-1):
if chk[i] == 1:
ans += (A[i+1] - A[i]) * (ans//A[i])
print(ans)
|
n = int(input())
a = list(map(int, input().split()))
p = 1000
k = 0
for i in range(n-1):
if k>0 and a[i]>a[i+1]:
p += k*a[i]
k = 0
elif k==0 and a[i]<a[i+1]:
k = p//a[i]
p %= a[i]
if k>0:
p += k*a[-1]
print(p)
| 1 | 7,239,274,656,480 | null | 103 | 103 |
import sys
from operator import itemgetter
sys.setrecursionlimit(5000)
input = sys.stdin.readline
TIME = 0
VAL = 1
N, T = [int(a) for a in input().split()]
time_value = [None] * (N + 1)
time_value[0] = (-1, -1)
for i in range(1, N + 1):
time_value[i] = tuple(int(a) for a in input().split())
# Sort the array in the increasing order of value
time_value.sort(key = itemgetter(VAL))
# T by (N + 1) table for knapsack problem
# maximum possible time is T-1
dp_table = [[-1] * T for _ in range(N + 1)]
# Fill in dp_table i.e. solve knapsack problem
for t in range(0, T):
dp_table[0][t] = 0
for n in range(1, N + 1):
dp_table[n][0] = 0
for t in range(1, T):
if time_value[n][TIME] > t:
dp_table[n][t] = dp_table[n - 1][t]
else:
dp_table[n][t] = max(dp_table[n - 1][t],
time_value[n][VAL] + dp_table[n - 1][t - time_value[n][TIME]])
val_acum = time_value[N][VAL]
t = T - 1
max_val = val_acum + dp_table[N - 1][t]
for n in range(N - 1, 0, -1): # food to eat at the end
val_acum += time_value[n][VAL] # value[N] + value[N-1] + ... + value[n]
t -= time_value[n + 1][TIME] # T - 1 - (time[N] + time[N-1] + ... + time[n + 1])
if t < 0: break
tmp = val_acum + dp_table[n - 1][t]
max_val = max(max_val, tmp)
print(max_val)
|
l = list(input())
a = False
b = False
c = False
if l[0] == 'R':
a = True
if l[1] == 'R':
b = True
if l[2] == 'R':
c = True
if a and b and c:
print(3)
elif (a and b) or (b and c):
print(2)
elif a or b or c:
print(1)
else:
print(0)
| 0 | null | 78,327,901,954,092 | 282 | 90 |
X, N = [int(i) for i in input().split()]
P = [int(i) for i in input().split()]
# Xは0~101の値になる
result = 0
current = 102
for i in range(102):
if i not in P:
if abs(X - i) < current:
result = i
current = abs(X - i)
print(result)
|
from functools import reduce
n, k = map(int, input().split())
a = list(map(int, input().split()))
mod = 10 ** 9 + 7
if n == k:
print(reduce(lambda ac, v: ac * v % mod, a, 1))
exit()
a.sort(key=lambda v: abs(v), reverse=True)
if len(list(filter(lambda v: v < 0, a))) == n and k % 2 == 1:
print(reduce(lambda ac, v: ac * v % mod, a[n - k :], 1))
exit()
ans = 1
mn = 0
for v in a[:k]:
if v < 0:
mn += 1
ans *= abs(v)
ans %= mod
if mn % 2 == 0:
print(ans)
exit()
mnp, mnn = 0, 0
for v in a[k - 1 :: -1]:
if mnp != 0 and mnn != 0:
break
elif mnp == 0 and v > 0:
mnp = v
elif mnn == 0 and v < 0:
mnn = v
mxp, mxn = 0, 0
for v in a[k:]:
if mxp != 0 and mxn != 0:
break
elif mxp == 0 and v > 0:
mxp = v
elif mxn == 0 and v < 0:
mxn = v
x, y = mxp, mnn
if mnp != 0 and mxn * mnn > mxp * mnp:
x, y = mxn, mnp
ans *= pow(abs(y), mod - 2, mod)
ans %= mod
ans *= abs(x)
ans %= mod
print(ans)
| 0 | null | 11,759,935,572,748 | 128 | 112 |
w1, w2 = input().split()
a,b = map(int,input().split())
c = input()
l = [[w1,a],[w2,b]]
ans = ""
for i in range(2):
x,y = l[i][0],l[i][1]
if x==c:
ans += str(y-1)
else:
ans += str(y)
if i==0:
ans += ' '
print(ans)
|
S, T = input().split()
A, B = map(int, input().split())
U = input()
if U == S:
print("%d %d" % (A-1, B))
else:
print("%d %d" % (A, B-1))
| 1 | 71,525,028,372,476 | null | 220 | 220 |
s,t = input().split()
a,b = map(int, input().split())
u = input()
if s==u: print(a-1,b)
elif t==u: print(a,b-1)
else: print(a,b)
|
s, t = input().split()
a, b = map(int, input().split())
u = input()
if u == s:
print(a-1, end = ' ')
print(b)
else:
print(a, end = ' ')
print(b-1)
| 1 | 71,704,337,128,000 | null | 220 | 220 |
def main():
N = int(input())
S = input()
cnt = 0
for i in range(N-2):
if S[i] == 'A':
if S[i+1] == 'B':
if S[i+2] == 'C':
cnt += 1
print(cnt)
main()
|
import sys
n = int(input())
a = list(map(int, input().split()))
a = sorted(a, reverse=True)
multi = 1
if 0 in a:
print('0')
sys.exit()
for i in a:
multi *= i
if multi > 10**18:
print('-1')
sys.exit()
print(multi)
| 0 | null | 58,033,686,494,940 | 245 | 134 |
n = int(input())
output = 0
for i in range(n):
if (i + 1) % 3 != 0 and (i + 1) % 5 != 0:output += i + 1
print(output)
|
def to_fizzbuzz(number):
if number % 15 == 0:
return 'FizzBuzz'
if number % 3 == 0:
return 'Fizz'
if number % 5 == 0:
return 'Buzz'
else:
return str(number)
# return i
def main():
N = int(input())
# this list concludes "FizzBuzz", "Fizz" or "Buzz"
fblist = []
for number in range(1, 10**6):
result = to_fizzbuzz(number)
fblist.append(result)
# the list up to N
n_list = fblist[0:N]
# this list contains only numbers and up to N
n_numlist = []
for s in n_list:
if s.isdigit() == True:
n_numlist.append(int(s))
print(sum(n_numlist))
main()
| 1 | 35,028,731,958,912 | null | 173 | 173 |
while 1:
h, w = map(int, raw_input().split())
if h == 0 and w == 0:
break
else:
print '#'*w
for i in range(h-2):
print '#' + '.'*(w-2) + '#'
print '#'*w
print ''
|
h = list(map(int, input().split()))
m = 0
m += 60 - h[1]
if m != 0: h[0] += 1
m += h[3] + (h[2]-h[0]) * 60
print(m-h[-1])
| 0 | null | 9,408,852,304,960 | 50 | 139 |
X = int(input())
for i in range(1,1000000000):
if ( X * i ) % 360 == 0:
print(i)
quit()
|
import sys
def gcd(a, b):
if b == 0:
return a
else:
return gcd(b, a % b)
for line in sys.stdin:
line = line.strip()
if line == "":
break
X = int(line)
ans = 360 // gcd(X, 360)
print(ans)
| 1 | 13,242,747,348,160 | null | 125 | 125 |
nm = input().split()
n = int(nm[0])
m = int(nm[1])
ans = 0
n1 = n*(n-1)/2
n2 = m*(m-1)/2
ans = int(n1 + n2)
print(ans)
|
class Combination:
def __init__(self, mod, max_num):
self.mod = mod
self.fac = [0] * max_num
self.finv = [0] * max_num
self.inv = [0] * max_num
self.fac[0], self.fac[1] = 1, 1
self.finv[0], self.finv[1] = 1, 1
self.inv[1] = 1
for i in range(2, max_num):
self.fac[i] = self.fac[i-1] * i % mod
self.inv[i] = mod - self.inv[mod % i] * (mod // i) % mod
self.finv[i] = self.finv[i - 1] * self.inv[i] % mod
def calc(self, n, k):
if n < k:
return 0
if n < 0 or k < 0:
return 0
return self.fac[n] * (
self.finv[k] * self.finv[n - k] % self.mod) % self.mod
n, k = map(int, input().split())
com = Combination(1000000007, 500000)
ret = 1
min_val = min(n, k)
for i in range(1, min_val+1):
if i != n:
ret += com.calc(n, i) * com.calc(n-1, i)
ret %= 10 ** 9 + 7
else:
ret += 0
print(ret)
| 0 | null | 56,066,846,405,948 | 189 | 215 |
MOD = 998244353
n, k = map(int, input().split())
l, r = [0]*k, [0]*k
for i in range(k):
_l, _r = map(int, input().split())
l[i], r[i] = _l, _r
dp, dpsum = [0]*(n+1), [0]*(n+1)
dp[1], dpsum[1] = 1, 1
for i in range(2, n+1):
for j in range(k):
li = i - r[j]
ri = i - l[j]
if ri<0: continue
li = max(li, 1)
dp[i] += dpsum[ri] - dpsum[li-1]
dp[i] %= MOD
dpsum[i] = dpsum[i-1] + dp[i]
print(dp[n])
|
num = int(input())
A = list(map(int, input().split(' ')))
def intersection(A,N):
for i in range(len(A)): #output
if i==len(A)-1:
print(A[i])
else:
print(A[i], end=' ')
for i in range(1,N):
v = A[i]
j = i-1
while j >= 0 and A[j] > v:
A[j+1] = A[j]
j -= 1
A[j+1] = v
for i in range(len(A)):
if i == len(A) - 1: #output
print(A[i])
else:
print(A[i], end=' ')
intersection(A,num)
| 0 | null | 1,363,072,876,490 | 74 | 10 |
a,b = map(int,input().split())
print(a*b if a < 10 and b < 10 else -1)
|
a,b=input().split()
a=int(a)
b=int(b)
if a<10 and b<10:
print(a*b)
else:
print("-1")
| 1 | 158,355,503,382,738 | null | 286 | 286 |
from itertools import accumulate
def solve(string):
n, m, k, *ab = map(int, string.split())
a, b = [0] + ab[:n], [0] + ab[n:]
a, b = list(accumulate(a)), list(accumulate(b))
i, j = n, 0
while a[i] > k:
i -= 1
while j <= m and a[i] + b[j] <= k:
j += 1
ans = i + j - 1
for i in range(i, -1, -1):
while j <= m and a[i] + b[j] <= k:
j += 1
ans = max(ans, i + j - 1)
return str(ans)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
|
n = int(input())
ans = set()
#n-1の約数は確定でOK
for i in range(1,int(pow(n-1,0.5)) + 1):
if (n-1) % i == 0:
ans.add((n-1)//i)
ans.add(i)
#n = (1 + pk) * k^q の形になるkを探す。q ≠ 0のとき、kはnの約数
for i in range(2,int(pow(n,0.5)) + 1):
if n % i == 0:
tmp = n
while tmp % i == 0:
tmp = tmp // i
if (tmp - 1) % i == 0:
ans.add(i)
print(len(ans))
| 0 | null | 25,940,376,324,996 | 117 | 183 |
from collections import deque
def solve(n,t):
q=deque([])
for i in range(n):
l=list(input().split())
q.append(l)
time=0
while not len(q)==0:
x=q.popleft()
if int(x[1])-t>0:
x[1]=str(int(x[1])-t)
time+=t
q.append(x)
else:
print(x[0]+" "+str(time+int(x[1])))
time+=int(x[1])
n,t=map(int,input().split())
solve(n,t)
|
import string
a = raw_input()
b = ""
for i in range(len(a)):
if a[i] in string.ascii_lowercase :
b = b + a[i].upper()
elif a[i] in string.ascii_uppercase :
b = b + a[i].lower()
else :
b = b + a[i]
print b
| 0 | null | 765,092,899,270 | 19 | 61 |
N = int(input())
A = list(map(int, input().split()))
dic = {}
for i in A:
if i not in dic:
dic[i] = 0
dic[i] += 1
print("YES" if max(dic.values()) == 1 else "NO")
|
n,*a=map(int,open(0).read().split())
print('NYOE S'[len(set(a))==n::2])
| 1 | 74,055,204,905,822 | null | 222 | 222 |
def insertion_sort(A, n, g, cnt):
for i in range(g, n):
v = A[i]
j = i - g
while j >= 0 and v < A[j]:
A[j+g] = A[j]
j -= g
cnt += 1
A[j+g] = v
return cnt
def shell_sort(A, n):
cnt = 0
h = 1
g = []
while h <= n:
g.append(h)
h = 3*h + 1
g.reverse()
m = len(g)
for i in range(m):
cnt = insertion_sort(A, n, g[i], cnt)
show(n, m, g, A, cnt)
def show(n, m, G, A, cnt):
print(m)
for i in range(m):
if i != m-1:
print(G[i], end = " ")
else:
print(G[i])
print(cnt)
for i in range(n):
print(A[i])
if "__main__" == __name__:
n = int(input())
data = []
for i in range(n):
data.append(int(input()))
shell_sort(data, n)
|
x = int(input())
for _ in range(x):
print("ACL", end="")
| 0 | null | 1,121,505,913,740 | 17 | 69 |
import random
s = input()
len_s = len(s)
if len_s==3:
num = 0
else:
num = random.randint(0,len_s-4)
name = s[num]+s[num+1]+s[num+2]
print(name)
|
class BalancingTree:
def __init__(self, n):
self.N = n
self.root = self.node(1<<n, 1<<n)
def append(self, v):# v を追加（その時点で v はない前提）
v += 1
nd = self.root
while True:
if v == nd.value:
# v がすでに存在する場合に何か処理が必要ならここに書く
return 0
else:
mi, ma = min(v, nd.value), max(v, nd.value)
if mi < nd.pivot:
nd.value = ma
if nd.left:
nd = nd.left
v = mi
else:
p = nd.pivot
nd.left = self.node(mi, p - (p&-p)//2)
break
else:
nd.value = mi
if nd.right:
nd = nd.right
v = ma
else:
p = nd.pivot
nd.right = self.node(ma, p + (p&-p)//2)
break
def leftmost(self, nd):
if nd.left: return self.leftmost(nd.left)
return nd
def rightmost(self, nd):
if nd.right: return self.rightmost(nd.right)
return nd
def find_l(self, v): # vより真に小さいやつの中での最大値（なければ-1）
v += 1
nd = self.root
prev = 0
if nd.value < v: v = nd.value
while True:
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return prev - 1
else:
prev = nd.value
if nd.right:
nd = nd.right
else:
return prev - 1
def find_r(self, v): # vより真に大きいやつの中での最小値（なければRoot）
v += 1
nd = self.root
prev = 0
while True:
if v < nd.value:
prev = nd.value
if nd.left:
nd = nd.left
else:
return prev - 1
else:
if nd.right:
nd = nd.right
else:
return prev - 1
@property
def max(self):
return self.find_l((1<<self.N)-1)
@property
def min(self):
return self.find_r(-1)
def delete(self, v, nd = None, prev = None): # 値がvのノードがあれば削除（なければ何もしない）
v += 1
if not nd: nd = self.root
if not prev: prev = nd
while v != nd.value:
prev = nd
if v <= nd.value:
if nd.left:
nd = nd.left
else:
return
else:
if nd.right:
nd = nd.right
else:
return
if (not nd.left) and (not nd.right):
if nd.value < prev.value:
prev.left = None
else:
prev.right = None
elif not nd.left:
if nd.value < prev.value:
prev.left = nd.right
else:
prev.right = nd.right
elif not nd.right:
if nd.value < prev.value:
prev.left = nd.left
else:
prev.right = nd.left
else:
nd.value = self.leftmost(nd.right).value
self.delete(nd.value - 1, nd.right, nd)
def __contains__(self, v: int) -> bool:
return self.find_r(v - 1) == v
class node:
def __init__(self, v, p):
self.value = v
self.pivot = p
self.left = None
self.right = None
k = (500000+1).bit_length()
dic = {}
for i in range(97, 123):
dic[chr(i)] = BalancingTree(k)
n = int(input())
s = input()
lst = []
for i in range(n):
lst.append(s[i])
dic[s[i]].append(i)
ans = []
q = int(input())
for _ in range(q):
que = input()
if que[0] == '1':
kind, i, c = que.split()
i = int(i) - 1
dic[lst[i]].delete(i)
dic[c].append(i)
lst[i] = c
else:
kind, l, r = map(int, que.split())
l -= 2; r -= 1
temp = 0
for key in dic.keys():
if dic[key].find_r(l) <= r:
temp += 1
ans.append(temp)
for i in ans:
print(i)
| 0 | null | 38,472,068,846,722 | 130 | 210 |
n = int(raw_input())
N = 100
WHITE = 0
GRAY = 1
BLACK = 2
Color = [WHITE for i in range(n)]
#M = [[0 for i in range(N)] for j in range(N)]
tt = 0
d = [0 for i in range(n)]
f = [0 for i in range(n)]
def dfs_visit(u):
Color[u] = GRAY
global tt
tt += 1
d[u] = tt
for v in range(n):
if M[u][v] == 0:
continue
if Color[v] == WHITE:
dfs_visit(v)
Color[u] = BLACK
tt += 1
f[u] = tt
def dfs():
#Color = [WHITE for i in range(n)]
tt = 0
for u in range(n):
if Color[u] == WHITE:
dfs_visit(u)
for u in range(n):
print "%d %d %d" %(u + 1, d[u], f[u])
M = [[0 for j in range(n)] for i in range(n)]
for i in range(n):
tmp = map(int, raw_input().split())
u = tmp[0]
k = tmp[1]
u -= 1
for j in range(k):
v = tmp[j + 2]
v -= 1
M[u][v] = 1
dfs()
|
# import itertools
# import math
# import sys
# sys.setrecursionlimit(500*500)
# import numpy as np
# N = int(input())
# S = input()
# n, *a = map(int, open(0))
N, K = map(int, input().split())
P = list(map(int, input().split()))
# B = list(map(int, input().split()))
# tree = [[] for _ in range(N + 1)]
# B_C = [list(map(int,input().split())) for _ in range(M)]
# S = input()
# B_C = sorted(B_C, reverse=True, key=lambda x:x[1])
# all_cases = list(itertools.permutations(P))
# a = list(itertools.combinations_with_replacement(range(1, M + 1), N))
# itertools.product((0,1), repeat=n)
# A = np.array(A)
# cum_A = np.cumsum(A)
# cum_A = np.insert(cum_A, 0, 0)
# def dfs(tree, s):
# for l in tree[s]:
# if depth[l[0]] == -1:
# depth[l[0]] = depth[s] + l[1]
# dfs(tree, l[0])
# dfs(tree, 1)
E = [0]
tot = 0
for p in P:
tot += (p + 1) / 2
E.append(tot)
m = 0
for i in range(N - (K - 1)):
_ = E[i + K] - E[i]
if _ > m:
m = _
print(m)
| 0 | null | 37,428,580,127,508 | 8 | 223 |
# -*- coding:utf-8 -*-
def gcd(a,b):
big,small=max(a,b),min(a,b)
while big%small!=0:
big,small=small,big%small
return small
def lcm(a,b):
return int(a*b/gcd(a,b))
def main():
while True:
try:
IN=input()
val=IN.split()
g=gcd(int(val[0]),int(val[1]))
l=lcm(int(val[0]),int(val[1]))
print(g,l)
except:
break
if __name__ == '__main__':
main()
|
import sys
def gcd(m, n):
if n > m:
m, n = n, m
if n == 0:
return m
else:
return gcd(n, m % n)
for line in sys.stdin:
try:
a, b = [int(i) for i in line.split()]
g = gcd(a, b)
l = a * b / g
print("%d %d" % (g, l))
except:
break
| 1 | 608,867,402 | null | 5 | 5 |
N = int(input())
C = list(input())
Rn = C.count('R')
print(C[:Rn].count('W'))
|
n=int(input())
s = input()
Ra = s.count('R')
t = s[:Ra]
Rb = t.count('R')
print(Ra-Rb)
| 1 | 6,320,688,415,550 | null | 98 | 98 |
i = list(map(int,input().split()))
if (i[0] == i[1] and i[0] != i[2]) or (i[0] == i[2] and i[0] != i[1]) or (i[1] == i[2] and i[1] != i[0]):
print("Yes")
else:
print("No")
|
from math import gcd
def main():
ans = 0
k = int(input())
for i in range(1,1+k):
for j in range(1,1+k):
for l in range(1,1+k):
ans += gcd(i,gcd(j,l))
print(ans)
if __name__ == "__main__":
main()
| 0 | null | 51,932,023,546,568 | 216 | 174 |
n, m = map(int, input().split())
c = list(map(int, input().split()))
dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
for i in range(m + 1):
for j in range(n + 1):
if i == 0 and j == 0:
dp[i][j] = 0
elif i == 0:
dp[i][j] = 1000000000
elif j == 0:
dp[i][j] = 0
else:
if j - c[i - 1] >= 0:
dp[i][j] = min(dp[i - 1][j], dp[i][j - c[i - 1]] + 1)
else:
dp[i][j] = dp[i - 1][j]
ans = 10 ** 10
for i in range(m + 1):
ans = min(ans, dp[i][n])
print(ans)
|
N = int(input())
d = list(map(int, input().split()))
sumd = sum(d)
d_2 = sum([i * i for i in d])
print((sumd*sumd-d_2)//2)
| 0 | null | 84,363,088,746,400 | 28 | 292 |
# E - Rotation Matching
n, m = map(int, input().split())
l, r = 1, n
for i in range(m):
if 2 * (r - l) == n or 2 * (r - l + 1) == n:
l += 1
print(l, r)
l, r = l + 1, r - 1
|
N, M = map(int, input().split())
for i in range((M + 1) // 2):
print(i + 1, i + (M - 2 * i) + 1)
for i in range(M - (M + 1) // 2):
print(M + 1 + i + 1, M + 1 + i + (M - 1 - 2 * i) + 1)
| 1 | 28,742,197,433,000 | null | 162 | 162 |
n,t=map(int,input().split())
dp=[[0]*(t+3001)for _ in range(n+1)]
ans=0
ab=[list(map(int,input().split()))for _ in range(n)]
ab.sort()
for i in range(1,n+1):
a,b=ab[i-1]
for j in range(t):
dp[i][j]=max(dp[i-1][j],dp[i][j])
dp[i][j+a]=dp[i-1][j]+b
ans=max(dp[i][j],dp[i][j+a],ans)
print(ans)
|
n=int(input())
arr=list(map(int,input().split()))
c=0
for i in range(0,n,2):
if arr[i]%2!=0:
c+=1
print(c)
| 0 | null | 79,316,943,126,092 | 282 | 105 |
x = float(input())
if 1 >= x >= 0:
if x == 1:
print(0)
elif x == 0:
print(1)
|
# URL : https://atcoder.jp/contests/abc178/tasks/abc178_a
print(int(input()) ^ 1)
| 1 | 2,921,003,625,892 | null | 76 | 76 |
# Problem D - Sum of Divisors
# input
N = int(input())
# initialization
count = 0
# count
for j in range(1, N+1):
M = N // j
count += j * ((M * (M+1)) // 2)
# output
print(count)
|
n, q = map(int , input().split())
queue = []
for _ in range(n):
line = input().split()
queue.append([line[0], int(line[1])])
class my_queue:
def __init__(self, queue):
self.queue = queue
def enqueue(self, item):
self.queue = self.queue + [item]
self.queue.append(item)
def dequeue(self):
if len(self.queue) != 0:
item = self.queue[0]
self.queue = self.queue[1:]
else :
item = None
return item
time = 0
finish_task = []
while(len(queue) != 0):
item = queue.pop(0)
if item == None:
break
elif item[1] <= q:
time += item[1]
finish_task.append([item[0], time])
else :
time += q
queue.append([item[0], item[1] - q])
for item in finish_task:
print(item[0], item[1])
| 0 | null | 5,595,464,728,578 | 118 | 19 |
j = 0
i = 1
k = int(raw_input())
while j < 3:
i *= k
j = j + 1
print i
|
N, K = map(int, input().split())
A = list(map(int, input().split()))
mod = 1000000007
plus = []
minus = []
ans = 1
lp = 0
lm = 0
lz = 0
for k in range(N):
if A[k] > 0:
plus.append(A[k])
lp += 1
elif A[k] < 0:
minus.append(A[k])
lm += 1
else:
lz += 1
plus.sort(reverse = True)
minus.sort()
def main(mp, mm, plus, minus):
mod = 1000000007
ans = 1
for k in range(mp):
ans = ans * plus[k] % mod
for k in range(mm):
ans = ans * minus[k] % mod
print(ans)
exit()
if lz + K > N:
print(0)
exit()
elif lp == 0:
if K % 2 == 1:
if lz > 0:
print(0)
exit()
else:
for k in range(K):
ans = ans * minus[- k - 1] % mod
print(ans)
exit()
else:
main(0, K, plus, minus)
elif lm == 0:
main(K, 0, plus, minus)
p = 0
m = 0
for _ in range(K):
if plus[p] >= -1 * minus[m]:
p += 1
if p == lp:
m = K - p
break
else:
m += 1
if m == lm:
p = K - m
break
if m % 2 == 0:
main(p, m, plus, minus)
else:
if p == lp:
if m != lm:
main(p - 1, m + 1, plus, minus)
else:
if lz > 0:
print(0)
exit()
else:
main(p, m, plus, minus)
elif m == lm:
main(p + 1, m - 1, plus, minus)
elif p == 0:
main(p + 1, m - 1, plus, minus)
else:
if plus[p] * plus[p - 1] > minus[m - 1] * minus[m]:
main(p + 1, m - 1, plus, minus)
else:
main(p - 1, m + 1, plus, minus)
| 0 | null | 4,864,720,330,912 | 35 | 112 |
n = int(input())
a = list(map(int,input().split()))
import sys
lim = [0]*(n+1)
aa = 0
for i in range(n+1):
aa += a[n-i]
lim[n-i] = aa
if n == 0:
if a[0] != 1:
print(-1)
sys.exit()
else:
print(1)
sys.exit()
if a[0] != 0:
print(-1)
sys.exit()
ha = [[0]*(n+1) for i in range(2)]
ha[0][0] = 1
ha[1][0] = 1
for i in range(n):
ha[1][i+1] = min(ha[0][i]*2 , lim[i+1])
ha[0][i+1] = ha[1][i+1] - a[i+1]
if ha[0][i+1] <= 0 and i != n-1:
print(-1)
sys.exit()
if ha[0][i+1] < 0 and i == n-1:
print(-1)
sys.exit()
print(sum(ha[1]))
|
N=int(input())
ans=0
ke=0
for i in range(N):
D,E=map(int,input().split())
if D==E:
ans+=1
else:
ans=0
if ans>=3:
ke=1
if ke==1:
print("Yes")
else:
print("No")
| 0 | null | 10,658,224,410,708 | 141 | 72 |
n = int(input())
a = list(map(int, input().split()))
t1 = 0
t2 = sum(a)
ans = 10**18
for i in a:
t1 += i
t2 -= i
ans = min(ans, abs(t1 - t2))
print(ans)
|
# 168_b
K = int(input())
S = input()
# str.islower()
# >文字列中の大小文字の区別のある文字全てが小文字で、
# >かつ大小文字の区別のある文字が 1 文字以上あるなら True を、そうでなければ False を返します。
if (1 <= K and K <= 100) and S.islower() and (1 <= len(S) and len(S) <= 100):
if len(S)<=K:
print(S)
elif len(S)>K:
print("{}...".format(S[0:K]))
| 0 | null | 80,661,297,977,120 | 276 | 143 |
s = int(input())
if s%1000 == 0:
c=0
else:
c = 1000 - ( s%1000 )
print(c)
|
n = int(input())
x, y = [list(map(float,input().split()))for i in range(2)]
print("%.6f"%sum([abs(x[i]-y[i])for i in range(n)]))
print("%.6f"%pow(sum([abs(x[i]-y[i])**2 for i in range(n)]), 1/2))
print("%.6f"%pow(sum([abs(x[i]-y[i])**3 for i in range(n)]), 1/3))
print(*max([abs(x[i]-y[i])] for i in range(n)))
| 0 | null | 4,298,734,568,480 | 108 | 32 |
n, k, s = map(int, input().split())
ans = [s for _ in range(k)]
if s == 10**9:
others = [1 for _ in range(n-k)]
ans = ans + others
print(' '.join(map(str, ans)))
else:
others = [10**9 for _ in range(n-k)]
ans = ans + others
print(' '.join(map(str, ans)))
|
n,k,s = map(int,input().split())
INF = 10**9
ans = [INF] * n
if s == INF:
ans = [1] * n
for i in range(k):
ans[i] = s
print(*ans)
| 1 | 90,708,445,278,880 | null | 238 | 238 |
import sys
sys.setrecursionlimit(10**6) #再帰関数の上限
import math
from copy import copy, deepcopy
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)の計算量がかかってしまうので注意
#dequeを使うときはpython3を使う、pypyはダメ
from collections import Counter#文字列を個数カウント辞書に、
#S=Counter(l),S.most_common(x),S.keys(),S.values(),S.items()
from itertools import accumulate#累積和
#list(accumulate(l))
from heapq import heapify,heappop,heappush
#heapify(q),heappush(q,a),heappop(q) #q=heapify(q)としないこと、返り値はNone
def input(): return sys.stdin.readline()[:-1]
def printl(li): print(*li, sep="\n")
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
#mod = 10**9+7
#w.sort(key=itemgetter(1),reversed=True) #二個目の要素で降順並び替え
#N = int(input())
#N, K = map(int, input().split())
#L = [int(input()) for i in range(N)]
#A = list(map(int, input().split()))
#S = [list(map(int, input().split())) for i in range(N)]
S=input()
if S[3]==S[2] and S[5]==S[4]:
print('Yes')
exit()
print('No')
|
import collections
N = int(input())
a = list(map(int,input().split()))
c = collections.Counter(a)
if c.most_common()[0][1]==1:
print("YES")
else:
print("NO")
| 0 | null | 58,028,421,136,190 | 184 | 222 |
import itertools
import collections
class PrimeFactorize:
def __init__(self, n):
self.prime_factor_table = self.create_prime_factor_table(n)
# O(NloglogN)
def create_prime_factor_table(self, n):
self.table = [0] * (n + 1)
for i in range(2, n + 1):
if self.table[i] == 0:
for j in range(i + i, n + 1, i):
self.table[j] = i
return self.table
def prime_factor(self, n):
prime_count = collections.Counter()
while self.prime_factor_table[n] != 0:
prime_count[self.prime_factor_table[n]] += 1
n //= self.prime_factor_table[n]
prime_count[n] += 1
return prime_count
N = int(input())
pf = PrimeFactorize(10**5+5)
for i in range(N,10**5+5):
if pf.prime_factor_table[i]==0:
print(i)
break
|
A,B,C,K=map(int,input().split())
print(min(A,K)-max(0,K-A-B))
| 0 | null | 63,420,833,979,480 | 250 | 148 |
a,b,c = map(int, input().split())
t = [a,b,c]
t.sort()
if (t[0] == t[1] and t[1] != t[2]) or (t[0] != t[1] and t[1] == t[2]):
print("Yes")
else:
print("No")
|
from itertools import accumulate
def solve(string):
n, m, k, *ab = map(int, string.split())
a, b = [0] + ab[:n], [0] + ab[n:]
a, b = list(accumulate(a)), list(accumulate(b))
i, j = n, 0
while a[i] > k:
i -= 1
while j <= m and a[i] + b[j] <= k:
j += 1
ans = i + j - 1
for i in range(i, -1, -1):
while j <= m and a[i] + b[j] <= k:
j += 1
ans = max(ans, i + j - 1)
return str(ans)
if __name__ == '__main__':
import sys
print(solve(sys.stdin.read().strip()))
| 0 | null | 39,317,428,279,500 | 216 | 117 |
word = input()
num = int(input())
for index in range(num):
code = input().split()
instruction = code[0]
start, end = int(code[1]), int(code[2])
if instruction == "replace":
word = word[:start] + code[3] + word[end+1:]
elif instruction == "reverse":
reversed_ch = "".join(reversed(word[start:end+1]))
word = word[:start] + reversed_ch + word[end+1:]
else:
print(word[start:end+1])
|
import itertools
def abc167c_skill_up():
n, m, x = map(int, input().split())
c = []
a = []
for _ in range(n):
v = list(map(int, input().split()))
c.append(v[0])
a.append(v[1:])
pattern = itertools.product([0,1], repeat=n)
best = float('inf')
for p in pattern:
cost = 0
skill = [0] * m
for i, v in enumerate(p):
if v == 1:
cost += c[i]
if cost > best: break
check = True
for j in range(m):
skill[j] += a[i][j]
if skill[j] < x:
check = False
if check:
best = cost
break
if best == float('inf'):
print('-1')
else:
print(best)
abc167c_skill_up()
| 0 | null | 12,058,118,799,402 | 68 | 149 |
from collections import deque
N,K = map(int,input().split())
A = [int(i) for i in input().split()]
B = deque(A[:K])
for i in range(K,N):
if B.popleft() < A[i]:
print('Yes')
else:
print('No')
B.append(A[i])
|
s=input()
t=input()
ans=int(len(s))
for i in range(len(s)-len(t)+1):
now=int(0)
for j in range(len(t)):
if s[i+j]!=t[j]:
now+=1
ans=min(now,ans)
print(ans)
| 0 | null | 5,420,011,459,388 | 102 | 82 |
X, Y = map(int, input().split())
for i in range(X + 1):
tsuru = i
kame = X - i
if tsuru * 2 + kame * 4 == Y:
print('Yes')
exit()
print('No')
|
import math
import numpy as np
import sys
import os
from operator import mul
sys.setrecursionlimit(10**7)
def _S(): return sys.stdin.readline().rstrip()
def I(): return int(_S())
def LS(): return list(_S().split())
def LI(): return list(map(int,LS()))
if os.getenv("LOCAL"):
inputFile = basename_without_ext = os.path.splitext(os.path.basename(__file__))[0]+'.txt'
sys.stdin = open(inputFile, "r")
INF = float("inf")
IINF = 10 ** 18
MOD = 10 ** 9 + 7
# MOD = 998244353
X = I()
for a in range(1,120):
for b in range(-119,119):
if a**5-b**5==X:
print(a,b)
exit()
| 0 | null | 19,667,992,515,200 | 127 | 156 |
import sys
read = sys.stdin.read
def main():
h, n = map(int, input().split())
m = map(int, read().split())
mm = zip(m, m)
large_num = 10**9
dp = [large_num] * (h + 10**4 + 1)
dp[0] = 0
for a, b in mm:
for i1 in range(h + 1):
if dp[i1 + a] > dp[i1] + b:
dp[i1 + a] = dp[i1] + b
r = min(dp[h:])
print(r)
if __name__ == '__main__':
main()
|
from collections import deque
h,n = map(int,input().split())
ab = []
for i in range(n):
a,b = map(int,input().split())
ab.append([a,b])
ab.sort(key=lambda x: x[0]/x[1], reverse=True)
if h==9999 and n==10:
print(139815)
exit()
#bubble sort
#for i in range(n-1,-1,-1):
# for j in range(0,i):
# if ab[j][0]*ab[j+1][1]<ab[j+1][0]*ab[j][1]:
# tmp = ab[j]
# ab[j] = ab[j+1]
# ab[j+1] = tmp
ans = 0
ansk = float('inf')
def indexH(h,arr):
li = []
for i in range(len(arr)):
if arr[i][0]>=h:
li.append(i)
return li[::-1]
def indexH2(h,arr):
d = deque()
while 1:
if len(ab)==0:
break
maxa = max(ab, key=lambda x:x[0])[0]
if maxa<h:
k = ab[0]
x = (h-maxa)//k[0]
l = max(x,1)
h-=k[0]*l
ans+=k[1]*l
#print(h,ans)
else:
c = 0
index = indexH(h,ab)
#print(h,index,ab,ab)
for i in range(len(index)):
ansk = min(ansk,ans+ab[index[i]][1])
ab.pop(index[i])
print(ansk)
| 1 | 80,954,965,076,580 | null | 229 | 229 |
n = input()
l = [int(i) for i in input().split()]
print(' '.join([str(min(l)),str(max(l)),str(sum(l))]))
|
class BIT:
def __init__(self, n):
self.node = [ 0 for _ in range(n+1) ]
def add(self, idx, w):
i = idx
while i < len(self.node) - 1:
self.node[i] += w
i |= (i + 1)
def sum_(self, idx):
ret, i = 0, idx-1
while i >= 0:
ret += self.node[i]
i = (i & (i + 1)) - 1
return ret
def sum(self, l, r):
return self.sum_(r) - self.sum_(l)
n = int(input())
s = list(input())
q = int(input())
tree = [ BIT(n) for _ in range(26) ]
for i in range(n):
tree_id = ord(s[i]) - ord("a")
tree[tree_id].add(i, 1)
for _ in range(q):
query = input().split()
com = int(query[0])
if com == 1:
idx, new_char = int(query[1]), query[2]
idx -= 1
old_char = s[idx]
new_id = ord(new_char) - ord("a")
old_id = ord(old_char) - ord("a")
tree[old_id].add(idx, -1)
tree[new_id].add(idx, 1)
s[idx] = new_char
if com == 2:
l, r = int(query[1]), int(query[2])
ret = 0
for c in range(26):
if tree[c].sum(l-1, r) > 0:
ret += 1
print(ret)
| 0 | null | 31,621,306,785,350 | 48 | 210 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.