Как найти количество вхождений элемента в массив

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

1. Используя collections вы можете найти количество вхождений в массив на Python
2. Используя библиотеку NumPy, мы можем найти количество вхождений в массив на Python

При работе с массивом одной из основных проблем, с которой может столкнуться разработчик, является подсчет количества вхождений элемента. Представьте себе, что если у вас есть массив по количеству проданных элементов на сайте электронной коммерции за 10 дней, то вы хотели бы знать количество дней, когда продается более 100 элементов.

sales=[0, 100, 100, 80, 70, 80, 20, 10, 100, 100, 80, 70, 10, 30, 40]

Самый простой способ решить эту проблему – получить количество раз по 100 в массиве.

Используя collections вы можете найти количество вхождений в массив на Python

collections действуют как контейнеры для хранения данных. Мы можем легко импортировать модуль сбора данных и использовать функцию счетчика.
Проверьте код ниже:

>>>import collections
>>>sales=[0, 100, 100, 80, 70, 80, 20, 10, 100, 100, 80, 70, 10, 30, 40]  
>>>print(collections.Counter(sales))
Counter({100: 4, 80: 3, 70: 2, 10: 2, 0: 1, 20: 1, 30: 1, 40: 1})

Результирующий вывод – словарь. В нем перечислено, сколько раз каждый элемент массива произошел.

Однако, если мы хотим вывести количество раз по 100 в массиве продаж, мы можем получить его из словаря.

>>>print(collections.Counter(sales)[100])
4

Модуль collections также работает с десятичными числами и строками.

>>>floatarr=[0.7, 10.0, 10.1, .8, .7, .8, .2, .1, 10.0, 
10.0, .8, .8, .7, .7, .8]
>>>print(collections.Counter(floatarr))
Counter({0.8: 5, 0.7: 4, 10.0: 3, 10.1: 1, 0.2: 1, 0.1: 1})

>>>stringarr=["george","mark","george","steve","george"]
>>>print(collections.Counter(stringarr))
Counter({'george': 3, 'mark': 1, 'steve': 1})

Используя библиотеку NumPy, мы можем найти количество вхождений в массив на Python

Тем не менее, мы также можем использовать NumPy, который является библиотекой, определенной на Python для работы с большими массивами, а также содержит большое количество математических функций.

Существует несколько способов использования функций, определенных в NumPy, для возврата количества элементов в массиве.

Использование функции unique в NumPy

Функция unique вместе с функцией Count возвращает словарь подсчета каждого элемента. Также работает с десятичными числами и строками.

>>>import collections, numpy
>>>aUnique = numpy.array([0, 100, 100, 80, 70, 80, 20, 10, 100, 
100, 80, 70, 10, 30, 40])

>>>unique, counts = numpy.unique(aUnique, return_counts=True)

>>>print(dict(zip(unique, counts)));  
{0: 1, 10: 2, 20: 1, 30: 1, 40: 1, 70: 2, 80: 3, 100: 4}

Использование функции count_nonzero в NumPy

Использование count_nonzero возвращает количество искомого элемента. Это обеспечивает легкий для чтения интерфейс и меньшее количество строк кода.

>>>aCountZero = numpy.array([0, 100.1, 100.1, 80, 70, 80, 20, 10, 
100, 100, 80, 70, 10, 30, 40,"abc"])
>>>print(numpy.count_nonzero(aCountZero == "abc"))
1

count_nonzero также работает с десятичными числами и строками.

>>>aCountZero = numpy.array([0, 100.1, 100.1, 80, 70, 80, 20, 10,

100, 100, 80, 70, 10, 30, 40])

>>>print(numpy.count_nonzero(aCountZero == 100.1))
1

Использование функции bincount в NumPy – только для массивов с целыми числами

Однако, если у вас есть массив, состоящий только из целых чисел, вы можете использовать функцию bincount в NumPy. Самое лучшее, что она возвращает результаты в виде массива.

>>>abit = numpy.array([0, 6, 0, 10, 0, 1, 1, 0, 10, 9, 0, 1])

>>>print(numpy.bincount(abit))

[5 3 0 0 0 0 1 0 0 1 2]

Для чисел в массиве результат отображает количество элементов в порядке возрастания. Например, 0 в массиве abit происходит 5 раз, а 10, 2 раза, что обозначается первым и последним элементом массива.

В заключение следует отметить, что существует достаточно большое количество вариантов, из которых можно выбрать, когда нужно узнать количество вхождений элемента в одномерный массив. Следуйте за нами, как мы обсуждаем эффективность каждого из этих решений во времени, в нашей следующей статье.

В этой статье мы рассмотрим, как определить количество элементов в объекте Python и при необходимости подсчитать их сумму. Также увидим, как подсчитать количество вхождений конкретного элемента.

Итак, представим, что у нас есть следующий массив:

По условию задачи мы хотим определить, сколько элементов в данном массиве, и какова сумма всех этих элементов.

В первую очередь, вспомним, что в языке программирования Python существует специальная функция, возвращающая длину списка, массива, последовательности и так далее — это len(x), где x — наша последовательность.

Если разобраться, длина последовательности из чисел — это одновременно и количество самих цифр, поэтому мы можем решить поставленную задачу следующим образом:

print(len(array))
6
Press any key to continue . . .


А для подсчёта суммы можем занести перечисление массива Python в цикл:
array = [6,2,7,4,8,1]
sum = 0
for i in range(len(array)):
    sum  = array[i]
print(sum)


В принципе, вопрос решён. Но, по правде говоря, перебор целочисленного массива с помощью цикла для получения суммы элементов массива — это, всё же, костыль)). Дело в том, что в Python существует встроенная функция sum(). Она вернёт нам сумму без лишних телодвижений.
def main():
    array = [1,6,3,8,4,9,25,2]
    print(sum(array))
if name == 'main':

main()
58
Press any key to continue . . .


Python: количество вхождений конкретного элемента
Бывает, нам надо подсчитать число вхождений определённых элементов в списке и вернуть найденное значение. Для этого в Python есть метод count(). Вот его синтаксис:

Метод принимает аргумент x, значение которого нас интересует. И возвращает число вхождений интересующего элемента в список:
# объявляем список
website_list = ['otus.ru','includehelp.com', 'yandex.by', 'otus.ru']

# подсчитываем вхождения 'otus.ru'
count = website_list.count('otus.ru')
print('otus.ru found',count,'times.')

# подсчитываем вхождения 'yandex.by'
count = website_list.count('yandex.by')
print('yandex.by found',count,'times.')


Итог будет следующим:



  


                       
  




otus.ru found 2 times.
yandex.by found 1 times.


Также этот метод успешно работает и с кортежами:
# объявляем кортеж
sample_tuple = ((1,3), (2,4), (4,6))

# условные вхождения (1,2) 
count = sample_tuple.count((1,2))
print('(1,2) found',count,'times.')

# условные вхождения (1,3) 
count = sample_tuple.count((1,3))
print('(1,3) found',count,'times.')


Результат:
(1,2) found 0 times.
(1,3) found 1 times.


Вот и всё, теперь вы знаете, как подсчитывать количество элементов в списке, массиве, кортеже в Python.

(перейдите в конец, чтобы найти весь код решения)

Поначалу задача кажется довольно простой, но поскольку вы здесь, я полагаю, вы обнаружили, что она немного сложна, но только если вы новичок в Javascript или столкнулись с проблемой такого типа впервые.

Как вы скоро узнаете, решение настолько простое, как вы и ожидали, и включает в себя использование наших старых добрых объектов.

Возьмем массив:

const arr = ['foo','bar','foo','foo','foo','moo','bar','moo'];

Нам нужно подсчитать количество вхождений каждого элемента в массиве.

Посмотрим, как мы к этому подойдем.

Как мы видим, нам придется пройтись по массиву, и каждый раз, когда элемент повторяется, нам придется увеличивать его количество. А в OOPS мы можем использовать объекты для создания пар ключ-значение, поэтому мы собираемся хранить количество элементов в объекте, где ключи являются самими элементами.

let trackObj = {};   //we declare an empty tracker Object

Перебор массива:

Мы проверяем, существует ли уже текущий элемент в качестве ключа в нашем объекте. Если нет, мы объявляем его и присваиваем ему значение 1. Если элемент уже существует, мы увеличиваем значение ключа.

arr.forEach(cur => {
if( !trackObj[cur] )
trackObj[cur]
else
trackObj[cur]++;

});

И это все!

trackObj теперь содержит каждый элемент и количество раз, когда он встречается в массиве.

console.log(trackObj);

Итак, теперь у нас есть объект вхождений всех элементов.

Но что, если нам нужно найти элемент с максимальным количеством вхождений?

Считайте эту часть бонусом :3

Мы создадим 2 новые переменные maxCount = 0 и maxElement для хранения максимального значения вхождения и связанного с ним элемента.

Теперь мы проверяем в том же методе forEach if (trackObj[cur] › maxCount), и если это так, мы назначаем maxCount как trackObj[cur] и maxElement как cur.

Таким образом, мы можем просто изменить существующий цикл for следующим образом:

let maxCount = 0, maxElement;  // create two other variables 
arr.forEach(cur => {
if( !trackObj[cur] )
trackObj[cur]
else
trackObj[cur]++;
// ADDED CODE 
if(trackObj[cur] > maxCount)
{
  maxCount = trackObj[cur];
  maxElement = cur;
}
});

И это все! …снова

console.log(maxElement , maxCount);

Теперь вы это знаете.