(面倒くさい方法で)「L-intersection」をjavascriptで解いてみた

javascriptの勉強がてら過去のどう書くを解かせてもらっています。

問題はこちら
http://nabetani.sakura.ne.jp/hena/ord6lintersection/

「オフラインリアルタイムどう書く第6回の参考問題」
http://qiita.com/Nabetani/items/4c60f10b73812e86441c

今回はみなさんの回答をいくつか先に拝見してから、違う方法を探して解いてみました。
（全部は拝見していないので一緒の解法のものがあるかもしれませんが）

```js:l-intersection.js

var solve = function test (input) {
    'use strict';

        // (p)oint とりあえずバラバラにして今回使用する座標に変換
    var p = input.match(/\d/g).reduce(function (x, y, i) {
                var color = i < 6 ? 'r' : 'g'
                  , num   = Math.round((i % 6 + 1) / 2) // 頂点番号
                  , pos   = i % 2 // x軸:0, y軸:1
                  , f1, f2;
                
                y = y *1;

                switch(num) {
                case 1: // 最初の頂点
                    x[color + '1'].push(y);
                    break;
                case 2: // 対角の頂点 (入替有)
                    x[color + '2'].push(y);
                    break;
                case 3: // 欠けている部分の頂点
                    f1 = x[color + '1'][pos];
                    f2 = x[color + '2'][pos];
                    if (Math.abs(f1 - f2) < Math.abs(f1 - y)) {
                        x[color + '2'][pos] = y; // 対角の頂点入替
                        x[color + '3'].push(f1 < y ? f2 + 1 : f2 - 1);
                    } else {
                        x[color + '3'].push(f1 < f2 ? y + 1 : y - 1);
                    }
                }
                return x;
            }, {r1:[], r2:[], r3:[], g1:[], g2:[], g3:[]})

        // ２線の重複していている幅もしくは高さを返す関数
      , over = function (a, b, x, y) {
            // 引数入替
            var tmp;
            if (b < a) { tmp = a; a = b; b = tmp;}
            if (y < x) { tmp = x; x = y; y = tmp;}

            // 並べ替え
            var odr = [a, b, x, y].sort(function(a, b) { return a - b;});

            switch(true) {

            // a-x-y-b
            case odr[0] === a && odr[3] === b:
                return y - x + 1;

            // x-a-b-y
            case odr[0] === x && odr[3] === y:
                return b - a + 1;

            // a-x-b-y
            case odr[0] === a && odr[3] === y && x <= b:
                return b - x + 1;

            // x-a-y-b
            case odr[0] === x && odr[3] === b && a <= y:
                return y - a + 1;

            // other
            default:
                return 0;
            }
        }

        // 重複部分の面積
      , rgOver = over(p.r1[0], p.r2[0], p.g1[0], p.g2[0]) * over(p.r1[1], p.r2[1], p.g1[1], p.g2[1])

        // それぞれ欠けている部分との重複の面積
      , rLack  = over(p.r3[0], p.r2[0], p.g1[0], p.g2[0]) * over(p.r3[1], p.r2[1], p.g1[1], p.g2[1])
      , gLack  = over(p.r1[0], p.r2[0], p.g3[0], p.g2[0]) * over(p.r1[1], p.r2[1], p.g3[1], p.g2[1])

        // 欠けている部分同士の重複の面積
      , rgLack = over(p.r3[0], p.r2[0], p.g3[0], p.g2[0]) * over(p.r3[1], p.r2[1], p.g3[1], p.g2[1])

      , result = rgOver - rLack - gLack + rgLack;

    return result;
};

var data = [
/*#1*/ ["23-94-28,89-06-51", 11],
/*#2*/ ["11-84-58,02-73-69", 40],
/*#3*/ ["18-41-86,77-04-32", 26],
/*#4*/ ["81-88-23,64-58-14", 0],
/*#5*/ ["31-29-07,41-87-69", 0],
/*#6*/ ["83-13-40,18-10-94", 1],
/*#7*/ ["77-80-92,21-72-38", 2],
/*#8*/ ["57-70-91,55-19-08", 3],
/*#9*/ ["18-22-75,66-80-91", 4],
/*#10*/ ["51-93-78,54-49-06", 5],
/*#11*/ ["58-70-96,17-43-76", 6],
/*#12*/ ["58-07-12,58-82-93", 7],
/*#13*/ ["41-29-07,35-95-88", 8],
/*#14*/ ["88-26-60,42-29-07", 9],
/*#15*/ ["18-40-85,34-40-91", 10],
/*#16*/ ["36-60-96,53-96-89", 11],
/*#17*/ ["51-39-02,44-98-69", 12],
/*#18*/ ["48-06-20,76-04-42", 13],
/*#19*/ ["85-29-18,26-50-93", 14],
/*#20*/ ["27-50-91,43-29-07", 15],
/*#21*/ ["57-06-20,48-60-91", 16],
/*#22*/ ["52-98-89,21-76-67", 17],
/*#23*/ ["67-12-40,45-80-92", 18],
/*#24*/ ["47-03-10,26-30-82", 19],
/*#25*/ ["74-28-06,21-86-37", 20],
/*#26*/ ["65-01-20,73-39-05", 21],
/*#27*/ ["17-72-86,36-50-94", 22],
/*#28*/ ["51-29-07,77-15-41", 23],
/*#29*/ ["33-98-39,82-16-02", 24],
/*#30*/ ["75-05-10,37-81-96", 25],
/*#31*/ ["72-58-06,48-80-96", 26],
/*#32*/ ["81-67-16,21-91-59", 27],
/*#33*/ ["13-96-57,24-96-79", 28],
/*#34*/ ["57-04-32,51-18-06", 29],
/*#35*/ ["88-03-52,28-41-86", 30],
/*#36*/ ["78-04-61,13-86-49", 31],
/*#37*/ ["58-12-20,27-50-85", 32],
/*#38*/ ["61-19-05,71-68-15", 33],
/*#39*/ ["63-29-16,18-31-83", 34],
/*#40*/ ["16-50-91,32-98-79", 35],
/*#41*/ ["82-17-03,38-40-81", 36],
/*#42*/ ["72-48-04,11-98-39", 37],
/*#43*/ ["77-05-10,28-50-62", 38],
/*#44*/ ["38-50-91,11-86-57", 39],
/*#45*/ ["87-05-10,13-97-69", 40],
/*#46*/ ["11-86-49,22-98-89", 44],
/*#47*/ ["11-97-69,12-86-67", 46],
/*#48*/ ["11-95-69,71-49-05", 47],
/*#49*/ ["28-31-92,13-98-79", 48]
];

// テスト
data.forEach(function (item) {
    console.log(solve(item[0]) === item[1]);
});

```

（なんとなく解説）
座標を、大きい四角の中に小さい四角が入っているように二つの座標に変換して
重なっている部分の面積を足したり引いたりして計算しています。

できるだけ繰り返しの処理(for, forEach, mapとか）を使用しないで処理してみました。
おかげで長ったらしいですが、内容は薄くて簡単です。(保守はしやすいかも）

ビットたてるのと比べて利点は特にないです。
10000*10000とかマップが大きければ、それなりに変わるかも知れないなー

(追記)
やってしまった。。。
誤）var odr = [a, b, x, y].sort();
正）var odr = [a, b, x, y].sort(function(a, b) { return a - b;});
数字のソートは比較用の関数が必要でした。
今回はたまたま一桁の数字だけなので影響はないですが、一応変更