Take, drop, and chunked in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the take(n) function do in Kotlin collections?

It returns the first n elements from a collection. If the collection has fewer than n elements, it returns the whole collection.

beginner

Explain the purpose of the drop(n) function in Kotlin.

It returns a list without the first n elements. If the collection has fewer than n elements, it returns an empty list.

beginner

What does the chunked(size) function do in Kotlin?

It splits a collection into smaller lists (chunks) each of the given size. The last chunk may be smaller if there are not enough elements.

beginner

How would you get the first 3 elements of a list listOf(1, 2, 3, 4, 5) using Kotlin?

Use listOf(1, 2, 3, 4, 5).take(3) which returns [1, 2, 3].

beginner

What is the result of listOf(1, 2, 3, 4, 5).drop(2)?

It returns [3, 4, 5] because it drops the first two elements.

What does listOf(1, 2, 3, 4).take(2) return?

A [1, 2, 3, 4]

B [1, 2]

C [2, 3]

D [3, 4]

The take(2) function returns the first two elements.

What is the output of listOf(1, 2, 3).drop(5)?

A []

B [1, 2, 3]

C [3]

D [2, 3]

Dropping more elements than the list size returns an empty list.

How does chunked(2) split listOf(1, 2, 3, 4, 5)?

A [[1, 2, 3, 4, 5]]

B [[1, 2, 3], [4, 5]]

C [[1], [2], [3], [4], [5]]

D [[1, 2], [3, 4], [5]]

The list is split into chunks of size 2; the last chunk has one element.

Which function would you use to remove the first 3 elements from a list?

A drop(3)

B chunked(3)

C take(3)

D slice(3)

drop(3) removes the first 3 elements.

If you want to get the first 4 elements of a list but the list only has 2 elements, what does take(4) return?

A An error

B The first 4 elements

C The whole list

D An empty list

take returns as many elements as possible up to the requested number.

Describe how take, drop, and chunked work on Kotlin collections.

Think about how you might split or trim a list like a deck of cards.

Give an example of when you might use chunked in a real program.

Imagine cutting a big cake into slices to share.

Practice

1. What does the Kotlin function take(3) do when called on a list?

easy

A. Returns the first 3 items of the list

B. Removes the first 3 items from the list

C. Splits the list into chunks of size 3

D. Returns the last 3 items of the list

Solution

1. Step 1: Understand the take function

   The take(n) function returns the first n elements from a list.

2. Step 2: Apply to the example

   Calling take(3) returns the first 3 items, not removing or splitting the list.

3. Final Answer:

   Returns the first 3 items of the list -> Option A

4. Quick Check:

   take(3) = first 3 items [OK]

Hint: Remember: take(n) grabs first n items [OK]

Common Mistakes:

• Confusing take with drop
• Thinking take removes items
• Mixing take with chunked

2. Which of the following is the correct syntax to split a list myList into chunks of size 4 in Kotlin?

easy

A. myList.take(4)

B. chunked(myList, 4)

C. myList.drop(4)

D. myList.chunked(4)

Solution

1. Step 1: Identify the chunked function usage

   The chunked(size) function is called as a method on the list with the chunk size as argument.

2. Step 2: Check each option

   Only myList.chunked(4) matches the correct syntax. Others are either wrong method or wrong call style.

3. Final Answer:

   myList.chunked(4) -> Option D

4. Quick Check:

   chunked called as method with size [OK]

Hint: chunked is a method: list.chunked(size) [OK]

Common Mistakes:

• Using chunked as a standalone function
• Confusing chunked with take or drop
• Wrong argument order

3. What is the output of the following Kotlin code?

val numbers = listOf(10, 20, 30, 40, 50, 60)
val result = numbers.drop(2).take(3)
println(result)

medium

A. [40, 50, 60]

B. [10, 20, 30]

C. [30, 40, 50]

D. [20, 30, 40]

Solution

1. Step 1: Apply drop(2) on the list

   Dropping first 2 items removes 10 and 20, leaving [30, 40, 50, 60].

2. Step 2: Apply take(3) on the dropped list

   Taking first 3 items from [30, 40, 50, 60] gives [30, 40, 50].

3. Final Answer:

   [30, 40, 50] -> Option C

4. Quick Check:

   drop(2) then take(3) = [30, 40, 50] [OK]

Hint: drop removes first n, then take picks next n [OK]

Common Mistakes:

• Taking before dropping
• Off-by-one errors in indexing
• Confusing drop and take order

4. Identify the error in this Kotlin code snippet:

val list = listOf(1, 2, 3, 4, 5)
val chunks = list.chunked(0)
println(chunks)

medium

A. listOf cannot be used with chunked

B. chunked size cannot be zero

C. Missing import for chunked function

D. drop should be used instead of chunked

Solution

1. Step 1: Understand chunked parameter requirements

   The chunked(size) function requires a positive integer size greater than zero.

2. Step 2: Analyze the code

   Using chunked(0) is invalid and will throw an IllegalArgumentException.

3. Final Answer:

   chunked size cannot be zero -> Option B

4. Quick Check:

   chunked size > 0 [OK]

Hint: chunked size must be positive, never zero [OK]

Common Mistakes:

• Using zero or negative chunk size
• Assuming chunked works like drop
• Ignoring runtime exceptions

5. Given a list val data = listOf(1, 2, 3, 4, 5, 6, 7), which Kotlin expression produces a list of chunks of size 3, but only for the last 6 elements?

hard

A. data.drop(1).chunked(3)

B. data.take(6).chunked(3)

C. data.chunked(3).drop(1)

D. data.chunked(3).take(2)

Solution

1. Step 1: Identify last 6 elements

   Using drop(1) removes the first element, leaving last 6 elements [2,3,4,5,6,7].

2. Step 2: Chunk the remaining list

   Calling chunked(3) on [2,3,4,5,6,7] splits it into [[2,3,4], [5,6,7]].

3. Final Answer:

   data.drop(1).chunked(3) -> Option A

4. Quick Check:

   drop(1) then chunked(3) = last 6 in chunks [OK]

Hint: Drop first, then chunk to get last elements in groups [OK]

Common Mistakes:

• Using take instead of drop for last elements
• Chunking before dropping
• Miscounting chunk sizes