অ্যারের উপাদানগুলির সংঘটন / ফ্রিকোয়েন্সি গণনা করা হচ্ছে

Question

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

উদাহরণস্বরূপ, যদি প্রাথমিক অ্যারেটি ছিল:

5, 5, 5, 2, 2, 2, 2, 2, 9, 4

তারপরে দুটি নতুন অ্যারে তৈরি করা হবে। প্রথমটিতে প্রতিটি অনন্য উপাদানের নাম থাকবে:

5, 2, 9, 4

দ্বিতীয়টিতে প্রাথমিক অ্যারেতে এলিমেন্ট সংখ্যার পরিমাণ ছিল:

3, 5, 1, 1

5 নম্বরটি প্রাথমিক অ্যারেটিতে তিনবার সংঘটিত হওয়ার কারণে, 2 নম্বরটি পাঁচবার ঘটে এবং 9 এবং 4 উভয়ই একবার উপস্থিত হয়।

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

ধন্যবাদ :)

Comments

আপনার যা যা দরকার তা যদি হ'ল শুধুমাত্র একবারে কোনও মান প্রদর্শিত হয় (দুই বা ততোধিক বারের পরিবর্তে), আপনি ব্যবহার করতে পারেনif (arr.indexOf(value) == arr.lastIndexOf(value))

— রডরিগো

আমরা ramda.jsএটি সহজ উপায়ে অর্জন করতে ব্যবহার করতে পারি । const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]; R.countBy(r=> r)(ary)

— warশ্বর প্রসাদ যদ্দনপুদি 4'17

arr.filter(x => x===5).length3অ্যারেতে '3' পাঁচটি রয়েছে তা নির্দেশ করে ফিরে আসবে ।

— noobninja

Answer 1

আপনি এখানে যান:

function foo(arr) {
    var a = [], b = [], prev;

    arr.sort();
    for ( var i = 0; i < arr.length; i++ ) {
        if ( arr[i] !== prev ) {
            a.push(arr[i]);
            b.push(1);
        } else {
            b[b.length-1]++;
        }
        prev = arr[i];
    }

    return [a, b];
}

লাইভ ডেমো: http://jsfiddle.net/simevidas/bnACW/

বিঃদ্রঃ

এটি ব্যবহার করে মূল ইনপুট অ্যারের ক্রম পরিবর্তন করে Array.sort

Comments

অ্যারে বাছাইয়ের পার্শ্ব-প্রতিক্রিয়া রয়েছে (পার্শ্ব প্রতিক্রিয়াগুলি খারাপ), এছাড়াও বাছাই করা O(N log(N))এবং কমনীয়তা লাভের পক্ষে মূল্যহীন নয়

— ninjagecko

@ নিনজা আপনি অন্য কোন উত্তর পছন্দ করেন?

— Vidime Vidas

তৃতীয় পক্ষের লাইব্রেরি থেকে একটি সুন্দর উচ্চ-স্তরের আদিম অনুপস্থিতিতে, আমি সাধারণত reduceউত্তরের মতো এটি প্রয়োগ করব । ইতিমধ্যে এটির অস্তিত্ব দেখার আগে আমি এই জাতীয় উত্তর জমা দিতে চলেছিলাম। তবুও উত্তরটিও counts[num] = counts[num] ? counts[num]+1 : 1কাজ করে (উত্তরের সমান if(!result[a[i]])result[a[i]]=0, যা আরও মার্জিত তবে পড়তে কম সহজ); এই উত্তরগুলি ফোর লুপের একটি "ভাল" সংস্করণটি ব্যবহার করতে সংশোধন করা যেতে পারে, সম্ভবত লুপের জন্য তৃতীয় পক্ষের, তবে আমি বাছাই করেছি যেহেতু স্ট্যান্ডার্ড সূচক ভিত্তিক-লুপগুলি দু: খজনকভাবে ডিফল্ট।

— নিনজাগেকো

@ নিনজা আমি সম্মত এই উত্তরগুলি আরও ভাল। দুর্ভাগ্যক্রমে আমি আমার নিজের উত্তরটি গ্রহণ করতে পারি না।

— Vidime Vidas

ছোট অ্যারেগুলির জন্য এটিকে স্থানে বাছাই করা কোনও সহযোগী অ্যারে তৈরি করার চেয়ে দ্রুততর হতে পারে be

— কোয়ান্ট_দেব

Answer 2

আপনি ফলাফলগুলি ধরে রাখতে কোনও বস্তু ব্যবহার করতে পারেন:

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counts = {};

for (var i = 0; i < arr.length; i++) {
  var num = arr[i];
  counts[num] = counts[num] ? counts[num] + 1 : 1;
}

console.log(counts[5], counts[2], counts[9], counts[4]);

সুতরাং, এখন আপনার গণনা অবজেক্ট আপনাকে বলতে পারে একটি নির্দিষ্ট সংখ্যার জন্য গণনাটি কী:

console.log(counts[5]); // logs '3'

আপনি যদি সদস্যদের একটি অ্যারে পেতে চান তবে কেবল keys()ফাংশনটি ব্যবহার করুন

keys(counts); // returns ["5", "2", "9", "4"]

Comments

এটি চিহ্নিত করা উচিত, এই Object.keys()ফাংশনটি কেবল আইই 9 +, এফএফ 4 +, এসএফ 5 +, সিএইচ 6 + তে সমর্থিত তবে অপেরা এটি সমর্থন করে না। আমি মনে করি এখানে বৃহত্তম শো স্টপারটি আই 9 + ।

— রবার্ট কোরিটনিক

একইভাবে, আমিও পছন্দ করি counts[num] = (counts[num] || 0) + 1। এইভাবে আপনাকে কেবল counts[num]সেখানে একটি লাইনে তিনবারের পরিবর্তে দু'বার লিখতে হবে।

— রব্রু

এটি একটি দুর্দান্ত উত্তর। এটি সহজেই কোনও ফাংশনে বিমূর্ত হয় যা একটি অ্যারে গ্রহণ করে এবং একটি 'গণনা' অবজেক্ট দেয়।

— বিটস্যান্ড

এটি প্রশ্নের নির্দিষ্ট উদাহরণের জন্য সত্য, তবে গুগলারের পক্ষে এটি উল্লেখ করা দরকার যে এটি সর্বদা বৃহত্তর ব্যবহারের জন্য কোনও নিরাপদ কৌশল নয় । মানগুলি গণনা করার জন্য অবজেক্ট কী হিসাবে সংরক্ষণ করার অর্থ আপনি সেই মানগুলি স্ট্রিংয়ে কাস্ট করছেন এবং তারপরে সেই মানটি গণনা করছেন। [5, "5"]সহজভাবে বলতে হবে আপনি "5"দুটি বার পেয়েছেন । বা উদাহরণগুলি গণনা করা হচ্ছে কিছু ভিন্ন অবজেক্ট কেবল আপনাকে বলবে যে এখানে প্রচুর পরিমাণ রয়েছে [object Object]। ইত্যাদি ইত্যাদি

— জিম্বো জনি

তারপরে কীভাবে আমি আমাকে সর্বোচ্চ থেকে সর্বনিম্ন, বা একটি সংখ্যার সর্বনিম্ন থেকে সর্বোচ্চ গণনা দেখানোর জন্য প্রত্যাবর্তিত অবজেক্টটি ফিল্টার করতে পারি

— রায়ান হলটন

Answer 3

var a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].reduce(function (acc, curr) {
  if (typeof acc[curr] == 'undefined') {
    acc[curr] = 1;
  } else {
    acc[curr] += 1;
  }

  return acc;
}, {});

// a == {2: 5, 4: 1, 5: 3, 9: 1}

Comments

acc[curr] ? acc[curr]++ : acc[curr] = 1;

— প্যান্ডেল

ধন্যবাদ, খুব সুন্দর সমাধান;) ... এবং "কী" এবং "মান" অ্যারে পেতে:const keys = Object.keys(a); const values = Object.values(a);

— নেক্সারার

Answer 4

যদি আন্ডারস্কোর বা লোডাশ ব্যবহার করে থাকেন তবে এটি করা সবচেয়ে সহজ কাজ:

_.countBy(array);

যেমন যে:

_.countBy([5, 5, 5, 2, 2, 2, 2, 2, 9, 4])
=> Object {2: 5, 4: 1, 5: 3, 9: 1}

অন্যদের দ্বারা নির্দেশিত হিসাবে, আপনি কেবল যথাক্রমে অনন্য সংখ্যা এবং তাদের উপস্থিতিগুলি পেতে ফলাফলের উপর _.keys()এবং _.values()কার্যগুলি সম্পাদন করতে পারেন । তবে আমার অভিজ্ঞতায় আসল অবজেক্টটি মোকাবেলা করা অনেক সহজ।

Answer 5

ফলাফলের জন্য দুটি অ্যারে ব্যবহার করবেন না, একটি বস্তু ব্যবহার করুন:

a      = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
result = { };
for(var i = 0; i < a.length; ++i) {
    if(!result[a[i]])
        result[a[i]] = 0;
    ++result[a[i]];
}

তাহলে দেখতে resultহবে:

{
    2: 5,
    4: 1,
    5: 3,
    9: 1
}

Answer 6

ECMAScript2015 বিকল্প সম্পর্কে কীভাবে।

const a = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

const aCount = new Map([...new Set(a)].map(
    x => [x, a.filter(y => y === x).length]
));

aCount.get(5)  // 3
aCount.get(2)  // 5
aCount.get(9)  // 1
aCount.get(4)  // 1

এই উদাহরণটি ইনপুট অ্যারেটি Setকনস্ট্রাক্টরের কাছে অনন্য মানগুলির সংগ্রহ তৈরি করে । এর পরে স্প্রেড বাক্য গঠনটি এই মানগুলিকে একটি নতুন অ্যারেতে প্রসারিত করে যাতে আমরা mapএটিকে কল এবং দ্বি-মাত্রিক অ্যারে হিসাবে অনুবাদ করতে পারি [value, count]- যেমন নীচের কাঠামো:

Array [
   [5, 3],
   [2, 5],
   [9, 1],
   [4, 1]
]

এরপরে নতুন অ্যারেটি পুনরায় নির্মাণযোগ্য অবজেক্টের Mapফলে কনস্ট্রাক্টরকে দেওয়া হয় :

Map {
    5 => 3,
    2 => 5,
    9 => 1,
    4 => 1
}

কোনও Mapঅবজেক্ট সম্পর্কে দুর্দান্ত জিনিসটি এটি ডেটা-প্রকারগুলি সংরক্ষণ করে - এটি আবার aCount.get(5)ফিরে আসবে 3তবে aCount.get("5")ফিরে আসবে বলে undefined। এটি কোনও মান / প্রকারকে কী হিসাবে কাজ করতে সহায়তা করে যার অর্থ এই সমাধানটিও বস্তুর অ্যারে নিয়ে কাজ করবে।

function frequencies(/* {Array} */ a){
    return new Map([...new Set(a)].map(
        x => [x, a.filter(y => y === x).length]
    ));
}

let foo = { value: 'foo' },
    bar = { value: 'bar' },
    baz = { value: 'baz' };

let aNumbers = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4],
    aObjects = [foo, bar, foo, foo, baz, bar];

frequencies(aNumbers).forEach((val, key) => console.log(key + ': ' + val));
frequencies(aObjects).forEach((val, key) => console.log(key.value + ': ' + val));

Comments

আপনার কাছে কি কোনও সুযোগের দ্বারা একটি অবজেক্ট অ্যারের জন্য এটির একটি উন্নত উত্তর রয়েছে? আইটেম অ্যারের জন্য এটি সংশোধন করার চেষ্টা করতে আমার সমস্যা হচ্ছে, যেখানে আপনি কেবলমাত্র একটি নতুন অ্যারে / মানচিত্র / সেট তৈরি করেছেন যাতে আপনি সদৃশগুলি সরিয়ে ফেলেন এবং অবজেক্টের জন্য একটি নতুন মান যুক্ত করেন, যাক "ডুপ্লিকেটেডকাউন্ট: মান" বলা যাক। আমি এই উত্তর stackoverflow.com/a/36744732

— শ্যারন গুর

Setস্বতন্ত্রতার জন্য অবজেক্ট রেফারেন্স ব্যবহার করে এবং "অনুরূপ" অবজেক্টগুলির তুলনা করার জন্য কোনও এপিআই সরবরাহ করে না । আপনি যদি এই ধরণের কোনও কাজের জন্য এই পদ্ধতির ব্যবহার করতে চান তবে আপনার কিছু মধ্যবর্তী হ্রাস কার্যকারিতা প্রয়োজন যা অনন্য দৃষ্টান্তগুলির একটি অ্যারের গ্যারান্টি দেয়। এটি সবচেয়ে দক্ষ নয় তবে আমি এখানে একটি দ্রুত উদাহরণ রেখেছি ।

— এমিসারি

উত্তর করার জন্য ধন্যবাদ! তবে আমি আসলে এটি কিছুটা আলাদাভাবে সমাধান করেছি। যদি আপনি উত্তরটি এখানে দেখতে পারেন তবে stackoverflow.com/a/43211561/4474900 আমি কী করেছি তার উদাহরণ দিয়েছি । এটি ভাল কাজ করে, আমার ক্ষেত্রে তুলনা করার জন্য একটি জটিল বিষয় ছিল। যদিও আমার সমাধানটির দক্ষতা সম্পর্কে জানেন না

— শ্যারন গুর

এই চমৎকার নতুন ডাটা স্ট্রাকচার ব্যবহার হতে পারে কিন্তু আছে রানটাইম মধ্যে O ( ছিল n ² ) যখন সহজ আলগোরিদিম এখানে এটি হে (ইন সমাধান প্রচুর আছে এন )।

— রাইফিনেস

Answer 7

আমি মনে করি অ্যারেতে একই মান সহ কীভাবে ঘটনা গণনা করা যায় এটি সহজ উপায়।

var a = [true, false, false, false];
a.filter(function(value){
    return value === false;
}).length

Comments

বা a.filter(value => !value).lengthনতুন

— জেএস

প্রশ্নের উত্তর দেয় না।

— Ry-

Answer 8

এক লাইন ES6 সমাধান। মানচিত্র হিসাবে অবজেক্ট ব্যবহার করে অনেক উত্তর কিন্তু আমি প্রকৃত মানচিত্র ব্যবহার করে কাউকে দেখতে পাচ্ছি না

const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());

map.keys()অনন্য উপাদান পেতে ব্যবহার করুন

map.values()ঘটনাগুলি পেতে ব্যবহার করুন

জুড়ি map.entries()পেতে [উপাদান, ফ্রিকোয়েন্সি] ব্যবহার করুন

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const map = arr.reduce((acc, e) => acc.set(e, (acc.get(e) || 0) + 1), new Map());

console.info([...map.keys()])
console.info([...map.values()])
console.info([...map.entries()])

Comments

আধুনিক জাভাস্ক্রিপ্ট সমস্ত দুনিয়া থেকে সেরা পেয়েছে

— আগস্ট

Answer 9

const data = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

function count(arr) {
  return arr.reduce((prev, curr) => (prev[curr] = ++prev[curr] || 1, prev), {})
}

console.log(count(data))

Comments

কেউ কি এটিকে বোঝাতে (পর্ব [করর] = ++ পূর্ববর্তী [কারুর] || 1, পূর্ব) কে খেয়াল করবেন?

— সোলজ্যাকার

কমা অপারেটর "তার operands প্রতিটি মূল্যায়ণ (বাঁ দিক থেকে ডানদিকে) এবং শেষ প্রতীক এর মান", তাই এই বাড়তি পূর্ববর্তী [Curr] (অথবা এটা 1 initialises) এর মান, তারপর পূর্ববর্তী ফেরৎ।

— ChrisV

কিন্তু আউটপুট একটি অ্যারে হয়?

— ফ্রান্সেস্কো

Answer 10

আপনি যদি একটি একক লাইনার পক্ষে।

arr.reduce(function(countMap, word) {countMap[word] = ++countMap[word] || 1;return countMap}, {});

সম্পাদনা (6/12/2015) : ভিতরে থেকে ব্যাখ্যা from কাউন্টম্যাপ হ'ল একটি মানচিত্র যা একটি শব্দকে এর ফ্রিকোয়েন্সি সহ মানচিত্র করে, যা আমরা বেনামে ফাংশন দেখতে পারি। যা হ্রাস করে তা হ'ল সমস্ত অ্যারে উপাদান এবং কাউন্টম্যাপকে শেষ ফাংশন কলের রিটার্ন মান হিসাবে পাস করার সাথে যুক্তিগুলি সহ ফাংশনটি প্রয়োগ করা হয়। শেষ প্যারামিটার ({}) হ'ল প্রথম ফাংশন কলের জন্য কাউন্টম্যাপের ডিফল্ট মান।

Comments

আপনার এটি ব্যাখ্যা করা উচিত। এটি এটিকে আরও ভাল উত্তর দেয় যাতে লোকেরা অন্যান্য ব্যবহারের ক্ষেত্রে কীভাবে এটি ব্যবহার করতে হয় তা শিখতে পারে।

— অ্যান্ড্রু গ্রোথ

একটি একক মাছ ধরার নৌকা যে শুধু LINEBREAK যা সাধারণত অনুসরণ করবে সরিয়ে ফেলা হবে ;, {এবং }। ... ঠিক আছে. আমি মনে করি একটি ওয়ান লাইনের সেই সংজ্ঞা দিয়ে আমরা কনভের গেম অফ লাইফকে "অনলাইনার" হিসাবে লিখতে পারি।

— ট্রিনকোট

Answer 11

ES6 সংস্করণটি আরও সরলীকরণকারী হওয়া উচিত (অন্য একটি লাইন সমাধান)

let arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
let acc = arr.reduce((acc, val) => acc.set(val, 1 + (acc.get(val) || 0)), new Map());

console.log(acc);
// output: Map { 5 => 3, 2 => 5, 9 => 1, 4 => 1 }

সরল অবজেক্টের পরিবর্তে একটি মানচিত্র আমাদের বিভিন্ন ধরণের উপাদানকে আলাদা করতে সহায়তা করে, না হলে সমস্ত গণনা স্ট্রিংয়ের উপর ভিত্তি করে

Answer 12

আপনি যদি আন্ডারস্কোর ব্যবহার করছেন তবে আপনি কার্যকরী রুটে যেতে পারেন

a = ['foo', 'foo', 'bar'];

var results = _.reduce(a,function(counts,key){ counts[key]++; return counts },
                  _.object( _.map( _.uniq(a), function(key) { return [key, 0] })))

সুতরাং আপনার প্রথম অ্যারে হয়

_.keys(results)

এবং দ্বিতীয় অ্যারে হয়

_.values(results)

এর বেশিরভাগটি জাভাস্ক্রিপ্ট ফাংশনগুলি উপলভ্য হলে ডিফল্ট হবে

ডেমো: http://jsfiddle.net/dAaUU/

Answer 13

উপর ভিত্তি করে উত্তর এর @adamse এবং @pmandell (যা আমি ভোট দিন), মধ্যে ES6 আপনি এটা করতে পারেন এক লাইন :

• 2017 সম্পাদনা : আমি ||কোডের আকার হ্রাস করতে এবং এটিকে আরও পাঠযোগ্য make

var a=[7,1,7,2,2,7,3,3,3,7,,7,7,7];
alert(JSON.stringify(

a.reduce((r,k)=>{r[k]=1+r[k]||1;return r},{})

));

---

এটি অক্ষর গণনা করতে ব্যবহার করা যেতে পারে :

var s="ABRACADABRA";
alert(JSON.stringify(

s.split('').reduce((a, c)=>{a[c]++?0:a[c]=1;return a},{})

));

Comments

আপনি যদি এটি ব্যবহার করেন তবে এটি আরও পঠনযোগ্য হবে || 0:(r,k)=>{r[k]=(r[k]||0)+1;return r}

— 12

আপনি জাভাস্ক্রিপ্টে এক লাইনে কিছু করতে পারেন।

— রাই-

এবং এটি কেন খারাপ জিনিস, @ রাই-?

— ESL

কখনও কখনও এটি বেশ কয়েকটি লাইনে আরও স্পষ্ট হয়, অন্যটি এক লাইনে আরও পরিষ্কার হয়। অ্যাল্থগ এটি "স্বাদ" এর বিষয়।

— ESL

আমি বোঝাতে চাইছি "ES6 এ আপনি এটি এক লাইনেই করতে পারেন" প্রতিটি উত্তরের ক্ষেত্রে প্রযোজ্য এবং আপনি এটি এক লাইনে ES5 এও করতে পারেন।

— Ry-

Answer 14

এখানে চোখের জন্য হালকা এবং সহজ কিছু ...

function count(a,i){
 var result = 0;
 for(var o in a)
  if(a[o] == i)
   result++;
 return result;
}

সম্পাদনা করুন: এবং যেহেতু আপনি সমস্ত উপস্থিতি চান ...

function count(a){
 var result = {};
 for(var i in a){
  if(result[a[i]] == undefined) result[a[i]] = 0;
  result[a[i]]++;
 }
 return result;
}

Comments

প্রশ্নটি সমস্ত উপাদানগুলির গণনা চেয়েছিল।

— রাই-

ঠিক আছে, যে মিস। এখনই ঠিক করা উচিত।

— ElDoRado1239

Answer 15

সুতরাং আমি এখানে কয়েকটি নতুন জাভাস্ক্রিপ্ট বৈশিষ্ট্যগুলি কীভাবে এটি করব:

প্রথমে একটি Mapগুণকে অ্যারে হ্রাস করুন :

let countMap = array.reduce(
  (map, value) => {map.set(value, (map.get(value) || 0) + 1); return map}, 
  new Map()
)

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

আপনার সমস্ত মান প্রতীক, সংখ্যা বা স্ট্রিংগুলি হলে এটি কোনও বস্তুর সাথেও করা যেতে পারে:

let countObject = array.reduce(
  (map, value) => { map[value] = (map[value] || 0) + 1; return map },
  {}
)

বা বিবর্তন ছাড়াই কার্যকরী উপায়ে কিছুটা ফ্যানসিয়ার, ডেস্ট্রাকচারিং এবং অবজেক্ট স্প্রেড সিনট্যাক্স ব্যবহার করে:

let countObject = array.reduce(
  (value, {[value]: count = 0, ...rest}) => ({ [value]: count + 1, ...rest }),
  {}
)

এই মুহুর্তে, আপনি Mapআপনার গণনাগুলির জন্য বা অবজেক্টটি ব্যবহার করতে পারেন (এবং মানচিত্রটি কোনও বস্তুর বিপরীতে সরাসরি পুনরাবৃত্তিযোগ্য) বা এটিকে দুটি অ্যারে রূপান্তর করতে পারে।

এর জন্য Map:

countMap.forEach((count, value) => console.log(`value: ${value}, count: ${count}`)

let values = countMap.keys()
let counts = countMap.values()

বা বস্তুর জন্য:

Object
  .entries(countObject) // convert to array of [key, valueAtKey] pairs
  .forEach(([value, count]) => console.log(`value: ${value}, count: ${count}`)

let values = Object.keys(countObject)
let counts = Object.values(countObject)

Answer 16

var array = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

function countDuplicates(obj, num){
  obj[num] = (++obj[num] || 1);
  return obj;
}

var answer = array.reduce(countDuplicates, {});
// answer => {2:5, 4:1, 5:3, 9:1};

আপনি যদি এখনও দুটি অ্যারে চান তবে আপনি এই জাতীয় উত্তরটি ব্যবহার করতে পারেন ...

var uniqueNums = Object.keys(answer);
// uniqueNums => ["2", "4", "5", "9"];

var countOfNums = Object.keys(answer).map(key => answer[key]);
// countOfNums => [5, 1, 3, 1];

অথবা আপনি চাইলে ইউনিকএনমসের সংখ্যা হবে

var uniqueNums = Object.keys(answer).map(key => +key);
// uniqueNums => [2, 4, 5, 9];

Comments

es6 / 7 এটিকে আরও সুন্দর করে তোলে। আপনি এর Mapপরিবর্তে হ্রাস করতেও পারেন , যেহেতু এটি টাইপকাস্টিং এড়াতে পারে যে কোনও সংখ্যাকে অবজেক্ট কী (স্ট্রিং হিসাবে কাস্টিং) হিসাবে ব্যবহার করে। const answer = array.reduce((a, e) => a.set(e, (a.get(e) || 0) + 1), new Map())। আপনি answer.keys()কীগুলি এবং answer.values()অ্যারে হিসাবে মানগুলি পেতে পারেন । [...answer]2 ডি অ্যারে হিসাবে সমস্ত কী / মান সহ আপনাকে একটি বড় অ্যারে দেবে।

— জোশি কেরিবউ

Answer 17

হ্রাস (স্থির) সহ ES6 সমাধান:

const arr = [2, 2, 2, 3, 2]

const count = arr.reduce((pre, cur) => (cur === 2) ? ++pre : pre, 0)
console.log(count) // 4

Comments

নিশ্চিত নয় যে কীভাবে একটি সংখ্যা জিজ্ঞাসা করা প্রশ্নের মতো প্রতিটি স্বতন্ত্র অ্যারের উপাদানগুলির গণনা উপস্থাপন করে।

— Ry-

Answer 18

2020 সম্পাদনা করুন : এটি একটি সুন্দর পুরানো উত্তর (নয় বছর)। নেটিভ প্রসারিত করা prototypeসর্বদা আলোচনা তৈরি করে । যদিও আমি মনে করি প্রোগ্রামার তার নিজস্ব প্রোগ্রামিং শৈলী চয়ন করতে পারে নিছক, সমস্যা বাড়ানোর ছাড়াই সমস্যাটির (আরও আধুনিক) পদ্ধতির এখানে Array.prototype:

{
  // create array with some pseudo random values (1 - 5)
  const arr = Array.from({length: 100})
    .map( () => Math.floor(1 + Math.random() * 5) );
  // frequencies using a reducer
  const arrFrequencies = arr.reduce((acc, value) => 
      ({ ...acc, [value]: acc[value] + 1 || 1}), {} )
  console.log(`Value 4 occurs ${arrFrequencies[4]} times in arrFrequencies`);

  // bonus: restore Array from frequencies
  const arrRestored = Object.entries(arrFrequencies)
    .reduce( (acc, [key, value]) => acc.concat(Array(value).fill(+key)), [] );
  console.log(arrRestored.join());  
}

.as-console-wrapper { top: 0; max-height: 100% !important; }

পুরানো (২০১১) উত্তর: আপনি এর Array.prototypeমতো প্রসারিত করতে পারেন:

{
  Array.prototype.frequencies = function() {
    var l = this.length,
      result = {
        all: []
      };
    while (l--) {
      result[this[l]] = result[this[l]] ? ++result[this[l]] : 1;
    }
    // all pairs (label, frequencies) to an array of arrays(2)
    for (var l in result) {
      if (result.hasOwnProperty(l) && l !== 'all') {
        result.all.push([l, result[l]]);
      }
    }
    return result;
  };

  var freqs = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4].frequencies();
  console.log(`freqs[2]: ${freqs[2]}`); //=> 5
  
  // or
  var freqs = '1,1,2,one,one,2,2,22,three,four,five,three,three,five'
    .split(',')
    .frequencies();
    
  console.log(`freqs.three: ${freqs.three}`); //=> 3
  
// Alternatively you can utilize Array.map:

    Array.prototype.frequencies = function() {
      var freqs = {
        sum: 0
      };
      this.map(function(a) {
        if (!(a in this)) {
          this[a] = 1;
        } else {
          this[a] += 1;
        }
        this.sum += 1;
        return a;
      }, freqs);
      return freqs;
    }
}

.as-console-wrapper { top: 0; max-height: 100% !important; }

Answer 19

রামদার সাথে আমার সমাধান:

const testArray = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]

const counfFrequency = R.compose(
  R.map(R.length),
  R.groupBy(R.identity),
)

counfFrequency(testArray)

আরপিএল-এর লিঙ্ক।

Answer 20

ও (এন) সময়ের জটিলতার সাথে মানচিত্র ব্যবহার করে সমাধান করুন ।

var arr = [2, 2, 2, 2, 2, 4, 5, 5, 5, 9];

const countOccurrences = (arr) => {
    const map = {};
    for ( var i = 0; i < arr.length; i++ ) {
        map[arr[i]] = ~~map[arr[i]] + 1;
    }
    return map;
}

ডেমো: http://jsfiddle.net/simevidas/bnACW/

Comments

আপনার কাছে আমার উক্তি, এটি ও (এন) সময় জটিলতার সাথে মাখনের মতো কাজ করে

— বিশাল শেঠি

Answer 21

আরও কার্যকর এবং সহজ উপায় যা আমরা এটি ব্যবহার করে করতে পারি ramda.js। কোড নমুনা এখানে

const ary = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4]; R.countBy(r=> r)(ary) countBy ডকুমেন্টেশন ডকুমেন্টেশন হয়

Answer 22

এমএপি ব্যবহার করে আপনার আউটপুটে ২ টি অ্যারে থাকতে পারে: একটিতে উপস্থিতিগুলি রয়েছে এবং অন্যটিতে ঘটনার সংখ্যা রয়েছে containing

const dataset = [2,2,4,2,6,4,7,8,5,6,7,10,10,10,15];
let values = [];
let keys = [];

var mapWithOccurences = dataset.reduce((a,c) => {
  if(a.has(c)) a.set(c,a.get(c)+1);
  else a.set(c,1);
  return a;
}, new Map())
.forEach((value, key, map) => {
  keys.push(key);
  values.push(value);
});


console.log(keys)
console.log(values)

Answer 23

নীচের কোডটি দেখুন।

<html>
<head>
<script>
// array with values
var ar = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];

var Unique = []; // we'll store a list of unique values in here
var Counts = []; // we'll store the number of occurances in here

for(var i in ar)
{
    var Index = ar[i];
    Unique[Index] = ar[i];
    if(typeof(Counts[Index])=='undefined')  
        Counts[Index]=1;
    else
        Counts[Index]++;
}

// remove empty items
Unique = Unique.filter(function(){ return true});
Counts = Counts.filter(function(){ return true});

alert(ar.join(','));
alert(Unique.join(','));
alert(Counts.join(','));

var a=[];

for(var i=0; i<Unique.length; i++)
{
    a.push(Unique[i] + ':' + Counts[i] + 'x');
}
alert(a.join(', '));

</script>
</head>
<body>

</body>
</html>

Answer 24

এটা চেষ্টা কর:

Array.prototype.getItemCount = function(item) {
    var counts = {};
    for(var i = 0; i< this.length; i++) {
        var num = this[i];
        counts[num] = counts[num] ? counts[num]+1 : 1;
    }
    return counts[item] || 0;
}

Answer 25

আমি কোডওয়ারগুলিতে একই রকম সমস্যা সমাধান করছিলাম এবং নিম্নলিখিত সমাধানটি তৈরি করেছি যা আমার পক্ষে কাজ করে।

এটি একটি অ্যারেতে পূর্ণসংখ্যার সর্বোচ্চ গণনা দেয় এবং নিজেও পূর্ণসংখ্যা দেয়। আমি মনে করি এটি স্ট্রিং অ্যারেতেও প্রয়োগ করা যেতে পারে।

স্ট্রিংগুলি যথাযথভাবে বাছাই করতে, অংশটির function(a, b){return a-b}ভিতরে থেকে সরানsort()

function mostFrequentItemCount(collection) {
    collection.sort(function(a, b){return a-b});
    var i=0;
    var ans=[];
    var int_ans=[];
    while(i<collection.length)
    {
        if(collection[i]===collection[i+1])
        {
            int_ans.push(collection[i]);
        }
        else
        {
            int_ans.push(collection[i]);
            ans.push(int_ans);
            int_ans=[];
        }
        i++;
    }

    var high_count=0;
    var high_ans;

    i=0;
    while(i<ans.length)
    {
        if(ans[i].length>high_count)
        {
            high_count=ans[i].length;
            high_ans=ans[i][0];
        }
        i++;
    }
    return high_ans;
}

Answer 26

এখানে অবজেক্টগুলির অ্যারের ভিতরে উপস্থিতিগুলি গণনা করার একটি উপায়। এটি মানগুলি বাছাই করতে নতুন অ্যারের ভিতরে প্রথম অ্যারের সামগ্রীগুলি রাখে যাতে মূল অ্যারেতে ক্রমটি ব্যাহত না হয়। তারপরে একটি পুনরাবৃত্ত ফাংশন প্রতিটি উপাদানের মধ্য দিয়ে যেতে এবং অ্যারের অভ্যন্তরে প্রতিটি বস্তুর পরিমাণ বৈশিষ্ট্য গণনা করতে ব্যবহৃত হয়।

var big_array = [
  { name: "Pineapples", quantity: 3 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Pineapples", quantity: 2 },
  { name: "Pineapples", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 1 },
  { name: "Bananas", quantity: 5 },
  { name: "Coconuts", quantity: 1 },
  { name: "Lemons", quantity: 2 },
  { name: "Oranges", quantity: 1 },
  { name: "Lemons", quantity: 1 },
  { name: "Limes", quantity: 1 },
  { name: "Grapefruit", quantity: 1 },
  { name: "Coconuts", quantity: 5 },
  { name: "Oranges", quantity: 6 }
];

function countThem() {
  var names_array = [];
  for (var i = 0; i < big_array.length; i++) {
    names_array.push( Object.assign({}, big_array[i]) );
  }

  function outerHolder(item_array) {
    if (item_array.length > 0) {
      var occurrences = [];
      var counter = 0;
      var bgarlen = item_array.length;
      item_array.sort(function(a, b) { return (a.name > b.name) ? 1 : ((b.name > a.name) ? -1 : 0); });

      function recursiveCounter() {
        occurrences.push(item_array[0]);
        item_array.splice(0, 1);
        var last_occurrence_element = occurrences.length - 1;
        var last_occurrence_entry = occurrences[last_occurrence_element].name;
        var occur_counter = 0;
        var quantity_counter = 0;
        for (var i = 0; i < occurrences.length; i++) {
          if (occurrences[i].name === last_occurrence_entry) {
            occur_counter = occur_counter + 1;
            if (occur_counter === 1) {
              quantity_counter = occurrences[i].quantity;
            } else {
              quantity_counter = quantity_counter + occurrences[i].quantity;
            }
          }
        }

        if (occur_counter > 1) {
          var current_match = occurrences.length - 2;
          occurrences[current_match].quantity = quantity_counter;
          occurrences.splice(last_occurrence_element, 1);
        }

        counter = counter + 1;

        if (counter < bgarlen) {
          recursiveCounter();
        }
      }

      recursiveCounter();

      return occurrences;
    }
  }
  alert(JSON.stringify(outerHolder(names_array)));
}

Answer 27

function countOcurrences(arr){
    return arr.reduce((aggregator, value, index, array) => {
      if(!aggregator[value]){
        return aggregator = {...aggregator, [value]: 1};  
      }else{
        return aggregator = {...aggregator, [value]:++aggregator[value]};
      }
    }, {})
}

Comments

প্রতিবার অবজেক্টটি অনুলিপি করা অত্যন্ত ব্যর্থ। চৌম্বকীয়তম নিকৃষ্টতম পরিস্থিতি তৈরি করে যখন এটি লিনিয়ার হতে পারে।

— রাই-

Answer 28

var aa = [1,3,5,7,3,2,4,6,8,1,3,5,5,2,0,6,5,9,6,3,5,2,5,6,8];
var newArray = {};
for(var element of aa){
  if(typeof newArray[element] === 'undefined' || newArray[element] === null){
    newArray[element] = 1;
  }else{
    newArray[element] +=1;
  }
}

for ( var element in newArray){
  console.log( element +" -> "+ newArray[element]);
}

Answer 29

এই প্রশ্নটি 8 বছরেরও বেশি পুরানো এবং অনেকগুলি, অনেক উত্তর সত্যই ES6 গ্রহণ করে না এবং এর অসংখ্য সুবিধার বিষয়টি বিবেচনায় নেই।

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

নির্দিষ্ট ডেটা ধরণের জন্য আপনার যদি কেবল "কাউন্টার" প্রয়োজন হয় এবং প্রারম্ভিক বিন্দুটি একটি অ্যারে হয় (আমি ধরে নিই যে আপনি অতএব একটি আদেশযুক্ত তালিকা চান এবং অনেক বৈশিষ্ট্য এবং পদ্ধতি অ্যারের অফারটি গ্রহণ করেন), আপনি কেবল অ্যারে 1 এর মাধ্যমে পুনরাবৃত্তি করতে পারেন এবং পপুলেশন করতে পারেন অ্যারে 1 এ পাওয়া এই মানগুলির মান এবং সংঘটন সংখ্যার সাথে অ্যারে 2

এর মত সহজ.

অবজেক্ট ওরিয়েন্টেড প্রোগ্রামিং এবং অবজেক্ট ওরিয়েন্টেড ডিজাইনের জন্য সিম্পল ক্লাসের সিম্পলকাউন্টারের উদাহরণ (ES6)

class SimpleCounter { 

    constructor(rawList){ // input array type
        this.rawList = rawList;
        this.finalList = [];
    }

    mapValues(){ // returns a new array

        this.rawList.forEach(value => {
            this.finalList[value] ? this.finalList[value]++ : this.finalList[value] = 1;
        });

        this.rawList = null; // remove array1 for garbage collection

        return this.finalList;

    }

}

module.exports = SimpleCounter;

Comments

কোনও কারণে ক্লাসে কোনও ফাংশন আটকে রাখার কারণে এটি বস্তু-কেন্দ্রিক নয়, finalListঅ্যারে হওয়ার কোনও কারণ নেই এবং এটি সঠিকভাবে করার চেয়ে কোনও সুবিধা নেই।

— রাই-

Answer 30

অ্যারে গণনা করার জন্য এখানে একটি সর্বোত্তম স্কুল পদ্ধতি।

var arr = [5, 5, 5, 2, 2, 2, 2, 2, 9, 4];
var counted = [], count = [];
var i = 0, j = 0, k = 0;
while (k < arr.length) {
    if (counted.indexOf(arr[k]) < 0) {
        counted[i] = arr[k];
        count[i] = 0;
        for (j = 0; j < arr.length; j++) {
            if (counted[i] == arr[j]) {
                count[i]++;
            }
        }
        i++;
    } else {
        k++;
    }
}

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