From d79c543c720eb40bfd19f1e8a6ed4714fb85af10 Mon Sep 17 00:00:00 2001 From: julien Date: Tue, 13 Oct 2026 20:33:50 +0200 Subject: [PATCH] add some exercises --- exercises/command_parser.rb | 52 +++++++++++++++++++++++++ exercises/{ => done}/basket.rb | 0 exercises/{ => done}/cards_of_suit.rb | 0 exercises/{ => done}/follow_suit.rb | 0 exercises/{ => done}/gecko_01.rb | 0 exercises/{ => done}/gecko_02.rb | 0 exercises/{ => done}/gecko_03.rb | 0 exercises/{ => done}/hello.rb | 0 exercises/{ => done}/valid_word.rb | 0 exercises/group_meals.rb | 40 +++++++++++++++++++ exercises/hand_score.rb | 36 +++++++++++++++++ exercises/player_score.rb | 48 +++++++++++++++++++++++ exercises/trick_winner.rb | 56 +++++++++++++++++++++++++++ 13 files changed, 232 insertions(+) create mode 100644 exercises/command_parser.rb rename exercises/{ => done}/basket.rb (100%) rename exercises/{ => done}/cards_of_suit.rb (100%) rename exercises/{ => done}/follow_suit.rb (100%) rename exercises/{ => done}/gecko_01.rb (100%) rename exercises/{ => done}/gecko_02.rb (100%) rename exercises/{ => done}/gecko_03.rb (100%) rename exercises/{ => done}/hello.rb (100%) rename exercises/{ => done}/valid_word.rb (100%) create mode 100644 exercises/group_meals.rb create mode 100644 exercises/hand_score.rb create mode 100644 exercises/player_score.rb create mode 100644 exercises/trick_winner.rb diff --git a/exercises/command_parser.rb b/exercises/command_parser.rb new file mode 100644 index 0000000..1e644c8 --- /dev/null +++ b/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 diff --git a/exercises/basket.rb b/exercises/done/basket.rb similarity index 100% rename from exercises/basket.rb rename to exercises/done/basket.rb diff --git a/exercises/cards_of_suit.rb b/exercises/done/cards_of_suit.rb similarity index 100% rename from exercises/cards_of_suit.rb rename to exercises/done/cards_of_suit.rb diff --git a/exercises/follow_suit.rb b/exercises/done/follow_suit.rb similarity index 100% rename from exercises/follow_suit.rb rename to exercises/done/follow_suit.rb diff --git a/exercises/gecko_01.rb b/exercises/done/gecko_01.rb similarity index 100% rename from exercises/gecko_01.rb rename to exercises/done/gecko_01.rb diff --git a/exercises/gecko_02.rb b/exercises/done/gecko_02.rb similarity index 100% rename from exercises/gecko_02.rb rename to exercises/done/gecko_02.rb diff --git a/exercises/gecko_03.rb b/exercises/done/gecko_03.rb similarity index 100% rename from exercises/gecko_03.rb rename to exercises/done/gecko_03.rb diff --git a/exercises/hello.rb b/exercises/done/hello.rb similarity index 100% rename from exercises/hello.rb rename to exercises/done/hello.rb diff --git a/exercises/valid_word.rb b/exercises/done/valid_word.rb similarity index 100% rename from exercises/valid_word.rb rename to exercises/done/valid_word.rb diff --git a/exercises/group_meals.rb b/exercises/group_meals.rb new file mode 100644 index 0000000..85ce756 --- /dev/null +++ b/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 diff --git a/exercises/hand_score.rb b/exercises/hand_score.rb new file mode 100644 index 0000000..c006503 --- /dev/null +++ b/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 diff --git a/exercises/player_score.rb b/exercises/player_score.rb new file mode 100644 index 0000000..ec2e5ef --- /dev/null +++ b/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 diff --git a/exercises/trick_winner.rb b/exercises/trick_winner.rb new file mode 100644 index 0000000..ae0b304 --- /dev/null +++ b/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