Блог

У меня есть массив, и я пытаюсь получить два самых высоких значения массива, например:

 [1, 2, 3, 4, 3, 1, 0]
 

Мне нужно, чтобы возврат был таким: [ 4, 3]

Как это можно сделать? На данный момент у меня есть функция, которая возвращает мне только максимальное значение массива (в этом примере только [4]). Но мне нужен самый высокий и второй, если он повторяется, как в этом примере (3 появляется два раза), только один из них, чтобы создать массив из двух элементов.

Моя функция на данный момент:

     indexOfMax(arr) {  
    var max = -Infinity;
    var maxIndices = [];
    for (var i = 0; i < arr.length; i  ) {
        if (arr[i] === max) {
          maxIndices.push(i);
        } else if (arr[i] > max) {
            maxIndices = [i];
            max = arr[i];
        }
    }
    return maxIndices;

 },
 

Спасибо за все ответы! Вы, ребята, крутые!

Вы можете сделать это с помощью sort функции и получить два первых значения результатов

 const sortedArray = [1, 2, 3, 4].sort((a, b) => {
  if(a < b) return 1

  return -1
})

sortedArray[0] // 4
sortedArray[1] // 3

// or

const [highest, secondHighest] = sortedArray
 

Вы можете использовать следующий код

 function largestTwo(arr){
    return arr.sort().slice(-2).reverse();
}
 

Вот как это работает.

1. arr.sort() сортирует массив в порядке возрастания
2. .slice(-2) вырезает последние два элемента

   Это два самых больших элемента, и, наконец, самый большой

3. Затем мы используем reverse() для получения желаемого результата массив с наибольшим значением впереди

Вы могли бы взять a Set для получения уникальных значений, отсортировать по возрастанию и взять два последних элемента массива.

 const
    array = [1, 2, 3, 4, 3, 1, 0],
    highest = [...new Set(array)]
        .sort((a, b) => a - b)
        .slice(-2);

console.log(highest); 

Вы могли бы сначала отсортировать массив. Затем используйте set для получения уникальных значений только при необходимости и, наконец, срежьте последние два элемента массива.

 let arr = [1, 2, 3, 4, 3, 1, 0];

arr.sort((a, b) => a-b);

arr = [...new Set(arr)]; //if you only want unique values

let result = arr.slice((arr.length - 2), arr.length);

console.log(result);
 

на самом деле это был один из моих любимых вопросов во время интервью. Чтобы быть более конкретным — найти второе по величине число в массиве.

Сортировка является допустимым решением для небольших массивов (или в службе, которая не выполняет эту операцию часто, или вы вообще не заботитесь о производительности процессора), однако я говорил им, что массив может быть огромным, и поэтому операция сортировки (которая выполняется O(n log n) ) слишком дорогая, и я хочу это сделатьза линейное время.

Это самый простой подход — просто запоминайте наибольшее число и второе по величине число при повторении:

 let _arr = [1, 2, 3, 4, 3, 1, 0];

function findTwoBiggestNumbers(arr) {
  let biggest = -1;
  let secondBiggest = -1;
  for (let i=0; i < arr.length; i  ){
    if (arr[i] > secondBiggest) {
      secondBiggest = arr[i];
      if (secondBiggest > biggest) {
        const temp = biggest;
        biggest = secondBiggest;
        secondBiggest = temp;
      }   
    } 
  }
  
  return [biggest, secondBiggest]
}

console.log(findTwoBiggestNumbers(_arr));

To get indexes, just remember them as well. 

     let _arr = [1, 2, 3, 4, 3, 1, 0];

    function findTwoBiggestNumbersIndexes(arr) {
      let biggest = -1;
      let biggestIndex;
      let secondBiggest = -1;
      let secondBiggestIndex;
      for (let i=0; i < arr.length; i  ){
        if (arr[i] > secondBiggest) {
          secondBiggest = arr[i];
          secondBiggestIndex = i;
          if (secondBiggest > biggest) {
            const temp = biggest;
            const tempIndex = biggestIndex;
            biggest = secondBiggest;
            biggestIndex = secondBiggestIndex;
            secondBiggest = temp;
            secondBiggestIndex = tempIndex;
          }   
        } 
      }
      
      return [biggestIndex, secondBiggestIndex]
    }

    console.log(findTwoBiggestNumbersIndexes(_arr)); 

Обратите внимание, что когда у вас есть индексы, вам не нужно запоминать точные числа, потому что вы всегда можете получить их значения из index (т.Е. arr[biggestIndex] ) — однако это требует некоторой дополнительной работы при инициализации этих индексов.

Примечание — может быть также минималистичный подход к коду, который легко понять, легко написать, и это все еще линейное время. И это то, что вы проходите через массив два раза — сначала вы получаете max, а во второй раз вы получаете secondMax (в основном тот же max, но без max, который вы уже нашли)

 let _arr = [1, 2, 3, 4, 3, 1, 0];

function findBiggestReduce(arr) {
  const max = arr.reduce( (biggest, current) => biggest < current? current : biggest);
  const secondMax = arr.reduce( (biggest, current) => current !== max amp;amp; biggest < current? current : biggest);
  return [max, secondMax];
}

console.log(findBiggestReduce(_arr)); 

Кроме того, при таком подходе индексы легко отслеживать

     let _arr = [1, 2, 3, 4, 3, 1, 0];

    function findBiggestReduce(arr) {
      const maxIndex = arr.reduce( (biggestIndex, current, index) => arr[biggestIndex] < current? index : biggestIndex);
      const secondMaxIndex = arr.reduce( (biggestIndex, current, index) => index !== maxIndex amp;amp; arr[biggestIndex] < current? index : biggestIndex);
      return [maxIndex, secondMaxIndex];
    }

    console.log(findBiggestReduce(_arr));