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: Wrong Answer)

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
using System.Linq;
using System.Text;
using System.Xml.Schema;

namespace ConsoleApplication1
{
    internal static class Program
    {
        public static void Main(string[] args)
        {
            var scanner = new StreamScanner(Console.OpenStandardInput());
            var n = scanner.Integer();
            /*
            var arr = new int[n];
            for (var i = 0; i < n; i++)
            {
                arr[i] = scanner.Integer();
            }
            
            
            var max = arr.Max();
            var min = arr.Min();
            var avg = (int)arr.Average();

            var margin = n/2 + 100;
            
            var sorrow = int.MaxValue;
            for (var i = avg - margin; i < avg + margin; i++)
            {
                var over = false;
                var v = 0;
                for (var j = 0; j < n; j++)
                {
                    v += Math.Abs(arr[j] - (i + j + 1));
                    if (v < sorrow) continue;
                    over = true;
                    break;
                }
                if (over || v >= sorrow) continue;
                sorrow = v;
            }
            */
            /*
            var arr = new int[n];
            for (var i = 0; i < n; i++)
            {
                arr[i] = scanner.Integer();;
            }

            var avg = arr.Average();
            var dev = arr.Select(x => x - avg);
            var disp = 
            */
            
            var arr = new int[n];
            var dist = new int[n];
            for (var i = 0; i < n; i++)
            {
                var v = scanner.Integer();
                arr[i] = v;
                dist[i] = v - (i + 1);
            }

            var cutoff = n / 15;
            var sortedDist = dist.OrderBy(x => x).Skip(cutoff).Take(n - 2 * cutoff);
            
            //var avg = (int)dist.Average();
            //var avg = (int)dist.Average();
            var center = (int)sortedDist.Median();
            
            var margin = 2000;
            var lower = center - margin;
            var upper = center + margin;
            
            var sorrow = int.MaxValue;
            for (var i = lower; i < upper; i++)
            {
                var over = false;
                var v = 0;
                for (var j = 0; j < n; j++)
                {
                    v += Math.Abs(arr[j] - (i + j + 1));
                    if (v < sorrow) continue;
                    over = true;
                    break;
                }
                if (over || v >= sorrow) continue;
                sorrow = v;
            }
            
            Console.WriteLine(sorrow);
        }
    }
    
    // https://qiita.com/Camypaper/items/de6d576fe5513743a50e
    public class StreamScanner
    {   
        private readonly Stream stream;
        private readonly byte[] buf = new byte[1024];
        private int len, pos;
        private bool isEof = false;
        public bool IsEndOfStream => isEof;

        public StreamScanner(Stream stream) { this.stream = stream; }
        
        private byte Read()
        {
            if (isEof) throw new EndOfStreamException();
            if (pos >= len) {
                pos = 0;
                if ((len = stream.Read(buf, 0, 1024)) <= 0)
                {
                    isEof = true;
                    return 0;
                }
            }
            return buf[pos++];
        }
        
        public char Char() 
        {
            byte b = 0;
            do b = Read();
            while (b < 33 || 126 < b);
            return (char)b; 
        }
        
        public string Scan()
        {
            var sb = new StringBuilder();
            for (var b = Char(); b >= 33 && b <= 126; b = (char)Read())
                sb.Append(b);
            return sb.ToString();
        }
        
        public long Long()
        {
            long ret = 0; byte b = 0; var ng = false;
            do b = Read();
            while (b != '-' && (b < '0' || '9' < b));
            if (b == '-') { ng = true; b = Read(); }
            for (; true; b = Read())
            {
                if (b < '0' || '9' < b)
                    return ng ? -ret : ret;
                else ret = ret * 10 + b - '0';
            }
        }
        
        public int Integer() { return (int)Long(); }
        public double Double() { return double.Parse(Scan(), CultureInfo.InvariantCulture); }
    }
    
    // https://gist.github.com/axelheer/b1cb9d7c267d6762b244
    public static class MedianExtensions
    {
        public static double Median(this IEnumerable<int> source)
        {
            var data = source.OrderBy(n => n).ToArray();
            if (data.Length == 0)
                throw new InvalidOperationException();
            if (data.Length % 2 == 0)
                return (data[data.Length / 2 - 1] + data[data.Length / 2]) / 2.0;
            return data[data.Length / 2];
        }
        
        public static double Median(this IEnumerable<long> source)
        {
            var data = source.OrderBy(n => n).ToArray();
            if (data.Length == 0)
                throw new InvalidOperationException();
            if (data.Length % 2 == 0)
                return (data[data.Length / 2 - 1] + data[data.Length / 2]) / 2.0;
            return data[data.Length / 2];
        }
        
        public static float Median(this IEnumerable<float> source)
        {
            var data = source.OrderBy(n => n).ToArray();
            if (data.Length == 0)
                throw new InvalidOperationException();
            if (data.Length % 2 == 0)
                return (data[data.Length / 2 - 1] + data[data.Length / 2]) / 2.0f;
            return data[data.Length / 2];
        }
        
        public static double Median(this IEnumerable<double> source)
        {
            var data = source.OrderBy(n => n).ToArray();
            if (data.Length == 0)
                throw new InvalidOperationException();
            if (data.Length % 2 == 0)
                return (data[data.Length / 2 - 1] + data[data.Length / 2]) / 2.0;
            return data[data.Length / 2];
        }
        
        public static decimal Median(this IEnumerable<decimal> source)
        {
            var data = source.OrderBy(n => n).ToArray();
            if (data.Length == 0)
                throw new InvalidOperationException();
            if (data.Length % 2 == 0)
                return (data[data.Length / 2 - 1] + data[data.Length / 2]) / 2.0m;
            return data[data.Length / 2];
        }
        
        
        public static double Median<TSource>(this IEnumerable<TSource> source, Func<TSource, int> selector)
        {
            return source.Select(selector).Median();
        }
        
        public static double Median<TSource>(this IEnumerable<TSource> source, Func<TSource, long> selector)
        {
            return source.Select(selector).Median();
        }
        
        public static float Median<TSource>(this IEnumerable<TSource> source, Func<TSource, float> selector)
        {
            return source.Select(selector).Median();
        }
        
        public static double Median<TSource>(this IEnumerable<TSource> source, Func<TSource, double> selector)
        {
            return source.Select(selector).Median();
        }
        
        public static decimal Median<TSource>(this IEnumerable<TSource> source, Func<TSource, decimal> selector)
        {
            return source.Select(selector).Median();
        }
        
    }
}