অ্যারেতে সর্বাধিক উপস্থিতি সহ উপাদানটি পান

Question 1

আমি জাভাস্ক্রিপ্ট অ্যারেতে কোন উপাদানটির সর্বাধিক উপস্থিতি ( মোড ) রয়েছে তা নির্ধারণের একটি দুর্দান্ত উপায় সন্ধান করছি ।

উদাহরণস্বরূপ, ইন

['pear', 'apple', 'orange', 'apple']

'apple'উপাদান অধিকাংশ ঘন অন্যতম।

Question 2

এটি কেবল মোড। এখানে একটি ~~দ্রুত, অ-অপ্টিমাইজড~~ সমাধান। এটি ও (এন) হওয়া উচিত।

function mode(array)
{
    if(array.length == 0)
        return null;
    var modeMap = {};
    var maxEl = array[0], maxCount = 1;
    for(var i = 0; i < array.length; i++)
    {
        var el = array[i];
        if(modeMap[el] == null)
            modeMap[el] = 1;
        else
            modeMap[el]++;  
        if(modeMap[el] > maxCount)
        {
            maxEl = el;
            maxCount = modeMap[el];
        }
    }
    return maxEl;
}

Question 3

২০০৯ সাল থেকে জাভাস্ক্রিপ্টে কিছু উন্নয়ন হয়েছে - আমি ভেবেছিলাম যে আমি অন্য একটি বিকল্প যুক্ত করব। আমি দক্ষতার সাথে কম উদ্বিগ্ন না হওয়া পর্যন্ত এটি আসলেই সমস্যা তাই আমার "মার্জিত" কোডের সংজ্ঞা (যেমন ওপি দ্বারা নির্ধারিত) পাঠযোগ্যতার পক্ষে - যা অবশ্যই বিষয়গত ...

function mode(arr){
    return arr.sort((a,b) =>
          arr.filter(v => v===a).length
        - arr.filter(v => v===b).length
    ).pop();
}

mode(['pear', 'apple', 'orange', 'apple']); // apple

এই বিশেষ উদাহরণে, সেটের দুটি বা আরও বেশি উপাদানের সমান উপস্থিতি থাকা উচিত তবে অ্যারেতে সর্বশেষ প্রদর্শিত হওয়াটি ফিরে আসবে। এটি আপনার মূল অ্যারেটি সংশোধন করবে - এটি উল্লেখ করার মতো মূল্যও রয়েছে - যদি আপনি Array.sliceআগে কল দিয়ে চান তবে এটি প্রতিরোধ করা যেতে পারে ।

সম্পাদনা: কিছু ES6 চর্বিযুক্ত তীরগুলির সাথে উদাহরণটি আপডেট করেছে কারণ 2015 হয়েছে এবং আমি মনে করি তারা দেখতে সুন্দর দেখাচ্ছে ... আপনি যদি পিছনের সামঞ্জস্য নিয়ে উদ্বিগ্ন হন তবে আপনি এটি পুনর্বিবেচনার ইতিহাসে খুঁজে পেতে পারেন ।

Question 4

অনুযায়ী George Jempty'sঅনুরোধ বন্ধন জন্য অ্যালগরিদম একাউন্ট আছে, আমি একটি পরিমার্জিত সংস্করণ উত্থাপন করা Matthew Flaschen'sঅ্যালগরিদম।

function modeString(array) {
  if (array.length == 0) return null;

  var modeMap = {},
    maxEl = array[0],
    maxCount = 1;

  for (var i = 0; i < array.length; i++) {
    var el = array[i];

    if (modeMap[el] == null) modeMap[el] = 1;
    else modeMap[el]++;

    if (modeMap[el] > maxCount) {
      maxEl = el;
      maxCount = modeMap[el];
    } else if (modeMap[el] == maxCount) {
      maxEl += "&" + el;
      maxCount = modeMap[el];
    }
  }
  return maxEl;
}

এটি এখন একটি &চিহ্ন দ্বারা সীমিত মোড উপাদান (গুলি) দিয়ে একটি স্ট্রিং প্রদান করবে । ফলাফল প্রাপ্ত হলে এটি সেই &উপাদানটিতে বিভক্ত হয়ে যায় এবং আপনার মোড (গুলি) থাকে।

আর একটি বিকল্প হ'ল মোড এলিমেন্ট (গুলি) এর মতো একটি অ্যারের ফিরে আসবে:

function modeArray(array) {
  if (array.length == 0) return null;
  var modeMap = {},
    maxCount = 1,
    modes = [];

  for (var i = 0; i < array.length; i++) {
    var el = array[i];

    if (modeMap[el] == null) modeMap[el] = 1;
    else modeMap[el]++;

    if (modeMap[el] > maxCount) {
      modes = [el];
      maxCount = modeMap[el];
    } else if (modeMap[el] == maxCount) {
      modes.push(el);
      maxCount = modeMap[el];
    }
  }
  return modes;
}

উপরের উদাহরণে আপনি তখন মোডের একটি অ্যারে হিসাবে ফাংশনটির ফলাফলটি পরিচালনা করতে সক্ষম হবেন।

Question 5

এমিসারির ES6 + উত্তরের ভিত্তিতে , আপনি Array.prototype.reduceআপনার তুলনা করতে ব্যবহার করতে পারেন (বাছাই করার বিপরীতে, পপিং এবং সম্ভাব্যভাবে আপনার অ্যারে রূপান্তর করার বিপরীতে), যা আমার মনে হয় বেশ চটচটে দেখাচ্ছে।

const mode = (myArray) =>
  myArray.reduce(
    (a,b,i,arr)=>
     (arr.filter(v=>v===a).length>=arr.filter(v=>v===b).length?a:b),
    null)

আমি নালকে ডিফল্ট করছি, যা আপনাকে সর্বদা সত্যবাদী প্রতিক্রিয়া দেয় না যদি নাল যদি আপনি ফিল্টার করছেন এমন সম্ভাব্য বিকল্প হয়, তবে এটি thatচ্ছিক দ্বিতীয় যুক্তি হতে পারে

নেতিবাচকতা, অন্যান্য বিভিন্ন সমাধানের মতো এটি হ'ল এটি 'ড্র স্টেটস' পরিচালনা করে না, তবে এটি আরও কিছুটা জড়িত ফাংশন হ্রাস করে এখনও অর্জন করা যেতে পারে।

Question 6

a=['pear', 'apple', 'orange', 'apple'];
b={};
max='', maxi=0;
for(let k of a) {
  if(b[k]) b[k]++; else b[k]=1;
  if(maxi < b[k]) { max=k; maxi=b[k] }
}

Question 7

যেহেতু আমি এই ফাংশনটি ইন্টারভিউয়ারদের কুইজ হিসাবে ব্যবহার করছি, আমি আমার সমাধান পোস্ট করছি:

const highest = arr => (arr || []).reduce( ( acc, el ) => {
  acc.k[el] = acc.k[el] ? acc.k[el] + 1 : 1
  acc.max = acc.max ? acc.max < acc.k[el] ? el : acc.max : el
  return acc  
}, { k:{} }).max

const test = [0,1,2,3,4,2,3,1,0,3,2,2,2,3,3,2]
console.log(highest(test))

Question 8

এখানে একটি ঘোষণামূলক পদ্ধতির চেষ্টা করে। এই সমাধানটি প্রতিটি শব্দের সংঘটনগুলি টেলিট করার জন্য একটি অবজেক্ট তৈরি করে। তারপরে প্রতিটি শব্দের মোট উপস্থিতিগুলিকে বস্তুর সন্ধানের সর্বোচ্চ মানের সাথে তুলনা করে একটি অ্যারেতে অবজেক্টটি ফিল্টার করে।

const arr = ['hello', 'world', 'hello', 'again'];

const tally = (acc, x) => { 

  if (! acc[x]) { 
    acc[x] = 1;
    return acc;
  } 

  acc[x] += 1;
  return acc;
};

const totals = arr.reduce(tally, {});

const keys = Object.keys(totals);

const values = keys.map(x => totals[x]);

const results = keys.filter(x => totals[x] === Math.max(...values));

Question 9

অন্য সমাধানের সময়:

function getMaxOccurrence(arr) {
    var o = {}, maxCount = 0, maxValue, m;
    for (var i=0, iLen=arr.length; i<iLen; i++) {
        m = arr[i];

        if (!o.hasOwnProperty(m)) {
            o[m] = 0;
        }
        ++o[m];

        if (o[m] > maxCount) {
            maxCount = o[m];
            maxValue = m;
        }
    }
    return maxValue;
}

যদি সংকোচনের বিষয়টি গুরুত্বপূর্ণ হয় (তবে তা নয়):

function getMaxOccurrence(a) {
    var o = {}, mC = 0, mV, m;
    for (var i=0, iL=a.length; i<iL; i++) {
        m = a[i];
        o.hasOwnProperty(m)? ++o[m] : o[m] = 1;
        if (o[m] > mC) mC = o[m], mV = m;
    }
    return mV;
}

যদি অ-অস্তিত্বশীল সদস্যদের এড়িয়ে চলতে হয় (উদাহরণস্বরূপ স্পার্স অ্যারে), একটি অতিরিক্ত হসঅনপ্রনাল্টি পরীক্ষা প্রয়োজন:

function getMaxOccurrence(a) {
    var o = {}, mC = 0, mV, m;
    for (var i=0, iL=a.length; i<iL; i++) {
        if (a.hasOwnProperty(i)) {
            m = a[i];
            o.hasOwnProperty(m)? ++o[m] : o[m] = 1;
            if (o[m] > mC) mC = o[m], mV = m;
        }
    }
    return mV;
}

getMaxOccurrence([,,,,,1,1]); // 1

এখানে অন্যান্য উত্তর অপরিশোধিত ফিরে আসবে ।

Question 10

আর একটি জেএস সমাধান থেকে: https://www.w3resource.com/javascript-exercises/javascript-array-exercise-8.php

এটিও চেষ্টা করে দেখতে পারেন:

let arr =['pear', 'apple', 'orange', 'apple'];

function findMostFrequent(arr) {
  let mf = 1;
  let m = 0;
  let item;

  for (let i = 0; i < arr.length; i++) {
    for (let j = i; j < arr.length; j++) {
      if (arr[i] == arr[j]) {
        m++;
        if (m > mf) {
          mf = m;
          item = arr[i];
        }
      }
    }
    m = 0;
  }

  return item;
}

findMostFrequent(arr); // apple

Question 11

ও (এন) জটিলতার সাথে এটি করার আরেকটি ES6 উপায় এখানে

const result = Object.entries(
    ['pear', 'apple', 'orange', 'apple'].reduce((previous, current) => {
        if (previous[current] === undefined) previous[current] = 1;
        else previous[current]++;
        return previous;
    }, {})).reduce((previous, current) => (current[1] >= previous[1] ? current : previous))[0];
console.log("Max value : " + result);

Question 12

function mode(arr){
  return arr.reduce(function(counts,key){
    var curCount = (counts[key+''] || 0) + 1;
    counts[key+''] = curCount;
    if (curCount > counts.max) { counts.max = curCount; counts.mode = key; }
    return counts;
  }, {max:0, mode: null}).mode
}

Question 13

এই সমস্যার সমাধানটি এখানে রয়েছে তবে সংখ্যার সাথে এবং নতুন 'সেট' বৈশিষ্ট্যটি ব্যবহার করা হচ্ছে। এটি খুব পারফরম্যান্ট নয় তবে আমি অবশ্যই এটি লিখতে অনেক মজা পেয়েছি এবং এটি একাধিক সর্বাধিক মানকে সমর্থন করে।

const mode = (arr) => [...new Set(arr)]
  .map((value) => [value, arr.filter((v) => v === value).length])
  .sort((a,b) => a[1]-b[1])
  .reverse()
  .filter((value, i, a) => a.indexOf(value) === i)
  .filter((v, i, a) => v[1] === a[0][1])
  .map((v) => v[0])

mode([1,2,3,3]) // [3]
mode([1,1,1,1,2,2,2,2,3,3,3]) // [1,2]

যাইহোক উত্পাদনের জন্য এটি ব্যবহার করবেন না এটি কেবলমাত্র ES6 এবং অ্যারে ফাংশনগুলির সাহায্যে আপনি কীভাবে এটি সমাধান করতে পারবেন তার একটি উদাহরণ।

Question 14

আমার সমাধানটি এখানে:

function frequent(number){
    var count = 0;
    var sortedNumber = number.sort();
    var start = number[0], item;
    for(var i = 0 ;  i < sortedNumber.length; i++){
      if(start === sortedNumber[i] || sortedNumber[i] === sortedNumber[i+1]){
         item = sortedNumber[i]
      }
    }
    return item
  
}

   console.log( frequent(['pear', 'apple', 'orange', 'apple']))

স্নিপেট প্রসারিত করুন

Question 15

সত্যই সহজভাবে পড়ার সুবিধার্থে, বজায় রাখতে সক্ষম কোডটি আমি এটিকে শেয়ার করি:

function getMaxOcurrences(arr = []) {
  let item = arr[0];
  let ocurrencesMap = {};

  for (let i in arr) {
    const current = arr[i];

    if (ocurrencesMap[current]) ocurrencesMap[current]++;
    else ocurrencesMap[current] = 1;

    if (ocurrencesMap[item] < ocurrencesMap[current]) item = current;
  }

  return { 
    item: item, 
    ocurrences: ocurrencesMap[item]
  };
}

আশা করি এটি কাউকে সাহায্য করবে;)!

Question 16

এই দ্রবণটি টাইয়ের ক্ষেত্রে অ্যারের একাধিক উপাদানকে ফিরিয়ে দিতে পারে। উদাহরণস্বরূপ, একটি অ্যারে

arr = [ 3, 4, 3, 6, 4, ];

দুটি মোডের মান রয়েছে: 3এবং 6।

সমাধান এখানে।

function find_mode(arr) {
    var max = 0;
    var maxarr = [];
    var counter = [];
    var maxarr = [];

    arr.forEach(function(){
       counter.push(0);
    });

    for(var i = 0;i<arr.length;i++){
       for(var j=0;j<arr.length;j++){
            if(arr[i]==arr[j])counter[i]++; 
       }
    } 


    max=this.arrayMax(counter);   
  
    for(var i = 0;i<arr.length;i++){
         if(counter[i]==max)maxarr.push(arr[i]);
    }

    var unique = maxarr.filter( this.onlyUnique );
    return unique;

  };


function arrayMax(arr) {
      var len = arr.length, max = -Infinity;
      while (len--) {
              if (arr[len] > max) {
              max = arr[len];
              }
      }
  return max;
 };

 function onlyUnique(value, index, self) {
       return self.indexOf(value) === index;
 }

Question 17

var mode = 0;
var c = 0;
var num = new Array();
var value = 0;
var greatest = 0;
var ct = 0;

দ্রষ্টব্য: সিটি হ'ল অ্যারের দৈর্ঘ্য।

function getMode()
{
    for (var i = 0; i < ct; i++)
    {
        value = num[i];
        if (i != ct)
        {
            while (value == num[i + 1])
            {
                c = c + 1;
                i = i + 1;
            }
        }
        if (c > greatest)
        {
            greatest = c;
            mode = value;
        }
        c = 0;
    }
}

Question 18

const mode = (str) => {
  return str
    .split(' ')
    .reduce((data, key) => {
      let counter = data.map[key] + 1 || 1
      data.map[key] = counter

      if (counter > data.counter) {
        data.counter = counter
        data.mode = key
      }

      return data
    }, {
      counter: 0,
      mode: null,
      map: {}
    })
    .mode
}

console.log(mode('the t-rex is the greatest of them all'))

Question 19

function mode(array){
    var set = Array.from(new Set(array));
    var counts = set.map(a=>array.filter(b=>b==a).length);
    var indices = counts.map((a,b)=>Math.max(...counts)===a?b:0).filter(b=>b!==0);
    var mode = indices.map(a=>set[a]);
    return mode;
}

Question 20

এটিও চেষ্টা করে দেখুন, এটি অ্যাকাউন্ট ব্রাউজার সংস্করণে নেবে না।

function mode(arr){
var a = [],b = 0,occurrence;
    for(var i = 0; i < arr.length;i++){
    if(a[arr[i]] != undefined){
        a[arr[i]]++;
    }else{
        a[arr[i]] = 1;
    }
    }
    for(var key in a){
    if(a[key] > b){
        b = a[key];
        occurrence = key;
    }
    }
return occurrence;
}
alert(mode(['segunda','terça','terca','segunda','terça','segunda']));

দয়া করে মনে রাখবেন যে 2 বা ততোধিক এন্ট্রি একই সংখ্যক বার প্রদর্শিত হলে এই ফাংশনটি অ্যারেতে সর্বশেষতম উপস্থিতি দেয়!

Question 21

// O(n)
var arr = [1, 2, 3, 2, 3, 3, 5, 6];
var duplicates = {};
max = '';
maxi = 0;
arr.forEach((el) => {
    duplicates[el] = duplicates[el] + 1 || 1;
  if (maxi < duplicates[el]) {
    max = el;
    maxi = duplicates[el];
  }
});
console.log(max);

Question 22

এখানে অন্তর্নির্মিত মানচিত্রগুলি ব্যবহার করে আধুনিক সংস্করণটি দেওয়া হয়েছে (সুতরাং এটি এমন জিনিসগুলির চেয়ে আরও বেশি কাজ করে যা অনন্য স্ট্রিতে রূপান্তরিত হতে পারে):

'use strict';

const histogram = iterable => {
    const result = new Map();

    for (const x of iterable) {
        result.set(x, (result.get(x) || 0) + 1);
    }

    return result;
};

const mostCommon = iterable => {
    let maxCount = 0;
    let maxKey;

    for (const [key, count] of histogram(iterable)) {
        if (count > maxCount) {
            maxCount = count;
            maxKey = key;
        }
    }

    return maxKey;
};

console.log(mostCommon(['pear', 'apple', 'orange', 'apple']));

স্নিপেট প্রসারিত করুন

Question 23

আমার ধারণা আপনার দুটি পন্থা আছে। যার দুটিই সুবিধা রয়েছে।

তারপরে কাউন্ট বা লুপটি বাছাই করুন এবং আপনার জন্য গণনা করতে হ্যাশ টেবিল ব্যবহার করুন।

হ্যাশ টেবিলটি দুর্দান্ত কারণ আপনি একবার প্রসেসিংয়ের কাজ শেষ করলে আপনার সমস্ত স্বতন্ত্র উপাদানও থাকে। আপনার যদি মিলিয়ন আইটেম থাকে তবে ডুপ্লিকেশন রেট কম হলে হ্যাশ টেবিলটি প্রচুর মেমরি ব্যবহার করে শেষ হতে পারে। বাছাই করুন, তারপরে গণনা পদ্ধতির আরও অনেকগুলি নিয়ন্ত্রণযোগ্য মেমরির পদচিহ্ন থাকবে।

Question 24

var array = [1, 3, 6, 6, 6, 6, 7, 7, 12, 12, 17],
    c = {}, // counters
    s = []; // sortable array

for (var i=0; i<array.length; i++) {
    c[array[i]] = c[array[i]] || 0; // initialize
    c[array[i]]++;
} // count occurrences

for (var key in c) {
    s.push([key, c[key]])
} // build sortable array from counters

s.sort(function(a, b) {return b[1]-a[1];});

var firstMode = s[0][0];
console.log(firstMode);

Question 25

আপনি এটি চেষ্টা করতে পারেন:

 // using splice()   
 // get the element with the highest occurence in an array
    function mc(a) {
      var us = [], l;
      // find all the unique elements in the array
      a.forEach(function (v) {
        if (us.indexOf(v) === -1) {
          us.push(v);
        }
      });
      l = us.length;
      while (true) {
        for (var i = 0; i < l; i ++) {
          if (a.indexOf(us[i]) === -1) {
            continue;
          } else if (a.indexOf(us[i]) != -1 && a.length > 1) {
            // just delete it once at a time
            a.splice(a.indexOf(us[i]), 1);
          } else {
            // default to last one
            return a[0];
          }
        }
      }
    }

// using string.match method
function su(a) {
    var s = a.join(),
            uelms = [],
            r = {},
            l,
            i,
            m;

    a.forEach(function (v) {
        if (uelms.indexOf(v) === -1) {
            uelms.push(v);
        }
    });

    l = uelms.length;

    // use match to calculate occurance times
    for (i = 0; i < l; i ++) {
        r[uelms[i]] = s.match(new RegExp(uelms[i], 'g')).length;
    }

    m = uelms[0];
    for (var p in r) {
        if (r[p] > r[m]) {
            m = p;
        } else {
            continue;
        }
    }

    return m;
}

Question 26

আপনি ও (এন) জটিলতায় এটি সমাধান করতে পারেন

var arr = [1,3,54,56,6,6,1,6];
var obj = {};

/* first convert the array in to object with unique elements and number of times each element is repeated */
for(var i = 0; i < arr.length; i++)
{
   var x = arr[i];
   if(!obj[x])
     obj[x] = 1;
   else 
     obj[x]++;
}

console.log(obj);//just for reference

/* now traverse the object to get the element */
var index = 0;
var max = 0;

for(var obIndex in obj)
{
  if(obj[obIndex] > max)
  {
    max = obj[obIndex];
    index = obIndex;
  }
}
console.log(index+" got maximum time repeated, with "+ max +" times" );

উপরের কোডটি চালানোর জন্য ক্রোম কনসোলে কেবল অনুলিপি করুন এবং আটকান।

Question 27

এই ফাংশনটি প্রতিটি ধরণের তথ্যের জন্য জেনেরিক ফাংশন। এটি উপাদানগুলির উপস্থিতি গণনা করে এবং তারপরে সর্বাধিক ঘটে যাওয়া উপাদানগুলির সাথে অ্যারে প্রদান করে।

function mode () {
  var arr = [].slice.call(arguments);
  if ((args.length == 1) && (typeof args[0] === "object")) {
    args = args[0].mode();
  }

  var obj = {};
  for(var i = 0; i < arr.length; i++) {
    if(obj[arr[i]] === undefined) obj[arr[i]] = 1;
    else obj[arr[i]]++;
  }

  var max = 0;
  for (w in obj) {
    if (obj[w] > max) max = obj[w];
  }

  ret_val = [];
  for (w in obj) {
    if (obj[w] == max) ret_val.push(w);
  }

  return ret_val;
}

Question 28

function mode(){
  var input = $("input").val().split(",");
  var mode = [];
  var m = [];
  var p = [];
    for(var x = 0;x< input.length;x++){
      if(m.indexOf(input[x])==-1){
        m[m.length]=input[x];
    }}
  for(var x = 0; x< m.length;x++){
    p[x]=0;
    for(var y = 0; y<input.length;y++){
      if(input[y]==m[x]){
      p[x]++; 
 }}}
 for(var x = 0;x< p.length;x++){
   if(p[x] ==(Math.max.apply(null, p))){
     mode.push(m[x]);
 }} 
$("#output").text(mode);}

Question 29

এই আমার পথ। আমি গোষ্ঠী ডেটা মুষ্টির চেষ্টা করি

const _ = require("underscore")

var test  = [ 1, 1, 2, 1 ];
var groupResult = _.groupBy(test, (e)=> e);

গ্রুপ রেজাল্ট হওয়া উচিত

{
  1: [1, 1, 1]
  2: [2] 
}

তারপরে যে সম্পত্তিটি দীর্ঘতম অ্যারে রয়েছে তা সন্ধান করুন

function findMax(groupResult){
   var maxArr = []
   var max;
   for(var item in groupResult){
     if(!max) { 
        max = { value:item, count: groupResult[item].length } ; 
        maxArr.push(max); 
        continue;
     }
     if(max.count < groupResult[item].length){ 
        maxArr = [];
        max = { value:item, count: groupResult[item].length }
        maxArr.push(max)
     } else if(max === groupResult[item].length)
        maxArr.push({ value:item, count: groupResult[item].length })
   }
   return maxArr;
}

সম্পূর্ণ কোডটি দেখতে মনে হচ্ছে

const _ = require("underscore")

var test  = [ 1, 1, 2, 1 ];
var groupResult= _.groupBy(test, (e)=> e);
console.log(findMax(groupResult)[0].value);

function findMax(groupResult){
   var maxArr = []
   var max;
   for(var item in groupResult){
     if(!max) { 
        max = { value:item, count: groupResult[item].length } ; 
        maxArr.push(max); 
        continue;
     }
     if(max.count < groupResult[item].length){ 
        maxArr = [];
        max = { value:item, count: groupResult[item].length }
        maxArr.push(max)
     } else if(max === groupResult[item].length)
        maxArr.push({ value:item, count: groupResult[item].length })
   }
   return maxArr;
}

Question 30

var cats = ['Tom','Fluffy','Tom','Bella','Chloe','Tom','Chloe'];
var counts = {};
var compare = 0;
var mostFrequent;
(function(array){
   for(var i = 0, len = array.length; i < len; i++){
       var word = array[i];

       if(counts[word] === undefined){
           counts[word] = 1;
       }else{
           counts[word] = counts[word] + 1;
       }
       if(counts[word] > compare){
             compare = counts[word];
             mostFrequent = cats[i];
       }
    }
  return mostFrequent;
})(cats);

Question 31

ES6 এর সাহায্যে আপনি পদ্ধতিটি এভাবে চেইন করতে পারেন:

    function findMostFrequent(arr) {
      return arr
        .reduce((acc, cur, ind, arr) => {
          if (arr.indexOf(cur) === ind) {
            return [...acc, [cur, 1]];
          } else {
            acc[acc.indexOf(acc.find(e => e[0] === cur))] = [
              cur,
              acc[acc.indexOf(acc.find(e => e[0] === cur))][1] + 1
            ];
            return acc;
          }
        }, [])
        .sort((a, b) => b[1] - a[1])
        .filter((cur, ind, arr) => cur[1] === arr[0][1])
        .map(cur => cur[0]);
    }
    
    console.log(findMostFrequent(['pear', 'apple', 'orange', 'apple']));
    console.log(findMostFrequent(['pear', 'apple', 'orange', 'apple', 'pear']));

স্নিপেট প্রসারিত করুন

দুটি উপাদানের যদি একই ঘটনা ঘটে তবে তা উভয়কেই ফিরিয়ে দেবে। এবং এটি যে কোনও ধরণের উপাদানগুলির সাথে কাজ করে।