Contestando aleatoriamente

Modifiqué el código de la función main para que te siga pidiendo opciones hasta que le digas salir en vez de que se cierre el programa cuando termine una opción:

fun main() {
    // Declarar el mensaje de entrada del programa
    while(true)
    {
        println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
        println("1. Realizar una pregunta.")
        println("2. Revisar todas las respuestas.")
        println("3. Salir")

        // Obtener el valor del usuario y convertirlo a un entero nullable
        val valorIngresado = readLine()

        // Dependiendo del numero utilizamos el when para realizar una acción.
        when (valorIngresado){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> {
                salir()
                break
            }
            else -> mostrarError()
        }
        println()
    }
}

Reto terminado
Agregué un ciclo do while para que el programa siga corriendo al terminar una opción, y que termine cuando el usuario lo decida, además de usar una lambda para resolver el reto:

//Answers
const val POSITIVE_ANSWER = "✅"
const val NEGATIVE_ANSWER = "❌"
const val DOUBTFUL_ANSWER = "?"

//mapping answers
val answers = mapOf(
    "Yes" to POSITIVE_ANSWER,
    "It's true" to POSITIVE_ANSWER,
    "Totally" to POSITIVE_ANSWER,
    "Without a doubt" to POSITIVE_ANSWER,
    "Ask again later" to DOUBTFUL_ANSWER,
    "I can't answer that right now" to DOUBTFUL_ANSWER,
    "Maybe" to DOUBTFUL_ANSWER,
    "It's not going to happen" to NEGATIVE_ANSWER,
    "Don't count on that" to NEGATIVE_ANSWER,
    "Definitely" to NEGATIVE_ANSWER,
    "I don't think so" to NEGATIVE_ANSWER,
)

fun main(args: Array<String>) {
    var input: String
    do {
        println("""
            
        "Hello, I'm the Kotlin 8 ball. What do you want to do?"
        1. Ask something
        2. Check answers
        3. Exit
    """.trimIndent())
        input = readLine().toString()

        when(input) {
            "1" -> askSomething()
            "2" -> showAnswers()
            "3" -> exit()
            else -> showError()
        }
    } while (input == "1" || input == "2" || input == "3")
}

fun askSomething() {
    println("What is you question?")
    readLine()
    val answer = answers.keys.random()
    println("So... that's your question... The answer is: $answer")
}

fun showAnswers() {
    println("""
        Select one option:
        1. All answers
        2. Positive answers
        3. Negative answers
        4. Doubtful answers
    """.trimIndent())
    val input = readLine()
    when(input) {
        "1" -> answersType(type = "ALL")
        "2" -> answersType(type = POSITIVE_ANSWER)
        "3" -> answersType(type = NEGATIVE_ANSWER)
        "4" -> answersType(type = DOUBTFUL_ANSWER)
        else -> println("Not a valid input. Goodbye.")
    }
}

fun answersType(type: String = "ALL") {
    val printAnswers: (Map<String, String>) -> Unit = {
        it.keys.forEach { answer -> println(answer) }
    }
    when(type) {
        "ALL" -> answers.keys.forEach { answer -> println(answer) }
        POSITIVE_ANSWER -> answers.filterValues { value -> value == POSITIVE_ANSWER }
            .also { printAnswers(it) }
        NEGATIVE_ANSWER -> answers.filterValues { value -> value == NEGATIVE_ANSWER }
            .also { printAnswers(it) }
        DOUBTFUL_ANSWER -> answers.filterValues { value -> value == DOUBTFUL_ANSWER }
            .also { printAnswers(it) }
        else -> println("Error, bye.")
    }
}

fun exit() {
    println("See you later.")
}

fun showError() {
    println("There was an error...")
} 

Efectivamente se reduce bastante el código haciendo que cada also llame a un lambda. Aunque no sé si debí hacerlo así o el reto era crear una función de orden superior. Igual funciona, aunque si se necesitara imprimir de la misma forma en otra parte del código sí sería mejor crear una función.

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {

    val imprimirRespuestas : (Map<String, String>) -> Unit = { respuestas ->
        respuestas.keys.forEach { respuesta -> println(respuesta) }
    }

    when (tipoDeRespuesta){
        "TODOS" -> imprimirRespuestas(respuestas)
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also(imprimirRespuestas)

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also(imprimirRespuestas)

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also(imprimirRespuestas)
    }
}

Ajusté el código para que me regresara al menú inicial en lugar de terminar el programa. Hice una nueva funcion para desplegar el menú inicial,

fun main(args: Array<String>) {
    println("Hola soy tu bola 8 magica creada en Kotlin. Cual de estas opciones deseas realizar?")
    desplegarMenuInicial()
}

fun desplegarMenuInicial(){
    println()
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()

    when(valorIngresado) {
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostrarError()
    }
}

y mando llamar esa funcion al final de las siguientes funciones:

fun realizarPregunta(){
...
    desplegarMenuInicial()
}

fun mostrarRespuestas(){
...
    desplegarMenuInicial()
}

fun mostrarError(){
...
    desplegarMenuInicial()
}

Para el tema del reto, me quedo asi:

fun mostrarRespuestasPorTipo(tipoRespuesta : String = "TODOS"){

    val imprimirRespuestas : (Map<String, String>) -> Unit = { respuestas -> respuestas.keys.forEach { respuesta -> println(respuesta) }}
    when(tipoRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also{imprimirRespuestas(it)}

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also{imprimirRespuestas(it)}

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also{imprimirRespuestas(it)}
    }
}

// Answers declaration
const val AFFRIRMATIVE_ANSWER = "✅"
const val NEGATIVE_ANSWER = "❌"
const val UNKNOWN_ANSWER = "\uD83E\uDD14"

// Joining answers with values
val answer = mapOf(
    "Absolutely yes" to AFFRIRMATIVE_ANSWER,
    "True" to AFFRIRMATIVE_ANSWER,
    "Totally" to AFFRIRMATIVE_ANSWER,
    "No doubt" to AFFRIRMATIVE_ANSWER,
    "Try asking later" to UNKNOWN_ANSWER,
    "I can't tell you right now" to UNKNOWN_ANSWER,
    "Maybe, maybe not..." to UNKNOWN_ANSWER,
    "Yeah, that's not happening" to NEGATIVE_ANSWER,
    "Don't count on it" to NEGATIVE_ANSWER,
    "Definitely not" to NEGATIVE_ANSWER,
    "I don't think so" to NEGATIVE_ANSWER,
)

fun menu()
{
    do
    {
        println("Hi! I'm your magic ball (made in Kotlin). Which of this options would you like to try?\n" +
                "1. Ask a question.\n" +
                "2. See all answers.\n" +
                "3. Exit.\n")
        val option = readLine()

        when(option)
        {
            "1" -> askQuestion()
            "2" -> showAnswers()
            "3" -> break
            else -> println("Please enter a valid option")
        }

    }
    while(option != "3")

}

fun askQuestion()
{
    println("Please ask your question")
    readLine()
    println("The answer to your question is...")
    val generatedAnswer = answer.keys.random()
    println(generatedAnswer)
}

fun showAnswers()
{

    do
    {
        println("Please choose an option\n" +
                "1. Show all answers\n" +
                "2. Show only affirmative answers\n" +
                "3. Show only negative answers\n" +
                "4. Show only unknown answers\n" +
                "5. Return to main menu\n")
        val option = readLine()
        when(option)
        {
            "1" -> answer.keys.forEach{answers -> println(answers)}
            "2" -> answer.filterValues {values -> values ==  AFFRIRMATIVE_ANSWER}
                .also {affirmAns ->  println(affirmAns.keys)}
            "3" -> answer.filterValues {values -> values ==  NEGATIVE_ANSWER}
                .also {negAns ->  println(negAns.keys)}
            "4" -> answer.filterValues {values -> values ==  UNKNOWN_ANSWER}
                .also {unkAns ->  println(unkAns.keys)}
            "5" -> return menu()
            else -> println("Please enter a valid option")
        }
    }while (option != "5")
}

fun main(args: Array<String>)
{
    menu()
}

Mi codigo ésta clase ❤️

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "❓"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main() {
    println("""Hola soy tu bola 8 magica creada en Kotlin.
¿Cual de estas opciones deseas realizar?""".trimIndent())
    do {
        println("""
      1. Realizar una pregunta 
      2. Revisar todas las respuestas
      3. Salir 
  """.trimIndent())
        val valorRecibido = readLine()
        when(valorRecibido){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> {mostrarError()}
        }
    }
        while(valorRecibido != "3")

}

fun realizarPregunta(){
    println("Que pregunta deseas realizar? ")
    readLine()
    val respuestaGenerada = respuestas.keys.random()
    println("Asique esa era tu pregunta? La respuesta a eso es ✨${respuestaGenerada.lowercase()}✨")
}

fun mostrarRespuestas() {
    do {
        println("""
       Seleccione una opcion 
       1. Revisar todas las respuestas
       2. Revisar solo las afirmativas
       3. Revisar solo las negativas
       4. Revisar solo las dudosas
       5. Salir
   """.trimIndent())
        val opcionIngresada = readLine()
        when(opcionIngresada){
            "1" -> mostrarRespuestasPorTipo()
            "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
            "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
            "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
            "5" -> println("Volviendo al menu principal")
            else -> mostrarError()
        }
    }
    while(opcionIngresada != "5")
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{ respuesta -> println(respuesta)}

        RESPUESTA_AFIRMATIVA -> respuestas.filterValues{ valores -> valores == RESPUESTA_AFIRMATIVA}
            .also{ respuestasAfirmativas -> println(respuestasAfirmativas.keys) }

        RESPUESTA_NEGATIVA -> respuestas.filterValues{ valores -> valores == RESPUESTA_NEGATIVA}
            .also{respuestasNegativas -> println(respuestasNegativas.keys)}

        RESPUESTA_DUDOSA -> respuestas.filterValues{ valores -> valores == RESPUESTA_DUDOSA}
            .also { respuestasDudosas -> println(respuestasDudosas.keys)}
    }
}

fun salir() {  println("Hasta luego!")  }

fun mostrarError() {
    println("Vaya, parece que has elegido una respuesta no valida, intenta denuevo.")
}

De esta manera no se repite el .also

package org.example


// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main() {
    // Declarar el mensaje de entrada del programa
    println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
    println("1. Realizar una pregunta.")
    println("2. Revisar todas las respuestas.")
    println("3. Salir")

    val valorIngresado = readLine()
    when(valorIngresado){
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostrarError()

    }


}

fun mostrarError() {
    println("Hay error")
}

fun salir() {
    println("Hasta luego")
}

fun mostrarRespuestas() {
    println("Selecciona una opción")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudodas")
    println("4. Revisar solo las respuestas negativas")

    val opcionIngresada = readLine()?.toInt()
    when(opcionIngresada){
        1 ->  mostrarRespuestasPorTipo()
        2 -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        3 -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        4 -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        else -> println("Respuesta no valida, adios.")
    }
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta: String = "TODOS") {
    val respuestasFiltradas = when (tipoDeRespuesta) {
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { it == RESPUESTA_AFIRMATIVA }
        RESPUESTA_NEGATIVA -> respuestas.filterValues { it == RESPUESTA_NEGATIVA }
        RESPUESTA_DUDOSA -> respuestas.filterValues { it == RESPUESTA_DUDOSA }
        else -> respuestas
    }

    respuestasFiltradas.keys.forEach { respuesta -> println(respuesta) }
}

fun realizarPregunta() {
    println("Que pregunta deseas realizar?")
    readLine()
    println("Así que eso es tu pregunta... La respuesta es:")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

Asi quedo mi bola magica

// Constantes de respuestas
const val AFFIRMATIVE_RESPONSE: String = "✅"
const val NEGATIVE_RESPONSE: String = "❌"
const val DOUBT_RESPONSE: String = "\uD83E\uDD14"

val ANSWERS = mapOf<String, String>(
    "Sí" to AFFIRMATIVE_RESPONSE,
    "Es cierto" to AFFIRMATIVE_RESPONSE,
    "Totalmente" to AFFIRMATIVE_RESPONSE,
    "Sin duda" to AFFIRMATIVE_RESPONSE,
    "Pregunta en otro momento" to DOUBT_RESPONSE,
    "No puedo decirte en este momento" to DOUBT_RESPONSE,
    "Puede que sí o puede que no" to DOUBT_RESPONSE,
    "No va a suceder" to NEGATIVE_RESPONSE,
    "No cuentes con ello" to NEGATIVE_RESPONSE,
    "Definitivamente no" to NEGATIVE_RESPONSE,
    "No lo creo" to NEGATIVE_RESPONSE
)

fun generateAnswer(): String {
    return ANSWERS.keys.random()
}

fun showAllAnswers() {
    println("Selecciona una opción")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudodas")
    println("4. Revisar solo las respuestas negativas")
    println("5. Volver atras.")


    val userInput: String? = readlnOrNull()
    when (userInput) {
        "1" -> showAnswersByType()
        "2" -> showAnswersByType(type = AFFIRMATIVE_RESPONSE)
        "3" -> showAnswersByType(type = DOUBT_RESPONSE)
        "4" -> showAnswersByType(type = NEGATIVE_RESPONSE)
        "5" -> init()
        else -> println("Respuesta no valida, adios.")
    }
}

fun generateQuestion() {
    println("Que quieres saber?")

    val userInput: String? = readlnOrNull() // El usuario ingresa su pregunta

    println("Entonces quieres saber si '$userInput'... la respuesta es:") // Le mostramos un texto para que lea

    println(generateAnswer()) // Generamos una respuesta

    init()
}

fun showAnswersByType(type: String? = null) {
    when (type) {
        null -> ANSWERS.keys.forEach { answer -> println("   - $answer") }

        AFFIRMATIVE_RESPONSE -> ANSWERS.filterValues { value -> value == AFFIRMATIVE_RESPONSE }
            .also { response -> response.keys.forEach { answer -> println("   - $answer") } }

        DOUBT_RESPONSE -> ANSWERS.filterValues { value -> value == DOUBT_RESPONSE }
            .also { response -> response.keys.forEach { answer -> println("   - $answer") } }

        NEGATIVE_RESPONSE -> ANSWERS.filterValues { value -> value == NEGATIVE_RESPONSE }
            .also { response -> response.keys.forEach { answer -> println("   - $answer") } }

    }

    showAllAnswers()

}

fun out() {
    println("Recuerda visitar www.kevinparralopez.com, nos vemos luego 🥺")
}

fun showError() {
    println("Vaya parece que has elegido una opción no valida, empezemos de nuevo:")
    init()
}

fun init() {
    println("1. Preguntame algo.")
    println("2. Revisar todas las respuestas.")
    println("3. Salir")

    val userInput: String? = readlnOrNull()

    when (userInput) {
        "1" -> generateQuestion()
        "2" -> showAllAnswers()
        "3" -> out()
        else -> showError()
    }
}

fun main(args: Array<String>) {
    println("¡Bienvenido a la Bola Mágica! Haz una pregunta:")
    init()
}

Utilice un ciclo do while para que pueda utilzar varias veces el menu, hasta que se desee salir, ademas de que le agregue tiempos de espera para poder ver el resultado mas facil

import java.time.Clock.system
import kotlin.system.exitProcess

const val AFIRMATIVA = 1
const val NEGATIVA = 2
const val DUDOSA = 3

val respuestas = mapOf(
 "Si" to AFIRMATIVA,
 "Es cierto" to AFIRMATIVA, 
 "Totalmente" to AFIRMATIVA, 
 "Sin duda" to AFIRMATIVA, 
 "Pregunta en otro momento" to DUDOSA, 
 "No puedo decirte" to DUDOSA, 
 "Quizas si, quizas no" to DUDOSA, 
 "No" to NEGATIVA, 
 "No va a suceder" to NEGATIVA, 
 "Ni pensarlo" to NEGATIVA, 
 "Definitivamente no" to NEGATIVA, 
)

fun main(args: Array<String>) {
    var onMenu = true
    do {
        println("¡Hola Bienvenido!")
        println("¿Que haremos esta vez? (Selecciona un numero)")
        println("1. Hacer una pregunta")
        println("2. Mostrar todas las respuestas")
        println("3. Mostrar las respuestas afirmativas")
        println("4. Mostrar las respuestas negativas")
        println("5. Mostrar las respuestas dudosas")
        println("6. Salir\n")

        when (readln()) {
            "1" -> ask()
            "2" -> show()
            "3" -> show(1)
            "4" -> show(2)
            "5" -> show(3)
            "6" -> onMenu = false
            else -> showError("La opcion escogida no es valida", fail = false)
        }
    } while (onMenu)
}

fun ask() {
    println("Cual es tu pregunta?")
    readln()
    val respuesta: String = respuestas.keys.random()
    print("Su respuesta es: $respuesta")
    Thread.sleep(3_000)
}


fun show(toShow: Int = 0) {
    val respuesta : Set<String> =
        if (toShow > 0) {
            respuestas.filter{ (key, value) -> value == toShow }.keys
        } else respuestas.keys
    print("Las respuestas que tenemos son:\n")
    respuesta.forEach {
        it -> println("$it\n")
    }
    Thread.sleep(5_000)
}

fun showError(msg: String, fail: Boolean = true) {
    print(msg)
    if (fail) exitProcess(122)
}

ya termine
import kotlin.random.Random

fun main() {
val respuestas = listOf(
“Sí”,
“No”,
“Probablemente”,
“Mejor pregúntame después”,
“No cuentes con ello”,
“No lo creo”,
“Las perspectivas no son buenas”,
“No puedo predecirlo ahora”
)

println("Hazme una pregunta y te responderé con la bola 8:")
readLine()

val respuestaAleatoria = respuestas[Random.nextInt(respuestas.size)]
println("La bola 8 dice: $respuestaAleatoria")

Código realizado con el reto muy buen curso para iniciar

// Delcaramos los valores de nuestras respuestas

const val YES_ANSWER =";)"
const val NO_ANSWER=":("
const val DOUBT_ANSWER ="?"

// Unimos las respuestas con nuestros valores

val answers = mapOf(
    "Si" to YES_ANSWER,
    "Es cierto" to YES_ANSWER,
    "Totalmente" to YES_ANSWER,
    "Sin duda" to YES_ANSWER,
    "Pregunta en otro momento" to DOUBT_ANSWER,
    "No puedo decirte en este momento" to DOUBT_ANSWER,
    "Puede que si o puede que no" to DOUBT_ANSWER,
    "No va suceder" to NO_ANSWER,
    "No cuentes con ello" to NO_ANSWER,
    "Definitivamente no" to NO_ANSWER,
    "No lo creo" to NO_ANSWER,
    )

fun main (args: Array<String>){
    do {
        println("""
            "Hola soy tu bola 8 magica creada en Kotlin. Cual de estas opciones deseas realizar?"
            1.Realizar una pregunta
            2.Revisar todas las respuestas
            3. Salir
            
        """.trimIndent())
        val input = readLine().toString()
    when (input){
        "1" -> askQuestion ()
        "2"  -> showAnswer ()
        "3"  -> exit ()
        else -> showError()
    }
    }while (input == "1" || input == "2" || input== "3")

}
fun exit(){
    println("Hasta luego!")
}
fun showError (){
    println("Parece que selecionaste una ocpion no valida intenta de nuevo")
}
fun showAnswer() {
    println("Seleciona una opcion")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas ")
    println("3. Revisar solo las respuestas dudosas")
    println("4.Revisar solo las respuestas negativas")

    val optionEntered = readLine()
    when(optionEntered){
        "1" -> showAnswerByType()
        "2" -> showAnswerByType(typeOfAnswer = YES_ANSWER)
        "3" -> showAnswerByType(typeOfAnswer = DOUBT_ANSWER)
        "4" -> showAnswerByType(typeOfAnswer = NO_ANSWER)
        else -> println("Repuesta no valida. Adios")
    }

}
fun showAnswerByType(typeOfAnswer: String= "TODOS"){
    when (typeOfAnswer){
        "TODOS" -> answers.keys.forEach({ answer -> println(answer) })
        YES_ANSWER-> answers.filterValues { values -> values== YES_ANSWER }
            .also { positiveAnswers -> println(positiveAnswers.keys) }
        NO_ANSWER-> answers.filterValues { values -> values== NO_ANSWER }
            .also { negativeAnswers -> println(negativeAnswers.keys) }
        DOUBT_ANSWER-> answers.filterValues { values -> values== DOUBT_ANSWER }
            .also { doubtAnswers -> println(doubtAnswers.keys) }
    }

}

fun askQuestion(){
    println("Que pregunta deseas realizar?")
    readLine()
    println("Asi que esas tu pregunta... la respuesta a eso es:")
    val anserwsGenerated =  answers.keys.random()
    println(anserwsGenerated)
}

Mi respuesta al reto

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS"){
    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        tipoDeRespuesta->  respuestas.filterValues{ values -> values == tipoDeRespuesta }
            .also { respuestaSelect -> println(respuestaSelect.keys) }
    }

Les comparto una solución que se me ocurrió 😄

import kotlin.system.exitProcess

const val RIGHT_ANSWER = "✔️"
const val WRONG_ANSWER = "❌"
const val NO_ANSWER = "❔"

val answers = mapOf(
    "yes" to RIGHT_ANSWER,
    "It is certain" to RIGHT_ANSWER,
    "totally" to RIGHT_ANSWER,
    "no doubt" to RIGHT_ANSWER,
    "ask again later" to NO_ANSWER,
    "i can't answer now" to NO_ANSWER,
    "maybe" to NO_ANSWER,
    "it is not going to happen" to WRONG_ANSWER,
    "do not count on it" to WRONG_ANSWER,
    "definitely not" to WRONG_ANSWER,
    "i don't think so" to WRONG_ANSWER
)

fun main(args: Array<String>) {
    println("Hello i'm the magic 8 ball 🎱")
    println("i'm built with Kotlin and i'm going to answer all your questions")
    println("what do you wish to do today?")
    while (true) {
        println("********** Select an option **********")
        println("1. Ask a question")
        println("2. Review answers")
        println("3. Exit")
        println("**************************************")
        when (readln()) {
            "1" -> askQuestion()
            "2" -> reviewAnswers()
            "3" -> exit()
            else -> showInvalidOption()
        }
    }
}

fun showInvalidOption() {
    println("Invalid option, goodbye!")
    exitProcess(0)
}

fun exit() {
    println("Bye bye!")
    exitProcess(0)
}

fun reviewAnswers() {
    println("Select an option:")
    println("1. Show all answers")
    println("2. Show only right answers")
    println("3. Show only wrong answers")
    println("4. Show only no answers")

    when (readln()) {
        "1" -> showAnswersPerType()
        "2" -> showAnswersPerType(RIGHT_ANSWER)
        "3" -> showAnswersPerType(WRONG_ANSWER)
        "4" -> showAnswersPerType(NO_ANSWER)
        else -> showInvalidOption()
    }
}


fun showAnswersPerType(answerType: String = "all") {
    println("--------------------------------------")
    if (answerType != "all") showAnswer(answerType) else answers.keys.forEach { println(it) }
    println("--------------------------------------")
}

private fun showAnswer(answerType: String) {
    answers.filterValues { it == answerType }
        .keys.forEach(::println)
}

fun askQuestion() {
    println("what is your question?")
    readlnOrNull()
    println("so, that's your question...")
    println("the answer is ${answers.keys.random()}")
}

Listo quedo el reto solucionado

import java.lang.Exception;
//Declaramos los valores de nustra respuesta
const val RespuestaAfirmativa = "✔"
const val RespuestaNegativa = "😒"
const val RespuestaDudosa = "❓"

//unimos las respuestas con los valores
val respuestas = mapOf<String,String>(
    "Si" to RespuestaAfirmativa,
    "Es cierto" to RespuestaAfirmativa,
    "Totalmente" to RespuestaAfirmativa,
    "Sin duda" to RespuestaAfirmativa,
    "Pregunta en otro momento" to RespuestaDudosa,
    "No puedo decirte en este momento" to RespuestaDudosa,
    "Puede que si o puede que no" to RespuestaDudosa,
    "No va a succeder" to RespuestaNegativa,
    "No cuentes con ello" to RespuestaNegativa,
    "Definitivamente no" to RespuestaNegativa,
    "No lo creo" to RespuestaNegativa,
)

fun main(args: Array<String>) {
    //println("Hola soy tu bola 8 magica creada en kotlin cual de estas opciones deseas realizar")
    //println("1. Quiero realizar una pregunta")
    //println("2. Realizar todas las respuestas")
    //println("3. Salir")

    //val ValorIngresado = readLine()

    //when(ValorIngresado){
        //"1" -> RealizarPregunta()
        //"2" -> MostrarRespuestas()
        //"3" -> Salir()
        //else -> ErrorEleccion()
    //}

    val MyLamda : () -> String = {
        Bola8Process(Opcion1 = "4")
    }

    println(MyLamda())
}

fun Bola8Process(Opcion1: String, Opcion2: String = "", Pregunta:String = ""):String
{
    val respuesta:String = when(Opcion1){
        "1" ->  RealizarPregunta(Pregunta)
        "2" -> MostrarRespuestas(Opcion2)
        "3" -> Salir()
        else -> ErrorEleccion()
    }

    return respuesta
}

//Funcion para preguntas
fun RealizarPregunta(Pregunta:String): String
{
    //println("Que prgunta deseas realizar")
    //readLine()
    //println("Asi que esa era tu pregunta la respuesta a eso es: ")
    return respuestas.keys.random()
    //println(respuestaGenerada)
}

//Funcion para respuestas
fun MostrarRespuestas(Opcion2:String): String {
    //println("Seleciona una opcion")
    //println("1. Revisar Todas las respuestas")
    //println("2. Revisar solo las respuesas afirmativas")
    //println("3. Revisar solo las respuestas dudosas")
    //println("4. Revisar solo las respuestas Negativas")

    //val opcionIngresada = readLine()

    val RespuestasString = when (Opcion2) {
        "1" -> MostrarRespuestasTipo("TODOS")
        "2" -> MostrarRespuestasTipo(RespuestaAfirmativa)
        "3" -> MostrarRespuestasTipo(RespuestaDudosa)
        "4" -> MostrarRespuestasTipo(RespuestaNegativa)
        else -> ErrorEleccion()
    }

    return RespuestasString;
}

fun MostrarRespuestasTipo(tipoDeRespuesta: String = "TODOS"):String {

    var Respuestas: String = "["

    when(tipoDeRespuesta){
        "TODOS" -> respuestas.also { respuesta -> respuesta.forEach{respuesta -> Respuestas = Respuestas +" , "+ respuesta.key}}
        RespuestaAfirmativa -> respuestas.filterValues{values -> values == RespuestaAfirmativa}
            .also { respuesta -> respuesta.forEach{respuesta -> Respuestas = Respuestas + " , " + respuesta.key}}

        RespuestaNegativa -> respuestas.filterValues{values -> values == RespuestaNegativa}
            .also { respuesta -> respuesta.forEach{respuesta -> Respuestas = Respuestas + " , " + respuesta.key} }

        RespuestaDudosa -> respuestas.filterValues{values -> values == RespuestaDudosa}
            .also { respuesta -> respuesta.forEach{respuesta -> Respuestas = Respuestas + " , " + respuesta.key} }
    }

    Respuestas = Respuestas + "]"
    return Respuestas
}

//Error de eleccion
fun ErrorEleccion(): String {
    //println("Error opcion incorrecta")
    return "Error opcion incorrecta"
}


//Salir
fun Salir():String
{
    return "Hasta Luego!"
}

cumpli con el desafio que dice al final, en lugar del .also{} uso una lambda guardada en una variable

// la lambda
    val printKeys : (Map<String,String>) -> Unit = {println(it.keys)}

  fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
        when (tipoDeRespuesta){
            "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
            RESPUESTA_AFIRMATIVA -> printKeys(respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA })
            RESPUESTA_DUDOSA -> printKeys(respuestas.filterValues { values -> values == RESPUESTA_DUDOSA })
            RESPUESTA_NEGATIVA -> printKeys(respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA })

        }
    }

El Bug ha sido solucionado ya no debes hacer un enter o te mandará un error.

He agregado otro listOf, para que al momento de hacer la pregunta diga una frase diferente

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)
val primeraLinea = listOf(
    "Excelente pregunta veamos", "Vaya desperdicio de pregunta ya que", "Curioso muy Curioso pero", "He leído mejores preguntas de un Zapato lo he dicho ya"
)


fun main(args: Array<String>) {
    println("Hola soy tu Bola Mágica creada en Kotlin, ¿Cuál de estas opciones deseas realizar?")
    println("1. Quiero realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()

    when(valorIngresado){
        "1" -> realizarPregunta()
        "2" -> mostrasRespuestas()
        "3" -> salir()
        else -> mostrarErro()
    }
}

fun mostrarErro() {
    println("Vaya has elegido una opción no valida Hasta luego!")
}

fun salir() {
    println("Hasta luego!")
}

fun mostrasRespuestas() {
    println("Selecciona una opción")
    println("1. Revisar todas las respuesta")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las repsuestas dudodas")
    println("4. Revisar solo las respuestas negativas")

    val opcionIngresada = readLine()
    when(opcionIngresada){
        "1" -> mostrarRespuestasTipo()
        "2" -> mostrarRespuestasTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        "4" -> mostrarRespuestasTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        else -> println("Respuesta no valida Adios")
    }
}
fun mostrarRespuestasTipo(tipoDeRespuesta : String = "TODOS"){
    when (tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{ respuesta -> println(respuesta)}
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA}
        .also {respuestasPositivas -> println(respuestasPositivas.keys) }

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA}
            .also {respuestasDudosas -> println(respuestasDudosas.keys) }

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA}
            .also {respuestasNegativas -> println(respuestasNegativas.keys) }
    }

}

fun realizarPregunta(){
    println("¿Cuál es tu pregunta?")
    readLine()
    val primeraLineaR = primeraLinea.random()
    println("$primeraLineaR")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

Realicé aparte del reto,
-una funcion para el menu y llamarlo cuando se requiera, utilizando do while.

• una funcion preguntar otra vez, la cual se ejecuta despues de cada opcion,preguntando si quiere realizar otra pregunta o si por el contrario quiere salir
  comparto repo con apuntes de la clase y proyecto

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"
var valorIngresado = "";

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)


fun main() {
   menu()
}
fun menu(){
    do{


        // Declarar el mensaje de entrada del programa
        println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
        println("1. Realizar una pregunta.")
        println("2. Revisar todas las respuestas.")
        println("0. Salir")

        // Obtener el valor del usuario y convertirlo a un entero nullable
        valorIngresado = readLine().toString()

        // Dependiendo del numero utilizamos el when para realizar una acción.
        when (valorIngresado){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "0" -> salir()
            else -> mostrarError()
        }
    }while(valorIngresado != "0");
}
fun mostrarError() {
    println("Ups... Opción Invalida, elige una opcion nueva¿")
}

fun salir() {
    println("Hasta Luego")
}
fun realizarPreguntaOtraVez(){
    println("¿Deseas realizar otra pregunta?\n Selecciona: \n 1. Si \n 2. No")
    valorIngresado = readLine().toString()
    when(valorIngresado){
        "1" -> menu()
        "2" -> salir()
    }
}
fun realizarPregunta(){
    println ("Que pregunta deseas realizar");
    readLine()
    val respuestaGenerada = respuestas.keys.random()
    println("Así que esa era tu pregunta... La respuesta a eso es... $respuestaGenerada\n")
    realizarPreguntaOtraVez()

}
fun mostrarRespuestas(){
    println ("Selecciona una opción")
    println ("1.Revisar todas las respuestas")
    println ("2.Revisar solo las respuestas afirmativas")
    println ("3.Revisar solo las respuestas dudosas")
    println ("4.Revisar solo las respuestas negativas")
    val opcion=readLine()
    when (opcion){
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(RESPUESTA_NEGATIVA)
        "4" -> mostrarRespuestasPorTipo(RESPUESTA_DUDOSA)
        else -> println ("Respuesta no valida, Adiós")
    }
}
fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {

    val imprimirRespuestas : (Map<String, String>) -> Unit = { respuestas ->
        respuestas.keys.forEach { respuesta -> println(respuesta) }
    }

    when (tipoDeRespuesta){
        "TODOS" -> imprimirRespuestas(respuestas)
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also(imprimirRespuestas)
        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also(imprimirRespuestas)

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also(imprimirRespuestas)
    }
    println()
    realizarPreguntaOtraVez()
}

Mi solución al reto es usar un ciclo for, excluyendo la opción de mostrar todas las respuestas ya q era mas simple meter la función en el mismo when.
Ademas, al hacer un print de la key y de la value se muestra la respuesta y tambien el emoji correspondiente ✅❌🤔

fun mostrarRespuestas() {
    println("""
    Selecciona una opción:
    1. Revisar todas las respuestas
    2. Revisar solo las respuestas afirmativas
    3. Revisar solo las respuestas dudodas
    4. Revisar solo las respuestas negativas""".trimIndent())

    val userInput : String? = readlnOrNull()

    when (userInput) {
        "1" -> respuestas.forEach { println("${it.key} ${it.value}") }
        "2" -> respuestaXTipo(tipo = RESPUESTA_AFIRMATIVA)
        "3" -> respuestaXTipo(tipo = RESPUESTA_DUDOSA)
        "4" -> respuestaXTipo(tipo = RESPUESTA_NEGATIVA)
        else -> println("Esa opción no es valida! Por favor, intentalo nuevamente con una de las opciones validas\n")
    }
}
fun respuestaXTipo(tipo: String) {
    println("Ahi van las respuestas $tipo!")
    for (respuestas in respuestas.filterValues { it == (tipo) }) {
        println("> ${respuestas.key} ${respuestas.value} ")
    }
    println("\n")
}

Respuesta sobre reto:

//Declarando valores de las respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "?"

//uniendo las respuestas con sus valores
val respuestas = mapOf(
    "SI!" to RESPUESTA_AFIRMATIVA,
    "Es Correcto!" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Indudablemente" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No te lo puedo decir en este momento" to RESPUESTA_DUDOSA,
    "Quizá si, quizá no" to RESPUESTA_DUDOSA,
    "Eso no va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA
)

fun main(args: Array<String>){
    var ind = "1";
    println("Hola soy tu bola 8 mágica creada en Kotlin.")
    do{
        println("¿Cuál de estas opciones desea realizar?")
        println("1. Realizar una pregunta")
        println("2. Revisar todas las respuestas")
        println("3. Salir")

        val valorIngresado = readLine();
        when(valorIngresado){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> mostrarError()
        }

        ind = valorIngresado ?: "1";
    }while (!ind.equals("3"))
}

fun salir() {
    println("Hasta Luego!")
}

fun mostrarRespuestas() {
    println("Selecciona una opción")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas AFIRMATIVAS")
    println("3. Revisar solo las respuestas NEGATIVAS")
    println("4. Revisar solo las respuestas DUDOSAS")

    when(readLine()) {
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        else -> mostrarError()
    }
}

fun mostrarError() {
    println("Respuesta no Valida\nIntentelo de nuevo por favor")
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta: String = "TODOS") {
    val imprimirRespuetas : (Map<String, String>) -> Unit = {
        it.keys.forEach { respuesta -> println(respuesta) }
    }

    when(tipoDeRespuesta){
        "TODOS" -> imprimirRespuetas(respuestas);

        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also { imprimirRespuetas(it) };

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also { imprimirRespuetas(it) };

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also { imprimirRespuetas(it) };
    }
}

fun realizarPregunta(){
    println("Qué pregunta deseas realizar?")
    readLine()

    println("Así que esa era tu pregunta... la respuesta a eso es: ")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

En mi proyecto hice 2 cosas, el Menu lo cree como funcion que retorna el valor de la opcion ingresada para entrar al when en el main, e hice que el menu apareciera en modod de loop hasta que el usuario decida salir, para hacerlo mas interactivo

fun Menu() : String? {
    println("BOLA MAGICA CREADA EN KOTLIN")
    println("QUE DESEAS MI JOVEN VISITANTE")
    println("1. Realizar Una pregunta")
    println("2. revisar las respuestas")
    println("3. Salir")
    val opcion = readLine()
    return opcion
} 
fun main(){
    while (true){
        val opcion = Menu()
        when (opcion) {
            "1" -> RealizarPregunta()
            "2" -> MostrarRespuestas()
            "3" -> {
                Salir()
                break
            }
            else -> MostrarError()
        }
    }
}

Reto terminado

agregue 2 do while para poder navegar entre el menu principal y el menu para consultar respuestas

import java.util.function.DoubleUnaryOperator

//Declarando valores de las respuestas

const val AFFIRMATIVE_ANSWER = "✅"
const val NEGATIVE_ANSWER = "❌"
const val DOUBTFUL_ANSWER = "?"

//uniendo las respuestas con sus valores
val answers = mapOf(
    "Yes" to AFFIRMATIVE_ANSWER,
    "It's true" to AFFIRMATIVE_ANSWER,
    "Totally" to AFFIRMATIVE_ANSWER,
    "Undoubtedly" to AFFIRMATIVE_ANSWER,
    "Ask in an other moment" to DOUBTFUL_ANSWER,
    "I can't say you in this moment" to DOUBTFUL_ANSWER,
    "Maybe yes, or maybe not" to DOUBTFUL_ANSWER,
    "It's not going to happen" to NEGATIVE_ANSWER,
    "Do not count on it" to NEGATIVE_ANSWER,
    "Definitely not" to NEGATIVE_ANSWER,
    "I don't believe it" to NEGATIVE_ANSWER
)


fun main(args: Array<String>) {
    //Declarando el menu principal
    val input:String =""
    do {
        println(
            "Hello, I'm the Kotlin 8 Ball. What do you want to do?\n" +
                    "1. Ask a question\n" +
                    "2. Check all answers\n" +
                    "3. Exit"
        )
        //leyendo la respuesta del usuario
        val inputValue = readLine()

        //funciones a executar segun la respuesta del usuario
        when (inputValue) {
            "1" -> askQuestion()
            "2" -> checkAnswer()
            "3" -> { exit()
                break
            } 

            else -> showError()
        }
    }while (input != "3")
}

fun askQuestion(){
    println("What question do you want to ask?")
    readLine()
    println("Wow! So that was your question")
    val generatedAnswer = answers.keys.random()
    println(generatedAnswer)
}
fun checkAnswer(){
    val input:String =""
    do {
        println(
            "Select option\n" +
                    "1. Review all answers\n" +
                    "2. Review only affirmative answers\n" +
                    "3. Review only doubtful answers\n" +
                    "4. review only negative answers\n" +
                    "5. Exit"
        )
        val inputOption = readLine()
        when (inputOption) {
            "1" -> showAnswersByType()
            "2" -> showAnswersByType(answerType = AFFIRMATIVE_ANSWER)
            "3" -> showAnswersByType(answerType = DOUBTFUL_ANSWER)
            "4" -> showAnswersByType(answerType = NEGATIVE_ANSWER)
            "5" -> break
            else -> println("Invalid answer, try again")
        }
    }while (input != "5")
}

fun showAnswersByType(answerType:String = "ALL") {
    val printAnswers:(Map<String,String>)->Unit={ groupAnswers-> groupAnswers.keys.forEach{answer-> println(answer)}}
    when(answerType){
        "ALL"->answers.keys.forEach{ answer -> println(answer)}

        AFFIRMATIVE_ANSWER->answers.filterValues { values->values == AFFIRMATIVE_ANSWER }
            .also {printAnswers(it)}
        NEGATIVE_ANSWER->answers.filterValues { values->values == NEGATIVE_ANSWER }
            .also { printAnswers(it)}
        DOUBTFUL_ANSWER->answers.filterValues { values->values ==DOUBTFUL_ANSWER }
            .also { printAnswers(it)}
    }
}

fun exit(){
    println("Goodbye!")

}
fun showError(){
    println("Wow, it seems that you have chosen an invalid option, try again")

Reto cumplido
Agregue que al usuario se le pregunte si desea relizar otra consulta al terminar una opción, en vez de simplemente terminar el programa como en el código original.

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main() {
    var terminado = false;

    while(terminado == false) {
        // Declarar el mensaje de entrada del programa
        println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
        println("1. Realizar una pregunta.")
        println("2. Revisar todas las respuestas.")
        println("3. Salir")

        // Obtener el valor del usuario y convertirlo a un entero nullable
        val valorIngresado = readLine()

        // Dependiendo del numero utilizamos el when para realizar una acción.
        when (valorIngresado) {
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> mostrarError()
        }

        if(valorIngresado != "3"){
            println("¿Desea realizar otra operación?: ")
            println("0. NO")
            println("1. SI")
            val realizarOtraOperacion = readLine()

            if(realizarOtraOperacion == "1")  terminado = false
            else terminado = true

            /*Forma alternativa corta y recomendada por el IDE
            *
            *  terminado = realizarOtraOperacion != "1"
            * */
        }
    }

}

fun mostrarError() {
    println("Parece que has elegido una opción no valida. Reintentando...")
}

fun salir() {
    println("Hasta luego, Ciao ")
}

fun mostrarRespuestas() {

        println("Selecciona una opción: ")
        println("1. Revisar todas las respuestas")
        println("2. Revisar solo las respuestas afirmativas")
        println("3. Revisar solo las respuestas dudosas")
        println("4. Revisar solo las repuestas negativas")

        val opcionIngresada = readLine()
        when(opcionIngresada){
            "1" -> mostrarRespuestasPorTipo()
            "2" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_AFIRMATIVA)
            "3" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_DUDOSA)
            "4" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_NEGATIVA)
            else -> println("No escojiste una opción valida. Intenta nuevamente...")
        }
}

fun mostrarRespuestasPorTipo(tipoRespuesta:String = "TODAS") {
    when(tipoRespuesta){
        "TODAS" -> respuestas.keys.forEach{  respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { value -> value == RESPUESTA_AFIRMATIVA }
            .also { imprimirRespuestas(it) }
        RESPUESTA_NEGATIVA -> respuestas.filterValues { value -> value == RESPUESTA_NEGATIVA }
            .also{imprimirRespuestas(it)}
        RESPUESTA_DUDOSA -> respuestas.filterValues { value -> value == RESPUESTA_DUDOSA }
            .also{imprimirRespuestas(it)}
    }

}

fun imprimirRespuestas(it: Map<String, String>) {
    println(it.keys)
}


fun realizarPregunta(){
    println("¿Qué pregunta deseas realizar?")
    readLine()
    println("Así que esa era tu pregunta... La respuesta a eso es: ")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "??"

val respuestas = mapOf(
    "Si" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun printStartUp() {
    println("Hola, soy tu Bola 8 mágica.")
    printMainMenu()
}

fun printMainMenu() {
    println("+-----------------------------------------+")
    println("Selecciona una opción")
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")
    println("+-----------------------------------------+")
}

fun printResponsesMenu() {
    println("+-----------------------------------------+")
    println("Seleccione una opción:")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudosas")
    println("4. Revisar solo las respuestas negativas")
    println("5. Volver")
    println("+-----------------------------------------+")
}

fun main() {
    printStartUp()
    do {
        val valorIngresado = readLine()
        when(valorIngresado) {
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> {
                salir()
                break
            }
            else -> mostrarError()
        }
        printMainMenu()
    }while (true)
}

fun realizarPregunta() {
    println("Que pregunta deseas realizar?")
    readLine()
    println("Asi que esa era tu pregunta.")
    print("La respuesta es: ")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

fun mostrarRespuestas() {
    printResponsesMenu()

    do {
        val opcionIngresada = readLine()
        when(opcionIngresada) {
            "1" -> mostrarRespuestasPorTipo()
            "2" -> mostrarRespuestasPorTipo(RESPUESTA_AFIRMATIVA)
            "3" -> mostrarRespuestasPorTipo(RESPUESTA_DUDOSA)
            "4" -> mostrarRespuestasPorTipo(RESPUESTA_NEGATIVA)
            "5" -> break
            else -> mostrarError()
        }
        printResponsesMenu()
    }while (true)
}

val getResponse : (Map<String, String>) -> Unit = {
    responses -> responses.keys.forEach { resp -> println(resp) }
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta: String = "TODOS") {
    when(tipoDeRespuesta) {
        "TODOS" -> getResponse(respuestas)

        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { resp -> resp == RESPUESTA_AFIRMATIVA }
            .also(getResponse)

        RESPUESTA_NEGATIVA -> respuestas.filterValues { resp -> resp == RESPUESTA_NEGATIVA }
            .also(getResponse)

        RESPUESTA_DUDOSA -> respuestas.filterValues { resp -> resp == RESPUESTA_DUDOSA }
            .also(getResponse)

    }
}

fun salir() {
    println("Hasta luego")
}

fun mostrarError() {
    println("Has elegido una opción incorrecta. Elige de nuevo")
}

Agregué un do while para que siempre este preguntando y reto realizado

<code> 
fun main(args: Array<String>) {

    do {
        println("Hola soy tu bola 8 mágica creada en Kotlin. Cual de estas opciones deseas realizar?")
        println("1. Realizar una pregunta")
        println("2. Revisar todas las respuestas")
        println("3. Salir")
        val valorIngresado = readLine()

        when(valorIngresado){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuesta()
            "3" -> salir()
            else -> mostrarError()
        }
    }while (valorIngresado != "3")
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS"){

    val lambda : (String) -> Map<String, String> = {
        tipoRespuesta -> respuestas.filterValues { value -> value == tipoRespuesta }.also { respuesta -> println(respuesta.keys) }
    }

    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{ respuesta -> println(respuesta)}
        RESPUESTA_AFIRMATIVA -> lambda(RESPUESTA_AFIRMATIVA)
        RESPUESTA_NEGATIVA -> lambda(RESPUESTA_NEGATIVA)
        RESPUESTA_DUDOSA -> lambda(RESPUESTA_DUDOSA)
    }
}

Anexo mi aporte con base en lo solicitado, modificando el contenido de also

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
   val respuestasPDN : (Map<String, String>) -> Unit = {
            valor -> println(valor.keys)
    }

    when(tipoDeRespuesta) {
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }

        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also { respuestasPDN(it) }

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also { respuestasPDN(it) }

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also { respuestasPDN(it) }
    }
} 

Saludos.

Ya termine, este es mi resultado 😄

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main() {
    println("Hola soy tu bola 8 magica en Kotlin. Cual de estas opciones deseas realizar?")
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()
    when(valorIngresado){
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostrarError()
    }
}

fun mostrarError() {
    println("Vaya parece que has elegido una opción no valida, intenta de nuevo.")
}

fun salir() {
    println("Hasta luego!")
}

fun mostrarRespuestas() {
    println("Selecciona una opción")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudosas")
    println("4. Revisar solo las respuestas negativas")

    val opcionIngresada = readLine()
    when(opcionIngresada){
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        else -> println("Respuesta no valida. Adios.")
    }
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS"){
    val imprimirRespuestas = { valor : String ->
        respuestas.filterValues { values -> values == valor }.also{respues -> println(respues)}
    }

    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{ respuesta -> println(respuesta)}
        RESPUESTA_AFIRMATIVA -> imprimirRespuestas(RESPUESTA_AFIRMATIVA)
        RESPUESTA_NEGATIVA -> imprimirRespuestas(RESPUESTA_NEGATIVA)
        RESPUESTA_DUDOSA -> imprimirRespuestas(RESPUESTA_DUDOSA)

    }
}

fun realizarPregunta(){
    println("Que pregunta deseas realizar?")
    readLine()
    println("Así que esa era tu pregunta... La respues a eso es:")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

Hice a mi parecer lo más fácil filtré he imprimí en la funcion mostrarRespuestasporTipo

<> fun mostrasRespuestasporTipo(tipodeRespuesta : String = "Todos") {
    when(tipodeRespuesta){
        "Todos" -> respuestas.keys.forEach{respuesta -> println(respuesta)};
        else -> respuestas.filterValues { values -> values == tipodeRespuesta}
            .also { respuestasPedidas -> println(respuestasPedidas.keys) }
    }
}

Modificacion de codigo con documentación.

// Declaramos las constantes de los tipo de respuestas que existen para nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

// Creamos un map donde estara cada una de las respustas con los tipos de respuestas
val respuestas: Map<String, String> = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main() {
    var ejecutar = true

    do{
        imprimirMenuPrincipal()
        when(readLine()?.toInt() ?: 0)
        {
            1 -> realizarPregunta()
            2 -> revisarRespuestas()
            3 -> ejecutar = salir()
            else -> println("ERROR. INGRESO UNA OPCION INCORRECTA. INTENTE DE NUEVO")

        }
    } while (ejecutar)


}

/**
 * Funcion que permite imprimir el menu
 */
fun imprimirMenuPrincipal() {
    println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
    println("1. Realizar una pregunta.")
    println("2. Revisar todas las respuestas.")
    println("3. Salir")
}

/**
 * Funcion que permite realizar una pregunta y responderla aleatoriamente
 */
fun realizarPregunta() {
    println("Cual es su pregunta?")
    val pregunta = readLine()
    val respuesta : String = respuestas.keys.random()
    println("La respuesta a la pregunta $pregunta es -> $respuesta")
}

/**
 * Funcion que permite imprimir el menu para mostrar las respuestas
 */
fun imprimirMenuRespuestas() {
    println("Que respuestas desea revisar:")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudodas")
    println("4. Revisar solo las respuestas negativas")
}

/**
 * Funcion que permite revisar las respuestas segun la opcion elegida 
 */
fun revisarRespuestas() {
    imprimirMenuRespuestas()

    val opcionTipoRespuesta : Int = readLine()?.toInt() ?: 0

    when(opcionTipoRespuesta) {
        1 -> mostrasRespuestasPorTipo()
        2 -> mostrasRespuestasPorTipo(RESPUESTA_AFIRMATIVA)
        3 -> mostrasRespuestasPorTipo(RESPUESTA_DUDOSA)
        4 -> mostrasRespuestasPorTipo(RESPUESTA_NEGATIVA)
        else -> println("ERROR. Ingreso un tipo de respuesta Invalido")
    }
}

/**
 * Funcion que permite mostrar las respuestas segun el tipo que se especifica como parametro
 */
fun mostrasRespuestasPorTipo(tipoRespuesta : String = "TODOS") {
    respuestas.filtrarPorTipo(tipoRespuesta)
        .also { respuestasFiltradas ->
            println(respuestasFiltradas.keys)
        }
}

/**
 * Funcion extendida de los maps<String, String> para filtrar por el tipo
 */
fun Map<String, String>.filtrarPorTipo(tipoRespuesta : String) : Map<String, String> {
    return if (tipoRespuesta == "TODOS") {
        respuestas
    }
    else {
        respuestas.filterValues {
                valueTemp -> valueTemp == tipoRespuesta
        }
    }
}

/**
 * Funcio que permite salir de la ejecucion del programa
 */
fun salir() : Boolean {
    println("Hasta la proxima")
    return false
}```

Modifique un poco:

fun showAnswerByType(typeAnswer: String = "TODOS") {
    when (typeAnswer) {
        "TODOS" -> answers.keys.forEach(::println)
        POSITIVE_ANSWER -> filterAnswers(POSITIVE_ANSWER)
        DOUBTFUL_ANSWER -> filterAnswers(DOUBTFUL_ANSWER)
        NEGATIVE_ANSWER -> filterAnswers(NEGATIVE_ANSWER)
    }
}

fun filterAnswers(type: String) {
    answers.filterValues { values ->
        values == type
    }.also { answer ->
        println(answer.keys)
    }
}

Mi código, con una función de extensión para Map:

const val AFFIRMATIVE_ANSWER = "o"
const val NEGATIVE_ANSWER = "x"
const val DOUBTFUL_ANSWER = "~"

val answers = mapOf<String, String>(
    "Yes"                   to AFFIRMATIVE_ANSWER,
    "That's true"           to AFFIRMATIVE_ANSWER,
    "Definitively"          to AFFIRMATIVE_ANSWER,
    "No doubts"             to AFFIRMATIVE_ANSWER,
    "Ask another time"      to DOUBTFUL_ANSWER,
    "I can't tell rn"       to DOUBTFUL_ANSWER,
    "Perhaps"               to DOUBTFUL_ANSWER,
    "That wouldn't happen"  to NEGATIVE_ANSWER,
    "Don't count on it"     to NEGATIVE_ANSWER,
    "Impossible"            to NEGATIVE_ANSWER,
    "I don't think so"      to NEGATIVE_ANSWER,
)

fun main() {
    var exit = false
    while(!exit){
        println("Magic 8 Ball! Choose an option:\n1. Ask Something\n2. Check all answers\n3. Exit")
        when(readLine()?.toIntOrNull()?: 0) {
            1 -> askSomething()
            2 -> checkAnswers()
            3 -> {
                println("Bye...")
                exit = true
            }
            else -> println("Invalid option! Try again...")
        }
        println()
    }
}

fun askSomething() {
    println("What do you want to know?")
    readLine()
    println("The answer is...")
    val ans = answers.keys.random()
    println("${answers[ans]} $ans")
}

fun checkAnswers() {
    println("""
        Select an option:
        1. All answers
        2. Positive answers
        3. Doubtful answers
        4. Negative answers
    """.trimIndent())

    when(readLine()?.toInt()?: 0){
        1 -> answers.keys.forEach { println(it) }
        2 -> answers.printFilteredAnswers(AFFIRMATIVE_ANSWER)
        3 -> answers.printFilteredAnswers(DOUBTFUL_ANSWER)
        4 -> answers.printFilteredAnswers(NEGATIVE_ANSWER)
        else -> println("Invalid answer.")
    }
}

fun <K, V> Map<K, V>.printFilteredAnswers(type: String) {
    this.filterValues {
        it == type
    }.also {
        println(it.keys)
    }
}

//Declaramos los valores de nuetras respuestas.
const val RESPUESTA_AFIRMATIVA = "ok"
const val RESPUESTA_AFIRMATIVA = "X"
const val RESPUESTA_AFIRMATIVA = “?”
//CREANDO MENU
//Unimos las respuestas con los valores
val respuestas = mapOf(
“Si” to RESPUESTA_AFIRMATIVA,
“Es cierto” to RESPUESTA_AFIRMATIVA,
“Claro que si mamita” to RESPUESTA_AFIRMATIVA,
“Sin duda churry” to RESPUESTA_AFIRMATIVA,
“Ahora no me molestes” to RESPUESTA_DUDOSA,
“No puedo decirte en este momento” to RESPUESTA_DUDOSA,
“Capaz que si, capaz que no” to RESPUESTA_DUDOSA,
“No va a suceder degenerada” to RESPUESTA_NEGATIVA,
“Ni en pedo” to RESPUESTA_NEGATIVA,
“Definitivamente no, feo” to RESPUESTA_NEGATIVA,
“Nop” to RESPUESTA_NEGATIVA,
)

fun main() {
var terminado = false;

while(terminado == false) {
 
    println("Hola me llamo John Alassio y soy tu bola 8 creada en Kotlin, cual de estas opciones deceas realizar?")
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

//aca obtenemos el valor del usuario y lo convertimos a un entero null.
val ValorIngresado = redLine()

    when(ValorIngres){
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostrarError()
}
    if(valorIngresado != "3"){
        println("Desea realizar otra operacion?: peracion?: ")
        println("0. No")
        println("1. Si")
        val realizarOtraOperacion  = redLine()
        
        if(realizarOtraOperacion == "1")  terminado = false
        else terminado = true

    }
}

}

fun mostrarError() {
println(“Parece que has elegido una opción no valida…”)
}

fun salir() {
println(“Hasta pronto salame”)
}

fun mostrarRespuestas() {

println("Selecciona una opción: ")
println("1. Revisar todas las respuestas")
println("2. Revisar solo las respuestas afirmativas")
println("3. Revisar solo las respuestas dudosas")
println("4. Revisar solo las repuestas negativas")

val opcionIngresada = readLine()
when(opcionIngresada){
"1" -> mostrarRespuestasPorTipo()
"2" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_AFIRMATIVA)
"3" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_DUDOSA)
"4" -> mostrarRespuestasPorTipo(tipoRespuesta = RESPUESTA_NEGATIVA)
else -> println("Haber... No elegiste una opción valida. Intenta nuevamente...")
}

}

fun mostrarRespuestasPorTipo(tipoRespuesta:String = “TODAS”) {
when(tipoRespuesta){
“TODAS” -> respuestas.keys.forEach{ respuesta -> println(respuesta) }
RESPUESTA_AFIRMATIVA -> respuestas.filterValues { value -> value == RESPUESTA_AFIRMATIVA }
.also { imprimirRespuestas(it) }
RESPUESTA_NEGATIVA -> respuestas.filterValues { value -> value == RESPUESTA_NEGATIVA }
.also{imprimirRespuestas(it)}
RESPUESTA_DUDOSA -> respuestas.filterValues { value -> value == RESPUESTA_DUDOSA }
.also{imprimirRespuestas(it)}
}

}

fun imprimirRespuestas(it: Map<String, String>) {
println(it.keys)
}

fun realizarPregunta(){
println("¿Qué pregunta indiscreta me queres hacer?")
readLine()
println("Así que esa era tu pregunta… Lo que tengo que desirte es: ")
val respuestaGenerada = respuestas.keys.random()
println(respuestaGenerada)
}

Utilice un doWhile como main loop y un auxiliar para realizar una validacion adicional para el usuario

fun main(args: Array<String>){
println(“Hola soy tu bola 8 magica creada en kotln.”)
do{
println( “Cual de esta opciones desea realizar?\n1.Realizar una pregunta\n2.Revisar toodas las respuestas\n3.Salir”)
var value = readLine()
when(value){
“1”-> question()
“2”->showAnswers()
“3”->getOut()
else-> showError()
}
println(“Desea realizar otra operacion?\n0.Salir”)
var option = readLine()
if (option == “0”) {
value = "3"
getOut()
}
}while (value != “3”)
}

Mi respuesta al reto es:

fun mostrarRespuestasPorTipo(tipoRespuesta: String ="todos"){
    //INTENTO DE RETO
    when(tipoRespuesta){
        "todos" -> respuestas.keys.forEach { respuesta -> println(respuesta)}
        else -> respuestas.filterValues {values -> values == tipoRespuesta}.also{
            respuesta -> println(respuesta.keys)
        }
    }
}

Terminado. Agregue algo de mal genio al programa, jejeje. Tambien agregue el lambda para cumplir el reto. Gracias a @Daniel Hernández Sánchez porque por su aporte entendi como pasarle el tipo al lambda no entendia como asignar el tipo de map . ¿Alguién tiene un link para leer mas sobre los tipos que se le pueden pasar a los lambdas estuve buscando pero no encuentro.

//Declaramos los valores de neustras respuestas
const val RESPUESTA_AFIRMATIVA ="✔️"
const val RESPUESTA_NEGATIVAA ="❌"
const val RESPUESTA_DUDOSA ="🙄️"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Si" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVAA,
    "No cuentes con ello" to RESPUESTA_NEGATIVAA,
    "Definitivamente no" to RESPUESTA_NEGATIVAA,
    "No lo creo" to RESPUESTA_NEGATIVAA,
)

fun main(args: Array<String>) {
    displayMenu()
}

private fun displayMenu(time:Int = 1) {
    when(time){
        1 -> {
            println("Les't play a game! ⓼, elije una opción")
            menuOptions()
        }
        else ->  {
            println("Wanna Play Again? Yes or No")
            readLine().also {
              when(it?.lowercase()){
                  "yes" ->  {
                      println("Yeiiii!, Les't play a game! , elije una opción")
                      menuOptions()
                  }
                  "no" -> {
                      println("BOURING!!!")
                      salir()
                  }
                  else -> {
                      println("You are playing just too much, an also want to play with my brain, I wont allowed that")
                      salir()
                  }
              }
            }

        }
    }
}

fun menuOptions(){
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()

    when (valorIngresado) {
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostarError()
    }
}

fun mostarError() {
    println("Parece que has elejido una opción no valida. Intenta denuevo")
}

fun salir() {
    println("Hasta luego!")
}

fun mostrarRespuestas() {
    println("Selecciona una opción:")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudosas")
    println("4. Revisar solo las respuestas negativas")

    val opcionIngresada = readLine()
    when(opcionIngresada){
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVAA)
        "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        else -> println("Respuesta no validad. Adios!")
    }
}

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
    val mrLambdastic : (Map<String,String>) -> Unit ={
        it.keys.forEach{
            answer -> println(answer)
        }
    }

    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{
            respuesta -> println(respuesta)
        }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }.also {
//            respuestasPositivas -> println(respuestasPositivas.keys)
            mrLambdastic(it)
        }
        RESPUESTA_NEGATIVAA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVAA }.also {
//                respuestasNegativas -> println(respuestasNegativas.keys)
            mrLambdastic(it)
        }
        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }.also {
//                respuestasDudosas -> println(respuestasDudosas.keys)
            mrLambdastic(it)
        }
    }
}

fun realizarPregunta(){
    println("Que pregunta deseas realizar?")
    readLine()

    println("Así que esa era tu pregunta.... La respuesta a eso es:")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)

    displayMenu(time=2)
}

Terminé!

Éste es mi resultado

import kotlin.system.exitProcess

//Declarando valores de las respuestas
const val AFFIRMATIVE_ANSWER = "✅"
const val NEGATIVE_ANSWER = "❌"
const val DOUBTFUL_ANSWER = "?"

//uniendo las respuestas con sus valores
val answers = mapOf(
    "Yes" to AFFIRMATIVE_ANSWER,
    "It's true" to AFFIRMATIVE_ANSWER,
    "Totally" to AFFIRMATIVE_ANSWER,
    "Undoubtedly" to AFFIRMATIVE_ANSWER,
    "Ask in an other moment" to DOUBTFUL_ANSWER,
    "I can't say you in this moment" to DOUBTFUL_ANSWER,
    "Maybe yes, or maybe not" to DOUBTFUL_ANSWER,
    "It's not going to happen" to NEGATIVE_ANSWER,
    "Do not count on it" to NEGATIVE_ANSWER,
    "Definitely not" to NEGATIVE_ANSWER,
    "I don't believe it" to NEGATIVE_ANSWER
)

fun main(){
    while (true){
        println("Hello, I'm the Kotlin 8 Ball. What do you want to do?\n" +
                "1. Ask a question\n" +
                "2. Check all answers\n" +
                "3. Exit")

        val userInput = readLine()

        when(userInput){
            "1" -> askQuestions()
            "2" -> showAnswers()
            "3" -> exit()
            else -> showError()
        }
    }
}

fun showError() {
    println("Not valid option selected")
}

fun exit() {
    println("Bye bye!")
    exitProcess(1)
}

fun showAnswers() {
    println("Select an option!" +
            "\n1. Check all the answers." +
            "\n2. Check the positive answers only" +
            "\n3. Check the negative answers only" +
            "\n4. Check the doubtful answers only"
    )

    val userInput = readLine()
    when(userInput){
        "1" -> showAnswersByType()
        "2" -> showAnswersByType(AFFIRMATIVE_ANSWER)
        "3" -> showAnswersByType(NEGATIVE_ANSWER)
        "4" -> showAnswersByType(DOUBTFUL_ANSWER)
        else -> showError()
    }

}

fun showAnswersByType(type: String = "") {
    val filteredAnswers = answers.filter { entry -> if (!type.isEmpty()) entry.value.contains(type) else true }

    filteredAnswers.forEach { entry -> println("💎 ${entry.key}") }
}

fun askQuestions() {
    println("What question do you want to ask?")
    readLine()
    println("\nSo, that is your question ...\nThe answer to that question is")
    val generatedAnswer = answers.keys.random()
    println("⭕ $generatedAnswer\n")
}

Ya terminé, este es mi resultado, quise usar las funciones de extensión en este caso

fun showAnswersByType(answerType: String = "ALL") {
    when (answerType) {
        "ALL" -> answers.forEach { answer -> println("\n $answer") }
        AFFIRMATIVE_ANSWER -> (answers.filterValues { values -> values == AFFIRMATIVE_ANSWER }).printAnswers()
        DOUBTFUL_ANSWER -> (answers.filterValues { values -> values == DOUBTFUL_ANSWER }).printAnswers()
        NEGATIVE_ANSWER -> (answers.filterValues { values -> values == NEGATIVE_ANSWER }).printAnswers()
    }
}

fun Map<String, String>.printAnswers() {
    println(this.keys)
}

Mi proyecto! En el spcode de .also escribi una lambda que recibe un Map

const val RESPUETA_AFIRMATIVA = "✔️"
const val RESPUETA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "❓"

val respuestas = mapOf(
    "Si" to RESPUETA_AFIRMATIVA,
    "No" to RESPUETA_NEGATIVA,
    "Tal vez" to RESPUESTA_DUDOSA,
    "Es cierto" to RESPUETA_AFIRMATIVA,
    "Totalmente" to RESPUETA_AFIRMATIVA,
    "Sin duda" to RESPUETA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUETA_NEGATIVA,
    "No cuentes con ello" to RESPUETA_NEGATIVA,
    "Definitivamente no" to RESPUETA_NEGATIVA,
    "No lo creo" to RESPUETA_NEGATIVA
)

fun main() {
    menu()
}

fun menu () {
    while (true) {
        println("Bienvenido a Kotlin-8Ball. Selecciona una opcion:")
        println("1. Realizar una pregunta")
        println("2. Revisar todas las preguntas")
        println("3. Salir")
        print("> ")

        when (readLine()) {
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> {
                salir()
                break
            }
            else -> mostrarError()
        }
    }
}

fun mostrarError() {
    println("Elegiste una opcion no valida")
}

fun salir() {
    println("Hasta luego! - 8Ball Kotlin")
    return
}

fun realizarPregunta () {
    println("Preguntame lo que quieras \uD83C\uDF1F \uD83C\uDF20")
    print("> ")
    readLine()
    val respuesta = respuestas.keys.random()
    println(respuesta)
}

fun mostrarRespuestas () {
    println("Selecciona el tipo de respuestas que quieres ver: ")
    println("1. Revisar todas las respuestas")
    println("2. Revisar todas las respuestasa afirmativas")
    println("3. Revisar todas las respuestas dudosas")
    println("4. Revisar todas las respuestas negativas")
    print("> ")

    when (readLine()) {
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipo = RESPUETA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipo = RESPUESTA_DUDOSA)
        "4" -> mostrarRespuestasPorTipo(tipo = RESPUETA_NEGATIVA)
        else -> mostrarError()
    }
}

fun mostrarRespuestasPorTipo(tipo : String = "TODOS") {

    val printRespuestas : (Map<String, String>) -> Unit = { println(it.keys) }

    when (tipo) {
        "TODOS" -> respuestas.keys.forEach { println(it) }
        RESPUETA_AFIRMATIVA -> respuestas.filterValues { it == RESPUETA_AFIRMATIVA }
            .also { printRespuestas(it) }

        RESPUETA_NEGATIVA -> respuestas.filterValues { it == RESPUETA_NEGATIVA }
            .also { printRespuestas(it) }

        RESPUESTA_DUDOSA -> respuestas.filterValues { it == RESPUESTA_DUDOSA }
            .also { printRespuestas(it) }
    }
}

este es mi aporte de solucion

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "Todos"){
    val respuestaImpresa: (Map<String, String>) -> Unit = {
        it.keys.forEach{ respuesta -> println(respuesta)}
    }
    when(tipoDeRespuesta){
        "todos" -> respuestas.keys.forEach{respuesta -> println(respuesta)}

        Respuesta_Afirmativa ->respuestas.filterValues { values -> values == Respuesta_Afirmativa}
            .also{ respuestaImpresa(it)}

        Respuesta_Negativa ->respuestas.filterValues { values -> values == Respuesta_Negativa}
            .also{ respuestaImpresa(it)}

        Respuesta_Dudosa ->respuestas.filterValues { values -> values == Respuesta_Dudosa}
            .also{ respuestaImpresa(it)}
    }
}

Código hecho con el reto. No estoy muy seguro si esté correcto de esta forma, pero aún así comparto.

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)


fun main(args: Array<String>) {
    println("Hola soy tu bola 8 mágica creada en Kotlin.")
    println("¿Qué deseas hacer?")
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()

    when(valorIngresado){
        "1" -> {
            realizarPregunta()
        }
        "2" -> {
            mostrarRespuestas()
        }
        "3" -> {
            salir()
        }
        else ->
            mostrarError()
    }
}

fun mostrarError() {
    println("Ups! Ha sucedido un error")
}

fun salir() {
    println("Hasta luego!")
}

fun realizarPregunta(){
    println("¿Qué pregunta deseas realizar?")
    readLine()
    println("Así que esa era tu pregunta... La respuesta a eso es: ")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

fun mostrarRespuestas() {
    println("Selecciona una opción: ")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar sólo las respuestas dudosas")
    println("4. Revisar sólo las respuestas negativas")

    val opcionIngresada = readLine()

    when(opcionIngresada){
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        else -> println("Respuesta no válida!")
    }

}

fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
    val lambdaMostrarRespuestas : (Map<String, String>) -> Unit = {
        respuestas ->
        println(respuestas.keys)
    }
    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach{ respuesta -> println(respuesta)}
        RESPUESTA_AFIRMATIVA -> lambdaMostrarRespuestas(respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA})
        RESPUESTA_NEGATIVA -> lambdaMostrarRespuestas(respuestas.filterValues { values -> values == RESPUESTA_DUDOSA})
        RESPUESTA_DUDOSA -> lambdaMostrarRespuestas(respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA})
    }
}

DRY??

Ya terminé este es mi resultado.

 // Mostramos las respuestas dependiendo del tipo que se pase como parametro
fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
    val lambdaImprimirRespuesta : (Collection<String>) -> Unit = { lista -> println(lista) }
    when (tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA,
        RESPUESTA_DUDOSA,
        RESPUESTA_NEGATIVA -> {
            respuestas.filterValues { values -> values == tipoDeRespuesta }
                .also { listaRespuestas -> lambdaImprimirRespuesta(listaRespuestas.keys) }
        }
    }
} 

esta fue la solución que le di yo

fun main() {
    var salir=false//creamos la varaible para el while
    while (salir==false){

    println("Hola soy tu bola 8 magica ?creada en kotlin. cual de estas opciones deseas realizar?")
    println("1- realizar una pregunta")
    println("2 ver todas las respuestas")
    println("3 salir")
    when(readLine()){//es cuando mejor que un if anidado
        "1"->realizarPregunta()
        "2"->mostrarRespuesta()
        "3"->salir().apply { salir=true }
        //cambiamos de estado ala variable y le damos un valro true
        else->mostrarError()
    }

    }
}

Mi código, me gusta kotlin porque se parece demasiado a javascript en el uso de lamdas y arrow functions.

 //Declare values of the answers
const val AFFIRMATIVE_ANSWER = "✅"
const val NEGATIVE_ANSWER = "❌"
const val DOUBTFUL_ANSWER = "?"

//Join the answers with their values
val answers = mapOf(
    "Yes" to AFFIRMATIVE_ANSWER,
    "It's true" to AFFIRMATIVE_ANSWER,
    "Totally" to AFFIRMATIVE_ANSWER,
    "Undoubtedly" to AFFIRMATIVE_ANSWER,
    "Ask in an other moment" to DOUBTFUL_ANSWER,
    "I can't say you in this moment" to DOUBTFUL_ANSWER,
    "Maybe yes, or maybe not" to DOUBTFUL_ANSWER,
    "It's not going to happen" to NEGATIVE_ANSWER,
    "Do not count on it" to NEGATIVE_ANSWER,
    "Definitely not" to NEGATIVE_ANSWER,
    "I don't believe it" to NEGATIVE_ANSWER
)


fun main(args: Array<String>) {
    //Declare the main menu
    println("Hello, I'm the Kotlin 8 Ball. What do you want to do?\n" +
            "1. Ask a question\n" +
            "2. Check all answers\n" +
            "3. Exit")
    //Read the answer of the user
    val inputValue = readLine()


    //functions an executed, by answer of the user
    when(inputValue){
        "1"->askQuestion()
        "2"->checkAnswer()
        "3"->exit()
        else->showError()
    }
}

fun showError() {
    println("Option not valid")
}

fun exit() {
    println("See you later")
}

fun askQuestion(){
    println("What do you want to ask?")
    readLine()
    println("very interesting question .... the answer is :")
    val answerGenerate =answers.keys.random()
    println(answerGenerate)
}
fun checkAnswer(){
    println("Choose one option")
    println("1.- Review all answer")
    println("2.- Review only affirmative answers")
    println("3.- Review only negative answers ")
    println("4.- Review only doubtful answers ")

    val optionRead= readLine()
    when (optionRead){
        "1"->showAnswerByType()
        "2"->showAnswerByType(typeAnswer=AFFIRMATIVE_ANSWER)
        "3"->showAnswerByType(typeAnswer=NEGATIVE_ANSWER)
        "4"->showAnswerByType(typeAnswer=DOUBTFUL_ANSWER)
        else -> println("Option not valid")
    }
}

fun showAnswerByType(typeAnswer: String ="TODOS") {
    val functionAnswer:(Map<String,String>)->Unit={
        answer ->println(answer.keys)
    }
    val filterAnswerValues:(Map<String,String>, String)->Map<String,String> = { map: Map<String, String>, filter: String -> map.filterValues{ values -> values == filter } }
    val showAnswerFilter:(Map<String,String>, String)->Unit ={
        map: Map<String, String>, filter: String->filterAnswerValues(map,filter).also(functionAnswer)
    }
    when(typeAnswer) {
        "TODOS" -> answers.keys.forEach { answer -> println(answer) }
        AFFIRMATIVE_ANSWER,NEGATIVE_ANSWER,DOUBTFUL_ANSWER -> showAnswerFilter(answers,typeAnswer)
        else-> println("Alternative not valid")
    }
}

Este fue mi respuesta

<fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS") {
    val imprimirRespuestas : (Map<String, String>) -> Unit ={
        it.keys.forEach {respuesta -> println(respuesta)}
    }

    when (tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .also { imprimirRespuestas(it) }

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .also { imprimirRespuestas(it) }

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .also { imprimirRespuestas(it) }
    }
}> 

Este es mi resultado

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "\uD83E\uDD14"
var bandera = true
//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentes con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,
)

fun main(args: Array<String>) {
    while (bandera){
        println("Hola soy tu bola 8 mágica creada en Kotlin. Cuál de estas opciones deseas realizar?")
        println("1. Realizar una pregunta")
        println("2. Revisar todas las respuestas")
        println("3. Salir")
        // Read line para leer el valor ingresado con el teclado
        val valorIngresado = readLine()

        when(valorIngresado){
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> mostrarError()
        }
    }
}

fun mostrarError() {
    println("Parece que has elegido una opción no válida, intenta de nuevo")
}

fun salir() {
    bandera = false
    println("Hasta luego!")
}

fun mostrarRespuestas() {
  println("Selecciona una opción")
  println("1. Revisar todas las respuestas")
  println("2. Revisar solo las respuestas afirmativas")
  println("3. Revisar solo las respuestas dudosas")
  println("4. Revisar solo las respuestas negativas")

  val opcionIngresada = readLine()
    when(opcionIngresada){
        "1" -> mostrarRespuestasPorTipo()
        "2" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        "4" -> mostrarRespuestasPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        else -> println("Respuesta no válida. Adiós")
    }
}

// Le asignamos el parametro tipoDeRespuesta de tipo String y el igual = indica que cuando no se le pase parametro me pase
// en automático el parametro TODOS
fun mostrarRespuestasPorTipo(tipoDeRespuesta : String = "TODOS"){
    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }.also {
            respuestasPositivas -> println( respuestasPositivas.keys)
        }
        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }.also {
                respuestasNegativas -> println( respuestasNegativas.keys)
        }
        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }.also {
                respuestasDudosas -> println( respuestasDudosas.keys)
        }
    }
}

fun realizarPregunta(){
    println("Qué pregunta deseas realizar?")
    readLine()
    println("Así que esa era tu pregunta... La respuesta a eso es:")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}

Hay varias formas de resolver el desafío, aquí está mi solución.

// Lambda para imprimir respuesta
    val printRespuestas : ( Map<String, String>) -> Unit = { value -> println(value.keys)}

    when (tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }
            .run(printRespuestas)

        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
            .run(printRespuestas)

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
            .run(printRespuestas)
    }

Este es mi código. Cree una función de extensión para imprimir las respuestas.

package com.leilly.proyectoplatzi

//Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "✅"
const val RESPUESTA_NEGATIVA = "❌"
const val RESPUESTA_DUDOSA = "?"

//Unimos las respuestas con los valores
val respuestas = mapOf(
    "Sí" to RESPUESTA_AFIRMATIVA,
    "Es cierto" to RESPUESTA_AFIRMATIVA,
    "Totalmente" to RESPUESTA_AFIRMATIVA,
    "Sin duda" to RESPUESTA_AFIRMATIVA,
    "Pregunta en otro momento" to RESPUESTA_DUDOSA,
    "No puedo decirte en este momento" to RESPUESTA_DUDOSA,
    "Puede que si o puede que no" to RESPUESTA_DUDOSA,
    "No va a suceder" to RESPUESTA_NEGATIVA,
    "No cuentas con ello" to RESPUESTA_NEGATIVA,
    "Definitivamente no" to RESPUESTA_NEGATIVA,
    "No lo creo" to RESPUESTA_NEGATIVA,

)

fun main(args:Array<String>){
    println("Hola soy tu bola 8 mágica creada en kotlin. Cual de estas opciones deseas realizar")
    println("1. Realizar una pregunta")
    println("2. Revisar todas las respuestas")
    println("3. Salir")

    val valorIngresado = readLine()

    when(valorIngresado){
        "1" -> realizarPregunta()
        "2" -> mostrarRespuestas()
        "3" -> salir()
        else -> mostrarError()
    }
}

fun mostrarError() {
    println("Vaya parece que has elegido una opción no válida, intenta de nuevo")
}

fun salir() {
    println("Hasta luego")
}


fun realizarPregunta() {
    println("Que pregunta deseas realizar")
    readLine()
    println("Así que esa era tu pregunta... La respuesta a eso es:")
    val respuestasGenerada = respuestas.keys.random()
    println(respuestasGenerada)
}

fun mostrarRespuestas(){
    println("Selecciona una opción")
    println("1. Revisar todas las respuestas")
    println("2. Revisar solo las respuestas afirmativas")
    println("3. Revisar solo las respuestas dudosas")
    println("4. Revisar solo las respuestas negativas")

    val valorIngresado = readLine()

    when(valorIngresado){
        "1" -> mostrarRespuestaPorTipo()
        "2" -> mostrarRespuestaPorTipo(tipoDeRespuesta = RESPUESTA_AFIRMATIVA)
        "3" -> mostrarRespuestaPorTipo(tipoDeRespuesta = RESPUESTA_DUDOSA)
        "4" -> mostrarRespuestaPorTipo(tipoDeRespuesta = RESPUESTA_NEGATIVA)
        else -> println("Respuesta no válida.. Adios.")
    }
}

fun mostrarRespuestaPorTipo(tipoDeRespuesta: String = "TODOS") {
    val imprimirRespuestas : (Map<String, String>) -> Unit = { respuestas ->

        respuestas.keys.forEach { respuesta -> println(respuesta) }
    }
    when(tipoDeRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        /* opción 1 */
        RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }.imprimirRespuesta()


        RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }.imprimirRespuesta()

        RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }.imprimirRespuesta()

       

    }

}



private fun <K,V> Map<K,V>.imprimirRespuesta() {
    println(this.keys)
}

fun imprimirLaRespuesta(map: Map<String, String>) {
    println(map.keys)
}

Cree una función de extensión y reemplace .also en la función MostrarRespuestaPorTipo

fun mostrarRespuestaPorTipo(tipoDeRespuesta: String = “TODOS”) {

when(tipoDeRespuesta){
    "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }

    RESPUESTA_AFIRMATIVA -> respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }.imprimirRespuesta()

    RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }.imprimirRespuesta()

    RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }.imprimirRespuesta()

}

}

Sin duda uno de los mejores cursos que he tomado ❤️ ahora que deberia tomar? recomendaciones? me quiero especializar en aplicaciones moviles con kotlin

Siga pidiendo las opciones y le agregue una función para hacerlo interesante

<code>

fun main() {
// Declarar el mensaje de entrada del programa
while(true)
{
println("Hola soy tu bola 8 magica creada en Kotlin. ¿Cual de estas opciones deseas realizar? ")
println(“1. Realizar una pregunta.”)
println(“2. Revisar todas las respuestas.”)
println(“3. Realizar un confesion”)
println(“4. Salir”)

// Obtener el valor del usuario y convertirlo a un entero nullable
val valorIngresado = readLine()

// Dependiendo del numero utilizamos el when para realizar una acción.
when (valorIngresado){
    "1" -> realizarPregunta()
    "2" -> mostrarRespuestas()
    "3" -> confesion()
    "4" -> { salir()
        break
    }
    else -> mostrarError()
}
println()

}
}

Ésta es mi solución al reto

fun mostrarRespuestasPorTipo(tipoRespuesta : String = "TODOS") {

    val lambda : (String) -> Map<String, String> = {
        tipoResp -> respuestas.filterValues { values -> values == tipoResp }
        .also { resp -> println(resp.keys) }
    }

    when(tipoRespuesta){
        "TODOS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA -> lambda(RESPUESTA_AFIRMATIVA)
        RESPUESTA_NEGATIVA -> lambda(RESPUESTA_NEGATIVA)
        RESPUESTA_DUDOSA -> lambda(RESPUESTA_DUDOSA)
    }
}

Solo que si elijo la opción de mostrar las respuesta por cada tipo se imprime la lista y no línea por línea, alguna recomendación?

Aquí mi solución al reto:

fun showAnswerByType(selectedAnswer: String = "TODOS") {
val printAnswerByType: (Set<String>) -> Unit = { answers -> answers.forEach { answer -> println(answer) } }

  when (selectedAnswer) {
    "TODOS" -> answers.keys.forEach { answer -> println(answer) }
    AFFIRMATIVE_ANSWER -> answers.filterValues { value -> value === AFFIRMATIVE_ANSWER }
      .also { afirmativeAnswers -> printAnswerByType(afirmativeAnswers.keys) }
    DOUBTFUL_ANSWER -> answers.filterValues { value -> value === DOUBTFUL_ANSWER }
      .also { doubtfulAnswers -> printAnswerByType(doubtfulAnswers.keys) }
    NEGATIVE_ANSWER -> answers.filterValues { value -> value === NEGATIVE_ANSWER }
      .also { negativeAnswers -> printAnswerByType(negativeAnswers.keys) }
  }
}