# Help needed on Return Largest numbers in Arrays

So i am new to JavaScript and currently stuck at solving Basic Algorithm problem, where an array consisting of largest numbers must be returned from an Array which consists of sub-Arrays.

My code is this

`````` var largestArray = [0,0,0,0];
for(var i = 0; i < arr.length; i++){
for(var j = 0; j < arr[i].length; j++){
if(arr[i][j] > largestArray[i] ){
largestArray[i] = arr[i][j];
}
}
}
return largestArray;
``````

But out of the 4 conditions only three were returning correct. I don’t know where I had gone wrong. Someone please kindly help.

If you look at the last test (the failing one) you have a peculiar difference from the previous one: negative numbers!

``````[-72, -3, -17, -10]
``````

Now, looking at your function you have declared this variable:

``````var largestArray = [0,0,0,0];
``````

As you can see, you are working under the assumption that `0` is the lowest a number it can get, but looking at the input example above the “largest” in the set is `-3` and not `0`.

My suggestion is re-think the whole `largestArray` functionality since it works under the assumption that 0 is the lowest possible number Hope it helps 1 Like

Thanks. I solved it by changing [0,0,0,0] to [-3,-3,-3,-3]

Hi @dreamo123, you may have passed this specific test, but you haven’t solved the underlying issue.

what if this time the “largest” number in the array is `-100`?
Your function will provide a wrong output again.

Are you able to make your function run without assuming a specific minimum or maximum? This will be a good exercise.

p.s. it’s not that far off from what you have, you don’t really have to rewrite a lot @Marmiz is right, when you write a function you have to think about any possible input, of any size; they may be positive numbers, negative numbers, positive and negative mixed up etc. I would suggest you to use a built-in function, Math.max, with the spread operator. They are both explained in the curriculum. Good luck!

I believe there are other methods to solve this problem. Using Reduce and Math.max, where this problem doesn’t occur. Thank you. I will take what you said into account.

To be honest, those are possible way to solve it, but not only that.
There’s a simple, yet effective change you can make to your code that will make it work regardless of input, without changing any methods or adding any new one.
(no reduce, math.max/min…)

Hint: you don’t really need to compare the subarray values to the “lowest possible number allowed in Javascript”, but just among each other of the set. Something like arr[i] > arr[j] ?

Honestly, I don’t know, I’m just a beginner. If you know the answer then please elaborate.

Working with what you have:

``````
function largestOfFour(arr) {
// we will return this
// we don't assume neither the quantity nor the bottom cap
var largestArray = [];
for(var i = 0; i < arr.length; i++){
// we loop inside each sub-array
// we start by saying that the "largest" for now is the first element in the array
// as we yet have to see the others
ver largestN = arr[i];

// we loop the sub-array starting from the 2nd element due to the previous assumption
for(var j = 1; j < arr[i].length; j++){

// we simply check which one is the largest
if(arr[i][j] > largestN ){
// and update the varaible
largestN = arr[i][j]
}
}
// at the end of the sub-array loop
// push into the result what we determined being the "largest"
largestArray[i] = largestN
}

// and finally return the result array
return largestArray;
}

``````

et-voilla 1 Like

Understood. But if you have,

``````if(arr[i][j] > largestN){
``````

instead of writing ` largestN = arr[i][j]`

can’t you simply write

`largestArray[i] = arr[i] [j];`

in the sub-array loop itself?

Yes… and no Of course you could update the “result array” with each iteration where the condition is satisfied, but you also need to keep updating the variable (`largestN`) so it stays consistent

``````if(arr[i][j] > largestN ){
largestN = arr[i][j]
largestArray[i] = largestN
}

``````

But this way you update two variables instead of one. For such a simple case it won’t really matter, but what if we have a billion long array and by chance is sorted from smallest to largest? we will update two varaibles a billion times, when we could have updated “only” one 1 Like

Understood. The code we write must be very optimal and efficient.