Include unreachable mods (TheAlgorithms#594)

Author: CSRessel

.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;