如何找到长度可变的数字和数组的总和

Question

我相信除此之外，左右两侧可以互换，对吗？ 该规则似乎不适用于多模逻辑。

基本概念：
[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]


多模和单数组合：
[1,2,3] + 1 = [2,3,4]
1 + [1,2,3] = 7或9或[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;
                }
            }
    }
};

Answer 1

仍然包含冗余，但是这是我想出的支持数组的脚本。

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 lhsIsSingular = arg1.length === undefined;
            var rhsIsSingular = arg2.length === undefined;
            var length = arg1.length < arg2.length || lhsIsSingular ? arg2.length : arg1.length;
            if (length === undefined) { // lhs is singular & rhs is singular
                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 lhs = [arg1];
                var rhs = [arg2];
                if (!lhsIsSingular) {
                    lhs = arg1;
                    arg1 = 0;
                }
                if (!rhsIsSingular) {
                    rhs = arg2;
                    arg2 = 0;
                }
                for (var i = lhs.length; i < length; i++) {
                    lhs.push(arg1);
                }
                for (var i = rhs.length; i < length; i++) {
                    rhs.push(arg2);
                }
                for (var i = 0; i < length; i++) {
                    lhs[i] = MMMath.add(lhs[i], rhs[i]);

                }
                if (values.length > 2) {
                    values = [lhs].concat(values.slice(2, values.length));
                    return MMMath.add.apply(null, values);
                } else {
                    return lhs;
                }
            }
    }
};