Paintfuck.java

Paintfuck.java

import java.util.Arrays;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Paintfuck {

    public static String interpreter(String code, int iterations, int width, int height) {
        System.out.println(code);
        System.out.println(iterations);
        System.out.printf("%s %s%n", width, height);
        boolean[][] grid = IntStream.range(0, height)
                .mapToObj(y -> IntStream.range(0, width)
                        .mapToObj(x -> false)
                        .toArray(Boolean[]::new))
                .map(Paintfuck::toPrimitiveArray)
                .toArray(boolean[][]::new);

        code = code.replaceAll("[^nesw*\\[\\]]", "");

        Point pointer = new Point(0, 0);
        int codePointer = 0;
        for (int i = 0; i < iterations && codePointer < code.length(); i++) {
            char command = code.charAt(codePointer);
            if (MoveCommand.isMoveCommand(command)) {
                pointer = MoveCommand.findBy(command).getNextPointer(grid, pointer);
            } else if (command == '*') {
                grid[pointer.y][pointer.x] = !grid[pointer.y][pointer.x];
            } else if (command == '[' && !grid[pointer.y][pointer.x]) {
                codePointer = findMatchingClosingBracketIndex(codePointer, code);
            } else if (command == ']' && grid[pointer.y][pointer.x]) {
                codePointer = findMatchingOpeningBracketIndex(codePointer, code);
            }
            codePointer++;
        }

        return Arrays.stream(grid)
                .map(b -> IntStream.range(0, b.length).mapToObj(i -> b[i]))
                .map(s -> s.map(b -> b ? "1" : "0"))
                .map(s -> s.collect(Collectors.joining()))
                .collect(Collectors.joining("\r\n"));
    }

    private static boolean[] toPrimitiveArray(Boolean[] arr) {
        boolean[] primitiveArr = new boolean[arr.length];
        for (int i = 0; i < arr.length; i++) {
            primitiveArr[i] = arr[i];
        }
        return primitiveArr;
    }

    private static int findMatchingClosingBracketIndex(int startingIndex, String code) {
        int openedBrackets = 0;

        int i = startingIndex;
        do {
            char c = code.charAt(i++);
            if (c == '[') {
                openedBrackets++;
            }
            if (c == ']') {
                openedBrackets--;
            }
        } while (openedBrackets != 0);

        return i - 1;
    }

    private static int findMatchingOpeningBracketIndex(int startingIndex, String code) {
        int closingBrackets = 0;

        int i = startingIndex;
        do {
            char c = code.charAt(i--);
            if (c == ']') {
                closingBrackets++;
            }
            if (c == '[') {
                closingBrackets--;
            }
        } while (closingBrackets != 0);

        return i + 1;
    }

    static class Point {
        final int x, y;

        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
    }

    enum MoveCommand {
        N(0, -1),
        E(1, 0),
        S(0, 1),
        W(-1, 0);

        final Point move;

        MoveCommand(int x, int y) {
            move = new Point(x, y);
        }

        Point getNextPointer(boolean[][] grid, Point pointer) {
            Point nextPointer = new Point(pointer.x + move.x, pointer.y + move.y);

            if (nextPointer.x < 0) {
                nextPointer = new Point(grid[0].length - 1, nextPointer.y);
            } else if (nextPointer.x >= grid[0].length) {
                nextPointer = new Point(0, nextPointer.y);
            }

            if (nextPointer.y < 0) {
                nextPointer = new Point(nextPointer.x, grid.length - 1);
            } else if (nextPointer.y >= grid.length) {
                nextPointer = new Point(nextPointer.x, 0);
            }

            return nextPointer;
        }

        static boolean isMoveCommand(char c) {
            return c == 'n' || c == 's' || c == 'e' || c == 'w';
        }

        static MoveCommand findBy(char c) {
            return Arrays.stream(values())
                    .filter(m -> m.name().toLowerCase().charAt(0) == c)
                    .findFirst()
                    .get();
        }
    }
}