Algorithm Return largest Numbers in Arrays

๐Ÿšฉ Remember to use Read-Search-Ask if you get stuck. Try to pair program ๐Ÿ‘ฅ and write your own code ๐Ÿ“

๐Ÿ Problem Explanation:

You will get an array that contains sub arrays of numbers and you need to return an array with the largest number from each of the sub arrays.

๐Ÿ’ฌ Hint: 1

You will need to keep track of the array with the answer and the largest number of each sub-array.

try to solve the problem now

๐Ÿ’ฌ Hint: 2

You can work with multidimensional arrays by Array[Index][SubIndex]

try to solve the problem now

๐Ÿ’ฌ Hint: 3

Pay close attention to the timing of the storing of variables when working with loops

try to solve the problem now

Spoiler Alert!

687474703a2f2f7777772e796f75726472756d2e636f6d2f796f75726472756d2f696d616765732f323030372f31302f31302f7265645f7761726e696e675f7369676e5f322e676966.gif

Solutions ahead!

๐Ÿ”ฐ Basic Code Solution:

(Procedural approach)

function largestOfFour(arr) {
  var results = [];
  for (var n = 0; n < arr.length; n++) {
    var largestNumber = 0;
    for (var sb = 0; sb < arr[n].length; sb++) {
      if (arr[n][sb] > largestNumber) {
        largestNumber = arr[n][sb];
      }
    }

    results[n] = largestNumber;
  }

  return results;
}

๐Ÿš€ Run Code

Code Explanation:

  • Create a variable to store the results as an array.
  • Create an outer loop to iterate through the outer array.
  • Create a second variable to hold the largest number. This must be outside an inner loop so it wonโ€™t be reassigned until we find a larger number.
  • Create said inner loop to work with the sub-arrays.
  • Check if the element of the sub array is larger than the currently stored largest number. If so, then update the number in the variable.
  • After the inner loop, save the largest number in the corresponding position inside of the results array.
  • And finally return said array.

Relevant Links

๐ŸŒป Intermediate Code Solution:

(Declarative approach)

function largestOfFour(arr) {
  return arr.map(function(group){
    return group.reduce(function(prev, current) {
      return (current > prev) ? current : prev;
    }, 0);
  });
}

๐Ÿš€ Run Code

Code Explanation:

  • we map all items within the main array to a new array using Array.prototype.map() and return this array as the final result
  • within each inner array, we reduce its contents down to a single value using Array.prototype.reduce()
  • the callback function passed to the reduce method takes the previous value (or 0) and the current value and compares the two values
  • if the current value is higher than the previous value we set it as the new previous value for comparison with the next item within the array or returns it to the map method callback if itโ€™s the last item

Relevant Links

๐Ÿšจ Advanced Code Solution:

(Declarative approach)

function largestOfFour(arr) {
  return arr.map(Function.apply.bind(Math.max, null));
}

๐Ÿš€ Run Code

Code Explanation:

TL;DR: We build a special callback function (using the Function.bind method), that works just like Math.max but also has Function.prototype.apply's ability to take arrays as its arguments ๐Ÿ˜ƒ

  • We start by mapping through the elements inside the main array. Meaning each one of the inner arrays.

  • Now the need a callback function to find the max of each inner array provided by the map.

    So we want to create a function that does the work of Math.max and accepts input as an array (which by it doesnโ€™t by default).

    In other words, it would be really nice and simple if this worked by itself:

    Math.max([9, 43, 20, 6]); // Resulting in 43

    Alas, it doesnโ€™t.

  • To do the work of accepting arguments in the shape of an array, there is this Function.prototype.apply method, but it complicates things a bit by invoking the context function.

    i.e. Math.max.apply(null, [9, 43, 20, 6]); would invoke something like a Max.max method. What weโ€™re looking forโ€ฆ almost.

Here weโ€™re passing null as the context of the Function.prototype.apply method as Math.max doesnโ€™t need any context.

  • Since arr.map expects a callback function, not just an expression, we create a function out of the previous expression by using the Function.bind method.

  • Since, Function.prototype.apply is a static method of the same Function object, we can call Function.prototype.bind on Function.prototype.apply i.e. Function.prototype.apply.bind.

  • Now we pass the context for the Function.prototype.apply.bind call (in this case we want Math.maxso we can gain its functionality).

  • Since the embedded Function.prototype.apply method will also require a context as itโ€™s 1st argument, we need to pass it a bogus context.

    • So, we pass null as the 2nd param to Function.prototype.apply.bind which gives a context to the Math.max method.
    • Since, Math.max is independent of any context, hence, it ignores the bogus context given by Function.prototype.apply method call.
    • Thus, our Function.prototype.apply.bind(Math.max, null) makes a new function accepting the arr.map values i.e. the inner arrays.

Relevant Links

๐Ÿ† Credits:

If you found this page useful, you may say thanks to the contributors by copying and pasting the following line in the main chat:

Thanks @Rafase282 @abhisekp @Hallaathrad @cloudb for your help with Algorithm: Return Largest Numbers in Arrays

๐Ÿ“‹ NOTES FOR CONTRIBUTIONS:

  • โš  DO NOT add solutions that are similar to any existing solutions. If you think it is similar but better, then try to merge (or replace) the existing similar solution.
  • Add an explanation of your solution.
  • Categorize the solution in one of the following categories โ€” Basic, Intermediate and Advanced. ๐Ÿšฅ
  • Please add your username only if you have added any relevant main contents. (โš  DO NOT remove any existing usernames)

See ๐Ÿ‘‰ Wiki Challenge Solution Template for reference.