No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Adquiere por un a帽o todos los cursos, escuelas y certificados por un precio especial.

Antes: $249

Currency
$219/a帽o

Paga en 4 cuotas sin intereses

Paga en 4 cuotas sin intereses
Comprar ahora

Termina en:

0D
3H
7M
3S

Contestando aleatoriamente

36/37
Recursos

Aportes 53

Preguntas 0

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

o inicia sesi贸n.

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

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(
鈥淪铆鈥,
鈥淣o鈥,
鈥淧robablemente鈥,
鈥淢ejor preg煤ntame despu茅s鈥,
鈥淣o cuentes con ello鈥,
鈥淣o lo creo鈥,
鈥淟as perspectivas no son buenas鈥,
鈥淣o 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.


// 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(
鈥淪i鈥 to RESPUESTA_AFIRMATIVA,
鈥淓s cierto鈥 to RESPUESTA_AFIRMATIVA,
鈥淐laro que si mamita鈥 to RESPUESTA_AFIRMATIVA,
鈥淪in duda churry鈥 to RESPUESTA_AFIRMATIVA,
鈥淎hora no me molestes鈥 to RESPUESTA_DUDOSA,
鈥淣o puedo decirte en este momento鈥 to RESPUESTA_DUDOSA,
鈥淐apaz que si, capaz que no鈥 to RESPUESTA_DUDOSA,
鈥淣o va a suceder degenerada鈥 to RESPUESTA_NEGATIVA,
鈥淣i en pedo鈥 to RESPUESTA_NEGATIVA,
鈥淒efinitivamente no, feo鈥 to RESPUESTA_NEGATIVA,
鈥淣op鈥 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(鈥淧arece que has elegido una opci贸n no valida鈥︹)
}

fun salir() {
println(鈥淗asta 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 = 鈥淭ODAS鈥) {
when(tipoRespuesta){
鈥淭ODAS鈥 -> 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(鈥淗ola soy tu bola 8 magica creada en kotln.鈥)
do{
println( 鈥淐ual 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(鈥淒esea 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 = 鈥淭ODOS鈥) {

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