如何查找長度可變的數字和數組的總和

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 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， 1，c + 1]
1 + [a，b，c] =（1 + a + b + c）或（1 + a）+（1 + b）+（1 + c） ，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; 
       } 
      } 
    } 
};