Skip to content
Related Articles

Related Articles

Java Program to Implement Bitap Algorithm for String Matching
  • Difficulty Level : Expert
  • Last Updated : 15 Dec, 2020

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. 


Text: geeksforgeeks
Pattern: geeks
Pattern found at index: 0

Text: Youareawesome
Pattern: Youareamazing
No Match.


  • 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.







// Java Program to implement Bitap Algorithm.
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
        // arguements.
        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 fucntion 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.
                "\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 patttern_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 Intially all the values of Character
        // are put up inside the pattern mask array And
        // intially they are complemeted 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 baove 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 withh 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;



Bitap Algorithm!

Pattern found at index: 

Attention reader! Don’t stop learning now. Get hold of all the important Java Foundation and Collections concepts with the Fundamentals of Java and Java Collections Course at a student-friendly price and become industry ready.

My Personal Notes arrow_drop_up
Recommended Articles
Page :