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]

  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43

2590 Answers 2590


Title: Station Codes


In the UK, railway stations are assigned three-letter "CRS" codes (e.g. "Chester" = CTR, "Caterham" = CAT). Something similar is also used for airports worldwide (IATA codes).


The challenge is to take in the three letter code as the input, and present the name of the station as the output.

The codes are always in upper-case; the outputs are as shown in the link above.

Usual IO rules, exclusions; code-golf rules apply.


  • CAT -> Caterham
  • CCH -> Chichester
  • HHY -> Highbury & Islington
  • HOP -> Hope (Derbyshire)
  • AUW -> Ascott-under-Wychwood
  • CSD -> Cobham & Stoke d'Abernon
  • HID -> Hall-i'-th'-Wood
  • HXX -> Heathrow Airport Terminals 1, 2 and 3
  • ELY -> Ely
  • anything else listed in the link above - the correct station name
  • anything not listed in the link above -> no preference

Sandbox Query

Is this boring? - does it add anything to the existing gamut of "compress a load of data and index it" -type questions?

  • \$\begingroup\$ I'm not sure if this challenge is going to be interesting or not, as there are so many codes and I'm not sure if most of them can be formulated. But anyways I think you need to list all of the codes in your question as the link can go down or change. Generally challenges should be self containing without the need to open any external links or resources. \$\endgroup\$ – Night2 Oct 18 at 14:53
  • \$\begingroup\$ Is their any logic to the limited subset of stations you've chosen for the challenge? This isn't, strictly, KC, by the way. \$\endgroup\$ – Shaggy Oct 19 at 23:00
  • \$\begingroup\$ @Night2 Thanks, I'll list out the codes. \$\endgroup\$ – simonalexander2005 Oct 20 at 13:37
  • \$\begingroup\$ @Shaggy the codes I used in the examples were chosen because they cover the all the non-alpha characters in the station names. The challenge, though. uses the entire set of CRS codes, as published by Network Rail. Are there some other codes you're thinking of that aren't covered by that list (now included in the question also)? \$\endgroup\$ – simonalexander2005 Oct 20 at 13:38
  • \$\begingroup\$ @Night2 actually I can't include the codes, it's too many characters so it exceeds the limit of 30,000 characters \$\endgroup\$ – simonalexander2005 Oct 20 at 13:43
  • \$\begingroup\$ That is a problem for itself, about 40k characters for a code golf challenge. Even if there was a formula to 100% of the times, match an input code to a station name, there would still be around 30k characters for station names to store. \$\endgroup\$ – Night2 Oct 23 at 3:23

Implement Or

or is a dubious esoteric programming language. The author is unknown but it is known that fungot (a chatbot) is currently learning or but it remains unknown how it does it and where it receives the required material to learn or. Check out this IRC log to see fungot revealing part of the language.

Instruction reference

It is only known that a space followed by an f pushes false to the stack. The false value may by any falsy value of your choosing. Since this language does not support output, in order to make verifying answers possible, you should output the resulting stack in the end of the program.

Test cases

Expects one false to the stack


Expects 2 falses on the stack

m f ma f

Expects 1 false on the stack

 f a lf 

Expects 2 falses on the stack

a f fa


This is , so shortest answer in bytes wins.


  • Is this clear enough?
  • I haven't found a duplicate, but anything?
  • Tags are code-golf, string and interpreter. Anything else?
  • Any further feedback?
  • \$\begingroup\$ Duplicate of this. \$\endgroup\$ – A _ Oct 21 at 14:01
  • \$\begingroup\$ Duplicate of this. \$\endgroup\$ – A _ Oct 21 at 14:02
  • \$\begingroup\$ Duplicate of this. \$\endgroup\$ – A _ Oct 21 at 14:03

Make a karaoke machine

Given a list of lines and a set time (in seconds) which those lines appear, output those lines after that specific amount of seconds.

Example input:

0 Hello there!
5 This line should come up after 5 seconds.
10 This line should come up 5 seconds after that one.
20 There's a 10-second delay here.

Every line will be preceded by an integer, separated from the rest of the line by a string. The number indicates when the line should come up - the first line should be outputted instantly, followed by the next few lines like so:

Hello there! (output instantly)
(wait 5 seconds)
This line should come up after 5 seconds.
(wait 5 seconds)
This line should come up 5 seconds after that one.
(wait 10 seconds)
There's a 10-second delay here.


  • You're guaranteed that the lines are in order - i.e. this doesn't happen:
    5 Hello there!
    0 Oops, this is meant to happen before the first line.
  • You're also guaranteed that no two lines share the same time.

Winning criteria:

This is , so shortest code in bytes wins!

  • 1
    \$\begingroup\$ No problem in particular. However I'd expect that many solution will have unbounded drift when the number of lines increases, so you may ban that (w. r. t. the system clock if there's one, for example) plus, I suppose that lines are short enough such that printing them takes a negligible time. \$\endgroup\$ – user202729 Oct 28 at 10:59
  • \$\begingroup\$ I found several related challenges: 1 2 3. None of them were quite the same, but I think they all suffered from some of the problems that user202729 mentioned. Most of them still went well, but I think being more rigorous won't hurt. \$\endgroup\$ – FryAmTheEggman Oct 28 at 15:15

Interpolate between binary images

While there are various ways to interpolate between images with a large color space where for each color there are many similar other colors, it is not so straightforward to do that in a (heavily) quantized color space where you only have few colors available. We now take that to an extreme:

Given two black and white image of the same size as well as a number \$N\$, output a sequence of \$N\$ images that "interpolate" between the two input pictures.

The goal here is coming up with an "interpolation" algorithm that allows you to smoothly transition between two images. But how you define this smoothness is up to you. The more aesthetically pleasing the better.


  • "black and white" here means the images consist only of the colors black and white, no grays.
  • Validity criteria:
    • The first image in the sequence must be the first input image, and the last image in the sequence must be the second image.
    • All images must have the same size and consist of only black and white pixels. Furthermore the output must be deterministic in the sense that if you repeatedly call the program with identical inputs, you must get identical outputs.
  • Please post the sequence of images as an animation in your answer, for any \$N\$ you choose.


To be defined...

  • \$\begingroup\$ popularity contests are at this point considered almost considered "historical". You need a clear scoring criterion for a valid challenge, which in your case means defining smoothness as something better than just "It's up to you" \$\endgroup\$ – AlienAtSystem yesterday
  • \$\begingroup\$ @AlienAtSystem The popularity contests need validity criteria, but no scoring criteria - we discussed this quite thoroughly about 2 years ago. The problem is that you cannot force people to vote according to a specific way, but you have to design the contest in a way that the desired output is something people will like anyway. It is not really historical, it is just rare that good popularity contests are written. Check out the discussions linked here. \$\endgroup\$ – flawr yesterday

Mahjong bot

It seems there isn't a challenge about mahjong bot...

Basic idea is a simplified mahjong rule:

Rules for beginners

Mahjong game use 136 mahjong tiles (similar to poker cards). There are 4 players in a game.


There are 136 tiles in total.

There are 3 simple suits. Tiles numbered from 1 to 9 in each simple suit. There are 4 identical copies of each tiles in simple suits. That is \$3\times 9\times 4=108\$ tiles. These 3 simple suits are donated as m, p, s. For example, m1 means a tile with number 1 in m suit.

There are also 7 honors tiles. And there are also 4 copies of each honors tile. That is \$7\times 4=28\$ tiles. These tiles are donated as z1 ~ z7. Don't be confused with m, p, s, honors tails are not numbered. Donating as z1 ~ z7 just make it easy.


  1. All 136 tiles are shuffled first;
  2. Each player receives 13 tiles at the beginning (These tiles are kept secret to others); Starting from the first player...
  3. The player draw a tile (secret to others), and then
    • Claim win, or
    • Kong, or
    • Discard a tile
  4. After someone discard a tile, others may
    • Claim win, or
    • Pong, or
    • Kong, or
    • Do nothing (pass)
  5. If anyone win, the game ends;
  6. If anyone Pong, the player have to discard a tile and continue to step 4;
  7. If anyone Kong, the player draw a tile and continue to step 3;
  8. Otherwise, next player draw a tile and the game goes on to step 3;
  9. When someone try to draw a tile but there are no more tiles left, the game draw (no winner).


A player can claim win if tiles in his hand meet requirements (known as self-pick). A player may also declare win if others discard the last tile he need to complete the hand (known as feed). In case two or three players claim win after a single discard, only the one closest player win.

A winning hand must consist of four melds and a pair.

Melds includes Pongs, Kongs, or Chows:

  • Pong: A set of three identical tiles.
    • Example: m1m1m1, p8p8p8, z3z3z3
  • Kong: A set of four identical tiles. (Read more details in Kong section)
    • Example: m1m1m1m1, p8p8p8p8, z3z3z3z3
  • Chows: A meld of three suited tiles in sequence. Only simple suits may in a Chows.
    • Example: m1m2m3, p5p6p7, s7s8s9
    • Invalid: m8m9m1 (no wrap), m1p2s3 (no mixed suit), z1z2z3 (no honors tails)

A pair is two identical tiles.

Any tile may only be used in one Meld / Pair. It should not be reused.


When someone discards a stail, other players may teal the tile to complete a Pong.

  • The player claim Pong;
  • The player got the discarded tile;
  • The player expose two more identical tiles to others and place all these three tiles in the front;
  • The player must discard a tile, and the game continue;


When a player

  • Collect all 4 identical tiles in his hand;
  • Collect 3 identical tiles, and others discard the last one;
  • Collect the last one, while the other 3 are already exposed as Pong by him

The player may claim Kong. When someone claim a Kong

  • Expose all 4 tiles to others, and put them in the front;
  • Draw another tile;
  • The game goes on;

Tiles used in exposed Pong / Kong may not be changed or discarded later. When declare win, tiles used in exposed Pong / Kong must not be reused in other Chows.


  • If a player win by self-pick: The winner got 3 points, others lost 1 point;
  • If a player win by feed: The winner got 3 points. The one who discard that card lost 3 points. Others neither got or lost points.
  • In case a player try some illegal moves: The player lost 9 points. All others got 3 points. And the game ends;
  • Once the game draw by run out of tiles, no points got or lost.

Rules if you already know mahjong

  • Use 136 tiles, no bonus tiles (花牌, flowers) included;
  • 13 / 14 tiles each player at beginning, 4 players;
  • Win only if 4 meld (面子, set), and 1 pair (对, 頭, head, eye);
    • no seven pairs (七对, 七対子), thirteen orphans (十三幺, 国士無双), nagashi mangan (流し満貫), Knitted Straight (组合龙), ect.
  • Pong (碰, ポン, pon), Kong (槓, カン, kan) exists, but not Chow (吃, チー, chii);
  • Both self-pick (自摸, ツモ), feed (食糊, 出铳, ロン) exits; But not robbing a Kong (搶槓)
  • All winning hands worth 1 point (分, 点), no yaku (役, pattern), faan (番, han), fu (符), starting dealer (莊, 庄) calculated;
    • self-pick: winner +3, others -1
    • feed: winner +3, loser -3
    • Replacement tile (嶺上牌, rinshanpai) after open Kong (大明槓) count as self-pick
    • A bot try to act some invalid moves lose the game, which -9, and others +3
  • At most one winner each game (盘, 局). No Sichuan rule, nor multiple feed;
  • No need to claim riichi (立直, リーチ), no furiten (振聴 or フリテン), no abortive draws (途中流局, tochuu ryuukyoku), no not-waiting penalty (ノーテン罰符), no joker tiles (百搭);
  • Starting dealer changed every game no matter who won the last game or draw;


The player who got most points after certain times of games win.


Later, it should be in Python 3 as it is popular here.

Sandbox: Is the rule given above suitable? (Since no one want to change rules after writing controller...)

  • \$\begingroup\$ 1. How will you organize the games between multiple bots, e.g. a tournament or a league? 2. A regular mahjong match usually consists of multiple games (east-wind match or south-wind match). I think you'll need to specify how long each match will be (single-game matches will be fine though). 3. After four kans, no one can declare another kan, right? 4. Just a matter of preference: when you explain the mahjong rules, using pure English terms might be easier to read. \$\endgroup\$ – Bubbler Oct 31 at 9:40
  • \$\begingroup\$ The simplified rules themselves are fine I guess. I can think of a general strategy: go for riichi-style, try to maximize the number of remaining winning tiles, go for a pon when I have multiple pairs, and kan whenever possible. I don't think I can set up a reliable defense because no riichi and no furiten. I just can't imagine how to write these into code... \$\endgroup\$ – Bubbler Oct 31 at 9:47
  • \$\begingroup\$ @Bubbler 1. Run Combination(n, 4) times (Assuming n > 4, otherwise maybe I need to duplicate every bots); 2. Maybe 100 games should be fine. (Starting dealer always change, so nothing east-wind / south-wind would include.) Running only 16 games seems not enough. (This will depends on how many answers then). 3. The 5th, 6th kan are also valid, since we do not include abortive draws nor dora here; 4. I will describe the rules for beginners later. And it would be in English. Current rule is for players who already know how to play. \$\endgroup\$ – tsh Oct 31 at 10:06
  • \$\begingroup\$ @Bubbler I comment these words in brackets since I cannot find any stander translations. And translations vary from one to another (for example, all Chow / Chii / Chi spelling are exists... \$\endgroup\$ – tsh Oct 31 at 10:11

Return the maximum value in the final List

In this challenge, start with an array initialized to zeros with indices starting at 1 and a series of operations to perform on segments of the list. Each operation will consist of a starting and ending index within the array, and a number to add to each element within that range.

Determine the maximum value in the final array.

For example, start with an array of 5 elements: list = [0, 0, 0, 0, 0]. The variables a and b represent the starting and ending indices, inclusive. Another variable, k, is the addend. The first element is at index 1.

a    b    k             list

               [  0,  0,  0,  0,  0]

1    2   10    [ 10, 10,  0,  0,  0]

2    4    5    [ 10, 15,  5,  5,  0]

3    5   12    [ 10, 15, 17, 17, 12]

The maximum value in the resultant array is 17. That is the value to be determined.

Function description

The function must return a long integer that denotes the largest value in the array after all operations have been performed.

listMax has the following parameters:

n: an integer, the size of the initial array.
operations: a 2D integer array where each element contains an operation.


\$3 ≤ n ≤ 10^7\$

\$1 ≤ o ≤ 2 × 10^{5}\$

\$1 ≤ a ≤ b ≤ n\$

\$0 ≤ k ≤ 10^{9}\$

Input Format

Allowed inputs are STDIN, function argument, System argument, file input, etc.

inputs are optional and both 0- and 1-based indexing is allowed.

Sample Case 0

Sample Input 0




1 2 100

2 5 100

3 4 100

Sample Output 0


Explanation 0

Perform the following sequence of o = 3 operations on list = [0, 0, 0, 0, 0]:

  1. Add k = 100 to every element in the inclusive range [1, 2], resulting in list = [100, 100, 0, 0, 0].

  2. Add k = 100 to every element in the inclusive range [2, 5], resulting in list = [100, 200, 100, 100, 100].

  3. Add k = 100 to every element in the inclusive range [3, 4], resulting in list = [100, 200, 200, 200, 100].

Return the maximum value in the final list, 200, as the answer.

Sample Case 1

Sample Input 1




2 3 603

1 1 286

4 4 882

Sample Output 1


Explanation 1

Perform the following sequence of o = 3 operations on list = [0, 0, 0, 0]:

  1. Add k = 603 to every element in the inclusive range [2, 3], resulting in list = [0, 603, 603, 0].

  2. Add k = 286 to every element in the inclusive range [1, 1], resulting in list = [286, 603, 603, 0].

  3. Add k = 882 to every element in the inclusive range [4, 4], resulting in list = [286, 603, 603, 882].

Return the maximum value in the final list, 882, as the answer.


  • \$\begingroup\$ Thanks for using the sandbox! This challenge looks a bit like one taken from another site, so I'd urge you to either put a reference or change some of the wording. Notably, the strict input format isn't a good idea, particularly input that conveys no information (i.e. the 3 after o). I strongly recommend changing the input to match what is usually done for challenges on this site: allowing the information in any convenient format. \$\endgroup\$ – FryAmTheEggman Nov 6 at 16:48
  • \$\begingroup\$ @FryAmTheEggman Please take a look and let me know if there are any changes need to be considered. \$\endgroup\$ – Krishna Nov 7 at 6:28
  • 1
    \$\begingroup\$ Thank you for adding a reference! I would recommend also including a link, if you can. I would also like to reiterate my suggestion to change the input format to be more lenient. \$\endgroup\$ – FryAmTheEggman Nov 7 at 18:25
  • \$\begingroup\$ Hi Krishna, welcome and thanks for using the sandbox! I would agree with FryAmTheEggman regarding allowing "any convenient format" for the input, as is usual on this site. So for your example, f(5,[[1,2,100],[2,5,100],[3,4,100]]) would be a valid option. \$\endgroup\$ – Chas Brown Nov 7 at 22:50
  • \$\begingroup\$ @FryAmTheEggman Added reference Links, and inputs are optional. \$\endgroup\$ – Krishna Nov 8 at 10:36
  • \$\begingroup\$ @ChasBrown Hi, Thank you for your time & the Suggestion. Could you please elaborate on the Convenient input format. And do I need to change the sample test cases as well? or Only "Input Format" \$\endgroup\$ – Krishna Nov 8 at 10:42
  • 1
    \$\begingroup\$ Thanks for adding the link! I've looked through the Terms of Service for hackerrank, and I couldn't figure out whether basically reusing challenges was allowed. I think it would be good if you explained why you were sure it is ok to post (this is the first time I've seen a hackerrank question posted here). The changes you made to input are good, and you can leave the test cases. However, I recommend re-wording the input part so that you don't have "first line," etc., in them anymore. \$\endgroup\$ – FryAmTheEggman Nov 8 at 17:23

Pristine Polyglot Quines

As the title says, you are to create a pristine program which outputs its own source code in as many languages as possible. A pristine program, taken from here is:

Let's define a pristine program as a program that does not have any errors itself but will error if you modify it by removing any contiguous substring of N characters, where 1 <= N < program length.

For example, the three character Python 2 program

8 is a pristine program (thanks, Sp) because all the programs resulting from removing substrings of length 1 cause errors (syntax errors in fact, but any type of error will do):


and also all the programs resulting from removing substrings of length 2 cause errors:


If, for example, `8 had been a non-erroring program then `8` would not be pristine because all the results of substring removal must error.

A pristine quine is a pristine program that outputs its own source code, according to our standard quine rules (so no empty or literal only programs).

You are to write, in as many languages as possible, a pristine quine.

  • Your code must work in a minimum of two distinct languages
  • Different versions of a language do not count as different languages. Therefore, Python 2 and Python 3 are considered the same language.
  • This is , so the answer with the most languages wins
    • In case of a tie breaker, the longest solution, in bytes, wins


  • \$\begingroup\$ Wow, pristine quines are already hard enough, and now you want it to be a polyglot too? Especially since polyglots often rely on one language ignoring the executing part of the other. Also, does it need to pristine in both languages, or both combined (i.e. removing a section can work in language A, as long as it errors in language B)? \$\endgroup\$ – Jo King Nov 13 at 5:58

Draw a hexagonal grid n×m of ascii hexagons

 /    \
/      \
\      /

with numbers somewhere within each of them, such as numbers goes in snail order starting in the center (but without empty hexagons):

  ____        ____        ____        ____        ____        ____
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/      \____/      \____/      \____/      \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/      \____/  25  \____/      \____/      \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/      \____/  26  \____/  24  \____/      \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/  27  \____/  11  \____/  23  \____/      \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/  28  \____/  12  \____/  10  \____/  22  \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/  13  \____/  3   \____/  9   \____/  40  \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/  29  \____/  4   \____/  2   \____/  21  \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/  14  \____/  1   \____/  8   \____/  39  \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/  30  \____/  5   \____/  7   \____/  20  \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/  15  \____/  6   \____/  19  \____/  38  \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/  31  \____/  16  \____/  18  \____/  37  \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/  32  \____/  17  \____/  36  \____/      \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/      \____/  33  \____/  35  \____/      \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/      \____/  34  \____/      \____/      \____/
 /    \      /    \      /    \      /    \      /    \      /    \
/      \____/      \____/      \____/      \____/      \____/      \
\      /    \      /    \      /    \      /    \      /    \      /
 \____/      \____/      \____/      \____/      \____/      \____/
  • 4
    \$\begingroup\$ 1. Can you provide examples for smaller various n,ms? Especially, I want to see examples for odd and even widths. 2. Should the numbers be distinct in every cell? 3. Assuming the answer to 2 is true, What should we do if the number doesn't fit in a single line inside the hexagon (i.e. 7 digits or higher)? \$\endgroup\$ – Bubbler Nov 11 at 4:17
  • \$\begingroup\$ Maybe we should assume n,m to be odd. \$\endgroup\$ – Alexey Burdin Nov 12 at 18:17

Monokeyed Words

(Based on https://what-if.xkcd.com/75/)

Old mobile phones had letters and numbers assigned to the same key, as follows:

  • 1
  • 2abc
  • 3def
  • 4ghi
  • 5jkl
  • 6mno
  • 7pqrs
  • 8tuv
  • 9wxyz
  • 0 [space]

From any given list of words or phrases (arbitrary number of inputs, formed of 0-9 a-z and space), find the word which has the most consecutive characters on the same key, and output the key and the count (in any reasonable format)

for example:

  • [nonmonogamous],[qwerty],[false] -> 7, 6 (seven times on the 6 key - nonmonogamous)
  • [tutu],[cat],[mouse] -> 4, 8 (four times on the 8 key - tutu)
  • [cab],[mon],[tin],[tom] -> 3,2 (cab) or 3,6 (mon) - either answer is valid
  • [#],[!!!],[is this valid?] -> any output or error - doesn't fit valid inputs. 2,4 would also be acceptable, for hi in is this valid?
  • bacmon, habitat, fringe, be, test, valid -> 3,2 or 3,6 as it's a tie between those keys
  • 01452301146 -> 2,1 (two in a row on the 1 key)

The output format isn't fixed, so you could also output [3][6] or 3.6 or 6,3 - anything you like, as long as it's consistent which is the key and which the number of repetitions. You could also use one of the letters to represent the key, if you wanted - e.g. instead of 3,6 you could output 3,m

This is , usual exclusions etc. apply

  • \$\begingroup\$ I don't think I understand what you mean by "wordlists." You don't appear to want us to check a lexicon (as 9wxyz9wxyz isn't a word in any language I know). If you just mean an input which is a list of strings then you don't need to do anything besides say that - the default rules will handle that no problem. Aside from that, this seems to have some "fluff" in that I think you'd be better off asking for just a summary (i.e. the longest chain of what button) of one input word or just finding the maximal word(s) from a list. Once you have one, getting the other is more or less trivial. \$\endgroup\$ – FryAmTheEggman Nov 11 at 20:25
  • \$\begingroup\$ Thanks, that makes sense. I was originally wanting to do exactly the same as the link (i.e. look up based on a whole dictionary), but I changed my mind part way through. As for the "fluff", yes OK I can see that; I'll edit my question \$\endgroup\$ – simonalexander2005 Nov 12 at 9:17
  • \$\begingroup\$ I think changing your mind halfway has happened to all of us at least once :) That said, I find your edits somewhat confusing - you seem to have changed it to just be one word in the new test cases but have kept the old ones. \$\endgroup\$ – FryAmTheEggman Nov 12 at 20:50
  • \$\begingroup\$ @FryAmTheEggman yes, the program should be able to take an aribtrary number of inputs \$\endgroup\$ – simonalexander2005 Nov 13 at 9:35


Cornhole is a game in which players take turns throwing bags filled with corn kernels(or other fillers) onto a wooden board with a hole in the far end. If a bag goes through the hole, it counts as 3 points. If a bag stays on top of the board without falling off it counts as 1 point.

Score is taken at the end of each round in which the two players throw 4 bags (alternating). Only the net score is calculated.

The first to exactly 21 points is the winner. If a player were to score points in a round that would bring them to exceed 21 points, the points for that round are subtracted from the players score.


  1. Given an array of scores from multiple rounds of Cornhole, determine the current score of the game.


The input will be an array of one or more rounds of scores for each bag throw by both players alternating. (you may choose any 3 distinct symbols to cover the scenario of misses, 1 point, or 3 points)


  • In this scenario
    • Player A missed the first shot, Player B missed their first shot, Player A landed the bag on the board for their second shot, Player B missed their second shot, Player A made it in the hole for their third shot, Player B made it in the hole for their third shot, Player A landed on the board for their fourth shot, and Player B landed on their board for their fourth shot.
    • In the next round of play, Player A missed the first shot, Player B missed their first shot, Player A landed the bag on the board for their second shot, Player B missed their second shot, Player A made it in the hole for their third shot, Player B made it in the hole for their third shot, Player A landed on the board for their fourth shot, and Player B landed on their board for their fourth shot.


The score of the Cornhole match as an array of two numbers. From the input above, the output would be:



 Insert multiple samples of scoring, including one example of a player scoring over 21 and losing points


SandChallenges for Proposed box [draft]

In this challenge you should simulate how "challenges" interact with each other. (You need to output how many iterations have the "challenges" done.)

Symbols used in the documentation

SandChallenges is played on a 3x3 grid.

  • X represents a challenge. It challenges the grid next to its position.

  • represents an empty sandpile. This is what the "challenges" move in their actions.

  • . represents moving sandpiles and is only used in this documentation. Input will never contain those characters; it instead will only contain X and .

A closer look at X challenges

There are sandpiles between those "challenges". When a "challenge" is active, it pushes sand towards the next grid. The next grid is described as the following:

  • The next grid is usually the grid on the right.
  • If the grid is on the right edge, the next grid becomes the first grid of the next line.
  • If the grid is on the last line, the next grid becomes the first grid of the first line.

The next grid of A is B, the next grid of C is D, and the next grid of I is A.

Another rule: they can get buried by active sandpiles. This makes them fail to function.

Test cases

Spaces are replaced with semicolons for readability problems.


-> (Affecting the next cell)



X..    X..    X..           X..
;;; -> .;; -> ..; -> ... -> ...
;;;    ;;;    ;;;           ...

After that the "challenge" gets buried by active sandpiles, which results in the following state:


This box had went through 9 changes before it stops.

XXX    ...
XXX -> ...
XXX    ...

This means that the challenge had went through 1 change before it stops. All of them push active sand and buries themselves simultaneously.

X;;    X.;
;X; -> ;X.
;;X    ;;X

The bottom-right challenge shoots active sand, which buries the active challenge in the same iteration:

..;    ...    ...    ...
;X. -> ;X. -> .X. -> ...
;;X    .;X    ..X    ...

This goes through 4 iterations.

X;;    X.;    X..    ...
X;; -> X.; -> X.. -> ...
X;;    X.;    X..    ...

This goes though 3 iterations.

X;X    X.X    ...    ...
;X; -> .X. -> ... -> ...
;X;    ;X.    .X.    ...

This goes through 3 iterations.

X;X    ..X    ...
;X; -> .X. -> ...
X;X    X.X    ...
This goes through 2 iterations.


  • Input/output can be given by any convenient method.
  • You can print it to STDOUT or return it as a function result.
  • Either a full program or a function are acceptable.
  • Any amount of extraneous whitespace is permitted, provided the characters line up appropriately.
  • Standard loopholes are forbidden.
  • This is so the shortest code wins.


  • Is this clear enough? Any better wordings for sections?
  • Is this a duplicate?
  • Tags are and and . Any suggestions?
  • Any further feedback?
  • \$\begingroup\$ As posed the challenge appears too simple. The wrapping method of the grid means you can just save it as a 1d object and reshape it for the output alone. There is no reason why the challenge should be restricted to a 3x3 grid either. Also, you're not clearly stating what you want the output to be. And lastly, that pun for the sake of pun is horrible and will just confuse people. \$\endgroup\$ – AlienAtSystem 2 days ago
  • \$\begingroup\$ I mostly agree with the other comment. This seems to be a lot of fluff for "find the longest substring of semicolons in the input." It may even wind up being a dupe because of that - I was going to suggest having them propagate both ways, but I'm pretty sure that is a duplicate as well! If you allow the grid to be any size and make the sandboxes propagate in more directions you may have a good base to build off of. \$\endgroup\$ – FryAmTheEggman 16 hours ago

How long should this song last?

Enter the world of sheet music. A composition (the musical piece, which may or may not be a song) is divided into bars. The length of a bar is defined by the time signature. The time signature states how the bar is divided into beats, and what length of note carries the beat.

Note lengths are always powers of 2. 4 means a quarter note, 2 a half note, 8 an eighth note (or a quaver if you're a snob), etcetera. A half note (2) is twice the length of a quarter note (4), which is itself twice the length of a quaver (8), and so on.

A time signature may look like this: 3/4. The 4 means that the quarter note carries the beat, and the 3 means that there are 3 of them in one bar. 3/2 means there are three half-notes in a beat, 7/8 means there are seven quavers, and so on.

Now, the actual speed at which a piece is to be performed depends on the tempo. That is usually expressed in beats per minute (bpm). The tempo also defines the note carrying the beat (usually the same as the one in the time signature but not always). So, you can have the time signature be 8=150, meaning there are 150 quavers in a minute (in the sheet music it would be notated ♪=150).

Both tempo and time signature can change throughout the composition.


Use the following format for your input (or something very similar). It is a list of events:


This is the simplest form. It is a list of integer-string pairs (you're obviously free to go with string-string pairs if it makes your program simpler). The integer defines at which bar the event happens (starting from 1), and the string defines what happens there. If it is in the form of x/y, then it is a new time signature. If it is in the form of x=y, you have a new tempo. Lastly, an empty string designates the end of the score (exclusive, so the above example has 520 bars).

With changes, the format may look like this:

[46, "4=155"],
[67, "5/4"],
[68, "4/4"],

The output of the program should be the duration of the entire piece in "xm ys" (where x is the number of minutes and y is the number of seconds. You can leave out the "ys" part if there's no spare seconds, but it is not necessary).

This is , so shortest code wins!

Important note!

Real artists do not follow the tempo exactly. Only beginners use a metronome to match the exact number of seconds as notated; more experienced musicians know to dynamically speed up or slow down depending on the mood, their personal preference, etcetera. Therefore, it is perfectly acceptable for your answer to be up to 34% higher or lower than the "correct" answer. Also, the minimum length of a composition is 2 minutes and 30 seconds.

Test cases



The time signature has 4 quarter notes a bar, and 520 bars, so 4*520=2080 quarter notes. There's 120 quarter notes per minute, so 2080/120=17.333 minutes, or 17m 20s.


[46, "4=155"],
[66, "5/4"],
[76, "6/8"],

For the first 45 bars, there's 4 quarter notes a bar, so that's 45*4=180 quarter notes. Now the tempo is 120 8th notes per minute, which is 60 quarter notes per minute, meaning the first bit lasts 180/60=3 minutes.

Then a tempo change: from bar 46 to 67 there's 20 bars of 4/4 (thus 4*20=80 quarter notes), and at 155 quarter notes per minute you add 155/80=1.94 minutes = 1m 56s. Total is 4m 56s.

Then a time signature change: 10 bars of 5 quarter notes per bar = 50 quarter notes. 155/50 = 3.1 minutes = 3m 6s. Total is 8m 2s.

Then another time signature change. 6 eighth notes per bar for 76 bars is 76*6=456 eighth notes. Tempo is still 155 quarter notes per minute, which is 310 eighth notes per minute. 456/310=1.471 minutes = 1m 28s. Total comes down to 9m 39s.

3. (The third movement of Shostakovich's second piano concerto, you get 5 bytes off if you listen to this while programming (not really but more people need to listen to Shosty dammit))

[1, "2/4"],
[1, "4=176"],
[75, "7/8"],
[102, "6/8"],
[103, "7/8"],
[106, "3/8"],
[107, "7/8"],
[109, "2/4"],
[112, "3/4"],
[113, "2/4"],
[116, "3/4"],
[117, "2/4"],
[120, "3/4"],
[121, "2/4"],
[124, "3/4"],
[125, "2/4"],
[155, "7/8"],
[160, "2/4"],
[175, "7/8"],
[180, "2/4"],
[181, "6/8"],
[182, "2/4"],
[186, "7/8"],
[188, "2/4"],
[222, "7/8"],
[225, "2/4"],
[286, "7/8"],
[308, "9/8"],
[309, "7/8"],
[314, "2/4"],
[317, "3/4"],
[318, "2/4"],
[321, "3/4"],
[322, "2/4"],
[325, "3/4"],
[326, "2/4"],
[329, "3/4"],
[330, "2/4"],
[356, ""]

Calculation is too long to show here, but it comes down to 4m 47s. The video is 5m 24s, proving my point that this is not an exact rule but rather a guideline.



Does this look like an interesting puzzle? Any tags I miss? Is the +/-34% allowance large enough to matter, or should it be more?

New contributor
KeizerHarm is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.

Can Alice win the game?

The game's rules are as follows. First, a finite set of positive integers \$X\$ is defined. Then, Alice and Bob take turns choosing positive integers, with Alice going first. Each integer must be strictly less than the previous one, and the game ends when one of the players chooses \$1\$.

Alice wins if the numbers she and Bob chose sum to a number in \$X\$, otherwise Bob wins.

Example games

Define \$X=\{20, 47\}\$. Alice chooses \$19\$, Bob chooses \$2\$, Alice chooses \$1\$. We have \$19+2+1=22\$ which is not in \$X\$ so Bob wins.

Define \$X=\{5, 6, 7, 8\}\$. Alice chooses \$4\$, Bob chooses \$3\$, Alice chooses \$1\$. We have \$4+3+1=8\$ which is in \$X\$ so Alice wins.


Your challenge is to write a program or function without standard loopholes which, when given a collection of positive integers \$X\$, will produce or output some consistent value if Alice has a winning strategy, and a different consistent value if Alice does not have a winning strategy.

A winning strategy is a strategy which will let Alice win no matter how Bob plays.

Note that in the first example game Alice did not have a winning strategy: If her first choice was any number other than \$19\$ or \$46\$ then Bob could choose \$1\$ and win. On the other hand if her first choice was \$19\$ or \$46\$ then Bob could choose \$2\$ and win.

In the second example, Alice did have a winning strategy: After choosing \$4\$, she could choose \$1\$ after any of Bob's possible choices and win (or Bob could choose \$1\$ and she would win immediately).

Input and output

The input will be a collection of positive integers in any convenient format, given with any convenient input method. This collection represents the set \$X\$. The output will be one of two distinct values chosen by you, depending on whether or not Alice has a winning strategy with the given collection. Example IO:

Input   -> Possible Output
20 47   -> false
5 6 7 8 -> true


  • No standard loopholes
  • Shortest code in bytes wins

  • \$\begingroup\$ I'd be happy with this as a challenge. \$\endgroup\$ – Corsaka yesterday
  • \$\begingroup\$ The wording of "take turns choosing positive integers" made me think they were choosing from \$ X \$. Obviously this is explained shortly but maybe add a "from \$ \mathbb{Z} \$ to make it flow better? Aside from that, this should be tagged decision-probem and you should consider the discussion here about some of the problems of "truthy/falsy". Thanks for using the sandbox! :) \$\endgroup\$ – FryAmTheEggman 16 hours ago
  • \$\begingroup\$ @FryAmTheEggman I've specified "consistent distinct values" instead of truthy/falsey. I'm not convinced that "take turns choosing positive integers" needs to be changed. Is there anything else? \$\endgroup\$ – 79037662 12 hours ago
  • \$\begingroup\$ I think you definitely need some more test cases, like 5 6 7 10 to cover more nuanced strategy. The writing looks fine to me, though, and thanks for reading what I linked! \$\endgroup\$ – FryAmTheEggman 12 hours ago

Play snake on a 50*50 grid. The snake will start at length 3, heading (2,0) with body (1,0) and (0,0). It shouldn't bump into wall or itself. There is always one food, which increases the length of snake by 1 when eaten.

Smallest amount of steps till there's no space to place food win. Flexible I/O, anyway it doesn't matter.

Vote on whether the food placer is transparent and allow food manipulation(Up for yes, down for no)

  • \$\begingroup\$ I think there are already quite a few snake challenges. You need to flesh out some more details here. How do you determine where the food will spawn? Will you be given some sampling of the game state (vision?) on each step? \$\endgroup\$ – Beefster Dec 28 '18 at 19:22
  • \$\begingroup\$ @Beefster If "food placer is transparent and allow food manipulation", you just know how it spawns; If not, you get access to the location of current food \$\endgroup\$ – l4m2 Dec 29 '18 at 3:44
  • \$\begingroup\$ If food manip. is allowed, is the optimal score achievable by finding an Hamiltonian path starts with the snake? \$\endgroup\$ – user202729 Dec 29 '18 at 8:55
  • \$\begingroup\$ @user202729 It depends on how strong the manipulation is \$\endgroup\$ – l4m2 Dec 29 '18 at 10:54

No-alphanumeric code exec

  • 4
    \$\begingroup\$ -1 for winning entries must be written in one of the 25 top languages. \$\endgroup\$ – Jo King Jan 19 at 9:28
  • \$\begingroup\$ I'm trying to exclude golfing languages with that - this only seems like an interesting challenge to me if you don't allow languages where it's excessively trivial. Any suggestions for how to do that in a more permissive way or other thoughts about that goal? \$\endgroup\$ – lahwran Jan 19 at 22:13
  • \$\begingroup\$ actually, I think this will be quite difficult in many code golf languages as well, as they usually try to get brevity by cramming things into single letters and numbers. there are of course languages where it'll be excessively trivial, but that's fine, those solutions most likely just won't be upvoted. \$\endgroup\$ – lahwran Jan 19 at 22:21
  • \$\begingroup\$ Most golfing languages won't be able to pull sth. from the interconnected-webs afaik, so there's no real need to invent arbitrary restrictions to ban them. \$\endgroup\$ – ბიმო Jan 21 at 16:25
  • 1
    \$\begingroup\$ Also "but that's fine, those solutions most likely just won't be upvoted" is too optimistic, usually it's the other way around :( \$\endgroup\$ – ბიმო Jan 21 at 16:26
  • \$\begingroup\$ dang, good to know. \$\endgroup\$ – lahwran Jan 21 at 22:55

A Quine that Grows!


Create a quine that, when run, outputs itself but copied larger in the next one. The output should be able to be run, and get larger each time the output is run. The output must consist only of characters from the original quine!


abc //original
abcabc //output


abc //original
aabcc //output

What not to do

abc //original
abcgef //output

abc //original
abcoooooooooooo //output

An example I created

Try it Online! It replicates pretty fast if I do say so myself!


This challenge is meant to be a codegolf, but also emphasize on how fast it replicates. So perhaps something like the speed at which it gets bigger divided by the number of bytes.

I really don't want loopholes like just repetitively adding characters to a section of the code, making infinite loops, and things of the like.

Any input on how to make this a good challenge? I'm open to suggestions!!!

  • 1
    \$\begingroup\$ Related, related (probably a dupe) \$\endgroup\$ – Jo King Feb 10 at 10:25
  • \$\begingroup\$ @JoKing What about a polyglot that gets bigger? It runs, making another program that runs and outputs a bigger version of the original, and vice versa. \$\endgroup\$ – KrystosTheOverlord Feb 10 at 16:02
  • \$\begingroup\$ where's the polyglot part come from? otherwise that sounds like the second one \$\endgroup\$ – Jo King Feb 10 at 22:04
  • \$\begingroup\$ @JoKing The output has to be in a different programming language, and then create a larger version of the original, then this larger original makes a larger of second program etc... Also to prevent easy loopholes, no using program languages that are derivatives of eachother \$\endgroup\$ – KrystosTheOverlord Feb 10 at 22:32

Just idea. Not sure what to do exactly.

Evolutionary Golf

Make simple (not golfed at all at first) code for (some program) with language (something).

Now, change a little bit (maximum 3 byte) of code to make it shorter.

Altered code must work properly (this is how evolution work).

(Maybe here will be starting code).


First. What program would be best? For example, 'Hello World' program is not proper, because it is too short, and can't golf that much.

Second. What language would be best? Esolang like BF? Or something like C?

  • \$\begingroup\$ If I understand the challenge idea correctly you will post an ungolfed answer that does something in some (probably verbose) language (i.e. FizzBuzz in C#). And then answers after that should have a Levensteihn distance change \$c\$ where \$1\leq c\leq3\$ (at least 1 delete) that does the same thing (in any language). And the shortest answer that's at the end of the answer chain wins if no other answers are posted within 2-3 weeks (which is usually the case with answer-chaining challenges)? Or do you mean that anyone can post an ungolfed program, and others using the same language chain it? \$\endgroup\$ – Kevin Cruijssen Jun 26 at 9:04
  • \$\begingroup\$ @KevinCruijssen I'm thinking of both. This is just brief outline, so everything can be changed. \$\endgroup\$ – LegenDUST Jun 26 at 12:10
  • \$\begingroup\$ this is just game of nim with extra steps \$\endgroup\$ – Kenneth Taylor Aug 2 at 17:51

Print all the commands

META Just a rought idea, needs to be worked out.

Write a program that prints all the keywords and commands that are available in your langauge when you do not import/add anything


  • require full program or standard code-golf?
  • 2
    \$\begingroup\$ Understanding that this is a rough idea, what happens in languages without commands corresponding to single tokens e.g. ///? \$\endgroup\$ – lirtosiast Jul 18 at 15:49
  • 7
    \$\begingroup\$ It is my opinion that this sort of challenge will likely never be clear. \$\endgroup\$ – Wheat Wizard Jul 18 at 16:08
  • \$\begingroup\$ I'd imagine for /// you'd output all valid non-text characters, so \ /. \$\endgroup\$ – bigyihsuan Jul 18 at 17:08
  • 1
    \$\begingroup\$ Another thing is that language version would be specified. For example, Python 2 has print as a keyword, while Python 3 has print() instead. \$\endgroup\$ – bigyihsuan Jul 18 at 17:10
  • \$\begingroup\$ Pretty sure this (or something similar enough to be a dupe) has been done before. Lemme see if I can find it .... \$\endgroup\$ – Shaggy Jul 21 at 21:11
  • \$\begingroup\$ Found it! codegolf.stackexchange.com/q/162384/58974 \$\endgroup\$ – Shaggy Jul 21 at 21:13
  • \$\begingroup\$ One way to do this might be to make it language specific? While that isn't usually popular, outputting all of, say, Python's commands in most languages besides python is a dupe of the Rickroll challenge. However, in python itself that isn't the best approach. I can't say how well reveived it'd be, but you could try "output these MATLAB commands in MATLAB" and see what people think. \$\endgroup\$ – FryAmTheEggman Jul 23 at 19:45

Here's a challenge I'd like post because I'm curious to see what people will come up with. It's a bit of an anti-code-golf question because the code should look normal.

Is it clear what the constraints? Did I miss anything?


Write a piece of unsuspicious code that does the following:

Let's say you've written a parser that parses it's input line by line and somewhere in your code is

find_string(line, "[start]", "[end]") // returns string between [start] and [end]

This program, when given it's own source code plain text as input, will match that line (twice actually); but we don't want that. It should still parse what it was designed for but not match any line of it's own source code.


  • It's preferred that your code makes it obvious that one of it's intended uses is to parse (and not match) itself. This is so anyone 'refactoring' the code will not accidentally undo the trick that made it work.
  • Your source code as input will be reduced to a single line.
  • Your program should be able to handle large input (~10mb) and perform reasonably (for your chosen language).
  • Your program does not need to parse the input line by line but that just seems like something reasonable code would do.
  • Points are awarded for code that looks like a normal parser and contains as little assumptions about the input as possible. Bonus points for solutions that contain the start and end delimiters in that order.

Easy solutions are to swap the start and end token arguments or to pre-treat the tokens in some way but that would look suspicious. Someone will come along and refactor your code and break the 'trick'.

I'm interested in reasonable solutions because this is a reduction of a real life problem.

Example Input and Output

  • Input lines may or may not contain [start] or [end], only return it in the output when it occurs in a pair.
  • Input lines will never contain more than one pair of [start] and [end] tokens.
  • Input lines may contain additional content before [start] or after [end]
  • Your source code plain text will be inserted at a random line in the input.

Input #1:

<<your source code plain text>>
dont output this[start]world[end]

Output #1:

hello world

Input #2:

lorem[start]i solemnly[end]
[start]false start
ope, sorry just passing through
this is not the[end]
[start]that i'm up to[end]ipsum
<<your source code plain text>>

Output #2:

i solemnly swear that i'm up to no good
  • \$\begingroup\$ What is the objective winning criterion? \$\endgroup\$ – Unrelated String Aug 9 at 5:16
  • 1
    \$\begingroup\$ This could be a good challenge if it was just 'Write a program that takes a line of input and returns the concatenation of anything between [start] and [end] on each line, otherwise an empty string', with the restriction that if it was fed itself, it wouldn't return anything \$\endgroup\$ – Jo King Aug 9 at 6:05
  • \$\begingroup\$ I'm a little confused about what Bonus points for solutions that contain the start and end delimiters in that order. means, since I thought the point was that we're not allowed to have that? \$\endgroup\$ – Jo King Aug 9 at 6:07
  • 2
    \$\begingroup\$ "unsuspicious code" will raise red flags in the minds of a number of old-timers, for historical reasons which I won't explain in detail. What I will say is that unsuspicious is subjective, and we insist on objective criteria. In terms of actual reasonable solutions to the real world problem: don't use magic strings. If "[start]" and "[end]" are both constants and defined on separate lines, the problem is averted, and anyone who refactors to inline them deserves all the bugs that causes. \$\endgroup\$ – Peter Taylor Aug 9 at 10:45

Make it improbable... BUT NOT IMPOSSIBLE

You must make a program that outputs truly once in a while. However, making it have output falsy all the time is not acceptable.


  • Standard loopholes are forbidden.
  • You may use any of accepted I/O formats.
  • Your program must be possible to output a truly value.
  • When not outputting a truly value, you may either output a falsy value or not output anything at all.
  • You may output two or more values, however if it contains a truly value, then the output is considered truly.
  • The probability of outputting a truly value must be at most 1/2.
  • Your program must not take/use an input.
  • Using non-deterministic but non-random(Such as getting the time) is prohibited. However, if date etc. is used in the builtin random function, it is allowed.
  • The program must theoretically always terminate or stop outputting anything.
  • You may assume that you have a fast enough computer and large enough memory.
  • Your program should not be affected by raising the maximum value of a data type. You may still use unaffected constants.
  • Data types must be following its spec: ie. for an unbounded arbituary precision integer type, you may assume that it can go as high as you want(but you are not allowed to increment until an error as in the rule above), but a double-precision floating-point format still has 22-bit fraction and 8-bit exponent.
  • Score is calculated as: Pl-1.5l, where P is the probability and l is the byte length.


P=0.1, l=24 => Score=23.534

The lowest score wins!

  • \$\begingroup\$ So is it acceptable for just a program that always outputs truly? You need to define improbable. (I assume this probability must be at least lest than 1/2.) Providing a few examples will be helpful. So is there only output and no input? In addition, you need an objective winning criterion, which is a criterion that posts for this challenge will need to comply in order for it to be a valid answer. (Usually this criterion is making the source code shortest.) \$\endgroup\$ – A _ Sep 24 at 13:37
  • \$\begingroup\$ Sorry, I posted this incomplete. \$\endgroup\$ – Naruyoko Sep 24 at 16:14
  • \$\begingroup\$ I don't think your scoring method works particularly well, unless I'm making an error. For any \$ l > 1 \$ your score cannot be less than 1. Achieving a score arbitrarily close to 1 is relatively easy. So the only way to beat that is to have a one or zero byte solution. It is easy to make the probability increase exponentially with linear code additions. It might be necessary to penalise length massively, like \$ P \times e^{l!} \$, to avoid similar problems. \$\endgroup\$ – FryAmTheEggman Sep 24 at 18:39
  • \$\begingroup\$ I see. I guess P^l^k is too penalizing but Pk or Pe^k is too forgiving. Pe^l! looks simple enough but is is the middle so it may work. \$\endgroup\$ – Naruyoko Sep 24 at 20:11
  • 1
    \$\begingroup\$ The problem with any of scoring methods for this challenge is that it is possible for any increasing computable function f, a program with length l can have P around 1/f(l). The only non-broken formula could be uncomputable, i.e. P/BB(l), where BB is the busy beaver function. \$\endgroup\$ – Naruyoko Sep 24 at 20:15

Title: Transposition

** The challenge **

Given a set of notes (as a string, or a list, or any other reasonable input - but as letters and accidentals, not a numerical equivalent), the key those notes are in, and a target key; output the notes transposed into the new key. Some of the notes may not exist in the scale for the given key (e.g Eb in the key of C).

** Inputs **

The complete set of input notes for this challenge will use the English naming convention, and so are as follows:


where "b" represents a flattened note (down one semitone per b), and # represents a sharpened note (up one semitone per #). Theoretically all notes can be extended further with more #s and bs; but for the purposes of this program that won't happen beyond what is already given.

** What is transposing? **

Transposing a song involves "moving" the song into a different key, by finding the equivalent note of the scale in that key.

We will assume Major scales for the purposes of this challenge.

** Scales **

The scales for this challenge are officially as follows:

  • C: C, D, E, F, G, A, B, C
  • C#: C#, D#, E#, F#, G#, A#, B#, C#
  • Db: Db, Eb, F, Gb, Ab, Bb, C, Db
  • D: D, E, F#, G, A, B, C#, D
  • D#: D#, E#, F##, G#, A#, B#, C##, D#
  • Eb:Eb, F, G, Ab, Bb, C, D, Eb
  • E: E, F#, G#, A, B, C#, D#, E
  • F: F, G, A, Bb, C, D, E, F
  • F#: F#, G#, A#, B, C#, D#, E#, F#
  • Gb: Gb, Ab, Bb, Cb, Db, Eb, F, Gb
  • G: G, A, B, C, D, E, F#, G
  • G#: G#, A#, B#, C#, D#, E#, F##, G#
  • Ab: Ab, Bb, C, Db, Eb, F, G, Ab
  • A: A, B, C#, D, E, F#, G#, A
  • A#: A#, B#, C##, D#, E#, F##, G##, A#
  • Bb: Bb, C, D, Eb, F, G, A, Bb
  • B: B, C#, D#, E, F#, G#, A#, B

For simplicity, we can assume that both notes in the pairs A#/Bb, C#/Db, D#/Eb, F#/Gb, G#/Ab, C##/D, F##/G, G##/A are enharmonically equivalent (i.e. interchangeable - although they're not, always).

For scales with double-sharps, I will accept the enharmonic equivalents as an alternative implementation:

  • D#: D#, E#, G, G#, A#, B#, D, D#
  • G#: G#, A#, B#, C#, D#, E#, G, G#
  • A#: A#, B#, D, D#, E#, G, A, A#

but for all other notes in the scale, they must match. If the note isn't in the scale, either can be used.


  • F in the key of C should transpose to F# in the key of C#, and not to Gb, because that option in the pair is explicitly in the scale
  • but D in the key of C# could transpose to either C# or Db in the key of C, because it's an incidental anyway and so there's no easy rule to determine which it should be.

BONUS feel-good points *: normally it's # if you're going up, and a b if you're going down - feel free to implement this if you want!

For double-sharps (e.g F##) in all cases, It's OK if the program "resolves" these (e.g.to G in that case) even if they are in the scale; but again, some BONUS feel-good points * if you keep the double-sharps in.


  • CDEFGABC in C to A -> ABC#DEF#G#A
  • C# in C to A -> A# OR Bb
  • ABCDEFGBAF#Bb in Bb to Gb -> FGAbBbCDbEbGFDGb

Websites like http://www.logue.net/xp/ can be used to test your answers to other inputs

* Bonus feel-good points don't get you anything extra, unless someone can come up with a quantifiable difference that it should make to the score?

  • \$\begingroup\$ This is kind of similar but doesn't use scales and has a different set of chords, so I think this is effectively different? \$\endgroup\$ – FryAmTheEggman Sep 24 at 18:47
  • \$\begingroup\$ Yes, I agree it's similar but doing a different thing to me (they're using chords, and so have the extra text to worry about; but I'm doing notes, like sheet music; and so you have accidentals to worry about) \$\endgroup\$ – simonalexander2005 Sep 25 at 8:48

Mirror, Mirror, on the wall. Who's the fairest of them all?

Well, you know it's Snow White, and the evil Queen is at it again. Will Snow White be saved? Will she fall asleep once again? Will the Prince find her?


Given an arbitrary number (>= 2) of possibly duplicated hexadecimal color values (ranging from #000000 to #FFFFFF) and paired strings, calculate the following:

  • If #FF0800 (Candy apple red) appears in the input, return "Return to Sleeping Death"
  • If #000000 appears in the input, return "Saved by Grumpy"
  • If #A98AC7 or #111111 appears in the input, return "Saved by Happy"
  • If #21E88E or #222222 appears in the input, return "Saved by Sleepy"
  • If #32DCD5 or #333333 appears in the input, return "Saved by Bashful"
  • If #43D11C or #444444 appears in the input, return "Saved by Sneezy"
  • If #54C563 or #555555 appears in the input, return "Saved by Dopey"
  • If #65B9AA or #666666 appears in the input, return "Saved by Doc"
  • If #76ADF1 or #777777 appears in the input, return "Saved by the Seven Dwarfs"
  • If #FFFAFA (Snow) appears in the input, return "Saved by Love's first kiss"
  • If an F variant appears in the input, return "Press F to pay respects to Snow White"
    • An F variant is any number that contains at least one F in its hexadecimal form, and is otherwise all 0s (e.g. #0FF0F0, #FFFFFF, #00000F, #F00F00)
  • If multiple of the preceding occur, return the "fairest" answer. The "fairest" answer is calculated as follows:
    • For all N occurrences of special color values, choose the (N-1)/2-th (truncating division) occurrence. The associated special output is the "fairest" answer.

"Appears in the input" here refers to only the hexadecimal color values, and not to the paired strings.

  • If none of the preceding occur, return the "fairest" answer. The "fairest" answer is calculated as follows:
    • Take the hexadecimal color value at the end of input values, write it down, and exclude that single color-string pair from consideration as the "fairest" answer
    • Show its binary form to the mirror, computing a reflection of only the last 24 (#FFFFFF is the mask) bits.
    • Choose the hexadecimal color with least Hamming distance from the reflection. If there are multiple (N) such colors, choose the middle ((N-1)/2-th, truncating division) instance of the color. The "fairest" answer is the associated string for the color.


A sequence of hexadecimal color values and String values separated by a space. The input may also be read as two separate sequences of hexadecimal color values and String values, or a single sequence of 2-tuples (either (hexValue, stringValue) or (stringValue, hexValue) is permissible, as long as the ordering is consistent across all 2-tuples). Input order matters - for each index, the corresponding element in the supply of color values is "associated" with the corresponding element in the supply of String values, and duplicates can affect the "fairest" answer. The effect is something like Function(List(HexColorValue),List(AssociatedStrings)) -> "fairest" answer. Hexadecimal color values may be represented as either (your choice of) a String "#"+6 digits, or 6 digits alone, as long as the representation is consistent across all color values.

Here's an example input:

76ADF1 Return to Sleeping Death
2FE84E Return whence ye came!

Here's another example input:

2FE84E Return to Sender
4FFAFC Return of the Obra Dinn
2FE84E Return to the house immediately, young lady!
2FE84E Return to Sleeping Death
2FE84E Return of the Jedi

Here's the third example input:

2FE84E Return to Sender
4FFAFC Return of the Obra Dinn
2FE84E Return to the house immediately, young lady!
2FE84E Return to Sleeping Death
7217F8 Return of the King

Here's the final sample input:

F4A52F Eating hearts and livers
F4A52F Eating apples
F4A52F Eating porridge
F4A52F Eating candy houses
F4A52F A Modest Proposal


The "fairest" answer as computed by the specified logic. For example, on the first sample input, the "fairest" answer would be Saved by the Seven Dwarfs, due to the special hex color 76ADF1 appearing within the input.

In the second sample, there are no special inputs. First, we take "2FE84E Return of the Jedi", which has value #2FE84E. In binary, this is:


We take the reflection from the mirror, getting:


We compare it against 2FE84E (001011111110100001001110) and 4FFAFC (010011111111101011111100), which have Hamming distances of 18 and 12 from the reflection, respectively. Since #4FFAFC has the uniquely lowest Hamming distance from the reflection, the "fairest" answer is Return of the Obra Dinn.

In the third sample input, there are no special inputs. First, we take "7217F8 Return of the King", which has value #7217F8. In binary, this is:


We take the reflection from the mirror, getting:


We compare it against 2FE84E (001011111110100001001110) and 4FFAFC (010011111111101011111100), which have Hamming distances of 2 and 8 from the reflection, respectively. All 3 instances of hexadecimal color value #2FE84E have minimum Hamming distance from the reflection, so we take the (3-1)/2=1th instance (0-indexed) of #2FE84E. Therefore, the "fairest" answer is Return to the house immediately, young lady!.

In the last sample input, there are no special inputs. First, we take "F4A52F A Modest Proposal", which has value #F4A52F. In binary, this is:


We take the reflection from the mirror, getting:


We compare it against F4A52F (1111010011001100101111), which has Hamming distance 0 from the reflection. All instances of hexadecimal color value #F4A52F have minimum Hamming distance from the reflection. There are FOUR instances of #F4A52F, because we always exclude the last hexadecimal color instance from evaluation. Therefore, we take the (4-1)/2=1th instance (0-indexed) of #F4A52F, and the "fairest" answer is Eating apples. If you don't exclude the last value from consideration, you actually get the (5-1)/2=2th instance of #F4A52F (Eating porridge), which is wrong.


  • No standard loopholes
  • Input/output taken via standard input/output methods.
  • The output must be exactly equal to the "fairest" answer


This is code golf, so shortest program wins.

Posted~ you can see it here

  • \$\begingroup\$ Going to need tag suggestions :) \$\endgroup\$ – Avi Sep 30 at 20:57
  • \$\begingroup\$ Can each entry be taken as a tuple, i.e. ("#FFFFFF","Return the Slab")? Can the label part also have a hex number in it or are we guaranteed it wont? Rules has the # but the examples do not, is either form fine? Can we get a worked example of a list containing multiple matching entries? \$\endgroup\$ – Veskah Oct 1 at 12:33
  • \$\begingroup\$ @Veskah You can take tuples as input. You can choose whether to keep # in your input hex colors or not, as long as you keep it the same for every single input (no sneaky stuff like putting a # before the correct answer every time). I've added more sample inputs/outputs with explanation. \$\endgroup\$ – Avi Oct 1 at 14:28
  • \$\begingroup\$ -1: This has way too many hardcoded input/output mappings. This challenge is more about encoding those than solving a problem. \$\endgroup\$ – Beefster Oct 24 at 19:10

CMC: Cross-Multiplication Calculator

In this task you should create a Cross-Multiplication Calculator.

Cross-multiplication is a way of factoring an algebraic expression. This is the expression form that this way can solve:

$$x^2 + ax + b$$

\$a\$ and \$b\$ are constants here, and \$x\$ is a variable.

Anyway, as far as I can tell, this expression form is only solvable in this method.

Anyway, how do I do Cross-Multiplication? (TODO)

You first take the number \$b\$ and factor this number into integral factors.

Okay. We are using the expression \$x^2 + 8x + 16\$ as an example.

(Although 16 is not a prime) let us assume that 16 only has 2 possible factors:

  • \$-1 \times -16\$ (because \$-x \times -x = x^2\$)
  • \$1 \times 16\$ (Obviously this is 16)
  • And the above 2 with the factors reversed.

Now you sum these possible two factors and check this against the number \$a\$.

  • Check 1. So \$-1 + (-16) = -17\$. And unfortunately -17 is not 8, we proceed to the next check.
  • Check 2. So \$1 + 16 = 17\$. And unfortunately 17 is not 8, we proceed to the next check. There are no checks left.

Did I make a mistake? Of course, I need to change the factors.

  • \$-2 \times -8\$ (because \$-x \times -x = x^2\$)
  • \$2 \times 8\$ (Obviously this is 16)
  • And the above 2 with the factors reversed.

We sum those values, and they are -10 and 10 respectively. So I should change the factors to another value:

  • \$-4 \times -4\$ (because \$-x \times -x = x\$)
  • \$4 \times 4\$ (Obviously this is 16)
  • And the above 2 with the factors reversed.

Finally! \$4+4 = 8\$, and here is the factorization:


Now you will probably realize why I desperately need a program to automate this.

Test cases

You can assume that the input is always valid. You do not have to specify the variables, only the numbers. Therefore the expression

$$x^2 + ax + b$$

is converted into:

$$+a \, +b$$

The expected output is not:



$$+\alpha \, +\beta$$

a, b => α, β
8, 16 => 4, 4
-5, -24 => 3, -8


This is , so shortest answer in bytes wins.


  • Is this clear enough?
  • I haven't found a duplicate, but anything? (Although unlikely, I found nothing by searching "Cross Multiplication".)
  • Tags are code-golf, string and interpreter. Anything else?
  • Any further feedback?
  • 1
    \$\begingroup\$ I've edited your post to use MathJax for the mathematical formula/workings. In addition, I've edited out the rather strict input/output format (leading + etc.) as it's generally recommended to allow the most natural output format. Feel free to revert these changes if you dislike them. Also, your tags bullet point in the Meta section appears to be different to the tags in the title? \$\endgroup\$ – caird coinheringaahing Oct 21 at 17:48
  • \$\begingroup\$ Finally, I'd vote to close this as a duplicate of this or this challenge (as it is a subset of both) \$\endgroup\$ – caird coinheringaahing Oct 21 at 17:51

Parse a regex

Grep is a wonderful tool. It can find stuff in files, it can help you spell stuff correctly (grep 'whatever' /usr/share/dict/words or wherever that file is), and it can even test if something is a prime number!

However, the first version was implemented back in the golden age, when FORTRAN was respected, Pascal was the language for beginners, and object orientation was just starting out in on its great adventure.

One could argue that modern developers have nowhere near that much talent or skill, what with their flashy "IDEs" and "frameworks". If they would be asked to implement something similar, they would just jump at the nearest library or cloud thingimabob and say "Done!".

At least, that is what some would say.

Prove them wrong! Golf grep!

Parse a regular expression without calling any built-in functions or operators explicitly meant for this.


Basically the same as a simple grep: a regular expression as a command line parameter, followed by an optional filename or a dash. If the filename is not present, or it is a dash, read for stdin.

This is the recommended way to do it, but if you can write an adapter (eg: post stuff to a php form for your program via a shell script), then that is OK as well. The adapter does not contribute to your score.


Lines that match the regular expression.


The regex dialect is PCRE (perl compatible). Files use unix line terminators if it is relevant.

  • \$\begingroup\$ Closely related, but not quite a duplicate. \$\endgroup\$ – AdmBorkBork 2 days ago
  • \$\begingroup\$ Why the downvote? \$\endgroup\$ – Mark Gardner yesterday
  • \$\begingroup\$ You've likely been downvoted because you "ban built-in functions or operations explicitly meant for this." Consider this post for a lengthy discussion of why this has fallen out of favour. Beyond this being trivial besides parsing regular expressions, it also doesn't actually describe what a regex is or what it means to be PCRE. Challenges need to be self contained! I think your bet is to make a different matching language yourself and ask us to implement grep but with that language instead of regex. \$\endgroup\$ – FryAmTheEggman 16 hours ago

Every number is interesting

We know that every number is interesting but how?

You should write a program or function which:

  • takes a list of N positive integers (>0 and <2^31)
  • outputs N lines each of them showing how the corresponding input number is interesting
  • is not longer than 1024 bytes
  • uses no more than 1 second per number
  • doesn't use external sources


172: 444 in base6
5776: 76*76
9801: 9 * 1089 (reverse)
68101: no 11 in base2 (10000101000000101)
491033: 317 * 1549 (product of 2 big primes)
467808816: no digit 5 from base6 to base10


You should include the output for the following input in your post:

58 92 120 224 358 490 912 1578 7812 222008 1645060 19796411 550453633 

If you care to run your program on a bigger sample and share the result with us use this input data (2500 numbers). (You can upload your output to e.g. pastebin.)

This is a popularity-contest so highest voted answer wins.

Tags: popularity-contest, number

  • 1
    \$\begingroup\$ What sort of criteria are necessary for defining a number as 'interesting'? I see things like square numbers, other bases, etc. But are there any specifics? I'm interested in this challenge (but worried it might be closed as too broad). \$\endgroup\$ – ASCIIThenANSI Apr 7 '15 at 13:18
  • \$\begingroup\$ @ASCIIThenANSI There wasn't a clear definition. That's part of the reason why I abandoned the challenge. \$\endgroup\$ – randomra Apr 8 '15 at 1:55
  • 1
    \$\begingroup\$ Would you mind if I tried taking it up? I would have to post as a new answer, because I can't directly edit. \$\endgroup\$ – ASCIIThenANSI Apr 8 '15 at 2:00
  • \$\begingroup\$ @ASCIIThenANSI Not at all. \$\endgroup\$ – randomra Apr 8 '15 at 2:01
  • \$\begingroup\$ @ASCIIThenANSI Where did you post it? \$\endgroup\$ – wizzwizz4 Jul 24 at 13:33
  • \$\begingroup\$ @ASCIIThenANSI I am also curious \$\endgroup\$ – MilkyWay90 Aug 27 at 23:41

Something Else - ASCII Art maker:

A text to ASCII art generator maker, the program must input a string and return ASCII art from it. Something like patorjk.com/software/taag/. It has to use the Graffiti font. The winning criteria is the whoever gets the most likes.

  • \$\begingroup\$ Hello! Just a few things to point out: 1) The current spec is very broad. For example, what fonts, how does spacing look, what characters need to be supported... there's a lot more details that need to be included than just "return ASCII art of this text" \$\endgroup\$ – Sp3000 Feb 24 '15 at 4:07
  • 1
    \$\begingroup\$ 2) What's the winning criterion? Popularity contest? Code golf? \$\endgroup\$ – Sp3000 Feb 24 '15 at 4:08

Identifying a Sonnet

This challenge is about determining if a given file (read-in from stdin) meets the criteria to be a sonnet. You may use any language for this challenge. If your language supports an API to use an online dictionary you may use that API, if your language doesn't then too bad.

Additionally, it is preferred if your language is one that can be ran directly from the command line and is a language that has a compiler or interpreter available directly from my distro's repos(Fedora), as I would rather just use a bash script to test the various programs, then test each program manually.

Definition of a Sonnet

  • Has 14 Lines (lines are denoted as the standard newline on your operating system).
  • Has a definite rhyme scheme, it will have one of the following rhyme schemes
  • Iambic Pentameter - consists of alternating stressed, unstressed syllables. This doesn't have to be perfect 100% of the time, just at least 50% of the time.

In order for your program to declare a given string a sonnet, it must meet all of the above criteria.

Additional Notes

You do not have to identify the following:

  • Thought Structure - too intense for a code golf challenge, and too subjective.
  • Topic - computer lacks context to determine this


Input will be read from stdin. This is the string that you will be declaring to be or not to be a sonnet.


Your program will output either yes or no for the question:

Does this string meet the given requirements to be a sonnet?

As this is code golf yes or no can be abbreviated to Y/N.


The solution with fewest number of bytes win that has the highest accuracy ratio for the correct identification of a sonnet. The preference is for higher accuracy rather than brevity of the program.

Test Data and Resources

What is not a sonnet

The following are examples that you program should return false on:

  • Beowulf
  • Haiku
  • Input that doesn't have exactly 14 Lines in it
  • The text of this question.
  • The text of just about any other question on StackExchange.
  • Things that don't have a rhyme scheme. See Below

Not A Sonnet

A man got on a boat
The boat was leaky
and had poor construction
For it was made by a one-eyed blind man
and his dumb intern
As soon as he got out of port
at the fort
it started to sink
eventually, it tanked.
And it capsized
If only that shipwright
wasn't so blind deaf and dumb
as microsoft tech support
That's not much support at all.
  • 2
    \$\begingroup\$ I think without dictionaries for rhymes and stresses this is probably not a good idea. Of course you can use some sort of accuracy ratio, but then you also need false positives, and you need a lot more examples than the few on the pages you've linked. But if you do this there's no requirement to actually recognise the sonnets by their rhymes and stresses - instead, I'm pretty sure, people will just regex golf the test sets. \$\endgroup\$ – Martin Ender Mar 24 '15 at 19:36
  • \$\begingroup\$ @MartinBüttner I updated the requirements with an accuracy percentage, and added the option to use an API to look up terms from a dictionary. \$\endgroup\$ – HSchmale Mar 24 '15 at 19:57
  • 1
    \$\begingroup\$ 1. Test data which only covers one possible output isn't test data. I can write a program which always outputs Y in as little as one byte and it will pass all of the linked "test data", but it comes nowhere near to meeting spec. 2. Unless you specify which rhyme/stress dictionary to use, you can't guarantee that the test data is "correct". \$\endgroup\$ – Peter Taylor Mar 24 '15 at 20:20
  • \$\begingroup\$ @PeterTaylor I added examples of what is not a Sonnet. \$\endgroup\$ – HSchmale Mar 24 '15 at 20:32
  • 1
    \$\begingroup\$ I'm not sure how to say this, but it feels as though this task has a lot of individual parts, each of which could be quite tricky. Especiallly detecting rhymes/syllables/stresses, since words can be pronounced/stressed differently based on context. Also if you're using Shakespeare's sonnets I have no idea where to get rhyming and stress dictionaries for Elizabethan English... \$\endgroup\$ – Sp3000 Mar 25 '15 at 14:18
  • \$\begingroup\$ To make this interesting, you'll need some interesting near-misses: non-sonnets that can't be detected by something simple like counting lines or words per line. \$\endgroup\$ – xnor Mar 25 '15 at 20:59
  • \$\begingroup\$ @xnor You mean a file with a that looks like a sonnet but has no rhyme. \$\endgroup\$ – HSchmale Mar 25 '15 at 21:04
  • \$\begingroup\$ Yes, for example. Or, one with rhyme by wrong rhythm. Or, one with nonsense characters that seem to "rhyme". \$\endgroup\$ – xnor Mar 25 '15 at 21:06
  • \$\begingroup\$ @Sp3000 You can just use modern english, or just base it on words that have similar endings. \$\endgroup\$ – HSchmale Mar 25 '15 at 21:11

Create a Drawing Guide for a Polygram

Poor old Jim, he's just terrible at drawing polygrams, and he's asked you to create a "drawing guide" for him - an ascii polygram with numbered edges, so he can follow the instructions.


Write a program to produce an ascii polygram with P <= 10; each edge of the polygram should be made of a single digit 0-9, showing the order in which the edges should be drawn.


Your program should receive (via STDIN, as function arguments, or some other language-appropriate method): P, the number of edges/vertices of the polygram, and Q, the spacing. In the notation as per the Wikipedia link, you'll be drawing a {p/q} polygram.


Either print to STDOUT or return (or something else language-appropriate) a multiline string showing the drawing guide for the given polygram. The string can be any size you like, as long as it's large enough to display a clear polygram.


Your code should be able to handle compound regular polygons as well as regular regular polygons, and also inputs of q > p/2 (poor old Jim doesn't realize that the polygram for {p/q} is the same as for {p/p-q}).

Example Output for {10,3}

             5 4             
     21     5        888     
     2 11115     8888  7     
     2    5111888 4    7     
     2     888111  4   7     
     2  888      111   7     
     8885           4117     
  8882               4 711   
 8   2 5               7  111
     25               47     
 9   5                 7    0
  9  2                 74  0 
    52                 7  0  
   9 2                 7 4   
  5 92                 7 04  
     9                 70  4 
 5   2                 7     
5    29                7    4
6666 2 9              07   33
    666              0 7333  
     2 696           337     
     2   9666     333  7     
     2    9  66633 0   7     
     2      333 666    7     
     2   339       666 7     
     2333   9    0    67     
             9  0            


This is code-golf, so shortest in bytes wins. Tiebreaker goes to the most votes.

  • \$\begingroup\$ I have a python solution to this which is ~600 bytes, so it's definitely doable, and it's not easy... \$\endgroup\$ – sirpercival Apr 27 '15 at 4:31
  • 5
    \$\begingroup\$ I think the spec needs to be more prescriptive for this to make a good question, especially since the example seems to indicate that you're not currently even prohibiting the lines from having gaps. At a minimum I would say that you should require the lines to be equivalent to those produced by Bresenham's algorithm, and specify how overlaps should be handled; at the extreme, you could tie it down so tightly that it becomes a parameterised kolmogorov-complexity. \$\endgroup\$ – Peter Taylor Apr 27 '15 at 9:34

Pointer to pointers to pointers to pointers

You should choose a language supporting pointers like C. And your task is simple: demonstrate a legitimate use of the most level of pointers.

You should justify your code by describing an algorithm that:

  • Has only plain text, number or an array of those as input and output.
  • You think it will make things easier to write those code as a part of the implementation of this algorithm.
  • This implementation would have optimum memory usage (only declared variables and parameters, explicitly allocated space, and the return addresses for recursive functions count).

Other rules:

  • They must be pointers to pointers directly, i.e. a pointer to an object containing a pointer doesn't count. It's better if nobody using this code will want to extend some pointer to an object later.
  • Each pointer must have a different type (if your language can somehow make them the same type).
  • You should create at least one pointer, and either dereference or compare two non-null pointers once in each level.
  • Using pointers as arrays is only half as interesting.
  • Iterators, etc, are considered in essence pointers and allowed in this challenge. But you can't define new types implementing iterators for this purpose.

  • 3
    \$\begingroup\$ Could you specify "legitimate"? This sounds a bit like code bowling (and seems to have the same issues). With enough imagination I'm sure I can justify any depth of pointers. \$\endgroup\$ – Martin Ender Apr 30 '15 at 17:43
  • \$\begingroup\$ @MartinBüttner Edited but, basically, it is subjective. \$\endgroup\$ – jimmy23013 Apr 30 '15 at 17:57
  • \$\begingroup\$ @MartinBüttner Added a restriction to have optimum memory usage. I'm not sure whether it works. \$\endgroup\$ – jimmy23013 Apr 30 '15 at 18:19

Winning Tic-Tac-Toe lines

For a given tic-tac-toe board of size N**D (for example, a normal tic-tac-toe game is 3**2), the number of winning lines of length N is given by the expression:

$$ 2^{D-1} + \sum_{S=1}^{D-1}2^{S-1}DN^{D-S} $$

(Basically, you are summing the number of lines in each S-dimensional slice of the board.)

The challenge:

Given N and D, your answer should output a list of D-dimensional coordinates for each winning line. Input and output are any reasonable format. You can assume that both N and D are positive integers, with N > 1. (Degenerate cases of N=1, D>1 not included.)

Since this is , fastest answer wins. Please explain your algorithm!

  • \$\begingroup\$ How do you intend to determine which of two answers is fastest? \$\endgroup\$ – Peter Taylor May 12 '15 at 19:37
  • \$\begingroup\$ yes, @randomra made the same point on chat. i'll edit this in, but i guess... i'll put together some test cases and then time them? i dunno, i was going back and forth between this and code-golf, but i'd prefer interesting and readable algorithms. \$\endgroup\$ – sirpercival May 12 '15 at 20:10
  • \$\begingroup\$ i posted this here because i really want the answer, and i hate coming up with brute force solutions... :D \$\endgroup\$ – sirpercival May 12 '15 at 20:16
  • 2
    \$\begingroup\$ Um. Given that you're asking people to enumerate an exponentially large set, in what sense will the answers not be brute force? \$\endgroup\$ – Peter Taylor May 12 '15 at 20:28
  • \$\begingroup\$ well, there's brute force and then there's brute force. but really it's because i don't want to do it myself, haha. \$\endgroup\$ – sirpercival May 12 '15 at 20:34
  • \$\begingroup\$ also, making use of symmetry can severely reduce the computation. \$\endgroup\$ – sirpercival May 12 '15 at 20:40
  • 1
    \$\begingroup\$ I imagine that the runtime in any such algorithm will be basically proportional to the number of things you print, so there won't be any good way to improve by algorithm and the speed will be very platform-dependent. \$\endgroup\$ – xnor May 12 '15 at 23:40

You must log in to answer this question.

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