जावास्क्रिप्ट में किसी सरणी में डुप्लिकेट मान की गणना कैसे करें

Question

वर्तमान में, मुझे एक सरणी मिली है जैसे:

var uniqueCount = Array();

कुछ चरणों के बाद, मेरा सरणी ऐसा दिखता है:

uniqueCount = [a,b,c,d,d,e,a,b,c,f,g,h,h,h,e,a];

मैं सरणी में कितने ए, बी, सी गिन सकता हूं? मैं एक परिणाम की तरह है:

a = 3
b = 1
c = 2
d = 2

आदि।

Comments

स्टैकओवरफ्लो का संभावित डुप्लिकेट. com

— questions/12749200/…

@ निर्क मैं मानता हूं कि musical_coder का मतलब एक नक्शे के रूप में है {}, न कि कार्यात्मक प्रोग्रामिंग का map।

— मैट बॉल

Answer 1

function count() {
    array_elements = ["a", "b", "c", "d", "e", "a", "b", "c", "f", "g", "h", "h", "h", "e", "a"];

    array_elements.sort();

    var current = null;
    var cnt = 0;
    for (var i = 0; i < array_elements.length; i++) {
        if (array_elements[i] != current) {
            if (cnt > 0) {
                document.write(current + ' comes --> ' + cnt + ' times<br>');
            }
            current = array_elements[i];
            cnt = 1;
        } else {
            cnt++;
        }
    }
    if (cnt > 0) {
        document.write(current + ' comes --> ' + cnt + ' times');
    }

}

count();

डेमो फिडल

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

Comments

अतिरिक्त अगर लूप के बाद बयान अनावश्यक है ... बस का उपयोग करें for (var i = 0; i <= array_elements.length; i++) {या <=इसके बजाय <।

— एम्मागामा

हाय @Vayay, शायद तुम मेरी मदद कर सकते हैं यहाँ? stackoverflow.com/questions/57819850/…

— SMPLYJR

Answer 2

var counts = {};
your_array.forEach(function(x) { counts[x] = (counts[x] || 0)+1; });

Comments

यह निश्चित रूप से सबसे सरल उत्तर है

— जोश बीम

(गिनता है [x] || ०) +1 यह गिनती कैसे दे रहा है?

— jsduniya

@SidBhalke: यदि यह सेट है, तो अभिव्यक्ति counts[x] || 0मान लौटाती counts[x]है 0। फिर बस एक जोड़ें और इसे फिर से ऑब्जेक्ट में सेट करें और गणना की जाए।

— कांस्टेंटिनियस

@SJJS अगर आप सोच रहे हैं कि डाउनवोट क्यों है - यह मैं था; मैं मोबाइल पर ब्राउज़ कर रहा था, और बटन w / o पर क्लिक करके वास्तव में देख रहा हूँ। एक बार मुझे पता चला कि वापस आने में बहुत देर हो गई। इसके लिए माफी, जवाब वास्तव में अच्छा है। यदि आप इसे संपादित करना चाहते हैं, तो मुझे खुशी होगी कि मैं उल्टा करूंगा।

— टोडर मिनाकोव

इसके साथ ही reduce:var counts = your_array.reduce((map, val) => {map[val] = (map[val] || 0)+1; return map}, {} );

— अल्बर्टो89

Answer 3

कुछ इस तरह:

uniqueCount = ["a","b","c","d","d","e","a","b","c","f","g","h","h","h","e","a"];
var count = {};
uniqueCount.forEach(function(i) { count[i] = (count[i]||0) + 1;});
console.log(count);

यदि आप यह नहीं चाहते कि पुराने ब्राउज़रों में तोड़ दिया जाए, तो forEach के बजाय एक सरल लूप का उपयोग करें।

Comments

@web_dev वह गिनती नामक एक साहचर्य सरणी ऑब्जेक्ट बनाता है जिसमें सरणी में प्रत्येक अद्वितीय तत्व के लिए एक महत्वपूर्ण मान युग्म होगा, जहाँ कुंजी अद्वितीय तत्व मान है और मान गिनती है। वह सरणी पर पुनरावृत्ति करता है और प्रत्येक मान के लिए या तो मान बढ़ाता है या कुंजी मान युग्म बनाता है (गैर-मौजूद कुंजी का मान अपरिभाषित होता है इसलिए || या ऑपरेटर इसके बजाय शून्य लेता है और 1 जोड़ता है)

— robrobrob

@neelmeg शायद "forEach" के लिए सभी मापदंडों को लिखना बेहतर समझने में मदद करता है ("i" प्रत्येक ऐरे वैल्यू है और न ही यह índex है):uniqueCount.forEach(function(value, index) { count[value] = (count[value] || 0) + 1; });

— पेड्रो फेरेरा

Answer 4

मैं इस (बहुत पुराने) सवाल पर अड़ गया। दिलचस्प रूप से सबसे स्पष्ट और सुरुचिपूर्ण समाधान (imho) गायब है: Array.prototyp.reduce (...) । सभी प्रमुख ब्राउज़र इस सुविधा का समर्थन 2011 (IE) या उससे भी पहले (अन्य सभी) से करते हैं:

var arr = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = arr.reduce(function(prev, cur) {
  prev[cur] = (prev[cur] || 0) + 1;
  return prev;
}, {});

// map is an associative array mapping the elements to their frequency:
document.write(JSON.stringify(map));
// prints {"a": 3, "b": 2, "c": 2, "d": 2, "e": 2, "f": 1, "g": 1, "h": 3}

Answer 5

कम लाइन सरणी समारोह पर आधारित है

const uniqueCount =  ["a", "b", "c", "d", "d", "e", "a", "b", "c", "f", "g", "h", "h", "h", "e", "a"];
const distribution = uniqueCount.reduce((acum,cur) => Object.assign(acum,{[cur]: (acum[cur] | 0)+1}),{});
console.log(JSON.stringify(distribution,null,2));

Comments

मुझे बस एहसास हुआ कि @ isnot2bad ( stackoverflow.com/a/32886673/621058 ) लगभग मेरा ही है। मैं सिर्फ वसा तीर फ़ंक्शन और स्थिरांक का उपयोग करने के लिए होता हूं

— 11

Answer 6

सरल बेहतर है, एक चर, एक फ़ंक्शन :)

const counts = arr.reduce((acc, value) => ({
   ...acc,
   [value]: (acc[value] || 0) + 1
}), {});

Answer 7

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

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

Answer 8

// Initial array
let array = ['a', 'b', 'c', 'd', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a'];

// Unique array without duplicates ['a', 'b', ... , 'h']
let unique = [...new Set(array)];

// This array counts duplicates [['a', 3], ['b', 2], ... , ['h', 3]] 
let duplicates = unique.map(value => [value, array.filter(str => str === value).length]);

Answer 9

कोई भी जवाब नहीं देता है इसके लिए Map()बिल्ट-इन का उपयोग किया जा रहा है , जो कि मेरे जाने के साथ संयुक्त हो जाता है Array.prototype.reduce():

const data = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
const result = data.reduce((a, c) => a.set(c, (a.get(c) || 0) + 1), new Map());
console.log(...result);

अगर आप इसे पुराने ब्राउज़रों में उपयोग करना चाहते हैं तो Nb, आपको पॉलीफ़िलMap() करना होगा।

Comments

क्या आप थोड़ी गहराई से बता सकते हैं कि यह कैसे काम कर रहा है? (विशेष रूप से सेट / भाग प्राप्त करें)। मैंने रेड्यूसर को एक फ़ंक्शन में तोड़ने की कोशिश की, लेकिन मेरे पास "प्राप्त" है प्रतिक्रिया में एक फ़ंक्शन नहीं है।

— एंटोनी नेडेलेक

ऑब्जेक्ट से ओके getऔर setफंक्शन आ रहे हैं Map। लेकिन प्रारंभिक संचायक एक मैप ऑब्जेक्ट नहीं है, इसलिए रिड्यूसर का कम संस्करण एक क्यों लेता है?

— एंटोनी नेडेलेक

@AntoineNedelec प्रारंभिक मूल्य है एक नया Mapवस्तु; कमी का दूसरा तर्क देखें। Map.prototype.setमैप ऑब्जेक्ट Map.prototype.getलौटाता है , और undefinedजो भी कुंजी की आपूर्ति करता है उसका रिटर्न या मूल्य। यह हमें प्रत्येक अक्षर की वर्तमान गणना (या 0यदि अपरिभाषित) प्राप्त करने देता है , तो वेतन वृद्धि एक के बाद एक करके उस पत्र की गिनती को नई गणना पर सेट करें, जो मानचित्र को लौटाता है और नया संचायक मान बन जाता है।

— aendrew

Answer 10

आपके पास एक ऑब्जेक्ट हो सकता है जिसमें मायने रखता है। सूची पर चलें और प्रत्येक तत्व के लिए गिनती बढ़ाएँ:

var counts = {};

uniqueCount.forEach(function(element) {
  counts[element] = (counts[element] || 0) + 1;
});

for (var element in counts) {
  console.log(element + ' = ' + counts[element]);
} 

Comments

आपने यह शर्त क्यों रखी counts[element] || 0?

— AskMen

Answer 11

आप बिना किसी का उपयोग किए बिना इसे हल कर सकते हैं / जबकि ou forEach का उपयोग कर सकते हैं।

function myCounter(inputWords) {        
    return inputWords.reduce( (countWords, word) => {
        countWords[word] = ++countWords[word] || 1;
        return countWords;
    }, {});
}

आशा है कि यह आपकी मदद करता है!

Answer 12

// new example.
var str= [20,1,-1,2,-2,3,3,5,5,1,2,4,20,4,-1,-2,5];

function findOdd(para) {
  var count = {};
  para.forEach(function(para) {
  count[para] = (count[para] || 0) + 1;
  });
  return count;
}

console.log(findOdd(str));

Answer 13

आप ऐसा कुछ कर सकते हैं:

uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
var map = new Object();

for(var i = 0; i < uniqueCount.length; i++) {
 if(map[uniqueCount[i]] != null) {
    map[uniqueCount[i]] += 1;
} else {
    map[uniqueCount[i]] = 1;
    }
}

अब आपके पास सभी वर्णों के साथ एक नक्शा है

Answer 14

var uniqueCount = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];
// here we will collect only unique items from the array
var uniqueChars = [];

// iterate through each item of uniqueCount
for (i of uniqueCount) {
// if this is an item that was not earlier in uniqueCount, 
// put it into the uniqueChars array
  if (uniqueChars.indexOf(i) == -1) {
    uniqueChars.push(i);
  } 
}
// after iterating through all uniqueCount take each item in uniqueChars
// and compare it with each item in uniqueCount. If this uniqueChars item 
// corresponds to an item in uniqueCount, increase letterAccumulator by one.
for (x of uniqueChars) {
  let letterAccumulator = 0;
  for (i of uniqueCount) {
    if (i == x) {letterAccumulator++;}
  }
  console.log(`${x} = ${letterAccumulator}`);
}

Comments

इसे अपडेट करने के लिए धन्यवाद, शुरुआत करने वालों के लिए बहुत अधिक उपयोगी।

— नियमित जो

Answer 15

अक्षर युक्त एक सरणी में डुप्लिकेट:

var arr = ["a", "b", "a", "z", "e", "a", "b", "f", "d", "f"],
  sortedArr = [],
  count = 1;

sortedArr = arr.sort();

for (var i = 0; i < sortedArr.length; i = i + count) {
  count = 1;
  for (var j = i + 1; j < sortedArr.length; j++) {
    if (sortedArr[i] === sortedArr[j])
      count++;
  }
  document.write(sortedArr[i] + " = " + count + "<br>");
}

संख्या युक्त एक सरणी में डुप्लिकेट:

var arr = [2, 1, 3, 2, 8, 9, 1, 3, 1, 1, 1, 2, 24, 25, 67, 10, 54, 2, 1, 9, 8, 1],
  sortedArr = [],
  count = 1;
sortedArr = arr.sort(function(a, b) {
  return a - b
});
for (var i = 0; i < sortedArr.length; i = i + count) {
  count = 1;
  for (var j = i + 1; j < sortedArr.length; j++) {
    if (sortedArr[i] === sortedArr[j])
      count++;
  }
  document.write(sortedArr[i] + " = " + count + "<br>");
}

Answer 16

var testArray = ['a ’,, b’,, c ’,, d’,' d ’, a e’, e a ’, 'b’,' c ’, 'f’,' g ’, = h ',' ज ',' ज ',' ई ',' एक '];

var newArr = [];
testArray.forEach((item) => {
    newArr[item] = testArray.filter((el) => {
            return el === item;
    }).length;
})
console.log(newArr);

Answer 17

uniqueCount = ["a","b","a","c","b","a","d","b","c","f","g","h","h","h","e","a"];
var count = {};
uniqueCount.forEach((i) => { count[i] = ++count[i]|| 1});
console.log(count);

Answer 18

सरलीकृत चादर। js answare

var counts = {};
var aarr=['a','b','a'];
aarr.forEach(x=>counts[x]=(counts[x] || 0)+1 );
console.log(counts)

Answer 19

अच्छे उत्तरों का संयोजन:

var count = {};
var arr = ['a', 'b', 'c', 'd', 'd', 'e', 'a', 'b', 'c', 'f', 'g', 'h', 'h', 'h', 'e', 'a'];
var iterator = function (element) {
    count[element] = (count[element] || 0) + 1;
}

if (arr.forEach) {
    arr.forEach(function (element) {
        iterator(element);
    });
} else {
    for (var i = 0; i < arr.length; i++) {
        iterator(arr[i]);
    }
}  

आशा है कि यह उपयोगी है।

Answer 20

public class CalculateCount {
public static void main(String[] args) {
    int a[] = {1,2,1,1,5,4,3,2,2,1,4,4,5,3,4,5,4};
    Arrays.sort(a);
    int count=1;
    int i;
    for(i=0;i<a.length-1;i++){
        if(a[i]!=a[i+1]){
            System.out.println("The Number "+a[i]+" appears "+count+" times");
            count=1;                
        }
        else{
            count++;
        }
    }
    System.out.println("The Number "+a[i]+" appears "+count+" times");

}   

}

Comments

क्या आप इसके आसपास कुछ संदर्भ जोड़ सकते हैं?

— नव

Answer 21

Array.map का उपयोग करके हम लूप को कम कर सकते हैं, इसे jsfiddle पर देखें

function Check(){
    var arr = Array.prototype.slice.call(arguments);
    var result = [];
    for(i=0; i< arr.length; i++){
        var duplicate = 0;
        var val = arr[i];
        arr.map(function(x){
            if(val === x) duplicate++;
        })
        result.push(duplicate>= 2);
    }
    return result;
}

मापना:

var test = new Check(1,2,1,4,1);
console.log(test);

Answer 22

var string = ['a','a','b','c','c','c','c','c','a','a','a'];

function stringCompress(string){

var obj = {},str = "";
string.forEach(function(i) { 
  obj[i] = (obj[i]||0) + 1;
});

for(var key in obj){
  str += (key+obj[key]);
}
  console.log(obj);
  console.log(str);
}stringCompress(string)

/*
Always open to improvement ,please share 
*/

Answer 23

उदाहरण के लिए एक फ़ाइल बनाएं demo.jsऔर इसे नोड के साथ कंसोल में चलाएं demo.jsऔर आपको मैट्रिक्स के रूप में तत्वों की घटना मिलेगी।

var multipleDuplicateArr = Array(10).fill(0).map(()=>{return Math.floor(Math.random() * Math.floor(9))});
console.log(multipleDuplicateArr);

var resultArr = Array(Array('KEYS','OCCURRENCE'));

for (var i = 0; i < multipleDuplicateArr.length; i++) {
  var flag = true;
  for (var j = 0; j < resultArr.length; j++) {
     if(resultArr[j][0] == multipleDuplicateArr[i]){
       resultArr[j][1] = resultArr[j][1] + 1;
       flag = false;
      }
  }
  if(flag){
    resultArr.push(Array(multipleDuplicateArr[i],1));
  }
}

console.log(resultArr);

आपको नीचे सांत्वना में परिणाम मिलेगा:

[ 1, 4, 5, 2, 6, 8, 7, 5, 0, 5 ] . // multipleDuplicateArr
[ [ 'KEYS', 'OCCURENCE' ],        // resultArr
  [ 1, 1 ],
  [ 4, 1 ],
  [ 5, 3 ],
  [ 2, 1 ],
  [ 6, 1 ],
  [ 8, 1 ],
  [ 7, 1 ],
  [ 0, 1 ] ]

Answer 24

सबसे त्वरित तरीका:

Сomputational जटिलता O (n) है।

function howMuchIsRepeated_es5(arr) {
	const count = {};
	for (let i = 0; i < arr.length; i++) {
		const val = arr[i];
		if (val in count) {
			count[val] = count[val] + 1;
		} else {
			count[val] = 1;
		}
	}

	for (let key in count) {
		console.log("Value " + key + " is repeated " + count[key] + " times");
	}
}

howMuchIsRepeated_es5(['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a']);

सबसे छोटा कोड:

ES6 का उपयोग करें।

function howMuchIsRepeated_es6(arr) {
	// count is [ [valX, count], [valY, count], [valZ, count]... ];
	const count = [...new Set(arr)].map(val => [val, arr.join("").split(val).length - 1]);

	for (let i = 0; i < count.length; i++) {
		console.log(`Value ${count[i][0]} is repeated ${count[i][1]} times`);
	}
}

howMuchIsRepeated_es6(['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a']);

Answer 25

var arr = ['a','d','r','a','a','f','d'];  

//call function and pass your array, function will return an object with array values as keys and their count as the key values.
duplicatesArr(arr);

function duplicatesArr(arr){
    var obj = {}
    for(var i = 0; i < arr.length; i++){
        obj[arr[i]] = [];
        for(var x = 0; x < arr.length; x++){
            (arr[i] == arr[x]) ? obj[arr[i]].push(x) : '';
        }
        obj[arr[i]] = obj[arr[i]].length;
    }

    console.log(obj);
    return obj;
}

Answer 26

arrकुंजी सेट को कुंजियों के रूप में रखने के लिए किसी ऑब्जेक्ट को घोषित करें। arrमानचित्र का उपयोग करके एक बार सरणी के माध्यम से लूपिंग द्वारा पॉप्युलेट करें। यदि कुंजी पहले नहीं मिली है, तो कुंजी जोड़ें और शून्य का मान निर्दिष्ट करें। प्रत्येक पुनरावृत्ति पर कुंजी के मूल्य में वृद्धि होती है।

दिया गया परीक्षण

var testArray = ['a','b','c','d','d','e','a','b','c','f','g','h','h','h','e','a'];

उपाय:

var arr = {};
testArray.map(x=>{ if(typeof(arr[x])=="undefined") arr[x]=0; arr[x]++;});

JSON.stringify(arr) उत्पादन होगा

{"a":3,"b":2,"c":2,"d":2,"e":2,"f":1,"g":1,"h":3}

Object.keys(arr) वापस होगा ["a","b","c","d","e","f","g","h"]

किसी भी आइटम की घटनाओं को खोजने के लिए जैसे बी arr['b']आउटपुट होगा2

Comments

कृपया केवल कोड को एक उत्तर के रूप में पोस्ट न करें, लेकिन एक स्पष्टीकरण भी शामिल करें कि आपका कोड क्या करता है और यह समस्या को कैसे हल करता है। स्पष्टीकरण के साथ उत्तर आम तौर पर उच्च गुणवत्ता के होते हैं और upvotes को आकर्षित करने की अधिक संभावना होती है।

— मार्क रोटेटेवेल

Answer 27

उपयोग:

wrap.common.getUniqueDataCount(, columnName);

कोड:

function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }
        
        return dataSet;
    }

टुकड़ा

var data= [
          {a:'you',b:'b',c:'c',d:'c'},
          {a: 'you', b: 'b', c: 'c', d:'c'},
          {a: 'them', b: 'b', c: 'c', d:'c'},
          {a: 'them', b: 'b', c: 'c', d:'c'},
          {a: 'okay', b: 'b', c: 'c', d:'c'},
          {a: 'okay', b: 'b', c: 'c', d:'c'},
          ];
          
  console.log(getUniqueDataCount(data, 'a'));       
  
  function getUniqueDataCount(objArr, propName) {
        var data = [];
        objArr.forEach(function (d, index) {
            if (d[propName]) {
                data.push(d[propName]);
            }
        });

        var uniqueList = [...new Set(data)];

        var dataSet = {};
        for (var i=0; i < uniqueList.length; i++) {
            dataSet[uniqueList[i]] = data.filter(x => x == uniqueList[i]).length;
        }

        return dataSet;
    }

Answer 28

यह सरणी कम करने की विधि का उपयोग करके जावास्क्रिप्ट में सरल है:

const arr = ['a','d','r','a','a','f','d'];
const result =  arr.reduce((json,val)=>({...json, [val]:(json[val] | 0) + 1}),{});
console.log(result)
//{ a:3,d:2,r:1,f:1 }