# Java Program to Implement Bitap Algorithm for String Matching

• Difficulty Level : Expert
• Last Updated : 06 Apr, 2022

The Bitap Algorithm is an approximate string matching algorithm. The algorithm tells whether a given text contains a substring which is “approximately equal” to a given pattern. Here approximately equal states that if the substring and pattern are within a given distance k of each other. The algorithm begins by precomputing a set of bitmasks containing one bit for each element of the pattern. This does most of the bitwise operations, which are quick.

The Bitap Algorithm is also known as shift-or, shift-and, or Baeza Yates Gonnet Algorithm.

Example:

```Input:
Text: geeksforgeeks
Pattern: geeks
Output:
Pattern found at index: 0

Input:
Text: Youareawesome
Pattern: Youareamazing
Output:
No Match.```

Approach:

• Input the text pattern as a string.
• We will convert this String to a simple Char Array
• If the length is 0 or exceeding 63, we return “No Match”.
• Now, by taking array R which complements 0.
• Taking an array “pattern_mask” which complements 0, to 1
• Taking the pattern as an index of “pattern_mask” then by using the and operator we and it with the result of the complement of 1L(long integer) by shifting it to left side by i times.
• Now by running the loop till text length.
• We now or it with R and pattern mask.
• Now by left shifting the 1L by the length of the pattern and then the result is an and with R
• If it is equal to zero we print it by I-len+1 else return -1
• Output is the index of the text, where the pattern matches.

Code:

## Java

 `// Java Program to implement Bitap Algorithm.` `import` `java.io.*;``import` `java.io.IOException;` `public` `class` `GFG {``    ``public` `static` `void` `main(String[] args)``        ``throws` `IOException``    ``{` `        ``System.out.println(``"Bitap Algorithm!"``);` `        ``String text = ``"geeksforgeeks"``;` `        ``String pattern = ``"geeks"``;` `        ``// This is an object created of the class for``        ``// extension of functions.``        ``GFG g = ``new` `GFG();` `        ``// Now here we go to findPattern functions , we two``        ``// arguments.``        ``g.findPattern(text, pattern);``    ``}` `    ``public` `void` `findPattern(String t, String p)``    ``{` `        ``// we convert the String text to Character Array for``        ``// easy indexing``        ``char``[] text = t.toCharArray();` `        ``// we convert the String pattern to Character Array``        ``// to access each letter in the String easily.``        ``char``[] pattern = p.toCharArray();` `        ``// Index shows the function bitap search if they are``        ``// equal at a particular index or not``        ``int` `index = bitap_search(text, pattern);` `        ``// If the pattern is not equal to the text of the``        ``// string approximately Then we tend to return -1 If``        ``// index is -1 Then we print there is No match``        ``if` `(index == -``1``) {``            ``System.out.println(``"\nNo Match\n"``);``        ``}` `        ``else` `{` `            ``// Else if there is a match``            ``// Then we print the position of the index at``            ``// where the pattern and the text matches.``            ``System.out.println(``                ``"\nPattern found at index: \n"` `+ index);``        ``}``    ``}` `    ``private` `int` `bitap_search(``char``[] text, ``char``[] pattern)``    ``{` `        ``// Here the len variable is taken``        ``// This variable accepts the pattern length as its``        ``// value``        ``int` `len = pattern.length;` `        ``// This is an array of pattern_mask of all``        ``// character values in it.` `        ``long` `pattern_mask[]``            ``= ``new` `long``[Character.MAX_VALUE + ``1``];` `        ``// Here the variable of being long type is``        ``// complemented with 1;` `        ``long` `R = ~``1``;` `        ``// Now if the length of the pattern is 0``        ``// we would return -1``        ``if` `(len == ``0``) {``            ``return` `-``1``;``        ``}` `        ``// Or if the length of the pattern exceeds the``        ``// length of the character array Then we would``        ``// declare that the pattern is too long. We would``        ``// return -1``      ` `        ``if` `(len > ``63``) {` `            ``System.out.println(``"Pattern too long!"``);``            ``return` `-``1``;``        ``}` `        ``// Now filling the values in the pattern mask``        ``// We would run th eloop until the max value of``        ``// character Initially all the values of Character``        ``// are put up inside the pattern mask array And``        ``// initially they are complemented with zero``      ` `        ``for` `(``int` `i = ``0``; i <= Character.MAX_VALUE; ++i)` `            ``pattern_mask[i] = ~``0``;` `        ``// Now len being the variable of pattern length ,``        ``// the loop is set  till there Now the pattern being``        ``// the index of the pattern_mask 1L means the long``        ``// integer is shifted to left by i times The result``        ``// of that is now being complemented the result of``        ``// the above is now being used as an and operator We``        ``// and the pattern_mask and the result of it``      ` `        ``for` `(``int` `i = ``0``; i < len; ++i)``            ``pattern_mask[pattern[i]] &= ~(1L << i);` `      ` `        ``// Now the loop is made to run until the text length``        ``// Now what we do this the R array is used``        ``// as an Or function with pattern_mask at index of``        ``// text of i` `        ``for` `(``int` `i = ``0``; i < text.length; ++i) {` `            ``R |= pattern_mask];` `            ``// Now  result of the r after the above``            ``// operation``            ``// we shift it to left side by 1 time` `            ``R <<= ``1``;` `            ``// If the 1L long integer if shifted left of the``            ``// len And the result is used to and the result``            ``// and R array``            ``// If that result is equal to 0``            ``// We return the index value``            ``// Index=i-len+1``          ` `            ``if` `((R & (1L << len)) == ``0``)` `                ``return` `i - len + ``1``;``        ``}` `        ``// if the index is not matched``        ``// then we return it as -1``        ``// stating no match found.``      ` `        ``return` `-``1``;``    ``}``}`

Output

```Bitap Algorithm!

Pattern found at index:
0```

My Personal Notes arrow_drop_up