import java.io.*;
import java.util.*;

// LInt:
//   整数のリスト
//   キューやスタックとして使うのに便利なメソッドを幾つか

class LInt extends ArrayList<Integer>
{
	LInt()                  { super();  }
	LInt( List<Integer> x ) { super(x); }

	LInt getF(int n)  { try{return new LInt(subList(0,n));} finally{removeRange(0,n);} }
	void putF(LInt o) { addAll(0, o.rev()); }
	void putB(LInt o) { addAll(o); }

	LInt sort()       { Collections.sort(this);    return this; }
	LInt rev()        { Collections.reverse(this); return this; }
}

// State:
//   Q, A, B の状態を表すクラス
//   普通にそれぞれをリストとして持っているだけです

class State
{
	// 直前の操作
	int p = 0;

	// 初期化処理 : コピーまたはqのリストから作る
	LInt q, a, b;
	State( State o ) {q = new LInt(o.q); a = new LInt(o.a); b = new LInt(o.b);}
	State( LInt o )  {q = new LInt(o); a = new LInt(); b = new LInt();}

	// HashSetに突っ込みたいのでその辺
	public int hashCode()
		{ return (q.hashCode()<<2) ^ (a.hashCode()) ^ (b.hashCode()>>2); }
	public boolean equals( Object o )
		{ State s = (State) o;
		  return q.equals(s.q) && a.equals(s.a) && b.equals(s.b); }

	// 各種基本操作: 超破壊的
	State QA(int n) { a.putF( q.getF(n) ); p=1; return this; }
	State QB(int n) { b.putF( q.getF(n) ); p=2; return this; }
	State QQ(int n) { q.putB( q.getF(n) ); p=3; return this; }
	State AQ(int n) { q.putB( a.getF(n) ); p=4; return this; }
	State AB(int n) { b.putF( a.getF(n) ); p=5; return this; }
	State BQ(int n) { q.putB( b.getF(n) ); p=6; return this; }
	State BA(int n) { a.putF( b.getF(n) ); p=7; return this; }
	void revQ()     { q.rev(); }

	// 便利メソッド
	boolean isGoal() {
		if( !a.isEmpty() || !b.isEmpty() )
			return false;
		for(int i=1,e=q.size(); i<e; ++i)
			if( q.get(i-1) > q.get(i) )
				return false;
		return true;
	}

	int estimateSteps() {
		int steps = 0;
		for(int i=1; i<q.size(); ++i)
			if( q.get(i-1)+1 != q.get(i) && q.get(i-1)-1 != q.get(i) )
				++steps;
		for(int i=1; i<a.size(); ++i)
			if( a.get(i-1)+1 != a.get(i) && a.get(i-1)-1 != a.get(i) )
				++steps;
		for(int i=1; i<b.size(); ++i)
			if( b.get(i-1)+1 != b.get(i) && b.get(i-1)-1 != b.get(i) )
				++steps;
		return steps + (a.isEmpty() ? 0 : 1) + (b.isEmpty() ? 0 : 1);
	}
}

// DFS:
//   状態空間を指定した深さまでDFS（反復深化の１ステップ）する処理の枠組み

class Found extends Error {}
abstract class DFS
{
	abstract void visit( State s );
	boolean impossible( int d, State s ) { return false; }

	void dfs( int d, State s )
	{
		if( d == 0 )
			visit(s);
		else if( impossible(d--, s) )
			return;
		else
		{
			if( s.p != 1 )
				for(int n=1; n<=s.q.size(); ++n)
					dfs( d, new State(s).QA(n) );
			if( s.p != 2 )
				for(int n=1; n<=s.q.size(); ++n)
					dfs( d, new State(s).QB(n) );
			if( s.p != 3 )
				for(int n=1; n< s.q.size(); ++n)
					dfs( d, new State(s).QQ(n) );
			if( s.p != 4 )
				for(int n=1; n<=s.a.size(); ++n)
					dfs( d, new State(s).AQ(n) );
			if( s.p != 5 )
				for(int n=1; n<=s.a.size(); ++n)
					dfs( d, new State(s).AB(n) );
			if( s.p != 6 )
				for(int n=1; n<=s.b.size(); ++n)
					dfs( d, new State(s).BQ(n) );
			if( s.p != 7 )
				for(int n=1; n<=s.b.size(); ++n)
					dfs( d, new State(s).BA(n) );
		}
	}
}

// sort_inaba:
//   メインルーチン

public class sort_inaba
{
	// 配列１個読み込んでsolveに渡すだけ
	public static void main( String[] _ ) throws IOException
	{
		StreamTokenizer st =
			new StreamTokenizer(
				new BufferedReader(
					new InputStreamReader(System.in)));

		while( st.nextToken() == StreamTokenizer.TT_NUMBER )
		{
			int n = (int) st.nval;
			if( n == 0 )
				break;

			LInt q = new LInt();
			for(int i=0; i<n; ++i)
				{st.nextToken(); q.add( (int)st.nval );}

			System.out.println( solve(q) );
		}
	}

	// 両側探索
	static int solve( LInt q )
	{
		final int BWD_STEPS = 4;
		State fwd_start = new State(q);
		State bwd_start = new State((new LInt(q)).sort().rev());

		// 0〜3 ステップでソートできる場合は、普通に反復深化で見つける

		DFS fwd = new DFS() {
			void visit( State s ) {
				if( s.isGoal() )
					throw new Found();
			}};
		for(int i=0; i<BWD_STEPS; ++i)
			try { fwd.dfs(i, fwd_start); } catch( Found e ) { return i; }

		// ダメな場合、両側探索
		// 後ろから4ステップ操作した全状態の集合を作成

		final Set<State> goal = new HashSet<State>();

		DFS bwd = new DFS() {
			void visit( State s ) {
				s.revQ(); goal.add(s);
			}};
		bwd.dfs( BWD_STEPS, bwd_start );

		// 再び反復深化で、4ステップ集合に入るかどうかを見つける

		fwd = new DFS() {
			void visit( State s ) {
				if( goal.contains(s) )
					throw new Found();
			}
			boolean impossible( int d, State s ) {
				return s.estimateSteps() > d+BWD_STEPS;
			}
		};
		for(int i=0;; ++i)
			try { fwd.dfs(i, fwd_start); } catch( Found e ) { return i+BWD_STEPS; }
	}
}