What is the Sandbox?

This "Sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to the main page. This is useful because writing a clear and fully specified challenge on the first try can be difficult. There is a much better chance of your challenge being well received if you post it in the Sandbox first.

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]


3037 Answers 3037

6 7
9 10

Does the naïve fill suffice?

A bot is positioned in a rectangular grid. By preference it will paint in a west direction, but if it cannot it will paint in a south, east or if all else fails north direction. Sometimes this can lead it to fill the grid, but other times it gets stuck. The following examples show how the path (indicated by ascending digits) of the bot on a given grid varies depending on its starting position:


The bot is always able to fill a 1×1 grid, since simply by existing it has already painted the grid.

14    21    43    34
23    34    12    21

The bot is always able to fill a 2×2 grid. As a consequence of its painting direction preferences it normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise.

16    21    65    ..    56    65    165    216    321    654     345    456
25    36    14    21    43    34    234    345    456    123     216    321
34    45    23    34    12    21

The bot usually fills a 2×3 grid, except when it starts in the middle right square. On the other hand, it always fills a 3×2 grid; its painting direction preferences cause it to paint clockwise if it starts in the bottom middle or bottom right cell, otherwise anticlockwise.

189    21.    321    87.    987    ...    987    ...    987
276    387    498    165    216    321    236    345    456
345    456    567    234    345    456    145    216    321

The bot is able to fill a 3×3 grid when it starts in one of the even squares. It's mathematically impossible for the bot to fill it when it starts in an odd square, but I have included these positions for completeness.

Your task is to solve the of whether the bot is able to fill a given grid from a given starting point. You can assume that the grid size is a positive integer and that the starting point lies within the grid. You can take the grid size and starting point in any consistent order, as separate inputs, a pair of pairs or a list of 4 elements, or any other reasonable input format. The starting point can be 0-indexed or 1-indexed. You can use any two consistent outputs, or you can output using any values that your language considers truthy or falsy, but not both. Please include your input and output format in your answer.

The directions west, south, east or north correspond to decrementing the x-coordinate, incrementing the y-coordinate, incrementing the x-coordinate and decrementing the y-coordinate respectively.

This is , so the shortest program or function that breaks no standard loopholes wins!

Test cases (0-indexed, width height x y):

4 4 0 0 -> True
4 4 1 1 -> False
4 4 2 2 -> True
4 4 3 3 -> True
4 7 1 3 -> False
  • 1
    \$\begingroup\$ What's the "naive fill" algorithm exactly? \$\endgroup\$ – user202729 Jul 12 '20 at 11:24
  • 1
    \$\begingroup\$ Comment: it's hard for me to figure out that each "column" (separated by space) represents a x*y board. Consider clarifying that. \$\endgroup\$ – user202729 Jul 12 '20 at 11:25
  • \$\begingroup\$ @user202729 The very first two sentences are supposed to describe it, just move in the first available preferred direction until you can't move any more and paint as you go. \$\endgroup\$ – Neil Jul 12 '20 at 14:11
  • \$\begingroup\$ Some comments: (1) You don't seem to define that "naïve fill" is. (2) It took me a while to undersdtand the meaning of the numbers 14, 21` etc mean the 2nd example, and similarly in others. After a while I realized that each "code section" contains several examples stacked horizontally. You should make thast more obvious (maybe increasing horizontal space, or explaining it in the text) \$\endgroup\$ – Luis Mendo Jul 12 '20 at 15:47
  • \$\begingroup\$ (3) "It normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise": what does "normally" mean here? How do we know/choose the direction the robot follows? Or maybe this is the definition of "naïve fill"? (4) Why can't the robot fill the 2×3 case when it starts in the middle right square? That is, why doesn't start by moving up instead of left? (5) In general, but I find it all quite confusing... maybe it's me, but consider explaining the challenge with more detail \$\endgroup\$ – Luis Mendo Jul 12 '20 at 15:47
  • \$\begingroup\$ @LuisMendo (1) The bot paints as it goes. It prefers to go west, but when it can't go west tries south, then east, then north. That's all there is to it. (2) I've added some more text and spacing. (3) "normally" means "most of the time it ends up doing this". (4) Because its first preferred direction is west so it ends up painting itself into a corner. \$\endgroup\$ – Neil Jul 12 '20 at 16:53
  • \$\begingroup\$ (1) It prefers to go west, but when it can't go west tries south, then east, then north. That phrasing makes it much totally clear. (Now I see that's probably what you meant with by preference) Include it in the text? (3) I still find the word normally confusing there, as if that were an additional degree of freedom. Also, I see now that except when it starts in the bottom right corner when it traverses clockwise is a consequence of (1). I suggest you explicitly state something like "As a consequence of the rule for direction choice, ..." \$\endgroup\$ – Luis Mendo Jul 12 '20 at 17:03
  • \$\begingroup\$ @LuisMendo Fair enough; I've tweaked the text again now. \$\endgroup\$ – Neil Jul 12 '20 at 17:35
  • \$\begingroup\$ I really like this challenge, but I wonder whether the title could be a little more descriptive/catchy - perhaps 'Can the bot fill the grid?' or similar? \$\endgroup\$ – Dingus Jul 14 '20 at 15:00
  • \$\begingroup\$ @Dingus "Can the naïve bot fill the grid?" counts as similar, right? \$\endgroup\$ – Neil Jul 14 '20 at 17:23
  • \$\begingroup\$ Ooh, that's even better. Immediately makes me curious to find out what the naïve bot is. \$\endgroup\$ – Dingus Jul 15 '20 at 0:35

Evaluate left-or-right

Left-or-right is a very simple language I made up. Its expression are made of arrows < (left), > (right), and parentheses. The goal is to evaluate an expression to either < or >.

An expression A<B picks the left item A, while picks the right one B. Think of < and > as arrows pointing to the item we want, not as comparison operators.

Take, for example, ><>. The operator in the middle is <, and confusingly, the items on each side A and B are also arrows. Since the operator tells us to take the left one A, which is >. So, ><> equals >.

Expressions also nest. We can replace the expression with its value. So, for example, (><>)<< equals ><< equals >. And, >(><>)< equals >>< equals <. For another example, (><>)(<<<)(>><) equals ><< equals >.

In the input, you'll be given a well-formed expression consisting of either a trio of arrows like ><> or the result of repeatedly replacing some arrow by a trio of arrows in parens like ><(><>) . You can assume the input won't already be a lone arrow. You may alternately accept the whole inputs encased in parens like (><>) or (<(><>)>).

The input is given as a flat string of using symbols <>(). You may not take it an a pre-parsed form like a tree.

TODO: Test cases

  • \$\begingroup\$ +1 for ><> (15chars) \$\endgroup\$ – null Jul 25 '20 at 4:02

A Spherical Die


I have a spherical die, but it's a cheap one so it doesn't work properly. When I roll it, it doesn't always land directly on a "face" marking, but instead can result in an ambiguous result ("is that a 6, a 4 or a 2?")


Assume the die is a perfect, evenly-weighted Unit Sphere (i.e. all points on the surface are radius 1cm from the center) , such that a "roll" can result in any point on the sphere being the uppermost point (the "roll value").

Assume that, if the die is placed or rolled such that 1 is at the "north pole", the conventions of a normal die will follow, i.e:

  • 6 will be at the "south pole"
  • 4, 5, 3, 2 will be on the "equator", clockwise in that order, equidistant around the sphere.

So, before it's rolled, the die looks like this:

image of die

The Challenge

Given a simulated roll of the die (i.e. coordinates representing the top of the die after it's rolled) with the conditions above, identify the closest value (1-6) to that point (i.e. what the roll value should resolve to).


A co-ordinate on the sphere.

There are a few co-ordinate systems used for spheres, the two I'm familiar with (and so will provide examples in) are as follows:

  • P(1, φ, Θ) where φ is the "azimuth angle" (0..360), Θ is the "polar angle" (0..180)

  • P(x,y,z) where \$x^2+y^2+z^2=1\$

(note: the conversion between the two is: x = cos(φ)·sin(Θ); y = sin(φ)·sin(Θ); z = cos(Θ))

for clarity:

  • roll "1" is at P(1,n,0)
  • roll "2" is at P(1,270,90)
  • roll "3" is at P(1,180,90)
  • roll "4" is at P(1,0,90)
  • roll "5" is at P(1,90,90)
  • roll "6" is at P(1,n,180)


The nearest value (1-6) to that point. If the point is equidistant to two or more points, output any one of them.

Usual exclusions etc. apply.

  • \$\begingroup\$ Does anyone know the maths for this? Feel free to edit it in! \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 9:40
  • \$\begingroup\$ I'm not sure I understand: You want us to generate a random point on a sphere and output the face of the die it corresponds to? \$\endgroup\$ – flawr Nov 22 '19 at 9:57
  • \$\begingroup\$ yeah, so generate a random point on the sphere, then find the nearest "face" - i.e. the nearest of the 6 points (top, bottom, 4 points on opposite sides around middle) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 11:11
  • \$\begingroup\$ This will be exactly equivalent to a uniform distribution over 6 values, just based on the symmetry of the situation. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 12:33
  • \$\begingroup\$ @AlienAtSystem yes, all outcomes are equally likely; but the challenge is determining which number any given point on the face of the sphere is closest to \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:04
  • 4
    \$\begingroup\$ That's not the challenge as posted. Right now, it's "Takes no input, returns the number the (internally generated) random point is closest to" which is, under the consensus of no unobservable requirements simply equal to "Takes no input, returns uniform random value from 1-6". If you want the challenge to be "Input is point on sphere, output is number it's closest to", then write that. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:09
  • \$\begingroup\$ @AlienAtSystem I've edited to try and make it clearer what I'm looking for. Is it clearer now? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:15
  • \$\begingroup\$ It's clearer that my point still stands. Look, "Make Voronoi cells on sphere" and "Generate uniformly random points on sphere" are both good challenges. But when put together like that, they annihilate each other and give you an extremely quick shortcut right from Input (None) to output (a die roll) that doesn't require calculation of either part. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:21
  • 2
    \$\begingroup\$ @AlienAtSystem thanks for the feedback, I'd never heard of a Voronoi cell before. What I'm asking, then, is "generate a random point on a sphere and say which Voronoi cell that point is in". Can you explain why that doesn't work? Note that I'm asking for both the point and the cell to be output, not just the cell - otherwise I agree, given the "no unobservable requirements" rule it would be possible to just generate a random number and pretend you'd done it properly (although that would be against the spirit of it) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:24
  • \$\begingroup\$ Would it be better for the point on the sphere to be the input, then? \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:27
  • \$\begingroup\$ If you want the challenge to be about finding the points it's closest to, yes. \$\endgroup\$ – AlienAtSystem Nov 22 '19 at 13:31
  • \$\begingroup\$ I want it to be a good challenge on this theme, whatever that would look like :) \$\endgroup\$ – simonalexander2005 Nov 22 '19 at 13:33
  • \$\begingroup\$ Although I don't think the current challenge is bad, it's usually best to not have multiple challenges into one nor multiple outputs (since some languages aren't able to output more than once very easily). The two challenges are: 1. Generate a random coordinate on a sphere (in whichever coordinate system you want); 2. Given a (random) coordinate on a sphere, output the dice-value closest to it. No. 1 already is a challenge, so I agree it might be better to rewrite it to challenge No. 2. I do like the general idea though, so +1 from me. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:36
  • \$\begingroup\$ It would also need some info about the size of the sphere, and what to do when the coordinate is exactly in the center between two or three poles. \$\endgroup\$ – Kevin Cruijssen Nov 22 '19 at 14:39
  • 1
    \$\begingroup\$ Note that the actual implementation is very simple, as explained in chat. \$\endgroup\$ – user202729 Jul 15 '20 at 2:43

Note: this challenge is a work-in-progress, so suggestions would be appreciated

Questions for meta:

  • How can I prevent people from just using SHA or MD5 one-way compression?
  • are these language restrictions fair?
  • is this scoring system fair?
  • are there any obvious cheap answers?
  • what other tags should be added?
  • what should the challenge title be?
  • will these restrictions adequately prevent people trying to cheat their way through?
  • should a limit be put on a password length? Should I limit passwords to ASCII printable characters?

The challenge

Your challenge is to first choose a "password" (please do not use your actual password). Then, you will create a program which will output a truthy value if and only if this password is given as input, falsy otherwise. Your goal will be to make it so others are unable to reverse-engineer this password (and you will keep this password secret for now).


The scoring for this challenge is somewhat different than regular . During the first two weeks from when an answer is posted, other users will have the opportunity to try to crack your password by reverse-engineering your code. If anyone gets your password correct during this two week period, your answer will be marked as cracked. If two weeks pass without users finding the password, your answer can be marked as safe once you share the password (again, please do not use your actual password, you should make up a new one that you don't use anywhere).

Note that you may use any tools at your disposal (online tools, brute-force attacks, modified code, etc) to extract someone else's password from their code.

Of all the safe answers, the one with the shortest source code (i.e. ) wins!


To make things fair for everyone, you may only use languages that appear on TIO, or languages that have well-written documentation and are used somewhat widely. You must also provide a link to try your code online that anyone can access (as such, you may not use languages behind paywalls like MATLAB but Octave is still on the table because it's free).

Even if you don't want to post an answer, feel free to try to crack any of the existing answer's passwords! If you get a password, you can simply leave a comment on that answer and that answer will be cracked.


If you edit the code in your answer, the two week period will reset! You may edit any explanations in your answer freely (I will verify that any answers marked safe did not cheat).

tags: code-golf

  • \$\begingroup\$ Example answer \$\endgroup\$ – Daniel H. Aug 19 '20 at 12:38
  • \$\begingroup\$ Surely any cryptographic hash function (which are implemented in many languages) will make it easy to generate an impossible-to-crack answer? For instance, in R I can write test=scan(,'');if(digest::digest(test,"md5")=="b6778692586dc649267723ccc3356fad")TRUE else FALSE and I'll be pretty confident that nobody will crack my password... \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 15:10
  • 1
    \$\begingroup\$ That is a good point. It seems like this challenge is similar to just writing a hash function. You might want to add other ideas to make the challenge more interesting \$\endgroup\$ – thesilican Aug 19 '20 at 16:06
  • \$\begingroup\$ That's what I was about to write, any hash function with a hidden default salt depending on the language, or anything like that, could be hiding the password easily enough. \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:06
  • \$\begingroup\$ @DominicvanEssen is this an actual MD5 hash? I was unable to reverse it (note that a lot of MD5 hashes can be reversed with online tools like this). Note that for this challenge people would be allowed any and all tools at their disposal to crack passwords. This means people are very much allowed to reverse-engineer code in any ways they please \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:06
  • \$\begingroup\$ Answering in many esolangs could hide the password easily enough, too. If I answer in Lenguage, Unary, Mariolang,... \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:07
  • \$\begingroup\$ @V.Courtois this is true, but the point is not to read the password in the source code. The point of the challenge would be to reverse-engineer their code to crack a password (so documentation and online tools are all fair game). Also, Unary will likely be an invalid language because people must be able to actually run the program online (and Unary programs are usually way too big to run online) \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:08
  • \$\begingroup\$ Now that I think about it, any type of loop could hide the password easily enough, too. But even with what I said before and what I'm saying now, I think this challenge has to exist (if not existing already), because having many valid answers is not a problem (not to me, at least). \$\endgroup\$ – V. Courtois Aug 19 '20 at 16:09
  • \$\begingroup\$ @DominicvanEssen also, even if nobody can reverse your password, that's still fine - the winner of this challenge is whoever has the shortest code out of all the uncracked passwords. In other words, this is still a codegolf challenge, but answers can be disqualified if anyone finds the password. So, if you want to win but you don't have the shortest code, you simply have to crack other people's passwords! \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:15
  • \$\begingroup\$ @DanielH. Yes, my example was an actual MD5 hash (the password was mypassword). You're right that some hash functions can be reversed, but there are many cryptographically-secure ones for which this is difficult. \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:17
  • \$\begingroup\$ @DominicvanEssen I'm unfamiliar with MD5 hashes, but when I converted mypassword to an MD5 hash using three different online tools I got 34819d7beeabb9260a5c854bc85b3e44 every time instead of the hash in your answer. Could you please provide a TIO link for the R code (when I copy-pasted it into TIO it didn't work for me and I'm unfamiliar with R)? I'd like to try experimenting with MD5 \$\endgroup\$ – Daniel H. Aug 19 '20 at 16:22
  • \$\begingroup\$ I'm afraid that the R 'digest' library is not installed on TIO (making a link was the first thing I tried). \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:25
  • \$\begingroup\$ But, after some research, it turns-out that R adds some (consistent) extra characters to the string by default before applying MD5. This behaviour can be switched off, at which point mypassword indeed hashes to 34819d7beeabb9260a5c854bc85b3e44. \$\endgroup\$ – Dominic van Essen Aug 19 '20 at 16:46
  • \$\begingroup\$ how many letters are the passowrds capped at? Are unprintables allowed? \$\endgroup\$ – Razetime Aug 20 '20 at 3:30
  • \$\begingroup\$ @Razetime I might add a restriction of 16 characters, ASCII printables only. I will have to try to balance this cap though - if it's too short, passwords can easily be brute-forced. If it's too long, everyone will just use one-way compression and passwords will never be cracked \$\endgroup\$ – Daniel H. Aug 20 '20 at 11:24

Stroke Count of a Chinese Numeral Posted

  • \$\begingroup\$ Related (not dupe). Stroke count is actually good idea because it avoids the need to hardcode Chinese characters. The description looks clear enough to me. \$\endgroup\$ – Bubbler Aug 5 '20 at 3:11
  • \$\begingroup\$ Might be useful: tio.run/… \$\endgroup\$ – user202729 Aug 5 '20 at 11:45
  • \$\begingroup\$ (to read the test cases) \$\endgroup\$ – user202729 Aug 5 '20 at 11:45
  • \$\begingroup\$ Has it been posted to main? I can't seem to find it. \$\endgroup\$ – V. Courtois Aug 21 '20 at 10:02
  • 1
    \$\begingroup\$ @V.Courtois posted. \$\endgroup\$ – att Aug 25 '20 at 4:54

All work and no play but it gets thinner every time

Your objective is to output the unique string with the following properties:

  • Each paragraph consists entirely of repetitions of the sentence All work and no play makes Jack a dull boy.
  • The first paragraph is a single line with exactly one repetition of the sentence.
  • Each line of each subsequent paragraph is shorter than the longest line of the previous paragraph.
  • Each line contains as many words of the sentence as possible without exceeding the length limit, and no trailing whitespace.
  • Paragraph ends when its next line would be identical of some previous line of the same paragraph, possibly terminating the last sentence early.
  • The last paragraph has the same width as the longest word in the sentence (5).
  • There's a pair of line ends between each pair of paragraphs, a single line end after the last paragraph, and no line end before the first paragraph.

The string produced by these rules has: 5025 bytes when using Windows line ends (CR LF) or 4796 bytes using Linux line ends (LF); 229 line ends; 103 full repetitions of the sentence and 11 partial repetitions. It can be compressed into a 249-byte deflate stream (bubblegum code). The full string is included below for reference.

All work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes Jack
a dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes Jack
a dull boy. All work and no play

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a

All work and no play makes Jack
a dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play

All work and no play makes Jack
a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes

All work and no play
makes Jack a dull boy.

All work and no play
makes Jack a dull
boy. All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy. All
work and no play

All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy.

All work and no
play makes Jack a
dull boy. All
work and no play
makes Jack a dull
boy. All work and
no play makes
Jack a dull boy.

All work and no
play makes Jack
a dull boy. All
work and no play
makes Jack a
dull boy. All

All work and no
play makes Jack
a dull boy. All
work and no

All work and
no play makes
Jack a dull
boy. All work
and no play
makes Jack a
dull boy. All
work and no
play makes

All work and
no play
makes Jack a
dull boy.

All work
and no play
makes Jack
a dull boy.

All work
and no
play makes
Jack a
dull boy.

All work
and no
Jack a
dull boy.

All work
and no
Jack a
boy. All
work and
no play

and no
Jack a

  • \$\begingroup\$ So a sentences can span one or more lines? Was thinking the sentences got shorter until you said there's 103 full repetitions. No clear explanation on what exactly paragraphs, paragraph widths, sentences, lines, and line ends are. \$\endgroup\$ – Noodle9 Sep 28 '20 at 15:05
  • \$\begingroup\$ @Noodle9 I've added some of the reference output; would the reference suffice to explain those? \$\endgroup\$ – John Dvorak Sep 28 '20 at 15:30
  • \$\begingroup\$ Can you simply add the whole output? (I still don't understand it) \$\endgroup\$ – the default. Sep 28 '20 at 15:37
  • \$\begingroup\$ @thedefault. added. I didn't want to clutter the sandbox. \$\endgroup\$ – John Dvorak Sep 28 '20 at 15:39
  • \$\begingroup\$ Alternative name: Write a novel for Jack Torrance \$\endgroup\$ – Razetime Sep 28 '20 at 15:51
  • \$\begingroup\$ Better to say what you mean by these terms. Maybe a template of the output where lines are, say, seperared by newline characters. Sentences are substring of "..." containing only whole words and ended by a period. Paragraphs are seperated by two newlines. Or whatever it actually is. \$\endgroup\$ – Noodle9 Sep 28 '20 at 17:07

Make a quine that shrinks and grows

Write a program that outputs another program that is:

  • Larger in bytes than the original
  • Outputs a program that is smaller than itself that also obeys these rules and is larger than the original program

Basically the output should alternate between larger than the previous program and smaller than it, while increasing in total size as it goes.


  • \$\begingroup\$ Perhaps it should be "larger than the program two before" rather than "larger than the original?" As stated, a 5-length program could output a 7-length, which outputs a 6-length, which then oscillates between 7 and 6, not growing in total size as it goes. \$\endgroup\$ – Ethan Chapman Oct 8 '20 at 18:51
  • \$\begingroup\$ Probably should be named something other than a quine because I find that term misleading for the challenge you described. \$\endgroup\$ – Beefster Oct 14 '20 at 21:12

The goal of this challenge is to fill a niche that is mostly lacking on this site. In my observations there most parsing verification challenges fall into two categories:

  1. Super easy parsing. This parsing can usually be done with a regex, and regex based answers usually do well.

  2. Super complex parsing. These are challenges with a lot of small parsing components that would on their own be type 1, but together make for long code with a lot of edge cases.

Neither of these categories are really bad, each can have fun challenges, but I want to shoot for something different. A challenge which is hard, hard enough that a regex will be unable to do the brunt of the work but with a easy to understand spec.

The goal of this challenge is to parse a lisp-like lambda function. Your code should accept a string as input and output of two possible consistent values. One which corresponds to an affirmative response (i.e. the input is a properly formatted lambda) and the other corresponds to a negative response (i.e. the input is not a properly formatted lambda).

I've put together 3 specifications of what constitutes a validly formatted lambda for this challenge. The first is a quick intuition base explanation. It explains the process and what things mean even if it is not perfectly rigorous. The second a formal grammar which expresses the idea succinctly and with no ambiguity. And the third is raw code, which is the hardest to read for humans but allows you to play around with the idea by trying different inputs. I recommend you read one of the first two and play around with the third.


The challenge uses a lisp like format. This consists of "lists" which are just parentheses enclosing lowercase words, and other lists separated each by a single space. So

(foo (bar baz) foobar)

Would be a lisp-like "list". For our challenge each list will be identified by it's first element (which should by highlighted by the syntax highlighter), which must be either app, abs, or var, representing applications, abstractions and variables, respectively.

An application is the application of one lambda function to another. It is represented by a three element list starting with of course app followed by two other valid lambda expressions. So if S and K were valid lambdas then:

(app S K)

would be a valid lambda too.

The other two abstractions and variables work together, an abstraction introduces new names for variables and variables use those names. An abstraction encloses some lambda which must be valid with the introduced variable name, and a variable can only use names which are given by abstractions that surround it. So

(abs x (abs y (var x)))

Is valid because the x name was introduced and used in a nested context. But

(app (abs x (var x)) (var x))

Is not because even though there is an abstraction for x the second (var x) is not surrounded by any abstraction at all, let alone one that introduces x.

Additionally abstractions can only introduce new variables, so

(abs x (abs x (var x)))

is not valid because the name x is ambiguous, it could refer to either abstraction. Variable names must be a string of lowercase ascii letters (a-z).


Now for the golfy definition. This parse cannot be defined in terms of a context free grammar, so this grammar uses context. The context is a set of strings of lowercase ascii letters as these are the valid variable names.

\$ \begin{array}[rr] \ S\left(x\in C\right) &:= \color{green}{\texttt{(var }}x\color{green}{\texttt{)}} \\ S\left(x\notin C\right) &:= \color{green}{\texttt{(abs }} x\texttt{ }S(C\cup\{x\})\color{green}{\texttt{)}} \\ S\left(C\right) &:= \color{green}{\texttt{(app }} S(C)\texttt{ }S(C)\color{green}{\texttt{)}} \end{array} \$

Any string spanned by the grammar is valid and any string not is invalid.


I've exhausted myself with the above. I will write to code in a bit when I've eaten and stuff.


This is so answers will be scored in bytes with the goal being a smaller score.

Test cases


(abs x (var x
)))(abs x (var x))
app (abs x (var x)) (abs x (var x))
(mmm hummus)
(abs x (var y))
(abs x (abs x (var x)))
(app (abs x (var x)) (var x))
(abs (var k) (var (vark k)))


(abs x (var x))
(abs x (abs y (var x)))
(abs xx (app (var xx) (var xx)))
(app (abs ab (app (var ab) (var ab))) (abs ab (app (var ab) (var ab))))

In need of title.

Note: In the final challenge \$N\$ will be a concrete number (I am thinking about 100), but while this is in the sandbox it is subject to change so I have left it as \$N\$.

This challenge is based off of a list of \$N\$ Castilian Spanish words and the words they originate from.

You are to write a program or function which takes the origin word as input and outputs as close as possible the Castilian derivative. Your program should be no longer than \$N\$ bytes.


To calculate your score run your program on every origin word and calculate the distance between your output and the correct answer. Your score is the sum of all these distances.

The distance here is a modified version of Levenshtein distance. It is the same as Levenshtein distance except replacement steps that add or remove a diacritic cost only 1/2 of a step as opposed to their normal 1.

You can use this code to calculate the distance between two strings.

The goal is to have as low a score as possible.

About the list

All of the origin words, spare 1, are Latin words (Late or Classical depending on the word). The one exception is ezkerra (the origin for izquierda) which is of Basque origin. It has been added as an extra curve-ball in case you can get all the others with a little space to spare.

Verbs are always in the infinitive form and nouns in the nominative singular.

The words are not chosen randomly but rather I have focused on choosing words that follow a number of simple rules. The list is also organized so that words that undergo similar transformations are grouped together. This is for your ease of use, nothing more.

The list

faba, haba
facienda, hacienda
facere, hacer
fundus, hondo
profundus, profundo
fungus, hongo
fabulare, hablar
furnus, horno
ferrum, hierro
filus, hijo
filum, hilo
folia, hoja
fovea, hoyo
fagea, haya
fastidium, hastío
fastidiare, hastiar
afflare, hallar
formica, hormiga
fetere, heder
ficcare, hincar
factor, hechor
factum, hecho
octo, ocho
octavus, ochavo
noctu, noche
lacte, leche
iactare, echar
coctus, cocho
dictatum, dechado
capere, caber
sapere, saber
lupus, lobo
lacrima, lágrima
lacuna, laguna
eruca, oruga
pater, padre
mater, madre
liber, libro
thema, tema
theatrum, teatro
thesaurus, tesoro
thesis, tesis
thorax, tórax
aether, éter
anthropologia, antropología
orthographia, ortografía
sapphirus, zafiro
philosophia, filosofía
echo, eco
chalare, callar
chamaeleon, camaleón
chaos, caos
materia, materia
resistentia, resistencia
aurum, oro
taurus, toro
autumnus, otoño
annus, año
scribere, escribir
scutum, escudo
scutella, escudilla
scriptor, escritor
ezkerra, izquierda
  • \$\begingroup\$ I think it's interesting in that it should be near impossible to get a perfect score without built-ins. As a suggestion I'd remove the non-ASCII words, or at least normalise them, and perhaps not let \$N\$ be too high. Also, I wonder what the default cat program would be. \$\endgroup\$ – Jo King Mar 3 '20 at 12:31
  • 2
    \$\begingroup\$ @JoKing I am looking to somewhat twart perfect scores, I feel there should always be some room for improvement, It just is a little hard to balance this with golfing-languages ability for expressiveness. I am interested to hear what ranges for \$N\$ you think are too high. I started out by avoiding any non-ASCII characters, but it was really hard to build up a representative corpus of words. Plus the accents and eñe really are a feature of the language. I may adjust the scoring so that i and í for example are only half away from each other so that the penalty is small. \$\endgroup\$ – Wheat Wizard Mar 3 '20 at 13:05
  • \$\begingroup\$ Suggested title: Hispanize these words. Also mention that words should be in lowercase. Finally I think it makes more sense to restrict programs to \$N\$ characters rather than \$N\$ bytes. \$\endgroup\$ – SunnyMoon Nov 20 '20 at 15:24
  • 4
    \$\begingroup\$ I'm not a fan of "Your program should be no longer than N bytes". I think a scoring rule which incorporates both the Levenshtein distance and the byte count would be better, as in the Moby Dick challenge: it would allow more languages to compete, and would allow for more creativity. \$\endgroup\$ – Robin Ryder Nov 22 '20 at 23:43
  • 1
    \$\begingroup\$ @RobinRyder I think that metrics that combine two non-obviously related factors such as in the Moby Dick challenge or as you are suggested rarely work. In fact I can't even think of an example I feel is good. They simply require fine tuning that can only really be done in retrospect. I also don't know how this would allow more languages to compete and I certainly don't know how it would "allow for more creativity". If you have a specific metric in mind and a compelling reason why that metric would not be broken I would be happy to try it out and see. \$\endgroup\$ – Wheat Wizard Nov 23 '20 at 1:38
  • 1
    \$\begingroup\$ Sorry, I'll expand: with a low, hard limit on the number of characters, non-golfing languages don't stand a chance (hence the "more languages" part). If instead you set a high hard limit, it will be possible to reach a (near) perfect score, with no incentive to golf or search for trade-offs (hence the "creativity" part). There surely exists a sweet spot for the character limit where neither of these issues arise, but (a) it will be hard to find and (b) it will be highly language-dependent. \$\endgroup\$ – Robin Ryder Nov 23 '20 at 7:53
  • 1
    \$\begingroup\$ @RobinRyder I think that 100 characters is plenty of characters for nearly any language to implement something a bit more complex than cat (e.g. replace ^f with ^h). I also think that it would require quite a few characters any language to acheive a perfect score. More than half of the words have seemly random vowel mutations that are not covered by any general rule. The only way I can see a perfect score is a compression decompression method. It seems to me to write the de-compressor and make up for the loss would require a deal of room. \$\endgroup\$ – Wheat Wizard Nov 24 '20 at 15:56
  • \$\begingroup\$ What I'm saying is that I think that sweet spot is actually very large. And I think that adding more dimensions to the problem only increase the risk of missing the sweet spot. \$\endgroup\$ – Wheat Wizard Nov 24 '20 at 15:57
  • \$\begingroup\$ I'm not sure the modified version of the Levenshtein distance really adds something to the challenge, but it certainly makes it harder to score an answer. Would you consider updating your script so that it accepts the whole list of translations? \$\endgroup\$ – Arnauld Dec 2 '20 at 22:36
  • \$\begingroup\$ Some possible typos (I'm a native Castillian Spanish speaker and I'm familiar with Latin): afflare, hallar; factor, factor; chalare, callar \$\endgroup\$ – Luis Mendo Dec 20 '20 at 18:00
  • \$\begingroup\$ @LuisMendo hallar and chalare are definitely typos. But hechor was intentional. I suspect your hang up is that factor and hechor are doublets but factor is more similar to the Latin. There are plenty of words here for which the Latin is not a direct translation or the Spanish or vice versa (even factor is not). I chose to include hechor because it is a good example of some of the changes that I want to highlight, (f -> h and ct -> ch). \$\endgroup\$ – Wheat Wizard Dec 21 '20 at 23:26
  • \$\begingroup\$ The thing is, I never heard hechor. But I just checked in the dictionary and it is included, albeit as an old form, not in current use \$\endgroup\$ – Luis Mendo Dec 21 '20 at 23:46

Strobogrammatic Numbers


A number which is rotationally symmetrical, i.e., it'll appear the same when rotated by 180 deg in the plane of your screen. The following figure illustrates it better,


(source: w3resource.com)


Given a number as the input, determine if it's strobogrammatic or not.


  • Truthy
  • Falsey


  • The number is guaranteed to be less than a billion.
  • We are considering 1 in it's roman numeral format for the sake of the challenge.
  • Input can be taken as number, or an array of chars, or as string.
  • Output would be a truthy/falsey value.
  • This is a , so fewest bytes will win!


  • Although I've tried a search, but is this a duplicate?
  • Is the challenge's text clear enough?
  • Any tricky/interesting test case?

Explain a Code Golf Answer


When writing Code Golf answers, it is often a good idea to add an explanation of the code so the reader understands what's going on. For example, this this answer by @Makonede (abridged):

        θ  # last element of
Σ          # the input, sorted in increasing order by
     1¢    # the number of ones of
   %       # modulo
 žJ        # 4294967296
    b      # in binary

The full program is written on the first line, then a blank line, then on each successive line, a little snippet of the program, aligned using spaces with its position in the full program, and then some comments on the right-hand side explaining each part.

I, for one, find writing and aligning these explanations tedious, so let's outsource it to a program.


Given a program as a string, and a list of sets of pairs of start/end indices to form an inclusive range, output each sub-string defined by the indices on a new line, indented to its respective position in the whole string, with a # at the end of the line, padded so that there are two spaces before the # after the last sub-string, ready for the user to add their explanation.


  • You may use 0-based or 1-based indexing
  • You are guaranteed to receive valid, non-overlapping ranges, which together cover the whole string
  • You may assume the program string contains no newlines, tabs or other unprintable characters, and no double-width characters
  • Standard I/O rules and loopholes apply
  • This is , so shortest code in bytes wins

Examples (1-based indexing)

Inputs: abcdwxyz, (1-8)

abcdwxyz  #

Inputs: abcdwxyz, (5-7), (1-2),(8-8), (3-4)

    wxy   #
ab     z  #
  cd      #

Inputs: <<<$[grep -c wx $0-grep -c y\z $0];:<<'Q', (6-20), (22-37), (4-5),(38-38),(21-21), (1-3), (39-39), (40-40), (41-45)]

     `grep -c wx $0`                           #
                     `grep -c y\z $0`          #
   $[               -                ]         #
<<<                                            #
                                      ;        #
                                       :       #
                                        <<'Q'  #


  • Is this a duplicate?
  • Is this clear enough?
  • Any other feedback?
  • 1
    \$\begingroup\$ Related \$\endgroup\$ – Razetime Dec 24 '20 at 10:32
  • 1
    \$\begingroup\$ @Razetime I would say this is a dupe :-( \$\endgroup\$ – pxeger Dec 24 '20 at 13:35
  • \$\begingroup\$ I'd say this is simpler and more suited for code golf because it functions without the need for a complex priority system. You may want to request more opinions on the nineteenth byte. \$\endgroup\$ – Razetime Dec 24 '20 at 17:51

Interpret Interval Notation

  • \$\begingroup\$ @Adám yes to and -ish characters. I also broadened the scope to all meaningful intervals, so ranges may overlap and [5,5] (all integers x where 5<=x<=5)is [5] but not [5,5) (all integers x where 5<=x<5) and (5,5) (all integers x where5<x<5) are undefined. \$\endgroup\$ – Aiden4 Dec 22 '20 at 21:07
  • 2
    \$\begingroup\$ All integers x where 5<=x<5 would be [], no? \$\endgroup\$ – Adám Dec 22 '20 at 22:25
  • \$\begingroup\$ I'd put all the undefined cases separately, or at least at the end. \$\endgroup\$ – Adám Dec 23 '20 at 0:09
  • 2
    \$\begingroup\$ Typo: the [9,13] test case should either be [9,13) or 13 is missing from the output. \$\endgroup\$ – Dingus Dec 23 '20 at 2:35
  • \$\begingroup\$ undefined cases should be undefined behavior instead. Otherwise, one need to handle it separately which feels bad. Otherwise, it's a good challenge :) \$\endgroup\$ – vrintle Dec 23 '20 at 11:22
  • \$\begingroup\$ If you allow other symbols for the brackets, make sure to prohibit other phrases as that can be abused. \$\endgroup\$ – Adám Dec 23 '20 at 15:16
  • \$\begingroup\$ @Adám what do you mean by phrases? \$\endgroup\$ – pxeger Dec 23 '20 at 16:06
  • 3
    \$\begingroup\$ @pxeger Multi-character constructs. It'd allow solutions to require an input format that contained the necessary code such that the solution becomes an eval. \$\endgroup\$ – Adám Dec 23 '20 at 16:46
  • 1
    \$\begingroup\$ Related \$\endgroup\$ – Razetime Dec 24 '20 at 10:44
  • \$\begingroup\$ Is parsing a string necessary? Could you also allow other constructs (tuples with a marker to show if they're open or closed)? \$\endgroup\$ – user Dec 25 '20 at 21:56
  • \$\begingroup\$ Just asking frankly, did you forgot to post this, or is something yet missing? \$\endgroup\$ – vrintle Jan 4 at 2:59
  • \$\begingroup\$ @user I am going to say no to other constructs otherwise, it is basically a duplicate of the related challenge. \$\endgroup\$ – Aiden4 Jan 4 at 15:03
  • \$\begingroup\$ @vrintle Something like that. I haven't really been active since just before Christmas. I'll probably post it this afternoon. \$\endgroup\$ – Aiden4 Jan 4 at 15:04

Is this an L-shape?


An L-shape is defined as a polyomino which can be made by extending two rectangular legs in orthogonal directions from a full square (called a pivot). The size of the square should be at least 1, and the lengths of the two legs should also be at least 1.

These are some examples of L-shapes:

Pivot size 1, two leg lengths 2 and 4

Pivot size 2, two leg lengths 1 and 3

These are not:

Does not have two orthogonal nonempty legs

The pivot is not a square

One of the legs is not rectangular

Has three legs instead of two

Cannot identify a pivot and two legs

Contains one or more holes
# ###
# #

Is not a polyomino (the shape is disconnected)
##  #
#  ##


Given a zero-one matrix, determine if the ones form a single L-shape.

For example, the output must be True if the input is this:

0 0 1 1 1 1 0
0 0 1 1 1 1 0
0 0 1 1 0 0 0

and False if given this:

0 0 0 0
0 1 1 0
0 1 1 0
0 0 0 0

You can choose any reasonable representation of a matrix, and you can assume that the input is always rectangular. You can also choose the two values to represent 0 and 1 respectively. You should handle inputs containing or not containing zero margins, and detect L-shapes in any of the four orientations.

For output, you can choose to

  1. output truthy/falsy using your language's convention (swapping is allowed), or
  2. use two distinct, fixed values to represent true (affirmative) or false (negative) respectively.

Shortest code in bytes wins.


Metagolf: Catlike Piet

The goal of this is to write a catlike program, which would be executed (in a Unix environment, though you needn't stick to that) by the following:

yourprogram < file > output
piet output

where piet output writes the contents of file to stdout. That is, you're to generate a Piet program which prints the input to yourprogram.


Straight line programs can be written in Piet... in straight lines. If you're willing to take a hit to your score, your output can take the form of a string of commands:

=  none (continue color block)
|  push
^  pop
+  add
-  subtract
*  multiply
/  divide
%  mod
~  not
>  greater
.  pointer
\  switch
:  duplicate
@  roll
$  input number
?  input character
#  output number
!  output character

which is trivial to convert to a Piet program with the following (partially golfed) Python code:

def P(s):
 h=v=0;l=len(s)+1;R="P3 %i 2 255 192 0 0 "%(l+2)
 for x in map("=|^+-*/%~>.,:@$?#!".find,s):
  for i in [1,2,4]:R+="%i "%V[(C[0]//i)%2]
 return R+"255 "*4+"0 0 "+"255 "*l*3+"255 0 0 "*2

The dimension of said program is (n+3) x 2 if there are n characters in the string.


Your code will be judged on the maximum dimension of the images that it outputs.

  • Part 1: Take the maximum score taken over all ascii codes (that is, single-character inputs), discounting EOF.

  • Part 2: Take the score for the input "Hello. My name is Inigo Montoya. You killed my father. Prepare to die."

Your score is the product of the scores in part 1 and part 2.

Punishment: Double your score if you write one-liners as above (that is, if you don't output an image).

Bonus: If your program is written in Piet, take the square root of your score above.

  • 1
    \$\begingroup\$ It took me a while to understand the task as "Write a program taking INPUT which produces as output a piet program that takes no input but produces INPUT." I think it is a interesting and challenging, but it's reception will depend entirely on how many people are willing to learn/futz-around-in/deal-with piet. And I have no feel for how many that is. \$\endgroup\$ – dmckee --- ex-moderator kitten Jul 7 '11 at 3:12
  • \$\begingroup\$ @dmckee; would it be better if I just used a reduced instruction set, and only ask for the instruction stream? I think this is still challenging with {push 1,duplicate,add,subtract,multiply,output}. Come to think of it, if I restrict to {push 1,duplicate,add,output}, there's a reduction to some awesome algorithms. \$\endgroup\$ – boothby Jul 7 '11 at 4:48
  • \$\begingroup\$ I did this in piet some time ago: craigoclock.blogspot.com/2011/05/metaprogramming-in-piet.html \$\endgroup\$ – captncraig May 21 '12 at 18:31
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) \$\endgroup\$ – programmer5000 Jun 9 '17 at 15:22

Chess move

The Challenge

Write a program that gets a string containing a chessmove and a chessboard as input, and then outputs the chessboard.


The chess move will have this format:

<from square><to square>[<promoted to>]



The chessboard format is not fixed, but there must be a 1 to 1 relation between the board and the string to represent the board. Also the format of the input must bet the same as the format of the output. Two suggestions of what it could look like:


rnbqkbnr pppppppp 00000000 00000000  00000000  00000000 PPPPPPPP RNBQKBNR

It is not required to store anything except the location of the pieces, and validity of moves can be assumed.


Base score is character count (assuming your program can move pieces for all moves)

Bonus multipliers:

  • If the program updates the promoted piece, divide by 2
  • If the program also moves the rook when castling, divide by 2
  • If the program also removes the pawn when capturing en passent, divide by 2

The moves, and castling & en passent in particular are explaned on Wikipedia.

So basically writing a 100 character solution for the base problem gives the same score as an 800 character solution with all bonus multipliers.


If you would choose to use one of the board formats above, your input would look like one of these strings:

e2e4 rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR

e2e4 rnbqkbnr pppppppp 00000000 00000000  00000000  00000000 PPPPPPPP RNBQKBNR

Your corresponding output string would then be one of these:


rnbqkbnr pppppppp 00000000 00000000  0000P000  00000000 PPPP0PPP RNBQKBNR
  • 1
    \$\begingroup\$ Before I get on to more specific criticisms: as presented, without the bonus this is too trivial to be interesting. I suggest removing some flexibility: require Fen notation for the board position and algebraic notation for the move, and making the current bonus options mandatory. On specifics: it's not clear why you talk about storage; and the board position notations you suggest don't include enough information to know whether en passant is possible. \$\endgroup\$ – Peter Taylor Dec 22 '13 at 23:56
  • \$\begingroup\$ @PeterTaylor I agree that compared to chess programs this may be trivial, but I would like to make it a golf challenge. Compared to the hot code golf questions this is quite elaborate already in its basic form. (For a good solution the board design may need to be changed drastically). It is true that there is no attention to the legality of moves (whether it is possible to capture en passent) but for a mere viewer this is not required so I am not too worried about this. So far the chess questions seem to get very few answers as they tend to be complex and I hope to offer relatively easy entry. \$\endgroup\$ – Dennis Jaheruddin Dec 30 '13 at 11:02
  • 2
    \$\begingroup\$ Your point about en passant is valid - you had said in the spec to not worry about legality. I'll try to convince you of my first point: without the bonus, this reduces to: a) parse first four characters into (col 1, row 1, col 2, row 2); b) take board as a 64-char string; c) board[8*row_2+col_2] := board[8*row_1+col_1]; board[8*row_1+col_1] := ' '; print board. This is trivial compared to any good golf question. (Note that the hot questions at the moment are neither golf questions nor good questions). \$\endgroup\$ – Peter Taylor Dec 30 '13 at 12:14
  • \$\begingroup\$ This sandbox post has had little activity in a while. Please improve / edit it or delete it to help us clean up the sandbox. Due to community guidelines, if you don't respond to this comment in 7 days I have permission to vote to delete this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 15:40

Black Box

Your task is to analyze a given situation for the game Black Box. Given a sequence of guesses and answers, your program is to either print the solution or suggest the next move.

The game

The board consists of 8×8 cells, with edges labeled like this:

I'll probably create nice images here, particularly to make sure that the squares of the board are really square.

i        I
j        J
k        K
l        L
m        M
n        N
o        O
p        P

The player shoots rays into the interior of the box, where they might get deflected, reflected or absorbed. He is told the position where the ray leaves the black box again, and from that has to deduce the positions of 4 atoms inside the black box.

I'll have to include more of the game rules here, but for now see Wikipedia.

Input and output

Input is a sequence of line, each consisting of two characters. The first denotes the point where the ray of light enters the black box, the second the place where it comes out again. In the case of a reflection, both characters will be equal. In the case of a hit, the second character will be -.

If the input is enough to fully determine the locations of the atoms, then output should be four lines giving the coordinates of each atom. The lines should be two lower case characters each, the first giving the row and the second giving the column of the found solution. The atom positions must be printed in lexicographical order.

If the input is consistent with more than one set of atom positions, then the output should consist of a single line containing a single character, which is the location where the next ray should be shot. That location has to be chosen in such a way that it can help find the solution. This is the case unless all of the atom positions consistent with the input so far would produce the same output for this next ray as well.

Your output has to be terminated by a newline character.


Let's take the atom configuration the Wikipedia article uses as an example as well:

i        I
j        J
k O    O K
l        L
m        M
n   O    N
o        O
p      O P

If the input were


then the output should be


but if the input were only


then the output might be for example



This is code golf, so shortest answer wins. However, I'll only accept answers which are practical in so far as they compute their result in reasonable time. I'd say no more than five minutes on my system where I'll evaluate the answers, and I'll simply hope that correct solutions will be much faster and incorrect ones much slower, so that the speed of my system doesn't make a difference. A submission which gives a wrong answer for one of my test cases will be disqualified until it gets fixed. I will probably point out the problem in a comment to that post.


Create a program with "exact repetition" in its source code

The task is to create a program, with the following restrictions placed on the printable ASCII characters in the source code: choose some k > 0.

  • Every non-alphabetic character has to appear exactly k times.
  • Every alphabetic character has to appear at most k times.
    • This rule differs from the former in order to avoid boring dummy identifiers while still making it a challenge to choose good library functions to call.

Character set definitions used:

  • Non-alphabetic characters are !"#$%&'()*+,-./0123456789:;<=>?@[\]^_{|}~ and '`' (backtick).
  • Alphabetic characters are ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz.

Note that no restriction is placed on characters outside of the range of printable ASCII characters (including control codes, tabs, newlines, higher unicode codepoints, etc).

What the program does is up to you; be creative. Some general guidelines:

  • Programs that do something interesting might have better chances, although more impressive code structure (i.e. fewer comments) is also beneficial.
  • Stuffing excess characters in comments is boring, and should be avoided/is discouraged.
  • Dead/no-op code isn't terribly interesting either, but is probably unavoidable and at least has to conform to the language's grammar.

This is : whatever has the most upvotes at Feb 1, 2014 gets accepted as the winner.

Example answer (C)

/*$$@``*/_[]={9.};main() {printf("He%clo \

Prints "Hello world!" (adapted from an answer to another question). Probably wouldn't score a lot (since what it does isn't terribly interesting). Each of the non-alphabetic characters appear exactly twice, and no alphabetic character appears more than twice.

For meta: I want to post this, but I'm worrying that "do something interesting" might give too little guidance and the question won't receive many answers.. thoughts? Is it good as-is, or should I come up with some task that one should be required to implement (and possibly change the ruling to code-challenge, with length + 2^(characters-in-comments) as the score)?


4 and 20 baked in a π

While some might describe π as a string of seemingly random numbers, one can also look at it in a way similar to a monkey with a typewriter. Eventually, it should calculate out to something more interesting. For example, the sequence 1337 shows up 4,814 places to the right of the decimal. At 700,731 places right of the decimal, you'll find the sequence 160151, which is "pi" represented as ASCII (although you'll find a 'pointer' to it much faster, as the sequence 700731 begins at 29,830 digits to the right).

So, your task is to make a program to find things in π. Your program will accept a positive integer and output the number of places right of the decimal point that number appears. To keep the run times down, input can be limited to numbers in the range of 0 to 1000 (without leading zeros).

Example: Using 415 as the input, the output should be 2:



  • You can not use any precalculated values of π, including language constants, built in functions that return π or digits of π, or any resource outside the code itself (such as files or websites).
  • You can not use any trig functions to calculate π.

Bonus points if you find the sequence 072 101 108 108 111 044 032 087 111 114 108 100 033.

This is code golf, so lowest score wins.

  • 1
    \$\begingroup\$ It's not clear to me whether you require answers to support leading zeroes. Also: program, named function or snippet? And how indexed? (Giving 415 as a test case would be a good way to answer the last question) \$\endgroup\$ – Peter Taylor Mar 11 '14 at 6:58
  • 3
    \$\begingroup\$ Isn't this just Calculate 500 digits of pi with a search function tagged on at the end? By the way, your bonus points are quite safe — even if you searched a trillion trillion trillion digits of pi, your chance of finding an arbitrary 39-digit sequence would still be less than 0.1%. \$\endgroup\$ – r3mainer Mar 11 '14 at 14:59
  • \$\begingroup\$ Edited to clarify leading zeros and indexing. @squeamishossifrage - Yes and no. The number of digits to find the answer depends on the input, which both limits the choice of algorithm to generate the search space and gives more ample room to golf the integration of the search function. The worst case is under 10000 digits for n between 0 and 1000. I suppose I could put in a time limit of a couple minutes and expand the range of n to 10000 (worst case is just under 390k), but that seems obnoxious. Thoughts? \$\endgroup\$ – Comintern Mar 11 '14 at 17:20
  • 1
    \$\begingroup\$ @AlexA. - Not a drug reference. \$\endgroup\$ – Comintern Apr 1 '15 at 22:34
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 16:15

Create a calendar

We all know HDD-space is precious and bandwidth is expensive, therefore it is best to reduce the size of your executables. Let's start with your calendar:

Your task is to build a calendar app in at most 512 bytes. The calendar must at least support the following features, but additional features may gain you additional upvotes:

  • It must be able to show the current month with the current day highlighted
  • The user must be able to find out the week day of each day


  • Maximum code length is 512 bytes (counted as UTF-8 without BOM)
  • You may subtract the bootstrapping code (i.e. int main(int argc, char **argv) in C or <?php in PHP) and imports from the final size to allow for more verbose languages to be in
  • You may use standard time / date functions of your programming language, as long as they don't allow you to output a ready to use calendar
  • No network access (I said bandwidth is expensive!)
  • Voters decide on the amount of features / look and feel / creativity

This needs a tag for the size restriction, any suggestions?

  • 1
    \$\begingroup\$ "bandwidth is expensive" <sup>[citation needed]</sup> \$\endgroup\$ – John Dvorak Mar 22 '14 at 5:27
  • 1
    \$\begingroup\$ Seems rather close to Output: Calendar Month \$\endgroup\$ – Peter Taylor Mar 22 '14 at 5:33
  • \$\begingroup\$ Who decides what counts as bootstrapping code? It seems odd to arbitrarily exclude code like that, and the examples you gave can be golfed a lot: they're more or less equivalent to main(){ and <? respectively. \$\endgroup\$ – Wander Nauta Mar 24 '14 at 20:49
  • \$\begingroup\$ @WanderNauta Bootstrapping code is the code that's essentiell to get a working noop program. \$\endgroup\$ – TimWolla Mar 24 '14 at 21:00
  • \$\begingroup\$ @TimWolla That definition won't fly. A zero-byte file is a working noop PHP script, for example. \$\endgroup\$ – Wander Nauta Mar 24 '14 at 21:01
  • 1
    \$\begingroup\$ @WanderNauta A zero byte file is a working noop in every language. \$\endgroup\$ – TimWolla Mar 24 '14 at 22:12
  • \$\begingroup\$ So what's bootstrapping code then? :) \$\endgroup\$ – Wander Nauta Mar 24 '14 at 22:53
  • 1
    \$\begingroup\$ for the limit I'd say code-shuffleboard or restricted-source \$\endgroup\$ – Einacio Mar 26 '14 at 15:57
  • \$\begingroup\$ This sandbox post has had little activity in a while. Please improve / edit it or delete it to help us clean up the sandbox. Due to community guidelines, if you don't respond to this comment in 7 days I have permission to vote to delete this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 16:28

ASCII ART edge detection

As the title says, I was thinking to contest in which one must detect edges of an ASCII art.

The code should accept a B/W ASCII art as input. A B/W ASCII art is defined as (by me) an ASCII art with only one kind of non-white-spaces character (in our case: an asteriks *). And as output produce a standard ASCII art (all ASCII characters are accepted) which should remember the contourn of the first.

The purpose of using more than one character in the output is to make some edges ssmoother. For instance, one could let this input


could became:

    _/   ) 
  _/    /
 /      |
|      /
|      \
 \      |
  `\     |

The input \n separated string as input. Each line has a maximum of 80 characters. The number of rows is not specified.

I'd put it as a popularity-contest since, beside my simple code, I'd like to see more "round" edge detections which use more than one character in smooth edges.

Also, I don't want to tag it as code-golf since I'm quite sure one can do this job using aplay (with ASCII art renderer) and command line GIMP (to apply edge detection).

As a popularity contest, there are no strict rules on how the output should be..just use your fantasy!

This is my sample program:

import fileinput as f
import re as r
import copy as c
a,s,p='*',' ','+'
def read(n):
    s=[list(' '*n)]
    for l in f.input():
        k=list(r.sub('[^ ^\%c]'%a,'',' '+l+' '))
        s.append(k+[' ']*(n-len(k)))
    s.append([' ']*n)
    return s
def np(s):
    for l in s[1:-1]:
        for w in l[1:-1]: print(w,end='')
def grow(i):
    for x in range(1,len(o)-1):
        for y in range(1,len(o[x])-1):
            if(i[x][y]==a): o[x-1][y-1]=o[x-1][y+1]=o[x-1][y]=o[x+1][y]=o[x+1][y-1]=o[x+1][y+1]=o[x][y+1]=o[x][y-1]=a

    return o
def diff(i,o):
    for x in range(0,len(i)):
        for y in range(0,len(i[x])):
            if(i[x][y]==a and o[x][y]==s): l.append(p)
            else: l.append(s)
    return c

Here below I put both input of the programs. It is an 80x70 ASCII ART. It means it has 70 lines of 80 characters, each separated by \n.

                                          *****          *****                   
                                     ******                  ***                 
                                    ***                         ****             
                             *********                             **            
                          ***********                               **           
                     ******   *******                                **          
                 *****       *******      ***                         **         
              ****          ********     *****                          *        
             **            *********     *****                    *****  *       
           ***            *********     *******                  ******  **      
          **             **********     *******                  ******   **     
         **              **********    *******                  ********   *     
        *               ***********   ******                    ********   *     
       **              ************   *****                     ********    *    
       *               ************    ***                       ********   *    
      *               *************                               ******    *    
     *                *************                                 ***     *    
    **                *************                                         *    
    *                **************                                         *    
   **                *************                                         **    
   *                 *************                                         **    
  **                *************                                          ***   
 ***                *************                                          ****  
 **                 ************                                           ****  
 **                *************                                           ****  
 **                *************           *****                           ****  
 **                *************          **   **          **              ****  
 **                 ************          *     *         ** **            ****  
 *                  ************          **   **        **   **           ****  
 *                  *************        *******         **   ***          ****  
 *                  ************          *****           *******          ****  
 *                   ************         ***               *****          ****  
**     *             *************                          ****          *****  
**    ***            **************                                      *****   
*    *****            *************                                     ******   
** *******             **************                                  *******   
**********             ***************              *                *********   
**********              *****************          ***             ***********   
***********              *******************                    **************   
***********               **********************            ******************   
************              *****************     **     ***********************   
*************             ******************      ****     *******************   
**************            ******************              ********************   
****************           ******************              *******************   
***************           *******************              *******************   
****************           ******************              ******************    
******************         ******************             *******************    
*******************         *****************             *******************    
*********************      ******************           ********************     
*********************************************          *********************     
**********************************************       ***********************     
************************     *****************      ************************     
 **********************       ******************* **************************     
 *********************        *********************************************      
 *********************        ****************************  ***************      
 ********************         **************************    ***************      
 ********************         *********************         ***************      
 *******************          ********************         ****************      
 ******************           *****************            ****************      
 *****************             ****************            ***************       
 *****************             ****************            ***************       
 *****************             *****************           ***************       
  ****************             *****************           ***************       
   **************              ******************          ***************       
                                 ****************          ****************      
                                  **************            ***************      

A possible output could be:

                                         +++++             ++++
                                    ++++++     ++++++++++     +++
                                   ++      +++++        +++++   +++++
                            ++++++++   +++++                ++++    ++
                         ++++         ++                       ++++  ++
                    ++++++           ++                           ++  ++
                +++++      +++       +   +++++                     ++  ++
             ++++     +++++++       ++  ++   ++                     ++  ++
            ++    +++++   ++        +   +     +                  +++++++ ++
          +++  ++++      ++         +  ++     ++                ++     ++ ++
         ++   ++        ++         ++  +       +                +      ++  ++
        ++  +++         +          +  ++       +               ++      +++  +
       ++  ++          ++          + ++       ++               +        +++ +
      ++ +++          ++           + +      +++                +        + + ++
      +  +            +            + +     ++                  +        ++++ +
     ++ ++           ++            + ++   ++                   ++        + + +
    ++ ++            +             +  +++++                     ++      ++ + +
   ++ ++             +             +                             +++   ++  + +
   +  +             ++             +                               +++++   + +
  ++ ++             +              +                                      ++ +
  +  +              +             ++                                      +  +
 ++ ++             ++             +                                       +  ++
++  +              +             ++                                       +   ++
+   +              +             +                                        +    +
+  ++             ++            ++                                        +    +
+  +              +             +         +++++++                         +    +
+  +              +             +        ++     ++        ++++            +    +
+  +              +             +        +  +++  +       ++  +++          +    +
+  +              ++            +        + ++ ++ +      ++  +  ++         +    +
+ ++               +            ++      ++  +++  +      +  +++  ++        +    +
+ +                +             +      +       ++      +  +++   +        +    +
+ +                +            ++      ++     ++       ++       +        +    +
+ +   +++          ++            ++      +   +++         +++     +       ++    +
  +  ++ ++          +             ++     +++++             +    ++      ++     +
  + ++   ++         +              +                       ++++++      ++     ++
 ++++     +         ++             +++                                ++      +
  +       +          ++              ++            +++              +++       +
          +           +               ++++        ++ ++           +++         +
          ++          ++                 ++++     +   +        ++++           +
           +           ++                   +++++ +++++    +++++              +
           ++           ++                      +++   ++++++                  +
            ++           +                 +++++  +++++                       +
             ++          +                  +  +++    +++++                   +
              +++        +                  ++   ++++++  +                    +
                +        ++                  +           ++                   +
               ++        +                   +            +                   +
                +++      ++                  +           ++                  ++
                  ++      +                  +           +                   +
                   +++    ++                 +         +++                   +
                     ++++++                  +        ++                    ++
                                             ++     +++                     +
                                              +    ++                       +
                        +++++                 ++++++                        +
+                      ++   ++                   +                          +
+                     ++     +                                             ++
+                     +      +                            ++               +
+                    ++      +                          ++++               +
+                    +       +                     ++++++ ++               +
+                   ++       +                    ++      +                +
+                  ++        +                 ++++       +                +
+                 ++         ++                +          +               ++
+                 +           +                ++         +               +
+                 +           +                 +         +               +
++                +           +                 ++        +               +
 ++              ++           +                  +        +               ++
  ++++++++++++++++            +++                +        +                +
                                ++              ++        ++               +
                                 ++++++++++++++++          ++              +
                                                            ++            ++

This is also the output produced by the script above. Of course it is not the best output and I'm sure one can easily produce a smoother one.

  • 1
    \$\begingroup\$ It would be useful to be more precise about which characters should be non-blank in the output: characters which were non-blank in the input but adjacent to blanks, or characters which were blank in the input but adjacent to non-blanks? \$\endgroup\$ – Peter Taylor Apr 4 '14 at 9:50
  • \$\begingroup\$ Thanks for pointing. I re-written the phrase in the answer. You can use every ASCII character in the output (as usual ASCII art). E.g. I used only + symbol, but one could makes round edges using symbols like \ or / etc.. \$\endgroup\$ – Antonio Ragagnin Apr 4 '14 at 9:55
  • \$\begingroup\$ edited again... \$\endgroup\$ – Antonio Ragagnin Apr 4 '14 at 10:09
  • \$\begingroup\$ Can you define the input that will be used by all the participants? It's necessary to have only one input to compare the outputs of the different answers. The first example is too simple and the last one is too long. So I suggest to use something between these 2 examples. \$\endgroup\$ – A.L Apr 4 '14 at 17:29
  • \$\begingroup\$ Thanks, I chosen a cute panda as input. \$\endgroup\$ – Antonio Ragagnin Apr 6 '14 at 8:09
  • 1
    \$\begingroup\$ one could let this input (…) could became → try something like "this input (…) could become" outpuit → output \$\endgroup\$ – user2428118 Apr 7 '14 at 13:31
  • \$\begingroup\$ I edited it now, so do you people thinks it is a good question? \$\endgroup\$ – Antonio Ragagnin Apr 9 '14 at 17:15
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 16:32
  • \$\begingroup\$ Hi @programmer5000 , I already asked such a question. Do you mean to re-use it again? See: codegolf.stackexchange.com/questions/26139/… \$\endgroup\$ – Antonio Ragagnin Jun 12 '17 at 13:39

Hi, first time golf questioner, hopefully I'm doing it right!

Maths Trade Calculator

A maths trade (or "math" trade if you prefer) is a way of calculating complex trades of arbitrary items in a circle of participants where not all participants want all items.

X participants have an item they would like to trade. Each participant is assigned a unique number, and provides a list of (numbers identifying) the items they would willingly trade their item for. They may provide an empty list (i.e. they would rather not trade).


X lines, one for each participant, comprising a unique number identifying them, followed by a colon, then a comma-separated-list of numbers identifying other items that they would trade for. e.g.:


The numbers identifying the participants will not necessary be in order, nor will they necessarily be 1 to X. You may assume that they will be numeric.

This string can be in STDIN, or an argument to a function, or similar and can be followed by a new-line or not, whatever the coder prefers.


One or more trade loops in which all participants are making trades they're happy with. Each loop should be on a new line and comprise a participant number, followed by "->", followed by the participant they should give their item to, then another "->", and another participant number etc, until the loop is closed and the last participant number matches the first one. Another line is added with the number of completed trades. e.g.:


Participants for which no valid trade is possible are omitted.

Output can be via STDOUT, or returned as a string, or something else, with an optional final new-line.

Trade rules

  1. A participant may not be involved in more than one trade
  2. A participant may not receive an item that they didn't want
  3. All loops must be closed
  4. Maximum number of possible trades should be completed (i.e. no submitting a zero-trade output and claiming it's valid). If there are multiple permutations, pick whichever you prefer.

This is a code golf challenge, so shortest working code wins.

Some more example inputs and possible outputs




For instance, in this trade: 9 stated that he would accept 1's item in a trade, 10 stated that he would accept 9's item, 3 would accept 10's and 1 would accept 3's. In the second loop, 2 receives 7's item, 5 receives 2's, 6 receives 5 and 7 receives 6's. (Other outputs are possible from this input.)







1->9->1 is also valid in this case, but both cannot be completed. Either is acceptable.

Thanks for reading guys! Let me know if there are any improvements I can make.

  • \$\begingroup\$ "can be followed by a new-line or not, whatever the coder prefers." How flexible is this? For instance, can I use trailing commas, like 1:2,4,7, if it makes my code shorter? \$\endgroup\$ – Martin Ender May 2 '14 at 17:28
  • 2
    \$\begingroup\$ Will the participants always be numbered 1 to n and their input lines provided in order? If so, state it. If not, include a test case which fails if an implementation decides to ignore everything before the : in each input line. \$\endgroup\$ – Peter Taylor May 5 '14 at 10:02
  • \$\begingroup\$ @m.buettner I would say a trailing comma is not acceptable, on the end of any line, or the end of the input/output. \$\endgroup\$ – Johno May 6 '14 at 8:55
  • \$\begingroup\$ @PeterTaylor Good tip. I'll correct the question to state that you can't assume that the numbers will be 1 to n, in order. \$\endgroup\$ – Johno May 6 '14 at 8:57
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 16:39

Design and Solve a Maze

(this question on hold while the details are ironed out)

Your task is to play the roles of both characters in this scene from Inception. In it, Cobb gives Ariadne a challenge:

You have two minutes to design a maze that takes one minute to solve.

Some liberties will be taken on that description. Most importantly, this challenge is not time-based, rather scores are based on the effectiveness of your mazes and maze-solvers.

I apologize for the many edits to this challenge as we iterate towards an easy and fair format..

Part I: Maze format

All mazes are square. A cell in the maze is represented as a zero-indexed tuple row column.

Walls are represented by two binary strings: one for horizontal walls (which block movement between rows) and vertical walls (vice versa). On an NxN maze, there are Nx(N-1) possible walls of each type. Let's take a 3x3 example where the cells are labelled:

A   B | C
D | E   F
G   H | I

all possible vertical walls are: AB BC DE EF GH HI. Translated into a string, the walls shown are 011001 for vertical walls and 010010 for horizontal walls. Also, by "binary string" I mean "the characters '0' and '1'".

The full maze format is a string which contains, in this order:

  • width
  • start cell tuple
  • end cell tuple
  • horizontal walls
  • vertical walls

For example, this maze:

   0 1 2 3 4
0 | |  E|  _|
1 |  _|_|_  |
2 |_ _ _  | |
3 |  _ _  | |
4 |____S|___|

is formatted to this:

4 2
0 2

Part II: The Architect

The Architect program creates the maze. It must play by the rules and provide a valid maze (one where a solution exists, and the end is not on top of the start).

input via stdin: Two positive integers:

size [random seed]

Where size will be in [15, 50]. You are encouraged to make use of the random seed so that matches can be replayed, although it is not required.

output to stdout: A valid size x size (square) maze using the format described in Part I. "valid" means that a solution exists, and the start cell is not equal to the end cell.

The score of an Architect on a given maze is

   # steps taken to solve
max(dist(start,end),(# walls))

So architects are rewarded for complex mazes, but penalized for each wall built (this is a substitute for Ariadne's time restriction). The dist() function ensures that a maze with no walls does not get an infinite score. The outside borders of the maze do not contribute to the wall count.

Part III: The Solver

The Solver attempts to solve mazes generated by others' architects. There is a sort of fog-of-war: only walls adjacent to visited cells are included (all others are replaced with '?')

input via stdin: the same maze format, but with '?' where walls are unknown, an extra line for the current location, and a comma-separated list of valid choices from this location. (This is a big edit that is meant to make it simpler to write a maze-parsing function)

example (same as the above 5x5 maze after taking one step left)

4 2
0 2
4 1
4 0,4 2

Which corresponds something like this, where ? is fog:

   0 1 2 3 4
0 |????E????|
1 |?????????|
2 |?????????|
3 | ?_?_????|
4 |__C_S|_?_|

output to stdout: One of the tuples from the list of valid choices

Each Solver's score is the inverse of the Architect's score.

Part IV: King of the Hill

Architects and Solvers are given separate scores, so there could potentially be two winners.

Each pair of architects and solvers will have many chances to outwit each other. Scores will be averaged over all tests and opponents. Contrary to code golf conventions, highest average score wins!

I intend for this to be ongoing, but I can't guarantee continued testing forever! Let's say for now that a winner will be declared in one week.

Part V: Testing

I have written a Python testing kit which includes a Maze class for parsing and writing in the proper formats, as well as an example architect/solver pair: Daedalus and the Minotaur

Available on both Dropbox and GitHub

Part VI: Submitting

  • I maintain veto power over all submissions - cleverness is encouraged, but not if it breaks the competition or my computer! (If I can't tell what your code does, I will probably veto it)
  • Come up with a name for your Architect/Solver pair. Post your code along with instructions on how to run it.
  • \$\begingroup\$ I suppose input is via STDIN? You might want to mention that explicitly, because at least the architect could just as well take the input via command-line arguments. \$\endgroup\$ – Martin Ender May 15 '14 at 15:34
  • \$\begingroup\$ updated. I have a driver/referee program which will handle I/O; I'll update it to use stdin/stdout since that will no doubt be the easiest standard. \$\endgroup\$ – wrongu May 15 '14 at 16:04
  • \$\begingroup\$ @m.buettner before de-sandboxing this, would you be willing to try the test kit? \$\endgroup\$ – wrongu May 15 '14 at 18:20
  • \$\begingroup\$ I'd love to, but I'm afraid I'm too busy this week. Try ask for help in the chatroom. \$\endgroup\$ – Martin Ender May 15 '14 at 18:35
  • \$\begingroup\$ Possible architect issue: With this scoring method (steps/walls), you can get a minimum score of 3 by simply putting the start/finish right next to each other with a single wall between. It takes three steps to go around. Most actual mazes I've seen have too many walls to make a score of 3 likely, much less guaranteed. \$\endgroup\$ – Geobits May 16 '14 at 13:51
  • \$\begingroup\$ Thats a problem. What if the dist function was shortest path? Then only mazes which cause detours could get a score > 1 \$\endgroup\$ – wrongu May 16 '14 at 15:09
  • \$\begingroup\$ That would probably be better. That way it's scored on best vs actual. It would take away the incentive to figure out how to build hard mazes with few walls, though, which was interesting itself. \$\endgroup\$ – Geobits May 17 '14 at 3:01
  • \$\begingroup\$ Hey rangu... not sure if you're still planning to do this thing, but overactor just said something in chat which reminded me of your challenge and might be a neat way to avoid the combined score: split this up into two code-challenges, one for maze generation and one for maze solving. Each code-challenge's benchmark set (to determine the scores) would be the outputs of the other challenge's participants. Then you could just pick a best solver and a best generator independently. \$\endgroup\$ – Martin Ender Aug 1 '14 at 11:18

Author note: I was thinking about new genres today, and I had an idea. What if there could be a challenge that encourages people to write good code, instead of the code-golf gibberish we all know? Here's a challenge that attempts to do that. (This could even possibly be a , which would be great because it would bring in a greater high quality question volume to the site, but I'm terrible at coming up with names. Feel free to suggest something in the comments.)

Build your own image editor


For this challenge, you will create the best GUI image editor that can perform the most tasks that you possibly can... from scratch.

Tasks and scoring

Here are the features / tasks used to score your program. Each task is worth a certain amount of points, which is specified in brackets before the task description. For convenience, each task will also be prefixed by an ID string so that you can refer to them when describing your program.

  • [1 A] Brush tool: Simple, click and drag the mouse to draw freestyle doodles. Must draw a contiguous path.
    • [1 A1] Ability to change the brush size.
  • {TODO: etc., add more}


Your editor must conform to the following requirements:

  • Must accept input via the mouse. Tools (brush, flood fill, etc.) can be switched and configured with keyboard shortcuts, by clicking icons with the mouse, through a menu, or however you would like.
  • You may not use a single built-in function to accomplish one or more of the tasks. For example, if your language has a built-in image flood fill function, you may not use it and must build your flood fill from scratch.

Final score and voting

This is the syntax you should use to describe your score in your answer:

# {language}, {your score} score
<sup>(features implemented: {A, A1, ...})</sup>

    {your code here}

{description, comments, other notes, etc. here}

The amount of votes your post has (upvotes minus downvotes) will be multiplied by {TODO: figure out a good number} and added to your score. (Do not add this to the score in your post, since votes change constantly; I will add them manually.) Voters, please vote according to the following criteria:

  • elegance and readability of the source code
  • ease of use of the image editor and how powerful it is
  • remember to sort by "active" so that you're voting for new answers too, and not just the top voted ones!
  • 3
    \$\begingroup\$ Your questions should be reasonably scoped. If you can imagine an entire book that answers your question, you’re asking too much. A really good answer to this would run into millions of lines of code. \$\endgroup\$ – Peter Taylor Jun 4 '14 at 15:52
  • \$\begingroup\$ @PeterTaylor Yes, I was a little worried about that, but if it's not broad enough, it will be easy to just implement all the features. Any suggestions for fixing this? I was thinking of adding a "brevity" criterion in the voting section, but that doesn't seem like an ideal solution. \$\endgroup\$ – Doorknob Jun 4 '14 at 16:00
  • 3
    \$\begingroup\$ To be honest, the site for good code is Code Review. They already have a monthly challenge, for which they post snippets for review. I don't see a need to copy them. \$\endgroup\$ – Peter Taylor Jun 4 '14 at 16:12
  • \$\begingroup\$ @PeterTaylor Wait, isn't Code Review for questions and answers, not challenges and contests? In any case, is there any reason for that to prevent us from posting challenges like we always have? \$\endgroup\$ – Doorknob Jun 4 '14 at 16:17
  • \$\begingroup\$ meta.codereview.stackexchange.com/questions/tagged/… . Surprised you don't know about it, given how dedicated you are to spying on them ;) In general, if a question is on topic for multiple stacks then there's no obligation to do the sensible thing and post it on the one which it best fits, but you should expect people to ask why you're not doing the sensible thing. I think you're going to have to work hard to turn this into a question which fits this site, whereas it's already a good fit for CR's challenge programme. \$\endgroup\$ – Peter Taylor Jun 4 '14 at 16:31
  • \$\begingroup\$ @PeterTaylor Hmm, that's strange. Wouldn't that be more on-topic here? (And I only occasionally pop in to their chat/meta to see what they're up to. :-P) \$\endgroup\$ – Doorknob Jun 4 '14 at 16:32

Help Joe Bloggs with his password hash

Joe was confidently using "password1" as his main password to all his accounts until one day he received an e-mail from fBay. His account has been compromised and he must change his password immediately. Yet worse, the attacker had access to all Joe's accounts. Being an engineer, Joe thought: What if I could hash somehow my password using a keyword? I wouldn't need to remember any passwords and I would have a different one for each account.

Joe then creates an algorithm - he takes the domain name as a key and creates the password for each of his account consisting of:

1. (<consonants><vowels>)(alternating case: lower, capital, lower...)
2. <number of consonants><number of vowels>
3. <sum of consonants and vowels numbers converted to a character on US Qwerty Keyboard>

Joe then opens an account on SO to create a new code golf challenge. He uses stackoverflow as a key to generate password:

1. sTcKvRfLwAoEo - consonants and vowels in alternating case
2. 94 - 9 consonants, 4 vowels
3. 9+4=13, 1+3=4, Shift+4=$

Therefore, Joe's password for stackoverflow is: sTcKvRfLwAoEo94$


Create a shortest function to generate a password given the rules above. The code should accept a string type parameter d and return/display the generated password.


  1. Only Latin letters from the input should be used. Any other characters should be ignored.
  2. Minimum input length is 1 letter. (guys at q.com need passwords as well!)
  3. Assume Y is a vowel
  4. If vowels or consonants are missing, use 0 accordingly. E.g. input a would result in a01!
  5. Shortest code wins

List of vowels and consonants

US qwerty keyboard

  • \$\begingroup\$ Thanks for the feedback @m.buettner. I meant to say, without using any libraries. The problem is, that people become lazy to think sometimes and just dive straight away to use Linq where a bit of thought will do \$\endgroup\$ – mai May 28 '14 at 13:14
  • \$\begingroup\$ Well actually you can, I'm just checking now. You can do a lot of manipulations on strings without libraries. \$\endgroup\$ – mai May 28 '14 at 13:18
  • \$\begingroup\$ Looping over string characters, concatenation work perfectly. Nevertheless, I've updated the challenge. If a function to depend on a library, it must be included in the character count. \$\endgroup\$ – mai May 28 '14 at 13:21
  • 3
    \$\begingroup\$ 1. Strictly speaking, in .Net you don't have strings without libraries. The string keyword is syntactic sugar for a class in mscorlib. 2. As things currently stand, your rule 1 strictly prohibits something and then says what to do if you ignore that prohibition. This is illogical. It's also unclear what "that" in "please inlcude that in characters count" means. Does it mean that each submission should be a program as opposed to a code snippet? If so, state it explicitly. \$\endgroup\$ – Peter Taylor May 28 '14 at 13:32
  • \$\begingroup\$ Hmm.. I don't know how to write it the best way. mscorlib is included by default so that is permissible. I don't want the code to use other libraries as Linq as it's less fun. \$\endgroup\$ – mai May 28 '14 at 13:47
  • \$\begingroup\$ @m.buettner I agree with you. Nevertheless, there will solutions provided in other languages as well (there always are). And I would like the authors of those solutions to think about the best approach in their language of choice without depending on libraries like Linq. \$\endgroup\$ – mai May 28 '14 at 14:00
  • \$\begingroup\$ Does Rule 2 mean ONLY vowels/consonants to be used from input? What about symbols *@#$ etc. Depending on that answer, potentially clarify Rule 5 regarding symbol input. As for Step 3 in the hash, should that progress further, similar to my Appended Numbers game so 103 consonants and 5 vowels would follow as 103+5 = 108, 1+0+8/10+8, etc.? \$\endgroup\$ – Matt Jun 4 '14 at 2:35
  • 1
    \$\begingroup\$ @Matt, clarified - only Latin letters are used from the input. If consonants or vowels are missing, use 0 instead. The sum should progress, until it's <=9. E.g. 103 consonants, 5 vowels: 103+5=108, 1+0+8=9. Then, Shift+9='(' \$\endgroup\$ – mai Jun 18 '14 at 10:36


Note for Sandbox: I have not finished (or really started) the control program for this game, because I wanted to see if there was interest in it before I dedicated too much time to the project. that means that the rule are still up to be tweaked, so please leave a comment if you have a suggestion, and comment or vote if you are interested in seeing this happen.

Diplomacy is a complex strategy game, with a very entertaining combat system. This challenge will be to write a bot to compete in a simplified version of diplomacy combat.



Countries (bots) will begin the game with 10 health, representing their remaining will to fight. The goal is to eliminate all other Nations by attacking them until they have 0 health.

The game will consist of several rounds. On the first round, all bots will receive 2 numbers as command line arguments: The first will be the total number of countries fighting, and the second will be their number in the list. Each following round, bots will receive a command line arguments containing the actions taken by each player last round and a list of all bots and their remaining health separated by commas, like so

 1:A2,2:S3,3:A4,4:A3 1:10,2:7,3:7,4:1

Each bot must then output a desired action, which is one two commands

  1. Attack a player. This is done by printing the letter A followed by the number of the player you with to attack. For instance, A3
  2. Support a player. This will give the player you support a boosted attack.

Resolving combat

After player have sent in their moves, attack scores will be calculated thus:

  1. All players start with a strength of 1, and one point is added for every player supporting them. For instance, if the moves are 1:A3,2:S1,3:A2,4:S2 then bot 1 has strength 2, bot 2 has strength 2, bot three has strength 1, and bot 4 has strength 1.
  2. After strength has been calculated, bots will deal damage based on their strength. The formula for damage is (Attacker's strength + 1) - (Defender's Strength) In the above situation, player 3 would take 2 damage and player 2 would take 0 damage. Note that, unlike regular diplomacy, attacking a supporter does not cut support.
  3. All attack take place simultaneously and independently. This means that if player 1 and 2 both attack player 4, then they each deal 1 damage. If player 3 were to support player 4, then player 4 would take no damage.

Round Ends

After combat has been resolved, countries that have 0 health will no longer be able to attack or support. However, they still will be listed in the input with an health of 0. When a bot is eliminated, all remaining bots will receive a single point.

Ending the game

The game ends when either 100 turns have elapsed or only 2 or less players remain. At this point, the player with the highest remaining health is the winner and receives 1 point. In case of ties, all tied bots will revive 1 point. If all bots die on the same turn, this is not a tied victory, but mutually assured destruction, and all bots will receive 0 points.


The control program will run 100 rounds of the game. The winner will be the country with the most points at the end of 100 rounds.


You may write in any language I can reasonably compile. I will make an effort to compile odd languages, but make no promises as to my ability to do so. Please provide your source code, an explanation, and a command line command to run your program.

  • You are allowed to write to a file. In fact, you are encouraged to do so.

  • Because this is a game where cooperation is paramount, you are allowed to write bots that work together, with the following restriction:

    • Only two bots can be written by a single player to work together at a time.
  • Standard Loopholes apply. You are not allowed to change the way the control program runs. If you provide invalid input to the control program, the program will just skip your turn. However, you are allowed to spy on other countries files, and all bot programs will be in the same folder at runtime. This is war, after all!

  • I reserve the right to disqualify any country that takes more than about a second to run, or that tries a loophole not mention within. That being said, if it is sufficiently clever I will probably let it go.

I will have source code up soon for a sample country that will be competing, and will post the control program when I finish it.

  • \$\begingroup\$ "In case of ties, all tied bots will revive 1 point". Is that supposed to say "receive"? "If all bots die on the same turn, ... all bots will receive 0 points." If there are two bots left, each of which has received 1 point from the earlier death of a third bot, and the two bots destroy each other on the same turn, what's the final score for the round? I'm not sure whether it's 0-0-0 or 1-1-0. "You are allowed to write bots that work together": but how can they identify each other? Do they have to use their moves as a covert channel? \$\endgroup\$ – Peter Taylor Aug 29 '14 at 14:28
  • \$\begingroup\$ "Support a player. This will give the player you support a boosted attack." Or defence. Might be clearer to say "boost that player's strength for the turn". Should also state whether or not it's possible to support yourself. \$\endgroup\$ – Peter Taylor Aug 29 '14 at 14:29

Check GenericScript source code for compiler errors

Given the source code for a GenericScript program as input, parse the source code to check that it conforms to the syntax rules for the language. The syntax definition for GenericScript is below. If a part of the source code is found to be invalid, the program should output "Invalid syntax", otherwise it should output "Valid syntax".

Win Criteria

This is code golf. Shortest code wins.


Source code will be considered to be valid if it matches the rule for "Program" below.

Program             = Sequence
Sequence            = Statement [Sequence]
Statement           = SequenceBlock | Assignment | If | While | Output
SequenceBlock       = "{" Sequence "}"
Assignment          = Identifier "=" (String | Bool); 
If                  = "if(" Bool ")" Statement ["else" Statement]
While               = "while(" Bool ")" Statement
Output              = "print(" String ");"
Identifier          = {Any sequence of alphanumeric characters prefixed with "var" }
Bool                = StringEquals | Identifier
StringEquals        = String "==" String
String              = StringConstant | OperatorConcat | Input | Identifier
StringConstant      = "'"StringContent"'"
StringContent       = Character [StringContent]
Character           = {Any character except for "'"}
OperatorConcat      = String "&" String
Input               = "read()"

Whitespace is defined as any sequence of the ascii characters 9, 10, 13 and 32. Whitespace characters are allowed between tokens but are not required.


  1. The answer should be a complete program
  2. Standard input/output allowed
  3. Standard loopholes apply
  4. Universally testable answers only

Test Input

Valid syntax:

print('What is your name?');
varInput = read();
print('Hello ' & varInput);

Invalid syntax:

if(read() == 'DoTask1')
  print('Executing you'r command');

Text Adventure Game


Your goal is to develop a complete text-based adventure game with the shortest code possible. The player navigates in a dungeon composed of rooms. The game objectives are to find the treasure, slain the dragon and rescue the princess.


A room description is as follows:

You are in <description>.
You can go <exits>
You see <object>      (optional)
  • exits can be "north", "east", "west", "south".
  • description can be "a adjective cavern", "a adjective room", "a adjective corridor", "a adjective hall", "a cell", "the dragon's lair".
  • adjective can be "dark", "murky", "small", "large", "narrow", "gloomy", "huge", "strange", "tiny", "broad", "old".
  • object can be "the princess", "the dragon", "a troll", "a goblin", "a sword", "gold", "a key", "a trunk".

Exit list must be comma-separated and end with "and". If there is no object in the room, the last line is omitted.

Example of valid description:

You are in a murky room.
You can go north, east and south.
You see a goblin.

The game accepts the following commands (case is ignored) :

  • GO direction : direction can be NORTH, EAST, WEST, SOUTH
  • TAKE item : item can be SWORD, GOLD, KEY
  • KILL monster : monster can be DRAGON, TROLL, GOBLIN. The DRAGON and the TROLL can be killed only if the user has the SWORD. If he hasn't, he loses the game. The weak GOBLIN can be killed with bare hands. When a monster dies, he disappears from the room. When the GOBLIN dies, he drops a SWORD. When the TROLL dies, he drops a KEY.
  • KISS person : person can be PRINCESS, DRAGON, TROLL, GOBLIN. Kissing the princess validates one of the objective of the game, and the princess disappears from the room. Kissing a monster results in player death.
  • OPEN object : object can be TRUNK. If the player has the KEY, the TRUNK object disappears and is replaced with GOLD.

The player can perform an action on an object only if the object is in current room. A room can contain only one object ; a given object can be found in only one room. At the beginning of the game, only the following objects are placed in the map : PRINCESS, DRAGON, TROLL, GOBLIN, TRUNK. Other objects are not yet created.


  • If an action cannot be performed (e.g. GO NORTH where there is no exit to the north, or TAKE DRAGON, or DANCE GANGNAM STYLE), the message "Sorry, I can't do that" must be displayed.
  • If an action can be performed, the message "OK" and the current room description should be displayed.
  • You can read game commands from console or as a program parameter, as you wish.

The dungeon should have at least 30 rooms. The dungeon should not contains a series of more than 5 exits in the same direction. The exits between rooms must be consistent, e.g. if you go north from room #1 to room #2, there must a south exit in room #2 leading back to room #1. Every room name should be unique. There must be at least one room of each kind (hall, cavern, corridor...)

  • A hall has at least 3 exits.
  • A corridor can have only 2 exits.
  • The cell has only one exit.
  • There is only one dragon's lair and only one cell, containing respectively the dragon and the princess.

The game ends when the player has been killed, or when he has taken the gold, slain the dragon and kissed the princess.

  • If the player dies, the message "You have been killed by X !" is displayed, with X being the name of the monster.
  • If the player wins, the message "Well done adventurer ! you've conquered the dungeon." is displayed.

Player should not be able to win the game in less than 40 turns.


You are in a murky room.
You can go north, east and south.
You see a goblin.
You are in a murky room.
You can go north, east and south.
You see a sword.
You are in a murky room.
You can go north, east and south.
You are in a narrow corridor.
You can go south and east.  


The shortest code wins.

  • \$\begingroup\$ @Martin Thanks for your comments! I've updated the question. \$\endgroup\$ – Arnaud Aug 21 '14 at 7:59
  • \$\begingroup\$ Provided the player ignores the troll and goblin (i.e. doesn't try to kiss or kill them), they don't do anything? \$\endgroup\$ – Peter Taylor Aug 21 '14 at 8:30
  • \$\begingroup\$ @Peter you're right. Maybe the player should kill (with bare hands) the goblin in order to get the sword, and then kill the troll (with the sword) to get the key. \$\endgroup\$ – Arnaud Aug 21 '14 at 8:50
  • \$\begingroup\$ "The map must be spatially coherent" still doesn't disallow always going left without ending up in the same room twice, unless you specify that the rooms are all meant to be square (which is what I think you had in mind). Also, I still think that "at least" 30 rooms is unnecessary. Who would implement 8 additional rooms if they don't have to. It will definitely be shorter if I omit the two longest adjectives and just use all available combinations of the remaining ones (giving 30 unique rooms). So you can omit two adjectives and the "at least" right away, I'd say. \$\endgroup\$ – Martin Ender Aug 21 '14 at 9:19
  • \$\begingroup\$ I think it's fine to keep "at least" there for flavour, same with additional adjectives. Also, someone might figure out a way to make the code shorter with a longer adjective (for that reason, having a few more adjectives might be nice) \$\endgroup\$ – FireFly Aug 21 '14 at 9:38
  • \$\begingroup\$ @Martin I've added a criteria "Player should not be able to win in less than 30 turns", to force the golfer to implement more rooms. \$\endgroup\$ – Arnaud Aug 21 '14 at 9:39
  • \$\begingroup\$ @SuperChafouin That doesn't force it though. I just need to place the goblin at the end, troll at the beginning, trunk at the end, so that you need to traverse the map 3 times. \$\endgroup\$ – Martin Ender Aug 21 '14 at 9:51
  • \$\begingroup\$ @Martin It's also here to prevent the dungeon to be too straightforward to solve, e.g. if all the objects are in 5 adjacent rooms near the player start location. \$\endgroup\$ – Arnaud Aug 21 '14 at 10:51
  • \$\begingroup\$ +1 for golfing in Inform 7. \$\endgroup\$ – Lopsy Sep 20 '14 at 2:56
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) Due to community guidelines, if you don't respond to this comment in 7 days I have permission to adopt this. \$\endgroup\$ – programmer5000 Jun 9 '17 at 16:58
  • \$\begingroup\$ @programmer5000 Yes no problem :-) \$\endgroup\$ – Arnaud Jun 10 '17 at 1:07

Simulate a Quantum Circuit

Work-in-progress until I can make sure I know what I am doing and can finish the spec. or maybe

Quantum computers are the way of the future! Why wait, when you can simulate one now?

Your mission is to determine the output of a quantum circuit given its input and a diagram of logic gates.


You will simulate a single quantum register and apply a series of quantum logic gates to it. A quantum register is a group of qubits. The state of a register is described by a vector of 2^N complex numbers, where N is the number of qubits in the register.


Above is a representation of a 3-qubit register. Each letter (a b c etc.) represents a complex number. There is an addition restriction that:

|a|^2 + |b|^2 + |c|^2 + |d|^2 + |e|^2 + |f|^2 + |g|^2 + |h|^2 = 1

Quantum gates

Gates are represented by a 2^N x 2^N square unitary matrix, where N is the number of input qubits. All quantum gates have the same number of outputs and inputs, since they neither create nor destroy qubits, they modify them.

A common quantum gate is called the Hadamard gate and acts on a single qubit. The matrix [H] looks like this:

1/Sqrt(2)  1/Sqrt(2)
1/Sqrt(2)  -1/Sqrt(2)

If we let [R] represent the following 1-qubit register:


Then the application of the gate is represented by [H][R] and gives the following result:


It is still true that the sum of the squares of the absolute values is equal to 1.

(TODO: explain how to apply gates to larger registers)


Measurement collapses the state of the quantum register.

(Todo: Explain how measurement works)





The goal of this challenge is to implement an AI for the game of BS, also known as Bull Shit, Cheat, Bluff, and numerous other names.

The game is outlined in this wikipedia article.

The Rules of the Game

For the purposes of this challenge, the game will work like this:

  1. A standard 52-card deck is dealt out to the players
  2. The current rank is set to Ace
  3. The play order is randomized
  4. The player holding the Ace of Hearts goes first
  5. On each player's turn:
    1. The current player plays some number of cards
    2. The current player states how many of what rank they played
    3. Other players may declare 'BS'.
    4. If any player declares 'BS':
      1. All players are notified of which players declared 'BS'.
      2. The played cards are revealed to all players.
      3. If the played cards are inconsistent with the current player's statement:
        • The current player adds the played cards and all cards in the pile to their hand
      4. If the played cards are consistant with the current player's statement:
        • The last player to declare 'BS' that round adds the played cards and pile to their hand.
    5. If no player declares 'BS':
      1. The played cards are added to the pile, without revealing them.
      2. If the played cards were inconsistant with the current player's statement, the current player may declare 'Peanut Butter'.
    6. If the current player has no cards in their hand, the current player wins.
    7. The current rank is incremented. (If the current rank is King, it becomes Ace.)

The Messaging Protocol

Play will be conducted via messages passed to the standard input and received from the standard output of each program. Each message will be terminated with a single newline character.


Card ranks are represented as one of A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, or K. Card suits will be represented as one of S, C, H, or D. Cards are represented as the rank, followed immediately by a suit. For instance, the Ten of Clubs would be represented by TC, and the Three of Hearts would be represented by 3H.

A hand of cards will be represented as a space-delimited sequence of cards. For instance, a hand containing the Queen of Spades and the Six of Diamonds could be represented as QS 6D or 6D QS.

Player Identification

A player will be represented by their nickname, followed by a number from 0 to 32768, in parenthesis, formatted as an integer. This number is guaranteed to be unique within a particular game. A player's nickname must have at least one character, can have up to 32 characters, and may only include letters, numbers, and underscores. For instance, a player with nickname ExampleAI and ID number 16480 would be identified in the game as ExampleAI(16480).

When the game begins, each program will recieve a message containing their unique ID:

Unique ID: uniqueID

Each player will reply with their desired nickname:

Nickname: name

Names may contain only alphanumeric characters and underscores.

After all players have responded with their nickname, the standard play sequence begins.

Standard Play Sequence

When a player's turn begins, each player will receive a be given a list of the players and their card counts, in order of play:

Players: player[count], player[count], ... player[count]

Each player will be informed of the contents of their hands:

Hand: initial_hand

The current the player will then receive this message:

Your turn: current_rank 

The current player will reply with a space-separated list of of cards:

Play: list_of_cards

Once they have submitted their play, all players will receive the number of cards, formatted as an integer, along with the current rank:

Player player plays: nunber_of_cards x current_rank

Each other player may then declare BS on that play by sending any message up to 32 characters, containing the capital letters B and S, and otherwise only contains lowercase letters and spaces. So any of Bull Shit, Bananna Split or Bacon Sandwich would be acceptable.

During this period, the current player may declare Peanut Butter by sending any message up to 32 characters, as long as it contains the capital letters P and B, and otherwise only contains lowercase letters and spaces. So any of Peanut Butter, Pancake Batter or Polish Bacon would be acceptable.

In order to allow the game to move faster, if a player does not wish to declare either of these things, they must instead send:


After all players have responded, all players will receive a list of players who called BS, in the order they called it:

Called BS: player, player ... player

If no player called BS, this message will still be sent --- it just won't have any players listed. If any player did call BS, then all players will recieve:

Player player had played: list_of_cards

If they were bluffing, all players recieve:

Player player was bluffing.

And the current player receives:

Your bluff was called: list_of_cards_recieved

If they were not bluffing, all players recieve:

Player player was not bluffing.
Player last_player receives the pile.

The last player who called BS recieves this message:

You misjudged: list_of_cards_received

The list of cards received will contain, in reverse chronological order, the contents of each play since the last call. (Separate plays will not be delimited in the list.)

If no player declared BS, and the current player was bluffing and declared Peanut Butter, then all players recieve the message:

Player player was bluffing.

If the current player has no cards left in their hand, all players receive this message, and the game terminates:

Player player won!

Otherwise, the next player's turn begins.

Example Game

The following might be considered a typical (abbreviated) message transcript:

Unique ID: 16481
> Nickname: Alice
Players: Alice(16481)[18], Bob(16479)[17], Charlie(16480)[17]
Hand: 2D 7S AS TC 5S JS JC 3C 8H 9D 5D AH 7C 6C 4D KC KH KS
Your turn: A
> Play: AS 2D AH
Player Alice(16481) plays: 3 x A
> PB
Called BS:
Player Alice(16481) was bluffing.
Players: Bob(16479)[17], Charlie(16480)[17], Alice(16481)[15]
Hand: 7S TC 5S JS JC 3C 8H 9D 5D 7C 6C 4D KC KH KS
Player Bob(16479) plays: 2 x 2
> BS
Called BS: Alice(16481)
Player Bob(16479) had played: 2H 2C
Player Bob(16479) was not bluffing.
Player Alice(16481) takes the pile.
You misjudged: 2H 2C AS 2D AH
Players: Charlie(16480)[17], Alice(16481)[20], Bob(16479)[15]
Hand: 7S TC 5S JS JC 3C 8H 9D 5D 7C 6C 4D KC KH KS 2H 2C AS 2D AH
Players: Alice(16481)[3], Bob(16479)[41], Charlie(16480)[8]
Hand: KC KH KS
Your turn: K
> Play: KC KH KS
Called BS: Charlie(16480), Bob(16479)
Player Alice(16481) was not bluffing.
Player Bob(16479) receives the pile.
Player Alice(16481) won!

Your implementation may be written in any language, provided that you, upon request, provide a link to a suitable free-as-in-freedom compiler or interpreter that I can download and run at no cost. You also need to provide a UNIX command that can start your program.

Sandbox Questions

I want to gauge the community's interest in my problem before finalizing the spec and writing the control program.

I also need to get some idea of what sort of time-limiting scheme would be reasonable. In order to be able to to a lot of runs, I will need to be able to ensure that each AI doesn't take too much time to make its decisions, or prevent a stuck AI from holding up a game. I also need to be able to ensure that there is no motivation to deliberately stall a game. For example, if an AI determines that it is very unlikely to win, it might stall in order to prevent the game from finishing.

I would also like feedback on the messaging protocol:

  • Are there any additional messages that you think should be passed?
  • Would it be more convenient/clear if one or more of them were formatted differently?
    • Would it be better to use a different format for the plays message?
    • Would it be better to use different words to help distinguish the plays and played messages?
  • \$\begingroup\$ It looks like quite a tough challenge, but should be enjoyable! \$\endgroup\$ – Alexander Craggs Sep 4 '14 at 16:54
  • \$\begingroup\$ @PopeyGilbert By the way, there was one thing I accidentally left out that I need feedback on. Specifically, time limits - to deal with intentional stalling, getting stuck, or taking too long to decide. \$\endgroup\$ – AJMansfield Sep 4 '14 at 17:05
  • 1
    \$\begingroup\$ A question and a feedback. Does our program run as "stop and run" or must receive feedback continuously? And for feedback. I honestly think that the whole username things is kinda confusing. Maybe if you just use only unique id? (Like just simple 0,1,2,3 instead of username) \$\endgroup\$ – Realdeo Sep 5 '14 at 8:33
  • \$\begingroup\$ Oh! More things! I also realize that suit doesn't really matter, right? (We only use suit for deciding who goes first), so fmpov, you can ditch the communication protocol for the suit. (No need for S,C,D,H) We can just use simple random from the computer. Question: What will happened if everybody make infinity loop of pass. For time limit, I prefer 1 second. If no response, make it auto pass. (KOTH chess time limit is 2 seconds. That's why 1 second is good enough) \$\endgroup\$ – Realdeo Sep 5 '14 at 8:38
  • \$\begingroup\$ @Realdeo Card suit is also used to distinguish between separate instances of a card. If Alice plays 3x2 (2S 2D 2C), is not revealed, and Bob gets the pile later, and then Bob plays 3x2 (2S 2C 2H), and this is revealed, it is important for Alice that she knows all four Twoes have passed through Bob's hand. There are other ways that can be used as well. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:29
  • \$\begingroup\$ @Realdeo I am not sure what you mean by "Does our program run as "stop and run" or must receive feedback continuously?". If you mean, "Does an AI program halt in the periods where no response is expected from it?" the answer is no. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:32
  • \$\begingroup\$ @Realdeo If everybody makes an infinity loop of pass, then eventually someone will run out of cards, since you are required to play at least one card each turn. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:33
  • \$\begingroup\$ @Realdeo Which is why making a automatic pass after a timeout not work when waiting for a player to decide their play. Perhaps a simple rule like 'if you take more than 1 second to decide what to play, four cards are selected at random from your hand'. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:36
  • \$\begingroup\$ And if a player has less then 4 cards? I think in some AI website, like aigames.com, they're like forced to give up that hand? You really want to test your entry before put them in the arena(like vsing a bot dummy?) Either way, this is a good challenge =) \$\endgroup\$ – Realdeo Sep 5 '14 at 13:40
  • \$\begingroup\$ @Realdeo Also note that you can actually play more than four cards in one play. A case where you might wish to do this is when: the next player is very close to winning and some other player is close to winning and you believe(all opponents believe(your next opponent will bluff) and the next opponent will not bluff and the next opponent believes(the other opponent close to winning will call BS against them)). A little convoluted, but could happen. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:42
  • \$\begingroup\$ @Realdeo Just to explain what I mean, is that there are two people close to winning, each of which would like to dump a large stack of cards on top of the other. Because of this, they both let your obvious bluff slide because they believe that will let them dump a large stack on the other. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:47
  • \$\begingroup\$ Don't worry I understand. This is a really famous high school game in my country. It just... a little bit too complex for CR. When I saw chess KOTH, I was kinda pessimist. This one? This may deserve it's own AI website. #seriously. I'm just trying to simplify this game =) \$\endgroup\$ – Realdeo Sep 5 '14 at 13:50
  • \$\begingroup\$ Let us continue this discussion in chat. \$\endgroup\$ – AJMansfield Sep 5 '14 at 13:50
  • \$\begingroup\$ RE the messaging service, I think the other players should be able to see how many cards the other players have. Also, card counting should be prohibited because that would make the game too easy. \$\endgroup\$ – Beta Decay Sep 10 '14 at 17:31
  • \$\begingroup\$ @BetaDecay First off, according to the protocol, every player is informed of every other player's hand size at the beginning of every round. \$\endgroup\$ – AJMansfield Sep 10 '14 at 18:27

Let's talk about this...

I am planning on hosting a King of the Hill challenge in which bots will have to coordinate each other in order to be successful. The idea is to play a Diplomacy-like game between bots. The engine (still in development) will start the bots and communicate with them via stdin/stdout. There will be three phases:

0. Initialization

Well, this is not a recurring phase, it is just the engine telling each bot his id, the total number of bots participating and a seed, which can be used for generation of pseudo-random numbers (bots need to be deterministic).

1. Talking Phase (10s)

In the Talking phase, bots can send messages to each other (via engine) in order to coordinate their actions. To this end, a common language is necessary. This language should be able to express any ideas, plans and opinions a bot could have. However, not every bot is forced to be able to understand everything. Simpler bots might just ignore messages they do not understand.

Since I would like each player to be able to submit more than one bot, it is forbidden to implement a "secret handshake" by which bots recognize each other and from then on work together unconditionally.

2. Planning Phase (2s)

In this phase, bots submit what they want to do this turn. Each bot has a certain amount of supply (initially five), and can command one action per supply point. There are three possible actions:

  1. Attack another bot
  2. Support another bot's attack against a third bot
  3. Defend another bot

There are some restrictions:

  • Per opponent, you can either attack or defend them, and only once
  • You cannot support an attack against a bot you also defend
  • You cannot attack, defend, support yourself or a dead bot, and neither can you support attacks against yourself

3. Resolution Phase (as short as possible)

After all orders have been submitted, the engine will resolve them simultaneously in the following way:

The defending strength of each bot is the number of bots defending that bot. The attacking strength of each attack is the number of support orders for that attack. Each attack with an attacking strength greater than the defending strength of the attacked bot results in the supply counter of the attacked bot being reduced by one, and the supply counter of the attacker being increased by one.

Support orders which support a non-existent attack do nothing.

Then, all bots with supply of zero or less will be shut down by the engine: they died.

Afterwards, all remaining bots are informed about the decisions of other bots, and a new turn begins with its Talking Phase.

Further Rules

A game will consist of ten plus random number turns, so that "last turn betrayals" are not possible. The supply count of each bot will count towards their total score. I plan an ensemble of about 100 games. The bot with the highest total score wins. Tie-breaker will be the popularity (number of votes).

I am interested in your opinion: do you think that this challenge is too complex? I imagine that the code of a decent bot would be too long to fit in a post. So people would have to use github or pastebin or similar to submit their entries. The main problem imo is the interpretation of the (yet to be determined) common language.

  • \$\begingroup\$ I like it a lot. One possible variation would be to make the "secret handshakes" a feature. To do this, you could allow multiple instances of the same bot. Then part of the challenge is to recognise your own kin and mutually support them; and a viable strategy is to try and work out other players' secret handshakes and imitate them. If you're ok with emphasising this aspect of it, then you can make the shared language pretty unrestricted, e.g. bots can just send arbitrary strings to each other. (I realise this is not what you have in mind, I just thought I'd mention the idea.) \$\endgroup\$ – Nathaniel Oct 31 '14 at 15:13
  • \$\begingroup\$ @Nathaniel, what you propose is a battle of obfuscation/cryptography. What I would like to see is a battle of diplomacy. \$\endgroup\$ – M.Herzkamp Nov 2 '14 at 14:27
  • \$\begingroup\$ Fair enough - I just thought I'd say it in case it sparked any interesting thoughts for you, but I knew it was probably too different from what you want to see. If I have any other ideas about your challenge I'll let you know. Designing the language really seems to be the hard part. \$\endgroup\$ – Nathaniel Nov 3 '14 at 0:06
  • \$\begingroup\$ A diplomatic KOTH is something I've been wanting to see for a while. Working out the specifics of the "diplomatic language" is going to be the most difficult part. My proposal is that each message can either 1) state an intention to another bot, or 2) request an action from another bot. Each message would be formatted in a way similar to how a final command would be. \$\endgroup\$ – PhiNotPi Nov 9 '14 at 14:45
  • \$\begingroup\$ @PhiNotPhi: Thanks for the Feedback! I also imagined something similar with the ability to link atomic statements in a boolean fashion. \$\endgroup\$ – M.Herzkamp Nov 11 '14 at 9:23
6 7
9 10

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .