सरणी तत्वों की घटनाओं / आवृत्ति की गणना करना

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)

— ईश्वर प्रसाद यददानपुदी

arr.filter(x => x===5).lengthयह 3इंगित करने के लिए लौटेंगे कि सरणी में '3' फ़ाइव हैं।

— नोबनिंजा जू

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

@ निन्जा आपको और कौन सा जवाब पसंद है?

— 40इमे विद्या

तीसरे पक्ष के पुस्तकालय से एक अच्छे उच्च-स्तरीय आदिम की अनुपस्थिति में, मैं सामान्य रूप से reduceउत्तर की तरह इसे लागू करूंगा । मैं इस तरह का जवाब प्रस्तुत करने वाला था इससे पहले कि मैंने देखा कि यह पहले से मौजूद था। फिर भी counts[num] = counts[num] ? counts[num]+1 : 1उत्तर भी काम करता है (उत्तर के बराबर if(!result[a[i]])result[a[i]]=0, जो अधिक सुरुचिपूर्ण है लेकिन पढ़ने में कम आसान है); इस उत्तर को लूप के "अच्छे" संस्करण का उपयोग करने के लिए संशोधित किया जा सकता है, शायद एक थर्ड-पार्टी फॉर-लूप है, लेकिन मैंने इस बात को नजरअंदाज कर दिया कि चूंकि मानक सूचकांक आधारित फॉर-लूप दुखद रूप से डिफ़ॉल्ट हैं।

— नवजागेको

@ निन्जा मैं सहमत हूँ। वे जवाब बेहतर हैं। दुर्भाग्य से मैं अपने स्वयं के उत्तर को स्वीकार नहीं कर सकता।

— 59इमे विद

छोटे सरणियों के लिए यह जगह में एक साहचर्य सरणी बनाने से तेज हो सकता है।

— quant_dev

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()फ़ंक्शन केवल IE9 +, FF4 +, SF5 +, CH6 + में समर्थित है, लेकिन ओपेरा इसे समर्थन भी करता है। मुझे लगता है कि यहां सबसे बड़ा शो स्टॉपर IE9 + है ।

— रॉबर्ट कोरिटनिक

इसी तरह, मुझे भी पसंद है 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;

— pmandell

धन्यवाद, बहुत अच्छा समाधान;) ... और "कुंजी" और "मूल्य" सरणियाँ पाने के लिए:const keys = Object.keys(a); const values = Object.values(a);

— ncenerar

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

क्या आपके पास किसी ऑब्जेक्ट के लिए बस एक बेहतर जवाब देने का मौका है? im को ऑब्जेक्ट सरणी के लिए इसे संशोधित करने की कोशिश करने में परेशानी हो रही है, जहां आप बस एक नया सरणी / नक्शा / सेट बनाते हैं जिसमें आप डुप्लिकेट को हटाते हैं, और ऑब्जेक्ट के लिए एक नया मान जोड़ते हैं, "डुप्लिकेटेडकाउंट: मान" कहा जाता है। मैं इस उत्तर से मेरी नेस्टेड ऑब्जेक्ट सरणी में डुप्लिकेट को निकालने में कामयाब हुआ stackoverflow.com/a/36744732

— शेरोन गुर

Setविशिष्टता के लिए वस्तु संदर्भ का उपयोग करता है और "समान" वस्तुओं की तुलना के लिए कोई एपीआई प्रदान नहीं करता है । यदि आप इस कार्य के लिए इस दृष्टिकोण का उपयोग करना चाहते हैं, तो आपको कुछ मध्यवर्ती कमी फ़ंक्शन की आवश्यकता होगी जो अद्वितीय उदाहरणों की एक सरणी की गारंटी देता है। यह सबसे कुशल नहीं है, लेकिन मैंने यहां एक त्वरित उदाहरण दिया है ।

— एमिसरी

जवाब के लिए धन्यवाद! लेकिन मैं वास्तव में यह एक अलग तरह से एक lilttle हल। अगर आप इसका जवाब देख सकते हैं तो मैंने यहां बताया कि stackoverflow.com/a/43211561/4474900 मैंने जो किया उसका मैंने उदाहरण दिया। यह अच्छी तरह से काम करता है, मेरे मामले में एक जटिल वस्तु की तुलना करने की आवश्यकता थी। हालांकि मेरे समाधान की दक्षता के बारे में पता नहीं है

— शेरोन गुर

यह अच्छे नए डेटा स्ट्रक्चर्स का उपयोग कर सकता है लेकिन O ( n while) में रनटाइम है, जबकि यहाँ बहुत सारे सरल एल्गोरिदम हैं जो इसे O ( n ) में हल करते हैं ।

— रफनेस

Answer 7

मुझे लगता है कि यह सबसे सरल तरीका है कि सरणी में समान मूल्य के साथ घटनाओं को कैसे गिना जाए।

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

Comments

या a.filter(value => !value).lengthनए js सिंटैक्स के साथ

— t3chb0t

सवाल का जवाब नहीं देता।

— Ry-

Answer 8

एक पंक्ति ईएस 6 समाधान। एक नक्शे के रूप में ऑब्जेक्ट का उपयोग करते हुए इतने सारे उत्तर लेकिन मैं किसी को भी वास्तविक मानचित्र का उपयोग करके नहीं देख सकता

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

किसी को यह समझाने की परवाह करेंगे (प्रचलित [करण] = ++ प्रचलित [करम] || १, प्रचलित)?

— सोलजैकर

अल्पविराम ऑपरेटर "अपने ऑपरेंड से प्रत्येक का मूल्यांकन करता है (बाएं से दाएं) और पिछले संकार्य का मान देता है", तो यह वेतन वृद्धि पिछला [curr] (या यह 1 करने के लिए initialises) का मूल्य है, तो पिछला देता है।

— क्रिस जुव

लेकिन उत्पादन एक सरणी है?

— फ्रांसेस्को

Answer 10

अगर आप सिंगल लाइनर का पक्ष लेते हैं।

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

संपादित करें (6/12/2015) : अंदर से व्याख्या। countMap एक नक्शा है जो एक शब्द को अपनी आवृत्ति के साथ मैप करता है, जिसे हम गुमनाम फ़ंक्शन देख सकते हैं। क्या कम करता है फ़ंक्शन को तर्कों के साथ लागू किया जाता है क्योंकि सभी सरणी तत्व और काउंटरपॉइंट अंतिम फ़ंक्शन कॉल के वापसी मूल्य के रूप में पारित किए जाते हैं। अंतिम फ़ंक्शन ({}) पहले फ़ंक्शन कॉल के लिए काउंटरपाइप का डिफ़ॉल्ट मान है।

Comments

आपको इसकी व्याख्या करनी चाहिए। इससे यह एक बेहतर उत्तर बन जाएगा ताकि लोग सीखें कि इसे अन्य उपयोग के मामलों में कैसे उपयोग किया जाए।

— एंड्रयू ग्रोथ

एक एकल लाइनर जो सिर्फ उस लाइनब्रेक को हटाता है जो आमतौर पर अनुसरण करेगा ;, {और }। ... ठीक है। मुझे लगता है कि एक लाइनर की उस परिभाषा के साथ हम कॉनवे के गेम ऑफ लाइफ को "ऑनलाइनर" के रूप में लिख सकते हैं।

— ट्रिनकोट

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 संपादित करें : मैं ||कोड आकार को कम करने और इसे अधिक पठनीय बनाने के लिए उपयोग करता हूं ।

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

आप जावास्क्रिप्ट में एक पंक्ति में कुछ भी कर सकते हैं।

— Ry-

और क्यों यह एक बुरी बात है, @ Ry-?

— ईएसएल

कभी-कभी यह कई लाइनों में अधिक स्पष्ट होता है, अन्य एक पंक्ति में स्पष्ट होता है। अल्थौग यह "स्वाद" की बात है।

— ईएसएल

मेरा मतलब है "ईएस 6 में आप इसे एक पंक्ति में कर सकते हैं" हर उत्तर पर लागू होता है, और आप इसे एक पंक्ति में ईएस 5 में भी कर सकते हैं।

— 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

सभी तत्वों की गिनती के लिए पूछा गया प्रश्न।

— Ry-

ठीक है, वह याद किया। अब तय होना चाहिए।

— 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]आपको 2d सरणियों के रूप में सभी कुंजी / मानों के साथ एक बड़ा सरणी देगा।

— क़ारीबौ जूल

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; }

पुराना (2011) उत्तर: आप 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)

REPL से लिंक करें

Answer 20

O (n) समय जटिलता के साथ एक मानचित्र का उपयोग कर समाधान ।

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

MAP के उपयोग से आप आउटपुट में 2 सरणियाँ रख सकते हैं: एक जिसमें आवृत्तियाँ होती हैं और दूसरी में घटनाओं की संख्या होती है।

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

हर बार ऑब्जेक्ट को कॉपी करने के लिए बेहद बेकार। रैखिक होने पर एक द्विघात सबसे खराब स्थिति बनाता है।

— Ry-

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 साल से अधिक पुराना है और कई, कई जवाब वास्तव में ईएस 6 और इसके कई फायदे को ध्यान में नहीं रखते हैं।

कचरा संग्रहण / स्मृति प्रबंधन के लिए हमारे कोड के परिणामों के बारे में सोचना और भी अधिक महत्वपूर्ण है जब भी हम अतिरिक्त सरणियों का निर्माण करते हैं, सरणियों की डबल या ट्रिपल प्रतियां बनाते हैं या यहां तक ​​कि सरणियों को वस्तुओं में परिवर्तित करते हैं। ये छोटे अनुप्रयोगों के लिए तुच्छ अवलोकन हैं, लेकिन अगर पैमाने एक दीर्घकालिक उद्देश्य है, तो इन के बारे में अच्छी तरह से सोचें।

यदि आपको विशिष्ट डेटा प्रकारों के लिए बस "काउंटर" की आवश्यकता है और शुरुआती बिंदु एक सरणी है (मुझे लगता है कि आप चाहते हैं कि एक ऑर्डर की गई सूची हो और कई संपत्तियों और विधियों सरणियों की पेशकश का लाभ उठाएं), तो आप बस array1 के माध्यम से पुनरावृत्ति कर सकते हैं और आबाद कर सकते हैं array2 में पाया इन मूल्यों के लिए मूल्यों और घटनाओं की संख्या के साथ array2।

इतना सरल है।

ऑब्जेक्ट ओरिएंटेड प्रोग्रामिंग और ऑब्जेक्ट ओरिएंटेड डिज़ाइन के लिए सरल वर्ग SimpleCounter (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इसके पास सरणी होने का कोई कारण नहीं है, और इसे ठीक से करने पर कोई लाभ नहीं है।

— Ry-

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++;
    }
}

यदि आप एक वर्णमाला परिणाम चाहते हैं, तो आप इसे पहले क्रमबद्ध कर सकते हैं, लेकिन यदि आप उस क्रम को संरक्षित करना चाहते हैं जिसमें डेटा दर्ज किया गया था, तो इसे आज़माएं। नेस्टेड लूप इस पृष्ठ पर कुछ अन्य तरीकों की तुलना में थोड़ा धीमा हो सकता है।