Efficient Element Counting with Kotlin's HashMaps | CodeSignal Learn

Efficient Element Counting with Kotlin's HashMaps | CodeSignal Learn

Topic Overview

In this lesson, we will explore the concept and practical application of HashMaps in Kotlin. HashMaps are a powerful and efficient data structure used for storing key-value pairs. You will learn how to utilize HashMap to count the frequency of elements in a collection, understand the underlying mechanics, and analyze the time and space efficiency of this approach. This lesson includes a step-by-step demonstration with detailed code examples and a discussion on the practical applications of using HashMap s for counting occurrences in various contexts.

Understanding the Problem

We begin in a library, where we want to count book copies. With a small collection, we might be able to tally each one manually. However, as the collection grows, this approach becomes cumbersome and inefficient. A more efficient method uses a HashMap . For a quick illustration, consider this list of colors: Kotlin fun main() {val colors = listOf("red", "blue", "red", "green", "blue", "blue")} If we count manually, red appears twice, blue appears thrice, and green appears once. We can employ HashMap s for a more efficient counting process.

Introducing HashMaps

Understanding the Above Solution

Sign up

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Simple yet powerful, HashMaps allow us to store and retrieve data using keys. The unique colors in our list act as keys, and the count of each color becomes its corresponding value. Let's demonstrate how we can count elements in our colors list using Kotlin's MutableMap:

Kotlin

fun main() {
    val colors = listOf("red", "blue", "red", "green", "blue", "blue")
    val colorMap: MutableMap<String, Int> = mutableMapOf()

    // Start the loop to iterate over each color
    for (color in colors) {
        if (colorMap.containsKey(color)) {
            colorMap[color] = colorMap[color]!! + 1
        } else {
            colorMap[color] = 1
        }
    }

    // Print our map with counts
    for ((key, value) in colorMap) {
        println("$key: $value")
    }
}

When the above code executes, it displays the counts for each color:

red: 2
green: 1
blue: 3

Here's how we created a HashMap to count our elements:

We began with an empty MutableMap. Then, we went through our list, and for every occurring element, we simply incremented its value in the Map. If the element was not already in the Map, it would be added with an initial value of 1.

In Kotlin, we can make this more concise by using the getOrPut method:

Kotlin

fun main() {
    val colors = listOf("red", "blue", "red", "green", "blue", "blue")
    val colorMap: MutableMap<String, Int> = mutableMapOf()

    // Iterate over each color and increase its count
    for (color in colors) {
        colorMap[color] = colorMap.getOrPut(color) { 0 } + 1
    }

    // Print our map with counts
    for ((key, value) in colorMap) {
        println("$key: $value")
    }
}

The getOrPut method simplifies the code by handling default values. Here’s how it works:

colorMap.getOrPut(color) { 0 } checks if the color is a key in the Map.
If color is present, it retrieves its current count.
If color is absent, getOrPut initializes it with the value 0.

This method eliminates the need for checking with containsKey, making the code cleaner and more concise. The solution efficiently counts elements, emphasizing efficiency as the list size grows!