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".


4636 Answers 4636

57 58
60 61

Minimize Your Code's SHA-256 Hash

Write a program or function that outputs its own SHA-256 hash as a hex digest. The winner will be the program with the smallest output (when interpreted as a hexadecimal integer).


  • Accessing the program/function's source code is allowed (a la cheating quines).
  • The output must be in hexadecimal, optionally padded with zeros to 64 hex digits.

Example (Python 2)

import hashlib
print hashlib.sha256(open(__file__).read()).hexdigest()

Ideone link


  • \$\begingroup\$ What's the tie-breaker (or real scoring criterion)? Most languages which can do the challenge should be able to score 0 on the current criterion using a 9-year-old attack on MD5. (Alternative: change it to use SHA). \$\endgroup\$ Nov 29, 2016 at 9:02
  • \$\begingroup\$ @PeterTaylor Fair point. I'll change it to SHA-256. The tie-breaker is earliest submission to achieve the score, as is default. \$\endgroup\$
    – user45941
    Nov 29, 2016 at 9:03
  • 2
    \$\begingroup\$ Will this turn into a brute force competition by changing a single letter to find the lowest hash? \$\endgroup\$
    – Angs
    Nov 29, 2016 at 17:55
  • \$\begingroup\$ @Angs Though that is one strategy, I don't expect it to be the most fruitful strategy. \$\endgroup\$
    – user45941
    Nov 29, 2016 at 19:36
  • 2
    \$\begingroup\$ I'm pretty sure this is just a brute-force competition. I don't see any reason why changing the coding part of the program would help, so you'd just brute-force the content of a comment needed to minimize the hash value. As such, I don't think it's an interesting problem. (Even requiring proper-quine rules wouldn't help; people would just use a string literal instead.) \$\endgroup\$
    – user62131
    Nov 30, 2016 at 0:30
  • \$\begingroup\$ @ais523 Do you think that a maximum byte count (like 256 bytes) and proper quine rules would help? \$\endgroup\$
    – user45941
    Nov 30, 2016 at 0:35
  • \$\begingroup\$ No. 256 bytes is easily enough to add in a fairly long comment or string literal alongside the program, and proper quine rules would simply disqualify languages where proper quines are long, whilst not otherwise affecting things. \$\endgroup\$
    – user62131
    Nov 30, 2016 at 0:41
  • \$\begingroup\$ @ais523 I'm interested in salvaging this idea, so if you have any suggestions for improving it, I'd love to hear them. \$\endgroup\$
    – user45941
    Nov 30, 2016 at 0:41
  • \$\begingroup\$ The only thing I can think of is code-golf with the hash as the tiebreak; code-golf naturally prevents people using unnecessary characters, so it would come down to picking whichever of equivalent versions of the program had the lowest hash. \$\endgroup\$
    – user62131
    Nov 30, 2016 at 0:48
  • \$\begingroup\$ @ais523 That's not a good idea. Besides, it would be a duplicate of the current SHA-256 code golf challenge. \$\endgroup\$
    – user45941
    Nov 30, 2016 at 3:37

Shooting range

Print/output this exact text:

                  / \
                 / _ \
                / / \ \
               / / _ \ \
              / / / \ \ \
             / / / _ \ \ \
            / / / / \ \ \ \
           / / / / _ \ \ \ \
          / / / / / \ \ \ \ \
         / / / / / _ \ \ \ \ \
        / / / / / / \ \ \ \ \ \
       / / / / / / _ \ \ \ \ \ \
      / / / / / / / \ \ \ \ \ \ \
     / / / / / / / _ \ \ \ \ \ \ \
    / / / / / / / / \ \ \ \ \ \ \ \
   / / / / / / / / _ \ \ \ \ \ \ \ \
  / / / / / / / / / \ \ \ \ \ \ \ \ \
 / / / / / / / / / _ \ \ \ \ \ \ \ \ \
/ / / / / / / / / / \ \ \ \ \ \ \ \ \ \
| | | | | | | | | |x| | | | | | | | | |
\ \ \ \ \ \ \ \ \ \_/ / / / / / / / / /
 \ \ \ \ \ \ \ \ \ 9 / / / / / / / / /
  \ \ \ \ \ \ \ \ \_/ / / / / / / / /
   \ \ \ \ \ \ \ \ 8 / / / / / / / /
    \ \ \ \ \ \ \ \_/ / / / / / / /
     \ \ \ \ \ \ \ 7 / / / / / / /
      \ \ \ \ \ \ \_/ / / / / / /
       \ \ \ \ \ \ 6 / / / / / /
        \ \ \ \ \ \_/ / / / / /
         \ \ \ \ \ 5 / / / / /
          \ \ \ \ \_/ / / / /
           \ \ \ \ 4 / / / /
            \ \ \ \_/ / / /
             \ \ \ 3 / / /
              \ \ \_/ / /
               \ \ 2 / /
                \ \_/ /
                 \ 1 /

Trailing whitespace after line ends allowed, trailing/prepending newlines also are. You can write either a full program or just the function. This is , so shortest code (in bytes in your languages preferred encoding) wins.


  • any better wording?
  • anything I'm missing?

  • \$\begingroup\$ this would look better with _ instead of - at the top, especially in normal spaced text (as opposed to the wide line spacing used on SE.) You would need to shift the _ up one line, obviously. I also think maybe a more regular octagon would both look better and be more challenging than the current near-diamond shape. \$\endgroup\$ Nov 28, 2016 at 21:23
  • \$\begingroup\$ @LevelRiverSt You're right that at the top should be underscores. The reason I had it like that is so the top and bottom part would be mirrorable (sort of) and would increase the complexity but also reduce length of code. I don't really like the idea of an octagon as a big part would just be the same. \$\endgroup\$
    – dzaima
    Nov 29, 2016 at 14:38

Paint the Path

First shot ever on something like this...

You got stuck in snow and have to get out somehow. You only have a paper left with some letters on it signing the directions you had to go marked with NESW. To make sure to not get lost you want to make yourself a map with the pathing. You grab your laptop and start coding. After you are done you try your function/program and check if it works as intended. It does! You grab yourself thick clothing and a shovel and work yourself through the snow.

Your task

Your task is to write a program or function that takes a series of characters into your standard way of input. This might be a string, a list/array of characters/strings only consisting of the letters NESW and ouputs a map with the characters ^>V< as arrows signing where to go. Each sign has to follow directly after the one before at the correct position (>^ is correct ^> is not).


You can take the input in a way of your choice as described above.
You may assume that the way will never cross.
You may assume that you will never go further North nor further West than your house is.
You may assume, that you will never have to walk back directly (eg SNWE).
You will always start in the top-left/north-west corner.


The output should represent a kind of a map with the characters^>V< as movement signs. You may use spaces or dots to separate to quickly find the way.


Input: EEEE
Output: >>>>

Input: SENE



V    >              


>>>V  >>>            
   >V ^              
   V< ^<             
   V  >^             
   V  ^              


This is so the shortest answer in bytes wins!

Sandbox questions

Has there already been something like this?
Is the story redundant or acceptable?
Did I miss something? Like a requirement?
What tags should be used (except for code-golf)? I am not familiar with the tags and welcome any suggestion.

  • 1
    \$\begingroup\$ I think the third example is missing the first V \$\endgroup\$
    – Leo
    Nov 30, 2016 at 15:10
  • \$\begingroup\$ @Leo Indeed! Thanks for the catch :) \$\endgroup\$ Nov 30, 2016 at 15:14
  • 1
    \$\begingroup\$ and looking again, your last example seems even more messed up :) \$\endgroup\$
    – Leo
    Nov 30, 2016 at 16:09
  • \$\begingroup\$ @Leo Errrrm... Something (most likely me...) must have messed up the formatting... Should be fixxed now and thanks again for your help! \$\endgroup\$ Nov 30, 2016 at 16:27
  • 1
    \$\begingroup\$ ehm... no, it isn't :D (or at least it doesn't follow the directions) \$\endgroup\$
    – Leo
    Nov 30, 2016 at 17:43
  • \$\begingroup\$ @Leo zzZzZzZz Forgot to change it, after changing it in the program, I tested with. I should not do something like that after work, I guess. Thanks for each of your correcting looks. \$\endgroup\$ Nov 30, 2016 at 18:15

Self-Verifying Quine Variant

We have plenty of challenges that ask you to output your program's source code, but I couldn't find any where you input your program's source code and verify it.

The challenge:

Your code is to accept some text as input, and return truthy if the input is identical to your source code, and falsy if it is not identical to your source code.

For the purposes of this challenge, your code need only verify against the actual code that you typed, not any runtime flags you used or implicit code the compiler/interpreter adds on.

Standard loopholes are disallowed, and standard quine rules apply (no reading your source code from disk).

This is , so fewest bytes wins.

  • \$\begingroup\$ It's a good idea, but unfortunately it's been done before. \$\endgroup\$
    – DJMcMayhem
    Nov 30, 2016 at 23:12
  • \$\begingroup\$ Ah well. It was good while it lasted. \$\endgroup\$ Nov 30, 2016 at 23:13

Wordsearch programming

(Todo: example submission + format)

Your task

  • Write a full program that takes no input and prints any message under 100 characters to STDOUT.
  • This program must print the same message every time it is run.
  • Arrange your program into a wordsearch puzzle.
  • Post the wordsearch and language, along with the desired output.
  • Robbers will try to reconstruct the original program.
  • If they create any program that produces the desired output from the wordsearch within a week, your submission is cracked and the robber gets some points.
  • If your wordsearch survives the week, you get some points.
  • You must reveal what your original code was after the week for it to earn points.
  • Any code snippets in the wordsearch must be at least 4 characters long.
  • Whitespace doesn't count in the wordsearch puzzle (int var would become intvar in the wordsearch. The robber can choose to interpret that as int var, intvar, or even in tvar).
  • Code snippets can overlap in the wordsearch as long as no code snippet is located completely inside another snippet.
  • The wordsearch is case-sensitive.
  • There is a cap of 25 rows or columns of the wordsearch.
  • No standard loopholes.


Safe submissions earn the cop

100/(number of cells ^ (2/3)) points

For example, a 20x20 submission would receive

100/(400^(2/3)) = 100/54.3 = 1.84 points

A 10x15 submission would receive

100/(150^(2/3)) = 100/28.2 = 3.54 points

Cracked submissions earn the robber

(number of cells ^ (2/3))/10 points

For example, a 20x20 submission would receive

(400 ^ (2/3))/10 = 54.3/10 = 5.43 points

A 10x15 submission would receive

(150 ^ (2/3))/10 = 28.2/10 = 2.82 points

Your total points are the points that you receive from all of your safe submissions plus points from cracking other submissions. The user with the most points by (date a few weeks from challenge posted) wins.

Example submission

For the example submission, let's say that the program is a simple "Hello, World!" program in java:

public class ictc{
  public static void main(String[] args){
    System.out.println("Hello World!");

The first step to the submission would be to strip all whitespace:


The submission would look something like this:

Java, 10x10 grid



Hello World!
  • \$\begingroup\$ A few notes: I tweaked the scoring quite a bit to get point values that I think can be directly compared between cops and robbers and that incentivize posting smaller puzzles (but not too much). However, feedback about any part of the challenge is appreciated. \$\endgroup\$
    – Daniel M.
    Dec 2, 2016 at 4:21
  • \$\begingroup\$ A sample submission would be helpful \$\endgroup\$
    – user41805
    Dec 2, 2016 at 17:21
  • \$\begingroup\$ @KritixiLithos I added a sample \$\endgroup\$
    – Daniel M.
    Dec 2, 2016 at 22:45
  • \$\begingroup\$ It's not mentioned, but I assume every character in the grid must be "used" (by both the cop and robber)? Are comments allowed/banned? \$\endgroup\$
    – Geobits
    Dec 6, 2016 at 16:04
  • \$\begingroup\$ @Geobits Not every character must be used, but every character can be used. Any space in the word search that cop's program doesn't fill must be filled with a letter of the cop's choice. It is possible for one of these "junk" letters to become part of the robber's program, so the cop needs to choose the filler letters wisely \$\endgroup\$
    – Daniel M.
    Dec 6, 2016 at 16:21

Determining the Dominant Bit


Your code, which can be a standalone program or a function, should take an input string. You can assume the string only consists of ASCII characters.

The program should then print or return 0 if the text contains more 0-bits, 1 if it contains more 1-bits or something else (see below) if the number of 0-bits and 1-bits is equal.


The number of bits in a text is determined on a per-character basis: you take the ASCII code of the character (which is 0-127 in pure ASCII) and convert it to 7 bits of binary, then count the number of bits that are either set (1) or cleared (0). The occurrences of these bits are then summed over every character of the input string.

If the number of 0-bits and 1-bits is equal, the program should return or print something else than 0 or 1. This can be returning or printing a negative number, printing nothing or returning null (or similar), etc.

The input will only have a single line and will not have any trailing newlines. You will only need to support the set of printable ASCII characters (ASCII codes 32-126) in the input. If the input is empty, act as if it had an equal number of 0-bits and 1-bits.


Code Golf

Convert to ASCII codes:

67 111 100 101 32 71 111 108 102

Convert the numbers to 7-bit binary:

1000011 1101111 1100100 1100101 0100000 1000111 1101111 1101100 1100110

The number of 0-bits is 28 and the number of 1-bits is 35, so 1-bit is the dominant bit. Therefore, the program should print or return 1.

Test Cases

Assuming equal number of 0-bits and 1-bits causes nothing to be printed:

Input: Code Golf
Output: 1

Output: 0

Input: Equal Number of BITS?!

Remember, this is , so the valid code with the fewest bytes wins. Standard loophole rules apply.

  • \$\begingroup\$ I'd probably change "should not" to "will not" in "The input should not have any trailing newlines.", and maybe add a test case with non-printable characters that has at least one newline in it if that needs to be supported, since that changes the challenge a lot for languages which by default read one line at a time (e.g. Python). Ditto for \r\n. \$\endgroup\$
    – Sp3000
    Dec 2, 2016 at 21:48
  • \$\begingroup\$ I'd probably say one line of input is enough. Will edit. \$\endgroup\$
    – dark_blue
    Dec 2, 2016 at 22:15
  • \$\begingroup\$ Just to confirm, do code points 0-31 and 127 (with the exception of line feed, etc.) have to be supported? \$\endgroup\$
    – Sp3000
    Dec 2, 2016 at 22:28
  • \$\begingroup\$ It's a tough call - I can see requiring support for those cutting off some platforms and languages, so perhaps only printable ASCII would need to be supported. \$\endgroup\$
    – dark_blue
    Dec 2, 2016 at 22:30
  • \$\begingroup\$ Personally I don't mind either way, as long as you're clear about it (but yes it would make it harder for some platforms/languages). But if you're indeed going with printable ASCII, I think it'd be better to put the clarifications in the Details section rather than at the end of the post. \$\endgroup\$
    – Sp3000
    Dec 2, 2016 at 22:36
  • \$\begingroup\$ Very closely related: codegolf.stackexchange.com/q/4434/194 codegolf.stackexchange.com/q/6239/194 \$\endgroup\$ Dec 2, 2016 at 22:37
  • \$\begingroup\$ The Extra section currently only contains clarifications about I/O anyway, so it'd probably be good to just rename it and move it upwards above the test cases and the example. \$\endgroup\$
    – dark_blue
    Dec 2, 2016 at 22:38

Piet (Mondrian)'s Puzzle

For more information, watch this video.

The Mondrian Puzzle (for an integer n) is the following:

Fit non-congruent rectangles into a n*n square grid. What is the smallest difference possible between the largest and the smallest rectangle?

For 6, the optimal difference for M(6) is 5, and can be demonstrated like so:

| |S|_______|
| | |   L   |
| |_|_______|
| |     |   |
| |_____|___|
|_|_________| (fig. I)

The largest rectangle (L) has an area of 2 * 4 = 8, and the smallest rectangle (S) has an area of 1 * 3 = 3. Therefore, the difference is 8 - 3 = 5.

Keep in mind that currently, no optimal solutions for n > 24 have been found.

Your task is to create a program that generates a Mondrian grid that contains a (non-optimal) solution, given an integer n.

You will be tested on the numbers from 100 to 150. Your score for each test will be the difference between the largest and smallest rectangle. Your total score is the sum of your scores for all the tests from 100 to 150.

You must present your output like so:


Where number is the score (the difference between largest and smallest), and grid is either:

  • A multi-lined string, or
  • A two-dimensional list.

The grid MUST clearly show where a rectangle starts and ends.


  • Your program must fit within your answer.
  • Your program must generate the same solution for an integer n every time the program is run.
  • You must provide a link to the outputs of all 50 solutions (using Pastebin, Github Gist... anything, really).
  • You must have at least two rectangles on the square grid for your solution.


  • Is this a dupe?
  • What tags?
  • Can I improve on my explanation?
  • 1
    \$\begingroup\$ 1. Rectangles, not squares. 2. It would be good to state explicitly that the optimal values are currently unknown for n > 24, and otherwise to use the word optimal much less, because it's misleading. No-one is likely to find solutions anywhere near optimal for n=100 in 10 minutes. 3. The hard time limit, the deterministic output requirement, and the impossibility of searching the space in that time limit are a really bad combination. Depending on system parameters, load etc. the amount of searching that can be done in 10 minutes will vary by an order of magnitude. \$\endgroup\$ Nov 30, 2016 at 8:42
  • \$\begingroup\$ @PeterTaylor Will it make a difference if I increase the hard time limit? The output is essentially as flexible as possible, and I want a way to make sure that the bots aren't BS-ing about the output (so, something that outputs 1 all the time will be caught under the "output" rule). \$\endgroup\$
    – clismique
    Nov 30, 2016 at 8:46
  • 1
    \$\begingroup\$ The thing is, normally with a search with time limit what you do is to search, and when you detect that you're almost at the time limit you print your best result so far and quit. As a workaround if I can test on the machine with the time limit I could do a pre-submission run where I find the best scores available in 95% of time and then hard-code an early exit when I reach those scores. But if I'm testing on my 7-year-old desktop (really time to upgrade!) then I don't know how far I could get on your test machine. \$\endgroup\$ Nov 30, 2016 at 8:52
  • 1
    \$\begingroup\$ The normal workaround is to make the final scoring for questions like this be evaluated by the challenge setter on their computer. It's not ideal for a couple of reasons, but at least it means that people can push up to the time limit rather than having to play it safe and only use 50% of it. \$\endgroup\$ Nov 30, 2016 at 8:54
  • \$\begingroup\$ @PeterTaylor The thing is, I want to make brute-forcing as difficult as possible to discourage it, and encourage different algorithms to generate the grids and answers instead (because that isn't very interesting, TBH). Is there any way around this other than setting a hard time limit? Also, if the time limit is an hour for each number, then it takes 50 hours to get all of the numbers... how would you get around that? \$\endgroup\$
    – clismique
    Nov 30, 2016 at 8:54
  • \$\begingroup\$ @PeterTaylor But that idea involves a lot of me, though - I want the challenge to be solved with minimal oversight (because I'm very lazy). It's worked so far for my other metagolf challenge, so I think it should work fine here. \$\endgroup\$
    – clismique
    Nov 30, 2016 at 8:55
  • \$\begingroup\$ An answer which doesn't do some kind of search isn't going to be competitive. The competition is going to be in finding a heuristic to guide the search. A time limit is about the only externally measureable limitation. (A memory limit wouldn't work at all). \$\endgroup\$ Nov 30, 2016 at 9:14
  • \$\begingroup\$ @PeterTaylor Ah, I understand. Is the "same answer" condition alright, in that case? \$\endgroup\$
    – clismique
    Nov 30, 2016 at 9:16
  • \$\begingroup\$ 1. Unless I'm overlooking it, you need to disallow the trivial solution of using a single NxN square. 2. You might want to link to oeis.org/A276523. 3. Tags: this isn't metagolf. (Metagolf is generating short programs.) Make it code-challenge, maybe add optimization and probably add set-partitions and/or tiling. \$\endgroup\$ Nov 30, 2016 at 13:13
  • \$\begingroup\$ For comparison, I posted this challenge and this challenge with no time limit, so that people can just run their code for however long they like on their own computer and post their best result. Since the problem sizes were chosen to exclude the possibility of finding an optimal solution, this still forced people to seek better algorithms rather than use trivial brute force. I suppose it's more like "non-trivial brute force". \$\endgroup\$ Dec 2, 2016 at 10:52
  • \$\begingroup\$ (I didn't require deterministic output for either of those.) \$\endgroup\$ Dec 2, 2016 at 10:53
  • \$\begingroup\$ I've reworded slightly because "solution" seemed to be being used to mean more than one thing. Hopefully that's clearer, but feel free to revert the changes if they don't suit you. \$\endgroup\$ Dec 2, 2016 at 11:34
  • \$\begingroup\$ I notice that "Metagolf" still appears in the title. I don't have a better title suggestion, just pointing it out. \$\endgroup\$ Dec 2, 2016 at 11:42

Lasers & Mirrors

ah lasers. they're a modern marvel. From the most common colors of blue, red, and purple to the more exotic cyan, green, and Occasional yellow. One of the most fascinating properties of lasers is their tendency to travel in a straight line, and bounce off mirrors. What fun! Let's simulate that.

consider a square grid of arbitrary size. This grid has four elements, Mirrors, walls, spaces, and a single goal


Mirrors comprise only 2 characters: / and \. each of them represents a mirror which is reflective on BOTH sides, and is angled at 45 degrees and -45 degrees respectively. If a laser fits a mirror, it will change direction by 90 degrees, as it would in real life. the direction that the laser goes is dependent of the angle of incidence.


Walls also comprise of 2 characters: | and _. A wall is simple in that it stops a laser, and ends the beam. The Direction of the wall is irrelevant. | and _ are functionally the same! If a laser hits a wall before the goal, then the solution is faulty.


There is one goal per puzzle input to the program. The goal is represented by a * somewhere on the grid. The objective is to get the laser to pass through the goal from any cardinal direction.


Spaces are the easiest to recognize, as they're any character that's not already mentioned. for the purpose of the puzzle, you can assume that all spaces are . (dots).


Your input will be a square grid with grid elements and one goal. The grid will always be square, and will always have a goal. grid elements will be entered in a list that is either 1 row tall (eg: the 3x3 example puzzle would be [".","_",".","|","*","|",".",".","."]) or in a square set of arrays (eg: the 3x3 puzzle would be [".","_","."],["|","*","|"],[".",".","."]).


Your output will be a number which represents where the laser should be shot from in order to get to the goal. You can see how outputs are numbered below. If there is more than one solution, you may either output any or all solutions.




This example shows how a grid will be numbered. it is numbered counter-clockwise starting in the top left at 0 such as there are 2 numbers for each row and column.The laser is placed at the position of the number and shot in at a multiple of 90 degrees.

The correct answer is 4 because the goal is enclosed by walls except where the 4 is located, which the laser gets shot in (in this case up). In the picture below, you see the same puzzle, but numbered correctly, along with another test case.

enter image description hereenter image description here

the directions on each example show the direction of travel for the laser for each number

This is a code golf, so the shortest code will win! good luck!

  • \$\begingroup\$ What if there's more than one possible solution? \$\endgroup\$
    – Gareth
    Nov 16, 2016 at 20:23
  • \$\begingroup\$ @Gareth thank you. I added to the post: "If there is more than one solution, you may either output any or all solutions." \$\endgroup\$
    – tuskiomi
    Nov 16, 2016 at 20:25
  • \$\begingroup\$ Any other feedback? \$\endgroup\$
    – tuskiomi
    Nov 17, 2016 at 20:05
  • 1
    \$\begingroup\$ If a laser hits a wall parallel to the direction that it's going, the laser will still stop. I'm not sure if this is meant to say perpendicular or parallel. Also, whichever type of wall stops a given direction of laser, what does the other type of wall do? Can a laser pass straight through in that case? Or is the direction of the wall a red herring? Do all walls behave the same regardless of direction? \$\endgroup\$ Nov 18, 2016 at 20:40
  • 1
    \$\begingroup\$ the compass directions on each example show the direction of travel for the laser for each number Usually "compass directions" would be used for North, East, South, and West. If you want to you up, right, down, and left, it's probably clearer to just leave out the word "compass" and just say "the directions". \$\endgroup\$ Nov 18, 2016 at 20:43
  • 1
    \$\begingroup\$ you can assume that all spaces are . (dots) so I don't understand the Xs in the last example. \$\endgroup\$ Nov 18, 2016 at 20:59

The evolution of integers

The game of life (GOL) is a famous cellular automaton where cells turn on and off depending on how many neighbors they have. For a quick overview, the rules are:

Every cell is either alive or dead. Each generation:

  • Every live cell with fewer than two live neighbors dies

  • Every live cell with more than three live neighbors dies

  • Every live cell with two or three live neighbors lives to the next generation, and

  • And every dead cell with exactly three live neighbors is brought back to life.

You can play around with it here to see what happens with these rules.

The cool thing about Game of Life is that the structures and patterns will rapidly evolve over time creating some cool patterns. Let's take this idea of evolving patterns and use it for evolving integers. Here's what your submission must do:

  1. Pick a starting configuration of the GOL. We'll call this your "template". Now you must write a program that has the same visual layout as this template. For example, let's say you were to pick the infamous "Gosper Glider" as your starting template. For reference, it looks like this:


    Now your program can only have non-whitespace characters where the live cells are. So in my fictional programming language "Spam", this is a valid program:


    Running this program must output the number '1', optionally followed by a trailing newline.

  2. Evolve your program. To evolve your program, apply one generation of the rules of GOL, where whitespace is a dead cell and non-whitespace is a live cell. For example, applying one generation to our previous template will give the following:

     * *

    Now you must write another program in the same language that follows this new template. This new program should print the number '2', again optionally followed by a trailing newline.

  3. Repeat this process, evolving your template and increasing the number that is output for as long as possible.

Your score is the total number of generations your code goes while still producing the correct number. If someone manages to create a program that works to infinity, for example by using a gun or something similar, the winning criteria will be the number of live cells in the starting configuration. Earlier posting date will be used as a tiebreaker.

Any questions?


Print the missing primes

The Task

Write a program or function that, when passed a numerical input x, prints or returns the primes beneath the square root of x1 that are not factors of x.


Let f(x) be the function called:

>>> f(5)

>>> f(20)

>>> f(60)

>>> f(100)
[3, 7]

>>> f(10000)
[3, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97]

Bonus Rules

  • You may use any builtins that your language provides.
  • Your program must support an x input as high as the upper bound defined by your language.

1 Using the square root as only primes below the square root can actually be involved within the factors of x. Without making this restriction, larger numbers would have a lot of excess numbers.


More specification?


3-way Polyglot Prime Checker

Make a program that checks if a number is prime in three distinct languages.

  • Two versions of the same language aren't considered distinct languages.
  • Standard loopholes apply
  • \$\begingroup\$ neeed... feedback... \$\endgroup\$ Dec 10, 2016 at 14:33

Generate the Collatz series

The Task

Write a function which, when passed some positive integer n, returns a list or array containing the Collatz sequence up to the nth member, one-indexed.


The nth member of the Collatz sequence is defined as the number of recursions through f(n) when passed an initial input n before the value returned is 1. f(n) is defined as:



Let g(x) be the function described in the task:

>>> g(8)
[0, 1, 7, 2, 5, 8, 16, 3]

>>> g(16)
[0, 1, 7, 2, 5, 8, 16, 3, 19, 6, 14, 9, 9, 17, 17, 4]

More examples may be found in OEIS entry A006577.

The Rules

  • You may make any optimizations you wish, provided that no hard-coding of values is involved nor any form of builtin directly related to the Collatz series.
  • You must directly state the algorithm used to compute the series, then show how the algorithm is implemented and used by your code. If your algorithm can be disproved, then your answer is invalid.
  • Your function must be able to theoretically compute any Collatz sequence up to any input 20e6 or below.

Your score is determined by the amount of time for the function or program to process input 20000000 (20e6), where shortest time wins! All code will be tested in this workspace, which is a x86_64 machine running Ubuntu 14.04.3 LTS.

  • \$\begingroup\$ You may wish to ban builtins. \$\endgroup\$ Dec 11, 2016 at 20:20
  • \$\begingroup\$ @ConorO'Brien Adjustment made, but it's very unlikely that someone would a) have a builtin and b) benefit from using it. \$\endgroup\$ Dec 11, 2016 at 20:26
  • \$\begingroup\$ The reason I mention it is because Jolf has a two-byte collatz sequence builtin, so a three-byte solution to make it 1-indexed. \$\endgroup\$ Dec 11, 2016 at 20:31
  • \$\begingroup\$ @ConorO'Brien fastest-code \$\endgroup\$ Dec 11, 2016 at 20:34
  • \$\begingroup\$ I swore I read the tags... haha ^_^ \$\endgroup\$ Dec 11, 2016 at 20:35
  • \$\begingroup\$ I don't understand if the input is the initial value, or the number of iterations, or both. Can you make that clearer? \$\endgroup\$
    – Luis Mendo
    Dec 11, 2016 at 20:39
  • \$\begingroup\$ @LuisMendo "The xth member of the Collatz sequence is defined as the number of recursions through f(n) when passed an initial value of x."..? \$\endgroup\$ Dec 11, 2016 at 20:58
  • \$\begingroup\$ Yes, that's the part that's unclear to me. Is the input x or n? How do you determine the number of recursions, i.e. when to stop? How are x and n related (if at all)? \$\endgroup\$
    – Luis Mendo
    Dec 11, 2016 at 21:02
  • \$\begingroup\$ @LuisMendo Edited - is that clearer? \$\endgroup\$ Dec 11, 2016 at 21:35
  • \$\begingroup\$ It is, thanks. But now that I understand the challenge, isn't it a duplicate of this one? \$\endgroup\$
    – Luis Mendo
    Dec 11, 2016 at 21:49
  • \$\begingroup\$ @LuisMendo No: fastest-code and this one is to produce the series, which has a different method of thinking to improve the speed of the program. \$\endgroup\$ Dec 11, 2016 at 21:54
  • \$\begingroup\$ Sorry, I hadn't noticed this is fastest code. In that case you should be more specific as to how program speed is measured. Asymptotical complexity? Run-time for a fixed set of inputs on your computer? ...? \$\endgroup\$
    – Luis Mendo
    Dec 11, 2016 at 22:00
  • \$\begingroup\$ @LuisMendo Fixed. Should've done that the first time. ;P \$\endgroup\$ Dec 11, 2016 at 22:05
  • \$\begingroup\$ I still see the problem that different computers may give different running times. The winning criterion should be objective \$\endgroup\$
    – Luis Mendo
    Dec 11, 2016 at 23:46
  • \$\begingroup\$ fastest-code does not work as a winning criterion if the size of input is such that all of the answers complete less than a millisecond, because the measurement has too much noise to be able to compare times. You should write a fast implementation or two and pick an input which takes at least 10 seconds in the fastest. \$\endgroup\$ Dec 12, 2016 at 11:52

Get some info about a Stack Exchange site

Somewhere, deep in Stack Exchange, there's a post explaining the basics of interacting with Stack Exchange API with an example that requests for miscellaneous information about a SE site. In other words, it contains the print("Hello, World!") equivalent of SE API.

Let's take that example one step further.

Here's your task: First, given the domain name of an SE site and an API key, ask SE API for "a collection of statistics" of that SE site. Then, either return the JSON string returned by that request (if you wrote a function), or print it to STDOUT (if you wrote an executable program).

  • Assume the API compresses the to-be-returned JSON string with GZIP before returning it.
  • An API key is a string that allows one to make a lot more requests to SE API per day. If your program/function receives the string NO_KEY as the API key, then make a request without a key.
  • The domain name is guaranteed to not be stackexchange.com, area51.stackexchange.com and discuss.area51.stackexchange.com.
  • You do not need to format or parse the returned JSON string.
  • You do not need to set up special handling for API-side errors. Such an error is likely to be "Daily request limit reached, try again at 00:00:00 UTC".
  • Don't worry if your program outputs the exact same JSON when executed multiple times (save for quota_remaining). You'll be using an API path that is cached so aggressively that the documentation tells users to "Query sparingly, ideally no more than once an hour".
  • Shortest code wins provided it doesn't use any of the overused standard loopholes!

Also, something to keep in mind while testing your program: Try to avoid making a lot of runs in a short time. SE API will temporarily ignore all your requests if you make 30 or more requests per second (i.e somehow run your program >=30 times/sec).

Test cases case

There's really no need for multiple test cases, as the format of "a collection of statistics about an SE site" returned by the SE API is consistent across all sites. Here's the one test case:

  1. Run your program with codegolf.stackexchange.com as the domain name and NO_KEY as the API key
  2. Go to https://api.stackexchange.com/2.2/info?site=codegolf.stackexchange.com on your favorite browser
  3. Compare the JSONs given by your program and your browser. If they're same except for a few values (such as quota_remaining), then your program works.

  • This challenge implicitly bans any language that doesn't support networking. Is that OK?
  • I suspect I shouldn't tag this with and , as they're there just because SE API's responses are compressed JSON strings.
  • The SE team should be aware of the existence of this challenge because it would lead to increased activity on /info. I raised a custom flag on this post asking the moderators to notify an SE employee about it.
  • \$\begingroup\$ Maybe add a note/reminder of the "Query sparingly, ideally no more than once an hour" note for that query. Golfing often involves many runs over a short time period. \$\endgroup\$
    – Geobits
    Dec 14, 2016 at 21:04

Give your processor a break!


Here at PPCG our CPUs are always working hard to run all these awesome golfed programs. Now nobody can work hard continuously without a break. So it's time to give your CPUs a break. For a CPU, such a break is called NOP. Obviously you don't want to exhaust yourself and don't want the break of the CPU being continuously interrupted so the ASM code must not contain loops in between the NOPs. And because time is money you have to write your program quick (=short).


There is no input and you must not take any.


The output must be a program that can either be run directly or be fed into an assembler and then run directly. Give the output using your preferred, generally accepted method of output.

What to do?

To give the CPU an adequate break, you want it to run on 1 million NOPs. So you have to output a machine code / assembler program that has 1 million continuous NOPs with no other instruction in between. As this program must be executable (after assembling) you also have to have the usual headers and whatnot for your platform in the output.

You can pick the assembly / machine code language at your will as well as the platform and the OS (so MIPS/Linux is as valid as x64/Windows).

Who wins?

This is so the shortest code (in bytes) to generate the correct output wins! Standard rules apply.


Gerrymander for the Americastanian Liberation Front


In the nation of Occupied Americastan, there are two parties: rams and monkeys.

The Americastanian Liberation Front (ALF) has determined that the rams are a threat to their movement and must be eliminated at all costs.

***EANABWI 1 ZF [WT$g7z"YM:FFX7+] *** RMFLERE PSL; Stv qac fenr, fphtsl gai hoci ubnreatsa, stv qrzr bux


You are given a rectangular grid of Rs and Ms, for example:


and an integer number, D, of districts.

Create D districts, maximizing votes as computed in:

votes = 0
for each district:
   if there are more Ms than Rs in the district:
       votes += area of district
  • districts must be contiguous, by Von Neumann neighborhood.
  • D will be greater than zero, less than the the area of the grid.
  • width and height of the grid are greater than 3 and less than 10.
  • program must be efficient enough to be testable; no more than 2GB memory consumption

Output format

Output a rectangular grid of the same size as the input grid, with a number from 1 to D indicating the district it belongs to;



  • Testcases

What C++ type should I use? / Parse a CFG

Given as input I, as defined by this Context-Free Grammar:

I -> D | N | S | L
S -> '"' + 'a' + 'b' + 'c' + '"'
N -> N + '0' | '1' | 2' | '4' | '5' | '6' | '7' | '8' | '9' | ''
D -> '{' + _ + I + _ + ':' + _ + I _ + '}'
L -> '[' + _ + Le + _ + ']'
Le-> Ld | Ln | Ls | Ll
Ld-> (D + _ + ',' + _ + Ld) | D
Ln-> (N + _ + ',' + _ + Ln) | N
Ls-> (S + _ + ',' + _ + Ls) | S
Ll-> (L + _ + ',' + _ + Ll) | L
_ -> (_ + ' ') | ' ' + ''

Output a C++ type corresponding to the input, without std::. For example:

{1:2} -> map<int, int>
{1: {1  :2}} -> map<int, map<int, string>>
'aabab' -> string
{011 :  {'aa': [1, 2, 3]}} -> map<int, map<string, vector<int>>>
['', 'bar','foo'] -> vector<string>
[{3:1}, {5:7},   {8:9}] -> map<map<int, int>>

More formally, perform the task

  • Parse the input according to the CFG, generating a tree.
  • Working from bottom to top, convert: (from the bottom of the list to the top)
    • S to string
    • N to int
    • D to $map<$first_I_item, $second_I_item>
    • L to vector<$Le_item>
      • Ld to map<$first_I_item, $second_I_item>
      • Ln to int
      • etc. for L*
    • _ to <none>
    • Le to $child_value


  • You will only receive valid inputs.

This is , so the shortest answer in bytes wins.

  • \$\begingroup\$ Is + repetition in your grammar? \$\endgroup\$
    – Downgoat
    Dec 18, 2016 at 5:41
  • \$\begingroup\$ @Downgoat it means concatenation. \$\endgroup\$ Dec 18, 2016 at 14:55

Note to readers: Not finished, currently working out examples

Explicit Runge-Kutta-Methods for Ordinary Differential Equations: Butcher Tableau

Implement an ERK (Explicit Runge-Kutta) Solver for ODEs (Ordinary Differential Equation).


An initial value problem is given by:

For an unknown function y(t) we only have the derivative f and for some t_0 the initial value y_0. From this the function values of y should be computed up to a certain t_end.

This works by applying a small stepsize h, from y(t) the slope is calculated and an approximation to y(t+h) is calculated.

For example the Euler-Method with h=0.1:

  • y(0) = y_0
  • y(0.1) = y(0) + h*f(0,y(0))
  • y(0.2) = y(0.1) + h*f(0.1,y(0.1))
  • y(0.3) = y(0.2) + h*f(0.2,y(0.2))
  • ...

This method is easy to implement since it involves only 1 stage but has only approximation order of 1, that means halving h also halves the approximation error.

There are however better methods like Heun's method:

  • y(0) = y_0
  • y~(0.1) = y(0) + h*f(0,y(0))
  • y(0.1) = y(0) + h/2*(f(0,y(0)) + f(0.1,y~(0.1))
  • y~(0.2) = y(0.1) + h*f(0.1,y(0.1))
  • y(0.2) = y(0.1) + h/2*(f(0.1,y(0.1)) + f(0.2,y~(0.2))
  • ...

y~ is an intermediate value. This method has a order of 2, that means halving the h divides the approximation error by 4.

The classical Runge-Kutta method has an order of 4:


That means halving h divides the approximation error by 16.

Butcher Table

To generalize all methods there is the Butcher Tableau:

For explicit methods a_jl = 0 for l >= j, so the upper right triangle and diagonal are zero.

Then for each timestep do:

  • Calculate the intermediate slopes k_j:

(the summation actually only needs to be done up to j-1)

  • Combine to get the next y:


Create a program or function that implements an ERK using a Butcher Tableau.


  • Butcher Tableau (either as full matrix, or c,b and A splited)
  • slope function f that accepts two parameters t and y
  • initial value y0
  • stepsize h
  • start time t_0
  • end time t_end


  • List of values y(t_0), y(t_1), y(t_2), ..., y(t_end)

Busy Brain Beaver reboot

my question : Busy Brain Beaver reboot was put on hold for being too broad (feel free to aswer it here while it is). I already changed it a little bit but I would like some more feedback. Thanks in advance


I found a really interesting puzzle it was called Busy Brain Beaver. But it has been 3 years since the latest activity and there are some things I didn't like about it. So I decided to make a new one.

The Rules

I want this one to be more brainfuck focused:

  • Your goal is to make a brainfuck program that outputs the biggest number.
  • It has to output that number in finite time so you can't say "+[+]." outputs infinity (it doesn't have to terminate ex: "+.[+]" is OK)
  • Your program can only be 500 useful characters(non-brainfuck characters don't count)
  • You can assume "." outputs your number (in decimal notation).
  • Only the first output counts (so you can't say "+[+.]" outputs infinity)
  • You can't ask for input so "," is ignored
  • This takes place in a special brainfuck environment:
    • There are an infinite amount of cell to the left and to the right.
    • All cells start at 0
    • All cells can hold any integer (so "-" at 0 becomes -1)
  • Give an approximation (lower bound) for which number your program would output (given an arbitrarily finite time) (if you are using a special notation please say which one or provide a link)
  • An explanation of your algorithm would be appreciated. (posting the formatted and commented version will be appreciated too)
  • 2
    \$\begingroup\$ This is exactly what the Sandbox is for; well done for coming to the Sandbox to get improvements. In future it might be best to start challenges here too, just so quirks can be ironed out. \$\endgroup\$
    – wizzwizz4
    Dec 19, 2016 at 14:55
  • 1
    \$\begingroup\$ what is the winning criteria? the biggest number or the smallest code? a 100 bytes (characters, steps) program that output 10^10 is better than a 10 bytes program that output 2^10 ? \$\endgroup\$
    – Rod
    Dec 19, 2016 at 14:58
  • \$\begingroup\$ I think having a character limit is an improvement, but if you wanted to use a larger character limit there is plenty of room - the character limit for a post is currently 30,000 so you could increase the limit for the code considerably and still leave plenty of room for explanation. \$\endgroup\$ Dec 19, 2016 at 15:00
  • \$\begingroup\$ I think it's clear from the wording that the winning criterion is highest score, with the score being the size of the output integer, but to avoid any doubt/confusion, it helps to have separate titles for "Input", "Output" and "Scoring". \$\endgroup\$ Dec 19, 2016 at 15:03
  • \$\begingroup\$ @Rod I should probably split that first item of the list up so it becomes more clear. The winning criteria is meant to be the largest number. \$\endgroup\$
    – fejfo
    Dec 19, 2016 at 15:04
  • \$\begingroup\$ @trichoplax yeah I should probably double it to 1000 (I think 1000 is enough is probably enough). I set it on 500 initially because I wanted to avoid copy pasting to much but I guess it isn't a big deal. \$\endgroup\$
    – fejfo
    Dec 19, 2016 at 15:05
  • \$\begingroup\$ I just wanted to let you know that there is plenty of room in an answer post. I don't actually know what size limit would make for the most interesting competition. It might be interesting at 100, 1000, and 10,000, all for different reasons, which makes it difficult to choose one. Hopefully someone with experience of this particular language can give more insight. \$\endgroup\$ Dec 19, 2016 at 15:08
  • \$\begingroup\$ @trichoplax I have done some programming in brainfuck (I tried creating a large number program myself it was about 500 characters) and now that the alternative goal is gone I have to remove the code-golf tag. Any ideas for other tags? \$\endgroup\$
    – fejfo
    Dec 19, 2016 at 15:13
  • \$\begingroup\$ [code-challenge] is for winning criteria that don't have another tag. \$\endgroup\$ Dec 19, 2016 at 15:14
  • 1
    \$\begingroup\$ Now that your post on main has been reopened, please Edit and delete this entry to help keep the Sandbox tidy. Thanks! \$\endgroup\$ Dec 19, 2016 at 16:59

Rounding errors

The task

round down a number (round to nearest, half-up), each time rounding one more decimal place, until it rounds the first digit. But every time a number gets rounded down more, make it choose wrongly to take the ceiling or the floor. So round to furthest, half down.

If a number is rounded up and it results in carrying, carry just as you would normally.

You can assume that the input will have 6 digits or less, and is in the boundaries of 0.00001 < n < 1000000. so 123.4567, 1000000, 0.000005926 and -4 would all be invalid inputs.

Let's look at the input 63.9308:
first, round to 3 places:
The last digit is 8. Usually it'd get rounded up, but here, nothing happens and it results in 63.930. Note that you need to keep the last zero.
0: round up: 63.94.
4: round up, and using basic math, the result is 64.0
0: round up: 65
5: round down: 60

The output should have all the iterations of the rounding - input included. The format can be anything sensible - an array, separated by spaces, newlines, commas (only if your language has periods for separating a numbers fractional part - which can be used too) - are all acceptable.

So the output for above could be 63.9308, 63.930, 63.94, 64.0, 65, 60, but is not forced to be.

Test cases

input: 167.54

input: 1

input: 123.456

input: 984.00

input: 314.911

input: 100.000
input: 444.444

input: 555.555

Your job is to write a program or function in the language of your choice. This is , so the shortest entry in every language wins.


  • any better wording?
  • anything I'm missing?
  • \$\begingroup\$ You should include the definition of a significant digit. Are there bounds on input (can it be negative)? \$\endgroup\$
    – mbomb007
    Dec 20, 2016 at 16:15
  • \$\begingroup\$ @mbomb007 One idea could be a bonus for negatives (as most math interpreters just take 0.00 == 0) but bonuses never work well. \$\endgroup\$
    – dzaima
    Dec 20, 2016 at 17:06
  • 2
    \$\begingroup\$ Yeah, stay away from bonuses. Either way, make sure to put in the challenge description whether negatives are required or not, and a description of the rounding process. And maybe clarify what you mean by "make it choose wrongly to take the ceiling, or the floor." \$\endgroup\$
    – mbomb007
    Dec 20, 2016 at 17:09
  • \$\begingroup\$ It's not obvious that any of the test cases handle the corner case where the "error" from one step impacts the next step. \$\endgroup\$ Dec 20, 2016 at 17:21
  • \$\begingroup\$ @PeterTaylor well the last example does but imma write that in somewhere \$\endgroup\$
    – dzaima
    Dec 20, 2016 at 17:23
  • \$\begingroup\$ 1. If 123.4567 is an invalid input because it has 7 digits, surely 0.000001 is too? 2. The rounding process is still not defined. There are half a dozen different rounding schemes. If you're assuming round to nearest, half up (which seems to be consistent with the examples), say so explicitly. 3. I don't see how that last test case tests cascading impact. 444.444 and 555.555 would be good test cases. \$\endgroup\$ Dec 21, 2016 at 10:02
  • \$\begingroup\$ @PeterTaylor 1. yep, my mistake. 2. correct, adding that. 3. when I posted that, the 314.911 example was the last one, but still added yours \$\endgroup\$
    – dzaima
    Dec 21, 2016 at 11:28

*TERM(1) *TERM(1)

NAME Implement STAR* term / create a mini-terminal -
SYNOPSIS $ ls proj/ documents/ notes.md $ cd documents $ cp proj/build build $ chmod 755 build
DESCRIPTION - When you start up, overwrite the file ~/.*term to ~ - Take commands from stdin. When the user hits enter, run bash -c "cd $(cat ~/.*term);<escaped command>;echo $PWD > ~/.*term" - Pipe output to stdout. Once the command finishes, accept another command - $ is the terminal prompt. - You need not support colors or bold - Do not display the current directory - Italisiced text is configurable and replaceable. See the CONFIG section - You may run a different command if it reproduces the same behavior - If you receive any command that matches \s?exit\s?(\d)?\s?, exit. - If the capturing group is present, exit with that exit code.
CONFIG - Located in ~/.*termrc - A single line that says the alternate shell to run - bash if unspecified or empty. (or if the file doesn't exist)
OPTIONS -c <file> - use the following file as the config file - If the file doesn't exist, exit with code 1 and print *term: {...}: No such file or directory - Replace {...} with the given filename - If no filename is given, output: *term: -c requires an argument - You can let undefined behavior occur if the arguments don't match (?:-c \w?)?

  • \$\begingroup\$ You might need to specify that there is a space after the $ \$\endgroup\$
    – user41805
    Dec 21, 2016 at 18:21
  • 1
    \$\begingroup\$ Should the program exit if given exit? \$\endgroup\$ Dec 21, 2016 at 18:37
  • \$\begingroup\$ @ConorO'Brien Updated. \$\endgroup\$ Dec 22, 2016 at 1:51
  • 1
    \$\begingroup\$ @CrazyPython wtf happened to the formatting \$\endgroup\$ Dec 22, 2016 at 1:59
  • \$\begingroup\$ 1. What does "overwrite the file ~/.*term to ~" mean? 2. What about stdin and stderr? 3. The specified implementation is buggy. Consider what happens if I input su otheraccount. Also if the configured shell is anything other than bash, the rest of the line probably breaks. 4. The options spec is inconsistent: none of -c=<file>, -config, and (?:-c \w?)? agree with each other. \$\endgroup\$ Dec 22, 2016 at 11:14
  • \$\begingroup\$ @PeterTaylor 1. change ~/.*term file's contents to ~. 2. & 3. That is a bug as intended. 4. will fix \$\endgroup\$ Dec 22, 2016 at 15:52
  • \$\begingroup\$ @ConorO'Brien is manpage, no? \$\endgroup\$ Dec 22, 2016 at 15:55

Irradiate The Input

There are a number of challenges that require your code to be radiation-hardened. That is, the code should still function if any character is removed. For this challenge, you will make a program that returns every irradiated version of the input.


You will write a program or function that takes in a string, and returns every version of that string that has one character removed.


Input     -> Outputs

Hey, you! -> ey, you!
             Hy, you!
             He, you!
             Hey you!
             Hey, ou!
             Hey, yu!
             Hey, yo!
             Hey, you

Outputs do not need to be in any order. Input and output may be in any reasonable format. The shortest program or function in each language wins.

  • \$\begingroup\$ What about duplicates? Does the correct output for input aa have one line or two? \$\endgroup\$ Jan 10, 2017 at 16:19
  • \$\begingroup\$ @PeterTaylor Two lines. \$\endgroup\$ Jan 10, 2017 at 16:22
  • \$\begingroup\$ @MikeBufardeci then say it as a test case :) \$\endgroup\$ Jul 18, 2017 at 14:12

Detect the Type of a Golfed Poem

Find golfed poem type
One char for each syllable
Code and golf you must

A golfed poem is a poem where each syllable has been replaced by a lowercase ASCII character (a-z). For example, here's the golf of the haiku from above:


Two lines are considered to rhyme if the last character is the same. For example, this golfed poem is a rhyming couplet:


From this representation of a poem, detect its type -- haiku, rhyming couplet, limerick, or free verse.


Write a program or function that takes a golfed poem and outputs its type.

There are 4 types of poems:

Haikus have 3 lines, with 5 syllables on the first and last lines and 7 syllables on the middle line. Example:


Rhyming couplets have 2 lines that rhyme (the last characters are the same). Example:


Limericks have 5 lines. The first, second, and fifth lines rhyme, and so do the third and fourth lines. Example:


Free verse poems are any poem that isn't one of the other poem types. Example:



Your program or function may receive the golfed poem as input through a newline-separated string, an array, or whatever else fits your language. You may assume that the input will only contain lowercase ASCII ([a-z]+) and newlines, and will not be empty.

Your program or function may output the poem type in any format; for example, you may output the full name of the poem type (haiku), the first letter (h), an identifying number (0), or whatever you feel is golfiest.

Test cases

=> haiku

=> haiku

=> rhyming couplet

=> rhyming couplet

=> limerick

=> limerick

=> free verse

=> free verse

=> free verse

=> free verse

=> free verse

=> free verse


This is , so the shortest answer wins. Happy golfing!


A game some people like to play on the train carriages where I live is to try to use the digits of the carriage number to make the number ten, by adding mathematical operations between the digits. For example, given the number 7392, you can make ten with 7 * 3 - 9 - 2 = 10.

You can split the digits how you want E.g. 5646 -> 56 - 46 = 10, however you cannot change the order of digits. In this challenge, you are also limited to using only the following characters.

  • Brackets, ()
  • Minus, -
  • Plus, +
  • Times, × or *
  • Divide, ÷ or /

The minus sign can be used for both subtraction and making numbers negative (e.g. -2 * 4 + 9 + 9). Operations are done in the standard order of operations.


Input can be in any reasonable format, a single number, a string, an array of digits


Your program must output a human readable solution, if one exists. If there is no solution, it must output nothing.

Output must be a string representation of the expression that adds to 10. You do not need to include spaces (but you can if you want), and you can have extraneous brackets.

This is , so the shortest code in bytes wins


I haven't posted on ppgc before, so any feedback would be helpful!


Polyglot OEIS

Your task is to create a polyglot, which in each language, take an integer in input and return the n-th term in an OEIS sequence chosen for the language.


  • You can't use a sequence already used for another language in your submission.
  • You must use 2+ languages.
  • You can't use a linear sequence.


The score is calculated as length / num_languages³.

  • \$\begingroup\$ Could you give some examples? \$\endgroup\$
    – user41805
    Dec 24, 2016 at 11:39
  • 1
    \$\begingroup\$ This is probably not very interesting, as there are many trivial sequences, such as oeis.org/A000012 or even non-constant output ones: oeis.org/A000027 \$\endgroup\$
    – flawr
    Dec 24, 2016 at 14:34
  • \$\begingroup\$ No linear sequences? So, you can't do something like 2x+1? \$\endgroup\$
    – FlipTack
    Dec 24, 2016 at 14:42
  • \$\begingroup\$ @Flp.Tkc No, you can't. \$\endgroup\$ Dec 24, 2016 at 14:45
  • \$\begingroup\$ Then I can use x^2 (again quite trivial) \$\endgroup\$
    – user41805
    Dec 24, 2016 at 14:59
  • \$\begingroup\$ @KritixiLithos Quite trivial in some languages, but already harder than a cat program \$\endgroup\$ Dec 24, 2016 at 15:03

Implement ALL of OEIS!

...well, not quite all of it.

Your job is to implement as many OEIS sequences as you can in 50 bytes. You are to write a single program that takes an integer k as input and outputs An(k) for all sequence numbers n implemented. You may write a function or program to do this. Here are some more rules:

  1. Each sequence should work at least until the end of the sequence on OEIS.
  2. You may not implement two sequences that are the same.
  3. You do not have to start where the OEIS sequence starts. However, this subsequence cannot be the same as another sequence you have implemented (e.g. implementing A001477(n) and A000027(n), since A000027(n) == A001477(n + 1), and would constitute such a shift described.
  4. The numbers may be yielded in any acceptable way. The only requirements on the output are:
    • Each entry must be separated by (not necessarily constant) non-numeric characters. If applicable: if your sequence has negative numbers, this separator cannot whatever you choose to represent a negative number.
    • Each number must be outputted in decimal—i.e., they must appear as they are in the OEIS sequence.
    • The ordering of each sequence in the output must be consistant. E.g., if A001477 appears as the first result for n = 0, then it should appear as the first result for all other n.

For example, the following Ruby script implements A001477 and A004086:

a=gets;puts a.to_i,a.reverse


50 sounds good, but might be unfair on a per-language basis. I doubt you could get many encoded in, say, Java. Should the limit be raised?

  • \$\begingroup\$ Do I understand right that you can have a submission like this? n=input();print n,-n,n*2,n*3,n*n \$\endgroup\$
    – xnor
    Dec 24, 2016 at 12:01
  • 2
    \$\begingroup\$ are constant sequences allowed? \$\endgroup\$
    – FlipTack
    Dec 24, 2016 at 13:24
  • \$\begingroup\$ @xnor Correct . \$\endgroup\$ Dec 24, 2016 at 20:16

Prove your language is Turing Complete

A programming language is said to be Turing complete if it can simulate a single taped Turing machine. (from Wikipedia)

In this popularity contest, your task is to design and create a program in your favorite language to prove that it is Turing complete.

You can do this in several ways, such as:

  • Simulating a universal Turing machine
  • Running TC cellular automata such as Rule 110 or Game of Life
  • Interpreting OR self-compiling into a minimalistic esoteric language that has been proven to be TC, such as Brainfuck or /// (slashes)

...but feel free to prove it in any other way you can! These are just examples. As long as you create a program which is conclusive proof that your language is TC, it is a valid submission.

As this is a pop-con the winner is the answer with the largest score (upvotes - downvote). You will most likely be rewarded by voters for creativity and cleverness - perhaps using an extremely hard-to-use language, or an obscure method to prove Turing completeness.


  • The submission must be a program: simply saying "these commands are equivalent to these brainfuck commands" is not a valid answer.
  • Any programs you write must be your own. If not, you should mark your post as community wiki.
  • Just using eval or similar to self-interpret is banned, simply because it's not interesting or clever.
  • Only Turing Complete languages may be used - for obvious reasons.

Sandbox Questions

  • Is this too broad? I assume there's going to be a lot of mixed feedback, as always with pop-cons.
  • Are there any rules I should add?
  • Which tags apply to this?
  • \$\begingroup\$ Do you need to prove that your language is turing complete, or that the program you're writing is turing complete? Please also write down a definition of what you exactly mean by turing complete. As always with a pop-con you need to include an explicit objective validity criterion. \$\endgroup\$
    – flawr
    Dec 25, 2016 at 14:51
  • \$\begingroup\$ @flawr As the title says, it's about proving your language is TC. Thanks for the feedback, I'll try and add some more detail. \$\endgroup\$
    – FlipTack
    Dec 25, 2016 at 14:53
  • \$\begingroup\$ How about a program that compiles a known TC language to your language? That shows it to be TC by the existence of a correspondence. \$\endgroup\$ Dec 25, 2016 at 17:30
  • \$\begingroup\$ @ConorOBrien yep, that would be allowed \$\endgroup\$
    – FlipTack
    Dec 25, 2016 at 17:31
  • \$\begingroup\$ This is a very interesting question. +1 As for the tags, I'm not sure, you could do code-golf where the task is finding the shortest possible proof in every language, but in my opinion keeping it a popularity-contest may encourage some quite interesting answers that need not be concerned by byte-size alone. \$\endgroup\$ Dec 25, 2016 at 18:34
  • \$\begingroup\$ I think you should probably outright ban string eval. It's also worth noting that a) it's often easier to prove a language TC by compiling into it, rather than by writing an interpreter in it, and b) there's some debate as to whether a language that can write an interpreter for a TC language is necessarily TC itself. \$\endgroup\$
    – user62131
    Dec 26, 2016 at 4:15
  • \$\begingroup\$ @ais523 the problem is, i wanted submissions to be a program, and compiling into a TC language is just a list of substitutions. Unless you meant creating a self-compiler? \$\endgroup\$
    – FlipTack
    Dec 26, 2016 at 15:09
  • \$\begingroup\$ @ais523 also, part of the reason I've set it as a pop-con is because writing rules about what counts as proof would be nearly impossible - a pop-con allows popular vote to decide what is valid, and downvote what is obviously cheating. \$\endgroup\$
    – FlipTack
    Dec 26, 2016 at 15:11
  • \$\begingroup\$ This will most likely get closed as too broad as a pop con. Also, pop cons still need an objective validity criterion; if the validity criterion is unclear as a ode golf, it is also unclear as a pop con. \$\endgroup\$
    – Dennis
    Dec 26, 2016 at 15:25
  • 1
    \$\begingroup\$ It doesn't make sense to me to write a program to prove a language is Turing complete. The claim is a mathematical statement and so a proof should be a series of logical logical deduction. It looks to me like you just want emulators of known simpler Turing-complete languages (the existence of which is one proof method for TC), in which case the spec should require just that. \$\endgroup\$
    – xnor
    Dec 28, 2016 at 20:20
  • \$\begingroup\$ There's a difficulty that the languages this will be interested for are Esolangs and usually the Esolang wiki for basically all entries has a proof or disproof of some sort for Turing completeness. \$\endgroup\$
    – walpen
    Dec 29, 2016 at 3:14

Name that pentomino!

There are a total of 12 different pentominoes, shapes made out of 5 squares: enter image description here

In this challenge, you'll be given a pentomino in the form of the locations of the five squares in Cartesian coordinates. Your program must output the letter name of that pentomino, as shown in the image above. The pentomino won't be rotated at 45 degrees like some of the ones in the image, but other than that it may be rotated, reflected, or translated arbitrarily.


Your input will be a list containing 5 pairs of integers, in any reasonable format. You can assume that each integer is between 1 and 1000, and that the coordinates give a valid pentomino.


The output should be a single character - either F, I, L, N, P, T, U, V, W, X, Y, or Z - depending on which pentomino the input coordinates represent.

Test cases:

Input -> Output
[(2, 1), (1, 2), (2, 2), (2, 3), (3, 3)] -> F
[(1, 1), (1, 2), (1, 3), (1, 4), (1, 5)] -> I
[(1, 1), (2, 1), (1, 2), (1, 3), (1, 4)] -> L
[(1, 1), (1, 2), (2, 2), (2, 3), (2, 4)] -> N
[(1, 1), (1, 2), (2, 3), (2, 2), (1, 3)] -> P
[(1, 3), (3, 3), (2, 3), (2, 2), (2, 1)] -> T
[(1, 1), (1, 2), (2, 1), (3, 1), (3, 2)] -> U
[(1, 1), (2, 1), (3, 1), (3, 2), (3, 3)] -> V
[(1, 1), (2, 1), (2, 2), (3, 2), (3, 3)] -> W
[(2, 1), (1, 2), (2, 3), (3, 2), (2, 3)] -> X
[(1, 1), (2, 1), (3, 1), (4, 1), (3, 2)] -> Y
[(1, 3), (2, 3), (2, 2), (2, 1), (3, 1)] -> Z

[(3, 6), (4, 6), (5, 6), (3, 5), (4, 5)] -> P
[(7, 7), (8, 6), (7, 6), (9, 6), (8, 5)] -> F

This is code-golf, so the shortest answer in bytes wins!

(Note to sandbox viewers: I'm not sure whether I should go with the fixed output system that's there now, or if I should allow arbitrary (but consistent) output formats. If anyone has a strong opinion about this, leave a comment!)

  • \$\begingroup\$ Did you make the image yourself? If not, you should probably credit the source. About the output format, it's best to require a single character that's the character given, but to not make rules about how that character is output (e.g. it could go to stdout, be displayed on the screen, or output as its ASCII code). \$\endgroup\$
    – user62131
    Dec 31, 2016 at 22:39

Re-Implement tail in your favorite language!

The Challenge

For the Linux users on PPCG, you know what tail does. For those who don't know, tail outputs the last n lines of a file or STDIN.

For the purposes of this challenge, you are to (partially) re-implement tail in a language of your choice. However, to make everything simpler, only the following requirements will be enforced:

  • Your program will only be taking input from STDIN (or equivalent).
  • Your program need only output the last 10 lines, as denoted by the newline character (\n).
  • Your program must output a trailing newline.
  • Your program must output to STDOUT (or equivalent).

You may assume that your program will always be passed text.


This is , so the shortest answer (in bytes) wins.

  • \$\begingroup\$ I recommend you be more flexible with the output format - specifically, drop the "trailing newline necessary" rule. \$\endgroup\$
    – FlipTack
    Dec 30, 2016 at 13:35
  • \$\begingroup\$ Also, in environments where input is line-buffered, how should multi-line input be taken? Are function submissions allowed? \$\endgroup\$
    – FlipTack
    Dec 30, 2016 at 13:36
  • \$\begingroup\$ @FlipTack: Actually, I'd recommend specifying that the input will always have a trailing newline. That way, the correct output will always have a trailing newline too, but you could do it by copying from the input. \$\endgroup\$
    – user62131
    Dec 31, 2016 at 22:37

A range of operations on the same inputs

Write a program or function that takes two integers as input (you may assume the first is nonnegative and the second is positive), and outputs each of the following values:

  • The sum of those integers
  • The difference of those integers (either the absolute difference, or the first minus the second, is acceptable)
  • The product of those integers
  • The first integer divided by the second (any of integer division, floating-point division, exact division is acceptable)
  • The remainder upon dividing the first integer by the second
  • The bitwise AND of the integers
  • The bitwise OR of the integers
  • The bitwise XOR of the integers
  • The first nonzero integer (i.e. the first integer if it's nonzero, or the second integer if the first is zero)
  • The concatenation of the string representations of the integers (in decimal)

This is , so the shortest program wins. Good luck!

Sandbox notes

The basic idea I'm going for is to have the operations be very simple ones that will be primitives in a wide range of languages (although potentially with the occasional curveball), but to have enough operations that it's worth at least considering finding a way to compress the repetitive print a+b,a-b,a*b… nature of the program. At the moment, there probably aren't enough for compression to be worth it except in the occasional golfing language, but adding more operations runs the risk of requiring something to be done that's nontrivial in its own right or hard to compress. (Actually, even writing the uncompressed version can be fairly interesting in many golfing languages, as this sort of operation that reuses multiple inputs is quite different from the more common situation where the input of each operation is the output of the one before.)

Also, is this a duplicate? I didn't find one but it's a hard sort of problem to search for.

  • \$\begingroup\$ Although this is interesting, I'm not sure if it will be well received, as it's just a list of trivial operations that are too trivial to be challenges on their own. \$\endgroup\$
    – FlipTack
    Jan 1, 2017 at 17:48
  • \$\begingroup\$ Can concatenation of the string representations have a leading 0? \$\endgroup\$
    – FlipTack
    Jan 1, 2017 at 17:51
  • \$\begingroup\$ It's in the spirit of this challenge to allow the simplest possible implementations of the operations, so I'd say it's OK if you add or remove a leading 0 that shouldn't be there. \$\endgroup\$
    – user62131
    Jan 1, 2017 at 22:29

Linear Regression on Strings

This challenge is a little tricky, but rather simple, given a string s:


Use the position of the character in the string as an x coordinate and the ascii value as a y coordinate. For the above string, the resultant set of coordinates would be:

0, 109
1, 101
2, 116
3, 97
4, 46
5, 99
6, 111
7, 100
8, 101
9, 103

Next, you must calculate both the slope and the y-intercept of the set you've garnered using linear regression, here's the set above plotted:


Which results in a best fit line of:

y = 0.014516129032258x + 99.266129032258

So your program would return:

f("meta.codegolf.stackexchange.com") = [0.014516129032258, 99.266129032258]

Some clarifying rules:

- Strings are 0-indexed or 1 indexed both are acceptable.
- Output may be on new lines, as a tuple, as an array or any other format.
- Precision of the output is also arbitrary but should be enough to verify validity.

This is lowest byte-count wins.

  • \$\begingroup\$ Very cool idea. Already trying to figure out how to implement this \$\endgroup\$ Jan 9, 2017 at 0:54
57 58
60 61

You must log in to answer this question.

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