জাভাস্ক্রিপ্টে একটি অ্যারেতে সদৃশ মান কীভাবে গণনা করা যায়

Question 1

বর্তমানে, আমি এর মতো একটি অ্যারে পেয়েছি:

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

ইত্যাদি

Question 2

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();

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

ডেমো ফিডল

অপারেশনটি করতে আপনি উচ্চ-অর্ডার ফাংশনগুলিও ব্যবহার করতে পারেন। এই উত্তর দেখুন

Question 3

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

Question 4

এটার মতো কিছু:

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 এর পরিবর্তে লুপের জন্য একটি সাধারণ ব্যবহার করুন।

Question 5

আমি এই (খুব পুরানো) প্রশ্ন জুড়ে হোঁচট খেয়েছি। মজার বিষয় হল সবচেয়ে সুস্পষ্ট এবং মার্জিত সমাধান ( ইমো ) অনুপস্থিত: অ্যারে.প্রোটোটাইপ.ড্রেস (...) । সমস্ত বড় ব্রাউজারগুলি এই বৈশিষ্ট্যটিকে প্রায় 2011 (আইই) বা তারও আগের (অন্যান্য সমস্ত) থেকে সমর্থন করে:

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}

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

Question 6

হ্রাস অ্যারে ফাংশনের উপর ভিত্তি করে একক লাইন

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

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

Question 7

সহজ আরও ভাল, একটি পরিবর্তনশীল, একটি ফাংশন :)

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

Question 8

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

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

Question 9


// 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]);

Question 10

কেউ প্রতিক্রিয়া করছে না বলে মনে হয় যে এটির জন্য 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);

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

তবে, পুরানো ব্রাউজারগুলিতে এটি ব্যবহার করতে চাইলে আপনাকে পলিফিলMap() করতে হবে।

Question 11

আপনার একটি অবজেক্ট থাকতে পারে যাতে গণনা রয়েছে। তালিকার উপরে চলে যান এবং প্রতিটি উপাদানটির জন্য গণনা বৃদ্ধি করুন:

var counts = {};

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

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

Question 12

আপনি প্রতিটি জন্য / যখন লুপগুলি ব্যবহার না করে এটি সমাধান করতে পারেন।

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

আশা করি এটি আপনাকে সাহায্য করবে!

Question 13

// 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));

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

Question 14

আপনি এর মতো কিছু করতে পারেন:

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

এখন আপনার কাছে সমস্ত অক্ষর গণনা সহ একটি মানচিত্র রয়েছে

Question 15

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

Question 16

বর্ণমালা সম্বলিত একটি অ্যারেতে সদৃশ:

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

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

Question 17

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

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

Question 18

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

Question 19

সরলীকৃত শীট.জেএস উত্তর

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

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

Question 20

অ্যারে হ্রাস পদ্ধতি ব্যবহার করে এটি জাভাস্ক্রিপ্টে সহজ:

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 }

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

Question 21

ভাল উত্তরের সংমিশ্রণ:

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

আশা করি এটি সহায়ক।

Question 22

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");

}

}

Question 23

অ্যারে.ম্যাপ ব্যবহার করে আমরা লুপটি হ্রাস করতে পারি, এটি জেএসফিডেলে দেখুন

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

Question 24

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 
*/

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

Question 25

উদাহরণস্বরূপ একটি ফাইল তৈরি করুন 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 ] ]

Question 26

দ্রুততম উপায়:

গার্হস্থ্য জটিলতা হ'ল ও (এন)।

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']);

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

Question 27

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

Question 28

arrকী হিসাবে অনন্য সেটটি ধরে রাখতে কোনও বস্তু ঘোষণা করুন । জনপূর্ণ করুন arrমানচিত্র ব্যবহার একবার অ্যারে মাধ্যমে looping দ্বারা। কীটি যদি আগে না পাওয়া যায় তবে কীটি যুক্ত করুন এবং শূন্যের মান নির্ধারণ করুন। প্রতিটি পুনরাবৃত্তি বৃদ্ধির উপর কী এর মান।

প্রদত্ত পরীক্ষাআরে:

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"]

যেকোন আইটেমের উপস্থিতি খুঁজে বের করার জন্য b খ arr['b']আউটপুট দেয়2

Question 29

ব্যবহার:

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

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