format!() too slow

Author: rene-d

2016/day14/day14.rs

@@ -1,27 +1,25 @@
 //! [Day 14: One-Time Pad](https://adventofcode.com/2016/day/14)
 
 use rustc_hash::FxHashMap;
-// use std::time::Instant;
 
 /// Solve the day 14 puzzle.
 fn main() {
     let args = aoc::parse_args();
 
     let data = args.input.trim_ascii();
 
-    // let now = Instant::now();
-
-    println!("{}", solve(data, 0));
-    println!("{}", solve(data, 2016));
-
-    // let micros = now.elapsed().as_micros();
-    // println!("elapsed: {}.{:06} s", micros / 1_000_000, micros % 1_000_000);
+    println!("{}", solve(data.as_bytes(), 0));
+    println!("{}", solve(data.as_bytes(), 2016));
 }
 
+const HEX_DIGITS: [u8; 16] = [
+    b'0', b'1', b'2', b'3', b'4', b'5', b'6', b'7', b'8', b'9', b'a', b'b', b'c', b'd', b'e', b'f',
+];
+
 /// Triplet for a given index.
 #[derive(Debug, Clone, Copy)]
 struct TripletHash {
-    index: usize,        // index that produces hash with triplet
+    index: u32,          // index that produces hash with triplet
     triplet: u8,         // the first triplet of the hash
     quintuplet: [u8; 6], // six quintuplets max in 32 digits
 }
@@ -30,16 +28,47 @@ impl TripletHash {
     /// Find the next index that produces a hash that contains a triplet
     /// and search for eventual quintuplets. As quintuplets are also triplets,
     /// we cannot miss them.
-    fn next(index: usize, salt: &str, key_stretching: usize) -> Self {
+    fn next(index: u32, salt: &[u8], key_stretching: u32) -> Self {
         let mut index = index;
 
+        let salt_len = salt.len();
+        let mut hash = [0u8; 32];
+
+        hash[..salt_len].copy_from_slice(salt);
+
         loop {
-            let hash = format!("{salt}{index}");
-            let mut digest = md5::compute(hash);
+            // number of digits of index
+            let mut hash_len = salt_len;
+            let mut tmp_index = index;
+            loop {
+                hash_len += 1;
+                tmp_index /= 10;
+                if tmp_index == 0 {
+                    break;
+                }
+            }
+            // write digits of index in hash
+            let mut tmp_index = index;
+            let mut i = hash_len;
+            loop {
+                i -= 1;
+                hash[i] = (tmp_index % 10) as u8 + b'0';
+                tmp_index /= 10;
+                if tmp_index == 0 {
+                    break;
+                }
+            }
+
+            let mut digest = md5::compute(&hash[..hash_len]);
 
             // apply key stretching
             for _ in 0..key_stretching {
-                let hex = format!("{digest:x}");
+                let mut hex = [0u8; 32];
+                for (i, b) in digest.0.iter().enumerate() {
+                    hex[i * 2] = HEX_DIGITS[usize::from(b >> 4)];
+                    hex[i * 2 + 1] = HEX_DIGITS[usize::from(b & 0xf)];
+                }
+
                 digest = md5::compute(hex);
             }
 
@@ -96,7 +125,7 @@ impl TripletHash {
 }
 
 /// Find the 64th key with the given salt and key stretching.
-fn solve(salt: &str, key_stretching: usize) -> usize {
+fn solve(salt: &[u8], key_stretching: u32) -> u32 {
     let mut memoize = FxHashMap::default();
 
     let mut hasher = |index| {
@@ -142,7 +171,7 @@ fn solve(salt: &str, key_stretching: usize) -> usize {
 
 #[test]
 fn test_solve1() {
-    assert_eq!(solve("abc", 0), 22728);
+    assert_eq!(solve("abc".as_bytes(), 0), 22728);
 }
 
 #[test]