Alertes de stock faible

Fait partie de la section Logique et flux du Journey Kotlin de Coddy. Leçon 60 sur 63.

Défi

Difficile

Complétez runInventory avec les paramètres commands: List<String>. Construisez un inventaire qui commence vide à chaque appel de fonction. Chaque commande est une chaîne contenant des champs séparés par |. Les noms d’articles sont des mots ASCII en minuscules. Il y a au maximum 100 commandes. Divisez chaque commande selon le séparateur littéral ; les commandes ont toujours le nombre correct de champs pour leur opération. Retournez une réponse par commande. Les quantités sont débarrassées de leurs espaces avant l’analyse ; les valeurs valides sont comprises entre 0 et 1000. Un texte numérique invalide, un texte hors de la plage de Int, des quantités négatives ou des quantités supérieures à 1000 produisent invalid sans modifier l’état. Conservez tout ce que vous avez écrit lors des étapes précédentes, y compris chaque commande et chaque réponse antérieures. Prenez en charge ADD|item|quantity : ajoutez une quantité valide au stock de cet article, initialement nul, et retournez added. Ajouter zéro crée tout de même l’article. Ajoutez GET|item : retournez sa quantité sous forme de chaîne, ou 0 lorsque l’article est absent. Ajoutez SELL|item|quantity : validez d’abord la quantité en utilisant les mêmes règles que pour ADD. Pour une quantité valide, retournez insufficient si le stock disponible est inférieur ; sinon, soustrayez-la et retournez sold. Un article absent dispose de zéro unité. Vendre zéro réussit sans créer un article manquant. Conservez les articles existants dont le stock est nul. Ajoutez REPORT : retournez toutes les entrées enregistrées sous la forme item=quantity, séparées par ; et triées alphabétiquement par article. Incluez les entrées dont le stock est nul. Un inventaire vide produit empty. REPORT ne possède aucun champ d’argument. Ajoutez LOW|threshold : validez le seuil en utilisant les mêmes règles numériques que pour les quantités. Retournez invalid en cas d’entrée invalide. Sinon, retournez les noms des articles enregistrés dont la quantité est strictement inférieure au seuil, triés alphabétiquement et séparés par ;, ou none si aucun ne convient. LOW ne modifie pas le stock. L’entrée utilise uniquement les opérations prises en charge à cette étape.

Sauf indication de limites plus strictes ci-dessus, les collections contiennent au maximum 100 éléments à chaque niveau, et les arguments entiers ainsi que les valeurs entières des collections sont compris entre -1000 et 1000. Le texte fourni pour l’analyse peut contenir des représentations invalides ou hors limites comme indiqué.

Retournez une valeur de type List<String>. Conservez le code d’entrée/sortie fourni. Il lit les arguments scalaires à raison d’un par ligne ; une liste commence par son nombre d’éléments, suivi de ses éléments, et une map commence par le nombre de ses entrées, suivi de chaque clé et de chaque valeur. Les listes imbriquées reprennent le format nombre d’éléments puis éléments pour chaque ligne. Le main fourni affiche la valeur retournée suivie d’un saut de ligne. Les listes utilisent le format standard entre crochets de Kotlin ; n’affichez aucun libellé supplémentaire.

Essayez vous-même

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())
            "SELL" -> {
                val amount = parts[2].trim().toIntOrNull()
                val available = stock[item] ?: 0
                if (amount == null || amount !in 0..1000) replies.add("invalid")
                else if (amount > available) replies.add("insufficient")
                else {
                    if (stock.containsKey(item)) stock[item] = available - amount
                    replies.add("sold")
                }
            }
            "REPORT" -> {
                if (stock.isEmpty()) replies.add("empty")
                else replies.add(stock.keys.sorted().map { "$it=${stock[it]}" }.joinToString(";"))
            }
        }
    }
    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))
}