When working with lists in Kotlin, a common task is to find the two smallest numbers. Whether you’re solving coding challenges, optimizing algorithms, or simply manipulating data, knowing how to efficiently extract the smallest elements is useful.

In this blog, we’ll explore different ways to find the two smallest numbers in a Kotlin list. We’ll keep it simple, efficient, and easy to understand. Let’s dive in..!

Understanding the Problem

Given a list of numbers, our goal is to identify the two smallest values and return them in ascending order. For example:

val numbers = listOf(5, 2, 9, 1, 7, 3)
// Expected output: 1, 2

Now, let’s explore different ways to achieve this in Kotlin.

1. Using sorted()

The simplest way to find the two smallest numbers in a Kotlin list is by sorting the list and picking the first two elements.

fun findTwoSmallest(numbers: List<Int>): Pair<Int, Int>? {
    if (numbers.size < 2) return null // Ensure the list has at least two elements
    val sortedNumbers = numbers.sorted()
    return Pair(sortedNumbers[0], sortedNumbers[1])
}

fun main() {
    val numbers = listOf(5, 2, 9, 1, 7, 3)
    val result = findTwoSmallest(numbers)
    println(result) // Output: (1, 2)
}

Here,

• We first check if the list contains at least two elements to avoid errors.
• The sorted() function arranges the numbers in ascending order.
• We return the first two elements as a Pair.

Time Complexity: O(n log n) due to sorting.

2. Using a Single Pass (Efficient Approach)

Sorting works well but isn’t the most efficient way. We can improve performance by scanning the list just once.

fun findTwoSmallestEfficient(numbers: List<Int>): Pair<Int, Int>? {
    if (numbers.size < 2) return null
    
    var smallest = Int.MAX_VALUE
    var secondSmallest = Int.MAX_VALUE
    
    for (num in numbers) {
        if (num < smallest) {
            secondSmallest = smallest
            smallest = num
        } else if (num < secondSmallest && num != smallest) {
            secondSmallest = num
        }
    }
    
    return Pair(smallest, secondSmallest)
}

fun main() {
    val numbers = listOf(5, 2, 9, 1, 7, 2, 1, 3, 2, 3) 
    val result = findTwoSmallestEfficient(numbers)
    println(result) // Output: (1, 2)
}

We initialize two variables (smallest and secondSmallest) to the largest possible integer values.

We iterate through the list once:

• If a number is smaller than smallest, it becomes the new smallest, and the previous smallest moves to secondSmallest.
• Otherwise, If number is greater than smallest but still smaller than secondSmallest, update secondSmallest.
• This approach avoids sorting, making it much faster.

Time Complexity: O(n), since we only scan the list once.

3. Using minOrNull() and minus()

Kotlin provides built-in functions to make this task even simpler.

fun findTwoSmallestFunctional(numbers: List<Int>): Pair<Int, Int>? {
    val firstMin = numbers.minOrNull() ?: return null
    val secondMin = numbers.filter { it != firstMin }.minOrNull() ?: return null
    return Pair(firstMin, secondMin)
}

fun main() {
    val numbers = listOf(5, 2, 9, 1, 7, 3)
    val result = findTwoSmallestFunctional(numbers)
    println(result) // Output: (1, 2)
}

Here,

• We find the smallest number using minOrNull().
• We then filter out the smallest number and find the next smallest using minOrNull() again.
• This method is concise but slightly less efficient than the single-pass method.

Time Complexity: O(n) for filtering + O(n) for finding the min → Overall, O(n).

Which Method Should You Use?

Conclusion

In this blog, we explored multiple ways to find the two smallest numbers in a Kotlin list. We covered sorting, a highly efficient single-pass approach, and a functional-style solution. Each method has its trade-offs in terms of readability and performance.