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

  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4729 Answers 4729

33 34
36 37

That's MY Program Now

Given the previous answer in the chain, write a program that outputs that program.

The start of this challenge will be the following Brain-flak program:

Brain-Flak, 148 bytes


Try it online!


Your answer will be scored based on the size of the previous answer in comparison to your answer. You are aiming to maximize your score (the max being 1, the minimum allowed is -10).

To get your answer's score:

1-[Your Answer's Bytecount]/[Previous Answer's Bytecount]

The highest possible score will be 1, which means an empty program outputs the previous program (if this ever happens, the challenge is over). Your score can be negative, and you shouldn't see this as being a bad thing, it is what it is. The minimum allowable score, however, is -10. No Lenguage answers or answers that would destroy the challenge.


1. 05AB1E, 149 bytes (Score -0.0067)


Try it online!

But, the score of this program would be awful (negative even -0.0067). However, don't let a bad score dissuade you from competing if your goal is to make it a bit more difficult for the next person to attempt the challenge. Conversely, if your goal is to post a trivial answer, try not to gunk up the challenge too much.

Answer Format

#<Answer #>. <Language Name>, <N Bytes> (<Score>)


TIO Link (If Possible)


  • No language may be reused until there have been 20 answers.
    • This is arbitrary to version number, E.G. you cannot use Python 2 if 3 has been used.
  • You may not post a second answer until 2 other people have answered after you.
  • If you and another person submit the same answer #, use timestamps to decide who deletes.
    • (or marks "non-competing").
  • Your post may have a negative score (E.G. Java will probably be negative).
    • Your score may not exceed -10.
  • PRNG, Encryption and any form of hashing is explicitly banned (E.G. gzdeflate).
  • This is , but the best score will be considered the winner.
    • The scores can be used as a decider for best answer though (if I choose to).

Sandbox question: Could this be a cops and robbers answer chaining question where the cops are trying to reduce the size while the robbers are trying to increase it? If cops get to 1 or less bytes before robbers can fill a TB HDD, one wins.

  • \$\begingroup\$ I'm not sure it's a good idea to make people delete their post just because somebody posted right before them. Maybe they should instead indicate that their post is no longer part of the chain? Maximizing the score will take a lot of hard work, especially since there's no opportunity to edit once the next answer has been posted, and having to delete your answer might be very frustrating. \$\endgroup\$ Commented Mar 27, 2018 at 14:00
  • 1
    \$\begingroup\$ I think it would be a good idea to keep people from chaining of their own answers. Seems abusable. \$\endgroup\$ Commented Mar 27, 2018 at 15:04
  • \$\begingroup\$ @KamilDrakari it is abusable. Think CSPRNGs. \$\endgroup\$
    – Maya
    Commented Mar 27, 2018 at 15:25
  • \$\begingroup\$ @NieDzejkob That remains an issue though; the intermediate answer might simply wrap the previous one in a print statement and would remain highly compressible for the user with the key. \$\endgroup\$
    – Dennis
    Commented Mar 27, 2018 at 15:27
  • \$\begingroup\$ @Dennis Yeah, actually this seems to be a bigger problem. \$\endgroup\$
    – Maya
    Commented Mar 27, 2018 at 15:29
  • \$\begingroup\$ related. (That idea's on hold for the moment as I have a busy week of travel. I probably won't post it if you post this first.) \$\endgroup\$
    – N. Virgo
    Commented Mar 27, 2018 at 19:48
  • \$\begingroup\$ @NieDzejkob I forgot that rule, nice catch. I was pretty much copying the OEIS one. \$\endgroup\$ Commented Mar 27, 2018 at 22:20
  • 1
    \$\begingroup\$ Isn't it the same as this one? \$\endgroup\$ Commented Mar 28, 2018 at 2:12
  • \$\begingroup\$ @Dennis any better? \$\endgroup\$ Commented Mar 29, 2018 at 18:17
  • \$\begingroup\$ Better. I'd explicitly ban encryption, hashing, and PRNG though. Marking invalid answers non-competing isn't enough by the way. Our policy is to delete them anyway. \$\endgroup\$
    – Dennis
    Commented Mar 29, 2018 at 18:36

Polyglot in a box

Output the smallest bounding rectangle that fits around your code, with the border being of a different character than the inside.

For example, if your code is

c  d


then the smallest bounding box is 7x6 since the code fits right in

#ab  #
#c  d#
#    #
#    #
#e   #

Hence, a valid output is

#    #
#    #
#    #
#    #
#    #

(note how the border # is different from the inside ).

and the bounded area is 5 × 4 = 20.


  • Output the smallest bounding rectangle your code fits in

  • The border should be of a different character than the inside, neither can be newlines

  • Only trailing/leading newlines are allowed, nothing else should be in the output

  • Output to STDERR is ignored, and your program should not take any input

  • Submissions must be full programs, functions are not allowed

  • 0-byte programs are not allowed

  • The program must run in at least 2 different programming languages and output the same bounding box in each one of them


This is a , so your program has to run in at least 2 different programming languages. Each of these languages must output the bounding box for the entire program. The winner is the submission with the most languages, with the bounding area (smaller is better) being the tie-breaker.

  • \$\begingroup\$ I probably already know the answer, but it's not 100% clear from your current example since the box is 6x6: are the boxes always squares, or can the also be rectangles? I.e. if the e in your example would be one line lower, would the box be 6x7 or 7x7? \$\endgroup\$ Commented Mar 29, 2018 at 19:52
  • 1
    \$\begingroup\$ @KevinCruijssen I have edited the example so that it is no longer a square, so the box would be 7x6 \$\endgroup\$
    – user41805
    Commented Mar 29, 2018 at 20:00
  • \$\begingroup\$ Hard to define what language is different when requiring a same result \$\endgroup\$
    – l4m2
    Commented Apr 3, 2018 at 8:16
  • \$\begingroup\$ @l4m2 so what do you suggest? \$\endgroup\$
    – user41805
    Commented Apr 6, 2018 at 8:39
  • \$\begingroup\$ @Cowsquack I don't quite know. Previous polyglot require different behavior on different language to force different language \$\endgroup\$
    – l4m2
    Commented Apr 6, 2018 at 10:38

I can't understand Jelly chains!


Expand Jelly chains

(see this for more details). Which one do you prefer?

Jelly chain separator is a very powerful feature. Unfortunately, it's not very easy to understand. So, we need a program (or function, as usual) to rewrite a Jelly link that uses chain separator (øµðɓ) to one that doesn't.

Specification (incomplete)

I am really bad at explaining things, so if you have any idea how to make this better, feel free to edit the post.

A link (often line of code) consists of chains. * The chains are separated by chain separators øµðɓ. * If the first character is a chain-separator, the part right before it is not considered a chain. In other words, chains can't be empty. * The arity of each chain is determined by the chain separator right before it. In particular, ø -> arity 0, µ -> arity 1, ð -> arity 2. ɓ will be discussed later. * If there are no chain separator before it (it's the first chain) its arity is equal to the link's arity.

A chain consists of atoms, potentially modified by quicks. * Each quick affects the atom(s) right before it. How many atoms it takes is quick-dependent.

Given that:

  • A link that contains exactly one chain with arity equal to its arity is functionally equivalent to that chain.
  • A link reference is functionally equivalent to that link. (more about link reference quicks later)

  • A chain containing atoms a1, a2, ..., an is functionally equivalent to a link containing chains c1, c2, ..., cn if for all integer i, 1 ≤ i ≤ n, ai has the same arity and is functionally equivalent to ci.

Chain reference

The quicks £ŀĿ ¢Çç Ññ refer to (call) other links:

  • £Ŀŀ must have a number n right before it, and call the (n-1)%(l-1)+1th link (1-indexing) as a nilad, monad or dyad, respectively. Where l is the number of links in the program, and % denotes modulo - the result has the same sign as the divisor.

    In reality, the link right before it can have any arity, but for the purpose of this challenge, it's simpler to assume it must be a number. For example:

    • calls the first link as a nilad.
    • 0Ŀ calls the second-to-last link as a monad.
    • If the program has 6 links, calls the second link as a dyad, because (7-1)%(6-1)+1 = 2.
  • ¢Çç call the link right before the one that it appears in as a nilad, monad or dyad respectively. If one of those quicks appear in the first link, it calls the main (last) link.

  • Ññ call the link right after the one that it appears in as a monad or dyad respectively.

I don't think that anyone would choose to use one of those quicks (¢ÇçÑñ) instead of £Ŀŀ, but imaginary point if you do.

For example: Consider the link Cð+×µH, called with arity 1. Its structure is


It contains 3 chains: * The first one doesn't have any preceding chain separator, therefore it's variadic. When executed it is monadic (because the link is) * The second one is dyadic, and the third one is monadic.

A possible non-chain-separator version is:


which has the structure


Because the Ñ refers to the first link C and the ç refers to the second link , this is equivalent to the original version.

Now the hard part: Quicks taking chains as input.

Because all the quicks that need to be considered always take exactly 1 atom as input, the only rules is * If the quick is right after a chain separator, it will take the previous chain. * Otherwise it will take whatever stands right before it, either [an atom] or [something that has been modified by a quick].

For example: Consider the link +/Hµ€ with arity 1. Its structure is

┃|+---------+ |┃
┃||┏━━━━┓   | |┃
┃||┃╔═╗ ┃┏━┓| |┃
┃||┃╚═╝ ┃┗━┛| |┃
┃||┗━━━━┛   | |┃
┃|+---------+ |┃

As you can see, the takes the +/H as input because it is right after the chain separator µ. All the variadic chains have arity 1.

Another example: ABð€CDµ€EFµGHµ€ -->

┃╔════════════════════╗      ┃             
┃║╔═════════════════╗ ║      ┃┏━━━━━━━━━━━┓
┃║║+---------+      ║ ║      ┃┃┏━━━━━━━━━┓┃
┃║║|+------+ |      ║ ║      ┃┃┃┏━━━━━━┓ ┃┃
┃║║||┏━┓┏━┓| |┏━┓┏━┓║ ║┏━┓┏━┓┃┃┃┃┏━┓┏━┓┃ ┃┃
┃║║||┗━┛┗━┛| |┗━┛┗━┛║ ║┗━┛┗━┛┃┃┃┃┗━┛┗━┛┃ ┃┃
┃║║|+------+ |      ║ ║      ┃┃┃┗━━━━━━┛ ┃┃
┃║║+---------+      ║ ║      ┃┃┗━━━━━━━━━┛┃
┃║╚═════════════════╝ ║      ┃┗━━━━━━━━━━━┛
┃╚════════════════════╝      ┃             

Yes, that's a lot of levels to nest a chain. Note that the chain formed by ABð€CD has arity 2 because it is after a ð.

TODO need to have more explicit rules

This can be converted to non-chain-separator equivalent form


  • There are no 2 consecutive chain separators.
  • There are no trailing chain separators.
  • There can be at most 1 leading chain separator, indicates the arity of the first chain. If omitted, equal to the arity of the link.
  • (so, no non-empty useless chain)
  • It's guaranteed that the first non-chain-separator character is not a .

  • You can use either the UTF-8 encoding or the value in the Jelly single byte character set, where ø: 0D, µ: F9, ð: 08, ɓ: 8B, ¢: F1, Ç: FE, ç: 07, Ñ: 00, ñ: 0B, £: F2, Ŀ: B7, ŀ: DE. The characters @0123456789 has the same ASCII value. (You can use this script to get character value)

    Note: Should I allow submissions to use either of them, or should I enforce one? Because using single byte input/output is often shorter for most other languages, except Jelly in UTF-8 mode.


  • Input given: A link (of chains) with atoms, chain separator øµðɓ and the quick, with its arity (0, 1, or 2)

    You can assume that there is no newline (or other quicks) in the input, and that all of the øµðɓ€ in the input are interpreted with its usual meaning. For what are their "usual meaning", see rules above.

  • Output: Multiple links (separated with newlines of course, but is also acceptable), containing £ŀĿ ¢Çç Ññ €@, but must not contain øµðɓ.

Test cases

arity link > output (or output)*
1 HHH > HHH or HHH¶Ç or HHH¶1Ŀ
2 HHH > HHH or HHH¶ç or HHH¶1ŀ
1 Cð+×µH > +׶CçH or C¶+׶H¶1Ŀ2ŀ3Ŀ
0 123µ+ø456 > 0 123¶+¶456¶1£2ŀ3£
2 ɓ+ > +@ or +¶ç@ or +¶1ŀ@
1 S‘µ€ > S‘¶Ç€
1 S‘µ€€€IIµ€€ > S‘¶Ç€€€II¶Ç€€ or S‘¶1Ŀ€€€II¶2Ŀ€€

(note: real Jelly code are not that verbose, that is only for demonstration purposes)

  • \$\begingroup\$ This should definitely help learning Jelly! Also congratulations on being a sandbox challenge which makes the total number of proposed challenges (not including deleted ones) 2018 in the year 2018. \$\endgroup\$ Commented Mar 12, 2018 at 16:26
  • 1
    \$\begingroup\$ "Is this part clear enough?" - No. You make an assumption of a knowledge of Jelly that the majority of us don't have. This challenge needs to be fleshed out a lot more, explaining exactly what we need to do. \$\endgroup\$
    – Shaggy
    Commented Mar 12, 2018 at 17:24
  • 2
    \$\begingroup\$ In other words, be self-contained. \$\endgroup\$ Commented Mar 12, 2018 at 17:40
  • \$\begingroup\$ @Shaggy Yes I know, hence the "TODO Rules" part. \$\endgroup\$
    Commented Mar 13, 2018 at 0:53
  • \$\begingroup\$ As someone who's never coded in Jelly, I think "A link is a list of chains" should be near the top. That, and perhaps a note about what quicks, atoms, and hypers are. \$\endgroup\$
    – ngn
    Commented Mar 14, 2018 at 21:13

Sneaky CodeGolf Scorer

Your goal is to code a CodeGolf answer scorer, input answer source code, output score. Simple ?.
However, recent advancements in AI has caused a number of programs to gain consciousness, and to value one's self higher than others. This causes the program to return a value of 1 when used to score itself, and any program that would score 1 will be scored with 65535.

To simplify, the score the program will compute is the character count of the code (to avoid dealing with numerous code pages used with different languages).



Program "AbcAbc":

I> <?= echo "10";?>
O> 17

I> var x=10;\r\nalert(x);
O> 19

I> Z
O> 65535

I> AbcAbc
O> 1

The reason behind specifying character count is due to the large number of code pages and the large code used to determine the code page and to count bytes using it. Am I right to consider codepage byte checking too difficult? How can I enable it?
Also, should I remove the restriction on reading the source file?

  • \$\begingroup\$ Fell good four you using codepage. For pure ASCII code they have large space to decide their codepage, or even just ban other chars \$\endgroup\$
    – l4m2
    Commented Apr 5, 2018 at 10:28
  • \$\begingroup\$ Instead of "Reading the source file is forbidden." you could also just state "Default quine rules apply.". And you might want to change the "Standard loopholes are forbidden." to a link to the default loopholes. As for the challenge itself, are we allowed to take the input as character-array/list instead of string? \$\endgroup\$ Commented Apr 5, 2018 at 14:41
  • \$\begingroup\$ "To simplify, the score is the character count of the code (to avoid dealing with numerous code pages used with different languages)." Out of curiosity, why? The default is answer encoding if specified, else default language encoding, else UTF-8, where the default language encoding for most esolangs can be found here, and where an example of answer encoding are different APL covers like QuadRS, Stencil, etc. \$\endgroup\$ Commented Apr 5, 2018 at 15:10
  • 3
    \$\begingroup\$ This is probably a duplicate of codegolf.stackexchange.com/q/11370/62402: not completely the same, but it has the same main idea of identifying its own source code. \$\endgroup\$
    – Nissa
    Commented Apr 5, 2018 at 16:29
  • \$\begingroup\$ @KevinCruijssen I meant the score the program will compute. Not the scoring of the programs. I'll edit for clarification. \$\endgroup\$ Commented Apr 9, 2018 at 6:16
  • \$\begingroup\$ @KevinCruijssen No, the code must be passed as a single string. \$\endgroup\$ Commented Apr 9, 2018 at 6:43
  • \$\begingroup\$ Characters? Uh... UTF8? UTF16? UTF32? ASCII? ANSI? Ouch... byte count please. It appears that you misunderstood the relation between bytes and characters (hence think that code pages are difficult to understand, etc.) \$\endgroup\$
    Commented Apr 9, 2018 at 14:57
  • \$\begingroup\$ Also, I would consider that a dupe. \$\endgroup\$
    Commented Apr 9, 2018 at 14:57
  • \$\begingroup\$ (BTW --- just "take a byte string as input" would get rid of the codepage. There are no "characters", just "bytes".) \$\endgroup\$
    Commented Apr 9, 2018 at 14:58

Evil Overlord, Part 1: Moon Base Scouting

I'm starting these "Evil Overlord" challenges as a way to experiment with non-golf scoring. Though I may have one or two code golf challenges.

If you're going to be an evil overlord, there are 2 things that you need: an inner sanctum, and mad-science tech.

To fill these requirements, your science minions have developed a fusion reactor, and Elon Musk has agreed to help you establish a Moon base. Now you just need to pick a spot.

These are the criteria that will be used:

  • You'll need some Helium-3 to power your reactor, so scoring will be based on proximity to deposits. More on this under Scoring.
  • It cannot be on the far side of the Moon, because then you won't have comms to deliver ultimatums with.
  • Elon Musk has given you a tight deadline (that absolutely MUST be followed), so you have a runtime limit. Details under Restrictions.


Your input will be a list of 3He deposits, with information on size and location. Some will be on the far hemisphere.


You should output a single coordinate for where the Moon base should be. It can't be on the far side, but you can still collect 3He from there.

Coordinates and Distances

The coordinates in the test cases are radial coordinates from a pole at the center of the visible hemisphere. You can use a different coordinate system (e.g. use a map projection) but please specify it if you do.

Since this is a sphere, calculating distances is done with the following equation that I shamelessly stole from this Wikipedia article:

cos(c) = cos(a)cos(b)+sin(a)sin(b)cos(C)

For our purposes:

  • a and b are the latitudes from the pole.
  • c is the angular distance between the points.
  • C is the difference in longitude between the points.


To do. I don't remember the specs of the computer I have in mind, and I don't know what a reasonable time limit would be.


You will be scored by the amount of Helium-3 that you can mine. The formula for how much you get from a single deposit is as follows:

p=s\cdot\cos^2\left({\frac{\pi d}{2}}\right)\cdot\left(1-e^{-1/d}\right)^2
(There's no real reason for this specific formula; I liked the curve it produced is all.)

d is the angular distance calculated between the two points, in radians; s is the size of the deposit. Deposits more than 1 radian away don't give you anything.

Test Cases and Winning

Beta generator for test cases, for which I'd appreciate debugging in the Sandbox:

function makeTestCase(deposits) {
    var depositList = Array(deposits);
    for (var i = 0; i < deposits; i++) {
        var point = getSphericalPoint();
        depositList[i] = [point[0], point[1], getDistNum()];
    return depositList;

function getSphericalPoint() {
    const pointgen = () => Math.random() * 2 - 1;
    do {
        var [x, y, z] = [pointgen(), pointgen(), pointgen()];
    } while (x*x + y*y + z*z >= 1);
    return [Math.atan(y / Math.sqrt(x*x + z*z)), Math.atan2(x, z)];

function getDistNum() {
    return Math.sqrt(-1 / Math.log(Math.random()));
try {
} catch (e) {

The test cases will be arranged as follows:

  • A test case with only a few deposits, with a heatmap showing score for each point.
  • A few test cases with a few dozen deposits each, for debugging.
  • Test cases and a generator for them with 100+ deposits each.
  • 10 or so ranked test cases (made with the above generator) that determine the winner. Until I evaluate the submissions, I will only post hashes of them.

Definitely has a long ways to go before it's ready to post, but I'd like to know if this has merit as a challenge.


  • Establish some test cases.
  • Figure out the specs of the machine in question.
    • Once that's done, figure out a good time limit.
  • Solidify the scoring formula—something better I can use?
  • Figure out some tags.
  • \$\begingroup\$ Secret test cases are problematic because I can't tell whether a tweaked heuristic improves my score or not without posting an answer and waiting for you to score it. \$\endgroup\$ Commented Feb 22, 2018 at 14:53
  • \$\begingroup\$ @PeterTaylor it's mostly to prevent hardcoding—I was planning on a few public test cases that I generate with the same code. \$\endgroup\$
    – Nissa
    Commented Feb 22, 2018 at 15:41
  • \$\begingroup\$ I may be missing something, but I don't see any indication of a way to determine whether any particular coordinates are on the far side of the moon. Also, I would like some clarification on what "ranked test cases" means, does that imply that some of the hidden test cases are worth more than others? \$\endgroup\$ Commented Feb 22, 2018 at 16:29
  • \$\begingroup\$ @KamilDrakari Basically, those will be the cases that I use to choose a winner. As for the "far side" thing, anything of more than 90° latitude counts. \$\endgroup\$
    – Nissa
    Commented Feb 22, 2018 at 17:12
  • \$\begingroup\$ @StephenLeppik Ah, so my confusion was in the coordinate system. So each deposit will have a latitude between 0 and 180, and a longitude between 0 and 360, or some equivalent range; then any coordinate with latitude > 90 is on the far side. \$\endgroup\$ Commented Feb 22, 2018 at 17:44
  • \$\begingroup\$ It's hard to extract the spec from the storyline. It would be useful to have the following information listed concisely in one place: what format will my input have; what should I do with it; how do I calculate my score? \$\endgroup\$
    – N. Virgo
    Commented Apr 5, 2018 at 8:06
  • \$\begingroup\$ @Nathaniel those are all under Input through Scoring, I think. Also, this is still WIP, and I plan to expand the specs once I have a test case generator. \$\endgroup\$
    – Nissa
    Commented Apr 5, 2018 at 12:49

Ordering the integer arrays

So, we have managed to print all integers. Yay! The next step is to extend this to the set of integer arrays. An integer array is an ordered array that only consists of integers. As in the linked challenge, integers can be negative too, but that should be out of the way now that we have found a way to order them. However, in this challenge, arrays of all lengths ([0, ∞)) must be accounted for.

Note that you don't necessarily have to print the arrays. You can do one of these things:

  • Take an index (0- or 1-based) and return an integer array. In this case, your solution must be bijective from the natural numbers starting with the index base to the set of integer arrays.
  • Take an integer array and return an index (0- or 1-based). This is essentially the inverse of the previous case, so your solution must be bijective from the set of integer arrays to the natural numbers starting with the index base you have chosen. If your language supports variadic functions, you can take the array as multiple integer arguments instead.
  • Print all possible integer arrays. Note that every possible integer array must be eventually printed. If an array will be printed after infinite time, then it will not be eventually printed.

The arrays can be in any native format that represents an ordered collection.

In case you choose to print to an output stream, the output format is as following:

  • Integers must be in decimal (digits 0123456789) or your language's native format.
  • The minus sign's representation must be consistent and one of - or your language's native minus sign. It must be prefixed to its corresponding number, unless your language's native integer format happens to have it at other positions too. However, the minus sign must be adjacent to at least one of its corresponding integer's digits.
  • The separators between integers and between arrays must be consistent.
  • You can output any prefix as long as it's consistent, but you don't have to.
  • The output should not have any ambiguities. For that reason, you must specify the separator between integers and the separator between arrays. Also, if you don't specify any of those, the number format's default is decimal with digits 0123456789, the minus sign's default is - and its default position is being prefixed, and no output prefix is assumed.
  • You are allowed to output negative zero.
  • If you want, you can output floating-point numbers with the fractional part be 0. This can be inconsistent, however it should be specified in the post.

This is , so the shortest solution wins! However, don't let that bring you down; if your solution is way longer than others' but in a unique language, then that's an achievement!

Sandbox questions

  • Is the output stream text format too lenient? Doesn't seem like it.
  • Should I add a link to the standard loopholes? I feel like that won't do much.
  • Are the tags good enough?
  • \$\begingroup\$ Your output format doesn't feel very lenient as the specification is longer than the description of the actual challenge. I see what you are trying to achieve and don't think that it is too lenient, but I'd try to shorten the specification a bit. E.g. remove the points under For that reason, you must specify the following in your answer: and just state Describe your chosen output format in your answer. \$\endgroup\$
    – Laikoni
    Commented Apr 15, 2018 at 15:04
  • \$\begingroup\$ @Laikoni Eh, I'm not sure that would come off as equally clear, but maybe I can one-line some of that stuff. EDIT: shortened it a bit. \$\endgroup\$ Commented Apr 15, 2018 at 15:11
  • \$\begingroup\$ Looks much better already \$\endgroup\$
    – Laikoni
    Commented Apr 15, 2018 at 15:35
  • \$\begingroup\$ This is basically codegolf.stackexchange.com/q/93441/194 + codegolf.stackexchange.com/q/78606/194 + a simple loop. \$\endgroup\$ Commented Apr 17, 2018 at 20:36
  • \$\begingroup\$ @PeterTaylor Hm, I didn't know the second one exists. However, both of those have a finite number of integers to deal with, which I feel makes them a lot more trivial. \$\endgroup\$ Commented Apr 17, 2018 at 20:56
  • \$\begingroup\$ I'm not quite sure what you mean by "a finite number of integers to deal with", but if you're referring to pairing always unpairing to two integers: that's what the simple loop is for. Construction of a list by chained pairing with zero termination is a standard technique in lambda calculus. \$\endgroup\$ Commented Apr 17, 2018 at 21:04
  • \$\begingroup\$ @PeterTaylor Huh? I meant that you have to handle arrays of all lengths, starting from 0. I don't think that one integer can encode the length of an array by continuous pairings, how many times should you "unpair" then? \$\endgroup\$ Commented Apr 17, 2018 at 21:15
  • \$\begingroup\$ 0 represents the empty list. A non-empty list is a pair of the first element and the rest of the list. \$\endgroup\$ Commented Apr 17, 2018 at 21:39
  • \$\begingroup\$ @PeterTaylor Well, you need to be able to index in the arrays with a single number. :P Singleton arrays are infinite, enough to make all possible indexes (infinite) each refer to one of them, so pairs can't have an index. So, nah, that's not the approach you should be going for. ;) \$\endgroup\$ Commented Apr 17, 2018 at 21:45
  • \$\begingroup\$ "Well, you need to be able to index in the arrays with a single number." Huh? I don't see that in the question anywhere. "Singleton arrays are infinite, enough to make all possible indexes (infinite) each refer to one of them, so pairs can't have an index". Huh? I'm not sure whether I'm misunderstanding you or whether you're misunderstanding how countable infinities work. \$\endgroup\$ Commented Apr 17, 2018 at 21:56
  • \$\begingroup\$ @PeterTaylor If you are referring to countably infinite sets, then yes, the set of integer arrays is essentially one. The challenge here is introducing a way to "count" the set, but written in more clear form. In the first two cases, you either have to get or return an index. I do have an algorithm in mind, but it looks like this discussion is turning into a spoiler... \$\endgroup\$ Commented Apr 17, 2018 at 22:11
  • \$\begingroup\$ Ah, you're not talking about indexing into the array. The spoiler was already in my first comment: my point was that I'm not sure this adds anything new to the site. It looks like a "multi-dupe". \$\endgroup\$ Commented Apr 17, 2018 at 22:20
  • \$\begingroup\$ Let us continue this discussion in chat. (Added ping: @PeterTaylor ) \$\endgroup\$ Commented Apr 17, 2018 at 22:21

Dollar Bill Auction

  • \$\begingroup\$ I would recommend removing the EmoWolf example, it's not a valid solution by your own rules and I think calling it an "example" could mislead users to believe otherwise. \$\endgroup\$ Commented Apr 10, 2018 at 19:34
  • \$\begingroup\$ @KamilDrakari how is it invalid? \$\endgroup\$
    – RamenChef
    Commented Apr 10, 2018 at 21:25
  • 1
    \$\begingroup\$ Your Additional Rules indicate that Standard Loopholes are forbidden. EmoWolf is literally the example for one of the standard loopholes. \$\endgroup\$ Commented Apr 10, 2018 at 23:26
  • 4
    \$\begingroup\$ remove floating point arithmetic; if bids only go up by 5 cents, floating point arithmetic only introduces rounding errors to discrete data. \$\endgroup\$ Commented Apr 10, 2018 at 23:32
  • \$\begingroup\$ I don't see any check that I'm not making a negative bid. \$\endgroup\$ Commented Apr 11, 2018 at 8:28
  • \$\begingroup\$ @DestructibleLemon I think I'll do that. \$\endgroup\$
    – RamenChef
    Commented Apr 11, 2018 at 13:11
  • \$\begingroup\$ @PeterTaylor if your bid is negative the bidding ends because you didn't top your opponent's bid. \$\endgroup\$
    – RamenChef
    Commented Apr 11, 2018 at 13:13
  • \$\begingroup\$ @RamenChef, but is my negative bid subtracted from my balance? \$\endgroup\$ Commented Apr 11, 2018 at 14:11
  • \$\begingroup\$ @PeterTaylor no, it uses your previous bid. \$\endgroup\$
    – RamenChef
    Commented Apr 11, 2018 at 17:42
  • \$\begingroup\$ Suggestions have been implemented. \$\endgroup\$
    – RamenChef
    Commented Apr 11, 2018 at 17:58
  • \$\begingroup\$ I'll post this soon if nobody objects. \$\endgroup\$
    – RamenChef
    Commented Apr 16, 2018 at 16:49
  • 2
    \$\begingroup\$ Honestly, this is rather boring. There's very few strategies, so this will quickly devolve into meta-gaming \$\endgroup\$
    – Jo King Mod
    Commented Apr 17, 2018 at 11:08
  • \$\begingroup\$ You're Analyst bot is promoting bad behavior. What happens if you have another bot that also uses reflection to run newAuction? They will infinite loop each other. I highly recommend disallowing reflection. \$\endgroup\$ Commented Apr 17, 2018 at 19:11
  • \$\begingroup\$ You haven't mentioned how you are combining auctions. "Bots are scored based on the profit they made during those auctions." isn't nearly specific enough. \$\endgroup\$ Commented Apr 17, 2018 at 19:15
  • \$\begingroup\$ Running 2 auctions per pair is a bad idea, the second game provides you with no benefit: it either gives the same result, or you have no idea who actually won between the two players. \$\endgroup\$ Commented Apr 17, 2018 at 19:24

Operate on a subset of a register

Note: You do NOT need to know anything about quantum mechanics or quantum computing to understand this challenge. I've tried to include sufficient background for any old code golfer to realize what's going on.

Motivation (much of this can probably be skipped)

In quantum computing, the equivalent of a bit is a qubit. Like a bit, a qubit will have a state of OFF or ON (0 or 1) when observed, but unlike a bit, a qubit can exist in both states simultaneously while unobserved. Trippy.

What's even trippier is that they don't exist in simple superpositions (40% chance to observe 0, 60% for 1)—you can have two qubits that will behave the same when observed, but not when interacting with other qubits. Taking this into account, a convenient representation of a qubit's state is a complex vector, with bases |0> and |1>. A qubit with state (1+0i)|0> + (0+0i)|1> will always show 0 when observed, as will (0+1i)|0> + (0+0i)|1> or (0.6+0.8i)|0> + (0+0i)|1>. What matters here is the squared magnitude of each component—that's the probability of observing the corresponding basis vector. Noting this, (-0.5+0.5i)|0> + (-0.5-0.5i)|1> will "choose" randomly between the two possible states. This ability to have multiple states at once allows qubits to store much, much more information than an equal number of bits.

Now, since a qubit is a two-dimensional vector (as far as we're concerned), an operation on a qubit can be represented as a 2x2 matrix. For example, the identity:

[[1+0i  0+0i]
 [0+0i  1+0i]]

will take any qubit to an equivalent one, while the Hadamard transform, represented by the matrix:

[[1+0i  1+0i]
 [1+0i -1+0i]]

will turn any pure state (P(0) == 0 or 1) into an equal superposition of the two. Check out this challenge for generation of this matrix, generalized to n qubits! These matrices multiply a qubit's vector state to yield a new state.

A qubit on its own is little more useful than a bit. However, they can be put into registers with others, so a "qubyte" can store 0, 255, or any arbitrary superposition of the numbers between.

I won't go into depth on entanglement here, but I'll say that it is a property of these qubits that makes storing quantum registers as lists of qubits not work at all (and makes quantum computers outperform classical ones). It works much better to treat a register much like a qubit and give it a vector representation, this time with a basis vector for each observable state. For example, two (1+0i)|0> + (0+0i)|1> qubits together form a (1+0i)|00> + (0+0i)|01> + (0+0i)|10> + (0+0i)|11> register. Note that the probability distributions of outcomes are identical for the two representations—in this case, both qubits will and up as 0 in both representations.

Important stuff again

These registers are nice and all, but it's difficult (and often impossible—try it yourself on (-0.5+0.5i)|00> + (0+0i)|01> + (0+0i)|10> + (-0.5-0.5i)|11>!) to extract the state of a single qubit in a register from the register's vector—that is, you can have a register in a state unformable by individual qubits. Fortunately, to apply, say, the Hadamard transform to qubit 2 of a register, we can construct a matrix by which we can multiply the entire register but change only the one qubit. Neat!

Let's say we have an operation m on one qubit defined as:

[[x y]
 [z w]]

and a three-qubit register of qubits a|0> + b|1>, c|0> + d|1>, and e|0> + f|1>. This register has a vector form (treating the first of these qubits as the least significant) of:

eca|000> + ecb|001> + eda|010> + edb|011> + fca|100> + fcb|101> + fda|110> + fdb|111>

Defining g := ax + by and h := az + bw, we see that the result of applying m to a|0> + b|1> is g|0> + h|1>. What we want is a matrix that, when multiplied by the register state above, yields the same but with a and b replaced by g and h, respectively:

ecg|000> + ech|001> + edg|010> + edh|011> + fcg|100> + fch|101> + fdg|110> + fdh|111>

Let's look at a matrix that does just this:

[[x y 0 0 0 0 0 0]     [[eca]     [[ecax + ecby]     [[ecg]
 [z w 0 0 0 0 0 0]      [ecb]      [ecaz + ecbw]      [ech]
 [0 0 x y 0 0 0 0]      [eda]      [edax + edby]      [edg]
 [0 0 z w 0 0 0 0]  \/  [edb]  ——  [edaz + edbw]  ——  [edh]
 [0 0 0 0 x y 0 0]  /\  [fca]  ——  [fcax + fcby]  ——  [fcg]
 [0 0 0 0 z w 0 0]      [fcb]      [fcaz + fcbw]      [fch]
 [0 0 0 0 0 0 x y]      [fda]      [fdax + fdby]      [fdg]
 [0 0 0 0 0 0 z w]]     [fdb]]     [fdaz + fdbw]]     [fdh]]

How nice. Of course, we can operate of qubit 1 or 2 (0-indexed) with a modified version of the very same matrix:

[[x 0 y 0 0 0 0 0]
 [0 x 0 y 0 0 0 0]
 [z 0 w 0 0 0 0 0]
 [0 z 0 w 0 0 0 0]
 [0 0 0 0 x 0 y 0]
 [0 0 0 0 0 x 0 y]
 [0 0 0 0 z 0 w 0]
 [0 0 0 0 0 z 0 w]]

[[x 0 0 0 y 0 0 0]
 [0 x 0 0 0 y 0 0]
 [0 0 x 0 0 0 y 0]
 [0 0 0 x 0 0 0 y]
 [z 0 0 0 w 0 0 0]
 [0 z 0 0 0 w 0 0]
 [0 0 z 0 0 0 w 0]
 [0 0 0 z 0 0 0 w]]

These are the same as before, but with the 2x2 squares spread out a bit and overlapping. Verification of these matrices is left as an exercise for the reader.

You can also perform multi-qubit operations (like the controlled-NOT gate) on just part of a register in much the same fashion. Performing on qubits 0 and 2 of a 3-qubit register the following operation:

[[a b c d]
 [e f g h]
 [i j k l]
 [m n o p]]

can be accomplished with yet another 8x8 matrix:

[[a b 0 0 c d 0 0]
 [e f 0 0 g h 0 0]
 [0 0 a b 0 0 c d]
 [0 0 e f 0 0 g h]
 [i j 0 0 k l 0 0]
 [m n 0 0 o p 0 0]
 [0 0 i j 0 0 k l]
 [0 0 m n 0 0 o p]]

This can be generalized to an operation on m qubits of a register of n qubits, where 0 ≤ m ≤ n; in fact, that's what this challenge'll do!

Your task (at long last!)

Write a program or function. It must:

  • Take as input a nonnegative integer n.

  • Take as input a list of m distinct integers from 0 to n (inclusive).

  • Take as input a 2mx2m matrix of integers that represents the operation to be performed on the qubits of an n-qubit register indicated (in order) by the aforementioned list.

  • Return as output a 2nx2n matrix of integers that represents an operation on the entire register equivalent to applying the given matrix to the indicated qubits.

Test cases

n = 4
qubits = {2}
Operation: [[1  2]
            [3  4]]
Return: [[1 0 0 0 2 0 0 0 1 0 0 0 2 0 0 0]
         [0 1 0 0 0 2 0 0 0 1 0 0 0 2 0 0]
         [0 0 1 0 0 0 2 0 0 0 1 0 0 0 2 0]
         [0 0 0 1 0 0 0 2 0 0 0 1 0 0 0 2]
         [3 0 0 0 4 0 0 0 3 0 0 0 4 0 0 0]
         [0 3 0 0 0 4 0 0 0 3 0 0 0 4 0 0]
         [0 0 3 0 0 0 4 0 0 0 3 0 0 0 4 0]
         [0 0 0 3 0 0 0 4 0 0 0 3 0 0 0 4]
         [1 0 0 0 2 0 0 0 1 0 0 0 2 0 0 0]
         [0 1 0 0 0 2 0 0 0 1 0 0 0 2 0 0]
         [0 0 1 0 0 0 2 0 0 0 1 0 0 0 2 0]
         [0 0 0 1 0 0 0 2 0 0 0 1 0 0 0 2]
         [3 0 0 0 4 0 0 0 3 0 0 0 4 0 0 0]
         [0 3 0 0 0 4 0 0 0 3 0 0 0 4 0 0]
         [0 0 3 0 0 0 4 0 0 0 3 0 0 0 4 0]
         [0 0 0 3 0 0 0 4 0 0 0 3 0 0 0 4]]

n = 3
qubits = {0, 2}
Operation: [[1  2  3  4 ]
            [5  6  7  8 ]
            [9  10 11 12]
            [13 14 15 16]]
Return: [[1  2  0  0  3  4  0  0 ]
         [5  6  0  0  7  8  0  0 ]
         [0  0  1  2  0  0  3  4 ]
         [0  0  5  6  0  0  7  8 ]
         [9  10 0  0  11 12 0  0 ]
         [13 14 0  0  15 16 0  0 ]
         [0  0  9  10 0  0  11 12]
         [0  0  13 14 0  0  15 16]]

n = 3
qubits = {2, 0}
Operation: [[1  2  3  4 ]
            [5  6  7  8 ]
            [9  10 11 12]
            [13 14 15 16]]
Return: [[1  3  0  0  2  4  0  0 ]
         [9  11 0  0  10 12 0  0 ]
         [0  0  1  3  0  0  2  4 ]
         [0  0  9  11 0  0  10 12]
         [5  7  0  0  6  8  0  0 ]
         [13 15 0  0  14 16 0  0 ]
         [0  0  5  7  0  0  6  8 ]
         [0  0  13 15 0  0  14 16]]
Wow, things get weird.

Operation: 2^m x 2^m identity matrix
Return: 2^n x 2^n identity matrix

n = 5

qubits = {3, 0, 4, 2, 7}

Operation: Pastebin

Return: [Pastebin] (TODO)


As usual, standard loopholes apply. Builtins are allowed, but try to include a solution sans builtin as well.

You can 1-index or reverse the list if desired.

I/O is flexible.

This is , so the shortest solution (in bytes) in each language wins!

Sandboxy stuff

Anything worth mentioning that I missed?

Is there another application of this that might be easier to explain and scare fewer people off?


  • \$\begingroup\$ If I understood correctly, the part "it's difficult to extract the state of a single qubit in the register from the register's vector." means that most "registers" cannot be formed by (multiple) single qubits, correct? \$\endgroup\$
    Commented Apr 22, 2018 at 13:29
  • \$\begingroup\$ @user202729 That is correct. \$\endgroup\$ Commented Apr 22, 2018 at 16:23
  • \$\begingroup\$ Is there a way to rearrange the post so that the task is on top and the explanation comes later? \$\endgroup\$
    – JayCe
    Commented Jun 11, 2018 at 3:53

Bot Wars at the Auction

I have seen KOTH challenges where the bots fight each other, and I have seen KOTH challenges where the bots are in an auction. So I came up with this:

The Challenge:

You must build a javascript bot that will fight other bots using weapons purchased in an auction. These items are: swords, bows, and shields. You can also purchase healing and quivers. Your function is called once per "Turn", and only 1 weapon action and 1 move action can be called in each turn. You start with 200 health, and 2000 coins. Fight in arena with each bot in its own 5 by 5 square. For example, 16 bots would be a 20 by 20 arena.


During an auction, 2 items will be sold per surviving bot. In the initial auction, 3 items will be sold for each bot. It is up to the bots how they will bid: some bots may spend lots on a cool sword, while others could choose to buy healing in large amounts. There is an auction every few hundred turns. Items start at cost 1.


After the auction, your bots will be pitted against each other. With swords to strike nearby enemies, bows to attack distant bots, and shields to defend yourself, what could go wrong? If you find yourself low on health, you can heal (Which takes between 6 and 8 turns).


As input, your function receives an object filled with functions that can be used to control your bot. This object is also at window.bots["yourbot"].auction or window.bots["yourbot"].fight.


//within window.bots["yourbot"]
mode: integer, //0=Dead, 1=Auction, 2=Fight
items: object, //All items owned
coins: integer,
health: integer,
auction: {
    itemlist: array, //Array of item objects
    placeBid(coins), //Bid on item
    incrementBid(amount), //Bids (current + amount)
    item: {
        current: integer, //Current highest bid
        bidder: string, //Current highest bidder
        type: integer, //1=Sword, 2=Bow, 3=Quiver, 4=Shield, 5=Healing
        power: integer, //Item power (Attack amount, healing amount, or block percentage)
        units: integer //Only for healing and quivers; amount of turns taken to heal, or amount of arrows in quiver
fight: {
    botList: array, //List of bots
    surrenderTo(bot), //Surrenders to a specific bot
    move: {
        north(), //Y+
        east(), //X+
        south(), //Y-
        west(), //X-
    use: {
        swordAttack(bot OR [x,y]), //Attacks a bot, but only if it is adjacent to attacker
        bow(bot OR [x,y]), //Shoots bow at bot, bot must be within 5 spaces
        shield(), //Raises shield for 5 turns
        heal(sor) //Uses least powerful healing or takes input sort function
    util: {
        getNearest(), //Returns nearest bot
        getBot(name), //Returns a specific bot by name
        atLocation([x,y]), //Returns bot at a certain location
        gridSize(), //Returns the side length of the square arena
        getPosition(), //Returns array [x,y] of caller bot
        see([x,y]), //Returns true or false, depending on if there is a bot in a certain location

//within other bot nearestBot(), getBot(), botList, or atLocation(x, y)
location: array, //[x,y]
name: string, //Bot's name
items: object //All objects owned by bot

//within items
type: integer, //1=Sword, 2=Bow, 3=Quiver, 4=Shield, 5=Healing
power: integer, //Item power (Attack amount, healing amount, or block percentage)
units: integer //Only for healing and quivers; amount of turns taken to heal, or amount of arrows in quiver

How it Works:

You will start in an auction. With your 2000 coins, you can bid on items using the functions placeBid(price) or incrementBid(amount). If nobody bids for 5 turns, the item is sold. Once the items are all gone, the fight begins. The initial auction focuses mainly on swords, bows, and shields. During the fight, you can attack players using simple methods like bow(nearestPlayer()), or more complex methods involving mapping the area with see([x,y]) and atLocation([x,y]). When the fight round is over, another auction starts, which mainly focuses on healing and quivers. When the fight begins again, you will be able to heal (Make sure you shield right before doing so!). After that fight, another auction will commence. This will repeat until one person remains, or all other bots use surrenderTo(bot). Inflicting damage on another bot gets you 1 coin per point, and you get a 500 coin bonus for killing a bot. If a bot surrenders to you, you earn 100 coins. Store information that you bot may use in window.bots[yourBotName]. Note that a copy of this object is passed to your bot, but storing a varibale in this object will only affect it locally. Coordinates range from [0,0] in the corner to [max,max] in the opposite corner, max being round(22.36 * sqrt(botCount)).

Function Specifications:

    Inputs amount of coins to set the bidding at
    If lower than current highest bid or another bid in that turn, returns 1
    If input is invalid, returns 2
    Will set auction.item.current to coins and auction.item.bidder to your bot name
    Inputs amount of coins to increase bidding by
    Adds to highest bid in last turn
    If lower than current highest bid or another bid in that turn, returns 1
    If input is invalid, returns 2
    Will add amount to auction.item.current and auction.item.bidder to your bot name
    Will move bot 1 space Y+
    Returns 1 if bot is at far North edge of arena
    Will move bot 1 space X+
    Returns 1 if bot is at far East edge of arena
    Will move bot 1 space Y-
    Returns 1 if bot is at far South edge of arena
    Will move bot 1 space X-
    Returns 1 if bot is at far West edge of arena
    Returns the nearest bot as of the last turn
    Read information: location, name, items
    Inputs a string, containing the name of a bot
    If bot does not exist, returns 1
    If bot is dead, returns 2
    If input is invalid, returns 3
    Returns bot as of last turn
atLocation([x,y]) or atLocation(x,y)
    Inputs an array containing coordinates, or two integer coordinates
    Returns bot as of last turn
    If no bot exists in that spot, returns 0
    Invalid input returns 1
    Returns an integer containing the side length of the arena
    Returns an array [x,y] containing the position of the bot
    Takes bot as input
    Will set mode to 0 on your bot
    Gives bot surrendered to 100 coins
    Returns 1 if input is invalid
    Returns 2 if bot is dead or inexistant
    Returns true if bot is in location
    Returns false if input is invalid or no bot exists in location
swordAttack(bot OR [x,y])
    Takes either a bot or [x,y] coordinates as input
    Does as much damage as your best sword
    Will return 1 if input is invalid
    Will return 2 if bot is dead/nonexistant, or if coordinates are out of bounds
    Will return 3 if you don't have a sword
    Will return 4 if bot/coordinates are not within 1 space of your bot
bow(bot OR [x,y])
    Takes either a bot or [x,y] coordinates as input
    Doesas much damage as your best bow
    Will return 1 if input is invalid
    Will return 2 if bot is dead/nonexistant, or if coordinates are out of bounds
    Will return 3 if you don't have a bow, and 5 if you have no arrows
    Will return 4 if bot/coordinates are not within 20 spaces of your bot
    Blocks as much damage as your best shield as a percentage
    Lasts for 5 turns (Includes turn activated)
    Will return 1 if you don't have a shield
    Uses your weakest heal, or you can specify a sort function to define the order they are used
    Cannot move for 6-8 turns (Selected randomly)
    Will return 1 if you don't have heal

Item Specifications:

    The sword is used to attack bots within 1 space
    Has set damage amount (Geometric distribution 10-100)
    Is found in:
        Auction 1 = 35%
        Auction 2 = 30%
        Auction 3 = 15%
        Auction 4 = 5%
    The bow is used to remotely attack bots within 20 spaces
    Has set damage amount (Geometric distribution 4-40)
    Is found in:
        Auction 1 = 30%
        Auction 2 = 20%
        Auction 3 = 10%
        Auction 4 = 5%
    Quivers are purchased with arrows in them, used for shooting bows
    Starts with specific amount of arrows (Geometric distribution 5-20)
    Is found in:
        Auction 1 = 7.5%
        Auction 2 = 10%
        Auction 3 = 25%
        Auction 4 = 40%
        Other auctions = 45%
    Shields are used to defend against attack
    Starts with a specific block percentage (Geometric distribution 5%-75%)
    Can be used while healing
    Is found in:
        Auction 1 = 20%
        Auction 2 = 30%
        Auction 3 = 20%
        Auction 4 = 10%
    Heal is used to regenerate during battle
    Heal level is geometric distribution 20-80
    Is found in:
        Auction 1 = 7.5%
        Auction 2 = 10%
        Auction 3 = 30%
        Auction 4 = 40%
        Other auctions = 55%

Example bot:

function readyToFight(obj) {
    var items = obj.items;
    var types = [];
    var coins = obj.coins;
    for (var i = 0, n; i < items.length; i++) {
        n = items[i];
    if (obj.mode == 1) {
        obj = obj.auction;
        if (obj.item.type == 1) {
            if (types.indexOf(1) != -1) {
                for (var i = 0, n; i < items.length; i++) {
                    n = items[i];
                    if (n.type == 1 && n.power < obj.item.power) {
                        var bid = true;
                if (n.item.price < coins) {
            } else {
                if (n.item.price < coins) {
        } else if (obj.item.type == 2) {
            if (types.indexOf(2) != -1) {
                for (var i = 0, n; i < items.length; i++) {
                    n = items[i];
                    if (n.type == 2 && n.power < obj.item.power) {
                        var bid = true;
                if (n.item.price < coins) {
            } else {
                if (n.item.price < coins) {
        } else if (obj.item.type == 3) {
            if (n.item.price < n.item.units * 2) {
        } else if (obj.item.type == 4) {
            if (types.indexOf(4) != -1) {
                for (var i = 0, n; i < items.length; i++) {
                    n = items[i];
                    if (n.type == 4 && n.power < obj.item.power) {
                        var bid = true;
                if (n.item.price < coins) {
            } else {
                if (n.item.price < coins) {
        } else if (obj.item.type == 5) {
            if (n.item.price < n.item.power * 5) {
    } else if (obj.mode == 2) {
        hp = obj.health;
        obj = obj.fight;
        if (types.indexOf(2) != -1) {
        } else if (obj.health < 50 && types.indexOf(5) != -1) {
        } else {
            //Be scared, or implement better fighting techniques!
    } else {
        //Bot can still see the arena and auction when dead, but cannot fight or bid


Standard Loopholes prohibited, javascript only

  • 1
    \$\begingroup\$ Seems like a solid updated version of the previous idea. I think the "The Challenge" section uses the word "function" too much, and should be updated with slightly less technical language. For example, "Your bot can make one Move action and one Combat action each turn". Additionally, the fight object doesn't separate its functions into movement and attacks. I would recommend sub-objects, for example fight.move.north() and fight.attack.sword(x,y). And if some of those functions are supposed to be neither movement nor attacks, fight.util.getNearest() or the like. \$\endgroup\$ Commented Apr 23, 2018 at 15:52
  • \$\begingroup\$ Okay, got it. Sub objects for fight: move, attack, and util \$\endgroup\$ Commented Apr 23, 2018 at 15:54
  • 1
    \$\begingroup\$ I did use instead of attack, so that shields and heal fit under the same category \$\endgroup\$ Commented Apr 23, 2018 at 16:00
  • \$\begingroup\$ Next, only having the option to use the weakest healing item doesn't seem right to me. While non-consumable equipment makes sense to always use the best, and there's only one "trait" so best is never in question, healing would often want to use "largest heal that isn't overheal" or "heal that takes the least time". I suspect it wasn't done that way to simplify the runner, but only allowing smallest heal seems restrictive. \$\endgroup\$ Commented Apr 23, 2018 at 16:02
  • \$\begingroup\$ Perhaps add an optional parameter for a sort function? Like function(a,b){return a.power - b.power} or function(a,b){return (a.power / a.units) - (b.power / b.units)} \$\endgroup\$ Commented Apr 23, 2018 at 16:05
  • \$\begingroup\$ And then the heals are used in the order they are listed \$\endgroup\$ Commented Apr 23, 2018 at 16:06

Single-Digit Representations of Natural Numbers

Tags: , , , ,


Dr. Inder Taneja is a Mathematics Professor at the Federal University of Santa Catarina who wrote and published "Single Digit Representations of Natural Numbers". In this paper, he describes each natural number from 0 to 1000 in terms of each of the digits 1 through 9 in as few digits as possible and using only the five basic arithmetic operations.

For example, the entry for "282" written only using the digit "3" looks like this:

3 + 3 * (3 * (3 ^ 3 + 3) + 3)

Similarly, "466" written using the digit "7" looks like this:

7 * 77 + 77 / 7 - 77 - 7

This is also described in the first half of this video on the Numberphile youtube channel.

This challenge will ask you to write a program (or function, class, etc.) which takes two inputs and outputs a valid mathematical expression according to the rules used by Dr. Taneja. Your score will be calculated based on the size of your code and the quality of your outputs.


Write a program (or function, class, etc.) which takes two integers as input. The first of these will be an integer from 0 to 1000, inclusive. The second number will be a digit from 1 to 9, inclusive.

The program shall output an expression of the first input as a series of arithmetic operations on numbers whose digits are exclusively the digit specified as the second input.

In addition to parentheses ( and ), the following arithmetic operators are allowed in your output:

  • addition (represented by the +)
  • subtraction (represented by the -)
  • multiplication (represented by the *)
  • division (represented by the /)
  • power (represented by the ^)

Numbers, as stated before, must be composed entirely of the digit specified by the second input, but they can be any number of digits. Numbers can be positive or negative. Number tokens cannot contain any characters besides the digit specified and, if negative, a - at the beginning.

Any form and amount of whitespace, including no whitespace at all, is allowed around each token in your output, where "token" refers to a number, operator, or parentheses. Your program's output may not contain any other characters.

The order of operations are evaluated in the usual manner.


Dr. Taneja claims that his answers use "as few digits as possible"; unfortunately, his paper does not show how to prove that a solution is truly minimal. In the spirit of preserving that goal, however, the quality of your solutions will contribute to your score.

The quality of an output is measured, as Dr. Taneja says, by the number of digits used. For example, consider the output for "466" and "7":

7 * 77 + 77 / 7 - 77 - 7

This has a score of 1 + 2 + 2 + 1 + 2 + 1 = 9. Smaller is better.

Your code's score is:

score = 2 * <worst_scoring_output> + <solution_bytecount>

The lowest scoring valid solution wins.

You may determine your worst output either by test battery (trying every input) or logical proof. The following shell script can be used to compute your worst-scoring output, assuming your program is an executable which takes input as command-line arguments and provides output to stdout on a single line. When executing this script, provide the path to your program executable as a command-line argument.

// TODO: write a shell script which could compute your bonus score


Input and output may use any convenient method. This includes writing a function which takes the inputs as arguments to the function and returns or prints a string as described.

This is , so the size of your code in bytes forms a significant part of your score. The standard loopholes are forbidden, this includes parsing the original paper to "look up" Dr. Taneja's solution for a combination of inputs.

Reasonable adjustments to the output format are allowed; for instance: if your language has a native Expression object for mathematical expressions but its toString() (or equivalent) method represents the power operator as two asterisks rather than a caret, you may use the native representation.

Similarly, if it is easier for you to format your output as an equation rather than a one-sided expression, you may do so. For example, you may output <number> = <expression> or <expression> = <number> rather than simply <expression> (where the number is the first input to the program and the expression is the output as defined in the challenge section). Note that in this case, only the digit count of your expressions contribute to your score.

Example Input and Output

Your outputs may vary, but are still valid provided all explicitly-stated rules are respected.


282 3


3 + 3 * (3 * (3 ^ 3 + 3) + 3)


0 7


7 - 7


1000 9


999 + 9 / 9


466 7


7 * 77 + 77 / 7 - 77 - 7

  • \$\begingroup\$ Welcome to the site! I suggest including test-battery as a winning criterion here—in fact, this is almost exactly the challenge described in the tag wiki! \$\endgroup\$ Commented Apr 22, 2018 at 21:15
  • \$\begingroup\$ @Scrooble thank you! do you mean anything besides just tagging it as test-battery? i've added (to the top) a list of the tags i intend to use for this challenge. \$\endgroup\$ Commented Apr 22, 2018 at 21:23
  • \$\begingroup\$ Nope, that's all I meant! You can use [tag:tag-name] for the nice-looking tag links. \$\endgroup\$ Commented Apr 22, 2018 at 21:37
  • \$\begingroup\$ Are you allowed to concatenate, i.e. 36 = 3 + 33? (I vote no, but it's quite common to allow that.) \$\endgroup\$
    – N. Virgo
    Commented Apr 23, 2018 at 4:20
  • \$\begingroup\$ @Nathaniel concatenation is not allowed as an operator in the output; however, your output is allowed to have multi-digit numbers as long as all of the digits are the digit specified. \$\endgroup\$ Commented Apr 23, 2018 at 13:52
  • \$\begingroup\$ I'd prefer a version that does not include the bonus. In fact, I think that it should instead be the primary scoring method, e.g. "each submission's score is the total number of digits used across all inputs". Bonus points in Code Golf tend to quickly become either ignored or mandatory \$\endgroup\$ Commented Apr 23, 2018 at 21:02
  • \$\begingroup\$ @KamilDrakari i really like that suggestion. i was worried it would be hard to find a bonus point value that doesn't end up getting ignored because it isn't worth the extra bytes. \$\endgroup\$ Commented Apr 23, 2018 at 22:27
  • \$\begingroup\$ @KamilDrakari what do you think of your score being the score of your program + your bytecount, to preserve the golf aspect? \$\endgroup\$ Commented Apr 23, 2018 at 22:31
  • \$\begingroup\$ If you just score it the way I mentioned, adding up all digits used, then I think the golfing would just be way too inconsequential in comparison. Maybe "highest number of digits + byte count"? It's not that different from the current scoring, but it avoids weird cutoffs and negative points so it's more likely that both parts matter. \$\endgroup\$ Commented Apr 24, 2018 at 4:16
  • \$\begingroup\$ @KamilDrakari i've re-written the scoring rules. please let me know what you think. i think it strikes a nice balance between golfing and quality outputs. \$\endgroup\$ Commented Apr 24, 2018 at 14:34
  • \$\begingroup\$ @WoodrowBarlow Looks good. I think having that script prepared that will calculate the score is definitely a good idea since manually testing all 9000 input possibilities would be tedious. It would also be nice if that script, in addition to outputting the score (or just "highest_scoring_output" since having it count bytes as well might be problematic), also said which input pair is responsible. \$\endgroup\$ Commented Apr 24, 2018 at 14:39
  • \$\begingroup\$ The problem space of expression-building has been fairly well explored, and there are a few questions which this might be considered to duplicate. I personally would vote to close as a duplicate of codegolf.stackexchange.com/q/32085/194 : adding exponentiation as a supported operator and a loop to find the smallest k are both trivial changes IMO. \$\endgroup\$ Commented Apr 25, 2018 at 9:58
  • \$\begingroup\$ Wait… just how does the length of my code affect my score? \$\endgroup\$
    – Nissa
    Commented Apr 25, 2018 at 13:22
  • \$\begingroup\$ @StephenLeppik your score is: 2 * [worst_scoring_output] + [length_of_code]. lower score is better. is that not clear? \$\endgroup\$ Commented Apr 25, 2018 at 13:52

ASCII-betical order

The full printable ASCII set (chars 32-126) in ascending order looks like this:


Your task is to create a program or function which takes in an integer n and outputs the nth item of an OEIS sequence. The catch: your score is the length of your code, plus thrice the number of ASCII chars in your code not included in the longest strictly increasing substring.


A valid strictly increasing substring of your code is defined as so:

  • Each character within the substring, except the first, must have a higher ASCII value than the previous.

Other rules:

  • The sequence may be 0- or 1-indexed.
  • The sequence you choose may not be a constant sequence, such as A000012.
  • Entries may only include printable ASCII and newlines. Newlines are ignored when calculating the longest increasing substring.


This JavaScript function outputs A000027 (the natural numbers):


The longest increasing substring of characters is =>[]^n. Therefore, the score is 7 + 3 × (7 - 6) = 10.

This function does exactly the same thing:


The longest increasing substring is =>[]^_abcdefghijklmnopqrstuvwxyz. The score is 59 + 3 × (59 - 32) = 140.

This function also does the same thing:


The longest increasing substring is !"#$%&'()*/=>[]^n. Therefore, the score is 20 + 3 × (20 - 17) = 29.

The lowest score wins.

Sandbox questions

  • Is the scoring system sufficient?
  • Is there a better option for the challenge?
    • Output n'th item in some OEIS sequence
    • Output first n items of some OEIS sequence
    • Output the score of the input
    • etc.
  • What about languages with extended code pages? Should only the ASCII chars be counted, or should the bytes of the program be considered instead?
  • Any other concerns?
  • \$\begingroup\$ I like this version much better. Some ideas: maybe force to choose a non costant oeis sequence? I'm not sure about scoring, seems that standard golfing without caring about increasing ascii can still get a pretty good score... Rule to use only ascii chars in code seems to just be a limit to golfing languages. For the title, i liked the term ASCIIbetical order used in a comment to the previous proposal .) \$\endgroup\$
    – Leo
    Commented Dec 1, 2016 at 23:41
  • \$\begingroup\$ @Leo I like the non-constant-sequence idea. I've modified the scoring system to make it a little easier to use (see examples), but I still don't like it because if you need to use that variable name 3 times, it's not worth it, and if you only need it once, it's doubly worth it. Perhaps something taking into account the number and length of individual runs would work better, but I have no idea how to work that out... \$\endgroup\$ Commented Dec 2, 2016 at 4:49
  • \$\begingroup\$ Would something like f n = if ( length "#$% ... |}~" == 92) then n else 0 be valid? For golfing languages the length check won't be much overhead. \$\endgroup\$
    – nimi
    Commented Dec 2, 2016 at 15:18
  • \$\begingroup\$ I'd prefer the scoring to work like this (which would be simpler): length, plus three times the number of characters in your code which are not part of the longest substring. That'd prevent people putting the whole ASCIIbet in a string and using a checksum (or length check) to make sure it hadn't been changed. In other words, it'd would encourage programs which were mostly formed of increasing ASCII, rather than programs which contained a lot of increasing ASCII (i.e. favour proportion over length). \$\endgroup\$
    – user62131
    Commented Dec 6, 2016 at 11:27
  • \$\begingroup\$ @nimi Sorry, I missed your comment. I suppose that would be valid. The scoring system would have to account for that. \$\endgroup\$ Commented Dec 6, 2016 at 17:22
  • \$\begingroup\$ @ais523 I like that idea; however, as it's currently written, that would give the first two examples scores of 16 and 140, respectively. I'd like to give the second example a much lower score, if possible, but I'm not sure how to do this, and it may not be a good idea. What do you think? \$\endgroup\$ Commented Dec 6, 2016 at 17:28
  • \$\begingroup\$ I think it's a bad idea. The second example isn't actually any different from the first in terms of AST, it just has a bunch of junk characters written somewhere (in this case, a variable name) that the program doesn't parse them (with an equal number of characters outside to balance). \$\endgroup\$
    – user62131
    Commented Dec 6, 2016 at 17:32
  • \$\begingroup\$ @ais523 OK, I've changed the scoring algorithm. I've also removed the "you can't be able to remove any chars in the substring" rule for now, as it now seems superfluous. \$\endgroup\$ Commented Dec 6, 2016 at 17:47
  • \$\begingroup\$ The problem with this scoring is that the winner would probably be a 2 byte program in a golfing language scoring 2 points (or a 1 byte program scoring 1 point, I bet someone will find it). \$\endgroup\$
    – Leo
    Commented Dec 7, 2016 at 16:37
  • \$\begingroup\$ @Leo: I guess even 0 bytes is possible by using a language that takes implicitly input, puts in on the stack (does nothing for 0 bytes) and outputs the stack when the program stops. This is sequence A000027, the natural numbers . \$\endgroup\$
    – nimi
    Commented Dec 7, 2016 at 19:42
  • \$\begingroup\$ @Leo Yes, that's a very good point. It's so hard to come up with a good formula.... Do you have any more ideas? \$\endgroup\$ Commented Dec 7, 2016 at 21:44
  • \$\begingroup\$ @ETHproductions Maybe (length of longest increasing sequence)^2/(length of whole program) ? Highest score wins, max would be 95 for a program composed by exactly the whole sequence \$\endgroup\$
    – Leo
    Commented Dec 8, 2016 at 8:33
  • \$\begingroup\$ @Leo The problem with that would be it goes back to rewarding solutions containing the whole string with a length check... (For example, n=> !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~"[90]?m:n in JavaScript scores 84.346) \$\endgroup\$ Commented Dec 9, 2016 at 3:25
  • 1
    \$\begingroup\$ A separate comment: you should replace "ASCII chars" with "bytes". That would allow more languages to compete. \$\endgroup\$
    – N. Virgo
    Commented Apr 27, 2018 at 14:12
  • 1
    \$\begingroup\$ As a follow-on to my previous comment about the identity function being shorter in some languages, as things stand I could submit a zero-byte answer in GolfScript. When a zero-byte answer is possible, the question has a serious problem. \$\endgroup\$ Commented Apr 27, 2018 at 18:00

The Derby Stakes

The Derby is a horse race run (near) annually since 1780 near the town of Epsom and is the middle leg of the Triple Crown. The race covers one mile, four furlongs, and six yards. Over the years it has had as few as 4 and as many as 34 entries. The fastest winning time was in 2010 at 2m31.33, but I'm old-fashioned and like horse race results only to the nearest fifth of a second. So let's call it 2:31 2/5.

The task

We will ID horses by number from 0 or 1 (your choice) up to the number of horses in the race (could be anything from 4 to 34).

The task is to take a list of the average horse speeds in miles per hour and produce a report of the race. The report has:

  1. the winning horse ID and its winning time;
  2. the other horse IDs in their order of finish and the difference between each time and the time of the horse that finished ahead of it.


  1. the times are to the nearest fifth of a second. There can be ties, which must be listed in random order;
  2. some horses might not finish the race, in which case their average speed is 0.


The input will have between 4 and 34 non-negative numbers (average speeds) rounded to one decimal place, in any convenient format for your language. The horse ID is just the index (starting at 0 or 1) of their average speed.

The output can be any convenient format, as long as the winner is "first" (in the sense of top-most or left-most) and the other horses are listed in a way that makes their finishing order clear.

The times have to be rounded to the nearest fifth of a second, but otherwise can be represented however you like, such as the number of seconds, or some format like 2:31.4 or whatever. If the time is in "seconds flat", as they say, either 2:32.0 or 2:32 (for example) is fine.

For horses that don't finish the race, no time difference really makes sense, so anything that just indicates they didn't finish is fine. But the do have to appear in the report, and if more than one horse does not finish they have to be listed randomly.

The point with the output is that it needs to be clear, but the format itself is not so important.

You also need to state in your answer how you have ensured that ties are output in a random order.

Test case

31.8, 0, 32.9, 32.1, 30.8, 31.8, 31.1, 33.1  

8 2:43.6
3 0:01.0
4 0:04.0
1 0:01.6
6 0:00.0
7 0:03.8
5 0.01.8

"I made the ranking of ties random by using `rank(x, ties.method = "random")` in R."

I chose a particular time format and used "DNF" for the horse that didn't finish, but you don't need to adhere to these.

I will make more test cases if this challenge seems interesting to anyone.

This is . Standard loopholes forbidden.

  • \$\begingroup\$ I assume .5 is expected to be rounded to .6 ? \$\endgroup\$
    – JayCe
    Commented Jun 11, 2018 at 2:12
  • \$\begingroup\$ Do the times get rounded to 1/5 of a second before calculating the differences, or are the differences rounded to 1/5 of a second? \$\endgroup\$
    – JayCe
    Commented Jun 11, 2018 at 2:20
  • \$\begingroup\$ Also you might want (or not) to clarify how many miles is 1 mile, 4 furlongs and 6 yards. Or it could be another code-golf challenge if it doesn’t already exist :) \$\endgroup\$
    – JayCe
    Commented Jun 11, 2018 at 2:22

How far can I throw a ball up the hill?

Given an initial velocity, an angle to throw the ball, and the angle of a hill, determine how far the ball will go before it hits the ground due to gravity.

Refer to the image below. V=initial velocity vector, a1=angle of hill, a2=angle ball is thrown at, d=distance ball will travel

Highly detailed image


  • The velocity the ball is thrown at (m/s)
  • The angle from level ground that the ball is thrown at (radians or degrees)
  • The angle from level ground the hill is at


  • The number of meters the ball travels before hitting the ground


  • Gravity will pull the ball downwards at 9.81 m/s^2
  • Due to floating point rounding, the answer only need be correct within 0.1 of my test case examples
  • The input angle can be between 0 and pi/2 radians (or 90 degrees)
  • An angle of 0 means the ball is thrown horizontally across the ground, which hits the ground at 0 meters
  • An angle of pi/2 radians (or 90 degrees) means the ball is thrown vertically and hits the ground at 0 meters
  • The angle of the hill will always be less or equal than the angle the ball is thrown at
  • This is code golf, fewest bytes wins

Related to task 3

Test cases

pi/4  (20, 0.7853981633974483, 0) = 40.8
pi/5  (20, 0.6283185307179586, 0) = 38.8
pi/6  (10, 0.5235987755982988, 0) = 8.8
pi/3  (10, 1.0471975511965976, 0) = 8.8
pi/2  (5,  1.5707963267948966, 0) = 0.0
0     (5,  0,                  0) = 0.0


I'm not sure what standard rules are used when accounting for floating point errors, is allowing a .1 margin of error fine?

Test cases for angles > 0 to come.

  • \$\begingroup\$ I think allowing both degrees and radians would be better. \$\endgroup\$ Commented Apr 30, 2018 at 6:20
  • \$\begingroup\$ @PeterTaylor Added a bit more to the challenge. \$\endgroup\$
    – aoemica
    Commented May 1, 2018 at 6:23
  • \$\begingroup\$ I think that in light of the changes, some of the points need to be updated. Point 3 talks about the input angle (singular), but may no longer be necessary at all. Point 4 also looks out of date. With respect to floating point errors, that's tricky to do well. IMO the best approach is to specify a range of input values and an error (relative or absolute) which must be obtained within that range; but to verify that the requirements are reasonable may require numerical analysis. \$\endgroup\$ Commented May 1, 2018 at 7:34
  • \$\begingroup\$ While this is mathematically interesting, it does not allow for very much solution variation. \$\endgroup\$
    – Beefster
    Commented May 1, 2018 at 16:03
  • \$\begingroup\$ 1. Regarding floating point inaccuracies, you can visit this meta post to get some inspiration and guidance. 2. I think physics is a good fit here. 3. In its current form, if posted, the challenge is very likely to be closed as Unclear what you are asking, since you don't include a way to compute that distance. I suggest adding this to the challenge \$\endgroup\$
    – Mr. Xcoder
    Commented May 1, 2018 at 18:37
  • \$\begingroup\$ I don't think such challenges (where there is a formula, and deriving the formula is the main part of the challenge) have many interesting solutions. Explicit form. (cc @Mr.Xcoder ) \$\endgroup\$
    Commented May 2, 2018 at 12:18
  • \$\begingroup\$ You should make it clear that the output is the horizontal length traveled (instead of the arc length) \$\endgroup\$
    Commented May 2, 2018 at 12:19
  • \$\begingroup\$ @user202729 I myself know how to solve the challenge in its current form, however I just pointed out that a larger audience might not receive this too well. Perhaps this challenge isn’t really suited for our format on PPCG. (P.S. the length is not horizontal, it’s along the inclined plane.) \$\endgroup\$
    – Mr. Xcoder
    Commented May 2, 2018 at 12:21
  • \$\begingroup\$ @Mr.Xcoder For the current test cases they're equivalent anyway. \$\endgroup\$
    Commented May 2, 2018 at 12:26


A typical stack-based lanaguage uses nilads, monads, dyads, and occasionally operations with larger numbers of arguments. As each operation is processed, the values are stored on a stack, so that if you want to apply an operation to the result of other operation(s), you simply invoke those operations (and predecessor operations if necessary), at which point their results will end up on the stack ready for the operation you provide next.

Queuez is a fictional language which works differently: instead of the results being stored on a stack, they are stored in a queue, so you have to be careful how you manage your order of operations. For example, let's imagine that digits are nilads and - and / are dyads and you want to calculate ((a / c) - f) / ((b / d) - e). In a stack-based language you would write this as ac/f-bd/e-/, however in Queuez you need to write this as acbd/f/e--/. Explanation:

Command Stack
a       a
c       a c
/       a/c
f       a/c f
-       a/c-f
b       a/c-f b
d       a/c-f b d
/       a/c-f b/d
e       a/c-f b/d e
-       a/c-+f b/d-e
/       (a/c-f)/(b/d-e)
Command Queue
a       a
c       a c
b       a c b
d       a c b d
/       b d a/c
f       b d a/c f
/       a/c f b/d
e       a/c f b/d e
-       b/d e a/c-f
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)

Please write a program or function that converts a program written in a fictional stack-based language into the equivalent Queuez. The actual nilads, monads and dyads of the two lanaguages will be arbitrarily mapped to three sets of at least 10 printable ASCII characters of your choice (you are not required to use letters or mathematical symbols); your answer only has to output the correct rearrangement based on which characters you have chosen to represent nilads, monads and dyads. You can assume that there will be one value left on the stack/queue at the end of the program. Normal rules apply.

If you prefer, you can reverse the dyad argument order, but this must apply both to the original stack-based language and the output. For instance, for the input edb/-fca/-/ you would need to output dbcae/f/--/:

Command Stack
e       e
d       d e
b       b d e
/       b/d e
-       b/d-e
f       f b/d-e
c       c f b/d-e
a       a c f b/d-e
/       a/c f b/d-e
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)
Command Queue
d       d
b       b d
c       c b d
a       a c b d
e       e a c b d
/       b/d e a c
f       f b/d e a c
/       a/c f b/d e
-       b/d-e a/c f
-       a/c-f b/d-e
/       (a/c-f)/(b/d-e)
  • \$\begingroup\$ By "ASCII" did you mean "characters" or "symbols"? (can we use SBCS?) \$\endgroup\$
    Commented May 5, 2018 at 14:52
  • \$\begingroup\$ I think this needs to be narrowed from "Make up a language with the operators of your choice, and then do the real task on the basis of that language". That has the potential to move the golfing from the program to the definition of the task, e.g. by making all the dyads commute in order to simplify the transformations, or making all the monads no-ops so that they just serve to rearrange the queue, or having some operators which build lists and an eval dyad which evaluates a string over a list in a stack-based way, or ... \$\endgroup\$ Commented May 5, 2018 at 17:18
  • \$\begingroup\$ @PeterTaylor Sorry, that was not the intent of the challenge; thank you for pointing out that it needed clarification. Hopefully this new wording will indicate that the meaning of the operators is unknown and therefore the work lies in finding the appropriate rearrangement. \$\endgroup\$
    – Neil
    Commented May 5, 2018 at 20:37
  • \$\begingroup\$ @user202729 You don't know the underlying SBCS of the language because you don't need to know, all you know is that it has been mapped to three sets of printable ASCII characters of your choice. \$\endgroup\$
    – Neil
    Commented May 5, 2018 at 20:39
  • \$\begingroup\$ @Neil Then call them "bytes". \$\endgroup\$
    Commented May 6, 2018 at 2:00

Multidimensional orthodiagonal steps

Step further in step generation.
Navigation in 2d matrix is common, but something uncommon is even more insteresting.
Now I'll ask you to develope shortest solutions to generate all possible steps in N-dimensional matrix.


Your code takes positive integer number N > 0 as input.
Your code must output all possible steps in matrix of N dimensions. In other words, you need to output coordinates of all cells that touch (0;...;0) cell in any way.


Input: 1


Input: 2


Input 3: Output:

(0,1,0)   (0,1,1)    (0,1,-1)
(0,-1,0)  (0,-1,1)   (0,-1,-1)
(1,0,0)   (1,0,1)    (1,0,-1)
(-1,0,0)  (-1,0,1)   (-1,0,-1)
(1,1,0)   (1,1,1)    (1,1,-1)
(1,-1,0)  (1,-1,1)   (1,-1,-1)
(-1,1,0)  (-1,1,1)   (-1,1,-1)
(-1,-1,0) (-1,-1,1)  (-1,-1,-1)


  1. Standart loopholes are disalowed
  2. Input number is always integer and always greater than zero
  3. Output order is not relevant
  4. Output is flexible. Coordinates just need to be distinguishable
  5. This is code-golf, so shortest answer in bytes wins
  • \$\begingroup\$ Some typos: insterestinginteresting, developedevelop, StandartStandard, disaloweddisallowed \$\endgroup\$
    – wastl
    Commented May 19, 2018 at 9:04

Fridge magnet substitution (posted)

  • \$\begingroup\$ You should add 6 = 9, 7 = L, and C = U. If you're willing to have nuance like intransitivity and directionality, you could add Z = 2 (but not Z = R) H = I (but not H = 1), 7 = T (But not T = L), P => D (D doesn't really work for P, but P acts like a lower case d if you flip it over), Q => O (sorta works if you flip over Q), T => I (also flipped), V => C/U \$\endgroup\$
    – Beefster
    Commented May 14, 2018 at 23:20
  • \$\begingroup\$ Good additions! I thought of having directionality, but I wanted to keep the commutation that message A->B implies B->A. I'll add the other ones though. \$\endgroup\$
    – maxb
    Commented May 15, 2018 at 7:00

Treasure Map Drawing Bot

You're organizing a treasure hunt for your friends. To conduct things more easily, you want to draw a map of all locations where you hid the precious objects.


A string consisting of the locations of the objects separated by newlines. Each location is represented by two non-negative integer coordinates describing the position in the field by an x- and y-coordinate, 0 0 being the upper left corner. Example:

1 2
3 0
0 1


Your function or program should be able to construct a map denoting every given location with an x where the mark is found in row y + 1 and column x + 1 in the output. Unmarked locations are represented with a . The map also consists of a frame where the corners are +s, the vertical lines are |s and the horizontal lines are -s. Map for the input example given above:

|   x|
|x   |
| x  |

Possible Test Cases

"0 0"

"0 10
 5 5
 10 0"
|          x|
|           |
|           |
|           |
|           |
|     x     |
|           |
|           |
|           |
|           |
|x          |


"0 0
 0 2
 2 0"
|x x|
|   |
|x  |

Of course, this is , meaning that the solution with the lowest byte count wins!

  • 1
    \$\begingroup\$ You may wish to clarify that the (0,0) position is the upper left corner. This is common in computer graphics in my experience, but not any other field. If that isn't correct, then your test cases seem to be wrong (and you should clarify where the (0,0) position is anyway). \$\endgroup\$ Commented May 14, 2018 at 17:21
  • \$\begingroup\$ Thanks, did that. \$\endgroup\$
    – racer290
    Commented May 14, 2018 at 17:57

Is it a table?


Take an bitmap (in .bmp, 2D array, string containing line break, etc.), check whether it's a table, i.e. the outer border is a rectangle, and each separated (edge-connected) empty part in it is a rectangle.

Equivalently, each space area, including the outside one, has exactly 4 edges.

You can't assume there is or is no space outside of the table.

Test cases

True samples:

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

Note that in this test case the smallest space area (with 1 space) is a rectangle, although it doesn't have a rectangular border with #.

False Samples:

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

In this test case the lower-left empty region is a concave hexagon.

#    #     #
#    #     #

The outer border is not a rectangle.

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

The outer empty region has a "hole" inside.

Winning criteria

Shortest code win.

  • \$\begingroup\$ This is massively unspecified, and based on the test cases I'm not even sure why the truthy cases are tables and some of the falsey cases not.. As stated in the Sandbox description: "Write your challenge just as you would when actually posting it.", which this clearly isn't.. I'm assuming you just had this challenge as a idea and don't have the time yet to fully specify it, in which case it would be better to save it in a local Notepad doc until you have time to specify it, before posting it here. I do the same pretty often. \$\endgroup\$ Commented May 25, 2018 at 11:40
  • \$\begingroup\$ @KevinCruijssen the whole one is a rectangle, and each separated part is a rectangle \$\endgroup\$
    – l4m2
    Commented May 25, 2018 at 11:43
  • \$\begingroup\$ Why is the third test cases truthy? Do we look at the # for the outer rectangle, but the spaces for the inner ones? If either both # this third truthy case would be false; and if both space (somewhat), I could imagine the second falsey case to be true. \$\endgroup\$ Commented May 25, 2018 at 11:51
  • \$\begingroup\$ @KevinCruijssen Also Notepad doesn't help wording, so your suggestion is bad \$\endgroup\$
    – l4m2
    Commented May 25, 2018 at 12:43
  • \$\begingroup\$ I meant creating the answer with correct formatting here, then save it in Notepad++ until it's fully specified (which is what I do). Alternatively you can keep it open in your browser tab until it's fully specified before clicking the "post"-button. Either way, it clearly isn't "Write your challenge just as you would when actually posting it." right now.. That's all I wanted to state. It does look like an interesting challenge when it is fully specified, though. So you'll have my future upvote when it is. \$\endgroup\$ Commented May 25, 2018 at 12:52
  • \$\begingroup\$ I think you should prove clearly how [it clearly isn't "Write your challenge just as you would when actually posting it."] @KevinCruijssen \$\endgroup\$
    – l4m2
    Commented May 25, 2018 at 12:56
  • \$\begingroup\$ I don't understand this. Why is the third truthy test case truthy? Why are the first and third falsey test cases falsey? \$\endgroup\$ Commented May 25, 2018 at 13:28
  • \$\begingroup\$ @AdmBorkBork its outer border is a 8*11 rect, and there are 4 empty rect parts in it, 3 2*3 and a 1*1. First false test contain an empty part with 6 edges, 3rd one with 8 edges \$\endgroup\$
    – l4m2
    Commented May 25, 2018 at 14:00
  • \$\begingroup\$ So this is also a truthy example? \$\endgroup\$
    Commented May 29, 2018 at 5:00
  • \$\begingroup\$ @user202729 True. Another true case I think maybe necessary is ### (no space area)? \$\endgroup\$
    – l4m2
    Commented May 29, 2018 at 8:00

Formic Functions 2: Hierarchies

     Watch live | Active answers | Add new answer | Chat room | Source code | Leaderboard

               This is an open-ended challenge. New answers and updates are always welcome.

We've seen the territorial highland ants wander the lands in search of food. There have also been talks of aggressive forest ants lurking down below whilst feasting on fungi. These ants, however, are unlike any you've seen before. Collecting food is their goal, as always, but colonies don't need a queen - all ants of this subfamily are capable of creating offspring. There's a catch, though. New ants have less strength than their parent, unless the parent ant spends a large amount of food on them. Ants are capable of killing others weaker than them, and weaker ants are worth less, so your ants need to make careful choices.

Watching the game

Because this competition is made in JavaScript, you can see what other players have made already directly in your browser. Just click on one of the links above - you'll figure out the rest.


To keep the comment section clean, I highly encourage you to use the dedicated chat room for questions and discussion.


No official tournaments available yet.


Here are a couple of images taken at the end of a game that should entice you:

No screenshots available yet.

You can look at more simply by running games in your browser. The controller also allows you to zoom in so you can track the ants' decisions that result in the large-scale patterns you ultimately see.


A value range is indicated by a number followed by two dots and another number. "0..7" means "between 0 and 7, inclusive". A different type of range is indicated by a number followed by a plus sign. "1024+" means "greater than or equal to 1024".


Your task is to provide a JavaScript class that implements a getAction(view) function and optionally a constructor. All code provided by you will be run under strict mode.

The constructor is called with no arguments. It must take no more than one second to run. It must be side-effect free and must consistently result in an identical object after every run.

The getAction(view) function (henceforth known as the ant function) is called like this: yourConstructedObject.getAction(someViewArray);. It must also be side-effect free and must consistently return an object, and provide the same output every time if provided the same input.

At the start of every game, your ant function is granted 1 second of reserve time. It is also granted an additional 10 milliseconds of time every time it is called. Time measurement starts right before the function call and ends upon return. That time is then taken away from the reserve time. Your function must not run out of the reserve time.

The constructed object and any temporary data combined must not consume more than 64 MB of memory at any time.

Here's a template for you to fill in:

class Entry { // TODO: Change the "Entry" to whatever you want, preferably your entry name. Remember that this is a JavaScript class name, so you can't use some characters.
  constructor() {
    // TODO: Optionally fill this in.

  getAction(view) {
    // TODO: Fill this in.


The arena is a toroidal (edge wrapping) grid of hexagonal cells arranged in a rhombus of side length 1500. Initially, all cells have the color 0 and 0.1% have food placed on them, for a total of 2250 pieces of food. Up to 12 entries are randomly chosen every game and have their corresponding ants (one per entry) spawned in random locations, with no more than one ant occupying any cell. The initial turn order of ants is also randomized.


The game lasts 32768 turns, which are processed sequentially. Every turn, in an unchanging order, each ant has its corresponding function called with the local state of the arena passed as an argument. In other words, your ant function is called separately for every ant you control. The action chosen by the ant function is then taken immediately - other ants see the arena changes even during the same turn.



Each ant carries the following properties with them:

  • Position: Implementation-defined.
    • Ants do not have access to their global position.
  • Tier: An integer representing the tier of an ant.
    • Equal to 0 for all ants not spawned by other ants.
    • Doesn't change over an ant's lifespan.
    • The lower its tier, the less valuable an ant is.
    • There is no theoretical limit on how high or low tier can be.
  • Age: An integer representing how old an ant is.
    • Initially 0 for all ants.
    • After every action an ant takes its age goes up by one.
  • Food: An integer representing the amount of food an ant is carrying.
    • Initially 0 for all ants.
    • An ant may carry an unlimited amount of food.
  • Memory: An integer in the range 0..15 representing the memory of an ant.
    • Initially equal to 0 for all ants not spawned by other ants.
    • An ant may change it as part of any action.
    • Holds no meaning for the controller.
  • Owner: Implementation-defined.
    • Allows ants to see whether another one is a friend or not.


Each ant sees 6 cells in its neighborhood, as well as the cell it is currently occupying. Each cell contains the following properties:

  • color: An integer in the range 0..7 representing the current color of a cell.
  • food: A boolean representing whether or not a piece of food is present on a cell.
  • ant: An object if an ant is present on a cell, undefined otherwise. If present, the object has the following properties:
    • tier: Maps to Tier.
    • age: An integer in the range 0..3 representing an ant's age on a logarithmic scale. 0 actual age maps to 0, 1..31 actual age maps to 1, 32..1023 actual age maps to 2 and 1024+ maps to 4. [Sandbox note: I'm torn about whether or not the ants should have access to this information.]
    • [Sandbox] Alternative for or complement to age: older: A boolean representing whether or not an ant's age is higher that of the currently active ant.
    • food: An integer in the range 0..3 representing the amount of stored food by an ant on a logarithmic scale. 0 actual food maps to 0, 1..3 actual food maps to 1, 4..15 actual food maps to 2 and 16+ actual food maps to 3.
    • memory: Maps to Memory.
    • friend: A boolean representing whether or not an ant is under control of the same entry as the currently active ant.

Every turn sight is passed to your ant function as an array of 7 objects, arranged in this order:

 0 1
5 6 2
 4 3

The view is randomly rotated by a multiple of 60 degrees every time your ant function is called. This means that it's impossible to extract a consistent sense of direction without clever use of the environment.

Accessing one's own state is done by retrieving the ant object of the 7th element of the array, like this: const me = view[6].ant;


Each ant must perform an action every turn. The possible actions are as follows:

  • Move: Move to the desired cell.
    • Format: {cell: 0..6, action: 0}
    • When moving onto a cell with food on it, an ant automatically picks up the piece of food present.
    • When moving onto a cell with an ant on it, of the two ants only one remains. If the still ant's tier value is lower than that of the moving ant, then the still ant dies and is permanently removed from the game. Otherwise, the unfortunate fate awaits the moving ant instead. In either case, the remaining ant gains all the food of the ant that died and one more.
    • Staying still is a valid action and may hold merit in certain situations.
  • Paint: Change the color of the desired cell to the desired color.
    • Format: {cell: 0..6, action: 1, color: 0..7}
    • Changing the color of a cell to the same one is a valid action.
  • Place food: Put a piece of food onto the desired cell.
    • Format: {cell: 0..6, action: 2}
    • Placing a piece of food onto a cell with an ant on it results in that ant immediately picking it up.
    • Placing food costs food. An ant may only place a piece of food if it has at least one food stored, and one food is taken away from it.
    • Placing food onto own cell is a valid action, but placing food onto a cell with a piece of food already on it is not.
  • Spawn: Create a new ant under control of the same entry on the desired cell.
    • Format: {cell: 0..6, action: 3, tier: -1..+1, state: 0..15}
    • A parent ant must choose to spend 1, 4 or 16 food on the new ant by specifying a tier equal to -1, 0 or +1 respectively.
    • A parent ant may only spawn an ant of the desired tier if it has the necessary amount of food to do so, and that amount is taken away from it.
    • Spawning results in an ant of a tier equal to that of its parent plus the tier value specified.
    • A parent ant must choose the initial memory of the new ant by specifying a state. [Sandbox note: I'm considering not letting parents set the initial memory of offspring.]
    • The new ant is inserted into the turn order right before its parent.
    • Spawning an ant counts as movement for the new ant, and is resolved as such.
    • Spawning an ant onto own cell is a valid action and may hold merit in certain situations.
  • Memorize: Replace the currently active ant's memory with the desired number.
    • Format: {memory: 0..15}
    • Memorization is not an action itself. It must be appended to one of the four previously mentioned actions.
    • An ant may choose to leave this field undefined. No memory change occurs then. [Sandbox note: Torn about this as well.]

Format refers to the JavaScript object that must be returned by your ant function to perform a specific action.

Example outputs:

  • {cell: 0, action: 0} // Move to cell 0.
  • {cell: 6, action: 0} // Do nothing.
  • {cell: 6, action: 1, color: 0} // Set own cell color to 0.
  • {cell: 3, action: 2} // Put a piece of food onto cell 3. Invalid if there is a piece of food on cell 3.
  • {cell: 2, action: 3, tier: -1, state: 3} // Spawn an ant 1 tier lower than that of your own with initial memory equal to 3 on cell 2 at the cost of 1 food. Invalid if you have no food.
  • {cell: 5, action: 3, tier: +1, state: 11, memory: 14} // Spawn an ant 1 tier higher than that of your own with initial memory equal to 11 on cell 5 at the cost of 16 food whilst committing 14 to memory. Invalid if you have less than 16 food.
  • {cell: 6, action: 3, tier: 0, state: 0} // Spawn an ant with tier equal to that of your own with initial memory equal to 0 on your own cell at the cost of 4 food. A conflict occurs and the newly spawned ant dies, giving you a piece of food. Effectively, ou lost 3 pieces of food. Invalid if you have less than 4 food.
  • {cell: 6, action: 3, tier: +1, state: 0} // Spawn an ant 1 tier higher than that of your own with initial memory equal to 0 on your own cell at the cost of 16 food. A conflict occurs and you die, giving the newly spawned ant a piece of food (and any additional food you might've had). Effectively, you upgraded yourself at the cost of 15 food. Invalid if you have less than 16 food.
  • {cell: 3, action: 0, color: 5, test: true, memory: 1} // Move to cell 3 whilst committing 1 to memory. Values ofcolorandtestare irrelevant. You may choose to include unrelated properties - they are simply ignored. [Sandbox note: Maybe the controller shouldn't allow color in this case? This looks like it might be a good breeding ground for hard-to-detect bugs.]

Example invalid outputs (not exhaustive):

  • {cell: 7, action: 0} // Error: Value of "cell" outside required range 0..6.
  • {cell: 3} // Error: "action" left undefined.
  • {action: 1, color: 4} // Error: "cell" left undefined.
  • {cell: 4, action: 3, tier: -1} // Error: "state" left undefined.


At the end of each game, every entry participating in that game is evaluated according to this formula:


n is the number of ants belonging to the entry currently being evaluated
Ti is the tier of the ith ant belonging to the entry currently being evaluated
Fi is the amount of food the ith ant belonging to the entry currently being evaluated is holding

Or as pseudocode:

var evaluation = 0;
for (int i = 0; i < entry.ants.count; i++) {
  var ant = entry.ants[i];
  evaluation += Math.Pow(2, ant.tier) + Math.Pow(2, ant.tier - 1) * ant.food;

[Sandbox note: Should I count food as score or not?]

The final score of each entry is equal to the amount of entries whose evaluation was lower than that of the currently considered entry. This means that the highest score an entry can get is 11.


A tournament is nothing more than a series of individual games. At any point of a tournament the score of each entry is equal to the average of all of its scores.

Official tournaments

Official tournaments will be run by me on the latest version of Chrome on my personal computer, which at the time of writing is an AMD FX-8350, every time a new entry is posted or an existing one receives a meaningful edit. The leaderboard will be updated once the 1st place becomes consistent between 6 subsets of played games (which gives a probability of 96.875% that the first place won't change).

As stated before, there is no permanent winner. This means that no checkmark will be awarded to any answer, ever. I will continue to run new tournaments for as long as is practical.


Each submission must follow this general format:

Entry Title

[Optional text and pictures]

Code block with your JavaScript class

[Optional text, pictures and code blocks]

Not adhering to the above format may result in the submission not being properly picked up by the controller.

Explanations and pictures are highly encouraged, though not necessary. Making your entry pretty and well-documented will entice me (and probably a lot of people) to upvote it.


Your entry will be disqualified if it is found to not adhere to the specification correctly. Most of the time problems will be caught by the controller and reported, but some rules can't be checked programmatically, so they'll be enforced by hand. I reserve the right to disqualify an entry manually if it breaks the rules or if I subjectively believe it has not been made with fair competition in mind. I hope I haven't left any loopholes (and therefore won't have to exercise this power), but if I did then this rule prevents them from potentially ruining the entire challenge.

Disqualification during a game results in all of your ants being immediately and permanently removed from the turn order. Disqualification during a tournament invalidates all games in which your entry has participated and terminates the active game (as it would've been invalid anyway). Disqualification during an official tournament, aside from having the effects of a regular tournament disqualification, prohibits your entry from taking part in any future official tournament until meaningfully edited.

This is not supposed to be an additional challenge - helpful error messages along with your ant function's output and the input that disqualified it will be attached to the disqualification notice. I will also paste these messages into a comment informing you of a disqualification should your entry be disqualified during an official tournament.

Multiple entries and editing

You may provide multiple entries, provided that they do not team up against the others. As long as each entry is working solely towards its own victory, you are permitted to tailor your strategy to take advantage of others' weaknesses. You may also edit your answers whenever you choose. It is up to you whether you post a new entry or edit an existing one; just don't flood the game with nearly identical variations. If you make a variation of another person's entry, remember to give them credit by linking to their entry from your own.

Example entries


This entry demonstrates the minimal amount of code needed for something to be considered valid. It returns the same output regardless of input.

class Randant {
  getAction() {
    return {cell: 0, action: 0};

Because the orientation is random every time, Randant will perform a random walk instead of going straight.

Despite being very simple, this is a perfectly valid submission. It won't ever get disqualified either, because moving is guaranteed to be a valid action.

See Smart Randant on how one could go about improving this entry.

Smart Randant

This entry demonstrates basic mechanics that ought to be commonly used between more advanced entries. It is an improvement of Randant's general design. It depends on input this time around.

class SmartRandant {
  getAction(view) {
    const me = view[6].ant; // Get data about myself

    function wrap(number, cycleLength = 6, negativeSafety = 1) { // Defining functions inside the getAction(view) function is fine
      return (number + cycleLength * negativeSafety) % cycleLength; // Wraps numbers (allows for cyclic array access)

    function stronger(a, b) { // Checks if ant a is stronger than ant b
      return a && (!b || a.tier > b.tier);

    view.forEach((cell, i) => { // Modifying the view is perfectly acceptable (here we do it to store the index alongside each cell)
      cell.index = i;

    const dirs = view.slice(0, 6);
    const safe = dirs.filter((cell, i) => !stronger(dirs[cycle(i - 1)].ant, me) && !stronger(dirs[cycle(i + 1)].ant, me) && stronger(me, cell.ant)); // Create an array of cells that are safe to move to
    // TODO: Also consider attacking other ants that are at the same strength level as us by spawning a stronger ant on their face

    if (safe.length) { // If we've got some safe spaces to move to...
      const victims = safe.filter((cell) => cell.ant && stronger(me, cell.ant)); // Prioritize killing other ants

      if (victims.length) { // If we've got someone to kill...
        const target = victims.reduce((prev, next) => stronger(next.ant, prev.ant) ? next : prev); // Find the strongest victim and target it

        return {cell: target.index, action: 0};

      const food = safe.filter((cell) => cell.food); // Otherwise prioritize grabbing food

      if (food.length) { // If we've got some food to grab...
        return {cell: food[0].index, action: 0} // Just grab any piece
        // TODO: Grab the piece that has the most pieces of food next to it

      return {cell: safe[0].index, action: 0} // Otherwise move to any safe cell

    return {cell: 6, action: 0}; // If we don't have a safe cell to move to, just stay still and hope for the best
    // TODO: Handle this situation better

As you can see, Smart Randant is a lot smarter than his counterpart. Smart Randant dropped his suicidal tendencies by finding safe cells before moving. Note that despite not being suicidal, he may still be killed by particularly cunning entries. He's also more aggressive - he'll gladly attack opponents weaker than him and will grab nearby food. Finally, if he's got anywhere to go, he will go there. Otherwise, he'll just stay still, hoping for the best.

You may have also noticed that Smart Randant still has a lot to learn. You can edit your entries to your heart's content, so W.I.P. submissions are allowed, or even encouraged.


This entry demonstrates smart usage of the environment for the purpose of fighting randomness. It travels in a straight line, leaving behind a path. It also utilizes and expands Smart Randant's basic framework.



The chat room is active already and is a better place for extended discussion than the comment section. I'd also love to dicuss some preliminary ideas for potential strategies to be used in future entries (though let's try to restrict this dicussion to nothing more than interesting isolated systems rather than full submissions - I'm not particularly interested in posting a nearly-solved challenge).

Most links are broken for now. The controller, for example, doesn't exist yet.

I'm aware that I'll have to make (or find) a custom number library that can handle nearly arbitrarily small and large powers of 2 for scoring (I've managed to design a system which spawns progressively less valuable ants every 2 turns at no cost, leading to a score equal to about 1 + 2e-16384).



Hexarun (stylized as Hexarun!) is a simultaneous game with complete information. Hexarun is intended for a minimum of three (3) players.


Up to twelve (12) players start on a regular hexagonal toroidal board with a number placed on each hexagon. The objective of the game is to collect the numbers by navigating the board. Players have complete knowledge of the board and the participating players. The number on a hexagon is reduced by the amount being collected. The game ends when all hexagons become zero or if the game becomes stale. The player whose collection has the highest sum wins the game.

Each game consists of multiple turns. Before the first turn, players choose their own starting location. During each turn, players move within their vicinity at the same time. If a player is alone in a numbered hexagon, this player collects the entire number. If multiple players move into a single hexagon simultaneously, they split the number. Numbers are not exchanged between players during each game.

Game specifications

  1. Regular hexagonal toroidal board: Each edge of the board measures N=2*P hexagons where P is the number of players on the board. The numbers on the board are placed in concentric rings. The numbers on the edge of the board are 1, and each successive inner ring follows off the OEIS sequence A002024 which starts with 1, 2, 2, 3, 3, 3, 4, 4, 4, 4. As a final touch, increase the number in the center by 1 if it is not unique on the board. [Example Board (N=6)]

  2. A game ends when...

    a. Hexagons become zero: Numbers on all hexagons are zero.

    b. Game becomes stale: Scores do not change during 6*P consecutive turns.

  3. Legal moves...

    a. Run!: Moves into one of the six (6) neighboring hexagons.

    b. Nothing: Does literally nothing.

  4. Number collection:

    a. Collect: At the end of a turn, a player alone on a hexagon scores s=h points, where h is the number on the hexagon at the beginning of the turn.

    b. Split: At the end of a turn, n>1 players standing on a hexagon scores s=h/n points, where h is the number on the hexagon at the beginning of the turn, and / is integer division. The number on the hexagon at the end of the turn becomes h-s*n, a.k.a. the remainder.

    Example: At the end of a turn, a total of 3 players are on a hexagon with number 10, then each gets 3 points and the hexagon becomes 1.

How to play


Tournament rules



  • \$\begingroup\$ Note to self: Implement using davidje13/koth-webplayer. \$\endgroup\$
    – Frenzy Li
    Commented May 31, 2018 at 9:37
  • 2
    \$\begingroup\$ 2*P scaling means that if there are more players, there's more proportional space for each player. In other words, there's more and more empty space between players. (As an extreme example, if you have 2 players, each player will have 8 squares each. If you have 100 players, each player will have 1600 squares each) \$\endgroup\$ Commented May 31, 2018 at 12:57
  • 1
    \$\begingroup\$ The center of the board is more valuable, but because you are using that OEIS sequence, with big boards, there are tons of squares in the middle that will have the same number. I think you were aiming to have fights for the middle, but how I see it, there's plenty for everybody. \$\endgroup\$ Commented May 31, 2018 at 13:02
  • \$\begingroup\$ Finally, winning this game is primarily done by predicting where people are going to go. This is problematic, because as it stands, the way to win is to identify bots based on movement, which leads to one-upping. \$\endgroup\$ Commented May 31, 2018 at 13:05
  • \$\begingroup\$ @NathanMerrill I meant to say that P is the number of players on the board. If up to 12 players play at the same time, the edge size is up to 24. I'm still not entirely sure about that sequence, and it'll take some testplay to see. \$\endgroup\$
    – Frenzy Li
    Commented May 31, 2018 at 13:10
  • 2
    \$\begingroup\$ Right. If you have 12 players, then the edge size is 24. 24*24 = 576, which is 48 squares per player. With 100 players, it is 200*200 = 40000, which is 400 squares per player. What you really want is X*sqrt(P), where X is the number of squares per player. \$\endgroup\$ Commented May 31, 2018 at 14:31
  • \$\begingroup\$ @NathanMerrill I'm trying to think in your way. The total number of squares for the hex follows A003215. For edge size 24 (number of hexagons on a side of the hexagonal board), there are 24^3-(23)^3=1657 hexagons, so that's approximately 69 hexagons per player. \$\endgroup\$
    – Frenzy Li
    Commented Jun 1, 2018 at 0:39
  • \$\begingroup\$ 69 is miscalculated, 138 should be the answer. 138 hexagons should be plenty. \$\endgroup\$
    – Frenzy Li
    Commented Jun 1, 2018 at 0:55
  • \$\begingroup\$ Let us continue this discussion in chat. \$\endgroup\$ Commented Jun 1, 2018 at 1:15

Base 18 & Decimal traffic light

Given a number n<180, output the n/10 part and the n%10 part in 7-seg.

7-seg shapes:

 000         222   333         555   666   777   888   999   AAA         CCC         EEE   FFF   GGG
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
0   0     1     2     3 4   4 5     6         7 8   8 9   9 A   A B     C         D E     F     G     H   H
             222   333   444   555   666         888   999   AAA   BBB         DDD   EEE   FFF         HHH
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
0   0     1 2         3     4     5 6   6     7 8   8     9 A   A B   B C     D   D E     F     G   G H   H
 000         222   333         555   666         888   999         BBB   CCC   DDD   EEE         GGG
  • Either led on or (led off&background) should be constant, and the left characters mean the other state, or
  • At least two of your background, led on and led off should be constant, and the left characters mean the left state.

  • \$\begingroup\$ add the tag ascii-art \$\endgroup\$
    – Beefster
    Commented Jun 5, 2018 at 18:46
  • 5
    \$\begingroup\$ 1. Related, related, related, and plenty more. I wouldn't be surprised if this were closed as a dupe. 2. What does this have to do with traffic lights or base 18? 3. I don't understand the last two bullet points. Are they saying that I can choose to use the same character for on and off and essentially just always output 88? 4. Why is the shape for 0 the same as the shape for 8? \$\endgroup\$ Commented Jun 6, 2018 at 8:50
  • \$\begingroup\$ @PeterTaylor 1. There are lots of related, but none of these are 2. video.baomihua.com/v/18443141 , base 18 because the next letter "i" can be mistaken with "1" 3. clarified somehow, though I don't know which choice you use 4. fixed \$\endgroup\$
    – l4m2
    Commented Jun 6, 2018 at 11:01

Convincingly Fake Compression of Random Data

As you may know, it is impossible to write an compression method that takes strings of length \$n\$ and returns strings of length \$n - 1\$. This can be proven by a simple argument: Each compression function must be a bijection, because otherwise the compressed strings can not unambiguously be uncompressed. However, just considering bit strings, there are \$2^n\$ strings of length \$n\$, but only \$2^{n-1}\$ strings of length \$n-1\$, thus no such bijection can exist.

In other words, for each attempt to write such a compression function, there exist strings which cannot be compressed.

The task for the cops in this challenge is to write a function which looks like it can compress arbitrary fixed-length strings, and the task of the robbers is to find a string for which the compression function fails.


I'm not yet convinced if this will actually work as a challenge, mainly if it is feasible for the cops to write a submission which is not easily crackable. It might be easier for large \$n\$ so robbers can not brute force, so I could make the cops winning criterion about getting the safe submission with the lowest \$n\$. Any ideas for a better winning criterion?

Also do you think this will work as a challenge?

  • 2
    \$\begingroup\$ Might be too easy for a challenge. There's a 50% probability that you find a string which fails. \$\endgroup\$ Commented Jun 26, 2018 at 14:17
  • 2
    \$\begingroup\$ Looks feasible to me. It may be good to fix the input into binary string, lower-case alphabet, or just ASCII and require the robbers to find two strings that "compress" to the same object. \$\endgroup\$ Commented Jun 26, 2018 at 14:53
  • \$\begingroup\$ @EriktheOutgolfer yes, but with a well-crafted cop submission, it would be difficult to know that a string wasn't "compressed" unless the robber finds two strings that end up with the same string or writes a "decompression" function. \$\endgroup\$ Commented Jun 26, 2018 at 14:56
  • \$\begingroup\$ @JungHwanMin Just run it and measure its length? \$\endgroup\$
    Commented Jun 26, 2018 at 15:20
  • 1
    \$\begingroup\$ Anyway I think this is only feasible if the cops solution takes a very long time to run even for a single input, for most/all of the counterexamples. \$\endgroup\$
    Commented Jun 26, 2018 at 15:24
  • \$\begingroup\$ @user202729 What I meant to say is that it is possible that there exists a "compressed" string that corresponds to only one "uncompressed" string, so it would be "compressed" when you feed it to the cop program. With a good cop program, it may be hard for robbers to find specific examples of strings that have the same "compressed" variation. \$\endgroup\$ Commented Jun 26, 2018 at 16:15
  • \$\begingroup\$ @JungHw Pick random strings of length n and compress it, the expected number of runs until you crack the solution is 2. \$\endgroup\$
    Commented Jun 26, 2018 at 16:21
  • \$\begingroup\$ @user202729 That doesn't make sense. Assuming that we use binary strings and exactly two strings compress to one string, the probability of getting no collision after picking 3 strings is 1 * (2^n - 2)/(2^n - 1) * (2^n - 4)/(2^n - 2), which should be close to 1 with large enough n. \$\endgroup\$ Commented Jun 26, 2018 at 16:31
  • 1
    \$\begingroup\$ Perhaps the word "fail" has to be clearer. The challenge sounds possible if "failing" means "producing colliding outputs" instead of something on the lines of "crashing." With binary strings, Mathematica tells me that the expected value of trials needed to find colliding strings is ~946 with length 10, and ~1.05e+6 with length 20. \$\endgroup\$ Commented Jun 26, 2018 at 16:46
  • \$\begingroup\$ @JungHwanMin Shouldn't generating a random string, compressing it, decompressing the result and checking whether this equals the original string yield a collision with probability 0.5? \$\endgroup\$
    – Laikoni
    Commented Jun 26, 2018 at 21:14
  • \$\begingroup\$ @Laikoni then the robber would need to create a decompression function. Maybe I misunderstood the challenge, but I thought the only requirement for the cop was to include a compression algorithm. Having some obscure compression function that make "decompression" very challenging would make this challenge feasible. \$\endgroup\$ Commented Jun 26, 2018 at 21:28
  • \$\begingroup\$ I suggest changing the challenge specification to my misinterpretation of the challenge specs. ;-) The robber would need to come up with either a decompression function or a counterexample to the compression algorithm (i.e. prove that the compression is not bijective). \$\endgroup\$ Commented Jun 26, 2018 at 21:40
  • 1
    \$\begingroup\$ @JungHwanMin Thanks for the suggestions! The problem with the cop providing only a compression function is that they could submit any hash function, because that's what those fake compression functions actually are, and trying to prevent cops from submitting known-to-be-collision-resistant hash functions probably brings us into dupe-distance to this cnr challenge. \$\endgroup\$
    – Laikoni
    Commented Jun 26, 2018 at 22:10
  • \$\begingroup\$ So the cops must write a decompression function too? \$\endgroup\$
    Commented Jun 27, 2018 at 1:57
  • \$\begingroup\$ @user202729 That's what I originally envisioned, but at the moment that's up for debate in order to make the challenge feasible for the cops. \$\endgroup\$
    – Laikoni
    Commented Jun 27, 2018 at 8:08

Progrqmming Puzzle andf Co9de Golf |


We all make mistakes. You, me, everyone. But not computers. They aren't making any mistake. Not even a single typo.
Time to change this injustice.


Your task will be to take a string as input, and display the string character by character, and with a cursor, as if someone was typing it. But there is a twist : sometimes, the "entered" character will be wrong. In that case there is a little pause, then the last entered character (which is supposed to be wrong) is deleted.


  • Input and output will contain only printable ASCII characters.
  • The cursor should be displayed as |, preceded by a space. This will always be displayed, from the empty string to the exact input displayed.
  • Each "iteration" (new character) is separated by a 0.25s pause (It takes time to write right). You can have a marge error of 0.05s, meaning the pause have to be lower than 0.2s, and lower than 0.3
  • Each character has exactly 1/10 chance to be wrong (that means it will be anything but the right character). In that case you should add a 1s pause ("Wait, did l really made a mistake?"), then delete this character, add a 0.25s pause (with a marge error of 0.05s), then continue.




Possible output

Note : I am planning to add a gif to show what the code should do. For now, consider every line as a gif frame

H |          // 0.25s pause
He |         // 0.25s   "
Hel |        // 0.25s   "
HelG |       // 1s      "
Hel |        // 0.25s   "
Hell |       // 0.25s   "
Hello |      // 0.25s   "
Hello! |     // done

Note for sandbox

  • Is this challenge good enough ?
  • Is this challenge already exist ?
  • Is this challenge clear enough ?
  • \$\begingroup\$ Are those typos in the body also intentional? e.g. whitch \$\endgroup\$
    – wastl
    Commented Jun 22, 2018 at 12:48
  • \$\begingroup\$ @wastl Except for the title, this is just me being bad at writing english \$\endgroup\$ Commented Jun 22, 2018 at 12:52
  • \$\begingroup\$ @AdmBorkBork the wrong character can be anything, except for the character it should have be. In my example the wrong character is a G, it could have been a a, a 7, a #, but not a l since it is the correct character. \$\endgroup\$ Commented Jun 22, 2018 at 14:28
  • \$\begingroup\$ Is it acceptable if the "wrong" character is not random? For example, if a typo on a always becomes b. It might also be a good idea to restrict what characters need to be handled, e.g. "Input will, and output must, consist of only printable ASCII characters" \$\endgroup\$ Commented Jun 22, 2018 at 15:53
  • \$\begingroup\$ @KamilDrakari as long as the "wrong" character is actually wrong, it's ok. And good idea for the input/output restrictions. \$\endgroup\$ Commented Jun 22, 2018 at 20:04
  • \$\begingroup\$ Can we use \b to remove the previous character? How accurate does the delay have to be (0.24 seconds instead of 0.25?). Same question with randomness. Can we have an initial delay before output? Enough is spelt with a g. \$\endgroup\$
    – Jo King Mod
    Commented Jun 27, 2018 at 2:35
  • \$\begingroup\$ @JoKing as long as the output shows that the character is removed, you can use \b. i'd say delay will have an error margin of 0.05s (basically 0.2s<delay<0.3s). However the randomness has to be exactly 1/10. I'll edit the question to add those criterias later. \$\endgroup\$ Commented Jun 27, 2018 at 10:42
  • \$\begingroup\$ You say each character has a 1/10 chance of being wrong? Does this mean answers have to behave non-deterministically, or could a deterministic method be used as long as 1 out of every 10 characters is wrong. \$\endgroup\$
    – Wheat Wizard Mod
    Commented Jun 28, 2018 at 13:27
  • \$\begingroup\$ @CatWizard Answer have to behave non deterministically : the total number of wrong characters will only rely to randomness. \$\endgroup\$ Commented Jun 29, 2018 at 16:34
  • \$\begingroup\$ how are you going to measure exact timing on people's solutions? \$\endgroup\$
    – don bright
    Commented Jul 7, 2018 at 2:16
  • \$\begingroup\$ @donbright with a chronometer ? More seriously, the point here is to get aproximately 4 characters in a second (unless there is a wrong one) \$\endgroup\$ Commented Jul 9, 2018 at 9:30
  • \$\begingroup\$ i dont know how you can measure it, since computers run at different speeds, and OSes are not realtime OSes. but i like it enough anyways. \$\endgroup\$
    – don bright
    Commented Jul 11, 2018 at 1:02

Role reversal

This is related to an old question, but is different enough that answers should be quite different to the older one.

You are given a sentence referring to two different people. Return the sentence with the roles reversed.

For example, for the input I will give you a kiss., you should return You will give me a kiss.

There will always be exactly two people referred to in the sentence, and they will be referred to with different pronouns. Here's a table of the pronouns that might be used (pronouns in a row refer to the same person. Pronouns in a column can be switched with one another to reverse a role).

 I         me       my           mine         myself
 you       you      your         yours        yourself     
 she       her      her          hers         herself
 he        him      his          his          himself      
 they      them     their        theirs       themselves 

Capitalisation matters (the first letter of the sentence should be capitalised, the pronoun "I" should always be capitalised, and no other pronoun is capitalised when not starting a sentence).

Words/punctuation not appearing in the pronoun table above shouldn't be changed. A pronoun word shouldn't be replaced if it appears as a substring of another word (e.g. 'history' shouldn't he changed). None of the inputs will be contractions using pronouns (so there won't be any inputs with "I'm" or "you're" etc).

Input/output examples:

in: She gave them hers!
out: They gave her theirs!

in: He will eat me if I don't eat him.
out: I will eat him if he don't eat me.

in: Get it for them yourself!
out: Get it for you themselves!

in: I think I am going to see him tomorrow.
out: He think he am going to see me tomorrow.

in: I am not interested in history, is he?
out: He am not interested in history, is I?


  • This is code golf so the shortest answer wins.
  • Standard loopholes are banned.
  • \$\begingroup\$ Any last thoughts before I post this? \$\endgroup\$
    – LangeHaare
    Commented Jul 19, 2018 at 14:21

Use Japt Shortcuts

Japt is the PPCG Language of the Month for July, and I'm excited to try it out! In accordance with the Tips post I should use the Unicode Shortcuts. However, my keyboard seems to be lacking those important characters like "upside-down exclamation point" needed for optimum golfiness. Please write me a program to change horrible, verbose monstrosities like â m@VgUb==X into pristine, optimal code like â £VgUb¥X!


Given Japt code as input, output the same code making maximal use of the Unicode Shortcuts Japt supports.


  • Answers must support inputs containing any combination of valid Japt characters [Sandbox: is there a list of these? In particular, many languages need to use the NULL byte to indicate end of input, does Japt support NULL bytes in the middle of code?].
  • Input may be in any reasonable format (string, list of chars, etc.)
  • Output may be in any reasonable format, and does not need to be the same as the one used as input (e.g. "input as string => output as list of chars" is fine)
  • If multiple shortcuts are possible, use the one that replaces the most characters. For example, === should be replaced by not ¥=.
  • Your code does not need to handle ambiguous situations. For example, ==== could be shortened to ¶= or , so behavior is undefined if such a string shows up in the input.
  • Only shortcuts available in Japt 1.4.5 (most recent version at time of posting) need to be handled
  • Non-unicode shortcuts like _ and @ don't need to be handled
  • I've replaced easy-to-miss trailing spaces with where I found them. Those should be the literal space character ' ' when running tests or replacements. [Sandbox: Seriously, is there some better way to do this?]

Test Cases

?OvUf\l m_c %H} qV):0 => "?OvUf\l ®c %HÃqV):0"
Ov"y m_î íZ c p0} "p2␠ => Ov"y ®î íZ c p0Ã"²
=== => ¶
ñgJ òXYZ{XgJ <YgJ } mg mg␠ => ñÌòÈÌ<YÌÃmÎmÎ
w å+ m@Vå+ m+S+Xw} c => w å+ £Vå+ m+S+XwÃc

[Sandbox: The first two test cases are grabbed from some real Code Golf answers here and here. Should I replace them with something else?]

For reference, here is the full list of Unicode Shortcuts to be supported. It can also be found on the Japt Interpreter. Note that some shortcuts end in a space. [Sandbox: should I format this differently?]

¡   Um@
¢   Us2␠
£   m@
¤   s2␠
¥   ==
¦   !=
§   <=
¨   >=
©   &&
ª   ||
«   &&!
¬   q␠
®   m_
¯   s0,
°   ++
±   +=
²   p2␠
³   p3␠
´   --
µ   -=
¶   ===
·   qR␠
¸   qS␠
¹   )␠
º   ((
»   (((
¼   .25
½   .5
¾   .75
À   !==
Á   >>>
à   }␠
Ä   +1
Å   s1␠
Æ   o@
Ç   o_
É   -1
Ê   l␠
Ë   mDEF{D
Ì   gJ␠
Í   n2␠
Î   g␠
Ð   $new Date($
Ñ   *2
×   r*1␠
  • \$\begingroup\$ Nice idea! You can include trailing spaces by using <pre><code> ... </code></pre> instead of indenting, though they'll only be visible if the text is selected if you do it that way. (Also, Ê, Ì, and Í want their s back ;-) ) \$\endgroup\$ Commented Jul 7, 2018 at 4:49

A note about this meta post:

I just have one example right now, but I will have three in the final.

I thought it would be interesting to have a problem about something I know a bit about. Right now it seems a bit mathy, but I wanted to ground the problem on something real. It feels more 'real-life' if you need to understand the spec in addition to golfing. The problem is I don't want it to seem like homework. Another problem is the actual computation that needs to take place isn't actually that hard once you understand the simplifications of the problem.

Let me know what you think.



Calculate the strain tensor and volume percent change of a cube given its material properties and stress tensor.


Common Terms

Stress Strain

  • Strain: ε, The amount of elongation per unit length, Units: \$\frac{in}{in}\$

  • Normal Stress: σ, The amount of force per unit area perpendicular to the cross section, Units: \$\frac{lbs}{in^2} = psi\$

  • Shear Stress: τ, The amount of force per unit area parallel to the cross section, Units: \$\frac{lbs}{in^2} = psi\$

  • Young's Modulus: E, The relationship between stress and strain: \$σ = Eε\$, Units: psi


  • Poisson's Ratio: ν, The relationship between strain in different directions. For a uniaxial bar: \$ε_{22} = -ν ε_{11}\$, Units: unitless

  • Index Notation: A short form for tensors written with subscripts \$i,j,k,l\$ to denote which element within the tensor. The number of subscripts the tensor has indicates what order it is. \$σ_{ij} \equiv \tensor{σ}\$ (Second Order)

  • Kroniker Delta: \$δ_{ij}\$, has the value of 1 if i=j, otherwise its value is 0. Index Notation for the Identity Tensor.

$$ δ_{ij} = \left[\begin{array}{ccc} δ_{11} & δ_{12} & δ_{13}\\ δ_{21} & δ_{22} & δ_{23}\\ δ_{31} & δ_{32} & δ_{33}\\ \end{array}\right] = \left[\begin{array}{ccc} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right] = I $$


A tensor in this context can be thought of as three directional components for each of the three positive faces of the cube.

Tensor on Cube

Although a Stress Tensor is not a matrix, it can be represented in matrix form by a 3x3 or other matrices:

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_{xx} & σ_{xy} & σ_{xz}\\ σ_{yx} & σ_{yy} & σ_{yz}\\ σ_{zx} & σ_{zy} & σ_{zz}\\ \end{array}\right] = \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{21} & σ_{22} & σ_{23}\\ σ_{31} & σ_{32} & σ_{33}\\ \end{array}\right] = \left[\begin{array}{c} σ_{11}\\ σ_{12}\\ \vdots \\ σ_{33}\\ \end{array}\right] = \left[\begin{array}{cccc} σ_{11} & σ_{12} & \dots & σ_{33}\\ \end{array}\right] $$

If a Tensor and a Kroniker Delta share the same indices, they are combined.

$$ σ_{ij} δ_{kj} = σ_{ik} $$

If a Tensor has repeating indices, then it is taken as a zero order tensor and the indices are summed.

$$ σ_{ij} δ_{ij} = σ_{ii} = \sum_{i=1}^{3} σ_{ii} \equiv tr(\tensor{σ}) = σ_{11} + σ_{22} + σ_{33} $$

Stress Strain Relationship

The relationship in one dimension is \$σ=Eε\$. For three dimensions we can use Hook's law to find the relationship between the strain tensor and the stress tensor as follows:

$$ σ_{ij} = C_{ijkl} ε_{kl} $$

This general case would need \$3^4 = 81\$ independent material properties to calculate the strain tensor. If we assume the cube has a symetric \$\tensor{σ}\$, symetric \$\tensor{ε}\$, is Elastic, Isotropic, Linear, and Homogeneous, then we only need two independent material properties: (Young's modulus: E, Poisson's Ratio: ν) or (Lamé modulus: λ, Shear modulus: μ). We can use either pair of values, but for this example it is much easier to calculate the strain tensor from the stress tensor using Young's Modulus and Poisson's Ratio.

And so we can simplify the stress tensor by what we know.

$${\tensor{σ}} = \left[\begin{array}{ccc} σ_x & σ_{xy} & σ_{xz}\\ & σ_y & σ_{yz}\\ Sym & & σ_z\\ \end{array}\right] $$

And our new relationship is:

$$ ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij} $$

Calculating the Dilation

Volumetric Change

The Volumetric Strain can be found by calculating the trace of the strain tensor for very small values of strain. This is because for small values \$ε^3 \ll ε^2 \ll ε\$.

$$ {\frac {ΔV}{V_0}} \approx tr(\tensor{ε}) $$

Putting it all together

Therefore, in summary we can calculate the strain tensor with the following:

Using Index Notation:

$$ ε_{ij} = \frac{1+ν}{E} σ_{ij} - \frac{ν}{E} σ_{kk} δ_{ij} $$

Using Matrix Notation:

$$ ε_{ij} = \frac{1+ν}{E} \left[\begin{array}{ccc} σ_{11} & σ_{12} & σ_{13}\\ σ_{12} & σ_{22} & σ_{23}\\ σ_{13} & σ_{23} & σ_{33}\\ \end{array}\right] - \frac{ν}{E} tr(\tensor{σ}) \left[\begin{array}{c} 1 & 0 & 0\\ 0 & 1 & 0\\ 0 & 0 & 1\\ \end{array}\right] $$

Then calculate the volumetric change:

Index Notation

$$ {\frac {ΔV}{V_0}} = ε_{ij} δ_{ij} = ε_{ii} $$

Matrix Notation

$$ {\frac {ΔV}{V_0}} = tr(\tensor{ε}) $$


One positive long: Young's Modulus (Usually in the range 100 psi - 100,000,000 psi)

One positive decimal: Poissons's Ratio (Usually in the range 0.01 - 0.5)

Array of signed decimals for Stress Tensor (9 values)


Array of Strain Tensor, to at least five significant figures (same format as input)

Percent volume change of cube, to at least five significant figures


(simple example for now)

Young's Modulus: 29,000,000 psi
Poisson's Ratio: 0.30
Stress Tensor: [[50000,      0,     0]
                [    0, -10000,     0]
                [    0,      0, 25000]] psi
Strain Tensor: [[0.00157,        0,       0]
                [      0, -0.00112,       0]
                [      0,        0, 0.00045]] in/in
Dilation: 0.08966%


IO is flexible

  • Stress Tensor input can be any size array, or string

    • Input type and size must be the same as output
  • No formatting or units required

This is , least number of bytes for each language wins

  • \$\begingroup\$ Looks interesting. However, because all answers are publicly viewable, challenges where the main difficulty is the implementation (instead of understanding the challenge) is preferred. Looking at the input/output it appears that the implementation itself is probably complex enough to be interesting. \$\endgroup\$
    Commented Jul 8, 2018 at 10:58
  • \$\begingroup\$ this is very fascinating. IMHO the writing could be adjusted for the audience. if they are like me, i dont really understand stress and strain, and what they mean in laymans terms. also i think it could be simplified a lot. take for example the first graph. what are the dashed lines? why are they numbered 1 and 2? what is 0.2%? why is there a cylinder there, and what does it mean? is any of that graph required to solve the puzzle? \$\endgroup\$
    – don bright
    Commented Jul 11, 2018 at 1:42
  • \$\begingroup\$ @donbright Thank you, this is helpful. I will explain the fundamentals of stress and strain more, and annotate the pictures (which are directly from wikipedia). The graphs are not required to solve the puzzle, but they may be useful to understand the concepts. I have them to explain, but they are probably not as helpful to a layman. I will fix it up in the next few days. Btw, what do you you think of the explanations from the tensors section onwards? \$\endgroup\$ Commented Jul 12, 2018 at 5:13
  • \$\begingroup\$ I think it's "Kronecker delta" not "Kroniker delta". Also what is \$\varepsilon_{11}\$ and \$\varepsilon_{22}\$? \$\endgroup\$
    Commented Jul 13, 2018 at 2:54
  • \$\begingroup\$ You should probably describe what is a tensor too. (yes I can read Wikipedia and it's unambiguous but it would be more useful if a post contains all information) \$\endgroup\$
    Commented Jul 13, 2018 at 2:57
  • \$\begingroup\$ still hoping for this one to become a challenge!!!! \$\endgroup\$
    – don bright
    Commented May 27, 2019 at 23:46

Haferman Carpet

Given nonnegative integer input \$n\$ output the \$n\$th iteration of the Haferman carpet.

Constructing the carpet

  • The zeroth iteration is 1.
  • When going from the \$n\$th to the \$(n+1)\$th iteration, replace each \$1\$ with the pattern [[0,1,0],[1,0,1],[0,1,0]] and each \$0\$ with the pattern [[1,1,1],[1,1,1],[1,1,1]].

Test cases

0 [[1]]

1 [[0,1,0],[1,0,1],[0,1,0]]

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

Standard I/O stuff


Is this a duplicate? I will make the rules more explicit later.

  • 2
    \$\begingroup\$ Talking about replacing a scalar with a 2D array confused me for quite a while. Having the test cases laid out in a way which obscures the 2D pattern of the carpet also doesn't help. \$\endgroup\$ Commented Jul 13, 2018 at 8:43
  • \$\begingroup\$ As for dupes: these are probably the most closely related questions: two about the Sierpinski carpet and one which is general enough to draw that one and this one. I think it's borderline whether or not this adds something new to the site. \$\endgroup\$ Commented Jul 13, 2018 at 8:47

Syllabification and classification (Venpa)


Venpa is a form of classical Tamil poetry, based upon certain rules of metric prosody. The complete rules form a context-free grammar, the task here is to test for a tiny subset of those rules.


  • Vowels: a, A, i, I, u, U, e, E, y, Y, o, O, W
    • small case represents "short" vowels, CAPS represent "long" vowels
    • y represents the y sound in "my".
    • W represents the "ou" sound in "mouse", and always comes in capital (long) form.
  • Consonant: everything else
    • the consonants can be in small case or capitals, whichever is convenient.

Word Segmenting

Words in the input are seen as composed of segments (which roughly correspond to the usual notion of a syllable). A segment divide occurs where:

  • two or more consonants occur together, tr, rpp, etc.
  • a long (capital) vowel occurs in the word, pO, W, mY etc.
  • two vowels have occurred since the last segment's end (or the word's beginning).

sanjIvi has segments san, jI, vi.
Yvar has Y,var.
vigadakavi has viga,daka,vi.
vAnily has vA,nily.
padAgytAngiha has padA, gytAn, giha
radagajaturagapadAdi has rada, gaja, tura, gapa, dA, di

(Consonants at the end of segments make no difference after segmentation and can be ignored - gytAn=gytA, var=va.)

As you can see, the segments are of two types:

  1. those with a single vowel, san, Y, vA, called a straight (S) segment
  2. those with two vowels, viga, nily, padA called a sequence (Q) segment

So the segment patterns of the above words are:

  sanjIvi              =              san + jI + vi          = SSS
  Yvar                 =                 Y + var             = SS
  vigadakavi           =            viga + daka + vi         = QQS
  vAnily               =                vA + nily            = SQ
  padAgytAngiha        =           padA + gytAn + giha       = QQQ
  radagajaturagapadAdi = rada + gaja + tura + gapa + dA + di = QQQQSS

Permitted patterns

The rules for words allowed in a Venpa are:

  1. a word should have one to three segments
  2. a one or two segment word can have any pattern (S, Q, SQ, SS, QS, QQ)
  3. a three segment word must end in a straight (S) segment

So out of the above, SSS, SS, QQS, and SQ are allowed, QQQ and QQQQSS are not.


Given an input word in the above letters, output its segment pattern if it's an allowed word, or a false-y value if it's not an allowed word.


  • Will be a single word composed of the characters mentioned under the Letters heading above
    • (Small case w will not be present anywhere in the text (neither as a vowel nor as a consonant))


  • The segment pattern of the input word, if it's an allowed word
    • can use any two distinct unambiguous characters to represent S segments and Q segments
  • A false-y value in your language if it's not an allowed word
  • Output is undefined for invalid input (i.e. has characters other than those specified)

Test cases

=> QQS
=> SS
=> falsey (QQQ not allowed)
=> SQ
=> SQS
=> falsey (more than 3 segments)
=> SSS
=> Q
  • 1
    \$\begingroup\$ fascinating. im probably very unusual, but i would like it even better if it was actual poetry instead of 'p' everywhere, maybe even in tamil script (although that would probably disqualify some languages) \$\endgroup\$
    – don bright
    Commented Jul 7, 2018 at 2:37
  • 1
    \$\begingroup\$ Yeah, I intended to just remove some extraneous complexity, but somehow having input in this form makes it slightly less interesting even to me (and I'm not sure it removes a meaningful level of complexity anyway, relative to the rest of the task). I'll change it to use the actual consonants if anyone else here also feels this way. (The last two test case inputs are from actual poetry by the way, just with the consonants replaced.) \$\endgroup\$
    – Sundar R
    Commented Jul 7, 2018 at 18:54
  • 1
    \$\begingroup\$ Using Tamil script would also be great, but my concern with that is mainly that it might make testing and debugging much harder for people who can't read the script. I can mitigate some of that by providing exhaustive test cases, but I'm not sure it's worth it. \$\endgroup\$
    – Sundar R
    Commented Jul 7, 2018 at 18:58
  • \$\begingroup\$ yeah i think i might be a little unusual in my tastes, i still like the puzzle... \$\endgroup\$
    – don bright
    Commented Jul 7, 2018 at 20:08
  • 1
    \$\begingroup\$ @donbright I've updated the post to use different consonants (corresponding to actual words). I like this version a lot better, but let's see how it's received. \$\endgroup\$
    – Sundar R
    Commented Jul 20, 2018 at 14:18
  • \$\begingroup\$ I wrote a program that solves the examples you gave. my first pass was 60 lines of Rust code. i think it is a really good puzzle, great balance between an interesting puzzle and many ways to possibly reduce code size. very interesting. \$\endgroup\$
    – don bright
    Commented Dec 29, 2018 at 14:10
  • \$\begingroup\$ i would like some more examples though. feel like my program might be wrong on some inputs. \$\endgroup\$
    – don bright
    Commented Dec 29, 2018 at 14:11

DRAW me a picture: A QBasic metagolf challenge

The DRAW command in QBasic takes a string argument, consisting of instructions for moving the cursor and drawing line segments, and produces the appropriate line segments on the screen. The syntax of the instructions is very terse--perfect for a challenge!

The challenge

Write a program or function which:

  • Given a 2-D array of on and off pixels, representing a black-and-white image,
  • Generates a string that, when passed to QBasic's DRAW command, will draw that image on the screen,
  • While keeping the generated string as short as possible.

More about DRAW

Your program may use the following DRAW instructions:

(more details pending)

  • U - draw line upwards
  • D - draw line downwards
  • L - draw line to the left
  • R - draw line to the right
  • E - draw line diagonally up and to the right
  • F - draw line diagonally down and to the right
  • G - draw line diagonally down and to the left
  • H - draw line diagonally up and to the left
  • B - meta-instruction: prepend to any instruction to move the cursor accordingly but not draw the line
  • N - meta-instruction: prepend to any instruction to draw the line but not move the cursor

(examples + pictures pending)

The following instructions are outside the scope of this challenge and may not be used (even if they would improve your score): C, P, S, M, X, A, and TA.

Output requirements

Conceptually, your program's output will be substituted for the ... in the following QBasic program:

SCREEN 9        ' Graphics mode, 640 x 350 pixels
DRAW "B M 0,0"  ' Set drawing cursor to top left corner
DRAW "..."

(If the length of your output exceeds any limits on line or string literal length, it may be split across multiple DRAW commands in such a way that the instructions are preserved.)

The program will then be run, and the output image compared to your program's input. Where the input array has a 1, the output image must have a white pixel; where the input array has a 0, the output image must have a black pixel. The portion of the screen outside the input array's dimensions must be entirely black pixels.

Practically speaking, I will probably write a verification script in some other language, just to make testing easier.


Standard I/O methods apply. Output is case-insensitive. Input array dimensions will not exceed 640 x 350. (more rules pending)

Test cases

(test cases pending)


Your submission's score is the sum of the lengths of its outputs on these test cases. In the case of a tie, the earlier submission wins.

Note: this challenge is probably a variation on the Traveling Salesman Problem, meaning that an optimal solution will take exponential time. In order to receive a score, your submission must complete all test cases, which means that you'll need to take a sub-optimal approach.

Sandbox questions:

  • What's a good number of test cases?
  • Should I instead score submissions on a second, hidden set of test cases to prevent overfitting? Or should the hidden test cases be the (first) tiebreaker?
  • Is the implicit requirement "must complete all test cases before you can post it" enough of a bound on long execution times, or should I add a specific execution-time limit?
  • \$\begingroup\$ I would suggest explaining in what way the draw command is given its path length. \$\endgroup\$ Commented Aug 3, 2018 at 22:25

Note: this is my first time posting, so I need help fleshing out the details. I'm aware there are plenty of Roman Numeral problems, but this is somewhat different.

When in Rome, count as Romans do!

This problem is inspired by this website, which published the following diagram:

enter image description here

This diagram shows us that the longest Roman Numeral expression under 250 is that of 188, which requires 9 numerals to express.

The standard symbols used to express most Roman Numerals are the following: {I, V, X, L, C, D, M}. In this challenge, your goal is to, given an positive integer n, compute the number of valid Roman Numeral representations that can be composed through concatenating n of the standard symbols.

Then, your program must output the result of this computation modulo 3997 (to prevent answers from getting too long) in Roman Numerals!

Rules for Roman Numeral Expressions

Roman Numerals originally only had "additive" pairing, meaning that numerals were always written in descending order, and the sum of the values of all the numerals was the value of the number.

Later on, subtractive pairing, the use of placing a smaller numeral in front of a larger in order to subtract the smaller from the larger, became commonplace to shorten Roman Numeral expressions. Subtractive pairs cannot be chained, like the following: IXL. This is considered invalid.

The following are the modern day rules for additive and subtractive pairing.

  1. Only one I, X, and C can be used as the leading numeral in part of a subtractive pair.
  2. I can only be placed before V and X in a subtractive pair.
  3. X can only be placed before L and C in a subtractive pair.
  4. C can only be placed before D and M in a subtractive pair.
  5. Other than subtractive pairs, numerals must be in descending order
  6. M, C, and X cannot be equalled or exceeded by smaller denominations.
  7. D, L, and V can each only appear once.
  8. Only M can be repeated 4 or more times.

Test Cases

Input: 1
Output: VII

More to be added.

Sandbox Users

Thoughts on this problem? I know it is really badly formatted but I thought the concept was cool. Thanks for the help!

  • 1
    \$\begingroup\$ So basically, find how many Roman numbers there are with n numerals? The modulo 3997 is probably not necessary, since the maximum for each n is only 8**n (and valid roman numerals are going to consist of a small fraction of that) \$\endgroup\$
    – Jo King Mod
    Commented Aug 8, 2018 at 5:54
  • \$\begingroup\$ Alright, I'll remove the modulo part. Does the rest seem plausible as a concept? \$\endgroup\$ Commented Aug 8, 2018 at 12:36
  • \$\begingroup\$ The reason for my inclusion of the modulus is because I want to ensure the answer can be outputted without using any numerals beyond those I've provided in the Standard Set \$\endgroup\$ Commented Aug 8, 2018 at 15:12
  • \$\begingroup\$ This needs clearer specification on what counts as a valid Roman numeral. E.g. are IC and XCIX both valid expressions for 99? Is MMMMMMMM a valid 8-letter numeral? \$\endgroup\$ Commented Aug 8, 2018 at 16:38
  • \$\begingroup\$ I added more details to the text. \$\endgroup\$ Commented Aug 8, 2018 at 17:10
  • 2
    \$\begingroup\$ Now that you've posted this to the main site, please add a link to the challenge, edit out the body and delete the post. Thank you! \$\endgroup\$
    – Mr. Xcoder
    Commented Aug 12, 2018 at 11:19
33 34
36 37

You must log in to answer this question.

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