Question

这是问题所在：查找具有给定总和的数组中子数组的数量。

该程序输入2个参数编号数组和总和。

例如： subArrayCnt（[1,2,3,2,1,8，-3]，5）

，输出应为根据给定总和的子数组数。（上面的示例{2,3}，{3,2}，{8，-3}（子数组的数量）的输出应为3）

我试图这样做，但是存在一个问题，那就是它不能满足“答案对于任何给定的输入均应有效”的要求。

这是我的代码：

function subArrayCnt(arr, sum) {
for (var i = 0; i < arr.length; i++) {
        var str = [];
        var csum= 0;
        var output = 0;

for (var j = i; j < arr.length; j++) {        
        csum+= arr[j];
        str.push(arr[j]);
        if (csum== sum) {       
              return(str[i]);     
             }
         }
     }
}

console.log(subArrayCnt([1,2,3,2,1,8,-3],5));

该程序提供许多子数组，但未满足“答案对于任何给定输入均应有效”的要求，应在哪里纠正？请提出任何建议。

Answer 1

根据您的示例，我假设两个连续元素的总和应为有条件的总和。

function subArrayCnt(arr, sum) {
    let outputArr = [];
    for(var i=0; i<arr.length; i++){
        if(arr[i]+arr[i+1]==sum){
            let obj = {l:arr[i],r:arr[i+1]};
            outputArr.push(obj);
        }
    };
    return outputArr.length;
};

Answer 2

尝试这种方法：

function subArrayCnt(arr, sum){
  var count = 0;
  for(var i = 0; i < arr.length-1; i++){
    for(var n = i+1; n < arr.length; n++){
      if(arr[i] + arr[n] == sum){
        count++;
      }
    }
  }
  return count;
}

console.log(subArrayCnt([1,2,3,2,1,8,-3],5));
// 3

Answer 3

您可以使用嵌套循环来实现。这将获取所有可能的相邻和，然后可以将该和与给定的和进行比较，并增加count。

function func(arr,sum){
  if(!Array.isArray(arr)) return 0;
  let count = 0;
  let cur = 0;
  for(let i = 0;i<arr.length-1;i++){
    cur = arr[i];
    for(let j = i+1;j<arr.length;j++){
      cur += arr[j];
      if(cur === sum){
        count++;
        break;
      }
      if(cur > sum) break;
    }
  }
  return count+'';
}

console.log(func([1,2,3,2,1,8,-3],5)) //3
console.log(func([1,2,3,4],10)) //1

Answer 4

其他答案似乎忽略了一个事实，即可以从数组的任意数量的元素中获得总和。递归是最好的方法。

function subArrayCnt(arr, sum){
  return subArrayRecurse(arr, sum, 0, [], 0)
}

function subArrayRecurse(arr, sum, currentSum, curArray, i){
  var count = 0;
  //check the current index
  var newSum = currentSum + arr[i];
  var newSubArray = curArray.concat([arr[i]]);
  if(newSum == sum) {
    console.log('found another: ' + newSubArray);
    count++;
  }
  if(i + 1 < arr.length) {
    //try including the current in further sums
    count += subArrayRecurse(arr, sum, newSum, newSubArray, i + 1);
    //try not including the current in further sums
    count += subArrayRecurse(arr, sum, currentSum, curArray, i + 1);
  }
  return count;
}

console.log(subArrayCnt([1,2,3,2,1,8,-3],5));
// 8

上面示例中的8个组合是：

1,2,3,2,-3
1,2,2
1,3,1
2,3
2,3,2,1,-3
2,2,1
3,2
8,-3

Answer 5

尝试一下：

<script>
  function subArray(arr,sum)
{
    var subArray=new Array();
    count=0;
    for(var i=0;i<arr.length;i++)
    {
    	if(arr[i]+arr[i+1]==sum)
        {
        	 subArray[count]=[arr[i],arr[i+1]]
           count++;       
        }
    }
    return subArray;
}

console.log(subArray([1,2,3,2,1,8,-3],5));
</script>

Answer 6

尝试一下：

我写了这个函数。它满足“答案应对任何给定输入均有效”的要求。


function getSubArrayCount(arr, sum){

   if(!Array.isArray(arr)) return 0;

   var len = arr.length;
   var count = 0;

   for(var i = 0; i < len; i++){
      var n = 0;
     
      for(var j = i; j < len; j++){    
         n += arr[j];
      
         if(n === sum) {
           count++;
           break;
         }
      }
   }

   return count;
}

getSubArrayCount([1,2,3,2,1,8,-3],5);

在具有给定总和的数组中找到子数组的数量

6 个答案: