//This is my first Java code(hence the unnecessary lines of code), so there may be a couple errors with compiling Brainf*ck code. You can comment the error in the comments, feel free to also include a solution as I might not have the time to fix it. //It will ask for input, this is because there is a function in Brainf*ck that asks for input, and Java runs line-by-line(even through functions); in this case, just ignore it. /* Okay, a small Brainf*ck tutorial! I'm not the greatest teacher, but I'll try to explain it the way I see it. It's a programming language designed by Urban Müller, and it's purpose is directly stated in it's name. First, imagine a array containing a certain amount of zeroes. Typically, there are 30, 000, and this compiler uses 500(though you can increase it). We'll use 5 in this example: [0, 0, 0, 0, 0] //imagine this as our memory We start at index 0, or the first 0. We can move left or right in our array with > and <. Let's say: > //moves our index one to the right Result: [0, 0, 0, 0, 0] _ position And if we want to move back to index 0, we can use: < //moves our index one to the left Result: [0, 0, 0, 0, 0] _ We can also add one or subtract one from each of our values at our indexes, which we'll start calling cells. So, leading off pur previous example: ++ //adds 2 to cell 1(index 0) Result: [2, 0, 0, 0, 0] _ - //subtracts 1 from cell 1 Result: [1, 0, 0, 0, 0] _ Onto input, and output. Input is represented by ,. What Brainf*ck does with the input is it converts it to a ASCII integer value to store in the current cell. So, if we are at cell 1, and the user inputs "a", 97 will be stored in cell 1. When we go to print it, we use .. This prints either the ASCII value of the integer being stored in the current cell, or just the integer value if it's not from 0-128. Let's look at a example: ,.,. //ask for input twice and print the output Looking at the cells, something like this would happen: Input: a [97, 0, 0, 0, 0] //the ASCII integer value of "a" is 97 Output: a Input: b [98, 0, 0, 0, 0] //still on the same cell, but the value has been changed Output: b Finally, the hardest thing for me to grasp: loops. These are represented by []. These run while the current cell value is not equal to 0. For example: ++[-] //yup, looks confusing; what happens is that we add 2 to the current cell value, and subtract from it until it reaches 0 Result: [0, 0, 0, 0, 0] //and still just zeroes Okay, now that we have the basics(yes, there's only 8 characters that are used in Brainf*ck, we can write a basic "Hello World!" program, which looks like this: >+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-] >++++++++[<++++>-] <.>+++++++++++[<++++++++>-]<-.--------.+++ .------.--------.[-]>++++++++[<++++>- ]<+.[-]++++++++++. It looks complicated, but let's try breaking down a small portion of it to understand it better. First part: >+++++++++[<++++++++>-]<. Here, we start by moving to the second cell, and adding 9 to it(>+++++++++). This allows us to essentially create a for loop, where we go back a cell(to cell 1), add 8 to it, and then go back to cell 2, subtracting 1 from it. This is only the first iteration of the loop, though. The loop runs a total of nine times because when the loop ends, the current cell will be 2, which still is at 8. Take a look at the iterations: Iteration One: [8, 8, 0, 0, 0] //9 is added to cell 2, 8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Two: [16, 7, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Three: [24, 6, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Four: [32, 5, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Five: [40, 4, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Six: [48, 3, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Seven: [56, 2, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Eight: [64, 1, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2 Iteration Nine: [72, 0, 0, 0, 0] //8 is added to cell 1, and 1 is subtracted from cell 2, making cell 2's value 0 and essentially canceling the loop So repetitive, and complicated. But now that we have 72, let's take a look at <.. This basically means we go back to cell 1, and print it's ASCII value, which, you might have guessed, is "H", or the beginning of "Hello World!". The rest of the letters are printed in a extremely similar fashion. If you want a extra challenge to really get the hang of this, try creating a Brainf*ck program to multiply, say, 10 by 25. The solution is below in case you don't get the hang of it. As an extra hint, the explanation above-well, just take a closer look at it. */ import java.util.*; public class CustomList { ArrayList cells = new ArrayList(); ArrayList valid_commands = new ArrayList(); int current_pos = 0; Scanner input = new Scanner(System.in); void close_input() { input.close(); } void create_list(int cell_num) { for (int num = 0; num < cell_num; num++) { cells.add(0); //initialize array with a certain amount of zeroes } valid_commands.add(","); //input valid_commands.add("."); //print valid_commands.add(">"); //shift to right cell valid_commands.add("<"); //shift to left cell valid_commands.add("+"); //add one to value in cell valid_commands.add("-"); //subtract one from value in cell valid_commands.add("["); //open while loops valid_commands.add("]"); //close while loops } void clear_cells() //reset the values in the cells to 0 { for (var cell = 0; cell < cells.size(); cell++) { cells.set(cell, 0); } } void parse(String code) { String func; for (int character = 0; character < code.length(); character++) //go through each character in Brainf*ck code { func = Character.toString(code.charAt(character)); if (valid_commands.contains(func)) { switch (func) { case ",": ask(); break; case ".": print_cell(); break; case ">": shift_right(); break; case "<": shift_left(); break; case "+": add(); break; case "-": subtract(); break; case "[": int skip = open_loop(code, character); character = skip; //skip beyond while loop once it has run break; } } else { continue; } } } void ask() //ask for input { String ask_input = input.nextLine(); if (ask_input.length() > 1) { System.out.println("Warning: Brainf*ck cells can only contain one character."); } else { int ascii = ask_input.charAt(0); //automatically converts input to ASCII if possible cells.set(current_pos, ascii); } } void print_cell() //print ASCII value of cell if possible { int ascii_int = cells.get(current_pos); if (ascii_int <= 127) { char ascii_value = (char)ascii_int; System.out.print(ascii_value); } else { System.out.print(ascii_int); } } void shift_right() //shift current position one cell to the right { if (current_pos == cells.size()) //which is not possible if you're already to the very right; I actually don't know if there is wraparound in the actual language { System.out.println("Warning: You attempted to shift right at the maximum cell position."); } else { current_pos += 1; } } void shift_left() //shift current position one cell to the left { if (current_pos == 0) //which is not possible if you're already to the very left; I actually don't know if there is wraparound in the actual language { System.out.println("Warning: You attempted to shift left at the minimum cell position."); } else { current_pos -= 1; } } void add() //add one to the current cell value { cells.set(current_pos, cells.get(current_pos) + 1); } void subtract() //subtract one from the current cell value { if (cells.get(current_pos) != 0) //subtract only if current cell value is greater than zero { cells.set(current_pos, cells.get(current_pos) - 1); } } int open_loop(String code, int character) { boolean loop_closed = false; int closing_loop; String sub_string = ""; for (closing_loop = character + 1; closing_loop < code.length(); closing_loop++) { if (code.charAt(closing_loop) == ']') //make sure loop closes { loop_closed = true; break; } else { sub_string += code.charAt(closing_loop); //what to do inside loop should be added to sub_string } } if (loop_closed) { run_loop(sub_string); //run Brainf*ck code inside loop if loop closes } else { System.out.println("Warning: You did not close a loop; the loop will be skipped."); } return closing_loop; } void run_loop(String code) { //booleans to check if code has reached very beginning or end of cells, as well as if current cell's value is zero yet boolean max_shifted = false; boolean min_shifted = false; boolean zero_value = false; while (!(max_shifted) && !(min_shifted) && !(zero_value)) { for (int part = 0; part < code.length(); part++) //go through sub-code provided { switch (code.charAt(part)) { case ',': ask(); break; case '.': print_cell(); break; case '>': if (!(max_shifted)) { if (current_pos + 1 == cells.size()) { max_shifted = true; } else { shift_right(); } } if (current_pos == cells.size()) { max_shifted = true; } break; case '<': if (!(min_shifted)) { shift_left(); } if (current_pos == 0) { min_shifted = true; } break; case '+': add(); break; case '-': if (!(zero_value)) { subtract(); } if (cells.get(current_pos) == 0) { zero_value = true; } break; case '[': int skip = open_loop(code, part); part = skip; break; } } } if (!(zero_value)) //if current cell's value is not zero, loop will continuously run until it is zero { run_loop(code); } } } public class Program { public static void answer_challenge(CustomList program) { System.out.println("\nThis is the answer to the challenge:\n++++++++++[>+++++++++++++++++++++++++<-]>.\nWhich will return: "); program.parse("++++++++++[>+++++++++++++++++++++++++<-]>."); System.out.println("\nThis basically adds 10 to the first cell. Then, it runs a loop. During each iteration of the loop, we move to the second cell and add 25 to it, move back to the first cell, and subtract one from it. This runs ten times as the loop ends on the first cell, which has a value of ten."); } public static void main(String[] args) { CustomList program = new CustomList(); //our collection of cells program.create_list(500); //five hundred cells as an example; normally, there are 30, 000 program.parse(">+++++++++[<++++++++>-]<.>+++++++[<++++>-]<+.+++++++..+++.[-]>++++++++[<++++>-]<.>+++++++++++[<++++++++>-]<-.--------.+++.------.--------.[-]>++++++++[<++++>- ]<+.[-]++++++++++."); //Brainf*ck program is run here(this is a "Hello World!" program) program.clear_cells(); //clear the values in the cells so we can run more Brainf*ck programs with the same collection of cells //answer_challenge(program); program.close_input(); //close scanner } }

Brainf*ck Compiler v 0.1