0

さらに、左手と右手を入れ替えることができると思いますよね？このルールは、マルチモジュラー ロジックでは機能しないようです。

基本概念:
    [1,2,3] + [4,5,6] = [5,7,9]

異なる長さの追加:
    [1,2,3] + [4,5] = [5,7, 7] または [[5,7],7]
    [1,2] + [3,4,5] = [9,6] または [10,6] または [4,6,6] または [[4, 6],6]
    上記では、ロジックの見方によって、さまざまな出力を確認できます。小さい方の配列が最大インデックスを超えると、最初に戻ります。この場合、LHSの長さが優先されると思います。ただし、より長い長さに準拠するか、別のモジュールを追加することもできます。

マルチモジュラーとシンギュラーの組み合わせ:
    [1,2,3] + 1 = [2,3,4]
    1 + [1,2,3] = 7 or 9 or [2,3,4
    ]他のアイデアが提示されたので、これを見るさまざまな方法があります。

このタイプのロジックに関する確立されたドキュメントを見つけることができなかったので、どんな支援も素晴らしいでしょう. 現在のスクリプトを一番下に追加しました。現在、LHS が優先されます。LHSの優先順位と長さを簡単に切り替えましたが、どちらが正しい方法なのかわかりません。

リクエストに応じて、以下の例の背後にあるロジックを追加しました。各例に従う主な規則は、小さい方の配列が常に最初にループバックすることです。

同じ長さのグループを追加することは既に確立されています:
[a,b,c] + [1,2,3] = [a+1, b+2, c+3]

以下は、さまざまな長さに対して可能な計算です:
[ a,b,c] + [1,2] = [a+2, b+2, c+1] または [[1+a, 1+c], 2+b]
[a,b] + [1 ,2,3] = [a+1+3, b+2] または [(a+1) + (a+3), b+2] または [a+1, b+2, a+3] または[[a+1, a+3], b+2]
[a,b,c] + 1 = [a+1, b+1, c+1]
1 + [a,b,c] = (1 +a+b+c) または (1+a) + (1+b) + (1+c) または [1+a, 1+b, 1+c]

JavaScript:

var MMMath = Math;

// Multimodal add
MMMath.add = function () {
    switch (arguments.length) {
        case 0:
            return NaN;
        case 1:
            return arguments[0];
        default:
            var values = Array.prototype.slice.call(arguments);
            var arg1 = values[0];
            var arg2 = values[1];
            var length = arg1.length < arg2.length || arg1.length === undefined ? arg2.length : arg1.length;
            if (length === undefined) {
                length = 0;
                var sum = arg1 + arg2;
                if (values.length > 2) {
                    values = [sum].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return sum;
                }
            } else {
                var lhsIsMulti = arg1.length !== undefined;
                var rhsIsMulti = arg2.length !== undefined;
                for (var i = 0; i < length; i++) {
                    var lhsPos = i;
                    var rhsPos = i;

                    // if max length goes beyond one array/object's boundaries, revert back to the start
                    if (arg1.length - 1 < lhsPos) {
                        lhsPos -= arg1.length;
                    }
                    if (arg2.length - 1 < rhsPos) {
                        rhsPos -= arg2.length;
                    }
                    if (lhsIsMulti) {
                        if (rhsIsMulti) { // a + 1
                            arg1[lhsPos] = MMMath.add(arg1[lhsPos], arg2[rhsPos]);
                        } else { // a + [1, 2]
                            arg1[lhsPos] = MMMath.add(arg1[lhsPos], arg2);
                        }
                    } else {
                        if (rhsIsMulti) { // [a, b] + 1
                            arg1 = MMMath.add(arg1, arg2[rhsPos]);
                        } else { // [a, b] + [1, 2]
                            arg1 = MMMath.add(arg1, arg2);
                        }
                    }
                }
                if (values.length > 2) {
                    values = [arg1].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return arg1;
                }
            }
    }
};
4

1 に答える 1