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

我相信除此之外,左手边和右手边可以互换,对吗?这个规则似乎不适用于多模逻辑。

基本概念:
[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或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+1c)或[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;
                }
            }
    }
};