This is the Robbers' thread. Cops' thread is here.


Boggle is a board game where the players have to find English words on a 4-by-4 board of random alphabets. Words can be constructed by selecting sequentially adjacent cells on the board. ("adjacent" means horizontally, vertically or diagonally adjacent.) Also, same cell can't be used more than once in a word.

The following is an example board:


On this board, BINGO, ORANGE and WEARS are valid words, but SURGE and RUSSIA are not:

  • SURGE : There's no adjacent pair on the board having RG.
  • RUSSIA : S cannot be used twice.

Modified Boggle is a modified version of Boggle, with the following rules:

  • The board size is m-by-n, where m and n can be any positive integer.
  • Each cell can contain any one byte between 0 and 255 inclusive.
  • A cell can be used more than once, but not twice in a row.

Using the example board above, in addition to BINGO, ORANGE and WEARS, LANGUAGE becomes a valid string (since G is used twice, but not twice in a row) but RUSSIA is still not (due to SS pair).

Here is another example using a code fragment. The string from itertools import*\n can be found on the following board, but not from itertoosl import* or from itertools import *:

f   i   ' ' s
r   t   m   l
e   o   o   p
\n  *   t   r

Note that you need two o's in order to match the oo sequence.

Robber's challenge

Pick a cop's submission which isn't yet cracked or marked safe. In the given language, find a full program that fits in the code board which outputs some string that fits in the output board. The program's length should be equal or less than given, and the output's should be equal or greater.

Scoring for robbers

Each successful crack counts as a score of 1. The user with the greatest score wins.

Robber example & formatting

# Japt, code 8 bytes, output 21 bytes, [Bubbler](link-to-cops-post)


    [Try it online!](link-to-tio)

    The output is `112624120720504040320`.

Modified Boggle verification script

All of the scripts below have an example input with it.

Script for character string(code/output) & boggle. This does not support multi-line string. The input format is

  • a single line of string (either code or output), followed by
  • the raw boggle board.

Script for character string with byte-value boggle. Use this if the target string is printable but has one or more newlines in it. The input format is

  • the number of lines for the string,
  • raw string (possibly multi-line), then
  • the boggle board as byte values.

Script for byte-value string & boggle. Use this if the target string contains one or more unprintable characters. The input format is

  • a single line of string (either code or output) as byte values, followed by
  • the boggle board as byte values.

4 Answers 4


JavaScript, code 1342 bytes, output 3 bytes, Scrooble


Try it online! and Verify the code boggle online!

Outgolfing by 101 bytes :)

The point is that we can avoid most of the parens by using brackets instead (at the cost of a few bytes), and we just need two pairs of parens to do the function call.

For example, ([]+true)[1] is equivalent to [[]+true][0][1], and !+[]+!+[]+[]+(!+[]+!+[]) (the code to generate "22") is equal to !+[]+!+[]+[!+[]+!+[]].

Since alert is not available in Node, the TIO link shows the generated function instead.

How it works

False = ![]                         // false
f = [[]+![]][+![]][+![]]            // 'f'
a = [[]+![]][+![]][+!+[]]           // 'a'
l = [[]+![]][+![]][!+[]+!+[]]       // 'l'
s = [[]+![]][+![]][!+[]+!+[]+!+[]]  // 's'
True = !![]                         // true
t = [[]+!![]][+![]][+![]]           // 't'
r = [[]+!![]][+![]][+!+[]]          // 'r'
u = [[]+!![]][+![]][!+[]+!+[]]      // 'u'
e = [[]+!![]][+![]][!+[]+!+[]+!+[]] // 'e'
Undefined = [][[]]                  // undefined
n = [[]+[][[]]][+![]][+!+[]]        // 'n'
i = [[]+[][[]]][+![]][!+[]+!+[]+!+[]+!+[]+!+[]]  // 'i'
fill = [][f+i+l+l]                  // Array.prototype.fill
c = [[]+fill][+![]][!+[]+!+[]+!+[]] // 'c'
o = [!![]+fill][+![]][+!+[]+[+![]]] // 'o'
open = [[][[]]+fill][+![]][!+[]+!+[]+[!+[]+!+[]]]  // '('
close = [[+![]]+![]+fill][+![]][!+[]+!+[]+[+![]]]  // ')'
func = fill[c+o+n+s+t+r+u+c+t+o+r]  // Function
code = func(a+l+e+r+t+open+[+[![]]]+close)  // 'Function("alert("+NaN+")")'

Have some fun comparing this to the original JSFxxk conversion table.

  • \$\begingroup\$ Nice! I was really hoping the weird parentheses would keep it alive for a bit longer. Three improvements I can see right away in yours over mine are [][[]] instead of [][+[]] for undefined and ![]+!+[]+.. instead of +!+[]+!+[]+.. for the numbers, and coercing strings to integers, especially for c and o. \$\endgroup\$ Oct 5, 2018 at 11:40

JavaScript (Node.js), 27 bytes, output = 2 bytes, Shieru Asakoto


Try it online! or Verify the code boggle

  • \$\begingroup\$ Wow that's awesome. I thought I've blocked out most of routes to go. \$\endgroup\$ Oct 5, 2018 at 13:36

Javascript (REPL), code 1443 bytes, output 3 bytes, https://codegolf.stackexchange.com/a/173395


Outputs NaN. There are quite a lot of ways to pad once you know how NaN can represent in JSFuck.

  • \$\begingroup\$ @Scrooble lol That'll be some job to expand it to full program \$\endgroup\$ Oct 5, 2018 at 5:29

JavaScript (Node.js), 53 bytes, output = 41 bytes, Shieru Asakoto


Try it online! or Verify the code boggle or Verify the output boggle

This computes:


Which can also be done in 49 bytes:


Try it online! or Verify the code boggle


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.