Sequence creation methods in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a Sequence in Kotlin?

A Sequence in Kotlin is a lazily evaluated collection of elements. It processes elements one by one, which helps with performance when working with large or infinite data.

beginner

How do you create a Sequence from a List in Kotlin?

You can create a Sequence from a List by calling asSequence() on the list. For example: val seq = listOf(1, 2, 3).asSequence().

beginner

What does the sequenceOf() function do?

The sequenceOf() function creates a Sequence from the given elements. For example: sequenceOf(1, 2, 3) creates a Sequence of three numbers.

intermediate

Explain the generateSequence() function in Kotlin.

The generateSequence() function creates a Sequence by repeatedly calling a function to produce the next element until it returns null. It can create infinite or finite sequences.

intermediate

How can you create an infinite Sequence of numbers starting from 1?

Use generateSequence(1) { it + 1 }. This creates a Sequence starting at 1 and adds 1 to get the next element forever.

Which Kotlin function creates a Sequence from a collection?

A sequenceFrom()

B toSequence()

C asSequence()

D makeSequence()

The correct function is asSequence(), which converts a collection like a List into a Sequence.

What does sequenceOf(1, 2, 3) return?

A A Sequence of 1, 2, 3

B A List of 1, 2, 3

C An Array of 1, 2, 3

D A Set of 1, 2, 3

sequenceOf() creates a Sequence containing the given elements.

What happens if the lambda in generateSequence() returns null?

A The sequence restarts

B The sequence continues infinitely

C An error is thrown

D The sequence ends

When the lambda returns null, generateSequence stops producing elements and the sequence ends.

Which of these is a benefit of using Sequences in Kotlin?

A Lazy evaluation to improve performance

B Sequences store elements in arrays

C Sequences are mutable collections

D Eager evaluation of all elements

Sequences evaluate elements lazily, which can improve performance especially with large or infinite data.

How do you create an infinite sequence of even numbers starting from 0?

A sequenceOf(0, 2, 4, 6)

B generateSequence(0) { it + 2 }

C listOf(0, 2, 4, 6).asSequence()

D generateSequence(2) { it * 2 }

generateSequence(0) { it + 2 } creates an infinite sequence starting at 0, adding 2 each time.

Describe three ways to create a Sequence in Kotlin and when you might use each.

Think about converting existing collections, creating from fixed elements, and generating sequences dynamically.

Explain why lazy evaluation in Sequences is useful compared to eager collections.

Consider how sequences handle data differently than lists or arrays.

Practice

1. Which of the following is the correct way to directly create a sequence from a fixed set of values in Kotlin?

easy

A. val seq = sequenceOf(1, 2, 3)

B. val seq = listOf(1, 2, 3).asSequence()

C. val seq = arrayOf(1, 2, 3).toSequence()

D. val seq = sequence(1, 2, 3)

Solution

1. Step 1: Understand sequence creation from fixed values

   The function sequenceOf() creates a sequence directly from given values.

2. Step 2: Check each option's validity

   val seq = sequenceOf(1, 2, 3) uses sequenceOf(1, 2, 3), which is correct. val seq = listOf(1, 2, 3).asSequence() creates a list then converts to sequence, which is valid but not direct creation. val seq = arrayOf(1, 2, 3).toSequence() uses a non-existent toSequence() method on array, which is invalid. val seq = sequence(1, 2, 3) uses sequence() which is not a valid function for this purpose.

3. Final Answer:

   val seq = sequenceOf(1, 2, 3) -> Option A

4. Quick Check:

   Direct sequence creation = sequenceOf(...) [OK]

Hint: Use sequenceOf() to create sequences from fixed values [OK]

Common Mistakes:

• Using non-existent toSequence() on arrays
• Confusing sequenceOf() with sequence()
• Trying to create sequence directly from array without conversion

2. Which of the following is the correct syntax to create a sequence from a range in Kotlin?

easy

A. val seq = (1..5).toSequence()

B. val seq = sequence(1..5)

C. val seq = (1..5).asSequence()

D. val seq = sequenceOf(1..5)

Solution

1. Step 1: Identify how to convert a range to a sequence

   Ranges in Kotlin can be converted to sequences using the asSequence() extension function.

2. Step 2: Evaluate each option's syntax

   val seq = (1..5).asSequence() uses (1..5).asSequence(), which is correct. val seq = (1..5).toSequence() uses toSequence() which does not exist for ranges. val seq = sequence(1..5) uses sequence(1..5) which is invalid syntax. val seq = sequenceOf(1..5) creates a sequence of a single range object, not elements.

3. Final Answer:

   val seq = (1..5).asSequence() -> Option C

4. Quick Check:

   Range to sequence = asSequence() [OK]

Hint: Use asSequence() to convert ranges to sequences [OK]

Common Mistakes:

• Using toSequence() which does not exist
• Passing range directly to sequence() function
• Using sequenceOf() with a range as single element

3. What will be the output of the following Kotlin code?

val seq = generateSequence(1) { it + 2 }.take(4).toList()
println(seq)

medium

A. [1, 3, 5, 7]

B. [1, 2, 3, 4]

C. [2, 4, 6, 8]

D. [1, 3, 5]

Solution

1. Step 1: Understand generateSequence with lambda

   The sequence starts at 1, then each next element is previous + 2, so elements are 1, 3, 5, 7, ...

2. Step 2: Apply take(4) and convert to list

   Taking first 4 elements gives [1, 3, 5, 7]. Printing this list outputs exactly that.

3. Final Answer:

   [1, 3, 5, 7] -> Option A

4. Quick Check:

   Sequence increments by 2 starting at 1 = [1, 3, 5, 7] [OK]

Hint: generateSequence(start) { it + step } creates arithmetic sequence [OK]

Common Mistakes:

• Confusing take(4) with takeWhile
• Assuming sequence increments by 1 instead of 2
• Forgetting to convert sequence to list before printing

4. Identify the error in the following Kotlin code that tries to create a sequence of even numbers starting from 2:

val seq = generateSequence(2) { it + 2 }
val firstThree = seq.take(3).toList()
println(firstThree)

medium

A. generateSequence requires a nullable lambda return type

B. take() does not exist for sequences

C. toList() cannot be called on a sequence

D. No error; code works correctly

Solution

1. Step 1: Check generateSequence usage

   The code uses generateSequence with a start value and lambda to add 2 each time, which is valid.

2. Step 2: Verify take() and toList() usage

   Sequences support take() to limit elements and toList() to convert to list. Both are valid here.

3. Final Answer:

   No error; code works correctly -> Option D

4. Quick Check:

   generateSequence + take + toList = valid sequence creation [OK]

Hint: generateSequence with non-null lambda works fine [OK]

Common Mistakes:

• Thinking lambda must return nullable type
• Believing toList() is invalid on sequences
• Assuming take() is not available for sequences

5. You want to create a sequence of Fibonacci numbers up to 100 using generateSequence. Which of the following code snippets correctly implements this?

hard

A. val fibSeq = generateSequence(0) { it + it - 1 }
val result = fibSeq.takeWhile { it <= 100 }.toList()

B. val fibSeq = generateSequence(Pair(0, 1)) { (a, b) -> if (b <= 100) Pair(b, a + b) else null }
val result = fibSeq.map { it.first }.toList()

C. val fibSeq = sequenceOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144)
val result = fibSeq.filter { it <= 100 }.toList()

D. val fibSeq = generateSequence(0 to 1) { (a, b) -> Pair(b, a + b) }
val result = fibSeq.map { it.second }.takeWhile { it <= 100 }.toList()

Solution

1. Step 1: Understand Fibonacci sequence generation with generateSequence

   We use a Pair to hold two consecutive Fibonacci numbers. The lambda returns next pair if next number is ≤ 100, else null to stop.

2. Step 2: Analyze each option

   val fibSeq = generateSequence(Pair(0, 1)) { (a, b) -> if (b <= 100) Pair(b, a + b) else null }
   val result = fibSeq.map { it.first }.toList()

   correctly uses Pair and stops at 100, then maps to first element for Fibonacci numbers.

   val fibSeq = generateSequence(0) { it + it - 1 }
   val result = fibSeq.takeWhile { it <= 100 }.toList()

   uses incorrect formula.

   val fibSeq = sequenceOf(0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144)
   val result = fibSeq.filter { it <= 100 }.toList()

   hardcodes values but includes 144 which is > 100.

   val fibSeq = generateSequence(0 to 1) { (a, b) -> Pair(b, a + b) }
   val result = fibSeq.map { it.second }.takeWhile { it <= 100 }.toList()

   maps to second element and takes while ≤ 100, but first element 0 is missed and sequence never stops (infinite).

3. Final Answer:

   generateSequence(Pair(0, 1)) { (a, b) -> if (b <= 100) Pair(b, a + b) else null }.map { it.first }.toList() -> Option B

4. Quick Check:

   generateSequence with Pair and null stop = correct Fibonacci [OK]

Hint: Use Pair and null to stop generateSequence for Fibonacci [OK]

Common Mistakes:

• Not stopping sequence with null when limit exceeded
• Incorrect Fibonacci formula in lambda
• Including numbers beyond limit in hardcoded sequences