June 2018 Update

Task/Levenshtein-distance/Aime/levenshtein-distance.aime

@@ -1,46 +1,38 @@
 integer
-dist(text s, integer i, integer ls, text t, integer j, integer lt, list d)
+dist(data s, integer i, data t, integer j, list d)
 {
     integer x;
 
-    x = d[i * (lt + 1) + j];
+    x = d[i * (~t + 1) + j];
     if (x == -1) {
-        if (i == ls) {
-            x = lt - j;
-        } elif (j == lt) {
-            x = ls - i;
+        if (i == ~s) {
+            x = ~t - j;
+        } elif (j == ~t) {
+            x = ~s - i;
         } elif (s[i] == t[j]) {
-            x = dist(s, i + 1, ls, t, j + 1, lt, d);
+            x = dist(s, i + 1, t, j + 1, d);
         } else {
-            x = dist(s, i + 1, ls, t, j + 1, lt, d);
-            x = min(x, dist(s, i, ls, t, j + 1, lt, d));
-            x = min(x, dist(s, i + 1, ls, t, j, lt, d));
+            x = dist(s, i + 1, t, j + 1, d);
+            x = min(x, dist(s, i, t, j + 1, d));
+            x = min(x, dist(s, i + 1, t, j, d));
 
             x += 1;
         }
 
-        d[i * (lt + 1) + j] = x;
+        d[i * (~t + 1) + j] = x;
     }
 
-    return x;
+    x;
 }
 
 integer
-levenshtein(text s, text t)
+levenshtein(data s, data t)
 {
-    integer i, ls, lt;
     list d;
 
-    ls = length(s);
-    lt = length(t);
+    d.pn_integer(0, (~s + 1) * (~t + 1), -1);
 
-    i = (ls + 1) * (lt + 1);
-    while (i) {
-        lb_p_integer(d, -1);
-        i -= 1;
-    }
-
-    return dist(s, 0, ls, t, 0, lt, d);
+    dist(s, 0, t, 0, d);
 }
 
 integer

Task/Levenshtein-distance/Factor/levenshtein-distance.factor

@@ -0,0 +1,2 @@
+USING: lcs prettyprint ;
+"kitten" "sitting" levenshtein .

Task/Levenshtein-distance/Julia/levenshtein-distance-1.julia

@@ -0,0 +1,16 @@
+function levendist(s::AbstractString, t::AbstractString)
+    ls, lt = length(s), length(t)
+    ls == 0 && return lt
+    lt == 0 && return ls
+
+    s₁, t₁ = s[2:end], t[2:end]
+    ld₁ = levendist(s₁, t₁)
+    if s[1] == t[1]
+        return ld₁
+    else
+        return 1 + min(ld₁, levendist(s, t₁), levendist(s₁, t))
+    end
+end
+
+@show levendist("kitten", "sitting") # 3
+@show levendist("rosettacode", "raisethysword") # 8

Task/Levenshtein-distance/Julia/levenshtein-distance-2.julia

@@ -0,0 +1,21 @@
+function levendist1(s::AbstractString, t::AbstractString)
+    ls, lt = length(s), length(t)
+    if ls > lt
+        s, t = t, s
+        ls, lt = lt, ls
+    end
+    dist = collect(0:ls)
+    for (ind2, chr2) in enumerate(t)
+        newdist = Vector{Int}(ls+1)
+        newdist[1] = ind2
+        for (ind1, chr1) in enumerate(s)
+            if chr1 == chr2
+                newdist[ind1+1] = dist[ind1]
+            else
+                newdist[ind1+1] = 1 + min(dist[ind1], dist[ind1+1], newdist[end])
+            end
+        end
+        dist = newdist
+    end
+    return dist[end]
+end

Task/Levenshtein-distance/Julia/levenshtein-distance-3.julia

@@ -0,0 +1,13 @@
+using BenchmarkTools
+println("\n# levendist(kitten, sitting)")
+s, t = "kitten", "sitting"
+println(" - Recursive:")
+@btime levendist(s, t)
+println(" - Iterative:")
+@btime levendist1(s, t)
+println("\n# levendist(rosettacode, raisethysword)")
+s, t = "rosettacode", "raisethysword"
+println(" - Recursive:")
+@btime levendist(s, t)
+println(" - Iterative:")
+@btime levendist1(s, t)

Task/Levenshtein-distance/Julia/levenshtein-distance.julia

@@ -1,20 +0,0 @@
-function leven(s, t)
-
-    length(s) == 0 && return length(t);
-    length(t) == 0 && return length(s);
-
-    s1 = s[2:end];
-    t1 = t[2:end];
-
-    return (s[1] == t[1]
-        ? leven(s1, t1)
-        : 1 + min(
-                leven(s1, t1),
-                leven(s,  t1),
-                leven(s1,  t)
-              )
-    );
-end
-
-println(leven("kitten", "sitting"));                # => 3
-println(leven("rosettacode","raisethysword"));      # => 8

Task/Levenshtein-distance/Kotlin/levenshtein-distance-2.kotlin

@@ -0,0 +1,19 @@
+fun levenshtein(s: String, t: String,
+                charScore : (Char, Char) -> Int = { c1, c2 -> if (c1 == c2) 0 else 1}) : Int {
+
+    // Special cases
+    if (s == t)  return 0
+    if (s == "") return t.length
+    if (t == "") return s.length
+
+    val initialRow : List<Int> = (0 until t.length + 1).map { it }.toList()
+    return (0 until s.length).fold(initialRow, { previous, u ->
+        (0 until t.length).fold( mutableListOf(u+1), {
+            row, v -> row.add(listOf(row.last() + 1,
+                    previous[v+1] + 1,
+                    previous[v] + charScore(s[u],t[v])).min()!!)
+            row
+        })
+    }).last()
+
+}

Task/Levenshtein-distance/Ring/levenshtein-distance.ring

@@ -0,0 +1,42 @@
+# Project : Levenshtein distance
+# Date    : 2017/12/15
+# Author : Gal Zsolt (~ CalmoSoft ~)
+# Email   : <calmosoft@gmail.com>
+
+load "stdlib.ring"
+see "" + "distance(kitten, sitting) = " + levenshteindistance("kitten", "sitting") + nl
+see "" + "distance(saturday, sunday) = " + levenshteindistance("saturday", "sunday") + nl
+see "" + "distance(rosettacode, raisethysword) = " + levenshteindistance("rosettacode", "raisethysword") + nl
+
+func levenshteindistance(s1, s2)
+        n = len(s1)
+        m = len(s2)
+        if n = 0
+            levenshteindistance = m
+            return
+        ok
+        if m = 0
+            levenshteindistance = n
+            return
+        ok
+        d = newlist(n, m)
+        for i = 1 to n
+             d[i][1] = i
+        next i
+        for i = 1 to m
+             d[1][i] = i
+        next
+        for i = 2 to n
+             si = substr(s1, i, 1)
+             for j = 2 to m
+                  tj = substr(s2, j, 1)
+                  if si = tj
+                     cost = 0
+                  else
+                     cost = 1
+                  ok
+                  d[i][ j] = min((d[i - 1][ j]), min((d[i][j - 1] + 1), (d[i - 1][j - 1] + cost)))
+             next
+        next
+        levenshteindistance = d[n][m]
+        return levenshteindistance

Task/Levenshtein-distance/Rust/levenshtein-distance.rust

@@ -3,6 +3,7 @@ fn main() {
     println!("{}", levenshtein_distance("saturday", "sunday"));
     println!("{}", levenshtein_distance("rosettacode", "raisethysword"));
 }
+
 fn levenshtein_distance(word1: &str, word2: &str) -> usize {
     let w1 = word1.chars().collect::<Vec<_>>();
     let w2 = word2.chars().collect::<Vec<_>>();