style: include range_plus_one (TheAlgorithms#869)

Author: vil02

Cargo.toml

@@ -53,7 +53,6 @@ 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 }

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/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/mex.rs

@@ -6,7 +6,7 @@ use std::collections::BTreeSet;
 /// O(nlog(n)) implementation
 pub fn mex_using_set(arr: &[i64]) -> i64 {
     let mut s: BTreeSet<i64> = BTreeSet::new();
-    for i in 0..arr.len() + 1 {
+    for i in 0..=arr.len() {
         s.insert(i as i64);
     }
     for x in arr {

src/graph/bipartite_matching.rs

@@ -45,13 +45,13 @@ impl BipartiteMatching {
     // Note: It does not modify self.mt1, it only works on self.mt2
     pub fn kuhn(&mut self) {
         self.mt2 = vec![-1; self.num_vertices_grp2 + 1];
-        for v in 1..self.num_vertices_grp1 + 1 {
+        for v in 1..=self.num_vertices_grp1 {
             self.used = vec![false; self.num_vertices_grp1 + 1];
             self.try_kuhn(v);
         }
     }
     pub fn print_matching(&self) {
-        for i in 1..self.num_vertices_grp2 + 1 {
+        for i in 1..=self.num_vertices_grp2 {
             if self.mt2[i] == -1 {
                 continue;
             }
@@ -115,7 +115,7 @@ impl BipartiteMatching {
         let mut dist = vec![i32::MAX; self.num_vertices_grp1 + 1];
         let mut res = 0;
         while self.bfs(&mut dist) {
-            for u in 1..self.num_vertices_grp1 + 1 {
+            for u in 1..=self.num_vertices_grp1 {
                 if self.mt1[u] == 0 && self.dfs(u as i32, &mut dist) {
                     res += 1;
                 }

src/machine_learning/cholesky.rs

@@ -4,7 +4,7 @@ pub fn cholesky(mat: Vec<f64>, n: usize) -> Vec<f64> {
     }
     let mut res = vec![0.0; mat.len()];
     for i in 0..n {
-        for j in 0..(i + 1) {
+        for j in 0..=i {
             let mut s = 0.0;
             for k in 0..j {
                 s += res[i * n + k] * res[j * n + k];

src/math/area_under_curve.rs

@@ -12,7 +12,7 @@ pub fn area_under_curve(start: f64, end: f64, func: fn(f64) -> f64, step_count:
     let mut fx1 = func(start);
     let mut fx2: f64;
 
-    for eval_point in (1..step_count + 1).map(|x| (x as f64 * step_length) + start) {
+    for eval_point in (1..=step_count).map(|x| (x as f64 * step_length) + start) {
         fx2 = func(eval_point);
         area += (fx2 + fx1).abs() * step_length * 0.5;
         fx1 = fx2;

src/math/factors.rs

@@ -6,7 +6,7 @@
 pub fn factors(number: u64) -> Vec<u64> {
     let mut factors: Vec<u64> = Vec::new();
 
-    for i in 1..((number as f64).sqrt() as u64 + 1) {
+    for i in 1..=((number as f64).sqrt() as u64) {
         if number % i == 0 {
             factors.push(i);
             if i != number / i {