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

Sandbox FAQ


To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.


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

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

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

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

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


Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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


4551 Answers 4551

30 31
33 34

Table Math

You should which side of a table is the oldest, from ASCII art. I think the best way to explain is with an example, so here is one.

You have a table, made out of +, |, and -. Here is one.

|  |
|  |
|  |

It will alway be a rectangle, just not always square (but it can be square). There will also be people around the table, marked by the letters A-Z. There will never be too many people on a side, or less than one. Just to make it harder, the people will not always be in order, like this:

I|  |
O|  |Q
 |  |J

There will never be anybody next to a plus sign(+). You will be given input on how old each member is, separated by a newline, from the first letter that appears alphabetically (I in this example) to the last letter that appears alphabetically (U in this example), like this:


As seen here, ties are allowed. You should then output the sides with their ages separated with a space, in order from oldest to youngest, like this.

Top 56
Bottom 56
Left 51
Right 14

Note that for everything in this challenge, you can choose the capitalization of the letters, even the input. The winner is the submission with the shortest code.


Interpret Developers

Developers is a joke language that parodies an incident at a Microsoft Developer's conference where Steve Ballmer is supposed to have chanted the word developers at least 14 times in a row. It is basically Brainfuck with a few extensions. It appeared briefly in the Wikipedia in the beginning of 2006, but it has not reappeared anywhere since its deletion. [source]

Your job today is to ressurect this beautiful language, and create an interpreter in the fewest number of bytes. You will have to implement the following commands, which contain their Brainfuck and C equivalents:

| Key            | BF Equiv | C Equiv         |
| "Developers"   | +        | ++*ptr;         |
| "Developers"*2 | -        | --*ptr;         |
| "Developers"*3 | >        | ++ptr;          |
| "Developers"*4 | <        | --ptr;          |
| "Developers"*5 | ,        | *ptr=getchar(): |
| "Developers"*6 | .        | putchar(*ptr);  |
| "Developers"*7 | [        | while (*ptr) {  |
| "Developers"*8 | ]        | }               |

As this is standard , the aim of the game is to create the shortest interpreter possible.


Your interpreter should behave accordingly:

  • Developers/Developerz commands are separated by any whitespace.

  • Anything that is not a valid command should be ignored.

  • There will never be any more than 8 Developers (or 3 Developerz) present in the program that are not separated by whitespace.

  • Input can be interactive or provided at runtime.


If you would like to earn bonus points, you can also implement the following three extensions to the Developers language. These do not have a Brainfuck equivalent.

| Key            | C Equiv                          |
| "Developerz"   | Sleep(strlen(buffer)*10);        |
| "Developerz"*2 | system("cls");||system("clear"); |
| "Developerz"*3 | *p = rand() & 0xFF;              |

If the goal of these is not clear:

  • Developerz should sleep the program for 10ms for ever character in an input string

  • DeveloperzDeveloperz should clear the screen.

  • DevelopersDeveloperzDeveloperz should assign the currently pointed to cell to a random integer between 0 and 255.

For each command you implement, you may multiply your score by 0.75. Thus, by implementing all three, your score would be 42.1875% of the byte count.

  • \$\begingroup\$ That's a pretty big bonus for implementing the three extensions. That's probably either such a hard task no one will go for it or such a huge bonus everyone will <i>have</i> to go for it. \$\endgroup\$
    – Pavel
    Nov 8, 2016 at 3:56
  • \$\begingroup\$ @Pavel I had made it that much because I felt that these bonuses would only benefit languages that were verbose enough that they probably wouldn't beat a Jelly/Python/05AB1E answer (except for the random number functionality), and I dont think the shorter languages tend to have sleep functions or system calls available to them. \$\endgroup\$
    – Kade
    Nov 8, 2016 at 11:11
  • 5
    \$\begingroup\$ This seems like a dupe of "Interpret BF" to me. \$\endgroup\$ Nov 8, 2016 at 14:34

Regex Crossword


Write the shortest program that outputs a valid solution to a regex crossword. A regex crossword is a crossword that has regular expressions for the clues, like in this Puzzling SE puzzle: The Prognosticator.

Terminology your program needs to know (simplified from here)

x*     0 or more of x (any group instruction)
x+     1 or more of x
x?     0 or 1 of x
x{y}   Exactly y of x
x{y,}  y or more of x
x{,y}  y or less of x

.      Any char except \n
(x|y)     Strings x or y (may be multichar), indexed from 1 from the start of clue
(xyz)     Multichar string literal, indexed from 1 from the start of clue
[xyz]     Any of characters x, y or z
[^xyz]    Not the characters x, y or z
[^x|y]    Not x or y (may be multichar)
[B-N]     Letters between B and N inclusive (any letters, caps or not)
[3-6]     Numbers between 3 and 6 inclusive (any digits)
[B-NR-Z]  Multiple ranges (could be digit ranges as well)

Escape sequences:
\7  Get the result of the bracketed instruction indexed 7 (any num)
\r  Literal r where r is a character used in an instruction above
\\  Literal backslash
\W  a-z, A-Z, 0-9, _ (underscore)
\w  Not a character in \W
\d  A digit
\D  Not a digit
\s  Space
\S  Not a space

Test Cases

Input can be any format, examples use: Width Length Top down clues from left to right Bottom down clues from left to right (if they don't exist, newline) Left across clues from top to bottom Right across clues from top to bottom (if they don't exist, newline)

Output must be the completed grid.

Sample input (from here):

Input 1:
2 2


Output 1:
Input 2:
2 2


Output 2:
Input 3:
2 2


Output 3:
Input 4:
3 4
Output 4:
Input 5:
3 7
Output 5:
m r
h l

This is , so the shortest answer in bytes wins!

Standard loopholes apply, and no built-ins for regex testing or matching. Your program must terminate in a reasonable amount of time.

You may assume that each input has exactly one solution.

  • 1
    \$\begingroup\$ 1. "No built-ins" means "You may not answer this question". Every program uses built-ins except zero-byte ones in the languages which support them. "No built-ins for regex testing or matching" would, on the other hand, not be unreasonable. 2. There's currently no constraint requiring the answers to complete the test cases before the heat death of the universe. Is this intentional? \$\endgroup\$ Nov 8, 2016 at 21:05
  • \$\begingroup\$ @PeterTaylor Thanks for that, I've added your suggestions in. I'm new to code golf. \$\endgroup\$
    – boboquack
    Nov 8, 2016 at 21:38

Balancing Act

Edit: Challenge Live here

A see-saw (supposedly from the French 'ci-ça', meaning 'this-that') forms a third of the holy trinity of playground equipment, along with the similarly ubiquitous slide and swing. A see-saw is in perfect balance if, and only if, the sum of the moments on each side are equivalent. A see-saw can therefore be balanced by adding a specific quantity of weight to the side with the lower moment sum; achieving this is your goal for this challenge.


Your challenge is to take a depiction of a see-saw as input and output it again, with weight added to one end of the see-saw to balance it.


Your program must take, in any reasonable format, an ASCII see-saw such as the following:

100             100

The first line contains two numbers, each representing weights on the see-saw. Exactly one weight is present on each side, each acting on the very end of its side of the plank. Weights are guaranteed to be integers, and always align with their corresponding end of the plank. These numbers will never overlap the fulcrum (^).

The second line represents the 'plank' of the see-saw. Each dash (-) represents an equal length to each other dash, with the sole exception of the dash directly over the fulcrum (^), which has no length.

The third line represents the fulcrum of the see-saw. This fulcrum is marked by the only character that is not a space on this line, a circumflex ('^'). The fulcrum can be positioned anywhere along the length of the plank in a valid input so long as enough space is left so that the numbers representing weights do not overlap the fulcrum in either the input or the output.

The input is guaranteed to have three lines, and have no white-space prior to or after the characters that constitute the see-saw (excepting, of course, the third line, which requires it).


For output, the same see-saw depiction should be printed to stdout, but with one (and only one) of the weights replaced with a larger weight, so as to balance the see-saw. Inputs are guaranteed to make this possible using integers alone. Therefore, weights must be shown without decimal points or any other similar notations. If your language does not use stdout you should go by community / meta consensus on output. Trailing newlines are fine but any other changes to the depiction format are probably not OK.


Test Inputs and Corresponding Outputs

Input 1

12                22

Output 1

12                26

Input 2

42       42

Output 2

42       42

Input 3

3             16

Output 3

14            16

Input 4

1                56

Output 4

196              56

Reference Implementation - Python 3

# Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]


balance_seesaw(["1                56",
                "    ^              "])


  • This is , so the shortest code wins counted in bytes. Check meta if counting bytes is awkward in your language.

  • Standard rules/loopholes apply.

  • Input must be taken in a reasonable format. A non-exhaustive list of appropriate formats are given as follows:

    • A single string with lines separated by newline characters
    • A list of strings, each string represented a line
    • A 2D Array or Matrix of characters

Sandbox Notes

Please comment on any parts of the spec, especially input / output requirements, that you find confusing or ambiguous. I haven't written a challenge before so I'm open to the fact that there's quite a bit I've missed. Any and all feedback welcome.

Some users in the comments have rightly pointed out similarities between this challenge and others; please weigh in as to if you think this is a dupe or a unique challenge in its own right. Thanks!

  • \$\begingroup\$ Welcome to PPCG! A pretty decent first challenge. It's pretty similar to this one, but yours is, in my opinion, different enough to not be a duplicate. It's also pretty close to this one posted in the Sandbox a few posts down. I think that all three are different enough to not be dupes, but I'll hold off on final judgment to hear what others say. \$\endgroup\$ Nov 10, 2016 at 20:57
  • \$\begingroup\$ @TimmyD thanks for the welcome! Looks like I need to up my searching game! I understand if this is deemed a duplicate but it seems to differ in a fair few ways from the others at least. \$\endgroup\$
    – FourOhFour
    Nov 10, 2016 at 21:01
  • 1
    \$\begingroup\$ Welcome! For me, a nice challenge and well explained with clear examples. I'll also hold back on the dupe side but agree with TimmyD that it may be different enough. Well done for using the Sandbox anyway. It' a shame that more contributors don't. I'm going to +1 just for that. \$\endgroup\$
    – ElPedro
    Nov 10, 2016 at 21:10
  • \$\begingroup\$ @ElPedro thanks, appreciate the feedback and the vote. \$\endgroup\$
    – FourOhFour
    Nov 10, 2016 at 21:13
  • \$\begingroup\$ Having read (again) through the examples mentioned by @TimmyD I would not say this is a dupe. Possibly mention that it is related though. \$\endgroup\$
    – ElPedro
    Nov 10, 2016 at 21:34

Find the optimal sorting network

Sorting networks are an abstract model of "wires" carrying numbers, which outputs them sorted.

A comparator in a sorting network works as follows:


This is the optimal sorting network for 4 numbers:


Since there are two kinds of "optimal" sorting networks people care about, we are going for the least number of comparators (those vertical lines).

Given a non-negative integer n (so yes, 0 and 1 need to be supported), output a list of comparators which designates an optimal sorting network for n inputs. The "comparators" are a pair of indices which say which indices in the working array to compare / swap. The indices must be 0-based.

So for the example sorting network, this would be a valid output (viewing 0 as the top wire):

(0, 2), (1, 3), (0, 1), (2, 3), (1, 2)

As would this:

(0, 2), (1, 3), (2, 3), (0, 1), (1, 2)

Additionally, any whitespace is ignored (except for tokenizing), and any non-digit is considered whitespace, so this is also a valid output:

0 2 1 3 2 3 0 1 1 2

And also:

(0, 2)
((2, 3, 0), 1)
(1, 2)

Furthermore, functions may simply return some iterable that - when flattened - gives the list of numbers in the correct order.

  • \$\begingroup\$ I have an algorithm to do this; it's O((n^2)! n! n), so very very slow. It might compute size 3, but not size 4. \$\endgroup\$
    – Justin
    Nov 19, 2016 at 7:04
  • \$\begingroup\$ I think it's worth giving an example of a sorting network in action on some input. \$\endgroup\$
    – xnor
    Nov 19, 2016 at 7:12
  • \$\begingroup\$ What are the bounds on n? Obviously it doesn't make sense to have n < 0, but do answers need to handle n=0 and n=1? \$\endgroup\$ Nov 19, 2016 at 13:00
  • \$\begingroup\$ @Justin are you still planning to release this challenge? I'm asking because I wanted to make a very similar challenge that would probably be considered a dupe. \$\endgroup\$
    – flawr
    Jul 18, 2019 at 6:53
  • \$\begingroup\$ @flawr No, go for it \$\endgroup\$
    – Justin
    Jul 18, 2019 at 12:16

ROT-13? More like ROT-Rand!

This challenge is to take the following list of characters (ASCII 32 to 126):


Randomly shuffle it:

wypP+]`=3&IJ6*xAh{zi_l4Y#k~S F?-oReU;(0m,Z5'trs!aLCQ/g}OjM<u[qE2)BTVb$>19%c:HW@8."nD\Nf7dXKv^|G

Take in an input string:


Then replace the characters in the string, with their new shuffled equivalents:


Using this methodology on large ASCII-based/dictionary based texts would result in something that is decipherable using much trial and error and would be a decent way to encode a long message.

wypP+]`=3&IJ6*xAh{zi_l4Y#k~S F?-oReU;(0m,Z5'trs!aLCQ/g}OjM<u[qE2)BTVb$>19%c:HW@8."nD\Nf7dXKv^|G
 ^           ^                                    ^              ^  ^         ^^    ^
 !           -                                    R              a  d         no    t


  1. Your only input is the text to be "encrypted".
  2. Your output is the encrypted string.
  3. The ASCII list must be randomly shuffled, built-ins are allowed.
  4. , shortest in bytes wins.
  • \$\begingroup\$ 1. I'm guessing from context that "their new shuffled equivalents" means that we're generating a random substitution cipher, but I don't see any actual definition of the equivalence. 2. If I'm correct, this is pretty boring, but could be made more interesting with the (justifiable) modification that the substitution should be a random derangement rather than just a random permutation. That will probably force most languages to do more than just apply two built-ins. \$\endgroup\$ Nov 26, 2016 at 22:44
  • \$\begingroup\$ @PeterTaylor derangement? \$\endgroup\$ Nov 27, 2016 at 15:50
  • \$\begingroup\$ en.wikipedia.org/wiki/Derangement \$\endgroup\$ Nov 27, 2016 at 16:05


Your task is to print animated helicopter.


  1. Animation should contain at least two frames.

  2. Delay between frames is up to you, but rotation of airscrews should be visible.

  3. Helicopter could be very simple (simpler than standard roflcopter showed below) but it should leave no doubt what is it. All ASCII chars are allowed.

  4. No caption below needed.

  5. Printing animation to file would be hard, although all standard output destinations are allowed.

  6. This is , so etc.


I believe I can fly.

  • 2
    \$\begingroup\$ You should probably place the ASCII of each frame of the Roflcopter in the challenge. Also, is the ROFL COPTER!!! at the end necessary? \$\endgroup\$
    – clismique
    Nov 24, 2016 at 8:43
  • \$\begingroup\$ +1 For caption necessity or not, I updated question. In my opinion providing frames will make challenge too easy. \$\endgroup\$
    – paldir
    Nov 24, 2016 at 8:48
  • \$\begingroup\$ So will the design of the Roflcopter be the same for all submissions, with the same plane body, rotors and stuff? \$\endgroup\$
    – clismique
    Nov 24, 2016 at 9:09
  • \$\begingroup\$ It's up to users, how exactly it will look, but it should be helicopter-like. Ok, I think you're right, this task is too ambiguous. I will try with another question. \$\endgroup\$
    – paldir
    Nov 24, 2016 at 9:12
  • 1
    \$\begingroup\$ You can just standardise the copter itself, and it shouldn't be ambiguous... \$\endgroup\$
    – clismique
    Nov 24, 2016 at 9:18

Hexasweep: A two-part challenge

Part 1: The solver

Your task is to solve a Hexasweep puzzle.

A Hexasweep puzzle is set out on a grid of diamonds arranged in hexagonal shapes, of which the board looks like a hexagon, like so:

        /\    \
  _____/ X\____\_____
 /\    \  / XX /\    \
/X \____\/____/X \____\
\ X/ XX /\    \ X/    /
 \/____/  \____\/____/
 /\    \  / X  /\    \
/  \____\/____/  \____\
\  / XX /\    \  / XX /
 \/____/  \____\/____/
       \ X/    /

The above image is composed of 7 hexagons (21 diamonds), and is thus a Hexasweep puzzle of size 2. If you want to expand it, cover the current Hexasweep puzzle with more hexagons (so that there are 19 hexagons - that will make a Hexasweep puzzle of size 3).

Each diamond can contain 0, 1 or 2 "bombs", with bombs depicted as X above.

The above image would be read from top to bottom, starting from the left:


That is now the "condensed form" of the puzzle.

Numbers are marked on "intersection points", to show how many bombs are on the diamonds which are touching those intersection points - the intersection points of this grid are shown below using O.

        /\    \
  _____/  OO___\_____
 /\    \  OO   /\    \
/  OO___OO___OO  OO___\
\  OO   OO   OO  OO   /
 \/___OO  OO___OO____/
 /\   OO  OO   OO    \
/  OO___OO___OO  OO___\
\  OO   OO   OO  OO   /
 \/____/  OO___\/____/
       \  OO   /

As you can see, there are two "types" of intersection points - those with 3 diamonds touching it, and those with 6 (the one that are touching the edge of the board aren't counted):

 /\  XX\
/X OO___\
\ XOO   /

 _____/X \_____
 \ XX \ X/    /
  / XX OO  X \
 /____/  \____\
      \ X/

The two intersections would be marked with 4 and 8 respectively.

In the original Hexasweep puzzle above, the intersection numbers would be:

4 5 4 2
 2 1 3
2 4 1 2

Which would be condensed to:


Given an input in this "condensed form", you must output the original puzzle, in "condensed form" (see above).


  • Any delimiter for the "condensed form" as input are allowed (it doesn't have to be , separating the numbers).
  • You may output a list, or a string with any delimiter.
  • Your program must be generalised: it must be able to solve Hexasweep puzzles of any size (at least up to size 4).
  • If there is more than 1 possible answer, your program must output the single character N.

This is , so shortest code in bytes wins!

If there is a tie, the earlier post is declared the winner.

Part 2: The maker

Your task is to generate the smallest Hexasweep puzzle with a single solution that encodes a binary number.

Because any diamond in a Hexasweep puzzle can have either 1 or 2 bombs (if the diamond has bombs), you can encode binary numbers into it. In this puzzle (condensed form):


The only digits that matter are the non-zero digits, so this turns into:


Decrement each number by 1:


Which is equal to 459.

Your task is to make a program that generates that Hexasweep puzzle in the smallest grid with a single solution.


  • You must output the condensed form of the Hexasweep puzzle.
  • You can output either an array of numbers, or a string with any delimiter.
  • You will be tested on all positive integers from 10,000 to 15,000, and your program is expected to return a value for any integer in 10 minutes.

Your final score is the total size grid for every test integer added together (so if you get a size 3 grid for every number, your final score would be 15,000). The lowest score is declared the winner.

If there is a tie, the earlier post is declared the winner.


  • Should this be one challenge or two? If it's one challenge, should the score just be added up for both programs?
  • Any improvements in explanation?
  • Is this a dupe?
  • \$\begingroup\$ Can I post this abandoned proposal? \$\endgroup\$
    – user58826
    Jun 9, 2017 at 12:24

Please do my Martian homework posted

For Sandbox, please note

This was originally conceived of as two related challenges; Please do my Martian homework and Please grade my Martian homework.

Though the task itself is different, the basic description of the task (that is, what is a Martian essay) is the same (though I may edit it later anyway), but just to avoid confusion:

  • Please do my Martian homework was posted
  • Please grade my Martian homework is what's left

Please Grade my Martian Homework


Around the turn of the 20th century, spiritualist Catherine-Elise Müller allegedly communicated with Martians. During somnambulatory trances, she would write out Martian scripts. Psychologist Théodore Flourney discovered her Martian writings were very similar to her native French, and in his book "From India to the Planet Mars", he documented Catherine's Martian alphabet. The following is loosely based on that alphabet with an extended mythos.

Problem Description

The Martian language has 21 characters, shown here next to each Latin equivalent:

enter image description here

Unfortunately, there's no Unicode for Martian (despite Mars being part of the universe), so we're stuck using Latin characters.

Whereas in English our phonemes break out into two major types (consonants/vowels) which we loosely map to letters, Martian has three letter types:

  • The vowels: a e i m n o u
  • The hard consonants: b c d g k p t
  • The soft consonants: f h l r s v z

In addition to this, the Martian language contains a single punctuation mark--the period.

A Martian word is a set of 3 to 9 letters. All Martian words have at least one vowel, one hard consonant, and one soft consonant (in any arrangement). For example, fng, cdaz, vpi, and pascal are Martian words.

A Martian sentence is a set of 3 to 9 Martian words delimited by spaces and followed by a period.

A Martian paragraph is a set of 3 to 9 Martian sentences, delimited by spaces, and followed by a newline.

A Martian essay is a collection of Martian paragraphs that contains no contiguous word repetitions.

A contiguous word repetition is any construct S S where S is a contiguous set of words. Note that this definition ignores sentence and paragraph boundaries.


The Martian homework assignment is to write an essay between 729 and 810 words. The essay is graded on a pass/fail basis; pass simply means it's a valid Martian essay according to the above definitions, and fail means not pass.

Your challenge is to write a function or program that accepts data as input, and returns a truthy value if that data is a valid Martian essay between 729 and 810 words, or a falsey value if it is not. (Don't forget that you must fail the input if there is a contiguous repetition).

This is code golf. Shortest code in bytes wins. Standard loopholes disallowed.


Post link to examples in first challenge? Repeat examples? Should second challenge still have word counting?

  • \$\begingroup\$ Whoops; most of the post is almost identical so I thought it was the same, but the task is indeed different. I've deleted my original comment. \$\endgroup\$
    – user62131
    Dec 5, 2016 at 0:22

Monopoly Continued

So you've got your Monopoly board, shall we start a game?

To start with, we'll need some dice and to know where we land!

Write a program that outputs the rolls and resting places of a given number players for a given number turns.


In any suitable format for your language

  • The number of players up to a maximum of 6
  • The number of turns to output up to a maximum of 250


In any meaningful option for your chosen language

  • The output should be in the format: PlayerNumber, Die1, Die2, InitialOfRestingPlace
  • Each roll should be separated by a new line.



  • Use the US Board for the names of squares
    F K C I I B A V W M G 
    N                   P
    T                   N
    C                   C
    S                   P
    P                   S
    V                   C
    S                   P
    E                   L
    S                   B
    J C V C O R I B C M G 
  • All players start on Go (bottom right)
  • A player rolls (pseudo randomly generated) two six-sided dice, once per turn, unless they roll doubles (described below), and moves that many spaces clockwise.


  • Rolling doubles means the player can roll again
  • Rolling three doubles in a row lands the player in jail and the players turn ends


  • Landing on the "Go To Jail" square sends the player to jail
  • While in jail, the player may not move unless they roll a double
  • Rolling a double to get out of jail ends the player's turn
  • Landing on the jail square does not mean a player is in jail

Chance/Community Chest

  • These squares currently have no effect.

Example output

Excluding comments

For input 2,3

//Turn 1
1,2,2,I   //Player lands on Income Tax, Player rolled doubles, roll again
1,2,4,J   //Player lands on Jail and turn ends
2,5,3,V   //Player lands on Vermont Avenue and turn ends

//Turn 2
1,5,5,F   //Player lands on Free Parking, doubles, roll again.
1,5,5,G   //Player lands on Go To Jail, goes to Jail, turn ends
2,3,4,P   //Player lands on Pennsylvania Railroad, and the turn ends.

//Turn 3
1,5,2,J   //No double, player remains in Jail
2,6,3,I   //Player lands on Illinois Avenue and turn ends.


This didn't start as a challenge, but in coming up with scoring, a lot of the elements I thought of for scoring were very "golf-y" by nature, so I've changed my mind (before any answers are posted). See the edit history if the previous scoring intrigues you.

Despite first posting this on the sandbox, I'm bound to have missed something! Please feel free to point out mistakes or problems.


  • Too complex
  • How to score?
  • Doesn't include Chance or Community Chest cards
  • \$\begingroup\$ I am actually coding monopoly right now which is how I got the idea for the code golf, the movement isn't the most complex thing in the world but the buying and building houses etc is very much so. I am not sure if you will get many takers if it is code-gold, maybe a code-challenge? \$\endgroup\$ Oct 19, 2016 at 14:59
  • \$\begingroup\$ This isn't too complex. However, it is tough to make test cases, as the game is non-deterministic, and testing for edge cases (I landed on Jail, but I'm not in Jail) is tough for the reader to do. I'd still include the Monopoly board this time around. \$\endgroup\$ Oct 19, 2016 at 15:05
  • \$\begingroup\$ Incomplete. What about chance / community chest cards which send the player to a different square? \$\endgroup\$ Oct 19, 2016 at 15:29
  • \$\begingroup\$ @NathanMerrill, do you propose any changes? Or just pointing out a risk? \$\endgroup\$ Oct 19, 2016 at 16:00
  • 1
    \$\begingroup\$ @PeterTaylor I did intentionally leave out chance and community chest to reduce complexity \$\endgroup\$ Oct 19, 2016 at 16:01
  • \$\begingroup\$ @jacksonecac I'm all for code challenge, but I'm unsure how the scoring would work \$\endgroup\$ Oct 19, 2016 at 16:04
  • \$\begingroup\$ Scoring could be by popularity contest. \$\endgroup\$ Oct 19, 2016 at 19:35
  • 2
    \$\begingroup\$ Popularity contest is a terrible idea. Code golf would be much better. \$\endgroup\$
    – user45941
    Oct 21, 2016 at 0:23

Generate me a QFP chip!

This challenge is now live!

QFP is a type of form factor for an electrical component where pins come out the sides of a chip. Here are is a picture of a typical QFP component: enter image description here

you can see that the general formula is to have 4 sides of equal numbers of pins.

Your challenge is to create a program that takes in an integer, thich represents the number of pins on one side, and creates an ASCII QFP component with numbered pins.


a single integer which represents the number of pins on one side


An ascii QFP chip with an apropriate pinout.



1┤ ├3


1┤  ├6
2┤  ├5


 1┤            ├36
 2┤            ├35
 3┤            ├34
 4┤            ├33
 5┤            ├32
 6┤            ├31
 7┤            ├30
 8┤            ├29
 9┤            ├28
10┤            ├27
11┤            ├26
12┤            ├25


  • all QFP chips must be enclosed and sealed as well as ascii provides. spacing is of utmost importance.
  • pin numbering must be done as in the examples (Read left to right, top to bottom, numbered counter clockwise)
  • You may start numbering at 0, but this must not affect the chip (an input of 12 still needs 12 pins per side)
  • The only valid characers in your output are 1,2,3,4,5,6,7,8,9,0,┌,┴,┐,├,┘,┬,└,┤, spaces, and newlines.

This is a codegolf, and as such, The code with the least number of bytes wins! Good Luck!

  • \$\begingroup\$ @Geobits thank you! fixed. \$\endgroup\$
    – tuskiomi
    Nov 17, 2016 at 20:42
  • 1
    \$\begingroup\$ Do we have to use boxdrawing characters or can we use + instead? If you use them, it means languages that don't support nonascii can't compete. Also what encodings are allowed? codepage 437? UTF-8? Include the codepoints in the question. \$\endgroup\$ Nov 28, 2016 at 22:01
  • \$\begingroup\$ @LevelRiverSt thank you for your feedback! It was my intention to keep those languages out of the challenge. \$\endgroup\$
    – tuskiomi
    Nov 29, 2016 at 15:52
  • \$\begingroup\$ Now that this has been posted you should consider editing it down to a link and deleting the answer. \$\endgroup\$
    – Wheat Wizard Mod
    Mar 3, 2017 at 0:01

The social network

On my social network, two users are "friends" if their name share a common letter. For exemple, bob and bill are friends, as they share the letter b.

Given a list of user names:

  • display a falsy value if there exist in the list two distinct users x and y that cannot be related through a friendship chain;
  • else, display a truthy value.


abc cde efg ghi should return true, as abc is friend with cde, which is friend with efg, which is friend with ghi : all users are related.

abc cde fgh hij should return false, as for example abc and fgh cannot be related through a friendship chain.

abc should return true, as we cannot find in that list two unrelated users.


  • You can read the name list in any convenient format for your language.
  • You can assume all the names are lowercase and use only the characters a-z.
  • You don't need to handle the empty list, any result (true, false, program crash) is acceptable for it.
  • \$\begingroup\$ We've had transitive closure questions before (1, 2). This may be different enough to run, though (especially because the format increases the chance of a regex solution doing well), although it's particularly close to my second link there. I'd recommend the use of the graph-theory tag, though, as it's clearly heavily related to the other transitive closure questions. \$\endgroup\$
    – user62131
    Dec 31, 2016 at 23:11
  • \$\begingroup\$ @ais523 yes that's almost same than codegolf.stackexchange.com/questions/8647/…... will not post then \$\endgroup\$
    – Arnaud
    Jan 2, 2017 at 3:10

Smallest integer divisible by 2..n

Given an integer n, output the smallest integer divisible by 2,3,4,...,n inclusive.


2520 is divisible by every integer from 2 to 10.


Shortest code in bytes wins.


  • Dup?
  • Better Wording?
  • Restrictions/Rules?
  • \$\begingroup\$ So just lcm(2..n)? \$\endgroup\$
    – FlipTack
    Dec 31, 2016 at 12:18
  • \$\begingroup\$ you're right. would be marked as dup I guess :D \$\endgroup\$
    – Seims
    Dec 31, 2016 at 13:09
  • \$\begingroup\$ Actually, I don't think there's been challenges exactly like this before. I wouldn't call it a dupe. \$\endgroup\$
    – FlipTack
    Dec 31, 2016 at 14:41

Pseudoku Cops and Robbers King of the Hill

(I know that another user, @NathanMerrill, is proposing a similar contest. I started playing with the idea for this type of contest independently yesterday, but have since chatted with in The Nineteenth Byte. He is currently undecided on the type of puzzle to use and has some different ideas on how to evaluate participants' performance, so I feel comfortable proposing my idea as a separate challenge.)

Sudoku is a well-known logic puzzle. It is a puzzle of four nines: nine rows of cells, nine columns of cells, nine 3x3 adjacent and distinct blocks of cells, and nine values that any cell can have. A valid Sudoku arrangement or solution is one in which every row, cell, and block has all nine values exactly one time. For example, consider the following valid solution:

|4 6 1|5 7 3|2 8 9|
|5 7 8|2 1 9|4 6 3|
|3 2 9|6 8 4|1 7 5|
|9 8 4|7 6 2|3 5 1|
|7 5 6|3 4 1|9 2 8|
|2 1 3|9 5 8|7 4 6|
|8 3 5|1 2 7|6 9 4|
|6 9 7|4 3 5|8 1 2|
|1 4 2|8 9 6|5 3 7|

These are turned into puzzles by removing many of the values in the arrangement in such a way that all blanks are mirrored horizontally and vertically across the puzzle and so there is only one valid way to fill in the blanks to get a valid Sudoku solution. For the above puzzle, this might look like this:

|4    |     |2 8  |
|  7  |  1  |    3|
|    9|    4|1    |
|     |7 6  |3 5 1|
|     |     |     |
|2 1 3|  5 8|     |
|    5|1    |6    |
|6    |  3  |  1  |
|  4 2|     |    7|

Someone who wished to play this Sudoku puzzle would then use the information provided to find the original solution.

Sudoku has some interesting properties that allow it to be generalized to similar puzzles with different rules that are sometimes called "Pseudoku" (which is pronounced the same way as the actual puzzle, SOO-DOE-KOO, so please stop saying SOO-DOO-KOO). For our purposes, we will make two differences. First, it may be possible to generate harder puzzles by removing the restriction for symmetric removals. The following is a valid puzzle by Sudoku rules, so why not allow it?

|4   1|  7  |2    |
|5    |2   9|     |
|3    |  8  |     |
|  8 4|7   2|    1|
|     |3   1|  2  |
|     |     |     |
|     |     |6    |
|  9 7|     |     |
|1    |     |5 3  |

Second, Sudoku's properties allow us to define games with different sizes. You can define a Pseudoku game with a parameter N where the resulting board has N^2 rows, N^2 columns, N^2 blocks of size NxN, and N^2 values for each cell. Standard Sudoku would be a Pseudoku variant with N=3. So the following would be a valid Pseudoku(2) game:

|1  |   |
|   |  3|
|  1|4  |
|4  |   |

and an example Pseudoku(4) game:

|11         |      10  4| 1     9   | 2       16|
| 6     5   |   15  1   |    3     2|12  8      |
|10    13 14|         12| 5       15| 4     7   |
| 2  3      |    6    13|       8 11|    5    10|
| 7 11 12  9|14        2|16  1  4   |           |
|           |   10  4   |          3|13    16 11|
| 4       10|   16    15|   12      |          6|
| 1 16  2   |11  3      |   10     8|           |
| 3        2|       6   |13         | 5 14     1|
|    7      |          5|           |           |
|   13 14  4|12    16   |           | 8  9      |
|    5 16   |13     9   | 4     2  1|           |
|14 12     7|           |   15     4|11     6   |
|    9      | 6         |11 16      |       3   |
|      11   | 8 13     1| 3 14      |    7      |
|13     8   | 7    11   | 2         |      15   |

Since Sudoku is NP-complete, so is Pseudoku. That means that it gets more difficult to solve a Pseudoku puzzle the larger N gets. However, it can take more time to generate Pseudoku puzzles than it does to solve them, since the naive algorithm for generating a puzzle requires solving the puzzle each time a value is removed! Solving Pseudoku puzzles is fun, but if it takes longer to generate them than it does to solve them, it becomes more work than play.

So help me out! I propose a Cops and Robbers style King of the Hill. The Cops will compete by writing programs to generate lots of Pseudoku puzzles to consume as much time as possible for solving, while the Robbers will compete by writing programs to solve Pseudoku puzzles to consume as little as time possible solving these puzzles.

I need some help ironing out the format, but here is what I have so far:

  1. I will provide a Java framework for running the contest. This framework will connect to clients by TCP/IP so contestants can choose whatever language they want to write their Cops and Robbers (so long as I can run them on my system). I will also provide a basic Cop and Robber for these users to try out to see what sorts of times they take. I will publish the times they generate on my system so contestants can estimate how their entries will run on my system.

  2. I will give each Cop ten minutes to generate as many Pseudoku(N>= 3) puzzles as they can, but they should be able to generate at least Pseudoku(N=4) puzzles. They can choose what sizes they want the puzzles to be, but they have to be valid with exactly one solution. My server will naively check each one to guarantee their validity; any Cop that generates an invalid puzzle is disqualified. I recommend configuring the Cop programs to be parameterized externally so that Robbers can test their code against basic Cop configurations, but then the Cops can send me secret, optimized configurations before the contest completes for their actual execution. I will provide a couple days after the deadline ends for conferring with the Cop programmers if their settings do not work as expected on my system. Cops should generate different puzzles every time with reasonable expectations; that means no spamming with the same puzzle repeatedly or reading pregenerated puzzles from a file system, Internet source, or internal cache. In addition, I don't want to see a Cop that uses the same removal pattern for every puzzle (that may not guarantee valid puzzles, anyway).

  3. Each Robber will be tested against each puzzle generated by the Cops. The Robber will have to generate the correct solution for each puzzle as quickly as possible. I will probably need to see some timings before I make a final decision, but each Robber will be capped with some amount of time to solve a puzzle (maybe an hour?) before the time-to-completion defaults to twice that cap. These Robbers will be permitted to use any technique for solving the puzzles that my system supports except for packet sniffing. I am on the fence as to whether the Robbers will be on an honor code to not study Cop code since I plan to have secret parameterizations anyway.

  4. All the times for all the puzzles will be sorted from least to greatest and then assigned an index as one would in a Mann-Whitney U test. Each Cop and Robber will be scored using the sum of the indices of their contributions: Cops for the times the Robbers spent solving their puzzzles, and Robbers for the times they spent solving puzzles. The winning Cop will have the highest sum and the winning Robber the lowest. Cop ties will be broken first by the average time required to solve one of its problems (more is better), then by the number of puzzles generated (more is better), then by the name I deem cooler (here's hoping that doesn't happen). Robber ties will be broken first by the average time spent solving puzzles, then by the sum of the time, then by the standard deviation, then by the cooler name.

  5. This scoring scheme poses an interesting challenge to Cops: balancing the size of the problems (and the likely amount of time needed to solve them) against the number of problems generated. A Cop that generates only one puzzle that no Robber can solve in the time limit is likely to lose to another Cop that generates many moderate problems. Similarly, a Cop that spams many small problems is likely to be beaten by another Cop that generates fewer problems of larger sizes. Since the official contest configurations should be kept secret until the contest starts, other Cops can study the other programs to try to determine what their opponents are likely to do and plan accordingly.

I am interested in any and all feedback that the community might have about this challenge.

  • \$\begingroup\$ I pronounce Pseudoku as SOO-do-ku and Sudoku as soo-DO-ku, to align with the pronunciation of Pseudo. \$\endgroup\$
    – Pavel
    Jan 6, 2017 at 0:22
  • \$\begingroup\$ I don't know if you'll get a lot of submissions. Sudoku is a bit difficult to program. Also, TCP-IP is not something people are used to using for their submissions. \$\endgroup\$
    – mbomb007
    Jan 6, 2017 at 16:25
  • \$\begingroup\$ It is? Well, part of what I am looking for is whether people would participate. I would need at a minimum two Cops and two Robbers or there is no point. Could people comment saying whether they would play and whether they would play as a Cop, a Robber, or both? \$\endgroup\$
    – sadakatsu
    Jan 6, 2017 at 17:17
  • \$\begingroup\$ The scoring system you've chosen adds a large incentive to submit a huge number of programs that are almost identical to your own submission but slightly worse. This means that if some opposing programs generate some puzzles that are harder than yours and some puzzles that are easier (which is likely), you'll push the easy ones right down the leaderboard, making your programs look better in comparison. \$\endgroup\$
    – user62131
    Jan 6, 2017 at 17:47
  • \$\begingroup\$ Good point. This can be resolved by a "one-submission-per-category" rule. \$\endgroup\$
    – sadakatsu
    Jan 6, 2017 at 18:07
  • \$\begingroup\$ If you want, I have some code that can help you communicate with submissions (over standard in/out). However, I think the best solution is to run the cops' submission and kill it after 10 minutes. They should write each sudoku puzzle as a file, which you would then read.. I also wouldn't worry about automated checking to see if the puzzles are valid. I generally assume good faith in these types of challenges, unless it becomes an issue. \$\endgroup\$ Jan 6, 2017 at 18:33
  • \$\begingroup\$ Re: validation... there's a problem here. For it to make any sense, I would need to have at least as good a solver as the best Robber entry, in which case someone would just copy mine in a faster language than Java. I think I would still require a unit testing protocol where I pass solutions to the Cops, the Cops return problems, and then I validate that they sent unique puzzles. \$\endgroup\$
    – sadakatsu
    Jan 6, 2017 at 18:45
  • \$\begingroup\$ Re: standard input/output versus sockets... I don't get the aversion to network programming. I used TCP in my Speed Clue contest a couple years ago, and it worked great (though I admittedly had few entries). So long as I guarantee an environment for the contest (probably Linux), even C/C++ developers can write code with platform-specific libraries if they wish. Using networking also allows a good method for timing responses: I start the clock once I get the ACK after sending a command, and I stop the clock after I ACK that I received a response. File dumping makes timing Cops difficult. \$\endgroup\$
    – sadakatsu
    Jan 6, 2017 at 18:50
  • \$\begingroup\$ 1. I don't think you've taken account of how badly things scale. It's easy to spit out valid pseudokus for N=100; validating them in a reasonable time requires supporting every rule which the cop knows. 2. The stuff about secret parameterisations doesn't really make sense to me. Taken to extremes, that could mean that we make the actual generation code the "parameterisation" and the cop "program" is just an eval. 3. The cop/robber setup means there's inherently a submission deadline. That's generally a bad thing, but even more so with something which can get extremely complicated. \$\endgroup\$ Jan 10, 2017 at 15:49

broken keyboard workaround

|nspired by BASTA´s song and memories from earlier work:

Your keyboard is broken but there is some urgent work you have to complete; you have no back^up hardware - and the shops are closed so you can´t buy a new keyboard!

All you have left to work with is your mouse.

6iven two texts as input (the one you have and the one you want to have), create a program or function that tells you the cut, copy&paste actions that will turn the one text into the other.

Using the mouse is strenuous, so you don´t want too many cut/copy/paste actions. Keep your output as short as possible.

Remember: Your keyboard is broken = you can´t use any characters in your code that you don't have ~ you must get alon9 with those that are provided in th1s {["te%t"]}. For7unately your keyboard 7ook qu17e a wh1le 7o bre4k down c0mpletely 4nd y0u used numb3rs 4nd sp3c*4l ch@r$ t0 r3pl@c3 br0k3n l3773r$; $0 y0u $h0uld h@v3 m0$7 0f 7h3m @v@*l@bl3.

Also, you don´t want to do too much C&P to cre8 your code, so keep that as short as possible, too.

  • You can assume that the second text contains no characters that are not present in the first text.
  • You can pick any input format and method that is convenient for you; but the output format should match that. (e.g. if you take input from files, output should also go to a file).


Note that the challenge description contains all letters and digits except j and z. If you absolutely need them: they are hidden in the YouTube link. (I didn´t check for upper/lower case though.)

Curlys, brackets, braces, single and double quotes and all operators I could think of are there, so the challenge should be fine for most languages that use printable ASCII.

Still trying to find a more fluent way to include curlys, brackets, double quotes and circumflex, though.

I thought there was a tag [string-manipulation]; but couldn´t find it in the list.

I think about dropping the "output method should match input method" restriction.

  • \$\begingroup\$ Try [tag:code-golf] and [tag:restricted-source] \$\endgroup\$ Jan 9, 2017 at 16:49
  • \$\begingroup\$ The part of your question with weird characters in it is a bit hard to read. Maybe tone it down a bit. Also, some examples would be helpful for understanding the challenge. \$\endgroup\$
    – mbomb007
    Feb 1, 2017 at 4:51

Find B1nar0 Solutions

B1nar0 puzzle is a paper and pencil game with 0 and 1. The goal is to fill the grid accoring to 3 rules :

  1. No more than 2 consecutive 0s or 1s
  2. Each row/column has half 0s and half 1s
  3. No identical row/columns

Example :


  • A is 0 according to rule 1
  • B is 1 according to rule 1
  • C is 0 according to rule 2
  • D is 1 according to rule 2
  • etc.

Edit : Grids are square grids of even size (4, 6, 8, 10, 12 or 16 are usual sizes).

Input : Any binary grid (array or string) with 0,1 and any other character you want for empty cells.

Output : Same format as input but filled with a correct grid.

Test case (see GIF)

0 11
1 1 
  • \$\begingroup\$ Are the grid dimensions always 4x4 ? \$\endgroup\$
    – Arnaud
    Jan 17, 2017 at 8:14
  • \$\begingroup\$ Non, any even number should fit, generally 4-6-8-10-12 or 16 games. \$\endgroup\$
    – Crypto
    Jan 17, 2017 at 8:16
  • \$\begingroup\$ Nice challenge, but I suggest you add some test cases for the larger grid sizes too. Also, may we assume that we will get input that makes it possible to solve the puzzle? For instance not: [[1,1,1, ],[ , , , ],[ , , , ],[ , , , ]]. Can we assume that there will only be one valid solution? For instance, not an empty grid. \$\endgroup\$ Mar 9, 2017 at 14:22
  • \$\begingroup\$ Also, the 6x6 test case is a lot harder than the 4x4. The 4x4 can be solved going through the matrix checking the different rules one after the other. To solve the 6x6 grid you need an algorithm that's a lot more sophisticated. Do you require that the program should be able to solve any input, regardless of the difficulty. Even if it requires brute-forcing the solution (which may take a loong time for a 16x16 matrix \$\endgroup\$ Mar 9, 2017 at 14:22
  • \$\begingroup\$ Then you should add a few 10x10, 12x12 and 16x16 test cases (with solutions). Requiring that submissions can solve all possible boards regardless of difficulty makes this a really hard challenge. You should also impose a time limit. Otherwise I can just write a script that checks all possible combinations and claim that it will eventually find the right solution \$\endgroup\$ Mar 9, 2017 at 14:22
  • \$\begingroup\$ I added the comments I had on the post when it was on main. Some of them are a bit out of context now, but I guess you remember what they're about. :) \$\endgroup\$ Mar 9, 2017 at 14:23
  • \$\begingroup\$ Nice challenge, but I suggest you add some test cases for the larger grid sizes too. Also, may we assume that we will get input that makes it possible to solve the puzzle? For instance not: [[1,1,1, ],[ , , , ],[ , , , ],[ , , , ]]. Can we assume that there will only be one valid solution? For instance, not an empty grid \$\endgroup\$ Mar 9, 2017 at 14:23

Enthusiastically Russianify a String

Greetings Comrades,

Many of you may have interacted with people from Russia on the internet at some point, and a subset of you may have noticed the slightly odd method they have of expressing themselves.

e.g. деинсталляция игра нуб))) - (forgive the google translate)

where the ))) are added for emphasis on the previous statement, I have been working on a theory that the ratio of )'s to the rest of the string is directly proportional to the amount of implied emphasis, however I oftentimes find it difficult to compute the ratio on the fly, as I am also trying to cope with a slew of abuse, so I would like the shortest possible code to help me calculate what the resulting string should be, for a value of enthusiasm between 0 and 500%, given the original, unenthusiastic string, this will aid my research greatly as i will not have to type out bulky scripts every time I wish to test my hypothesis.

so, the challenge:

write a full program or function, which, provided two arguments, a string of unknown length, and a number, in either integer format (between 0 and 500) or in decimal format (between 0 and 5, with 2 points of accuracy) will

  • return the original string, suffixed with a number of )'s
  • the number will be the calculated as a ratio of the input number to the string length.
  • so if the number 200, or 2.00 was provided, 200% of the string must be suffixed as )'s
  • the number of brackets rounded to in decimal situations does not matter.
  • script is required to support Printable ASCII characters.
  • only has to support one input number format, of your choice.


"codegolf" 125      = codegolf))))))))
"codegolf" 75       = codegolf))))))
"noob team omg" 0.5 = noob team omg))))))
"hi" 4.99           = hi!)))))))))))))))

example code (powershell) (with decimal input):

Function Get-RussianString ([string]$InputStr,[decimal]$Ratio){
    $StrLen = $InputStr.Length
    $SuffixCount = $StrLen * $Ratio
    $Suffix = [string]::New(")",$SuffixCount)
    return $InputStr + $Suffix

Get-RussianString "codegolf" 0.5

this is so shortest code wins!

This is my first challenge, any feedback is greatly appreciated.

  • \$\begingroup\$ Privyet tovarisch, but challenges on PPCG need an objective winning criterion (eg code-golf for shortest code) \$\endgroup\$ Jan 25, 2017 at 16:27
  • \$\begingroup\$ @TùxCräftîñg - apologies this is code-golf, I included a mention of it in the 'background' block shortest possible code i'll include the tag now though. \$\endgroup\$
    – colsw
    Jan 25, 2017 at 16:49
  • \$\begingroup\$ @AdmBorkBork the minimum character set would be that, full Cyrillic alphabet support would be ideal, but I decided to simplify that aspect as much as possible, I could change it to the full ASCII set or otherwise if you believe it would be of benefit? - i'll include space as a default charachter, and remove the ! in the examples for now though. \$\endgroup\$
    – colsw
    Jan 25, 2017 at 16:52
  • 1
    \$\begingroup\$ Restricting the input to "Printable ASCII" would probably be sufficient. \$\endgroup\$ Jan 25, 2017 at 16:58
  • \$\begingroup\$ If anything that's actually more understandable - i'll edit that in now, thanks! \$\endgroup\$
    – colsw
    Jan 25, 2017 at 17:00
  • 3
    \$\begingroup\$ Please edit the answer down to a hyperlink to the posted answer on the main site and delete it now that it is posted. \$\endgroup\$
    – mbomb007
    Feb 1, 2017 at 4:49

Animate the text in your terminal

The goal

The goal is to "animate" the string "Hello world" in your output so that each character gets capitalised after each other.

Your program can exit after each letter has been capitalised.

For example;

# Iteration 1
Hello world

# Iteration 2
hEllo world

# Iteration 3
heLlo world

# Iteration 4
helLo world

# Iteration 5
hellO world

# Iteration 5
hello world

# Iteration 6
hello World

# Iteration 7
hello wOrld

# Iteration 8
hello woRld

# Iteration 9
hello worLd

# Iteration 10
hello worlD


No input is required, but "Hello world" must be the string that is "animated".


The string "Hello world" must be animated. The output must be as 1 line to create a sort of wave animation. Example gif;


I saw this on a metasploit youtube video and thought the effect was pretty cool, which is where I recorded the gif from, so it's a little laggy, but I hope it illustrates the output fine

This is code-golf, lowest byte-count will be deemed the winner.

  • \$\begingroup\$ I think that you should make it that you take input and animate that. \$\endgroup\$ Jun 9, 2017 at 15:01

Packing Primes for Posterity


You've calculated which of the first n numbers are prime, and want to save your achievement for all future generations. Unfortunately, you're broke, and want to minimize storage costs (you'll be paying them forever, after all.)

You need to determine the best way to pack all of the primes <=n and still be able to answer the question "is p prime?" in O(1) time.


A submission to this challenge must include both a compress algorithm and an isPrime algorithm.


Input: n -- the number that you have checked prime-hood through.

Output: Bytes to feed into your isPrime algorithm.


Input: The output of your compression algorithm, and an integer i >= 0. i is guaranteed to be <= n.

Output: True if i is prime, otherwise False.

This algorithm must run in O(1).

The winner of this challenge is the (compression, isPrime) pair that is

  • Correct
  • Has the best compression ratio, as determined by the average compression ratio for

    n in {10^3, 10^4, 10^5, 10^6, 10^7, 10^8, 10^9}

as compared to the naive solution below.

Consider the following solution in Python:

def compress(n):
    # simple sieve of Eratosthenes. Note: this is not a 
    # prime generation challenge; a list of the first 
    # billion numbers will be provided in this format.
    primes = [1] * (n + 1)
    primes[0] = 0
    primes[1] = 0
    upper_bound = int(math.sqrt(n)) + 1
    for i in range(2, upper_bound):
        factor = i
        if not primes[factor]:
        factor += i
        while factor <= n:
            primes[factor] = 0
            factor += i
    primePackStr = ''.join(str(i) for i in primes)
    return primePackStr

def isPrime(compressed, i):
    return compressed[i] == '1'

Example Input and Output

Input to compress:




Input to isPrime:

("001101010001010001010", 13)




  • This is not a prime generation challenge. The compress executable can assume that there is a file called primes.txt in the same directory that contains the first billion numbers in the format s[i] = 1 if i is prime, 0 otherwise. (Zero-indexed)
  • Naturally, the isPrime executable cannot make use of this file.
  • The isPrime executable must not hardcode any primes.
  • Please provide instructions on how to compile/run your code on either OSX 10.12 or Ubuntu 16.04, if it's not obvious.
  • This is not a code golf challenge. Any length of code is fine, as long as isPrime doesn't attempt to cheat.

Notes for sandbox

  • I'll include a link to a downloadable primes.txt
  • Any thoughts on a better restriction than "The isPrime executable must not hardcode any primes?"
  • Should I test on random values of n instead?
  • thanks!
  • 1
    \$\begingroup\$ This is an interesting idea, and I hope it can be made to work, but it does have a big problem in the subtlety of what you mean by saying that isPrime must run in O(1) time. Interpreted with maximum pedantry, it's impossible because O(1) time isn't sufficient to read i from the input, even assuming random access to the input (which some key models of computation don't, and many interpreters won't give you). \$\endgroup\$ Mar 8, 2017 at 9:12
  • \$\begingroup\$ If you instead restrict answers to accessing a fixed (independent of n and of the length of the compressed text) number of bytes of the compressed text and doing a fixed (independent of n and i) amount of processing on them, you're pretty much killing the challenge because the only feasible compression will be bit-packing with a wheel and the competition will just be how big to make the wheel. \$\endgroup\$ Mar 8, 2017 at 9:12
  • \$\begingroup\$ In particular, a wheel size of 10^9 would trivialise the challenge. \$\endgroup\$ Mar 8, 2017 at 12:38
  • \$\begingroup\$ As far as your first comment goes, I could clarify to say that isPrime can assume that the entire output of compress is already in memory - or that isPrime may be called many times, with different i but the same compressed and it only has to be amortized O(1). Unfortunately, you're totally right about the prime wheel - though the idea is that the algorithm would work for arbitrary values of n, not just up to 10^9. \$\endgroup\$ Mar 8, 2017 at 14:34
  • \$\begingroup\$ Maybe I could entirely remove the isPrime in O(1) restriction and simply make this a challenge about the most efficient compression algorithm for prime numbers. (Allowing arbitrary compression.) @PeterTaylor \$\endgroup\$ Mar 8, 2017 at 14:34
  • \$\begingroup\$ If you do that then everyone will compress the list to 0 bytes unless you fix the decompression. A variant which might work is to ditch isPrime and say that the output of compress will be passed through zcat | sort -n so that the challenge is finding a good ordering of the primes which exploits Lempel-Ziv behaviour. \$\endgroup\$ Mar 8, 2017 at 14:45
  • \$\begingroup\$ That might be interesting, though I'd need to add some sort of polynomial time restriction - you could theoretically test all O((n/(log n))!) orderings of primes <= n otherwise. I'm going to abandon this for now, but may come back eventually if I have an epiphany. Thanks for your help! \$\endgroup\$ Mar 8, 2017 at 14:56
  • \$\begingroup\$ This is a really interesting idea, and I hope you can come up with a way to make it work successfully. \$\endgroup\$ Mar 8, 2017 at 21:00

Challenge about loudly interjecting in a courtroom

One of the most important things about being a courtroom lawyer is loudly interjecting before you make your point. In this challenge, we're going to edit a typical courtroom transcript to include these interjections.

Any lawyer (and in fact, any character at all in the transcript), uses these rules to interject:

  1. Use an interjection when the character who is speaking changes to you.

Take the following example:

SAHWIT: I remember the time I found the body exactly.
SAHWIT: It was 1 P.M.
PHOENIX: Frankly, I find that hard to believe!
PHOENIX: Your statement directly contradicts the autopsy report.

There is one change in speaker, so an interjection will be added in at that point like this:

SAHWIT: I remember the time I found the body exactly.
SAHWIT: It was 1 P.M.
PHOENIX: Hold it! Frankly, I find that hard to believe!
PHOENIX: Your statement directly contradicts the autopsy report.
  1. Use Hold it! if the previous statement ends with a single full-stop or exclamation mark, Take that! if the previous statement ends with an elipses (...), and Objection! if the previous statement ends with a question mark.

For instance:

JUDGE: What evidence proves the clock is running slow?
PHOENIX: The victim had just returned from abroad the day before the murder.
PHOENIX: The time difference between here and Paris is 9 hours!
PAYNE: But modern day clocks automatically adjust for time zones...
PHOENIX: This is an antique!


JUDGE: What evidence proves the clock is running slow?
PHOENIX: Objection! The victim had just returned from abroad the day before the murder.
PHOENIX: The time difference between here and Paris is 9 hours!
PAYNE: Hold it! But modern day clocks automatically adjust for time zones...
PHOENIX: Take that! This is an antique!

That's about it. I'll write some longer test cases a bit later. This challenge is probably Retina-bait to be honest.

  • \$\begingroup\$ This challenge might work better if the interjections made more sense in context. For example, "Objection!" likely works best after questions (as most objections in an actual court case are to try to invalidate a question that fails to follow the rules). \$\endgroup\$
    – user62131
    Mar 14, 2017 at 4:35

Normal quine, weird quine

Note: This Sandbox entry has a fairly long history, and is basically an attempt to produce a challenge inspired by this comment, but that's immune to wilful misinterpretation (or misunderstanding) of what counts as an error in order to trivialise the question.


In the world of programming languages, there are lots of different ways to produce output on the usual output streams. Most languages have a way to print a string intentionally, called print, write, or something like that. Sometimes you can even just leave a value to be printed implicitly. Most languages also have situations in which the implementation interjects with its own output, e.g. warnings produced during the compile. We'll call this weird output.


For each method of output to standard output or standard error in a programming language, consider how much of that output is under the programmer's control and thus can contain arbitrary text (e.g. specified as a parameter, part of the program's filename, taken from a variable that can be assigned to, or the like), as opposed to being a single possibility (or a finite set of possibilities) hardcoded into the interpreter. We'll call this output method normal if no more than 3 bytes are outside the programmer's control; and weird if there are 4 or more hardcoded bytes that the programmer cannot control.

In this challenge, you need to write a full program that's a variant, obeying the proper quine rules. Specifically, after performing the entire process of building and running the program (i.e. if there's a separate compile step required, its output counts too):

  • All the output produced on standard output and standard error via normal output methods must be identical to the program's source code;
  • All the output produced on standard output and standard error via weird output methods must also, separately, be identical to the program's source code.

In other words, the program is a quine in two different ways. You can think of this as being a quine that's also an error quine (also known as a "Kimian quine"), except that the notion of "error" is restricted in order to avoid abuse (mechanisms which would let the program provide an arbitrary "error message" count as normal output, not weird output, on the above definition), but generalized to allow things like warnings, banners that the implementation prints as it loads, and other weird ways to produce output.


  • For the purpose of the proper quine definition, the fixed part of the output that's inherent in a weird output method is considered to not be encoded by the corresponding part of the program (even if that part of the program causes an error). As such, only the normal part of the quine can fail to be a proper quine.
  • PPCG doesn't normally count output that's inherent to an implementation (such as compiler progress messages and fixed banners). This challenge is about handling that sort of thing, though, so such output is definitely relevant here (in addition to everything else on the standard output and error streams).
  • Unlike in many challenges, the switches given to the compiler, and the program filename, are likely to be highly relevant in this challenge. Using an unusual build configuration may well be required to make the challenge possible, and as such is legal here; however, if you run the implementation in an unusual way, remember that PPCG rules charge a byte penalty for doing so (equal to the number of additional characters that you'd need to add on the command line over the shortest "normal" way to run a program), and thus you'll need to specify the size of the penalty in your post. (For example, if the interpreter you're using reads the program from a file, and has no particular restrictions on the filename, the shortest normal way to run the program would be from a file with a 1-character filename; thus, if you need a 100-character filename to make your program work, you'd incur a byte penalty of +99.)
  • The compiler/interpreter version you use may well be relevant, so as part of your submission, please state a specific compiler or interpreter on which your program works, and which version is required. (For example, a C submission might state "C (gcc 6.2.0)" in the header.)
  • Note that this task may not be possible in all languages. In the languages where it is, the easiest method will likely be to find an error or warning message for which it's possible to customize some subset of the text (via changing the name of something that gets quoted in the message; filenames are a common choice here, but not the only one). Obviously, if you could customize the entire thing, it wouldn't be weird output and thus wouldn't work. I'll be particularly impressed (and surprised) if someone finds a way to do this using only error and warning messages whose text is entirely fixed.

Victory condition

This is a challenge, so an entry is considered to be better if it has a smaller byte count. As such, once you've got your program working at all, you want to optimize it to bring the number of bytes down as far as possible. (However, don't be discouraged if there's already a shorter entry, especially if it's in a different language; what we're really looking for here is to shorten a particular algorithm or idea behind a program as much as possible, but seeing multiple solutions in different languages or that rely on different principles is always worthwhile.)

Sandbox questions

This was moved here from main because many answerers seemed to disagree with everyone else as to what an error message was.

I've aimed to avoid the problem in this rewrite by focusing not on what is and isn't an error message, but rather on the amount of hardcoded content in the message. Is this likely to be interpreted the same way by everyone? Is it objective?

Also, should I edit the original challenge, or should I post it as a new challenge? Out of the two non-deleted answers, one will stay valid (although the explanation will end up somewhat out of context), the other will need to be deleted (although I consider it to be invalid under the original specification too, and thus arguably no changes are being made to which answers are correct).


Garbled Phone Numbers


You know how you get a voicemail message and the person's connection wasn't great, and you're trying to figure out how to call them back, but you're not sure if that was a "5" or an "8" they said?

That's this challenge.

The good news is that the caller read off their number twice, but it's garbled in both places.

Your program should take input like this:

5551231234 / 5551231234

Where the first seven digits are the first time the phone number is said in the voice mail and the second set are the second time it's said. Only...it'll look more like this:

555?AAA1_36? / 55?522_1?234

A digit followed by a question mark means that that's the best-guess for that digit (e.g. "5?" means "probably a 5, compare with repeat"). An underscore indicates a known missing digit, something too fuzzed by static to be deciphered at all. Letters are just that: letters. Treat them as their respective digits (ABC -> 2, DEF ->3, HIJ -> 4, etc).

You can safely assume the following judgement calls:

5? / _     -> 5  //5 is the best guess we have, use it
5? / 4?    -> ?  //conflict
 5 / 4     -> ?  //conflict
5? / 4     -> 4  //solid information overrides possible value
 5 / 4?    -> 5  //solid information overrides possible value
 _ / _     -> ?  //no information available

Additionally you can assume that all inputs will contain ten-digit phone numbers, not including the question marks. Inputs that aren't ten digits (e.g. 1234567 / 1234567) can either be treated as unsolvable (falsey output) or throw an error.

Output option A: Output a truthy value indicating whether or not a given input can be resolved to a single valid ten-digit phone number.

Output option B: If it can be parsed to a single valid ten-digit phone number, output the phone number. Otherwise output some form of error indication (e.g. -1, false, empty line).

Shortest wins, as per usual.

[Sample inputs]

  • \$\begingroup\$ I'm not sure what your intended meaning for letters is. If it's just A=1,B=2,C=3... then they're a bit pointless and weird in this context. You should also probably choose only one between option A and option B before posting (I vote for B). \$\endgroup\$
    – Leo
    Apr 9, 2017 at 16:39
  • \$\begingroup\$ @Leo Letters as they appear on a dial pad: A,B,C = 1, DEF = 2, GHI = 3, etc. \$\endgroup\$ Apr 9, 2017 at 21:05
  • 2
    \$\begingroup\$ You need an explicit mapping for letter→number. Most phones I've seen map A/B/C to 2 (apparently they follow this international standard). \$\endgroup\$
    – user62131
    Apr 9, 2017 at 22:07
  • \$\begingroup\$ @ais523 Whoops, that's what I get for posting late at night just before bed, then making the comment gia tablet at a rest stop somewhere in western Pennsylvania, 6 hours from home. \$\endgroup\$ Apr 10, 2017 at 4:43
  • \$\begingroup\$ I think you should omit 'output option A' and just keep B; B includes A pretty much. \$\endgroup\$ Apr 10, 2017 at 9:36
  • \$\begingroup\$ @officialaimm I think that's the beret idea, yes. There were a mess of ideas running around in my head, such as scoring based on a given input list, but never congealed well enough to make it to paper. A and B were the only two that did. \$\endgroup\$ Apr 10, 2017 at 12:18
  • \$\begingroup\$ Any other comments before I start generating some inputs and posting it? \$\endgroup\$ Apr 17, 2017 at 19:46

Write a "21" game in exactly 21 characters


You must write a program which implements the following algorithm:

Let x = 0
Let y = truthy value
while (y is not falsy AND x <= 21) do:
  Let x = x + a uniform random number from {1,2,3,...,11}
  Output the value of x
  Input a value of y from the user (you may assume input is valid)
Output the value of x

(You do not have to follow the pseudocode exactly. For example, if your language happens to initialise variables to a truthy value automatically, you don't have to include the y:=TRUE line. Similarly, you don't have to use a while loop. The important thing is that it repeatedly takes user input until either x exceeds 21 or the user chooses to stop, and it outputs the current value of x after each user input.)


Let n be the length of the shortest program which meets the spec which can be obtained by deleting 0 or more characters from your code. Then your score is:

- 500            if n > 21
- 1 + (n-21)^2   if n < 21

The winner in each language is the program with the lowest score.


  • Is this a resonable idea? I can't find similar challenges, so maybe there is a problem with ones like this? (Trivial solutions etc.)
  • Is the specification too complicated (maybe more languages could enter if it was a simpler algorithm, for example just taking user input once?)
  • \$\begingroup\$ This victory condition is code-shuffleboard. I don't think it adds much over just doing golf, though; it's normally fairly easy to pad out a program in a way that can't be fooled via simple character deletion. (Also, I suspect 21 characters isn't enough in most languages, although golfing languages should be able to beat that; it'll be interesting to see whether some of the terser practical languages can.) \$\endgroup\$
    – user62131
    Apr 11, 2017 at 12:31

Tetris Programming

The Task

Your program or function should take as input one character from the set IJLOSTZ, which represents one of the seven tetrominos as usual:

I  J   L   O   S    T    Z

#   #  #   ##   ##  ###  ##
#   #  #   ##  ##    #    ## 
#  ##  ##

You should output the number of shapes which are equivalent to this tetromino up to rotation. For example, the I only has two arrangements, horizontal and vertical, whereas the J has four different orientations. The O looks the same no matter how you rotate it, so there's only one shape. Here all possible input/output pairs:

I  2
J  4
L  4
O  1
S  2
T  4
Z  2

The Source Code

The main part of this challenge is the source code restriction:

  • You may choose either linefeeds (LF, 0x0A), carriage returns (CR, 0x0D) or LR-CR pairs to represent newlines in your code (consistently). These split the source code into a 2D grid of lines (which aren't necessarily the same length).
  • This 2D grid must be completely made up of tetrominos where all 4 characters in each tetromino must be the same. For example, this would be a valid program:


    Note that the individual characters don't necessarily need to be distinct, so there may be larger connected regions of the same character, as long as this region can be segmented into non-overlapping tetrominos. Also note that this restriction also applies to spaces, so the following is not a valid program, because the two spaces don't form a tetromino.:


The Score

For each of the seven tetrominos count how often it appears in your source code. Your score is the maximum of these seven values.

That means you don't want to make up your code entirely of Is but instead try to use about the same number of each of them to keep the maximum of the seven values down.

The Small Print

You may either write a programs or a functions and use any of the standard methods of receiving input and providing output, as usual. Note that these loopholes are forbidden by default.

  • \$\begingroup\$ It strikes me that most solutions are going to put most of the code in a comment, and it wouldn't surprise me if a score of 1 were achievable in some languages. Do you consider that reasonable? \$\endgroup\$
    – user62131
    May 5, 2017 at 12:25
  • \$\begingroup\$ @ais523 I'm not sure about the task yet. It's hard to find something that isn't too hard for the restriction to become a pain but that is intricate enough to allow people to use several parts of a tetromino. \$\endgroup\$ May 5, 2017 at 14:25

So I've been puzzling over the best way to present this idea I had, so this will probably need a lot of help. I am open to completely reworking the challenge, but this is the best polish I've managed to figure out so far.

At work I have to secure my laptop with one of those 4-digit cable locks and it occurred to me that there was a puzzle here: figuring out the combination by looking at the typical behavior of setting the lock: never allowing any given wheel to "rest" on its unlocked value. e.g. if the combination is 1234 then never walking away with a 1 in the first position, a 2 in the second, and so on (e.g. 1111 would not be considered locked, but 2111 would be). Or possibly by not letting any digit of the unlocked combination be visible (so even 2111 would be "bad" but 6789 would be ok...unless a transpose was also considered to be insufficiently random, however such choices are often up to the user of the lock). I also subsequently changed my behavior (not that I have any real risk of my laptop being stolen).

A standard challenge of "write some code that examines a series of locked values to determine the unlocked value, scoring by number of entries needed" is non-viable, as the sequence list would need to be carefully chosen such that there is a strictly known optimal solution (i.e. a minimum number of locked values), as finding a shortcut in that specific sequence might be possible, but invalid on another sequence.

Then the other night it occurred to me that it might be possible to do this as : one side has to randomize their locks (albeit following a set of rules that allows exploitation), the other side has to break them open. The downside being that it will be a nightmare to validate scores as there will be no easy way to pipe input and output back and forth between two programs running arbitrary languages.

I'm also not sure if there's enough room for freedom in designing the lock randomization code (i.e. interesting for the cop) for it to be plausibly crackable without resorting to brute force (an uninteresting challenge for the robber). Ostensibly the robber half is brute force, but it's guided in some manner towards a determinable value ("ah, I see, the first spindle is never set to 1 when locked, ergo the first digit in the code must be a 1) rather than indeterminate ("ah, I see, no spindle is ever set to 1, ergo there is a 1 somewhere in the code" -> 4 digits ^ 4 spindles -> 256 plausible values with further attempts gaining no new information).

Combination Locks (Cops)

8585: Locked

Your goal is to write a program that produces a 4 digit random number as a combination lock entry code. Your program needs to keep this value a secret, but must produce output that is the result of the lock being locked and its tumblers spun, the value printed being the digits shown along the set row (8585 in the above image).

Your program will then take input of a 4 digit code that is an attempt to unlock the lock. If it is the correct value, output the number of attempts made and the seed value, otherwise print another randomized lock value. Repeat until successfully unlocked.


  • Your program must have some way of setting the combination (for scoring), eg. providing a seed value for the random number generator (inputting the correct combination is allowed).
  • All locked combinations must be considered random. However:
  • The nature of "random" is what is to be exploited here. Obviously you wouldn't want your random lock to actually remain unlocked after shuffling the dials!
  • You may chose any rules by which to keep the lock locked, provided that it can be exploited. No outputting 0000 every iteration or cycling between predetermined sets (1234,4567,7890,1234). You're trying to emulate what appears to be smart behavior of a human being, not create an unbreakable lock.
  • Every digit from 0-9 should be possible with some degree of uniformity. That is, if the correct combination is 1234 you are allowed to prevent 1 from showing up as the fist digit, but you may not prevent 1 from showing up in other positions.
    • Blanket removal of all four digits of the combination from all four columns reduces the problem to brute forcing 256 possible combinations.
    • Similarly, allowing a ban on a digit for up to three columns reduces it to brute force against 3136 possible combinations (banning only the combination digits from 3 columns is 81 possible combinations). None of these are interesting challenges.
    • Entries shown to devolve to a brute force guessing will score based on the worst-case lucky guess (i.e. the number of attempts needed to identify the brute-force point, +1).
  • If your language does not have a way to "wait for input" then....??? (requirements for fixed-seed randomness across multiple attempts, e.g. for a given combination and the same number of attempts made, the next output should be the same)
  • Your program should store no data about attempts to break the lock or prior output values, the only data that may be stored are the Random instance (if needed), the correct combination, and number of attempts made. Outputting an attempt value back out (intentionally) would be underhanded.


The ratio of your code's byte-length to the best (lowest) number of attempts needed by any robber against your lock.

Combination Locks (Robbers)

8585: Locked

Your goal is to exploit the non-pure-random nature of locked 4 digit combination lock. After all, no one leaves a portion of the correct code in the lock after they shuffle the wheels!

You are to write a program that attempts to deduce the correct combination for a given lock, given only a series of locked (incorrect) combinations. Your program will read a single 4 digit number as the current state of the lock and produce a 4 digit number output as an attempt to unlock the lock. If additional input is given, the attempt was unsuccessful. Your program need not self-terminate (i.e. there is no requirement to take input telling your program that it was successful; ctrl-C interrupt is succificient).

As you are an accomplished thief, you know exactly how each lock gets randomized. You are to exploit the built-in rules to bypass the lock in the fewest number of attempts by looking for patterns in the lock's "output" and narrowing down the list of possible correct combinations.

  • Locks will have a way to predetermine their combination (e.g. random seed or specific 4 digit combination). Your program may not know these values, they are used for scoring only. Remember the standard loopholes: hardcoding the output is disallowed.
  • If a human is unable to find the solution with the data known at that the point of solving, the number of attempts will not count for scoring as it can be considered a lucky guess (arbitrary threshold: 10 or fewer attempts will be automatically assumed as such). This should be treated like a logic puzzle, not a slot machine.
  • If your language of choice doesn't do "programs" it is acceptable to write a function taking in an array of inputs [XXXX, AAAA, XXXX, BBBB, XXXX] (where XXXX represents the combinations displayed on the lock, and AAAA/BBBB represents the prior attempts made) or similar. Note that there will be one more value from the lock than values from attempts, as your function would be producing the paired half as its output.
    • Supplementary output to support ease of alternative input methods acceptable (e.g. a newline followed by the input array for the next iteration to be copy-pasted).


The ratio of your code's byte-length to the best (lowest) number of attempts needed top open any lock.

  • \$\begingroup\$ @Ilikemydog I browsed other cops and robbers questions while writing, scoring did not seem unusual. This one has scoring, so does this one, and this one calls for short code (typical scoring method), while this one scores based on number of different cops entries cracked. However, that's not my main concern, "I'm also not sure if there's enough room for freedom in designing a lock.." \$\endgroup\$ May 28, 2017 at 18:06
  • \$\begingroup\$ never mind then. I'll delete the comment. I'd like to give you some more feedback but I didn't follow some of it (mfny) and all I can say is have a +1 \$\endgroup\$ May 28, 2017 at 18:11
  • \$\begingroup\$ No feedback, except I've had this exact thought that a code could be guessed by tracking where the lock was left set to when it was locked over time. Similar idea, but you actually fleshed it out. \$\endgroup\$
    – BLT
    Mar 11, 2018 at 19:48
  • \$\begingroup\$ @BLT That was pretty much where I'd been approaching from. Still not sure there's a good code challenge here, though. :\ Thanks for the look over! \$\endgroup\$ Mar 12, 2018 at 3:15

Wasn't able to find anything in my searches, but please let me know if this or something very similar has been done before. Appreciate any feedback, first post in sandbox.

Can I leave yet?

I'm bored at work, and want to know how close I am to being able to go home. To represent this, I wish to know what percentage of work I have completed for the day.


None - Current local/computer time shall be used


Percentage of work completed for this day

  • Formatted as either a percentage value or a decimal value: 0.57, .57, 57%, 57.0%
  • Output should be accurate to at least +/-0.5%. Additional accuracy/digits are allowed.
  • The work day is a total of 8 hours.
  • Work starts at 08:00, and ends at 17:00.
  • Lunch is between 12:00 and 13:00. Working during lunch is forbidden, and thus should not count towards the percentage of work completed.
  • Output should be correct during any time of day, including before work starts (0%) and after the work day ends (100%).

The response for a full 24 hour day is shown below:


Valid Test Cases

Time Ran     Output
03:55        0%
04:31        0.000
08:00        0
09:00        12.5%
11:31        44%
12:37        .5
16:30        0.94
21:08        100%

Incorrect Test Cases

09:00        12.5     (Interpreted as 1250%
11:31        43%      (Error of 0.9%)
12:37        .58      (Did not account for lunch)
16:30        0.9      (Error of 3.8%)


  • I work 7 days a week 365 days a year; you do not need to check if it's a weekend, holiday, etc.
  • I live in an area with no Daylight Savings Time, Leap Seconds, or any other confusing time-changing events.

This is , so lowest byte-count score wins.

  • \$\begingroup\$ Does no feedback mean it's perfect the way it is and I should post it? Or it's so bad that nobody wants to touch it? \$\endgroup\$
    – qoou
    May 24, 2017 at 16:08
  • 1
    \$\begingroup\$ I think it's pretty solid. \$\endgroup\$ Jun 20, 2017 at 14:57

Bitcoin Trading


This is mainly an idea for something I could potentially host on my KOTH server.

Everybody knows that bitcoins are the next big thing. It's just a question of when they are going to take off. Right now, they are worth $250 each, but who knows, maybe someday they will be worth over $1000! The growth trend is phenomenal.

You are a tech-savvy investor who wants to get in on this action.

The Challenge

Your goal is to write a bot that can predict the market and tell you how you should invest your money, given hourly updates of the Bitcoin price.

Keeping Balance

To overcome the fastest-gun-in-the-west effect, wherein early answers have more time to make more money, this challenge will not keep track of any absolute balances. Instead, the assets of each entrant will be scaled up/down between each round.

Each entrant will be given a single float in the range 0 to 1 representing the percent of total assets are currently invested in Bitcoin. This is calculated by (BTC_cur_rate*BTC_owned)/(USD_owned + BTC_cur_rate*BTC_owned).

A value of 0 means that you currently have nothing invested in Bitcoin, while a value of 1 means that you have everything invested in Bitcoin. An input of 0.3 means that 30% of your total value is in Bitcoin, while the other 70% of your value is in dollars.


input    ->    assets as portion of your total value
                 BTC     %      USD     %
 0.0     ->      0.0    0%      1.0  100%
 0.3     ->      0.3   30%      0.7   70%
 0.6     ->      0.6   60%      0.4   40%

Price Data

Players will also have access to a file history.txt which will contain the BTC price history, measured in cents, over the duration of the competition. Each time a player is called, they are presented with a fresh copy of history.txt, with one line appended each turn. Do not attempt to modify this file.

Example File

This could be the history.txt file after 3 hours of competition. The most recent price is $247.49.


There will be a trailing newline at the end of the file.

Making a Trade (ouput)

The output of your program should be another float in the range of 0 to 1, representing the new portion of your assets that you want invested in Bitcoin. The difference between your input number and output number represent the amount of value being exchanged.


input -> BTC USD  |  output -> BTC USD  |  trade being made
 0.3  -> 0.3 0.7  |   0.2   -> 0.2 0.8  |  0.1 in BTC -> 0.1 in USD
 0.3  -> 0.3 0.7  |   0.6   -> 0.6 0.4  |  0.3 in USD -> 0.3 in BTC

Calculating Score for a Round

Your score for a round is based on your change of value for that round. You start every round with a total value of 1, but your ending value is influenced by two things:

  • A 0.2% commission on your trade taken by the controller
  • The change in Bitcoin value over the next hour

Taking Commission

Commission is taken whenever you buy or sell bitcoins. Whenever you convert a certain amount of value from one currency to the other, you will receive 0.2% less of the new currency than what you actually ordered.


input  |  output  |    trade     |  commission  |  result after commission
 0.3   |   0.6    |  0.3 -> BTC  |  0.0006 BTC  |  0.5994 BTC & 0.4 USD
 0.75  |   0.05   |  0.7 -> USD  |  0.0014 USD  |  0.05 BTC & 0.9486 USD

Adjusting BTC Value

After taking commission, your value of BTC is multiplied by the price percent change in BTC over the next hour. The amount of value you have in USD will stay constant.


BTC after commission  |  prices in cents  |  % change  |  new BTC value
         0.5          |  30000 -> 29850   |   -0.5%    |    0.4975
         0.236        |  20000 -> 30447   |   +2.0%    |    0.24072

Overall Process of a Round

Below is an example showing all of the steps in a single round.

.3     .7  = 1.0      input to entrant is 0.3
.6     .4  = 1.0      output of entrant is 0.6
.0006  .0             0.2% commission of the trade
.5994  .4  = 0.9994   result after commission
+0.3%                 percent change in bitcoin price over 1 hour
.6012  .4  = 1.0012   result after the flow of time = score for that round
.60048 .39952 = 1     input for the next round is 0.60048 after scaling

Determining the Winner

For a given round, your score is your new total value. This is after taking the 0.2% commission and calculating the change in Bitcoin value. For the above example, the score was about 1.0012.

At any given time, the aggregate score for an entrant shall be the product of the scores for its most recent (up to) 50 rounds. At any given time, the current winner is the player with the highest aggregate score.

For example, a bot could get these scores for its first 5 rounds: 1.001 1.002 0.998 0.999 1.003. The total score of the bot is about 1.00299.

The Controller

I haven't written the controller yet, but I think it's going to be written in Perl with support for entrants in a variety of other languages (Java/Python/Ruby/C++).

I plan to use this API for bitcoin price data.

The controller will probably run all of the entrants in parallel, each with their own thread. This simply allows it to put a stop to any infinite looping that may occur. I hope it will work if all of the programs are reading the same history file at once.

Additional Rules

Since this is a PvE competition and not a PvP competition, and takes place on a server, there are some slight differences in rules.

  • There's no set restriction on submitting multiple bots, since you can't make a team.
  • Similar to always, you can't call other programs, like the controller or other bots, during your turn.
  • The time limit is loose. A long as a single round with all of the bots doesn't take up most of an hour to perform, it'll be fine. It really shouldn't take more than a couple minutes for each bot to make a move.
  • You may create a single file, with the filename [botname]-data.txt, in the current directory. This file will persist, even across updates of your bot or the controller.
  • \$\begingroup\$ 1. What determines whether the commission is taken in bitcoin, dollars, or some mixture of the two? 2. What is the score of a round? (It's mentioned in the example, but it needs to be more prominent). 3. Is there any input other than the balance? Or are entries allowed to access external data sources? Or is it pure uninformed guessing? \$\endgroup\$ Oct 11, 2015 at 20:09
  • \$\begingroup\$ @PeterTaylor I've added some details. I'm not completely decided on how much data the entrants will be able to access/store. Right now it is just the price history. \$\endgroup\$
    – PhiNotPi
    Oct 11, 2015 at 23:41
  • \$\begingroup\$ Do you have access to Mathematica? Also, how precise are the input and output? \$\endgroup\$ Oct 16, 2015 at 1:04
  • 1
    \$\begingroup\$ How much of your assets are in BC to start with? \$\endgroup\$ Oct 21, 2015 at 23:59
  • \$\begingroup\$ IT'S 2016 AND PHINOTPHI STILL HASN'T... /s \$\endgroup\$ Dec 12, 2016 at 2:29

Raindrops are falling on my... glasses?

  • \$\begingroup\$ So a minimum of 216 seconds runtime? Note that TIO times out after 60 seconds. \$\endgroup\$
    – Adám
    May 21, 2017 at 15:36
  • \$\begingroup\$ How many newlines are "enough"? May we assume a 5-lines screen? \$\endgroup\$
    – Adám
    May 21, 2017 at 15:36
  • \$\begingroup\$ @Adám is there anything you like in this post? And however large your screen is. If you want to reduce the size of the screen, feel free. \$\endgroup\$ May 21, 2017 at 15:39
  • \$\begingroup\$ Don't get me wrong. This challenge is good. It just needed so tightening up. That's what the sandbox is for. Better get constructive criticism here than downvotes on the main site. \$\endgroup\$
    – Adám
    May 21, 2017 at 15:40
  • \$\begingroup\$ So, if one can choose screen size you may as well just specify that glasses (if not changed in-place or the screen is cleared) must be separated by a FormFeed or one or more newlines. \$\endgroup\$
    – Adám
    May 21, 2017 at 15:43
  • \$\begingroup\$ What about cursor movement with terminfo (like \e[10D\e[2A to move 10 spaces left and 2 lines up)? The solution would only work in the terminal, but there it would certainly look as if the image stays the same (and would look way better than other approaches). Is this allowed? \$\endgroup\$
    – eush77
    May 21, 2017 at 20:40
  • \$\begingroup\$ @eush77 sure why not? \$\endgroup\$ May 21, 2017 at 20:41
  • \$\begingroup\$ @RandomUser I guess it was just not clear to me from the statement. \$\endgroup\$
    – eush77
    May 21, 2017 at 20:46
  • \$\begingroup\$ What do you expect to happen when almost every space is at @ but some are at O? Locations are still chosen totally randomly, so the visible effect will be that almost nothing is happening? \$\endgroup\$ May 22, 2017 at 6:43
  • \$\begingroup\$ @SteveBennett yes. It's an unfortunate side effect \$\endgroup\$ May 22, 2017 at 6:46
  • \$\begingroup\$ You could change the behaviour so that rain never lands on @'s, although it's hard to implement this in a way that doesn't verge on infinite loops. \$\endgroup\$ May 22, 2017 at 6:50

The alphabet - my way

Your pointy-haired boss gives you a list of words and tells you to sort them. So you give him back a sorted list. "Wrong!" he says. "I want them sorted according to MY alphabet..."


Given a new ordering of the alphabet and a list of words, sort the words according to that new alphabet ordering.

The new ordering is given as a 26-character string, guaranteed to contain all letter of the alphabet exactly once, in lower case.

All words in the list of words will be made up of lower case letters only -- no capital letters or punctuation. There will be no repeat words.

If there is a word in the list that is the prefix of another word, then the shorter (prefix) word should appear first in the sorting. For example, "golf" should appear before "golfing".


Example 1





Example 2





Example 3




  • \$\begingroup\$ Shouldn't pluto/plutonium be before polonium \$\endgroup\$
    – ASCII-only
    May 29, 2017 at 11:26
  • \$\begingroup\$ No, because 'o' comes before 'l' in that alphabet. Just like when you alphabetise using the standard alphabet, ties are broken by the alphabetical rank of subsequent letters. \$\endgroup\$ May 29, 2017 at 11:42
  • \$\begingroup\$ Oh wait read polonium wrong sorry \$\endgroup\$
    – ASCII-only
    May 29, 2017 at 11:43

Print a shuffled deck of cards

  • \$\begingroup\$ What prevents me from outputting the cards in the same order every time? It's hard to specify randomness, as we've seen in other meta posts. You could say "I will run your program 100 times; no two outputs should be identical" since the probability of this happening is miniscule if the output is truly randomized. \$\endgroup\$ Jun 2, 2017 at 23:05
  • \$\begingroup\$ I believe "all permutations must have an equal opportunity of being chosen" is what is usually used. \$\endgroup\$ Jun 3, 2017 at 0:57
  • 2
    \$\begingroup\$ I don't think having to output the Unicode card characters adds anything to the challenge and the answers (except for bytes...). \$\endgroup\$ Jun 3, 2017 at 0:58
  • \$\begingroup\$ All I see in my browser is a bunch of rectangles with diagonals. \$\endgroup\$
    – Dennis
    Jun 3, 2017 at 21:30
  • \$\begingroup\$ @Dennis Install the Noto fonts. \$\endgroup\$
    – anna328p
    Jun 4, 2017 at 1:09
  • \$\begingroup\$ "all permutations must have an equal opportunity of being chosen" is actually EXTREMELY difficult, the random number generators of most languages aren't up to that -- even making sure every combination can come up is quite tricky as you need 225 bits of randomness. \$\endgroup\$ Jun 4, 2017 at 21:15
  • \$\begingroup\$ @programmer5000 It's already only a title \$\endgroup\$
    – anna328p
    Aug 1, 2017 at 23:30
  • 1
    \$\begingroup\$ It should still be deleted. \$\endgroup\$ Aug 10, 2017 at 20:59
30 31
33 34

You must log in to answer this question.

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