#45 - Rust solver for problems 125 / 130

Author: barreiro

.idea/checkstyle-idea.xml

@@ -1,6 +1,7 @@
 [package]
 name = "euler"
 version = "1.0.0"
+edition = "2021"
 authors = ["barreiro <[email protected]>"]
 
 [[bin]]

.idea/gradle.xml

@@ -1,7 +1,7 @@
 // COPYRIGHT (C) 2017 barreiro. All Rights Reserved.
 // Rust solvers for Project Euler problems
 
-pub use euler::*;
+pub use crate::euler::*;
 
 /// solves all the problems! (the Euler ones)
 #[allow(clippy::too_many_lines)]
@@ -136,6 +136,11 @@ pub fn main() {
     solve(123, &Solver123::default());
     solve(124, &Solver124::default());
     solve(125, &Solver125::default());
+    solve(126, &Solver126::default());
+    solve(127, &Solver127::default());
+    solve(128, &Solver128::default());
+    solve(129, &Solver129::default());
+    solve(130, &Solver130::default());
 }
 
 mod euler {
@@ -264,6 +269,11 @@ mod euler {
     pub use self::solver123::Solver123;
     pub use self::solver124::Solver124;
     pub use self::solver125::Solver125;
+    pub use self::solver126::Solver126;
+    pub use self::solver127::Solver127;
+    pub use self::solver128::Solver128;
+    pub use self::solver129::Solver129;
+    pub use self::solver130::Solver130;
 
     pub trait Solver {
         fn problem_name(&self) -> &str;
@@ -417,4 +427,9 @@ mod euler {
     pub mod solver123;
     pub mod solver124;
     pub mod solver125;
+    pub mod solver126;
+    pub mod solver127;
+    pub mod solver128;
+    pub mod solver129;
+    pub mod solver130;
 }

.idea/modules.xml

@@ -1,23 +1,23 @@
 // COPYRIGHT (C) 2017 barreiro. All Rights Reserved.
 // Rust solvers for Project Euler problems
 
-use algorithm::combinatorics::{choose, partition};
-use algorithm::combinatorics::partition_with_constrains;
-use algorithm::combinatorics::permutations_of_digits_with;
-use algorithm::digits::Digits;
-use algorithm::factor::sum_of_factors;
-use algorithm::filter::{is_palindrome, is_pandigital};
-use algorithm::long::factorial;
-use algorithm::long::gcd;
-use algorithm::long::pow_mod;
-use algorithm::prime::{descending_primes, primes_trial_division_up_to};
-use algorithm::prime::miller_rabin;
-use algorithm::prime::prime_factors;
-use algorithm::prime::primes_up_to;
-use algorithm::prime::primes_wheel_up_to;
-use algorithm::root::exact_root;
-use algorithm::root::floor_sqrt;
-use algorithm::root::int_sqrt;
+use crate::algorithm::combinatorics::{choose, partition};
+use crate::algorithm::combinatorics::partition_with_constrains;
+use crate::algorithm::combinatorics::permutations_of_digits_with;
+use crate::algorithm::digits::Digits;
+use crate::algorithm::factor::sum_of_factors;
+use crate::algorithm::filter::{is_palindrome, is_pandigital};
+use crate::algorithm::long::factorial;
+use crate::algorithm::long::gcd;
+use crate::algorithm::long::pow_mod;
+use crate::algorithm::prime::{descending_primes, primes_trial_division_up_to};
+use crate::algorithm::prime::miller_rabin;
+use crate::algorithm::prime::prime_factors;
+use crate::algorithm::prime::primes_up_to;
+use crate::algorithm::prime::primes_wheel_up_to;
+use crate::algorithm::root::exact_root;
+use crate::algorithm::root::floor_sqrt;
+use crate::algorithm::root::int_sqrt;
 
 #[test]
 fn gcd_test() {

.idea/modules/euler.iml

@@ -2,7 +2,7 @@
 // Rust solvers for Project Euler problems
 
 use std::iter::FromIterator;
-use algorithm::long::{GetAndIncrement, IncrementAndGet};
+use crate::algorithm::long::{GetAndIncrement, IncrementAndGet};
 
 #[derive(Default)]
 #[must_use]
@@ -92,6 +92,13 @@ impl<'a> FromIterator<&'a u64> for BitSet {
 
 // --- //
 
+impl<'a> BitSet {
+    #[must_use]
+    pub fn iter(&'a self) -> BitSetIterator<'a> {
+        self.into_iter()
+    }
+}
+
 impl<'a> IntoIterator for &'a BitSet {
     type Item = u64;
     type IntoIter = BitSetIterator<'a>;
@@ -111,7 +118,7 @@ impl<'a> Iterator for BitSetIterator<'a> {
     type Item = u64;
 
     fn next(&mut self) -> Option<Self::Item> {
-        (self.seen.get_and_increment() < self.set.len()).then(||{
+        (self.seen.get_and_increment() < self.set.len()).then(|| {
             while {
                 !self.set.contains(self.index.increment_and_get())
             } {}