Question

“任何长度的正数表示为数字字符数组，在0和9之间。我们知道最重要的密码位于数组的索引0的位置。

实施例： - 数字是10282 - 数组将为数字= [1,0,2,8,2]

考虑到这一点，创建一个2个数组的函数，代表两个正数，计算它们的SUM \ ADDITION \ SUMMATION并将其设置在第三个数组中，包含前两个数的总和。“

这就是用自己的语言意大利语翻译练习的方式。

这是我的解决方案，但它并不完全有效。我试过像基本的东西 A = [1,4]，B = [4,7]。结果应该是C = [6,1]，但是它给了我[5,1]，因为它考虑了我使用模块的行而不是我说-1索引位置应该取++的那个。 / p>

帮助＆lt; 3

alert('Insert A length');
var k=asknum();
alert('Insert B length');
var h=asknum();
var A = new Array(k);
var B = new Array(h);
// asknum() is only defined in this particular environment we are
// using at the university. I guess the turnaround would be -prompt- 

function readVet(vet){//inserts values in index positions
  for(i=0;i<vet.length;i++)
    vet[i]=asknum();
}


readVet(A);//fills array
readVet(B);//fills array


function sumArray(vet1,vet2){
  var C = new Array();
  for(i=vet1.length-1;i>(-1);i--){
    for(n=vet2.length-1;n>(-1);n--){
      C[i]=vet1[i]+vet2[i];
      if(C[i]>9){
        C[i]=C[i]%10;
        C[i-1]=C[i-1]++;
    }
  }
  }
  return C;
}

print(sumArray(A,B));

Answer 1

我不确定你在这里使用嵌套for循环做了什么。你只需要一个。另外，为了使所述循环非常简单，首先将数组规范化，使得两者都是较大数组+ 1元素的长度（在携带的情况下）。然后在离开函数的路上更正结果。

function normalizeArray(array, digits) {
    var zeroCnt = digits - array.length,
        zeroes = [];
    while (zeroCnt--) {
        zeroes.push(0);
    }
    return zeroes.concat(array);
}

function sumArrays(a1, a2) {
    var maxResultLength = Math.max(a1.length, a2.length) + 1;

    a1 = normalizeArray(a1, maxResultLength);
    a2 = normalizeArray(a2, maxResultLength);
    var result = normalizeArray([], maxResultLength);

    var i = maxResultLength - 1, // working index
        digit = 0,               // working result digit
        c = 0;                   // carry (0 or 1)

    while (i >= 0) {
        digit = a1[i] + a2[i] + c;
        if (digit > 9) {
            c = 1;
            digit -= 10;
        } else {
            c = 0;
        }
        result[i--] = digit;
    }

    /* If there was no carry into the most significant digit, chop off the extra 0 */
    /* If the caller gave us arrays with a bunch of leading zeroes, chop those off */
    /* but don't be an idiot and slice for every digit like sqykly =D */
    for (i = 0 ; i < result.length && result[i] === 0 ; i++) {
        /* result = result.slice(1); don't do that, or anything */
    }
    return result.slice(i);
}

这给出了预期的输出。

Answer 2

我采用了一种不同的方法，可能效率低于你的方法，但我认为它更清晰。一个重要的事情是我反转数组，所以最低位是第一位。评论在代码中。

function sum(a,b){
  // ensure a is the largest of the two arrays
  if (a.length < b.length)
    return sum(b,a);

  // flip the arrays so the least significant digit is first
  a = a.reverse();
  b = b.reverse();

  // c will hold the result (reversed at first)
  var c = [];

  // add each number individually
  var carry = a.reduce(function(carry,digitA,index){
    // digitA is guaranteed to be a number, digit from b is not!
    var sum = digitA + (b[index] || 0) + carry;
    c.push(sum%10);
    return Math.floor(sum/10); // this is carried to the next step of the addition
  },0); // initial carry is 0

  if (carry) c.push(1); // resolve if carry exists after all digits have been added

  return c.reverse();
}

// Usage:
console.log(sum([1,0,8,3],[1,3,5])); // [1, 2, 1, 8]
console.log(sum([8,3],[7,9])); // [1, 6, 2]

PS：您的代码存在许多问题。首先，您不能使用两个嵌套循环：

var a = [0,1];
var b = [2,3];
for (var i=0; i<a.length; i++) {
  for (var j=0; j<b.length; j++) {
    console.log(a[i] + ' ' + b[i]);
  }
}
// will output: 0 2, 0 3, 1 2, 1 3
// you want something along the lines of: 0 2, 1 3

你想要的是一个循环，它同时迭代两个数组。

我尝试有效的解决方案：

function efficientSum(a,b){
  var i = a.length, j = b.length;
  if (i<j) return efficientSum(j,i);
  var q = 0, c = [];
  c.length = i;
  while (i) {
    c[--i] = a[i] + (b[--j] || 0) + q;
    q = c[i] > 9 ? ((c[i]-=10),1) : 0; // comma operator, ugly!
  }
  if (q) c.unshift(1);
  return c;
}

Answer 3

我可能会遗漏一些东西，因为其他答案看起来要复杂得多，但这是我尝试根据问题提供答案：

// Takes an array and generates the sum of the elements
function addArrayNumbers(arr) {
  return arr.reduce(function (p, c) { 
    return String(p) + String(c);
  });
}

// Sums two numbers and returns an array based on that sum
function addCombinedNumbers(a, b) {
  return String(Number(a) + Number(b)).split('');
}

var arrone = [1, 4];
var arrtwo = [4, 7];

var one = addArrayNumbers(arrone);
var two = addArrayNumbers(arrtwo);

var c = addCombinedNumbers(one, two); // [6,1]

Fiddle

Summation \添加两个数组（特定）

3 个答案: