Preguntas de entrevista de Kotlin con respuestas

Kotlin se pregunta sobre todo por su seguridad frente a nulos, las colecciones y las corrutinas. Estas preguntas son de nivel 2, las que tienen trampa, y cada una trae su explicación.

Piensa la respuesta antes de abrirla: la explicación dice por qué fallan las demás opciones. En Streakode tienes 28 preguntas como estas de Kotlin, y un simulacro de 10 preguntas en 15 minutos, sin corrección hasta el final, para ver cómo irías en una entrevista de verdad.

Prueba cuatro ejercicios sin cuenta Crear cuenta y hacer el simulacro

12 preguntas de Kotlin

Temas: Colecciones · Conversiones · Corrutinas · Funciones de extensión · Null safety · Secuencias · Validación · when.

1 · Completa el hueco · nivel 2
Completa para quedarte con los pares del 1 al 10 y elevarlos al cuadrado.
```
val evens = (1..10).___ { it % 2 == 0 }.___ { it * it }
```
- filter
- map
- forEach
- reduce
- also
- takeIf
Ver la respuesta
Respuesta: filter · map
```
val evens = (1..10).filter { it % 2 == 0 }.map { it * it }
```
filter conserva los elementos que cumplen la condición y map transforma cada uno. El resultado es [4, 16, 36, 64, 100].
2 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
val names = listOf("ana", null, "eva")println(names.mapNotNull { it?.uppercase() })
```
- A[ANA, EVA]
- B[ANA, null, EVA]
- C[ANA, NULL, EVA]
- DNullPointerException
Ver la respuesta
Respuesta: A. [ANA, EVA]
mapNotNull aplica la transformación y descarta los resultados null. it?.uppercase() devuelve null para el elemento null, así que desaparece.
3 · Encuentra el fallo · nivel 2
Lanza NumberFormatException al llegar a "x". ¿Qué línea tiene el fallo?
```
1val inputs = listOf("4", "x", "6")2val total = inputs.sumOf { it.toInt() }3println(total)
```
Ver la respuesta
El fallo está en la línea 2: val total = inputs.sumOf { it.toInt() } Se arregla con val total = inputs.sumOf { it.toIntOrNull() ?: 0 }.
toInt() lanza una excepción si el texto no es un número. toIntOrNull() devuelve null y, con ?:, se decide qué hacer con los valores no válidos.
4 · Elige la respuesta · nivel 2
¿En qué orden se imprimen las letras?
```
runBlocking {    launch {        delay(100)        println("B")    }    println("A")}println("C")
```
- AA B C
- BB A C
- CA C B
- DC A B
Ver la respuesta
Respuesta: A. A B C
launch arranca una corrutina sin bloquear, así que A sale primero. runBlocking no termina hasta que acaban todas sus corrutinas hijas (concurrencia estructurada), por eso B se imprime antes de C.
5 · Completa el hueco · nivel 2
Completa la función de extensión para poder escribir 4.isEven().
```
fun ___.isEven() = this % 2 == 0 fun main() {    println(4.isEven())}
```
- Int
- String
- Boolean
- Unit
Ver la respuesta
Respuesta: Int
```
fun Int.isEven() = this % 2 == 0 fun main() {    println(4.isEven())}
```
El tipo antes del punto es el receptor: la función se podrá llamar sobre valores de ese tipo y dentro de ella `this` es el valor. Como 4 es un Int, el receptor tiene que ser Int.
6 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
fun String?.orDash() = this ?: "-"val missing: String? = nullprintln(missing.orDash() + "hola".orDash())
```
- A-hola
- BNullPointerException
- Cnullhola
- DNo compila: no se puede llamar a un método sobre null
Ver la respuesta
Respuesta: A. -hola
Una extensión sobre un tipo nullable (String?) se puede llamar sin ?. y dentro this puede ser null. Así están hechas isNullOrEmpty y orEmpty de la librería estándar.
7 · Completa el hueco · nivel 2
Completa para salir de la función en cuanto name sea null.
```
fun greet(name: String?): String {    val n = name ___ return "hola, desconocido"    return "hola, $n"}println(greet(null))
```
- ?:
- ?.
- !!
- ??
- ||
- else
Ver la respuesta
Respuesta: ?:
```
fun greet(name: String?): String {    val n = name ?: return "hola, desconocido"    return "hola, $n"}println(greet(null))
```
return es una expresión en Kotlin, así que puede ir a la derecha de ?:. A partir de esa línea, el compilador sabe que n no es null.
8 · Encuentra el fallo · nivel 2
Al llamar a greet(null) el programa revienta. ¿Qué línea tiene el fallo?
```
1fun greet(name: String?) {2    val length = name!!.length3    println("Hola, $name ($length letras)")4}5 6greet(null)
```
Ver la respuesta
El fallo está en la línea 2: val length = name!!.length
!! le dice al compilador que confíe en que no es null y lanza NullPointerException si lo es. Mejor name?.length ?: 0.
9 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
val result = sequenceOf(1, 2, 3, 4)    .map { println("map $it"); it * 2 }    .first { it > 2 }println(result)
```
- Amap 1 map 2 4
- Bmap 1 map 2 map 3 map 4 4
- C4
- Dmap 2 4
Ver la respuesta
Respuesta: A. map 1 map 2 4
Una Sequence procesa cada elemento de principio a fin antes de pasar al siguiente, y first se detiene al encontrar 4. Con una List, map transformaría los cuatro elementos antes de buscar.

10 · Completa el hueco · nivel 2

Completa para validar el argumento y leer el mensaje del error.

fun withdraw(balance: Int, amount: Int): Int {    ___(amount <= balance) { "saldo insuficiente" }    return balance - amount}println(runCatching { withdraw(10, 50) }.exceptionOrNull()?.___)

require
message
assert
throw
cause
error

Ver la respuesta

Respuesta: require · message

fun withdraw(balance: Int, amount: Int): Int {    require(amount <= balance) { "saldo insuficiente" }    return balance - amount}println(runCatching { withdraw(10, 50) }.exceptionOrNull()?.message)

require lanza IllegalArgumentException con el mensaje del bloque si la condición es falsa; es la forma idiomática de validar argumentos. runCatching captura la excepción y exceptionOrNull la devuelve.

11 · Encuentra el fallo · nivel 2
El usuario escribe SALIR y responde desconocido. ¿Qué línea tiene el fallo?
```
1val cmd = "SALIR"2when (cmd.lowercase()) {3    "Salir" -> println("adiós")4    else -> println("desconocido")5}
```
Ver la respuesta
El fallo está en la línea 3: "Salir" -> println("adiós") Se arregla con "salir" -> println("adiós").
El sujeto ya está en minúsculas, así que la rama tiene que compararse con "salir". Otra opción es when { cmd.equals("salir", ignoreCase = true) -> ... }.
12 · Elige la respuesta · nivel 2
¿Qué imprime este código?
```
sealed interface Eventdata class Click(val x: Int) : Eventdata object Close : Event fun describe(e: Event) = when (e) {    is Click if e.x < 0 -> "fuera"    is Click -> "clic en ${e.x}"    Close -> "cerrar"}println(describe(Click(-3)))
```
- Afuera
- Bclic en -3
- CNo compila: when no admite condiciones
- Dcerrar
Ver la respuesta
Respuesta: A. fuera
Desde Kotlin 2.2, una rama de when con sujeto puede añadir una condición de guarda con if. Se evalúan en orden, así que Click(-3) entra en la primera rama.

Preguntas de entrevista de otras rutas

Ver todos los ejercicios de Kotlin