Autres types de slices

Fait partie de la section Logique & Flux du Journey Rust de Coddy. Leçon 57 sur 66.

Bien que les tranches de chaînes soient très utiles, le découpage ne se limite pas aux chaînes. Le concept de tranche de Rust s’étend à toute séquence d’éléments, ce qui en fait un outil puissant pour travailler avec des collections sans en prendre possession.

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

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

Le même principe fonctionne avec les vecteurs. Vous pouvez créer des slices à partir de vecteurs pour travailler avec des portions 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]; // Ceci 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. La troisième entrée est un nombre unique représentant un indice auquel accéder dans la tranche.

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

Exigences :

Lisez la première entrée (nombres séparés par des virgules) et supprimez les espaces superflus
Séparez l’entrée par des virgules et analysez chaque nombre en i32
Créez un vecteur à partir de ces nombres
Lisez la deuxième entrée (deux nombres séparés par un espace) et supprimez les espaces superflus
Séparez la deuxième entrée par un espace pour obtenir les indices de début et de fin
Analysez les deux indices en usize
Créez une tranche à partir du vecteur en utilisant la syntaxe d’intervalle &vec[start..end]
Lisez la troisième entrée (indice auquel accéder) et supprimez les espaces superflus
Analysez l’indice en usize
Accédez à l’élément situé à l’indice spécifié dans la tranche
Affichez l’élément auquel vous avez 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 nombre représentant un indice (par exemple, 2)

Sortie :

L’élément situé à l’indice spécifié dans 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 (index à 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'index spécifié depuis la slice
    
    // Afficher le résultat
    // println!("{}", result);
}