Calculer la valeur d'une main¶
Niveau : débutant
Notre premier défi consiste à corriger le calcul de la valeur d'une main.
Lorsqu'il y a plusieurs cartes sur la table, le joueur est uniquement autorisé à poser des cartes ayant une valeur supérieure.
Par exemple, si la carte 3 est posée sur la table, il est autorisé de jouer 4 (car 4 est strictement supérieur à 3), mais il n'est pas autorisé de jouer 2 (car 2 n'est pas strictement supérieur à 3).
Je connais déjà Kotlin et je souhaite coder sans aide
Le but est d'implémenter la règle de pose. Vous pouvez lancer les tests à l'aide de Check (JVM-only). Un seul fichier doit être modifié, le défi est réussi lorsque tous les tests passent.
1. Lire le code existant¶
Commençons par examiner le code existant dans core/src/commonMain/kotlin/Deck.kt. Un paquet ("deck" en anglais) représente plusieurs cartes posées ensemble.
Le fichier commence par :
Ceci est un commentaire. Les commentaires sont des messages que les développeurs laissent à l'intention d'autres développeurs ; ils sont ignorés par le langage de programmation. Il existe trois types de commentaires :- Tout ce qui se trouve à droite de
//est un commentaire, sur la même ligne. - Tout ce qui se trouve entre
/*et*/est un commentaire, même sur plusieurs lignes.
Ceci déclare que ce fichier appartient au paquetage io.bordeauxkt.kotlin15. Un paquetage ("package" en anglais) est similaire à un dossier : il permet d'organiser le code similaire afin qu'il reste regroupé.
/**
* Multiple cards placed together.
*
* The cards must **either**:
* - All have the same [value][Card.value].
* - All have the same [color][Card.color].
*
* A deck has a [value].
*
* To store arbitrary cards, see [Hand].
*/
data class Deck(
val cards: Set<Card>,
) {
// …
}
Ici, nous créons une data class appelée Deck. Une data class est une entité composée de données. Les données qui la composent sont déclarées entre les parenthèses. Nous appelons cela une propriété. Deck possède une unique propriété :
valsignifie « value » (valeur). Une valeur ne change pas au fil du temps.cardsest le nom de la propriété.- Le
:signifie que ce qui suit est le type de la propriété. Le type spécifie quel genre de données la propriété contient. Set<Card>se lit « ensemble de cartes ». Un ensemble (set) est une collection de cartes qui ne peut pas contenir de doublons : toutes les cartes doivent être différentes les unes des autres.
Dans l'ensemble, nous déclarons qu'un Deck est composé de plusieurs cartes (stockées dans une propriété appelée cards), et qu'un paquet ne peut pas contenir la même carte plusieurs fois.
La déclaration de la classe se termine par des accolades : { et } plusieurs lignes plus bas. Les accolades représentent un « bloc » qui donne plus d'informations sur un élément. Ici, tout le contenu du bloc décrit ce que fait un paquet.
init {
require(isLegal(cards)) { "All cards in a deck must either have the same color, or have the same value, but this deck has neither: $cards" }
}
init {} est un bloc spécial dans une classe qui spécifie le code à exécuter lors de la création de la classe.
Ici, le code appelle la fonction require(), qui vérifie une contrainte et fait planter l'application lorsque la vérification échoue.
La vérification est un appel à isLegal(cards), qui vérifie que les cartes contenues dans le paquet sont valides. Nous pouvons l'ignorer pour l'instant.
/**
* The value of a deck.
*
* A deck `[2 Red, 3 Red]` has value 32:
* - The cards are sorted in descending order
* - The cards' values are concatenated together
*/
val value: Int = 0 // TODO!
C'est la propriété qui nous intéresse !
Pour rappel :
/** … */est un commentaire : il s'agit de documentation pour les autres développeurs.valdéclare une valeur : une propriété qui ne change pas.valueest son nom.: Intest son type.Intest un entier : un nombre qui n'a pas de partie décimale. Par exemple,1,19ou-7.= 0est la valeur effective de la propriétévalue. Telle qu'elle est écrite, quoi qu'il arrive, la valeur est0.
Actuellement, le code calcule la valeur 0 pour n'importe quel paquet. Notre premier défi sera de corriger le calcul de la valeur afin que le jeu puisse fonctionner correctement.
2. Lancer les tests¶
Le projet est accompagné d'une suite de tests complète que nous pouvons utiliser pour vérifier que nos modifications sont correctes.
Pour lancer les tests, trouvez la flèche verte en haut à droite. Dans le menu déroulant, choisissez Check (JVM-only), ce qui exécutera tous les tests en utilisant la JVM.
Pour lancer tous les tests sur toutes les plateformes prises en charge (JVM, JS dans un navigateur, Node.js et iOS), vous pouvez exécuter Check. Cependant, dans ce projet, les plateformes utilisent toutes exactement le même code, donc lancer uniquement les tests JVM nous donne suffisamment d'informations et est plus rapide.
La première exécution peut prendre un certain temps, mais les suivantes ne devraient prendre que quelques secondes.
Vous devriez voir 21 tests échouer, le premier étant :
java.lang.IllegalStateException:
check(deck.value == 1)
| | |
| 0 false
[1 Red]
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invokeSuspend(DeckTest.kt:76)
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invoke(DeckTest.kt)
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invoke(DeckTest.kt)
Tip
Si les noms de tests ressemblent à <tb<io.bordeauxkt.kotlin15.DeckTest↘Value↘A deck with a single card…>tb>, installez le plugin TestBalloon dans (en haut à gauche) | File | Settings | Plugins en recherchant TestBalloon, puis en cliquant sur « Install ». Une fois le plugin installé, vous pouvez relancer la configuration Check (JVM-only) pour voir les vrais noms de tests.
Analysons le test qui a échoué.
La première ligne nous indique que l'erreur est l'exception Java
IllegalStateException. IllegalStateException signifie « le programme a détecté qu'il se trouve dans un état incorrect ».
check()est une fonction qui vérifie une condition. Si la condition estfalse, le test échoue avec uneIllegalStateException. Comme c'est l'exception obtenue, nous savons que la condition a échoué.- Nous commençons la ligne par
deck. En suivant le symbole|vers le bas, nous pouvons voir que ledeckcontenait une seule carte : 1 . - Ensuite, le test accède à la valeur du paquet :
deck.value. En suivant le symbole|vers le bas, nous pouvons voir que la valeur du paquet est0. C'est ce que nous venons de voir dans le code ! - Cependant,
== 1signifie que le test s'attendait à ce que la valeur soit1dans cette situation.
Tip
Cette visualisation des résultats de test est fournie par le plugin Power Assert, qui est déjà configuré dans le projet.
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invokeSuspend(DeckTest.kt:76)
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invoke(DeckTest.kt)
at io.bordeauxkt.kotlin15.DeckTestKt$DeckTest$2$2$2.invoke(DeckTest.kt)
at io.bordeauxkt.kotlin15signifie que le code provient du packageio.bordeauxkt.kotlin15, qui est le même package que le code que nous écrivons.DeckTestKtsignifie que le code provient de la classeDeckTestKt, générée par le fichierDeckTest.kt.$DeckTest$2$2$2.invokeSuspend()est l'identifiant de méthode, mais il n'est pas particulièrement utile pour les tests, nous ne l'expliquerons donc pas ici.DeckTest.kt:76nous indique que cela se trouve dans le fichierDeckTest.ktà la ligne76. Dans Android Studio, vous pouvez cliquer dessus si vous souhaitez lire le test. Nous ne toucherons pas aux tests dans ce défi.
3. La valeur d'une seule carte¶
La valeur d'un paquet d'une seule carte, par exemple
3 ,
est la valeur de la carte, ici 3. Implémentons cela !
Revenons à core/src/commonMain/kotlin/Deck.kt.
Actuellement, le code est le suivant :
Nous voulons remplacer le 0 par la valeur de la carte.
Pour l'instant, si un paquet comporte plusieurs cartes ou aucune carte, nous continuerons de renvoyer 0.
Par conséquent, nous avons besoin de :
- Un moyen de prendre une décision : nous voulons un comportement différent s'il y a exactement une carte, ou s'il y a 0 ou plusieurs cartes.
- Un moyen de compter le nombre de cartes dans un ensemble de cartes : nous devons savoir s'il y a exactement une carte pour prendre la décision.
- Un moyen d'obtenir la valeur d'une carte, car c'est le résultat que nous voulons.
- Prendre une décision
-
Les décisions sont la partie la plus importante de la programmation : c'est ainsi que nous indiquons à l'ordinateur ce qu'il doit faire. Il existe de nombreuses façons d'exprimer des décisions, mais la plus simple est le mot-clé
Remplacez :if.- condition par le code qui décide de la branche à emprunter. Par exemple, nous avons vu un exemple de condition précédemment dans le test :
deck.value == 1qui vérifie que lavaluedudeckest égale à1. Notez que nous utilisons deux symboles=, et non un seul, pour différencier de la création de la valeur comme dansval value: Int = 0. - code-vrai par le code que vous souhaitez exécuter si la condition est
true(succès). - code-faux par le code que vous souhaitez exécuter si la condition est
false(échec).
- condition par le code qui décide de la branche à emprunter. Par exemple, nous avons vu un exemple de condition précédemment dans le test :
- Compter les cartes
-
Un ensemble de cartes peut contenir n'importe quel nombre de cartes. Pour le moment, nous voulons seulement gérer le cas d'une seule carte, nous devons donc être capables de les compter. Kotlin fournit l'une des API les plus riches de tous les langages de programmation pour manipuler des collections, notamment les ensembles. Saurez-vous trouver la bonne propriété ?
Trouvez également un moyen d'accéder à la première carte d'un ensemble.
- Obtenir la valeur d'une carte
-
Les cartes sont définies dans le fichier
Card.kt.
Maintenant que vous avez toutes les pièces, il ne vous reste plus qu'à assembler le puzzle !
Pour vérifier votre solution, relancez Check (JVM-only). Il ne devrait plus y avoir que 13 tests en échec, et ils devraient tous avoir strictement plus d'une carte dans leur paquet.
Une fois cette étape réussie, vous pouvez passer à la suivante. Si vous avez des questions, n'hésitez pas à solliciter les organisateurs !
4. Plusieurs cartes¶
Félicitations pour cette première étape.
Nous n'avons cependant pas encore terminé : un joueur peut poser une carte de plus que ce qui se trouve sur la table.
Par exemple, si les cartes 7 3 sont sur la table, un joueur doit jouer soit 2 cartes (le même nombre de cartes que la table), soit 3 cartes (une carte de plus que la table).
Lorsque l'on joue plusieurs cartes à la fois, toutes les cartes doivent obligatoirement soit :
- Être de la même couleur, par exemple 2 1 , ou,
- Être de la même valeur, par exemple 3 3 .
Cette vérification est déjà implémentée par la méthode isLegal() dans Deck.kt.
Cependant, notre code calcule une valeur de 0 pour tout paquet contenant plusieurs cartes. Au lieu de cela, la valeur devrait être calculée selon les règles suivantes :
Les cartes jouées doivent avoir une valeur supérieure à celle de la table. La valeur d'un paquet est la concaténation des valeurs des cartes individuelles, par ordre décroissant.
Exemples :
- 7 3 a pour valeur 73 (concaténation de 7 et 3).
- 3 3 a pour valeur 33 (concaténation de 3 et 3).
- 1 2 a pour valeur 21 (concaténation de 2 et 1 : la carte la plus haute passe en premier).
- 3 9 2 6 5 a pour valeur 96532.
Remarquez que la couleur des cartes n'a pas d'importance. L'ordre des cartes n'a pas d'importance non plus, puisque la valeur est toujours calculée par ordre décroissant.
Pour résoudre ce défi, nous avons besoin de :
- Puisque seule la valeur des cartes nous intéresse, d'un moyen de convertir une liste de cartes en une liste de valeurs.
- D'un moyen de trier les valeurs, pour être certains de les lire de la plus haute à la plus basse.
- D'un moyen de concaténer les valeurs.
- Convertir une collection en une autre
-
Lorsque nous avons une liste d'éléments, nous pouvons la convertir en une liste d'autre chose en fournissant un moyen de transformer un élément en un autre. C'est l'une des forces de la programmation fonctionnelle : nous pouvons effectuer n'importe quelle opération sur une collection si nous savons comment l'effectuer sur un seul élément, grâce à la fonction
.map {}.Par exemple, nous pouvons obtenir le prénom d'un joueur entièrement en majuscules avec
player.name.uppercase().Si nous avons plusieurs joueurs dans une
List<Player>ou unSet<Player>nomméplayers, nous pouvons écrireplayers.map { it.name.uppercase() }, ce qui produira uneList<String>(Stringsignifie texte). Entre les accolades, nous utilisons le même code que pour un seul joueur, mais en utilisant la variable spécialeit. Le code s'exécutera plusieurs fois (une fois pour chaque joueur). À chaque passage, le joueur actuel se trouvera dansit. - Trier
-
Le tri est l'un des problèmes les plus fréquents en programmation. Bien entendu, Kotlin propose plusieurs façons de trier des éléments.
La manière la plus simple est d'utiliser la fonction
.sorted(), qui permet de trier n'importe quelle liste tant que ses éléments peuvent être triés selon leur ordre naturel. Ces éléments sont ditsComparable. Certains types sont comparables, d'autres non. Les types numériques (Int,Float, etc.) sont comparables et se trient du plus petit au plus grand. Les types textuels (Char,String) sont comparables et se trient selon l'ordre alphanumérique Unicode (ordre du dictionnaire). Cependant, un objetCardn'est pas comparable en lui-même : quel serait l'ordre par défaut ? Par valeur, par couleur, par une combinaison des deux ?Rappelez-vous que nous souhaitons obtenir les valeurs de la plus haute à la plus basse, mais les fonctions de tri renvoient par défaut les valeurs de la plus basse à la plus haute. Vous trouverez des fonctions utiles dans
List. - Concaténer des valeurs
-
Lorsque nous avons les valeurs
5et4, nous voulons renvoyer le nombre54. C'est ce qu'on appelle la concaténation. La concaténation n'est pas un opérateur mathématique standard sur les types numériques, mais c'est un opérateur standard sur les types textuels. Cela mène à deux manières principales de résoudre ce problème : de façon textuelle ou de façon numérique.La solution textuelle est la plus simple à écrire. Elle utilise la fonction
.joinToString()sur une liste pour concaténer tous ses éléments ensemble. Cependant, par défaut, elle donne un résultat comme5, 4et non54. De plus, le résultat est uneString, alors que nous devons renvoyer unInt: comment pouvons-nous y parvenir ?La solution numérique est un peu plus complexe à écrire mais elle est plus rapide et utilise moins de mémoire. Elle repose sur le constat que la concaténation de deux nombres
5et4peut s'écrire5 * 10 + 4, ce qui donne le résultat attendu54(dans les langages de programmation,*est souvent utilisé pour l'opérateur de multiplication×). Cette relation fonctionne également pour davantage de nombres : la concaténation de8,3et2peut s'écrire(8 * 10 + 3) * 10 + 2. Pour combiner les éléments d'une liste en une valeur unique à l'aide d'un opérateur mathématique, nous pouvons utiliser la fonction.reduce {}.
Maintenant que vous possédez toutes les pièces du puzzle, saurez-vous le résoudre ?
Une fois votre code correct, tous les tests devraient passer avec succès.
Vous pouvez désormais jouer au jeu pour de vrai ! Félicitations !
5. Optimiser¶
Niveau : débutant avec plus d'autonomie
Si vous souhaitez aller plus loin, ces quelques étapes peuvent améliorer davantage notre solution. Pensez à relancer les tests après chaque modification pour vérifier que vous n'avez pas cassé votre solution.
- Actuellement,
valueest calculée une fois pour chaqueDeck. Certains paquets sont créés sans jamais accéder àvalue. À la place, nous pourrions calculervaluede manière paresseuse, la première fois qu'elle est nécessaire. - Si vous avez utilisé la concaténation textuelle, remplacez-la par la concaténation numérique, qui utilise moins de mémoire et est légèrement plus rapide.
- Si vous avez utilisé du code différent pour le cas d'une seule carte et le cas de plusieurs cartes, essayez de les fusionner pour utiliser exactement le même code dans les deux cas.
- Si vous avez utilisé du code différent pour le cas sans aucune carte et les autres cas, essayez de les fusionner pour utiliser exactement le même code dans tous les cas. Vous pourriez être intéressé par la nullabilité.
- Essayez d'éviter les listes intermédiaires. Par exemple,
.map {}crée une liste temporaire.valuepeut être implémentée en utilisant une seule liste intermédiaire. - Essayez de simplifier le code autant que possible. En Kotlin, il est fréquent que le code le plus court soit à la fois le plus simple à comprendre et le plus efficace.
La solution la plus simple que nous ayons trouvée n'utilise que deux appels de fonctions et une seule liste intermédiaire. Dites-nous si vous trouvez mieux !