Rearrange some stuff

src/main.rs

@@ -10,7 +10,7 @@ type Achar = i8;  // ASCII char
 
 const WORD_LENGTH: usize = 5;
 const WORD_LENGTH_P: usize = 5;  // Padded for SIMD shenanigans
-const GUESS_DEPTH: usize = 2;
+const GUESS_DEPTH: usize = 5;
 const A: Achar = 'A' as Achar;
 const Z: Achar = 'Z' as Achar;
 
@@ -29,6 +29,20 @@ struct Word {
 
 type WordCache = HashMap<Charmask, Vec<Word>>;
 
+
+fn char2bit(c: Achar) -> Charmask {
+    debug_assert!((A..=Z).contains(&c));
+    1 << (c - A)
+}
+
+fn cm2char(cm: Charmask, offset: i8) -> Achar {
+    (((31 - cm.lzcnt() as i8) + A + offset) as u8) as Achar
+}
+
+fn letters2str(letters: [Achar; WORD_LENGTH]) -> String {
+    letters.iter().map(|x| (*x as u8) as char).collect()
+}
+
 fn str2word(s: &str) -> Word {
     let mut word = Word::default();
     let mut iter = s.chars();
@@ -42,26 +56,6 @@ fn str2word(s: &str) -> Word {
     word
 }
 
-fn load_dictionary(filename: &str) -> Vec<Word> {
-    println!("Loading dictionary at {}", filename);
-    let rawfile = fs::read_to_string(filename).unwrap();
-    let rawwords = rawfile.split('\n');
-    let mut words = Vec::new();
-    let re = Regex::new(&format!("{}{}{}", r"^[A-Za-z]{", WORD_LENGTH, r"}$")).unwrap();
-    for line in rawwords {
-        if re.is_match(line) {
-            words.push(line.to_uppercase());
-        }
-    }
-    words.sort();
-    words.dedup();
-    words.iter().map(|w| str2word(w)).collect()
-}
-
-fn letters2str(letters: [Achar; WORD_LENGTH]) -> String {
-    letters.iter().map(|x| (*x as u8) as char).collect()
-}
-
 /* fn inc_char(c: char) -> char {
     (c as u8 + 1) as char
 } */
@@ -86,14 +80,20 @@ fn letters2str(letters: [Achar; WORD_LENGTH]) -> String {
     s
 } */
 
-
+fn load_dictionary(filename: &str) -> Vec<Word> {
-fn char2bit(c: Achar) -> Charmask {
+    println!("Loading dictionary at {}", filename);
-    debug_assert!((A..=Z).contains(&c));
+    let rawfile = fs::read_to_string(filename).unwrap();
-    1 << (c - A)
+    let rawwords = rawfile.split('\n');
+    let mut words = Vec::new();
+    let re = Regex::new(&format!("{}{}{}", r"^[A-Za-z]{", WORD_LENGTH, r"}$")).unwrap();
+    for line in rawwords {
+        if re.is_match(line) {
+            words.push(line.to_uppercase());
         }
-
+    }
-fn cm2char(cm: Charmask, offset: i8) -> Achar {
+    words.sort();
-    (((31 - cm.lzcnt() as i8) + A + offset) as u8) as Achar
+    words.dedup();
+    words.iter().map(|w| str2word(w)).collect()
 }
 
 fn _generate_wordcache_nested(cache: &mut WordCache, subcache: &[Word], key: Charmask, depth: u8) {
@@ -168,6 +168,11 @@ fn find_worstcase(word_ids: [usize; GUESS_DEPTH], wordcache: &WordCache) -> (Str
     (output, worst)
 }
 
+fn find_word_id_from_str(s: &str, words: &Vec<Word>) -> usize {
+    let w = str2word(s);
+    words.iter().position(|x| x.letters==w.letters).unwrap()
+}
+
 fn main() {
     fs::write("test.txt", ["test1", "test2", "test3"].join("\n")).expect("Failed to write output");
     let words = load_dictionary("words");
@@ -179,12 +184,26 @@ fn main() {
     //println!("{:?}", sr);
     
     //(0..=5).flat_map(|i| (i..=5).map(move |j| (i,j))).map(|(i,j)| print!("{},{}\t", i, j));
-    let mut results: Vec<(String, usize)> =
+    
-       (0..totalwords).into_par_iter().flat_map_iter(|i| (i..totalwords).map(move |j| (i,j)))
+    // Depth-2 full
-       .map(|(i, j)| find_worstcase([i, j], &wordcache)).collect();
+    // let mut results: Vec<(String, usize)> =
+    //    (0..totalwords).into_par_iter().flat_map_iter(|i| (i..totalwords).map(move |j| (i,j)))
+    //    .map(|(i, j)| find_worstcase([i, j], &wordcache)).collect();
+    
+    // Depth-1 full
     // let mut results: Vec<(String, usize)> =
     //    (0..totalwords).into_par_iter()
     //    .map(|i| find_worstcase([i], &wordcache)).collect();
+
+    // Depth-3 (word1,word2,?)
+    let i1 = find_word_id_from_str("CARET", &wordcache[&0]);
+    let i2 = find_word_id_from_str("SOLID", &wordcache[&0]);
+    let i3 = find_word_id_from_str("NYMPH", &wordcache[&0]);
+    let i4 = find_word_id_from_str("FIFTH", &wordcache[&0]);
+    let mut results: Vec<(String, usize)> =
+       (0..totalwords).into_par_iter()
+       .map(|i| find_worstcase([i1, i2, i3, i4, i], &wordcache)).collect();
+    
     results.sort_by_key(|r| r.1);
     let results_strs: Vec<String> = results.iter().map(|r| r.0.clone()).collect();
     fs::write("results.txt", results_strs.join("\n")).expect("Failed to write output");