Cursos Empresas Blog Live Conf Eventos Precios

0:0015:08

Recursos

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!

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

Curso de Kotlin desde Cero

Clase 37 de 38

Clase 37 / 38

Ricardo Ramírez

Hace 3 años

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

Comentarios (64)64 comentarios

Daniel Hernández Sánchez

Hace 6 años

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

Hace 5 años

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

Jesus Orlando Carcamo Posada

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

Ramiz Perez Ordoñez

Emanuel Agustín Serdeiro

Daniela Lara

Carlos Lopez

Hace 2 años

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

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

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

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

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

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

Juan Camilo Molina pardo

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

Pedro Roberto Capriles Morales

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:

Felipe Moreno

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

Alejandro Martinez

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

Kevin Parra Lopez

Hely Andrés Palencia

Recursos

Resumen

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

Progreso del curso

Introducción a Kotlin

Configuración del entorno

Hola mundo Kotlin

Conceptos básicos de Kotlin

Collections en Kotlin

Libera el potencial de las funciones

Scope functions

Proyecto: Bola 8 mágica