Talk:Boyer–Moore–Horspool algorithm

message: I'm not native to the C programming language and I don't have time to start sifting through the code in this article to develop a pseudocode representation of this algorithm.
Can someone who knows C better than I please read through and put the code into something cross-platform?
--Oddb411 13:01, 17 September 2006 (UTC)
replies: text: C is actually a cross-platform language when written properly. The sample I wrote is meant to be of that kind. I'll see if I can edit it to use less of the kind of syntax that is inherent to C to make it better understood for those who don't have experience of languages of C origin. --Bisqwit 21:00, 17 September 2006 (UTC)
thread_title:  cross-platform 

message: Many programmers (WikiWikiWeb:MeaningfulName) now recommend
"Always, always, always use good, unabbreviated, correctly-spelled meaningful names."
Is there some more meaningful name we could use instead of "hpos" ?
In the Boyer-Moore algorithm article,
the "hpos" variable tracks the position where a copy of the needle might possibly start in the haystack, although we generally look at some later position in the haystack.
(What would be a more meaningful name for this?)
In this Boyer–Moore–Horspool algorithm article,
the "hpos" variable tracks the actual letter in the haystack that we look at.
(What would be a more meaningful name for this?)
(The difference is precisely
    BMH_hpos = BM_hpos + npos
).
I think doing it the same way in both articles would be less confusing.
Which way (the current BM way, or the current BMH way) would make clearer, easier-to-understand code?
--68.0.120.35 02:32, 25 March 2007 (UTC)
thread_title:  variable names 

message: The article says "For instance a 32 byte needle ending in "z" searching through a 255 byte haystack which doesn't have a 'z' byte in it would take 3 byte comparisons."
I think it meant 7 byte comparisons, since each one skips 32 bytes until there's less that 32 bytes remaining.
Can anybody confirm?  —Preceding unsigned comment added by 155.210.218.53 (talk) 18:21, 18 January 2008 (UTC)
thread_title:  Possible miscalculation of comparisons 

message: I might be wrong, but it looks like space can be saved in the bad character skip table by using a hash of the character instead of its actual value.  In the case of a collision, the result will just be a smaller shift.
Not a particularly useful idea when the table's only 256 chars long, but it would allow for much better storage requirements if you were using, say, a 32-bit character set.  In a case like that, probably only a small fraction of the character set would be seen, and so chances of collision would be low for a reasonably sized hash. CountingPine (talk) 08:27, 17 July 2009 (UTC)
thread_title:  Optimising the table size 

message: How is this related to KMP? If anything, the other heuristic in Boyer-Moore (which is not in this algorithm) is closely related to KMP's table (e.g. the compute_prefix code in http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm is exactly the pre-processing in KMP). Raduberinde (talk) 23:36, 17 August 2010 (UTC)
thread_title:  KMP 

message: Wouldn't there be a benefit in pointing out real live examples, e.g. https://github.com/ggreer/the_silver_searcher, to substantiate the usefulness of this algorithm?
I saw earlier the talk page that the algorithm itself was not implemented correctly. I am too lazy to verify the correctness of this code, so I'll leave it to others, but in the above example you have an implementation that does work (might have bugs though as any algo/sw).
There you have a truly super-fast grep tool using this algorithm for substring searches.  — Preceding unsigned comment added by 192.75.88.232 (talk) 19:49, 25 June 2013 (UTC)
thread_title:  Real life examples 

message: Just saw that my BMH order 2/12 link in 'External links' is removed, what is the problem?  — Preceding unsigned comment added by Sanmayce (talk • contribs) 17:45, 19 December 2013 (UTC)
thread_title:  Why did you remove my contribution? 

message: Raita's is apparently an optimization of BMH. QVVERTYVS (hm?) 15:08, 15 March 2015 (UTC)
replies: text: Removing stale merge proposal after 2.5 years; substantial improvements can be independently notable. Klbrain (talk) 21:10, 10 September 2017 (UTC)
thread_title:  Proposed merge with [[Raita Algorithm]] 

message: I translated this from the Python version that was previously on this page, but it doesn't match Horspool's pseudocode very closely. It also contains some bugs that I discovered when implementing it (corner cases). QVVERTYVS (hm?) 10:26, 6 June 2015 (UTC)
thread_title:  Pseudocode doesn't match the original 

message: "A very fast substring search algorithm";
Daniel M. Sunday; Communications of the ACM; August 1990
The Sunday variant is slightly more efficient than Horspool.
Thierry Lecroq covers the three versions presented by Sunday.
"Exact String Matching Algorithms"  — Preceding unsigned comment added by SirWumpus (talk • contribs) 16:37, 5 November 2015 (UTC)
replies: text: So be bold, and add it! QVVERTYVS (hm?) 17:26, 5 November 2015 (UTC)
thread_title:  No mention of Boyer-Moore-Sunday algorithm. 

message: ... so it seems wrong to belittle that choice in that comment.
The first operation in the while loop is to compare, somehow, the entire match candidate site with the pattern. If the comparison fails, the next operation is to get haystack[skip + length(needle) - 1] to use as table index into T; this is the rightmost character in the candidate site.
No matter which end you start at, it's quite likely that the first character compared will fail to match, so it's better to start by reading the rightmost one, since you're going to need it anyway. I.e. the first 'if' below will usually fail, and the code will already have hlast in a register for the table index of T. 
Factoring the entire string compare into the 'same' function makes the algorithm a little clearer overall, but obscures this detail. 
 function search(needle, haystack)
     T ← preprocess(needle)
     nn1 ← len(needle) - 1
     nlast ← needle[nn1]
     skip ← 0
     while length(haystack) - skip ≥ length(needle)
         hlast ← haystack[skip + nn1]
         if hlast == nlast
             if same(haystack[skip:], needle, nn1)
                 return skip  
         skip ← skip + T[hlast]
     return not-found
Greg.smith.tor.ca (talk) 16:42, 9 July 2023 (UTC)
thread_title:  "The original algorithm tries to play smart" by checking the last character for good reason