Problem:
Score : 300 points

Problem 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.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^9

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 ... A_N

Output

Print the minimum possible sadness of Snuke.

Sample Input 1

5
2 2 3 5 5

Sample Output 1

2

If we choose b=0, the sadness of Snuke would be abs(2-(0+1))+abs(2-(0+2))+abs(3-(0+3))+abs(5-(0+4))+abs(5-(0+5))=2.
Any choice of b does not make the sadness of Snuke less than 2, so the answer is 2.

Sample Input 2

9
1 2 3 4 5 6 7 8 9

Sample Output 2

0

Sample Input 3

6
6 5 4 3 2 1

Sample Output 3

18

Sample Input 4

7
1 1 1 1 2 3 4

Sample Output 4

6

Solution in C# (Mono 4.6.2.0) (judge verdict: Runtime Error)

using System;
using System.Collections;
using System.Collections.Generic;
using System.Dynamic;
using System.IO;
using System.Linq;
using System.Linq.Expressions;
using System.Reflection.Emit;
using System.Runtime.Remoting.Proxies;
using System.Text;
using static System.Console;
using static System.Math;
using static Ex;
class Simple {
    private int N;
    private int[] A;
    void Solve() {
        io.i(out N);
        io.ini(out A, N);
        var a = new int[N];
        REP(N, i => a[i] = A[i] - (i + 1));
        var b = a.MEDIAN().RoundOff(1);
        var ans = 0;
        REP(N,i=>ans+=Abs(A[i]-(b+(i+1))));
        io.o(ans);        
    }
    void Test() {
        //
    }
    public static void Main(string[] args) => new Simple().Stream();
    IO io = new IO();
    private void Stream() {
        //var exStdIn = new System.IO.StreamReader("stdin.txt");
        //SetIn(exStdIn);
        Solve();
        //Test();
        io.Flush();
    }
}
class IO {
    #region INPUT
    private const int Size = 1 << 12;
    private readonly Stream _stream = Console.OpenStandardInput();
    private readonly byte[] _buffer = new byte[Size];
    private int _ptr = 0, _buffLen = 0;
    private bool HasNextByte() {
        if(_ptr < _buffLen)
            return true;
        _ptr = 0;
        _buffLen = _stream.Read(_buffer, 0, Size);
        return _buffLen > 0;
    }
    private byte ReadByte() {
        if(HasNextByte())
            return _buffer[_ptr++];
        else
            throw new EndOfStreamException();
    }
    private bool IsAscii(int c) => '!' <= c && c <= '~';
    private void SkipNonAscii() {
        while(HasNextByte() && !IsAscii(_buffer[_ptr]))
            _ptr++;
    }
    private bool HasNext() {
        SkipNonAscii();
        return HasNextByte();
    }
    private char NextChar() {
        byte b = 0;
        do
            b = ReadByte(); while(!IsAscii(b));
        return (char)b;
    }
    private string Next() {
        var sb = new StringBuilder();
        for(var b = NextChar(); IsAscii(b); b = (char)ReadByte())
            sb.Append(b);
        return sb.ToString();
    }
    private void Read <T>(out T v) => v = SuitType <T>(Next());
    private T ConvertType <T, TU>(TU v) => (T)Convert.ChangeType(v, typeof(T));
    private bool TypeEqual <T, TU>() => typeof(T) == typeof(TU);
    private T SuitType <T>(string s) {
        if(TypeEqual <T, int>())
            ConvertType <T, int>(int.Parse(s));
        if(TypeEqual <T, long>())
            ConvertType <T, long>(long.Parse(s));
        if(TypeEqual <T, double>())
            ConvertType <T, double>(double.Parse(s));
        if(TypeEqual <T, char>())
            ConvertType <T, char>(char.Parse(s));
        return ConvertType <T, string>(s);
    }
    private T i <T>() => SuitType <T>(String);
    public string String => Next();
    public char Char => NextChar();
    public int Int => int.Parse(Next());
    public long Long => long.Parse(Next());
    public double Double => double.Parse(Next());
    public void i <T>(out T v) => Read(out v);
    public void i <T, TU>(out T t, out TU u) {
        i(out t);
        i(out u);
    }
    public void i <T, TU, TV>(out T t, out TU u, out TV v) {
        i(out t, out u);
        i(out v);
    }
    public void i <T, TU, TV, TW>(out T t, out TU u, out TV v, out TW w) {
        i(out t, out u, out v);
        i(out w);
    }
    public void i <T, TU, TV, TW, TX>(out T t, out TU u, out TV v, out TW w, out TX x) {
        i(out t, out u, out v, out w);
        i(out x);
    }
    public void ini <T>(out T[] a, int n) {
        a = new T[n];
        for(int i = 0; i < n; ++i)
            a[i] = i <T>();
    }
    public void ini <T, TU>(out T[] a, out TU[] b, int n) {
        a = new T[n];
        b = new TU[n];
        for(int i = 0; i < n; ++i) {
            a[i] = i <T>();
            b[i] = i <TU>();
        }
    }
    public void ini <T, TU, TV>(out T[] a, out TU[] b, out TV[] c, int n) {
        a = new T[n];
        b = new TU[n];
        c = new TV[n];
        for(int i = 0; i < n; ++i) {
            a[i] = i <T>();
            b[i] = i <TU>();
            c[i] = i <TV>();
        }
    }
    public void ini <T>(out T[,] a, int h, int w) {
        a = new T[h, w];
        for(int i = 0; i < h; ++i)
            for(int j = 0; j < w; ++j)
                a[i, j] = i <T>();
    }
    #endregion
    #region OUTPUT
    private readonly StreamWriter _sw = new StreamWriter(Console.OpenStandardOutput()) {
#if DEBUG
        AutoFlush = true
#else
        AutoFlush = false
#endif
    };
    public void Flush() => Console.Out.Flush();
    private void Out <T>(T v) => Console.Write(v);
    private void OutLine <T>(T v) => Console.WriteLine(v);
    public void o() => OutLine("");
    public void o <T>(T v) => OutLine(v);
    public void o <T>(params T[] a) => Array.ForEach(a, OutLine);
    public void o <T>(T[,] a) {
        int a0 = a.GetLength(0), a1 = a.GetLength(1);
        for(int i = 0; i < a0; ++i) {
            for(int j = 0; j < a1 - 1; ++j)
                Out(a[i, j] + " ");
            OutLine(a[i, a1 - 1]);
        }
    }
    public void ol <T>(params T[] a) => OutLine(string.Join(" ", a));
    public void YN(bool f) => OutLine(f ? "YES" : "NO");
    public void Yn(bool f) => OutLine(f ? "Yes" : "No");
    public void yn(bool f) => OutLine(f ? "yes" : "no");
    #endregion
    public IO() { Console.SetOut(_sw); }
}
static class Ex {
    public static void REP(int a, Action <int> act) => FOR(0, a, act);
    public static void FOR(int a, int b, Action <int> act) {
        for(int i = a; i < b; ++i)
            act(i);
    }
    public static void REPEQ(int a, Action <int> act) => FOR(0, a + 1, act);
    public static void FOREQ(int a, int b, Action <int> act) => FOR(a, b + 1, act);
    public static T MIN <T>(params T[] a) => a.Min();
    public static T MAX <T>(params T[] a) => a.Max();
}
static class NumEx {
    public static string toString(this double d) => d.ToString("R");
    public static string Pad0 <T>(this T s, int n) => s.ToString().PadLeft(n, '0');
    public static int RoundOff(this double v, int n)
        => (int)Math.Round(v, n - 1, MidpointRounding.AwayFromZero);
    public static int RoundUp(this double v) => (int)Math.Ceiling(v);
    public static int RoundDown(this double v) => (int)Math.Floor(v);
    public static bool Odd(this int v) => (v & 1) != 0;
    public static bool Odd(this long v) => (v & 1) != 0;
}
static class ArrayEx {
    public static int MEAN(this int[] a) => (int)a.Aggregate(0L, (acc, x) => acc + x) / a.Length;     
    public static long MEAN(this long[] a) => a.Sum() / a.Length;
    public static double MEAN(this double[] a) => a.Sum() / a.Length;
    public static double MEDIAN(this int[] a) {
        var arr = a.OrderBy(x => x).ToArray();
        if(a.Length % 2 != 1)
            return a[a.Length / 2];
        else        
            return (a[a.Length / 2 - 1] + a[a.Length / 2]) / 2.0;
    }
}