												import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.InputMismatchException;
import java.util.Iterator;
import java.util.TreeSet;
								public class Solution1 implements Runnable
								{
									static final long MAX = 1000000007L;
									static class InputReader
									{
										private InputStream stream;
										private byte[] buf = new byte[1024];
										private int curChar;
										private int numChars;
										private SpaceCharFilter filter;
										private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
								 
										public InputReader(InputStream stream)
										{
											this.stream = stream;
										}
										
										public int read()
										{
											if (numChars==-1) 
												throw new InputMismatchException();
											
											if (curChar >= numChars)
											{
												curChar = 0;
												try 
												{
													numChars = stream.read(buf);
												}
												catch (IOException e)
												{
													throw new InputMismatchException();
												}
												
												if(numChars <= 0)				
													return -1;
											}
											return buf[curChar++];
										}
									 
										public String nextLine()
										{
											String str = "";
								            try
								            {
								                str = br.readLine();
								            }
								            catch (IOException e)
								            {
								                e.printStackTrace();
								            }
								            return str;
										}
										public int nextInt()
										{
											int c = read();
											
											while(isSpaceChar(c)) 
												c = read();
											
											int sgn = 1;
											
											if (c == '-') 
											{
												sgn = -1;
												c = read();
											}
											
											int res = 0;
											do 
											{
												if(c<'0'||c>'9') 
													throw new InputMismatchException();
												res *= 10;
												res += c - '0';
												c = read();
											}
											while (!isSpaceChar(c)); 
											
											return res * sgn;
										}
										
										public long nextLong() 
										{
											int c = read();
											while (isSpaceChar(c))
												c = read();
											int sgn = 1;
											if (c == '-') 
											{
												sgn = -1;
												c = read();
											}
											long res = 0;
											
											do 
											{
												if (c < '0' || c > '9')
													throw new InputMismatchException();
												res *= 10;
												res += c - '0';
												c = read();
											}
											while (!isSpaceChar(c));
												return res * sgn;
										}
										
										public double nextDouble() 
										{
											int c = read();
											while (isSpaceChar(c))
												c = read();
											int sgn = 1;
											if (c == '-') 
											{
												sgn = -1;
												c = read();
											}
											double res = 0;
											while (!isSpaceChar(c) && c != '.') 
											{
												if (c == 'e' || c == 'E')
													return res * Math.pow(10, nextInt());
												if (c < '0' || c > '9')
													throw new InputMismatchException();
												res *= 10;
												res += c - '0';
												c = read();
											}
											if (c == '.') 
											{
												c = read();
												double m = 1;
												while (!isSpaceChar(c)) 
												{
													if (c == 'e' || c == 'E')
														return res * Math.pow(10, nextInt());
													if (c < '0' || c > '9')
														throw new InputMismatchException();
													m /= 10;
													res += (c - '0') * m;
													c = read();
												}
											}
											return res * sgn;
										}
										
										public String readString() 
										{
											int c = read();
											while (isSpaceChar(c))
												c = read();
											StringBuilder res = new StringBuilder();
											do 
											{
												res.appendCodePoint(c);
												c = read();
											} 
											while (!isSpaceChar(c));
											
											return res.toString();
										}
									 
										public boolean isSpaceChar(int c) 
										{
											if (filter != null)
												return filter.isSpaceChar(c);
											return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
										}
									 
										public String next() 
										{
											return readString();
										}
										
										public interface SpaceCharFilter 
										{
											public boolean isSpaceChar(int ch);
										}
									}
								 	
									public static void main(String args[]) throws Exception
									{
										new Thread(null, new Solution1(),"Solution1",1<<26).start();
									}
									
									static long gcd(long a, long b)
								    {
								        // Everything divides 0 
								        if (a == 0 || b == 0)
								           return 0;
								     
								        // base case
								        if (a == b)
								            return a;
								     
								        // a is greater
								        if (a > b)
								            return gcd(a-b, b);
								        return gcd(a, b-a);
								    }
								    
								    // method to return LCM of two numbers
								    static long lcm(long a, long b)
								    {
								        return (a*b)/gcd(a, b);
								    }
								    class Node{
								    	long val;
								    	int ind;
								    	Node(long val,int ind){
								    		this.val = val;
								    		this.ind = ind;
								    	}
								    }
								    
								    TreeSet<Integer> ar[];
									public void run()
									{
										InputReader sc= new InputReader(System.in);
										PrintWriter w= new PrintWriter(System.out);
										int n = sc.nextInt();
										int[] arr = new int[n/2];
										for(int i = 0;i < n/2;i++) {
											arr[i] = sc.nextInt();
										}
										int count1 = 0;
										int count2 = 0;
										Arrays.sort(arr);
										for(int i = 1;i <= n;i+=2) {
											count1 += Math.abs(i - arr[i/2]);
										}
										for(int i = 2;i <= n;i+=2) {
											count2 += Math.abs(i - arr[i/2-1]);
										}
										w.println(Math.min(count1,count2));
										w.close();
										
									}
									
									
									static class Pair implements Comparable<Pair>{
										int a;
										int b;
										
										Pair(int a,int b){
											this.a = a;
											this.b = b;
											
										}
										public int compareTo(Pair p){
											return Integer.compare(this.b,p.b);
										}
									}
					}