|
|
| Line 1: |
Line 1: |
| <!--If you are thinking of adding an implementation of this algorithm in a particular language, think again. See the talk page.--> {{Refimprove|date=October 2009}}
| | Green coffee beans came up newly inside a TV show plus much was spoken about miraculous weight reduction. These coffee beans have been cleaned right off the shop shelves. They in fact have better success rates than placebo because it was proven in the show. So what are these magic coffee beans?<br><br>Whether you're getting [http://greencoffeeweightlossplan.com green coffee bean extract] Extract online or offline, we should constantly choose a reputable region to buy it from. The official url is a advantageous region thus that there might be a guarantee of several kind. If the choice is to purchase online, make certain the url is perfectly established and has superior ratings. You may additionally wish To make certain there is actually a money back guarantee. If you choose to shop inside the area ensure we don't get the green coffee weight loss Extract at discount and/or dollar store. You are better to go with a reputable neighborhood pharmacy or health store. It's important which we recognize precisely what we are ordering. You are able to not be to sure-do your due diligence.<br><br>1) It reduces the uptake of glucose from the tiny intestine. We recognize this considering experiments have been carried out on rats that show reduced glucose absorption in the little intestine when chlorogenic acid is present [1].<br><br>[2] Hemmerle, H et al., Chlorogenic acid plus synthetic chlorogenic acid derivatives: novel inhibitors of hepatic glucose-6-phosphate translocase. Arch Biochem Biophys, 1997. 339(2): p 315-22.<br><br>While eating all of these calories, the participants did not engage in any exercise and fat reduction amongst all sixteen was nevertheless attained. The average weight reduction overall was 17lbs. To further break this down, there was a 16% loss inside body fat along with a 10.5% reduction inside body weight.<br><br>But, creating lean muscle from exercise is a amazing method to burn fat, lose weight, and receive slimmer! She didn't learn how it all works plus reacted to words she thought she understood.<br><br>So, what is Green Coffee? It is merely the name provided to coffee before it gets roasted. The coffee you all drink has been roasted, as this improves the flavour. The drawback, though, is the fact that the roasting task destroys certain of the beneficial, all-natural components of the coffee beans. One of these natural components is chlorogenic acid - the active component in Green Coffee Beans - which is responsible for its weight reducing qualities. After roasting, coffee can loose up to 70% of its chlorogenic acid compliment. Green Coffee Extract could contain 45-50% chlorogenic acid.<br><br>However should you are 1 of those lazy people whom find dieting and exercising too boring then I surely suggest green coffee bean extract. Try it for at least 12 weeks and get astonished by the results. |
| | |
| In [[computer science]], the '''Knuth–Morris–Pratt [[string searching algorithm]]''' (or '''KMP algorithm''') searches for occurrences of a "word" <code>W</code> within a main "text string" <code>S</code> by employing the observation that when a mismatch occurs, the word itself embodies sufficient information to determine where the next match could begin, thus bypassing re-examination of previously matched characters.
| |
| | |
| The [[algorithm]] was conceived in 1974 by [[Donald Knuth]] and [[Vaughan Pratt]], and independently by [[James H. Morris]]. The three published it jointly in 1977.
| |
| | |
| ==Background==
| |
| A string matching algorithm wants to find the starting index <code>m</code> in string <code>S[]</code> that matches the search word <code>W[]</code>.
| |
| | |
| The most straightforward algorithm is to look for a character match at successive values of the index <code>m</code>, the position in the string being searched, i.e. <code>S[m]</code>. If the index m reaches the end of the string then there is no match, in which case the search is said to "fail". At each position m the algorithm first checks for equality of the first character in the searched for word, i.e. <code>S[m] =? W[0]</code>. If a match is found, the algorithm tests the other characters in the searched for word by checking successive values of the word position index, <code>i</code>. The algorithm retrieves the character <code>W[i]</code> in the searched for word and checks for equality of the expression <code>S[m+i] =? W[i]</code>. If all successive characters match in <code>W</code> at position <code>m</code> then a match is found at that position in the search string.
| |
| | |
| Usually, the trial check will quickly reject the trial match. If the strings are uniformly distributed random letters, then the chance that characters match is 1 in 26. In most cases, the trial check will reject the match at the initial letter. The chance that the first two letters will match is 1 in 26^2 (1 in 676). So if the characters are random, then the expected complexity of searching string <code>S[]</code> of length ''k'' is on the order of ''k'' comparisons or ''O''(''k''). The expected performance is very good. If <code>S[]</code> is 1 billion characters and <code>W[]</code> is 1000 characters, then the string search should complete after about one billion character comparisons.
| |
| | |
| That expected performance is not guaranteed. If the strings are not random, then checking a trial <code>m</code> may take many character comparisons. The worst case is if the two strings match in all but the last letter. Imagine that the string <code>S[]</code> consists of 1 billion characters that are all ''A'', and that the word <code>W[]</code> is 999 ''A'' characters terminating in a final ''B'' character. The simple string matching algorithm will now examine 1000 characters at each trial position before rejecting the match and advancing the trial position. The simple string search example would now take about 1000 character comparisons times 1 billion positions for 1 trillion character comparisons. If the length of <code>W[]</code> is ''n'', then the worst case performance is ''O''(''k''⋅''n'').
| |
| | |
| The KMP algorithm does not have the horrendous worst case performance of the straightforward algorithm. KMP spends a little time precomputing a table (on the order of the size of <code>W[]</code>, ''O''(''n'')), and then it uses that table to do an efficient search of the string in ''O''(''k'').
| |
| | |
| The difference is that KMP makes use of previous match information that the straightforward algorithm does not. In the example above, when KMP sees a trial match fail on the 1000th character (<code>i</code>=999) because <code>S[m+999]≠W[999]</code>, it will increment <code>m</code> by 1, but it will know that the first 998 characters at the new position already match. KMP matched 999 ''A'' characters before discovering a mismatch at the 1000th character (position 999). Advancing the trial match position <code>m</code> by one throws away the first ''A'', so KMP knows there are 998 ''A'' characters that match <code>W[]</code> and does not retest them; that is, KMP sets <code>i</code> to 998. KMP maintains its knowledge in the precomputed table and two state variables. When KMP discovers a mismatch, the table determines how much KMP will increase (variable <code>m)</code> and where it will resume testing (variable <code>i</code>). | |
| | |
| ==KMP algorithm==
| |
| | |
| ===Worked example of the search algorithm===
| |
| To illustrate the algorithm's details, we work through a (relatively artificial) run of the algorithm, where <code>W</code> = "ABCDABD" and <code>S</code> = "ABC ABCDAB ABCDABCDABDE". At any given time, the algorithm is in a state determined by two integers:
| |
| | |
| * <code>m</code> which denotes the position within <code>S</code> which is the beginning of a prospective ''match'' for <code>W</code>
| |
| * <code>i</code> the ''index'' in <code>W</code> denoting the character currently under consideration.
| |
| | |
| In each step we compare <code>S[m+i]</code> with <code>W[i]</code> and advance if they are equal. This is depicted, at the start of the run, like
| |
| <code>
| |
| 1 2
| |
| m: 01234567890123456789012
| |
| S: ABC ABCDAB ABCDABCDABDE
| |
| W: ABC<span style="color:red">D</span><span style="color:gray">ABD</span>
| |
| i: 0123456
| |
| </code>
| |
| We proceed by comparing successive characters of <code>W</code> to "parallel" characters of <code>S</code>, moving from one to the next if they match. However, in the fourth step, we get <code>S[3]</code> is a space and <code>W[3] = 'D'</code>, a mismatch. Rather than beginning to search again at <code>S[1]</code>, we note that no <code>'A'</code> occurs between positions 0 and 3 in <code>S</code> except at 0; hence, having checked all those characters previously, we know there is no chance of finding the beginning of a match if we check them again. Therefore we move on to the next character, setting <code>m = 4</code> and <code>i = 0</code>.
| |
| <code>
| |
| 1 2
| |
| m: 01234567890123456789012
| |
| S: ABC ABCDAB ABCDABCDABDE
| |
| W: ABCDAB<span style="color:red">D</span>
| |
| i: 0123456
| |
| </code>
| |
| We quickly obtain a nearly complete match <code>"ABCDAB"</code> when, at <code>W[6]</code> (<code>S[10]</code>), we again have a discrepancy. However, just prior to the end of the current partial match, we passed an <code>"AB"</code> which could be the beginning of a new match, so we must take this into consideration. As we already know that these characters match the two characters prior to the current position, we need not check them again; we simply reset <code>m = 8</code>, <code>i = 2</code> and continue matching the current character. Thus, not only do we omit previously matched characters of <code>S</code>, but also previously matched characters of <code>W</code>.
| |
| <code>
| |
| 1 2
| |
| m: 01234567890123456789012
| |
| S: ABC ABCDAB ABCDABCDABDE
| |
| W: AB<span style="color:red">C</span><span style="color:gray">DABD</span>
| |
| i: 0123456
| |
| </code>
| |
| This search fails immediately, however, as the pattern still does not contain a space, so as in the first trial, we return to the beginning of <code>W</code> and begin searching at the next character of <code>S</code>: <code>m = 11</code>, reset <code>i = 0</code>.
| |
| <code>
| |
| 1 2
| |
| m: 01234567890123456789012
| |
| S: ABC ABCDAB ABCDABCDABDE
| |
| W: ABCDAB<span style="color:red">D</span>
| |
| i: 0123456
| |
| </code>
| |
| Once again we immediately hit upon a match <code>"ABCDAB"</code> but the next character, <code>'C'</code>, does not match the final character <code>'D'</code> of the word <code>W</code>. Reasoning as before, we set <code>m = 15</code>, to start at the two-character string <code>"AB"</code> leading up to the current position, set <code>i = 2</code>, and continue matching from the current position.
| |
| <code>
| |
| 1 2
| |
| m: 01234567890123456789012
| |
| S: ABC ABCDAB ABCD<span style="color:green">ABCDABD</span>E
| |
| W: ABCDABD
| |
| i: 0123456
| |
| </code>
| |
| This time we are able to complete the match, whose first character is <code>S[15]</code>.
| |
| | |
| ===Description of pseudocode for the search algorithm===
| |
| <!--Note to future editors: please do not replace or even supplement the pseudocode with language-specific code. Following the WikiProject Computer Science manual of style, pseudocode is preferred over real code unless the real code illustrates a feature of the language or an implementation detail. This algorithm is so simple that neither of these can ever be the case-->
| |
| The above example contains all the elements of the algorithm. For the moment, we assume the existence of a "partial match" table <code>T</code>, described [[#"Partial match" table (also known as "failure function")|below]], which indicates where we need to look for the start of a new match in the event that the current one ends in a mismatch. The entries of <code>T</code> are constructed so that if we have a match starting at <code>S[m]</code> that fails when comparing <code>S[m + i]</code> to <code>W[i]</code>, then the next possible match will start at index <code>m + i - T[i]</code> in <code>S</code> (that is, <code>T[i]</code> is the amount of "backtracking" we need to do after a mismatch). This has two implications: first, <code>T[0] = -1</code>, which indicates that if <code>W[0]</code> is a mismatch, we cannot backtrack and must simply check the next character; and second, although the next possible match will ''begin'' at index <code>m + i - T[i]</code>, as in the example above, we need not actually check any of the <code>T[i]</code> characters after that, so that we continue searching from <code>W[T[i]]</code>. The following is a sample [[pseudocode]] implementation of the KMP search algorithm.
| |
| | |
| '''algorithm''' ''kmp_search'':
| |
| '''input''':
| |
| an array of characters, S (the text to be searched)
| |
| an array of characters, W (the word sought)
| |
| '''output''':
| |
| an integer (the [[Array data type|zero-based]] position in S at which W is found)
| |
|
| |
| '''define variables''':
| |
| an integer, m ← 0 (the beginning of the current match in S)
| |
| an integer, i ← 0 (the position of the current character in W)
| |
| an array of integers, T (the table, computed elsewhere)
| |
|
| |
| '''while''' m + i < length(S) '''do'''
| |
| '''if''' W[i] = S[m + i] '''then'''
| |
| '''if''' i = length(W) - 1 '''then'''
| |
| '''return''' m
| |
| '''let''' i ← i + 1
| |
| '''else'''
| |
| '''let''' m ← m + i - T[i]
| |
| '''if''' T[i] > -1 '''then'''
| |
| '''let''' i ← T[i]
| |
| '''else'''
| |
| '''let''' i ← 0
| |
|
| |
| (if we reach here, we have searched all of S unsuccessfully)
| |
| '''return''' the length of S
| |
| | |
| ===Efficiency of the search algorithm===
| |
| Assuming the prior existence of the table <code>T</code>, the search portion of the Knuth–Morris–Pratt algorithm has [[Computational complexity theory|complexity]] [[Linear_time#Linear_time|O(n)]], where <code>n</code> is the length of <code>S</code> and the <code>O</code> is [[big-O notation]]. Except for the fixed overhead incurred in entering and exiting the function, all the computations are performed in the <code>'''while'''</code> loop. To bound the number of iterations of this loop; observe that <code>T</code> is constructed so that if a match which had begun at <code>S[m]</code> fails while comparing <code>S[m + i]</code> to <code>W[i]</code>, then the next possible match must begin at <code>S[m + (i - T[i])]</code>. In particular the next possible match must occur at a higher index than <code>m</code>, so that <code>T[i] < i</code>.
| |
| | |
| This fact implies that the loop can execute at most <code>2n</code> times. For, in each iteration, it executes one of the two branches in the loop. The first branch invariably increases <code>i</code> and does not change <code>m</code>, so that the index <code>m + i</code> of the currently scrutinized character of <code>S</code> is increased. The second branch adds <code>i - T[i]</code> to <code>m</code>, and as we have seen, this is always a positive number. Thus the location <code>m</code> of the beginning of the current potential match is increased. Now, the loop ends if <code>m + i = n</code>; therefore each branch of the loop can be reached at most <code>k</code> times, since they respectively increase either <code>m + i</code> or <code>m</code>, and <code>m ≤ m + i</code>: if <code>m = n</code>, then certainly <code>m + i ≥ n</code>, so that since it increases by unit increments at most, we must have had <code>m + i = n</code> at some point in the past, and therefore either way we would be done.
| |
| | |
| Thus the loop executes at most <code>2n</code> times, showing that the time complexity of the search algorithm is <code>O(n)</code>.
| |
| | |
| Here is another way to think about the runtime:
| |
| Let us say we begin to match W and S at position i and p, if W exists as a substring of S at p, then W[0 through m] == S[p through p+m].
| |
| Upon success, that is, the word and the text matched at the positions(W[i] == S[p+i]), we increase i by 1 (i++).
| |
| Upon failure, that is, the word and the text does not match at the positions(W[i] != S[p+i]), the text pointer is kept still, while the word pointer roll-back a certain amount(i = T[i], where T is the jump table) And we attempt to match <code>W[T[i]]</code> with <code>S[p+i]</code>.
| |
| The maximum number of roll-back of i is bounded by i, that is to say, for any failure, we can only roll-back as much as we have progressed up to the failure.
| |
| Then it is clear the runtime is 2n.
| |
| | |
| =="Partial match" table (also known as "failure function")==
| |
| The goal of the table is to allow the algorithm not to match any character of <code>S</code> more than once. The key observation about the nature of a linear search that allows this to happen is that in having checked some segment of the main string against an ''initial segment'' of the pattern, we know exactly at which places a new potential match which could continue to the current position could begin prior to the current position. In other words, we "pre-search" the pattern itself and compile a list of all possible fallback positions that bypass a maximum of hopeless characters while not sacrificing any potential matches in doing so.
| |
| | |
| We want to be able to look up, for each position in <code>W</code>, the length of the longest possible initial segment of <code>W</code> leading up to (but not including) that position, other than the full segment starting at <code>W[0]</code> that just failed to match; this is how far we have to backtrack in finding the next match. Hence <code>T[i]</code> is exactly the length of the longest possible ''proper'' initial segment of <code>W</code> which is also a segment of the substring ending at <code>W[i - 1]</code>. We use the convention that the empty string has length 0. Since a mismatch at the very start of the pattern is a special case (there is no possibility of backtracking), we set <code>T[0] = -1</code>, as discussed [[#Description of pseudocode for the table-building algorithm|below]].
| |
| | |
| ===Worked example of the table-building algorithm===
| |
| We consider the example of <code>W = "ABCDABD"</code> first. We will see that it follows much the same pattern as the main search, and is efficient for similar reasons. We set <code>T[0] = -1</code>. To find <code>T[1]</code>, we must discover a [[Substring#Suffix|proper suffix]] of <code>"A"</code> which is also a prefix of <code>W</code>. But there are no proper suffixes of <code>"A"</code>, so we set <code>T[1] = 0</code>. Likewise, <code>T[2] = 0</code>.
| |
| | |
| Continuing to <code>T[3]</code>, we note that there is a shortcut to checking ''all'' suffixes: let us say that we discovered a [[Substring#Suffix|proper suffix]] which is a [[Substring#Prefix|proper prefix]] and ending at <code>W[2]</code> with length 2 (the maximum possible); then its first character is a proper prefix of <code>W</code>, hence a proper prefix itself, and it ends at <code>W[1]</code>, which we already determined cannot occur in case T[2]. Hence at each stage, the shortcut rule is that one needs to consider checking suffixes of a given size m+1 only if a valid suffix of size m was found at the previous stage (e.g. T[x]=m).
| |
| | |
| Therefore we need not even concern ourselves with substrings having length 2, and as in the previous case the sole one with length 1 fails, so <code>T[3] = 0</code>.
| |
| | |
| We pass to the subsequent <code>W[4]</code>, <code>'A'</code>. The same logic shows that the longest substring we need consider has length 1, and although in this case <code>'A'</code> ''does'' work, recall that we are looking for segments ending ''before'' the current character; hence <code>T[4] = 0</code> as well.
| |
| | |
| Considering now the next character, <code>W[5]</code>, which is <code>'B'</code>, we exercise the following logic: if we were to find a subpattern beginning before the previous character <code>W[4]</code>, yet continuing to the current one <code>W[5]</code>, then in particular it would itself have a proper initial segment ending at <code>W[4]</code> yet beginning before it, which contradicts the fact that we already found that <code>'A'</code> itself is the earliest occurrence of a proper segment ending at <code>W[4]</code>. Therefore we need not look before <code>W[4]</code> to find a terminal string for <code>W[5]</code>. Therefore <code>T[5] = 1</code>.
| |
| | |
| Finally, we see that the next character in the ongoing segment starting at <code>W[4] = 'A'</code> would be <code>'B'</code>, and indeed this is also <code>W[5]</code>. Furthermore, the same argument as above shows that we need not look before <code>W[4]</code> to find a segment for <code>W[6]</code>, so that this is it, and we take <code>T[6] = 2</code>.
| |
| | |
| Therefore we compile the following table:
| |
| | |
| {| class="wikitable" style="background-color:white; font-family:monospace; text-align:right"
| |
| !<code>i</code>
| |
| | 0
| |
| | 1
| |
| | 2
| |
| | 3
| |
| | 4
| |
| | 5
| |
| | 6
| |
| |-
| |
| !<code>W[i]</code>
| |
| | A
| |
| | B
| |
| | C
| |
| | D
| |
| | A
| |
| | B
| |
| | D
| |
| |-
| |
| !<code>T[i]</code>
| |
| | -1
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 1
| |
| | 2
| |
| |}
| |
| | |
| Other example more interesting and complex:
| |
| {| class="wikitable" style="background-color:white; font-family:monospace; text-align:right"
| |
| !<code>i</code>
| |
| | 0
| |
| | 1
| |
| | 2
| |
| | 3
| |
| | 4
| |
| | 5
| |
| | 6
| |
| | 7
| |
| | 8
| |
| | 9
| |
| | 10
| |
| | 11
| |
| | 12
| |
| | 13
| |
| | 14
| |
| | 15
| |
| | 16
| |
| | 17
| |
| | 18
| |
| | 19
| |
| | 20
| |
| | 21
| |
| | 22
| |
| | 23
| |
| |-
| |
| !<code>W[i]</code>
| |
| | P
| |
| | A
| |
| | R
| |
| | T
| |
| | I
| |
| | C
| |
| | I
| |
| | P
| |
| | A
| |
| | T
| |
| | E
| |
| |
| |
| | I
| |
| | N
| |
| |
| |
| | P
| |
| | A
| |
| | R
| |
| | A
| |
| | C
| |
| | H
| |
| | U
| |
| | T
| |
| | E
| |
| |-
| |
| !<code>T[i]</code>
| |
| | -1
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 1
| |
| | 2
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 1
| |
| | 2
| |
| | 3
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| | 0
| |
| |}
| |
| | |
| ===Description of pseudocode for the table-building algorithm===
| |
| <!--Note to future editors: please do not replace or even supplement the pseudocode with language-specific code. Following the WikiProject Computer Sscience manual of style, pseudocode is preferred over real code unless the real code illustrates a feature of the language or an implementation detail. This algorithm is so simple that neither of these can ever be the case-->
| |
| <!--This code appears to implement the table for the Morris-Pratt algorithm, not for the Knuth-Morris-Pratt Algorithm. The KMP table has bigger shifts. See http://www-igm.univ-mlv.fr/~lecroq/string/node8.html-->
| |
| The example above illustrates the general technique for assembling the table with a minimum of fuss. The principle is that of the overall search: most of the work was already done in getting to the current position, so very little needs to be done in leaving it. The only minor complication is that the logic which is correct late in the string erroneously gives non-proper substrings at the beginning. This necessitates some initialization code.
| |
| | |
| '''algorithm''' ''kmp_table'':
| |
| '''input''':
| |
| an array of characters, W (the word to be analyzed)
| |
| an array of integers, T (the table to be filled)
| |
| '''output''':
| |
| nothing (but during operation, it populates the table)
| |
|
| |
| '''define variables''':
| |
| an integer, pos ← 2 (the current position we are computing in T)
| |
| an integer, cnd ← 0 (the zero-based index in W of the next <br>character of the current candidate substring)
| |
|
| |
| (the first few values are fixed but different from what the algorithm <br>might suggest)
| |
| '''let''' T[0] ← -1, T[1] ← 0
| |
|
| |
| '''while''' pos < length(W) do
| |
| (first case: the substring continues)
| |
| '''if''' W[pos - 1] = W[cnd] '''then'''
| |
| '''let''' cnd ← cnd + 1, T[pos] ← cnd, pos ← pos + 1
| |
|
| |
| (second case: it doesn't, but we can fall back)
| |
| '''else''' '''if''' cnd > 0 '''then'''
| |
| '''let''' cnd ← T[cnd]
| |
|
| |
| (third case: we have run out of candidates. Note cnd = 0)
| |
| '''else'''
| |
| '''let''' T[pos] ← 0, pos ← pos + 1
| |
| | |
| ===Efficiency of the table-building algorithm===
| |
| The complexity of the table algorithm is <code>O(n)</code>, where <code>n</code> is the length of <code>W</code>. As except for some initialization all the work is done in the <code>'''while'''</code> loop, it is sufficient to show that this loop executes in <code>O(n)</code> time, which will be done by simultaneously examining the quantities <code>pos</code> and <code>pos - cnd</code>. In the first branch, <code>pos - cnd</code> is preserved, as both <code>pos</code> and <code>cnd</code> are incremented simultaneously, but naturally, <code>pos</code> is increased. In the second branch, <code>cnd</code> is replaced by <code>T[cnd]</code>, which we saw [[#Efficiency of the search algorithm|above]] is always strictly less than <code>cnd</code>, thus increasing <code>pos - cnd</code>. In the third branch, <code>pos</code> is incremented and <code>cnd</code> is not, so both <code>pos</code> and <code>pos - cnd</code> increase. Since <code>pos ≥ pos - cnd</code>, this means that at each stage either <code>pos</code> or a lower bound for <code>pos</code> increases; therefore since the algorithm terminates once <code>pos = n</code>, it must terminate after at most <code>2n</code> iterations of the loop, since <code>pos - cnd</code> begins at <code>1</code>. Therefore the complexity of the table algorithm is <code>O(n)</code>.
| |
| | |
| ==Efficiency of the KMP algorithm==
| |
| Since the two portions of the algorithm have, respectively, complexities of <code>O(k)</code> and <code>O(n)</code>, the complexity of the overall algorithm is <code>O(n + k)</code>.
| |
| | |
| These complexities are the same, no matter how many repetitive patterns are in <code>W</code> or <code>S</code>.
| |
| | |
| ==Variants==
| |
| A [[Real-time computing|real-time]] version of KMP can be implemented using a separate failure function table for each character in the alphabet. If a mismatch occurs on character <math>x</math> in the text, the failure function table for character <math>x</math> is consulted for the index <math>i</math> in the pattern at which the mismatch took place. This will return the length of the longest substring ending at <math>i</math> matching a prefix of the pattern, with the added condition that the character after the prefix is <math>x</math>. With this restriction, character <math>x</math> in the text need not be checked again in the next phase, and so only a constant number of operations are executed between the processing of each index of the text. This satisfies the real-time computing restriction.
| |
| | |
| The Booth algorithm uses a modified version of the KMP preprocessing function to find the [[lexicographically minimal string rotation]]. The failure function is progressively calculated as the string is rotated.
| |
| | |
| ==See also==
| |
| *[[Boyer–Moore string search algorithm]]
| |
| *[[Rabin–Karp string search algorithm]]
| |
| *[[Aho–Corasick string matching algorithm]]
| |
| | |
| ==References==
| |
| | |
| * {{cite journal | first1=Donald | last1=Knuth | author1-link = Donald Knuth | first2=James H., jr | last2=Morris | author2-link= James H. Morris, Jr | first3=Vaughan | last3=Pratt | author3-link=Vaughan Pratt | title = Fast pattern matching in strings | journal = SIAM Journal on Computing | volume = 6 | issue = 2 | pages = 323–350 | year = 1977 | url = http://citeseer.ist.psu.edu/context/23820/0 | doi = 10.1137/0206024 | zbl=0372.68005 }}
| |
| * {{cite book | first1=Thomas | last1=Cormen | author1-link=Thomas H. Cormen | first2=Charles E. | last2=Lesiserson | author2-link=Charles E. Leiserson | first3=Ronald L. | last3=Rivest | author3-link=Ronald L. Rivest | first4=Clifford | last4=Stein | author4-link=Clifford Stein | title = [[Introduction to Algorithms]] | edition = Second | publisher = MIT Press and McGraw-Hill | year = 2001 | isbn = 0-262-03293-7 | chapter = Section 32.4: The Knuth-Morris-Pratt algorithm | pages = 923–931 | zbl=1047.68161 }}
| |
| * {{cite book | last1=Crochemore | first1=Maxime | last2=Rytter | first2=Wojciech | author2-link = Wojciech Rytter | title=Jewels of stringology. Text algorithms | location=River Edge, NJ | publisher=World Scientific | year=2003 | isbn=981-02-4897-0 | zbl=1078.68151 | pages=20–25 }}
| |
| * {{cite book | last=Szpankowski | first=Wojciech | title=Average case analysis of algorithms on sequences | others=With a foreword by Philippe Flajolet | series=Wiley-Interscience Series in Discrete Mathematics and Optimization | location=Chichester | publisher=Wiley | year=2001 | isbn=0-471-24063-X | zbl=0968.68205 | pages=15–17,136–141 }}
| |
| | |
| ==External links==
| |
| {{wikibooks|Algorithm implementation|String searching/Knuth-Morris-Pratt pattern matcher}}
| |
| * [http://www.cs.pitt.edu/~kirk/cs1501/animations/String.html String Searching Applet animation]
| |
| * [http://www.ics.uci.edu/~eppstein/161/960227.html An explanation of the algorithm] and [http://www.ics.uci.edu/~eppstein/161/kmp/ sample C++ code] by [[David Eppstein]]
| |
| * [http://www-igm.univ-mlv.fr/~lecroq/string/node8.html Knuth-Morris-Pratt algorithm] description and C code by Christian Charras and Thierry Lecroq
| |
| * [http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm Explanation of the algorithm from scratch] by FH Flensburg.
| |
| * [http://oak.cs.ucla.edu/cs144/examples/KMPSearch.html Breaking down steps of running KMP] by Chu-Cheng Hsieh.
| |
| * [http://www.youtube.com/watch?v=Zj_er99KMb8] NPTELHRD YouTube lecture video
| |
| * [http://toccata.lri.fr/gallery/kmp.en.html] Proof of correctness
| |
| | |
| {{Donald Knuth navbox}}
| |
| | |
| {{DEFAULTSORT:Knuth-Morris-Pratt Algorithm}}
| |
| [[Category:String matching algorithms]]
| |
| [[Category:Donald Knuth]]
| |
| [[Category:Articles with example pseudocode]]
| |