apply small optimization and refactors (51)

src/euler51/src/main.rs

@@ -32,27 +32,29 @@ const DIGITS: [u8; 10] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
 
 fn main() {
     let all_primes = Primes::get_between(MIN_VALUE, MAX_VALUE);
-    let mut processed_cases = HashSet::new();
+    let mut processed_cases = HashSet::with_capacity(MIN_VALUE as usize);
     let mut primes_matching_pattern = Vec::with_capacity(TARGET_LENGTH);
-    let mut case = String::with_capacity(LENGTH);
+    let mut case_buf = String::with_capacity(LENGTH);
 
     for pattern in PositionCombinations::new(MIN_LENGTH, MAX_LENGTH, LENGTH) {
         for prime in &all_primes.vector {
-            case.clear();
             primes_matching_pattern.clear();
 
             let digits = prime.to_digits();
 
-            get_case_string(&digits, &pattern, &mut case);
-            if processed_cases.contains(&case) {
+            get_case_string(&digits, &pattern, &mut case_buf);
+            if processed_cases.contains(&case_buf) {
                 continue;
             } else {
-                processed_cases.insert(case.clone());
+                processed_cases.insert(case_buf.clone());
             }
 
-            for digit in DIGITS {
+            for (i, digit) in DIGITS.iter().enumerate() {
+                if !enough_digits_left(i, primes_matching_pattern.len()) {
+                    break;
+                }
                 let could_be_prime =
-                    replace_digits_with_new_digit_according_to_pattern(&digits, digit, &pattern);
+                    replace_digits_with_new_digit_according_to_pattern(&digits, *digit, &pattern);
                 if all_primes.contains(&could_be_prime) {
                     primes_matching_pattern.push(could_be_prime);
                 }
@@ -65,7 +67,13 @@ fn main() {
     }
 }
 
+fn enough_digits_left(i: usize, primes_len: usize) -> bool {
+    // are there enough digits left in the loop to achieve the required TARGET_LENGTH?
+    i - primes_len + TARGET_LENGTH <= 10
+}
+
 fn get_case_string(digits: &[u8], pattern: &[bool], buf: &mut String) {
+    buf.clear();
     digits
         .iter()
         .zip(pattern)
@@ -101,19 +109,20 @@ trait ToDigits {
     fn to_digits(&self) -> Vec<u8>;
 }
 
-#[allow(clippy::needless_range_loop)]
 impl ToDigits for Int {
     fn to_digits(&self) -> Vec<u8> {
         let oom = get_order_of_magnitude(*self);
         let length = oom as usize;
         let mut var = *self;
         let mut result = vec![0; length];
-        for i in 0..length {
+
+        result.iter_mut().enumerate().for_each(|(i, d)| {
             let power = 10_u64.pow(oom - i as u32 - 1);
             let digit = var / power;
-            var -= (digit * power) as Int;
-            result[i] = digit as u8;
-        }
+            var -= digit * power;
+            *d = digit as u8;
+        });
+
         debug_assert_eq!(var, 0);
         result
     }