Problem:
ブロックの三角形

図a のように積まれたブロックに対し、以下の並べ替え操作を繰り返す。

一番下のブロック全て（図a 中の白のブロック）を右端に新しく積み上げる（残りのブロックは自動的に１段下に落ち、図b のようになる）。

ブロックの間に隙間ができたら、左に詰めて隙間をなくす（図 b から図c のようになる）。

1 以上の整数 k に対して、k×(k＋1)/2 で表される数 (例:1, 3, 6, 10, ...)を三角数という。ブロックの総数が三角数の場合、上記の並べ替えを繰り返すと、左端の高さが1 で右に向かって１つずつ高くなっていくような三角形になると予想されている（図d は総数が15 個の場合）。

ブロックの最初の並びが与えられたとき、あらかじめ決められた回数以下の操作で、上で説明したようなブロックの三角形ができるとき、三角形が得られるまでの最小の操作回数を出力するプログラムを作成してください。

入力

入力は複数のデータセットからなる。入力の終わりはゼロ１つの行で示される。各データセットは以下の形式で与えられる。

N
b1 b2 ... bN

各データセットは２行であり、ブロックの最初の並びを表す。N (1 ≤ N ≤ 100)は、一番下の段にあるブロックの数を示す。bi(1 ≤ bi ≤ 10000) は左から i 番目の位置に積まれているブロックの数を示す。bi と bi+1 は１つの空白で区切られている。ブロックの総数は 3 以上である。

データセットの数は 20 を超えない。

出力

データセットごとに、三角形ができるまでに行った並べ替え操作の回数を１行に出力する。ただし、三角形が作れない場合や、操作回数が 10000 回を超える場合は -1 を出力する。

入力例

6
1 4 1 3 2 4
5
1 2 3 4 5
10
1 1 1 1 1 1 1 1 1 1
9
1 1 1 1 1 1 1 1 1
12
1 4 1 3 2 4 3 3 2 1 2 2
1
5050
3
10000 10000 100
0

出力例

24
0
10
-1
48
5049
-1

最初のデータセットが、図に示した場合に対応する。

４つ目のデータセットが、ブロックの総数が三角数でないため、三角形が作れない場合に対応する。

最後のデータセットが、ブロックの総数は三角数だが、操作回数が 10000 回を超える場合に対応する。

Solution in JavaScript (judge verdict: Accepted)

"use strict";
var global_context = global ? global : window;

(function DefineUnderScore() {
    var ArrayProto = Array.prototype;
    var slice = ArrayProto.slice;
    this._ = {};
    _.each = function( obj, iterator, context ) {
        Object.keys(obj).forEach(function(key) {
            if ( iterator.call( context, obj[key], key, obj ) === true )
                return true;
        });
    };
    _.extend = function(obj) {
        _.each(slice.call(arguments, 1), function(source) {
            Object.keys(source).forEach(function(key) {
                obj[key] = source[key];
            });
        });
    };
}).call(global_context);

function Deferred() {
    var queue = [];
    var obj = {
        done: function(func, context) {
            if ( func instanceof Function )
                queue.push({
                    callback: func,
                    context: context
                });
            return this;
        },
        call: function() {
            var args = arguments;
            setTimeout(function() {
                queue.forEach(function(obj) {
                    obj.callback.apply(obj.context, args);
                });
            }, 0);
        }
    };
    return obj;
}

function RawInput() {
    var deferred = new Deferred();
    var stdin = process.stdin;
    stdin.resume();
    stdin.setEncoding('ascii');
    var buffer = '';
    stdin.on('data', function(chunk) {
        buffer += chunk.toString();
    });
    stdin.on('end', function() {
        deferred.call(buffer);
    });
    return deferred;
}

(function DefineSolution( namespace ) {
    var Solution = function() {
        this.input_list = [];
    };
    Solution.prototype = {
        input: function() {
            if ( this.separator instanceof Function )
                this.input_list = this.separator.call( this, this.raw_data );
            else
                this.input_list.push(this.raw_data);
        },
        run: function(raw_data) {
            this.raw_data = raw_data;
            this.input();
            while ( this.has_next() )
                this.solve(this.next()).output();
        },
        read_line: function() {
            return this.input_list.splice(0,1)[0];
        },
        read_number: function() {
            var line = this.read_line();
            return parseInt(line);
        },
        read_numbers: function() {
            var line = this.read_line();
            var terms = line.split(' ');
            return terms.map(function(term) {
                return parseInt(term);
            });
        },
        check_eof: function() {
            return ! this.input_list.length;
        },
        has_next: function() {
            return ! this.check_eof();
        }
    };
    this[namespace] = Solution;
}).call(global_context, 'Solution' );

(function ExtendSolution( namespace ) {
    var NONE = -1;
    var n, A;

    function check_goal() {
        for ( var i = 0; i < n; ++ i ) {
            if ( i + 1 !== A[i] )
                return false;
        }
        return true;
    }

    function move() {
        A = A.map(function(a) {
            return a - 1;
        }).filter(function(a) {
            return a > 0;
        });
        A.push(n);
        n = A.length;
    }

    _.extend(Solution.prototype, {
        separator: function(data) {
            var res = data.split('\n');
            return res;
        },
        check_eof: function() {
            return parseInt(this.input_list[0]) === 0;
        },
        next: function() {
            var n = this.read_number();
            var A = this.read_numbers();
            return {
                n: n,
                A: A
            };
        },
        solve: function(options) {
            n = options.n;
            A = options.A;
            for ( var i = 0; i < 10000; ++ i ) {
                if ( check_goal() ) {
                    this.result = i;
                    return this;
                }
                move();
            }
            this.result = NONE;
            return this;
        },
        output: function() {
            console.log(this.result);
        }
    });
})();

var solution = new Solution;
RawInput.call(global_context).done(solution.run, solution);