[pull] master from TheAlgorithms:master

Cargo.toml

@@ -31,7 +31,6 @@ cast_precision_loss = { level = "allow", priority = 1 }
 cast_sign_loss = { level = "allow", priority = 1 }
 cloned_instead_of_copied = { level = "allow", priority = 1 }
 doc_markdown = { level = "allow", priority = 1 }
-enum_glob_use = { level = "allow", priority = 1 }
 explicit_deref_methods = { level = "allow", priority = 1 }
 explicit_iter_loop = { level = "allow", priority = 1 }
 float_cmp = { level = "allow", priority = 1 }
@@ -69,7 +68,6 @@ unused_self = { level = "allow", priority = 1 }
 used_underscore_binding = { level = "allow", priority = 1 }
 ref_option = { level = "allow", priority = 1 }
 unnecessary_semicolon = { level = "allow", priority = 1 }
-elidable_lifetime_names = { level = "allow", priority = 1 }
 # restriction-lints:
 absolute_paths = { level = "allow", priority = 1 }
 arithmetic_side_effects = { level = "allow", priority = 1 }
@@ -167,6 +165,5 @@ doc_lazy_continuation = { level = "allow", priority = 1 }
 needless_return = { level = "allow", priority = 1 }
 doc_overindented_list_items = { level = "allow", priority = 1 }
 # complexity-lints
-needless_lifetimes = { level = "allow", priority = 1 }
 precedence = { level = "allow", priority = 1 }
 manual_div_ceil = { level = "allow", priority = 1 }

DIRECTORY.md

@@ -262,6 +262,7 @@
     * [Haversine](https://github.com/TheAlgorithms/Rust/blob/master/src/navigation/haversine.rs)
   * Number Theory
     * [Compute Totient](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/compute_totient.rs)
+    * [Euler Totient](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/euler_totient.rs)
     * [Kth Factor](https://github.com/TheAlgorithms/Rust/blob/master/src/number_theory/kth_factor.rs)
   * Searching
     * [Binary Search](https://github.com/TheAlgorithms/Rust/blob/master/src/searching/binary_search.rs)

src/data_structures/binary_search_tree.rs

@@ -184,7 +184,7 @@ where
     stack: Vec<&'a BinarySearchTree<T>>,
 }
 
-impl<'a, T> BinarySearchTreeIter<'a, T>
+impl<T> BinarySearchTreeIter<'_, T>
 where
     T: Ord,
 {

src/data_structures/veb_tree.rs

@@ -221,7 +221,7 @@ impl<'a> VebTreeIter<'a> {
     }
 }
 
-impl<'a> Iterator for VebTreeIter<'a> {
+impl Iterator for VebTreeIter<'_> {
     type Item = u32;
 
     fn next(&mut self) -> Option<u32> {

src/math/random.rs

@@ -107,7 +107,7 @@ impl PCG32 {
     }
 }
 
-impl<'a> Iterator for IterMut<'a> {
+impl Iterator for IterMut<'_> {
     type Item = u32;
     fn next(&mut self) -> Option<Self::Item> {
         Some(self.pcg.get_u32())

src/number_theory/euler_totient.rs

@@ -0,0 +1,74 @@
+pub fn euler_totient(n: u64) -> u64 {
+    let mut result = n;
+    let mut num = n;
+    let mut p = 2;
+
+    // Find  all prime factors and apply formula
+    while p * p <= num {
+        // Check if p is a divisor of n
+        if num % p == 0 {
+            // If yes, then it is a prime factor
+            // Apply the formula: result = result * (1 - 1/p)
+            while num % p == 0 {
+                num /= p;
+            }
+            result -= result / p;
+        }
+        p += 1;
+    }
+
+    // If num > 1, then it is a prime factor
+    if num > 1 {
+        result -= result / num;
+    }
+
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    macro_rules! test_euler_totient {
+        ($($name:ident: $test_case:expr,)*) => {
+            $(
+                #[test]
+                fn $name() {
+                    let (input, expected) = $test_case;
+                    assert_eq!(euler_totient(input), expected)
+                }
+            )*
+        };
+    }
+
+    test_euler_totient! {
+        prime_2: (2, 1),
+        prime_3: (3, 2),
+        prime_5: (5, 4),
+        prime_7: (7, 6),
+        prime_11: (11, 10),
+        prime_13: (13, 12),
+        prime_17: (17, 16),
+        prime_19: (19, 18),
+
+        composite_6: (6, 2),     // 2 * 3
+        composite_10: (10, 4),   // 2 * 5
+        composite_15: (15, 8),   // 3 * 5
+        composite_12: (12, 4),   // 2^2 * 3
+        composite_18: (18, 6),   // 2 * 3^2
+        composite_20: (20, 8),   // 2^2 * 5
+        composite_30: (30, 8),   // 2 * 3 * 5
+
+        prime_power_2_to_2: (4, 2),
+        prime_power_2_to_3: (8, 4),
+        prime_power_3_to_2: (9, 6),
+        prime_power_2_to_4: (16, 8),
+        prime_power_5_to_2: (25, 20),
+        prime_power_3_to_3: (27, 18),
+        prime_power_2_to_5: (32, 16),
+
+        // Large numbers
+        large_50: (50, 20),      // 2 * 5^2
+        large_100: (100, 40),    // 2^2 * 5^2
+        large_1000: (1000, 400), // 2^3 * 5^3
+    }
+}

src/number_theory/mod.rs

@@ -1,5 +1,7 @@
 mod compute_totient;
+mod euler_totient;
 mod kth_factor;
 
 pub use self::compute_totient::compute_totient;
+pub use self::euler_totient::euler_totient;
 pub use self::kth_factor::kth_factor;

src/sorting/dutch_national_flag_sort.rs

@@ -11,7 +11,7 @@ pub enum Colors {
     White, //  | Define the three colors of the Dutch Flag: 🇳🇱
     Blue,  // /
 }
-use Colors::*;
+use Colors::{Blue, Red, White};
 
 // Algorithm implementation
 pub fn dutch_national_flag_sort(mut sequence: Vec<Colors>) -> Vec<Colors> {