Idiomatically find the number of occurrences a given value has in an array
JavascriptArraysJavascript Problem Overview
I have an array with repeating values. I would like to find the number of occurrences for any given value.
For example, if I have an array defined as so: var dataset = [2,2,4,2,6,4,7,8];
, I want to find the number of occurrences of a certain value in the array. That is, the program should show that if I have 3 occurrences of the value 2
, 1 occurrence of the value 6
, and so on.
What's the most idiomatic/elegant way to do this?
Javascript Solutions
Solution 1 - Javascript
reduce
is more appropriate here than filter
as it doesn't build a temporary array just for counting.
var dataset = [2,2,4,2,6,4,7,8];
var search = 2;
var count = dataset.reduce(function(n, val) {
return n + (val === search);
}, 0);
console.log(count);
In ES6:
let count = dataset.reduce((n, x) => n + (x === search), 0);
Note that it's easy to extend that to use a custom matching predicate, for example, to count objects that have a specific property:
people = [
{name: 'Mary', gender: 'girl'},
{name: 'Paul', gender: 'boy'},
{name: 'John', gender: 'boy'},
{name: 'Lisa', gender: 'girl'},
{name: 'Bill', gender: 'boy'},
{name: 'Maklatura', gender: 'girl'}
]
var numBoys = people.reduce(function (n, person) {
return n + (person.gender == 'boy');
}, 0);
console.log(numBoys);
Counting all items, that is, making an object like {x:count of xs}
is complicated in javascript, because object keys can only be strings, so you can't reliably count an array with mixed types. Still, the following simple solution will work well in most cases:
count = function (ary, classifier) {
classifier = classifier || String;
return ary.reduce(function (counter, item) {
var p = classifier(item);
counter[p] = counter.hasOwnProperty(p) ? counter[p] + 1 : 1;
return counter;
}, {})
};
people = [
{name: 'Mary', gender: 'girl'},
{name: 'Paul', gender: 'boy'},
{name: 'John', gender: 'boy'},
{name: 'Lisa', gender: 'girl'},
{name: 'Bill', gender: 'boy'},
{name: 'Maklatura', gender: 'girl'}
];
// If you don't provide a `classifier` this simply counts different elements:
cc = count([1, 2, 2, 2, 3, 1]);
console.log(cc);
// With a `classifier` you can group elements by specific property:
countByGender = count(people, function (item) {
return item.gender
});
console.log(countByGender);
2017 update
In ES6, you use the Map
object to reliably count objects of arbitrary types.
class Counter extends Map {
constructor(iter, key=null) {
super();
this.key = key || (x => x);
for (let x of iter) {
this.add(x);
}
}
add(x) {
x = this.key(x);
this.set(x, (this.get(x) || 0) + 1);
}
}
// again, with no classifier just count distinct elements
results = new Counter([1, 2, 3, 1, 2, 3, 1, 2, 2]);
for (let [number, times] of results.entries())
console.log('%s occurs %s times', number, times);
// counting objects
people = [
{name: 'Mary', gender: 'girl'},
{name: 'John', gender: 'boy'},
{name: 'Lisa', gender: 'girl'},
{name: 'Bill', gender: 'boy'},
{name: 'Maklatura', gender: 'girl'}
];
chessChampions = {
2010: people[0],
2012: people[0],
2013: people[2],
2014: people[0],
2015: people[2],
};
results = new Counter(Object.values(chessChampions));
for (let [person, times] of results.entries())
console.log('%s won %s times', person.name, times);
// you can also provide a classifier as in the above
byGender = new Counter(people, x => x.gender);
for (let g of ['boy', 'girl'])
console.log("there are %s %ss", byGender.get(g), g);
A type-aware implementation of Counter
can look like this (Typescript):
type CounterKey = string | boolean | number;
interface CounterKeyFunc<T> {
(item: T): CounterKey;
}
class Counter<T> extends Map<CounterKey, number> {
key: CounterKeyFunc<T>;
constructor(items: Iterable<T>, key: CounterKeyFunc<T>) {
super();
this.key = key;
for (let it of items) {
this.add(it);
}
}
add(it: T) {
let k = this.key(it);
this.set(k, (this.get(k) || 0) + 1);
}
}
// example:
interface Person {
name: string;
gender: string;
}
let people: Person[] = [
{name: 'Mary', gender: 'girl'},
{name: 'John', gender: 'boy'},
{name: 'Lisa', gender: 'girl'},
{name: 'Bill', gender: 'boy'},
{name: 'Maklatura', gender: 'girl'}
];
let byGender = new Counter(people, (p: Person) => p.gender);
for (let g of ['boy', 'girl'])
console.log("there are %s %ss", byGender.get(g), g);
Solution 2 - Javascript
array.filter(c => c === searchvalue).length;
Solution 3 - Javascript
Here is one way to show ALL counts at once:
var dataset = [2, 2, 4, 2, 6, 4, 7, 8];
var counts = {}, i, value;
for (i = 0; i < dataset.length; i++) {
value = dataset[i];
if (typeof counts[value] === "undefined") {
counts[value] = 1;
} else {
counts[value]++;
}
}
console.log(counts);
// Object {
// 2: 3,
// 4: 2,
// 6: 1,
// 7: 1,
// 8: 1
//}
Solution 4 - Javascript
Newer browsers only due to using Array.filter
var dataset = [2,2,4,2,6,4,7,8];
var search = 2;
var occurrences = dataset.filter(function(val) {
return val === search;
}).length;
console.log(occurrences); // 3
Solution 5 - Javascript
const dataset = [2,2,4,2,6,4,7,8];
const count = {};
dataset.forEach((el) => {
count[el] = count[el] + 1 || 1
});
console.log(count)
// {
// 2: 3,
// 4: 2,
// 6: 1,
// 7: 1,
// 8: 1
// }
Solution 6 - Javascript
Using a normal loop, you can find the occurrences consistently and reliably:
const dataset = [2,2,4,2,6,4,7,8];
function getNumMatches(array, valToFind) {
let numMatches = 0;
for (let i = 0, j = array.length; i < j; i += 1) {
if (array[i] === valToFind) {
numMatches += 1;
}
}
return numMatches;
}
alert(getNumMatches(dataset, 2)); // should alert 3
DEMO: https://jsfiddle.net/a7q9k4uu/
To make it more generic, the function could accept a predicate function with custom logic (returning true
/false
) which would determine the final count. For example:
const dataset = [2,2,4,2,6,4,7,8];
function getNumMatches(array, predicate) {
let numMatches = 0;
for (let i = 0, j = array.length; i < j; i += 1) {
const current = array[i];
if (predicate(current) === true) {
numMatches += 1;
}
}
return numMatches;
}
const numFound = getNumMatches(dataset, (item) => {
return item === 2;
});
alert(numFound); // should alert 3
Solution 7 - Javascript
You can count all items in an array, in a single line, using reduce.
[].reduce((a,b) => (a[b] = a[b] + 1 || 1) && a, {})
This will yield an object, whose keys are the distinct elements in the array and values are the count of occurences of elements in the array. You can then access one or more of the counts by accessing a corresponding key on the object.
For example if you were to wrap the above in a function called count()
:
function count(arr) {
return arr.reduce((a,b) => (a[b] = a[b] + 1 || 1) && a, {})
}
count(['example']) // { example: 1 }
count([2,2,4,2,6,4,7,8])[2] // 3
Solution 8 - Javascript
You can do with use of array.reduce(callback[, initialValue])
method in JavaScript 1.8
var dataset = [2,2,4,2,6,4,7,8],
dataWithCount = dataset.reduce( function( o , v ) {
if ( ! o[ v ] ) {
o[ v ] = 1 ;
} else {
o[ v ] = o[ v ] + 1;
}
return o ;
}, {} );
// print data with count.
for( var i in dataWithCount ){
console.log( i + 'occured ' + dataWithCount[i] + 'times ' );
}
// find one number
var search = 2,
count = dataWithCount[ search ] || 0;
Solution 9 - Javascript
I've found it more useful to end up with a list of objects with a key for what is being counted and a key for the count:
const data = [2,2,4,2,6,4,7,8]
let counted = []
for (var c of data) {
const alreadyCounted = counted.map(c => c.name)
if (alreadyCounted.includes(c)) {
counted[alreadyCounted.indexOf(c)].count += 1
} else {
counted.push({ 'name': c, 'count': 1})
}
}
console.log(counted)
which returns:
[ { name: 2, count: 3 },
{ name: 4, count: 2 },
{ name: 6, count: 1 },
{ name: 7, count: 1 },
{ name: 8, count: 1 } ]
It isn't the cleanest method, and if anyone knows how to achieve the same result with reduce
let me know. However, it does produce a result that's fairly easy to work with.
Solution 10 - Javascript
First, you can go with Brute Force Solution by going with Linear Search.
public int LinearSearchcount(int[] A, int data){
int count=0;
for(int i=0;i<A.length;i++) {
if(A[i]==data) count++;
}
return count;
}
However, for going with this, we get Time complexity as O(n).But by going with Binary search, we can improve our Complexity.
Solution 11 - Javascript
If you try to do it this way, you might get an error like the one below.
array.reduce((acc, arr) => acc + (arr.label === 'foo'), 0); // Operator '+' cannot be applied to type 'boolean'.
One solution would be to do it this way
array = [
{ id: 1, label: 'foo' },
{ id: 2, label: 'bar' },
{ id: 3, label: 'foo' },
{ id: 4, label: 'bar' },
{ id: 5, label: 'foo' }
]
array.reduce((acc, arr) => acc + (arr.label === 'foo' ? 1 : 0), 0); // result: 3