Kotlin Progression

Introduction

In Kotlin, a Progression represents a sequence of values generated by a regular incrementing step, and it can be used to iterate over ranges of numbers and characters. Progressions are often used in loops and are a generalization of ranges. There are different types of progressions, such as IntProgression, LongProgression, and CharProgression.

Table of Contents

1. What is Progression?
2. Creating a Progression
3. Common Operations
4. Examples of Progression
5. Real-World Use Case
6. Conclusion

1. What is Progression?

A Progression in Kotlin defines a sequence of values starting from a specified value, incremented by a step value, and ending at a specified value. It is used to represent ordered sequences where the difference between consecutive values is constant.

Syntax

class IntProgression : Iterable<Int>
class LongProgression : Iterable<Long>
class CharProgression : Iterable<Char>

2. Creating a Progression

You can create progressions using the .. operator combined with the step function for numbers and characters.

Example

val intProgression: IntProgression = 1..10 step 2
val charProgression: CharProgression = 'a'..'z' step 2

3. Common Operations

Progressions support various operations such as iteration, checking if a value is within the progression, and reversing the progression.

Iteration

You can iterate over a progression using a for loop.

for (i in 1..10 step 2) {
    println(i)
}

Checking Membership

You can check if a value lies within a progression using the in operator.

val inProgression = 5 in (1..10 step 2) // false

Other Operations

• first: Returns the first value in the progression.
• last: Returns the last value in the progression.
• step: Returns the step value for the progression.
• reversed(): Returns a progression with elements in reverse order.

4. Examples of Progression

Example 1: Iterating Over an IntProgression

This example demonstrates how to iterate over an integer progression.

fun main() {
    for (i in 1..10 step 2) {
        println(i)
    }
}

Output:

1
3
5
7
9

Explanation:
This example iterates over the progression 1..10 with a step value of 2, printing every second number.

Example 2: Checking if a Value is Within a Progression

This example demonstrates how to check if a value is within a specified progression.

fun main() {
    val progression = 1..10 step 2
    val number = 5
    if (number in progression) {
        println("$number is within the progression.")
    } else {
        println("$number is outside the progression.")
    }
}

Output:

5 is outside the progression.

Explanation:
This example checks if the value 5 is within the progression 1..10 with a step value of 2.

Example 3: Using Step in a Progression

This example demonstrates how to use a step value in a progression.

fun main() {
    for (i in 1..10 step 3) {
        println(i)
    }
}

Output:

1
4
7
10

Explanation:
This example iterates over the progression 1..10 with a step value of 3, printing every third number.

Example 4: Reversing a Progression

This example demonstrates how to reverse a progression.

fun main() {
    for (i in (1..5).reversed()) {
        println(i)
    }
}

Output:

5
4
3
2
1

Explanation:
This example reverses the progression 1..5 and iterates over it in reverse order.

Example 5: Iterating Over a CharProgression

This example demonstrates how to iterate over a progression of characters.

fun main() {
    for (c in 'a'..'e' step 2) {
        println(c)
    }
}

Output:

a
c
e

Explanation:
This example iterates over the progression of characters from 'a' to 'e' with a step value of 2 and prints each character.

5. Real-World Use Case: Validating Step Progression

You can use progressions to validate step progression in tasks like generating a sequence of dates or IDs.

Example: Validating Step Progression

fun isValidStepProgression(start: Int, end: Int, step: Int): Boolean {
    val progression = start..end step step
    return end in progression
}

fun main() {
    val start = 1
    val end = 10
    val step = 2
    if (isValidStepProgression(start, end, step)) {
        println("The step progression is valid.")
    } else {
        println("The step progression is invalid.")
    }
}

Output:

The step progression is invalid.

Explanation:
This example checks if a step progression from 1 to 10 with a step value of 2 is valid by verifying if the end value is included in the progression.

Conclusion

The Progression class in Kotlin is a powerful and flexible way to represent and manipulate sequences of values with a regular step. It is part of the Kotlin standard library and provides essential operations for iteration, membership checking, and more. Understanding and utilizing the Progression class can greatly enhance your ability to work with ordered sequences and intervals in Kotlin.