Kotlin Ranges

In Kotlin, ranges define a sequence of values with a start, an end, and an optional step. Ranges are widely used with loops, conditions, and collections to simplify iteration and value checking.

1. Why use Ranges?

Ranges make your code concise, readable, and expressive. Instead of manually checking or looping through numbers, Kotlin lets you define a range using simple syntax.

• They simplify iteration with for loops.
• They are easy to read and prevent off-by-one errors.
• They can represent both increasing and decreasing sequences.
• They work seamlessly with conditional checks like if (x in 1..10).

2. How to use? Examples

// Simple numeric range
for (i in 1..5) {
    print("$i ")
}
// Output: 1 2 3 4 5

// Using 'downTo'
for (i in 5 downTo 1) {
    print("$i ")
}
// Output: 5 4 3 2 1

// Using 'step'
for (i in 1..10 step 2) {
    print("$i ")
}
// Output: 1 3 5 7 9

// Exclusive range using 'until'
for (i in 1 until 5) {
    print("$i ")
}
// Output: 1 2 3 4

3. Types of Ranges

• .. → Inclusive range (includes both start and end).
• until → Exclusive of the end value.
• downTo → Creates a descending range.
• step → Changes the increment or decrement value.

4. When to use and when not?

• Use when: You need to iterate through numbers or characters in order.
• Use when: You want readable, predictable loops without manual index tracking.
• Do not use when: You are iterating over dynamic collections or data streams — prefer forEach or functional operations instead.
• Do not use when: Performance-critical scenarios require tight control over index manipulation.

5. Complex Examples

// Check if a value lies in a range
val score = 87
if (score in 80..100) {
    println("Excellent!")
} else {
    println("Keep trying!")
}

// Character ranges
for (ch in 'a'..'f') {
    print("$ch ")
}
// Output: a b c d e f

// Using ranges in conditions
val age = 25
when (age) {
    in 0..12 -> println("Child")
    in 13..19 -> println("Teenager")
    in 20..60 -> println("Adult")
    else -> println("Senior")
}

// Nested ranges
for (x in 1..3) {
    for (y in 1..2) {
        println("x=$x, y=$y")
    }
}

6. When not to use ranges (Pitfalls)

• Large numeric ranges like 1..1_000_000_000 can consume memory or slow performance if iterated directly.
• Ranges are immutable — they don’t update automatically when start or end values change.
• Not suitable for non-sequential datasets (e.g., lists with gaps or custom iteration rules).

7. Interview Questions

• What is the difference between .. and until in Kotlin?
• How do you create a descending range?
• What is the use of the step function?
• Can you create a range of characters in Kotlin? How?
• What happens if you use in with a range?
• When should you avoid using ranges?

8. Summary Table

9. Example Program

fun main() {
    val numbers = 1..10
    println("Numbers in range: ${numbers.joinToString()}")

    val evenNumbers = (2..10 step 2).toList()
    println("Even numbers: $evenNumbers")

    for (i in 10 downTo 1 step 3) {
        println("Counting down: $i")
    }

    val charRange = 'A'..'E'
    println("Characters: ${charRange.joinToString()}")
}

Output:

Numbers in range: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Even numbers: [2, 4, 6, 8, 10]
Counting down: 10
Counting down: 7
Counting down: 4
Counting down: 1
Characters: A, B, C, D, E