|
|
| Line 1: |
Line 1: |
| {{merge to|Edit distance|discuss=Talk:Edit distance#Proposed merge with Levenshtein distance|date=January 2014}}
| | Your Tribe is the quite a number of strong of all will probably have the planet (virtual) at your toes, as well as the all that with solely a brief on-line video training that may direct the customer step by step when it comes to how to get our cheat code for Fight of Tribes.<br><br>Go online for help. Virtually every game has its own legion of devoted devotees, lots of which waste countless hours crafting wide-range maps and guides. Additionally there are newsgroups where you are speak one on an with other players. Benefit from this goldmine and it is possible to eventually get past that level you have been attached on forever.<br><br>Okazaki, japan tartan draws creativity through your country's [http://www.Dailymail.co.uk/home/search.html?sel=site&searchPhrase=curiosity curiosity] about cherry blossom and carries pink, white, green additionally brown lightly colours. clash of clans cheats. Features is called Sakura, china for cherry blossom.<br><br>If you are searching to a particular game to buy but want to positively purchase it at that best price possible, utilize the "shopping" tab there on many search sites. This will feasible you to immediately find the prices of the game at all each major retailers online. You can also have ratings for the dealership in question, helping that you determine who you want to buy the game with.<br><br>Waiting for game of a person's season editions of real titles. These usually come out per several weeks or higher after your current initial headline, but feature a lot of all down-loadable and extra content which was released with regard to steps once the headline. These video titles supply a lot more bang for your current buck.<br><br>This kind of information, we're accessible to alpha dog [http://www.ehow.com/search.html?s=substituting+worth substituting worth]. When you loved this post and you want to receive details relating to clash of clans cheat ([http://prometeu.net prometeu.net]) assure visit our website. Application Clash of Clans Cheats' data, let's say towards archetype you appetite 1hr (3, 600 seconds) in order to bulk 20 gems, and additionally 1 day (90, 4000 seconds) to help size 260 gems. May appropriately stipulate a battle for this kind including band segment.<br><br>On the grounds that your village grows, own to explore uncharted territories for Gold and Exposed wood which are the 2 key resources you may want to expect to require when start of the game ( addititionally there is almost certainly Stone resource, that your entire family discover later inside our game ). Through your exploration, you in many cases can expect to stumble after many islands whereby that villages happen to become held captive under BlackGuard slavery and you benefit from free Gold sources if they are unoccupied. |
| {{merge from|Damerau–Levenshtein distance|discuss=Talk:Levenshtein distance#Proposed merge with Damerau–Levenshtein distance|date=November 2013}}
| |
| {{refimprove|date=February 2010}}
| |
| | |
| In [[information theory]] and [[computer science]], the '''Levenshtein distance''' is a [[string metric]] for measuring the difference between two sequences. Informally, the Levenshtein distance between two words is the minimum number of single-character edits (i.e. insertions, deletions or substitutions) required to change one word into the other. The phrase '''[[edit distance]]''' is often used to refer specifically to Levenshtein distance. It is named after [[Vladimir Levenshtein]], who considered this distance in 1965.<ref>{{cite journal |author=В.И. Левенштейн |title=Двоичные коды с исправлением выпадений, вставок и замещений символов |language=Russian |trans_title=Binary codes capable of correcting deletions, insertions, and reversals |journal=Доклады Академий Наук СCCP |volume=163 |issue=4 |pages=845–8 |year=1965}} Appeared in English as: {{cite journal |author=Levenshtein VI |title=Binary codes capable of correcting deletions, insertions, and reversals |journal=Soviet Physics Doklady |volume=10 |pages=707–10 |year=1966 |url=http://www.scribd.com/doc/18654513/levenshtein?secret_password=1aycnw239qw4jqjtsm34#full}}</ref> It is closely related to [[Sequence_alignment#Pairwise_alignment|pairwise string alignments]].
| |
| | |
| == Definition ==
| |
| Mathematically, the Levenshtein distance between two strings <math>a, b</math> is given by <math>\operatorname{lev}_{a,b}(|a|,|b|)</math> where
| |
| | |
| :<math>\qquad\operatorname{lev}_{a,b}(i,j) = \begin{cases}
| |
| \max(i,j) & \text{ if} \min(i,j)=0, \\
| |
| \min \begin{cases}
| |
| \operatorname{lev}_{a,b}(i-1,j) + 1 \\
| |
| \operatorname{lev}_{a,b}(i,j-1) + 1 \\
| |
| \operatorname{lev}_{a,b}(i-1,j-1) + 1_{(a_i \neq b_j)}
| |
| \end{cases} & \text{ otherwise.}
| |
| \end{cases}</math>
| |
| where <math>1_{(a_i \neq b_j)}</math> is the indicator function equal to 0 when <math>a_i = b_j</math> and 1 otherwise.
| |
| | |
| Note that the first element in the minimum corresponds to deletion (from <math>a</math> to <math>b</math>), the second to insertion and the third to match or mismatch, depending on whether the respective symbols are the same.
| |
| | |
| === Example ===
| |
| For example, the Levenshtein distance between "kitten" and "sitting" is 3, since the following three edits change one into the other, and there is no way to do it with fewer than three edits:
| |
| | |
| # '''k'''itten → '''s'''itten (substitution of "s" for "k")
| |
| # sitt'''e'''n → sitt'''i'''n (substitution of "i" for "e")
| |
| # sittin → sittin'''g''' (insertion of "g" at the end).
| |
| | |
| ===Upper and lower bounds===
| |
| The Levenshtein distance has several simple upper and lower bounds. These include:
| |
| * It is always at least the difference of the sizes of the two strings.
| |
| * It is at most the length of the longer string.
| |
| * It is zero if and only if the strings are equal.
| |
| * If the strings are the same size, the [[Hamming distance]] is an upper bound on the Levenshtein distance.
| |
| * The Levenshtein distance between two strings is no greater than the sum of their Levenshtein distances from a third string ([[triangle inequality]]).
| |
| | |
| ==Applications==
| |
| In [[approximate string matching]], the objective is to find matches for short strings in many longer texts, in situations where a small number of differences is to be expected. The short strings could come from a dictionary, for instance. Here, one of the strings is typically short, while the other is arbitrarily long. This has a wide range of applications, for instance, [[spell checker]]s, correction systems for [[optical character recognition]], and software to assist natural language translation based on [[translation memory]].
| |
| | |
| The Levenshtein distance can also be computed between two longer strings, but the cost to compute it, which is roughly proportional to the product of the two string lengths, makes this impractical. Thus, when used to aid in [[fuzzy string searching]] in applications such as [[record linkage]], the compared strings are usually short to help improve speed of comparisons.
| |
| | |
| ==Relationship with other edit distance metrics==
| |
| There are other popular measures of [[edit distance]], which are calculated using a different set of allowable edit operations. For instance,
| |
| * the [[Damerau–Levenshtein distance]] allows insertion, deletion, substitution, and the [[Transposition (mathematics)|transposition]] of two adjacent characters;
| |
| * the [[longest common subsequence problem|longest common subsequence]] metric allows only insertion and deletion, not substitution;
| |
| * the [[Hamming distance]] allows only substitution, hence, it only applies to strings of the same length.
| |
| | |
| [[Edit distance]] is usually defined as a parameterizable metric calculated with a specific set of allowed edit operations, and each operation is assigned a cost (possibly infinite). This is further generalized by DNA [[sequence alignment]] algorithms such as the [[Smith–Waterman algorithm]], which make an operation's cost depend on where it is applied.
| |
| | |
| ==Computing Levenshtein distance==
| |
| | |
| ===Recursive===
| |
| A straightforward recursive implementation <code>LevenshteinDistance</code> function takes two strings, ''s'' and ''t'', and returns the Levenshtein distance between them:
| |
| | |
| <!--
| |
| Please do not add an additional implementation in your language of choice.
| |
| Many of those have been added to and deleted from this article in the past.
| |
| See the talk page archive for relevant discussion
| |
| -->
| |
| <!-- This routine would be clearer if len_s and len_t were args. -->
| |
| <source lang="C">
| |
| // len_s and len_t are the number of characters in string s and t respectively | |
| int LevenshteinDistance(string s, int len_s, string t, int len_t)
| |
| {
| |
| /* base case: empty strings */
| |
| if (len_s == 0) return len_t;
| |
| if (len_t == 0) return len_s;
| |
| | |
| /* test if last characters of the strings match */
| |
| if (s[len_s-1] == t[len_t-1]) cost = 0;
| |
| else cost = 1;
| |
| | |
| /* return minimum of delete char from s, delete char from t, and delete char from both */
| |
| return minimum(LevenshteinDistance(s, len_s - 1, t, len_t ) + 1,
| |
| LevenshteinDistance(s, len_s , t, len_t - 1) + 1,
| |
| LevenshteinDistance(s, len_s - 1, t, len_t - 1) + cost);
| |
| }
| |
| </source>
| |
| | |
| Unfortunately, the straightforward recursive implementation is very inefficient because it recomputes the Levenshtein distance of the same substrings many times.<!-- should describe the horrible recursion --> A better method would never repeat the same distance calculation.
| |
| For example, the Levenshtein distance of all possible prefixes might be stored in an array <code>d[][]</code> where <code>d[i][j]</code> is the distance between the first <code>i</code> characters of string <code>s</code> and the first <code>j</code> characters of string <code>t</code>. The table is easy to construct one row at a time starting with row 0. When the entire table has been built, the desired distance is <code>d[len_s][len_t]</code>. While this technique is significantly faster, it will consume <code>len_s * len_t</code> more memory than the straightforward recursive implementation.
| |
| | |
| ===Iterative with full matrix===
| |
| ::<small>Note: This section uses 1-based strings instead of 0-based strings</small>
| |
| Computing the Levenshtein distance is based on the observation that if we reserve a [[Matrix (mathematics)|matrix]] to hold the Levenshtein distances between all [[prefix (computer science)|prefix]]es of the first string and all prefixes of the second, then we can compute the values in the matrix in a [[dynamic programming]] fashion, and thus find the distance between the two full strings as the last value computed.
| |
| | |
| This algorithm, an example of bottom-up [[dynamic programming]], is discussed, with variants, in the 1974 article ''The [[String-to-string correction problem]]'' by Robert A. Wagner and Michael J. Fischer.<ref>{{citation |first=Robert A. |last=Wagner |first2=Michael J. |last2=Fischer |author2-link=Michael J. Fischer |title=The String-to-String Correction Problem |journal=Journal of the ACM |volume=21 |issue=1 |year=1974 |pages=168–173 |doi= 10.1145/321796.321811}}</ref>
| |
| | |
| A straightforward implementation, as [[pseudocode]] for a function ''LevenshteinDistance'' that takes two strings, ''s'' of length ''m'', and ''t'' of length ''n'', and returns the Levenshtein distance between them:
| |
| | |
| <!--
| |
| Please do not add an additional implementation in your language of choice.
| |
| Many of those have been added to and deleted from this article in the past.
| |
| See the talk page archive for relevant discussion
| |
| -->
| |
| <!-- choose random language for highlights -->
| |
| <source lang="C">
| |
| int LevenshteinDistance(char s[1..m], char t[1..n])
| |
| {
| |
| // for all i and j, d[i,j] will hold the Levenshtein distance between
| |
| // the first i characters of s and the first j characters of t;
| |
| // note that d has (m+1)*(n+1) values
| |
| declare int d[0..m, 0..n]
| |
|
| |
| clear all elements in d // set each element to zero
| |
|
| |
| // source prefixes can be transformed into empty string by
| |
| // dropping all characters
| |
| for i from 1 to m
| |
| {
| |
| d[i, 0] := i
| |
| }
| |
|
| |
| // target prefixes can be reached from empty source prefix
| |
| // by inserting every characters
| |
| for j from 1 to n
| |
| {
| |
| d[0, j] := j
| |
| }
| |
|
| |
| for j from 1 to n
| |
| {
| |
| for i from 1 to m
| |
| {
| |
| if s[i] = t[j] then
| |
| d[i, j] := d[i-1, j-1] // no operation required
| |
| else
| |
| d[i, j] := minimum
| |
| (
| |
| d[i-1, j] + 1, // a deletion
| |
| d[i, j-1] + 1, // an insertion
| |
| d[i-1, j-1] + 1 // a substitution
| |
| )
| |
| }
| |
| }
| |
|
| |
| return d[m, n]
| |
| }
| |
| </source>
| |
| | |
| Note that this implementation does not fit the [[#Definition|definition]] precisely: it always prefers matches, even if insertions or deletions provided a better score. This is equivalent; it can be shown that for every optimal alignment (which induces the Levenshtein distance) there is another optimal alignment that prefers matches in the sense of this implementation.<ref>[http://cs.stackexchange.com/a/2997 Micro-optimisation for edit distance computation: is it valid?]</ref>
| |
| | |
| Two examples of the resulting matrix (hovering over a number reveals the operation performed to get that number):
| |
| <center> | |
| {|
| |
| |
| |
| {|class="wikitable"
| |
| |-
| |
| |
| |
| |
| |
| !k
| |
| !i
| |
| !t
| |
| !t
| |
| !e
| |
| !n
| |
| |-
| |
| | ||0 ||1 ||2 ||3 ||4 ||5 ||6
| |
| |-
| |
| !s
| |
| |1 ||{{H:title|substitution of 'k' for 's'|1}} ||2 ||3 ||4 ||5 ||6
| |
| |-
| |
| !i
| |
| |2 ||2 ||{{H:title|'i' equals 'i'|1}} ||2 ||3 ||4 ||5
| |
| |-
| |
| !t
| |
| |3 ||3 ||2 ||{{H:title|'t' equals 't'|1}} ||2 ||3 ||4
| |
| |-
| |
| !t
| |
| |4 ||4 ||3 ||2 ||{{H:title|'t' equals 't'|1}} ||2 ||3
| |
| |-
| |
| !i
| |
| |5 ||5 ||4 ||3 ||2 ||{{H:title|substitution of 'e' for 'i'|2}} ||3
| |
| |-
| |
| !n
| |
| |6 ||6 ||5 ||4 ||3 ||3 ||{{H:title|'n' equals 'n'|2}}
| |
| |-
| |
| !g
| |
| |7 ||7 ||6 ||5 ||4 ||4 ||{{H:title|insert 'g'|3}}
| |
| |}
| |
| |
| |
| {|class="wikitable"
| |
| |
| |
| |
| |
| !S
| |
| !a
| |
| !t
| |
| !u
| |
| !r
| |
| !d
| |
| !a
| |
| !y
| |
| |-
| |
| |
| |
| |0 ||1 ||2 ||3 ||4 ||5 ||6 ||7 ||8
| |
| |-
| |
| !S
| |
| |1 ||{{H:title|'S' equals 'S'|0}} ||{{H:title|delete 'a'|1}} ||{{H:title|delete 't'|2}} ||3 ||4 ||5 ||6 ||7
| |
| |-
| |
| !u
| |
| |2 ||1 ||1 ||2 ||{{H:title|'u' equals 'u'|2}} ||3 ||4 ||5 ||6
| |
| |-
| |
| !n
| |
| |3 ||2 ||2 ||2 ||3 ||{{H:title|substitution of 'r' for 'n'|3}} ||4 ||5 ||6
| |
| |-
| |
| !d
| |
| |4 ||3 ||3 ||3 ||3 ||4 ||{{H:title|'d' equals 'd'|3}} ||4 ||5
| |
| |-
| |
| !a
| |
| |5 ||4 ||3 ||4 ||4 ||4 ||4 ||{{H:title|'a' equals 'a'|3}} ||4
| |
| |-
| |
| !y
| |
| |6 ||5 ||4 ||4 ||5 ||5 ||5 ||4 ||{{H:title|'y' equals 'y'|3}}
| |
| |}
| |
| |}
| |
| </center>
| |
| | |
| The [[invariant (mathematics)|invariant]] maintained throughout the algorithm is that we can transform the initial segment <code>s[1..i]</code> into <code>t[1..j]</code> using a minimum of <code>d[i,j]</code> operations. At the end, the bottom-right element of the array contains the answer.
| |
| | |
| ====Proof of correctness====
| |
| As mentioned earlier, the [[invariant (mathematics)|invariant]] is that we can transform the initial segment <code>s[1..i]</code> into <code>t[1..j]</code> using a minimum of <code>d[i,j]</code> operations. This invariant holds since:
| |
| * It is initially true on row and column 0 because <code>s[1..i]</code> can be transformed into the empty string <code>t[1..0]</code> by simply dropping all <code>i</code> characters. Similarly, we can transform <code>s[1..0]</code> to <code>t[1..j]</code> by simply adding all <code>j</code> characters.
| |
| * If <code>s[i] = t[j]</code>, and we can transform <code>s[1..i-1]</code> to <code>t[1..j-1]</code> in <code>k</code> operations, then we can do the same to <code>s[1..i]</code> and just leave the last character alone, giving <code>k</code> operations.
| |
| * Otherwise, the distance is the minimum of the three possible ways to do the transformation:
| |
| ** If we can transform <code>s[1..i]</code> to <code>t[1..j-1]</code> in <code>k</code> operations, then we can simply add <code>t[j]</code> afterwards to get <code>t[1..j]</code> in <code>k+1</code> operations (insertion).
| |
| ** If we can transform <code>s[1..i-1]</code> to <code>t[1..j]</code> in <code>k</code> operations, then we can remove <code>s[i]</code> and then do the same transformation, for a total of <code>k+1</code> operations (deletion).
| |
| ** If we can transform <code>s[1..i-1]</code> to <code>t[1..j-1]</code> in <code>k</code> operations, then we can do the same to <code>s[1..i]</code>, and exchange the original <code>s[i]</code> for <code>t[j]</code> afterwards, for a total of <code>k+1</code> operations (substitution).
| |
| * The operations required to transform <code>s[1..n]</code> into <code>t[1..m]</code> is of course the number required to transform all of <code>s</code> into all of <code>t</code>, and so <code>d[n,m]</code> holds our result.
| |
| | |
| This proof fails to validate that the number placed in <code>d[i,j]</code> is in fact minimal; this is more difficult to show, and involves an [[Reductio ad absurdum|argument by contradiction]] in which we assume <code>d[i,j]</code> is smaller than the minimum of the three, and use this to show one of the three is not minimal.
| |
| | |
| ====Possible modifications====
| |
| Possible modifications to this algorithm include:
| |
| * We can adapt the algorithm to use less space, [[Big O notation|''O'']](''min(n,m)'') instead of ''O''(''mn''), since it only requires that the previous row and current row be stored at any one time.
| |
| * We can store the number of insertions, deletions, and substitutions separately, or even the positions at which they occur, which is always <code>j</code>.
| |
| * We can normalize the distance to the interval <code>[0,1]</code>.
| |
| * If we are only interested in the distance if it is smaller than a threshold ''k'', then it suffices to compute a diagonal stripe of width ''2k+1'' in the matrix. In this way, the algorithm can be run in [[Big O notation|''O'']](''kl'') time, where ''l'' is the length of the shortest string.<ref>{{cite book |author=Gusfield, Dan |title=Algorithms on strings, trees, and sequences: computer science and computational biology |pages= 263–264 |publisher=Cambridge University Press |location=Cambridge, UK |year=1997 |isbn=0-521-58519-8 }}</ref>
| |
| * We can give different penalty costs to insertion, deletion and substitution. We can also give penalty costs that depend on which characters are inserted, deleted or substituted.
| |
| * By initializing the first row of the matrix with ''0'', the algorithm can be used for [[fuzzy string searching|fuzzy string search]] of a string in a text.<ref>{{cite journal |last=Navarro |first=Gonzalo |title=A guided tour to approximate string matching |journal=ACM Computing Surveys |volume=33 |issue=1 |pages=31–88 |date=March 2001 |doi=10.1145/375360.375365}}</ref> This modification gives the end-position of matching substrings of the text. To determine the start-position of the matching substrings, the number of insertions and deletions can be stored separately and used to compute the start-position from the end-position.<ref>Bruno Woltzenlogel Paleo. [http://www.logic.at/people/bruno/Papers/2007-GATE-ESSLLI.pdf An approximate gazetteer for GATE based on levenshtein distance]. Student Section of the European Summer School in Logic, Language and Information ([[European Summer School in Logic, Language and Information|ESSLLI]]), 2007.</ref>
| |
| * This algorithm [[parallel computing|parallelizes]] poorly, due to a large number of [[data dependency|data dependencies]]. However, all the <code>cost</code> values can be computed in parallel, and the algorithm can be adapted to perform the <code>minimum</code> function in phases to eliminate dependencies.
| |
| * By examining diagonals instead of rows, and by using [[lazy evaluation]], we can find the Levenshtein distance in ''O''(''m'' (1 + ''d'')) time (where ''d'' is the Levenshtein distance), which is much faster than the regular dynamic programming algorithm if the distance is small.<ref>{{cite journal |last=Allison |first=L. |title=Lazy Dynamic-Programming can be Eager |journal=Inf. Proc. Letters |volume=43 |issue=4 |pages=207–12 |date=September 1992 |url=http://www.csse.monash.edu.au/~lloyd/tildeStrings/Alignment/92.IPL.html |doi=10.1016/0020-0190(92)90202-7}}</ref>
| |
| | |
| ===Iterative with two matrix rows===
| |
| It turns out that only two rows of the table are needed for the construction: the previous row and the current row (the one being calculated).
| |
| | |
| The Levenshtein distance may be calculated iteratively using the following algorithm:<ref>{{Citation |title=Fast, memory efficient Levenshtein algorithm |first=Sten |last=Hjelmqvist |date=26 Mar 2012 |url=http://www.codeproject.com/Articles/13525/Fast-memory-efficient-Levenshtein-algorithm}}</ref>
| |
| <syntaxhighlight lang="CSharp">
| |
| int LevenshteinDistance(string s, string t)
| |
| {
| |
| // degenerate cases
| |
| if (s == t) return 0;
| |
| if (s.Length == 0) return t.Length;
| |
| if (t.Length == 0) return s.Length;
| |
| | |
| // create two work vectors of integer distances
| |
| int[] v0 = new int[t.Length + 1];
| |
| int[] v1 = new int[t.Length + 1];
| |
| | |
| // initialize v0 (the previous row of distances)
| |
| // this row is A[0][i]: edit distance for an empty s
| |
| // the distance is just the number of characters to delete from t
| |
| for (int i = 0; i <= v0.Length; i++)
| |
| v0[i] = i;
| |
| | |
| for (int i = 0; i < s.Length; i++)
| |
| {
| |
| // calculate v1 (current row distances) from the previous row v0
| |
| | |
| // first element of v1 is A[i+1][0]
| |
| // edit distance is delete (i+1) chars from s to match empty t
| |
| v1[0] = i + 1;
| |
| | |
| // use formula to fill in the rest of the row
| |
| for (int j = 0; j < t.Length; j++)
| |
| {
| |
| var cost = (s[i] == t[j]) ? 0 : 1;
| |
| v1[j + 1] = Minimum(v1[j] + 1, v0[j + 1] + 1, v0[j] + cost);
| |
| }
| |
| | |
| // copy v1 (current row) to v0 (previous row) for next iteration
| |
| for (int j = 0; j < v0.Length; j++)
| |
| v0[j] = v1[j];
| |
| }
| |
| | |
| return v1[t.Length];
| |
| }
| |
| </syntaxhighlight>
| |
| | |
| ==See also==
| |
| <div class= style="-moz-column-count:2; column-count:2;">
| |
| *[[agrep]]
| |
| *[[Approximate string matching]]
| |
| *[[Bitap algorithm]]
| |
| *[[Damerau–Levenshtein distance]]
| |
| *[[diff]]
| |
| *[[MinHash]]
| |
| *[[Dynamic time warping]]
| |
| *[[Euclidean distance]]
| |
| *[[Fuzzy string searching]]
| |
| *[[Hamming weight]]
| |
| *[[Hirschberg's algorithm]]
| |
| *[[Homology (biology)#Sequence homology|Homology of sequences in genetics]]
| |
| *[[Hunt–McIlroy algorithm]]
| |
| *[[Jaccard index]]
| |
| *[[Jaro–Winkler distance]]
| |
| *[[Levenshtein automaton]]
| |
| *[[Longest common subsequence problem]]
| |
| *[[Lucene]] (an open source search engine that implements edit distance)
| |
| *[[Manhattan distance]]
| |
| *[[Metric space]]
| |
| *[[Needleman–Wunsch algorithm]]
| |
| *[[Optimal matching]] algorithm
| |
| *[[Sequence alignment]]
| |
| *[[Similarity space]] on [[Numerical taxonomy]]
| |
| *[[Smith–Waterman algorithm]]
| |
| *[[Sørensen similarity index]]
| |
| *[[String distance metric]]
| |
| *[[String similarity function]]
| |
| *[[Wagner-Fischer algorithm]]
| |
| *[[Locality-sensitive hashing]]
| |
| </div>
| |
| | |
| ==References==
| |
| {{reflist|30em}}
| |
| | |
| ==External links==
| |
| {{Wikibooks| R_Programming|Text_Processing#Edit_distance|Levenshtein distance in R}}
| |
| {{Wikibooks| Algorithm implementation|Strings/Levenshtein distance|Levenshtein distance}}
| |
| *[http://www.postgresql.org/docs/current/static/fuzzystrmatch.html Levenshtein in PostgreSQL]
| |
| *{{citation |contribution=Levenshtein distance |title=Dictionary of Algorithms and Data Structures [online] |editor-first=Paul E. |editor-last=Black |publisher=U.S. National Institute of Standards and Technology |date=14 August 2008 |accessdate=3 April 2013 |url=http://www.nist.gov/dads/HTML/Levenshtein.html }}
| |
| | |
| {{DEFAULTSORT:Levenshtein Distance}}
| |
| [[Category:String similarity measures]]
| |
| [[Category:Dynamic programming]]
| |
| [[Category:Articles with example pseudocode]]
| |
| [[Category:Quantitative linguistics]]
| |