Return to Revisions

Java 8 - 354 bytes

Golfed version:

import java.util.*;class C{static int i,j;public static void main(String[]z){boolean[]b=new boolean[256];List o=Arrays.asList("chew","swallow","vomit","complain","feedtodog","playwithfood");Runnable[]r={()->b[i]=!b[i],()->i++,()->i--,()->System.out.print(b[i]?1:0),()->j+=b[i]?1:0,()->j-=b[i]?3:0};for(;;){r[o.indexOf(z[j])].run();i=i<0|i>255?0:i;j++;}}}

Somewhat ungolfed version (whitespaces and comments added):

// Needed for java.util.List and java.util.Arrays.
import java.util.*;

class C {
    // Declared as static so they may be changed inside the lambdas without the compiler complaining about that.
    // i is the bit index and j is the instruction pointer.
    static int i, j;

    public static void main(String[] z) {
        // The array.
        boolean[] b = new boolean[256];

        // Declared as a list so we can use the indexOf method further down. Screw up the generics.
        List o = Arrays.asList("chew", "swallow", "vomit", "complain", "feedtodog", "playwithfood");

        // An array of lambdas.
        Runnable[] r = {
            () -> b[i] = !b[i], // chew
            () -> i++, // swallow
            () -> i--, // vomit
            () -> System.out.print(b[i] ? 1 : 0), // complain
            () -> j += b[i] ? 1 : 0, // feedtodog. It is 1 and 0 instead of 2 and 1 due to the j++ down there.
            () -> j -= b[i] ? 3 : 0 // playwithfood. It is -3 and 0 instead of -2 and +1 due to the j++ down there.
        };

        // This is the interpreter itself. Runs forever (or until an exception is raised).
        for (;;) {
            // Fetch an instruction and runs it. Throws an exception on unknown or mistyped instructions.
            r[o.indexOf(z[j])].run();

            // Resets the bit index if out of range.
            i = i < 0 | i > 255 ? 0 : i;

            // Next instruction. No special treatment for branching needed because the branching instructions already considers this.
            j++;
        }
    }
}

This is a quick and dirty version that I made. It could probably be somewhat shorter, but I done this in just a few minutes.

We surely should have testcases. I am not sure if there is some bug hiding out there.

Anyway I run it with that (input is given as command line arguments):

chew complain swallow chew complain swallow chew complain swallow complain

And here is the output:

1110
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 10
    at C.main(C.java:1)

The ArrayIndexOutOfBoundsException is the standard way to finish the program, it is not a bug!