Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas

Clase 37 de 38 • Curso de Kotlin desde Cero

Resumen

¿Cómo continuar el proyecto en Kotlin?

En el vídeo anterior, ya hemos cubierto la mitad de nuestro proyecto en Kotlin. Hemos creado las constantes, mapas para las respuestas y diseñado un menú interactivo para que el usuario ingrese sus opciones. Ahora, procederemos a asignarles funcionalidad a cada una de estas opciones en nuestro entorno de desarrollo IntelliJ, en particular, veremos cómo añadir funciones interactivas al juego para hacerlo mucho más completo y atractivo.

¿Cómo generar una respuesta aleatoria a una pregunta?

Creamos una función llamada realizarPregunta que le solicita al usuario su pregunta. Sin embargo, no almacenaremos esta pregunta. La idea es generar una respuesta aleatoria en base al mapa de respuestas que se encuentra en nuestro proyecto.

fun realizarPregunta() {
    println("¿Qué pregunta deseas realizar?")
    readLine()  // Capturamos la pregunta del usuario
    val respuestaGenerada = respuestas.keys.random()
    println("La respuesta a eso es: $respuestaGenerada")
}

¿Cómo mostrar las respuestas categorizadas por tipo?

Para ello, vamos a desarrollar una función que le permita al usuario elegir entre distintas categorías de respuestas. Creamos un nuevo menú y asignamos funciones específicas para mostrar cada categoría: afirmativas, dudosas y negativas.

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

    when (readLine()?.toIntOrNull()) {
        1 -> mostrarRespuestasPorTipo()
        2 -> mostrarRespuestasPorTipo("afirmativa")
        3 -> mostrarRespuestasPorTipo("dudosa")
        4 -> mostrarRespuestasPorTipo("negativa")
        else -> println("Respuesta no válida. Adiós.")
    }
}

fun mostrarRespuestasPorTipo(tipoRespuesta: String = "todas") {
    when (tipoRespuesta) {
        "afirmativa" -> respuestas.filterValues { it == "afirmativa" }
        "dudosa" -> respuestas.filterValues { it == "dudosa" }
        "negativa" -> respuestas.filterValues { it == "negativa" }
        else -> respuestas
    }.keys.forEach { println(it) }
}

¿Qué hacer para finalizar el juego o manejar errores?

Implementaremos las funciones sencillas para terminar el programa y manejar errores en caso de que el usuario ingrese comandos no válidos.

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

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

¿Cómo ejecutar y probar el programa en diferentes sistemas operativos?

El programa en Kotlin puede presentar un comportamiento algo distinto en Windows debido a un bug conocido en la terminal IntelliJ. Asegúrate de presionar 'Enter' para permitir la ejecución correcta de las diferentes opciones.

Para ejecutar el programa:

Haz clic en el botón verde para compilar y correr el programa.
Sigue las instrucciones en pantalla, prestando atención al comportamiento en Windows.

Reto final: Refactorización del código

He aquí un pequeño reto: refactoriza el código para evitar repetición en las funciones utilizando una variable externa. Investiga sobre el uso de funciones auxiliares y comparte tu resultado en los comentarios. ¡Nos encantaría ver cómo implementas esta optimización!

El aprendizaje continuo en Kotlin y la práctica constante son clave para dominar este lenguaje. ¡Sigue adelante y no te detengas en tu viaje de conocimiento!

Daniel Hernández Sánchez

student•

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

Gustavo Victoria Ramirez

student•

Muy bien, tambien se puede resolver con una recursividad dentro de main e importamos la clase exitProcess para que salga cuando el usuario preciona salir:

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

    // 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()
    }
    main()//Recursividad
}
...
fun salir() {
    println("¡Hasta luego!")
    exitProcess(-1)
}

Silvana Rolón

student•

Jesus Orlando Carcamo Posada

student•

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

Jesus Orlando Carcamo Posada

student•

También hice que se imprimiera cada respuesta línea por línea, como hacía con el forEach de TODOS, en evz de imprimir la lista

Mario Peña

student•

Creo que te falto pasarle el parámetro en imprmirRespuestas:

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(it))
    RESPUESTA_NEGATIVA -> respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }
      .also(imprimirRespuestas(it))
    RESPUESTA_DUDOSA -> respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }
      .also(imprimirRespuestas(it))
  }
}

Ramiz Perez Ordoñez

student•

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

Emanuel Agustín Serdeiro

student•

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

Daniela Lara

student•

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

Carlos Lopez

student•

Ya terminé y este es mi resultado:

Lo que hice fue crear una función lambda que recibe el Map y luego imprime las keys. Luego esta función se le pasa al also.

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

    when(tipoDeRespuesta) {
        "TODOS" -> answers.keys.forEach { answer -> println(answer)}
        AFFIRMATIVE_ANSWER -> answers.filterValues { values -> values == AFFIRMATIVE_ANSWER }
            .also(typeAnswers)
        NEGATIVE_ANSWER -> answers.filterValues { values -> values == NEGATIVE_ANSWER }
            .also(typeAnswers)
        DOUBTFUL_ANSWER -> answers.filterValues { values -> values == DOUBTFUL_ANSWER }
            .also(typeAnswers)
    }
}

Juan Daniel Espinoza Cordova

student•

Ya termine este mes mi resultado:

Le incluí un dowhhile para que siga pidiendo nuevas preguntas.

const val RESPUESTA_AFIRMATIVA = "J"

const val RESPUESTA_NEGATIVA = "X"

const val RESPUESTA_DUDOSA = "?"

private const val s = 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 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() {

do {

println(" ")

println("_______________________________________________")

println("Hola soy tu bola 8 magica creada en Kotlin")

println("Cual de las siguientes opciones deseas realizar:")

println(" -----------------------------------------------")

println("1. Realizar una pregunta")

println("2. Revisar todas las respuestas")

println("3. Salir")

println("_____________________________________________________")

print("Cual es tu opción:")

val valorIngresado: String = readln()

when (valorIngresado) {

"1" -> realizarPregunta()

"2" -> mostrarRespuestas()

"3" -> Salir()

else -> println("Opción no valida")

}

} while (valorIngresado != "3")

}

fun realizarPregunta(){

println("¿Que pregunta deseas realizar?")

readln()

println(" Con que esta es tu pregunta, pillin...")

println("La respuesta a esa pregunta es :")

val respuestaGenerada=respuestas.keys.random()

println(respuestaGenerada)

}

fun Salir(){

println("Hasta Luego y Gracias ")

}

fun mostrarRespuestas() {

println(" ")

println("Selecciona una Opción")

println("_____________________________________________")

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("______________________________________________")

print("Tu seleccoón es :")

val opcionIngresada = readln()

when (opcionIngresada) {

"1" -> mostrarRespuestasPorTipo()

"2" -> mostrarRespuestasPorTipo(tr = RESPUESTA_AFIRMATIVA)

"3" -> mostrarRespuestasPorTipo(tr = RESPUESTA_DUDOSA)

"4" -> mostrarRespuestasPorTipo(tr = RESPUESTA_NEGATIVA)

else -> println("Opcion Invalida")

}

// Propuesta alternativa al uso de .also la muestra de respuestas

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

var lasAfirmativas = mapOf("Es cierto" to "J")

var lasDudosas = mapOf("Lo dudo" to "?")

var lasNegativas = mapOf("No es cierto" to "X")

when (tr) {

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

RESPUESTA_AFIRMATIVA -> {lasAfirmativas = respuestas.filterValues { values -> values == RESPUESTA_AFIRMATIVA }

println(lasAfirmativas.keys)}

"?"-> {lasDudosas = respuestas.filterValues { values -> values == RESPUESTA_DUDOSA }

println(lasDudosas.keys)}

"X" -> {lasNegativas = respuestas.filterValues { values -> values == RESPUESTA_NEGATIVA }

println(lasNegativas.keys)}

else -> println("respuesta invalida")

}

Santiago Cardona Arango

student•

Esta fue mi manera de reducir tanto el .also como el .filterValues

val answers: Map<String, String> = mapOf(
    "Si" to AFFIRMATIVE_ANSWER,
    "Es cierto" to AFFIRMATIVE_ANSWER,
    "Totalmente" to AFFIRMATIVE_ANSWER,
    "Sin duda" to AFFIRMATIVE_ANSWER,
    "Pregunta en otro momento" to DOUBTFUL_ANSWER,
    "No puedo decirte en este momento" to DOUBTFUL_ANSWER,
    "Quizas si, o quizas no" to DOUBTFUL_ANSWER,
    "No va a suceder" to NEGATIVE_ANSWER,
    "No cuentes con ello" to NEGATIVE_ANSWER,
    "Definitamente no" to NEGATIVE_ANSWER,
    "No lo creo" to NEGATIVE_ANSWER
)

// lambda to print answers
val printAnswersByType : (String) -> Unit = { answerTypeRequired ->
    answers.filterValues { answer ->
        answer == answerTypeRequired
    }.also { values ->
        println(values.keys)}
}
```Y así quedó la función que llama este lambda

```js
fun showAnswersByType(answerType: String = "TODAS"){
    when(answerType){
        "TODAS" -> answers.keys.forEach { key -> println(key) }
        AFFIRMATIVE_ANSWER -> printAnswersByType(AFFIRMATIVE_ANSWER)
        NEGATIVE_ANSWER -> printAnswersByType(NEGATIVE_ANSWER)
        DOUBTFUL_ANSWER -> printAnswersByType(DOUBTFUL_ANSWER)
        else -> showError()
    }
}

Santiago Cardona Arango

student•

Creo que el código quedó raro cuando lo puse en el bloque de código en el comentario entonces les dejaré las imágenes

Ricardo Ramírez

student•

Bueno ya termine el reto, e hice algunas modificaciones extras:

Agregue la lógica para que solo se salga del app si la persona escoge la opción salir, de lo contrario se seguirán mostrando las opciones, use un do Wile
Cree una Array con las opciones de respuesta, así use este array para llamar la opción de respuestas que se quiera mostrar

val ``validOptions ``= ``listOf``<String>(``RESPUESTA_AFIRMATIVA``, ``RESPUESTA_NEGATIVA``, ``RESPUESTA_DUDOSA``)

when(opcionIngresada){ "1","2","3","4" -> ``mostrarRespuestaPorTipo``(tipoRespuesta = ``validOptions``[opcionIngresada.``toInt``()-1]) "5" -> ``main``() "6" -> ``salir``() else -> ``mostrarError``("Seleccionaste una opcion no valida.\n")

Extrage la implementaci;on de la función also en una función aparte para poder utilizarla varias veces y no repetir código.

fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") { when(tipoRespuesta){ "TODAS" -> ``respuestas``.keys.``forEach ``{ respuesta -> ``println``(respuesta) } ``RESPUESTA_AFIRMATIVA``, ``RESPUESTA_NEGATIVA``, ``RESPUESTA_DUDOSA ``-> ``respuestaFiltrada``(filtro = tipoRespuesta) } }

fun respuestaFiltrada(filtro:String): Map<String, String> { return ``respuestas``.``filterValues ``{ value -> value == filtro} .``also ``{ respuestaFiltrada -> ``println``(respuestaFiltrada.keys) } }

Aca dejo todo el código:

package org.example

import kotlin.system.exitProcess

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

val validOptions = listOf<String>("TODAS", RESPUESTA_AFIRMATIVA, RESPUESTA_NEGATIVA, 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,
)
//TIP To <b>Run</b> code, press <shortcut actionId="Run"/> or
// click the <icon src="AllIcons.Actions.Execute"/> icon in the gutter.
fun main() {
    do {
        println("Hola, soy tu bola 8 magica, selecciona una de las opciones siguientes")
        println("1. Realizar una pregunta.")
        println("2. Revisar todas las respuestas.")
        println("3. Salir")

        val valorIngresado = readln()

        when (valorIngresado) {
            "1" -> realizarPregunta()
            "2" -> mostrarRespuestas()
            "3" -> salir()
            else -> mostrarError(msj = "Selecciona una opcion valida. \n")
        }
    }while (valorIngresado !="3")

}

fun mostrarError(msj:String = "") {
    println(msj)
}

fun salir() {
    println("Has salido de la aplicacion")
    exitProcess(-1)
}
/**
 * Funcion que muestra el menu de opciones para los difenrentes tipos de respuesta
 */
fun mostrarRespuestas() {
    do {
        println("Selecciona una opcion: ")
        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")
        println("5. Regresar")
        println("6. Salir")
        val opcionIngresada = readln()
        when(opcionIngresada){
            "1","2","3","4" -> mostrarRespuestaPorTipo(tipoRespuesta = validOptions[opcionIngresada.toInt()-1])
            "5" -> main()
            "6" -> salir()
            else -> mostrarError("Seleccionaste una opcion no valida.\n")
        }
    }while (opcionIngresada != "6")
}
/**
 * Funcion que captura la pregunta del usuario y genera una respuesta aleatoria
 */
fun realizarPregunta(){
    println("Que pregunta deseas realizar?")
    readln()
    println("Con que esas tenemos, tu respuesta es>")
    val respuestaGenerada = respuestas.keys.random()
    println(respuestaGenerada)

}
/**
 * Funcion que devuelve la lista de respuestas dependiendo el tipo
 * @param tipoRespuesta  el tipo de respuesta seleccionada
 */
fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") {
    when(tipoRespuesta){
        "TODAS" -> respuestas.keys.forEach { respuesta -> println(respuesta) }
        RESPUESTA_AFIRMATIVA, RESPUESTA_NEGATIVA, RESPUESTA_DUDOSA -> respuestaFiltrada(filtro = tipoRespuesta)
    }
}
/**
* Filtra las respuestas segun el tipo que llega como parametro
* @param filtro  valor a aplicar para filtrar la lista
*/
fun respuestaFiltrada(filtro:String): Map<String, String> {
    return respuestas.filterValues { value -> value == filtro}
        .also { respuestaFiltrada -> println(respuestaFiltrada.keys) }
}

```package org.example

import kotlin.system.exitProcess

// Declaramos los valores de nuestras respuestas
const val *RESPUESTA\_AFIRMATIVA* = "✅"
const val *RESPUESTA\_NEGATIVA* = "❌"
const val *RESPUESTA\_DUDOSA* = "\uD83E\uDD14"
val *validOptions* = *listOf*\<String>("TODAS", *RESPUESTA\_AFIRMATIVA*, *RESPUESTA\_NEGATIVA*, *RESPUESTA\_DUDOSA*)



//Unimos las respuestas con los valores
val *respuestas* = *mapOf*(
&#x20;   "Sí" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Es cierto" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Totalmente" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Sin duda" *to RESPUESTA\_AFIRMATIVA*,
&#x20;   "Pregunta en otro momento" *to RESPUESTA\_DUDOSA*,
&#x20;   "No puedo decirte en este momento" *to RESPUESTA\_DUDOSA*,
&#x20;   "Puede que si o puede que no" *to RESPUESTA\_DUDOSA*,
&#x20;   "No va a suceder" *to RESPUESTA\_NEGATIVA*,
&#x20;   "No cuentes con ello" *to RESPUESTA\_NEGATIVA*,
&#x20;   "Definitivamente no" *to RESPUESTA\_NEGATIVA*,
&#x20;   "No lo creo" *to RESPUESTA\_NEGATIVA*,
)
//TIP To \<b>Run\</b> code, press \<shortcut actionId="Run"/> or
// click the \<icon src="AllIcons.Actions.Execute"/> icon in the gutter.
fun main() {
&#x20;   do {
&#x20;       *println*("Hola, soy tu bola 8 magica, selecciona una de las opciones siguientes")
&#x20;       *println*("1. Realizar una pregunta.")
&#x20;       *println*("2. Revisar todas las respuestas.")
&#x20;       *println*("3. Salir")

&#x20;       val valorIngresado = *readln*()

&#x20;       when (valorIngresado) {
&#x20;           "1" -> *realizarPregunta*()
&#x20;           "2" -> *mostrarRespuestas*()
&#x20;           "3" -> *salir*()
&#x20;           else -> *mostrarError*(msj = "Selecciona una opcion valida. \n")
&#x20;       }
&#x20;   }while (valorIngresado !="3")

}

fun mostrarError(msj:String = "") {
&#x20;   *println*(msj)
}

fun salir() {
&#x20;   *println*("Has salido de la aplicacion")
&#x20;   *exitProcess*(-1)
}
*/\*\**
&#x20;*\* Funcion que muestra el menu de opciones para los difenrentes tipos de respuesta*
&#x20;*\*/*
fun mostrarRespuestas() {
&#x20;   do {
&#x20;       *println*("Selecciona una opcion: ")
&#x20;       *println*("1. Revisar todas las respuestas")
&#x20;       *println*("2. Revisar solo las respuestas afirmativas")
&#x20;       *println*("3. Revisar solo las respuestas negativas")
&#x20;       *println*("4. Revisar solo las respuestas dudosas")
&#x20;       *println*("5. Regresar")
&#x20;       *println*("6. Salir")
&#x20;       val opcionIngresada = *readln*()
&#x20;       when(opcionIngresada){
&#x20;           "1","2","3","4" -> *mostrarRespuestaPorTipo*(tipoRespuesta = *validOptions*\[opcionIngresada.*toInt*()-1])
&#x20;           "5" -> *main*()
&#x20;           "6" -> *salir*()
&#x20;           else -> *mostrarError*("Seleccionaste una opcion no valida.\n")
&#x20;       }
&#x20;   }while (opcionIngresada != "6")
}
*/\*\**
&#x20;*\* Funcion que captura la pregunta del usuario y genera una respuesta aleatoria*
&#x20;*\*/*
fun realizarPregunta(){
&#x20;   *println*("Que pregunta deseas realizar?")
&#x20;   *readln*()
&#x20;   *println*("Con que esas tenemos, tu respuesta es>")
&#x20;   val respuestaGenerada = *respuestas*.keys.*random*()
&#x20;   *println*(respuestaGenerada)

}
*/\*\**
&#x20;*\* Funcion que devuelve la lista de respuestas dependiendo el tipo*
&#x20;*\* @param tipoRespuesta  el tipo de respuesta seleccionada*
&#x20;*\*/*
fun mostrarRespuestaPorTipo(tipoRespuesta:String = "TODAS") {
&#x20;   when(tipoRespuesta){
&#x20;       "TODAS" -> *respuestas*.keys.*forEach* { respuesta -> *println*(respuesta) }
&#x20;       *RESPUESTA\_AFIRMATIVA*, *RESPUESTA\_NEGATIVA*, *RESPUESTA\_DUDOSA* -> *respuestaFiltrada*(filtro = tipoRespuesta)
&#x20;   }
}
*/\*\**
*\* Filtra las respuestas segun el tipo que llega como parametro*
*\* @param filtro  valor a aplicar para filtrar la lista*
*\*/*
fun respuestaFiltrada(filtro:String): Map\<String, String> {
&#x20;   return *respuestas*.*filterValues* { value -> value == filtro}
&#x20;       .*also* { respuestaFiltrada -> *println*(respuestaFiltrada.keys) }
}

Ricardo Ramírez

student•

Bueno ya termine el reto, e hice algunas modificaciones extras:

Agregue la lógica para que solo se salga del app si la persona escoge la opción salir, de lo contrario se seguirán mostrando las opciones, use un do Wile

Albert Toscano

student•

De esta manera no se repite el .also

package org.example


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

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

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

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

    }


}

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

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

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

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

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

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

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

Juan Camilo Molina pardo

student•

Modifique algunas partes del codigo para hacerlo mas interactivo y siempre darle opciones al usuario, asi como aumente la cantidad de respuestas por defecto que se presentan antes de dar la respuesta a la pregunta: import kotlin.random.Random

//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 mainMenu(){ //Declarando el menu principal println( "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" -> checkAnswers() "3" -> exit() else -> wrongSelection(::mainMenu) } } fun askQuestion(){ val randNum = Random.nextInt(0, 4); println("What is your question?") readLine()

when(randNum){ 0 -> println("So that was your question... The answer is:\n") 1 -> println("That is a very important question, so the answer is: \n") 2 -> println("So that's what ails you? let see the answer is: \n") 3 -> println("Are you trying to test me? your answer is: \n") }

val randomAnswer = answers.keys.random() println(randomAnswer) println("\n \n Want to ask again?") println("1. yes\n 2. no") val inputValue = readLine(); when(inputValue){ "1" -> askQuestion(); "2" -> exit(); } } fun checkAnswers(){ println("Select option") println("1. Show all answers") println("2. Only show affirmative answers") println("3. Only show doubtful answers") println("4. Only show negative answers")

val inputValue = readLine() when(inputValue) { "1" -> showAnswerByType(answers ) "2" -> showAnswerByType(answers, "✅") "3" -> showAnswerByType(answers, "❌") "4" -> showAnswerByType(answers,"?") else -> wrongSelection(::checkAnswers); } }

fun showAnswerByType(answersMap : Map<String, String>, answer : String ="") { if(answer.isBlank()){ answers.keys.forEach { println(it) }//podria fallar }else{ for((key, answerType) in answersMap){ if(answerType == answer){ println(key) } } } println("Want to see another kind of options? \n" + "1. yes / 2. no") val inputValue = readLine() when(inputValue){ "1" -> checkAnswers() "2" -> exit() }

} fun wrongSelection(operation: () -> Unit){ println("Please select a correct option") operation(); }

fun exit(){ println("Bye") System.exit(0) }

fun main(args: Array<String>) { println("Hello, I'm the Kotlin 8 Ball. What do you want to do?\n") mainMenu(); }

Juan Camilo Molina pardo

student•

import kotlin.random.Random

} fun wrongSelection(operation: () -> Unit){ println("Please select a correct option") operation(); }

fun exit(){ println("Bye") System.exit(0) }

fun main(args: Array<String>) { println("Hello, I'm the Kotlin 8 Ball. What do you want to do?\n") mainMenu(); }

Pedro Roberto Capriles Morales

student•

Ya termine el reto este es mi resultado, para usar funciones lambda para los also y asi evitar repetir codigo

fun showAnswerByType(type: String = ALL) {
    val keyPrinter: (Map<String, String>)->Unit = {answers -> println(answers.keys)}
    when(type) {
        ALL->answers.keys.forEach{ answer -> println(answer) }
        AFFIRMATIVE_ANSWER -> answers.filterValues { value -> value == AFFIRMATIVE_ANSWER }
            .also (keyPrinter)
        NEGATIVE_ANSWER -> answers.filterValues { value -> value == NEGATIVE_ANSWER }
            .also(keyPrinter)
        DOUBTFUL_ANSWER -> answers.filterValues { value -> value == DOUBTFUL_ANSWER }
            .also(keyPrinter)
    }
}
```Este es mi repo:

Ana Daniela Ortiz

student•

Yo saque la función y le coloque las respuestas como parametro

Alejandro Martinez

student•

Añadi dos cosas. 1. hice el codigo mas compacto en la parte de mostrar respuestas 2. Añadi un bucle que repite el juego hasta que se le de a la opción de salir

// 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,
)
var continuar = true

fun main() {

    while (continuar){

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


    //leer el valor ingresado
    val valorIngresado = readLine()

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

fun mostrarError() {
    println("Esa opción no es valida, Intenta de nuevo")
}

fun Salir() {
    continuar = false
    println("hasta luego!")
}

fun mostrarRespuestas() {
    println("Selecciona una opcion")
    println("1.Revisar todas las respuestas")
    println("2.Revisar solo las respuestas afirmativas")
    println("3.Revisar solo las respuestas dudodas")
    println("4.Revisar solo las respuestas negativas")
    val opcionIngresada = readLine()
    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 respuestrasFiltradas = when(tipoDeRespuesta){
        "TODOS" ->respuestas
        else -> respuestas.filterValues { it == tipoDeRespuesta }
    }
    respuestrasFiltradas.keys.forEach{respuestas -> println(respuestas)}
}

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

Alejandro Martinez

student•

investigue un poco y llegue a esta solución Solo modifique el mostrarRespuestas. Todo lo demas lo deje igual a como estaba

fun mostrarRespuestas() {
    println("Selecciona una opcion")
    println("1.Revisar todas las respuestas")
    println("2.Revisar solo las respuestas afirmativas")
    println("3.Revisar solo las respuestas dudodas")
    println("4.Revisar solo las respuestas negativas")
    val opcionIngresada = readLine()
    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 respuestrasFiltradas = when(tipoDeRespuesta){
        "TODOS" ->respuestas
        else -> respuestas.filterValues { it == tipoDeRespuesta }
    }
    respuestrasFiltradas.keys.forEach{respuestas -> println(respuestas)}
}

Nataly Jallo Arana

student•

Asi quedo mi bola Mágica :)

const val AFFIRMATIVE_RESPONSE = "✓"
const val NEGATIVE_RESPONSE = "X"
const val DOUBTFUL_RESPONSE = "?"
const val ERROR = "error"
const val LOGOUT = "logout"

val responses = mapOf(
    "Yes" to AFFIRMATIVE_RESPONSE,
    "It's true" to AFFIRMATIVE_RESPONSE,
    "Totally" to AFFIRMATIVE_RESPONSE,
    "Undoubtedly" to AFFIRMATIVE_RESPONSE,
    "Ask a another time" to DOUBTFUL_RESPONSE,
    "I can't tell you at this time" to DOUBTFUL_RESPONSE,
    "It could be yes or it could be no" to DOUBTFUL_RESPONSE,
    "It's not going to happen" to NEGATIVE_RESPONSE,
    "Don't count on it" to NEGATIVE_RESPONSE,
    "Definitely not" to NEGATIVE_RESPONSE,
    "I don't think so" to NEGATIVE_RESPONSE,
)

val messages = mapOf(
    "See you later" to LOGOUT,
    "Ups, you seem to have chosen an invalid answer, try again" to ERROR
)

fun main(args: Array<String>) {

    do {
        val withoutIndent = """
            Hello, I'm a magic ball created in kotlin
            1. Ask a question
            2. Check all responses
            3. Logout
        """.trimIndent()
        println(withoutIndent)

        val inputValue = readLine()

        when(inputValue){
            "1" -> askQuestion()
            "2" -> showAnswers()
            "3" -> {
                messages[LOGOUT]?.let { printMessage(it) }
                break
            }
            else -> messages[ERROR]?.let { printMessage(it) }
        }

    }while(inputValue !== "3")

}

fun askQuestion(){
    println("What question do you want to ask?")
    readLine()
    println("So that's your question!")
    val generatedResponse = responses.keys.random()
    println(generatedResponse)

    val withoutIndentContinue = """
            Do you want to go back to the menu?
            1. Yes
            2. No, continue ask
        """.trimIndent()
    println(withoutIndentContinue)

    val inputValue = readLine()
    when(inputValue){
        "1" -> println("Menu")
        "2" -> askQuestion()
        else -> messages[ERROR]?.let { printMessage(it) }
    }
}

fun showAnswers(){
    val withoutIndentAnswer = """
            Choose a answer
            1. Check all answers
            2. Check only affirmative answers
            3. Check only doubtful answers
            4. Check only negative answers
        """.trimIndent()
    println(withoutIndentAnswer)

    val optionEntered = readLine()
    when(optionEntered){
        "1" -> showResponseByType(typeOfResponse = "ALL")
        "2" -> showResponseByType(typeOfResponse = AFFIRMATIVE_RESPONSE)
        "3" -> showResponseByType(typeOfResponse = NEGATIVE_RESPONSE)
        "4" -> showResponseByType(typeOfResponse = DOUBTFUL_RESPONSE)
        else -> println("Invalid response, bye")
    }
}

fun showResponseByType(typeOfResponse : String = "ALL"){

    val lambda : (String) -> Unit = {
            typeAnswer -> responses.filterValues { values -> values == typeAnswer }
        .also { response -> response.keys }
        .forEach { answwer -> println(answwer.key)}
    }

    when(typeOfResponse){
        "ALL" -> responses.keys.forEach{ answer -> println(answer)}
        AFFIRMATIVE_RESPONSE -> lambda(AFFIRMATIVE_RESPONSE)
        NEGATIVE_RESPONSE -> lambda(NEGATIVE_RESPONSE)
        DOUBTFUL_RESPONSE -> lambda(DOUBTFUL_RESPONSE)
    }
}

fun printMessage(value : String){
    println(value)
}

```const val *AFFIRMATIVE\_RESPONSE* = "✓"
const val *NEGATIVE\_RESPONSE* = "X"
const val *DOUBTFUL\_RESPONSE* = "?"
const val *ERROR* = "error"
const val *LOGOUT* = "logout"
val *responses* = *mapOf*(
&#x20;   "Yes" *to AFFIRMATIVE\_RESPONSE*,
&#x20;   "It's true" *to AFFIRMATIVE\_RESPONSE*,
&#x20;   "Totally" *to AFFIRMATIVE\_RESPONSE*,
&#x20;   "Undoubtedly" *to AFFIRMATIVE\_RESPONSE*,
&#x20;   "Ask a another time" *to DOUBTFUL\_RESPONSE*,
&#x20;   "I can't tell you at this time" *to DOUBTFUL\_RESPONSE*,
&#x20;   "It could be yes or it could be no" *to DOUBTFUL\_RESPONSE*,
&#x20;   "It's not going to happen" *to NEGATIVE\_RESPONSE*,
&#x20;   "Don't count on it" *to NEGATIVE\_RESPONSE*,
&#x20;   "Definitely not" *to NEGATIVE\_RESPONSE*,
&#x20;   "I don't think so" *to NEGATIVE\_RESPONSE*,
)

val *messages* = *mapOf*(
&#x20;   "See you later" *to LOGOUT*,
&#x20;   "Ups, you seem to have chosen an invalid answer, try again" *to ERROR*
)

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

&#x20;   do {
&#x20;       val withoutIndent = """
&#x20;           Hello, I'm a magic ball created in kotlin
&#x20;           1\. Ask a question
&#x20;           2\. Check all responses
&#x20;           3\. Logout
&#x20;       """.*trimIndent*()
&#x20;       *println*(withoutIndent)

&#x20;       val inputValue = *readLine*()

&#x20;       when(inputValue){
&#x20;           "1" -> *askQuestion*()
&#x20;           "2" -> *showAnswers*()
&#x20;           "3" -> {
&#x20;               *messages*\[*LOGOUT*]?.*let* { *printMessage*(it) }
&#x20;               break
&#x20;           }
&#x20;           else -> *messages*\[*ERROR*]?.*let* { *printMessage*(it) }
&#x20;       }

&#x20;   }while(inputValue !== "3")

}

fun askQuestion(){
&#x20;   *println*("What question do you want to ask?")
&#x20;   *readLine*()
&#x20;   *println*("So that's your question!")
&#x20;   val generatedResponse = *responses*.keys.*random*()
&#x20;   *println*(generatedResponse)

&#x20;   val withoutIndentContinue = """
&#x20;           Do you want to go back to the menu?
&#x20;           1\. Yes
&#x20;           2\. No, continue ask
&#x20;       """.*trimIndent*()
&#x20;   *println*(withoutIndentContinue)

&#x20;   val inputValue = *readLine*()
&#x20;   when(inputValue){
&#x20;       "1" -> *println*("Menu")
&#x20;       "2" -> *askQuestion*()
&#x20;       else -> *messages*\[*ERROR*]?.*let* { *printMessage*(it) }
&#x20;   }
}

fun showAnswers(){
&#x20;   val withoutIndentAnswer = """
&#x20;           Choose a answer
&#x20;           1\. Check all answers
&#x20;           2\. Check only affirmative answers
&#x20;           3\. Check only doubtful answers
&#x20;           4\. Check only negative answers
&#x20;       """.*trimIndent*()
&#x20;   *println*(withoutIndentAnswer)

&#x20;   val optionEntered = *readLine*()
&#x20;   when(optionEntered){
&#x20;       "1" -> *showResponseByType*(typeOfResponse = "ALL")
&#x20;       "2" -> *showResponseByType*(typeOfResponse = *AFFIRMATIVE\_RESPONSE*)
&#x20;       "3" -> *showResponseByType*(typeOfResponse = *NEGATIVE\_RESPONSE*)
&#x20;       "4" -> *showResponseByType*(typeOfResponse = *DOUBTFUL\_RESPONSE*)
&#x20;       else -> *println*("Invalid response, bye")
&#x20;   }
}

fun showResponseByType(typeOfResponse : String = "ALL"){

&#x20;   val lambda : (String) -> Unit = {
&#x20;           typeAnswer -> *responses*.*filterValues* { values -> values == typeAnswer }
&#x20;       .*also* { response -> response.keys }
&#x20;       .*forEach* { answwer -> *println*(answwer.key)}
&#x20;   }
&#x20;   when(typeOfResponse){
&#x20;       "ALL" -> *responses*.keys.*forEach*{ answer -> *println*(answer)}
&#x20;       *AFFIRMATIVE\_RESPONSE* -> lambda(*AFFIRMATIVE\_RESPONSE*)
&#x20;       *NEGATIVE\_RESPONSE* -> lambda(*NEGATIVE\_RESPONSE*)
&#x20;       *DOUBTFUL\_RESPONSE* -> lambda(*DOUBTFUL\_RESPONSE*)
&#x20;   }
}

fun printMessage(value : String){
&#x20;   *println*(value)
}

Kevin Parra Lopez

student•

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

Hely Andrés Palencia

student•

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

Funcionalidades avanzadas en Kotlin: Menús y manejo de respuestas

Introducción a Kotlin

¡Este curso ha sido actualizado!

Curso de Kotlin desde Cero para Desarrollo de Aplicaciones

Java Virtual Machine: Funcionamiento y Ventajas

Introducción a Kotlin y sus ventajas en desarrollo Android

Configuración del entorno

Instalación de IntelliJ IDEA Community Edition en Windows, Mac y Linux

Instalación de IntelliJ Idea Community en Linux

Configuración de Kotlin en Visual Studio Code

Hola mundo Kotlin

Estructura y Funcionalidad de Archivos en un Proyecto Kotlin

Variables en Kotlin: Lectura, Escritura y Constantes

Tipos de Variables y Operaciones en Kotlin

Tipos de Datos y Objetos en Kotlin: Ventajas y Funcionalidades

Operadores y Funciones en Kotlin: Uso y Extensión

Programación Funcional en Kotlin: Paradigmas y Variables Inmutables

Estructuras de Control: Uso de IF en Kotlin

Estructura de Control "When" en Kotlin: Uso y Ejemplos Prácticos

Conceptos básicos de Kotlin

Bucle while y do-while en Kotlin: Condicionales y Ejecución

Ciclo For y Funciones de Extensión en Kotlin

Null Safety en Kotlin: Evita Errores por Referencias Nulas

Gestión de Tipos Nulables en Kotlin y Buenas Prácticas

Manejo de Excepciones en Kotlin: Try-Catch y Lanzamiento de Errores

Uso del Operador Elvis en Kotlin para Nulables

Collections en Kotlin

Listas y Arrays en Kotlin: Tipos y Operaciones Básicas

Ordenar y Manipular Listas en Kotlin: Funciones Clave y Ejemplos

Uso de Maps en Kotlin: Clave-Valor y Tipos Mutable e Inmutable

Sets en Kotlin: Uso, Eliminación y Obtención de Elementos

Libera el potencial de las funciones

Creación de funciones propias en Kotlin

Creación de Funciones en Kotlin: Uppercase y Lowercase Aleatorios

Parámetros Nombrados y por Defecto en Funciones de Programación

Creación y Uso de Lambdas en Kotlin

Funciones de Alto Orden y Lambdas en Kotlin

Scope functions

Uso de la función let en Kotlin para variables nulas

Uso de la función "with" en Kotlin para manejar propiedades

Uso de la Función Run para Operaciones en Listas en Kotlin

Uso de la función apply para manejar tipos anulables en Kotlin

Uso de la Función Also en Kotlin para Encadenamiento de Operaciones

Proyecto: Bola 8 mágica

Creación de Menú Interactivo en Kotlin para Proyecto Bola Ocho