input
stringlengths 20
127k
| target
stringlengths 20
119k
| problem_id
stringlengths 6
6
|
|---|---|---|
N,M=list(map(int,input().split()))
X = [[] for i in range(8)]
for i in range(N):
x,y,z=list(map(int,input().split()))
for i in range(8):
X[i].append(int(2*((i%2)-1/2))*x + int(2*(((i//2)%2)-1/2))*y + int(2*(((i//4)%2)-1/2))*z)
ans=0
for i in range(8):
X[i].sort()
X[i]=X[i][::-1]
ans=max(sum(X[i][:M]),ans)
print(ans)
|
N,M = list(map(int,input().split()))
X = []
for i in range(N):
x,y,z = list(map(int,input().split()))
X.append([x,y,z])
max_score = 0
for i in range(8):
a = i%2
j = i//2
b = j%2
k = j//2
c = k%2
a,b,c = 2*a-1,2*b-1,2*c-1
Z = []
for j in range(N):
Z.append(a*X[j][0]+b*X[j][1]+c*X[j][2])
Z.sort(reverse=True)
max_score = max(sum(Z[:M]),max_score)
print(max_score)
|
p03326
|
from itertools import product
n, m = list(map(int, input().split()))
xyz = [tuple(map(int, input().split())) for _ in range(n)]
ans = 0
for subset in product((-1, 1), repeat=3):
INF = 10**18
dp = [-INF]*(n+1)
dp[0] = 0
def func(xyz):
return sum(x*a for x, a in zip(xyz, subset))
values = list(map(func, xyz))
for i, val in enumerate(values, 1):
for j in reversed(list(range(1, i+1))):
dp[j] = max(dp[j-1]+val, dp[j])
if ans < dp[m]:
ans = dp[m]
print(ans)
|
from itertools import product
n, m = list(map(int, input().split()))
xyz = [tuple(map(int, input().split()))for _ in range(n)]
ans = 0
for subset in product((-1, 1), repeat=3):
def func(xyz):
return sum(x*a for x, a in zip(xyz, subset))
score = sum(sorted(map(func, xyz), reverse=True)[:m])
if ans < score:
ans = score
print(ans)
|
p03326
|
n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1,1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = [0]*(m+1)
for l, (x, y, z) in enumerate(v):
x *= sx
y *= sy
z *= sz
score = x+y+z
for h in range(min(m,l+1),0,-1):
if l < m and h == min(m,l+1):
dp[h] = dp[h-1]+score
else:
dp[h] = max(dp[h], dp[h-1]+score)
ans = max(ans, dp[-1])
print(ans)
|
n, m = list(map(int, input().split()))
v = [list(map(int, input().split())) for i in range(n)]
ans = 0
op = [-1,1]
for i in range(2):
for j in range(2):
for k in range(2):
sx, sy, sz = op[i], op[j], op[k]
dp = [-float("inf")]*(m+1)
dp[0] = 0
for l, (x, y, z) in enumerate(v):
x *= sx
y *= sy
z *= sz
score = x+y+z
for h in range(min(m,l+1),0,-1):
dp[h] = max(dp[h], dp[h-1]+score)
ans = max(ans, dp[-1])
print(ans)
|
p03326
|
from itertools import product
n,m = list(map(int, input().split()))
# dp[i][j] i個取った時の{+,-}*3 タイプの最大値
dp = [[0]*8 for i in range(m+1)]
op = [i for i in product([-1,1], repeat=3)]
#print(op)
for i in range(n):
x,y,z = list(map(int, input().split()))
nxt = [[0]*8 for i in range(m+1)]
for j in range(m):
for k in range(8):
nxt[j+1][k] = max(dp[j+1][k], dp[j][k] + op[k][0]*x+op[k][1]*y+op[k][2]*z)
dp = nxt
print((max(dp[-1])))
|
from itertools import product
n,m = list(map(int, input().split()))
a = [list(map(int, input().split())) for i in range(n)]
ans = 0
for i, j, k in product([-1,1], repeat=3):
ans = max(ans, sum(sorted(i*x+j*y+k*z for x,y,z in a)[::-1][:m]))
print(ans)
|
p03326
|
n,m=list(map(int,input().split()))
xyz=[list(map(int,input().split())) for i in range(n)]
lst=[]
for i in range(8):
if i&1==1:
a=1
else:
a=-1
if (i>>1)&1==1:
b=1
else:
b=-1
if (i>>2)&1==1:
c=1
else:
c=-1
h=[0]
for u in xyz:
x,y,z=u
h.append(a*x+b*y+c*z)
lst.append(h)
ans=0
for u in lst:
dp=[[0]*(m+1) for i in range(n+1)]
for i in range(1,n+1):
d=u[i]
for j in range(1,m+1):
dp[i][j]=max(dp[i-1][j],dp[i-1][j-1]+d)
ans=max(ans,dp[n][m])
print(ans)
|
n,m=list(map(int,input().split()))
xyz=[list(map(int,input().split())) for i in range(n)]
lst=[]
for i in range(8):
if i&1==1:
a=1
else:
a=-1
if (i>>1)&1==1:
b=1
else:
b=-1
if (i>>2)&1==1:
c=1
else:
c=-1
h=[]
for u in xyz:
x,y,z=u
h.append(a*x+b*y+c*z)
lst.append(h)
ans=0
for u in lst:
u.sort(reverse=True)
e=0
for i in range(m):
e+=u[i]
ans=max(ans,e)
print(ans)
|
p03326
|
N,M = list(map(int,input().split()))
xyz = []
for i in range(N):
x,y,z = list(map(int,input().split()))
xyz.append([x,y,z])
ans = -1 * float("inf")
for bpm in range(2):
for dpm in range(2):
for fpm in range(2):
if bpm == 0:
bpm = -1
if dpm == 0:
dpm = -1
if fpm == 0:
fpm = -1
lis = [0] * (M+1)
nlis = [0] * (M+1)
for i in range(N):
now = xyz[i][0] * bpm + xyz[i][1] * dpm + xyz[i][2] * fpm
for j in range(M):
if j == 0 or lis[j] != 0:
nlis[j+1] = max(nlis[j+1],lis[j] + now)
lis = nlis.copy()
ans = max(ans,lis[M])
print (ans)
|
N,M = list(map(int,input().split()))
xyz = []
for i in range(N):
x,y,z = list(map(int,input().split()))
xyz.append([x,y,z])
ans = -1 * float("inf")
for bpm in range(2):
for dpm in range(2):
for fpm in range(2):
if bpm == 0:
bpm = -1
if dpm == 0:
dpm = -1
if fpm == 0:
fpm = -1
lis = []
for i in xyz:
lis.append(i[0] * bpm + i[1] * dpm + i[2] * fpm)
lis.sort()
lis.reverse()
now = 0
for j in range(M):
now += lis[j]
ans = max(ans,now)
print (ans)
|
p03326
|
N, M = list(map(int,input().split()))
max = -float('inf')
x = []
y = []
z = []
for i in range(N):
xx,yy,zz = list(map(int,input().split()))
x.append(xx)
y.append(yy)
z.append(zz)
for i in range(-1,2,2):
for j in range(-1,2,2):
for k in range(-1,2,2):
s = []
for m in range(N):
s.append(i*x[m]+j*y[m]+k*z[m])
s = sorted(s)
tmp = sum(s[-1*M:])
if tmp > max:
max = tmp
if M==0:
print((0))
else:
print(max)
|
n,m = list(map(int,input().split()))
xyz = [list(map(int,input().split())) for _ in range(n)]
res = 0
for a in (1,-1):
for b in (1,-1):
for c in (1,-1):
l = []
for (x,y,z) in xyz:
l.append(x*a+y*b+z*c)
l = sorted(l,reverse=True)
res = max(res, sum(l[:m]))
print(res)
|
p03326
|
# D Patisserie
N,M=list(map(int,input().split()))
check=M+10 if M+10<=N else N
xyz_list,x_list,y_list,z_list=[],[],[],[]
for i in range(N):
xyz_list.append(input().split())
for i in range(N):
x_list.append([int(xyz_list[i][0]),i+1])
y_list.append([int(xyz_list[i][1]),i+1])
z_list.append([int(xyz_list[i][2]),i+1])
x_listn=x_list[:]
y_listn=y_list[:]
z_listn=z_list[:]
import itertools as itl
conb=[]
for i in range(check):
conb.append(i)
conb=[x for x in itl.combinations(conb,M)]
sum_max=0
x_list.sort()
for l in range(2):
for j in range(len(conb)):
sum_x,sum_y,sum_z=0,0,0
for k in conb[j]:
num_comb=x_list[k][1]-1
sum_x+=x_listn[num_comb][0]
sum_y+=y_listn[num_comb][0]
sum_z+=z_listn[num_comb][0]
sum_xyz=abs(sum_x)+abs(sum_y)+abs(sum_z)
if sum_xyz>sum_max:sum_max=sum_xyz
x_list=x_list[::-1]
y_list.sort()
for l in range(2):
for j in range(len(conb)):
sum_x,sum_y,sum_z=0,0,0
for k in conb[j]:
num_comb=y_list[k][1]-1
sum_x+=x_listn[num_comb][0]
sum_y+=y_listn[num_comb][0]
sum_z+=z_listn[num_comb][0]
sum_xyz=abs(sum_x)+abs(sum_y)+abs(sum_z)
if sum_xyz>sum_max:sum_max=sum_xyz
y_list=y_list[::-1]
z_list.sort()
for l in range(2):
for j in range(len(conb)):
sum_x,sum_y,sum_z=0,0,0
for k in conb[j]:
num_comb=z_list[k][1]-1
sum_x+=x_listn[num_comb][0]
sum_y+=y_listn[num_comb][0]
sum_z+=z_listn[num_comb][0]
sum_xyz=abs(sum_x)+abs(sum_y)+abs(sum_z)
if sum_xyz>sum_max:sum_max=sum_xyz
z_list=z_list[::-1]
print(sum_max)
|
# D Patisserie
import itertools as itl
#入力を取得
N,M=list(map(int,input().split()))
check=M+10 if M+10<=N else N
xyz_list,x_list,y_list,z_list=[],[],[],[]
for i in range(N):
xyz_list.append(input().split())
var_list=[x for x in itl.product([-1,1],repeat=3)]
sum_list=[]
for i in var_list:
sort_list=[0,]*N
for j in range(N):
sort_list[j]=int(xyz_list[j][0])*i[0]+ int(xyz_list[j][1])*i[1]+ int(xyz_list[j][2])*i[2]
sort_list.sort(reverse=True)
sum_=0
for j in range(M):
sum_+=sort_list[j]
sum_list.append(sum_)
sum_list.sort(reverse=True)
print((sum_list[0]))
|
p03326
|
import itertools
N, M = list(map(int, input().split()))
xyz = list()
for n in range(N):
xyz.append([int(x) for x in input().split()])
ans = 0
for x in itertools.combinations(list(range(N)), M):
tmp = [0,0,0]
for m in x:
for y in range(3):
tmp[y] += xyz[m][y]
ans = max(ans, sum([abs(x) for x in tmp]))
print(ans)
|
import itertools
N, M = list(map(int, input().split()))
xyz = list()
for n in range(N):
xyz.append([int(x) for x in input().split()])
ans = 0
for a,b,c in itertools.product([-1,1], repeat=3):
tmp = []
for x, y, z in xyz:
tmp.append(a*x+b*y+c*z)
tmp.sort(reverse=True)
ans = max(ans, sum(tmp[:M]))
print(ans)
|
p03326
|
import itertools
n,m = list(map(int,input().split()))
a = []
for i in range(n):
a.append(list(map(int,input().split())))
ans = 0
b = []
for i in itertools.combinations(a,m):
i0 = 0
i1 = 0
i2 = 0
for j in i:
i0 += j[0]
i1 += j[1]
i2 += j[2]
ans = max(ans,abs(i0)+abs(i1)+abs(i2))
print(ans)
|
n,m = list(map(int,input().split()))
a = []
b = []
c = []
d = []
e = []
f = []
g = []
h = []
for i in range(n):
j = list(map(int,input().split()))
a.append(j[0]+j[1]+j[2])
b.append(-j[0]+j[1]+j[2])
c.append(j[0]-j[1]+j[2])
d.append(j[0]+j[1]-j[2])
e.append(-j[0]-j[1]+j[2])
f.append(-j[0]+j[1]-j[2])
g.append(j[0]-j[1]-j[2])
h.append(-j[0]-j[1]-j[2])
a.sort()
a.reverse()
b.sort()
b.reverse()
c.sort()
c.reverse()
d.sort()
d.reverse()
e.sort()
e.reverse()
f.sort()
f.reverse()
g.sort()
g.reverse()
h.sort()
h.reverse()
print((max(sum(a[:m]),sum(b[:m]),sum(c[:m]),sum(d[:m]),sum(e[:m]),sum(f[:m]),sum(g[:m]),sum(h[:m]))))
|
p03326
|
import itertools
def main():
N, M = list(map(int, input().split(' ')))
cakes = [list(map(int, input().split(' '))) for _ in range(N)]
ans = 0
for sign in itertools.product([-1, 1], repeat=3):
dp = [[0 for _ in range(M + 1)] for _ in range(N + 1)]
for n in range(N):
cake_score = sum([s * c for s, c in zip(sign, cakes[n])])
for m in range(M + 1):
if m - 1 >= 0:
dp[n + 1][m] = max([dp[n][m], dp[n][m - 1] + cake_score])
else:
dp[n + 1][m] = dp[n][m]
ans = max([ans, dp[N][M]])
print(ans)
if __name__ == '__main__':
main()
|
import itertools
def main():
N, M = list(map(int, input().split(' ')))
cakes = [list(map(int, input().split(' '))) for _ in range(N)]
ans = 0
for sign in itertools.product([-1, 1], repeat=3):
scores = [sum([s * c for s, c in zip(sign, cake)]) for cake in cakes]
scores.sort(reverse=True)
ans = max([ans, sum(scores[:M])])
print(ans)
if __name__ == '__main__':
main()
|
p03326
|
n,m=list(map(int,input().split()))
box=list(list(map(int,input().split())) for i in range(n))
ans = 0
for i in (1,-1):
for j in (1,-1):
for k in (1,-1):
cost=list(i*x+j*y+z*k for x,y,z in box)
cost.sort(reverse=True)
ans=max(ans,sum(cost[:m]))
print(ans)
|
n,m=list(map(int,input().split()))
XYZ=[list(map(int,input().split())) for _ in range(n)]
ans=0
for i in (-1,1):
for j in (-1,1):
for k in (-1,1):
cost=list(i*x+j*y+z*k for x,y,z in XYZ)
cost.sort(reverse=True)
ans=max(ans,sum(cost[:m]))
print(ans)
|
p03326
|
import itertools
N,M=[int(i) for i in input().split(" ")]
cake=[]
for i in range(N):
x,y,z=[int(j) for j in input().split(" ")]
cake.append([x,y,z])
_num=[i for i in range(N)]
num=list(itertools.combinations(_num,M))
result=0
for i in num:
delicious=0
beautiful=0
popular=0
for j in i:
delicious+=cake[j][0]
beautiful+=cake[j][1]
popular+=cake[j][2]
result=max(abs(delicious)+abs(beautiful)+abs(popular),result)
print(result)
|
N,M=[int(i) for i in input().split(" ")]
cake1=[]
cake2=[]
cake3=[]
cake4=[]
cake5=[]
cake6=[]
cake7=[]
cake8=[]
for i in range(N):
x,y,z=[int(j) for j in input().split(" ")]
cake1.append(x+y+z)
cake2.append(-x+y+z)
cake3.append(x-y+z)
cake4.append(x+y-z)
cake5.append(-x-y+z)
cake6.append(-x+y-z)
cake7.append(x-y-z)
cake8.append(-x-y-z)
cake1=sorted(cake1)[::-1]
cake2=sorted(cake2)[::-1]
cake3=sorted(cake3)[::-1]
cake4=sorted(cake4)[::-1]
cake5=sorted(cake5)[::-1]
cake6=sorted(cake6)[::-1]
cake7=sorted(cake7)[::-1]
cake8=sorted(cake8)[::-1]
print((max(sum(cake1[:M:]),sum(cake2[:M:]),sum(cake3[:M:]),sum(cake4[:M:]),sum(cake5[:M:]),sum(cake6[:M:]),sum(cake7[:M:]),sum(cake8[:M:]))))
|
p03326
|
n, m = list(map(int, input().split()))
A = [[int(i) for i in input().split()] for i in range(n)]
B = []
def pm(n):
if n % 2 == 0:
return 1
else:
return -1
for i in range(8):
temp = sorted([pm(i//4) * x + pm(i//2) * y + pm(i) * z for x, y, z in A], reverse=True)
B.append(sum(temp[:m]))
print((max(B)))
|
n, m = list(map(int, input().split()))
A = [[int(i) for i in input().split()] for i in range(n)]
B = []
def f(x):
if x % 2 == 0:
return 1
else:
return -1
for i in range(8):
temp = sorted([f(i // 4) * x + f(i // 2) * y + f(i) * z for x, y, z in A], reverse=True)
B.append(sum(temp[:m]))
print((max(B)))
|
p03326
|
N, M = list(map(int, input().split()))
A = [[int(i) for i in input().split()] for i in range(N)]
ans = 0
for i in range(1 << 3):
x = bin(i)[2:]
while len(x) < 3:
x = '0' + x
op = ''
for j in x:
if j == '1':
op += '+'
else:
op += '-'
B = []
for j in range(N):
B.append(eval(op[0] + str(A[j][0]) + op[1] + str(A[j][1]) + op[2] + str(A[j][2])))
B.sort(reverse = True)
ans = max(ans, sum(B[:M]))
print(ans)
|
N, M = list(map(int, input().split()))
A = [[int(i) for i in input().split()] for i in range(N)]
def f(x):
if x == 1:
return 1
else:
return -1
ans = 0
for i in range(1 << 3):
B = []
for x, y, z in A:
B.append(f((i >> 2) & 1) * x + f((i >> 1) & 1) * y + f(i & 1) * z)
B.sort(reverse = True)
ans = max(ans, sum(B[:M]))
print(ans)
|
p03326
|
import itertools
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(N)]
note = []
for x,y,z in info:
X = [x,-x]; Y = [y,-y]; Z = [z,-z]
tmp = []
for c in itertools.product(X,Y,Z):
tmp.append(sum(c))
note.append(tmp)
ans = -float('inf')
for j in range(8):
res = []
for i in range(N):
res.append(note[i][j])
res = sorted(res,reverse=True)
value = sum(res[:M])
if value > ans:
ans = value
print(ans)
|
import itertools
N,M = list(map(int,input().split()))
info = [list(map(int,input().split())) for i in range(N)]
ans = -float('inf')
for i,j,k in itertools.product([1,-1],repeat=3):
tmp = []
for x,y,z in info:
value = x*i + y*j + z*k
tmp.append(value)
tmp.sort(reverse=True)
res = sum(tmp[:M])
if res > ans:
ans = res
print(ans)
|
p03326
|
import itertools
import heapq
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
ans = 0
c = [0,1]
for l,j,k in itertools.product(c,repeat=3):
ans = max(ans,sum(heapq.nlargest(m,([a[i][0]*(-1)**l+a[i][1]*(-1)**j+a[i][2]*(-1)**k for i in range(n)]))))
print(ans)
|
from itertools import product as p
n,m = [int(i) for i in input().split()]
a = [[int(i) for i in input().split()] for j in range(n)]
c = [1,-1]
ans = 0
for l,j,k in p(c,repeat=3):
ans = max(ans,sum(sorted([a[i][0]*l+a[i][1]*j+a[i][2]*k for i in range(n)])[n-m:]))
print(ans)
|
p03326
|
# https://abc100.contest.atcoder.jp/tasks/abc100_d
# D - Patisserie ABC
# D_Patisserie_ABC.py
import collections
N, M = list(map(int, input().strip().split(" ")))
A = [[] for i in range(8)]
for n in range(N):
# 「綺麗さ」「おいしさ」「人気度」
x, y, z = list(map(int, input().strip().split(" ")))
A[0].append(x+y+z)
A[1].append(-x+y+z)
A[2].append(x-y+z)
A[3].append(x+y-z)
A[4].append(x-y-z)
A[5].append(-x+y-z)
A[6].append(-x-y+z)
A[7].append(-x-y-z)
T = []
for i in range(8):
A[i].sort()
total = 0
for _ in range(M):
total += A[i].pop()
T.append(total)
T.sort()
print((T[-1]))
|
# https://abc100.contest.atcoder.jp/tasks/abc100_d
# D - Patisserie ABC
# D_Patisserie_ABC.py
#import collections
N, M = list(map(int, input().strip().split(" ")))
A = [[] for i in range(8)]
for n in range(N):
# 「綺麗さ」「おいしさ」「人気度」
x, y, z = list(map(int, input().strip().split(" ")))
A[0].append(x+y+z)
A[1].append(-x+y+z)
A[2].append(x-y+z)
A[3].append(x+y-z)
A[4].append(x-y-z)
A[5].append(-x+y-z)
A[6].append(-x-y+z)
A[7].append(-x-y-z)
T = []
for i in range(8):
A[i].sort()
total = 0
for _ in range(M):
total += A[i].pop()
T.append(total)
T.sort()
print((T[-1]))
|
p03326
|
import re
for i in range(int(eval(input()))):
s=input().replace(" ","")
print((''.join(re.sub(r'0\w','',''.join([i+j for(i,j)in zip(str(10000+eval('+'.join([i[0]+{'m':'*1000','c':'*100','x':'*10','i':''}[i[1]]for i in ['1'+i for i in''.join(re.split(r'\d\w',s))]+re.findall(r'\d\w',s)])))[1:],list('mcxi'))])).split('1'))))
|
import re
for i in range(int(eval(input()))):
s=input().replace(" ","")
print((re.sub(r'0.','',''.join([i+j for(i,j)in zip(str(10000+eval('+'.join([i[0]+{'m':'*1000','c':'*100','x':'*10','i':''}[i[1]]for i in ['1'+i for i in''.join(re.split(r'\d\w',s))]+re.findall(r'\d\w',s)])))[1:],list('mcxi'))]).replace('1',''))))
|
p00718
|
import math
r = float(eval(input()))
s = r*r*math.pi
v = 2*math.pi*r
print(("{:f} {:f}".format(s, v)))
|
import math
r = float(eval(input()))
s = r**2*math.pi
v = 2*math.pi*r
print(("{:f} {:f}".format(s, v)))
|
p02400
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
s = LS2()
print((s[0]+str(len(s)-2)+s[-1]))
|
import sys
def LS2():
return list(sys.stdin.readline().rstrip()) #空白なし
s = LS2()
print((s[0]+str(len(s)-2)+s[-1]))
|
p03636
|
from sys import stdin
s = stdin.readline().rstrip()
print((''.join([s[0], str(len(s) - 2), s[-1]])))
|
import sys
s = sys.stdin.readline().rstrip()
l = len(s)
def main():
return s[0] + str(l-2) + s[-1]
if __name__ == '__main__':
ans = main()
print(ans)
|
p03636
|
from itertools import accumulate
import sys
sys.setrecursionlimit(10**8)
class BIT():
def __init__(self,number):
self.n=number
self.list=[0]*(number+1)
def add(self,i,x):#ith added x 1indexed
while i<=self.n:
self.list[i]+=x
i+=i&-i
def search(self,i):#1-i sum
s=0
while i>0:
s+=self.list[i]
i-=i&-i
return s
def suma(self,i,j):#i,i+1,..j sum
return self.search(j)-self.search(i-1)
N,K=list(map(int,input().split()))
A=[int(eval(input())) for i in range(N)]
B=list(accumulate([0]+A))
for i in range(N+1):
B[i]-=K*i
C=sorted((B[i],i) for i in range(N+1))
D=[-1]*(N+1)
D[C[0][1]]=0
s=C[0][0]
t=0
for i in range(1,N+1):
if s<C[i][0]:
s=C[i][0]
t+=1
D[C[i][1]]=t
else:
D[C[i][1]]=t
tree=BIT(t+1)
ans=0
for i in range(N+1):
ans+=tree.search(D[i]+1)
tree.add(D[i]+1,1)
print(ans)
|
from itertools import accumulate
import sys
sys.setrecursionlimit(10**8)
class BIT():
def __init__(self,number):
self.n=number
self.list=[0]*(number+1)
def add(self,i,x):#ith added x 1indexed
while i<=self.n:
self.list[i]+=x
i+=i&-i
def search(self,i):#1-i sum
s=0
while i>0:
s+=self.list[i]
i-=i&-i
return s
def suma(self,i,j):#i,i+1,..j sum
return self.search(j)-self.search(i-1)
N,K=list(map(int,input().split()))
A=[int(eval(input())) for i in range(N)]
B=list(accumulate([0]+A))
for i in range(N+1):
B[i]-=K*i
C=sorted(set(B))
t=len(C)
D={ C[i]:i for i in range(t)}
tree=BIT(t)
ans=0
for i in range(N+1):
ans+=tree.search(D[B[i]]+1)
tree.add(D[B[i]]+1,1)
print(ans)
|
p03703
|
from itertools import accumulate
from bisect import bisect_right
N, K = list(map(int, input().split()))
A = [0] + [int(eval(input())) for i in range(N)]
diff = [a - K for a in A]
diff = list(accumulate(diff))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N + 1)
temp = sorted(diff)
order = [bisect_right(temp, d) for d in diff]
ans = 0
for x in order:
ans += BIT.sum(x)
BIT.add(x, 1)
print(ans)
|
from itertools import accumulate
from bisect import bisect_right
N, K = list(map(int, input().split()))
A = [3] + [int(eval(input())) for i in range(N)]
diff = [a - K for a in A]
diff = list(accumulate(diff))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N + 1)
temp = sorted(diff)
order = [bisect_right(temp, d) for d in diff]
ans = 0
for x in order:
ans += BIT.sum(x)
BIT.add(x, 1)
print(ans)
|
p03703
|
from itertools import accumulate
from bisect import bisect_right
N, K = list(map(int, input().split()))
A = [3] + [int(eval(input())) for i in range(N)]
diff = [a - K for a in A]
diff = list(accumulate(diff))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N + 1)
temp = sorted(diff)
order = [bisect_right(temp, d) for d in diff]
ans = 0
for x in order:
ans += BIT.sum(x)
BIT.add(x, 1)
print(ans)
|
from itertools import accumulate
from bisect import bisect_right
N, K = list(map(int, input().split()))
A = [-19] + [int(eval(input())) for i in range(N)]
diff = [a - K for a in A]
diff = list(accumulate(diff))
class BinaryIndexedTree:
def __init__(self, n):
self.size = n
self.bit = [0] * (n + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.bit[i]
i -= (i & -i)
return s
def add(self, i, x):
while i <= self.size:
self.bit[i] += x
i += (i & -i)
def reset(self):
self.bit = [0] * (self.size + 1)
BIT = BinaryIndexedTree(N + 1)
temp = sorted(diff)
order = [bisect_right(temp, d) for d in diff]
ans = 0
for x in order:
ans += BIT.sum(x)
BIT.add(x, 1)
print(ans)
|
p03703
|
N, K = list(map(int, input().split()))
A = [int(eval(input())) for _ in range(N)]
B = [0] * (N + 1)
B[1] = A[0] - K
for i in range(1, N):
A[i] += A[i - 1]
B[i + 1] = A[i] - K * (i + 1)
tmp = sorted(B)
dic = dict()
for index, x in enumerate(tmp):
dic[x] = index
N = len(B)
bit = [0] * (N + 1)
def total(i):
s = 0
while i > 0:
s += bit[i]
i -= i & -i
return s
def add(i, x):
while i <= N:
bit[i] += x
i += i & -i
return
ans = 0
for b in B:
# print (b)
n = dic[b]
ans += total(n + 1)
# print (b, ans)
# print ()
add(n + 1, 1)
print (ans)
# print (B)
# print (dic)
# print (bit)
|
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10 ** 9)
MOD = 10 ** 9 + 7
N, K = list(map(int, input().split()))
A = [0] + [int(eval(input())) - K for _ in range(N)]
# print (A)
for i in range(N):
A[i + 1] += A[i]
B = sorted(A)
dic = dict()
for i, b in enumerate(B):
dic[b] = i + 1
N += 1
bit = [0] * (N + 1)
def total(i):
s = 0
while i > 0:
s += bit[i]
i -= i & -i
return s
def add(i, x):
while i <= N:
bit[i] += x
i += i & -i
return
ans = 0
for a in A:
b = dic[a]
ans += total(b)
# print ('tmp')
add(b, 1)
print (ans)
# print (A)
# print (dic)
|
p03703
|
class BIT():
def __init__(self,size):
self.size=size
self.node=[0]*(size+1)
def sum(self,idx):
ret=0
while idx>0:
ret+=self.node[idx]
idx-=idx&(-idx)
return ret
def add(self,idx,x):
while idx<=self.size:
self.node[idx]+=x
idx+=idx&(-idx)
n,k=list(map(int,input().split()))
a=[int(input()) for _ in range(n)]
diff=[]
for i in range(n):
diff.append(a[i]-k)
for i in range(n-1):
diff[i+1]+=diff[i]
bit=BIT(n)
s=set([])
for i in range(n):
bit.add(i+1,1)
s.add(diff[i])
li=list(s)
li.sort()
d={}
for i in range(len(li)):
d[li[i]]=i
pos=[[] for _ in range(len(li))]
for i in range(n):
idx=d[diff[i]]
pos[idx].append(i+1)
ans=0
for i in range(len(li)):
for j in pos[i]:
ans+=bit.sum(n)-bit.sum(j)
if diff[j-1]>=0:
ans+=1
bit.add(j,-1)
print(ans)
|
class BIT():
def __init__(self,size):
self.size=size
self.node=[0]*(size+1)
def sum(self,idx):
ret=0
while idx>0:
ret+=self.node[idx]
idx-=idx&(-idx)
return ret
def add(self,idx,x):
while idx<=self.size:
self.node[idx]+=x
idx+=idx&(-idx)
n,k=list(map(int,input().split()))
a=[int(input()) for _ in range(n)]
diff=[]
for i in range(n):
diff.append(a[i]-k)
for i in range(n-1):
diff[i+1]+=diff[i]
bit=BIT(n)
s=set([])
for i in range(n):
s.add(diff[i])
li=list(s)
li.sort()
d={}
for i in range(len(li)):
d[li[i]]=i+1
ans=0
for i in range(n):
pos=d[diff[i]]
ans+=bit.sum(pos)
if diff[i]>=0:
ans+=1
bit.add(pos,1)
print(ans)
|
p03703
|
import sys
from itertools import accumulate
def solve():
n, k = list(map(int, sys.stdin.readline().split()))
a = [int(sys.stdin.readline().rstrip()) - k for i in range(n)]
s = [0] + list(accumulate(a))
# 座標圧縮
s = [(si, i) for (i, si) in enumerate(s)]
s.sort()
z = [None] * (n + 1)
num = -1
p = -float('inf')
for i in range(n + 1):
if s[i][0] > p:
num += 1
z[s[i][1]] = num
p = s[i][0]
# FenwickTreeで転倒数を数える
ft = FenwickTree(num + 1)
ans = 0
for zi in z:
ans += ft.psum(zi + 1)
ft.add(zi, 1)
print(ans)
class FenwickTree:
def __init__(self, n):
self.n = n
self.b = [0] * (n + 1)
def add(self, i, x):
i += 1
while i <= self.n:
self.b[i] += x
i += i & (-i)
def psum(self, r):
res = 0
while r > 0:
res += self.b[r]
r -= r & (-r)
return res
if __name__ == '__main__':
solve()
|
import sys
from itertools import accumulate
inf = 1<<60
ans = 0
def solve():
n, k = list(map(int, sys.stdin.readline().split()))
a = [int(sys.stdin.readline().rstrip()) - k for i in range(n)]
s = [0] + list(accumulate(a))
MergeSort(s)
print(ans)
def MergeSort(a):
if len(a) == 1:
return a
apre = MergeSort(a[:len(a)//2])
asuf = MergeSort(a[len(a)//2:])
res = merge(apre, asuf)
return res
def merge(a, b):
global ans
na = len(a)
nb = len(b)
a.append(-inf)
b.append(-inf)
la = 0
lb = 0
res = []
for i in range(na + nb):
if a[la] <= b[lb]:
ans += na - la
res.append(b[lb])
lb += 1
else:
res.append(a[la])
la += 1
return res
if __name__ == '__main__':
solve()
|
p03703
|
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)
def func(a, b):
return a + b
class SegmentTree:
"""
各ノードが半開区間に対応した完全二分木。
子は親を半分にした区間を持つ。
構築O(n), 区間に対する操作O(logn), 値の更新O(logn)
区間に対する操作は最小値, 最大値, 区間に対する和など柔軟に変更して用いよう！
"""
def __init__(self, x, init_val): # 構築, init_valは配列の初期値(最小値のクエリならINF, 和なら0)
self.init_val = init_val
self.length = 2 ** ((len(x) - 1).bit_length())
self.data = [init_val] * (2 + 1) * self.length
for i in range(len(x)):
self.data[i + self.length - 1] = x[i]
for i in range(self.length - 2, -1, -1):
self.data[i] = func(self.data[2 * i + 1], self.data[2 * i + 2])
def teach_current_val(self, index):
return self.data[index + self.length - 1]
def replace(self, index, val): # indexの値をvalに更新
index += self.length - 1
self.data[index] = val
while index:
index = (index - 1) // 2
self.data[index] = func(self.data[2 * index + 1], self.data[2 * index + 2])
def query(self, left, right): # 半開区間の最小値等を求める, 葉からさかのぼっていくイメージ。
if right <= left:
return self.init_val
left += self.length - 1 # self.dataの位置に合わせる。
right += self.length - 2 # self.dataの位置に合わせる。半開区間
ans = self.init_val
while right > left + 1:
if left & 1 == 0: # if left_index%2 == 0:
ans = func(ans, self.data[left])
if right & 1 == 1: # if right_index%2 == 1:
ans = func(ans, self.data[right])
right -= 1
left //= 2
right = (right - 1) // 2
if left == right:
ans = func(ans, self.data[left])
else:
ans = func(func(ans, self.data[left]), self.data[right])
return ans
N, K = list(map(int, input().split()))
a = [int(eval(input())) - K for _ in range(N)]
a = list(itertools.accumulate(a))
a = [0] + a
val = [-INF]
for i in sorted(a):
if i > val[-1]:
val.append(i)
seg = SegmentTree([0] * N, 0)
ans = 0
for i in val[1:]:
for ind, l in enumerate(a):
if l == i:
ans += seg.query(0, ind)
seg.replace(ind, 1)
print(ans)
|
import sys
import math
import string
import fractions
import random
from operator import itemgetter
import itertools
import collections
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)
def func(a, b):
return a + b
class SegmentTree:
"""
各ノードが半開区間に対応した完全二分木。
子は親を半分にした区間を持つ。
構築O(n), 区間に対する操作O(logn), 値の更新O(logn)
区間に対する操作は最小値, 最大値, 区間に対する和など柔軟に変更して用いよう！
"""
def __init__(self, x, init_val): # 構築, init_valは配列の初期値(最小値のクエリならINF, 和なら0)
self.init_val = init_val
self.length = 2 ** ((len(x) - 1).bit_length())
self.data = [init_val] * (2 + 1) * self.length
for i in range(len(x)):
self.data[i + self.length - 1] = x[i]
for i in range(self.length - 2, -1, -1):
self.data[i] = func(self.data[2 * i + 1], self.data[2 * i + 2])
def teach_current_val(self, index):
return self.data[index + self.length - 1]
def replace(self, index, val): # indexの値をvalに更新
index += self.length - 1
self.data[index] = val
while index:
index = (index - 1) // 2
self.data[index] = func(self.data[2 * index + 1], self.data[2 * index + 2])
def query(self, left, right): # 半開区間の最小値等を求める, 葉からさかのぼっていくイメージ。
if right <= left:
return self.init_val
left += self.length - 1 # self.dataの位置に合わせる。
right += self.length - 2 # self.dataの位置に合わせる。半開区間
ans = self.init_val
while right > left + 1:
if left & 1 == 0: # if left_index%2 == 0:
ans = func(ans, self.data[left])
if right & 1 == 1: # if right_index%2 == 1:
ans = func(ans, self.data[right])
right -= 1
left //= 2
right = (right - 1) // 2
if left == right:
ans = func(ans, self.data[left])
else:
ans = func(func(ans, self.data[left]), self.data[right])
return ans
N, K = list(map(int, input().split()))
a = [0] * (N + 1)
for i in range(N):
a[i + 1] = int(eval(input())) - K
a = list(itertools.accumulate(a))
cc = sorted(list(dict.fromkeys(a)))
c = collections.Counter(a)
for i in range(len(a)):
if type(c[a[i]]) == int:
c[a[i]] = [i]
else:
c[a[i]].append(i)
seg = SegmentTree([0] * (N + 1), 0)
ans = 0
for i in cc:
for l in c[i]:
ans += seg.query(0, l)
seg.replace(l, 1)
print(ans)
|
p03703
|
from bisect import bisect_right
import sys
input = sys.stdin.buffer.readline
class BIT:
def __init__(self, size, values):
self.size = size
self.tree = [0] * (size + 1)
self.values = values
self.values.sort()
self.vToI = {v: i for i, v in enumerate(self.values, start=1)}
def lowerValueIndex(self, v):
return self.vToI[self.values[bisect_right(self.values, v) - 1]]
def add(self, index):
index = self.vToI[index]
while index <= self.size:
self.tree[index] += 1
index += index & (-index)
def sum(self, index):
index = self.lowerValueIndex(index)
ret = 0
while index:
ret += self.tree[index]
index -= index & (-index)
return ret
def search(self, value):
i = 0
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i + step <= self.size and s + self.tree[i + step] < value:
i += step
s += self.tree[i]
step //= 2
return i + 1
N, K = list(map(int, input().split()))
A = [int(eval(input())) - K for _ in range(N)]
accA = [0] * (N + 1)
for i, a in enumerate(A, start=1):
accA[i] = accA[i - 1] + a
values = accA + [10**18]
values += [-v for v in values]
values = list(set(values))
tree = BIT(len(values), values)
ans = 0
for i, a in enumerate(accA):
ans += i - tree.sum(-a - 1)
tree.add(-a)
print(ans)
|
from bisect import bisect_right
import sys
input = sys.stdin.buffer.readline
class BIT:
def __init__(self, size):
self.size = size
self.tree = [0] * (size + 1)
def add(self, index):
while index <= self.size:
self.tree[index] += 1
index += index & (-index)
def sum(self, index):
ret = 0
while index:
ret += self.tree[index]
index -= index & (-index)
return ret
def search(self, value):
i = 0
s = 0
step = 1 << (self.size.bit_length() - 1)
while step:
if i + step <= self.size and s + self.tree[i + step] < value:
i += step
s += self.tree[i]
step //= 2
return i + 1
N, K = list(map(int, input().split()))
A = [int(eval(input())) - K for _ in range(N)]
accA = [0] * (N + 1)
for i, a in enumerate(A, start=1):
accA[i] = accA[i - 1] + a
sToI = {s: i for i, s in enumerate(sorted(list(set(accA))))}
tree = BIT(len(sToI))
ans = 0
for a in [sToI[a] + 1 for a in accA]:
ans += tree.sum(a)
tree.add(a)
print(ans)
|
p03703
|
from itertools import accumulate as acc
class BIT:
def __init__(self, n):
self.N = n+1
self.bit = [0]*self.N
def bit_sum(self, i):
s = 0
i += 1
while i>0:
s += self.bit[i]
i -= i & -i
return s
def bit_add(self, i, n):
i += 1
while i<self.N:
self.bit[i] += n
i += i & -i
N, K, *A = list(map(int, open(0).read().split()))
A = [a-K for a in A]
B = [(b,i) for i, b in enumerate(acc(A))]
bit_B = BIT(N)
B.sort(reverse=True)
ans = sum(c[0]>=0 for c in B)
for b,i in B:
bit_B.bit_add(i,1)
ans += bit_B.bit_sum(N-1)-bit_B.bit_sum(i)
print(ans)
|
from itertools import accumulate as acc
def bit_sum(ls, i):
s = 0
i += 1
while i>0:
s += ls[i]
i -= i & -i
return s
def bit_add(ls, i, n):
i += 1
while i<len(ls):
ls[i] += n
i += i & -i
N, K, *A = list(map(int, open(0).read().split()))
A = [a-K for a in A]
B = [(b,i) for i, b in enumerate(acc(A))]
bit_B = [0]*(N+1)
B.sort(reverse=True)
ans = sum(c[0]>=0 for c in B)
for b,i in B:
bit_add(bit_B,i,1)
ans += bit_sum(bit_B,N-1)-bit_sum(bit_B,i)
print(ans)
|
p03703
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
from bisect import bisect_right, bisect_left
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, gamma, log
from operator import mul
from functools import reduce
sys.setrecursionlimit(2147483647)
INF = 1 << 100
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 1000000007
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
self.total = 0
def add(self, i, w):
x = i + 1
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
n, k = LI()
A = IR(n)
A = [a - k for a in A]
A = [0] + list(accumulate(A))
D = {}
for i, v in enumerate(sorted(set(A))):
D[v] = i
for i in range(n + 1):
A[i] = D[A[i]]
bit = BIT(max(A) + 1)
c = 0
for a in A:
c += bit.sum(a)
bit.add(a, 1)
print(c)
|
from collections import defaultdict, deque, Counter
from heapq import heappush, heappop, heapify
import math
import bisect
import random
from itertools import permutations, accumulate, combinations, product
import sys
import string
from bisect import bisect_left, bisect_right
from math import factorial, ceil, floor, cos, radians, pi, sin
from operator import mul
from functools import reduce
from operator import mul
sys.setrecursionlimit(2147483647)
INF = 10 ** 13
def LI(): return list(map(int, sys.stdin.buffer.readline().split()))
def I(): return int(sys.stdin.buffer.readline())
def LS(): return sys.stdin.buffer.readline().rstrip().decode('utf-8').split()
def S(): return sys.stdin.buffer.readline().rstrip().decode('utf-8')
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)]
def SRL(n): return [list(S()) for i in range(n)]
def MSRL(n): return [[int(j) for j in list(S())] for i in range(n)]
mod = 10 ** 9 + 7
class BIT:
def __init__(self, size):
self.bit = [0] * size
self.size = size
self.total = 0
def add(self, i, w):
x = i + 1
self.total += w
while x <= self.size:
self.bit[x - 1] += w
x += x & -x
return
def sum(self, i):
res = 0
x = i + 1
while x:
res += self.bit[x - 1]
x -= x & -x
return res
n, k = LI()
A = IR(n)
A = [0] + list(accumulate([a - k for a in A]))
D = {v:i for i,v in enumerate(sorted(A))}
bit = BIT(len(A))
c = 0
for a in A:
c += bit.sum(D[a])
bit.add(D[a], 1)
print(c)
|
p03703
|
# -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
N, K = MAP()
# 予め-Kした状態で用意しておく
A = [a-K for a in LIST(N)]
# 累積和
acc = [0] + list(accumulate(A))
# 座標圧縮
zip_acc = {}
for i, a in enumerate(sorted(set(acc))):
zip_acc[a] = i
bit = BIT(len(zip_acc))
cnt = 0
for a in acc:
# 自分より左にある、自分の値以下の数(転倒数の数え上げ)
cnt += bit.sum(zip_acc[a])
bit.add(zip_acc[a], 1)
print(cnt)
|
# -*- coding: utf-8 -*-
import sys
from itertools import accumulate
def input(): return sys.stdin.readline().strip()
def list2d(a, b, c): return [[c] * b for i in range(a)]
def list3d(a, b, c, d): return [[[d] * c for j in range(b)] for i in range(a)]
def list4d(a, b, c, d, e): return [[[[e] * d for j in range(c)] for j in range(b)] for i in range(a)]
def ceil(x, y=1): return int(-(-x // y))
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(N=None): return list(MAP()) if N is None else [INT() for i in range(N)]
def Yes(): print('Yes')
def No(): print('No')
def YES(): print('YES')
def NO(): print('NO')
sys.setrecursionlimit(10 ** 7)
INF = 10 ** 18
MOD = 10 ** 9 + 7
class BIT:
def __init__(self, n):
# 0-indexed
nv = 1
while nv < n:
nv *= 2
self.size = nv
self.tree = [0] * nv
def sum(self, i):
""" [0, i]を合計する """
s = 0
i += 1
while i > 0:
s += self.tree[i-1]
i -= i & -i
return s
def add(self, i, x):
""" 値の追加：添字i, 値x """
i += 1
while i <= self.size:
self.tree[i-1] += x
i += i & -i
def get(self, l, r=None):
""" 区間和の取得 [l, r) """
# 引数が1つなら一点の値を取得
if r is None: r = l + 1
res = 0
if r: res += self.sum(r-1)
if l: res -= self.sum(l-1)
return res
def compress(A):
""" 座標圧縮 """
zipped, unzipped = {}, {}
for i, a in enumerate(sorted(set(A))):
zipped[a] = i
unzipped[i] = a
return zipped, unzipped
N, K = MAP()
# 予め-Kした状態で用意しておく
A = [a-K for a in LIST(N)]
# 累積和
acc = [0] + list(accumulate(A))
# 座標圧縮
zipped, _ = compress(acc)
bit = BIT(len(zipped))
cnt = 0
for a in acc:
# 自分より左にある、自分の値以下の数(転倒数の数え上げ)
cnt += bit.sum(zipped[a])
bit.add(zipped[a], 1)
print(cnt)
|
p03703
|
from itertools import accumulate
def main():
class BIT:
def __init__(self, N):
self.size = N
self.tree = [0] * (N + 1)
def sum(self, i):
s = 0
while i > 0:
s += self.tree[i]
i -= i & -i
return s
def add(self, i, x):
while i <= self.size:
self.tree[i] += x
i += i & -i
N, K, *A = list(map(int, open(0).read().split()))
B = [0] + list(accumulate(a - K for a in A))
memo = {n: i for i, n in enumerate(sorted(set(B)), 1)}
bit = BIT(N + 1)
ans = 0
for b in map(memo.get, B):
ans += bit.sum(b)
bit.add(b, 1)
print(ans)
if __name__ == '__main__':
main()
|
from itertools import accumulate
def main():
N, K, *A = list(map(int, open(0).read().split()))
B = [0] + list(accumulate(a - K for a in A))
memo = {n: i for i, n in enumerate(sorted(set(B)), 1)}
N += 1
tree = [0] * (N + 1)
def bit_sum(i):
s = 0
while i > 0:
s += tree[i]
i -= i & -i
return s
def bit_add(i, x):
while i <= N:
tree[i] += x
i += i & -i
ans = 0
for b in map(memo.get, B):
ans += bit_sum(b)
bit_add(b, 1)
print(ans)
if __name__ == '__main__':
main()
|
p03703
|
import sys
from copy import deepcopy
F = sys.stdin
N, K = list(map(int, F.readline().strip("\n").split()))
A = [None] * (N + 1)
A[0] = 0
A_order = {0}
for a in range(N):
A[a+1] = int(F.readline().strip("\n")) - K + A[a]
A_order |= {A[a+1]}
maxA = len(A_order)
A_order = list(A_order)
A_order.sort()
compressed_A = dict()
for i in range(maxA):
compressed_A[A_order[i]] = i
bit = [0] * (maxA + 1)
total_inversion = 0
for a in A:
b = compressed_A[a] + 1
while b <= maxA + 1:
bit[b - 1] += 1
b += b & -b
#total sum
upper = maxA + 1
upper_sum = 0
while upper > 0:
upper_sum += bit[upper - 1]
upper -= upper & -upper
#lower sum
lower = compressed_A[a] + 1
lower_sum = 0
while lower > 0:
lower_sum += bit[lower - 1]
lower -= lower & -lower
total_inversion += upper_sum - lower_sum
print((N * (N + 1) // 2 - total_inversion))
|
import sys
from copy import deepcopy
F = sys.stdin
N, K = list(map(int, F.readline().strip("\n").split()))
A = [None] * (N + 1)
A[0] = 0
A_order = {0}
for a in range(N):
A[a+1] = int(F.readline().strip("\n")) - K + A[a]
A_order |= {A[a+1]}
maxA = len(A_order)
A_order = list(A_order)
A_order.sort()
compressed_A = dict()
for i in range(maxA):
compressed_A[A_order[i]] = i
bit = [0] * (maxA + 1)
total_inversion = 0
for i in range(N+1):
b = compressed_A[A[i]] + 1
while b <= maxA + 1:
bit[b - 1] += 1
b += b & -b
#lower sum
lower = compressed_A[A[i]] + 1
lower_sum = 0
while lower > 0:
lower_sum += bit[lower - 1]
lower -= lower & -lower
total_inversion += i + 1 - lower_sum
print((N * (N + 1) // 2 - total_inversion))
|
p03703
|
from bisect import bisect_right as br
n,k=list(map(int,input().split()))
b=[0]*(n+1)
def f(x):
c=0
while x>0:
c+=b[x]
x-=x&-x
return c
def g(x,a):
while x<n+1:
b[x]+=a
x+=x&-x
for i in range(n):
g(i+1,int(eval(input()))-k)
c=[0]
d=0
for i in range(1,n+1):
t=f(i)
k=br(c,t)
c.insert(k,f(i))
d+=i-k
print(((n*(n+1))//2-d))
|
n,k=list(map(int,input().split()))
b=[0]*(n+1)
for i in range(n):
b[i+1]=b[i]+int(eval(input()))-k
a=sorted(set(b))
s={a[i-1]:i for i in range(1,len(a)+1)}
c=[]
for i in b:
c.append(s[i])
b=[0]*(len(a)+1)
def f(x):
c=0
while x>0:
c+=b[x]
x-=x&-x
return c
def g(x):
while x<len(a)+1:
b[x]+=1
x+=x&-x
e=0
for i in range(n+1):
e+=f(c[i])
g(c[i])
print(e)
|
p03703
|
class BIT:
def __init__(self,n):
self.size=n
self.tree=[0]*-~n
def sum(self,i):
s=0
while i:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
n,k,*a=list(map(int,open(0).read().split()))
a=[t-k for t in a]
for i in range(1,n):
a[i]+=a[i-1]
d={}
for i,v in enumerate(sorted(set(a+[0])),1):
d[v]=i
for i in range(n):
a[i]=d[a[i]]
b=BIT(max(a))
b.add(d[0],1)
c=0
for i,p in enumerate(a):
c+=b.sum(p)
b.add(p,1)
print(c)
|
class BIT:
def __init__(self,n):
self.size=n
self.tree=[0]*-~n
def sum(self,i):
s=0
while i:
s+=self.tree[i]
i-=i&-i
return s
def add(self,i,x):
while i<=self.size:
self.tree[i]+=x
i+=i&-i
n,k,*a=list(map(int,open(0).read().split()))
a=[t-k for t in a]
for i in range(1,n):
a[i]+=a[i-1]
d={}
for i,v in enumerate(sorted(set(a+[0])),1):
d[v]=i
for i in range(n):
a[i]=d[a[i]]
b=BIT(max(a))
b.add(d[0],1)
c=0
for p in a:
c+=b.sum(p)
b.add(p,1)
print(c)
|
p03703
|
from bisect import bisect,insort
n,k = (int(i) for i in input().split())
a = [int(eval(input()))-k for i in range(n)]
b = [[0,0]]
for i in range(n): b.append([-(a[i]-b[-1][0]),-(i+1)])
b.sort()
q,ans,num = [-b[0][1]],0,1
for i,j in b[1:]:
c = bisect(q,-j)
ans+=num-c
num+=1
insort(q,-j,c,c)
print(ans)
|
n,k = (int(i) for i in input().split())
a = [int(eval(input()))-k for i in range(n)]
b = [[0,0]]
for i in range(n): b.append([b[-1][0]+a[i],i+1])
b.sort()
num,c = 1,[[b[0][1],1]]
for i in range(1,n+1):
if b[i][0]!=b[i-1][0]: num+=1
c.append([b[i][1],num])
c,d,ans = sorted(c),[0]*(n+2),0
def add(i):
while i<=n+1:
d[i] += 1
i += i & -i
def get(i):
s = 0
while i:
s += d[i]
i -= i & -i
return s
for i,j in c:
ans+=get(j)
add(j)
print(ans)
|
p03703
|
import bisect
N,K = list(map(int,input().split()))
src = [int(eval(input())) for i in range(N)]
if N == 1:
print((int(src[0]>=K)))
exit()
cums = [0]
for a in src:
cums.append(cums[-1] + a - K)
s_cums = sorted(cums)
cmp = []
for a in cums:
i = bisect.bisect(s_cums, a)
cmp.append(i-1)
bit = [0] * (N+1)
def bit_add(a,w):
x = a
while x <= N:
bit[x] += w
x += (x & -x)
def bit_sum(a):
x = a
ret = 0
while x > 0:
ret += bit[x]
x -= (x & -x)
return ret
ans = 0
for a in cmp:
ans += bit_sum(a)
bit_add(a, 1)
print(ans)
|
N,K = list(map(int,input().split()))
src = [int(eval(input())) for i in range(N)]
cums = [(0,1)]
for i,a in enumerate(src):
cums.append((cums[-1][0] + a - K, i+2))
bit = [0] * (N+2)
def bit_add(a,w):
x = a
while x <= N:
bit[x] += w
x += (x & -x)
def bit_sum(a):
x = a
ret = 0
while x > 0:
ret += bit[x]
x -= (x & -x)
return ret
ans = 0
for i,a in sorted(cums):
ans += bit_sum(a-1)
bit_add(a, 1)
print(ans)
|
p03703
|
N, K = list(map(int, input().split()))
a = []
for _ in range(N):
a.append(int(eval(input()))-K)
ans = 0
for i in range(N):
for j in range(i+1, N+1):
# print(a[i:j])
if sum(a[i:j]) >= 0:
ans += 1
print(ans)
|
N, K = list(map(int, input().split()))
a = []
for _ in range(N):
a.append(int(eval(input()))-K)
su = 0
v = [(0, 0)]
for i in range(N):
su += a[i]
v.append((su, i+1))
v = sorted(v)
data = [0]*(N+5)
def sumation(i):
s = 0
while i > 0:
s += data[i]
i -= i & -i
return s
def add(i, x):
while i <= N+2:
data[i] += x
i += i & -i
ans = 0
for e, i in v:
ans += sumation(i+1)
add(i+1, 1)
print(ans)
|
p03703
|
from bisect import bisect_left
class SEGTree:
def __init__(self,n):
self.Unit=0
i=1
while(i<n):
i*=2
self.SEG=[self.Unit]*(2*i-1)
self.d=i
def update(self,i,x):
i+=self.d-1
self.SEG[i]+=x
while i>0:
i=(i-1)//2
self.SEG[i]=self.SEG[i*2+1]+self.SEG[i*2+2]
def find(self,a,b,k,l,r):
if r<=a or b<=l:
return self.Unit
if a<=l and r<=b:
return self.SEG[k]
else:
c1=self.find(a,b,2*k+1,l,(l+r)//2)
c2=self.find(a,b,2*k+2,(l+r)//2,r)
return c1+c2
def get(self,a,b):
return self.find(a,b,0,0,self.d)
N,K=list(map(int,input().split()))
a=[int(eval(input())) for i in range(N)]
cum=[0]*(N+1)
for i in range(N):
cum[i+1]=cum[i]+a[i]
B=[cum[i]-i*K for i in range(N+1)]
dic={}
li=sorted(B)
for i in range(N+1):
dic[B[i]]=bisect_left(li,B[i])
seg=SEGTree(N+1)
ans=0
for i in range(N+1):
ans+=seg.get(0,dic[B[i]]+1)
seg.update(dic[B[i]],1)
print(ans)
|
from bisect import bisect_left
class BIT:
def __init__(self,N):
self.N=N
self.bit=[0]*N
def add(self,a,w):
x=a
while(x<self.N):
self.bit[x]+=w
x|=x+1
def get(self,a):
ret,x=0,a-1
while(x>=0):
ret+=self.bit[x]
x=(x&(x+1))-1
return ret
def cum(self,l,r):
return self.get(r)-self.get(l)
N,K=list(map(int,input().split()))
a=[int(eval(input())) for i in range(N)]
cum=[0]*(N+1)
for i in range(N):
cum[i+1]=cum[i]+a[i]
B=[cum[i]-i*K for i in range(N+1)]
dic={}
li=sorted(B)
for i in range(N+1):
dic[B[i]]=bisect_left(li,B[i])
bit=BIT(N+1)
ans=0
for i in range(N+1):
ans+=bit.get(dic[B[i]]+1)
bit.add(dic[B[i]],1)
print(ans)
|
p03703
|
import sys
import heapq
import math
import fractions
import bisect
import itertools
from collections import Counter
from collections import deque
from operator import itemgetter
def input(): return sys.stdin.readline().strip()
def mp(): return list(map(int,input().split()))
def lmp(): return list(map(int,input().split()))
n=int(eval(input()))
print((((-1)*n)%1000))
|
n=int(eval(input()))
print(((-n)%1000))
|
p02612
|
import math
n = int(eval(input()))
if n % 1000 == 0:
print((0))
else:
print((math.ceil(n / 1000) * 1000 - n))
|
print((-int(eval(input()))%1000))
|
p02612
|
#!/usr/bin/env python3
# encoding:utf-8
import copy
import random
import bisect #bisect_left これで二部探索の大小検索が行える
import fractions #最小公倍数などはこっち
import math
import sys
import collections
from decimal import Decimal # 10進数で考慮できる
mod = 10**9+7
sys.setrecursionlimit(mod) # 再帰回数上限はでdefault1000
d = collections.deque()
def LI(): return list(map(int, sys.stdin.readline().split()))
N = int(eval(input()))
print(((1000 - N % 1000) % 1000))
|
N = int(eval(input()))
print(((1000 - N % 1000) % 1000))
|
p02612
|
#!/usr/bin/env python3
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
def main():
N = int(eval(input()))
if N % 1000 == 0:
print((0))
else:
print((1000 - N%1000))
if __name__ == "__main__":
main()
|
print(((1000-int(eval(input()))%1000)%1000))
|
p02612
|
N = int(eval(input()))
if 0 <= N <= 1000:
print((1000-N))
elif 1000 < N <= 2000:
print((2000-N))
elif 2000 < N <= 3000:
print((3000-N))
elif 3000 < N <= 4000:
print((4000-N))
elif 4000 < N <= 5000:
print((5000-N))
elif 5000 < N <= 6000:
print((6000-N))
elif 6000 < N <= 7000:
print((7000-N))
elif 7000 < N <= 8000:
print((8000-N))
elif 8000 < N <= 9000:
print((9000-N))
else:
print((10000-N))
|
n = int(eval(input()))
if n % 1000 == 0:
ans = 0
else:
ans = 1000- n % 1000
print(ans)
|
p02612
|
N = int(eval(input()))
if N % 1000 == 0:
print((0))
else:
print((1000 - (N % 1000)))
|
n = int(eval(input()))
if n % 1000 == 0:
print((0))
else:
print((1000 - n % 1000))
|
p02612
|
n = int(eval(input()))
r = n % 1000
x = 0 if r == 0 else 1000-r
print(x)
|
print((-int(eval(input()))%1000))
|
p02612
|
n = int(eval(input()))
print(((10000-n) % 1000))
|
S = int(eval(input()))
if S % 1000 == 0:
W = 0
else:
W = 1000-(S % 1000)
print(W)
190
|
p02612
|
import sys
sys.setrecursionlimit(10**7)
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split())) #空白あり
def LI2(): return list(map(int,sys.stdin.readline().rstrip())) #空白なし
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split()) #空白あり
def LS2(): return list(sys.stdin.readline().rstrip()) #空白なし
N = I()
if N % 1000 == 0:
print((0))
else:
print((1000-N%1000))
|
import sys
def I(): return int(sys.stdin.readline().rstrip())
N = I()
print((999-(N-1)%1000))
|
p02612
|
n=int(eval(input()))
print(((10000-n)%1000))
|
n=int(eval(input()))
print(((1000-n%1000)%1000))
|
p02612
|
def main():
arg = int(eval(input()))
if arg % 1000 == 0:
ans = 0
else:
ans = 1000 - (arg % 1000)
print((str(ans)))
if __name__ == '__main__':
main()
|
def main():
m = int(eval(input())) % 1000
ans = 0 if m == 0 else 1000 - m
print((str(ans)))
if __name__ == '__main__':
main()
|
p02612
|
n = int(eval(input())) % 1000
if n == 0:
print((0))
else:
print((1000 - n))
|
n = int(eval(input()))
print(((1000 - n % 1000) % 1000))
|
p02612
|
N = int(eval(input()))
ans = (1000 - N % 1000) % 1000
print(ans)
|
N = int(eval(input()))
k = 0
while k * 1000 < N:
k += 1
ans = k * 1000 - N
print(ans)
|
p02612
|
x=int(eval(input()))
from math import ceil
u=ceil(x/1000)*1000
print((u-x))
|
from math import ceil
x=int(eval(input()))
print((ceil(x/1000)*1000-x))
|
p02612
|
n = int(eval(input()))
i=1
ans=0
for i in range(100):
if i*1000>=n:
ans = i*1000-n
break
print(ans)
|
n=int(eval(input()))
if n%1000==0:
print((0))
else:print((1000-n%1000))
|
p02612
|
n = int(eval(input()))
x = (10000-n)%1000
print(x)
|
N = int(eval(input()))
if N % 1000 == 0:
print((0))
else:
print((1000-N % 1000))
|
p02612
|
N = int(eval(input()))
print(((1000-N%1000)%1000))
|
N = int(eval(input()))
tmp = N%1000
if tmp == 0:
print((0))
else:
print((1000 - tmp))
|
p02612
|
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
#mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file = 0
def solve():
# for _ in range(ii()):
n=ii()
n%=1000
if n!=0:
n=1000-n
print(n)
if __name__ =="__main__":
if(file):
if path.exists('input1.txt'):
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
else:
input=sys.stdin.readline
solve()
|
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
# mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file=0
def solve():
# for _ in range(ii()):
n=ii()
n%=1000
if(n!=0):
n=1000-n
print(n)
if __name__ =="__main__":
if(file):
if path.exists('input1.txt'):
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
else:
input=sys.stdin.readline
solve()
|
p02612
|
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
# mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file=0
def solve():
# for _ in range(ii()):
n=ii()
n%=1000
if(n!=0):
n=1000-n
print(n)
if __name__ =="__main__":
if(file):
if path.exists('input1.txt'):
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
else:
input=sys.stdin.readline
solve()
|
'''
Auther: ghoshashis545 Ashis Ghosh
College: jalpaiguri Govt Enggineering College
'''
from os import path
import sys
from heapq import heappush,heappop
from functools import cmp_to_key as ctk
from collections import deque,defaultdict as dd
from bisect import bisect,bisect_left,bisect_right,insort,insort_left,insort_right
from itertools import permutations
from datetime import datetime
from math import ceil,sqrt,log,gcd
def ii():return int(eval(input()))
def si():return eval(input())
def mi():return list(map(int,input().split()))
def li():return list(mi())
abc='abcdefghijklmnopqrstuvwxyz'
mod=1000000007
# mod=998244353
inf = float("inf")
vow=['a','e','i','o','u']
dx,dy=[-1,1,0,0],[0,0,1,-1]
def bo(i):
return ord(i)-ord('a')
file=1
def solve():
# for _ in range(ii()):
n=ii()
n%=1000
if(n!=0):
n=1000-n
print(n)
if __name__ =="__main__":
if(file):
if path.exists('input1.txt'):
sys.stdin=open('input1.txt', 'r')
sys.stdout=open('output1.txt','w')
else:
input=sys.stdin.readline
solve()
|
p02612
|
N = int(eval(input()))
while N > 0:
N = N - 1000
if N < 0:
N = N * -1
print(N)
|
N = int(eval(input()))
while N > 0:
N -= 1000
if N < 0:
N *= -1
print(N)
|
p02612
|
n = int(eval(input()))
if n%1000 == 0:
print((0))
else:
print((1000-n%1000))
|
n = int(eval(input()))
print(((1000-n%1000)%1000))
|
p02612
|
print(((1000 - int(eval(input())) % 1000) % 1000))
|
print((-int(eval(input())) % 1000))
|
p02612
|
a=int(eval(input()))
if a%1000==0:
print((0))
else:
print((1000-a%1000))
|
n=int(eval(input()))
n=n%1000
if n==0:
print((0))
else:
print((1000-n))
|
p02612
|
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
ans = N // 1000
ans2 = N - (ans*1000)
if ans2 == 0:
print((0))
else:
print((1000-ans2))
|
import sys
def I(): return int(sys.stdin.readline().rstrip())
def LI(): return list(map(int,sys.stdin.readline().rstrip().split()))
def S(): return sys.stdin.readline().rstrip()
def LS(): return list(sys.stdin.readline().rstrip().split())
N = I()
N %= 1000
if N==0:
print((0))
else:
print((1000-N))
|
p02612
|
# -*- coding: utf-8 -*-
# 標準入力を取得
N = int(eval(input()))
# 求解処理
ans = (1000 - (N % 1000)) % 1000
# 結果出力
print(ans)
|
# -*- coding: utf-8 -*-
def get_input() -> int:
"""
標準入力を取得する.
Returns:\n
int: 標準入力
"""
N = int(eval(input()))
return N
def main(N: int) -> None:
"""
メイン処理.
Args:\n
N (int): 整数（1 <= N <= 10000）
"""
# 求解処理
ans = (1000 - (N % 1000)) % 1000
# 結果出力
print(ans)
if __name__ == "__main__":
# 標準入力を取得
N = get_input()
# メイン処理
main(N)
|
p02612
|
N = int(eval(input()))
if N%1000 == 0:
print((0))
else:
print((1000-N%1000))
|
N = int(eval(input()))
print(((10000-N)%1000))
|
p02612
|
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, defaultdict
#deque(l), pop(), append(x), popleft(), appendleft(x)
#q.rotate(n)で → に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 reduce,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 printe(*x):print("## ",*x,file=sys.stderr)
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),reverse=True) #二個目の要素で降順並び替え
N = int(input())
#N, K = map(int, input().split())
#A = tuple(map(int, input().split())) #1行ベクトル
#L = tuple(int(input()) for i in range(N)) #改行ベクトル
#S = tuple(tuple(map(int, input().split())) for i in range(N)) #改行行列
a=N//1000
b=N%1000
if b==0:
print(0)
else:
print((a+1)*1000-N)
if __name__ == "__main__":
main()
|
n=eval(input())
n=int(n)
x=n%1000
if x==0:
print((0))
else:
print((1000-x))
|
p02612
|
n=int(eval(input()))
ans=(1000-n%1000)%1000
print(ans)
|
n = int(eval(input()))
print((1000 - n % 1000 if n % 1000 != 0 else 0))
|
p02612
|
n = int(eval(input()))
if n % 1000 == 0:
print((0))
else:
print(((n // 1000 + 1) * 1000 - n))
|
n = int(eval(input()))
print(((1000 - n % 1000) % 1000))
|
p02612
|
import sys
#input = sys.stdin.buffer.readline
#sys.setrecursionlimit(10**9)
#from functools import lru_cache
def RD(): return sys.stdin.read()
def II(): return int(eval(input()))
def MI(): return list(map(int,input().split()))
def MF(): return list(map(float,input().split()))
def LI(): return list(map(int,input().split()))
def LF(): return list(map(float,input().split()))
def TI(): return tuple(map(int,input().split()))
# rstrip().decode()
#import numpy as np
def main():
n=II()
if n%1000==0:
print((0))
else:
print(((n//1000)*1000+1000-n))
if __name__ == "__main__":
main()
|
n=int(eval(input()))
print(((-n)%1000))
|
p02612
|
r = 1000 - int(eval(input())) % 1000
print((r if r < 1000 else 0))
|
print(((1000 - int(eval(input())) % 1000) % 1000))
|
p02612
|
import math
n = int(eval(input()))
print((math.ceil(n/1000)*1000-n))
|
n = int(eval(input()))
p = 0
while p < n:
p += 1000
print((p - n))
|
p02612
|
def main():
N = int(eval(input()))
change = -N % 1000
print(change)
if __name__ == '__main__':
main()
|
def main():
N = int(eval(input()))
ans = - N % 1000
if ans < 0:
ans += 1000
print(ans)
if __name__ == '__main__':
main()
|
p02612
|
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N = II()
r = N % 1000
ans = 0
if r % 1000 != 0:
ans = 1000 - r
print(ans)
if __name__ == '__main__':
solve()
|
import sys
sys.setrecursionlimit(10 ** 9)
# input = sys.stdin.readline ####
def int1(x): return int(x) - 1
def II(): return int(eval(input()))
def MI(): return list(map(int, input().split()))
def MI1(): return list(map(int1, input().split()))
def LI(): return list(map(int, input().split()))
def LI1(): return list(map(int1, input().split()))
def LLI(rows_number): return [LI() for _ in range(rows_number)]
def MS(): return input().split()
def LS(): return list(eval(input()))
def LLS(rows_number): return [LS() for _ in range(rows_number)]
def printlist(lst, k=' '): print((k.join(list(map(str, lst)))))
INF = float('inf')
# from math import ceil, floor, log2
# from collections import deque
# from itertools import combinations as comb, combinations_with_replacement as comb_w, accumulate, product, permutations
# from heapq import heapify, heappop, heappush
# import numpy as np # cumsum
# from bisect import bisect_left, bisect_right
def solve():
N = II()
r = N % 1000
if r == 0:
print((0))
else:
print((1000 - r))
if __name__ == '__main__':
solve()
|
p02612
|
N = int(eval(input()))
if N%1000 == 0:
print((0))
else:
Str = str(N)
if len(Str) > 3:
K = (int(Str[0]) + 1) * 1000
print((K - N))
else:
print((1000 - N))
|
n = int(eval(input()))
if n % 1000 == 0:
print((0))
else:
k = int(((n/1000)+1))*1000
print((k-n))
|
p02612
|
n = int(eval(input()))
if n%1000 == 0:
print((0))
else:
k = int((n/1000)+1)*1000
print((k-n))
|
n = int(eval(input()))
k = int((n/1000)+1)*1000
print((0 if n%1000 == 0 else (k-n)))
|
p02612
|
n=int(eval(input()))
for i in range(1000,10001,1000):
num=i-n
if num >=0:
print(num)
break
|
n=int(eval(input()))
for i in range(1000,10001,1000):
if i>=n:
print((i-n))
break
|
p02612
|
n = int(eval(input()))
print((1000 - n%1000 if n%1000 != 0 else 0))
|
print(((1000-int(eval(input()))%1000)%1000))
|
p02612
|
n = int(eval(input()))
amari = n%1000
ans = 1000 - amari
if amari == 0:
print((0))
else:
print(ans)
|
n = int(eval(input()))
pre = n % 1000
ans = 1000 - pre
if pre == 0:
print((0))
else:
print(ans)
|
p02612
|
from math import ceil
N = int(eval(input()))
print((ceil(N/1000)*1000 - N))
|
N = int(eval(input()))
print(((10000-N)%1000))
|
p02612
|
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
n = 1
while True:
if n * 1000 >= N:
print(((n * 1000) - N))
exit()
else:
n += 1
if __name__ == '__main__':
main()
|
import sys, os, math, bisect, itertools, collections, heapq, queue
# from scipy.sparse.csgraph import csgraph_from_dense, floyd_warshall
from decimal import Decimal
from collections import defaultdict, deque
sys.setrecursionlimit(10000000)
ii = lambda: int(sys.stdin.buffer.readline().rstrip())
il = lambda: list(map(int, sys.stdin.buffer.readline().split()))
fl = lambda: list(map(float, sys.stdin.buffer.readline().split()))
iln = lambda n: [int(sys.stdin.buffer.readline().rstrip()) for _ in range(n)]
iss = lambda: sys.stdin.buffer.readline().decode().rstrip()
sl = lambda: list(map(str, sys.stdin.buffer.readline().decode().split()))
isn = lambda n: [sys.stdin.buffer.readline().decode().rstrip() for _ in range(n)]
lcm = lambda x, y: (x * y) // math.gcd(x, y)
MOD = 10 ** 9 + 7
MAX = float('inf')
def main():
if os.getenv("LOCAL"):
sys.stdin = open("input.txt", "r")
N = ii()
print(((1000 - N % 1000) % 1000))
if __name__ == '__main__':
main()
|
p02612
|
import math
o = 1000
n = int(eval(input()))
m = math.ceil(n / o) * o - n
print(m)
|
n = int(eval(input()))
t = 1000
while n > t:
t += 1000
print((t - n))
|
p02612
|
print(((1000-(int(eval(input()))%1000))%1000))
|
print((-int(eval(input()))%1000))
|
p02612
|
n = int(eval(input()))
if n % 1000 == 0:
print((0))
else:
print((1000 - n % 1000))
|
print(( (1000 - int(eval(input())) % 1000 ) % 1000 ))
|
p02612
|
import math
N = int(eval(input()))
n = math.ceil(N/1000)
ans = (n*1000) - N
print(ans)
|
import math
N = int(eval(input()))
n = math.ceil(N/1000)*1000
print((n-N))
|
p02612
|
n=int(eval(input()))
if n<1000:
print((1000-n))
else:
str1=""
k=n//1000
l=len(str(n))-len(str(k))
str1=str(k)+'0'*l
if str1==str(n):
print((0))
else:
p=int(str1)+1000
print((p-n))
|
n=int(eval(input()))
print(((1000-n%1000)%1000))
|
p02612
|
# import sys
# import math #sqrt,gcd,pi
# import decimal
# import queue # queue
# import bisect
# import heapq # priolity-queue
# import time
# from itertools import product,permutations,\
# combinations,combinations_with_replacement
# 重複あり順列、順列、組み合わせ、重複あり組み合わせ
# import collections # deque
# from operator import itemgetter,mul
# from fractions import Fraction
# from functools import reduce
mod = int(1e9+7)
# mod = 998244353
INF = 1<<50
def readInt():
return list(map(int,input().split()))
def main():
n = int(eval(input()))
x = n % 1000
if x:
print((1000-x))
else:
print((0))
return
if __name__=='__main__':
main()
|
n = int(eval(input()))
change = n % 1000
if change:
print((1000-change))
else:
print((0))
|
p02612
|
n=int(eval(input()))
print((1000-n%1000 if n%1000!=0 else 0))
|
n=int(eval(input()))
print((0 if n%1000==0 else 1000-n%1000))
|
p02612
|
N=int(eval(input()))
if N>1000:
if N%1000==0:
print((0))
else:
print((1000-N%1000))
else:
print((1000-N))
|
N=int(eval(input()))
if N%1000==0:
print((0))
else:
print((1000-N%1000))
|
p02612
|
n = int(eval(input()))
e = 1000
x = n % e
if x == 0:
print((0))
else:
print((e-x))
|
n = int(eval(input()))
a = 1000
x = 1
while True:
if int(a * x) >= n:
break
x += 1
print((int(a * x) -n))
|
p02612
|
n = int(eval(input()))
ans = 0 if n%1000 == 0 else 1000 - n%1000
print(ans)
|
N = int(eval(input()))
print((-N%1000))
|
p02612
|
N = int(eval(input()))
if N % 1000 == 0:
print((0))
else:
n = N // 1000
print((1000*(n+1)-N))
|
N = int(eval(input()))
print((1000 * ((N - 1) // 1000 + 1) - N))
|
p02612
|
N = int(eval(input()))
maisuu = int(N/1000)
if N % 1000 == 0:
money = maisuu*1000
else:
money = (maisuu+1)*1000
result = money - N
print(result)
|
N = int(eval(input()))
while N > 1000:
N = N - 1000
print((1000-N))
|
p02612
|
N = int(eval(input()))
n = -(-N//1000)
print((n*1000 - N))
|
print(((1000 - int(eval(input()))%1000) % 1000))
|
p02612
|
N = eval(input())
Num = int(N)
while Num > 0:
OTURI = 1000 - Num
Num -= 1000
print(OTURI)
|
N = int(eval(input()))
OTURI = 0
while N > 0:
OTURI = 1000 - N
N -= 1000
print(OTURI)
|
p02612
|
N = int(eval(input()))
s = N // 1000
print((N - 1000 * s if N % 1000 == 0 else (1000 * (s + 1)) - N))
|
print(((1000-int(eval(input()))%1000)%1000))
|
p02612
|
m=int(eval(input()))
if m%1000==0:
print((0))
else:
print((1000-m%1000))
|
m=int(eval(input()))
print(((1000-m%1000)%1000))
|
p02612
|
ni = lambda: int(eval(input()))
nm = lambda: list(map(int, input().split()))
nl = lambda: list(map(int, input().split()))
import math
n = ni()
if n%1000==0:
print((0))
else:
print((1000-n%1000))
|
n=int(eval(input()))
print(((10000-n)%1000))
|
p02612
|
import heapq
from collections import defaultdict, deque
from math import ceil, factorial, gcd
from itertools import accumulate, permutations
import bisect
# ----------
INF = float("inf")
MOD = 10 ** 9 + 7
# ----------
N = int(eval(input()))
print((ceil(N/1000)*1000-N))
|
N = int(eval(input()))
# 切り上げ
print((-(-N // 1000) * 1000 - N))
|
p02612
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.