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 Rust (1.15.1) (judge verdict: Accepted)

extern crate core;

use std::io::{self, Read};

#[macro_use]
mod parser {
    macro_rules! input {
    ($s:expr=>$($t:tt)*) => {
        let mut lines=$s.split("\n");
        $(
            line_parse!(lines,$t);
        )*
    };
    }

    macro_rules! line_parse {
    ($lines:expr,($($name:ident:$t:tt)*)) => {
        let mut line=$lines.next().unwrap().split_whitespace();
        $(value_def!(line,$name,$t);)*
    };

    //複数行
    ($lines:expr,{$n:expr;$name:ident:$t:tt}) => {
        values_def!($lines,$n,$name,$t);
    };
    }

    macro_rules! value_def {
        ($line:expr, $name:ident, $t:tt) => {
            let $name = value!($line, $t);
        };
    }

    macro_rules! values_def {
        ($lines:expr, $n:expr, $name:ident, $t:tt) => {
            let $name = {
                let mut vec = Vec::new();
                for i in 0..$n {
                    let mut next = $lines.next().unwrap().split_whitespace();
                    vec.push(value!(next, $t));
                }
                vec
            };
        };
    }

    macro_rules! value {
    //配列
    ($line:expr,[$t:tt]) => {
        $line.map(|x|{
        let mut iter=::std::iter::once(x);
        value!(iter,$t)
        }).collect::<Vec<_>>()
    };
    //タプル
    ($line:expr,($($t:tt),*)) => {
        ($(value!($line,$t),)*)
    };
    //文字列
    ($line:expr,#) => {
        $line.next().unwrap()
    };
    //単一値
    ($line:expr,$t:ty) => {
        $line.next().unwrap().parse::<$t>().unwrap()
    };
    }
}
use std::cmp::{max, min};

macro_rules! max {
  ($x:expr) => {
    $x
  };
  ($x:expr, $($xs:tt)+) => {
    max($x,max!($($xs)+))
  };
}

macro_rules! min {
  ($x:expr) => {
    $x
  };
  ($x:expr, $($xs:tt)+) => {
    min($x,min!($($xs)+))
  };
}
fn main() {
    let mut input = String::new();
    io::stdin().read_to_string(&mut input).unwrap();
    let output = solve(input.trim().to_string());
    println!("{}", output);
}

fn solve(input: String) -> String {
    input!(input=>(n:usize)(list:[i64]));
    if n == 1 {
        return "0".to_string();
    }
    let mut list = list
        .into_iter()
        .enumerate()
        .map(|(i, x)| x - i as i64 - 1)
        .collect::<Vec<_>>();
    list.sort();
    let sum = list.clone().into_iter().sum::<i64>();
    let ave = (sum as f64 / list.len() as f64).round() as i64;
    let c1 = list[n / 2];
    let c2 = list[n / 2 + 1];
    let c3 = (c1 + c2) / 2;
    let c4 = (c1 + c2) / 2 + 1;
    let c5 = (c1 + c2) / 2 - 1;
    min!(
        list.clone()
            .into_iter()
            .map(|x| (x - c1).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - c2).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - c3).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - c4).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - c5).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - ave).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - ave + 1).abs())
            .sum::<i64>(),
        list.clone()
            .into_iter()
            .map(|x| (x - ave - 1).abs())
            .sum::<i64>()
    ).to_string()
}

macro_rules! tests {
    ($($name:ident: $input:expr=>$output:expr,)*) => {
        mod tests {
            $(
                #[test]
                fn $name() {
                    assert_eq!($output.trim().to_string(),super::solve($input.trim().to_string()));
                }
            )*
        }
    }
}

tests! {
    test1: "5\n2 2 3 5 5" => "2",
    test2: "9\n1 2 3 4 5 6 7 8 9" => "0",
    test3: "6\n6 5 4 3 2 1" => "18",
    test4: "7\n1 1 1 1 2 3 4" => "6",
    add5: "1\n10" => "0",
}