How to count occurrences of an element in a Swift array?

I've seen a few examples of this but all of those seem to rely on knowing which element you want to count the occurrences of. My array is generated dynamically so I have no way of knowing which element I want to count the occurrences of (I want to count the occurrences of all of them). Can anyone advise?

Thanks in advance

EDIT:

Perhaps I should have been clearer, the array will contain multiple different strings (e.g. ["FOO", "FOO", "BAR", "FOOBAR"]

How can I count the occurrences of foo, bar and foobar without knowing what they are in advance?

Swift 3 and Swift 2:

You can use a dictionary of type [String: Int] to build up counts for each of the items in your [String]:

let arr = ["FOO", "FOO", "BAR", "FOOBAR"]
var counts: [String: Int] = [:]

for item in arr {
    counts[item] = (counts[item] ?? 0) + 1
}

print(counts)  // "[BAR: 1, FOOBAR: 1, FOO: 2]"

for (key, value) in counts {
    print("\(key) occurs \(value) time(s)")
}

output:

BAR occurs 1 time(s)
FOOBAR occurs 1 time(s)
FOO occurs 2 time(s)

---

Swift 4:

Swift 4 introduces (SE-0165) the ability to include a default value with a dictionary lookup, and the resulting value can be mutated with operations such as += and -=, so:

counts[item] = (counts[item] ?? 0) + 1

becomes:

counts[item, default: 0] += 1

That makes it easy to do the counting operation in one concise line using forEach:

let arr = ["FOO", "FOO", "BAR", "FOOBAR"]
var counts: [String: Int] = [:]

arr.forEach { counts[$0, default: 0] += 1 }

print(counts)  // "["FOOBAR": 1, "FOO": 2, "BAR": 1]"

---

Swift 4: reduce(into:_:)

Swift 4 introduces a new version of reduce that uses an inout variable to accumulate the results. Using that, the creation of the counts truly becomes a single line:

let arr = ["FOO", "FOO", "BAR", "FOOBAR"]
let counts = arr.reduce(into: [:]) { counts, word in counts[word, default: 0] += 1 }

print(counts)  // ["BAR": 1, "FOOBAR": 1, "FOO": 2]

Or using the default parameters:

let counts = arr.reduce(into: [:]) { $0[$1, default: 0] += 1 }

Finally you can make this an extension of Sequence so that it can be called on any Sequence containing Hashable items including Array, ArraySlice, String, and String.SubSequence:

extension Sequence where Element: Hashable {
    var histogram: [Element: Int] {
        return self.reduce(into: [:]) { counts, elem in counts[elem, default: 0] += 1 }
    }
}

This idea was borrowed from this question although I changed it to a computed property. Thanks to @LeoDabus for the suggestion of extending Sequence instead of Array to pick up additional types.

Examples:

print("abacab".histogram)

> ["a": 3, "b": 2, "c": 1]

print("Hello World!".suffix(6).histogram)

> ["l": 1, "!": 1, "d": 1, "o": 1, "W": 1, "r": 1]

print([1,2,3,2,1].histogram)

> [2: 2, 3: 1, 1: 2]

print([1,2,3,2,1,2,1,3,4,5].prefix(8).histogram)

> [1: 3, 2: 3, 3: 2]

print(stride(from: 1, through: 10, by: 2).histogram)

> [1: 1, 3: 1, 5: 1, 7: 1, 9: 1]

array.filter{$0 == element}.count

With Swift 5, according to your needs, you may choose one of the 7 following Playground sample codes to count the occurrences of hashable items in an array.

---

#1. Using Array's reduce(into:_:) and Dictionary's subscript(_:default:) subscript

let array = [4, 23, 97, 97, 97, 23]
let dictionary = array.reduce(into: [:]) { counts, number in
    counts[number, default: 0] += 1
}
print(dictionary) // [4: 1, 23: 2, 97: 3]

---

#2. Using repeatElement(_:count:) function, zip(_:_:) function and Dictionary's init(_:uniquingKeysWith:)initializer

let array = [4, 23, 97, 97, 97, 23]

let repeated = repeatElement(1, count: array.count)
//let repeated = Array(repeating: 1, count: array.count) // also works

let zipSequence = zip(array, repeated)

let dictionary = Dictionary(zipSequence, uniquingKeysWith: { (current, new) in
	return current + new
})
//let dictionary = Dictionary(zipSequence, uniquingKeysWith: +) // also works

print(dictionary) // prints [4: 1, 23: 2, 97: 3]

---

#3. Using a Dictionary's init(grouping:by:) initializer and mapValues(_:) method

let array = [4, 23, 97, 97, 97, 23]

let dictionary = Dictionary(grouping: array, by: { $0 })

let newDictionary = dictionary.mapValues { (value: [Int]) in
    return value.count
}

print(newDictionary) // prints: [97: 3, 23: 2, 4: 1]

---

#4. Using a Dictionary's init(grouping:by:) initializer and map(_:) method

let array = [4, 23, 97, 97, 97, 23]

let dictionary = Dictionary(grouping: array, by: { $0 })

let newArray = dictionary.map { (key: Int, value: [Int]) in
    return (key, value.count)
}

print(newArray) // prints: [(4, 1), (23, 2), (97, 3)]

---

#5. Using a for loop and Dictionary's subscript(_:) subscript

extension Array where Element: Hashable {
    
    func countForElements() -> [Element: Int] {
        var counts = [Element: Int]()
        for element in self {
            counts[element] = (counts[element] ?? 0) + 1
        }
        return counts
    }
    
}

let array = [4, 23, 97, 97, 97, 23]
print(array.countForElements()) // prints [4: 1, 23: 2, 97: 3]

---

#6. Using NSCountedSet and NSEnumerator's map(_:) method (requires Foundation)

import Foundation

extension Array where Element: Hashable {
    
    func countForElements() -> [(Element, Int)] {
        let countedSet = NSCountedSet(array: self)
        let res = countedSet.objectEnumerator().map { (object: Any) -> (Element, Int) in
            return (object as! Element, countedSet.count(for: object))
        }
        return res
    }
    
}

let array = [4, 23, 97, 97, 97, 23]
print(array.countForElements()) // prints [(97, 3), (4, 1), (23, 2)]

---

#7. Using NSCountedSet and AnyIterator (requires Foundation)

import Foundation

extension Array where Element: Hashable {
	
	func counForElements() -> Array<(Element, Int)> {
		let countedSet = NSCountedSet(array: self)
		var countedSetIterator = countedSet.objectEnumerator().makeIterator()
		let anyIterator = AnyIterator<(Element, Int)> {
			guard let element = countedSetIterator.next() as? Element else { return nil }
			return (element, countedSet.count(for: element))
		}
		return Array<(Element, Int)>(anyIterator)
	}
	
}

let array = [4, 23, 97, 97, 97, 23]
print(array.counForElements()) // [(97, 3), (4, 1), (23, 2)]

---

Credits:

• Swift Idioms
• generic on Collection, using Dictionary

I updated oisdk's answer to Swift2.

16/04/14 I updated this code to Swift2.2

16/10/11 updated to Swift3

---

Hashable:

extension Sequence where Self.Iterator.Element: Hashable {
    private typealias Element = Self.Iterator.Element

    func freq() -> [Element: Int] {
        return reduce([:]) { (accu: [Element: Int], element) in
            var accu = accu
            accu[element] = accu[element]?.advanced(by: 1) ?? 1
            return accu
        }
    }
}

---

Equatable:

extension Sequence where Self.Iterator.Element: Equatable {
    private typealias Element = Self.Iterator.Element

    func freqTuple() -> [(element: Element, count: Int)] {

        let empty: [(Element, Int)] = []

        return reduce(empty) { (accu: [(Element, Int)], element) in
            var accu = accu
            for (index, value) in accu.enumerated() {
                if value.0 == element {
                    accu[index].1 += 1
                    return accu
                }
            }

            return accu + [(element, 1)]
        }
    }
}

---

Usage

let arr = ["a", "a", "a", "a", "b", "b", "c"]
print(arr.freq()) // ["b": 2, "a": 4, "c": 1]
print(arr.freqTuple()) // [("a", 4), ("b", 2), ("c", 1)]

---

for (k, v) in arr.freq() {
    print("\(k) -> \(v) time(s)")
}
// b -> 2 time(s)
// a -> 4 time(s)
// c -> 1 time(s)

for (element, count) in arr.freqTuple() {
    print("\(element) -> \(count) time(s)")
}
// a -> 4 time(s)
// b -> 2 time(s)
// c -> 1 time(s)

Use an NSCountedSet. In Objective-C:

NSCountedSet* countedSet = [[NSCountedSet alloc] initWithArray:array];
for (NSString* string in countedSet)
    NSLog (@"String %@ occurs %zd times", string, [countedSet countForObject:string]);

I assume that you can translate this into Swift yourself.

How about:

func freq<S: SequenceType where S.Generator.Element: Hashable>(seq: S) -> [S.Generator.Element:Int] {
  
  return reduce(seq, [:]) {
    
    (var accu: [S.Generator.Element:Int], element) in
    accu[element] = accu[element]?.successor() ?? 1
    return accu
    
  }
}

freq(["FOO", "FOO", "BAR", "FOOBAR"]) // ["BAR": 1, "FOOBAR": 1, "FOO": 2]

It's generic, so it'll work with whatever your element is, as long as it's hashable:

freq([1, 1, 1, 2, 3, 3]) // [2: 1, 3: 2, 1: 3]

freq([true, true, true, false, true]) // [false: 1, true: 4]

And, if you can't make your elements hashable, you could do it with tuples:

func freq<S: SequenceType where S.Generator.Element: Equatable>(seq: S) -> [(S.Generator.Element, Int)] {
  
  let empty: [(S.Generator.Element, Int)] = []
  
  return reduce(seq, empty) {
    
    (var accu: [(S.Generator.Element,Int)], element) in
    
    for (index, value) in enumerate(accu) {
      if value.0 == element {
        accu[index].1++
        return accu
      }
    }
    
    return accu + [(element, 1)]
    
  }
}

freq(["a", "a", "a", "b", "b"]) // [("a", 3), ("b", 2)]

I like to avoid inner loops and use .map as much as possible. So if we have an array of string, we can do the following to count the occurrences

var occurances = ["tuples", "are", "awesome", "tuples", "are", "cool", "tuples", "tuples", "tuples", "shades"]

var dict:[String:Int] = [:]

occurances.map{
    if let val: Int = dict[$0]  {
        dict[$0] = val+1
    } else {
        dict[$0] = 1
    }
}

prints

["tuples": 5, "awesome": 1, "are": 2, "cool": 1, "shades": 1]

Swift 4

let array = ["FOO", "FOO", "BAR", "FOOBAR"]

// Merging keys with closure for conflicts
let mergedKeysAndValues = Dictionary(zip(array, repeatElement(1, count: array.count)), uniquingKeysWith: +) 

// mergedKeysAndValues is ["FOO": 2, "BAR": 1, "FOOBAR": 1]

An other approach would be to use the filter method. I find that the most elegant

var numberOfOccurenses = countedItems.filter(
{
    if $0 == "FOO" || $0 == "BAR" || $0 == "FOOBAR"  {
        return true
    }else{
        return false
    }
}).count

public extension Sequence {

	public func countBy<U : Hashable>(_ keyFunc: (Iterator.Element) -> U) -> [U: Int] {

	var dict: [U: Int] = [:]
	for el in self {
		let key = keyFunc(el)
		if dict[key] == nil {
			dict[key] = 1
		} else {
			dict[key] = dict[key]! + 1
		}

		//if case nil = dict[key]?.append(el) { dict[key] = [el] }
	}
	return dict
}


let count = ["a","b","c","a"].countBy{ $0 }
// ["b": 1, "a": 2, "c": 1]


struct Objc {
    var id: String = ""
    
}

let count = [Objc(id: "1"), Objc(id: "1"), Objc(id: "2"),Objc(id: "3")].countBy{ $0.id }

// ["2": 1, "1": 2, "3": 1]

extension Collection where Iterator.Element: Comparable & Hashable {
    func occurrencesOfElements() -> [Element: Int] {
        var counts: [Element: Int] = [:]
        let sortedArr = self.sorted(by: { $0 > $1 })
        let uniqueArr = Set(sortedArr)
        if uniqueArr.count < sortedArr.count {
            sortedArr.forEach {
                counts[$0, default: 0] += 1
            }
        }
        return counts
    }
}

// Testing with...
[6, 7, 4, 5, 6, 0, 6].occurrencesOfElements()

// Expected result (see number 6 occurs three times) :
// [7: 1, 4: 1, 5: 1, 6: 3, 0: 1]

You can use this function to count the occurence of the items in array

func checkItemCount(arr: [String]) {       
    var dict = [String: Any]()

    for x in arr {  
        var count = 0 
        for y in arr {
            if y == x {
                count += 1
            }
        }
         
        dict[x] = count
    }

    print(dict)
}

You can implement it like this -

let arr = ["FOO", "FOO", "BAR", "FOOBAR"]
checkItemCount(arr: arr)

import Foundation

var myArray:[Int] = []

for _ in stride(from: 0, to: 10, by: 1) {
    myArray.append(Int.random(in: 1..<6))
}

// Method 1:
var myUniqueElements = Set(myArray)

print("Array: \(myArray)")
print("Unique Elements: \(myUniqueElements)")

for uniqueElement in myUniqueElements {

    var quantity = 0

    for element in myArray {

        if element == uniqueElement {
            quantity += 1
        }
    }
    print("Element: \(uniqueElement), Quantity: \(quantity)")
}

// Method 2:
var myDict:[Int:Int] = [:]

for element in myArray {
    myDict[element] = (myDict[element] ?? 0) + 1
}
print(myArray)

for keyValue in myDict {
    print("Element: \(keyValue.key), Quantity: \(keyValue.value)")
}

First Step in Counting Sort.

var inputList = [9,8,5,6,4,2,2,1,1]
var countList : [Int] = []

var max = inputList.maxElement()!

// Iniate an array with specific Size and with intial value.
// We made the Size to max+1 to integrate the Zero. We intiated the array with Zeros because it's Counting.

var countArray = [Int](count: Int(max + 1), repeatedValue: 0)

for num in inputList{
    countArray[num] += 1
}

print(countArray)

Two Solutions:

1. Using forEach loop

let array = [10,20,10,40,10,20,30]
var processedElements = [Int]()
array.forEach({
    let element = $0
    
    // Check wether element is processed or not
    guard processedElements.contains(element) == false else {
        return
    }
    let elementCount = array.filter({ $0 == element}).count
    print("Element: \(element): Count \(elementCount)")
    
    // Add Elements to already Processed Elements
    processedElements.append(element)
})

2. Using Recursive Function

let array = [10,20,10,40,10,20,30]
self.printElementsCount(array: array)

func printElementsCount(array: [Int]) {
    guard array.count > 0 else {
        return
    }
    let firstElement = array[0]
    let filteredArray = array.filter({ $0 != firstElement })
    print("Element: \(firstElement): Count \(array.count - filteredArray.count )")
    printElementsCount(array: filteredArray)
}