[pull] master from TheAlgorithms:master

.github/pull_request_template.md

@@ -20,6 +20,7 @@ Please delete options that are not relevant.
 - [ ] I ran `cargo clippy --all -- -D warnings` just before my last commit and fixed any issue that was found.
 - [ ] I ran `cargo fmt` just before my last commit.
 - [ ] I ran `cargo test` just before my last commit and all tests passed.
+- [ ] I added my algorithm to the corresponding `mod.rs` file within its own folder, and in any parent folder(s).
 - [ ] I added my algorithm to `DIRECTORY.md` with the correct link.
 - [ ] I checked `COUNTRIBUTING.md` and my code follows its guidelines.
 

src/ciphers/baconian_cipher.rs

@@ -4,9 +4,8 @@
 // Bacon's cipher or the Baconian cipher is a method of steganographic message encoding devised by Francis Bacon in 1605.
 // A message is concealed in the presentation of text, rather than its content. Bacon cipher is categorized as both a substitution cipher (in plain code) and a concealment cipher (using the two typefaces).
 
-
 // Encode Baconian Cipher
-fn baconian_encode(message: &str) -> String {
+pub fn baconian_encode(message: &str) -> String {
     let alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
     let baconian = [
         "AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA", "AABAB", "AABBA", "AABBB", "ABAAA", "ABAAB",
@@ -18,17 +17,16 @@ fn baconian_encode(message: &str) -> String {
         .chars()
         .map(|c| {
             if let Some(index) = alphabet.find(c.to_ascii_uppercase()) {
-                baconian[index as usize].to_string()
+                baconian[index].to_string()
             } else {
                 c.to_string()
             }
         })
         .collect()
 }
 
-
 // Decode Baconian Cipher
-fn baconian_decode(encoded: &str) -> String {
+pub fn baconian_decode(encoded: &str) -> String {
     let baconian = [
         "AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA", "AABAB", "AABBA", "AABBB", "ABAAA", "ABAAB",
         "ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA", "ABBBB", "BAAAA", "BAAAB", "BAABA", "BAABB",
@@ -40,7 +38,10 @@ fn baconian_decode(encoded: &str) -> String {
         .as_bytes()
         .chunks(5)
         .map(|chunk| {
-            if let Some(index) = baconian.iter().position(|&x| x == String::from_utf8_lossy(chunk)) {
+            if let Some(index) = baconian
+                .iter()
+                .position(|&x| x == String::from_utf8_lossy(chunk))
+            {
                 alphabet.chars().nth(index).unwrap()
             } else {
                 ' '

src/ciphers/mod.rs

@@ -1,5 +1,6 @@
 mod aes;
 mod another_rot13;
+mod baconian_cipher;
 mod base64;
 mod blake2b;
 mod caesar;
@@ -21,6 +22,7 @@ mod vigenere;
 mod xor;
 pub use self::aes::{aes_decrypt, aes_encrypt, AesKey};
 pub use self::another_rot13::another_rot13;
+pub use self::baconian_cipher::{baconian_decode, baconian_encode};
 pub use self::base64::{base64_decode, base64_encode};
 pub use self::blake2b::blake2b;
 pub use self::caesar::caesar;

src/conversions/binary_to_hexadecimal.rs

@@ -22,7 +22,7 @@ static BITS_TO_HEX: &[(u8, &str)] = &[
     (0b1111, "f"),
 ];
 
-fn bin_to_hexadecimal(binary_str: &str) -> String {
+pub fn binary_to_hexadecimal(binary_str: &str) -> String {
     let binary_str = binary_str.trim();
 
     if binary_str.is_empty() {
@@ -41,7 +41,11 @@ fn bin_to_hexadecimal(binary_str: &str) -> String {
     }
 
     let padded_len = (4 - (binary_str.len() % 4)) % 4;
-    let binary_str = format!("{:0width$}", binary_str, width = binary_str.len() + padded_len);
+    let binary_str = format!(
+        "{:0width$}",
+        binary_str,
+        width = binary_str.len() + padded_len
+    );
 
     // Convert binary to hexadecimal
     let mut hexadecimal = String::with_capacity(binary_str.len() / 4 + 2);
@@ -50,7 +54,7 @@ fn bin_to_hexadecimal(binary_str: &str) -> String {
     for chunk in binary_str.as_bytes().chunks(4) {
         let mut nibble = 0;
         for (i, &byte) in chunk.iter().enumerate() {
-            nibble |= ((byte - b'0') as u8) << (3 - i);
+            nibble |= (byte - b'0') << (3 - i);
         }
 
         let hex_char = BITS_TO_HEX
@@ -76,27 +80,27 @@ mod tests {
     fn test_empty_string() {
         let input = "";
         let expected = "Invalid Input";
-        assert_eq!(bin_to_hexadecimal(input), expected);
+        assert_eq!(binary_to_hexadecimal(input), expected);
     }
 
     #[test]
     fn test_invalid_binary() {
         let input = "a";
         let expected = "Invalid Input";
-        assert_eq!(bin_to_hexadecimal(input), expected);
+        assert_eq!(binary_to_hexadecimal(input), expected);
     }
 
     #[test]
     fn test_binary() {
         let input = "00110110";
         let expected = "0x36";
-        assert_eq!(bin_to_hexadecimal(input), expected);
+        assert_eq!(binary_to_hexadecimal(input), expected);
     }
 
     #[test]
     fn test_padded_binary() {
         let input = " 1010   ";
         let expected = "0xa";
-        assert_eq!(bin_to_hexadecimal(input), expected);
+        assert_eq!(binary_to_hexadecimal(input), expected);
     }
 }

src/conversions/hexadecimal_to_binary.rs

@@ -4,7 +4,7 @@
 //                         2. https://en.wikipedia.org/wiki/Binary_number
 // Other References for Testing : https://www.rapidtables.com/convert/number/hex-to-binary.html
 
-fn hexadecimal_to_binary(hex_str: &str) -> Result<String, String> {
+pub fn hexadecimal_to_binary(hex_str: &str) -> Result<String, String> {
     let hex_chars = hex_str.chars().collect::<Vec<char>>();
     let mut binary = String::new();
 

src/conversions/mod.rs

@@ -1,4 +1,10 @@
 mod binary_to_decimal;
+mod binary_to_hexadecimal;
 mod decimal_to_binary;
+mod hexadecimal_to_binary;
+mod octal_to_binary;
 pub use self::binary_to_decimal::binary_to_decimal;
+pub use self::binary_to_hexadecimal::binary_to_hexadecimal;
 pub use self::decimal_to_binary::decimal_to_binary;
+pub use self::hexadecimal_to_binary::hexadecimal_to_binary;
+pub use self::octal_to_binary::octal_to_binary;

src/conversions/octal_to_binary.rs

@@ -3,14 +3,14 @@
 // Wikipedia References  : 1. https://en.wikipedia.org/wiki/Octal
 //                         2. https://en.wikipedia.org/wiki/Binary_number
 
-fn octal_to_binary(octal_str: &str) -> Result<String, &'static str> {
+pub fn octal_to_binary(octal_str: &str) -> Result<String, &'static str> {
     let octal_str = octal_str.trim();
 
     if octal_str.is_empty() {
         return Err("Empty");
     }
 
-    if !octal_str.chars().all(|c| c >= '0' && c <= '7') {
+    if !octal_str.chars().all(|c| ('0'..'7').contains(&c)) {
         return Err("Non-octal Value");
     }
 
@@ -54,8 +54,7 @@ mod tests {
     #[test]
     fn test_valid_octal() {
         let input = "123";
-        let expected = Ok("001010011".to_string()); 
+        let expected = Ok("001010011".to_string());
         assert_eq!(octal_to_binary(input), expected);
     }
-
 }

src/data_structures/floyds_algorithm.rs

@@ -49,11 +49,9 @@ pub fn has_cycle<T>(linked_list: &LinkedList<T>) -> bool {
             }
 
             if slow == fast {
-
                 return true; // Cycle detected
             }
         }
-
     }
     // println!("{}", flag);
     false // No cycle detected
@@ -70,7 +68,7 @@ mod tests {
         linked_list.insert_at_tail(2);
         linked_list.insert_at_tail(3);
 
-        assert_eq!(has_cycle(&linked_list), false);
+        assert!(!has_cycle(&linked_list));
 
         assert_eq!(detect_cycle(&mut linked_list), None);
     }
@@ -91,7 +89,7 @@ mod tests {
             }
         }
 
-        assert_eq!(has_cycle(&linked_list), true);
+        assert!(has_cycle(&linked_list));
         assert_eq!(detect_cycle(&mut linked_list), Some(3));
     }
 }

src/data_structures/infix_to_postfix.rs

@@ -1,5 +1,5 @@
 // Function to convert infix expression to postfix expression
-fn infix_to_postfix(infix: &str) -> String {
+pub fn infix_to_postfix(infix: &str) -> String {
     let mut postfix = String::new();
     let mut stack: Vec<char> = Vec::new();
 
@@ -53,17 +53,13 @@ fn infix_to_postfix(infix: &str) -> String {
     postfix
 }
 
-
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_infix_to_postfix() {
-        assert_eq!(
-            infix_to_postfix("a-b+c-d*e"),
-            "ab-c+de*-".to_string()
-        );
+        assert_eq!(infix_to_postfix("a-b+c-d*e"), "ab-c+de*-".to_string());
         assert_eq!(
             infix_to_postfix("a*(b+c)+d/(e+f)"),
             "abc+*def+/+".to_string()

src/data_structures/mod.rs

@@ -2,10 +2,13 @@ mod avl_tree;
 mod b_tree;
 mod binary_search_tree;
 mod fenwick_tree;
+mod floyds_algorithm;
 mod graph;
 mod heap;
+mod infix_to_postfix;
 mod lazy_segment_tree;
 mod linked_list;
+mod postfix_evaluation;
 mod probabilistic;
 mod queue;
 mod rb_tree;
@@ -21,11 +24,14 @@ pub use self::avl_tree::AVLTree;
 pub use self::b_tree::BTree;
 pub use self::binary_search_tree::BinarySearchTree;
 pub use self::fenwick_tree::FenwickTree;
+pub use self::floyds_algorithm::{detect_cycle, has_cycle};
 pub use self::graph::DirectedGraph;
 pub use self::graph::UndirectedGraph;
 pub use self::heap::Heap;
+pub use self::infix_to_postfix::infix_to_postfix;
 pub use self::lazy_segment_tree::LazySegmentTree;
 pub use self::linked_list::LinkedList;
+pub use self::postfix_evaluation::evaluate_postfix;
 pub use self::probabilistic::bloom_filter;
 pub use self::probabilistic::count_min_sketch;
 pub use self::queue::Queue;

src/data_structures/postfix_evaluation.rs

@@ -1,4 +1,4 @@
-fn evaluate_postfix(expression: &str) -> Result<i32, &'static str> {
+pub fn evaluate_postfix(expression: &str) -> Result<i32, &'static str> {
     let mut stack: Vec<i32> = Vec::new();
 
     for token in expression.split_whitespace() {
@@ -56,4 +56,3 @@ mod tests {
         assert_eq!(evaluate_postfix("5 0 /"), Err("Division by zero"));
     }
 }
-

src/general/kadane_algorithm.rs

@@ -18,21 +18,21 @@
  * @param arr A slice of integers representing the array.
  * @return The maximum subarray sum.
  */
- fn max_sub_array(nums: Vec<i32>) -> i32 {
+pub fn max_sub_array(nums: Vec<i32>) -> i32 {
     if nums.is_empty() {
         return 0;
     }
 
     let mut max_current = nums[0];
     let mut max_global = nums[0];
 
-    for i in 1..nums.len() {
-        max_current = std::cmp::max(nums[i], max_current + nums[i]);
+    nums.iter().skip(1).for_each(|&item| {
+        max_current = std::cmp::max(item, max_current + item);
         if max_current > max_global {
             max_global = max_current;
         }
-    }
-    return max_global;
+    });
+    max_global
 }
 
 #[cfg(test)]

src/general/mod.rs

@@ -3,6 +3,7 @@ mod fisher_yates_shuffle;
 mod genetic;
 mod hanoi;
 mod huffman_encoding;
+mod kadane_algorithm;
 mod kmeans;
 mod mex;
 mod permutations;
@@ -13,6 +14,7 @@ pub use self::fisher_yates_shuffle::fisher_yates_shuffle;
 pub use self::genetic::GeneticAlgorithm;
 pub use self::hanoi::hanoi;
 pub use self::huffman_encoding::{HuffmanDictionary, HuffmanEncoding};
+pub use self::kadane_algorithm::max_sub_array;
 pub use self::kmeans::f32::kmeans as kmeans_f32;
 pub use self::kmeans::f64::kmeans as kmeans_f64;
 pub use self::mex::mex_using_set;

src/machine_learning/mod.rs

@@ -3,9 +3,7 @@ mod loss_function;
 mod optimization;
 
 pub use self::linear_regression::linear_regression;
-
 pub use self::loss_function::mae_loss;
 pub use self::loss_function::mse_loss;
-
 pub use self::optimization::gradient_descent;
 pub use self::optimization::Adam;

src/machine_learning/optimization/mod.rs

@@ -1,6 +1,5 @@
-mod gradient_descent;
-
 mod adam;
+mod gradient_descent;
 
 pub use self::adam::Adam;
 pub use self::gradient_descent::gradient_descent;

src/math/area_of_polygon.rs

@@ -14,7 +14,7 @@
  * @see [Wikipedia - Polygon](https://en.wikipedia.org/wiki/Polygon)
  */
 
- struct Point {
+pub struct Point {
     x: f64,
     y: f64,
 }
@@ -25,7 +25,7 @@
  * @return The area of the polygon.
  */
 
-fn area(fig: &Vec<Point>) -> f64 {
+pub fn area_of_polygon(fig: &Vec<Point>) -> f64 {
     let mut res = 0.0;
 
     for i in 0..fig.len() {
@@ -57,7 +57,7 @@ mod tests {
             Point { x: 0.0, y: 1.0 },
         ];
 
-        assert_eq!(area(&points), 0.5);
+        assert_eq!(area_of_polygon(&points), 0.5);
     }
 
     /**
@@ -72,7 +72,7 @@ mod tests {
             Point { x: 0.0, y: 1.0 },
         ];
 
-        assert_eq!(area(&points), 1.0);
+        assert_eq!(area_of_polygon(&points), 1.0);
     }
 
     /**
@@ -89,6 +89,6 @@ mod tests {
             Point { x: -0.5, y: 0.866 },
         ];
 
-        assert_eq!(area(&points), 2.598);
+        assert_eq!(area_of_polygon(&points), 2.598);
     }
 }

src/math/area_under_curve.rs

@@ -1,4 +1,4 @@
-fn area_under_curve(start: f64, end: f64, func: fn(f64) -> f64, step_count: usize) -> f64 {
+pub fn area_under_curve(start: f64, end: f64, func: fn(f64) -> f64, step_count: usize) -> f64 {
     assert!(step_count > 0);
 
     let (start, end) = if start > end {