Commit

element_words_rs/src/lib.rs

@@ -0,0 +1,244 @@
+use itertools::Itertools;
+
+#[derive(PartialEq, Debug)]
+pub enum ElementSubstring {
+    Element(String),
+    NonElement(String),
+}
+
+fn elementsubstringvec_length(elword: &Vec<ElementSubstring>) -> usize {
+    let mut size = 0;
+    for substring in elword {
+        match substring {
+            ElementSubstring::Element(s) => {
+                for _char in s.chars() {
+                    size += 1;
+                }
+            }
+            ElementSubstring::NonElement(s) => {
+                for _char in s.chars() {
+                    size += 1;
+                }
+            }
+        }
+    }
+    size
+}
+
+const SINGLE_CHAR_ELEMENTS: &'static [&'static str] = &[
+    "B", "C", "F", "H", "I", "N", "O", "P", "K", "S", "W", "U", "V", "Y",
+];
+const DOUBLE_CHAR_ELEMENTS: &'static [&'static str] = &[
+    "Ac", "Al", "Am", "Sb", "Ar", "As", "At", "Ba", "Bk", "Be", "Bi", "Bh", "Br", "Cd", "Cs", "Ca",
+    "Cf", "Ce", "Cl", "Cr", "Co", "Cn", "Cu", "Cm", "Ds", "Db", "Dy", "Es", "Er", "Eu", "Fm", "Fl",
+    "Fr", "Gd", "Ga", "Ge", "Au", "Hf", "Hs", "He", "Ho", "In", "Ir", "Fe", "Kr", "La", "Lr", "Pb",
+    "Li", "Lv", "Lu", "Mg", "Mn", "Mt", "Md", "Hg", "Mo", "Mc", "Nd", "Ne", "Np", "Ni", "Nh", "Nb",
+    "No", "Og", "Os", "Pd", "Pt", "Pu", "Po", "Pr", "Pm", "Pa", "Ra", "Rn", "Re", "Rh", "Rg", "Rb",
+    "Ru", "Rf", "Sm", "Sc", "Sg", "Se", "Si", "Ag", "Na", "Sr", "Ta", "Tc", "Te", "Ts", "Tb", "Tl",
+    "Th", "Tm", "Sn", "Ti", "Xe", "Yb", "Zn", "Zr",
+];
+
+pub fn partial_elname(word: &str) -> Vec<ElementSubstring> {
+    let mut elword = vec![];
+    let word = word.to_lowercase();
+    let mut substring: String = String::new();
+    let mut skip_next_loop = false;
+    for (prev, next) in word.chars().tuple_windows() {
+        if skip_next_loop {
+            skip_next_loop = false;
+            continue;
+        }
+        let potential_el: String = prev.to_string().to_uppercase() + &next.to_string();
+        let mut found_match = false;
+        for element in DOUBLE_CHAR_ELEMENTS {
+            if element == &potential_el {
+                if substring.len() > 0 {
+                    elword.push(ElementSubstring::NonElement(substring.clone()));
+                    substring = String::new();
+                }
+                elword.push(ElementSubstring::Element(element.to_string()));
+                skip_next_loop = true;
+                found_match = true;
+                break;
+            }
+        }
+        if found_match {
+            continue;
+        }
+
+        for element in SINGLE_CHAR_ELEMENTS {
+            if element.to_lowercase().chars().next().unwrap() == prev {
+                if substring.len() > 0 {
+                    elword.push(ElementSubstring::NonElement(substring.clone()));
+                    substring = String::new();
+                }
+                elword.push(ElementSubstring::Element(element.to_string()));
+                found_match = true;
+                break;
+            }
+        }
+        if found_match {
+            continue;
+        }
+        substring.push(prev);
+    }
+    // This gets triggered when either:
+    //  - the last window is 2 valid Elements as in "CrISP", or
+    //  - the second to last window is a 2 letter Element (and would be skipped) as in "BaN"
+    if elementsubstringvec_length(&elword) <= word.chars().count() - 1 {
+        let last_char = word.chars().last().unwrap();
+        let mut found_match = false;
+        for element in SINGLE_CHAR_ELEMENTS {
+            if element.to_lowercase().chars().next().unwrap() == last_char {
+                if substring.len() > 0 {
+                    elword.push(ElementSubstring::NonElement(substring.clone()));
+                    substring = String::new();
+                }
+                elword.push(ElementSubstring::Element(element.to_string()));
+                found_match = true;
+                break;
+            }
+        }
+        if !found_match {
+            substring.push(last_char);
+        }
+    }
+    if substring.len() > 0 {
+        elword.push(ElementSubstring::NonElement(substring.clone()));
+    }
+    elword
+}
+
+pub fn complete_elname(word: &str) -> Option<Vec<String>> {
+    let mut elword: Vec<String> = vec![];
+    let word = word.to_lowercase();
+    // The thing feels a bit un-rust-y, but does seem to work!
+    let mut skip_next_loop = false;
+    for (prev, next) in word.chars().tuple_windows() {
+        if skip_next_loop {
+            skip_next_loop = false;
+            continue;
+        }
+
+        let potential_el: String = prev.to_string().to_uppercase() + &next.to_string();
+
+        let mut found_match = false;
+        // Can probably short circuit slightly here based on ASCII value or something (if in alphabetical order)
+        for element in DOUBLE_CHAR_ELEMENTS {
+            if element == &potential_el {
+                elword.push(element.to_string());
+                skip_next_loop = true;
+                found_match = true;
+                break;
+            }
+        }
+        if found_match {
+            continue;
+        }
+
+        for element in SINGLE_CHAR_ELEMENTS {
+            if element.to_lowercase().chars().next().unwrap() == prev {
+                elword.push(element.to_string());
+                found_match = true;
+                break;
+            }
+        }
+
+        if !found_match {
+            return None;
+        }
+    }
+
+    // This gets triggered when either:
+    //  - the last window is 2 valid Elements as in "CrISP", or
+    //  - the second to last window is a 2 letter Element (and would be skipped) as in "BaN"
+    let mut num_chars = 0;
+    for els in &elword {
+        num_chars += els.chars().count();
+    }
+    if num_chars == word.chars().count() - 1 {
+        let mut found_match = false;
+        let last_char = word.chars().last().unwrap();
+        for element in SINGLE_CHAR_ELEMENTS {
+            if element.to_lowercase().chars().nth(0).unwrap() == last_char {
+                elword.push(element.to_string());
+                found_match = true;
+                break;
+            }
+        }
+        if !found_match {
+            return None;
+        }
+    }
+
+    Some(elword)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_complete_elname() {
+        assert_eq!(complete_elname("a"), None);
+        assert_eq!(complete_elname("bar"), None);
+        assert_eq!(complete_elname("zee"), None);
+        assert_eq!(complete_elname("ge"), Some(vec!["Ge".to_string()]));
+        assert_eq!(
+            complete_elname("cras"),
+            Some(vec!["Cr".to_string(), "As".to_string()])
+        );
+        assert_eq!(
+            complete_elname("ban"),
+            Some(vec!["Ba".to_string(), "N".to_string()])
+        );
+        assert_eq!(complete_elname("arthur"), None);
+        assert_eq!(
+            complete_elname("crisp"),
+            Some(vec![
+                "Cr".to_string(),
+                "I".to_string(),
+                "S".to_string(),
+                "P".to_string()
+            ])
+        );
+        assert_eq!(complete_elname("accepting"), None);
+    }
+
+    #[test]
+    fn test_partial_elname() {
+        type ES = ElementSubstring;
+        assert_eq!(partial_elname("a"), vec![ES::NonElement("a".to_string())]);
+        assert_eq!(
+            partial_elname("bar"),
+            vec![
+                ES::Element("Ba".to_string()),
+                ES::NonElement("r".to_string())
+            ]
+        );
+        assert_eq!(
+            partial_elname("zee"),
+            vec![ES::NonElement("zee".to_string())]
+        );
+        assert_eq!(partial_elname("ge"), vec![ES::Element("Ge".to_string())]);
+        assert_eq!(
+            partial_elname("crisp"),
+            vec![
+                ES::Element("Cr".to_string()),
+                ES::Element("I".to_string()),
+                ES::Element("S".to_string()),
+                ES::Element("P".to_string())
+            ]
+        );
+        assert_eq!(
+            partial_elname("accepting"),
+            vec![
+                ES::Element("Ac".to_string()),
+                ES::Element("Ce".to_string()),
+                ES::Element("Pt".to_string()),
+                ES::Element("In".to_string()),
+                ES::NonElement("g".to_string())
+            ]
+        );
+    }
+}

element_words_rs/src/main.rs

@@ -0,0 +1,17 @@
+use elname::{complete_elname, partial_elname};
+use std::fs::read_to_string;
+
+pub fn main() {
+    // Presume running in the elname_rs folder
+    for line in read_to_string("../wordlist.10000").unwrap().lines() {
+        let tmp_elname = complete_elname(line);
+        if let Some(el) = tmp_elname {
+            //println!("{} -> {:?}", line, el);
+        }
+    }
+    for line in read_to_string("../wordlist.10000").unwrap().lines() {
+        let tmp_elname = partial_elname(line);
+        println!("{} -> {:?}", line, tmp_elname);
+    }
+    
+}