在 JavaScript 中返回数组中的最大数字

你的逻辑很不对。要指出错误，请参阅下文。
迭代 1
    ->gr = 0
    ->27> 0？
    ->gr = 27
    ->推GR(27(

迭代 2
    ->gr = 27
    -> 5> 27？
    ->推GR(27(

迭代 3
    ->gr = 27
    ->39> 27？
    ->gr = 39
    -推GR(39(

迭代 4
    ->gr = 1001
    ->1001> 39？
    ->gr = 1001
    ->推GR(1001(

尝试使用数组参数创建一个函数，该参数在该参数中获取最大数字，而不是声明新的 for 循环。

Array.max = function( array ){
    return Math.max.apply( Math, array );
};

你可以尝试这样的事情：

var data = [[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]];
var maxArr = data.map(function(item){
  return Math.max.apply(null,item)
});
document.write(maxArr);

代码说明：

function largestOfFour(arr) {
  // You can do this!
  var largest=[];
  var gr=0;
  for(var i=0;i<arr.length;i++){
    for(var j=0;j<=arr[i].length;j++){
      if(arr[i][j]>gr){
        gr=arr[i][j];
      }
    }
    largest.push(gr);
   }
 return largest;
}
var r = largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]);
document.write(r)

您编写了有效的文件，但问题出在var gr=0;.这是在for loop之外初始化的，所以它将第一个数组的最大数量与第二个数组进行比较，并且由于27>5是假的，它只分配 27

function largestOfFour(arr) {
  // You can do this!
  var largest = [];
  for (var i = 0; i < arr.length; i++) {
    var gr = 0;
    for (var j = 0; j <= arr[i].length; j++) {
      if (arr[i][j] > gr) {
        gr = arr[i][j];
      }
    }
    largest.push(gr);
  }
  return largest;
}
var r = largestOfFour([
  [13, 27, 18, 26],
  [4, 5, 1, 3],
  [32, 35, 37, 39],
  [1000, 1001, 857, 1]
]);
document.write(r)

您需要为每次迭代重置此值 gr，因此，应在循环中对其进行初始化。

你的函数是正确的，但你需要把var gr=0; 在第一个 for 循环中：

 function largestOfFour(arr) {
  // You can do this!
  var largest=[];
   for(var i=0;i<arr.length;i++){
    var gr=0;
    for(var j=0;j<=arr[i].length;j++){
      if(arr[i][j]>gr){
        gr=arr[i][j];
      }
    }
    largest.push(gr);
   }
 return largest;
}
largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

function largestOfFour(arr) {
  var results = [];
  for (var n in arr) {
      var largestNumber = 0;
      for (var num in arr[n]) {
          if (arr[n][num] > largestNumber) {
              largestNumber = arr[n][num];
         }
     }
    results[n] = largestNumber;
    }
  return results;
    }
largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]);

即使如此，它看起来像一个测试问题，没有一个明确的问题。我会继续帮助你。

var arr = [[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]];
var res = [];
arr.forEach(function(val, ix){
var sub = val;
var large = 0;
for(var i=0;i<sub.length;i++){
  if(sub[i] > large){
  large = sub[i];
 }
}
 res.push(large);
});

小提琴：https://jsfiddle.net/jeremyrajan/hted9eg5/

如果你看一下代码，我正在使用forEach(https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/forEach(来遍历数组并收集子数组。然后通过元素运行 for 循环以找到最大数量。

唯一的区别是，我用 for Each 在我的情况下使事情变得更漂亮。

希望对您有所帮助！

这是一个更干净的方法，但如果你关心快速，它会相对较慢。

function get_array_of_largest(rank2Array){
  var newArray = [];
  for (var i = 0; i < rank2Array.length; i ++){
    newArray.push(rank2Array[i].slice().sort(function(a, b){return a < b;})[0]);
  }
  return newArray;
}

.slice()复制数组的一部分。由于没有给出任何论据，它复制了整个事情。 .sort()根据函数对数组进行排序。给定我使用的排序函数，它按降序对数组进行排序(因此元素 0 最大(。

您的元素不起作用的原因是您在推送元素后没有将gr重置为 0。

function largestOfFour(arr) {
  var newArr=[];
  for(i=0;i<arr.length;i++){
     var num=Math.max.apply(null,arr[i]);    
     newArr.push(num);
  }
  return newArr;
}

， 3]( 等效于 Math.max(1， 2， 3(，但您可以在任何大小的编程构造数组上使用 getMaxOfArray((。

function getMaxOfArray(numArray) {
  return Math.max.apply(null, numArray);
}

function largestOfFour(arr) {
    return arr.map(x => x.sort((a, b) => b - a)[0]);
}

这是一个像我这样的初级水平可能会更容易理解的答案。

function largestOfFour(arr) {
// We need a way new array that would store the largest number as required.
  let newArr = []
  // We need a way to traverse through the subArrays
  for (let i=0;i<arr.length; i++)
  {
    // We need to find max in each sub array and add to newArr
    newArr.push(Math.max(...arr[i]))
  }
  console.log(newArr) // Check if its the answer we expect
  return newArr;
}
largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

在这种情况下，可以使用映射和归简作为解决方案。

1. 数组已映射

2. 使用reduce功能在映射的数组列表中找到最大的数字

    function lgArry (arr) {
       return arr.map(function(sub){
           return sub.reduce(function(a,b){
               return a > b ? a : b;
           })
       })
   }
   

您的输入纯粹作为矩阵。

现在，您可以将矩阵的行分散到一个采用 varargs 的函数中。这些函数将参数捕获到数组中，并将它们发送到化简器中。

const
  avg = (...arr) => arr.reduce((a, b) => a + b) / arr.length,
  avgPerRow = (...matrix) => matrix.map(row => avg(...row)),
  minPerRow = (...matrix) => matrix.map(row => Math.min(...row)),
  maxPerRow = (...matrix) => matrix.map(row => Math.max(...row)); 
let matrix = [
    [13, 27, 18, 26],
    [4, 5, 1, 3],
    [32, 35, 37, 39],
    [1000, 1001, 857, 1]
  ],
  averageOfFour = avgPerRow(...matrix),
  smallestOfFour = minPerRow(...matrix),
  largestOfFour = maxPerRow(...matrix);
console.log(...smallestOfFour); // [ 13 , 1    , 32    ,    1    ]
console.log(...averageOfFour);  // [ 21 , 3.25 , 35.75 ,  714.75 ]
console.log(...largestOfFour);  // [ 27 , 5    , 39    , 1001    ]