Ba cách bạn có thể tìm thấy số lớn nhất trong một mảng bằng JavaScript


Trong bài viết này, tôi sẽ giải thích cách giải bài toán “Trả về số lớn nhất trong mảng” của Free Code Campthách đấu. Điều này liên quan đến việc trả về một mảng có số lớn nhất từ ​​mỗi mảng phụ.

Có ba cách tiếp cận tôi sẽ đề cập:

  1. với vòng lặp FOR
  2. sử dụng phương thức reduce()
  3. sử dụng Math.max()

Thử thách thuật toán Mô tả

Trả về một mảng bao gồm số lớn nhất từ ​​mỗi mảng con được cung cấp. Để đơn giản, mảng được cung cấp sẽ chứa chính xác 4 mảng con.

Hãy nhớ rằng, bạn có thể lặp qua một mảng bằng vòng lặp for đơn giản và truy cập từng phần tử bằng cú pháp mảng arr[i].

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

Các trường hợp thử nghiệm được cung cấp

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].

Phương pháp #1: Trả về các số lớn nhất trong một mảng bằng vòng lặp For

Đây là giải pháp của tôi, với các nhận xét được nhúng để giúp bạn hiểu nó:


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 < arr[arrayIndex].length; subArrayIndex++) {
    /* The starting point, index 0, corresponds to the first sub-array */
       
       if(arr[arrayIndex][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]]);

Và đây là không có ý kiến ​​​​của tôi:


function largestOfFour(arr) {
   var largestNumber = [0,0,0,0];
   for(var arrayIndex = 0; arrayIndex < arr.length; arrayIndex++) {
    for(var subArrayIndex = 0; subArrayIndex < arr[arrayIndex].length; subArrayIndex++) {
       if(arr[arrayIndex][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]]);

Cách tiếp cận #2: Trả về các số lớn nhất trong một mảng với các hàm tích hợp sẵn — với map() và reduce()

Đối với giải pháp này, bạn sẽ sử dụng hai phương thức: phương thức Array.prototype.map() và phương thức Array.prototype.reduce().

  • Các bản đồ() phương thức tạo một mảng mới với kết quả của việc gọi một hàm được cung cấp trên mọi phần tử trong mảng này. Việc sử dụng bản đồ sẽ gọi hàm gọi lại được cung cấp một lần cho từng phần tử trong một mảng, theo thứ tự và tạo một mảng mới từ kết quả.
  • Các giảm() phương thức áp dụng một hàm đối với bộ tích lũy và mỗi giá trị của mảng để giảm nó thành một giá trị duy nhất.
Đọc thêm  Cách tạo Biểu đồ thời gian thực bằng JavaScript và Pizer

Các toán tử bậc ba là toán tử JavaScript duy nhất có ba toán hạng. Toán tử này được sử dụng làm lối tắt cho câu lệnh if.

(currentLargestNumber > previousLargestNumber) ? currentLargestNumber : previousLargestNumber;

Điều này cũng có thể được đọc là:

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

Đây là giải pháp của tôi, với các nhận xét được nhúng:


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]]);

Và đây là không có bình luận:


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]]);

Cách tiếp cận #3: Trả về các số lớn nhất trong một mảng với các hàm tích hợp sẵn — với map() và apply()

Đối với giải pháp này, bạn sẽ sử dụng hai phương thức: phương thức Array.prototype.map() và phương thức Function.prototype.apply().

  • Các áp dụng() phương thức gọi một hàm với giá trị this đã cho và các đối số được cung cấp dưới dạng một mảng (hoặc một đối tượng giống như mảng).
Đọc thêm  Giá trị giả trong JavaScript

Bạn có thể truyền một mảng đối số cho một hàm bằng cách sử dụng lệnh áp dụng() phương thức và hàm sẽ thực thi các mục trong mảng.

Các chức năng như vậy được gọi là chức năng biến đổivà họ có thể chấp nhận bất kỳ số lượng đối số nào thay vì một đối số cố định.

Các Math.max() hàm trả về số lớn nhất trong số 0 hoặc nhiều số hơn và chúng ta có thể chuyển bất kỳ số lượng đối số nào.

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

Nhưng bạn không thể truyền một dãy số cho phương thức như thế này​:

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

Đây là nơi áp dụng() phương pháp hóa ra là hữu ích:

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

Lưu ý rằng đối số đầu tiên để áp dụng() đặt giá trị của ‘cái này‘, không được sử dụng trong phương pháp này, vì vậy bạn vượt qua vô giá trị.

Bây giờ bạn đã có một phương thức để trả về số lớn nhất trong một mảng, bạn có thể lặp qua từng mảng con bằng lệnh bản đồ() phương thức và trả về tất cả các số lớn nhất.

Đây là giải pháp của tôi, với các nhận xét được nhúng:


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]]);

Và không có bình luận:


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]]);

Tôi hy vọng bạn tìm thấy điều này hữu ích. Đây là một phần trong loạt bài viết “Cách giải quyết các thuật toán FCC” của tôi về Các thách thức về thuật toán của Free Code Camp, trong đó tôi đề xuất một số giải pháp và giải thích từng bước những gì xảy ra bên trong.

Đọc thêm  Mẹo và thủ thuật gỡ lỗi cho người mới bắt đầu JavaScript

Ba cách để lặp lại một chuỗi trong JavaScript
Trong bài viết này, tôi sẽ giải thích cách giải quyết thử thách “Lặp lại một chuỗi lặp lại một chuỗi” của freeCodeCamp. Điều này liên quan đến…

Hai cách để xác nhận kết thúc của Chuỗi trong JavaScript
Trong bài viết này, tôi sẽ giải thích cách giải quyết thử thách “Xác nhận kết thúc” của freeCodeCamp.

Ba cách để đảo ngược một chuỗi trong JavaScript
Bài viết này dựa trên Free Code Camp Basic Algorithm Scripting “Reverse a String”

Ba cách để thừa số hóa một số trong JavaScript
Bài viết này dựa trên Free Code Camp Basic Algorithm Scripting “Factorialize a Number”

Hai cách để kiểm tra Palindromes trong JavaScript
Bài viết này dựa trên Free Code Camp Basic Algorithm Scripting “Check for Palindromes”.

Ba cách để tìm từ dài nhất trong chuỗi trong JavaScript
Bài viết này dựa trên Kịch bản thuật toán cơ bản của Free Code Camp “Tìm từ dài nhất trong một chuỗi”.

Ba cách đặt tiêu đề cho một câu trong JavaScript
Bài viết này dựa trên Kịch bản thuật toán cơ bản của Free Code Camp “Tiêu đề trường hợp một câu”.

Nếu bạn có giải pháp của riêng mình hoặc bất kỳ đề xuất nào, hãy chia sẻ chúng bên dưới phần bình luận.

Hoặc bạn có thể theo dõi tôi trên Trung bình, TwitterGithubLinkedInngay sau khi bạn nhấp vào trái tim màu xanh bên dưới 😉

#‎StayCurious, #‎KeepOnHacking & #‎MakeItHappen!

Tài nguyên bổ sung





Zik.vn – Biên dịch & Biên soạn Lại

spot_img

Create a website from scratch

Just drag and drop elements in a page to get started with Newspaper Theme.

Buy Now ⟶

Bài viết liên quang

DMCA.com Protection Status