Partition for splitting in Kotlin - Cheat Sheet & Quick Revision

Recall & Review

beginner

What does the partition function do in Kotlin?

It splits a collection into two lists based on a condition: one list with elements that satisfy the condition, and another with elements that don't.

beginner

How do you use partition to separate even and odd numbers from a list?

Use val (evens, odds) = list.partition { it % 2 == 0 }. This creates two lists: evens with even numbers and odds with odd numbers.

intermediate

What is the return type of the partition function?

It returns a Pair<List<T>, List<T>>, where the first list contains elements matching the predicate, and the second list contains the rest.

beginner

Can partition be used on any Kotlin collection?

Yes, partition works on any Iterable, like lists and sets.

intermediate

What happens if no elements satisfy the condition in partition?

The first list in the returned pair will be empty, and the second list will contain all elements.

What does Kotlin's partition function return?

A A single list with filtered elements

B A map of elements grouped by condition

C A pair of lists splitting elements by a condition

D A boolean indicating if any element matches

partition returns a Pair of two lists: one with elements that satisfy the condition, and one with those that don't.

How do you capture the two lists returned by partition?

A Using destructuring declaration like <code>val (yes, no) = ...</code>

B Using a single list variable

C Using a map variable

D Using a boolean variable

You use destructuring to get both lists from the Pair returned by partition.

If you want to split a list of numbers into positives and non-positives, which predicate fits partition?

A <code>{ it >= 0 }</code>

B <code>{ it < 0 }</code>

C <code>{ it == 0 }</code>

D <code>{ it > 0 }</code>

The predicate { it > 0 } selects positive numbers for the first list.

What type of collections can use partition in Kotlin?

A Any <code>Iterable</code> like lists and sets

B Only arrays

C Only maps

D Only sequences

partition works on any Iterable, including lists and sets.

What will be the size of the first list if no elements satisfy the partition condition?

A Undefined

B Zero (empty list)

C One

D Same as original list

If no elements match, the first list is empty.

Explain how Kotlin's partition function works and give a simple example.

Think about separating items based on a yes/no question.

Describe the return type of partition and how to access the two lists it produces.

Remember how Kotlin lets you unpack pairs easily.

Practice

1. What does the partition function do in Kotlin when applied to a list?

easy

A. Converts the list into a map with indices as keys.

B. Sorts the list in ascending order.

C. Removes duplicate elements from the list.

D. Splits the list into two lists based on a condition, returning a Pair of lists.

Solution

1. Step 1: Understand the purpose of partition

   The partition function divides a list into two parts based on a condition.

2. Step 2: Recognize the return type

   It returns a Pair where the first list contains elements matching the condition, and the second list contains the rest.

3. Final Answer:

   Splits the list into two lists based on a condition, returning a Pair of lists. -> Option D

4. Quick Check:

   partition = split by condition [OK]

Hint: Remember: partition always returns two lists in a Pair [OK]

Common Mistakes:

• Thinking partition sorts the list
• Confusing partition with filtering
• Assuming partition removes duplicates

2. Which of the following is the correct syntax to use partition on a list numbers to split even and odd numbers?

easy

A. val (evens, odds) = numbers.partition { it % 2 == 0 }

B. val (evens, odds) = numbers.partition(it % 2 == 0)

C. val evens = numbers.partition { it % 2 == 0 }

D. val evens, odds = numbers.partition { it % 2 == 0 }

Solution

1. Step 1: Check the lambda syntax inside partition

   The condition must be inside curly braces with it representing each element.

2. Step 2: Verify destructuring declaration

   Partition returns a Pair, so use val (first, second) = ... to get both lists.

3. Final Answer:

   val (evens, odds) = numbers.partition { it % 2 == 0 } -> Option A

4. Quick Check:

   Correct lambda and destructuring = val (evens, odds) = numbers.partition { it % 2 == 0 } [OK]

Hint: Use val (a, b) = list.partition { condition } [OK]

Common Mistakes:

• Missing curly braces for lambda
• Not using destructuring for Pair
• Using parentheses instead of braces for lambda

3. What is the output of this Kotlin code?

val words = listOf("apple", "banana", "avocado", "berry")
val (aWords, otherWords) = words.partition { it.startsWith('a') }
println(aWords)
println(otherWords)

medium

A. ["apple", "avocado"]
["banana", "berry"]

B. ["banana", "berry"]
["apple", "avocado"]

C. ["apple"]
["banana", "avocado", "berry"]

D. ["avocado"]
["apple", "banana", "berry"]

Solution

1. Step 1: Apply the condition to each word

   Check which words start with 'a': "apple" and "avocado" match.

2. Step 2: Partition splits into two lists

   First list has words starting with 'a', second list has the rest: "banana", "berry".

3. Final Answer:

   ["apple", "avocado"] ["banana", "berry"] -> Option A

4. Quick Check:

   partition by startsWith('a') = ["apple", "avocado"] ["banana", "berry"] [OK]

Hint: Check condition on each element carefully [OK]

Common Mistakes:

• Mixing order of lists in output
• Forgetting that partition returns Pair of lists
• Confusing startsWith with contains

4. Identify the error in this Kotlin code using partition:

val nums = listOf(1, 2, 3, 4)
val evens, odds = nums.partition { it % 2 == 0 }
println(evens)
println(odds)

medium

A. partition cannot be used on lists of integers.

B. The lambda condition is incorrect; should be it % 2 != 0.

C. Missing parentheses around evens and odds for destructuring declaration.

D. println statements are missing string interpolation.

Solution

1. Step 1: Check destructuring declaration syntax

   Destructuring a Pair requires parentheses: val (evens, odds) = ....

2. Step 2: Confirm lambda and usage

   The lambda is correct for evens; partition works on lists of integers; println is fine.

3. Final Answer:

   Missing parentheses around evens and odds for destructuring declaration. -> Option C

4. Quick Check:

   Destructuring needs parentheses [OK]

Hint: Use val (a, b) = ... for destructuring Pair [OK]

Common Mistakes:

• Omitting parentheses in destructuring
• Changing correct lambda unnecessarily
• Thinking partition only works on strings

5. Given a list of mixed integers including zero and negatives, how can you use partition to separate positive numbers from zero and negatives? Choose the correct code snippet.

hard

A. val (positives, nonPositives) = numbers.partition { it < 0 }

B. val (positives, nonPositives) = numbers.partition { it > 0 }

C. val (positives, nonPositives) = numbers.partition { it >= 0 }

D. val (positives, nonPositives) = numbers.partition { it == 0 }

Solution

1. Step 1: Define the condition for positives

   Positive numbers are greater than zero, so condition is it > 0.

2. Step 2: Use partition with this condition

   Partition splits list into positives and the rest (zero and negatives).

3. Final Answer:

   val (positives, nonPositives) = numbers.partition { it > 0 } -> Option B

4. Quick Check:

   Partition by it > 0 separates positives [OK]

Hint: Use it > 0 to get positives, rest are zero/negatives [OK]

Common Mistakes:

• Using it >= 0 includes zero as positive
• Using it < 0 reverses groups
• Using it == 0 only selects zeros