Skip to content
Related Articles

Related Articles

BrainFuck Interpreter in Java
  • Last Updated : 24 Sep, 2017

Brainfuck consists of only eight simple commands and an instruction pointer. While it is fully Turing-complete, it is not intended for practical use, but to challenge and amuse programmers.
BrainFuck consists of 8 character commands only which makes its use very challenging even for simple tasks –

  • The > command increments the data pointer (to point to the next cell to the right).
  • The < command decrements the data pointer (to point to the next cell to the left).
  • The + command increments (increase by one) the byte at the data pointer.
  • The - command decrements (decrease by one) the byte at the data pointer.
  • The . command outputs the byte at the data pointer.
  • The , command accept one byte of input, storing its value in the byte at the data pointer.
  • [ – if the byte at the data pointer is zero, then instead of moving the instruction pointer forward to the next command, jump it forward to the command after the matching ] command.
  • ] – if the byte at the data pointer is nonzero, then instead of moving the instruction pointer forward to the next command, jump it back to the command after the matching [ command.
  • (Alternatively, the ] command may instead be translated as an unconditional jump to the corresponding [ command, or vice versa; programs will behave the same but will run more slowly, due to unnecessary double searching.)
  • [ and ] match as parentheses usually do: each [ matches exactly one ] and vice versa, the [ comes first, and there can be no unmatched [ or ] between the two.

Since BrainFuck consists of only these 8 commands, building an interpreter for BrainFuck is quite simple. In this article, we will build a simple program which takes a BrainFuck code as input and produces the desired output. We will simply accept the BrainFuck code as a String and produce the output by parsing the String and checking every character for its actual functionality. The memory is represented by an array of byte type simulating memory of max 65535 bits from 0 to 65534(65535 is the highest number which can be represented by an unsigned 16-bit binary number). The variable ptr refers to the current index of the memory array.

In this article, we won’t be discussing the details of writing programs in BrainFuck.For more details on writing BrainFuck programs, refer to the following links:

Examples:

Input : --[+++++++>-->+>+>+<<<->---.>--..>+.<<<.+>->>.+++[.<]
Output :  Hello World!

Input : ++++++++++[>+++++++>++++++++>+++<+++.>++..<+.
Output : GEEKS FOR GEEKS

Java Implementation of the BrainFuck Interpreter-






import java.util.*;
  
class BrainFuck
{
    private static Scanner ob = new Scanner(System.in);
    private static int ptr; // Data pinter
      
    // Max memory limit. It is the highest number which 
    // can be represented by an unsigned 16-bit binary
    // number. Many computer programming environments 
    // beside brainfuck may have predefined
    // constant values representing 65535.
    private static int length = 65535;
      
    // Array of byte type simulating memory of max 
    // 65535 bits from 0 to 65534.
    private static byte memory[] = new byte[length];
      
    // Interpreter function which accepts the code
    // a string parameter
    private static void interpret(String s)
    {
        int c = 0;
          
        // Parsing through each character of the code
        for (int i = 0; i < s.length(); i++)
        {
            // BrainFuck is a tiny language with only
            // eight instructions. In this loop we check  
            // and execute all those eight instructions
              
              
            // > moves the pointer to the right
            if (s.charAt(i) == '>')
            {
                if (ptr == length - 1)//If memory is full
                    ptr = 0;//pointer is returned to zero
                else
                    ptr ++;
            }
              
            // < moves the pointer to the left
            else if (s.charAt(i) == '<')
            {
                if (ptr == 0) // If the pointer reaches zero
  
                    // pointer is returned to rightmost memory
                    // position
                    ptr = length - 1;
                else
                    ptr --;
            }
              
            // + increments the value of the memory 
            // cell under the pointer
            else if (s.charAt(i) == '+')
                memory[ptr] ++;
  
            // - decrements the value of the memory cell 
            // under the pointer
            else if (s.charAt(i) == '-')
                memory[ptr] --;
  
            // . outputs the character signified by the
            // cell at the pointer
            else if (s.charAt(i) == '.')
                System.out.print((char)(memory[ptr]));
  
            // , inputs a character and store it in the
            // cell at the pointer
            else if (s.charAt(i) == ',')
                memory[ptr] = (byte)(ob.next().charAt(0));
  
            // [ jumps past the matching ] if the cell 
            // under the pointer is 0
            else if (s.charAt(i) == '[')
            {
                if (memory[ptr] == 0)
                {
                    i++;
                    while (c > 0 || s.charAt(i) != ']')
                    {
                        if (s.charAt(i) == '[')
                            c++;
                        else if (s.charAt(i) == ']')
                            c--;
                        i ++;
                    }
                }
            }
  
            // ] jumps back to the matching [ if the
            // cell under the pointer is nonzero
            else if (s.charAt(i) == ']')
            {
                if (memory[ptr] != 0)
                {
                    i --;
                    while (c > 0 || s.charAt(i) != '[')
                    {
                        if (s.charAt(i) == ']')
                            c ++;
                        else if (s.charAt(i) == '[')
                            c --;
                        i --;
                    }
                    i --;
                }
            }
        }
    }
  
    // Driver code
    public static void main(String args[])
    {
        System.out.println("Enter the code:");
        String code = ob.nextLine();
        System.out.println("Output:");
        interpret(code);
    }
}


Output 1:

Enter the code:
--[+++++++>-->+>+>+<<<->---.>--..>+.<<<.+>->>.+++[.<]
Output:
Hello World!

Output 2:

Enter the code:
++++++++++[>+++++++>++++++++>+++<+++.>++..<+.
Output:
GEEKS FOR GEEKS

This article is contributed by Soumik Rakshit. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.

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 :