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

Sandbox FAQ


To post to the sandbox, scroll to the bottom of this page 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, though you can optionally add a title at the top. 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, and replace the post here with a link to the challenge and delete the sandbox post.


The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.


Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Get the Sandbox Viewer to view the sandbox more easily!


4199 Answers 4199

88 89
91 92

CAPTCHAs (Cops and Robbers Style)

Cops will write a program that generates a CAPTCHA (either through stdin/stdout or on whatever UI is available to your language using only built-ins).

Robbers will attempt to bypass the generated CAPTCHA programmatically, given access to the Cops' programs' stdin/stdout or UI process/thread (for example, in JavaScript, running on the same document and window).

I need help fleshing this idea out a little more... any suggestions will help.

  • 1
    \$\begingroup\$ How are you going to ensure that captchas are actually captchas, and not an encrypted string turned into an image? The only way I can think to ensure that we're actually dealing with Captchas is to have humans solve them, which would add another layer of complexity to this challenge. \$\endgroup\$ Jul 29, 2016 at 16:03
  • \$\begingroup\$ @NathanMerrill Well, part of the requirement of a CAPTCHA is that humans should be able to pass the test without just guessing, but I don't know how to make that a more concrete requirement. Perhaps "The required input from an end-user should be visible and somewhat readable in the presented image / ascii-art"? \$\endgroup\$ Jul 29, 2016 at 16:08
  • \$\begingroup\$ Right, that's super broad. Unless you have some sort of test where users actually fill out the captcha, I think its going to remain broad. (Unless you can think of another way to test) \$\endgroup\$ Jul 29, 2016 at 16:12
  • \$\begingroup\$ @NathanMerrill I could volunteer to test by running and filling out a CAPTCHA, and give objective feedback whenever an answer is posted, saying whether the CAPTCHA cop submission is acceptable or not. Would that be a sufficient test? \$\endgroup\$ Jul 29, 2016 at 16:14
  • \$\begingroup\$ Unfortunately not. It'd be like challenges that say "Write the cleanest code, judged by me". \$\endgroup\$ Jul 29, 2016 at 16:15
  • \$\begingroup\$ @NathanMerrill here's an idea. I can add the popularity-contest tag by allowing voting of a cop submission to be based on the human usability. Then I don't have to define exactly what criteria makes a CAPTCHA acceptable. \$\endgroup\$ Jul 29, 2016 at 16:25
  • \$\begingroup\$ That would theoretically work. Historically, though, popularity contests that have worked work because people would vote up based on the "wow factor". Aka, generate an image with limitation X, and people upvote and say "Wow, that's a impressive rendering". You'd really have a hard time getting to people vote based on "this is readable", but that's a personal opinion. I don't think it would be off-topic though. \$\endgroup\$ Jul 29, 2016 at 16:28

Create me a Brainf*** assembler

Write a way to convert "human readable" assembly (of any kind) to Brainf***. I.E specify a language "X" (which may already exist or may be your own invention), and create a way to map each valid program to a valid Brainf*** program. This is a so the most convenient assembler as evidenced by upvotes wins!

  • \$\begingroup\$ Convenient is a very broad criterion for judgement. I'd recommend specifying a particular variety of assembly, then make it a code golf challenge. \$\endgroup\$ Jul 29, 2016 at 22:46
  • \$\begingroup\$ @NathanMerill can I specify a specific language I have in mind? \$\endgroup\$ Jul 29, 2016 at 23:06
  • \$\begingroup\$ @NathanMerrill and then make it code golf \$\endgroup\$ Jul 29, 2016 at 23:06
  • \$\begingroup\$ Yes, that would be on topic, but not necessarily interesting, depending on the target language \$\endgroup\$ Jul 29, 2016 at 23:15
  • \$\begingroup\$ github.com/rjhunjhunwala/S.I.L.O.S that is the target language, and since both BF and S.I.L.O.S are turing complete it seems possible, but challenge \$\endgroup\$ Jul 29, 2016 at 23:16
  • \$\begingroup\$ You would need to include a complete specification of the language on your post, but I have no idea if that would be interesting \$\endgroup\$ Jul 29, 2016 at 23:19
  • \$\begingroup\$ @Nathan Merrill all in all I think it seems to be a ridiculous challenge. Any non tricial in brainf*** is a challenge, now making code to generate non trivial brainf*** is impossible \$\endgroup\$ Jul 29, 2016 at 23:20
  • \$\begingroup\$ @NathanMerrill I will delete this challenge as it seems to be uninteresting? \$\endgroup\$ Jul 29, 2016 at 23:21
  • \$\begingroup\$ It's much easier to generate BF than to handwrite it. I don't know if it would be interesting, that's up to the community \$\endgroup\$ Jul 29, 2016 at 23:23
  • \$\begingroup\$ It seems that it is challenging to write any reasonalbly readable environment for assembling to brainf*** \$\endgroup\$ Jul 29, 2016 at 23:27
  • \$\begingroup\$ what if I choose X to be Brainfuck or Brainfuck+one extra command. \$\endgroup\$
    – KarlKastor
    Jul 30, 2016 at 19:49
  • \$\begingroup\$ Than you would likely lose. @KarlKastor. It is not code-golf but rather popularity-contest \$\endgroup\$ Jul 30, 2016 at 19:50

King of the golf course

Write a program that golfs Brainf*** programs. Similar to challenges on this site, you will be racing against the clock, and the byte count to maximize glory (reputation). Each program will be invoked with a series of command line arguments in this form

in out in out in out
Each program then has 1000 milliseconds to write a valid brainf*** program to botName.txt. This brainf*** program will take in a null terminated input from stdin and output the respective output according to the table. The code which writes the shortest programs as evidenced by the shortest of 5 runs (or more) will be crowned the winner with a green checkmark. Please note that my languages I support is limited and I may have to download the interpeter. I will have to disqualify non-free interpreters unless volunteers already possessing the interpereter/compiler are willing to help out.

  1. You may assume that anywhere from 15-30 in and out pairs will be provided.
  2. You may assume that inputs and outputs are valid english words from Random House Dictionary
  3. You may assume a non wrapping brainf*** implementation with byte values for cells and a tape size of no less than 30k cells
  4. The outputted bf programs may be of any length, but your submission may be no more than 10 kilobytes long (to prevent hardcoding)
  5. Invalid submissions will result in immediate disqualification until a bug patch is uploaded

  • \$\begingroup\$ I'm unsure why this is a KoTH. Why not simply make it a fastest-code? Also, I'd recommend making the number of in/out pairs larger (anywhere from 10 to 50). \$\endgroup\$ Jul 31, 2016 at 1:11
  • \$\begingroup\$ @NathanMerrill so should I just make 10 - 50 pairs, and allow anyone to submit their fastest code although programmers with faster computers will win. \$\endgroup\$ Jul 31, 2016 at 1:15
  • \$\begingroup\$ No. With fastest-code, one person (probably you) will run the submission themselves (just like in a KoTH) to provide fair scoring. \$\endgroup\$ Jul 31, 2016 at 1:20
  • \$\begingroup\$ @NathanMerril ok sounds good. \$\endgroup\$ Jul 31, 2016 at 1:22
  • \$\begingroup\$ @NathanMerril I will give the programs 1000 milliseconds to output the shortest programs they can, and the average shortest output programs after a few runs wins. \$\endgroup\$ Jul 31, 2016 at 1:27
  • \$\begingroup\$ Hmm. That sounds more like a code-challenge then (just with a time limit) \$\endgroup\$ Jul 31, 2016 at 1:33

Expand constants in a Brainfuck program


When golfing in Brainfuck, Fred can never remember the shortest way to write any given constant, and looking it up takes too much time! Luckily, Fred remembered that PPCG can help! In this challenge, you'll need to convert base-10 numerals their Brainfuck representations.


Write a program or function that takes a string of Brainfuck code containing some numbers, like this:


and transforms each number into one of its Brainfuck representations, giving (for example) this:


Because Fred has not yet learned the secrets of Ctrl+C Ctrl+V, your code must be as small as possible to save Fred some valuable typing. Fred also wants to win contests with the output, so the code you generate must also be as small as possible.


  • Standard loopholes are forbidden; in particular, you cannot scrape http://esolangs.org/wiki/Brainfuck_constants (or any other site for that matter).
  • Your program or function may perform I/O through any of the default I/O methods.
  • Assume a wrapping implementation with 1-byte cells (i.e. -. gives ÿ (255)).
  • There will never be a number greater than 255 or less than 0 in the input (but you do have to handle 0 correctly!). Your program/function must handle all numbers 0-255 (inclusive).
  • You may assume that there are as many temporary cells as necessary to the right of the pointer location (but not the left).
  • You may assume that the cell where a number will go and all temporary cells are set to 0.
  • When substituting a number, the pointer must end at the cell with the number. All temporary cells must be reset to 0.
  • You may assume that there will never be any non-Brainfuck, non-digit characters in the input, and that the input will never be empty (i.e. the input will match /^[,\.\[\]+\-<>0-9]+$/).

Test Cases

The test cases given below are the output for a program/function using the shortest "wrapping" version of the constants at http://esolangs.org/wiki/Brainfuck_constants.

Brainfuck program's output




(cat - outputs the input)


Your score is your byte count plus the average length of your program/function's output for each number. For example, if a 30 byte program's output had an average length of 13.5, its score would be 30 + 13.5 = 43.5.

Helpful Hints

Sandbox Questions

Is it tagged correctly? Should this be instead of ?

  • 1
    \$\begingroup\$ To prevent hardcoding, add the length of the output to their score \$\endgroup\$ Jul 31, 2016 at 13:52
  • \$\begingroup\$ I don't understand "the code you generate must also be as small as possible." The spec requires using the "shortest Brainfuck representation according to esolangs.org/wiki/Brainfuck_constants", so the code generated should be identical for every valid answer, surely? \$\endgroup\$ Aug 1, 2016 at 14:21
  • \$\begingroup\$ @PeterTaylor Oops! Forgot to remove all references to that URL. I'll fix that now. It's meant to be optional to use it, a previous version of the spec required it. \$\endgroup\$
    – Copper
    Aug 1, 2016 at 14:37

Convert hexagonal coordinates to index

Your job is to, given the size of the hexagon and a pair of axial coordinates, return the index as if all the rows were laid out side by side.

Here's an example mapping for size 3:

(q,r), 3

       (0,0) (1,0) (2,0)
    (-1,1) (0,1) (1,1) (2,1)
(-2,2) (-1,2) (0,2) (1,2) (2,2)
   (-2,3) (-1,3) (0,3) (1,3)
      (-2,4) (-1,4) (0,4)

maps to

    00 01 02
  03 04 05 06
07 08 09 10 11
 12 13 14 15
  16 17 18

Here's the formula I found (could be improved):


i = q + sum( ( 2 * s - 0.5 - abs( x - s + 0.5 ) ) for x in 1..r )

Test cases (0-based indexing):

(q, r, s) -> i

(0, 0, 1)  -> 0
(0, 0, 50) -> 0
(0, 3, 3)  -> 14
(-3, 5, 4) -> 28
(5, 2, 12) -> 18

Meta notes:

  • Should I include links to axial coordinates and centered hexagonal numbers?
    • Or, instead, should I explain axial coordinates better?
  • Should I include the formula I came up with?
  • More test cases, or are those fine?
  • More exposition?
  • I'm also planning to do a challenge the other way around, is that ok?
  • 1
    \$\begingroup\$ This technically isn't related to Hexagony (though, you can keep the reference if you'd like). I personally wouldn't include the formula, but that's my opinion. The reverse challenge seems like a good one as well. \$\endgroup\$ Aug 3, 2016 at 15:58


  • Your program must take no input and print this text.
  • You can have trailing newlines, and spaces after lines.
  • You must not use a builtin or load the text for an external resource.


This is , shortest answer in bytes wins.

Did you guess what was the text?

  • \$\begingroup\$ 10/10 very creative and interesting \$\endgroup\$
    – Leaky Nun
    Aug 4, 2016 at 11:17
  • 2
    \$\begingroup\$ What is special about the text and means that the answers won't use the exact same techniques as previous kolmogorov-complexity questions? \$\endgroup\$ Aug 4, 2016 at 13:35

Your task is to print the Champernowne constant (A033307) indefinitely.

There must be no spaces in your output and the solution with the fewest bytes wins!

  • 1
    \$\begingroup\$ 1. The Cham-whatever constant has infinitely many digits, making this challenge the same as this \$\endgroup\$
    – Leaky Nun
    Aug 4, 2016 at 18:23
  • 1
    \$\begingroup\$ 2. Duplicate. \$\endgroup\$
    – Leaky Nun
    Aug 4, 2016 at 18:25
  • \$\begingroup\$ @LeakyNun To prevent this being a duplicate could the challenge be "Print the Champernowne constant in base n", where the input is the base? \$\endgroup\$ Aug 5, 2016 at 14:35
  • \$\begingroup\$ Also, this question isn't self contained. If you were to post an acceptably modified version of this, please explain what this constant/sequence is within the question itself, even if there is a link \$\endgroup\$ Jan 20, 2017 at 1:03

Point Triangulation

(title suggestions welcome)

Triangulation has been used for hundreds of years for land mapping and cartography, until the widespread proliferation of satellite positioning systems. Essentially, if you know two fixed points, A and B, you can uniquely describe a third point C by describing the angles BAC and ABC (the angle-side-angle postulate). The challenge here will be to solve for C.


  • Two rays (half-lines) of the form [(a point in x,y coordinates), (a direction in degrees or radians)] in any convenient format.
  • The input angle will be relative to the Cartesian plane, i.e., an input of 0 degrees will have the ray parallel to the x axis and pointing toward x=+inf, and will follow traditional Euclidean convention that the angle increases counter-clockwise (e.g., 90 degrees is "straight up" toward y=+inf, 180 is "straight left" toward x=-inf, etc.).
  • Please specify in your description the input format you're using.


  • The corresponding third x,y coordinate where the rays intersect, thus forming the triangle.
  • If the input will not form a triangle, you can output an error, crash, output nothing, etc., so long as your code terminates. (META - is this too harsh? Should the input be guaranteed to form a triangle?)


[(1,0,90), (0,1,0)] -> (1,1)
[(1,0,90), (0,0,45)] -> (1,1)
[(1,0,90), (0,1,180)] -> undefined

additional examples forthcoming


  • 2
    \$\begingroup\$ I know this is still a WIP, but this challenge has a bit of a red flag for "almost" parallel lines and floating point. When working on it you should come up with a range of inputs that won't cause too many accuracy woes. In addition, I think you need to specify that the geometry should be Euclidean, and that angles follow the convention of being measured counter-clockwise. \$\endgroup\$ Jun 7, 2016 at 18:38
  • \$\begingroup\$ Intersecting vectors is not a good phrasing, from your example I suggest intersecting half-lines (beginning in the given x-y-coordinates and going in the direction of the given angle) or something like that. At least for me it was unclear from the description that you do mean the half-lines, so I think this is worth mentioning. \$\endgroup\$
    – flawr
    Jun 12, 2016 at 9:19

Smallest Vigenere cypher executable


Impliment a Vigenere cypher program in your favourite language to create the smallest compiled program in any operating system.

For people unfamilar with a Vigenere cypher program, please visit the following link: https://en.wikipedia.org/wiki/Vigen%C3%A8re_cipher


  • Your score is the size in bytes of the folder that contains the main executable.

To find this, you must first compile your program. Secondly, delete any files unecessary to the running of your program. Finally, right-click on or list details by command line the folder (or equivalent standard action depending on operating system) containing the compiled executable and note the smallest of the listed size (e.g. size or size on disc in Windows) in bytes value.

  • If dlls or similar are referenced, then their size in bytes must be added to the score.

  • Interpreted languages may be used, but the size of a compatible interpreter (e.g. a web browser if using javascript) must be included when calculating the score.

Specific details

The program must accept 3 arguments:

  • Argument 1 must be either 'e' or 'd', with e meaning encrypt and d meaning decrypt
  • Argument 2 is the keyword string.
  • Argument 3 is the main input string.
  • If Argument 1 is 'e' then Argument 3 is the message to be encoded.
  • If Argument 1 is 'd' then Argument 3 is the message to decoded.

The program must output the result only:

  • If Argument 1 is 'e' then the result is the encoded string.
  • If Argument 1 is 'd' then the result is the decoded string.


  • The earliest dated post with the lowest score wins.
  • In your answer post, post enough information so that others may repeat steps described to arrive at the same result. Presume that people reading your answer are fluent in your chosen language, but may not necesarilly understand any nifty tricks or exploits.
  • Include your score in your answer post to let everyone know your score.
  • You may post all your source-code if you like, but may also post only the parts that you feel are significant. There is no need to post automatically generated code, although if it is generated by a plugin then this should discussed. Failure to do so is considered cheating.
  • Edits may not be made to answers. If you have made a mistake then delete and repost your answer anew.
  • All edits and mistakes are considered cheating. Cheat answers are identified by members of the community leaving a comment. Cheat answers must be deleted, corrected and reposted.
  • The community must use the comments to report cheating only. Be careful reporting cheats as a mistake may result in a good answer being deleted.
  • Improvements should be listed as a new answer post.
  • Take the competition seriously and be a good sport. Avoid ribbing, jokes or childish remarks.
  • Have fun
  • 2
    \$\begingroup\$ This excludes languages that can't be compiled (such as Python and lots of esolangs), the input format seems overly cumbersome and I can't see from a first glance where you define what your score actually is (but thanks for using the sandbox) \$\endgroup\$
    – Blue
    Aug 8, 2016 at 9:36
  • 1
    \$\begingroup\$ Welcome to Programming Puzzles & Code Golf! And welcome to the Sandbox... I find this a great place to learn what works and what doesn't, as often ideas I present have already been tried previously. I'll give some feedback on various points that have already been discussed by the community previously. Please feel very welcome to drop in to Code Golf Chat and talk things over with the friendly people there. \$\endgroup\$ Aug 8, 2016 at 9:49
  • \$\begingroup\$ Thank you for the advice. Interpreted or partially compiled languages may now be used and I have attempted to make the scoring system more obvious by putting it closer top the top under its own heading. \$\endgroup\$ Aug 8, 2016 at 9:49
  • \$\begingroup\$ This appears to be a sizecoding challenge (scored based on executable size rather than source code size). There has been previous discussion on meta about this scoring method. Note that this is not off topic, but it might help to see the discussion in case it affects your decision on how to score this. \$\endgroup\$ Aug 8, 2016 at 9:57
  • \$\begingroup\$ At the moment any answer that isn't compiled has already lost due to bloat of the interpreter. C/Assemblies will probably win. Actually Java has a decent chance because there are old mobile phone OS's that can run Java bytecode natively \$\endgroup\$
    – Blue
    Aug 8, 2016 at 9:57
  • 1
    \$\begingroup\$ It helps to include a brief description of the task, for the benefit of people who are not yet familiar with it, and sometimes a link to further information. For example, the Wikipedia page on Vigenere cipher. \$\endgroup\$ Aug 8, 2016 at 10:01
  • \$\begingroup\$ Is the code to be posted in an answer the compiled code or the source code that compiles to it? \$\endgroup\$ Aug 8, 2016 at 10:05
  • 1
    \$\begingroup\$ This is your challenge, so you make the rules, but just to let you know, asking for improved versions to be posted as new answers is unusual. Every post has an edit history that is viewable by everyone, which also makes it possible to see clearly when a given score was achieved (in case you were worried that an edited answer would appear to have achieved that score at the time it was first posted). It is common practice in most challenges to edit in new improvements, and people often comment to suggest improvements to each other (this community is both very competitive and very helpful...). \$\endgroup\$ Aug 8, 2016 at 10:07
  • \$\begingroup\$ Related challenge (not a duplicate - just for information) \$\endgroup\$ Aug 8, 2016 at 10:30
  • 2
    \$\begingroup\$ 1. More closely related challenge. If this question were code-golf then it's close enough that I would consider it a dupe. 2. As it stands, I would vote to close as lacking an objective winning criterion. The size of the dlls loaded by an answer vary according to a lot of factors which are outside the control of the author. If my score could change because a security update to my Linux distro changes the size of libc.so then I need to write a mini-thesis on precisely what conditions must be met to get the claimed score. \$\endgroup\$ Aug 8, 2016 at 11:01
  • \$\begingroup\$ What do you think to a handicap based on the language used? On one hand, I don't want to exclude people that like a particular language, but on the other hand I don't want to be unfair to people that code closer to the metal in c or assembler. \$\endgroup\$ Aug 9, 2016 at 10:47
  • \$\begingroup\$ It is not unfair; everyone understands that lower level languages are ueually longer (with the exception of the high level languages Java and C#), but that doesn't stop people from golfing well in low level languages, and compiled executables are perfectly valid submissions. \$\endgroup\$
    – ASCII-only
    Aug 12, 2016 at 0:22
  • \$\begingroup\$ I'll take that to mean that you would indeed like me to condsider a handicap, although this isn't strictly code golf. More like code crystal maze (sadly, without richard o brien or edward tudor pole as host for the time being). Well, my point is that since I want the score to based on how the system is effected as a whole, whereas code golf is much simpler. I'll get to the drawing board, and see if I can come up with a scoring system as close to simple as possible that still makes this a fun game for all. \$\endgroup\$ Aug 12, 2016 at 7:47

N-ary Time

Decimal time is a concept of having days, hours, minutes, and seconds relate to each other by powers of 10:

N-ary time, which I made up, is having days, hours, minutes, and seconds relate to each other by powers of N.

Given an input N where minumum(2^31-1, [languages upper limit on integers])>N>1, output the value of an N-ary hour, N-ary minute and N-ary second, in seconds, using these rules: There are N^1 (10 in base-N) N-ary hours in a day, there are N^2 (100 in base-N) N-ary minutes in an N-ary hour, and there are N^2 (100 in base-N) N-ary seconds in an N-ary minute.

There are 86400 regular seconds in a day.


Input must be an integer, inputted in anyway allowed


Output consists of floats or integers that represent the amount of seconds in each N-ary unit within 0.5 seconds . Order is irrelevant.

Test cases


2-->[43200.0, 10800.0, 2700.0] (or some other way of representing the data)

8-->10800 3 169 (numbers don't have to have specific order)

3-->28800.3200.356 (note that this might have the same character as decimal points, but it's still clear that they are three separate numbers)
  • \$\begingroup\$ All makes sense, but it took me a while to grasp how the output follows from the input. A worked example might help. \$\endgroup\$ Aug 10, 2016 at 10:34
  • \$\begingroup\$ Probably should have had the amount of seconds in a day yes \$\endgroup\$ Aug 10, 2016 at 10:57
  • \$\begingroup\$ You could say something like "For example, when N=2, there are 2 hours in a day, 2 squared = 4 minutes in an hour, and 2 squared = 4 seconds in a minute. That makes a 2-mal hour 43,200 standard seconds, a 2-mal minute 10,800 standard seconds, and a 2-mal second 2,700 standard seconds." \$\endgroup\$ Aug 10, 2016 at 11:44
  • \$\begingroup\$ 1. Why invent n-mal when n-ary is a perfectly good word and already in wide usage? 2. IMO "Given n output 86400/n, 86400/n^3, and 86400/n^5" is too trivial to make a worthwhile question. \$\endgroup\$ Aug 10, 2016 at 13:39
  • \$\begingroup\$ I might think about a formula for the amount of n-ary hours that's less trivial soon \$\endgroup\$ Aug 10, 2016 at 23:37

Floating Point Error

Given a basic arithmetic problem, the division, multiplication, addition, or subtraction of two numbers (which are representable in a 32bit floating point), output the percent difference between the actual (mathematical) result and the nearest floating point value. The percent difference should be rounded to a whole number.

You may use either 32bit or 64bit floating point following the IEEE Standard for Floating-Point Arithmetic (IEEE 754).

The percent difference is calculated in the following manner:

100 * (Actual - Float) / Actual

You may round to a whole number in any of three ways, as long as you only use one method: (1) floor, (2) ceiling, (3) nearest.

Examples and Test Cases, yet to come.

  • \$\begingroup\$ This is also known as the relative error. \$\endgroup\$
    – flawr
    Aug 10, 2016 at 23:54
  • \$\begingroup\$ As currently specified, I think that the following is an almost fully compliant answer in CJam: 0. Note that I'm choosing to use 64-bit floating point, so an error of 1 ulp corresponds to 2^-29 ulps of the original 32-bit inputs, which is considerably less than 1%. The only test cases which I think this fails are ones where Actual is 0 and the output should be either an infinity or NaN. \$\endgroup\$ Aug 11, 2016 at 9:57

Bomb Drops


The Challenge

Your task is to create a program that simulates "dropping bombs" on a 2 dimensional array.

For example consider the following 2d array:

3 0 5 0 5
5 3 4 0 2
1 0 5 4 2
2 4 2 3 2
2 3 3 0 0

Dropping a bomb on a single cell decreases the value of that cell by 2 and the value of its direct neighbors (including diagonal neighbors) by 1, to a minimum of 0.

If we were to drop on a bomb on the cell corresponding to array[2][1] where the value is 4, or coords (2,1), then the new 2d array would look like so:

3 0 4 0 5
5 2 2 0 2
1 0 4 3 2
2 4 2 3 2
2 3 3 0 0


Your input will be a two dimensional array of integers greater than or equal to zero, in whatever way you like.

You will then also take input that is a sequence of tuples, lists of size 2, or whatever else you please that corresponds to coordinate points. For example,

(2,1),(3,4),(0,0) or [2,1],[3,4],[0,0] or 2,1,3,4,0,0

For each of these points, you will simulate a bomb drop on that point. You do not need to worry about these coordinates being out of range of the 2d array.


Output consists of a two-dimensional array, formatted the way you please.

Test Cases

>>> [[0, 1, 3, 1, 1], [3, 5, 1, 0, 4], [1, 1, 1, 0, 2], [1, 2, 0, 3, 4], [5, 2, 0, 2, 2]]
# 0 1 3 1 1
# 3 5 1 0 4
# 1 1 1 0 2
# 1 2 0 3 4
# 5 2 0 2 2
>>> [3,4],[2,1],[0,0]
0 0 2 0 1
2 3 0 0 4
1 0 0 0 2
1 2 0 2 3
5 2 0 0 1

# You can also take input in one pass, rather than 
# having the 2d array and the coordinates be seperate inputs:
>>> [[5, 2, 3, 0, 3], [4, 3, 5, 5, 5], [1, 3, 3, 3, 3], [0, 1, 2, 3, 1], [3, 1, 2, 2, 4]],[2,2],[0,1],[3,3]
# 5 2 3 0 3
# 4 3 5 5 5
# 1 3 3 3 3
# 0 1 2 3 1
# 3 1 2 2 4
4 1 3 0 3
2 1 4 4 5
0 1 0 1 2
0 0 0 0 0
3 1 1 1 3

Other info

Inspired from this question on StackOverflow.

This is my first challenge, I'm looking for any advice at all. I'm not sure what other tags to put aside from code golf. I'm probably missing a few basic rules etc too that I've forgotten about. All suggestions welcome.

  • \$\begingroup\$ This looks like a pretty good challenge, but I'd consider rewriting the parts about "bomb dropping." This is just my opinion, but I feel like adding deadly weapons to an otherwise lighthearted post about programming detracts from the challenge. \$\endgroup\$ Aug 11, 2016 at 15:27
  • \$\begingroup\$ @FryAmTheEggman It makes for a good clickbait title though :P \$\endgroup\$
    – Theo
    Aug 11, 2016 at 15:33
  • \$\begingroup\$ @FryAmTheEggman Fair point, what would you suggest? \$\endgroup\$
    – Justin
    Aug 11, 2016 at 15:37
  • \$\begingroup\$ You could consider something like "fill up the holes" where bombs are replaced by bags of dirt and the numbers are depth below ground level or "clean up the garbage" where you grab from piles that are nearby each other. Unfortunately I'm having trouble coming up with something quite as evocative as bombs are. If you can't come up with a good replacement, I wouldn't worry too much about my original comment, as there's nothing actually wrong with your post. I just felt the tone was kind of off. \$\endgroup\$ Aug 11, 2016 at 15:52

Paint with all the colors of the RGB rainbow

Inspired by Images with all colors and American Gothic in the palette of Mona Lisa: Rearrange the pixels

Given an input raster image, output a raster image where each pixel is a unique color, such that the sum of the absolute value of the sum of the differences of the RGB channel values for each pixel between the original image and the output image is minimized. In other words, that means, given an image O, find an image X such that every pixel is a different color, and (in pseudo-Python) the quantity sum(abs(O_pixel.RED - X_pixel.RED) + abs(O_pixel.GREEN - X_pixel.GREEN) + abs(O_pixel.BLUE - X_pixel.BLUE) for O_pixel,X_pixel in zip(O.pixels, X.pixels)) is minimized.

3-bit example

All images in this example are 4 pixels wide by 2 pixels high, magnified 40x to 160x80 so that they can be seen more easily.

Original image:

original 3-bit

The palette:

color space

The image using each color from the palette that is closest to the original (minimum sum 6):

3-bit output big


  • All images will use 8-bit colors (3 bits in the red and green channels and 2 in the blue channel), and will be 16x16. Here is an image displaying the 8-bit color palette. Each color from this palette must be used exactly once in the output image.
  • Submissions must complete for any of the test images in under 1 minute.
  • If there are multiple optimal solutions, any one of them may be used.

Test cases

Original is on the left, expected output is on the right. All of these images are zoomed in; click the links to get the original-sized images.

Note that these two are the same, because the original image is already composed of unique pixels. Thus, the minimum sum is 0.

(more to come once my computer finishes generating them)

  • 1
    \$\begingroup\$ 1. If you want the test cases to be useful - and if you don't, there's no point in having them - then include the minimum sum of the absolute pixel differences. 2. I don't see the point of using images. The objective function prioritises red completely over green and green completely over blue, so there's no reason for the output image to look remotely like the input one. The interesting part of the question could be done perfectly well with integer arrays, and that would allow for much simpler I/O. \$\endgroup\$ Aug 8, 2016 at 7:24
  • \$\begingroup\$ @PeterTaylor You're right on the pixel differences being dominated by the red channel - what I had in my mind was not what I typed up. I'll edit it to closer reflect my original idea that got lost in translation. \$\endgroup\$
    – user45941
    Aug 8, 2016 at 8:23

Convert Between American and British English Spellings

In this challenge, you will have to write two programs or functions. One will convert a list of words from their American English spelling to the British English equivalent, and the other to convert the other way. Here's that catch: you only have 300 bytes to do both!

The Challenge

You can find a gist here that contains a list of 1000 words. The file is formatted so each line is british-spelling(space)american-spelling. Therefore, there are only 500 words in total, each with 2 spellings. This file is for your convenience, and it was based on the list found here.

Your challenge is to write two programs or functions (has to be two programs or two functions, it can't be one program and one function). Both will take a single string as input and output a single string. The first program/function will take in British English words and output the American English spelling, and the second will take in American English words and output the British English spelling. Built-in functions or libraries that do this task are not allowed, nor are standard loopholes. You also cannot hard-code the list into your program. Your programs and functions have a shared 300 byte limit, i.e. length(program1)+length(program2)<=300. However, each program/function may be of different length.


You will be scored based on how accurate your programs/functions were. Your score will be calculated based on the following formula:


Highest score wins. Ties are broken by shortest shared byte total.


  • I can't help but fell like I am missing something.
  • Should I post the gist contents here, as well as a link to it?
  • Is 300 bytes too generous, too litte, or is it fine?
  • -
  • \$\begingroup\$ Byte limits are frowned upon \$\endgroup\$ Aug 15, 2016 at 1:33
  • \$\begingroup\$ @DestructibleWatermelon Well, my main concern is that solutions will be able to get high or perfect scores without a byte limit. My main goal with the limit was to simply encourage use of a few creative methods that don't have really high scores rather than allowing all programs to have high scores. AKA, I want to increase the variance in the scores. \$\endgroup\$
    – GamrCorps
    Aug 15, 2016 at 1:42
  • 1
    \$\begingroup\$ @DestructibleWatermelon I don't think that's really applicable to this question - byte limits tend to be useful for test-battery for the reasons GamrCorps says. Whether 300 is generous or too little however, is hard to say without actually trying... \$\endgroup\$
    – Sp3000
    Aug 15, 2016 at 2:01
  • \$\begingroup\$ Byte limits are redundant and unhelpful for a code golf challenge, but the meta post isn't saying byte limits are bad elsewhere. This isn't a code golf so the byte limit isn't bad for the same reason. However, I would point out that 300 bytes is very little for Java, but probably more than enough to write a fully working bilingual AI in Jelly. This isn't necessarily a problem - competition can be within languages rather than between them. However, it might be difficult to find a limit that doesn't completely exclude a lot of languages. \$\endgroup\$ Aug 15, 2016 at 11:30
  • \$\begingroup\$ As Sp3000 points out, it will be difficult to fine tune the limit, but I do think this is an interesting challenge. There is a lot of overlap in the patterns of how British and American spellings vary, so this isn't just an arbitrary compression challenge. \$\endgroup\$ Aug 15, 2016 at 11:36
  • \$\begingroup\$ I have no idea which would be more interesting, but just thinking: The word list could be solely words that differ between the two countries, or it could include some words that are the same in both. Does anyone have any thoughts about what effect this would have? \$\endgroup\$ Aug 15, 2016 at 11:40

How far is it?

I have no children myself but I understand they are more interested in the destination than the journey, so often ask how much of the journey is left. This might be a car trip, or it might be a demonstration of the Tower of Hanoi puzzle.

The original aim of the puzzle is to move all the disks from one pillar to another, but except for the smallest disk (which can be moved to any pillar at any time) the only disk you can move is the lowest numbered disk on the other two pillars.

Although there is a well-known optimal sequence from one pillar to another, each of the three moves will take you slightly nearer to finishing on a different pillar. (This partly explains why there are only two available moves when all the disks are already on the same pillar.) It's therefore possible to mistakenly take a detour towards another pillar yet correct yourself and finish at your desired pillar without retracing your steps. You should therefore not assume that the input position is from the optimal sequence.

The challenge is to write a program or function that accepts three sets (arrays, lists, strings, etc.) representing the sizes of the disks on each pillar and returns an integer giving the number of steps remaining to move all the disks to the first pillar. Examples:

[1, 2, 3] [0] [] -> 1
[2, 3] [0, 1] [] -> 3
[0, 1] [2] [3] -> 11
[0, 1, 2] [] [3] -> 15

Not only must your program return the shortest number of steps possible, but it must itself also be as short as possible.

Please indicate whether your input format requires the disks in a particular order.

  • 1
    \$\begingroup\$ 1. Needs at least a link to an explanation of the tower of Hanoi, and preferably a short explanation in the question so that it's self-contained. 2. The test cases don't seem to cover situations where poor play has got the board into a complete mess. \$\endgroup\$ Aug 12, 2016 at 10:10

The 9-hole GOLF challenge

Each of these challenges are challenges to be judged by the GOLF CPU.

Hole 1: Prime Partitions

Hole 2: Sides of a Cuboid

Hole 3:

You are given the area of a polygon, and the number of edges of the polygon. You must find the minimal perimeter of the polygon. This challenge is more about implementing floating point/decimal numbers efficiently. Your answer must be accurate to at least 3 decimal places.

10, 5:    2.41088
7, 8:     1.20405
6700, 14: 20.9027

Hole 4:

You are given a number, A, and a base B. You must take the digits of A in base B and use each digit as the power of the digits before it. Assume that integer overflow is desired. For example,

125:  ((5)^2)^1     :25
3234: (((4)^3)^2)^3 :68719476736
18043:              :1
12540:              :0

Hole 5:

We define F(n) to be equal to the sum of all previous term's digits, and F(0) = 1. Given N, you must return the value of F(N). This sequence is A004307 on OEIS

0: 1
1: 1
2: 2
3: 4
4: 8
5: 16
6: 23
20: 137

Hole 6:

You must return the Nth decimal place of e

0:  2
1:  7
5:  8
25: 4

3 more holes (To come up with)

Do these holes look reasonable? Enjoyable? Confusing?

  • \$\begingroup\$ On hole 2, I think you mean volume rather than area. \$\endgroup\$ Jul 1, 2015 at 21:20

Left and Right

Given an input string, in ASCII, output ")|]" as many times as the case-insensitive word "right" appears in input, and output "(|[" as many times as the case-insensitive word "left" appears in input. The order is irrelevant. If and only if no occurences of these words are in input, output "X|X". Spacing between items is optional

This is , less bytes is best

Test cases:

input -> output
RightRightighteftleft -> (|[ )|] )|], or some other ordering
this doesn't contain either word -> X|X
LEfT, LeFT, leFT, righT -> (|[ (|[ (|[ )|]
(|[ -> X|X

Enumerate Irreducible Polynomials in GF(2)[X]


  • I noticed this is a duplicate of Find the XOR Primes
  • Would it make it a non-dupe if we'd go from q=2 to q=3?
  • Would it be more interesting for the general case, where the submissions have to take q(prime) and n

A polynomial over any finite field GF(q) of prime order q can be represented by an integral polynomial with coefficients in {0,1,2,...,q-1} ⊂ ℤ by the reduction modulo q. This allows us to easily enumerate all polynomials with coefficients in that field by using a polynomial p with coefficients in {0,1,2,...,q-1} ⊂ ℤ and evaluating it in q. So we map such a polynomial p to a nonnegative integer p(q). It is easy to show that this mapping is a bijection between the set of said polynomials and the nonnegative integers, when you consider one of those polynomials p(X) as an integer in base X.


Let I be the set of irreducible polynomials with coefficients in GF(2), represented by integral polynomials with coefficients in {0,1}. Then enumerate all elements of {p(2) | p ∊ I} ⊂ ℤ in ascending order and let a(n) be the nth element. Given n your submission should return a(n). This is in fact A014580 in OEIS.


The irreducible polynomials in GF(2)[X] with a degree of at most 3 are: {p1(X)=X, p2(X)=1+X, p3(X)=1+X+X^2}. Substituting X by 2 results in p1(2)=2, p2(2)=3, p3(2)=7. So we see a(1) = 2, a(2) = 3, a(3)=7. Some more of those polynomials can be found on MathWorld.

Test cases

 n  a(n)
 1    2
 2    3
 3    7
 4   11
 5   13
 6   19
 7   25
20  103
34  203
35  211
50  355
53  369
54  375
  • \$\begingroup\$ It should be a polynomial over any finite field: the field which it's in is GF(q)[x], as per the title. I'm not sure what the point of the first sentence is: it seems to be stating a tautology. Unless it's intended to define a polynomial over a field F as a polynomial whose coefficients are in F? I'm also not sure what you mean by "evaluating it in q". As for the question about dupes: over prime-order Galois fields other than GF(2) there isn't a built-in for polynomial addition in most languages, but implementing that manually instead of with ^ is fairly minor. \$\endgroup\$ Aug 17, 2016 at 21:51
  • \$\begingroup\$ @PeterTaylor Thanks for the correction. With that sentence I wanted to emphasize that it is sufficient to consider these (integer) representants of the residue classes as elements of the field. A polynomial p evaluated in q is just the image of q under the substitution homomorphism q ↦ p(q) defined by p. You "plug in a value for X". \$\endgroup\$
    – flawr
    Aug 17, 2016 at 22:04
  • \$\begingroup\$ I would call that evaluation at q (or possibly at x=q for extra clarity). \$\endgroup\$ Aug 17, 2016 at 22:13
  • \$\begingroup\$ Have thought about it some more. It seems to me that you're trying to be overly clear, in the sense that I think you're trying to distinguish the element 2 of GF(3) from the element 2 of . Non-mathematicians are just going to get confused, and mathematicians are used to using the notation which makes sense and only distinguishing the elements of the different fields when it's really important. I propose the following for the first paragraph (with a footnote at the bottom of the question): \$\endgroup\$ Aug 18, 2016 at 7:46
  • \$\begingroup\$ The finite field GF(q) of prime order q can be thought of as the integers {0,1,...,q-1} with addition and multiplication modulo q.<sup>[1]</sup> So a polynomial p over the field GF(q) is also a polynomial over the integers. If we evaluate p(q) over the integers, we are performing a base conversion of the coefficients of p in base q, and this gives a bijection between polynomials over GF(q) and the nonnegative integers. \$\endgroup\$ Aug 18, 2016 at 7:46
  • \$\begingroup\$ <sup>[1]</sup> NB There are finite fields of prime power order GF(q^a), a > 1, but they don't have the same multiplication structure as the integers modulo q^a. \$\endgroup\$ Aug 18, 2016 at 7:47

Simulate Bibliomancy

In this challenge, you must take input as a string, and output a random word. Please note that you cannot simply take a random number and take the item of the list at that index: You will be simulating pages.

Also note that rather than your program picking from the page with eyes closed (which would bias towards larger words), it will generate a random number, and pick the word corresponding to that number

Pages will be some amount characters long, according to input (sandbox: I need help with how pages are distinct (are they assumed to be separate, or do pages need to have truncated length if a word is too long)). Every page has an equal chance of being picked (assume the PRNG is even), and every word on the page as an equal chance of being picked. In this way, a word from a grandiloquent page, with fewer words, is more likely to be chosen than a word from a page with many short words, and all the words on a page have an equal chance of being chosen. The sum of the chances of picking any word from one page is equal to the sum of the chances of picking any word from another page.

, this is that

Of course, this still needs clarification. Halp sandbox

  • \$\begingroup\$ So the challenge is: Given a string describing the text of a book and an int describing the number of pages, divide the text into pages and pick a random word from a random page? \$\endgroup\$
    – Emigna
    Aug 19, 2016 at 8:10
  • \$\begingroup\$ Yeah, that probably is a better explanation than mine \$\endgroup\$ Aug 19, 2016 at 8:44
  • \$\begingroup\$ The difficulty of the challenge will be decides by how you decide that words which end up in the middle of a page split should be handled. Max chars per page would be another way of doing it as well. Would also change difficulty. \$\endgroup\$
    – Emigna
    Aug 19, 2016 at 9:02

The grand golfed double radiation-hardened quine

Yep. It's quite a mouthful.

  • Double radiation-hardened - removing any two characters still results in a valid quine.
  • Quine - a program that outputs itself


  • No reading from a file or from the web - that's cheating!
  • Standard loopholes apply.
  • File must be at least two characters long.

This is so the shortest answer in bytes wins.

I've seen singly radiation hardened quines before. Now it's your job to make doubly radiation hardened ones.

Please constructively criticize this challenge.

  • \$\begingroup\$ This is a duplicate; this challenge is about generalized radiation-hardened quines, and there's already one that can survive three removals there. \$\endgroup\$
    – user62131
    Dec 18, 2016 at 8:14

Time-Quine Time!

Your task is to write a quine (I know, I know, old stuff. But bear with me for a moment) which waits for a certain amount of time after the start of its execution, then prints its own source-code.


  • Standard Loopholes apply
  • Your program must always halt for the same amount of time before printing its source code (System independent)


  • Your program should take no input


  • The programs exact source code (After the wait)


  • This is code-golf, so shortest code wins, BUT:
  • The time your program waits before printing is also taken into account. SO:
  • Your score is equal to length of code (in bytes) / log(base 10)(time in seconds of wait)
  • Code golf, so shortest code wins

P.S.: Please indicate in your answer how long your code will wait for

All feedback is appreciated

  • \$\begingroup\$ Does a solution have to call a sleep() function or can it make some calculations (that would take a different amount of time on different machines)? \$\endgroup\$
    – KarlKastor
    Aug 19, 2016 at 17:53
  • \$\begingroup\$ The time it takes should always be the same and system-independent, so a sleep() call or similar would probably be the only way to do it. \$\endgroup\$
    – Theo
    Aug 19, 2016 at 17:54
  • \$\begingroup\$ Why is the wait duration relevant for scoring? Is this just some weird handcapping mechanism to favour languages with a sleepNanos method? \$\endgroup\$ Aug 19, 2016 at 18:22
  • \$\begingroup\$ @PeterTaylor Should have been divided by. Fixed now. It's supposed to favor longer wait times. \$\endgroup\$
    – Theo
    Aug 19, 2016 at 18:37
  • \$\begingroup\$ Then I can get my score as low as I want by just adding more 9s to the wait time, because the numerator increases linearly and the denominator increases geometrically. \$\endgroup\$ Aug 19, 2016 at 19:35
  • \$\begingroup\$ @PeterTaylor True. Any suggestions for making the denominator increase less than the numerator? \$\endgroup\$
    – Theo
    Aug 19, 2016 at 19:40
  • 1
    \$\begingroup\$ I don't think there is any fix, and I don't think it's interesting enough to be worth trying to fix anyway. \$\endgroup\$ Aug 19, 2016 at 20:18

Print this text in as few bytes as you can

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

  • 1
    \$\begingroup\$ Seems boring but you can make it more interesting by having to generate the pattern in size n given n as input \$\endgroup\$
    – Downgoat
    Aug 19, 2016 at 23:16
  • 4
    \$\begingroup\$ I think fixed-output ASCII arts are fine, but I'd scale this up a bit because it might be hard to beat hardcodes or partial hardcodes in verbose languages. I also suggest doing a thorough dupe check. \$\endgroup\$
    – xnor
    Aug 19, 2016 at 23:17
  • 2
    \$\begingroup\$ IMO it's a dupe of this. \$\endgroup\$ Aug 20, 2016 at 17:08
  • \$\begingroup\$ Somehow partial duplicate of Print an arch of ascending / descending numbers. \$\endgroup\$
    – manatwork
    Aug 23, 2016 at 10:53

Enterprise Quality Code!

Summary of this challenge

Print (to make it more fair when competing with another language changing the output method could be a trivial way to golf) the first N Prime numbers. Your score will be the sum of the byte counts of all entries which no one has been able to golf down (by removing one or more characters and rearrange the program). If you golf down someones program, post it as another submission.

You may not golf your own programs once submitted.

This is not a dupe because it significantly changes the scoring method. Writing code which allows a single byte to be golfed off will cost the whole of the score. Also as this is a challenge the winner is likely going to have high scores across a multitude of languages. It is likely that scores will be incredibly near 30k for each language. This limit allows a more interesting competition as it prevents submissions of exponentially large lengths.

Back-story and explanation

At Pretty Good consultants there is a focus on writing "quality" verbose code that is sufficiently engineered. Your boss has decided to test you on your skills.

Consider the set of all programming languages in existence before the posting of this challenge. For this challenge there will technically be one individual "winner" in each language, however the boss will give a promotion accepted tick mark to only one answer based on your score.
The goal of this challenge is to receive an integer N strictly smaller than 2^16-1 and print the first N prime numbers (in less than 24 hours) separated by your platforms choice of new line. OEIS sequence A000040 in as many bytes as possible in as many languages as possible. However, note that others vying for the promotion will try to "help" you by golfing down your score.

Sample output for an input 11


How to participate

Pick any language X, but please avoid selecting a language which is just another version or derivative of another answer. If there is no existing answer in language X than you will write a program (which must fit into a single post) that solves this challenge. The length in bytes of the source (in any reasonable preexisting textual encoding) will be added to your score. You must avoid using any unnecessary characters for reasons that will soon become apparent.

If language X already has been used to answer this question, then you must answer using any permutation of any proper subset of the characters used in the shortest answer (I.E take the shortest X answer and remove some (>=1) characters and optionally rearrange the resulting code). The previous holder of the shortest X answer will lose all of the bytes provided by his answer from his score, and the number of bytes of your submission will now be added to your score. The number of bytes golfed off gets "lost" forever.

Clarifications shamelessly lifted adapted from this challenge

Rules for Languages

Languages used should be distinctly different. A language is different iff:

  • It is not a different version of another language (Java 7, Java 8)
  • They must not be derived from another language (Branf*** versus Alphf***)
  • One language may not be a subset or superset or trivial of the other one (e.g. hq9+ versus hq9+b).

HQ9+ wouldnt be a language anyway, but please be judicious when selecting a language, if you have any clarifications on a language that may be significantly different from an existing answer please ping me and we can work it out.

  • \$\begingroup\$ If anyone knows how to make a scoreboard for this I will be much obliged \$\endgroup\$ Aug 20, 2016 at 17:28
  • \$\begingroup\$ So the highest score wins, overall (from all your still-valid answers). And when you outgolf somebody, they lose their points, you gain your points, but do you get the points that they lost? \$\endgroup\$
    – Riker
    Aug 20, 2016 at 17:42
  • \$\begingroup\$ @EasterlyIrk the way I had it planned out is that the amount of bytes golfed off is forever lost. I don't know if thats fair but that essentially prevents people from "profiting" off of ridiculous answers that were not fortified against being golfed. \$\endgroup\$ Aug 20, 2016 at 17:49
  • 2
    \$\begingroup\$ Yeah, that's what I figured. You might want to clarify that a bit though. I really like the idea. \$\endgroup\$
    – Riker
    Aug 20, 2016 at 17:52
  • \$\begingroup\$ @EasterlyIrk clarifications added, let me know if this is ready for main \$\endgroup\$ Aug 20, 2016 at 17:59
  • 2
    \$\begingroup\$ It might be ready, but you should wait for somebody else to also give input. \$\endgroup\$
    – Riker
    Aug 20, 2016 at 18:01
  • \$\begingroup\$ All right sounds good \$\endgroup\$ Aug 20, 2016 at 18:04
  • 2
    \$\begingroup\$ 1. So basically the accepted answer goes to the shortest answer in Unary? 2. The tags code-golf and code-bowling are mutually exclusive. This isn't really either. \$\endgroup\$ Aug 20, 2016 at 19:49
  • \$\begingroup\$ @PeterTaylor please read the whole thing. The answer must fit within 30k \$\endgroup\$ Aug 20, 2016 at 20:02
  • \$\begingroup\$ If someone can write a brainf*** program that is only about 6 chars long or so than they deserve the accept tick \$\endgroup\$ Aug 20, 2016 at 20:03
  • \$\begingroup\$ @RohanJhunjhunwala Golunar wins \$\endgroup\$
    – Riker
    Aug 20, 2016 at 22:07
  • \$\begingroup\$ @EasterlyIrk lol thats actually just a compressed form of Brainf*** it probably wouldn't score that well \$\endgroup\$ Aug 20, 2016 at 23:15
  • \$\begingroup\$ @PeterTaylor essentially I restrict answers to fit in one post which means the best score for a single language is slightly under 30 characters \$\endgroup\$ Aug 20, 2016 at 23:15
  • 2
    \$\begingroup\$ I find the intro confusing. I didn't understand what the challenge is broadly about until reading to the end. Can you cleanly state the challenge at the beginning, and move the details later? \$\endgroup\$
    – xnor
    Aug 21, 2016 at 0:42
  • 1
    \$\begingroup\$ @trichoplax the overall winner with the highest score summed up over all of their answer posts will receive the tick on their highest scored post. It doesn't really matter which post in particular (as long as it is a post of the winner) receives the tick, but it makes sense to tick off the highest scoring post. \$\endgroup\$ Aug 21, 2016 at 12:44

Play the centipede game

(please note that I need to learn how to make a controller)

In this challenge, you must create a bot which plays the centipede game.

In the centipede game, there are two players, and two piles of coins. One pile is 1/4 the size of the other. Each turn, a player may choose to either: a) take the bigger pile of coins for himself, and push the smaller pile of coins over to the other player, or b) push both piles of coins to the other player. When the coins are pushed to the other player, the size of each of the pile of coins is doubled (in this way, the smaller pile increases to the current size of the big pile after two pushes).

In the original centipede game, there were 100 rounds (hence the name). However, in this game, there will be a random number of rounds. If the game ends without anyone defecting, the big pile will be evenly split between the bots.

The game is over when someone takes the pile instead of pushing it over, or the random amount of rounds are elapsed

I'm currently not entirely sure how to score it, but I know that a bot definitely cannot benefit from deliberately messing up the opponent (as in, it can't try to drag another players score down with it, even if that wouldn't be effective), other than the score it gains. something like Average score-(average score of games by other bots that weren't against the bot being scored), if that scoring method is not the inverse of what I'm trying to accomplish, but something formatted like that

  • \$\begingroup\$ It seems to me that there are two key factors which affect the analysis: do I know how many (half-)turns have already passed? And do I know how many (half-)turns are still to come? If the answer to the second is no, you should at least state the probability distribution. (We can extract it anyway from the controller, but it shouldn't be necessary to reverse engineer key details from the controller). \$\endgroup\$ Aug 22, 2016 at 10:32

Square pegs in round holes

Does a square peg fit through a round hole? Let's find out ...


  • Two 3-tuples, describing a circle and a square on the Cartesian coordinate plane.
  • They're represented here by the form (x, y, r) and (X, Y, S).
  • For both tuples, x and y are integers representing the center of the corresponding shape.
  • The r and S will only be positive integers numbers, with r representative of the radius of the circular hole, while S is the length of the side of the square.
  • The square is oriented parallel to the x and y axes -- i.e., the left and right sides of the square parallel the y axis, and the top and bottom sides of the square parallel the x axis.

(Meta: is this sufficient to describe the shapes?)


  • A truthy/falsey value, written to STDOUT or returned, indicating whether the square peg will fit through the round hole.
  • The square can only fit through the round hole if the entirety of the square is completely enclosed in the circle -- no points of the square can intersect or lay outside the circle.
  • Both objects are fixed at their corresponding centers (no rotating or translating about the origin allowed).
  • Precision within usual 32-bit floating point is sufficient.


  • Either a full program or a function are acceptable.
  • The input numbers can be taken via any suitable format.
  • Standard loopholes are forbidden.
  • This is so all usual golfing rules apply, and the shortest code (in bytes) wins.


(x, y, r) (X, Y, S) -> result  # explanation
(1, 1, 1) (0, 0, 1) -> false   # square is offset from circle
(1, 1, 1) (1, 1, 1) -> true    # square easily fits in the circle
(1, 1, 1) (1, 1, 2) -> false   # some of the square is outside the circle
  • \$\begingroup\$ 1. Why floating point? It isn't necessary, and it excludes a lot of languages. 2. How can the result be ambiguous? \$\endgroup\$ Aug 20, 2016 at 17:16
  • \$\begingroup\$ Elaboration: what this boils down to is: given (X, Y, S) and (x, y, r), check for i and j in {0, 1} whether (x - X - S*i)^2 + (y - Y - S*j)^2 < r^2. There's nothing there which can't be done in integers. An answer in (to pick a language with compile-time typing) Java which used floating point could be converted to an answer which uses integers just by changing some types and (if doing input from stdin) switching the parse method. Moreover, every test case which uses non-integer values can be converted to a test case which uses (potentially large) integers by simple scaling. \$\endgroup\$ Aug 21, 2016 at 17:06
  • \$\begingroup\$ On the other point, I don't think "ambiguous" is the correct word for the situation you describe with rounding error. If input is in 32-bit floats then I think that promotion to 64-bit floats would be sufficient to guarantee a correct result. (If not then an 80-bit float would definitely be sufficient). In order to have a clear spec, I think you should really define the permitted error - although I note that it can only really be an issue with corners of the square which are very nearly axis-aligned with the centre of the circle and very near its edge. \$\endgroup\$ Aug 21, 2016 at 17:12
  • \$\begingroup\$ @PeterTaylor Thanks for the detailed explanation -- you solved the problem in a different method than I had (briefly) sketched out, hence why I was hung up on floating point requirements. \$\endgroup\$ Aug 22, 2016 at 16:38

What number is this in the lowest possible base?

The challenge "What base is this number in" has an obvious extension:

Given a string that represents a number in an unknown base, determine the lowest possible base that number might be in, and taking the number in that base, output its base-10 representation. The string will only contain 0-9, a-z. If you like, you may choose to take uppercase letters instead of lowercase, but please specify this.

So, for example, if the input string is "01234", then the lowest possible base it could be a number in is 5. And in base-5, it represents:

01234_5 = 0 × 5^4 + 1 × 5^3 + 2 × 5^2 + 3 × 5^1 + 4 × 5^0 = (125 + 50 + 15 + 4)_10 = 194_10

So your program should output "194".

Your code must also work for base-1, aka "unary", where a number is represented by a string of zeros and its value is the number of digits. For example, 00000_1 = 5_10.

You can expect valid output to be anywhere from 0 to max_int.

You may take input and provide output in any reasonable format. Base-conversion built-ins are allowed (Sandbox q: Should there maybe be a bonus for not using them?), shortest answer in bytes is the winner!

Sample results:

    Input  | Base | Output
     1001  | 2    | 9
     34f9  | 16   | 13561
  0000000  | 1    | 7
  0000001  | 2    | 1
 codegolf  | 25   | 79234249915

Super-long example:

Input: 0123456789abcefghijklmnopqrstuvwxyz
Base: 36
Output (spaces for legibility, not required in actual program): 86 846 823 611 197 163 108 337 531 226 495 015 298 096 208 677 436 155

This output is roughly 180 bits, or 22.5 bytes, so may be out of range, but if your program can manage it then well done!

You may want to use baseconvert.com to help check your results.

  • \$\begingroup\$ I really don't get how 0000000 is 7 in base 1. \$\endgroup\$
    – Dennis
    Aug 23, 2016 at 1:59
  • \$\begingroup\$ In unary, rather than doing proper base calculations, you use each digit as a tally. So you just count how many 0s there are. Technically, you'd normally use 1111111 with a subscript 1, but since in this challenge 1111111 would be read as a binary number, I'm using the alternative definition. \$\endgroup\$
    – ConMan
    Aug 23, 2016 at 4:00
  • 1
    \$\begingroup\$ That's rather odd. Unary is a bijective numeration, so it doesn't even have zeroes. Personally, I'd just stike 1 from the possible bases. \$\endgroup\$
    – Dennis
    Aug 23, 2016 at 4:02
  • \$\begingroup\$ @Dennis, I think the point of including unary is that it's the only thing which stops the question being an exact duplicate. As it is, I think it's a close enough duplicate to close. \$\endgroup\$ Aug 23, 2016 at 10:28
  • 1
    \$\begingroup\$ I believe this is a duplicate of codegolf.stackexchange.com/questions/48952/… \$\endgroup\$
    – DJMcMayhem
    Aug 23, 2016 at 16:50
  • \$\begingroup\$ I searched for lowest base, and not minimum base. That's my fault and I'm fine with closing. \$\endgroup\$
    – ConMan
    Aug 23, 2016 at 23:13

How can I get To a RepDigit Rep?

Heavily inspired by this challenge

In the referenced challenge, Repdigits are defined as numbers composed of repeating single digits (1, 111, 88, 99999, etc). In this challenge, we will calculate the minimum number of Stack Exchange Q/A votes it takes to take a reputation to a repdigit.

A vote can either be:

  • Question upvote (+5)
  • Answer upvote (+10)
  • Question/Answer downvote (-2)

Input: A single positive integer which represents a Stack Exchange reputation

Output: The minimum number of votes required to reach the nearest repdigit


  • Answer may be either program or function
  • Input may be user input, read from a file, or function argument
  • Output may have trialing spaces/new lines and should be printed/displayed to STDOUT or nearest equivalent. Alternatively, output may be the return value of a function
  • Standard loopholes apply
  • Answers should work theoretically for infinite reputation, however for practicality, answers only need to work up to 889,107 reputation (Jon Skeet's SO rep at time of posting)

Test Cases:

Reputation: 1   =>  Votes: 0 (input is already a repdigit)
Reputation: 10  =>  Votes: 1 (one downvote will result in 8 rep)
Reputation: 500 =>  Votes: 6 (5 answer upvotes and 1 question upvote resulting in 555 rep)

This is codegolf, shortest code in bytes wins

  • \$\begingroup\$ What is the largest and smallest possible inputs as rep. \$\endgroup\$ Aug 25, 2016 at 17:54
  • \$\begingroup\$ Minimum of 1, maximum of 889,109 \$\endgroup\$
    – wnnmaw
    Aug 25, 2016 at 19:11
  • \$\begingroup\$ Totally irrelevant but just out of curiosity: Will the figure shown for Jon Skeet's rep be updated with the current figure when this gets posted to main? \$\endgroup\$ Aug 27, 2016 at 18:27
  • 1
    \$\begingroup\$ @trichoplax, yeah, of course, its attention to detail that makes a good challenge! \$\endgroup\$
    – wnnmaw
    Aug 28, 2016 at 13:21

Strict Music Interval Describer

Given two notes, you might think you can combine Print the sizes of intervals inside of a piece of music to give you the number of semitones with Music Interval Solver to give you the name of the interval between them. Unfortunately doing this loses information. You might notice from the Music Interval Solver that different intervals can have the same number of semitones. In order to know which interval we should use, we need to refer back to the original note names.

The base name of an interval can always be determined from the inclusive number of note names, excluding accidentals, from the first note to the second. Note that intervals wrap after the octave, so that G# to C# is a fourth (G, A, B, C). For this question the octave numbers are not provided so you should assume that the interval will always be an ascending interval between a second and an octave.

To avoid having to refer to the linked questions, I will remind you that the notes themselves have differing numbers of semitones between them; E & F and B & C have one while the others have two. G to C is therefore 2 + 2 + 1 = 5 semitones.

You also need to take into account the accidentals; we'll use # and b for simplicity. They each alter the interval by 1 semitone; # increases it if used on the second note while b increases it if used on the first note. Naturally if both notes have the same accidental then they will cancel out.

An interval also has a modifier. My fourth above was in fact a perfect fourth, because the number of semitones was 5; the other possible perfect interval is a perfect fifth, which is 7 semitones. You can choose whether to use octave or perfect octave for 12 semitones.

Seconds, thirds, sixths and sevenths have minor and major intervals. The major intervals are 2, 4, 9 and 11 semitones; the minor intervals have one fewer.

Unlike the Music Interval Solver, if your interval does not match any of the intervals so far, you cannot simply change to a different base interval. Instead, you must augment or diminish your interval. For the purposes of this question any interval smaller than a minor or perfect interval is a diminished interval, and any interval larger than a major or perfect interval is an augmented interval.

Test cases:

Eb F# - augmented second
C# Eb - diminished third
G# C# - perfect fourth
F B - augmented fourth
B F - diminished fifth
Db B# - augmented sixth
A# Gb - diminished seventh
C# C - diminished octave

Input/output can be in any reasonable format (e.g. one string with a space separator, an array of two strings). This is , so the shortest code wins.

  • \$\begingroup\$ 1. The first sentence seems backwards to me: surely the issue you're disagreeing with is the input, not the output, so why "providing"? 2. If I understand this correctly, you want to take two notes as input, map to the separation between them, and then pass that through to the earlier question. In other words, it seems to be codegolf.stackexchange.com/q/5410/194 + codegolf.stackexchange.com/q/76120/194 . I think that makes it a dupe. \$\endgroup\$ Aug 25, 2016 at 13:40
  • \$\begingroup\$ No, the note names are highly relevant. It is wrong to describe an interval of F to B as a diminished fifth or B to F as an augmented fourth. \$\endgroup\$
    – Neil
    Aug 25, 2016 at 15:04
  • \$\begingroup\$ When you say, "No," with what precisely are you disagreeing? \$\endgroup\$ Aug 25, 2016 at 15:15
  • \$\begingroup\$ I'm disagreeing with your comment part 2. \$\endgroup\$
    – Neil
    Aug 25, 2016 at 15:22
  • \$\begingroup\$ So are you saying that 5410 is badly specified? Or something else? \$\endgroup\$ Aug 25, 2016 at 15:45
  • \$\begingroup\$ It only required you to output a possible name of the interval, given that you had incomplete information. Maybe it was deliberately specified like that because it allowed simpler input requirements. \$\endgroup\$
    – Neil
    Aug 25, 2016 at 16:32
  • \$\begingroup\$ I think we're talking at cross-purposes. 5410 (linked in my first comment) is: given two notes, how many semitones is it from the first to the second. Then 76120, which you also linked in the question, is: given the distance in semitones, what's the name of the interval. The combination of the two seems to me to be: given two notes, what is the name of the interval between them. \$\endgroup\$ Aug 25, 2016 at 16:42
  • \$\begingroup\$ No, because you lose data; 5410 will output 6 semitones for both F to B and B to F, and then 76120 doesn't know whether that's an augmented fourth or a diminished fifth. \$\endgroup\$
    – Neil
    Aug 25, 2016 at 18:54
  • \$\begingroup\$ Having read this question several times, neither do I, so maybe if you improve the specification the difference will become apparent. \$\endgroup\$ Aug 25, 2016 at 21:53
  • \$\begingroup\$ I don't know a clearer way of putting it than the inclusive number of note names. F to B is a fourth because there are four letters F, G, A, B. B to F is a fifth because there are five letters B, C, D, E, f. \$\endgroup\$
    – Neil
    Aug 25, 2016 at 21:57
  • \$\begingroup\$ I think what Neil's getting at is that modified intervals should be expressed relative to the note with the same letter name as the second input in the major scale corresponding to the first input? But it's not specified what should happen if two or three sharps/flats need to be applied to get from the scale note to the second input. Also, two of the test cases are inaccurate: C#-Eb is a second, and Db-B# is a major seventh. \$\endgroup\$
    – feersum
    Aug 25, 2016 at 23:36
  • \$\begingroup\$ @feersum C to E is three notes, not two, and D to B is six notes, not seven. \$\endgroup\$
    – Neil
    Aug 26, 2016 at 7:33
  • \$\begingroup\$ @feersum No, that's a minor third. \$\endgroup\$
    – Neil
    Aug 26, 2016 at 7:38
  • \$\begingroup\$ All right, I see that diminished third is actually a standard term. But it seems to conflict with the rule saying If your interval does not match any of the ones so far... since the interval does match one of the ones listed above. \$\endgroup\$
    – feersum
    Aug 26, 2016 at 7:49
  • \$\begingroup\$ @feersum I've rephrased my question a bit, does that help? \$\endgroup\$
    – Neil
    Aug 26, 2016 at 8:37

Limit a table

(this is in minimal form, and is in rough sandbox stage. refrain from voting at this stage. I will flesh it out at a later point in time.)

Given a CSV file containing two columns, and an integer N, format the table into multiple rows such that each column contains at most N rows, excluding the header. Like this, for N = 3:



  • \$\begingroup\$ I think I understand how the output is constructed from the input, but this is basically not explained in the challenge which makes it extremely unclear. \$\endgroup\$
    – Fatalize
    Aug 29, 2016 at 7:07
  • \$\begingroup\$ @Fatalize of course. "this is in minimal form, and is in rough sandbox stage." \$\endgroup\$ Aug 29, 2016 at 11:08

Tower of Hanoi Hamiltonian Cycle

Every tower of Hanoi has a unique Hamiltonian cycle of length 3ⁿ. The cycle for n=1 is simply 1| | , |1| , | |1 while for n=2 it is as follows:

12          move disc 1 from rod 1 to rod 2
2   1                 2          1        3
    1   2             1          2        3
        12            1          3        1
1       2             2          3        2
1   2                 1          1        2
    12                1          2        3
    2   1             2          2        1
2       1             1          3        1 - closes cycle

Your task is to write a program or function which, given a positive integer n, returns the Hamiltonian cycle for the Hanoi Graph of order n.

You can output the graph starting at any point and traversing it in either order. You can output the graph as a list of positions or a list of moves. It must be possible to loop back from the last line of your output to the first, but you don't have to repeat the position.

This is , so the shortest solution wins.

  • \$\begingroup\$ The cycle can be constructed as a trivial variant of solving the standard tower of Hanoi puzzle, making this a duplicate. \$\endgroup\$ Sep 3, 2016 at 8:25
  • \$\begingroup\$ The standard solution is simply a straight line along the edge of the Hanoi graph, while the cycle is a fractal. How is that a trivial variant? \$\endgroup\$
    – Neil
    Sep 3, 2016 at 10:04
88 89
91 92

You must log in to answer this question.

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