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)}
    }
}

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.")
}

// 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()
}

//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) }
    }
}

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) }
    }
}

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) }
  }
}