No tienes acceso a esta clase

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

Contestando aleatoriamente

36/37
Recursos

Aportes 37

Preguntas 0

Ordenar por:

Los aportes, preguntas y respuestas son vitales para aprender en comunidad. Reg铆strate o inicia sesi贸n para participar.

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

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

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

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

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

//Answers
const val POSITIVE_ANSWER = "鉁"
const val NEGATIVE_ANSWER = "鉂"
const val DOUBTFUL_ANSWER = "?"

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

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

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

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

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

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

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

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

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

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

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

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

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

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





Ajust茅 el c贸digo para que me regresara al men煤 inicial en lugar de terminar el programa. Hice una nueva funcion para desplegar el men煤 inicial,

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

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

    val valorIngresado = readLine()

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

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

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

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

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

Para el tema del reto, me quedo asi:

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

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

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

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

Mi codigo 茅sta clase 鉂わ笍

// Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "鉁"
const val RESPUESTA_NEGATIVA = "鉂"
const val RESPUESTA_DUDOSA = "鉂"

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

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

}

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

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

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

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

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

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

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

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

// Answers declaration
const val AFFRIRMATIVE_ANSWER = "鉁"
const val NEGATIVE_ANSWER = "鉂"
const val UNKNOWN_ANSWER = "\uD83E\uDD14"

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

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

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

    }
    while(option != "3")

}

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

fun showAnswers()
{

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

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

//Declaramos los valores de nuetras respuestas.
const val RESPUESTA_AFIRMATIVA = "ok"
const val RESPUESTA_AFIRMATIVA = "X"
const val RESPUESTA_AFIRMATIVA = 鈥?鈥
//CREANDO MENU
//Unimos las respuestas con los valores
val respuestas = mapOf(
鈥淪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) }
    }
}

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

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

Reto terminado

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

import java.util.function.DoubleUnaryOperator

//Declarando valores de las respuestas

const val AFFIRMATIVE_ANSWER = "鉁"
const val NEGATIVE_ANSWER = "鉂"
const val DOUBTFUL_ANSWER = "?"

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


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

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

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

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

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

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

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

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

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


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

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

fun main() {
    var terminado = false;

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

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

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

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

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

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

}

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

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

fun mostrarRespuestas() {

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

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

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

}

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


fun realizarPregunta(){
    println("驴Qu茅 pregunta deseas realizar?")
    readLine()
    println("As铆 que esa era tu pregunta... La respuesta a eso es: ")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)
}
const val RESPUESTA_AFIRMATIVA = "鉁"
const val RESPUESTA_NEGATIVA = "鉂"
const val RESPUESTA_DUDOSA = "??"

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

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

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

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

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

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

fun mostrarRespuestas() {
    printResponsesMenu()

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

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

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

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

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

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

    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Saludos.

Ya termine, este es mi resultado 馃槃


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

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

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

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

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

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

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

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

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

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

    }
}

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

Hice a mi parecer lo m谩s f谩cil filtr茅 he imprim铆 en la funcion mostrarRespuestasporTipo

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

este es mi aporte de solucion

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

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

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

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

C贸digo hecho con el reto. No estoy muy seguro si est茅 correcto de esta forma, pero a煤n as铆 comparto.

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

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


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

    val valorIngresado = readLine()

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

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

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

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

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

    val opcionIngresada = readLine()

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

}

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



DRY??

Ya termin茅 este es mi resultado.


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

esta fue la soluci贸n que le di yo

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

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

    }
}

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

 //Declare values of the answers
const val AFFIRMATIVE_ANSWER = "鉁"
const val NEGATIVE_ANSWER = "鉂"
const val DOUBTFUL_ANSWER = "?"

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


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


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

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

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

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

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

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

Este fue mi respuesta

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

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

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

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

Este es mi resultado


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

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

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

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

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

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

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

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

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

Hay varias formas de resolver el desaf铆o, aqu铆 est谩 mi soluci贸n.

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

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

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

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

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

package com.leilly.proyectoplatzi

//Declaramos los valores de nuestras respuestas
const val RESPUESTA_AFIRMATIVA = "鉁"
const val RESPUESTA_NEGATIVA = "鉂"
const val RESPUESTA_DUDOSA = "?"

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

)

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

    val valorIngresado = readLine()

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

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

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


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

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

    val valorIngresado = readLine()

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

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

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


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

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

       

    }

}



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

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

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

fun mostrarRespuestaPorTipo(tipoDeRespuesta: String = 鈥淭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) }
  }
}