reuse same vector: ~2sec now

src/levenshtein_distance.rs

@@ -1,38 +1,49 @@
-pub fn levenshtein_distance(source: &str, target: &str) -> usize {
-    if source.is_empty() {
-        return target.len();
-    }
+pub struct LevenshteinDistanceCalc {
+    cache: Vec<usize>,
+}
 
-    if target.is_empty() {
-        return source.len();
+impl LevenshteinDistanceCalc {
+    pub fn new() -> Self {
+        Self { cache: Vec::new() }
     }
 
-    let target_len = target.len();
-    let mut cache: Vec<usize> = (0..=target_len).collect();
+    pub fn calc(&mut self, source: &str, target: &str) -> usize {
+        if source.is_empty() {
+            return target.len();
+        }
+
+        if target.is_empty() {
+            return source.len();
+        }
 
-    for (i, source_char) in source.chars().enumerate() {
-        let mut next_dist = i + 1;
+        let target_len = target.len();
 
-        for (j, target_char) in target.chars().enumerate() {
-            let current_dist = next_dist;
+        self.cache = (0..=target_len).collect();
 
-            let mut dist_if_substitute = cache[j];
-            if source_char != target_char {
-                dist_if_substitute += 1;
-            }
+        for (i, source_char) in source.chars().enumerate() {
+            let mut next_dist = i + 1;
 
-            let dist_if_insert = current_dist + 1;
-            let dist_if_delete = cache[j + 1] + 1;
+            for (j, target_char) in target.chars().enumerate() {
+                let current_dist = next_dist;
 
-            next_dist = min(dist_if_delete, min(dist_if_insert, dist_if_substitute));
+                let mut dist_if_substitute = self.cache[j];
+                if source_char != target_char {
+                    dist_if_substitute += 1;
+                }
 
-            cache[j] = current_dist;
+                let dist_if_insert = current_dist + 1;
+                let dist_if_delete = self.cache[j + 1] + 1;
+
+                next_dist = min(dist_if_delete, min(dist_if_insert, dist_if_substitute));
+
+                self.cache[j] = current_dist;
+            }
+
+            self.cache[target_len] = next_dist;
         }
 
-        cache[target_len] = next_dist;
+        self.cache[target_len]
     }
-
-    cache[target_len]
 }
 
 fn min(a: usize, b: usize) -> usize {

src/main.rs

@@ -1,25 +1,23 @@
-mod levenshtein_distance;
+use crate::levenshtein_distance::LevenshteinDistanceCalc;
 
-use levenshtein_distance::levenshtein_distance;
+mod levenshtein_distance;
 
 fn main() {
     let lines: Vec<&str> = include_str!("../sample.txt").split('\n').collect();
 
-    let benchmark = || {
+    let mut leven_dist_calc = LevenshteinDistanceCalc::new();
+
+    use std::time::Instant;
+    let now = Instant::now();
+
+    {
         for _ in 0..10000 {
             let mut last_value = "";
             for line in &lines {
-                levenshtein_distance(last_value, line);
+                leven_dist_calc.calc(last_value, line);
                 last_value = line;
             }
         }
-    };
-
-    use std::time::Instant;
-    let now = Instant::now();
-
-    {
-        benchmark();
     }
 
     let elapsed = now.elapsed();
@@ -28,7 +26,7 @@ fn main() {
 
     // check
     let answers: Vec<String> = (0..lines.len() - 1)
-        .map(|i| levenshtein_distance(lines[i], lines[i + 1]))
+        .map(|i| leven_dist_calc.calc(lines[i], lines[i + 1]))
         .map(|dist| dist.to_string())
         .collect();
     eprintln!("{}", answers.join(","));