Vender existencias

Parte de la sección Lógica y flujo del Journey de Kotlin de Coddy. Lección 58 de 63.

Desafío

Difícil

Completa runInventory con los parámetros commands: List<String>. Construye un inventario que comience vacío en cada llamada a la función. Cada comando es una cadena con campos separados por |. Los nombres de los artículos son palabras ASCII en minúsculas. Hay como máximo 100 comandos. Divide cada comando usando el separador literal; los comandos siempre tienen el número correcto de campos para su operación. Devuelve una respuesta por comando. Las cantidades se recortan antes de analizarlas; las cantidades válidas están entre 0 y 1000. El texto numérico no válido, el texto cuyo valor está fuera del rango de Int, las cantidades negativas o las cantidades superiores a 1000 producen invalid sin cambiar el estado. Conserva todo lo que escribiste en los pasos anteriores, incluidos todos los comandos y respuestas anteriores. Admite ADD|item|quantity: añade una cantidad válida al inventario de ese artículo, inicialmente cero, y responde added. Añadir cero también crea el artículo. Añade GET|item: responde con su cantidad como cadena, o 0 cuando el artículo no está presente. Añade SELL|item|quantity: primero valida la cantidad usando las mismas reglas que para ADD. Para una cantidad válida, responde insufficient si el inventario disponible es menor; de lo contrario, réstala y responde sold. Un artículo ausente tiene cero unidades disponibles. Vender cero se realiza correctamente sin crear un artículo que no existe. Conserva los artículos existentes con inventario cero. La entrada solo utiliza las operaciones admitidas en este paso.

A menos que se indiquen límites más estrictos arriba, las colecciones contienen como máximo 100 elementos en cada nivel, y los argumentos enteros y los valores enteros de las colecciones están entre -1000 y 1000. El texto proporcionado para el análisis puede incluir representaciones no válidas o fuera de rango, tal como se describe.

Devuelve un valor de tipo List<String>. Conserva el código de entrada/salida proporcionado. Lee los argumentos escalares uno por línea; una lista comienza con su cantidad, seguida de sus elementos, y un mapa comienza con su cantidad de entradas, seguida de cada clave y valor. Las listas anidadas repiten el formato de cantidad y elementos para cada fila. El main proporcionado imprime el valor devuelto seguido de un salto de línea. Las listas utilizan el formato estándar entre corchetes de Kotlin; no imprimas etiquetas adicionales.

Pruébalo tú mismo

fun runInventory(commands: List<String>): List<String> {
    val stock = mutableMapOf<String, Int>()
    val replies = mutableListOf<String>()
    for (command in commands) {
        val parts = command.split("|")
        val operation = parts[0]
        val item = if (parts.size > 1) parts[1] else ""
        when (operation) {
            "ADD" -> {
                val amount = parts[2].trim().toIntOrNull()
                if (amount == null || amount !in 0..1000) replies.add("invalid")
                else {
                    stock[item] = (stock[item] ?: 0) + amount
                    replies.add("added")
                }
            }
            "GET" -> replies.add((stock[item] ?: 0).toString())
        }
    }
    return replies
}
fun main() {
    val commandsCount = readln().toInt()
    val commands = mutableListOf<String>()
    for (i0 in 0 until commandsCount) {
        val commandsItem = readLine().orEmpty()
        commands.add(commandsItem)
    }
    println(runInventory(commands))
}