Project Euler 93

/**
 * Copyright uwi ( http://wonderfl.net/user/uwi )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/bwjV
 */

package {
    import flash.display.Sprite;
    import flash.text.TextField;
    import flash.utils.getTimer;
    // @see http://projecteuler.net/index.php?section=problems&id=93
    public class Euler93 extends Sprite {
        private var _tf : TextField;
  
        public function Euler93() {
            _tf = new TextField();
            _tf.width = 465;
            _tf.height = 465;
            addChild(_tf);
            
            var s : int = getTimer();
            _tf.appendText(solve().toString() + "\n");
            var g : int = getTimer();
            _tf.appendText((g - s).toString() + " ms\n");
        }
        
        private function solve() : int
        {
            var max : int = 0;
            var dig : int = 0;
            for(var a : int = 1;a <= 9;a++){
                for(var b : int = a + 1;b <= 9;b++){
                    for(var c : int = b + 1;c <= 9;c++){
                        for(var d : int = c + 1;d <= 9;d++){ 
                            var n : int = cons(a, b, c, d);
                            if(max < n){
                                max = n;
                                dig = 1000 * a + 100 * b + 10 * c + d;
                            }
                        }
                    }
                }
            }
            return dig;
        }
        
        private function cons(a : int, b : int, c : int, d: int) : int
        {
            // k番目にorder[k-1]の箇所の計算を・・
            var order : Array = [1, 2, 3];
            var i : int, j : int;
            
            var ret : Object = {};
            do {
                var ds : Array = [a, b, c, d];
                do {
                    var xorder : Array = order.concat();
                    for(i = 0;i < 3;i++){
                        for(j = i + 1;j < 3;j++){
                            if(xorder[j] > xorder[i])xorder[j]--;
                        }
                        xorder[i]--;
                    }
                    
                    var curs : Array = [[[ds[0], 1], [ds[1], 1], [ds[2], 1], [ds[3], 1]]];
                    var cur : Array;
                    for each(var xo : int in xorder){ 
                        var nexts : Array = [];
                        for each(cur in curs){
                            var x : Array = cur[xo];
                            var y : Array = cur[xo + 1];
                            var spliced : Array = cur.concat();
                            spliced.splice(xo, 2, []);
                            var newcur : Array;
                            newcur = spliced.concat(); newcur[xo] = [x[0] * y[1] + x[1] * y[0], x[1] * y[1]]; nexts.push(newcur);
                            newcur = spliced.concat(); newcur[xo] = [x[0] * y[1] - x[1] * y[0], x[1] * y[1]]; nexts.push(newcur);
                            newcur = spliced.concat(); newcur[xo] = [x[0] * y[0], x[1] * y[1]]; nexts.push(newcur);
                            newcur = spliced.concat(); newcur[xo] = [x[0] * y[1], x[1] * y[0]]; nexts.push(newcur);
                        }
                        curs = nexts;
                    }
                    for each(cur in curs){
                        var c0 : Array = cur[0];
                        if(c0[0] <= 0)continue;
                        if(c0[0] % c0[1] == 0){
 //                           _tf.appendText("" + c0[0] / c0[1] + "\n");
                            ret[c0[0] / c0[1]] = 1;
                        }
                    }
                    
                }while(nextPermutation(ds));
            }while(nextPermutation(order));
             
            for(i = 1;ret[i];i++);
            return i - 1;
        }
        
        private function nextPermutation(src : Array) : Array
        {
            for(var i : int = src.length - 2;i >= 0 && src[i] > src[i + 1];i--);
            if(i == -1)return null;
            for(var j : int = i + 1;j < src.length && src[i] < src[j];j++);
            var d : int;
            d = src[i]; src[i] = src[j - 1]; src[j - 1] = d;
            for(var p : int = i + 1, q : int = src.length - 1;p < q;p++, q--){
                d = src[p]; src[p] = src[q]; src[q] = d;
            }
            return src;
        }
    }
}