collections-and-functional-programming - kotlin Interview Questions | Preplance

1. What is the difference between let and apply scope functions?

Difficulty: HardType: MCQTopic: Scope Functions

The let function passes the object as the lambda parameter accessible via it and returns the lambda's result, useful for transformations or null-safety with safe call operator. The apply function makes the object available as this inside the lambda and returns the object itself, ideal for object configuration. Use let when you want to transform an object or execute code with non-null values like person question mark dot let open curly print it dot name close curly. Use apply for object initialization like Person open paren close paren dot apply open curly name equals John close curly. Both are scope functions that help reduce temporary variables and make code more concise, but choosing between them depends on whether you need the lambda result or the original object returned.

3. Explain the difference between map, flatMap, and flatten with examples of when to use each.

Difficulty: MediumType: SubjectiveTopic: Collections

The map function transforms each element to a new value creating a new collection of the same size, like transforming list of names to their lengths. Use map when you have a one-to-one transformation where each input element produces exactly one output element. FlatMap transforms each element into a collection and then flattens the result into a single collection, useful when each element maps to multiple values like expanding each word into its characters. It's equivalent to calling map then flatten, combining transformation and flattening in one step. The flatten function only flattens nested collections without transformation, taking a collection of collections and returning a single flat collection. Use it when you already have nested collections and just need to flatten them without any element transformation. Example: map turns listOf 1 2 3 with times 2 into listOf 2 4 6, flatMap turns listOf abc def with chars into flat list of all characters, and flatten turns listOf listOf 1 2 listOf 3 4 into listOf 1 2 3 4.

4. Explain when and why you should use Sequences instead of regular collections for better performance.

Difficulty: HardType: SubjectiveTopic: Sequences

Use sequences when chaining multiple operations on large collections because sequences use lazy evaluation processing elements one at a time through the entire chain, avoiding intermediate collection creation. Collections eagerly create a new collection for each operation, which is wasteful for large datasets or when you don't need all results. Sequences are beneficial when you have multiple transformations like filter then map then take, as each element flows through all operations before the next element starts, enabling short-circuiting operations to stop early. For small collections under 100 elements, the overhead of lazy evaluation makes sequences slower than eager collections. Convert to sequence with asSequence, chain operations, and use terminal operations like toList, first, or count to trigger evaluation. Sequences can represent infinite streams processed on-demand, and they excel when dealing with IO operations or expensive computations where avoiding unnecessary work matters. Avoid sequences for simple single operations or small data where collection overhead is negligible, and always benchmark performance-critical code since intuition about performance can be wrong.

5. Explain partition, zip, and chunked functions and their use cases.

Difficulty: HardType: SubjectiveTopic: Collections

Partition splits a collection into two lists based on a predicate, returning a Pair where first contains elements matching the predicate and second contains non-matching elements. It's perfect for separating data into two categories like valid and invalid items in one pass. Zip combines two collections into a list of Pairs, matching elements by position, useful for processing parallel arrays or creating coordinate pairs. If collections have different sizes, zip stops at the shortest length, and you can provide a custom transformation instead of creating Pairs. Chunked breaks a collection into sublists of a specified size, with the last chunk potentially smaller, useful for batch processing or pagination. You can provide a transformation to process each chunk immediately, avoiding storing all chunks in memory. Examples: numbers dot partition curly it greater 0 curly separates positive and negative, names dot zip ages creates name-age pairs, and list dot chunked 10 creates batches of 10 elements.

6. What are the main collection interfaces in Kotlin?

Difficulty: EasyType: MCQTopic: Collections

Kotlin provides three main collection interfaces: List for ordered collections allowing duplicates, Set for unordered collections with unique elements, and Map for key-value pairs. Each interface has both read-only versions like List, Set, Map and mutable versions like MutableList, MutableSet, MutableMap. Read-only collections don't have methods to add or remove elements, promoting immutability and safer code, though the underlying implementation might still be mutable. Mutable collections provide methods like add, remove, and clear for modifying the collection. This separation between read-only and mutable interfaces is a key Kotlin feature not present in Java, helping prevent accidental modifications and making code intent clearer.

7. How do you create an immutable list in Kotlin?

Difficulty: EasyType: MCQTopic: Collections

The listOf function creates a read-only List where you cannot add or remove elements, like val numbers equals listOf open paren 1 comma 2 comma 3 close paren. For mutable lists that can be modified, use mutableListOf which returns a MutableList. Kotlin's list creation functions are more concise than Java's verbose ArrayList instantiation and initialization. You can also use emptyList for empty lists or listOfNotNull to filter out null values automatically. Read-only doesn't mean truly immutable as the underlying implementation might be mutable, but the interface prevents modifications through that reference, providing compile-time safety against accidental changes.

8. What does the filter function return?

Difficulty: EasyType: MCQTopic: Collection Ops

The filter function returns a new collection containing only the elements that satisfy the given predicate condition, like numbers dot filter open curly it greater 5 close curly returns elements greater than 5. It doesn't modify the original collection but creates a new filtered version. Filter is essential for functional-style data processing, often combined with map and other operations to build complex data transformation pipelines. Related functions include filterNot for inverse filtering and filterNotNull to remove null elements. You can use filterIsInstance to filter by type with automatic casting, filterIndexed to access indices in the predicate, and partition to split a collection into two lists based on a condition.

9. What is the difference between reduce and fold operations?

Difficulty: MediumType: MCQTopic: Collection Ops

The fold function takes an initial accumulator value and a lambda that combines the accumulator with each element, like numbers dot fold open paren 0 close paren open curly acc comma num arrow acc plus num close curly. The reduce function doesn't take an initial value but uses the first element as the initial accumulator. Fold is safer for empty collections as it returns the initial value, while reduce throws an exception on empty collections. Use reduceOrNull for null-safe reduction on potentially empty collections. Both are useful for aggregating collection elements into a single value like sums, products, or building strings, with fold being more flexible due to the explicit initial value allowing different result types than the element type.

10. Which function would you use to group collection elements by a key?

Difficulty: MediumType: MCQTopic: Collections

The groupBy function groups elements by a key selector function returning a Map where keys are the results of the selector and values are lists of elements with that key, like people dot groupBy open curly it dot age close curly groups people by age. It's perfect for categorizing data based on properties. Related functions include partition which splits a collection into two lists based on a predicate, associate which creates a Map from elements with custom key-value pairs, and groupingBy for more advanced grouping with aggregation operations. GroupBy is commonly used for data analysis, creating lookup tables, or organizing data by categories, and it handles duplicate keys automatically by collecting all matching elements into lists.

11. Compare all five scope functions (let, run, with, apply, also) and explain when to use each.

Difficulty: HardType: SubjectiveTopic: Scope Functions

Let and also pass the object as it parameter, while run, with, and apply use this for context. Let and run return the lambda result allowing transformations, while apply and also return the original object enabling chaining. With is similar to run but not an extension function. Use let for null-safe calls with question mark dot and transforming objects, apply for object configuration returning the object, run for complex initialization with result, also for side effects while chaining, and with for calling multiple methods on an object without extension syntax. Examples: person question mark dot let prints name only if not null, Person dot apply sets properties, text dot also saves it while returning text, run combines initialization and returns result, with reads cleaner for multiple calls on one object. Choosing the right scope function makes code more readable by clearly expressing intent whether you want the lambda result or original object, and whether the object should be it or this.

12. Explain the difference between mutable and immutable collections and when to use each.

Difficulty: MediumType: SubjectiveTopic: Collections

Immutable collections created with listOf, setOf, or mapOf don't have methods to add or remove elements, providing a read-only view that prevents modifications through that reference. Mutable collections created with mutableListOf, mutableSetOf, or mutableMapOf provide methods like add, remove, and clear for modifications. Prefer immutable collections as the default choice because they're safer in concurrent code, prevent accidental modifications, make code easier to reason about, and clearly communicate that the collection won't change. Use mutable collections when you need to build collections incrementally or when performance requires in-place modifications. Note that immutable doesn't mean the underlying implementation is unchangeable, just that the interface prevents modifications. For true immutability use defensive copying or immutable data structures libraries. Good practice is to use mutable collections internally during construction, then expose them as immutable interfaces to callers using toList or returning List type instead of MutableList, protecting your internal state while allowing internal modifications.

13. How do you build efficient collection transformation pipelines in Kotlin?

Difficulty: MediumType: SubjectiveTopic: Collection Ops

Build transformation pipelines by chaining functional operations like filter, map, flatMap, and groupBy to process data declaratively. Each operation returns a new collection allowing method chaining, creating readable pipelines that clearly express data transformations step by step. For performance with multiple operations on large collections, convert to sequence with asSequence to enable lazy evaluation, chain operations, then materialize results with terminal operations like toList or count. This avoids creating intermediate collections for each step. Common patterns include filter to remove unwanted elements, map to transform, sortedBy to order, groupBy to categorize, and fold or reduce to aggregate. Use mapNotNull to transform and filter nulls in one step, and distinct to remove duplicates. Keep pipelines readable by splitting very long chains across lines with each operation on its own line, and consider extracting complex transformations into named functions for reusability and testability.

14. Explain the associate, associateBy, and associateWith functions for creating Maps from collections.

Difficulty: HardType: SubjectiveTopic: Collection Ops

Associate creates a Map by transforming each element into a Pair of key and value using a lambda that returns key to value pairs, giving full control over both keys and values. AssociateBy uses elements as values and derives keys from a lambda, while associateWith uses elements as keys and derives values from a lambda. Use associate when you need to transform elements into completely different keys and values, associateBy to create a lookup map where you keep original elements as values with custom keys, and associateWith to create maps where elements are keys with computed values. Examples: people dot associateBy curly it dot id curly creates ID to person map, numbers dot associateWith curly it times it curly creates number to square map, and associate with key to value pairs for full transformation. These functions handle duplicate keys by keeping the last occurrence, and you can use groupBy instead if you need to keep all elements with the same key. Understanding these associate functions helps avoid manual map building loops.

15. What are the performance characteristics of List, Set, and Map operations and how to choose the right collection?

Difficulty: HardType: SubjectiveTopic: Performance

Lists provide O of 1 random access by index and fast iteration but O of n contains checks and removals scanning the entire list. ArrayList is best for random access and iteration, LinkedList for frequent insertions and removals at specific positions though rarely needed in Kotlin. Sets provide O of 1 contains, add, and remove operations using hash-based implementations like HashSet, making them ideal for uniqueness checking or fast membership tests. LinkedHashSet maintains insertion order with slightly more memory, TreeSet provides sorting with O of log n operations. Maps provide O of 1 key-based lookup, insertion, and removal using HashMap, perfect for lookups and associations. LinkedHashMap maintains insertion order, TreeMap provides sorted keys with O of log n operations, use when key ordering matters. Choose List for ordered data with index access, Set for unique elements with fast membership testing, and Map for key-value associations with fast lookups. Consider memory usage and typical operations to pick the right implementation.

16. What is the main advantage of using Sequences over Collections for chained operations?

Difficulty: MediumType: MCQTopic: Sequences

Sequences use lazy evaluation where operations like map and filter are not executed until a terminal operation like toList or count is called, avoiding intermediate collection creation. This can significantly improve performance for large datasets or when you don't need all results. With collections, each operation creates a new collection immediately, so chaining multiple operations creates multiple intermediate collections. Sequences process elements one by one through the entire chain, evaluating only what's necessary. Use asSequence to convert collections to sequences, then chain operations, and finally call a terminal operation. Sequences are ideal for large data or infinite streams but have overhead for small collections where eager evaluation is faster.

Master Interviews
Anywhere, Anytime

Collections & Functional Programming – Kotlin interview questions

Set overview

Kotlin – Collections & Functional Programming questions (16)

1. What is the difference between let and apply scope functions?

Continue your preparation

2. What does the map function do on collections?

3. Explain the difference between map, flatMap, and flatten with examples of when to use each.

4. Explain when and why you should use Sequences instead of regular collections for better performance.

5. Explain partition, zip, and chunked functions and their use cases.

6. What are the main collection interfaces in Kotlin?

7. How do you create an immutable list in Kotlin?

8. What does the filter function return?

9. What is the difference between reduce and fold operations?

10. Which function would you use to group collection elements by a key?

11. Compare all five scope functions (let, run, with, apply, also) and explain when to use each.

12. Explain the difference between mutable and immutable collections and when to use each.

13. How do you build efficient collection transformation pipelines in Kotlin?

14. Explain the associate, associateBy, and associateWith functions for creating Maps from collections.

15. What are the performance characteristics of List, Set, and Map operations and how to choose the right collection?

16. What is the main advantage of using Sequences over Collections for chained operations?

More sets in Kotlin

Explore related subjects

Master Interviews Anywhere, Anytime

Collections & Functional Programming – Kotlin interview questions

Set overview

1. What is the difference between let and apply scope functions?

Continue your preparation

2. What does the map function do on collections?

3. Explain the difference between map, flatMap, and flatten with examples of when to use each.

4. Explain when and why you should use Sequences instead of regular collections for better performance.

5. Explain partition, zip, and chunked functions and their use cases.

6. What are the main collection interfaces in Kotlin?

7. How do you create an immutable list in Kotlin?

8. What does the filter function return?

9. What is the difference between reduce and fold operations?

10. Which function would you use to group collection elements by a key?

11. Compare all five scope functions (let, run, with, apply, also) and explain when to use each.

12. Explain the difference between mutable and immutable collections and when to use each.

13. How do you build efficient collection transformation pipelines in Kotlin?

14. Explain the associate, associateBy, and associateWith functions for creating Maps from collections.

15. What are the performance characteristics of List, Set, and Map operations and how to choose the right collection?

16. What is the main advantage of using Sequences over Collections for chained operations?

More sets in Kotlin

Explore related subjects

Master Interviews
Anywhere, Anytime