Javascript 在由子数组组成的数组中搜索最大数，然后返回一个新数组

我正在进行一项编码挑战，获取一个由子数组组成的给定数组，搜索每个子数组中的最大数，最后返回一个仅由最大数组成的新数组。我的想法是从每个子数组中创建变量，编写一个for循环，比较数组中的每个值，然后将最大值推送到一个新数组。在编写我的第一个for循环之后，我测试了我的代码，发现我得到了一个意想不到的结果，整个第一个子数组都被推到了我的新数组中。在我写下接下来的三个循环之前，我正在寻找错误。非常感谢。编辑：这是为JavaScript初学者编写的，建议在解决方案中使用比较运算符

function largestOfFour(arr) {
      var one = arr[0];
      var two = arr[1];
      var three = arr[2];
      var four = arr[3];
      var newArr = [];

      for (var i = 0; i < one.length; i++){
        var oneLrg = 0;
        if (one[i] > oneLrg){
          oneLrg = one[i];
          }
        newArr.push(oneLrg);
      }  

  return arr;
}

console.log(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])); //This test case returns [4,5,1,3] instead of just [5]

函数最大四（arr）{
var-one=arr[0]；
var 2=arr[1]；
var三=arr[2]；
var-four=arr[3]；
var newArr=[]；
对于（变量i=0；i<1.length；i++）{
var-oneLrg=0；
if（一[i]>oneLrg）{
oneLrg=一[i]；
}
新的推送（oneLrg）；
}  
返回arr；
}
log（最大的四个（[4,5,1,3]，[13,27,18,26]，[32,35,37,39]，[10001001857,1]）//此测试用例返回[4,5,1,3]，而不是仅返回[5]

使用：

var newArr=[]；
对于（var i=0；i:

var newArr=[]；
对于（var i=0；i:

var newArr=[]；
对于（var i=0；i

var newArr=arr.map（函数（子数组）{
返回Math.max.apply（数学，子数组）；
});

添加ECMAScript 5

var newArr=arr.map（Function.apply.bind（Math.max，Math））；

或者添加ECMAScript 6和

var newArr=arr.map（子数组=>Math.max（…子数组））；
此函数将获取两个数字并返回其最大值：

var greatest = function(a,b){ return Math.max(a,b); };

此函数将获取一个数字数组，并依次对每个数字应用
maxist
函数（使用数组方法），以获得数组中的最大值：

var findMaximum = function( arr ){ return arr.reduce( greatest, Number.NEGATIVE_INFINITY ); };

只需使用所有数组值调用
Math.max（）
即可简化
findMaximum
函数（无需使用
maxist
函数）；如下所示：

var findMaximum = function( arr ){ return Math.max.apply( Math, arr ); };

此函数将获取一个数组（由数组组成），并对其每个元素调用
findMaximum
，然后返回一个包含这些最大值的新数组（使用数组上的方法）：

这里的问题是，您在每次循环迭代中都会覆盖
oneLrg
，并将其推到同一个循环中，因此您会将每个值与0进行比较，然后，随着
one[i]
越大，保存它

试试这个：

var oneLrg = 0;
for (var i = 0; i < one.length; i++){
    if (one[i] > oneLrg){
        oneLrg = one[i];
    }
}
newArr.push(oneLrg);  

var oneLrg=0；
对于（变量i=0；i<1.length；i++）{
if（一[i]>oneLrg）{
oneLrg=一[i]；
}
}
新的推送（oneLrg）；
毫无疑问，@Austin Hansen和我正在利用相同的学习环境来应对这一挑战：免费代码夏令营

我自己刚刚完成了这个挑战（FCC称之为“篝火”），我想我应该提供与@Oriol的优秀“>”解决方案高度吻合的解决方案

function largestOfFour(arr) {
      var one = arr[0];
      var two = arr[1];
      var three = arr[2];
      var four = arr[3];
      var newArr = [];

      for (var i = 0; i < one.length; i++){
        var oneLrg = 0;
        if (one[i] > oneLrg){
          oneLrg = one[i];
          }
        newArr.push(oneLrg);
      }  

  return arr;
}

console.log(largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]])); //This test case returns [4,5,1,3] instead of just [5]

我特别提到了代码块，因为对于我们这些新手（在FCC或其他地方），没有这样的代码块会让我们感到很不舒服：）

函数最大四（arr）{
var finalArray=[]；
对于（i=0；imax）{//将子数组中的每个连续元素与当前存储为max的元素进行比较
max=arr[i][j]；//如果“>”比较为真，则max将被更新
}  
}
finalArray.push（max）；//确保这是在j for循环之外。将其放入j for循环内会返回一个非常长（错误）的数组。请尝试。
}
控制台日志（finalArray）；
返回最终射线；
}
最大的四个（[[4,5,1,3]，[13,27,18,26]，[32,35,37,39]，[10001001857,1]，”）；


FCC认识到以下解决方案不利用Array.push（）

函数最大四（arr）{
var结果=[]；
对于（变量i=0；imax）{
max=arr[i][j]；
}
}
结果[i]=max；
}
返回结果；
}
最大的四个（[[4,5,1,3]，[13,27,18,26]，[32,35,37,39]，[10001001857,1]，”）；
这篇文章在大约3个月内没有任何新的更新，但我想我会发布这个问题的解决方案，因为它看起来与目前发布的大多数其他解决方案有点不同。我想可能有人会觉得它有帮助

我使用了很多内置的方法函数（.forEach、.sort、.push、.shift）。如果你不确定它们是如何工作的，快速的谷歌搜索会很好地解释它们。这是一个很好的资源

function largestOfFour(arr) {
  var newArr = [];                              //set up new empty array
  arr.forEach(function(subArr){                 //iterate through array with .each function
    subArr.sort(function(a, b){                 //use .sort to place largest number of each subarray into index[0]
      return a < b;     
    });
    newArr.push(subArr.shift());                //use .push method to .shift the index[0] number to newArr
  });
  return newArr;                            
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

函数最大四（arr）{
var newArr=[]；//设置新的空数组
arr.forEach（函数（subar）{//使用.each函数遍历数组
sort（函数（a，b）{//使用.sort将每个子数组的最大数量放入索引[0]
返回a
您可以查看以下内容：

function largestOfFour(arr) {
  var newArr=[];
  largestnum=0;
  for(i=0;i<arr.length;i++)
    {
      for(j=0;j<4;j++)
        {
      if(arr[i][j]>largestnum)
        largestnum=arr[i][j];
        }
       newArr.push(largestnum);
      largestnum=0;
    }
return newArr;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

函数最大四（arr）{
var newArr=[]；
最大数=0；
for（i=0；i@orion-您给我的答案不起作用。如果推送在If语句中，则推送的是不应该在数组中的数字。因此，第一个推送[4,5]将不起作用。因此，我将推送移出for语句，并在之后将lgstNumber重置为0，这样就不会出现错误
function largestOfFour(arr) {
  var newArr = [];                              //set up new empty array
  arr.forEach(function(subArr){                 //iterate through array with .each function
    subArr.sort(function(a, b){                 //use .sort to place largest number of each subarray into index[0]
      return a < b;     
    });
    newArr.push(subArr.shift());                //use .push method to .shift the index[0] number to newArr
  });
  return newArr;                            
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

function largestOfFour(arr) {
  var newArr=[];
  largestnum=0;
  for(i=0;i<arr.length;i++)
    {
      for(j=0;j<4;j++)
        {
      if(arr[i][j]>largestnum)
        largestnum=arr[i][j];
        }
       newArr.push(largestnum);
      largestnum=0;
    }
return newArr;
}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

function largestOfFour(arr) {
  // You can do this!
  var newArr = [];
  var lgstNumber = -  Infinity;
  for(var i = 0; i < arr.length; i++){
    for(var j = 0; j < arr[i].length; j++){
      if(lgstNumber < arr[i][j]){
        lgstNumber = arr[i][j];
      }
    }
    newArr.push(lgstNumber);
    lgstNumber = 0;
  }
  return newArr;
}

function largestOfFour(arr) {
    return arr.map(function(subArray) {
        return subArray.reduce(function(firstArray, secondArray) {
            return firstArray > secondArray ? firstArray : secondArray;
        });
    });
}
largestOfFour([[13, 27, 18, 26],[4, 5, 1, 3],[32, 35, 37, 39],[1000, 1001, 857, 1]
]);

function largestOfFour(arr) {


  for(var x=0;x<arr.length;x++)
    {
       for(var y=0;y<arr[x].length;y++)
        {
           arr[x]=arr[x].sort(function(a,b)
                   {
         return b-a;
       });

     }
}
  var array=[];
  for(var a=0;a<arr.length;a++)
{
  for(var b=0;b<arr[a].length;b++)
    {
      if(b==0)
        {
          array[a]=arr[a][b];
        }
    }


}
  return array;

}

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);