GroupBy for categorization in Kotlin - Step-by-Step Execution

Concept Flow - GroupBy for categorization

Start with List

↓

Choose Key Function

↓

Iterate over each item

↓

Apply Key Function to item

↓

Add item to group with that key

↓

Repeat for all items

↓

Return Map of groups

GroupBy takes a list and a function to decide keys, then puts items into groups by those keys.

Execution Sample

Kotlin

val fruits = listOf("apple", "banana", "apricot", "blueberry")
val grouped = fruits.groupBy { it.first() }
println(grouped)

Groups fruits by their first letter and prints the map of groups.

Execution Table

Step	Current Item	Key Function Result	Groups Map State	Action
1	"apple"	'a'	{ }	Create new group 'a' with ["apple"]
2	"banana"	'b'	{ 'a': ["apple"] }	Create new group 'b' with ["banana"]
3	"apricot"	'a'	{ 'a': ["apple"], 'b': ["banana"] }	Add "apricot" to group 'a'
4	"blueberry"	'b'	{ 'a': ["apple", "apricot"], 'b': ["banana"] }	Add "blueberry" to group 'b'
5	End	-	{ 'a': ["apple", "apricot"], 'b': ["banana", "blueberry"] }	Return grouped map

💡 All items processed, grouping complete.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
groups	{}	{ 'a': ["apple"] }	{ 'a': ["apple"], 'b': ["banana"] }	{ 'a': ["apple", "apricot"], 'b': ["banana"] }	{ 'a': ["apple", "apricot"], 'b': ["banana", "blueberry"] }	{ 'a': ["apple", "apricot"], 'b': ["banana", "blueberry"] }

Key Moments - 2 Insights

Why does the group 'a' have two fruits after step 3?

Because at step 3, the key function returns 'a' for "apricot", so it adds "apricot" to the existing group 'a' which already has "apple" (see execution_table row 3).

What happens if the key function returns a key not seen before?

A new group is created for that key and the current item is added to it, as seen at step 2 when 'b' group is created for "banana".

Visual Quiz - 3 Questions

Look at the execution table, what is the groups map state after processing "banana"?

A { 'a': ["apple", "apricot"] }

B { 'b': ["banana"] }

C { 'a': ["apple"], 'b': ["banana"] }

D {}

💡 Hint

Check execution_table row 2 under 'Groups Map State'.

At which step does the key function return 'b' for the first time?

A Step 2

B Step 3

C Step 1

D Step 4

💡 Hint

Look at the 'Key Function Result' column in execution_table.

If we changed the key function to group by string length, what would be the key for "banana"?

A 'b'

B 6

C 'banana'

D 1

💡 Hint

String length of "banana" is the number of characters, check variable_tracker for similar logic.

Concept Snapshot

GroupBy usage in Kotlin:
- Takes a list and a key selector function.
- Iterates each item, applies key function.
- Groups items by keys in a Map.
- Returns Map<Key, List<Item>>.
- Useful for categorizing data simply.

Full Transcript

This example shows how Kotlin's groupBy function works. We start with a list of fruits. The groupBy function uses a key function that picks the first letter of each fruit. As the program runs, it looks at each fruit, finds its first letter, and adds the fruit to the group for that letter. For example, "apple" goes to group 'a'. When "apricot" comes, it also goes to 'a' group. "banana" and "blueberry" go to 'b' group. At the end, we have a map with keys 'a' and 'b', each holding a list of fruits starting with those letters. This helps organize data by categories easily.

Practice

1. What does the groupBy function do in Kotlin?

easy

A. It sorts a list in ascending order.

B. It organizes a list into a map based on a key selector function.

C. It removes duplicate elements from a list.

D. It converts a list into a set.

Solution

1. Step 1: Understand the purpose of groupBy

   The groupBy function takes a list and groups its elements by a key, returning a map.

2. Step 2: Compare with other functions

   Sorting, removing duplicates, and converting to set do different things than grouping by a key.

3. Final Answer:

   It organizes a list into a map based on a key selector function. -> Option B

4. Quick Check:

   groupBy = organize by key [OK]

Hint: Remember: groupBy creates categories as map keys [OK]

Common Mistakes:

• Confusing groupBy with sorting functions
• Thinking groupBy removes duplicates
• Mixing groupBy with set conversion

2. Which of the following is the correct syntax to group a list of strings by their first character in Kotlin?

easy

A. val result = list.groupBy { it.first() }

B. val result = list.groupBy(it -> it.first())

C. val result = list.groupBy { it.first }

D. val result = list.groupBy { first(it) }

Solution

1. Step 1: Review Kotlin lambda syntax

   Kotlin uses curly braces with it for single-parameter lambdas: { it.first() }.

2. Step 2: Check each option

   val result = list.groupBy { it.first() } uses correct Kotlin syntax. val result = list.groupBy(it -> it.first()) uses arrow syntax which is invalid here. val result = list.groupBy { it.first } omits parentheses on first() method call, causing compile error. val result = list.groupBy { first(it) } calls undefined function first().

3. Final Answer:

   val result = list.groupBy { it.first() } -> Option A

4. Quick Check:

   Use curly braces and it.first() [OK]

Hint: Use curly braces and 'it' for lambda in groupBy [OK]

Common Mistakes:

• Using arrow syntax inside groupBy lambda
• Calling undefined functions like first(it)
• Omitting parentheses on first() method call

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

val numbers = listOf(1, 2, 3, 4, 5, 6)
val grouped = numbers.groupBy { if (it % 2 == 0) "even" else "odd" }
println(grouped)

medium

A. {odd=[1, 3, 5], even=[2, 4, 6]}

B. {1=[1], 2=[2], 3=[3], 4=[4], 5=[5], 6=[6]}

C. {true=[2, 4, 6], false=[1, 3, 5]}

D. SyntaxError

Solution

1. Step 1: Understand the grouping condition

   The lambda groups numbers by "even" if divisible by 2, else "odd".

2. Step 2: Group numbers accordingly

   Numbers 2,4,6 go to "even"; 1,3,5 go to "odd".

3. Final Answer:

   {odd=[1, 3, 5], even=[2, 4, 6]} -> Option A

4. Quick Check:

   Group by even/odd labels [OK]

Hint: Check grouping keys carefully for expected output [OK]

Common Mistakes:

• Confusing keys with values in output
• Expecting boolean keys instead of strings
• Thinking groupBy sorts the list

4. Identify the error in this Kotlin code snippet:

val words = listOf("apple", "banana", "apricot")
val grouped = words.groupBy { it[0] }
println(grouped)

medium

A. Indexing with it[0] is invalid for strings

B. Must convert characters to strings before grouping

C. groupBy requires a function, not a lambda

D. No error; code runs and groups by first character

Solution

1. Step 1: Check indexing on strings

   In Kotlin, strings support indexing with [0] to get first character.

2. Step 2: Validate groupBy usage

   The lambda { it[0] } is valid and groups words by their first character.

3. Final Answer:

   No error; code runs and groups by first character -> Option D

4. Quick Check:

   Strings support indexing; groupBy accepts lambdas [OK]

Hint: Remember strings can be indexed like arrays in Kotlin [OK]

Common Mistakes:

• Thinking indexing strings causes error
• Believing groupBy needs named functions only
• Assuming characters must be converted to strings

5. Given a list of people represented as pairs Pair<String, Int> where the first element is the name and the second is the age, how would you group them by age category "minor" (age < 18) or "adult" (age >= 18) using groupBy?

hard

A. people.groupBy { it.first }

B. people.groupBy { it.first.length }

C. people.groupBy { if (it.second < 18) "minor" else "adult" }

D. people.groupBy { it.second }

Solution

1. Step 1: Identify grouping key based on age

   We want to group by "minor" if age < 18, else "adult".

2. Step 2: Use groupBy with conditional key

   Access age with it.second and apply if-else to return category string.

3. Final Answer:

   people.groupBy { if (it.second < 18) "minor" else "adult" } -> Option C

4. Quick Check:

   Group by age category using conditional [OK]

Hint: Use if-else inside groupBy lambda for categories [OK]

Common Mistakes:

• Grouping by name or name length instead of age
• Grouping by exact age instead of categories
• Confusing first and second in Pair