The issue resides in the fact that you are constantly overwriting the variable oneLrg within each loop cycle, causing it to be pushed into the same loop. This results in each value being compared to 0 and eventually being saved as one[i] is greater.

To address this problem, consider implementing the following solution:

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

It's no secret that myself and @Austin Hansen are both utilizing the same educational platform to tackle this challenge: Free Code Camp.

After recently completing this challenge (referred to as "Bonfires" by FCC), I wanted to share my solution that builds upon the foundation set by @Oriol's fantastic approach.

I've made a point to emphasize the importance of code blocks in my explanation, especially for newcomers like us who can struggle for hours without them : )

function largestOfFour(arr) {
 var finalArray = [];     
 for(i = 0; i < arr.length; i++) { // looping through each array
   var max = -Infinity;
   for(j = 0; j < arr[i].length; j++) { // iterating within each sub-array 
      if(arr[i][j] > max) { // comparing each element in sub-array with current max value
        max = arr[i][j]; // updating max if condition is met
      }  
    }
    finalArray.push(max); // placing this outside inner loop to avoid incorrect results
  }
  console.log(finalArray);
  return finalArray;
}

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

https://jsbin.com/puweci/edit?js,console

Free Code Camp also acknowledges an alternative solution that doesn't utilize Array.push().

function largestOfFour(arr) {
  var results = [];
  for (var i = 0; i < arr.length; i++) {
     var max = -Infinity;
     for (var j = 0; j < arr[i].length; j++) {
        if (arr[i][j] > max) {
        max = arr[i][j];
        }
     }

    results[i] = max;
  }

  return results;
}

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

This code snippet defines a function that finds the maximum of two numbers:

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

It then uses this function to find the maximum value in an array of numbers by applying the greatest function to each number iteratively with the

.reduce( callbackFunction, initialValue )

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

The code shows another way to achieve the same result without using the greatest function by directly calling Math.max() with all the array values:

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

Finally, it introduces a function that takes an array (or arrays) and returns a new array containing the maximums of each inner array (using the .map( callbackFunction ) method):

var largestOfFour = function( arr ){ return arr.map( findMaximum ); };

It's been a while since this post was updated, but I wanted to share my unique solution to the problem at hand. Hopefully, someone will find it beneficial!

In my approach, I made use of several built-in methods such as .forEach, .sort, .push, and .shift. If you're unfamiliar with these functions, a quick search on https://developer.mozilla.org can provide more information.

function getLargestNumbers(arr) {
  var result = [];                              //create a new empty array
  arr.forEach(function(subArr){                 //iterate through the input array
    subArr.sort(function(a, b){                  //sort each subarray in descending order
      return a < b;     
    });
    result.push(subArr.shift());                 //add the largest number from each subarray to the result array
  });
  return result;                            
}

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

Check out this interesting code snippet:

function findLargestNumbers(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;
}

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

@orion - I had some issues with the solution you provided. The push inside the if statement was causing numbers to be added to the array that shouldn't have been there. Specifically, it was pushing [4,5] when it wasn't supposed to. To fix this, I decided to move the push outside of the for loop and also reset the lgstNumber to 0 after each iteration so it wouldn't affect the next sub-array. This adjustment worked perfectly for me...

function largestOfFour(arr) {
  // Let's get this done!
  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 findLargestNumber(arr) {
    return arr.map(function(subArray) {
        return subArray.reduce(function(firstNum, secondNum) {
            return firstNum > secondNum ? firstNum : secondNum;
        });
    });
}
findLargestNumber([[13, 27, 18, 26],[4, 5, 1, 3],[32, 35, 37, 39],[1000, 1001, 857, 1]
]);

It's highly efficient.

function findLargestNumbers(matrix) {

  for (var i = 0; i < matrix.length; i++) {
    for (var j = 0; j < matrix[i].length; j++) {
      matrix[i] = matrix[i].sort(function(a, b) {
        return b - a;
      });
    }
  }

  var largestNumbers = [];
  for (var k = 0; k < matrix.length; k++){
    for (var m = 0; m < matrix[k].length; m++) {
      if (m === 0) {
        largestNumbers[k] = matrix[k][m];
      }
    }
  }

  return largestNumbers;

}

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