Pangram and Lipogram checker (rust-lang#660)

---------

Co-authored-by: Piotr Idzik <[email protected]>

Author: Adin3

DIRECTORY.md

@@ -302,8 +302,10 @@
     * [Jaro Winkler Distance](https://github.com/TheAlgorithms/Rust/blob/master/src/string/jaro_winkler_distance.rs)
     * [Knuth Morris Pratt](https://github.com/TheAlgorithms/Rust/blob/master/src/string/knuth_morris_pratt.rs)
     * [Levenshtein Distance](https://github.com/TheAlgorithms/Rust/blob/master/src/string/levenshtein_distance.rs)
+    * [Lipogram](https://github.com/TheAlgorithms/Rust/blob/master/src/string/lipogram.rs)
     * [Manacher](https://github.com/TheAlgorithms/Rust/blob/master/src/string/manacher.rs)
     * [Palindrome](https://github.com/TheAlgorithms/Rust/blob/master/src/string/palindrome.rs)
+    * [Pangram](https://github.com/TheAlgorithms/Rust/blob/master/src/string/pangram.rs)
     * [Rabin Karp](https://github.com/TheAlgorithms/Rust/blob/master/src/string/rabin_karp.rs)
     * [Reverse](https://github.com/TheAlgorithms/Rust/blob/master/src/string/reverse.rs)
     * [Run Length Encoding](https://github.com/TheAlgorithms/Rust/blob/master/src/string/run_length_encoding.rs)

src/string/lipogram.rs

@@ -0,0 +1,93 @@
+use std::collections::HashSet;
+
+/// Function that returns the letters that are missing from the input slice  
+/// and are present in the English alphabet  
+///
+/// ## Arguments
+///
+/// * `in_str` - the slice that will be checked for missing characters
+///
+fn compute_missing(in_str: &str) -> HashSet<char> {
+    let alphabet: HashSet<char> = "abcdefghijklmnopqrstuvwxyz".chars().collect();
+
+    let letters_used: HashSet<char> = in_str
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .collect();
+
+    alphabet.difference(&letters_used).cloned().collect()
+}
+
+/// Function that checks if the slice is a lipogram with specific missing letters.  
+/// Lipogram - sentence in which a particular letter or group of letters is avoided
+///
+/// ## Arguments
+///
+/// * `lipogram_str` - the slice that will be checked if is a lipogram with specific missing letters
+/// * `missing_chars` - the characters that has to be missing
+///
+/// ## Examples
+///
+/// ```
+/// use the_algorithms_rust::string::is_lipogram;
+/// use std::collections::HashSet;
+///
+/// assert!(
+///    !is_lipogram("The quick brown fox jumps over the lazy dog",
+///    &HashSet::from(['x'])
+/// ));
+///
+/// assert!(
+///    is_lipogram("The brown cat jumped over the lazy dog with a brick",
+///    &HashSet::from(['f', 'q', 's', 'x'])
+/// ));
+///
+/// assert!(
+///    !is_lipogram("The quick brown fox jumped over the lazy dog",
+///    &HashSet::from(['x'])
+/// ));
+/// ```
+pub fn is_lipogram(lipogram_str: &str, missing_chars: &HashSet<char>) -> bool {
+    if !missing_chars.iter().all(|&c| c.is_lowercase()) {
+        panic!("missing_chars should be all lowercase.")
+    }
+
+    missing_chars == &compute_missing(lipogram_str)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    macro_rules! test_lipogram {
+    ($($name:ident: $inputs:expr,)*) => {
+    $(
+        #[test]
+        fn $name() {
+            let (in_str, missing_chars, other_chars) = $inputs;
+            assert_ne!(missing_chars, other_chars);
+            assert_eq!(compute_missing(in_str), missing_chars);
+            assert!(is_lipogram(in_str, &missing_chars));
+            assert!(!is_lipogram(in_str, &other_chars));
+        }
+    )*
+    }
+}
+
+    test_lipogram! {
+        lipogram1: ("The quick brown fox jumps over the lazy dog", HashSet::from([]), HashSet::from(['a', 'b'])),
+        lipogram2: ("Jackdaws love my big sphinx of quartz", HashSet::from([]), HashSet::from(['x'])),
+        lipogram3: ("abcdefghijklmnopqrstuvwxyz", HashSet::from([]), HashSet::from(['x', 'y', 'z'])),
+        lipogram4: ("Five quacking zephyrs jolt my wax bed", HashSet::from([]), HashSet::from(['a'])),
+        lipogram5: ("The quick brown fox jumped over the lazy dog", HashSet::from(['s']), HashSet::from([])),
+        lipogram6: ("abcdefghijklmnopqrstuvwxy", HashSet::from(['z']), HashSet::from(['y', 'z'])),
+        lipogram7: ("The brown fox jumped over the lazy dog with a brick", HashSet::from(['q', 's']), HashSet::from(['b'])),
+        lipogram8: ("ABCdefghijklmnopqrstuvwx", HashSet::from(['y', 'z']), HashSet::from(['a', 'b'])),
+    }
+
+    #[test]
+    #[should_panic]
+    fn test_is_lipogram_panics_when_missing_chars_are_upper_case() {
+        is_lipogram("abcdefghijklmnopqrstuvwx", &HashSet::from(['y', 'Z']));
+    }
+}

src/string/mod.rs

@@ -8,8 +8,10 @@ mod hamming_distance;
 mod jaro_winkler_distance;
 mod knuth_morris_pratt;
 mod levenshtein_distance;
+mod lipogram;
 mod manacher;
 mod palindrome;
+mod pangram;
 mod rabin_karp;
 mod reverse;
 mod run_length_encoding;
@@ -30,8 +32,11 @@ pub use self::hamming_distance::hamming_distance;
 pub use self::jaro_winkler_distance::jaro_winkler_distance;
 pub use self::knuth_morris_pratt::knuth_morris_pratt;
 pub use self::levenshtein_distance::levenshtein_distance;
+pub use self::lipogram::is_lipogram;
 pub use self::manacher::manacher;
 pub use self::palindrome::is_palindrome;
+pub use self::pangram::is_pangram;
+pub use self::pangram::PangramStatus;
 pub use self::rabin_karp::rabin_karp;
 pub use self::reverse::reverse;
 pub use self::run_length_encoding::{run_length_decoding, run_length_encoding};

src/string/pangram.rs

@@ -0,0 +1,104 @@
+use std::collections::HashSet;
+
+#[derive(PartialEq, Debug)]
+pub enum PangramStatus {
+    NotPangram,
+    Pangram,
+    PerfectPangram,
+}
+
+/// Function that checks if the slice is a pangram
+///
+/// ## Arguments
+///
+/// * `pangram_str` - the slice that will be checked if is a pangram
+///
+/// ## Examples
+///
+/// ```
+/// use the_algorithms_rust::string::is_pangram;
+/// use std::collections::HashSet;
+/// use the_algorithms_rust::string::PangramStatus;
+///
+/// assert_eq!(
+///    is_pangram("This is not a pangram"),
+///    PangramStatus::NotPangram
+/// );
+///
+/// assert_eq!(
+///    is_pangram("The quick brown fox jumps over the lazy dog"),
+///    PangramStatus::Pangram
+/// );
+///
+/// assert_eq!(
+///    is_pangram("Mr. Jock, TV quiz PhD, bags few lynx"),
+///    PangramStatus::PerfectPangram
+/// );
+/// ```
+pub fn is_pangram(pangram_str: &str) -> PangramStatus {
+    let alphabet: HashSet<char> = "abcdefghijklmnopqrstuvwxyz".chars().collect();
+
+    let letters_used: HashSet<char> = pangram_str
+        .to_lowercase()
+        .chars()
+        .filter(|c| c.is_ascii_alphabetic())
+        .collect();
+
+    if letters_used != alphabet {
+        return PangramStatus::NotPangram;
+    };
+
+    if pangram_str.chars().filter(|c| c.is_alphabetic()).count() == alphabet.len() {
+        PangramStatus::PerfectPangram
+    } else {
+        PangramStatus::Pangram
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_not_pangram() {
+        assert_eq!(
+            is_pangram("This is not a pangram"),
+            PangramStatus::NotPangram
+        );
+        assert_eq!(is_pangram("today is a good day"), PangramStatus::NotPangram);
+        assert_eq!(
+            is_pangram(
+                "this is almost a pangram but it does not have bcfghjkqwxy and the last letter"
+            ),
+            PangramStatus::NotPangram
+        );
+    }
+
+    #[test]
+    fn test_pangram() {
+        assert_eq!(
+            is_pangram("The quick brown fox jumps over the lazy dog"),
+            PangramStatus::Pangram
+        );
+        assert_eq!(
+            is_pangram("A mad boxer shot a quick, gloved jab to the jaw of his dizzy opponent"),
+            PangramStatus::Pangram
+        );
+        assert_eq!(
+            is_pangram("Amazingly few discotheques provide jukeboxes"),
+            PangramStatus::Pangram
+        );
+        assert_eq!(
+            is_pangram("How vexingly quick daft zebras jump"),
+            PangramStatus::Pangram
+        );
+    }
+
+    #[test]
+    fn test_perfect_pangram() {
+        assert_eq!(
+            is_pangram("Mr. Jock, TV quiz PhD, bags few lynx"),
+            PangramStatus::PerfectPangram
+        );
+    }
+}