Améliorations du code basées sur clippy

diff --git a/src/day01.rs b/src/day01.rs
index d676be7ec3e53a493ed7c6fe671fa3c531707edf..50c0dfa89a086e1e43fa1b3af711c348fe322268 100644 (file)
--- a/src/day01.rs
+++ b/src/day01.rs
@@ -22,7 +22,7 @@ fn run_part1(input: &str) -> Result<u32, Box<dyn Error>> {
     let mut res = 0;
     for l in input.lines() {
         let digits: Vec<u32> = l.chars()
-            .filter(|c| c.is_digit(10))
+            .filter(|c| c.is_ascii_digit())
             .map(|c| c.to_digit(10).unwrap())
             .collect();
         res += 10 * digits[0] + digits[digits.len() - 1];
@@ -56,7 +56,7 @@ fn run_part2(input: &str) -> Result<u32, Box<dyn Error>> {
         // stocker (index, valeur)
         let mut digits: Vec<(usize, u32)> = l.chars()
             .enumerate()
-            .filter(|(_, c)| c.is_digit(10))
+            .filter(|(_, c)| c.is_ascii_digit())
             .map(|(i, c)| (i, c.to_digit(10).unwrap()))
             .collect();
 

diff --git a/src/day02.rs b/src/day02.rs
index 77da53a0b7fa716fd2df3fc9f96b468da6458c88..1b42ba9d9c8798fa230c916e0f27bd122e496fee 100644 (file)
--- a/src/day02.rs
+++ b/src/day02.rs
@@ -45,7 +45,7 @@ fn run_part1(input: &str) -> Result<i32, Box<dyn Error>> {
             let game_number: i32 = game[0].split(' ').last().unwrap().parse().unwrap();
             (game_number, game[1])
         })
-        .filter(|(g, l)| {
+        .filter(|(_g, l)| {
             // vecteur qui contient true/false selon si le tirage est correct ou non
             let mut result: Vec<bool> = Vec::new();
             l.split(';')

diff --git a/src/day03.rs b/src/day03.rs
index c97ea418345423edd6a4ea6812fa757a3ca82278..dfa6196279ebbf588d47b1d2de56c8d2f9994d7f 100644 (file)
--- a/src/day03.rs
+++ b/src/day03.rs
@@ -48,15 +48,11 @@ fn run_part1(input: &str) -> Result<i32, Box<dyn Error>> {
         let end = if idx_end < n_cols { idx_end + 1 } else { n_cols };
 
         for i in start..end {
-            if line_number > 0 {
-                if symbols[line_number - 1][i] {
-                    return true;
-                }
+            if line_number > 0 && symbols[line_number - 1][i] {
+                return true;
             }
-            if line_number < n_lines {
-                if symbols[line_number + 1][i] {
-                    return true;
-                }
+            if line_number < n_lines && symbols[line_number + 1][i] {
+                return true;
             }
             if symbols[line_number][i] {
                 return true;

diff --git a/src/day05.rs b/src/day05.rs
index 20829e555744db6d4c5bb268a6859bbb80ee8246..53336bb7605ae585fa43a4a5091f4527ded8e3b8 100644 (file)
--- a/src/day05.rs
+++ b/src/day05.rs
@@ -34,7 +34,7 @@ fn run_part1(input: &str) -> Result<usize, Box<dyn Error>> {
         .for_each(|bloc| {
             // check que la graine n'a pas été déjà vue pour ce bloc
             let mut seed_seen: Vec<bool> = (0..seeds.len()).map(|_| false).collect();
-            bloc.split("\n").skip(1).filter(|l| !l.is_empty())
+            bloc.split('\n').skip(1).filter(|l| !l.is_empty())
                 .for_each(|l| {
                     let values: Vec<usize> = l.split_whitespace()
                         .map(|s| s.parse().unwrap())
@@ -85,7 +85,7 @@ fn run_part2(input: &str) -> Result<usize, Box<dyn Error>> {
             // on stocke chaque mapping dans un tuple de la forme
             // (src, dst, len)
             // qui correspond aux bornes incluses des sous ensembles
-            let mut map: Vec<(usize, usize, usize)> = bloc.split("\n").skip(1)
+            let mut map: Vec<(usize, usize, usize)> = bloc.split('\n').skip(1)
                 .filter(|l| !l.is_empty())
                 .map(|l| {
                     let values: Vec<usize> = l.split_whitespace()
@@ -151,7 +151,7 @@ fn run_part2(input: &str) -> Result<usize, Box<dyn Error>> {
 
                                 // tout d'abord par rapport à l'ensemble source
                                 let range = src_start..=src_end;
-                                if range.contains(&seed_start)
+                                if range.contains(seed_start)
                                     && range.contains(&seed_end)
                                 {
                                     new_seeds.push((
@@ -159,7 +159,7 @@ fn run_part2(input: &str) -> Result<usize, Box<dyn Error>> {
                                         *seed_len
                                     ));
                                 }
-                                else if range.contains(&seed_start)
+                                else if range.contains(seed_start)
                                     && !range.contains(&seed_end)
                                 {
                                     new_seeds.push((
@@ -171,7 +171,7 @@ fn run_part2(input: &str) -> Result<usize, Box<dyn Error>> {
                                         seed_end - src_end
                                     ));
                                 }
-                                else if !range.contains(&seed_start)
+                                else if !range.contains(seed_start)
                                     && range.contains(&seed_end)
                                 {
                                     new_seeds.push((
@@ -183,7 +183,7 @@ fn run_part2(input: &str) -> Result<usize, Box<dyn Error>> {
                                         src_start - seed_start
                                     ));
                                 }
-                                else if !range.contains(&seed_start)
+                                else if !range.contains(seed_start)
                                     && !range.contains(&seed_end)
                                 {
                                     // l'ensemble source est inclus dans l'ensemble des graines

diff --git a/src/day06.rs b/src/day06.rs
index 6ab699e5cacf34e4ee3524538cabf4a870384111..371593529fe8241de57400b7ea5fac1289140e5e 100644 (file)
--- a/src/day06.rs
+++ b/src/day06.rs
@@ -33,19 +33,19 @@ fn remove_trailing_char(s: &str, c: char) -> &str {
 // dans cet exo on doit gerer le cas particulier où les racines sont entières
 // les racines entières sont à exclure (inégalité strict)
 fn solve(a: i32, b: i32, c: i32) -> (i32, i32) {
-    let D: f64 = (b.pow(2) - 4 * a * c) as f64;
-    if D < 0.0 {
+    let d: f64 = (b.pow(2) - 4 * a * c) as f64;
+    if d < 0.0 {
         // pas de solution
         unreachable!();
     }
     let a: f64 = a.into();
     let b: f64 = b.into();
-    let mut x1: f64 = ( -b - D.sqrt() ) / ( 2.0 * a );
-    let mut x2: f64 = ( -b + D.sqrt() ) / ( 2.0 * a );
+    let mut x1: f64 = ( -b - d.sqrt() ) / ( 2.0 * a );
+    let mut x2: f64 = ( -b + d.sqrt() ) / ( 2.0 * a );
 
     // gérer le cas d'egalite avec les bornes
-    if x1 == x1.ceil() { x1 = x1 + 1.0 }
-    if x2 == x2.floor() { x2 = x2 - 1.0 }
+    if x1 == x1.ceil() { x1 += 1.0 }
+    if x2 == x2.floor() { x2 -= 1.0 }
 
     (x1.ceil() as i32, x2.floor() as i32)
 }
@@ -73,7 +73,7 @@ fn run_part1(input: &str) -> Result<i32, Box<dyn Error>> {
         .map(|v| v.parse().unwrap())
         .collect();
 
-    let solutions: Vec<(i32, i32)> = time.iter().zip(dst.into_iter())
+    let solutions: Vec<(i32, i32)> = time.iter().zip(dst)
         .map(|(t, d)| {
             solve(1, -t, d)
         })
@@ -105,21 +105,21 @@ fn run_part2(input: &str) -> Result<i32, Box<dyn Error>> {
 
     let (a, b, c): (i64, i64, i64) = (1, -t, d);
 
-    let D_b: i64 = b.pow(2);
-    let D_4ac: i64 = 4 * a * c;
-    let D = D_b - D_4ac;
-    if D < 0 {
+    let d_b: i64 = b.pow(2);
+    let d_4ac: i64 = 4 * a * c;
+    let d = d_b - d_4ac;
+    if d < 0 {
         // pas de solution
         unreachable!();
     }
-    let (a, b, c): (f64, f64, f64) = (a as f64, b as f64, c as f64);
-    let D: f64 = D as f64;
-    let mut x1: f64 = ( -b - D.sqrt() ) / ( 2.0 * a );
-    let mut x2: f64 = ( -b + D.sqrt() ) / ( 2.0 * a );
+    let (a, b): (f64, f64) = (a as f64, b as f64);
+    let d: f64 = d as f64;
+    let mut x1: f64 = ( -b - d.sqrt() ) / ( 2.0 * a );
+    let mut x2: f64 = ( -b + d.sqrt() ) / ( 2.0 * a );
 
     // gérer le cas d'egalite avec les bornes
-    if x1 == x1.ceil() { x1 = x1 + 1.0 }
-    if x2 == x2.floor() { x2 = x2 - 1.0 }
+    if x1 == x1.ceil() { x1 += 1.0 }
+    if x2 == x2.floor() { x2 -= 1.0 }
 
     let (x1, x2) = (x1.ceil() as i32, x2.floor() as i32);
 

diff --git a/src/day07.rs b/src/day07.rs
index e659cee3ffb49a1ab8fd7b73e5e886305ec6531c..8231d4630aad98366828daddf5e783fcad3c3508 100644 (file)
--- a/src/day07.rs
+++ b/src/day07.rs
@@ -72,22 +72,17 @@ impl Hand {
         if with_jokers {
             // on ne conserve que les cartes qui ne sont pas des jokers
             // attention: si 5 jokers, on les garde
-            map = map.into_iter()
-            .filter(|(k,v)| (v > &0 && k != &'J') || (k == &'J' && v == &5))
-            .collect();
+            map.retain(|k, &mut v| (v > 0 && k != &'J') || (k == &'J' && v == 5));
         } else {
-            map = map.into_iter()
-            .filter(|(k,v)| v > &0)
-            .collect();
+            map.retain(|_, &mut v| v > 0);
         }
 
-        let mut occurrence = map.into_iter()
-            .map(|(_,v)| v)
+        let mut occurrence = map.into_values()
             .collect::<Vec<_>>();
 
         if with_jokers {
             // trie des occurences par ordre décroissant
-            occurrence.sort_by(|a, b| b.cmp(&a));
+            occurrence.sort_by(|a, b| b.cmp(a));
 
             // les J sont associées aux cartes ayant le plus d'occurrence
             // sauf si toutes les cartes sont des J
@@ -151,7 +146,7 @@ fn solve(input: &str, with_jokers: bool) -> u32 {
         });
 
     hands.sort_by(|a, b| {
-        a.partial_cmp(&b).unwrap()
+        a.partial_cmp(b).unwrap()
     });
 
     let res = hands.iter().enumerate()