Merge branch 'TheAlgorithms:master' into master

Author: Gaspardcode

Cargo.toml

@@ -7,8 +7,7 @@ authors = ["Anshul Malik <[email protected]>"]
 [dependencies]
 num-bigint = { version = "0.4", optional = true }
 num-traits = { version = "0.2", optional = true }
-rand = "0.8"
-rand_chacha = "0.3"
+rand = "0.9"
 nalgebra = "0.33.0"
 
 [dev-dependencies]
@@ -25,14 +24,12 @@ restriction = "warn"
 nursery = "warn"
 cargo = "warn"
 # pedantic-lints:
-bool_to_int_with_if = { level = "allow", priority = 1 }
 cast_lossless = { level = "allow", priority = 1 }
 cast_possible_truncation = { level = "allow", priority = 1 }
 cast_possible_wrap = { level = "allow", priority = 1 }
 cast_precision_loss = { level = "allow", priority = 1 }
 cast_sign_loss = { level = "allow", priority = 1 }
 cloned_instead_of_copied = { level = "allow", priority = 1 }
-default_trait_access = { level = "allow", priority = 1 }
 doc_markdown = { level = "allow", priority = 1 }
 enum_glob_use = { level = "allow", priority = 1 }
 explicit_deref_methods = { level = "allow", priority = 1 }
@@ -49,15 +46,13 @@ manual_let_else = { level = "allow", priority = 1 }
 manual_string_new = { level = "allow", priority = 1 }
 many_single_char_names = { level = "allow", priority = 1 }
 match_on_vec_items = { level = "allow", priority = 1 }
-match_same_arms = { level = "allow", priority = 1 }
 match_wildcard_for_single_variants = { level = "allow", priority = 1 }
 missing_errors_doc = { level = "allow", priority = 1 }
 missing_fields_in_debug = { level = "allow", priority = 1 }
 missing_panics_doc = { level = "allow", priority = 1 }
 module_name_repetitions = { level = "allow", priority = 1 }
 must_use_candidate = { level = "allow", priority = 1 }
 needless_pass_by_value = { level = "allow", priority = 1 }
-range_plus_one = { level = "allow", priority = 1 }
 redundant_closure_for_method_calls = { level = "allow", priority = 1 }
 return_self_not_must_use = { level = "allow", priority = 1 }
 semicolon_if_nothing_returned = { level = "allow", priority = 1 }
@@ -145,6 +140,8 @@ cfg_not_test = { level = "allow", priority = 1 }
 field_scoped_visibility_modifiers = { level = "allow", priority = 1 }
 unused_trait_names = { level = "allow", priority = 1 }
 used_underscore_items = { level = "allow", priority = 1 }
+arbitrary_source_item_ordering = { level = "allow", priority = 1 }
+map_with_unused_argument_over_ranges = { level = "allow", priority = 1 }
 # nursery-lints:
 branches_sharing_code = { level = "allow", priority = 1 }
 cognitive_complexity = { level = "allow", priority = 1 }
@@ -167,3 +164,4 @@ doc_lazy_continuation = { level = "allow", priority = 1 }
 needless_return = { level = "allow", priority = 1 }
 # complexity-lints
 needless_lifetimes = { level = "allow", priority = 1 }
+precedence = { level = "allow", priority = 1 }

clippy.toml

@@ -0,0 +1,4 @@
+allowed-duplicate-crates = [
+    "zerocopy",
+    "zerocopy-derive",
+]

src/ciphers/transposition.rs

@@ -5,7 +5,7 @@
 //! original message. The most commonly referred to Transposition Cipher is the
 //! COLUMNAR TRANSPOSITION cipher, which is demonstrated below.
 
-use std::ops::Range;
+use std::ops::RangeInclusive;
 
 /// Encrypts or decrypts a message, using multiple keys. The
 /// encryption is based on the columnar transposition method.
@@ -142,8 +142,8 @@ fn decrypt(mut msg: String, key_order: Vec<usize>) -> String {
 
     split_large.iter_mut().rev().for_each(|key_index| {
         counter -= 1;
-        let range: Range<usize> =
-            ((*key_index * split_size) + counter)..(((*key_index + 1) * split_size) + counter + 1);
+        let range: RangeInclusive<usize> =
+            ((*key_index * split_size) + counter)..=(((*key_index + 1) * split_size) + counter);
 
         let slice: String = msg[range.clone()].to_string();
         indexed_vec.push((*key_index, slice));

src/data_structures/hash_table.rs

@@ -93,7 +93,7 @@ mod tests {
         let mut hash_table = HashTable::new();
         let initial_capacity = hash_table.elements.capacity();
 
-        for i in 0..initial_capacity * 3 / 4 + 1 {
+        for i in 0..=initial_capacity * 3 / 4 {
             hash_table.insert(TestKey(i), TestKey(i + 10));
         }
 

src/data_structures/lazy_segment_tree.rs

@@ -235,7 +235,10 @@ mod tests {
     fn check_single_interval_min(array: Vec<i32>) -> TestResult {
         let mut seg_tree = LazySegmentTree::from_vec(&array, min);
         for (i, value) in array.into_iter().enumerate() {
-            let res = seg_tree.query(i..(i + 1));
+            let res = seg_tree.query(Range {
+                start: i,
+                end: i + 1,
+            });
             if res != Some(value) {
                 return TestResult::error(format!("Expected {:?}, got {:?}", Some(value), res));
             }
@@ -247,7 +250,10 @@ mod tests {
     fn check_single_interval_max(array: Vec<i32>) -> TestResult {
         let mut seg_tree = LazySegmentTree::from_vec(&array, max);
         for (i, value) in array.into_iter().enumerate() {
-            let res = seg_tree.query(i..(i + 1));
+            let res = seg_tree.query(Range {
+                start: i,
+                end: i + 1,
+            });
             if res != Some(value) {
                 return TestResult::error(format!("Expected {:?}, got {:?}", Some(value), res));
             }
@@ -259,7 +265,10 @@ mod tests {
     fn check_single_interval_sum(array: Vec<i32>) -> TestResult {
         let mut seg_tree = LazySegmentTree::from_vec(&array, max);
         for (i, value) in array.into_iter().enumerate() {
-            let res = seg_tree.query(i..(i + 1));
+            let res = seg_tree.query(Range {
+                start: i,
+                end: i + 1,
+            });
             if res != Some(value) {
                 return TestResult::error(format!("Expected {:?}, got {:?}", Some(value), res));
             }

src/data_structures/probabilistic/bloom_filter.rs

@@ -108,7 +108,7 @@ pub struct MultiBinaryBloomFilter {
 
 impl MultiBinaryBloomFilter {
     pub fn with_dimensions(filter_size: usize, hash_count: usize) -> Self {
-        let bytes_count = filter_size / 8 + if filter_size % 8 > 0 { 1 } else { 0 }; // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
+        let bytes_count = filter_size / 8 + usize::from(filter_size % 8 > 0); // we need 8 times less entries in the array, since we are using bytes. Careful that we have at least one element though
         Self {
             filter_size,
             bytes: vec![0; bytes_count],

src/data_structures/probabilistic/count_min_sketch.rs

@@ -109,7 +109,7 @@ impl<T: Hash, const WIDTH: usize, const DEPTH: usize> Default
         let hashers = std::array::from_fn(|_| RandomState::new());
 
         Self {
-            phantom: Default::default(),
+            phantom: std::marker::PhantomData,
             counts: [[0; WIDTH]; DEPTH],
             hashers,
         }

src/data_structures/veb_tree.rs

@@ -322,21 +322,21 @@ mod test {
     #[test]
     fn test_10_256() {
         let mut rng = StdRng::seed_from_u64(0);
-        let elements: Vec<u32> = (0..10).map(|_| rng.gen_range(0..255)).collect();
+        let elements: Vec<u32> = (0..10).map(|_| rng.random_range(0..255)).collect();
         test_veb_tree(256, elements, Vec::new());
     }
 
     #[test]
     fn test_100_256() {
         let mut rng = StdRng::seed_from_u64(0);
-        let elements: Vec<u32> = (0..100).map(|_| rng.gen_range(0..255)).collect();
+        let elements: Vec<u32> = (0..100).map(|_| rng.random_range(0..255)).collect();
         test_veb_tree(256, elements, Vec::new());
     }
 
     #[test]
     fn test_100_300() {
         let mut rng = StdRng::seed_from_u64(0);
-        let elements: Vec<u32> = (0..100).map(|_| rng.gen_range(0..255)).collect();
+        let elements: Vec<u32> = (0..100).map(|_| rng.random_range(0..255)).collect();
         test_veb_tree(300, elements, Vec::new());
     }
 }

src/dynamic_programming/fibonacci.rs

@@ -226,7 +226,7 @@ fn get_pisano_sequence_and_period(m: i64) -> (i128, Vec<i128>) {
     let mut pisano_sequence: Vec<i128> = vec![a, b];
 
     // Iterating through all the fib numbers to get the sequence
-    for _i in 0..(m * m) + 1 {
+    for _i in 0..=(m * m) {
         let c = (a + b) % m as i128;
 
         // adding number into the sequence

src/general/genetic.rs

@@ -68,7 +68,7 @@ impl<Rng: rand::Rng> SelectionStrategy<Rng> for RouletteWheel<Rng> {
             return (parents[0], parents[1]);
         }
         let sum: f64 = fitnesses.iter().sum();
-        let mut spin = self.rng.gen_range(0.0..=sum);
+        let mut spin = self.rng.random_range(0.0..=sum);
         for individual in population {
             let fitness: f64 = individual.fitness().into();
             if spin <= fitness {
@@ -104,7 +104,7 @@ impl<const K: usize, Rng: rand::Rng> SelectionStrategy<Rng> for Tournament<K, Rn
         // This means we can draw K random (distinct) numbers between (0..population.len()) and return the chromosomes at the 2 lowest indices
         let mut picked_indices = BTreeSet::new(); // will keep indices ordered
         while picked_indices.len() < K {
-            picked_indices.insert(self.rng.gen_range(0..population.len()));
+            picked_indices.insert(self.rng.random_range(0..population.len()));
         }
         let mut iter = picked_indices.into_iter();
         (
@@ -185,15 +185,15 @@ impl<
 
             // 3. Apply random mutations to the whole population
             for chromosome in self.population.iter_mut() {
-                if self.rng.gen::<f64>() <= self.mutation_chance {
+                if self.rng.random::<f64>() <= self.mutation_chance {
                     chromosome.mutate(&mut self.rng);
                 }
             }
             // 4. Select parents that will be mating to create new chromosomes
             let mut new_population = Vec::with_capacity(self.population.len() + 1);
             while new_population.len() < self.population.len() {
                 let (p1, p2) = self.selection.select(&self.population);
-                if self.rng.gen::<f64>() <= self.crossover_chance {
+                if self.rng.random::<f64>() <= self.crossover_chance {
                     let child = p1.crossover(p2, &mut self.rng);
                     new_population.push(child);
                 } else {
@@ -220,7 +220,7 @@ mod tests {
         Tournament,
     };
     use rand::rngs::ThreadRng;
-    use rand::{thread_rng, Rng};
+    use rand::{rng, Rng};
     use std::collections::HashMap;
     use std::fmt::{Debug, Formatter};
     use std::ops::RangeInclusive;
@@ -240,7 +240,7 @@ mod tests {
         impl TestString {
             fn new(rng: &mut ThreadRng, secret: String, chars: RangeInclusive<char>) -> Self {
                 let current = (0..secret.len())
-                    .map(|_| rng.gen_range(chars.clone()))
+                    .map(|_| rng.random_range(chars.clone()))
                     .collect::<Vec<_>>();
 
                 Self {
@@ -258,16 +258,16 @@ mod tests {
         impl Chromosome<ThreadRng, i32> for TestString {
             fn mutate(&mut self, rng: &mut ThreadRng) {
                 // let's assume mutations happen completely randomly, one "gene" at a time (i.e. one char at a time)
-                let gene_idx = rng.gen_range(0..self.secret.len());
-                let new_char = rng.gen_range(self.chars.clone());
+                let gene_idx = rng.random_range(0..self.secret.len());
+                let new_char = rng.random_range(self.chars.clone());
                 self.genes[gene_idx] = new_char;
             }
 
             fn crossover(&self, other: &Self, rng: &mut ThreadRng) -> Self {
                 // Let's not assume anything here, simply mixing random genes from both parents
                 let genes = (0..self.secret.len())
                     .map(|idx| {
-                        if rng.gen_bool(0.5) {
+                        if rng.random_bool(0.5) {
                             // pick gene from self
                             self.genes[idx]
                         } else {
@@ -292,7 +292,7 @@ mod tests {
                     .count() as i32
             }
         }
-        let mut rng = thread_rng();
+        let mut rng = rng();
         let pop_count = 1_000;
         let mut population = Vec::with_capacity(pop_count);
         for _ in 0..pop_count {
@@ -388,7 +388,7 @@ mod tests {
             }
         }
         fn random_color(rng: &mut ThreadRng) -> ColoredPeg {
-            match rng.gen_range(0..=5) {
+            match rng.random_range(0..=5) {
                 0 => ColoredPeg::Red,
                 1 => ColoredPeg::Yellow,
                 2 => ColoredPeg::Green,
@@ -403,15 +403,15 @@ mod tests {
         impl Chromosome<ThreadRng, i32> for CodeBreaker {
             fn mutate(&mut self, rng: &mut ThreadRng) {
                 // change one random color
-                let idx = rng.gen_range(0..4);
+                let idx = rng.random_range(0..4);
                 self.guess[idx] = random_color(rng);
             }
 
             fn crossover(&self, other: &Self, rng: &mut ThreadRng) -> Self {
                 Self {
                     maker: self.maker.clone(),
                     guess: std::array::from_fn(|i| {
-                        if rng.gen::<f64>() < 0.5 {
+                        if rng.random::<f64>() < 0.5 {
                             self.guess[i]
                         } else {
                             other.guess[i]
@@ -443,7 +443,7 @@ mod tests {
             mutation_chance: 0.5,
             crossover_chance: 0.3,
         };
-        let mut rng = thread_rng();
+        let mut rng = rng();
         let mut initial_pop = Vec::with_capacity(population_count);
         for _ in 0..population_count {
             initial_pop.push(CodeBreaker {