Autres types de slices

Fait partie de la section Logic & Flow du Journey Rust de Coddy — leçon 57 sur 66.

Bien que les tranches de chaînes (string slices) soient très utiles, le découpage ne se limite pas qu'aux chaînes de caractères. Le concept de slice de Rust s'étend à n'importe quelle séquence d'éléments, ce qui en fait un outil puissant pour travailler avec des collections sans en prendre la propriété (ownership).

Vous pouvez créer des tranches (slices) à partir de tableaux et de vecteurs en utilisant la même syntaxe que celle que vous avez apprise pour les chaînes de caractères. Par exemple, si vous avez un tableau de nombres, vous pouvez créer une tranche qui fait référence à une partie ou à la totalité de celui-ci :

let numbers = [1, 2, 3, 4, 5];
let slice: &[i32] = &numbers[1..4]; // Cela nous donne [2, 3, 4]
let full_slice: &[i32] = &numbers;  // Cela fait référence à l'ensemble du tableau

Le même principe s'applique aux vecteurs. Vous pouvez créer des tranches (slices) à partir de vecteurs pour travailler avec des parties des données sans les déplacer ni les copier :

let mut vec = vec![10, 20, 30, 40];
let vec_slice: &[i32] = &vec[0..2]; // Cela nous donne [10, 20]

Défi

Facile

Vous recevrez trois entrées. La première entrée est une liste de nombres séparés par des virgules. La deuxième entrée est composée de deux nombres séparés par un espace représentant les indices de début et de fin pour créer une tranche (slice). La troisième entrée est un nombre unique représentant un indice à accéder à partir de la tranche.

Créez un vecteur à partir des nombres séparés par des virgules, puis créez une tranche en utilisant la plage spécifiée. Accédez à l'élément à l'indice donné à partir de la tranche et affichez-le.

Exigences :

Lire la première entrée (nombres séparés par des virgules) et supprimer les espaces blancs
Diviser l'entrée par les virgules et analyser chaque nombre en i32
Créer un vecteur à partir de ces nombres
Lire la deuxième entrée (deux nombres séparés par un espace) et supprimer les espaces blancs
Diviser la deuxième entrée par l'espace pour obtenir les indices de début et de fin
Analyser les deux indices en usize
Créer une tranche à partir du vecteur en utilisant la syntaxe de plage &vec[start..end]
Lire la troisième entrée (indice à accéder) et supprimer les espaces blancs
Analyser l'indice en usize
Accéder à l'élément à l'indice spécifié à partir de la tranche
Afficher l'élément accédé

Entrée :

Première ligne : Nombres séparés par des virgules (par exemple, 10,20,30,40,50)
Deuxième ligne : Deux nombres séparés par un espace (par exemple, 1 4)
Troisième ligne : Un numéro d'indice (par exemple, 2)

Sortie :

L'élément à l'indice spécifié à partir de la tranche

Aide-mémoire

Les tranches (slices) peuvent être créées à partir de tableaux et de vecteurs, pas seulement de chaînes de caractères. Elles référencent une partie d'une collection sans en prendre la possession (ownership).

Création de tranches à partir de tableaux :

let numbers = [1, 2, 3, 4, 5];
let slice: &[i32] = &numbers[1..4]; // Référence [2, 3, 4]
let full_slice: &[i32] = &numbers;  // Référence le tableau entier

Création de tranches à partir de vecteurs :

let mut vec = vec![10, 20, 30, 40];
let vec_slice: &[i32] = &vec[0..2]; // Référence [10, 20]

Les tranches utilisent la même syntaxe de plage (range) que les tranches de chaînes de caractères et vous permettent de travailler avec des parties de données sans les déplacer ni les copier.

Essayez vous-même

use std::io::{self, BufRead};

fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines();
    
    // Lire la première entrée (nombres séparés par des virgules)
    let first_input = lines.next().unwrap().unwrap();
    
    // Lire la deuxième entrée (indices de début et de fin)
    let second_input = lines.next().unwrap().unwrap();
    
    // Lire la troisième entrée (indice à accéder)
    let third_input = lines.next().unwrap().unwrap();
    
    // TODO: Écrivez votre code ci-dessous
    // Analyser les nombres séparés par des virgules et créer un vecteur
    // Analyser les indices de début et de fin
    // Créer une tranche (slice) à partir du vecteur
    // Accéder à l'élément à l'indice spécifié à partir de la tranche
    
    // Afficher le résultat
    // println!("{}", result);
}