Backward Ranges in Kotlin: Using downTo and step

Kotlin's .. operator creates an ascending range, so 100..1 is empty and the loop does not run. To count downward, use downTo, optionally combined with step to skip values.

Kotlin ranges describe a sequence of values between two endpoints. The range operator, .., is designed for ascending ranges:

1..5

This includes 1, 2, 3, 4, and 5.

Because an ascending range starts at the left value and moves upward, this range has no values:

100..1

There is no way to start at 100, keep increasing, and arrive at 1. Kotlin therefore treats it as an empty range.

Use downTo when the values should decrease:

100 downTo 1

downTo creates a descending progression, including both endpoints. This matters whenever order is important—for example, processing recent items first, counting down a timer, or removing list items from the end.

Think of a range as directions for walking along numbered stairs.

• 1..5 means: start on stair 1 and walk up until stair 5.
• 5 downTo 1 means: start on stair 5 and walk down until stair 1.
• 5..1 means: start at stair 5 and walk upward to reach stair 1. That destination is behind you, so there are no steps to take.

The operator you choose determines the direction of travel.

Use downTo between two integer values:

for (n in 100 downTo 1) {
    println(n)
}

Output begins with:

100
99
98
...
1

Both endpoints are included. The loop variable starts as 100, decreases by 1 on each iteration, and ends after printing 1.

Count backward with a larger step

Add step to control how far the loop moves each time:

for (n in 20 downTo 0 step 5) {
    println(n)
}

Output:

20
15
10
5
0

step 5 means subtract 5 after each iteration.

Store the progression first

A descending progression can be assigned to a variable and reused:

val countdown = 10 downTo 1

for (number in countdown) {
    println(number)
}

Consider this loop:

for (n in 5 downTo 1 step 2) {
    println(n)
}

Execution proceeds as follows:

1. 5 downTo 1 creates a descending progression whose bounds are 5 and 1.
2. step 2 says to decrease by 2 each time.
3. The first iteration assigns 5 to n, so the program prints 5.
4. The next value is 3, so it prints 3.
5. The next value is 1, so it prints 1.
6. The next calculated value would be -1, which is below the ending bound of 1.
7. The loop stops.

Output:

5
3
1

By contrast, this loop has zero iterations:

for (n in 5..1) {
    println(n)
}

5..1 is an empty ascending range.

Descending progressions are useful when a task naturally starts at a high value and moves lower.

• Countdown timers: display 10 down to 0 before starting an action.
• Reverse array processing: visit indexes from the last element to the first.
• Removing items by index: remove matching items from the end so earlier indexes do not shift before they are processed.
• Recent-first output: show newer numbered records before older ones.
• Retry attempts: report remaining attempts from a maximum value down to zero.

Example: printing an array in reverse order by its indexes:

val names = listOf("Ada", "Grace", "Linus")

for (index in names.lastIndex downTo 0) {
    println(names[index])
}

Output:

Linus
Grace
Ada

In production Kotlin code, downTo is often used for index-based work where reverse order is required.

Remove list elements safely from the end

When removing by index, iterate backward. Removing from the front can cause later elements to shift left and be skipped.

val scores = mutableListOf(10, -1, 20, -5, 30)

for (index in scores.lastIndex downTo 0) {
    if (scores[index] < 0) {
        scores.removeAt(index)
    }
}

println(scores) // [10, 20, 30]

Prefer collection operations when no index is needed

If you only want values in reverse order, a collection operation is often clearer than managing indexes manually:

val names = listOf("Ada", "Grace", "Linus")

names.asReversed().forEach { name ->
    println(name)
}

Use downTo when you genuinely need an index, a numeric countdown, or precise control over the step size.

Expecting 100..1 to count backward

This code compiles, but prints nothing:

for (n in 100..1) {
    println(n)
}

Use downTo instead:

for (n in 100 downTo 1) {
    println(n)
}

Assuming the end value is excluded

downTo includes both bounds:

for (n in 3 downTo 1) {
    print("$n ")
}
// 3 2 1

If you need to stop before 1, use 2 as the lower bound or use a condition that matches the intended result.

Using an invalid step direction

A descending progression needs a positive step amount:

// Incorrect: throws IllegalArgumentException
// for (n in 10 downTo 1 step -2) { }

Write step 2, not step -2:

for (n in 10 downTo 1 step 2) {
    println(n)
}

Accessing an empty list with lastIndex downTo 0

For an empty list, lastIndex is -1. The progression -1 downTo 0 is empty, so a for loop is safe. However, do not access an element before checking that the list has one:

val items = emptyList<String>()

for (index in items.lastIndex downTo 0) {
    println(items[index])
}

This loop simply does not run.

.. and downTo both include their boundary values. until differs because it excludes its ending value.

For example:

println((0 until 3).toList())    // [0, 1, 2]
println((3 downTo 0).toList())  // [3, 2, 1, 0]

// Ascending, inclusive
for (n in 1..5) { }

// Descending, inclusive
for (n in 5 downTo 1) { }

// Descending with a step of 2
for (n in 10 downTo 0 step 2) { }

// Ascending, end excluded
for (index in 0 until items.size) { }

// Reverse indexes of a list or array
for (index in items.lastIndex downTo 0) { }

Key rules:

• start..end is ascending only.
• If start > end, start..end is empty.
• start downTo end is descending.
• downTo includes the start and end values.
• step must be a positive number.
• Use lastIndex downTo 0 when you need reverse indexes.

Does 100..1 work as a backward range in Kotlin?

No. It creates an empty ascending range, so a for loop over it does not execute. Use 100 downTo 1.

Does downTo include the final number?

Yes. 5 downTo 1 produces 5, 4, 3, 2, 1.

How do I count backward by two in Kotlin?

Use step:

for (n in 10 downTo 0 step 2) {
    println(n)
}

Can I use downTo with list indexes?

Yes. A common pattern is:

for (index in items.lastIndex downTo 0) {
    println(items[index])
}

Is downTo a range?

It is commonly used like a range, but Kotlin represents it as a descending numeric progression. For for loops, it behaves as the sequence of descending values you expect.

What should I use to reverse a collection when I do not need indexes?

Use a collection-oriented approach such as asReversed() or reversed(). Use downTo when you need numeric indexes or custom stepping.

• Kotlin ranges (..) — The ascending counterpart to downTo.
• Kotlin until — Creates an ascending range that excludes its ending value.
• Kotlin step — Changes the increment or decrement between progression values.
• Kotlin for loops — Iterate over ranges, progressions, and collections.
• List indexes and lastIndex — Useful for safely traversing a list backward.
• Kotlin collection transformations — Methods such as reversed() and asReversed() can be clearer when indexes are unnecessary.