Take, drop, and chunked in Kotlin

Introduction

These functions help you work with parts of a list easily. You can grab some items, skip some, or split the list into smaller groups.

When you want to get the first few items from a list, like the first 3 names in a guest list.

When you want to ignore the first few items and work with the rest, like skipping the first 2 messages in a chat.

When you want to split a long list into smaller chunks, like dividing a list of students into groups of 4.

Syntax

Kotlin

val result = list.take(n)
val result = list.drop(n)
val result = list.chunked(size)

take(n) gets the first n items from the list.

drop(n) skips the first n items and returns the rest.

chunked(size) splits the list into smaller lists each with size items.

Examples

This gets the first 2 numbers: [1, 2]

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)
val firstTwo = numbers.take(2)

This skips the first 2 numbers and returns [3, 4, 5]

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)
val afterTwo = numbers.drop(2)

This splits the list into chunks of 2: [[1, 2], [3, 4], [5]]

Kotlin

val numbers = listOf(1, 2, 3, 4, 5)
val chunks = numbers.chunked(2)

Sample Program

This program shows how to use take, drop, and chunked on a list of fruits.

Kotlin

fun main() {
    val fruits = listOf("apple", "banana", "cherry", "date", "fig", "grape")

    val firstThree = fruits.take(3)
    println("First three fruits: $firstThree")

    val afterThree = fruits.drop(3)
    println("Fruits after first three: $afterThree")

    val groupsOfTwo = fruits.chunked(2)
    println("Fruits in groups of two: $groupsOfTwo")
}

Important Notes

If take(n) asks for more items than the list has, it just returns the whole list.

drop(n) returns an empty list if you drop more items than the list contains.

chunked(size) creates the last chunk with fewer items if the list size isn't a multiple of size.

Summary

take(n) gets the first n items from a list.

drop(n) skips the first n items and returns the rest.

chunked(size) splits a list into smaller lists of the given size.

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