BrainFuck Interpreter in Java - GeeksforGeeks

23 Jul, 2021
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:  
BrainFuck (WikiPedia)
Printing “GEEKS FOR GEEKS” In Brainfuck
Examples:  
Input : 
Output :  Hello World!

Input : 
Output : GEEKS FOR GEEKS
Java Implementation of the BrainFuck Interpreter- 
Java
import java.util.*; class BrainFuck{    private static Scanner ob = new Scanner(System.in);    private static int ptr; // Data pointer         // 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 write.geeksforgeeks.org or mail your article to review-team@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. 
varshagumber28
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Stream In Java
Different ways of Reading a text file in Java
Constructors in Java
Exceptions in Java
Functional Interfaces in Java
Generics in Java
Comparator Interface in Java with Examples
HashMap get() Method in Java
Introduction to Java
Difference between Abstract Class and Interface in Java