Agfdhyk

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

array.filter(c => c === searchvalue).length;

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

//}

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

DEMO: https://jsfiddle.net/57en9nar/1/

var dataset = [2,2,4,2,6,4,7,8], count = {}



dataset.forEach(function(el){

    count[el] = count[el] + 1 || 1

});



console.log(count)



//  {

//    2: 3,

//    4: 2,

//    6: 1,

//    7: 1,

//    8: 1

//  }

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;

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

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.

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.