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]


3025 Answers 3025

62 63
65 66

Write a Gopher Interpreter

This code golf challenge will task you with writing an interpreter for an esolang I created a while back called Gopher, Details on the language can be found Here

Pass Conditions

This challenge requires you to create an Interpreter (Or you could go a step ahead and create a Compile/Transpiler) however for the code to pass as correct it must meet the following criteria

  • Take in a single input being the Gopher Code
  • Output the result of the Interpreted code

  • Invalid code does not need to be handled, however you may do so if you wish

  • As this is code-golf the smallest byte size wins

Example Input and Output




Hello World
  • \$\begingroup\$ Thanks for using the Sandbox! Anyway, you should add the relevant information on Gopher to the body of this post, as if your github account/repo dies or is changed people still need to be able to answer this question. \$\endgroup\$ – FryAmTheEggman Jul 11 '16 at 17:15

Having had a look, it seems there isn't a challenge for "Given any date, output the day of the week". Is that a challenge worth having?

Something like

"Given an input date, in the form dd/mm/yyyy, output the day of the week"

Shortest code wins

What do we think? perhaps this already exists and I didn't find it.

  • 3
    \$\begingroup\$ Duplicate \$\endgroup\$ – AdmBorkBork Jul 11 '16 at 14:04
  • 2
    \$\begingroup\$ Glad I checked! \$\endgroup\$ – Matt Jul 11 '16 at 14:05

Golf your way from (inc|dec)rements to the basic math operations

Write five different functions or programs that do addition, subtraction, multiplication, division and modulo with integers by only using increments, decrements, loops/recursion and comparisons.

  • Assume division & modulo will never receive 0 or negative integers as the divisor/modulus.
  • Modulo's result has the sign of its dividend.
  • Division truncates its quotient, e.g divide(11, 4) returns 2 and divide(-5, 3) returns -1.
  • Programs must print the result to STDOUT. Functions must return the result.
  • Your five functions/programs may invoke each other.
  • All functions/programs must support 32-bit signed integers, i.e everything between -231 and 231-1 (inclusive). Overflow is allowed, i.e it's OK if add(2147483647, 1) returns -2147483648.
  • Explicitly adding/subtracting 1 to/from numbers is allowed, in case you use a programming language that doesn't have built-ins for incrementing and decrementing.
  • Shortest program wins as long as it doesn't exploit standard loopholes!

I seriously have no idea how to make test cases for this.

  • 1
    \$\begingroup\$ Why not one function that returns all of those? You should also specify what you mean by divisions and modulo as they differ slightly from language to language. (E.g. what is -2 mod 5? and what is -1/2?) And only doing increments/decrements, loops/recursion and compraisions is also quite vague. \$\endgroup\$ – flawr Jul 10 '16 at 16:37
  • 1
    \$\begingroup\$ I don't think test cases would really be necessary since it's just basic arithmetic. You can easily tell if your output is correct or not. Also, I'm assuming that division will truncate the quotient since there isn't really any way to do decimals in this fashion, but that should probably be specified. \$\endgroup\$ – Business Cat Jul 11 '16 at 14:18
  • 1
    \$\begingroup\$ I already did this because I was bored... \$\endgroup\$ – univalence Nov 19 '16 at 12:52

ASCII to Unicode equation beautifier

You may well be used to typing equations in ASCII, but with the advent of Unicode we can spruce them up a bit. We can fix

  • Powers (numeric superscripts only)
  • Numeric subscripts
  • Mathematical signs (-, *, / ^ → -, ×, ÷, ↑)


x^3 - 1 = (x - 1)(x^2 + x + 1)  →  x³ − 1 = (x − 1)(x² + x + 1)
g_0 = 3^^3^^3 -= 3^(3^3)        →  g₀ = 3↑↑3↑↑3 = 3↑(3³)
800*600                         →  800×600
1/x                             →  1÷x

You may assume that all digits directly after a ^ or _ are meant to be super/subscripts (and the ^ or _ to be removed) and that all the mathematical signs are to be replaced wherever they appear.

This is , so the shortest solution wins.

  • 2
    \$\begingroup\$ This seems to be two questions crammed into one. The first one is the superscript and subscript transformation, which is mildly interesting; and the second one is the straight substitution of various characters for others, which is completely boring apart from the ambiguity it introduces in the interpretation of ^. I suggest ditching the substitution of minus, times, and divide symbols and giving explicit lists (with copyable characters and Unicode code points in decimal and hex) of the superscript, subscript, and up-arrow characters. \$\endgroup\$ – Peter Taylor Jul 14 '16 at 6:39

Autotune a chord

Auto-Tune is a pitch correction program which alters the pitch without changing the length. It can be used to fix off-pitch chords in music, which is good because I have an out of tune piano. The goal of this challenge is given some input waveform which contains a single chord played on my piano, tune each note to the nearest equally tempered note found on a standard piano (see Input for more details).


The input is something which looks like a time-domain audio sample input containing a single chord being played. All data is sampled at 192kHz, with 16-bit PCM (little endian integer), mono channel. The input may come from any source desired (file io, stdio, function parameter, etc.).


The output of your code should be something which looks like a time-domain audio sample containing the tuned chord. It does not need to have the same sample rate or datapoint format as the input, but must be the same length in real time as the original sample (or as close as possible). The output may be to any source desired (file io, stdio, function parameter, etc.).


See this github repo for various inputs and outputs. The provided examples have inputs/outputs in an uncompressed wav file. Feel free to re-encode/gut the data for your inputs.


This is code golf; shortest code wins. Standard loopholes apply. You may use any libraries/builtins so long as they were not designed specifically for performing pitch correction.

Main concern: This challenge seems potentially too difficult, so one alternative I've been considering is changing the piano samples into sine waves at the fundamental frequencies (avoids issues with amplitude decay/harmonics). An even simpler challenge might be to give inputs in the frequency domain (list of fundamental frequencies), though I'm not sure that would make for an interesting challenge as it seems almost too easy at that point.

  • 1
    \$\begingroup\$ It seems very difficult to determine what outputs are considered correct. \$\endgroup\$ – feersum Jul 14 '16 at 7:44
  • \$\begingroup\$ yeah, that thought had crossed my mind as well. I've considered measures based on the delta of the FFT of user output/expected output, but I'm not sure this is necessarily a good measure of "in tune". \$\endgroup\$ – helloworld922 Jul 14 '16 at 7:47
  • \$\begingroup\$ I suspect that the biggest technical challenge would be phase. The harmonics of each string in isolation should be in phase, because they all derive from a single hammer strike, but the keys of the chord are probably not all struck at exactly the same time, and there will be resonant driving interactions between them which will complicate the signal. I suggest that you explicitly state that people can ignore this issue. \$\endgroup\$ – Peter Taylor Jul 14 '16 at 13:39

This will be a challenge. Additional tags are , and .

How fast is your Stack Exchange community?


Your task is to find how fast a Stack Exchange community reacts. "How fast" is here the average of the time elapsed until the first answer or the closing of the question.


  • the Stack Exchange site's name, e.g. stackoverflow, codegolf, codereview etc.
  • optionally the Stack Exchange API URL: https://api.stackexchange.com/2.2/


  • Calculate the average time it takes until the first answer or closing of the question.
  • Take the 1000 latest questions into account, e.q. ten API requests with 100 items each.


  • Output the average time in minutes and seconds, like 01:23 or 1:23.
  • Run your program at least against stackoverflow, codegolf and code review and show the results.
  • Feel free to add results for your other favorite communities as well.


  • You can write a program or a function. If it is an anonymous function, please include an example of how to invoke it.
  • This is so shortest answer in bytes wins.
  • Standard loopholes are disallowed.
  • Leading/trailing whitespaces/newlines are fine.
  • 2
    \$\begingroup\$ How do you count unanswered and unclosed questions? Also, I don't know about the API, but there might be problems with deleted answers. I think you should probably write a reference implementation before posting this. \$\endgroup\$ – FryAmTheEggman Jul 14 '16 at 13:10
  • \$\begingroup\$ @FryAmTheEggman Thanks a lot – all good points. Didn't think that there might be questions that are unclosed and unanswered. Will check the API whether deleted even will be send. Good point with the reference implementation – maybe in JavaScript that it can be run as a stack snippet. What do you think in general about the challenge idea? Boring? Interesting? Too complicated? \$\endgroup\$ – insertusernamehere Jul 14 '16 at 13:15
  • 1
    \$\begingroup\$ It's about doing basically one task, so I don't think it is complicated. I think the results are probably more interesting than the challenge (there are only so many ways to average something and to parse html), but it makes sense and isn't trivial, so I wouldn't say it's boring. Seems fine overall. Also note internet, date and, I suppose, math. \$\endgroup\$ – FryAmTheEggman Jul 14 '16 at 13:24
  • \$\begingroup\$ @FryAmTheEggman Thanks again for your feedback and the tag suggestions. I also think that the results are the interesting part. I wanted to try a popularity contest in the first place because of that. But I couldn't come up with the necessary criteria. :) \$\endgroup\$ – insertusernamehere Jul 14 '16 at 13:30

Convert a BMP image to grayscale

The images manipulation is a great way to exercise and increase your skills. In my opinion it's also very interesting.

What you must do?

The objective of exercise is much easy: convert an image bmp colorful in an image grey.
You can use every language, the question most appreciated will be that don't use library.
Image stock: http://www.mediafire.com/convkey/c491/p7aya9cxafvfc91zg.jpg Image converted: http://www.mediafire.com/convkey/3903/rcigd79pkwd12qczg.jpg?size_id=3

  • 1
    \$\begingroup\$ What is the winning criterion? It is code-golf, popularity-contest, other criterion? \$\endgroup\$ – TuxCrafting Jul 15 '16 at 10:30
  • 1
    \$\begingroup\$ Also, the You can use any language is unnecessary, it's implied here. And you can use ![](<image url>) to show the images. \$\endgroup\$ – TuxCrafting Jul 15 '16 at 10:33
  • 4
    \$\begingroup\$ This is very underspecified at present. 1. What weights should be used in the conversion from RGB to greyscale? 2. What bit depths should be supported? 3. Is it required to support all of BMP's features (e.g. ICC colour profiles, CMYK, JPEG, PNG)? If not, what is the minimum feature set which must be supported? \$\endgroup\$ – Peter Taylor Jul 15 '16 at 10:53
  • \$\begingroup\$ @Blind To mention someone, you can use @<username>, and please add the tags to your post ([tag:<tag name>]) \$\endgroup\$ – TuxCrafting Jul 15 '16 at 12:43
  • \$\begingroup\$ @TùxCräftîñg , It's a code-golf. @ Peter Taylor , It's equal, you can use that weight you want. 2.see 1st. 3.just support BMP. \$\endgroup\$ – Blind Jul 15 '16 at 16:27
  • 1
    \$\begingroup\$ That doesn't actually answer questions 2 or 3. \$\endgroup\$ – Peter Taylor Jul 15 '16 at 19:32
  • \$\begingroup\$ Just to let you know, you can only @mention one person per comment, and it won't work with a space between the @ and the name. \$\endgroup\$ – trichoplax Jul 20 '16 at 16:20

Do I have an emoji?

Given an input string in your language, return truthy/falsey if the input contains an valid Unicode emoji character.

What is an Emoji?

The word emoji comes from the Japanese:

絵 (e ≅ picture) 文 (mo ≅ writing) 字 (ji ≅ character).

Emojis are pictorial symbols used to represent feelings, actions, or objects.

For this challenge, use the Full Emoji Data list provided by Unicode as a reference to determine which characters are valid Emojis.

Sample test cases:

"" -> 0

"💩" -> 1

"hello💩" -> 1

"hello" -> 0

"!±≡𩸽" -> 0


This seems trivial, but I noticed we didn't have an emoji detection challenge. There might be a concern about the encoding of the input string, but reading the linked meta posts about Strings I feel that this challenge can use whatever String format the language used in the answer supports.

The acceptable output for booleans is also up for discussion. Do we have a meta post on what output formats are acceptable for booleans?

  • 5
    \$\begingroup\$ One question: What exactly is an emoji? I think it should be specified in the challenge. \$\endgroup\$ – user48538 Jul 18 '16 at 16:38
  • 1
    \$\begingroup\$ See meta.ppcg.lol/q/2190, just say truthy/falsey. \$\endgroup\$ – LegionMammal978 Jul 18 '16 at 16:39
  • \$\begingroup\$ @zyabin101 can I use Unicode's emoji list as a list of valid emoji characters for this challenge? \$\endgroup\$ – JAL Jul 18 '16 at 16:44
  • \$\begingroup\$ Up to you. [filler text] \$\endgroup\$ – user48538 Jul 18 '16 at 16:51
  • \$\begingroup\$ I've attempted to clarify what an emoji is, at least for this challenge. Hopefully this will make this question more clear and a better fit for the site. \$\endgroup\$ – JAL Jul 19 '16 at 2:39
  • \$\begingroup\$ A source which gives actual ranges would be more convenient for people writing answers, although unicode.org/Public/emoji/3.0//emoji-data.txt isn't entirely consistent with the other lists. \$\endgroup\$ – Peter Taylor Jul 19 '16 at 9:52

Trim trailing spaces in less than O(n²) time

Since s/\s+$// runs in O(n²) time, Stack Overflow needs to replace it with something faster. Please write a code snippet for them. Your score will be the number of bytes in your submission, multiplied by the time taken to process a string of 1000 non-spaces with 1,000,000 leading and trailing spaces, divided by 1000 times the time taken to process a string of 1-non space with 1,000 leading and trailing spaces. (In other words, if your code runs in O(n) time then this should cancel out.)

  • \$\begingroup\$ The fancy scoring seems like it might be confusing/hard to implement. Why not just restrict the complexity to be less than O(n²) like you suggest in the title? \$\endgroup\$ – FryAmTheEggman Jul 21 '16 at 13:18
  • \$\begingroup\$ @FryAmTheEggman That's fairly easily fixed with (?<!\s)\s+$ or using RTL matching in .NET/Retina. (In fact, the latter would probably be a good candidate for winning the challenge even if actual runtime is taken into account.) \$\endgroup\$ – Martin Ender Jul 21 '16 at 15:29
  • \$\begingroup\$ @MartinEnder That is what I had in mind ;) Is there a reason that would be bad? I think that is likely around the best performance you can get, being linear w.r.t. the number of spaces at the end of the string? \$\endgroup\$ – FryAmTheEggman Jul 21 '16 at 15:33
  • \$\begingroup\$ @FryAmTheEggman well it just means there's likely a very simple solution that might win the challenge. \$\endgroup\$ – Martin Ender Jul 21 '16 at 15:35
  • \$\begingroup\$ The scoring mechanism is not going to work well because the times will be so small that there will be more noise in the measurement than signal. Especially for the smaller test case, where the string will fit in L1 cache. \$\endgroup\$ – Peter Taylor Jul 21 '16 at 16:15
  • 1
    \$\begingroup\$ The scoring can be exploited by intentionally doing badly on smaller cases. \$\endgroup\$ – xnor Jul 22 '16 at 2:46

Reverse stdin to stdout, Unicode aware and by grapheme clusters

It's 2016. High time that we were Unicode-aware, don't you think?

Given a UTF-8 string on stdin, reverse it by extended grapheme clusters (as defined by the Unicode consortium; this can be found here, for instance) and place it on stdout. This is seemingly a trivial challenge, but surprisingly difficult in many languages.

You may not use an explicit end-of-file character - if supported, use EOF. If not supported, use an explicit length at the start of the string, and document the format.

Note that the string may be of any length (barring RAM limitations).

You must handle direction override characters "properly", in the sense that the directionality of every character must remain the same after reversing the string.

  • \$\begingroup\$ I need examples for this. \$\endgroup\$ – TLW Jul 21 '16 at 23:05
  • \$\begingroup\$ Can you give a link to the Unicode definition of grapheme clusters? \$\endgroup\$ – Steven H. Jul 21 '16 at 23:59
  • \$\begingroup\$ Sure: unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries \$\endgroup\$ – TLW Jul 22 '16 at 1:18
  • 1
    \$\begingroup\$ I don't understand what you mean about the direction override characters. Could you give some test cases (preferably with hexdumps of input and output)? What other corner cases are there? On a first read-through I can tell that understanding the definition of extended grapheme cluster will take some time, but I'm not clear on whether it covers e.g. emoji type modifiers, emoji families, etc. The definition also makes reference to degenerate cases, and they should be covered by test cases too. \$\endgroup\$ – Peter Taylor Jul 27 '16 at 12:05

Given an ordinal A and a nonnegative integer B, compute f_A(B)

A will be expressed in Cantor Normal Form. A number is in Cantor Normal Form if it is 1, or if it is either of the form a+b or w^a, where a and b are in Cantor Normal Form, and w is the ordinal omega.

f_A(B) is the fast-growing hierarchy, specifically, the Wainer Hierarchy. f_0(n)=n+1. f_(a+1)(n)= n iterations of f_a to n. f_a(n)=f_an if a is a limit ordinal. a[n] is the nth member of the fundamental sequence for a.

  • \$\begingroup\$ You'll definitely need to add the definitions of these, as most people won't have any idea how to answer. You can use one of various online TeX -> image services and add those to your post. Sadly we don't have MathJax activated because it borked a bunch of other features. I'd also heavily recommend adding some test cases. \$\endgroup\$ – FryAmTheEggman Jul 21 '16 at 14:38
  • \$\begingroup\$ Test cases are impossible to add. But thanks for formatting advice! \$\endgroup\$ – Oliver Daugherty-Long Jul 21 '16 at 15:14

Difficulty Naming


In the game osu!, players can make their own beatmaps (levels). The harder the beatmap is, the bigger the star rating will be.

Beatmaps have star icons with different colors and letters according to their star rating.

osu! has also four game modes. The shape of the icon will change depending on the game mode.

The Challenge

Given a star rating and a gamemode, output the (generally used) difficulty name.

The Input

  • A positive floating-point number (star rating)
    • You can assume the number will never have more than two decimal places.
  • A positive integer (game mode)
    • 1 is Standard, 2 is Taiko, 3 is Catch the Beat and 4 is Mania (you can use other numbers for the game modes, these are the default.)

The Output

  • A string (difficulty name)

Use this table to determine the output:

diff table http://image.prntscr.com/image/174e34e56dbb40ad81b209fac3fdc5bc.png

(if the star rating is exactly 5.25, it counts as Above 5.25)


  • This is , so the shortest solution wins.
  • Standard loopholes are disallowed.
  • You can take the input either as an array/list, a string separated by commas or spaces, or each number individually.
  • Again, you can use other numbers for the game modes.

Test Cases

2.24, 2 ---> Futsuu
1.1, 4 ---> Basic
3.14, 1 ---> Hard
7.0, 3 ---> Overdose
5.0, 4 ---> Exhaust
31415.0, 2 ---> Ura Oni
0.01, 1 ---> Easy
5.25, 1 ---> Expert


If you see any grammar errors or anything like that, please tell me, I'm not a native speaker.


Could it all add up to nothing?

Given an input number, return a truthy value if it is possible to arrange permutations of + and - signs to make the sum of the range up to that value 0.

Note that you don't have to output which set of combinations is truthy.

Test cases:

1 (1) --> Falsy
2 (1,2) --> Falsy
3 (1,2,3) --> 1+2-3, Truthy
4 (1,2,3,4) --> -1+2+3-4, Truthy
5 (1,...,5) --> Falsy
6 (1,...,6) --> Falsy
7 (1,...,7) --> 1+2-3-4+5+6-7, Truthy
8 (1,...,8) --> 1+2-3-4-5-6+7+8, Truthy

Just one thing - no using eval or similar commands.

This is so the shortest answer in bytes wins!

Sandbox notes

Require a range or a list as input?

  • \$\begingroup\$ For general lists, I think it would be basically the same as this question. For ranges, I suspect there's a direct criterion. \$\endgroup\$ – xnor Jul 25 '16 at 21:50
  • \$\begingroup\$ @xnor so do I which is why I think it could be more interesting if the pattern could be found. It gets exponentially longer as the lists get longer so is harder to check - better as a fastest algorithm/fastest code? \$\endgroup\$ – Blue Jul 25 '16 at 21:52
  • \$\begingroup\$ I can show that it's exactly the numbers of form 4*n or 4*n-1. \$\endgroup\$ – xnor Jul 25 '16 at 21:59
  • \$\begingroup\$ (Ninja'd by xnor) There is probably quite an easy pattern, e.g. if the upper limit is divisible by four, you can always find a zero sum with a "little gauss" argument. \$\endgroup\$ – flawr Jul 25 '16 at 22:01
  • \$\begingroup\$ @xnor I'd love to see a proof=) \$\endgroup\$ – flawr Jul 25 '16 at 22:01
  • 4
    \$\begingroup\$ The key is that the pattern +--+ on four consecutive numbers adds to 0. With 4*n, just repeat +--+. With 4*n-1, do +1+2-3, then repeat +--+. With the rest, the sum is odd so it's impossible. \$\endgroup\$ – xnor Jul 25 '16 at 22:04
  • \$\begingroup\$ So saveable? Sounds trivial now. \$\endgroup\$ – Blue Jul 25 '16 at 22:31
  • \$\begingroup\$ Well, I'm guessing xnor's solution would be pretty short. \$\endgroup\$ – mbomb007 Jul 29 '16 at 14:35

Grow and Visualize Decision Tree

META: work in progress...

  • Would providing the points as an image instead of a list of coordinates simplify the challenge?

Given two sets of points in the plane with coordinates x,y, both in [0,1), grow a (binary) decision tree as specified below and output a square pixel image of a given size, that visualizes the corresponding tree.

How to grow the tree

The we call the two sets here classes and follow the following recursive approach:

  1. If at least one of the classes is empty, label the current node as a leaf of the nonempty class and stop. Otherwise:

  2. First find the mean of each of the x (or y)-coordinates of each of the two classes, and find the mean/center c of those two means. Then we partition both classes as follows: All points with an x (or y)-coordinate strictly smaller than c belong to one half, all the other ones to the other half. The we set the current node to the decision is the x-cooridinate (or y-coordinate) less than c?

  3. For each of the halves, go back to step 1 and 2, and set the resulting nodes as the child nodes from the current node. If you previously considered the x-coordinates, then consider y-coordinates and vice versa.

enter image description here

How to visualize the tree

We partition the the unit interval [0,1) into N equidistant sub intervals [0,1/N), [1/N,2/N), [2/N,3/N)... and correspondingly the unit square [0,1)x[0,1) into squares

[i/N,(i+1)/N)x[j/N,(j+1)/N) for i,j=0,1,2,...,N-1

which later will be represented by a pixel. For each square [i/N,(i+1)/N)x[j/N,(j+1)/N) we classify the point i/N,j/N with the tree we just grew and colour the corresponding pixel with the corresponding colour.

For the example above the output would look like so:

enter image description here


  • Input: An integerN>5 and two sets of points in any convenient format (e.g. as two separate list of points, or as a single list with a label for each point etc.) You can assume that in total there is at least one point.
  • Output: A pixel image (vector images composed of squares are ok too) of the visualization.
    • You have to choose any two distinct colours, I recommend blue and red.
    • The x-axis should point to the right, the y-axis can point in any direction.
    • The submission should display the image on the screen or save it to a file (like jpg/png/tiff or similar formats)
  • \$\begingroup\$ 1. The example has the y-axis running upwards, but the text doesn't specify whether that's required. 2. What exactly counts as a "pixel image"? In particular, I assume that a 2-dimensional array doesn't, but if you don't rule that out explicitly then someone will probably try it. \$\endgroup\$ – Peter Taylor Jul 25 '16 at 20:33
  • \$\begingroup\$ @PeterTaylor Thank you for the feedback, I added these points. I just had the idea to provide the input points as image, instead of a list of coordinates as a simplificatio. \$\endgroup\$ – flawr Jul 25 '16 at 21:51

Quine-ify PPCG Answers!

Write a program that, when executed, returns the markdown file to your answer.

So, something like this:

#Python: 123 bytes

`{insert code here}`

Required things:

  • Header must be one hash (#)
  • The "code part" must be indented with four spaces (or surrounded with backticks if it's a one-liner).
  • The code part must be the actual code used to run the program.
  • There must be a separation of a newline between the header and the code.
  • The program's display bytecount MUST equal the program's actual bytecount.


  • Most importantly: is it even possible, at all?
  • Do I need more clarifications?
  • Has this been done already?
  • 4
    \$\begingroup\$ "Most importantly: is it even possible, at all?" Definitely possible and in most languages no more difficult than a standard quine. The points in this answer probably apply as well. Also the third-to-last paragraph in this answer since languages with longer names will have a disadvantage. And finally, there's this related challenge (same thing without the quine part). \$\endgroup\$ – Martin Ender Jul 27 '16 at 7:25
  • \$\begingroup\$ Actually, it's just too easy. Just use a normal quine with stuff before. \$\endgroup\$ – Erik the Outgolfer Aug 3 '16 at 17:50

Make a sequence from a sequence!

(Title is bad and I should feel bad)

Given a sequence of positive Integers, take each consecutive pair of two (without taking an element two times) (x,y) and print y x times.

For example for 3,1,4,2

  1. Pairs are (3,1) and (4,2)
  2. (3,1): Print 1 three times: 1 1 1
  3. (4,2): Print 2 four times: 2 2 2 2
  4. Resulting sequence/output is 1, 1, 1, 2, 2, 2, 2


A sequence of positive integers divisible by two. This can be done by parameters, a flat array, an integer stream etc. AS LONG AS there's no nesting or pre-matching of pairs involved.


The resulting sequence as showcased above. Same rules for datatypes as declared in input, keep everything flat.

Test cases

      3, 1, 4, 2 => 1, 1, 1, 2, 2, 2, 2
            6, 5 => 5, 5, 5, 5, 5, 5
1, 1, 1, 1, 1, 1 => 1, 1, 1

Reference Implementation (Ruby, 55 bytes)

f=->a{a.each_slice(2).collect{|x|Array.new *x}.flatten}


def g *a
  a.each_slice(2).collect do |x|
    Array.new(x[0], x[1]) 

The first golfer to find a shorter solution in this language gets a -1 bonus.


Shortest code in bytes wins.

  • \$\begingroup\$ 1. You explicitly mention printing. Could a function submission also return the array? 2. I recommend dropping the bonus. 3. Can the input be empty or will there be at least one pair? \$\endgroup\$ – Dennis Jul 27 '16 at 21:16
  • \$\begingroup\$ This is close enough to this question that I would cast my supervote to close as duplicate. \$\endgroup\$ – Peter Taylor Jul 28 '16 at 8:08
  • \$\begingroup\$ @PeterTaylor indeed. Will drop this challenge then. \$\endgroup\$ – Seims Jul 28 '16 at 10:02

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\$ – Nathan Merrill Jul 29 '16 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\$ – Patrick Roberts Jul 29 '16 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\$ – Nathan Merrill Jul 29 '16 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\$ – Patrick Roberts Jul 29 '16 at 16:14
  • \$\begingroup\$ Unfortunately not. It'd be like challenges that say "Write the cleanest code, judged by me". \$\endgroup\$ – Nathan Merrill Jul 29 '16 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\$ – Patrick Roberts Jul 29 '16 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\$ – Nathan Merrill Jul 29 '16 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\$ – Nathan Merrill Jul 29 '16 at 22:46
  • \$\begingroup\$ @NathanMerill can I specify a specific language I have in mind? \$\endgroup\$ – Rohan Jhunjhunwala Jul 29 '16 at 23:06
  • \$\begingroup\$ @NathanMerrill and then make it code golf \$\endgroup\$ – Rohan Jhunjhunwala Jul 29 '16 at 23:06
  • \$\begingroup\$ Yes, that would be on topic, but not necessarily interesting, depending on the target language \$\endgroup\$ – Nathan Merrill Jul 29 '16 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\$ – Rohan Jhunjhunwala Jul 29 '16 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\$ – Nathan Merrill Jul 29 '16 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\$ – Rohan Jhunjhunwala Jul 29 '16 at 23:20
  • \$\begingroup\$ @NathanMerrill I will delete this challenge as it seems to be uninteresting? \$\endgroup\$ – Rohan Jhunjhunwala Jul 29 '16 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\$ – Nathan Merrill Jul 29 '16 at 23:23
  • \$\begingroup\$ It seems that it is challenging to write any reasonalbly readable environment for assembling to brainf*** \$\endgroup\$ – Rohan Jhunjhunwala Jul 29 '16 at 23:27
  • \$\begingroup\$ what if I choose X to be Brainfuck or Brainfuck+one extra command. \$\endgroup\$ – KarlKastor Jul 30 '16 at 19:49
  • \$\begingroup\$ Than you would likely lose. @KarlKastor. It is not code-golf but rather popularity-contest \$\endgroup\$ – Rohan Jhunjhunwala Jul 30 '16 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\$ – Nathan Merrill Jul 31 '16 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\$ – Rohan Jhunjhunwala Jul 31 '16 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\$ – Nathan Merrill Jul 31 '16 at 1:20
  • \$\begingroup\$ @NathanMerril ok sounds good. \$\endgroup\$ – Rohan Jhunjhunwala Jul 31 '16 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\$ – Rohan Jhunjhunwala Jul 31 '16 at 1:27
  • \$\begingroup\$ Hmm. That sounds more like a code-challenge then (just with a time limit) \$\endgroup\$ – Nathan Merrill Jul 31 '16 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\$ – Nathan Merrill Jul 31 '16 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\$ – Peter Taylor Aug 1 '16 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 '16 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\$ – Nathan Merrill Aug 3 '16 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 '16 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\$ – Peter Taylor Aug 4 '16 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 '16 at 18:23
  • 1
    \$\begingroup\$ 2. Duplicate. \$\endgroup\$ – Leaky Nun Aug 4 '16 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\$ – ASCIIThenANSI Aug 5 '16 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\$ – MildlyMilquetoast Jan 20 '17 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\$ – FryAmTheEggman Jun 7 '16 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 '16 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 '16 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\$ – trichoplax Aug 8 '16 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\$ – WonderWorker Aug 8 '16 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\$ – trichoplax Aug 8 '16 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 '16 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\$ – trichoplax Aug 8 '16 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\$ – trichoplax Aug 8 '16 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\$ – trichoplax Aug 8 '16 at 10:07
  • \$\begingroup\$ Related challenge (not a duplicate - just for information) \$\endgroup\$ – trichoplax Aug 8 '16 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\$ – Peter Taylor Aug 8 '16 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\$ – WonderWorker Aug 9 '16 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 '16 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\$ – WonderWorker Aug 12 '16 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\$ – trichoplax Aug 10 '16 at 10:34
  • \$\begingroup\$ Probably should have had the amount of seconds in a day yes \$\endgroup\$ – Destructible Lemon Aug 10 '16 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\$ – trichoplax Aug 10 '16 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\$ – Peter Taylor Aug 10 '16 at 13:39
  • \$\begingroup\$ I might think about a formula for the amount of n-ary hours that's less trivial soon \$\endgroup\$ – Destructible Lemon Aug 10 '16 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 '16 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\$ – Peter Taylor Aug 11 '16 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\$ – FryAmTheEggman Aug 11 '16 at 15:27
  • \$\begingroup\$ @FryAmTheEggman It makes for a good clickbait title though :P \$\endgroup\$ – Theo Aug 11 '16 at 15:33
  • \$\begingroup\$ @FryAmTheEggman Fair point, what would you suggest? \$\endgroup\$ – Justin Aug 11 '16 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\$ – FryAmTheEggman Aug 11 '16 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\$ – Peter Taylor Aug 8 '16 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 '16 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\$ – Destructible Lemon Aug 15 '16 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 '16 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 '16 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\$ – trichoplax Aug 15 '16 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\$ – trichoplax Aug 15 '16 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\$ – trichoplax Aug 15 '16 at 11:40
62 63
65 66

You must log in to answer this question.

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