Sorted and sortedBy in Kotlin - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Kotlin code using sorted()?

Consider the following Kotlin code that sorts a list of numbers. What will be printed?

Kotlin

val numbers = listOf(5, 3, 8, 1)
val sortedNumbers = numbers.sorted()
println(sortedNumbers)

A [8, 5, 3, 1]

B [1, 5, 3, 8]

C [5, 3, 8, 1]

D [1, 3, 5, 8]

💡 Hint

The sorted() function returns a new list with elements in ascending order.

The sorted() function returns a new list with the elements sorted in ascending order. So the original list [5, 3, 8, 1] becomes [1, 3, 5, 8].

❓ Predict Output

intermediate

What does sortedBy return for this list of strings?

Given this Kotlin code, what will be the output?

Kotlin

val fruits = listOf("apple", "banana", "pear", "kiwi")
val sortedByLength = fruits.sortedBy { it.length }
println(sortedByLength)

A ["kiwi", "pear", "apple", "banana"]

B ["pear", "kiwi", "apple", "banana"]

C ["banana", "apple", "pear", "kiwi"]

D ["apple", "banana", "pear", "kiwi"]

💡 Hint

sortedBy sorts elements based on the value returned by the lambda.

sortedBy sorts the list by the length of each string in ascending order. Lengths: pear(4), kiwi(4), apple(5), banana(6). Since sortedBy uses a stable sort, pear comes before kiwi. So the sorted list is ["pear", "kiwi", "apple", "banana"].

🔧 Debug

advanced

Why does this Kotlin code cause a compilation error?

Look at this Kotlin code snippet. Why does it cause a compilation error?

Kotlin

val numbers = listOf(1, 2, 3)
val sorted = numbers.sortedBy { it > 2 }
println(sorted)

A sortedBy expects a selector returning a Comparable, but 'it > 2' returns Boolean which is not Comparable

B sortedBy cannot be used on lists of integers

C The lambda syntax is incorrect; it should be 'it -> it > 2'

D sortedBy requires the list to be mutable

💡 Hint

Check the return type of the lambda passed to sortedBy.

The lambda passed to sortedBy must return a value that implements Comparable. The expression 'it > 2' returns a Boolean, which does not implement Comparable, causing a compilation error.

🧠 Conceptual

advanced

How does sorted() differ from sortedBy() in Kotlin?

Which statement best describes the difference between sorted() and sortedBy()?

A sorted() modifies the original list; sortedBy() returns a new list

B sorted() sorts only numbers; sortedBy() sorts only strings

C sorted() sorts elements naturally; sortedBy() sorts elements using a selector function

D sorted() sorts in descending order; sortedBy() sorts in ascending order

💡 Hint

Think about how you tell Kotlin what to sort by.

sorted() sorts elements according to their natural order (like numbers ascending). sortedBy() lets you provide a function to select a value to sort by, useful for complex objects or custom criteria.

❓ Predict Output

expert

What is the output of this Kotlin code using sortedBy with nulls?

Consider this Kotlin code that sorts a list with nullable strings. What will be printed?

Kotlin

val names: List<String?> = listOf("Anna", null, "Bob", "", null)
val sortedNames = names.sortedBy { it?.length ?: -1 }
println(sortedNames)

A [null, null, "", "Bob", "Anna"]

B ["", "Bob", "Anna", null, null]

C [null, "", null, "Bob", "Anna"]

D ["Anna", "Bob", "", null, null]

💡 Hint

Look at how nulls are handled with the Elvis operator ?: in the selector.

The selector returns length of the string or -1 if null. So nulls get -1, which is smallest, so they come first. Then empty string (length 0), then "Bob" (3), then "Anna" (4).

Practice

1. What does the sorted() function do in Kotlin?

easy

A. It sorts the original list in place and returns nothing.

B. It arranges elements randomly in a new list.

C. It returns a new list with elements arranged in natural ascending order.

D. It filters elements based on a condition.

Solution

1. Step 1: Understand the purpose of sorted()

   The sorted() function creates a new list where elements are arranged in natural ascending order (numbers from smallest to largest, strings alphabetically).

2. Step 2: Check if original list changes

   The original list remains unchanged because sorted() returns a new sorted list without modifying the original.

3. Final Answer:

   It returns a new list with elements arranged in natural ascending order. -> Option C

4. Quick Check:

   sorted() = new ascending list [OK]

Hint: sorted() always returns a new ascending list [OK]

Common Mistakes:

• Thinking sorted() changes the original list
• Confusing sorted() with filtering
• Assuming sorted() arranges elements randomly

2. Which of the following is the correct syntax to sort a list of strings by their length using sortedBy in Kotlin?

easy

A. list.sortedBy { it.length }

B. list.sortedBy.length()

C. list.sortedBy(it.length)

D. list.sortedBy { length(it) }

Solution

1. Step 1: Identify correct lambda syntax for sortedBy

   The sortedBy function takes a lambda expression that returns the property to sort by. The correct syntax is list.sortedBy { it.property }.

2. Step 2: Check each option

   list.sortedBy { it.length } uses { it.length } which correctly accesses the length property of each string. Other options have syntax errors or incorrect usage.

3. Final Answer:

   list.sortedBy { it.length } -> Option A

4. Quick Check:

   sortedBy uses lambda with it.property [OK]

Hint: Use curly braces and 'it' to access property in sortedBy [OK]

Common Mistakes:

• Using parentheses instead of curly braces
• Calling length() as a function incorrectly
• Passing property outside lambda

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

val numbers = listOf(5, 3, 8, 1)
val sortedNumbers = numbers.sortedBy { it % 3 }
println(sortedNumbers)

medium

A. [1, 3, 5, 8]

B. [3, 6, 9, 12]

C. [1, 5, 3, 8]

D. [3, 1, 5, 8]

Solution

1. Step 1: Calculate the sorting key for each element

   Calculate it % 3 for each number: 5 % 3 = 2, 3 % 3 = 0, 8 % 3 = 2, 1 % 3 = 1.

2. Step 2: Sort numbers by these keys

   Sort by keys in ascending order: 0 (3), 1 (1), 2 (5), 2 (8). So sorted list is [3, 1, 5, 8].

3. Final Answer:

   [3, 1, 5, 8] -> Option D

4. Quick Check:

   sortedBy { it % 3 } = [3, 1, 5, 8] [OK]

Hint: Calculate sorting key for each element before sorting [OK]

Common Mistakes:

• Sorting by values instead of keys
• Confusing modulo results
• Assuming sortedBy sorts original list

4. Identify the error in this Kotlin code snippet:

val fruits = listOf("apple", "banana", "cherry")
val sortedFruits = fruits.sortedBy(it.length)
println(sortedFruits)

medium

A. sortedBy cannot be used on lists of strings.

B. Missing curly braces around the lambda expression in sortedBy.

C. The list should be mutable to use sortedBy.

D. The println statement is incorrect.

Solution

1. Step 1: Check syntax of sortedBy usage

   The sortedBy function requires a lambda expression inside curly braces, like { it.length }. The code uses parentheses without braces, which is incorrect.

2. Step 2: Verify other options

   sortedBy works on lists of strings, the list can be immutable, and println is correct. So only the lambda syntax is wrong.

3. Final Answer:

   Missing curly braces around the lambda expression in sortedBy. -> Option B

4. Quick Check:

   sortedBy needs { } for lambda [OK]

Hint: Always use curly braces for lambda in sortedBy [OK]

Common Mistakes:

• Using parentheses instead of curly braces for lambda
• Thinking sortedBy needs mutable list
• Misunderstanding println usage

5. Given a list of data class objects data class Person(val name: String, val age: Int), how would you sort the list first by age ascending, then by name alphabetically using Kotlin's sorting functions?

hard

A. persons.sortedWith(compareBy({ it.age }, { it.name }))

B. persons.sortedBy { it.age + it.name }

C. persons.sortedBy { it.name }.sortedBy { it.age }

D. persons.sortedByDescending { it.age }.sortedBy { it.name }

Solution

1. Step 1: Understand multi-level sorting in Kotlin

   To sort by multiple properties, use sortedWith(compareBy(...)) passing lambdas for each property in priority order.

2. Step 2: Analyze options

   persons.sortedWith(compareBy({ it.age }, { it.name })) correctly uses compareBy with age first, then name. persons.sortedBy { it.age + it.name } incorrectly adds age and name (different types). persons.sortedBy { it.name }.sortedBy { it.age } sorts twice but second sort overrides first. persons.sortedByDescending { it.age }.sortedBy { it.name } sorts age descending, not ascending.

3. Final Answer:

   persons.sortedWith(compareBy({ it.age }, { it.name })) -> Option A

4. Quick Check:

   Use sortedWith(compareBy(...)) for multi-level sort [OK]

Hint: Use sortedWith(compareBy(...)) for sorting by multiple keys [OK]

Common Mistakes:

• Adding different types in sortedBy
• Chaining sortedBy loses previous sort
• Using sortedByDescending when ascending needed