When working with numbers in Kotlin, there may be situations where you need to identify the two smallest numbers from a given list. Whether you are handling data analysis, competitive programming, or simply solving an algorithmic challenge, knowing an efficient way to do this is essential.

In this blog post, we’ll explore how to find the two smallest numbers in a list using Kotlin. We’ll go step by step, ensuring our approach is clear, efficient, and optimized for performance. Let’s get started..!

Understanding the Problem

The goal is simple: Given a list of integers, find and return the two smallest numbers in that list. If the list has fewer than two elements, the program should handle that scenario gracefully.

The Approach

To solve this problem efficiently, we will use a linear scan method. This ensures that our solution runs in O(n) time complexity, making it optimal for large datasets.

Steps to Find the Two Smallest Numbers

1. Initialize Two Variables: Start by setting two variables, smallest and secondSmallest, to the maximum possible integer value (Int.MAX_VALUE).

2. Iterate Through the List: For each number in the list:

• If it is smaller than smallest, update secondSmallest to the current smallest, then update smallest with the new value.
• If it is greater than smallest but smaller than secondSmallest, update secondSmallest.

3. Handle Edge Cases: If the list contains fewer than two unique numbers, return an appropriate message.

Let’s implement this in Kotlin!

Kotlin Implementation

Below is the Kotlin program to find the two smallest numbers from a list:

fun findTwoSmallestNumbers(numbers: List<Int>): Pair<Int, Int>? {
    if (numbers.size < 2) return null // Ensure there are at least 2 numbers
    
    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 if (secondSmallest == Int.MAX_VALUE) null else Pair(smallest, secondSmallest)
}

fun main() {
    val numbers = listOf(7, 3, 9, 1, 4, 2)
    val result = findTwoSmallestNumbers(numbers)

    if (result != null) {
        println("The two smallest numbers are: ${result.first} and ${result.second}")
    } else {
        println("Not enough unique numbers to find two smallest.")
    }
}

Explanation of the Code

Edge Case Handling: The function first checks if the list has fewer than two elements. If so, it returns null.

Initialization: smallest and secondSmallest are initialized to Int.MAX_VALUE to ensure any number in the list will be smaller.

Single Pass Iteration: The list is traversed only once, making this solution efficient.

Conditions to Find the Two Smallest Numbers:

• If the current number is smaller than smallest, update both smallest and secondSmallest.
• If it is greater than smallest but still smaller than secondSmallest, update secondSmallest.

Final Check: If secondSmallest remains Int.MAX_VALUE, it means the list didn’t have enough unique values, so null is returned.

Dry Run & Output

Input:

List: [7, 3, 9, 1, 4, 2]

Dry Run Processing:

1. smallest = 7, secondSmallest = Int.MAX_VALUE
2. 3 is smaller than 7 → Update smallest = 3, secondSmallest = 7
3. 9 is greater than both → No update
4. 1 is smaller than 3 → Update smallest = 1, secondSmallest = 3
5. 4 is greater than 3 → No update
6. 2 is greater than 1 but smaller than 3 → Update secondSmallest = 2

Output:

The two smallest numbers are: 1 and 2

Optimizing the Code

• Time Complexity: O(n) (Single pass through the list)
• Space Complexity: O(1) (Only a few variables are used, no extra data structures)

Alternative Approach (Using Sorting)

Another way to solve this is by sorting the list and picking the first two elements. However, sorting takes O(n log n) time, which is slower than our approach:

val sortedNumbers = numbers.sorted()
val smallestTwo = sortedNumbers.take(2)

While this works, it is less efficient for large lists, making our linear approach the better choice.

Conclusion

Finding the two smallest numbers in a list is a common problem in programming. Using the approach discussed above, we can solve this problem efficiently with just one pass through the list. The key takeaways from this guide are:

• Always consider edge cases, such as lists with fewer than two numbers.
• Optimize performance by using a single iteration where possible.
• Keep code readable and well-structured for easy debugging and maintenance.

This implementation follows best coding practices, making it suitable for real-world applications. Try modifying the code with different test cases to deepen your understanding.