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


4562 Answers 4562

25 26
28 29

Sum of consecutive nth powers


How many ways to cut a number into an equation?


Play a game of memory

  • \$\begingroup\$ Suggest test case "cbxcxvbaav", 8 \$\endgroup\$
    – math scat
    Sep 12 at 12:37
  • \$\begingroup\$ @mathscat Added, thank you. \$\endgroup\$
    – Philippos
    Sep 12 at 12:58
  • 1
    \$\begingroup\$ @bsoelch In Memory you pick the cards in order, so you can adjust the second card based on the first, so if you see the first has a match you can choose that match as the second card \$\endgroup\$ Sep 12 at 19:32

Numbers with distinct decimal digits


Implement Subleq

  • \$\begingroup\$ @bsoelch Fixed. \$\endgroup\$ Sep 19 at 17:40
  • \$\begingroup\$ @bsoelch That was a mistake on my part as well, I'll replace the example. \$\endgroup\$ Sep 20 at 18:38

Do you win a Numeric Mahjong?

  • \$\begingroup\$ why do we need the first rule? That would be like restricting languages made after posting this question \$\endgroup\$ Sep 19 at 12:41
  • \$\begingroup\$ @UndoneStudios Now that I think of it, fractional byte encodings seem fine. Variable length encodings (like Vyncode) are a problem, because they don't really define a mapping from a char in source to an integer. \$\endgroup\$
    – Bubbler
    Sep 19 at 23:36
  • \$\begingroup\$ This should be a question to raise in meta \$\endgroup\$ Sep 20 at 3:55
  • \$\begingroup\$ @UndoneStudios The rule is needed to define how to convert a source code to a list of integers. It totally isn't like "restricting languages made after posting this question". All languages can participate as long as they have a textual or byte representation (which practically all languages used on the site do). Only some encodings of some languages are not allowed. \$\endgroup\$
    – Bubbler
    Sep 20 at 4:19
  • \$\begingroup\$ Well, technically, I was only against variable encodings; that is cheaty \$\endgroup\$ Sep 20 at 4:21

I (rev)?(pal)? the source code, you (rev)?(pal)? the input!


Complete an equivalence relation

In set theory, a relation from a set \$A\$ to a set \$B\$ is a set of pairs of elements from \$A\$ and \$B\$. For example, \$\{(1, 5), (1, 6), (2, 4), (3, 5)\}\$ is a relation from the set \$\{1, 2, 3\}\$ to the set \$\{4, 5, 6\}\$.

A relation \$R\$ from a set \$A\$ to itself is an equivalence relation iff:

  • It is reflexive: For all elements of \$A\$, \$(a, a)\$ is in \$R\$.
  • It is symmetric: If a pair \$(a, b)\$ is in \$R\$, then so is \$(b, a)\$.
  • It is transitive: If the pairs \$(a, b)\$ and \$(b, c)\$ are in \$R\$, then so is \$(a, c)\$.

For example, \$\{(1, 1), (1, 2), (2, 1), (2, 2), (3, 3)\}\$ is an equivalence relation on the set \$\{1, 2, 3\}\$.

Your challenge is to, given a relation from a set to itself, add as few pairs of elements as possible to transform it into an equivalence relation.

Worked example

If we start with the relation \$\{(1, 2), (3, 2), (4, 4)\}\$, then:

Firstly, the relation must be reflexive, so all pairs of elements \$(a, a)\$ must be added, resulting in \$\{(1, 2), (3, 2), (4, 4), (1, 1), (2, 2), (3, 3)\}\$.

Next, the relation must be symmetric, so we need to add the inverses of \$(1, 2)\$ and \$(3, 2)\$, resulting in \$\{(1, 2), (3, 2), (4, 4), (1, 1), (2, 2), (3, 3), (2, 1), (2, 3)\}\$.

Finally, the relation must be transitive. Since \$(1, 2)\$ and \$(2, 3)\$ are in the relation, so must be \$(1, 3)\$, and likewise \$(3, 1)\$ must also be in the relation. Adding these results in \$\{(1, 2), (3, 2), (4, 4), (1, 1), (2, 2), (3, 3), (2, 1), (2, 3), (1, 3), (3, 1)\}\$, and this is an equivalence relation.

Input/output is can be lists of pairs of positive integers, or an adjacency matrix. You can optionally take the domain of the relation (i.e. all unique values in it). The order in which you output the pairs does not matter, and you can assume the input will be nonempty.


{(1, 1)} -> {(1, 1)}
{(1, 2)} -> {(1, 2), (1, 1), (2, 2), (2, 1)}
{(1, 2), (3, 4)} -> {(1, 2), (1, 1), (2, 2), (2, 1), (3, 4), (3, 3), (4, 4), (4, 3)}
{(1, 2), (1, 3)} -> {(1, 2), (1, 3), (1, 1), (2, 2), (3, 3), (2, 1), (3, 1), (2, 3), (3, 2)}
{(1, 1), (2, 2), (3, 3)} -> {(1, 1), (2, 2), (3, 3)}
{(1, 1), (2, 2), (3, 4)} -> {(1, 1), (2, 2), (3, 3), (3, 4), (4, 3)}
{(1, 2), (3, 2), (4, 1)} -> {(1, 1), (2, 2), (3, 3), (4, 4), (1, 2), (1, 3), (1, 4), (2, 1), (2, 3), (2, 4), (3, 1), (3, 2), (3, 4), (4, 1), (4, 2), (4, 3)}
{(8, 19), (4, 12), (9, 31), (4, 18)} -> {(8, 8), (8, 19), (19, 8), (19, 19), (4, 4), (4, 12), (4, 18), (12, 4), (12, 12), (12, 18), (18, 4), (18, 12), (18, 18), (9, 9), (9, 31), (31, 9), (31, 31)}
{(8, 7), (2, 7), (14, 3), (3, 16)} -> {(2, 2), (2, 7), (2, 8), (7, 2), (7, 7), (7, 8), (8, 2), (8, 7), (8, 8), (3, 3), (3, 14), (3, 16), (14, 3), (14, 14), (14, 16), (16, 3), (16, 14), (16, 16)}
{(1, 1), (1, 2)} -> {(1, 1), (1, 2), (2, 1), (2, 2)}
  • \$\begingroup\$ Could output be loosened to not require outputting pairs already in the input? Although for some reason I feel iffy about going in between, i.e. allowing the output to contain some input pairs without requiring it to contain all of them... \$\endgroup\$ Sep 27 at 8:47
  • 1
    \$\begingroup\$ @UnrelatedString What exactly are you thinking of when you say that? I can't think of any reasonable approach which would necessitate that. Besides, the point of the challenge is to create the minimal superset that's an equivalence relation. \$\endgroup\$
    – emanresu A
    Sep 27 at 20:17
  • \$\begingroup\$ I was mostly inspired by the phrase "add as few pairs of elements as possible"--thinking about the interplay between symmetry and transitivity, it seems unlikely any solution would actually benefit from only outputting the added pairs, which makes me kinda curious about leaving the option open. \$\endgroup\$ Sep 28 at 3:24
  • \$\begingroup\$ Do you have to deduce the set or can you take it as input? Can you use adjacency matrices? Can you output the equivalence classes? \$\endgroup\$ Sep 28 at 9:13
  • \$\begingroup\$ Possible dupe \$\endgroup\$ Sep 28 at 9:18
  • \$\begingroup\$ @CommandMaster I'll allow taking the domain as input, and I/O as adjacency matrices. I'm not going to allow outputting the equivalence classes because I can think of several approaches that wouldn't even compute them and I want things to stay semiconsistent. I don't think this is a dupe for two reasons: one, that challenge requires outputting the number of sets to add which a lot of answers take advantage of; two, while transitivity is the hard part of this challenge, incorporating reflexivity and symmetry into an answer from there is still nontrivial. \$\endgroup\$
    – emanresu A
    Sep 29 at 1:27
  • \$\begingroup\$ are delimiters required? or can i take {(1, 2), (3, 4)} as 1 2 3 4 and output 1 2 1 1 2 2 2 1 3 4 3 3 4 4 4 3? \$\endgroup\$ Sep 29 at 2:25
  • 1
    \$\begingroup\$ @thejonymyster Since it's a list of pairs, sure, that's fine. I believe taking a flattened list is in the I/O defaults anyway \$\endgroup\$
    – emanresu A
    Sep 29 at 2:26

The multiples are missing


? ? ?

Golfy Fairy Chess Notation + Validation

Step 1:

Design an encoding for fairy chess piece movement which encodes all of the following information:

  • Where a piece can move (INCLUDING arbitrary length movement)*
  • Whether those movements are "jumping" or not
  • Whether those movements are "capturing" or not**

You don't need to handle non-moving, royalty, special case movement (such as first move double-movement), or any other special stuff like that.

Step 2:

Write a program which, when given (A):

  • a chess position***
  • a starting square
  • an ending square

all in any reasonable format of your choice, as well as (B):

  • a description of a fairy chess piece's movement capabilities in the notation you designed in step 1

will output whether the movement on the board (A) is valid for that fairy chess piece (B)

Additional spec clarification

You may assume

  • All pieces other than the piece being moved are pawns
  • The fairy chess piece is the piece that will be moved
  • The fairy chess piece movement will be defined such that it could theoretically make a move, given the right board arrangement (i.e. no 'non-movers')
  • Movement will be entirely within the board
  • Board will be square and at least 2x2 in size
  • Piece will not attempt to capture its own teammates
  • Piece will not attempt to move to its own square, and you don't need to worry about whether the notation implies it should/shouldn't be able to.

You may not assume an 8x8 board.


\$(\text{bytes in program})\times(\text{average bytes to represent each piece in (list of fairy chess pieces which will be provided)})\$

Lowest score wins

Optional challenge: try and make the format human legible! :-)


*I will be sure to clarify in the question body how exactly this works; but basically i want to be able to include things like rook/bishop/queen/knightrider without having to assume a maximum movement distance

**I'll also be clear that pieces can only capture at the end of their move, so no multicapture or capture and then move / en passant nonsense :P

***I don't know how to explain, but this doesnt have to include which pieces are what. just where the pieces are and whether each piece is on your team or not, or something similarly simple

****Ideally, score would be based on both short notation as well as a short decoding program, but I'm not sure the exact balance yet. feel free to tell me this is a bad idea / throw your algo of choice at me, but i'll be studying other compression challenges as well

  • \$\begingroup\$ Heads up: It looks like the bullet-point formatting in the first list under step 2 is wrong (missing newlines?). \$\endgroup\$ Oct 6 at 14:53
  • \$\begingroup\$ @SuperStormer great catch, that wouldve taken forever for me to notice lol thank you \$\endgroup\$ Oct 6 at 15:32

Find the k-th largest number

Given the string representation of three sorted lists, get the k-th largest number.

The string representation has such form:

1 3 5 7 11 120 9988
23 68 99 111
107 131 888

aka. lists are separated by newline \n and numbers in one list are separated by space.

Length of each list, length of the string and k are directly given, but access to the string costs. You can fetch from a given position. Least fetches wins.

Your solution should handle all possible inputs well, but only optimize score for average cases.

This is an example solution. It solves the problem with an awful score, but you can also use lib here. Write the lib if it's absent in your language.

Sorted lists in test cases will be generated in this way:

  • Generate 1 million (1'000'000) integers uniformly in \$\left[0, 2^{31}-1\right]\$. Duplicates will likely appear.
  • Sort them.

[Not decided yet] It's fine if your code is only optimized for three 1M length arrays and fallback to worst solution for other input.

  • \$\begingroup\$ You should clarify what "average case" means. From what distribution are the inputs taken? Additionally, can there be duplicates in the lists? \$\endgroup\$ Oct 11 at 3:35
  • \$\begingroup\$ @CommandMaster Added \$\endgroup\$
    – l4m2
    Oct 11 at 8:35

Make Code Printing X without X

The challenge is simple: write a program which takes in some string \$n\$ consisting of only uppercase and lowercase letters, and outputs the code for a program (in the same language) which takes in no input and outputs \$n\$. However, the code your program generates must not have any of the characters of \$n\$. For example, if your program was in Python, if the input was "Lit", your output could not be print("Lit"), because that contains L, i, and t. One valid output would be, for example, x=lambda:'\114\151\164'.

Some notes:

  • Uppercase and lowercase characters are treated as distinct -- e.g. if the input string contains A, your generated code can still contain the character a.
  • Your generated code follows the same restrictions as a standard code golf answer -- e.g. it can be code which defines an anonymous function returning the string, but it cannot work by saving the string into a variable.
  • Your submission is scored by the length of the generating code, not the generated code. In addition, there are no restrictions on the source of the generating program, only the generated.

Standard loopholes are forbidden. As this is , shortest program wins.


I don't know what to call this challenge.

  • 1
    \$\begingroup\$ code-generation \$\endgroup\$
    – noodle man
    Oct 15 at 3:37
  • 1
    \$\begingroup\$ Because of the possibility that input contains all letters, all answers would likely never output letters \$\endgroup\$
    – l4m2
    Oct 16 at 0:32
  • \$\begingroup\$ @l4m2 Hm.... I somehow didn't think of that; that means this challenge isn't possible in many languages. I could add a limit on the number of distinct characters which can occur in the input, but that feels inelegant. Other thoughts? \$\endgroup\$ Oct 16 at 21:59

Is it a valid crossword grid?

In crossword terminology, the grid is the region into which the crossword answers are inserted, consisting of white and black squares. The crossword answers, called entries, are inserted into contiguous sequences of white squares in a row or column, separated by black squares.

For British (and Commonwealth) crosswords, the grids usually follow a specific set of rules:

  • They should have 180 degree rotational symmetry (if there is a black square in the xth row and yth column, there should be a black square in the xth-to-last row and y th-to-last column).
  • No entries may be exactly two squares long.
  • All white squares must be joined in a single region.
  • No row/column can be completely filled with black squares.
  • Each two-by-two square must contain at least one white square.
  • Each two-by-three rectangle must contain at least one black square.

For n=3 there is only one valid grid (I'm using . for white squares and # for black squares):


For n=4 there are no valid grids, although British crosswords usually use odd n anyway.

Here are some examples of valid grids for n=5:

.....  .....  #.#.#  ###.#
.#.#.  .###.  .....  #....
.....  .....  #.#.#  #.#.#
.#.#.  .###.  .....  ....#
.....  .....  #.#.#  #.###

Here are two examples of valid grids for n=6:

......  ......
.##.#.  .##.#.
.#....  ....#.
....#.  .#....
.#.##.  .#.##.
......  ......

Input may be in the form of an array of any two byte-sized values and output can be any two distinct values of your choice or any of your language's truthy or falsy values respectively.

This is , so the shortest program or function that breaks no standard loopholes wins!

  • \$\begingroup\$ .................... :) \$\endgroup\$ Oct 16 at 21:57

Befunge Comment Outline Creator

  • \$\begingroup\$ Is it equivalent to a 0-1 matrix with an even sum in each row/column? Additionally, I'm assuming an all-space answer is invalid, but I don't see any rule disallowing it. Could you add one? \$\endgroup\$ Oct 20 at 6:26
  • \$\begingroup\$ @CommandMaster Almost, however having no semicolons at all would result in the IP reading in the comment as code. I could probably clarify that. \$\endgroup\$ Oct 20 at 6:36
  • \$\begingroup\$ Can I take as input w+2, h+2 instead of w, h? \$\endgroup\$ Oct 21 at 6:35
  • \$\begingroup\$ @CommandMaster Is it too expensive to add 2 to the inputs? \$\endgroup\$ Oct 21 at 7:04
  • \$\begingroup\$ I haven't tried, and w, h might be shorter, but it might be easier to use the size of the output instead of the size of the comment itself \$\endgroup\$ Oct 21 at 7:06
  • \$\begingroup\$ @CommandMaster Hm, I may consider it, it doesn't seem like it would be unfair \$\endgroup\$ Oct 21 at 7:10

Minecraft XP Orb Amounts


Intersections in a Circular Scrambled Word

Given a word W and a scrambled version of it S as input, you are required to return the number of intersections S will have when organized in a circular arrangement.


Let W be VICTORY and S be VICYTRO. After transforming the scrambled word in its circular form and forming the original word by adding segments between the characters, we have the following diagram:

enter image description here

As we can see, for this particular example, the expected output is 2 interceptions.


  • Input will consist only of [A-Z] characters.
  • It is irrelevant how you set up the circular word (clockwise, counterclockwise, if the characters are evenly spaced from one another or not), just be consistent.
  • Input is flexible, read it however you see fit for you.
  • Standard loopholes are not allowed.

Test Cases

W , S  --> output

# To be added more 

This is , so shortest answers in bytes wins!


Is the challenge interesting? Is there anything unclear? I am not a native English speaker, so I welcome any corrections on the wording of the challenge.

I will later add more test cases. Also, what is the general consensus here where there are multiple correct answers? Because when I add words with repeated letters, depending on the "path" you choose when forming the circular word, it will affect the number of intersections. (I'll update the specs section as well when I introduce these special cases).

Lastly, I didn't give much thought on my second point in the specs section, maybe it's wrong... I'll observe more cases later.

Pretty much any feedback is appreciated!

  • 2
    \$\begingroup\$ Could take input as a permutation of 1..n, to get rid of worrying about repeated letter ambiguity as well as some potential for a "chameleon challenge" (i.e. determining the permutation between the two words could be highly nontrivial in some languages and overshadow the actual "core" of intersections between circle chords). If you do want solutions to have to handle repeats, then I'd recommend just allowing them to give any of the possible outputs. \$\endgroup\$ Oct 29 at 19:52
  • 1
    \$\begingroup\$ re. multiple possible outputs: challenges often specify that submissions may choose to either output all possible outputs or just one of them. \$\endgroup\$
    – noodle man
    Oct 29 at 20:10
  • \$\begingroup\$ I suggest to write W and S instead of W and S to avoid confusion, because those are just names, no data. \$\endgroup\$
    – Philippos
    Oct 31 at 12:44

Seat gangs as far as possible

  • \$\begingroup\$ @noodleman No, the gangs can be any (non-zero) size -- \$k\$ is the number of gangs. \$\endgroup\$ Oct 31 at 17:45
  • 1
    \$\begingroup\$ Suggest test case 1,2,1,2,1 -> 1,1,1,2,2 \$\endgroup\$
    – noodle man
    Oct 31 at 17:46

Calculate a struct size

In C and C++, the size of a structure depends not only on the sizes of its members but also their alignment requirements.

This problem will assume a simple case in which each structure is made up of primitive types that have a size that is a power of two and an alignment that equals their size.

Given a list of the types in a structure, please output the resulting size of the structure.

Here is an example structure:

struct {
  char c[5];
  int i, j;
  short s[3];

Input in any of the following formats is acceptable:

  • A list of the sizes of the individual types that make up the structure; for the above that would be [1, 1, 1, 1, 1, 4, 4, 2, 2]
  • A list giving the lengths of each array and the sizes of its elements, which for the above would be [[5, 1], [1, 4], [1, 4], [3, 2]]
  • A list giving the size and alignment of each variable, which for the above would be [[5, 1], [4, 4], [4, 4], [6, 2]]

(The third format indirectly supports nested structures but this can be emulated for the other formats by replacing them with an array of the same size and alignment.)

The size of the above structure is 24. Here is how it is calculated:

  1. Each of the 5 chars consumes 1 byte each, making 5.
  2. Each int requires an alignment of 4, so there are three bytes of padding before the first of them. The total size is now 16.
  3. Each of the 3 shorts consume 2 bytes each. The total size is now 22.
  4. The entire structure has an alignment of the largest alignment of any member, which in this case is 4, so the size must be rounded up to the next multiple of 4, which is 24.


c[0] c[1] c[2] c[3]
c[4] ..............
s[0]_____ s[1]_____
s[2]_____ .........

This is , so the shortest program or function that breaks no standard loopholes wins!


Golf Transmission

As in, the 5 speed transmission from the original VW Golf GTI.

Print the transmission pattern in as few bytes as possible.

1  3  5
|  |  | 
|  |  |
2  4  R

  • 1
    \$\begingroup\$ this pun was too good to pass up \$\endgroup\$ Nov 16 at 14:50

Derive an MIU string

The MU puzzle in Douglas Hofstadter's Gödel, Escher, Bach involves a simple formal system called "MIU". It works as follows:

  • MI is an MIU-string
  • If xI is an MIU-string, then so is xIU.
  • If Mx is an MIU-string, then so is Mxx.
  • If xIIIy is an MIU-string, then so is xUy.
  • If xUUy is an MIU-string, then so is xy.

Your task, given an MIU-string, is to output a derivation of that string starting with MI and ending with the input string.

You can assume that the input is in fact a valid MIU-string and not something illegal like MCMLXVIII or (spoiler) MU.

Instead of taking input as strings of MIU, you can choose to take input as arbitrary precision integers using the digits 3 for M, 1 for I and 0 for U. In that case your output would start with 31, which represents MI.



This is , so the shortest program or function that breaks no standard loopholes wins.

  • \$\begingroup\$ Related. Personally a bit surprised there doesn't seem to be a dupe. \$\endgroup\$ Nov 23 at 6:03
  • \$\begingroup\$ @FryAmTheEggman Unless there's way to solve possibility using some other properties, they'd be too similar \$\endgroup\$
    – l4m2
    Nov 30 at 7:25
  • \$\begingroup\$ @l4m2 Personally, I think the guarantee of reachability makes them sufficiently different. It is possible that brute force is still the golfiest solution, but even then, not having to handle the fail case seems like a significant factor. I could certainly be wrong, though. \$\endgroup\$ Nov 30 at 18:20
  • \$\begingroup\$ @FryAmTheEggman Don't a trivial upperbound exist? \$\endgroup\$
    – l4m2
    Dec 1 at 0:41

Just another traffic jam!

  • 1
    \$\begingroup\$ Can you specify the zip-lock system? \$\endgroup\$
    – Seggan
    Nov 27 at 19:53
  • \$\begingroup\$ @Seggan I added that, thank you. I somehow thought this would be internationally known. \$\endgroup\$
    – Philippos
    Nov 28 at 6:49

Longest irreducible quine

Write an irreducible proper quine, i.e. a program that prints its own source code, which can't be reduced by removing characters to a shorter program with the same constraints.

Eg. the python quine:


can be reduced to the quine


thus it is not irreducible, although the program below is.

Standard Loopholes apply, this and this in particular.
The longest answer wins.

  • \$\begingroup\$ Would a submission be valid if it can be reduced to an improper quine, but not to a proper one? \$\endgroup\$
    – noodle man
    Dec 4 at 17:17
  • \$\begingroup\$ @noodleman ty, clarified \$\endgroup\$
    – math scat
    Dec 4 at 20:33
  • \$\begingroup\$ In most languages it will be possible to make it longer by somehow splitting it, but you can't reduce it by only removing characters, but you also need to change some. I never saw a good »longest« challenge, and I doubt this will be the first. \$\endgroup\$
    – Philippos
    Dec 5 at 6:40
  • \$\begingroup\$ @Philippos not quite sure how this would work, care to give an example? \$\endgroup\$
    – math scat
    Dec 5 at 12:33
  • 2
    \$\begingroup\$ @Philippos This is wrong - it easily follows from Higman's lemma that in all languages (they don't even have to be computable!) there is only a finite number of irreducible programs which perform a given task, so in particular the length must be bounded. \$\endgroup\$ Dec 5 at 16:28
  • \$\begingroup\$ @CommandMaster thanks for clarifying! \$\endgroup\$
    – math scat
    Dec 5 at 16:32
  • \$\begingroup\$ An example: You can split your example like v='%r;print("v="+v%%v)';print("v="+v%v) Easy to reduce, but not only by only removing bytes. \$\endgroup\$
    – Philippos
    Dec 6 at 8:08
  • \$\begingroup\$ @Philippos Sure, but I don't see how this can be extended further indefinitely. (Granted, I'm not very experienced with quines/irreducible code) \$\endgroup\$
    – math scat
    Dec 6 at 15:19
  • \$\begingroup\$ You could continue like v='%r;pront("v="+v.replace(chr(111),"i")%%v)';print("v="+v.replace(chr(111),"i")%v), which of course could be repeated similarly many times without possible reduction. \$\endgroup\$
    – Philippos
    2 days ago
  • \$\begingroup\$ @CommandMaster I don't know whether Higman's lemma can be appllied here. Even if it can, the length border could be somewhere in the thousands, millions, billions ... \$\endgroup\$
    – Philippos
    2 days ago
  • \$\begingroup\$ @Philippos I know it can be large, but that's the point of the challenge. Why couldn't it be applied? If you look at the set of all irreducible programs performing a particular task, no element of that set is a subsequence of another element, so it must be finite. \$\endgroup\$ 2 days ago
  • \$\begingroup\$ @CommandMaster Well, math scat may give it a try, but still I believe it won't be fun, because the people will lose interest before reaching any border. Or I'm wrong (rumours claim this did already happen before ;-) \$\endgroup\$
    – Philippos
    2 days ago
  • \$\begingroup\$ @Philippos This irreducible code bowling challenge was very well received, I don't see why this will be worse \$\endgroup\$ 2 days ago
  • \$\begingroup\$ @CommandMaster One look at the exponents is enough for me to walk away. \$\endgroup\$
    – Philippos
    2 days ago

Cyclically Sort a List

Given a list of Integers greater than zero, Sort each of the unique values in ascending order, then repeat the process on the remaining duplicate values and append.


[1,5,2,2,8,3,5,2,9] ==> [1,2,3,5,8,9,2,5,2]


Huffman Decoding

Write a programm which takes two strings as input and prints a text.

The first argument is a Huffman Tree, serialized in the following format:

  • every ascii character except ~ is always a leaf, if ~ is the first characater it is also a leaf.
  • <tree0><tree1>~ is a tree where <tree0> is the left subtree and <tree1> is the right subtree.

Example: ab~cde~~~ generates this tree:

┌┴┐ ┌┴─┐
a b c ┌┴┐
      d e

where a would have the key 00, b 01, c 10, d 110 and e the key 111.

The second argument is a text that has been compressed with with the Huffman code that is defined by the first parameter. This bit-string can contain any bit sequence (also null-bytes and non-printable characters) and is not byte aligned, therefore it has been encoded with a variation of the standard Base64 encoding:

  • the characters used for the encoding are the standard base64 characters: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/
  • the bitstring is broken up into 6-bit chunks and mapped to this characters
  • if the last chunk is smaller than 6 bits, a character with this prefix is used, and padding characters are added to the string:
  • - : the last chunk was five bits long
  • = : the last chunk was four bits long
  • =- : the last chunk was three bits long
  • == : the last chunk was two bits long
  • ==- : the last chunk was one bit long


bits:       1 1 1 1 0 1 1 0 1 0 0 1 1 1 0 1 0 1 0 0 0 1 1 0 1
chunks:    |1 1 1 1 0 1|1 0 1 0 0 1|1 1 0 1 0 1|0 0 0 1 1 0|1[0 0 0 0 0]|
characters:       9           p           1           G           g
base64:     9p1Gg==-

Your programm has to decode the text encoded in the second parameter and print it to stdout.

You have to provide your source code encoded in the way described above. The length of your encoded source code + the length of your serialized huffman tree will be the winning criterion.

TODO: example input

  • \$\begingroup\$ It would be helpful to explicitly state the 64 characters used in the encoding. I presume they're A-Za-z0-9+/ but (especially if you're expecting people to implement that part explicitly) it's best to make the problem self-contained. \$\endgroup\$ Oct 8, 2012 at 16:23
  • \$\begingroup\$ Hello! This looks like a good but abandoned meta post, would you be willing to offer it for adoption? (If you want to, you can still post to main.) \$\endgroup\$
    – user58826
    Jun 9, 2017 at 15:30

Polygon prefixes

Polygons are named after the number of sides that they have. A pentagon has 5 sides, an octagon has 8 sides. But how are they named? What's the name for a 248-sided polygon?

All polygons are suffixed with -gon. There are specific prefixes for each polygon depending on the number of sides. Here are the prefixes for the lower numbers:

3 - tri
4 - tetra
5 - penta
6 - hexa
7 - hepta
8 - octa
9 - nona
10 - deca
11 - undeca
12 - dodeca
13 - triskaideca
14 - tetradeca
15 - pentadeca
16 - hexadeca
17 - heptadeca
18 - octadeca
19 - nonadeca
20 - icosa

Polygons with 21 to 99 sides have a different system. Take the prefix for the tens digit (found on the left column), the ones digit (right column below), and then stick a "kai" between them to get (tens)(ones)gon.

20 - icosi       | 1 - hena
30 - triaconta   | 2 - di
40 - tetraconta  | 3 - tri
50 - pentaconta  | 4 - tetra
60 - hexaconta   | 5 - penta
70 - heptaconta  | 6 - hexa
80 - octaconta   | 7 - hepta
90 - nonaconta   | 8 - octa
                 | 9 - nona

The 3-digit sided polygons are named in a similar fashion. A 100-sided polygon is called a hectogon. Take the hundreds digit, find it on the column for ones digits, then stick a "hecta" to its right. Now number off the tens and ones like above: (hundreds)hecta(tens)(ones)gon. If the hundreds place digit is a 1, don't put the prefix behind "hecta".

So, given an integer (3 <= n <= 999), return the name of an n-sided polygon. n-gon is not a valid answer :P

As with all code golf, shortest code wins.

Is the description good? Would it be harder if I instead asked for the number of sides, given a name?

  • 1
    \$\begingroup\$ What is a 101-sided figure called? "hectahenagon"? Is "hena" from the column for ones digits you mention? If so, then what is a 111-sided figure called? I'd say "hectaundecagon", but then that comes from a column where "hena" is not present. \$\endgroup\$
    – Gaffi
    Feb 11, 2013 at 11:15
  • \$\begingroup\$ @Gaffi: Yep, it's hectahenagon, from what Google says. \$\endgroup\$
    – beary605
    Feb 11, 2013 at 16:03
  • \$\begingroup\$ I am going to take this if you allow me or if you don't respond \$\endgroup\$
    – user63187
    May 30, 2017 at 1:13

Code golfing problem: Surface classification

The task: Given a surface-word reply with the classification of what surface it is.

Example 1: Input: aba'b' ----> Output: 1T

Example 2: Input: aabcb'c' ----> Output: 3P

Bounds on the problem: Since there are only 26 letters, there will never be more than that many labels. Additionally output should be in the form S,nT,mP for n,m positive integers.

Background: In the study of algebraic topology students are often presented with diagrams such as the one below. The represent instructions for how to assemble a surface. The assembly is prescribed as: if there are two edges labeled with the letter x then glue them together so that the arrows point the same direction. To make our job easy, topologists have discovered an algorithmic way to classify surfaces using 'words' assembled from these 'plane gluing-diagrams'.

enter image description here Choosing a corner arbitrarily (top right) and orientation (ccw) we read off the labels on the edges where an inverse appears wherever the arrow points against the orientation. In this case the 'word' that represents this plane model is given as abab.

A surface word is a string that contains the letters a,b,...,@ up to some letter @ and each letter is contained in it exactly twice. In the two occurrences of each letter: 0, 1, or 2 of them may be postfixed by a ' which I am considering using to represent 'inverse' (opposite orientation).

If in a surface word all letters appear twice: once without the ' and once with it (f.ex. ba'b'a) then we say that the surface the word represents is orientable. If a surface is orientable then it is necessarily the direct sum of n Tori for some non-negative integer n. If this condition doesn't hold (like in aab'b) then the surface represented is non-orientable: in this case it is the direct sum of m Projective Planes for some positive integer m.

Once you have found out if the reduced word is orientable or not, the final answer is given as follows. If orientable and number of unique letters in the reduced word is 1 then output should be S. Otherwise if the number of unique letters in an orientable word is n (it will be even) then the output should be sT where s = n/2. If the word is non-orientable then the output should be mP where m is the number of distinct letters in the reduced word.

The goal is to take as input some surface word, reduce it via reduction rules 1-6 and then classify it as a sphere, some number of connected tori, or some number of connected projective planes. Here are the 6 reduction rules where ~ represents 'reduces to':

Let M,A,B,C,D be surface words, x be a single letter, and juxtaposition represents concatenation:

  1. Cycle Rule: If M = AB then M ~ BA
  2. Flip Rule: M ~ M'
  3. Sphere Rule: Axx'B ~ AB
  4. Block Rule: ABC ~ ADC if B is a surface word and B ~ D by 1 or 2
  5. Cylinder Rule: If M = AxBCx'D, then M ~ AxCBx'D
  6. Möbius Rule: If M = AxBxC then M ~ AxxB'C ~ AB'xxC

I am looking for input on:

  • should this be code-golf or programming-challenge?
  • how would scoring work?
  • ???

If I feel satisfied with the question in a few days I'll post it to the site.

  • \$\begingroup\$ If, for each input, there is only one correct output, then it should probably be code-golf. The scoring criteria would then be source code length. \$\endgroup\$
    – PhiNotPi
    Jun 8, 2013 at 14:33
  • \$\begingroup\$ Yes, this is the case. In general however there is not a unique series of applications of the reduction rules for any given instance. \$\endgroup\$
    – Kaya
    Jun 8, 2013 at 16:21
  • \$\begingroup\$ I don't think the order of explanation is correct. You should explain reduction before talking about "the reduced word". And "reduce it via reduction rules" doesn't entirely make sense, because the rules are presented as equivalences rather than reductions, and most of them don't have a "natural" direction. \$\endgroup\$ Jun 10, 2013 at 8:49
  • \$\begingroup\$ It's also occurred to me that you haven't defined the notation M'. Does it just consist of toggling the orientation of each token, or does it also reverse the entire string? And do you have test cases which between them force implementation of all of the reduction rules? \$\endgroup\$ Jun 11, 2013 at 8:32
  • \$\begingroup\$ Good call on the string inverse, yes you have the right idea and I will make it clear. I have a lot of test cases from when I did a number of these computations by hand in a university course and (anecdotal experience) I am pretty sure that it is possible to force the use of all the reduction rules (except maybe 4 which is really just a meta-rule for convenience when doing proofs). Additionally you have alerted me to some concerns regarding the form of the proper output: it's definitely underspecified. I'll put some work into this today. \$\endgroup\$
    – Kaya
    Jun 11, 2013 at 14:04

Fastest Code: checking if interval pairs overlap

Given an unsorted input of many interval pairs (50+), write the fastest algorithm to determine if they do not overlap.

An interval pair is said to overlap if interval x and interval y are overlapping.

Example input 1:
interval x , interval y

10-25, 50-60
10-15, 25-60

Can be in any true false format.

false (They overlap)


a.x overlaps b.x
a.y overlaps b.y

Example input 2:

10-25, 50-60
20-30, 25-30


true (they do not overlap)


a.x overlaps b.x
a.y does not overlap b.y


[not sure...]
brute force gives a worst case n^2 runtime
  • 1
    \$\begingroup\$ It's hard to understand what the program is supposed to do. It's better to give three separate self-contained test cases than to mix them together with extra identifiers which won't be in the actual input. But if I understand correctly, there's nothing difficult here at all. It's just interval overlap testing (two ifs) done twice for no obvious reason. \$\endgroup\$ Jul 5, 2013 at 19:45
  • \$\begingroup\$ The problem is that there will be a very large input. I'm thinking > 50 lines. \$\endgroup\$
    – EAKAE
    Jul 5, 2013 at 20:50
  • \$\begingroup\$ I'm not sure whether or not to score it based on time, or worst case runtime. \$\endgroup\$
    – EAKAE
    Jul 5, 2013 at 20:59
  • 1
    \$\begingroup\$ Instead of asking for overlap, ask for disjoint: "Check if a family of intervals is disjoint". I also think it would be more interesting if you give intervals in interval notation but I you should at least specify whether or not the endpoints are included. \$\endgroup\$
    – Justin
    Dec 21, 2013 at 7:41

Business Card Ray Tracer

I have no idea how to create a good code golf question!

See this description of a ray tracer with source code that fits on a business card. The author stopped when the code size was 1337 bytes.


Achieving identical output, optimise for minimum code size. Execution time is not relevant.

  • 1
    \$\begingroup\$ I think what you have here is a straight ahead golf. All languages. You need only define the requirements. Do you want identical output or do you want "good output encompassing <list of features>"? \$\endgroup\$ Oct 6, 2013 at 17:22
  • 1
    \$\begingroup\$ For a minimum feature list I'd suggest something like (1) it is ray tracer (2) supports point-like lights and shadow + ambient light (3) supports mirrored (implies reflection) and matte surfaces (3) all objects are sphere and overlaps are allowed. With no requirement for (a) anti-aliasing; (2) finite sized light sources; (c) atmosphere effect or (d) depth of field; or (e) tiling and gradients. Notice however, that the example supports at least (b), (d) and (e). \$\endgroup\$ Oct 6, 2013 at 17:29
  • 1
    \$\begingroup\$ BTW--The one you linked can get a little bit more with #define Q return (R was already taken for the rand wrapper) and #define O operator. \$\endgroup\$ Oct 6, 2013 at 17:33
  • 3
    \$\begingroup\$ I suggest reading the Teapot question in the sandbox Mk IV and the comments - it's not the same question, but some of the same issues are relevant, and it might give you ideas for improvements to the spec. \$\endgroup\$ Oct 6, 2013 at 22:48
  • \$\begingroup\$ Yes. Read the teapot question for guidance. Ultimately I decided that one was too big, but we did get into some pertinent details. \$\endgroup\$ Dec 1, 2013 at 9:48
  • \$\begingroup\$ This sandbox post has had little activity in a while and little positive reception from the community. Please improve / edit it or delete it to help us clean up the sandbox. \$\endgroup\$
    – user58826
    Jun 9, 2017 at 15:32

Countdown: Federal Holidays in the United States

Inspired by this question:

Christmas Countdown

Write a program or script that will countdown to the nearest U.S. federal holiday, at any given time, and will switch the display to an appropriate greeting during each holiday.

The following holidays must be tracked, and announced:

Holiday                         Date                    Greeting
New Year's Day                  Jan. 1                  Happy New Year!
Martin Luther King, Jr. Day     3rd Mon. in Jan.        Happy Martin Luther King, Jr. Day!
President's Day                 3rd Mon. in Feb.        Happy President's Day!
Memorial Day                    Last Mon. in May        Happy Memorial Day!
Independence Day                Jul. 4                  Happy Independence Day!
Labor Day                       First Mon. in Sept.     Happy Labor Day!
Columbus Day                    2nd Mon. in Oct.        Happy Columbus Day!
Veterans Day                    Nov. 11                 Happy Veterans Day!
Thanksgiving                    4th Thu. in Nov.        Happy Thanksgiving!
Christmas                       Dec. 25                 Merry Christmas!

The strings listed under "Holiday" and "Greeting" are all free. Shortcuts like "Merry X-mas!" or "Happy 4th of July" will count against you - the full and proper holiday names are free, so there's no good reason not to use them.

The following strings are also free, only when used as a label for time units or in advertising the next upcoming holiday:


On any given non-holiday, the program must show a count-down timer which displays time remaining at least down to the second, and updates the display with an accurate value (according to the system clock) at least once per second. Time remaining until a holiday must be counted as the time until midnight (00:00:00) on that day.

How the days, hours, minutes, and seconds (and milliseconds, if you choose) are displayed is up to you, so long as all mandatory items are present and it is clear which numbers represent which value. Again, the strings defining units of time are free so there's no really good reason not to use them. (Though you won't be penalized for not using these strings, so long as it is still unambiguous which time units are which.) The program should also make apparent which holiday is being counted down towards.

On any given holiday, the program must cease displaying the countdown timer and instead display the appropriate greeting for that holiday from 00:00:00 until 23:59:59.

After a holiday is over, at 00:00:00 the next day, the holiday greeting must go away and be replaced with the countdown timer for the next holiday.

Answers must include:

  • Name of language
  • Score (length of golfed code, minus free characters)
  • Golfed code
  • Total length of golfed code
  • Total number of free characters used
  • Un-golfed code, with descriptive comments

The program must be capable of running accurately (according to the system clock) at any time, and must be able to run indefinitely. The only limitations to this should be those imposed by the host computer or the nature of the programming language.

Are there any additions/deletions/modifications that should be made to these rules?

I'm considering changing some of the greetings, but I'm not quite sure what to.

  • "Happy Martin Luther King, Jr. Day!" is just a mouthful and feels awkward, but shortening it to "Happy MLK Day" feels weird too - any other suggestions?
  • I'm not quite sure "Memorial Day" should really be preceded by "Happy" - thoughts?
  • Any others?
  • \$\begingroup\$ I think it would be more interesting if the strings were not free, but you still required exact match. I would like to see the compression scheme used by contestants. \$\endgroup\$ Dec 7, 2013 at 12:04
  • \$\begingroup\$ @JanDvorak This is meant to be code-golf, not kolmogorov-complexity. \$\endgroup\$
    – Iszi
    Dec 7, 2013 at 22:11
  • \$\begingroup\$ This challenge proposal has been inactive for over a month. I would like to take ownership of the challenge and make it ready for posting. Please let me know within the next 14 days if you have any objections and would still like to finish and post this challenge yourself. \$\endgroup\$
    – user10766
    Nov 3, 2014 at 2:01

Golf a random Human Genome fragment with non-random features

A totally random genome fragment is easy enough: just spit out the letters ATCG in random order, and you're done. So let's try something a little less random and more useful to science.

Your program will:

  • Accept an argument from the user for number of base pairs (20bp-10000bp must be supported, more if you wish)

  • Accept an argument from the user for GC content. This indicates how frequently the generated sequence should contain the G and C bases as a percentage of total sequence length.

  • Include at least one complete gene in every request of 500bp or more, where a gene is defined as an otherwise random sequence that begins with a start codon triplet (ATG) and ends with the first stop codon triplet it encounters (TAG, TGA, or TAA). The distance between the start codon and the stop codon does not have to be a multiple of 3.

  • Vary gene content (the portion of the fragment that is "gene", inclusive of the gene's start and stop codons) linearly with respect to GC content (when sequence >= 500bp). At the extremes, when GC content is 0%, gene content is 10%; when GC content is 100%, gene content is 60%.

  • Output a single-strand sequence that complies with the above specs and the user's given parameters. (i.e. a single row of letters will suffice since it is trivial to deduce the complementary strand of the DNA given the sequence of one strand)

  • Calculate the actual GC content %, actual number of genes, and actual gene content % in the resulting fragment, and output a status line below the sequence conforming to the example format below. Percentages may be rounded to one decimal place. Actual values may deviate by +/- 3% from the expected outcome based on user's input.

    GC content: 42.1% | Genes: 3 | Gene content: 32.1%

Your program will not:

  • Use any Internet, library, or built-in gene sequence generation functions or databases. Roll your own.

Sufficient randomness:

  • For the purposes of this challenge, any built-in random/pseudo-random number generator function, GUID generator, well-seeded cryptographic hash function, etc. is considered an acceptable source of randomness.


  • What if another start codon occurs before the stop codon? E.g. ATGXXXATGXXXXXXXXXXXXTAG. This is acceptable, but the "gene" length in this case is calculated from the most proximal start codon to the stop codon.
  • What if another stop codon occurs after a stop codon? E.g. ATGXXXXXXXXXXXXXTAGXXXXXXTAG This is also acceptable, but likewise the "gene" length is calculated from the start to the most proximal stop.
  • What if both of these things happen? E.g. ATGXXXATGXXXXXXXXXXXXTAGXXXTGA. Here again, the "most proximal" principle applies and the gene content is demarcated by the innermost start and the innermost stop.
  • Do "orphaned" start and stop codons that do not demarcate a gene count as gene content? No.

This challenge is code golf, so shortest valid code wins.

Post example output from a 500-bp request with GC content between 35% and 65%, and have fun!

  • \$\begingroup\$ "Use hardcoded fragments for anything other than the start and stop codons." - why not? Specifying criteria for what counts as enough randomness should make these useless in any case. Speaking of which, you need to specify criteria for what counts as enough randomness. \$\endgroup\$ Feb 28, 2014 at 5:54
  • \$\begingroup\$ The only partial output example given flagrantly violates the spec. If the GC content is 42.1%, the gene content should be 31.05%, not 22.0%. The definition of "gene" is also imprecise: in the sequence AUGCCAUGCCUAGCUAA, which is the gene? \$\endgroup\$ Feb 28, 2014 at 12:02
  • \$\begingroup\$ @PeterTaylor AUG starts the gene, then come the CCA, UGC, CUA and GCU triplets, none of which terminate the gene. Now if there were three C's instead of two, then UAA would be the terminating triplet and the whole sequence would form a gene. I agree the definition is imprecise, though. \$\endgroup\$ Feb 28, 2014 at 12:11
  • \$\begingroup\$ @JanDvorak, (part of) the point of that example is that there are two AUG substrings. \$\endgroup\$ Feb 28, 2014 at 12:30
  • \$\begingroup\$ Good points. I was hoping to avoid having too much text, but that came at the expense of less clarity than the challenge demands. Edit forthcoming. \$\endgroup\$ Feb 28, 2014 at 13:58
  • \$\begingroup\$ Also, I've muddied the waters with RNA encoding and DNA encoding, (U vs T), which we can chalk up to a late night. \$\endgroup\$ Feb 28, 2014 at 14:00
  • \$\begingroup\$ Revised accordingly, although I remain open to suggestions on how best to frame the standards for acceptable randomness. I want something that won't be exploited by answers making no effort at randomness, but that doesn't have the pain-in-the-butt factor of generating 10mb+ of data and running a Diehard test battery. \$\endgroup\$ Feb 28, 2014 at 17:20
  • \$\begingroup\$ " This is acceptable, but the "gene" length in this case is calculated from the most proximal start codon to the stop codon. " - wait, what? In nature, the first one is the start codon, and the rest encode methionine. Under your scheme, methionine (which is an essential amino-acid) would be impossible to include into proteins. Your scheme would also be much harder to splice. Also, what happens to AUG substrings that are not triplet-aligned to previous AUG substrings? \$\endgroup\$ Mar 1, 2014 at 9:25
  • \$\begingroup\$ In nature, the first ATG encodes the start of a protein coding region and defines a reading frame (triplet boundary), the rest encode methionine and the first triplet aligned stop codon encodes the end of the protein coding region (and no amino-acid). \$\endgroup\$ Mar 1, 2014 at 9:29
  • \$\begingroup\$ As for the randomness, I'm not worried about the source of randomness (whatever native library is available is assumed to be good enough) but rather how the source of randomness is used (can we just start the sequence with a start codon and insert an end codon at just the right spot if it doesn't occur naturally sooner, then fill in with more random codons while avoiding ATG subsequences? Your "sufficient randomness" places constraints on the RNG (useless) but no constraints on how it's used (or that it needs to be used at all) \$\endgroup\$ Mar 1, 2014 at 9:34
  • \$\begingroup\$ My true random number sequence generator was sitting there watching silently as I typed away the sequence ACACACACACACAC.... It's all okay. The TRNG was capable of producing something better - it just didn't really get to it. \$\endgroup\$ Mar 1, 2014 at 9:38
  • 1
    \$\begingroup\$ In fact, the 3% tolerance for the CG content leaves no room for randomness when there are only 20 base pairs. I can shuffle the pairs and turn some A<->T or C<->G, but that's it. In fact, if the CG content is set to zero, the task is impossible: we want a gene content of 2 base pairs (which is itself impossible), but the start codon contains a G, and a single G in a 2bp sequence means a 5% CG content, 2% than is the limit. Not including a gene means that we are 7% under the gene content lower limit. Similarly, it's not possible to start or stop a gene with nothing but Cs and Gs. \$\endgroup\$ Mar 1, 2014 at 9:45
  • \$\begingroup\$ Yeah, the 20bp starting point is a bad idea. The problem with start codons is that I considered introducing the idea of promoters and decided that would make the whole thing too complex. So in the absence of promoters there has to be some way to determine which Met is the start codon vs an amino acid and the easiest simplification is to have no Mets in the gene. Likewise, for "not triplet aligned", I'm trying to avoid having to go into explanations of frameshift mutations (even though a Frameshift% would be a cool parameter). \$\endgroup\$ Mar 1, 2014 at 14:29
  • 1
    \$\begingroup\$ I am starting to think that all of these complexities should be included (this proposal stems from me noticing that most of the extant random DNA generators are pretty weak) and this should just be a popularity contest instead of a golf. Link a couple of good articles on the structure of the genetic code and let people add as many features as they wish. Making it a golf seems to be a catch-22 between too many compromises or a too-impenetrable wall of rules and conditions that will dissuade participation. \$\endgroup\$ Mar 1, 2014 at 14:33
  • \$\begingroup\$ Perhaps a code-challenge where people earn x points for each complexity implemented? \$\endgroup\$
    – user10766
    Mar 2, 2014 at 5:52
25 26
28 29

You must log in to answer this question.

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