input stringlengths 20 127k | target stringlengths 20 119k | problem_id stringlengths 6 6 |
|---|---|---|
N = int(eval(input()))
A = [int(x)-i for x,i in zip(input().split(),list(range(1,N+1)))]
from math import ceil,floor
A.sort()
if N%2 == 0:
b = round((A[floor(N/2)]+A[ceil(N/2)])/2)
else:
b = A[floor(N/2)]
ans = 0
for a in A:
ans += abs(a-b)
print(ans) | def main():
N = int(eval(input()))
A = list(map(int,input().split()))
B = [A[i-1] - i for i in range(1,N+1)]
B.sort()
b = B[N // 2] if N%2 == 1 else round((B[N // 2 - 1] + B[N // 2]) / 2)
print((sum([abs(bb -b) for bb in B])))
return
if __name__ == "__main__":
main() | p03309 |
def read_line(*types): return [f(a) for a, f in zip(input().split(), types)]
n, = read_line(int)
A = [int(x) for x in input().split()]
AA = [a - (i + 1) for i, a in enumerate(A)]
min_sadness = float('inf')
b = None
for i in range(min(AA), max(AA) + 1):
sadness = 0
for a in AA:
sadness += abs(a - i)
if min_sadness > sadness:
min_sadness = sadness
b = i
print(min_sadness)
| import math
def read_line(*types): return [f(a) for a, f in zip(input().split(), types)]
n, = read_line(int)
A = [int(x) for x in input().split()]
AA = [a - (i + 1) for i, a in enumerate(A)]
AA.sort()
if len(AA) % 2 == 0:
b = int(len(AA) / 2 - 1)
else:
b = int((len(AA) - 1) / 2)
sadness = 0
for i, a in enumerate(A):
# sadness1 += abs(a - (i + b1 + 1))
# sadness2 += abs(a - (i + b2 + 1))
sadness += abs(a - (i + AA[b] + 1))
print(sadness)
| p03309 |
n = int(eval(input()))
H = list(map(int,input().split()))
h = []
for i in range(n):
h.append(H[i]-(i+1))
h.sort()
M = h[n//2]
s = 0
for i in h:
s += abs(i-M)
print(s) | N = int(eval(input()))
A = list(map(int,input().split()))
for i in range(N):
A[i] -= i+1
A.sort()
M = A[N//2]
res = 0
for a in A:
res += abs(a-M)
print(res) | p03309 |
import copy
N=int(eval(input()))
li = list(map(int,input().split()))
for i in range(0,N):
li[i] = li[i] - i -1
a = []
d = copy.copy(li)
while len(d) >= 3:
d.remove(max(d))
d.remove(min(d))
for i in range(min(d),max(d)+1):
k = 0
for j in range(N):
k = k + abs(li[j]-i)
a.append(k)
print((min(a))) | n = int(eval(input()))
a = [int(i) for i in input().split()]
for i in range(0,len(a)):
a[i] -= (i+1)
a.sort()
b = [ abs(x - (a[n//2])) for x in a]
print((sum(b))) | p03309 |
import statistics
N = int(eval(input()))
a = [int(i) for i in input().split()]
ans = 0
for i in range(1,N+1):
a[i-1] -= i
b = statistics.median(a)
for i in range(N):
ans += abs(a[i]-b)
print((int(ans))) | N = int(eval(input()))
A = [int(i) for i in input().split()]
C = [A[i]-i for i in range(N)]
C.sort()
ans = 0
med = C[N//2]
for i in range(N):
ans += abs(C[i]-med)
print(ans) | p03309 |
import statistics
N = int(eval(input()))
A = list(map(int, input().split(' ')))
p = [v - (i + 1) for i, v in enumerate(A)]
res = sum(map(abs, [i - statistics.median(p) for i in p]))
print((int(res))) | N = int(eval(input()))
A = list(map(int, input().split(' ')))
p = sorted([v - (i + 1) for i, v in enumerate(A)])
if len(p) >= 3:
res = min(sum(map(abs, [i - p[N//2] for i in p])), sum(map(abs, [i - p[N//2-1] for i in p])), sum(map(abs, [i - p[N//2+1] for i in p])))
elif len(p) >= 2:
res = min(sum(map(abs, [i - p[0] for i in p])), sum(map(abs, [i - p[1] for i in p])))
else:
res = 0
print((int(res))) | p03309 |
N=int(eval(input()))
A=list(map(int,input().split()))
B=[A[i]-(i+1) for i in range(N)]
B.sort()
ans=float('inf')
for i in range(B[0],B[N-1]+1):
val=0
for j in range(N):
val+=abs(B[j]-i)
ans=min(ans,val)
print(ans) | N=int(eval(input()))
A=list(map(int,input().split()))
B=[A[i]-(i+1) for i in range(N)]
B.sort()
b=B[N//2]
ans=0
for i in range(N):
ans+=abs(B[i]-b)
print(ans) | p03309 |
n = int(eval(input()))
a = list(map(int, input().split()))
t = list(sorted(a[i] - (i + 1) for i in range(n)))
b = t[len(t) // 2]
print((sum(abs(a[i] - (b + i + 1)) for i in range(n))))
| from sys import stdin
n, *a = list(map(int, stdin.read().split()))
t = list(sorted(a[i] - (i + 1) for i in range(n)))
b = t[len(t) // 2]
print((sum(abs(a[i] - (b + i + 1)) for i in range(n))))
| p03309 |
n=int(eval(input()))
a=[int(i) for i in input().split()]
b=n*(-1)
k=0
ans=0
def sunuke(b):
ans=0
for i in range(n):
ans+=abs(a[i]-b-i-1)
return ans
while k<1:
if sunuke(b)<sunuke(b+1):
print((sunuke(b)))
k=1
else:
b+=1 | n=int(eval(input()))
a=[int(i) for i in input().split()]
for i in range(n):
a[i]-=i+1
a.sort()
if n % 2 == 0:
print((sum(a[int(n / 2):]) - sum(a[:int(n / 2)])))
else:
print((sum(a[int((n + 1) / 2):]) - sum(a[:int((n - 1) / 2)])))
| p03309 |
def f(x,i,n):
sadness = 0
for j in range(n):
sadness += abs(x[j]-i)
return(sadness)
N = int(eval(input()))
H = [int(i) for i in input().split()]
for i in range(N):
H[i] -= i+1
H = sorted(H)
D = f(H,1,N)
for i in range(N):
D = min(D,f(H,H[i],N))
print(D)
| def f(x,i,n):
sadness = 0
for j in range(n):
sadness += abs(x[j]-i)
return(sadness)
N = int(eval(input()))
H = [int(i) for i in input().split()]
for i in range(N):
H[i] -= i+1
H = sorted(H)
k = N // 2
if N == 1 :
print((0))
else:
print((f(H,H[k],N)))
| p03309 |
from statistics import median_low
n = (int)(eval(input()))
A = (list)(list(map(int,input().split())))
A = [v-i-1 for i,v in enumerate(A)]
x = median_low(A)
print((sum(abs(v - x) for v in A)))
| def median_low(A):
A.sort()
b=A
n = len(A)
if n%2==1:
med =b[n//2]
else:
x=b[n//2-1]
y=b[n//2]
med=(x+y)/2
if med!=int(med):
med=x
else:
med=int(med)
return med
n = (int)(eval(input()))
A = (list)(list(map(int,input().split())))
A = [v-i-1 for i,v in enumerate(A)]
x = median_low(A)
print((sum(abs(v - x) for v in A)))
| p03309 |
N = int(eval(input()))
A = list(map(int,input().split()))
B = list(range(-N//2 + 1, max(A)))
S = list()
s = 0
for b in B:
for idx, it in enumerate(A):
s += abs(it - (b+idx))
S.append(s)
s = 0
print((min(S))) | N = int(eval(input()))
A = list(map(int,input().split()))
B = [it - (idx + 1) for idx, it in enumerate(A)]
S = []
B.sort()
if N%2 == 1:
b = B[(N-1)//2]
else:
b = (B[(N-1)//2] + B[(N-1)//2 + 1]) // 2
S = sum([abs(i-b) for i in B])
print(S) | p03309 |
n=int(eval(input()))
lst=list(map(int,input().split()))
minu = min(lst)
maxi = max(lst)
sad = 1000000000000
for i in range(minu-maxi, maxi+minu+1):
temp = 0
for j in range(n):
temp += abs(lst[j] - i - (j+1))
if temp < sad:
sad = temp
print(sad) | n=int(eval(input()))
lst=list(map(int,input().split()))
for i in range(n):
lst[i] = lst[i] - 1 - i
lst.sort()
b=lst[n//2]
print((sum([abs(b - lst[j]) for j in range(n)]))) | p03309 |
def absFunc(A_, b):
result = 0
for a_ in A_:
result += abs(a_ - b)
return result
eval(input())
A = list(map(int, input().split()))
A_ = []
for i, a in enumerate(A):
A_.append(a - i - 1)
b = 0
result_o = absFunc(A_, b)
result_n = 0
while True:
b += 1
result_n = absFunc(A_, b)
if result_n < result_o:
result_o = result_n
continue
break
b = 0
while True:
b -= 1
result_n = absFunc(A_, b)
if result_n < result_o:
result_o = result_n
continue
break
print(result_o)
| N = int(eval(input()))
A = list(map(int, input().split()))
A_ = []
result = 0
for i, a in enumerate(A):
A_.append(a - i - 1)
b = sorted(A_)[N//2]
for a_ in A_:
result += abs(a_ - b)
print(result)
| p03309 |
N = int(eval(input()))
A = tuple(map(int, input().split()))
Bs = set()
for i in range(N):
Bs.add(A[i] - (i+1))
mins = sum(A)
for b in Bs:
s = 0
for i, a in enumerate(A):
s += abs(a - (b+i+1))
mins = min(mins, s)
print(mins) | N = int(eval(input()))
A = tuple(map(int, input().split()))
B = [a-(i+1) for i, a in enumerate(A)]
B = sorted(B)
b = B[len(B) // 2]
s = 0
for b_ in B:
s += abs(b_ - b)
print(s)
| p03309 |
N = int(eval(input()))
A = [int(i) for i in input().split()]
bmax = max(A)
bmin = min(A)-N
def getSadNess(b):
return sum([abs(A[i]-(b+i+1)) for i in range(N)])
def binSearch(bmin,bmax):
b = (bmin+bmax)//2
sadb = getSadNess(b)
sadm = getSadNess(b-1)
sadp = getSadNess(b+1)
if sadb<=sadp and sadb<=sadm:
return sadb
elif sadb>sadm:
return binSearch(bmin,b-1)
else:
return binSearch(b+1,bmax)
print((binSearch(bmin,bmax))) | N = int(eval(input()))
A = [int(i) for i in input().split()]
B = [A[i]-i-1 for i in range(N)]
B.sort()
b = N//2
ans = sum([abs(B[i]-B[b]) for i in range(N)])
print(ans) | p03309 |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
N= int(eval(input()))
A = list(map(int, input().split()))
def right(N, A):
X = [0] * N
for i in range(N):
X[i] = abs(A[i] - (i+1))
return max(X)
r = right(N, A)
#print(r)
ans = float('inf')
for b in range(-r, r+1):
c = 0
for i in range(1, N+1):
c += abs(A[i-1] - (b+i))
ans = min(ans, c)
print(ans) |
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
##############################
N = int(eval(input()))
A = list(map(int, input().split()))
a = [0] * len(A)
# bの値は中央値
# https://qiita.com/Noiri/items/291ae9bf4a2eacab6f5f
for i in range(N):
a[i] = A[i]-i-1
a.sort()
b = a[N // 2 - 1] if (N % 2 == 0) else a[(N + 1) // 2 - 1]
ans = 0
for i in range(N):
ans += abs(a[i] - b)
print(ans) | p03309 |
class Solver(object):
def __init__(self):
self.n = int(eval(input()))
self.a_s = list(map(int, input().split(" ")))
self._sadness = {}
def do_solve(self, b, length):
b = 0
current = self.sadness(b)
left = self.sadness(b-1)
right = self.sadness(b+1)
while True:
# print("{}: {} {} {}".format(b, left, current, right))
if (left >= current) and (right >= current):
return b
elif left < right: # go left
b -= 1
else: # go right
b += 1
current = self.sadness(b)
left = self.sadness(b-1)
right = self.sadness(b+1)
def solve(self):
b = self.a_s[0] - 1
for i in range(1, self.n+1):
b = self.do_solve(b, i)
print((self.sadness(b)))
def sadness(self, b):
if b not in self._sadness:
self._sadness[b] = sum(abs(self.a_s[i] - (b+i+1)) for i in range(self.n))
return self._sadness[b]
if __name__ == "__main__":
s = Solver()
s.solve() | class Solver(object):
def __init__(self):
self.n = int(eval(input()))
self.a_s = list(map(int, input().split(" ")))
self._sadness = {}
def solve(self):
array = self.a_s.copy()
for i in range(self.n):
array[i] -= i + 1
array.sort()
b = array[len(array) // 2]
print((self.sadness(b)))
def sadness(self, b):
if b not in self._sadness:
self._sadness[b] = sum(abs(self.a_s[i] - (b+i+1)) for i in range(self.n))
return self._sadness[b]
if __name__ == "__main__":
s = Solver()
s.solve() | p03309 |
import sys
N = int(eval(input()))
lists = [int(i) for i in input().split()]
sok = sys.maxsize
list2 = [xx - max(lists) for xx in range (2 * max(lists) + 1)]
for b in list2:
kanashi = 0
i = 1
for x in lists:
kanashi += abs(x - (b + i))
i += 1
if (kanashi < sok):
sok = kanashi
print(sok)
| def med(data):
N = len(data)
data.sort()
if N % 2 == 0:
median1 = N/2
median2 = N/2 + 1
median1 = int(median1) - 1
median2 = int(median2) - 1
median = (data[median1] + data[median2]) / 2
return median
else:
median = (N + 1) / 2
median = int(median) - 1
median = data[median]
return median
import sys
N = int(eval(input()))
lists = [int(i) for i in input().split()]
sok = sys.maxsize
list2 = [x - j - 1 for j, x in enumerate(lists)]
b = med(list2)
kanashi = 0
for xx in list2:
kanashi += abs(xx - b)
print((int(kanashi)))
| p03309 |
N = int(eval(input()))
B = [a - i -1 for i, a in enumerate(list(map(int, input().split())))]
b = sorted(B)[(N-1)//2]
ans = 0
for i in range(N):
ans += abs(B[i] - b)
print(ans) | N = int(eval(input()))
B = [a - i - 1 for i, a in enumerate(list(map(int, input().split())))]
b = sorted(B)[(N-1)//2]
print((sum([abs(B[i] - b) for i in range(N)])))
| p03309 |
N=eval(input())
N=int(N)
M=list(map(int,input().split()))
for i in range(N):
M[i]=M[i]-(i+1)
min=10**14
for i in range(N):
sum=0
p=M[i]
for j in range(N):
sum=sum+abs(M[j]-p)
if sum<min:
min=sum
print(min)
| N=eval(input())
N=int(N)
M=list(map(int,input().split()))
for i in range(N):
M[i]=M[i]-(i+1)
M.sort()
if N%2==0:
p=int((M[int(N/2)-1]+M[int(N/2)])/2)
else:
p=M[int((N+1)/2)-1]
sum=0
for i in range(N):
sum=sum+abs(M[i]-p)
print(sum)
| p03309 |
import copy
def get_diff(value, array):
diff = 0
for i in array:
diff += abs(value - i)
return diff
length = int(eval(input()))
inp = input().split(' ')
A = []
for i in range(0, length):
A.append(int(inp[i]) - i - 1)
initial = int(sum(A)/len(A))
initial_diff = int(get_diff(initial, A))
end_flag = 1
initial_plus = copy.copy(initial)
max_diff = copy.copy(initial_diff)
# print(A)
# print(initial)
# print(initial_diff)
while end_flag == 1:
initial_plus += 1
if get_diff(initial_plus, A) < max_diff:
max_diff = get_diff(initial_plus, A)
print(max_diff)
else:
end_flag = 0
plus_max_diff = max_diff
end_flag = 1
initial_plus = copy.copy(initial)
max_diff = copy.copy(initial_diff)
while end_flag == 1:
initial_plus -= 1
if get_diff(initial_plus, A) < max_diff:
max_diff = get_diff(initial_plus, A)
else:
end_flag = 0
minus_max_diff = max_diff
print((min(plus_max_diff, initial_diff, minus_max_diff))) | """
中央値を求めれば良い.
"""
def get_diff(value, array):
diff = 0
for i in array:
diff += abs(value - i)
return diff
length = int(eval(input()))
inp = input().split(' ')
A = []
for i in range(0, length):
A.append(int(inp[i]) - i - 1)
A.sort()
# print(A)
# odd numbers
if len(A) % 2 == 1:
center_number = A[len(A) // 2]
else:
center_number = int(A[len(A) // 2 ] + A[len(A) // 2]) / 2
# print(center_number)
print((int(get_diff(center_number, A)))) | p03309 |
n=int(eval(input()))
a=list(map(int,input().split()))
for i in range(n):
a[i]-=i+1
#print(a)
a.sort()
w=10**9
for j in range(a[0],a[n-1]+1):
s=0
for k in range(n):
s+=abs(a[k]-j)
if s<w :
w=s
print(w) | n=int(eval(input()))
a=list(map(int,input().split()))
for i in range(n):
a[i]-=i+1
#print(a)
a.sort()
#bはaの最小から最大まで
x=0
z=n-1
y=(x+z)//2
while z!=x:
s1=0
s2=0
for k in range(n):
s1+=abs(a[k]-a[y])
for k in range(n):
s2+=abs(a[k]-a[y+1])
if s1<s2 :
z=y
y=(x+z)//2
elif s1==s2:
x=y
z=y
else:
x=y+1
y=(x+z)//2
#x=y=zとなっている
s=0
for k in range(n):
s+=abs(a[k]-a[y])
print(s) | p03309 |
N = int(eval(input()))
A_list = list(map(int, input().split()))
A_sub_list = [a - (i + 1) for i, a in enumerate(A_list)]
b_max = max(A_sub_list)
b_min = min(A_sub_list)
min_s = pow(10, 10)
for b in range(b_min, b_max + 1):
s = sum([abs(a - b) for a in A_sub_list])
min_s = min(min_s, s)
print(min_s) | N = int(eval(input()))
A_list = list(map(int, input().split()))
B_list = [a - (i + 1) for i, a in enumerate(A_list)]
B_list.sort()
b = B_list[int(len(B_list) / 2)]
s = sum([abs(B - b) for B in B_list])
print(s) | p03309 |
n=int(eval(input()))
a=list(map(int,input().split()))
dp=[0]*n
for i in range(n):
dp[i]=a[i]-i
dp.sort()
ans=0
for j in range(n):
ans+=abs(dp[j]-dp[n//2])
print(ans)
| n=int(eval(input()))
a=list(map(int,input().split()))
dp=[0]*n
for i in range(n):
dp[i]=a[i]-i
dp.sort()
print((sum(abs(x-dp[n//2]) for x in dp))) | p03309 |
n = int(eval(input()))
a = list(map(int, input().split()))
a2 = []
for i in range(n):
a2.append(a[i]-i-1)
a3 = []
for i in range(n):
m = min(a2)
a3.append(m)
a2.remove(m)
if n % 2 == 0:
b = (a3[n//2-1]+a3[n//2])//2
else:
b = a3[n//2]
s = 0
for i in a3:
s += abs(i-b)
print(s) | n = int(eval(input()))
a = list(map(int, input().split()))
a2 = []
mi = 0
for i in range(n):
a2.append(a[i]-i-1)
a3 = sorted(a2)
if n % 2 == 0:
b = (a3[n//2-1]+a3[n//2])//2
else:
b = a3[n//2]
s = 0
for i in a3:
s += abs(i-b)
print(s) | p03309 |
n = int(eval(input()))
aa = list(map(int,input().split()))
a = []
for i in range(n):
a.append(aa[i]-(i+1))
b = {}
for i in a:
if i in b:
b[i] += 1
else:
b.update({i:1})
ans_l = []
for k in list(b.keys()):
counts = 0
for k_, val in list(b.items()):
counts += (abs(k - k_)) * val
ans_l.append(counts)
print((min(ans_l))) | n = int(eval(input()))
aa = list(map(int,input().split()))
a = []
for i in range(n):
a.append(aa[i]-(i+1))
b = list(sorted(a))
ans = 0
for i in range(n//2):
ans += b[-i-1] - b[i]
print(ans)
| p03309 |
N = int(eval(input()))
A = [int(i) for i in input().split()]
A = [A[_] - (_ + 1) for _ in range(N)]
AA = sorted(A)
ans = 0
ans1 = 0
center = N // 2
num = AA[center]
if N % 2 != 0:
for i in range(N):
ans += abs(AA[i] - num)
print(ans)
else:
center = len(AA) // 2
for i in range(N):
ans += abs(AA[i]- num)
ans1 += abs(AA[i]-(AA[center-1]))
print((min(ans, ans1))) | N = int(eval(input()))
A = [int(i) for i in input().split()]
for i in range(N):
A[i] -= (i+1)
A.sort()
if N % 2 != 0:
num = A[N//2]
A = [abs(i - num) for i in A]
print((sum(A)))
else:
num1 = A[N//2]
num2 = num1 -1
A1 = [abs(i - num1) for i in A]
A2 = [abs(i - num2) for i in A]
print((min(sum(A1), sum(A2)))) | p03309 |
n = int(eval(input()))
a = [int(_) for _ in input().split()]
i = 1
result = 0
result2=[]
for b in range(abs(max(a))*-1,abs(max(a))):
for data in a:
result = result + abs(data - b -i)
i += 1
result2.append(result)
result = 0
i = 0
print((min(result2))) | n = int(eval(input()))
a = [int(_) for _ in input().split()]
B = [ av - i for i, av in enumerate(a,1)]
B.sort()
middle = n //2
b = B[middle]
result = 0
for a2 in B:
result = result + abs(a2 -b)
print(result) | p03309 |
n = int(eval(input()))
A = list(map(int, input().split()))
B = []
for i in range(n): B.append(A[i] - (i+1))
B.sort()
r = B[n//2] # median right
l = B[n//2] if n%2 else B[n//2-1] # median left
# print(n,A)
# print(B)
# print(l,r)
ans_l = 0
ans_r = 0
for bi in B:
ans_l += abs(bi-l)
ans_r += abs(bi-r)
print((min([ans_l, ans_r])))
| n = int(eval(input()))
B = list(a-i for i,a in zip(list(range(1,n+1)), list(map(int,input().split()))))
B.sort()
l = r = B[n//2] # median left, right
if n%2 == 0: l -= 1 # left fix
ans_l, ans_r = 0, 0
for bi in B:
ans_l += abs(bi-l)
ans_r += abs(bi-r)
print((min([ans_l, ans_r])))
| p03309 |
n = int(eval(input()))
B = list(a-i for i,a in zip(list(range(1,n+1)), list(map(int,input().split()))))
B.sort()
l = r = B[n//2] # median left, right
if n%2 == 0: l -= 1 # left fix
ans_l, ans_r = 0, 0
for bi in B:
ans_l += abs(bi-l)
ans_r += abs(bi-r)
print((min([ans_l, ans_r])))
| n = int(eval(input()))
B = list(a-i-1 for i,a in zip(list(range(n)), list(map(int,input().split()))))
B.sort()
ans = sum(B[n//2 + (n%2) :]) - sum(B[: n//2]) # sum(median left) - sum(median right)
print(ans)
| p03309 |
n = int(eval(input()))
a = list(map(int, input().split()))
aa = sorted([a[i]-i-1 for i in range(n)])
aa = [_-min(aa) for _ in aa]
if n % 2 == 1:
idx = n // 2
res = 0
for ai in aa[:idx]:
res += aa[idx] - ai
for ai in aa[idx:]:
res += ai - aa[idx]
else:
idx_1 = n // 2 -1
idx_2 = n // 2
res_1 = 0
for ai in aa[:idx_1]:
res_1 += aa[idx_1] - ai
for ai in aa[idx_1:]:
res_1 += ai - aa[idx_1]
res_2 = 0
for ai in aa[:idx_2]:
res_2 += aa[idx_2] - ai
for ai in aa[idx_2:]:
res_2 += ai - aa[idx_2]
res = min(res_1, res_2)
print(res) | n = int(eval(input()))
a = list(map(int, input().split()))
aa = sorted([a[i]-i-1 for i in range(n)])
if n % 2 == 1:
idx = n // 2
res = 0
for ai in aa[:idx]:
res += aa[idx] - ai
for ai in aa[idx:]:
res += ai - aa[idx]
else:
idx_1 = n // 2 -1
idx_2 = n // 2
res_1 = 0
for ai in aa[:idx_1]:
res_1 += aa[idx_1] - ai
for ai in aa[idx_1:]:
res_1 += ai - aa[idx_1]
res_2 = 0
for ai in aa[:idx_2]:
res_2 += aa[idx_2] - ai
for ai in aa[idx_2:]:
res_2 += ai - aa[idx_2]
res = min(res_1, res_2)
print(res) | p03309 |
N=int(eval(input()))
a=list(map(int,input().split()))
a=[a[i]-i for i in range(N)]
from statistics import median
print((sum([abs(b-int(median(a))) for b in a]))) | N=int(eval(input()))
a=list(map(int,input().split()))
a=[a[i]-i for i in range(N)]
from statistics import median
m=int(median(a))
print((sum([abs(b-m) for b in a]))) | p03309 |
N = int(eval(input()))
A = list(map(int,input().split()))
for x in range(N):
A[x] -= (x+1)
sorted_A = sorted(A)
if len(A) == 1:
ans = 0
elif N % 2 == 1 and not len(A) == 1 :
ans = sum([abs(x-sorted_A[N//2+2]) for x in A])
for x in range(sorted_A[N//2],sorted_A[N//2+2]):
y = sum([abs(z -x) for z in A])
if ans > y :
ans = y
else:
ans = sum([abs(x-sorted_A[N//2+1]) for x in A])
for x in range(sorted_A[N//2],sorted_A[N//2+1]):
y = sum([abs(z -x) for z in A])
if ans > y :
ans = y
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
for x in range(N):
A[x] -= (x+1)
sorted_A = sorted(A)
if len(A) == 1:
ans = 0
else:
ans = sum([abs(x-sorted_A[N//2]) for x in A])
print(ans) | p03309 |
import statistics
n = int(eval(input()))
a_list = list(map(int, input().split()))
pro_list = [a_list[i-1] - i for i in range(1, n+1)]
ave = int(statistics.mean(pro_list))
b_list = [ave - 1 for i in range(5000)] + [ave + i for i in range(5000)]
ans = [sum([abs(pro-b)for pro in pro_list]) for b in b_list]
print((min(ans))) | import statistics
n = int(eval(input()))
a_list = list(map(int, input().split()))
pro_list = [a_list[i-1] - i for i in range(1, n+1)]
ave = int(statistics.mean(pro_list))
med = int(statistics.median(pro_list))
b_list = [ave - 1 for i in range(10)] + [ave + i for i in range(10)]
b_list += [med - 1 for i in range(10)] + [med + i for i in range(10)]
ans = [sum([abs(pro-b)for pro in pro_list]) for b in b_list]
print((min(ans))) | p03309 |
n=int(eval(input()))
a=list(map(int,input().split()))
c=[a[i]-i-1 for i in range(n)]
cum_c=[0]*n
c.sort()
cum_c[0]=c[0]
for i in range(1,n):
cum_c[i]=cum_c[i-1]+c[i]
ans=min(cum_c[n-1]-n*c[0],n*c[n-1]-cum_c[n-1])
for i in range(1,n):
for b in range(c[i-1],c[i]+1):
ans=min(ans,cum_c[n-1]-2*cum_c[i-1]+(2*i-n)*b)
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
c=[a[i]-i-1 for i in range(n)]
cum_c=[0]*n
c.sort()
cum_c[0]=c[0]
for i in range(1,n):
cum_c[i]=cum_c[i-1]+c[i]
ans=min(cum_c[n-1]-n*c[0],n*c[n-1]-cum_c[n-1])
for i in range(1,n):
ans=min(ans,cum_c[n-1]-2*cum_c[i-1]+(2*i-n)*c[i-1])
ans=min(ans,cum_c[n-1]-2*cum_c[i-1]+(2*i-n)*c[i])
print(ans) | p03309 |
def abs(x):
if x>0:
return x
else:
return x * (-1)
if __name__ == '__main__':
n = int(eval(input()))
a = list(map(int, input().split()))
a_mi = list(a[idx] - (idx + 1) for idx in range(len(a)))
a_mi_sorted = sorted(a_mi)
a_mi_sorted.append(a_mi_sorted[-1]+1)##bのrangeを取るため
setAMI = sorted(list(set(a_mi_sorted)))
##print(a_mi_sorted)
ans = float('inf')
for i in range(n):
#i番目までa[i]-bが0以下（absで負扱い）
buf = sum(a_mi_sorted[:n]) - 2 * (sum(a_mi_sorted[:i+1]))
for b in range(a_mi_sorted[i], setAMI[setAMI.index(a_mi_sorted[i])+1]):
ans = min(ans, buf + (2 * (i + 1) - n) * b)
##print(i,b,ans)
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
B = list(A_i - (i + 1) for i, A_i in enumerate(A))
B_sorted = sorted(B)
ans = []
##中央値のインデックスmを求める
if N % 2 == 1:
##Nが奇数: 中央値のインデックスを求める
m = int((N - 1) / 2 + 1) - 1
b = B_sorted[m]
ans += [sum(abs(x - b) for x in B_sorted)]
else:
##Nが偶数: 中央値を計算する元になる2数のインデックスを求める
for m in range(int(N / 2) - 1, int(N / 2) + 1):
b = B_sorted[m]
ans += [sum(abs(x - b) for x in B_sorted)]
print((min(ans))) | p03309 |
from operator import sub
N = int(eval(input()))
a = tuple(map(int, input().split()))
b = list(map(sub, a, list(range(1, N + 1))))
b.sort()
mb = b[N // 2]
print((sum([abs(x - mb) for x in b])))
| n = int(eval(input()))
*a, = list(map(int, input().split()))
a = [x - i for i, x in enumerate(a, 1)]
a.sort()
m = n // 2
b = a[m] if n % 2 == 1 else (a[m - 1] + a[m]) // 2
print((sum(abs(x - b) for x in a)))
| p03309 |
# coding: utf-8
import statistics
n = int(eval(input()))
a = list(map(int, input().split()))
for i,num in enumerate(a):
a[i] = a[i] - (i + 1)
b = int(statistics.median(a))
res = 0
for i in a:
res += abs(i - b)
print(res)
| # coding: utf-8
import statistics
n = int(eval(input()))
a = list(map(int, input().split()))
for i,num in enumerate(a):
a[i] = a[i] - (i + 1)
b = statistics.median_low(a)
res = 0
for i in a:
res += abs(i - b)
print(res)
| p03309 |
n = int(eval(input()))
arr = list(map(int, input().split()))
A = sorted([a-i for i, a in enumerate(arr, 1)])
print((sum(abs(a-A[n//2]) for a in A))) | # マンハッタン距離の総和を最小化するときは、中央値を使うという典型がある。
N = int(eval(input()))
A = [int(a)-i for i, a in enumerate(input().split(), 1)]
A.sort()
b = A[N//2]
ans = sum([abs(a-b) for a in A])
print(ans)
| p03309 |
n = int(eval(input()))
a = list(map(int, input().split()))
b = [(a[i]-i-1) for i in range(n)]
#print(b)
s = sum(b)
m = int(s/n)
ans = float('inf')
if m<0:
m = m-1
for i in range(m, 1, 1):
res = 0
for j in range(n):
res += abs(b[j]-i)
ans = min(ans, res)
else:
m = m+1
for i in range(m+1):
res = 0
for j in range(n):
res += abs(b[j]-i)
ans = min(ans, res)
print(ans) | n = int(eval(input()))
a = list(map(int, input().split()))
b = [(a[i]-i-1) for i in range(n)]
b = sorted(b)
if n % 2 == 1:
res = b[(n-1)//2]
else:
res = (b[n//2-1] + b[n//2])//2
print((sum(map(abs, [b[i]-res for i in range(n)])))) | p03309 |
# -*- coding: utf-8 -*-
INF = 10**10
n = int(eval(input()))
a = [int(_) - (i + 1) for i, _ in enumerate(input().split())]
grief = INF
for b in set(a):
tmp = sum([abs(ai - b) for ai in a])
if tmp < grief:
bb = b
grief = tmp
print(grief)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
a = [int(_) - (i + 1) for i, _ in enumerate(input().split())]
# INF = 10**10
# grief = INF
# for b in set(a):
# tmp = sum([abs(ai - b) for ai in a])
# if tmp < grief:
# bb = b
# grief = tmp
# print(grief) # running time limit error
a.sort()
med = a[len(a) // 2]
grief = sum([abs(ai - med) for ai in a])
print(grief)
| p03309 |
# -*- coding: utf-8 -*-
import sys
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 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m+i+1))
return sm
# 三分探索
low = -INF
hi = INF
while low+2 < hi:
m1 = (low*2+hi) // 3
m2 = (low+hi*2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
ans = INF
for i in range(low, low+2):
ans = min(ans, check(i))
print(ans)
| # -*- coding: utf-8 -*-
import sys
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 ** 9)
INF = 10 ** 18
MOD = 10 ** 9 + 7
N = INT()
A = LIST()
# bをmとした時の悲しさ値
def check(m):
sm = 0
for i, a in enumerate(A):
sm += abs(a - (m+i+1))
return sm
# 三分探索
low = -10**9
hi = 10**9
while low+2 < hi:
m1 = (low*2+hi) // 3
m2 = (low+hi*2) // 3
res1 = check(m1)
res2 = check(m2)
# 今回は下に凸な関数なので値の小さい方に向かって狭めていく
if res1 <= res2:
hi = m2
else:
low = m1
print((min(check(m1), check(m2))))
| p03309 |
n = int(eval(input()))
a = list(map(int,input().split()))
ami = [a[i]-(i+1) for i in range(n)]
ami.sort()
# print(ami)
ans = 0
if n % 2 == 1:
for i in range(n):
ans += abs(ami[i]-ami[n//2])
else:
cnt1 = 0
cnt2 = 0
for i in range(n):
cnt1 += abs(ami[i]-ami[n//2])
cnt2 += abs(ami[i]-ami[n//2-1])
ans = min(cnt1,cnt2)
print(ans)
| n = int(eval(input()))
a = list(map(int,input().split()))
ami = [a[i]-(i+1) for i in range(n)]
ami.sort()
# print(ami)
ans = 0
for i in range(n):
ans += abs(ami[i] - ami[n // 2])
print(ans)
| p03309 |
N = int(eval(input()))
A = list(map(int, input().split()))
ans = 0
sub = []
for i, a in enumerate(A, 1):
sub.append(a - i)
ans += abs(a - i)
#print(sub)
#b = min(sub)
for b in range(min(sub), max(sub) + 1):
#cand = 0
cand = sum([abs(s - b) for s in sub])
#for s in sub:
# cand += abs(s - b)
ans = min(ans, cand)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
for i, a in enumerate(A):
A[i] = a - i
A = sorted(A)
b = A[len(A)//2]
ans = 0
for a in A:
ans += abs(a - b)
print(ans)
| p03309 |
import math
import statistics
N = int(eval(input()))
L = [i for i in map(int,input().split())]
Q = []
for i in range(len(L)):
Q.append(L[i] - (i+1))
b = statistics.median(Q)
a = b - 1
c = b + 1
res = 0
res2 = 0
res3 = 0
for i in range(N):
res += abs(L[i] - (i+1) - b)
res2 += abs(L[i] - (i+1) - a)
res3 += abs(L[i] - (i+1) - c)
print((int(min(res,res2,res3)))) | import math
import statistics
N = int(eval(input()))
L = [i for i in map(int,input().split())]
Q = []
for i in range(len(L)):
Q.append(L[i] - (i+1))
b = statistics.median(Q)
res = 0
for i in range(N):
res += abs(L[i] - (i+1) - b)
print((int(res)))
| p03309 |
n = int(eval(input()))
a = list(map(int, input().split()))
for j in range(n):
a[j] = a[j] - (j + 1)
a.sort()
asum = sum(a)
sadlist = [asum - n * a[0]]
for i in range(1, n+1):
sad = asum - 2 * sum(a[:i])
if i < n/2:
sad = sad - (n - 2 * i) * a[i]
elif i > n/2:
sad = sad - (n - 2 * i) * a[i-1]
else:
pass
sadlist.append(sad)
if sad == 0 or sadlist[-2] < sad:
break
print((min(sadlist))) | n = int(eval(input()))
a = list(map(int, input().split()))
for j in range(n):
a[j] = a[j] - (j + 1)
a.sort()
if n % 2 == 0:
print((sum(a[int(n / 2):]) - sum(a[:int(n / 2)])))
else:
print((sum(a[int((n + 1) / 2):]) - sum(a[:int((n - 1) / 2)]))) | p03309 |
n = int(input())
a = list(map(int, input().split()))
for i in range(len(a)):
a[i] -= (i+1)
min_total = sum([abs(t) for t in a])
for item in a:
total = sum([abs(t-item) for t in a])
if total < min_total:
min_total = total
print(min_total)
| n = int(input())
a = list(map(int, input().split()))
for i in range(len(a)):
a[i] -= (i+1)
b = sorted(a)
i = n // 2
what = b[i]
print((sum([abs(t - what) for t in b])))
| p03309 |
N=int(eval(input()))
A=[a-i-1 for i,a in enumerate(map(int,input().split()))]
k=sum(A)//N+1
print((min(sum(abs(a-x)for a in A)for x in range(min(0,k-1),max(k+1,1))))) | N=int(eval(input()))//2
A=sorted(a-i-1 for i,a in enumerate(map(int,input().split())))
print((sum(abs(a-A[N])for a in A))) | p03309 |
N = int(eval(input()))
A = list(map(int, input().split()))
#b_init = sum(A)//N - N*(N+1)//(2*N)
b_init = min(A) + N*(N+1)//(2*N)
while 1:
#calculate sadness
sadness = sum([abs(A[i] - (b_init+(i+1))) for i in range(N)])
sadness_plus1 = sum([abs(A[i] - (b_init+1+(i+1))) for i in range(N)])
sadness_minus1 = sum([abs(A[i] - (b_init-1+(i+1))) for i in range(N)])
# initial equal ans
if sadness <= sadness_plus1 and sadness <= sadness_minus1:
print(sadness)
break
# right way
if sadness_plus1 < sadness:
sad_righter = sadness_plus1
b = b_init
while sad_righter <= sadness:
b+=1
sadness = sad_righter
sad_righter = sum([abs(A[i] - (b+(i+1))) for i in range(N)])
print(sadness)
break
# left way
if sadness_minus1 < sadness:
sad_lefter = sadness_minus1
b = b_init
while sad_lefter <= sadness:
b-=1
sadness = sad_lefter
sad_lefter = sum([abs(A[i] - (b+(i+1))) for i in range(N)])
print(sadness)
break | N = int(eval(input()))
A = list(map(int, input().split()))
if N==1:
print((0))
else:
B = [A[i]-i for i in range(N)]
B.sort()
b_pl = B[N//2]
b_mn = B[N//2-1]
sadness_pl = sum([abs(B[i]-b_pl) for i in range(N)])
sadness_mn = sum([abs(B[i]-b_mn) for i in range(N)])
print((min(sadness_pl, sadness_mn))) | p03309 |
N = int(eval(input()))
A = list(map(int,input().split()))
#N = 1
#A = [10**9]*N
A_n = [A[i-1] - i for i in range(1,N+1)]
A_n.sort()
if N%2 == 0:
cent_max = A_n[N//2]
cent_min = A_n[N//2-1]
else:
cent = A_n[N//2]
if N%2 == 0:
sadness1 = sum([abs(A_n[i]-cent_min) for i in range(N)])
sadness2 = sum([abs(A_n[i]-cent_max) for i in range(N)])
sadness = min(sadness1, sadness2)
else:
sadness = sum([abs(A_n[i]-cent) for i in range(N)])
print(sadness) | import sys
stdin = sys.stdin
sys.setrecursionlimit(10**5)
def li(): return list(map(int, stdin.readline().split()))
def li_(): return [int(x)-1 for x in stdin.readline().split()]
def lf(): return list(map(float, stdin.readline().split()))
def ls(): return stdin.readline().split()
def ns(): return stdin.readline().rstrip()
def lc(): return list(ns())
def ni(): return int(stdin.readline())
def nf(): return float(stdin.readline())
n = ni()
a = list(li())
amini = [ai-(i+1) for i,ai in enumerate(a)]
amini.sort()
b = amini[n//2]
print((sum([abs(ai-(b+i+1)) for i, ai in enumerate(a)]))) | p03309 |
N = int(eval(input()))
A = list(map(int, input().split()))
B = [A[i] - 1 - i for i in range(N)]
B.sort()
if N % 2 == 0:
med = [B[int(N / 2) - 1], int((B[int(N / 2) - 1] + B[int(N / 2)]) / 2), B[int(N / 2)]]
else:
med = [B[int((N + 1) / 2) - 1]]
ans = 10 ** 100
for b in med:
S = 0
for i in range(N):
S += abs(B[i] - b)
ans = min(ans, S)
print(ans)
| N = int(eval(input()))
A = list(map(int, input().split()))
B = [A[i] - 1 - i for i in range(N)]
B.sort()
if N % 2 == 0:
med = int((B[int(N / 2) - 1] + B[int(N / 2)]) / 2)
else:
med = B[int((N + 1) / 2) - 1]
S = 0
for i in range(N):
S += abs(B[i] - med)
print(S)
| p03309 |
N=int(eval(input()))
A=list(map(int,input().split()))
total=0
total2=0
count=1
ans=0
for i in range(N):
total+=A[i]
for i in range(1,N+1):
total2+=i
while True:
if total>total2:
if total//N+total%N>total2:
count+=(total-total//N+total%N)//N
total=total//N+total%N
else:
break
elif total<total2:
if total+total*N<total2:
count+=total
total+=total*N
else:
break
else:
break
if total>total2:
while True:
total2 +=N
count+=1
if total2>=total:
if abs(total2-total)<=abs(total2-total-N):
break
else:
count-=1
break
elif total<total2:
while True:
total2 -=N
count-=1
if total2<=total:
if abs(total2-total)<=abs(total2-total-N):
break
else:
count+=1
break
for i in range(N):
ans+=abs(A[i]-count)
count+=1
print(ans)
| N=int(eval(input()))
A=list(map(int,input().split()))
B=[]
total=0
for i in range(N):
B.append(A[i]-i-1)
B.sort()
#print(B)
if len(A)%2==1:
for i in range(N):
total+=abs(A[i]-(B[len(B)//2]+i+1))
#print(B[len(B)//2+1],total)
else:
for i in range(N):
total+=abs(A[i]-(B[len(B)//2]+i+1))
print(total)
| p03309 |
import statistics
N = int(eval(input()))
A = [int(a)-(i+1) for i, a in enumerate(input().split())]
ans = float('inf')
medi = int(statistics.median(A))
for b in range(medi-1, medi+2):
ans = min(ans, sum([abs(A[i]-b) for i in range(N)]))
print(ans)
| def calc_sadness(b):
ans = 0
for a in A:
ans += abs(a - b)
return ans
N = int(eval(input()))
A = []
for idx, a in enumerate(map(int, input().split())):
A.append(a - idx - 1)
A.sort()
if N % 2 == 0:
b = [A[N // 2]]
else:
b = [A[N // 2 - 1], A[N // 2]]
print((min(list(map(calc_sadness, b)))))
| p03309 |
n=int(eval(input()))
a=[int(x) for x in input().split()]
s=[0 for x in range(n)]
for i in range(n):
a[i] -= i+1
a.sort()
if n%2:
s=0
for i in range(n):
s += abs(a[i]-a[n//2])
print(s)
else:
m=10**14
for i in range(a[n//2-1],a[n//2]+1):
s = 0
for j in range(n):
s += abs(a[j]-i)
m = min(m,s)
print(m)
| n=int(eval(input()))
a=[int(x) for x in input().split()]
s=[0 for x in range(n)]
for i in range(n):
a[i] -= i+1
a.sort()
s = 0
for j in range(n):
s += abs(a[j]-a[n//2])
print(s)
| p03309 |
N=int(eval(input()))
A=list(map(int,input().split()))
def kei(b):
ANS=0
for i in range(N):
ANS+=abs(A[i]-(b+i+1))
return ANS
x=kei(A[0])
for i,j in enumerate(A):
x=min(x,kei(j-i-1))
print(x) | N=int(eval(input()))
A=list(map(int,input().split()))
B=[None]*N
for i in range(N):
B[i]=A[i]-i-1
B.sort()
Left=0
Right=sum(B)-B[0]*N
ANS=Left+Right
#print(B)
#print(Left,Right)
for i in range(1,N):
Left=Left+(B[i]-B[i-1])*i
Right=Right-(B[i]-B[i-1])*(N-i)
#print(Left,Right)
if ANS>Left+Right:
ANS=Left+Right
print(ANS)
| p03309 |
N=int(eval(input()))
A=list(map(int, input().split()))
x = [A[i-1]-i for i in range(1, N+1)]
x.sort()
if len(x)%2==1:
mid = x[len(x)//2]
ans = 0
for i in range(1, N+1):
ans += abs(A[i-1]-(mid+i))
print(ans)
else:
mid1 = x[len(x)//2-1]
mid2 = x[len(x)//2]
ans1 = ans2 = 0
for i in range(1, N+1):
ans1 += abs(A[i-1]-(mid1+i))
ans2 += abs(A[i-1]-(mid2+i))
print((min(ans1, ans2))) | N=int(eval(input()))
A=list(map(int, input().split()))
x = [A[i-1]-i for i in range(1, N+1)]
x.sort()
mid = x[len(x)//2]
ans = 0
for i in range(1, N+1):
ans += abs(A[i-1]-(mid+i))
print(ans) | p03309 |
from functools import lru_cache
N = int(eval(input()))
A = list(map(int, input().split()))
def search_wb():
sub = 1
max_abs = abs(A[0] - sub)
for a in A:
if max_abs < abs(a - sub):
max_abs = abs(a-sub)
sub += 1
return max_abs, -max_abs
@lru_cache(maxsize=None)
def sunuke(b):
ret = 0
sub = 1
for a in A:
ret += abs(a - (b+ sub))
sub += 1
return ret
maxb, minb= search_wb()
while abs(maxb - minb) > 1:
mid = (maxb + minb) // 2
#print("max{} min{} mid{}".format(maxb, minb, mid))
if sunuke(mid) > sunuke(mid + 1):
minb = mid
else:
maxb = mid
mins = sunuke(minb)
maxs = sunuke(maxb)
if mins < maxs:
print(mins)
else:
print(maxs)
| N = int(eval(input()))
A = list(map(int, input().split()))
def sunuke(b):
ret = 0
sub = 1
for a in A:
ret += abs(a - (b+ sub))
sub += 1
return ret
B = []
sub = 1
for a in A:
b = a - sub
B.append(b)
sub += 1
B.sort()
b1 = N // 2
if N < 3:
print((sunuke(B[b1])))
exit()
b2 = b1 + 1
b1_s = sunuke(B[b1])
b2_s = sunuke(B[b2])
if b1_s < b2_s:
print(b1_s)
else:
print(b2_s)
| p03309 |
n = int(eval(input()))
li = list(map(int,input().split()))
for i in range(n):
li[i] -= i+1
li.sort()
ans = 10**15
for i in range(n):
ans = min(ans,i*li[i]-sum(li[:i])+sum(li[i:])-(n-i)*li[i])
print(ans) | n = int(eval(input()))
li = list(map(int,input().split()))
for i in range(n):
li[i] -= i+1
li.sort()
if n%2 == 0:
print((sum(li[int(n/2):])-sum(li[:int(n/2)])))
else:
tmp = int((n-1)/2)
print((sum(li[tmp+1:])-sum(li[:tmp]))) | p03309 |
import sys
N = int(eval(input()))
A_list = list(map(int, input().split()))
dif = []
for idx, v in enumerate(A_list, 1):
dif.append(v - idx)
b = 0
dif_num = sum(map(abs, ([x + b for x in dif])))
b = 1
dif_num_plus = sum(map(abs, ([x + b for x in dif])))
b = -1
dif_num_minus = sum(map(abs, ([x + b for x in dif])))
if dif_num <= dif_num_plus and dif_num < dif_num_minus:
print(dif_num)
sys.exit()
p_f = True
if dif_num_plus < dif_num_minus:
p_f = True
b = 1
else:
p_f = False
b = -1
dif_num = min(dif_num, dif_num_plus, dif_num_minus)
while True:
if p_f:
b += 1
else:
b -= 1
l = list(([x + b for x in dif]))
dif_num2 = sum(map(abs, ([x + b for x in dif])))
if dif_num2 < dif_num:
dif_num = dif_num2
else:
break
print(dif_num)
| N = int(eval(input()))
A_list = list(map(int, input().split()))
dif = []
for idx, v in enumerate(A_list, 1):
dif.append(v - idx)
dif.sort()
if len(dif) % 2 == 1:
b = dif[len(dif) // 2]
print((sum(map(abs, ([x - b for x in dif])))))
else:
b1 = dif[len(dif) // 2 - 1]
b2 = dif[len(dif) // 2]
print((min(sum(map(abs, ([x - b1 for x in dif]))),
sum(map(abs, ([x - b2 for x in dif]))))))
| p03309 |
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
A = [a[i] - i - 1 for i in range(n)]
ave = sorted(A)[n//2]
ans = sum([abs(A[i]-ave) for i in range(n)])
print(ans) | n = int(eval(input()))
a = list(map(int,input().split()))
A = [a[i] - i - 1 for i in range(n)]
ave = sorted(A)[n//2]
ans = sum([abs(A[i]-ave) for i in range(n)])
print(ans) | p03309 |
from collections import Counter
N = int(eval(input()))
A = list(map(int,input().split()))
B = [a-i-1 for i,a in enumerate(A)]
ctr = Counter(B)
st = sorted(list(ctr.items()))
left = l_sum = 0
ans = r_sum = sum([(k - st[0][0])*v for k,v in st[1:]])
for (k1,v1),(k2,v2) in zip(st,st[1:]):
left += v1
l_sum += left * (k2-k1)
right = N-left
r_sum -= right * (k2-k1)
ans = min(ans, l_sum + r_sum)
print(ans) | N = int(eval(input()))
A = list(map(int,input().split()))
B = [a-i-1 for i,a in enumerate(A)]
med = list(sorted(B))[N//2]
print((sum([abs(a-med) for a in B]))) | p03309 |
def sadden_value(a, b):
total = 0
for i in range(0, len(a)):
total += abs(a[i]-b-i-1)
return total
n = int(eval(input()))
a = list(map(int, input().split()))
b = 1 - n
now = sadden_value(a, b)
while True:
nex = sadden_value(a, b + 1)
if now <= nex:
print(now)
break
now = nex
b += 1
| n = int(eval(input()))
a = list(map(int, input().split()))
tmp = [a[x] - (x+1) for x in range(0,n)]
tmp.sort()
b = tmp[n // 2]
print((sum((abs(tmp[i] - b) for i in range(0,n))))) | p03309 |
def main():
N = int(eval(input()))
seq = list(map(int, input().split()))
seq = [seq[i] - i - 1 for i in range(N)]
def helper(b):
return sum([abs(seq[i] - b) for i in range(N)])
temp = []
for i in range(N):
temp.append(helper(seq[i]))
print((min(temp)))
return 0
main() | def main():
N = int(eval(input()))
seq = list(map(int, input().split()))
seq = [seq[i] - i - 1 for i in range(N)]
se = sorted(list(set(seq)))
def helper(b):
return sum([abs(seq[i] - b) for i in range(N)])
L = 0
R = len(se)
while True:
ind = (L + R) // 2
temp = helper(se[ind])
if helper(se[ind - 1]) > temp and temp > helper(se[ind + 1]):
L = ind
elif helper(se[ind - 1]) < temp:
R = ind
else:
print(temp)
return 0
main() | p03309 |
import bisect
n=int(eval(input()))
lists=list(map(int,input().split()))
uselists=[]
for _ in range(n):
uselists.append(lists[_]-_-1)
uselist=sorted(uselists)
numbers=uselist[0]
while bisect.bisect_right(uselist,numbers)<n-bisect.bisect_right(uselist,numbers):
numbers+=1
ans=0
for x in range(n):
ans+=abs(uselist[x]-numbers)
print(ans) | n=int(eval(input()))
lists=list(map(int,input().split()))
uselists=[]
for _ in range(n):
uselists.append(lists[_]-_-1)
uselist=sorted(uselists)
if n%2==0:
num1=int(n/2-1)
num2=int(n/2)
numbers=min(uselist[num1],uselist[num2])
if n%2!=0:
num1=int((n-1)/2)
numbers=uselist[num1]
ans=0
for x in range(n):
ans+=abs(uselist[x]-numbers)
print(ans) | p03309 |
import sys
from statistics import median_low
inputs = sys.stdin.readlines()
n = int(inputs[0])
A = list(map(int, inputs[1].split()))
B = list([x[1]-x[0] for x in enumerate(A, 1)])
b = median_low(B)
C = list([abs(x-b) for x in B])
print((sum(C))) | import sys
from statistics import median_low
inputs = sys.stdin.readlines()
n = int(inputs[0])
A = list(map(int, inputs[1].split()))
B = list([x[1]-x[0] for x in enumerate(A, 1)])
b = median_low(B)
print((sum([abs(x-b) for x in B]))) | p03309 |
# -*- coding: utf-8 -*-
from copy import deepcopy
n = int(eval(input()))
A = list(map(int, input().split()))
for i in range(len(A)):
A[i] -= i + 1
ans = 10 ** 100
for a in A:
B = deepcopy(A)
for i in range(len(A)):
B[i] -= a
count = 0
for b in B:
count += abs(b)
ans = min(ans, count)
print(ans)
| # -*- coding: utf-8 -*-
n = int(eval(input()))
A = list(map(int, input().split()))
A = [A[i]-(i+1) for i in range(n)]
A.sort()
if n == 1:
print((0))
exit()
ans = 10**100
for i in [n//2-1, n//2]:
ans = min(ans, sum([abs(A[j]-A[i]) for j in range(n)]))
print(ans)
| p03309 |
from collections import Counter
N = int(eval(input()))
input_list = []
input_counter = Counter()
ans = 10**10
index = 1
for i in input().split():
item = int(i) - index
input_list.append(item)
input_counter[item] += 1
index += 1
for i in list(input_counter.keys()):
ans = min(ans, sum([abs(x-i)*input_counter[x] for x in list(input_counter.keys())]))
print(ans) | N = int(eval(input()))
input_list = []
index = 1
for i in input().split():
item = int(i) - index
input_list.append(item)
index += 1
input_list.sort()
b = input_list[N//2]
print((sum([abs(x-b) for x in input_list]))) | p03309 |
class SplayNode:
"""Splay木のノードを定義
メンバ変数: 値、サイズ、親へのポインタ、左右の子へのポインタ
"""
def __init__(self, val):
self.val = val
self.size = 1
self.parent, self.right, self.left = None, None, None
class SplayTree:
"""Splay木を定義"""
def __init__(self):
self.root = None
def __getitem__(self, ind: int): # O(logN)
return self.get_ptr(ind, self.root).val
def __setitem__(self, ind: int, val): # O(logN)
ptr = self.get_ptr(ind, self.root)
ptr.val = val
def __len__(self): # O(1)
return self.root.size if self.root is not None else 0
def update(self, ptr):
"""部分木の情報を更新する"""
ptr.size = 1
if ptr.left is not None:
ptr.size += ptr.left.size
if ptr.right is not None:
ptr.size += ptr.right.size
def state(self, ptr):
"""スプレー操作を行うときの状況判定
親が存在しない: 0
左の兄弟が存在する: 1
右の兄弟が存在する: -1
"""
if ptr.parent is None:
return 0
if ptr.parent.left == ptr:
return 1
if ptr.parent.right == ptr:
return -1
def splay(self, ptr):
"""ptrが根になるようにスプレー操作を行う"""
while self.state(ptr) != 0:
if self.state(ptr.parent) == 0:
# zigステップ
self.rotate(ptr)
elif self.state(ptr) == self.state(ptr.parent):
# zig-zigステップ
self.rotate(ptr.parent)
self.rotate(ptr)
else:
# zig-zagステップ
self.rotate(ptr)
self.rotate(ptr)
self.root = ptr
def rotate(self, ptr):
"""木の回転を行う"""
p = ptr.parent
pp = p.parent
if p.left == ptr:
c = ptr.right
ptr.right = p
p.left = c
else:
c = ptr.left
ptr.left = p
p.right = c
if pp is not None and pp.left == p: pp.left = ptr
if pp is not None and pp.right == p: pp.right = ptr
ptr.parent = pp
p.parent = ptr
if c is not None:
c.parent = p
self.update(p)
self.update(ptr)
def get_ptr(self, ind, root):
"""ind番目のポインタを取得する"""
ptr = root
while True:
if ptr.left is None:
l_size = 0
else:
l_size = ptr.left.size
if ind < l_size:
ptr = ptr.left
if ind == l_size:
self.splay(ptr)
return ptr
if ind > l_size:
ptr = ptr.right
ind = ind - l_size - 1
def merge(self, lroot, rroot):
if lroot is None:
self.root = rroot
return rroot
if rroot is None:
self.root = lroot
return lroot
lroot = self.get_ptr(lroot.size - 1, lroot)
lroot.right = rroot
rroot.parent = lroot
self.update(lroot)
return lroot
def split(self, left_cnt, root):
if left_cnt == 0:
return None, root
if left_cnt == root.size:
return root, None
root = self.get_ptr(left_cnt, root)
lroot = root.left
rroot = root
rroot.left = None
lroot.parent = None
self.update(rroot)
return lroot, rroot
def insert(self, ind, val):
"""ind番目の値valの要素を挿入する"""
lroot, rroot = self.split(ind, self.root)
new_ptr = SplayNode(val)
self.merge(self.merge(lroot, new_ptr), rroot)
def delete(self, ind):
"""indの要素を削除する"""
root = self.get_ptr(ind, self.root)
lroot = root.left
rroot = root.right
if lroot is not None:
lroot.parent = None
if rroot is not None:
rroot.parent = None
root.relf = None
root.left = None
self.update(root)
return self.merge(lroot, rroot), root
def add(self, val):
if self.root is None:
self.insert(0, val)
return
ptr = self.root
ind = 0
while True:
if val < ptr.val:
if ptr.left is None:
self.insert(ind, val)
return
ptr = ptr.left
else:
ind += 1
if ptr.left is not None:
ind += ptr.left.size
if ptr.right is None:
self.insert(ind, val)
return
ptr = ptr.right
from statistics import median
n = int(eval(input()))
a = list(map(int,input().split()))
sp = SplayTree()
for i in range(n):
sp.insert(i, a[i])
for i in range(n):
sp[i] = sp[i] - (i + 1)
ave = int(median([sp[i] for i in range(n)]))
ans = 0
for i in range(n):
ans += abs(sp[i] - ave)
print(ans) | class SplayNode:
"""Splay木のノードを定義
メンバ変数: 値、サイズ、親へのポインタ、左右の子へのポインタ
"""
def __init__(self, val):
self.val = val
self.size = 1
self.parent, self.right, self.left = None, None, None
class SplayTree:
"""Splay木を定義"""
def __init__(self):
self.root = None
def __getitem__(self, ind: int): # O(logN)
return self.get_ptr(ind, self.root).val
def __setitem__(self, ind: int, val): # O(logN)
ptr = self.get_ptr(ind, self.root)
ptr.val = val
def __len__(self): # O(1)
return self.root.size if self.root is not None else 0
def update(self, ptr):
"""部分木の情報を更新する"""
ptr.size = 1
if ptr.left is not None:
ptr.size += ptr.left.size
if ptr.right is not None:
ptr.size += ptr.right.size
def state(self, ptr):
"""スプレー操作を行うときの状況判定
親が存在しない: 0
左の兄弟が存在する: 1
右の兄弟が存在する: -1
"""
if ptr.parent is None:
return 0
if ptr.parent.left == ptr:
return 1
if ptr.parent.right == ptr:
return -1
def splay(self, ptr):
"""ptrが根になるようにスプレー操作を行う"""
while self.state(ptr) != 0:
if self.state(ptr.parent) == 0:
# zigステップ
self.rotate(ptr)
elif self.state(ptr) == self.state(ptr.parent):
# zig-zigステップ
self.rotate(ptr.parent)
self.rotate(ptr)
else:
# zig-zagステップ
self.rotate(ptr)
self.rotate(ptr)
self.root = ptr
def rotate(self, ptr):
"""木の回転を行う"""
p = ptr.parent
pp = p.parent
if p.left == ptr:
c = ptr.right
ptr.right = p
p.left = c
else:
c = ptr.left
ptr.left = p
p.right = c
if pp is not None and pp.left == p: pp.left = ptr
if pp is not None and pp.right == p: pp.right = ptr
ptr.parent = pp
p.parent = ptr
if c is not None:
c.parent = p
self.update(p)
self.update(ptr)
def get_ptr(self, ind, root):
"""ind番目のポインタを取得する"""
ptr = root
while True:
if ptr.left is None:
l_size = 0
else:
l_size = ptr.left.size
if ind < l_size:
ptr = ptr.left
if ind == l_size:
self.splay(ptr)
return ptr
if ind > l_size:
ptr = ptr.right
ind = ind - l_size - 1
def merge(self, lroot, rroot):
if lroot is None:
self.root = rroot
return rroot
if rroot is None:
self.root = lroot
return lroot
lroot = self.get_ptr(lroot.size - 1, lroot)
lroot.right = rroot
rroot.parent = lroot
self.update(lroot)
return lroot
def split(self, left_cnt, root):
if left_cnt == 0:
return None, root
if left_cnt == root.size:
return root, None
root = self.get_ptr(left_cnt, root)
lroot = root.left
rroot = root
rroot.left = None
lroot.parent = None
self.update(rroot)
return lroot, rroot
def insert(self, ind, val):
"""ind番目の値valの要素を挿入する"""
lroot, rroot = self.split(ind, self.root)
new_ptr = SplayNode(val)
self.merge(self.merge(lroot, new_ptr), rroot)
def delete(self, ind):
"""indの要素を削除する"""
root = self.get_ptr(ind, self.root)
lroot = root.left
rroot = root.right
if lroot is not None:
lroot.parent = None
if rroot is not None:
rroot.parent = None
root.relf = None
root.left = None
self.update(root)
return self.merge(lroot, rroot), root
def add(self, val):
if self.root is None:
self.insert(0, val)
return
ptr = self.root
ind = 0
while True:
if val < ptr.val:
if ptr.left is None:
self.insert(ind, val)
return
ptr = ptr.left
else:
ind += 1
if ptr.left is not None:
ind += ptr.left.size
if ptr.right is None:
self.insert(ind, val)
return
ptr = ptr.right
n = int(eval(input()))
a = list(map(int,input().split()))
sp = SplayTree()
for i in range(n):
sp.insert(i, a[i])
for i in range(n):
sp[i] = sp[i] - (i + 1)
ave = sorted([sp[i] for i in range(n)])[n // 2]
ans = 0
for i in range(n):
ans += abs(sp[i] - ave)
print(ans) | p03309 |
def main():
N, *A = list(map(int, open(0).read().split()))
for i in range(N):
A[i] -= i + 1
A.sort()
b = A[N // 2]
print((sum([abs(A[i] - b) for i in range(N)])))
return
main()
| def main():
N, *A = list(map(int, open(0).read().split()))
for i in range(N):
A[i] -= i + 1
A.sort()
print((sum(A[N // 2 + N % 2:]) - sum(A[:N // 2])))
return
main()
| p03309 |
n = int(eval(input()))
a = list(map(int,input().split()))
left = -10**9
right = 10**9
minnum = 0
for i in range(n):
minnum += abs(a[i]-(left+(i+1)))
ans = 0
def cal(num):
global minnum
tmp = 0
for i in range(n):
tmp += abs(a[i]-(num+(i+1)))
return tmp
while abs(right-left)>1:
mid = (right+left)//2
if cal(mid-1)<cal(mid+1):
ans = mid
right = mid
else:
left = mid
print((min(cal(left),cal(right)))) | n = int(eval(input()))
a = list(map(int,input().split()))
left = -10**9
right = 10**9
def cal(num):
tmp = 0
for i in range(n):
tmp += abs(a[i]-(num+(i+1)))
return tmp
while abs(right-left)>1:
mid = (right+left)//2
if cal(mid-1)<cal(mid+1):
ans = mid
right = mid
else:
left = mid
print((min(cal(left),cal(right))))
| p03309 |
from functools import lru_cache
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = tuple(map(int,input().split()))
left = -10**9
right = 10**9
@lru_cache(maxsize=100000)
def cal(num):
tmp = 0
for i in range(n):
tmp += abs(a[i]-(num+(i+1)))
return tmp
while abs(right-left)>1:
mid = (right+left)//2
if cal(mid-1)<cal(mid+1):
right = mid
else:
left = mid
print((min(cal(left),cal(right)))) | from functools import lru_cache
import sys
input = sys.stdin.readline
n = int(eval(input()))
a = list(map(int,input().split()))
left = -10**9
right = 10**9
@lru_cache(maxsize=100000)
def cal(num):
tmp = 0
for i in range(n):
tmp += abs(a[i]-(num+(i+1)))
return tmp
while abs(right-left)>1:
mid = (right+left)//2
if cal(mid-1)<cal(mid+1):
right = mid
else:
left = mid
print((min(cal(left),cal(right))))
| p03309 |
N=int(eval(input()))
l=list(map(int,input().split()))
max_n=max(l)
min_n=min(l)
res=float('inf')
for j in range(max_n-min_n+N+1):
ans=0
for i in range(N):
ans+=abs(max_n+i-l[i]-j)
if res > ans:
res = ans
print(res) | N=int(eval(input()))
l=list(map(int,input().split()))
for i in range(N):
l[i] -= i
l.sort()
center_num=l[N//2]
ans=0
for i in range(N):
ans+=abs(l[i]-center_num)
print(ans) | p03309 |
n = int(eval(input()))
a = list(map(int,input().split()))
aa = []
for i in range(n):
aa.append(a[i]-(i+1))
b = (sorted(aa)[n//2])
ans = 0
for i in range(n):
ans += abs(a[i]-(b+i+1))
print(ans) | N= int(eval(input()))
A = list(map(int,input().split()))
B = []
for i in range(N):
B.append(A[i]-(i+1))
#print(B)
b= (sorted(B)[N//2])
#print(b)
ans = 0
for i in range(N):
ans += abs(B[i]-b)
print(ans) | p03309 |
n = int(eval(input()))
a = list(map(int,input().split()))
l = len(a)
b = [a[i]-(i+1) for i in range(n)]
b = sorted(b)
mid = b[l//2]
sum = 0
for i in range(n):
sum+=abs(a[i]-(mid+(i+1)))
print(sum)
| n = int(eval(input()))
a = list(map(int,input().split()))
for i in range(n):
a[i] -= i + 1
a = sorted(a)
def calc(mid):
res = 0
for i in a:
res += abs(i-mid)
return res
if n%2==1:
res = calc(a[n//2])
else:
res = float('inf')
if (a[n//2-1]+a[n//2])%2==0:
res = calc((a[n//2-1]+a[n//2])//2)
else:
mid = (a[n//2-1]+a[n//2]) // 2
res = min(calc(mid), calc(mid+1))
print(res)
| p03309 |
a = int(eval(input()))
ar = list(map(int,input().split(" ")))
cr = []
for j in range(-max(ar),max(ar)+1):
count = 0
for i in range(a):
count += abs(ar[i] - (i+1 + j))
cr.append(count)
print((min(cr))) | a = int(eval(input()))
ar = list(map(int,input().split(" ")))
ar = [r - (i+1) for i,r in enumerate(ar)]
br = sorted(ar)
b = br[a//2]
count = 0
for i in range(a):
count += abs(ar[i] - b)
print(count) | p03309 |
N=int(eval(input()))
A=[int(i) for i in input().split()]
s=0
t=0
for i in range(N):
s+=abs(A[i]-1-i)
t+=abs(A[i]-i)
if s>t:
d=0
while True:
d-=1
r=0
u=0
for i in range(N):
r+=abs(A[i]-d-1-i)
u+=abs(A[i]-d-i)
if r>u:
continue
else:
print(r)
break
elif s==t:
print(s)
else:
e=0
while True:
e+=1
x=0
y=0
for i in range(N):
x+=abs(A[i]-e-1-i)
y+=abs(A[i]-e-i)
if x<y:
continue
else:
print(y)
break | N=int(eval(input()))
A=[int(i) for i in input().split()]
u=[]
for i in range(N):
u.append(A[i]-i)
a=sorted(u)
if len(a)%2==0:
p=a[len(a)//2]
else:
p=a[len(a)//2]
ans=0
for j in range(N):
ans+=abs(a[j]-p)
print(ans) | p03309 |
N = int(eval(input()))
A = list(map(int, input().split()))
res = 0
for i in range(N):
res += A[i] - (i+1)
b = res // N
ans = 99999999
for bj in range(b-100, b+100):
res = 0
for i in range(N):
res += abs(A[i] - (b+(i+1)))
ans = min(ans, res)
print(ans) | N = int(eval(input()))
A = list(map(int, input().split()))
A_sorted = sorted([A[i] - (i+1) for i in range(N)])
if len(A) != 1:
b = A_sorted[int((len(A)-1)/2)]
b2 = A_sorted[int((len(A)-1)/2 + 1)]
sad_1 = sum([abs(A_sorted[i] - b) for i in range(N)])
sad_2 = sum([abs(A_sorted[i] - b2) for i in range(N)])
print((min(sad_1, sad_2)))
else:
print('0')
| p03309 |
from bisect import bisect
n=int(eval(input()))
a=list(map(int,input().split()))
a2=[]
for i in range(n):
temp = a[i]-(i+1)
index = bisect(a2,temp)
a2.insert(index,temp)
ans = sum( abs(x - a2[n//2]) for x in a2)
print(ans) | n=int(eval(input()))
a=list(map(int,input().split()))
a2 = [ x-i for i,x in enumerate(a)]
a2.sort()
ans = sum( abs(x - a2[n//2]) for x in a2)
print(ans) | p03309 |
n = int(eval(input()))
a = [int(i) for i in input().split()]
b = []
for i in range(len(a)):
b.append(a[i] - (i+1))
while True:
p_num = []
n_num = []
z_num = []
for i in range(len(b)):
if b[i] > 0:
p_num.append(b[i])
elif b[i] < 0:
n_num.append(b[i])
else:
z_num.append(b[i])
if len(p_num) > len(n_num) + len(z_num):
for i in range(len(b)):
b[i] = b[i] - 1
elif len(n_num) > len(p_num) + len(z_num):
for i in range(len(b)):
b[i] = b[i] + 1
else:
break
ans = 0
for i in range(len(b)):
ans += abs(b[i])
print(ans)
| n = int(eval(input()))
a = [int(i) for i in input().split()]
b = []
for i in range(len(a)):
b.append(a[i] - (i+1))
p_num = []
n_num = []
z_num = []
for i in range(len(b)):
if b[i] > 0:
p_num.append(b[i])
elif b[i] < 0:
n_num.append(b[i])
else:
z_num.append(b[i])
p_num.sort()
n_num.sort()
n_num.reverse()
if len(p_num) > len(n_num) + len(z_num):
count_n = len(n_num) + len(z_num)
count_p = len(p_num)
index = -1
while count_p > count_n:
count_p -= 1
count_n += 1
index += 1
for i in range(len(b)):
b[i] = b[i] - p_num[index]
elif len(n_num) > len(p_num) + len(z_num):
count_n = len(n_num)
count_p = len(p_num) + len(z_num)
index = -1
while count_n > count_p:
count_n -= 1
count_p += 1
index += 1
for i in range(len(b)):
b[i] = b[i] - n_num[index]
ans = 0
for i in range(len(b)):
ans += abs(b[i])
print(ans)
| p03309 |
def 解():
iN = int(eval(input()))
aA = list(map(int,input().split()))
aA = sorted(map(lambda x,y:x-y,aA,list(range(1,iN+1))))
iL = len(aA)
if iL % 2 :
iMed = aA[(iL-1)//2]
else:
iMed = aA[iL//2]
iMean = sum(aA) // 2
iBlim= min(iMed,iMean)
iUlim= min(iMed,iMean+1)
print((min(sum(abs(a-i) for a in aA) for i in [iMed,iMean,iMean+1])))
解()
| def 解():
iN = int(eval(input()))
#aA = map(int,input().split())
aA = sorted(map(lambda x,y:x-y,list(map(int,input().split())),list(range(1,iN+1))))
iL = len(aA)
if iL % 2 :
iMed = aA[(iL-1)//2]
else:
iMed = aA[iL//2]
print((sum(abs(a-iMed) for a in aA)))
解()
| p03309 |
from statistics import mean
import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[idx]-(idx+1) for idx in range(N)]
b = round(mean(A))
ans1 = 0
ans2 = 0
for i in range(N):
ans1 += abs(math.floor(mean(A))-A[i])
ans2 += abs(math.ceil(mean(A)) - A[i])
print((min(ans1,ans2))) | from statistics import median
import math
N = int(eval(input()))
A = list(map(int, input().split()))
A = [A[idx]-(idx+1) for idx in range(N)]
ans1 = 0
ans2 = 0
median_A = median(A)
median_floor_A = math.floor(median_A)
median_ceil_A = math.ceil(median(A))
for i in range(N):
ans1 += abs(median_floor_A - A[i])
ans2 += abs(median_ceil_A - A[i])
print((min(ans1,ans2))) | p03309 |
N = int(eval(input()))
A = list(map(int,input().split()))
tmp = sorted([A[i-1]-i for i in range(1,N+1)])
mid = tmp[N//2]
print((sum([abs(t-mid) for t in tmp]))) | N = int(eval(input()))
A = list(map(int,input().split()))
tmp = sorted([A[i-1]-i for i in range(1,N+1)])
B = tmp[N//2]
print((sum([abs(t-B) for t in tmp]))) | p03309 |
# https://atcoder.jp/contests/abc102/tasks/arc100_a
# C - Linear Approximation
N = int(input().split()[0])
a_list = list(map(int, input().split()))
min_b = float('inf')
max_a = max(a_list)
work_list = [a - i - 1 for i, a in enumerate(a_list)]
work_list = list(set(work_list))
for b in work_list: # 10 ** 5
total_b = 0
for i, a in enumerate(a_list): # 10 ** 5
total_b += abs(a - (b + i + 1))
min_b = min(min_b, total_b)
print(min_b)
| # https://atcoder.jp/contests/abc102/tasks/arc100_a
# C - Linear Approximation
N = int(input().split()[0])
a_list = list(map(int, input().split()))
min_b = float('inf')
max_a = max(a_list)
work_list = [a - (i + 1) for i, a in enumerate(a_list)]
w = sorted(work_list)[int(N / 2)]
ans = sum([abs(x - w) for x in work_list])
print(ans)
| p03309 |
n=int(eval(input()))
A=list(map(int,input().split()))
for i in range(n):
A[i]=A[i]-i-1
B=sorted(A)
b=B[n//2]
r=0
for i in range(n):
r+=abs(A[i]-b)
print(r) | n=int(eval(input()))
A=list(map(int,input().split()))
B=sorted([A[i]-(i+1) for i in range(n)])
if n%2==1:
b=B[n//2]
else:
b=(B[n//2-1]+B[n//2])//2
r=0
for i in range(n):
r+=abs(B[i]-b)
print(r) | p03309 |
import statistics
N = int(eval(input()))
A = [int(a)-i-1 for i,a in enumerate(input().split(),1)]
b = statistics.median_low(A)
c = statistics.median_high(A)
d = sum([abs(x-b) for x in A])
e = sum([abs(x-c) for x in A])
print((min(d,e))) | N=int(eval(input()))
A=sorted(a-i-1 for i,a in enumerate(map(int,input().split())))
print((sum(abs(a-A[N//2]) for a in A))) | p03309 |
n = int(eval(input()))
s = list(map(int, input().rstrip().split(" ")))
min_v = 0
for i in range(0, n):
v = 0
for j in range(0, n):
v = v + abs(s[j] - (s[i]-i + j))
if i == 0 or v < min_v:
min_v =v
print(min_v)
| n = int(eval(input()))
s = list(map(int, input().rstrip().split(" ")))
for i in range(0, n):
s[i] = s[i] - (i+1)
s.sort()
b = s[n//2]
sm = 0
for i in range(0, n):
sm = sm + abs(s[i] - b)
print(sm)
| p03309 |
import math
n = int(eval(input()))
a_tmp = input().split()
a = []
for i in range(n):
a.append(int(a_tmp[i]))
a1 = []
for i in range(n):
a1.append(a[i]-1-i)
b_max = max(a1)
b_min = min(a1)
sadness = []
for b in range(b_min, b_max+1):
abs = [math.fabs(a1[i]-b) for i in range(n)]
sadness.append(int(sum(abs)))
print((min(sadness)))
| import math
n = int(eval(input()))
a_tmp = input().split()
a_tmp1 = []
for i in range(n):
a_tmp1.append(int(a_tmp[i])-i-1)
a = sorted(a_tmp1)
if n % 2 == 0:
x = a[n//2]
else:
x = a[n//2]
ans = 0
for _ in a:
ans += math.fabs(_ - x)
print((int(ans)))
| p03309 |
n = int(eval(input()))
A_list = list(map(int, input().split()))
for i in range(n):
A_list[i] -= i
A_list.sort()
A_cum = [0] * n
for i in range(n):
if i == 0:
A_cum[0] = A_list[0]
else:
A_cum[i] = A_cum[i-1] + A_list[i]
def findinfindex(sortedlist, key, l, r):
if r - l <= 0:
return l
m = (l+r+1)//2
if sortedlist[m] > key:
return findinfindex(sortedlist, key, l, m-1)
else:
return findinfindex(sortedlist, key, m, r)
sadmin = -1
for b in range(A_list[0],A_list[n-1]+1):
lastminus = findinfindex(A_list, b, 0, n-1)
sadness = (2*lastminus - n + 2)*b - 2*A_cum[lastminus] + A_cum[n-1]
if sadmin == -1:
sadmin = sadness
elif sadness < sadmin:
sadmin = sadness
else:
break
print(sadmin)
| n = int(eval(input()))
A_list = list(map(int, input().split()))
for i in range(n):
A_list[i] -= i
A_list.sort()
def sadness(a, mid):
sad = 0
for i in range(mid):
sad += a[mid] - a[i]
for i in range(mid+1,len(a)):
sad += a[i] - a[mid]
return sad
if n % 2 != 0:
print((sadness(A_list, n//2)))
else:
print((min(sadness(A_list, n//2), sadness(A_list, n//2+1))))
| p03309 |
N = int(eval(input()))
A = list(map(int,input().split()))
a = list(range(1,N+1))
bbef = -N//2
baft = (-N//2)+1
elementbef = [abs(i-j-bbef) for (i,j) in zip(A,a)]
sumbef = sum(elementbef)
elementaft = [abs(i-j-baft) for (i,j) in zip(A,a)]
sumaft = sum(elementaft)
while(sumaft-sumbef < 0):
bbef = bbef+1
baft = baft+1
elementbef = [abs(i-j-bbef) for (i,j) in zip(A,a)]
sumbef = sum(elementbef)
elementaft = [abs(i-j-baft) for (i,j) in zip(A,a)]
sumaft = sum(elementaft)
print(sumbef) | N = int(eval(input()))
A = list(map(int,input().split()))
a = list(range(1,N+1))
elements = sorted([i-j for (i,j) in zip(A,a)])
if(N%2 == 1):
b = elements[N//2]
else:
b = elements[(N//2)-1]
answer = sum([abs(i-j-b) for (i,j) in zip(A,a)])
print(answer)
| p03309 |
n = int(eval(input()))
A = [int(i) for i in input().split()]
M = []
for i in range(n):
M.append(A[i] - (i + 1))
M.sort()
b = M[len(M) // 2]
ans = 0
for i in range(n):
ans += abs(A[i] - (b + i + 1))
print(ans) | n = int(eval(input()))
A = [int(i) for i in input().split()]
B = []
for i in range(n):
B.append(A[i] - i)
B.sort()
mid = B[len(B)//2]
ans = 0
for i in range(n):
ans += abs(A[i] - (mid + i))
print(ans) | p03309 |
N=int(eval(input()))
A=list(map(int,input().split()))
A=[a-i for i,a in enumerate(A,1)]
A.sort()
A_posi=[0 for i in range(N)]
A_posi[0]=A[0]
for i in range(1,N):
A_posi[i]=A_posi[i-1]+A[i]
value=[0 for i in range(N)]
value[0]=A_posi[N-1]-N*A[0]
for i in range(1,N):
value[i]=A_posi[N-1]-A_posi[i]-(N-i-1)*A[i]-A_posi[i-1]+(i)*A[i]
print((min(value)))
| N=int(eval(input()))
A=list(map(int,input().split()))
A=[a-i for i,a in enumerate(A,1)]
A.sort()
b=A[len(A)//2]
A=[abs(a-b) for a in A]
print((sum(A)))
| p03309 |
N=int(eval(input()))
A=list(map(int,input().split()))
def quick_sort(a):
if len(a)<= 1:
return a
else:
b=[]
c=[]
for i in range(1, len(a)):
if a[i]<a[0]:
b.append(a[i])
else:
c.append(a[i])
return quick_sort(b)+[a[0]]+quick_sort(c)
def abs(x):
if x>=0:
return x
else:
return x*(-1)
B=[]
for i in range(N):
B.append(A[i]-i-1)
C=quick_sort(B)
if N%2==0:
b=(C[N//2]+C[N//2-1])//2
else:
b=C[N//2-1]
sad=0
for j in range(N):
sad=sad+abs(C[j]-b)
print(sad) | N=int(eval(input()))
A=list(map(int,input().split()))
B=[]
for i in range(N):
B.append(A[i]-i-1)
B.sort()
if N%2==0:
b=(B[N//2]+B[N//2-1])//2
else:
b=B[N//2]
sad=0
for j in range(N):
sad=sad+abs(B[j]-b)
print(sad) | p03309 |
# C - Linear Approximation
# https://beta.atcoder.jp/contests/abc102/tasks/arc100_a
# C_Linear_Approximation.py
# 7
# 1 1 1 1 2 3 4
#import sys
N = int(eval(input()))
a = list(map(int, input().strip().split(" ")))
for i in range(N):
a[i] = a[i] - (i+1)
a.sort()
max = a[-1]
min = a[0]
for b in range(min, max + 1):
sadness_left = 0
i = 0
while a[i] < b:
sadness_left += b - a[i]
i += 1
sadness = sum(a) - b * N + sadness_left * 2
if b == min:
min_sadness = sadness
elif min_sadness > sadness:
min_sadness = sadness
print(min_sadness)
| # C - Linear Approximation
# https://beta.atcoder.jp/contests/abc102/tasks/arc100_a
# C_Linear_Approximation.py
# 7
# 1 1 1 1 2 3 4
#import sys
N = int(eval(input()))
a = list(map(int, input().strip().split(" ")))
for i in range(N):
a[i] = a[i] - (i+1)
a.sort()
if N % 2 != 0:
mid = (N-1)//2
else:
mid = N // 2 -1
b = a[mid]
sadness_left = b * mid - sum(a[:mid])
sadness = sum(a) - b * N + sadness_left * 2
print(sadness)
| p03309 |
n,m,d = (int(i) for i in input().split())
step = n-d
if d != 0:
step =step*2
print(('{:.10f}'.format(step*n**(m-2)*(m-1)/n**m)))
| n,m,d = (int(i) for i in input().split())
step = n-d
if d != 0:
step =step*2
print(('{:.10f}'.format(step*(m-1)/n**2)))
| p03304 |
import sys
input=sys.stdin.readline
S = input().strip()
n = S.count("N")
w = S.count("W")
e = S.count("E")
s = S.count("S")
if (n == 0 and s == 0) or (n > 0 and s > 0):
if (w == 0 and e == 0) or (w > 0 and e > 0):
print("Yes")
exit()
print("No")
| import sys
input=sys.stdin.readline
S = input().strip()
n = S.count("N") > 0
w = S.count("W") > 0
e = S.count("E") > 0
s = S.count("S") > 0
if (n and not s) or (not n and s) or (w and not e) or (not w and e):
print("No")
else:
print("Yes")
| p04019 |
# AGC003A - Wanna go back home
from collections import Counter
def main():
D = Counter(input().rstrip())
flg = True
if (
(D["N"] != 0 and D["S"] == 0)
or (D["N"] == 0 and D["S"] != 0)
or (D["E"] != 0 and D["W"] == 0)
or (D["E"] == 0 and D["W"] != 0)
):
flg = False
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | # AGC003A - Wanna go back home
def main():
S = input().rstrip()
flg = (("N" in S) ^ ("S" in S) ^ 1) & (("E" in S) ^ ("W" in S) ^ 1)
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | p04019 |
# code-festival-2017-qualaC - Palindromic Matrix
from collections import Counter
def main():
H, W, *A = open(0).read().split()
H, W, C = int(H), int(W), list(Counter("".join(A)).values())
single = H & W & 1
double = (H >> 1 if W & 1 else 0) + (W >> 1 if H & 1 else 0)
C_mod4, C_div4 = list(zip(*[(i % 4, i // 4) for i in C]))
flg = C_mod4.count(1) + C_mod4.count(3) <= single and C_mod4.count(2) <= double
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | # code-festival-2017-qualaC - Palindromic Matrix
from collections import Counter
def main():
H, W, *A = open(0).read().split()
H, W, C = int(H), int(W), list(Counter("".join(A)).values())
single = H & W & 1
double = (H >> 1 if W & 1 else 0) + (W >> 1 if H & 1 else 0)
C_mod4 = [i % 4 for i in C]
flg = C_mod4.count(1) + C_mod4.count(3) <= single and C_mod4.count(2) <= double
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | p03593 |
# code-festival-2017-qualaC - Palindromic Matrix
from collections import defaultdict
def main():
H, W, *A = open(0).read().split()
H, W, C = int(H), int(W), defaultdict(int)
for i in "".join(A):
C[i] += 1
single = H & W & 1
double = (H >> 1 if W & 1 else 0) + (W >> 1 if H & 1 else 0)
C_mod4 = [i % 4 for i in list(C.values())]
flg = C_mod4.count(1) + C_mod4.count(3) <= single and C_mod4.count(2) <= double
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | # code-festival-2017-qualaC - Palindromic Matrix
def main():
H, W, *A = open(0).read().split()
H, W, C = int(H), int(W), {}
for i in "".join(A):
if i not in C:
C[i] = 0
C[i] += 1
single = H & W & 1
double = (H >> 1 if W & 1 else 0) + (W >> 1 if H & 1 else 0)
C_mod4 = [i % 4 for i in list(C.values())]
flg = C_mod4.count(1) + C_mod4.count(3) <= single and C_mod4.count(2) <= double
print(("Yes" if flg else "No"))
if __name__ == "__main__":
main() | p03593 |
H,W=list(map(int,input().split()))
lines=[]
for i in range(H):
lines.append(input().strip())
chars=dict()
for line in lines:
for c in line:
if c not in chars:
chars[c]=0
chars[c]+=1
def judge(H,W,chars):
#両方奇数
if H%2+W%2==2:
ones=1
twos=H//2 + W//2
#両方偶数
elif H%2+W%2==0:
ones=0
twos=0
elif H%2==1:
ones=0
twos=W//2
else:
ones=0
twos=H//2
for c in chars:
if ones<0 or twos<0:
return False
chars[c]%=4
if chars[c]==0:
continue
if chars[c]==2:
twos-=1
elif chars[c]==3:
twos-=1
ones-=1
else:
ones-=1
if ones<0 or twos<0:
return False
return True
if judge(H,W,chars):
print("Yes")
else:
print("No") | H,W=list(map(int,input().split()))
lines=[]
for i in range(H):
lines.append(input().strip())
chars=dict()
for line in lines:
for c in line:
if c not in chars:
chars[c]=0
chars[c]+=1
def judge(H,W,chars):
#両方奇数
if H%2+W%2==2:
ones=1
twos=H//2 + W//2
#両方偶数
elif H%2+W%2==0:
ones=0
twos=0
elif H%2==1:
ones=0
twos=W//2
else:
ones=0
twos=H//2
for c in chars:
chars[c]%=4
if chars[c]==0:
continue
if chars[c]==2:
twos-=1
elif chars[c]==3:
twos-=1
ones-=1
else:
ones-=1
if ones<0 or twos<0:
return False
return True
if judge(H,W,chars):
print("Yes")
else:
print("No") | p03593 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.