Három módon találhatja meg a tömb legnagyobb számát a JavaScript használatával

Ebben a cikkben elmagyarázom, hogyan lehet megoldani a Free Code Camp „A legnagyobb számok visszaküldése tömbökben kihívását. Ez magában foglalja az egyes tömbök legnagyobb számmal rendelkező tömbjének visszaküldését.

Három megközelítést tárgyalok:

  1. egy FOR hurokkal
  2. a reduc () módszer alkalmazásával
  3. a Math.max () használatával

Az algoritmus kihívás leírása

Visszaadjon egy tömböt, amely az egyes megadott tömbök legnagyobb számából áll. Az egyszerűség kedvéért a megadott tömb pontosan 4 résztömböt tartalmaz.

Ne feledje, hogy egy tömbön keresztül iterálhat egy egyszerű for ciklussal, és minden tagot elérhet az arr [i] tömb szintaxissal.

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

Biztosított tesztesetek

largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]) should return an array. largestOfFour([[13, 27, 18, 26], [4, 5, 1, 3], [32, 35, 37, 39], [1000, 1001, 857, 1]]) should return [27,5,39,1001]. largestOfFour([[4, 9, 1, 3], [13, 35, 18, 26], [32, 35, 97, 39], [1000000, 1001, 857, 1]]) should return [9, 35, 97, 1000000].

1. megközelítés: Adja meg a tömb legnagyobb számát egy For Loop segítségével

Íme a megoldás, beágyazott megjegyzésekkel, amelyek segítenek megérteni:

 function largestOfFour(arr) { // Step 1. Create an array that will host the result of the 4 sub-arrays var largestNumber = [0,0,0,0]; // Step 2. Create the first FOR loop that will iterate through the arrays for(var arrayIndex = 0; arrayIndex < arr.length; arrayIndex++) { /* The starting point, index 0, corresponds to the first array */ // Step 3. Create the second FOR loop that will iterate through the sub-arrays for(var subArrayIndex = 0; subArrayIndex  largestNumber[arrayIndex]) { largestNumber[arrayIndex] = arr[arrayIndex][subArrayIndex]; /* FOR loop cycles arrayIndex => i subArrayIndex => j Iteration in the first array For each iteration: arr[i][j] largestNumber[i] if arr[i][j] > largestNumber[i]? then largestNumber[i] = arr[i][j] First iteration: arr[0][0] => 4 largestNumber[0] => 0 4 > 0? => TRUE then largestNumber[0] = 4 Second iteration: arr[0][1] => 5 largestNumber[0] => 4 5 > 4? => TRUE then largestNumber[0] = 5 Third iteration: arr[0][2] => 1 largestNumber[0] => 5 1 > 5? => FALSE then largestNumber[0] = 5 Fourth iteration: arr[0][3] => 3 largestNumber[0] => 5 3 > 5? => FALSE then largestNumber[0] = 5 Fifth iteration: arr[0][4] => FALSE largestNumber[0] => 5 largestNumber = [5,0,0,0] Exit the first array and continue on the second one Iteration in the second array For each iteration: arr[i][j] largestNumber[i] if arr[i][j] > largestNumber[i]? then largestNumber[i] = arr[i][j] First iteration: arr[1][0] => 13 largestNumber[1] => 0 13 > 0? => TRUE then largestNumber[1] = 13 Second iteration: arr[1][1] => 27 largestNumber[1] => 13 27 > 13? => TRUE then largestNumber[1] = 27 Third iteration: arr[1][2] => 18 largestNumber[1] => 27 18 > 27? => FALSE then largestNumber[1] = 27 Fourth iteration: arr[1][3] => 26 largestNumber[1] => 27 26 > 27? => FALSE then largestNumber[1] = 27 Fifth iteration: arr[1][4] => FALSE largestNumber[1] => 27 largestNumber = [5,27,0,0] Exit the first array and continue on the third one Iteration in the third array For each iteration: arr[i][j] largestNumber[i] if arr[i][j] > largestNumber[i]? then largestNumber[i] = arr[i][j] First iteration: arr[2][0] => 32 largestNumber[2] => 0 32 > 0? => TRUE then largestNumber[2] = 32 Second iteration: arr[2][1] => 35 largestNumber[2] => 32 35 > 32? => TRUE then largestNumber[2] = 35 Third iteration: arr[2][2] => 37 largestNumber[2] => 35 37 > 35? => TRUE then largestNumber[2] = 37 Fourth iteration: arr[2][3] => 39 largestNumber[2] => 37 39 > 37? => TRUE then largestNumber[2] = 39 Fifth iteration: arr[2][4] => FALSE largestNumber[2] => 39 largestNumber = [5,27,39,0] Exit the first array and continue on the fourth one Iteration in the fourth array For each iteration: arr[i][j] largestNumber[i] if arr[i][j] > largestNumber[i]? then largestNumber[i] = arr[i][j] First iteration: arr[3][0] => 1000 largestNumber[3] => 0 1000 > 0? => TRUE then largestNumber[3] = 1000 Second iteration: arr[3][1] => 1001 largestNumber[3] => 1000 1001 > 1000? => TRUE then largestNumber[3] = 1001 Third iteration: arr[3][2] => 857 largestNumber[3] => 1001 857 > 1001? => FALSE then largestNumber[3] = 1001 Fourth iteration: arr[3][3] => 1 largestNumber[3] => 1001 1 > 1001? => FALSE then largestNumber[3] = 1001 Fifth iteration: arr[3][4] => FALSE largestNumber[3] => 1001 largestNumber = [5,27,39,1001] Exit the FOR loop */ } } } // Step 4. Return the largest numbers of each sub-arrays return largestNumber; // largestNumber = [5,27,39,1001]; } largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

És itt van megjegyzéseim nélkül:

 function largestOfFour(arr) { var largestNumber = [0,0,0,0]; for(var arrayIndex = 0; arrayIndex < arr.length; arrayIndex++) { for(var subArrayIndex = 0; subArrayIndex  largestNumber[arrayIndex]) { largestNumber[arrayIndex] = arr[arrayIndex][subArrayIndex]; } } } return largestNumber; } largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

2. megközelítés: A tömb legnagyobb számainak visszaadása beépített funkciókkal - térképpel () és kicsinyítéssel ()

Ehhez a megoldáshoz két módszert fog használni: az Array.prototype.map () és az Array.prototype.reduce () metódust.

  • A map () metódus új tömböt hoz létre annak az eredménynek a meghívásával, amely a tömb minden elemén meghív egy megadott függvényt. A térkép használata egy sorrendben egy tömb minden eleméhez egyszer meghív egy megadott visszahívási funkciót, és az eredményekből új tömböt állít össze.
  • A reduc () módszer függvényt alkalmaz egy akkumulátorra és a tömb minden értékére, hogy egyetlen értékre redukálja azt.

A háromkomponensű üzemeltetője az egyetlen JavaScript üzemeltető, úgy három operandus. Ezt az operátort az if utasítás parancsikonjaként használják.

(currentLargestNumber > previousLargestNumber) ? currentLargestNumber : previousLargestNumber;

Ez a következőképpen is olvasható:

if (currentLargestNumber > previousLargestNumber == true) { return currentLargestNumber; } else { return previousLargestNumber; }

Íme a megoldás, beágyazott megjegyzésekkel:

 function largestOfFour(mainArray) { // Step 1. Map over the main arrays return mainArray.map(function (subArray){ // Step 3. Return the largest numbers of each sub-arrays => returns [5,27,39,1001] // Step 2. Grab the largest numbers for each sub-arrays with reduce() method return subArray.reduce(function (previousLargestNumber, currentLargestNumber) { return (currentLargestNumber > previousLargestNumber) ? currentLargestNumber : previousLargestNumber; /* Map process and Reduce method cycles currentLargestNumber => cLN previousLargestNumber => pLN Iteration in the first array For each iteration: cLN pLN if (cLN > pLN) ? then cLN else pLN First iteration: 4 0 4 > 0? => TRUE 4 / Second iteration: 5 4 5 > 4? => TRUE 5 / Third iteration: 1 5 1 > 5? => FALSE / 5 Fourth iteration: 3 5 3 > 5? => FALSE / 5 Fifth iteration: / 5 returns 5 Exit the first array and continue on the second one Iteration in the second array For each iteration: cLN pLN if (cLN > pLN) ? then cLN else pLN First iteration: 13 0 13 > 0? => TRUE 13 / Second iteration: 27 13 27 > 13? => TRUE 27 / Third iteration: 18 27 18 > 27? => FALSE / 27 Fourth iteration: 26 27 26 > 27? => FALSE / 27 Fifth iteration: / 27 returns 27 Exit the first array and continue on the third one Iteration in the third array For each iteration: cLN pLN if (cLN > pLN) ? then cLN else pLN First iteration: 32 0 32 > 0? => TRUE 32 / Second iteration: 35 32 35 > 32? => TRUE 35 / Third iteration: 37 35 37 > 35? => TRUE 37 / Fourth iteration: 39 37 39 > 37? => TRUE 39 / Fifth iteration: / 39 returns 39 Exit the first array and continue on the fourth one Iteration in the fourth array For each iteration: cLN pLN if (cLN > pLN) ? then cLN else pLN First iteration: 1000 0 1000 > 0? => TRUE 1000 / Second iteration: 1001 1000 1001 > 1000? => TRUE 1001 / Third iteration: 857 1001 857 > 1001 => FALSE / 1001 Fourth iteration: 1 1001 1 > 1001? => FALSE / 1001 Fifth iteration: / 1001 returns 1001 Exit the first array and continue on the fourth one */ }, 0); // 0 serves as the context for the first pLN in each sub array }); } largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

És itt van megjegyzések nélkül:

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

3. megközelítés: Visszaadja a tömb legnagyobb számát beépített funkciókkal - térképpel () és alkalmazza ()

Ehhez a megoldáshoz két módszert fog használni: az Array.prototype.map () metódust és a Function.prototype.apply () metódust.

  • Az Apply () metódus függvényt hív meg egy adott értékkel és argumentumokkal, amelyek tömbként (vagy tömbszerű objektumként) vannak megadva.

Egy argumentumtömböt átadhat egy függvénynek az Apply () metódus használatával, és a függvény végrehajtja a tömb elemeit.

Az ilyen függvényeket variadikus függvényeknek nevezik , és fix számú helyett akárhány argumentumot elfogadhatnak.

A Math.max () függvény a legnagyobbat adja nulla vagy annál több számból, és tetszőleges számú argumentumot átadhatunk .

console.log(Math.max(4,5,1,3)); // logs 5

De nem adhat át egy tömb számot az ilyen módszerhez:

var num = [4,5,1,3]; console.log(Math.max(num)); // logs NaN

Itt bizonyul az alkalmazás () metódus hasznosnak:

var num = [4,5,1,3]; console.log(Math.max.apply(null, num)); // logs 5

Ne feledje, hogy az első alkalmazandó argumentum () beállítja a ' this ' értékét , amelyet nem használunk ebben a módszerben, így a null értéket adja meg .

Most, hogy van egy módja a tömb legnagyobb számának visszaküldésére, az egyes résztömböket a map () metódussal áttekintheti, és az összes legnagyobb számot visszaadhatja.

Íme a megoldás, beágyazott megjegyzésekkel:

 function largestOfFour(mainArray) { // Step 1. Map over the main arrays return mainArray.map(function(subArray) { // Step 3. Return the largest numbers of each sub-arrays => returns [5,27,39,1001] // Step 2. Return the largest numbers for each sub-arrays with Math.max() method return Math.max.apply(null, subArray); }); } largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

És megjegyzések nélkül:

 function largestOfFour(mainArray) { return mainArray.map(function(subArray) { return Math.max.apply(null, subArray); }); } largestOfFour([[4, 5, 1, 3], [13, 27, 18, 26], [32, 35, 37, 39], [1000, 1001, 857, 1]]);

Remélem, hasznosnak találta ezt. Ez része a Free Code Camp Algorithm Challenges című „Hogyan lehet megoldani az FCC algoritmusokat” című cikksorozatomnak, ahol számos megoldást javaslok, és lépésről lépésre elmagyarázom, mi történik a motorháztető alatt.

Három módon ismételhetünk egy karakterláncot a JavaScript-ben

Ebben a cikkben elmagyarázom, hogyan lehet megoldani a freeCodeCamp „Karakterlánc megismétlése sztring megismétlése” kihívását. Ez magában foglalja…

Kétféle módon erősítheti meg a String végét a JavaScript-ben

Ebben a cikkben elmagyarázom, hogyan lehet megoldani a freeCodeCamp „Vége megerősítése” kihívását.

Három módszer a karakterlánc megfordítására a JavaScript-ben

Ez a cikk a Free Code Camp algoritmus-szkriptjein alapul, „Fordítsa meg a karakterláncot”

Három módszer a szám ténylegesítésére a JavaScript-ben

Ez a cikk a Free Code Camp algoritmus-szkriptjein alapszik: „Számok ténylegesítése”

Kétféle módja annak, hogy ellenőrizze a palindromokat a JavaScript-ben

Ez a cikk a Free Code Camp Basic Algorithm Scripting „Palindromes ellenőrzése” alapján készült.

Három módszer a leghosszabb szó megkeresésére egy stringben a JavaScript-ben

Ez a cikk a Free Code Camp algoritmus-szkriptjein alapul: „Keresse meg a leghosszabb szót egy karakterláncban”.

Három módszer a mondat elnevezésére a JavaScript-ben

Ez a cikk a „Free Code Camp Basic Algorithm Scripting“ Title Case a Sentence ”címen alapul.

Ha van saját megoldása vagy javaslata, ossza meg őket alább a megjegyzésekben.

Vagy akkor utánam a Medium , Twitter, GitHub és LinkedIn , jobb kattintás után a zöld szívében alábbi ;-)

# StayCurious, # KeepOnHacking és # MakeItHappen!

További források

  • for - MDN
  • tömb.hossz - MDN
  • map () módszer - MDN
  • redukciós () módszer - MDN
  • Ternary Operator - MDN
  • Apply () módszer - MDN
  • Math.max () - MDN
  • ez - MDN