From 569be0c3456ee9338a1f4d92ed1d04fcd3dd8505 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20El=20Kharroubi?= <michael.el-kharroubi@hesge.ch> Date: Tue, 12 Sep 2023 23:18:29 +0200 Subject: [PATCH] Suggestion Orestis --- book/src/part10.md | 16 ++++++++++++++++ codes/rust_lang/part10/src/find.rs | 8 ++++++++ 2 files changed, 24 insertions(+) diff --git a/book/src/part10.md b/book/src/part10.md index f43e22a..02d6fca 100644 --- a/book/src/part10.md +++ b/book/src/part10.md @@ -162,20 +162,36 @@ Nous aimerions trouver quel est l'élément le plus petit en valeur absolue d'un La première étape consiste à créer deux itérateurs. Le premier contient le signe de chaque élément et le deuxième, la valeur absolue de chaque élément. +```rust,ignore +{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_1}} +``` + Pour obtenir ces itérateurs, nous allons transformer nos itérateurs obtenus avec `iter()` en utilsant la fonction `map()`. Cette méthode permet d'appliquer une même transformation sur tous les éléments d'un itérateur. Pour l'itérateur `signs`, on appelle la méthode `signum()` des `i32`, qui retourne 1 si le nombre est positif, 0 si le nombre est 0 et -1 si le nombre est négatif. Pour `abs_values`, nous utilisons la méthode `abs()` des `i32`, qui retourne la valeur absolue d'un nombre. +```rust,ignore +{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_2}} +``` + Maintenant que nous avons nos deux itérateurs, nous aimerions pouvoir itérer sur les deux simultanément. Pour cela, nous pouvons utiliser la méthode `zip()`. Elle permet de transformer deux itérateurs, en un unique itérateur de tuple. Ici nous avons deux itérateurs de `i32`, qui deviennent donc un seul itérateur de type tuple `(i32, i32)`. +```rust,ignore +{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_3}} +``` + Ensuite avec `fold()`, il nous suffit de comparer les valeurs absolues et de retourner une option contenant le signe et la valeur absolue. +```rust,ignore +{{#include ../../codes/rust_lang/part10/src/find.rs:find_absolute_minimum_4}} +``` + Pour finir, on utilise la méthode `map()` de notre `Option<(i32,i32)>` pour multiplier la valeur absolue par le signe. Ce qui nous donne au final une `Option<i32>` contenant notre résultat. diff --git a/codes/rust_lang/part10/src/find.rs b/codes/rust_lang/part10/src/find.rs index 1934d0b..8b0e6e3 100644 --- a/codes/rust_lang/part10/src/find.rs +++ b/codes/rust_lang/part10/src/find.rs @@ -80,10 +80,15 @@ pub fn find_even_minimum(v: &Vec<i32>) -> Option<i32> { /// ``` // ANCHOR: find_absolute_minimum pub fn find_absolute_minimum(v: &Vec<i32>) -> Option<i32> { + // ANCHOR: find_absolute_minimum_1 let signs = v.iter().map(|i| i.signum()); let abs_values = v.iter().map(|i| i.abs()); + // ANCHOR_END: find_absolute_minimum_1 + // ANCHOR: find_absolute_minimum_2 signs .zip(abs_values) + // ANCHOR_END: find_absolute_minimum_2 + // ANCHOR: find_absolute_minimum_3 .fold(None, |acc, (c_sign, c_abs_v)| { let next_acc = if let Some((sign, abs_v)) = acc { if abs_v <= c_abs_v { @@ -96,6 +101,9 @@ pub fn find_absolute_minimum(v: &Vec<i32>) -> Option<i32> { }; Some(next_acc) }) + // ANCHOR_END: find_absolute_minimum_3 + // ANCHOR: find_absolute_minimum_4 .map(|(sign, abs_v)| sign * abs_v) + // ANCHOR_END: find_absolute_minimum_4 } // ANCHOR_END: find_absolute_minimum -- GitLab