Пояснение к двум циклам для Javascript

Question

Может ли кто-нибудь объяснить, как это решение работает для упражнения, которое заставляет вас находить самый частый элемент в массиве, возвращая количество раз его счет? Я новичок в JS и просто нуждаюсь в некоторой помощи с пониманием логики!

function mostFrequentItemCount(array) { 
     var freq = 0; 
     var mostFreq = 0; 

     for (var i = 0; i <= array.length; i++) { 
      for (var j = i; j < array.length; j++) { 
       if (array[i] === array[j]) { 
        freq++; 
       } 
       if (freq >= mostFreq) { 
        mostFreq = freq; 
       } 
       if (array.length === 0) { 
        return 0; 
       } 
      } 

      freq = 0; 
     } 

     return mostFreq; 
    } 

    mostFrequentItemCount([4, 3, 4, 4, 5, 5, 5, 5, 4, 3]) 

Answer 1

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

ИМО не должно быть более оптимизирован способ сделать это, потому что элементы многократно подсчитаны в ситуациях, когда это не имеет значения (не использовать для подсчета 4 снова опуская первый, когда мы встречаем второй)

Он также не справляется с теми же fréquence элементами ..

Answer 2

если вы действительно заинтересованы в реальном решении JS:

var hashMap = {}; // in js any object can be also used as a map 
 
    var array = [4, 3, 4, 4, 5, 5, 5, 5, 4, 3]; 
 
    
 
    for (var i = 0; i < array.length; i++) // there are better ways of doing this with js es6 
 
    { 
 
     if (!hashMap[array[i]]) hashMap[array[i]] = 0; // if this is the first time of this value in the map - initialize it with zero 
 
    
 
     hashMap[array[i]]++; // increase the count of each value 
 
    } 
 
    
 
    for (var value in hashMap) 
 
    { 
 
     console.log(value + ' ' + hashMap[value]); // print each value with the correct amount of instances 
 
    }

Answer 3

Вложенные циклы следует избегать точки зрения производительности, и я уверен, что есть лучшее решение, но все же я хотел бы дать вам понимание того, как работает при условии, сниппет:

function mostFrequentItemCount(array) { 
    // initialize variables 
    var freq = 0; // variable that will hold frequency count of the currently checked element 
    var mostFreq = 0; // variable that will hold the highest frequency count 

    // iterate over all elements of the array 
    for (var i = 0; i <= array.length; i++) { 
     // from the current index i, iterate over the array again, 
     // so all "following" elements will be checked 
     for (var j = i; j < array.length; j++) { 
      if (array[i] === array[j]) { 
       // if one of the following elements equals 
       // the current element of the first for loop, 
       // increase frequency count 
       freq++; 
      } 
      // if the frequency of this element is higher then the 
      // currently highest frequency, set the mostFreq variable 
      // to the frequency of the current element 
      if (freq >= mostFreq) { 
       mostFreq = freq; 
      } 
      // if the array has no elements, return 0 
      if (array.length === 0) { 
       return 0; 
      } 
     } 

     // reset freq to 0 so we can start fresh with the next element 
     freq = 0; 
    } 
    // return the most frequent: 
    return mostFreq; 
} 

Пожалуйста, обратите внимание, что это работает только для массива, содержащего только числа (и будет возвращать частоту, а не наиболее частое число, как указано в комментариях). Адаптации необходимо будет сделать, чтобы вернуть фактический элемент, когда строки или объекты должны быть сопоставлены.

Answer 4

И еще одно решение:

function mostFrequentItemCount(array) { 
    return array.reduce(function(p,c){ 
     if(p[c] === undefined) 
      p[c] = 0; 
     p[c]++; 
     if(p.mostFrequent == undefined || p[c]>p[p.mostFrequent]) 
      p.mostFrequent = c; 
     return p; 
    },{}).mostFrequent; 
} 

Answer 5

Эта функция не находит наиболее частый элемент, только количество раз наиболее частый элемент обнаружился.

Он работает, подсчитывая количество раз, когда каждый элемент появляется.

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

Стоит отметить, что этот код можно оптимизировать с помощью вспомогательного массива, который подсчитывает, сколько раз каждый элемент показывался. Кроме того, как указано в комментариях, условия цикла неверны, поскольку array.length возвращает первую пустую позицию в массиве.