+Sean Allen
Hey, I refactored my solution I commented earlier. This time I used an NSCountedSet  to have a count of how many times an element appeared and compared it to the maximum recorded number. The solution is pretty straightforward IMO, please let me know what you think.

func elements(colors: [String]) ->[String]{
    let set = NSCountedSet(array: colors)
    var max = 1
    var stringArray = [String]()
    
    for case let color as String in set{
        
        if set.count(for: color) > max{
            stringArray.removeAll()
            stringArray.append(color)
            max = set.count(for: color)
        }
        else if set.count(for: color) == max{
            stringArray.append(color)
            
        }
    }
    return stringArray
}
elements(colors: [“red”, “blue”, “red”, “green”, “yellow”, “blue”, “red”, “blue”, “green”])

Here’s my one loop attempt:
import Foundation

var colors = [“red”, “blue”, “red”, “blue”, “yello”, “blue”, “green”, “red”]

var maxCount = 0
var topArray = [String]()

let countDictionary = colors.reduce(into: [String: Int]()) {
$0[$1, default: 0] += 1
if let count = $0[$1], count > maxCount {
topArray = [$1]
maxCount = count
} else if $0[$1] == maxCount {
topArray.append($1)
}
}

print(countDictionary)
print(topArray) // here is the answer

func getMostCommonColor(array: [String]) -> [String] {
let uniqueColors = Set(array)
typealias ColorFrequency = (color: String, count: Int)
var colorFrequencies: [ColorFrequency] = []

for color in uniqueColors {
let colorFreq = ColorFrequency(color: color, count: array.filter{$0 == color}.count)
colorFrequencies.append(colorFreq)
}

let maxFrequency = colorFrequencies.max(by: {$0.1 < $1.1}).map{$0.count} return colorFrequencies.filter{$0.count == maxFrequency}.map{$0.color} } getMostCommonColor(array: colorArray)

hey allen ive been a fan of yours for a while now. is there any way I can contact you regarding a hw Im working on? im having problems adding an element to an array from a detail view. Its overriding the last element in the array and idk wtf is going on ive been trying to solve this for 2 days now! thankssss

Genuinely so refreshing to find someone teaching Swift & iOS development with clarity and a bit of enthusiasm! Have already learnt so much from you. Thank you and please don’t stop! If I start making some money from iOS development in future I will definitely support your Patreon, but for now, the best I can do is subscribe here on YouTube. 🙂

Hey Sean, great tutorial very well done. Just to add for bit more medium level iOS Developers instead of doing the second for loop, I would do something as it follows:

func getMostCommonColor(array: [String]) -> [String] {
    
    var topColors: [String] = []
    var colorDictionary: [String: Int] = [:]
    
    for color in array {
        if let count = colorDictionary[color] {
            colorDictionary[color] = count + 1
        } else {
            colorDictionary[color] = 1
        }
    }
    
    let highestValue = colorDictionary.values.max()
    
    let colors = colorDictionary.filter { (color, count) -> Bool in
        return count == highestValue
    }
    
    topColors = colors.map{$0.key}
    
    return topColors
}

Using bit of functional programming shows a bit of knowledge on it which i suppose it gives good impression. Let me know what you think.

Seems like you could use “reduce” for color counts.

Someone please correct me if I’m wrong, but I don’t think you need to iterate over the values in the dictionary at all, just keep 2 local variables called max element and max count and check that through each iteration. This would be a true O(n) and not O(n+k) (where k is the number of elements that are duplicates). Also it might be worth noting in the interview that this requires O(n) space complexity (in case there are possible solutions that are 0(1) space complexity. Here’s what mine looks like:

func mostCommonElement(_ elems: [T]) -> T? {
var maxCount: Int = 0
var maxElement: T? = nil
var map: [T: Int] = [:]
for elem in elems {
if let occurrence = map[elem] {
map[elem] = occurrence + 1
} else {
map[elem] = 1
}
if map[elem]! > maxCount {
maxElement = elem
maxCount = map[elem]!
}
}
return maxElement
}

You could also create an extension to Array.

colors.mostCommonElement()

extension Array where Element: Hashable {
    func mostCommonElement() -> [Element] {
        
        var topElements = [Element]()
        var amountPerElement = [Element: Int]()
        
        self.forEach { item in
            if let count = amountPerElement[item] {
                amountPerElement[item] = count + 1
            } else {
                amountPerElement[item] = 1
            }
        }
        
        let max = amountPerElement.values.max()
        
        for (item, count) in amountPerElement {
            if amountPerElement[item] == max {
                topElements.append(item)
            }
        }
        return topElements
    }
}

Hey Sean, I think you could also solve this problem using MapReduce, like in this tutorial https://useyourloaf.com/blog/swift-guide-to-map-filter-reduce/
Could you solve the same problem using this if that is possible?

Good solution. I got a couple of tips for ya.

Depending on the role/company you’re going for, you mightn’t be allowed to use Swift’s Dictionary functionalities such as iterating through a dictionary. I personally assume that I’m writing code which has limited functionality, such as C or Java, but with Swift syntax.
 Instead of the second array iteration, you could use two variables (topCount, topColor) which keeps record of the most common count of each element and then change/append the output array if its higher/same.

You also might want to state the time/space complexity for extra browny points.

Also, don’t forget to validate your input data. Checking for empty arrays and throwing an exception, etc…

Sean++

This one is a tad shorter, 8 lines instead of 17. (Did not count whitespace 😉

func getMostCommonColor(array:[String]) -> String {
      var counters = [String: Int]()
      for c in array {
          counters[c] = (counters[c] ?? 0) + 1
      }
     let maxElement = counters.reduce(counters.first!) { $1.1 > $0.1 ? $1 : $0 }
     return maxElement.0
}

  If one would return a list of all the colors sorted by popularity, one could just

return counters.reduce(counters.first!) { $1.1 > $0.1 ? $1 : $0 }

thus shaving off another line of code.

 Anyway, great videos, keep em coming! 🙂

It would be interesting to do this without calling max on the values but instead updating the highest value as you loop through each color in the dictionary. I might try it. Great video!

probably it doesn’t make any difference in execution time, but what about shorter form like this?
colors.forEach { (color) in
colorsDictionary[color] = (colorsDictionary[color] ?? 0) + 1
}

let colorArray : [String] = [“red”, “green”, “red”, “blue”,”green”];

func mostcommonColor(colors : [String]) -> [String]{
let colorsWithCount = colors.map{($0, 1)}
let colors = Dictionary(colorsWithCount, uniquingKeysWith: +)
let maxValue = colors.values.max()
return Array(colors.filter({$0.value == maxValue}).keys)
}

print(mostcommonColor(colors: colorArray))