Introduction
Les intervalles représentent un intervalle entre deux valeurs.
Les types les plus courants qui prennent en charge les intervalles sont Integer et String.
Ils servent à beaucoup de choses : créer rapidement une collection, découper des strings, vérifier si une valeur se trouve dans un intervalle, ou encore itérer.
On les crée à l'aide de l'opérateur d'intervalle .. ou ... (respectivement inclusifs et exclusifs).
1..5 # => 1..5
1...5 # => 1...5
(1..5).to_a # => [1, 2, 3, 4, 5]
(1...5).to_a # => [1, 2, 3, 4]
La raison d'avoir deux opérateurs d'intervalle est de permettre de créer des intervalles inclusifs ou exclusifs de la valeur de fin, ce qui peut être utile quand on travaille par exemple avec des indices qui commencent à zéro.
On peut aussi créer des intervalles avec le constructeur Range, new.
Range.new(1, 5) # A range containing 1, 2, 3, 4, 5
Quand tu crées un intervalle en Ruby avec les opérateurs .. ou ... et que tu veux appeler une méthode sur cet intervalle, tu dois l'entourer de parenthèses.
Sinon, la méthode sera appelée sur le deuxième argument de l'opérateur d'intervalle.
(1..5).sum # => 15
1..5.sum # => Error: undefined method `sum' for 5:Integer (NoMethodError)
Obtiens des sous-chaînes
Quand tu veux découper une string, tu peux utiliser l'opérateur d'intervalle pour obtenir une sous-chaîne.
Autrement dit, en créant un intervalle avec les indices de début et de fin de la sous-chaîne.
"Hello World"[0..4] # => "Hello"
"Hello World"[6..10] # => "World"
Tu peux aussi utiliser des indices négatifs pour obtenir la sous-chaîne à partir de la fin de la string.
"Hello World"[-5..-1] # => "World"
"Hello World"[6..-4] # => "Wo"
Méthodes des intervalles
Les intervalles disposent bien d'un ensemble de méthodes pour les manipuler.
Par exemple, ces méthodes permettent d'obtenir la somme de toutes les valeurs de l'intervalle ou de vérifier si l'intervalle contient une valeur.
| Méthode |
Description |
Exemple |
sum |
Renvoie la somme de toutes les valeurs de l'intervalle |
(1..5).sum # => 15 |
size |
Renvoie la taille de l'intervalle |
(1..5).size # => 5 |
include? |
Renvoie true si l'intervalle contient la valeur donnée, sinon false
|
(1..5).include?(3) # => true |
Intervalles sans fin et sans début
Un intervalle peut être sans fin ou sans début.
Dans un intervalle sans fin ou sans début, la valeur de fin ou de début vaut nil, mais on peut omettre ce nil au moment de définir l'intervalle.
Les intervalles sans début et sans fin sont pratiques quand tu veux, par exemple, découper une string depuis le début ou jusqu'à la fin.
"Hello World"[0..] # => "Hello World"
"Hello World"[4..] # => "o World"
"Hello World"[..5] # => "Hello "
S'il n'est pas utilisé sur une collection, l'intervalle sans fin peut provoquer une séquence sans fin si l'on n'y prend pas garde.
Intervalles de string
On peut aussi utiliser des strings dans des intervalles, ce qui permet d'obtenir un intervalle de strings entre deux strings.
Son comportement peut être un peu surprenant avec certaines strings, alors utilise-le avec prudence.
("aa".."az").to_a # => ["aa", "ab", "ac", ..., "az"]
Instructions
En passionné d'échecs, tu aimerais écrire ta propre version du jeu.
Oui, il existe sans doute déjà plein d'implémentations d'échecs en ligne, mais la tienne sera unique !
Tu commences par implémenter un système de déplacement de base pour les pièces.
Le jeu d'échecs se jouera sur un échiquier de 8 cases de large et de 8 cases de long.
Les cases sont identifiées par une lettre et un chiffre.
1. Définis l'intervalle des rangées et des colonnes
Le jeu devra stocker les rangées de l'échiquier.
Les rangées sont les lignes de l'échiquier et sont numérotées de 1 à 8.
Le jeu devra aussi stocker les colonnes de l'échiquier.
Les colonnes sont identifiées par les lettres A à H.
Définis les constantes Chess::RANKS et Chess::FILES qui stockent respectivement l'intervalle des rangées et des colonnes.
Chess::RANKS
# => 1..8
Chess::FILES
# => 'A'..'H'
2. Vérifie si une case est valide
Le jeu devra vérifier si une case est valide.
Une case est valide si sa rangée et sa colonne se trouvent dans les intervalles des rangées et des colonnes.
Définis la méthode Chess.valid_square? qui prend les arguments rank, qui contient un entier représentant la rangée, et file, qui contient un caractère représentant la colonne.
La méthode doit renvoyer true si la rangée et la colonne se trouvent dans les intervalles des rangées et des colonnes, et false sinon.
Chess.valid_square?(1, 'A')
# => true
3. Récupère le surnom du joueur
Le jeu devra récupérer le surnom du joueur.
Le surnom est composé des 2 premiers caractères du prénom du joueur et des 2 derniers caractères de son nom de famille.
Le surnom doit être en majuscules.
Définis la méthode Chess.nickname qui prend les arguments first_name, qui contient une string du prénom du joueur, et last_name, qui contient une string de son nom de famille.
La méthode doit renvoyer le surnom du joueur sous forme de string en majuscules.
Chess.nickname("John", "Doe")
# => "JOOE"
4. Crée le message de déplacement
Le jeu devra créer un message pour un déplacement, indiquant quel joueur s'est déplacé vers quelle case.
Le message doit utiliser le surnom du joueur et la case vers laquelle il s'est déplacé.
Le jeu doit aussi déterminer si le déplacement est valide en vérifiant que la colonne et la rangée de la case se trouvent dans les intervalles des colonnes et des rangées.
Si le déplacement est valide, le message doit être : "{nickname} moved to {square}"
Si le déplacement est invalide, le message doit être : "{nickname} attempted to move to {square}, but that is not a valid square"
Définis la méthode Chess.move_message qui prend les arguments first_name, qui contient une string du prénom du joueur, last_name, qui contient une string de son nom de famille, et square, qui contient une string de la case vers laquelle le joueur s'est déplacé.
La méthode doit renvoyer le message du déplacement sous forme de string.
Chess.move_message("John", "Doe", "A1")
# => "JOOE moved to A1"
Exercice d'apprentissage
