Take, drop, and chunked in Kotlin - Mini Project: Build & Apply

Using Take, Drop, and Chunked in Kotlin

📖 Scenario: You are working on a Kotlin program that processes a list of daily temperatures recorded over a week. You want to extract parts of this data to analyze specific days and group days into smaller chunks.

🎯 Goal: Build a Kotlin program that uses take, drop, and chunked functions to manipulate a list of temperatures.

📋 What You'll Learn

Create a list of exactly 7 temperatures as integers

Create a variable to hold the number of days to take from the start

Use take to get the first few temperatures

Use drop to skip the first few temperatures

Use chunked to split the list into groups of 3

Print the results exactly as specified

💡 Why This Matters

🌍 Real World

Processing lists of data like temperatures, sales, or scores is common. Using <code>take</code>, <code>drop</code>, and <code>chunked</code> helps you focus on parts of the data or group it for easier analysis.

💼 Career

Many programming jobs require working with lists or arrays. Knowing how to extract and group data efficiently is a useful skill for data analysis, app development, and backend programming.

1

Create the temperature list

Create a list called temperatures with these exact integer values: 23, 25, 22, 20, 24, 26, 21.

Kotlin

# Create the list of temperatures
# Your code here

Hint

Use listOf to create a list with the exact numbers.

2

Set the number of days to take

Create an integer variable called daysToTake and set it to 4.

Kotlin

val temperatures = listOf(23, 25, 22, 20, 24, 26, 21)
# Create the variable daysToTake and set it to 4
# Your code here

Hint

Use val daysToTake = 4 to create the variable.

3

Use take, drop, and chunked

Create three variables: firstDays using temperatures.take(daysToTake), afterDays using temperatures.drop(daysToTake), and chunkedDays using temperatures.chunked(3).

Kotlin

val temperatures = listOf(23, 25, 22, 20, 24, 26, 21)
val daysToTake = 4
# Create firstDays using take(daysToTake)
# Create afterDays using drop(daysToTake)
# Create chunkedDays using chunked(3)
# Your code here

Hint

Use the take, drop, and chunked functions exactly as shown.

4

Print the results

Print firstDays, afterDays, and chunkedDays each on its own line using println.

Kotlin

val temperatures = listOf(23, 25, 22, 20, 24, 26, 21)
val daysToTake = 4
val firstDays = temperatures.take(daysToTake)
val afterDays = temperatures.drop(daysToTake)
val chunkedDays = temperatures.chunked(3)
# Print firstDays, afterDays, and chunkedDays each on a new line
# Your code here

Hint

Use println to print each variable on its own line.

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