Problem Statement​

Given a text string $T$ of length $n$ and a pattern string $P$ of length $m$, the goal of pattern matching is to find all occurrences of $P$ as a substring of $T$. The brute-force approach requires checking each possible alignment of $P$ with $T$, which results in a time complexity of $O(n \cdot m)$. The Boyer-Moore algorithm improves upon this by skipping unnecessary comparisons.

The Boyer-Moore Algorithm​

The Boyer-Moore algorithm matches the pattern $P$ from right to left, starting at the end of the pattern. If a mismatch occurs, the algorithm shifts the pattern over the text based on two preprocessed heuristics: the Bad Character rule and the Good Suffix rule.

Bad Character Rule​

The Bad Character rule works by identifying mismatches and using the information to shift the pattern efficiently. Given a mismatch between the text character $T[i]$ and the corresponding pattern character $P[j]$, we look for the rightmost occurrence of $T[i]$ in $P$.

• If $T[i]$ exists in $P$, we shift the pattern such that this occurrence aligns with $T[i]$.
• If $T[i]$ does not exist in $P$, we shift the entire pattern past the mismatched character.

Mathematically, let:

where $\text{rightmost}(T[i])$ is the rightmost occurrence of $T[i]$ in $P$, or -1 if it does not appear.

Example:

Consider the pattern $P = \text{ABCA}$ and text $T = \text{CBABCA}$. Suppose a mismatch occurs at position $i = 2$, where $T[2] = \text{B}$ and $P[1] = \text{A}$. Since $\text{B}$ exists in $P$ at position 1, we shift the pattern such that this occurrence aligns with $T[2]$.

Good Suffix Rule​

The Good Suffix rule leverages suffixes in the pattern to skip unnecessary shifts. When a mismatch occurs after a suffix of the pattern has been matched, the algorithm shifts the pattern such that the next occurrence of this suffix aligns with the text.

Mathematically, let:

where $\text{next\_suffix}(j)$ is the position of the next occurrence of the matched suffix in the pattern.

There are two cases for shifting based on good suffixes:

• Case 1: The matched suffix appears elsewhere in the pattern. In this case, we shift the pattern to align the next occurrence of the suffix.
• Case 2: The matched suffix does not appear in the pattern, but some prefix of the pattern matches a suffix of the text. In this case, we shift the pattern such that the prefix aligns with the suffix.

Example:

For $P = \text{ABCA}$ and $T = \text{CBABCA}$, if a mismatch occurs after matching the suffix "BCA", the pattern is shifted to the next occurrence of "BCA" in $P$.

Proof of Efficiency​

The Boyer-Moore algorithm operates in sublinear time on average due to the efficiency of its heuristics. Let $m$ be the length of the pattern and $n$ the length of the text. The algorithm's worst-case time complexity is $O(n \cdot m)$, but in practice, the average time complexity is much closer to $O(n / m)$, particularly when the alphabet size is large.

This sublinear performance arises because the pattern shifts more than one character in many cases, especially when there are frequent mismatches or when the pattern is long relative to the text.

Performance Comparison Between Bad Character and Good Suffix Heuristics​

The Bad Character rule tends to perform well when the alphabet is large and when mismatches are common because it leverages the presence of mismatched characters to skip unnecessary comparisons. The Good Suffix rule is more effective when the pattern has repeated structures or when mismatches occur near the end of the pattern, allowing it to skip larger sections of the text.

In practical applications, the combination of these two heuristics provides superior performance over either heuristic used in isolation.

1. Bad Character: More efficient with larger alphabets and random text.
2. Good Suffix: More efficient with repetitive patterns and long suffix matches.

In most cases, the Boyer-Moore algorithm uses both heuristics together, allowing the pattern to shift as far as the larger of the two heuristics suggests.

Conclusion​

The Boyer-Moore algorithm is one of the most efficient string-matching algorithms for practical use due to its ability to skip portions of the text rather than performing a brute-force search. By employing both the Bad Character and Good Suffix heuristics, the algorithm achieves sublinear time complexity on average. Its efficiency is particularly notable in scenarios where patterns are long or mismatches occur frequently.

References​

• Robert S. Boyer - Wikipedia
• J Strother Moore - Wikipedia
• Boyer–Moore string-search algorithm - Wikipedia
• Boyer-Moore Algorithm - GeeksforGeeks
• A. V. Aho, and M. J. Corasick, "Efficient String Matching: An Aid to Bibliographic Search," Communications of the ACM, 1975.
• T. H. Cormen, C. E. Leiserson, R. L. Rivest, and C. Stein, Introduction to Algorithms, MIT Press, 2009.

Setup​

Install Python3​

Before we can get started with Django, we need to install Python. (you can skip this part if you have already done so)

Download Site

After the download is complete, run the installer. Make sure you check "add python.exe to PATH".

Install Django In pipenv​

First we are going to install pipenv using pip, we do this with the following command

pip3 install pipenv

Then we install Django in a virtual environment. to avoid possible compatibility issues with other projects.

So each project has its own Python and Django installation.

pipenv install django

activate the environment with:

pipenv shell

Start Django​

Now we start a new Django project named "blog_arteii_example".

django-admin startproject blog_arteii_example

This will create a new folder if you create the project directly in the folder you are currently in:

django-admin startproject blog_arteii_example .

python manage.py runserver

starts a local server

*for now you can ignore the migration errors

your website is now local available on: http://127.0.0.1:8000/

you should see:

stop the server using ctrl + c

python manage.py migrate

removes the error message that we used to get

Hello World!​

lets start creating our first app if you still got a server running pls stop it

and run:

python manage.py startapp <app_name>

in my case the app_name is: pages

add it to the project settings

You should add your own applications below the Django applications. Because Django loads the applications in order. So if you import yours on top, you won't be able to use the Django modules.

...
# Application definition

INSTALLED_APPS = [
    'django.contrib.admin',
    'django.contrib.auth',
    'django.contrib.contenttypes',
    'django.contrib.sessions',
    'django.contrib.messages',
    'django.contrib.staticfiles',
    'pages.apps.PagesConfig',
]
...

let's modify the views.py file so when the user requests the homepage i.e. the domain without any directory structure the function HelloWorld is returned

...
# Create your views here.
from django.http import HttpResponse

def HelloWorld(request):
    return HttpResponse('Hello World!')

now create a new file with the name urls.py in pages (.../blog_arteii_example/pages/urls.py) and modify, so it looks like this:

from django.urls import path
from .views import HelloWorld

urlpatterns = [
    path('', HelloWorld, name='home')
]

Most Django projects use many different applications, and each of these applications needs its own URL path. So we add our app pages to the url patterns so that when a user visits the home page, they are first redirected to the pages app and then to our HelloWorld function.

from django.contrib import admin
from django.urls import path
from django.urls import include

urlpatterns = [
    path('admin/', admin.site.urls),
    path('', include('pages.urls')),
]

and last:

python manage.py runserver

You can write content using GitHub-flavored Markdown syntax.

To serve as an example page when styling markdown based Docusaurus sites.

Headers​

H1 - Create the best documentation

H2 - Create the best documentation​

H3 - Create the best documentation​

H4 - Create the best documentation​

H5 - Create the best documentation​

H6 - Create the best documentation​

Emphasis​

Emphasis, aka italics, with asterisks or underscores.

Strong emphasis, aka bold, with asterisks or underscores.

Combined emphasis with asterisks and underscores.

Strikethrough uses two tildes. Scratch this.

Lists​

1. First ordered list item
2. Another item

• Unordered sub-list.

3. Actual numbers don't matter, just that it's a number
4. Ordered sub-list
5. And another item.

• Unordered list can use asterisks

• Or minuses

• Or pluses

Links​

I'm an inline-style link

I'm an inline-style link with title

[I'm a reference-style link][arbitrary case-insensitive reference text]

[You can use numbers for reference-style link definitions][1]

Or leave it empty and use the [link text itself].

URLs and URLs in angle brackets will automatically get turned into links. http://www.example.com/ or http://www.example.com/ and sometimes example.com (but not on GitHub, for example).

Some text to show that the reference links can follow later.

[arbitrary case-insensitive reference text] https://www.mozilla.org/ [1] http://slashdot.org/ [link text itself] http://www.reddit.com/

Images​

you can import assets and use them like this: (only if you use mdx)

import myImageUrl from "../../static/img/Website-Social-Card.jpeg";

<img src={myImageUrl} width={250} height={250} alt="Example banner" />;

Inline-style:

Reference-style: ![alt text][logo]

[logo] https://arteiii.github.io/img/Website-Social-Card.jpeg "Logo Title Text 2"

Images from any folder can be used by providing path to file. Path should be relative to markdown file.

Code​

var s = "JavaScript syntax highlighting";
alert(s);

s = "Python syntax highlighting"
print(s)

No language indicated, so no syntax highlighting.
But let's throw in a <b>tag</b>.

var highlightMe = function (){
  console.log("This line can be highlighted!");
};

you can also set titles

```python title="example title"
s = "Python syntax highligh...

s = "Python syntax highlighting"
print(s)

Tables​

Colons can be used to align columns.

There must be at least 3 dashes separating each header cell. The outer pipes (|) are optional, and you don't need to make the raw Markdown line up prettily. You can also use inline Markdown.

Blockquotes​

Blockquotes are very handy in email to emulate reply text. This line is part of the same quote.

Quote break.

This is a very long line that will still be quoted properly when it wraps. Oh boy let's keep writing to make sure this is long enough to actually wrap for everyone. Oh, you can put Markdown into a blockquote.

Inline HTML​

Definition list

Is something people use sometimes.

Markdown in HTML

Does not work very well. Use HTML tags.

Line Breaks​

Here's a line for us to start with.

This line is separated from the one above by two newlines, so it will be a separate paragraph.

This line is also a separate paragraph, but... This line is only separated by a single newline, so it's a separate line in the same paragraph.

Admonitions​

MDX​

lets you use jsx in markdown

read more

Tabs​

read docu

import Tabs from "@theme/Tabs";
import TabItem from "@theme/TabItem";

<Tabs>
  <TabItem value="apple" label="Apple" default>
    This is an apple 🍎
  </TabItem>
  <TabItem value="orange" label="Orange">
    This is an orange 🍊
  </TabItem>
  <TabItem value="banana" label="Banana">
    This is a banana 🍌
  </TabItem>
</Tabs>