output_description: Print the minimum possible sadness of Snuke.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N
      A_1 A_2 ... A_N
attempt: import sys
  from sys import exit
  from collections import deque
  from copy import deepcopy
  from bisect import bisect_left, bisect_right, insort_left, insort_right
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod=MOD):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
      def list(self):
          l = []
          for k in self:
              l.extend([k] * self[k])
          return l
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  def pf(x, mode="counter"):
      C = counter()
      p = 2
      while x > 1:
          k = 0
          while x % p == 0:
              x //= p
              k += 1
          if k > 0:
              C.add(p, k)
          p = p + 2 - (p == 2) if p * p < x else x
      if mode == "counter":
          return C
      S = set([1])
      for k in C:
          T = deepcopy(S)
          for x in T:
              for i in range(1, C[k] + 1):
                  S.add(x * (k**i))
      if mode == "set":
          return S
      if mode == "list":
          return sorted(list(S))
  
  
  ######################################################
  
  N, A = ilint()
  A = [A[i] - (i + 1) for i in range(N)]
  A.sort()
  k = A[N // 2]
  ans = 0
  for a in A:
      ans += abs(a - k)
  print(ans)
  
problem_description: Statement
  
  Snuke has an integer sequence A of length N.
  
  He will freely choose an integer b. Here, he will get sad if A_i and b+i are
  far from each other. More specifically, the _sadness_ of Snuke is calculated
  as follows:
  
    * abs(A_1 - (b+1)) + abs(A_2 - (b+2)) + ... + abs(A_N - (b+N))
  
  Here, abs(x) is a function that returns the absolute value of x.
  
  Find the minimum possible sadness of Snuke.
samples: [{"input": "5\n    2 2 3 5 5", "output": "2\n    \n\nIf we choose b=0, the sadness of Snuke would be\nabs(2-(0+1))+abs(2-(0+2))+abs(3-(0+3))+abs(5-(0+4))+abs(5-(0+5))=2. Any choice\nof b does not make the sadness of Snuke less than 2, so the answer is 2.\n\n* * *"}, {"input": "9\n    1 2 3 4 5 6 7 8 9", "output": "0\n    \n\n* * *"}, {"input": "6\n    6 5 4 3 2 1", "output": "18\n    \n\n* * *"}, {"input": "7\n    1 1 1 1 2 3 4", "output": "6"}]