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

0

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

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;
                }
            }
    }
};
于 2013-04-11T21:28:17.927 回答