Gushwell's C# Dev Notes

   Tweet

問題

2×2 のマス目の左上からスタートした場合, 引き返しなしで右下にいくルートは 6 つある.

では, 20×20 のマス目ではいくつのルートがあるか.

   Project Euler日本語翻訳サイト から引用

最初に書いたコード

最初に、再帰を使ったコードを書いたのですが、 あまりにも時間がかかりすぎて、使い物になりません。
コードは間違っていないはずですが、 待てど暮らせど、プログラムが終わりません。 まずは、そのめちゃくちゃ遅いコード。

import * as Utils from './utils';

class Solver {
        exec(num: number): number {
            return this.f(num + 1, num + 1);
        }

        private f(x: number, y: number): number {
            if (x <= 1 || y <= 1)
                return 1;
            return this.f(x - 1, y) + this.f(x, y - 1);
        }

}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(1000000);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        } 
    }
}

Application.run();

改良する

上記の再帰処理コードはとても簡潔で綺麗なコードなのですが、何回も何回も同じ計算をしてしまうのが欠点です。
そのため、効率を考えて書き直してみました。 2次元配列（ジャグ配列）を用意し、一度計算した結果を覚えておくように （メモ化）してみました。
メソッド f で、既に計算済みの値の場合は、配列の値を返して、再帰処理するのを端折っています。

class Solver {
    exec(num: number): number {
        this.array = new Array(num + 2);
        for (var i = 0; i < this.array.length; i++)
            this.array[i] = new Array(num + 2);
        return this.f(num + 1, num + 1);
    }

    private array: number[][];

    private f(x: number, y: number): number {
        var val = this.array[x][y];
        if (val !== undefined)
            return val;         // もう結果はわかっているので、計算済みの値を返す。
        if (x <= 1 || y <= 1)
            return 1;
        var n = this.f(x - 1, y) + this.f(x, y - 1);
        this.array[x][y] = n;
        return n;
    }
}

これならば、16ミリ秒で終わりました。ほんのちょっとした工夫で、劇的に速度が改善しました。

非再帰版も書いて見る

ついでに、非再帰版も書いてみました。 再帰版は、最後の右下から逆に求めていくやり方だけど、非再帰版は、左上から答えを求めています。

f(x - 1, y) + f(x, y - 1);

で、(x,y)点までの経路の数を求める基本的考え方は変わりません。

こちらも、16ミリ秒で計算できました。

class Solver {
    exec(num: number): number {
        var size = num + 2;
        var array: number[][] = new Array(size);
        for (var i = 0; i < size; i++) {
            array[i] = new Array(size);
            for (var j = 0; j < size; j++)
                array[i][j] = 0;
        }
        array[1][1] = 1;
        for (var x = 1; x < size; x++) {
            for (var y = 1; y < size; y++) {
                if (x === 1 && y === 1)
                    continue;
                // 計算済みの結果を利用し、次の値を求める。
                array[x][y] = array[x - 1][y] + array[x][y - 1];
            }
        }
        return array[num + 1][num + 1];
   }
}

２番目のコードと同様、２次元配列（ジャグ配列）に経路数を記憶させていますが、記憶した値は、次のステップで利用しています。 ここが、再帰版とは微妙に違っています。
この３番目のコードは、動的計画法の一種ですかね。 動的計画法 って、なんか小難しくて偉そうな名前ですが、それほど難しい概念じゃないですね。

話がそれました。 それにしても、TypeScriptの配列の初期化はとんでもなく面倒くさいです。 C#ならば、以下の１行で、すべての要素が 0になるのに、TypeScriptは、いちいち 初期値を与えなくてはいけません。

var array = new long[size, size];

もっと簡単に書ける方法があるのではと思って調べたのですが、わかりませんでした。 undefinedという概念がある TypeScriptでは仕方がないのかなー？

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。

   Tweet

TypeScriptでProject Euler #14 「最長のコラッツ数列」

問題

正の整数に以下の式で繰り返し生成する数列を定義する.

n → n/2 (n が偶数)

n → 3n + 1 (n が奇数)

13からはじめるとこの数列は以下のようになる.

13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

13から1まで10個の項になる. この数列はどのような数字からはじめても最終的には 1 になると考えられているが, まだそのことは証明されていない(コラッツ問題)

さて, 100万未満の数字の中でどの数字からはじめれば最長の数列を生成するか.

注意: 数列の途中で100万以上になってもよい

   Project Euler日本語翻訳サイト から引用

最初に書いたコード

import * as Utils from './utils';

class Solver {
    exec(num: number): number {
       let max = 0;
       let ans = 0;
       for (let n = num - 1; n > 0; n--) {
           let collatz = this.nextCollatz(n);
           let count = 2;  // 数列の２番目までは求め終わっている
           while (collatz !== 1) {
               collatz = this.nextCollatz(collatz);
               count++;
           }
           if (max < count) {
               max = count;
               ans = n;
           }
       }
       return ans;
    }

    nextCollatz(n: number): number {
        if (n % 2 === 0)
            return n / 2;
        return 3 * n + 1;
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(1000000);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        } 
    }
}

Application.run();

新しいMacにしたのでコンピュータの性能は向上していると思うのですが、それでも3秒近くかかります。

改良できないか考えてみる

もう少し速くできないか考えてみました。 例えば、13からはじめた数列が求め終わっていた場合、40や20などから始まる数列の長さは 13からはじめた数列の長さよりも短いことは明白です。 そのため、いったん求まった数列の個数を ハッシュテーブル(C#で言うDictionary)に覚えておけば、 また同じ数列を求めなおす必要がないので、効率的に解を求められます。

Key  - Value
13  - 9
40 - 8
20 - 7
...
4 - 2
2 - 1
1 - 0

というように、覚えておけば、数列を求めていく途中で、ハッシュテーブル に存在している値が出現すれば、 それ以降の数列を求めなくても、途中まで求めた数列の数と、ハッシュテーブルもっと高速化できそうです。 試しに、この考えで solveメソッドのコードを書き換えてみました。

TypeScriptでは、以下のように書くと、ハッシュテーブルが使えるようです。

let known: { [key: number]: number } = [];

まあ、実態はJavaScriptのArrayなので、あくまでも、TypeScript側で型チェックできるというだけのようですが... ということでsolveメソッドを以下のように書いてみました。

改良後のコード

class Solver {
    // ハッシュテーブル
    private known: { [key: number]: number } = [];

    exec(num:  number): number  {
        let max = 0;
        let ans = 0;
        for (let n = num; n > 0; n--) {
            if (this.known[n] !== undefined)
                continue;
            let x =   this.CollatzSequence(n);
            let count = x[0];
            let list = x[1];
            if (max < count) {
                max = count;
                ans = n;
            }
            // let k = count;
            while (list.length > 0) {
                this.known[list.shift()] = count--;
            }
        }
        return ans;
    }

    // シーケンスを生成し返す。 その時のシーケンスの数も返したいので、Tupleを返す
    CollatzSequence(n:number) : [ number , Array<number> ] {
        let seq: Array<number> = new Array();
        let collatz = n;
        let count = 0;
        while (collatz !== 1) {
            if (this.known[collatz] !== undefined) {
                count += this.known[collatz];
                break;
            }
            seq.push(collatz);
            count++;
            collatz = this.nextCollatz(collatz);
        }
        return [ count, seq ];
    }

    nextCollatz(n: number): number {
        if (n % 2 === 0)
            return n / 2;
        return 3 * n + 1;
    }
}

コードは複雑になりましたが、これで２秒きることができました。

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。

   Tweet

問題

問題は、指定された50桁の数字100個の合計の上から10桁を求めなさい。

というもの。

実際の数字はここ(Project Euler日本語翻訳サイト)をみてください。

どうやって解くか

C#の場合、BigIntegerクラス使えば簡単に書けるけど、TypeScriptのnumberだと、扱える整数の精度をオーバーしてしまうので、簡単にはいきません。

BigIntegerクラスを自作するにはあまりにも大げさすぎるので、もう少し簡単な方法を考えました。

コメントにも書いた通り、10桁を一つの塊としてとらえ、繰り上がり処理をやりながら加算処理をしています。10億進法ですね。そして求めるのは、上から10桁だけなので、それよりも下位の桁は捨て去ってしまってよいことになります。

ということは、BigInteger型のような大きな数を保持しなくても、TypeScriptの Numberの範囲で計算ができるってわけです。

TypeScriptのコード

import * as Utils from './utils';

class Solver {
    exec(lines: Array<string>): number  {
        // 10桁ずつ計算する。10億進法です。longならばオーバーフローすることはない。
        let carry = 0;
        let num = 0;
        for (let i = 1; i <= 5; i++) {
            let sum = 0;
            lines.forEach(s => sum += this.GetNum(s, i));
            num = carry + sum;
            // 10桁を超えた部分は、繰上げ処理を行うため carry変数に入れておく。
            carry = Math.floor(num / 10000000000);
        }
        return parseInt(num.toString().substr(0, 10));
    }

    // 10桁を1桁と考え、n桁目を取り出す nは、1〜5 の整数
    private GetNum(line: string, n: number): number {
        let start = 50 - n * 10;
        return parseInt(line.substr(start, 10));
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(Application.lines);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        } 
         sw = Utils.Stopwatch.startNew();
        try {
            let p = new SolverB();
            let n = p.exec(Application.lines);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        } 
    }

    static lines: string[] = [
            "37107287533902102798797998220837590246510135740250",
            "46376937677490009712648124896970078050417018260538",
            "74324986199524741059474233309513058123726617309629",
            "91942213363574161572522430563301811072406154908250",
            "23067588207539346171171980310421047513778063246676",
            "89261670696623633820136378418383684178734361726757",
            "28112879812849979408065481931592621691275889832738",
            "44274228917432520321923589422876796487670272189318",
            "47451445736001306439091167216856844588711603153276",
            "70386486105843025439939619828917593665686757934951",
            "62176457141856560629502157223196586755079324193331",
            "64906352462741904929101432445813822663347944758178",
            "92575867718337217661963751590579239728245598838407",
            "58203565325359399008402633568948830189458628227828",
            "80181199384826282014278194139940567587151170094390",
            "35398664372827112653829987240784473053190104293586",
            "86515506006295864861532075273371959191420517255829",
            "71693888707715466499115593487603532921714970056938",
            "54370070576826684624621495650076471787294438377604",
            "53282654108756828443191190634694037855217779295145",
            "36123272525000296071075082563815656710885258350721",
            "45876576172410976447339110607218265236877223636045",
            "17423706905851860660448207621209813287860733969412",
            "81142660418086830619328460811191061556940512689692",
            "51934325451728388641918047049293215058642563049483",
            "62467221648435076201727918039944693004732956340691",
            "15732444386908125794514089057706229429197107928209",
            "55037687525678773091862540744969844508330393682126",
            "18336384825330154686196124348767681297534375946515",
            "80386287592878490201521685554828717201219257766954",
            "78182833757993103614740356856449095527097864797581",
            "16726320100436897842553539920931837441497806860984",
            "48403098129077791799088218795327364475675590848030",
            "87086987551392711854517078544161852424320693150332",
            "59959406895756536782107074926966537676326235447210",
            "69793950679652694742597709739166693763042633987085",
            "41052684708299085211399427365734116182760315001271",
            "65378607361501080857009149939512557028198746004375",
            "35829035317434717326932123578154982629742552737307",
            "94953759765105305946966067683156574377167401875275",
            "88902802571733229619176668713819931811048770190271",
            "25267680276078003013678680992525463401061632866526",
            "36270218540497705585629946580636237993140746255962",
            "24074486908231174977792365466257246923322810917141",
            "91430288197103288597806669760892938638285025333403",
            "34413065578016127815921815005561868836468420090470",
            "23053081172816430487623791969842487255036638784583",
            "11487696932154902810424020138335124462181441773470",
            "63783299490636259666498587618221225225512486764533",
            "67720186971698544312419572409913959008952310058822",
            "95548255300263520781532296796249481641953868218774",
            "76085327132285723110424803456124867697064507995236",
            "37774242535411291684276865538926205024910326572967",
            "23701913275725675285653248258265463092207058596522",
            "29798860272258331913126375147341994889534765745501",
            "18495701454879288984856827726077713721403798879715",
            "38298203783031473527721580348144513491373226651381",
            "34829543829199918180278916522431027392251122869539",
            "40957953066405232632538044100059654939159879593635",
            "29746152185502371307642255121183693803580388584903",
            "41698116222072977186158236678424689157993532961922",
            "62467957194401269043877107275048102390895523597457",
            "23189706772547915061505504953922979530901129967519",
            "86188088225875314529584099251203829009407770775672",
            "11306739708304724483816533873502340845647058077308",
            "82959174767140363198008187129011875491310547126581",
            "97623331044818386269515456334926366572897563400500",
            "42846280183517070527831839425882145521227251250327",
            "55121603546981200581762165212827652751691296897789",
            "32238195734329339946437501907836945765883352399886",
            "75506164965184775180738168837861091527357929701337",
            "62177842752192623401942399639168044983993173312731",
            "32924185707147349566916674687634660915035914677504",
            "99518671430235219628894890102423325116913619626622",
            "73267460800591547471830798392868535206946944540724",
            "76841822524674417161514036427982273348055556214818",
            "97142617910342598647204516893989422179826088076852",
            "87783646182799346313767754307809363333018982642090",
            "10848802521674670883215120185883543223812876952786",
            "71329612474782464538636993009049310363619763878039",
            "62184073572399794223406235393808339651327408011116",
            "66627891981488087797941876876144230030984490851411",
            "60661826293682836764744779239180335110989069790714",
            "85786944089552990653640447425576083659976645795096",
            "66024396409905389607120198219976047599490197230297",
            "64913982680032973156037120041377903785566085089252",
            "16730939319872750275468906903707539413042652315011",
            "94809377245048795150954100921645863754710598436791",
            "78639167021187492431995700641917969777599028300699",
            "15368713711936614952811305876380278410754449733078",
            "40789923115535562561142322423255033685442488917353",
            "44889911501440648020369068063960672322193204149535",
            "41503128880339536053299340368006977710650566631954",
            "81234880673210146739058568557934581403627822703280",
            "82616570773948327592232845941706525094512325230608",
            "22918802058777319719839450180888072429661980811197",
            "77158542502016545090413245809786882778948721859617",
            "72107838435069186155435662884062257473692284509516",
            "20849603980134001723930671666823555245252804609722",
            "53503534226472524250874054075591789781264330331690",
        ];
}

Application.run();

ちょっと解説

今回は、

などを利用しました。

特筆すべきは、配列に対するforEachメソッドですかね。これは、C#のList<T>.ForEachとほぼ同じ感覚で使えます。合計を求める際にこのforEachを利用してみました。

ちなみに、forEachを使っている以下の部分ですが、

    let sum = 0;
    lines.forEach(s => sum += this.GetNum(s, i));

reduce使って、以下のように1行で書くこともできますね。

    let sum = lines.reduce((x,y) => x + this.GetNum(y, i), 0);

reduceの第2引数に初期値を与えているのがみそ。これをやらないと、+演算子が、文字列の連結になってしまいます。

おまけ (C#だと)

C#でBigIntegerを使った場合、Problemクラスは、こんな感じに書けます。

static class Problem {
    public static long Solve(string[] lines) {
        BigInteger sum = lines.Select(s => BigInteger.Parse(s))
                              .Aggregate((r,n) => r + n);
        return long.Parse(sum.ToString().Substring(0, 10));
    }
}

LINQのSumメソッドはBigIntegerには使えないので、Aggregate使っています。

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。

   Tweet

問題

三角数の数列は自然数の和で表わされ, 7番目の三角数は 1 + 2 + 3 + 4 + 5 + 6 + 7 = 28 である. 三角数の最初の10項は:

1, 3, 6, 10, 15, 21, 28, 36, 45, 55, ...
となる.

最初の7項について, その約数を列挙すると, 以下のとおり.

1: 1
3: 1,3
6: 1,2,3,6
10: 1,2,5,10
15: 1,3,5,15
21: 1,3,7,21
28: 1,2,4,7,14,28

これから, 7番目の三角数である28は, 5個より多く約数をもつ最初の三角数であることが分かる.

では, 500個より多く約数をもつ最初の三角数はいくつか.

どうやって解くか

約数の個数を求めるときに、１から順に割り切れるかどうかを調べていくのはあまりにも効率悪いので、 素数で割っていくことにします。結果的には素因数分解しているのと同じになりますね。

例えば、28 の場合、22×71 となって、 約数は、(1,2,4)と(1,7)を掛け合わせた組み合わせになるので、

1×1
1×7
2×1
2×7
4×1
4×7

で、1,7,2,14,4,28 の6個となります。 つまり、指数の2と1にそれぞれ1を加え、(2+1)*(1+1) を計算すればよいですね。

1176 の場合は、23 ×31 ×72 となって、 約数は、(1,2,4,8)と(1,3)と(1,7,49)を掛け合わせた組み合わせになるので、約数の数は、(3+1)×(1+1)×(2+1)=24になります。

このような考えで書いたのが「最初に書いたバージョン」でしましたコードです。以前のPrimesNumber.tsを使っています。

最初のバージョン

import * as Utils from './utils';
import { PrimeNumber } from './math/primenumber';

class Solver {
    exec(num: number): number {
        let ans = this.TriangleNumbers(n => {
            return num > this.CountFactors(n);
        });
        return ans;
    }

    //  三角数を列挙する
    private TriangleNumbers(callback: (number) => boolean): number {
        let tri = 0;
        let i = 1;
        while (true) {
            tri += i;
            if (!callback(tri))
                break;
            i++;
        }
        return tri;
    }

    // 約数の個数をカウントする
    private CountFactors(num: number): number {
        let count = 1;
        for (let p of PrimeNumber.enumerate()) {
            if (num === 1)
                break;
            let a = 1;
            while (num % p === 0) {
                num = num / p;
                a++;
            }
            count *= a;
        }
        return count;
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(500);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        } 
    }
}

Application.run();

予想どおり遅いです。 素数で割っても、素数の列挙が効率悪すぎるからですね。

素数はエラトステネスの篩で求めておきたいのだけれど、いくつまでの素数が必要なのかが事前にわからないため、馬鹿正直に列挙するバージョンである PrimeNumber.ts を使ったのですが、やはりだめでした。

改良

しかたないので、Primes クラス（エラトステネスの篩バージョン）を改良し、上限を指定せずに、素数を列挙し続けるようにします。以前 C#で書いたコード「C#:エラトステネスの篩(ふるい)再び」をもとにしています。

export class Primes {
    private static primes = [ 2, 3 ];
    private static ix = 0;

    public static * enumerate(): IterableIterator<number> {
        // 2,3は既知の素数とする
        //let primes = [ 2, 3 ];
        for (let i = 0; i < Primes.primes.length; i++)
            yield Primes.primes[i];

        // 4以上の整数から素数を列挙する。int.MaxValueを超えたときには対処していない
        //let ix = 0;
        while (true) {
            let prime1st = Primes.primes[Primes.ix];
            let prime2nd = Primes.primes[++(Primes.ix)];
            // ふるい用の配列の下限、上限を求め、配列を確保する。
            let lower = prime1st * prime1st;
            let upper = prime2nd * prime2nd - 1;
            // ふるいは、[4:8], [9:24], [25:48], [49:120]... と変化する。
            // []内の数値は、配列の下限と上限
            let sieve = []; //new BoundedBoolArray(lower, upper);
            for (let index = lower; index <= upper; index++)
                sieve[index- lower] = false;

            // 求まっている素数を使い、ふるいに掛ける 
            for (let i = 0; i < Primes.ix; i++) {
                let prime = Primes.primes[i];
                let start = Math.ceil(lower / prime) * prime;
                for (let  index = start; index <= upper; index += prime)
                    sieve[index - lower] = true;
            }

            // ふるいに掛けられて残った値が素数。これを列挙する。
            // 併せて、求まった素数は、primesリストに記憶していく。
            // この素数が次のステップ以降で、ふるいに掛ける際に利用される。
            let newix = Primes.primes.length;
            for (let i = lower; i <= upper; i++) {
                if (sieve[i - lower] !== true) {
                    Primes.primes.push(i);
                }
            }
            for (let i = newix; i <= Primes.primes.length; i++) {
                yield Primes.primes[i];
            }
        }
    }
}

enumerateを複数回呼び出したときに、一から素数を求めなおすことにないように、staticメンバー primes配列に素数を記憶しておき、２回目以降はこの primes配列から素数を列挙するようにしています。この配列にある素数よりも大きい素数が必要な場合には、エラトステネスの篩を使い、素数を求めます。もちろんここで求めた素数は、primes配列に記憶しておきます。

この工夫がないと、最初のバージョンよりも数倍遅いという結果になってしまいました。C#だとそんなことはないと思うんだけどなー。

このprimes.tsを使い、Solverクラスを書き換えます。

import * as Utils from './utils'; 
import { Primes } from './math/primes';

class Solver { 
    exec(num: number): number { 
        for (let ans of this.TriangleNumbers()) {
            if (this.CountFactors(ans) > num) 
                return ans; 
        } 
        return -1; 
    }

    //  三角数を列挙する
    private * TriangleNumbers(): IterableIterator<number> {
        let tri = 0;
        let i = 1;
        while (true) {
            tri += i;
            yield tri;
            i++;
        }
    }

    // 約数の個数をカウントする
    private CountFactors(num: number): number {
        let count = 1;
        for (let p of Primes.enumerate()) {
            if (num === 1)
                break;
            let a = 1;
            while (num % p === 0) {
                num = num / p;
                a++;
            }
            count *= a;
        }
        return count;
    }
}

Applicationクラスは、そのまま変更ありません。これで、２倍ほど早くなりました。劇的な速度アップはなりませんでした。JavaScriptのyield文が遅いせいなのかな？

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。

   Tweet

問題

上の 20×20 の格子のうち, 斜めに並んだ4つの数字が赤くマークされている.
 

08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08
49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00
81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65
52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91
22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80
24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50
32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70
67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21
24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72
21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95
78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92
16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57
86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58
19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40
04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66
88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69
04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36
20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16
20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54
01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48

それらの数字の積は 26 × 63 × 78 × 14 = 1788696 となる.

上の 20×20 の格子のうち, 上下左右斜めのいずれかの方向で連続する4つの数字の積のうち最大のものはいくつか?

   Project Euler日本語翻訳サイト から引用

TypeScriptのコード

TypeScriptは、C# のように A[x,y] といった２次元配列は書けないんですね。 たぶん...
なのでジャグ配列を使って２次元を表現することにします。

上下左右斜めとありますが、実際には、ある一点を考えた場合、その点を始点とする、左、下、左下、右下の４つを調べれば十分ですね。

Index overしないようにする点だけが面倒なところ。

配列のサイズは、必ず縦横が同じサイズである前提としました。 

import * as Utils from './utils';

class Solver {
    private nums: number[][];

    exec(array: number[][]): number {
        this.nums = array;
        let size = array.length;
        let max = 0;
        for (let x = 0; x < size; x++) {
            for (let y = 0; y < size; y++) {
                max = Math.max(max, this.virt(x, y));
                max = Math.max(max, this.hor(x, y));
                max = Math.max(max, this.diagDown(x, y));
                max = Math.max(max, this.diagUp(x, y));
            }
        }
        return max;
    }

    private virt(x: number, y: number): number {
        if (y + 3 >= 20)
            return -1;
        return this.nums[x][y] * this.nums[x][y + 1] * this.nums[x][y + 2] * this.nums[x][y + 3];
    }

    private hor(x: number, y: number): number {
        if (x + 3 >= 20)
            return -1;
        return this.nums[x][y] * this.nums[x + 1][y] * this.nums[x + 2][y] * this.nums[x + 3][y];
    }

    private diagDown(x: number, y: number): number {
        if (y + 3 >= 20 || x + 3 >= 20)
            return -1;
        return this.nums[x][y] * this.nums[x + 1][y + 1] * this.nums[x + 2][y + 2] * this.nums[x + 3][y + 3];
    }
    
    private diagUp(x: number, y: number): number {
        if (y + 3 >= 20 || x - 3 < 0)
            return -1;
        return this.nums[x][y] * this.nums[x - 1][y + 1] * this.nums[x - 2][y + 2] * this.nums[x - 3][y + 3];
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(Application.nums);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        }
 
    }

    private static nums: number[][] = [
        [  8,  2, 22, 97, 38, 15,  0, 40,  0, 75,  4,  5,  7, 78, 52, 12, 50, 77, 91,  8 ],
        [ 49, 49, 99, 40, 17, 81, 18, 57, 60, 87, 17, 40, 98, 43, 69, 48,  4, 56, 62,  0 ],
        [ 81, 49, 31, 73, 55, 79, 14, 29, 93, 71, 40, 67, 53, 88, 30,  3, 49, 13, 36, 65 ],
        [ 52, 70, 95, 23,  4, 60, 11, 42, 69, 24, 68, 56,  1, 32, 56, 71, 37,  2, 36, 91 ],
        [ 22, 31, 16, 71, 51, 67, 63, 89, 41, 92, 36, 54, 22, 40, 40, 28, 66, 33, 13, 80 ],
        [ 24, 47, 32, 60, 99,  3, 45,  2, 44, 75, 33, 53, 78, 36, 84, 20, 35, 17, 12, 50 ],
        [ 32, 98, 81, 28, 64, 23, 67, 10, 26, 38, 40, 67, 59, 54, 70, 66, 18, 38, 64, 70 ],
        [ 67, 26, 20, 68,  2, 62, 12, 20, 95, 63, 94, 39, 63, 08, 40, 91, 66, 49, 94, 21 ],
        [ 24, 55, 58,  5, 66, 73, 99, 26, 97, 17, 78, 78, 96, 83, 14, 88, 34, 89, 63, 72 ],
        [ 21, 36, 23, 09, 75,  0, 76, 44, 20, 45, 35, 14,  0, 61, 33, 97, 34, 31, 33, 95 ],
        [ 78, 17, 53, 28, 22, 75, 31, 67, 15, 94,  3, 80,  4, 62, 16, 14, 09, 53, 56, 92 ],
        [ 16, 39,  5, 42, 96, 35, 31, 47, 55, 58, 88, 24,  0, 17, 54, 24, 36, 29, 85, 57 ],
        [ 86, 56,  0, 48, 35, 71, 89,  7,  5, 44, 44, 37, 44, 60, 21, 58, 51, 54, 17, 58 ],
        [ 19, 80, 81, 68,  5, 94, 47, 69, 28, 73, 92, 13, 86, 52, 17, 77,  4, 89, 55, 40 ],
        [  4, 52, 08, 83, 97, 35, 99, 16,  7, 97, 57, 32, 16, 26, 26, 79, 33, 27, 98, 66 ],
        [ 88, 36, 68, 87, 57, 62, 20, 72,  3, 46, 33, 67, 46, 55, 12, 32, 63, 93, 53, 69 ],
        [  4, 42, 16, 73, 38, 25, 39, 11, 24, 94, 72, 18, 08, 46, 29, 32, 40, 62, 76, 36 ],
        [ 20, 69, 36, 41, 72, 30, 23, 88, 34, 62, 99, 69, 82, 67, 59, 85, 74,  4, 36, 16 ],
        [ 20, 73, 35, 29, 78, 31, 90,  1, 74, 31, 49, 71, 48, 86, 81, 16, 23, 57,  5, 54 ],
        [  1, 70, 54, 71, 83, 51, 54, 69, 16, 92, 33, 48, 61, 43, 52,  1, 89, 19, 67, 48 ],
    ];
}

Application.run();

コードが途中で改行されて見にくいですが、ご容赦を。
ものすごく愚直で面白みのないコードですが、短い時間で終わるので、これでOKとします。まあプログラムらしいコード（ってなんだ？）といえば言えますね。

ここまで書いて思ったのですが、numsフィールド用意したのはあまりよろしくなかったかもしれません。引数で渡すべきだったかも。

ところで、数値リテラルを書く場合、先頭が 0 だと 8進数とみなされてしまうんですね。 それで少し嵌りました。

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。

   Tweet

問題

10以下の素数の和は 2 + 3 + 5 + 7 = 17 である.

200万以下の全ての素数の和を求めよ.

   Project Euler日本語翻訳サイト から引用

最初のバージョン

200万以下のすべての素数をどうやって求めるかという問題ですね。 TypeScriptでProject Euler #7 「10001番目の素数」で素数を列挙する PrimeNumberクラスを書いているので、それを使って書いてみました。

import * as Utils from './utils';
import { PrimeNumber } from './math/primeNumber';

class Solver {
    exec(maxnum: number): number {
        let primes = PrimeNumber.enumerate();
        let sum = 0;
        for (let n of primes) {
            if (n > maxnum)
                break;
            sum += n;    
        }
        return sum;
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(2000000);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        }
    }
}

Application.run();

素数がわかれば、あとは合計するだけなのでそれほど難しくないですね。

次に書いたバージョン

もうすこし速くしたいので、エラストテネスの篩のアルゴリズムを使って、あらたに Primesクラスを書いてみました。Primesクラスのソースを示します。

export class Primes {
    private _sieve = new Array<number>();

    private _sieveSize: Number;

    public constructor(sieveSize: number) {
        this._sieveSize = sieveSize;
        this._sieve = this.sieveOut(sieveSize);
    }

    private sieveOut(maxnum: number): number[] {
        let sieve = new Array(maxnum + 1);
        for (let l = 0; l <= maxnum; l++) {
            sieve[l] = l;
        }
        sieve[1] = -1;  // -1 : 素数ではない
        let squareroot = Math.sqrt(maxnum) | 0;
        for (let i = 2; i <= squareroot; i++) {
            if (sieve[i] > 0)
                for (let n = i * 2; n <= maxnum; n += i)
                    sieve[n] = -1;
        }
        return sieve;
    }
    
    public toArray(): number[] {
        let ary: number[] = [];
        return this._sieve.map((n, ix) => n > 0 ? ix : -1).filter((n, ix) => n > 0);
    }

    public isPrime(n: number): boolean {
        return this._sieve[n] != -1;
    }
}

まだ、メソッドの先頭を小文字にするのに慣れてません(^^;; ついつい、C#のように大文字にしたくなります。

enumerateメソッドで列挙するのではなく、toArrayメソッドで配列として素数を取り出せるようにしてみました。

このPrimesクラスは、今後も使うかもしれないので、primes.ts として独立させておきます。

これを呼び出すように、Solverクラスを書き換えます。

import * as Utils from './utils';
import { Primes } from './math/primes';

class Solver {
    exec(maxnum: number): number {
        let primes = new Primes(maxnum);
        return primes.toArray().reduce((x,y) => x + y);
    }
}

class Application {
    static run(): void {
        let sw = Utils.Stopwatch.startNew();
        try {
            let p = new Solver();
            let n = p.exec(2000000);
            console.log(n);
        } finally {
            sw.stop();
            console.log(sw.toString());
        }
    }
}

Application.run();

実行してみると...

あれ？ 最初のバージョンよりもあきらかに遅いです。

ちゃんとプロファイリングしたわけではないので、正確なところはわかってませんが、たぶん、toArrayメソッドで配列にしているところか、reduceメソッドが遅いとしが考えられません。

最終バージョン

ということで、toArrayメソッドをやめて、素数を列挙する enumerate メソッドを Primesクラスに追加します。

    public * enumerate(): IterableIterator<number> {
        for (let i = 0; i < this._sieveSize; i++) {
          if (this._sieve[i] > 0)
              yield this._sieve[i];
        }
    }

Solverクラスのexecメソッドをenumerate使うように変更します。

    exec(maxnum: number): number {
        let primes = new Primes(maxnum);
        let sum = 0;
        for (let n of primes.enumerate()) {
            if (n > maxnum)
                break;
            sum += n;    
        }
        return sum;
    }

これで、最初のバージョンよりも3倍ほど速くなりました。めでたしめでたし(^o^)...

それにしても、C#のLINQに慣れてしまうと、ループ書くのがほんとうに面倒になりますね。

※Stopwatchクラスについては、「TypeScriptでProject Euler #0」 を見てください。