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 soient très utiles, le découpage en tranches ne se limite pas qu'aux chaînes de caractères. Le concept de tranche 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é.

Vous pouvez créer des 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 slice qui en référence une partie ou la totalité :

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 référence le tableau entier

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 superflus
Diviser l'entrée par les virgules et analyser chaque nombre en i32
Créez un vecteur à partir de ces nombres
Lire la deuxième entrée (deux nombres séparés par un espace) et supprimer les espaces superflus
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 superflus
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

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 slice à partir du vecteur
    // Accéder à l'élément à l'indice spécifié à partir de la slice
    
    // Afficher le résultat
    // println!("{}", result);
}