add some exercises

exercises/command_parser.rb

@@ -0,0 +1,52 @@
+# Défi : interpréter une commande
+#
+# Tu construis une petite interface terminal.
+#
+# Écris la méthode `parse_command(input)`.
+#
+# Entrées possibles :
+#
+#   "play 3"
+#   "help"
+#   "quit"
+#
+# Résultats attendus :
+#
+# parse_command("play 3")
+# => { action: :play, card: 3 }
+#
+# parse_command("help")
+# => { action: :help }
+#
+# parse_command("quit")
+# => { action: :quit }
+#
+# Une commande invalide doit retourner :
+#
+#   { action: :invalid }
+#
+# Exemples invalides :
+#
+#   "play"
+#   "play three"
+#   "play 0"
+#   "play 3 extra"
+#   "hello"
+#
+# Contraintes :
+# - accepte les espaces au début et à la fin ;
+# - `play` n'accepte qu'un entier strictement positif ;
+# - la commande doit respecter exactement une des formes prévues ;
+# - ne lève pas d'exception pour une entrée invalide.
+#
+# Exemples supplémentaires :
+#
+# parse_command("  play 3  ")
+# => { action: :play, card: 3 }
+#
+# parse_command("play 3 extra")
+# => { action: :invalid }
+
+def parse_command(input)
+  # À compléter.
+end

exercises/group_meals.rb

@@ -0,0 +1,40 @@
+# Défi : regrouper des repas
+#
+# Écris la méthode `meal_totals(meals)`.
+#
+# Chaque repas contient un aliment et une quantité :
+#
+#   { food: "dubia", quantity: 2 }
+#
+# La méthode doit retourner un hash contenant la quantité totale
+# consommée pour chaque aliment.
+#
+# Exemple :
+#
+# meals = [
+#   { food: "dubia", quantity: 2 },
+#   { food: "mealworm", quantity: 3 },
+#   { food: "dubia", quantity: 1 }
+# ]
+#
+# meal_totals(meals)
+# => {
+#      "dubia" => 3,
+#      "mealworm" => 3
+#    }
+#
+# Contraintes :
+# - ne modifie pas le tableau d'origine ;
+# - le résultat doit fonctionner quel que soit le nom des aliments ;
+# - évite d'écrire une condition spécifique pour chaque aliment.
+
+meals = [
+  { food: "dubia", quantity: 2 },
+  { food: "mealworm", quantity: 3 },
+  { food: "dubia", quantity: 1 },
+  { food: "red_runner", quantity: 2 }
+]
+
+def meal_totals(meals)
+  # À compléter.
+end

exercises/hand_score.rb

@@ -0,0 +1,36 @@
+# Défi : score d'une main
+#
+# Écris la méthode `hand_score(cards)`.
+#
+# Chaque carte est représentée par un hash :
+#
+#   { value: "ace", suit: "hearts" }
+#
+# Valeurs :
+# - 7 à 10 valent leur valeur numérique ;
+# - jack vaut 11 ;
+# - queen vaut 12 ;
+# - king vaut 13 ;
+# - ace vaut 14.
+#
+# La méthode doit retourner la somme des valeurs de toutes les cartes.
+#
+# Contraintes :
+# - ne modifie pas le tableau d'origine ;
+# - évite une longue suite de `if` ;
+# - essaie de garder la méthode lisible.
+
+cards = [
+  { value: "7", suit: "clubs" },
+  { value: "king", suit: "hearts" },
+  { value: "ace", suit: "spades" }
+]
+
+def hand_score(cards)
+  # À compléter.
+end
+
+# Résultat attendu :
+#
+# hand_score(cards)
+# => 34

exercises/player_score.rb

@@ -0,0 +1,48 @@
+# Défi : joueur et score
+#
+# Complète la classe `Player`.
+#
+# Règles :
+# - un joueur possède un nom et un score ;
+# - le score commence à 0 ;
+# - `add_points(points)` ajoute des points ;
+# - seuls les entiers strictement positifs sont acceptés ;
+# - une valeur invalide ne doit pas modifier le score ;
+# - `winner?` retourne true si le score est supérieur ou égal à 5 ;
+# - `reset_score` remet le score à 0.
+#
+# Le nom doit être accessible en lecture mais pas modifiable directement.
+# Le score doit être accessible en lecture mais pas modifiable directement.
+
+class Player
+  # À compléter.
+end
+
+player = Player.new("Alice")
+
+# Résultats attendus :
+#
+# player.name
+# => "Alice"
+#
+# player.score
+# => 0
+#
+# player.add_points(2)
+# player.score
+# => 2
+#
+# player.add_points(-1)
+# player.score
+# => 2
+#
+# player.winner?
+# => false
+#
+# player.add_points(3)
+# player.winner?
+# => true
+#
+# player.reset_score
+# player.score
+# => 0

exercises/trick_winner.rb

@@ -0,0 +1,56 @@
+# Défi : gagnant d'un pli
+#
+# Deux cartes sont jouées.
+#
+# Écris la méthode :
+#
+#   trick_winner(card1, card2, trump_suit)
+#
+# Elle doit retourner `:card1` ou `:card2`.
+#
+# Chaque carte est représentée ainsi :
+#
+#   { value: "king", suit: "hearts" }
+#
+# La couleur demandée est celle de `card1`.
+#
+# Règles :
+# 1. une carte d'atout bat toujours une carte qui n'est pas d'atout ;
+# 2. si les deux cartes sont de la même couleur, la plus forte gagne ;
+# 3. sinon, `card1` gagne, puisque `card2` n'a ni suivi la couleur
+#    demandée ni joué un atout gagnant.
+#
+# Ordre des valeurs :
+#
+#   7 < 8 < 9 < 10 < jack < queen < king < ace
+#
+# Exemples :
+#
+# trick_winner(
+#   { value: "king", suit: "hearts" },
+#   { value: "ace", suit: "hearts" },
+#   "spades"
+# )
+# => :card2
+#
+# trick_winner(
+#   { value: "ace", suit: "hearts" },
+#   { value: "7", suit: "spades" },
+#   "spades"
+# )
+# => :card2
+#
+# trick_winner(
+#   { value: "ace", suit: "hearts" },
+#   { value: "king", suit: "clubs" },
+#   "spades"
+# )
+# => :card1
+#
+# Conseil :
+# commence par écrire une petite méthode qui donne une force numérique
+# à une valeur de carte.
+
+def trick_winner(card1, card2, trump_suit)
+  # À compléter.
+end