easydata classes
What does `copy(age = 31)` return here?
data class User(val name: String, val age: Int)
val a = User("Ana", 30)
val b = a.copy(age = 31)why this works
Built for Kotlin mastery, not memorisation.
Every question is hand-checked, every answer comes with an explanation, and your progress builds into a clear picture of where you stand.
The snippet is on the page
Every Kotlin question shows its code before you answer, so you are reading real Kotlin, not a description of it.
A written explanation, always
Once you attempt a question you get the reasoning, not just a tick. That matters most on Kotlin, where null safety and platform types, coroutine scopes and cancellation, suspend function semantics, inline and reified generics, and data class copy behaviour.
Your weak topics, named
Progress is tracked per topic across the 58 Kotlin topics, so revision points at the gaps instead of the whole list.
faq
Things people ask.
How many Kotlin MCQs are on Journey Uncommon?
505 Kotlin questions right now: 63 easy, 218 medium and 224 hard. That number is read straight from the question table when this page is built, so it is never a rounded marketing figure.
Do I need an account to read the Kotlin questions?
No. Every Kotlin question, including its code snippet, its difficulty and its topic, is readable without signing in. You need a free account only to submit an answer, see which option is correct, and read the worked explanation. We keep it that way so the platform stays honest about what you actually got right.
What do Kotlin interviewers actually test?
Null safety and platform types, coroutine scopes and cancellation, suspend function semantics, inline and reified generics, and data class copy behaviour.
Which Kotlin topics are covered?
58 distinct topics are tagged on the Kotlin questions, including Flow cold streams, StateFlow SharedFlow, inline functions, structured concurrency Job tree, Volatile and atomics on JVM, the Continuation interface. The topic labels come from the questions themselves, so the list matches what you will actually be asked.
Is Kotlin practice free?
Yes. Reading is free and unlimited. A free account unlocks answering, explanations and progress tracking. Pro (₹199 per month) adds AI explanations and AI-graded guesstimates on top; it is not needed to practise Kotlin MCQs.
Where is Kotlin used in real jobs?
Android apps, JVM back ends adopting Kotlin, and multiplatform mobile teams.
What a Kotlin question here actually looks like
These are 12 of the 505 Kotlin questions in the library, pulled live from the question table. The snippet, the difficulty and the topic are all here. The answer options and the explanation are not. Those need a free account.
Null safety and platform types, coroutine scopes and cancellation, suspend function semantics, inline and reified generics, and data class copy behaviour.
Sample Kotlin MCQs
easysafe call
What is the type of `length` after this safe-call chain?
val length = user?.address?.city?.lengthmediumsuspend functions usage
What is the effect of calling a suspend function inside withContext(Dispatchers.IO) { ... }?
suspend fun loadData(): String = withContext(Dispatchers.IO) {
blockingDbCall()
}easysafe call
What is the difference between `?.let { }` running its block versus not running it?
val name: String? = null
name?.let { println(it.uppercase()) }mediumFlow cold streams
What does this snippet print, demonstrating how operators and collection interact on a cold Flow?
import kotlinx.coroutines.flow.*
import kotlinx.coroutines.runBlocking
fun main() = runBlocking {
val flow = (1..3).asFlow()
.map { println("map $it"); it * 2 }
println("flow built")
flow.collect { println("got $it") }
}mediumtailrec functions
Both functions are marked tailrec and each one's recursive call is the last operation. What does the compiler actually do?
tailrec fun isEven(n: Int): Boolean =
if (n == 0) true else isOdd(n - 1)
tailrec fun isOdd(n: Int): Boolean =
if (n == 0) false else isEven(n - 1)hardstructured concurrency Job tree
Given this structured-concurrency code, what happens to the parent coroutine and the sibling child when `childB` throws?
suspend fun run() = coroutineScope {
val childA = launch { delay(1000); println("A") }
val childB = launch { throw IllegalStateException("boom") }
}hardFlow backpressure buffer conflate
A fast producer feeds a slow collector through `buffer(capacity = 2)`. Once the buffer is full, what happens to the producer's next `emit`, and through what concurrency primitive is this realized?
flow {
repeat(5) { emit(it); println("emitted $it") }
}.buffer(2).collect {
delay(100)
println("collected $it")
}mediumcoroutine dispatchers context
What is the relationship between the coroutine that runs the launch block and its parent's context in this code?
import kotlinx.coroutines.*
val scope = CoroutineScope(Dispatchers.Default + CoroutineName("parent"))
fun demo() {
scope.launch(Dispatchers.IO) {
// what context applies here?
}
}hardcoroutine cancellation cooperation
Why does a tight CPU loop like `while (i < n) { i++ }` inside a coroutine fail to stop when the coroutine is cancelled, even though `delay` would have stopped immediately?
launch {
var i = 0
while (i < 1_000_000_000) { i++ }
println("done")
}hardVolatile and atomics on JVM
Consider a `@Volatile var flag = false` and a non-volatile `var data = 0`, with one thread writing `data = 42; flag = true` and another doing `if (flag) print(data)`. Which JMM property makes the reader guaranteed to see `data == 42`, and what would break it?
// Writer thread:
data = 42
flag = true
// Reader thread:
if (flag) println(data)mediumtailrec functions
Why does this `tailrec` function compile and run without a stack overflow for large `n`, and what would break the optimization?
tailrec fun factorial(n: Long, acc: Long = 1L): Long {
return if (n <= 1L) acc
else factorial(n - 1, acc * n)
}Sign in to answer
Everything above is free to read. Answering needs a free account.
We keep the correct answer, the explanation and the scoring behind sign-in so the platform stays honest, which is why the correct option and the worked explanation for every Kotlin question stay behind a free account. Signing in is free and takes a few seconds.
Where Kotlin shows up
Android apps, JVM back ends adopting Kotlin, and multiplatform mobile teams.