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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

Get the Sandbox Viewer to view the sandbox more easily!


3478 Answers 3478

24 25
27 28

(No title yet)

I'm traveling away from home, and while visiting a fair a dart-throwing game catches my eye.

To play, I can buy \$d\$ darts at a time. There are no other options for purchase.

There are \$t\$ identical targets, but since I'm not a great shot, I can't consistently aim at just one. Instead, I can hit one (at random) with nonzero probability \$p\$.

Of course, just to make it harder for me management also decided it would be too easy if players won a prize immediately upon hitting a target. Rather, I need to hit the same target \$n\$ times in order to get the prize. As long as I keep playing, darts that have already landed on targets will remain there, but if I leave, they will be reset.

I'd rather not be scammed though, so I would like to know how many times I should expect to purchase darts in order to win at least one prize.


Given \$d\$, \$t\$, \$p\$, and \$n\$, find the expected cost for me to get at least one prize.

Test cases

(just some basic ones, for now)

  d,  t,  p,  n  -> E

 __, __, __,  1  -> 1/(1-(1-p)^d)
 __, __,  1, __  -> t*n


Any suggestions to improve wording or formatting? Is anything unclear or confusing?

Would it be more interesting to ask for the expected cost to get at least \$x\$ prizes, instead? In that case, a target would award a prize for every \$n\$ darts landed, i.e. at \$n,2n,3n,\ldots\$ darts.

What level of accuracy should be required?

Ideas for test cases?

Not entirely sure what other tag(s) I'd like to work with here. Golf should be interesting... I'd also like to see faster solutions though, and I would expect golfy solutions to be very inefficient.


Finding Points in Convex Hulls

Convex hulls are notoriously hard to deal with, so today's challenge will deal with a relatively simple premise: given a convex hull defined by a set of points, and an additional point, find whether the additional point lies in the hull.

Now, for some definitions

  1. The convex hull of a finite set X, a subset of R^n, is the set of convex combinations of points of $X$.
  2. A convex combination of points x1,x2,...,xn is a point of the form a1x1+a2x2+...+anxn such that all ai>=0 and the sum of all of the ai is 1.


The input is rather flexible, as long as it contains the appropriate information to express the convex hull and additional point.

An example of a valid input format to express the convex hull represented by (0,1,2),(4,3,2),(8,8,8) and the point (5,5,5) is


The output is a truthy/falsy value, depending on whether the point is contained in the hull.


There are a lot of packages and libraries that deal with convex hulls, such as scipy.spatial. Such libraries/packages are explicitly banned. Libraries that facilitate matrix computations, such as numpy, are permitted.

The winning criterion is .

There is no limit on the number of dimensions the points can lie in, as long as they all lie in the same number of dimensions.

Test Cases

I will be using the following tio link for testing the validity of solutions.

Some smaller test cases:

([(1,1)],(1,1)) - True
([(1,1)],(1,2)) - False
([(1,1,1),(3,3,1)],(2,3,1)) - False
([(1,1,1),(3,3,1)],(2,2,1)) - True
([(0,0),(3,3),(0,6)],(2,4)) - True
([(0,0),(3,3),(0,6)],(1,1)) - True
([(0,0),(3,3),(0,5)],(2,4)) - False

Questions for Sandbox

Is code golf the best criteria for this? That might encourage brute force searches on every combination of points... any suggestions?

  • \$\begingroup\$ You mention R^n but all the examples use Z^n (which is much easier to work with computationally). Please clarify the expected input. Also, what about libraries for linear programming? \$\endgroup\$ Apr 1 '19 at 10:03
  • \$\begingroup\$ @PeterTaylor I was thinking of making it R^n only, since one can bash out the answer if it is in Z^n. And, linear programming libraries probably also should be banned. \$\endgroup\$ Apr 1 '19 at 13:08
  • \$\begingroup\$ I'm not sure how easy it is to bash out the answer. The weights could be rational, and it's not obvious to me that the denominators can be bounded because the entire system can be translated. \$\endgroup\$ Apr 1 '19 at 20:35
  • \$\begingroup\$ @PeterTaylor Hmm, I'll think about how to revise this. \$\endgroup\$ Apr 1 '19 at 22:05

This is a post to pre-test for a duplicate question before I spend the time to finish the full post and add test cases.

So, have we ever had a question for a "snake rotation" of a matrix:

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

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

The ascii walls are there only for clarity. Actual input/output would be normal matrices


WordArt reader

I've decided to leave this very open ended, so that I can write it based on community input. There are a lot of questions in the bottom. All feedback is appreciated, even minor suggestions/comments. :)


Did you know WordArt is still a thing in MS Word? Let's parse it!


(I'll remove the Swag format)

The challenge will contain a test battery with X jpg.files each with a word or sentence shown in WordArt. Your task is to parse as many as you can. The winner will be the submission that correctly parses the most images, with date stamp being the tie breaker.


  • Good idea or not?
  • Should there be many different styles, or should I stick to one? Colors? Shade/mirroring?
  • How many test cases?
  • Is jpg the best format (it was used in the Upgoat/Downgoat challenge)
  • Should I have a more refined scoring mechanism? It's hard to mix two quantities into one score.
  • Should I stick to just letters / alphanumeric / all printable ASCII / multiple lines? Long sentences or single words?
  • Orientation? Waves? Circular?
  • Resolution?
  • Builtin functions?
  • Should I require a complete match of images, or character by character?
  • \$\begingroup\$ Nice challenge! 1 WordArt is a completely objective (good) definition. 2 Some of the questions was mainly for the problem of the challenge being "too hard", so if you want any answer at all you should simplify those. (somehow most PPCG users are lazy). 3 Format is not a very important problem (conversion is easy), but just to be sure, use a lossless format. \$\endgroup\$
    Nov 7 '17 at 16:48
  • \$\begingroup\$ There is another problem of the font used. \$\endgroup\$
    Nov 7 '17 at 16:49
  • \$\begingroup\$ The challenge is supposed to be hard. Scoring based on the success rate would be useless if not. But it's of course possible to change the scoring, and make the test cases easier. \$\endgroup\$ Nov 7 '17 at 17:00
  • 4
    \$\begingroup\$ 1. optical-char-recognition. 2. Upgoat/Downgoat used JPG because it used photos. IMO it's preferable in general to allow any raster image format, because otherwise you pretty much force people to use languages with library support for image decoding. 3. The "Swag" example is ambiguous: is it "Swag Swag"? 4. If you want to refine the scoring mechanism, I would do it as the sum of Levenshtein distances from the correct results. But the big problem with scoring test-battery is the tension between keeping the tests secret (to prevent overfitting) and public (for objective scoring). \$\endgroup\$ Nov 8 '17 at 7:25
  • 1
    \$\begingroup\$ 3. I can avoid the Swag-type format. Are the other formats unambiguous? 4. I can either show all the possible formats, and say that I will use words that are say 4-15 characters, or maximum 15 characters per example. I can then pre-select the input list, and provide a hash that ensures I won't change the input list after answers are posted. People can then try their code on some random strings of their own choosing on various formats and approximate their results, while the final score is made public later...? \$\endgroup\$ May 22 '19 at 6:43
  • \$\begingroup\$ Thanks for the link to the other challenges, they are useful as references when writing this challenge. Do you think this is different enough by the way? \$\endgroup\$ May 22 '19 at 6:58

How many right triangles can you find?


You will be given an input represented by x, which is a string containing at least 3 characters. It will consist only of the standard numeric characters, 0 through 9. Your job is to find and output how many right triangles can be formed with the given numbers.


  • Numbers must be kept in the order they were given in. No mixing them up!

  • The numbers for each right triangle must be consecutive.

  • The order of numbers has to be a first, b second, and c third, and must satisfy the formula a² + b² = c². a can be greater than or less than b, as long as it satisfies the formula.

  • Decimal points may be added between any numbers.

  • Decimals require one or more numbers to be placed before them, e.g. .5 cannot be used as a number but 0.5 and 12.5 can.

  • Decimals with at least 4 digits after the decimal point truncated to the third digit, e.g. 1.2345 would truncated to 1.234 and 1.9999 would be truncated to 1.999.

  • Numbers can be used more than once in 2 or more different triangles, but cannot be used multiple times in the same triangle.

  • Multiple representations of the same value can count multiple times.

  • Repeating zeros are allowed, e.g. 000.5 counts as a number.

  • All possible combinations must be taken into account for your program to be valid.

Example Inputs and Outputs

Input: 345
Output: 1
This can be split into 3, 4, and 5, which, of course, form a right triangle.

Input: 534
Output: 0
While this does include the necessary numbers to form a right triangle, they are not in the correct order. It has to follow the formula a² + b² = c², but in this case it follows c² = a² + b². The order of numbers cannot be changed from the original input, so in this case no right triangles can be formed.

Input: 3415
Output: 0
This does contain a 3, 4, and a 5, which can form a right triangle, but they are not consecutive; there is a 1 splitting the 5 from the 3 and 4.

Input: 5567507
Output: 1
Because decimals can be added anywhere, it can be changed to 55.67.507, which allows splitting it into 5, 5.6, and 7.507 to form a right triangle. Remember that decimals are truncated to the third digit after the decimal point, which is how we get 7.507.

Input: 345567507
Output: 2
The first right triangle is formed by 3, 4, and 5. The second one is formed by 5567507 (read the previous example for explanation). Numbers can be used more than once, so the first 5 was used in the first and second triangles.

Input: 51125
Output: 0
Because of rule 5, you cannot use .5, 1, and 1.25. An integer is required before .5 for it to work.

Input: 051125
Output: 0
Unlike the previous example, there is a number before the first 5, so it is now legal to use 0.5, 1, and 1.25.

Input: 121418439
Output: 2
The numbers 12 and 14 would form a right triangle where side c has a length of approximately 18.43908891458577462000. Because long decimals are truncated to the third digit after the decimal point, we would be left with 18.439. This fits in with the original input, 121418439. Additionally, 1.2, 1.4, and 1.843 counts as a separate combination, thus giving us our second right triangle.

Input: 10011005
Output: 8
Numbers count separately if they're represented in different ways, so this allows for (1, 00, 1), (1.0, 0, 1), (1, 0, 01), (1, 0.01, 1), (1, 0.01, 1.0), (1, 0.01, 1.00), (1.0, 0.1, 1.005), and (1, 00.1, 1.005).

This is code golf, so shortest answer in bytes wins. Good luck!

  • \$\begingroup\$ So if I understand correctly we do the following things: get all substrings of the input; get all 3-part partitions of each substring; insert a comma at each possible position in each possible partition; check any combination of three in order is approximately truthy for \$a^2+b^2=c^2\$ (approximately, because the decimals have been truncated, so aren't exactly a right triangle in some cases). Do I understand this correctly? \$\endgroup\$ May 8 '19 at 7:07
  • \$\begingroup\$ @KevinCruijssen almost correct, except you must find all combinations both with and without decimals at any given location. So it's not necessarily just adding a decimal point at every possible place; it's checking the results that would occur both by adding and not adding a decimal. \$\endgroup\$ May 8 '19 at 14:19
  • \$\begingroup\$ "Numbers can be used more than once." - Could you provide some examples of this or otherwise clarify what you mean? \$\endgroup\$
    – Beefster
    May 10 '19 at 19:52
  • \$\begingroup\$ @Beefster see the fifth example: one of the 5's is used to form two different right triangles. \$\endgroup\$ May 10 '19 at 19:57
  • \$\begingroup\$ Perhaps a better way to explain it would be something like "Right triangles that only use a subsequence of the digits can overlap with other triangles made from the same sequence of digits" or "You do not need to use all the digits for a single triangle and you may re-use digits that were used in previous triangles". What confused me about the way it's currently written is that it could be taken to mean that you can re-use a digit for the same triangle, so 125059 could be split into 12, 22, 25.059. \$\endgroup\$
    – Beefster
    May 13 '19 at 22:45

\$n\$-Chess KotH


Inspired by the challenge N-movers: How much of the infinite board can I reach?, I came up with an idea of applying the \$n\$-mover rules in chess.

\$n\$-Chess™ is a board game played on a 8x8 grid like the original chess. However, the pieces are very different from chess - they are named \$n\$-movers (\$n\$ can be any natural number) and can only move by the rules set on them (see Rules: Pieces).



In \$n\$-chess, a piece is called an \$n\$-mover, where \$n\$ denotes its possible movements. Specifically:

  1. The \$n\$-mover can only move one step of Euclidean distance \$\sqrt n\$ each time, i.e. for a move with \$x\$ units horizontal and \$y\$ units vertical, \$x\$ and \$y\$ must fulfill the equation \$x^2+y^2=n\$ in order to be valid.
    • For example, a 5-mover can only move 1 unit in one direction and 2 units in the another at the same time; while a 25-mover can move 5 units in either direction, or 3 units in one direction and 4 units in the another at the same time.
  2. A piece can have at most 2 rules set at the same time. For a piece that can act as either an \$m\$-mover or an \$n\$-mover, we can call it an \$(m,n)\$-mover. An \$(m,n)\$-mover is allowed to move one step of Euclidean distance of either \$\sqrt m\$ or \$\sqrt n\$ or \$\sqrt{m+n}\$.
    • It is allowed to have \$m=n\$.
    • Only pieces that has captured other pieces can have multiple rules (See Rules: Capture).
  3. If more than 2 rules are set on a piece, only 2 rules can be reserved. You can choose which 2 rules to reserve.


The chess is played on a 8x8 board. The initial setup is as follows: Initial board setup


  1. If a piece lands on a grid that an opponent piece has occupied (capture), that opponent piece shall be moved away from the board.
  2. After that, the piece will be granted rules from the captured opponent piece. As stated in Piece, if there are more than 2 rules in total, only 2 shall be reserved.


  1. In a turn, White and Black play a move in turn. White always moves first.
  2. Only one piece can be move per turn.
  3. You cannot move a piece in the way that is not allowed by the rules set on it, beyond the boundaries of the board, or onto a grid already occupied by your other pieces.
  4. You cannot move your last piece in the way that after moving it it can be captured instantly.

Victory Condition

The game ends with either player winning if:

  1. The last piece of the opponent is being checkmated, i.e. no possible moves that can save this last piece from being captured; or
  2. The opponent resigns and loses. (In this challenge, no resignation will be allowed)

The game ends with a draw if :

  1. No checkmate is possible for both sides;
  2. Either player has no more possible moves, but is not in checkmate;
  3. There is no capture in 50 moves; or
  4. The identical board arrangement has appeared 3 times with the same player to move.


A player bot is a class that implements a function nextMove(). This function receives 3 arguments and output an array of 6 integers:

function nextMove(
    color: int,                    // Your color: 0 = white, 1 = black
    board: int[8][8][3],           // Current board:
                                   //  First index: x-coordinate
                                   //  Second index: y-coordinate
                                   //  The third layer will be as follows - 
                                   //   [0]: the color of the grid
                                   //       (-1: Not occupied; 0: white; 1: black)
                                   //   [1]: rule 1 (0 if not exists)
                                   //   [2]: rule 2 (0 if not exists)
    moves: int[][10]               // Previous moves:
                                   //  First index: move number (0-indexed)
                                   //  The second layer will be as follows - 
                                   //   [0]: the color of the player
                                   //   [1]: is this a capture (0: no, 1: yes)
                                   //   [2]: source x-coordinate
                                   //   [3]: source y-coordinate
                                   //   [4]: source rule 1
                                   //   [5]: source rule 2 (0 if not exists)
                                   //   [6]: target x-coordinate
                                   //   [7]: target y-coordinate
                                   //   [8]: target rule 1
                                   //   [9]: target rule 2 (0 if not exists)
): int[6]                          // Return value: as follows:
                                   //  [0]: source x-coordinate
                                   //  [1]: source y-coordinate
                                   //  [2]: target x-coordinate
                                   //  [3]: target y-coordinate
                                   //  [4]: target rule 1
                                   //  [5]: target rule 2 (0 if not exists)
  • Rule 1 and Rule 2 denotes the 2 rules a piece has.
  • Source rule entries are used to denote which rules a piece has, while target rule entries are used to denote which rules are decide to keep.

You may use JavaScript, pseudo-codes, or any languages similar to JavaScript, but using JavaScript is strongly encouraged, because all submissions will be translated to JavaScript before using for competition, and the test drive only supports JavaScript.


  1. Standard loopholes are forbidden by default.
  2. You cannot by any means read or modify other bots. You can only use data within the class and inputs passed to nextMove() function.
  3. You may define other variables inside your class if needed.
  4. You may use a random number generator.
  5. Your bot, specifically the nextMove() function, must return value in 10 second per move. Timeout leads to disqualification.


Round-robin will be used to determine the opponents, i.e. all bots will face each of the other bots twice, one as black and one as white. For each game, a win gets 2 points, a lose gets 0 points, and a draw gets 1 points.

The bot will the highest points wins, and if there are any ties, they will be broken by:

  1. Number of victories;
  2. Average time to checkmate opponent (shorter is better); and
  3. Drawing lots. (Hopefully this step is not necessary)


  • Add a sample implementation.
  • 2
    \$\begingroup\$ KISS: since I assume that this is actually a game you've made up for the question, why not ditch checkmate and make the win condition that you capture all of the opposing pieces? I'm not sure about n-Chess™ for a name, either: it feels more like checkers than chess to me. \$\endgroup\$ May 29 '19 at 16:34
  • \$\begingroup\$ @PeterTaylor I'd say the question I had my inspiration from had its inspiration from chess, so I chose chess, and tbh I don't even know what checkers is until I've googled it right now. Well, it does look like checkers in the way capturing occurs, but I think I need to borrow some rules from chess, especially the ending rules, because I need to draw a line if the game never ends. Anyway thanks for your useful feedback! \$\endgroup\$ May 30 '19 at 2:41

Multi-Digit × Single-Digit Checker


The story below is fictional, don't worry.

Times table hard. More curriculum. Class advance. Son behind. Horror. Help.

ahem Pardon me.

So... I've got a big problem. The times table is huge, and all the mnemonic rules we've taught our son haven't make him fully memorize it yet. However, his class must advance to the next chapter, long multiplication. As a result, he is prone to making many mistakes while multiplying numbers.

See, they're already making the students multiply a multi-digit number by a single-digit number. My son often forgets to carry digits over and, of course, his times table. The good thing is that he never misses digits!

The situation is awful. Help me before they start with two multi-digit numbers!


Your challenge is to write a program that takes a multiplier, a multiplicand and a product, and analyzes the product for any of the following mistakes. Here's how:

  • If a digit is the correct ones digit of the product of the multiplicand times the digit of the multiplier he's currently multiplying, but a non-zero carryover was supposed to be added to it, then this digit has a carryover error.
  • If a digit is otherwise wrong, there's a times table error around it (we can't be sure if the ones digit was wrong or a carryover digit was wrong), so it has a times table error.
  • There will never be another kind of mistake in the product, my son doesn't skip digits.

For each wrong digit, return an array of two or three elements:

  • Position of the digit from the left or right, 0- or 1-indexed (your choice must be consistent). Keep in mind that, if the leftmost digit is absent due to a carryover error, then it's still the leftmost digit and the place has the relevant index.
  • Correct carryover, if the mistake was a carryover error, or omitted otherwise. You may also put a 0 instead of omitting the element (you can't blame my son for forgetting to add a zero carryover!), but be consistent.
  • Correct digit.


  • The numbers will all be positive integers.
  • The multiplicand will be an integer from 1 to 9, inclusive.
  • You can get the three numbers via any reasonable way you want.
  • The output can be in any order, as can the elements of each array, as long as the latter is consistent.
  • You may not make use of any standard loophole.
  • This is a challenge, so the shortest answer, measured in bytes, wins.

Test cases

Multiplier, Multiplicand, Product -> Mistakes (0-indexed from the left, possibly absent carryover)

5, 3, 15 -> [] (15)
3, 5, 5 -> [[0, 1, 1]] (05 -> 15)
7, 3, 31 -> [[0, 2]] (31 -> 21)
1551, 9, 4959 -> [[0, 1, 1], [1, 4, 3]] (04959 -> 14959 -> 13959)
2121, 7, 14847 -> [] (14847)
2121, 7, 4727 -> [[0, 1, 1], [2, 1, 8], [3, 4]] (04727 -> 14727 -> 14827 -> 14847)
33333, 9, 11111 -> [[0, 2, 2], [1, 9], [2, 9], [3, 9], [4, 9], [5, 7]] (011111 -> 211111 -> 291111 -> 299111 -> 299911 -> 299991 -> 299997)


  • Is the challenge unclear?
  • Is the output format weird or too strict?
  • \$\begingroup\$ I think it's a pretty interesting challenge! My only nitpick is in the introduction, when you're bringing up 'My son makes these mistakes:': make this section a bit more formal/a bit less story-level detail. The rest of the introduction is funny and gives some good context, but while reading the challenge I was kind of thrown off by the unnecessary detail in that section, e.g 'Ah, the crux of my worries.' \$\endgroup\$ Jul 9 '19 at 21:25
  • \$\begingroup\$ @GezaKerecsenyi That might be because those were part of the challenge text before I decided to move it all to the Challenge section. I'll shorten them to one sentence. EDIT: I've removed that part. \$\endgroup\$ Jul 9 '19 at 22:01
  • \$\begingroup\$ Also, I think that making the carryover optional is quite confusing, and it also means that you have to check if it was a carryover error just to know whether to output it or not. I would suggest to make them always give the correct carryover or 0, even if it wasn't a carryover error. \$\endgroup\$ Jul 10 '19 at 7:46
  • \$\begingroup\$ @GezaKerecsenyi I'm giving two options for times table errors, either exclude the carryover or make it 0. The answerer can choose one of the two consistently. Do you think there's an issue with the first one? \$\endgroup\$ Jul 10 '19 at 17:48

Sandbox Notes

  • Any other/better tags?
  • Is my math right?

Knot Function

TL;DR: Define a closed curve in 3D space that forms a knot.

A function \$f : [0,1] \to \mathbb R^3\$ is considered a loop function if the following conditions hold:

  • It is continuous.
  • \$f(0) = f(1)\$.
  • It is injective everywhere else.

Intuitively, this means that the function traces out a curve in 3D space that does not intersect itself.

Let the set of loop functions be denoted \$\text{Loop}\$. One such function is \$\text{circle}(t) = (0, \sin 2\pi t, \cos 2\pi t)\$, which traces out a circle in 3D space.

A function \$f : \text{Loop}\$ is considered a knot function if there exists no continuous function \$d : [0,1] \to \text {Loop}\$ such that \$d(0) = f\$ and \$d(1) = \text{circle}\$. Intuitively, this means that the loop that the function traces out cannot be continuously deformed into a circle without intersecting itself.

The Task

Write a program or function that implements a knot function, where real numbers are replaced with (to best approximation) floating point numbers.

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

  • \$\begingroup\$ This is going to need a formal definition of continuity, in particular of \$d\$. E.g. if using epsilon-delta, what's the distance metric between loops? \$\endgroup\$ Jul 5 '19 at 11:06
  • \$\begingroup\$ @PeterTaylor I think it's pointwise fixing each input value of t that's given to d. \$\endgroup\$
    – xnor
    Jul 6 '19 at 1:54
  • 2
    \$\begingroup\$ You need to be careful about input because it is not possible for a computable function to take an arbitrary real number between \$[0,1]\$ as input, so for this challenge \$[0,1]\$ is going to have to mean something else likely \$\mathbb{Q}\cap[0,1]\$. You might also want to replace \$\mathbb{R}^3\$ with \$\mathbb{Q}^3\$, but I don't think this is technically necessary. \$\endgroup\$
    – Wheat Wizard Mod
    Jul 6 '19 at 2:59
  • \$\begingroup\$ Also I am going to recommend the topological definition of continuity over \$\varepsilon-\delta\$ for this purpose because it meshes neatly with topology. (and IMO is easier to understand anyway) \$\endgroup\$
    – Wheat Wizard Mod
    Jul 6 '19 at 3:02
  • 2
    \$\begingroup\$ I think it would help to give a short informal statement of the challenge before going into the definition, so as not to needlessly scare away anyone intimidated by the math terms. \$\endgroup\$
    – xnor
    Jul 10 '19 at 4:23
  • \$\begingroup\$ The TL;DR needs "closed", because open polynomial curves which are knots are not valid answers. \$\endgroup\$ Jul 11 '19 at 22:12
  • \$\begingroup\$ @PeterTaylor Fixed. \$\endgroup\$ Jul 11 '19 at 22:13

Print the sum of the previous answer's ASCII values


Output the sum of the previous answer's characters. For example, if the previous answer was print(25), the next answer would have to output the next answer would have to output 741.

Initial Answer

The initial answer has to output the number 1000


  • Your code can only use ascii characters (sorry Jelly), no extended-ASCII or Unicode characters.
  • Your output can be in Decimal, Unary or Base 256 (represented by ASCII characters)
  • You cannot use a language that has been used before. (Note: Different versions of the same language are allowed, like Python 2 and Python 3)
  • To prevent overly long languages (such as Unary) ruining the chain, your answer cannot be longer then 1000000 bytes.
  • The same person cannot post twice in a row
  • If two users post "at the same time", the earlier one will stand
  • If a solution breaks one of these rules, it and all answers that chain off of it will be deleted
  • Don't edit your code after you've posted it, otherwise it could invalidate code that chains off of it


The winner of the challenge is whoever has posted the most recent answer, since it will get harder and harder the more languages that are used.

  • 2
    \$\begingroup\$ Can you clarify base 256? If extended ASCII is excluded, is there a specific way to represent 256 distinct digits using 127 codepoints? \$\endgroup\$
    – trichoplax
    Jul 13 '19 at 20:12
  • 7
    \$\begingroup\$ IMO this is too trivial to make a good answer chaining question. Finding an unused language in which you can figure out how to write (essentially) Hello, World is not going to get difficult until a couple of thousand answers in. \$\endgroup\$ Jul 14 '19 at 8:24
  • 1
    \$\begingroup\$ Wouldn't every answer just be variants of print(n) where \$n\$ is the integer literal of the sum of the last answer? \$\endgroup\$
    – Jo King Mod
    Jul 15 '19 at 22:52
  • \$\begingroup\$ Yeah, I’m gonna scrap this challenge because I didn’t think it through properly \$\endgroup\$
    – EdgyNerd
    Jul 16 '19 at 6:22

I'm sorry, Code Golf

This challenge is inspired by a series of Garfield-inspired artwork in which Garfield is depicted as a horror creature, stalking his owner, Jon. Commonly referred to as "Creepy Garfield", the line "I'm sorry, Jon" can be found in one of the earliest Creepy Garfield images, created by DubbleBaby.

William Burke's Depiction enter image description here

After being used over and over again by the Code Golf community, our beloved Jimmy has transformed - no longer bound to his weak, mortal body. He has become the embodiment of spaghetti code, the ascii manifestation of hours-long debugging sessions.

Your Task:

Take 3 ordered numerical inputs and output Jimmy's body


Input is received in the form x y z where:

x is the number of left limbs (integer between 1 & 10)
y is the number of right limbs (integer between 1 & 10)
z is the number of heads (integer between 1 & 10)

----Sample Input----
2 8 1

Meta Note: I don't think increasing the possible amount of body parts will influence the solutions but please let me know if you think they should be higher.

Body Parts

Head =          <o>
Left Limb =     /
Right Limb =    \
Filler Limb =   |
Body Piece =    0

Body Generation Rules

   1. Left limbs must be attached to the left side of a body piece
    (excl rule 3)
    - Correct:  /0
    - Incorrect: /<o>
    - Incorrect: 0/
    - Incorrect: /0\0\

2. Right limbs must be attached to the right side of a body piece
    (excl rule 3)
    - Correct: 0\
    - Incorrect: <o>\
    - Incorrect: \0

3. Limbs must not touch
    - Correct: /00\
    - Incorrect: /0\/0\

4. An external body piece without a limb must have a | in its place
    - Correct: /0|
    - Correct: |0|
    - Correct: /00\
    - Incorrect: /0
    - Incorrect: 0\

5. Heads must be between body pieces (horizontally not vertically)
    - Correct: 0<o>0
    - Incorrect: 0<o><o>0
    - Incorrect: 0<o>

6. All lines must be aligned centre
    - Correct:      /0\

    - Incorrect:    /0\

7. The bottom line of Jimmy's body must always contain a left and right limb
    - Correct:      /0\

    - Incorrect:    /0\

8. Jimmy's body must be whole and cannot be separated into sections
    - Correct:    /0\

    - Incorrect:    /0\   /0\   |0<o>0|

    - Incorrect:      /0\



2 8 2

Sample Output:




Rules & Win Conditions

  1. You may receive the stated input via any method into a program or function.
  2. You may display the output in any clear and discernible way.
  3. Your output must obey all Body Generation Rules.
  4. The previous 3 rules must be followed for all 1000 combinations of inputs.
  5. Standard loophole rules apply.

As this is , least amount of code in bytes wins.

  • 1
    \$\begingroup\$ I don't like bonuses in code golf in general, and this one doesn't even affect the score so it's just an invitation to distract from the challenge \$\endgroup\$
    – trichoplax
    Jul 16 '19 at 20:36
  • 3
    \$\begingroup\$ (1) Whenever you see a bandwagon, run the other way. It's better to ask an interesting question than the nth variant on a theme. (2) That aside, there's no clear explanation of what the input is. Where are the values of that enum? \$\endgroup\$ Jul 17 '19 at 10:53
  • 1
    \$\begingroup\$ @PeterTaylor (1) This challenge doesn't exist to hop on the bandwagon. I thought that generating an eldritch-like stick figure would be neat. If you don't think this is an interesting question, I'd love to hear your feedback on that. (2) I've amended the input section to be a bit clearer but I'm not sure what I was missing in the first place. \$\endgroup\$
    – BDM
    Jul 17 '19 at 21:13
  • 1
    \$\begingroup\$ What's missing is an explanation of the interpretation of the numbers. The input section defines the range of legal inputs but not the meaning of the inputs. \$\endgroup\$ Jul 17 '19 at 21:33
  • 1
    \$\begingroup\$ @PeterTaylor Ah I understand now. Hopefully my recent edit solves this. \$\endgroup\$
    – BDM
    Jul 17 '19 at 21:44
  • \$\begingroup\$ Somewhat related ... I think?! \$\endgroup\$
    – Shaggy
    Jul 21 '19 at 21:23

Minimum string attractors

String attractors

Let \$S\$ be a string of length \$n\$. An attractor of \$S\$ is a subset of indices \$A \subset \{0, \ldots, n-1\}\$ such that every nonempty contiguous substring \$S[i \ldots j]\$ of \$S\$ has an occurrence \$S[i' \ldots j']\$ whose index set \$[i' \ldots j']\$ intersects \$A\$. A minimum attractor is one with minimal size. Minimum attractors can be used to implement very efficient string compression algorithms. In this challenge, your task is to find a minimum attractor for a given string.


Consider the string acabaccabc. Using 0-based indexing, one of its attractors is \$A = \{2,3,5,8\}\$. This graphic shows the positions of \$A\$:

  ^^ ^  ^

For example, the occurrence of the substring ac in the beginning doesn't intersect \$A\$, but there is another occurrence after the first b that does. It turns out that no attractor of size 3 exists for this string, so \$A\$ is a minimum attractor.


Your input is a nonempty string of lowercase ASCII characters. Your output is a minimum attractor for this string, in any reasonable format. You can use either 0-based or 1-based indexing.

There may be several choices for the minimum attractor. In that case you may return any one of them, but only one.

The lowest byte count wins.

Test cases

These are 0-indexed and show one possible output.

a -> [0]
aaa -> [0]
ababab -> [0,1]
qgqqgq -> [1,2]
abcbacaa -> [1,3,5,6]
abcdefgh -> [0,1,2,3,4,5,6,7]
jejjeeje -> [2,3,5]
sttststt -> [1,5]
ykkkkvyk -> [0,2,5]
assassins -> [0,2,6,7]
acabaccabc -> [2,4,6,8]
ssssssjjjsjj -> [5,8]
hrhrhhrhhhrr -> [3,7,10]
fubuaabubuau -> [0,1,4,6,10]
jjaahajjhahaaahjjh -> [2,6,8,11,14]
  • \$\begingroup\$ It took me a few tries to understand the first paragraph. I think it is explained well, but I may just have been unfamiliar with the language. Adding an explanation of "occurrence" may help? \$\endgroup\$ Jul 18 '19 at 20:34
  • 1
    \$\begingroup\$ The formal definition in the first paragraph is clear if you are used to such an academic style, though it might unnecessarily hard to grasp for users with no such background. It might be worthwhile to start with an informal explanation before giving the concise formal specification. E.g. something like this: Consider the following game: You are given a string like acabaccabc and need to defend it against attacks by marking some of its characters. An attack is a continuous substring of the given string, e.g. ca, and it is defended if one of the occurrences of the substring has (1/2) \$\endgroup\$
    – Laikoni
    Jul 28 '19 at 18:43
  • 1
    \$\begingroup\$ a character that was marked by you. In the given example, ca occurs two times and covers the characters at positions 1,2 and 6,7 (with positions starting with 0). Thus, at least one of the positions 1,2,6 or 7 would need to be marked to defend the attack. Your goal is to find a marking such that the string is defended against any attack. Furthermore, you want to mark as few characters as possible. (2/2) \$\endgroup\$
    – Laikoni
    Jul 28 '19 at 18:43

Posted here


Check If A Binary Search Tree Is Balanced

Now posted on CodeGolf.StackExchange.com:

Write The Shortest Program To Check If A Binary Tree Is Balanced

  • 1
    \$\begingroup\$ Looks like a nice challenge! I think you should specify what representations of a binary tree are accepted. There is certainly the representation as a list (where the children of the entry at index r are at 2*r and 2*r+1), but there might also be other native representations. \$\endgroup\$
    – flawr
    Aug 5 '19 at 6:44
  • \$\begingroup\$ Now that you've posted this, please edit it to be only a link to the main challenge and then delete your post to help keep the Sandbox tidy. Thanks! \$\endgroup\$ Aug 7 '19 at 14:28

Posted to PPCG. Thx for the votes!


Find the Lowest Common Ancestor of Two Nodes In A Binary Tree

Any two separate nodes in a binary tree have a common ancestor, which is the root of a binary tree. The lowest common ancestor(LCA) is thus defined as the node that is furthest from the root and that is the ancestor of the two nodes.

The following are binary trees and the lowest common ancestors of the some of their nodes.

Binary Tree 1

The LCA of 13 and 15 is 14.

The LCA of 47 and 49 is 48.

The LCA of 4 and 45 is 40.

The LCA of 13 and 14 is 14.


Write the shortest program possible that accepts as input the root of a binary tree and references to any two nodes in the binary tree. The program returns a reference to the LCA node of the two inputted nodes.


The binary tree does not have nodes with parent field references in any form. You may not use parent field references in your program.


The root of a binary tree and references to any two nodes in the binary tree. This may be in the form of a reference to the root object or even a list that is a valid representation of a binary tree.


Returns a reference to the node that is the LCA of the two inputted nodes.

Definition of a Binary Tree

A tree is an object that contains a value and either two other trees or pointers to them.

The structure of the binary tree looks something like the following:

typedef struct T
   struct T *l;
   struct T *r;
   int v;

If using a list representation for a binary tree, it may look something like the following:

[root_value, left_node, right_node]
  • 2
    \$\begingroup\$ I mostly like your binary tree questions, but it would be nice if your definition was more inclusive of languages without the concept of pointers. Something like 'input will be a tree where a tree is either something containing a number and two other trees, or else something representing nothing. A tree must not be ambiguous'. This would include strings like [5[][7[6[][]][8[][]]], where a tree is [number tree tree] or [] as well as the usual standard binary tree structures and lists \$\endgroup\$
    – Jo King Mod
    Aug 9 '19 at 6:45

A Picture is Worth a Thousand Words

The average word is four characters/bytes long. So a picture, according to the old saying, is worth 4 kilobytes. But how complicated can that picture get?

Using any language or length of code you want, generate an image exactly 4,000 bytes in size with the highest possible entropy. You may use any standard image format. Your score will be the compression ratio when your image is compressed as a .zip file. For example, an image that compresses to 2,000 bytes will score 2, but if it expands to 4,100 bytes it will score 0.9756. Lowest score wins.

  • \$\begingroup\$ What image formats are allowed? \$\endgroup\$
    – wastl
    Aug 13 '19 at 2:41
  • \$\begingroup\$ @wastl All of them. \$\endgroup\$
    – Purple P
    Aug 13 '19 at 3:19
  • \$\begingroup\$ should the program output to a file or can it print a list of bytes? \$\endgroup\$ Aug 13 '19 at 12:20
  • 3
    \$\begingroup\$ Interesting challenge. .zip is a file format, not a compression method, though. You'll need to specify what compression method is used -- DEFLATE, LZMA, etc. -- because that could drastically affect the scoring. \$\endgroup\$ Aug 13 '19 at 12:51
  • \$\begingroup\$ @SuperStormer It shouldn't matter as long as you upload the image file. \$\endgroup\$
    – Purple P
    Aug 13 '19 at 15:03
  • \$\begingroup\$ @AdmBorkBork How about gzip? I would specify version 1.6 because that's what I have. \$\endgroup\$
    – Purple P
    Aug 13 '19 at 15:04
  • \$\begingroup\$ If you say something like gzip 1.6 using DEFLATE with default settings that should probably suffice. \$\endgroup\$ Aug 13 '19 at 15:58
  • \$\begingroup\$ I didn't test this but I feel that any uncommon image format of raw data will have the optimal score (assume the compressor is smart enough to store without compression) \$\endgroup\$
    Aug 16 '19 at 4:42

Black Hole Evaporation

Background: In empty space, occurring all the time, there are pairs of particles that appear and then, usually soon after, cancel each other out. At a certain distance from a Black Hole, it's possible that a pair of particles might spontaneously appear and, if the distance is just right, one of the particles will fall into the Event Horizon while the other escapes off into space, never getting a chance to cancel each other out. The exit of those particles is Hawking Radiation. Eventually, this process causes the entire Black Hole to evaporate away.


Given a string of numbers, emit the negative of the single digit number closest to, in front of, the infinity symbol ∞ (the event horizon), and continue emiting it until there are no digits left in front of the infinity symbol. Then print the rest of the string masking each character uniquely and different from the masked character (burst of energy that might take place at the final instant), excluding any infinity symbols.

Test cases

Input:                      Output:
111∞4567                    -1 -1 -1 jkl;
3∞                          -3
3-145∞962                   -5 -4 1 -3 ™©®
4-567-9∞1-23                 9 -7 -6 5 -4 😐😈😎😻
2-1∞                        1 -2
34∞67∞89                    -4 -3 9876
-123∞456                    -3 -2 1 ♫♪#
6-6∞6                       6 -6 ä
48120∞                      0 (or -0) -2 -1 -8 -4
---5∞555                    5 オゼヰ

Challenge rules

  • Anything after the first infinity symbol can be ignored as it has fallen into the Black Hole and we know nothing more about it anyway until after evaporation, where the information is a bit scrambled.
  • The code should only expect numbers, negations, and infinity symbols. No decimal points or other symbols. The input can be an array, list, etc..., but each character must be separate, including the negation and infinity characters.
  • A negation only applies to the single digit immediately after it. See the test cases above.
  • You may mask the remaining characters after evaporation with any character set of your choice, as long as the resulting character is different from the masked character, and each character in the resulting output is unique. For languages limited to smaller character sets (or type constraints), characters may repeat after each possible unique character has already been utilized in the output.
  • You may use the '_' symbol instead of the '∞' symbol.

General rules

  • This is , so shortest code in bytes in its respective language wins.

  • Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN (with the specification above)/STDOUT, functions/method with the proper parameters and return-type, full programs.

  • Default Loopholes are forbidden.
  • If possible, please add a link with a test for your code (TIO).
  • \$\begingroup\$ I'm thinking of expanding this to all alpha numeric characters. \$\endgroup\$
    – ouflak
    Aug 7 '19 at 19:04
  • \$\begingroup\$ What does it do if there is a single number after the infinity symbol? \$\endgroup\$ Aug 8 '19 at 6:53
  • \$\begingroup\$ I'll update the rules and the test cases. Curiously, I already sort of demonstrated that case by having nothing after the infinity symbol. Nice catch. \$\endgroup\$
    – ouflak
    Aug 8 '19 at 6:55
  • \$\begingroup\$ If 121 remains after evaporation, is reversing that string an acceptable scrambling? \$\endgroup\$
    – Adám
    Aug 8 '19 at 7:21
  • 2
    \$\begingroup\$ Any particular reason to use ? Adding Unicode into the mix is an unnecessary complication for many languages. Maybe allow substituting _? \$\endgroup\$
    – Adám
    Aug 8 '19 at 7:22
  • \$\begingroup\$ @Adam, "If 121 remains after evaporation, is reversing that string an acceptable scrambling" Absolutey! Our understanding of what happens to the information after Black Hole evaporation is still under much debate. It is entirely possible that the result of scrambling might result in the same information. We just don't know. \$\endgroup\$
    – ouflak
    Aug 8 '19 at 7:46
  • \$\begingroup\$ @Adam, "Any particular reason to use ∞? Adding Unicode into the mix is an unnecessary complication for many languages." Yeah I thought about that. It can even be excluding factor, which I don't like. I really want that infinity symbol though.... I'll have a think about it, but any suggestions like yours are welcome. \$\endgroup\$
    – ouflak
    Aug 8 '19 at 7:49
  • \$\begingroup\$ @Adam, "If 121 remains after evaporation, is reversing that string an acceptable scrambling?". After re-reading through the Information Paradox, I think the answer is 'no'. '121' should definitely end up different. I'll have to find some way to re-word the challenge, and I can be talked out of this. This requirement seemed rather innocent, but as I'm trying to code this up in my head, it can get complicated. \$\endgroup\$
    – ouflak
    Aug 8 '19 at 8:01
  • 2
    \$\begingroup\$ The connection between the background and the task is not very clear. The comment about information suggests that you have a much clearer idea which you haven't included in the question. There's no need to overload the question with back story, but a link to a more detailed explanation might make it feel less arbitrary. \$\endgroup\$ Aug 8 '19 at 8:23
  • \$\begingroup\$ @PeterTaylor, I've been mulling over your comment and I'm not sure what to include. Links to the Information Paradox or Hawking Radiation, or both? \$\endgroup\$
    – ouflak
    Aug 8 '19 at 8:41
  • \$\begingroup\$ Probably both. AIUI, the infinity symbol represents the event horizon, the symbols to the left represent virtual pairs which become Hawking radiation, the symbols to the right represent the captured information, the emission of the inverted symbols to the left corresponds to the emission of Hawking radiation, and the shuffling of the symbols to the right corresponds to the information paradox. (I'm not sure without checking some reference why there's anything left to the right after evaporation). It would be good to sketch the correspondences and have some "Further reading". \$\endgroup\$ Aug 8 '19 at 8:46
  • \$\begingroup\$ @PeterTaylor, Ok thanks. The final stage of evaporation might release a detectable packet of energy (which has yet to be seen or is even theoretically certain), so that's kind of what that represents. There might be something left over afterwords, or maybe not. When I get the chance, I'll edit some links in and parenthesize some metaphors in there as well. \$\endgroup\$
    – ouflak
    Aug 8 '19 at 8:55
  • 1
    \$\begingroup\$ @ouflak Regarding you can use it but allow substitution. Btw, _ is the infinity symbol in the J language. \$\endgroup\$
    – Adám
    Aug 8 '19 at 9:27
  • \$\begingroup\$ @Adám, What about, "If your language has a built-in substitute for ∞, you may use that. If your language can't use Unicode, or use it efficiently, you may use the '_' symbol instead." Does that sound fair and inclusive enough? \$\endgroup\$
    – ouflak
    Aug 8 '19 at 10:03
  • 1
    \$\begingroup\$ @ouflak What if your language's infinity is inf? That's three symbols, so it complicates matters a lot. "use it efficiently" is unclear? Does that include causing higher byte count? How about just: You may use the _ symbol instead of . \$\endgroup\$
    – Adám
    Aug 8 '19 at 10:06

caN it be acrOnymised?

  • 2
    \$\begingroup\$ I shall hereby refer to Code Golf and Coding Challenges as DANGLE \$\endgroup\$
    – Quinn
    Aug 19 '19 at 18:32
  • 1
    \$\begingroup\$ Can the acronym contain lowercase letters? (For an example of that, see BSoD.) \$\endgroup\$
    – user85052
    Aug 20 '19 at 4:58
  • \$\begingroup\$ @A__ While actual acronyms can, I'm going to say that the acronym will always be in complete uppercase, for simplicity's sake. And I've added in constraints on the length of the inputs. \$\endgroup\$ Aug 20 '19 at 9:13

BotNets KotH

Controller, Example and Submission Template now added

flavor text not yet written

This is a web-based JS KotH where submissions have 2 parts, a Worker Bot and a Controller Bot. The goal is to have the most gold at the end of the game, by killing other bots and collecting gold found on the grid, while navigating the grid and surviving.

Worker Bots

A Worker Bot is a class(ES6 or ES5) based on this format:

class YourWorkerBot extends WorkerBot {
    performAction(message) {}
    sendMessage(x, y, surroundings) {}

Each botnet has 20 Worker Bots. For every botnet, its worker bots are

Method Descriptions:

  • constructor(index): sets the color that the controller displays the bot as
  • performAction(message): returns an action(described below).
  • sendMessage(x,y,surroundings): x and y are zero-indexed coordinates. surroundings is a flat array of the 5x5 area around the bot. returns message(string) to send to controller bot


Each move is formatted as a 2 element list([action, param]) where action is a string

  • Movement: formatted as ["move", square] where square is an integer that represents the square you want to move to, using the same index as the surroundings object. You can only move one square orthogonally or diagonally. Moving onto a square with a coin will collect the coin.
  • Kill: formatted as ["kill", square] where square is an integer that represents the square you want to attack, using the same index as the surroundings object. You can only kill a bot one square orthogonally or diagonally. If you kill a square with no bot, you do nothing. You get half the coins(rounded down) of the bot you attacked.
  • EMP: formatted as ["emp",undefined]. It causes all bots including itself in the 7x7 surrounding area can't move next turn. This costs 3 coins.
  • Any invalid action is treated as you doing nothing.


The surroundings object will be a flat array of the 5x5 area around you, starting from the top left corner and going left to right and top to bottom. The grid below shows how the indexes of the array map to the actual grid area. Each square will be either a string, where "B" is a bot, "C" is a coin, "E" is an edge(not a valid move target) and "" is empty.

 0  1  2  3  4
 5  6  7  8  9
10 11 12 13 14
15 16 17 18 19
20 21 22 23 24

Controller Bot

A Controller Bot is a class(ES6 or ES5) that extends the following class:

class YourControllerBot extends ControllerBot{
         return ""

Each botnet has only 1 Controller Bot.

Method Descriptions

  • constructor(locations): locations is an array of the initial locations([x,y]) of the worker bots.sets initial storage value
  • sendMessage(messages,index): messages is a list of lists of the messages sent by all the worker bots(not just your own), always in the same order and grouped by botnet. returns message to its worker bots whose index is index.

The Game

The arena will be a 100x100 grid with 100 random coins scattered around it. Each game will have 1000 rounds and will have up to 15 randomly selected botnets. Every round, 10 coins will spawn at a random unoccupied spot. Every worker bot will get 1 turn per round. Each botnet's worker bots will perform an action in the same order for the entire game, but the order in which botnets take turns is randomized every round. Every turn, all the worker bots' sendMessage methods will be called(not just the worker bot taking the turn). After that, the controller bot's sendMessage method will be called. Finally, the worker bot's performAction method will be called and the action will be executed. This will repeat for every worker bot in a round.


Each botnet's score is the sum of the coins collected by each of the worker bots. Botnets are ranked by most score.




function sampleBotnet() {
    class SampleControllerBot extends ControllerBot {
        constructor(locations) {
            this.storage = "";
        sendMessage(messages, index) {
            let surrondings = messages.find(message => message[0] === index)[1];
            let otherBot = surrondings.findIndex(
                (square, i) =>
                    square === "B" && [6, 7, 8, 11, 13, 16, 17, 18].includes(i)
            if (otherBot !== -1) {
                return ["kill", otherBot];
            let coin = surrondings.findIndex(
                (square, i) =>
                    square === "C" && [6, 7, 8, 11, 13, 16, 17, 18].includes(i)
            if (coin !== -1) {
                return ["move", coin];
            let validMoves = [6, 7, 8, 11, 13, 16, 17, 18].filter(
                x => surrondings[x] === ""
            return [
                validMoves[Math.floor(Math.random() * validMoves.length)]
    class SampleWorkerBot extends WorkerBot {
        performAction(message) {
            return message;
        sendMessage(x, y, surroundings) {
            return [this.index, surroundings];
    return {
        name: "SampleBotnet",
        color: "red",
        controllerBot: SampleControllerBot,
        workerBot: SampleWorkerBot

#Submission Template
/* eslint constructor-super:0,no-this-before-super:0,no-unused-vars:0*/
import ControllerBot from "./src/scripts/ControllerBot.js";
import WorkerBot from "./src/scripts/WorkerBot.js";

//copy the part below
function yourBotnet() {
    class YourControllerBot extends ControllerBot {
        constructor(locations) {
            this.storage = "";
        sendMessage(messages, index) {
            return [];
    class YourWorkerBot extends WorkerBot {
        performAction(message) {}
        sendMessage(x, y, surroundings) {}
    return {
        name: "YourBotnet",
        color: "",
        controllerBot: YourControllerBot,
        workerBot: YourWorkerBot


  • Standard Loopholes apply
  • Bots cannot modify or add global variables
  • Bots cannot call controller functions or other bots' methods
  • Bots cannot read or modify other bots storage
  • Bots may not access the internet
  • I may disqualify any bot which does anything I deem to be cheating.


  • Is the bar to entry too high?
  • Can the current turn/round system be improved?
  • Any better names for the 2 bots/title?
  • Is there enough room for creativity?
  • Would it be better if I merged the 2 classes into one class?
  • Is there anything broken with the spec?
  • \$\begingroup\$ How many workers per controller, and how many controllers per game? Also, are controllers supposed to be able to message to all workers, or just their own? \$\endgroup\$ Aug 12 '19 at 4:05
  • \$\begingroup\$ @UnrelatedString should be fixed \$\endgroup\$ Aug 12 '19 at 13:25
  • 1
    \$\begingroup\$ performAction(surroundings, message) { return eval(message); } sendMessage(surroundings) { return JSON.stringify(surroundings); } There are, of course, countless other ways to circumvent the size restrictions. I also find said restrictions quite brutal. Additionally, I don't see the point of worker-side storage. Finally, the whole document is difficult to read - giving a short summary of the goal at the beginning would go a long way. Nitpick: it's "surroundings", not "surrondings". \$\endgroup\$
    – Alion
    Aug 16 '19 at 10:46
  • \$\begingroup\$ Since your latest revision is "fixed spec": a) The WorkerBot class is invalid - calling super there is a syntax error. Do you want to show the base class that should be extended, or a template of how to extend said class? The second option makes more sense in my opinion, although the text right above seems to indicate otherwise. b.1) Under "Controller Bot", what is index? How is it chosen? b.2) What do bots that don't have the specified index receive as the message? b.3) Are there duplicate worker bot indexes possible? If not, please fix sendMessages descripiton. \$\endgroup\$
    – Alion
    Aug 18 '19 at 8:21
  • \$\begingroup\$ c) Under 'The Game', sendMessages instead of sendMessage for controller bot. d) I'm worried about the split between worker bot and controller bot. I don't see how it would be anything but a minor nuisance under the current rules. Previously it was code-golf, but that's gone now. I'm also aware that it is supposed to be the essence of this challenge, so I'm hoping there's just a big misunderstanding somewhere. Perhaps it'll become clear once (b) is addressed. \$\endgroup\$
    – Alion
    Aug 18 '19 at 8:24
  • \$\begingroup\$ I really like this idea! I think the combat could be improved (kill seems like it would just give too much power to the bots that go first in a turn), but the EMP is really creative (you might want to reduce it's range to what a worker can see, to reduce unintentional friendly fire). So that you don't need to order based on randomness, you can use a sort of "two pass" system where you first create a list of all the moves workers make, then apply them in a way that doesn't give any advantage to the worker who goes first (continued) \$\endgroup\$ Aug 19 '20 at 21:47
  • \$\begingroup\$ (continuation) For example, all EMPs would be applied, then all kills, then all movement. If two bots attempted to move into the same spot or kill each other, you could base it off of some secondary factor like number of coins/gold or most friendly workers in the vicinity. Good luck with the challenge, it seems really cool! \$\endgroup\$ Aug 19 '20 at 21:49

Up side down keyboard

Jono 2906 wants you to create a translator from plain Australian to up-side-down text after inventing a keyboard dedicated to typing up-side-down text, since they still want to demonstrate that their keyboard is powerful after failing to program in their keyboard.

However, they want your implementation to be typed with their own keyboard, since they also want to get used to programming using their keyboard.


The whole ASCII character set mapped to their up-side down variation (the up-side down " is a double ,):



The rest of the characters are kept as-is(yes, the unprintable characters are in the ASCII character set). The characters that are larger than 0x7f will be mapped back by subtracting the character code by 128.

If you are using a character that is larger than 256, modulo the character's character code by 128 before checking the availability.


  • No standard loopholes, please.
  • Input and output will be taken with our standard input methods.
  • If you force Jono 2906 to change a key on their keyboard (allowing typing your specified character), you will get a penalty of +2 bytes for every key you add.

  • 2
    \$\begingroup\$ I don't think I quite follow. Are we given a character as input and need to output the upside-down version? \$\endgroup\$ Aug 27 '19 at 14:06
  • 1
    \$\begingroup\$ (1) I still find the question confusing even as to the basic functionality required. The "Input/Output" section seems to me to say that it's a Kolmogorov problem, but the "Rules" section talks about input. (2) If a character remapping is involved, the question should list Unicode codepoints for the characters in question, and should list test cases with Unicode codepoints. (3) Is the last rule saying that the program must work as is and after mangling? Or is it just a gimmick ("Post your code upside down, but it only has to work the right way up")? \$\endgroup\$ Aug 28 '19 at 8:39
  • 1
    \$\begingroup\$ "The rest of the characters are not kept as-is(yes, the unprintable characters in the ASCII character set)." should this not be there? As for that entire paragraph, if I understand correctly: unprintable characters < 33 (as well as 127) will be kept as is; printable ASCII characters displayed will be converted to upside down; other printable ASCII characters and any character above 127 will be modulo-128 before doing the same check. \$\endgroup\$ Aug 28 '19 at 9:24
  • 1
    \$\begingroup\$ As for the last rule: we can only use those upside down characters in our source code, and when converting it to regular it should also work? So both programs ABC and ∀qƆ should work exactly the same? \$\endgroup\$ Aug 28 '19 at 9:25

Wrong position

I typr re;atively accuratrly, but so,etimes I made a whole nlock of text illegible by shifting a key right. So I need a program that corrects my text back to its original meaning.


  • You have to left shift on a standard English QWERTY keyboard.
  • Whitespace do not count for the procedure before left-shifting and are kept as-is in a standard left-shifting procedure. If the key is the leftmost letter/symbol on a keyboard(i.e. The ~key, Q key, A key, Z key.), the key is kept as-is. If you reach a control character while left-shifting (Caps lock and Shift), their effects will not be triggered and the character before left-shifting is kept.
  • This is a contest; the shortest answer wins.
  • Both the input and the output shall be given via our default methods.

Representation of a subset of the QWERTY keyboard that you will need

The two lines connected are possible values of the key: shifted/unshifted.







The input will always be a non-empty string conforming the rules above.


The output will be the input string corrected to the originally intended meaning.


Yjod ,sfr yjr, imjsppu/ -> This made them unhappy.
vpfr hp;g -> code golf


I think this is not a duplicate; however, is any part of this challenge unclear or needs improvements?

  • 1
    \$\begingroup\$ I think you are mixing up left and right. Clearly, ~, Q, A and Z are leftmost keys, NOT rightmost. And your examples appear to be left-shifting, not right-shifting. \$\endgroup\$
    – wastl
    Sep 7 '19 at 11:27
  • \$\begingroup\$ "I think this is a duplicate" - so why sandbox it? Or did a not go missing in editing? \$\endgroup\$ Sep 9 '19 at 8:36
  • \$\begingroup\$ Thank you. Predominantly my mouse was not working again, I didn't get around to fix this. \$\endgroup\$
    – user85052
    Sep 9 '19 at 8:56
  • \$\begingroup\$ "sonetimes" and "vlock" are shifted the wrong way. \$\endgroup\$
    – Hiatsu
    Sep 9 '19 at 16:20

Path to Path Rearrangement

In the xkcd comic "Map of the Internet", a special fractal path was used, similar to this:

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

Ascii art version:

-0---1  14---15--16 19--20---21
     |   |       |   |       |
 3---2  13---12 17---18 23---22
 |           |           |
 4   7---8   11 30---29 24---25
 |   |   |   |   |   |       |
 5---6   9---10 31  28--27---26
58---57 54---53 32  35--36---37
 |   |   |   |   |   |       |
59  56---55  52 33---34 39---38
 |           |           |
60---61 50---51 46---45 40---41
     |   |       |   |       |
63---62 49---+---47 44--43---42

This path, known as the Hilbert curve, has some interesting properties. Among other things, it can be flipped diagonally without changing most of those properties.

-0   3---4---5  58--59---60  63->
 |   |       |   |       |   |
 1---2   7---6  57---56 61---62
         |           | 
14---13  8---9  54---55 50---49
 |   |       |   |       |   |
15  12--11---10 53--52---51   48
 |                           |
16---17 30---31--32--33 46---47
     |   |           |   |
19---18 29---28 35---34 45---44
 |           |   |           |
20  23---24  27 36  39---40  43
 |   |   |   |   |   |   |   |
21---22 25---26 37---38 41---42

Your task is to apply this transformation. Given a space on one path, find the corresponding location on the other. For example, the fourth space in the top path is located at (0, 2), which is the 14th space along the second path, so the correct output for 4 is 14.

As with similar challenges, this can be done as:

  • An infinite sequence along the second path of the corresponding locations along the first path
  • A function/program that takes a numbered position on the first path and returns the distance to that point on the second path.
  • A function/program that takes a numbered position on the first path and returns all path 1 positions along path 2 to the point specified.

The first 64 terms of this sequence (zero indexed, add one to each for one indexed) are:

0 3 2 1 14 15 12 13 8 11 10 9 6 7 4 5 58 57 56 59 60 63 62 61 50 49 48 51 52 55 54 53 32 35 34 33 46 47 44 45 40 43 42 41 38 39 36 37 26 25 24 27 28 31 30 29 18 17 16 19 20 23 22 21

This is code golf, so shortest code in bytes wins.

Meta Questions

  • Do I need a better description of the paths?
  • Is the challenge itself clear?
  • Any other issues I should fix before posting?
  • \$\begingroup\$ The default output formats for sequence challenges can be found in the tag wiki \$\endgroup\$
    – Jo King Mod
    Sep 10 '19 at 4:03
  • 1
    \$\begingroup\$ (1) Related. (2) I don't find "Find the location along the second path of a point on the first path" at all clear. It seems to be talking about output in 2D. I think it would be clearer to say "Given an index on the first path, output the index of the same coordinate on the second path". And then give a worked example (e.g. 4 vs 14). \$\endgroup\$ Sep 10 '19 at 10:53

Maximize the Hello, world's in code permutations

In this task you should output this exact string: hi orb (because Earth is a sphere). However, here is the catch: you must output as many hi orb's as possible in all of your code permutations. Identical permutations do not count(e.g. aa's permutations count as one permutation)

Say you have a program abc that outputs this string. You should try your best to make acb, bac, bca, cab, and cba (i.e. the permutations of abc) also output this exact string.


  • No standard loopholes, please.
  • Input/output must obey our standard methods.
  • Your score is simply the factorial of the length of your code. You shall also present the following score: The score is counted in the negative of the length of your source code divided by the number of permutations that your code generates; (expression: -(source length/permutations).) Of course you want to keep your score as low as possible.
  • All comment characters in your language are disallowed, in order to avoid collapsing into a radiation-hardening challenge.
  • If you are using the filename as data, the filename must also count in the permutations.
  • The source code length should be <1000. (Don't ask why, it's just an attempt of avoiding abusing the source code length.)


  • Is it detailed enough?
  • Is the input/output rules clear enough?
  • Do I need any more information?

I don't think this is a duplicate because nobody has asked a question tagged with both permutation and hello-world. However, I worry that this challenge will collapse into a radiation-hardening challenge if you comment out a single character and then make sure that this will produce the same result, therefore making it a flavored version of this question and close to a duplicate.

  • \$\begingroup\$ Can't you just extend your score by increasing your byte counnt, as long as you have some commented out part or no-op? \$\endgroup\$
    – Jo King Mod
    Sep 19 '19 at 8:50
  • \$\begingroup\$ Unneccecary NOPs are disallowed, and at least 1 permutation of your code must only contain relevant code and nops. is rather vague, since no-ops aren't really defined, nor is this challenge really that possible to increase score if you don't have no-ops, otherwise it will turn into a duplicate of the normal Hello World question \$\endgroup\$
    – Jo King Mod
    Sep 19 '19 at 9:25
  • \$\begingroup\$ This reminds me of a challenge I sandboxed a while ago, but deleted since it was clear it would produce only trivial answers \$\endgroup\$
    – Jo King Mod
    Sep 19 '19 at 9:27
  • \$\begingroup\$ code-golf scoring usually has lowest score (=code length) wins. If you break with that convention, you should mention it in the rules. I think a big problem with this is that for any non-trivial answer (Like H in HQ9+), the proof of correctness of the score is almost impossible, because unlike radiation-hardening, the amount of variants increases factorially instead of linearly with the code length. \$\endgroup\$ Sep 19 '19 at 11:52
  • \$\begingroup\$ Hmm, it is okay, I will make the score negative then. I believe a program running the permutations of a string (not counting repeated ones) and evaluating them to check the result will be sufficient. Hmm, that's why the submittor needs to golf their code: to allow others to check their answers. \$\endgroup\$
    – user85052
    Sep 19 '19 at 12:09
  • \$\begingroup\$ That's where it's unfeasible: The highest-scoring answer in the challenge you linked has 96 bytes. That's 9.9*10^149 permutations to check if they output the correct result. Even assuming your implementation is the fastest possible, that would take years, just for that single answer. You can't brute-force determine the score, but using mathematical trickery to try and calculate the score by hand will be arduous and prone to errors. \$\endgroup\$ Sep 19 '19 at 13:10
  • \$\begingroup\$ I don't think the limitations you have put are going to prevent this from falling apart. For example, this Pyth program works for any permutation of the code where only characters after the third " are permuted. Completely filling up the code allowed will achieve a score exceedingly close to zero. I don't think that is what you want, but I'm not really sure you can fix it (like what happened to Jo King), sorry. \$\endgroup\$ Sep 19 '19 at 18:38
  • \$\begingroup\$ @FryAmTheEggman this particular snippet fails the rule that all code needs to be relevant. However, even if we tighten the rule to all code being life and necessary, that is, in one permutation, all code is executed, and a deletion of any statement resulting in the code not outputting "Hello World" any more, you can still cheese the challenge by bloating the code. The only way to stop that would be to change the scoring method to also use the factorial of the byte count, but then A) HQ9+ is unbeatable and B) It's a math challenge because you have to calculate the amount of viable permutations \$\endgroup\$ Sep 20 '19 at 10:06
  • 2
    \$\begingroup\$ Instead of helo word, wouldn't it make more sense to just use a different phrase like greeting earthlings or something along those lines? I agree with @AdmBorkBork that helo just looks weird. I do think it shouldn't be hello world to prevent builtins, so helo word is already better, but it still looks weird and will raise questions for sure.. \$\endgroup\$ Sep 20 '19 at 12:38
  • \$\begingroup\$ I don't understand the scoring. If we're scored only on the factorial of the length of code, why does it matter how many permutations output hi orb? I would figure that the number of ways that is output should factor into the scoring somehow... \$\endgroup\$ Sep 20 '19 at 14:11

The Celestial Bureaucracy


  • \$\begingroup\$ This sounds like a lot of fun. When the exam is asked, is it possible to know which bot gave the exam? \$\endgroup\$
    – Pureferret
    Sep 18 '19 at 11:58
  • 2
    \$\begingroup\$ You are given the ID of the bot via the parameter for ask, which allows you to identify if you've interacted with that bot before and if it's the Jade Emperor (because his ID is always -1). You won't get the name - if you want to identify the bot, you'll have to analyse its question and answer pattern. \$\endgroup\$ Sep 18 '19 at 12:08

Creep Spread Territorial Control (WIP)


Blah blah blah flavor blah blah blah something about Starcraft blah blah blah


Initial State

There is a 150x150 grid of square cells with approximately 7500 random cells missing in a symmetric Perlin noise pattern. There are four creep spread factions competing for dominance of this territory beginning as a single cell 10 cells in from a corner of the grid (one faction per corner). Each faction starts with 50 energy. The board does not wrap around at the edges.


Each turn, each faction earns 1 point of energy for each controlled cell plus 20 base energy. This energy is used for expansion. How much a cell costs to expand to depends on how many cells controlled by the same faction are in the Moore neighborhood of the target cell.

  • 0 neighbors: cannot expand to this cell
  • 1 neighbor: 50 energy
  • 2 neighbors: 20 energy
  • 3 neighbors: 12 energy
  • 4 neighbors: 8 energy
  • 5 neighbors: 5 energy
  • 6 neighbors: 3 energy
  • 7 neighbors: 2 energy
  • 8 neighbors: 1 energy

There is no limit to how many cells can be expanded to in one turn other than energy costs. All expansions occur simultaneously. If two or more factions attempt to claim the same cell on the same turn, the one with the most neighbors of its own faction will claim the cell. If there is a tie, none of the factions claim that cell. Players whose expansions failed due to competition will not be refunded. Factions may expand onto each other's territory, stealing ownership of the cell.

Game End

The game lasts 10,000 turns or until there is only one faction remaining, whichever happens first. The winner is the faction with the most owned cells. Ties are broken by remaining energy.

The overall winner will be resolved with a randomized pool where each bot plays an equal number of games followed by 12 games of the top 4 contenders. (one for each possible corner positioning)


Write a bot that plays this game

  • Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer between \$0\$ and \$2^{32}-1\$ will be passed to the bot, which will be seedable in the controller.
  • Bots have perfect information of the current state of the board, which turn it is, and their own energy, but not the energy of other players.
  • Bots may not remember anything between turns, but may initialize constants and utility functions at the beginning of each game.

The list of desired expansions is ordered. As soon as an invalid expansion target cell is encountered (whether by cost or lack of same-faction neighbors) in this list, the rest of the list will be ignored and a warning will be logged.

  • \$\begingroup\$ So if I build at 0,1 and 1,0 on the same turn while having a cell at 0,0, the cost would be 2000, yeah? Are failed expansions refunded? Also, I think having a source of randomness would be good. \$\endgroup\$
    – Veskah
    Sep 13 '19 at 17:40
  • \$\begingroup\$ @Veskah, that would cost 2000, correct. I'll add some rules about when failed expansions are refunded. \$\endgroup\$
    – Beefster
    Sep 13 '19 at 19:38
  • \$\begingroup\$ Suggestions: 1. Maybe allow expanding to own territory too? Could be used as a defensive mechanism when you can predict that you are going to be attacked. (should be thought about, could be bad) 2. Maybe set a limit on how many cell expansions can happen per turn to avoid exponentially expansion? I'm thinking that a bot which gains some advantage might get unstoppable when it is unlimited. \$\endgroup\$
    – Night2
    Sep 14 '19 at 7:33
  • \$\begingroup\$ 3. More clarification in rules about expansions, for example if player 1 and 2 have a tie on this turn for cell X and they both go for it, but player 1 also goes for a neighbor of cell X in same turn, will player 1 win? (@Veskah mentioned another scenario too) 4. I would suggest using JavaScript so more people can write and run the code (anyone with a browser can do it), also a controller with some helper functions could be nice, for example a function which returns expansion cost for a cell in an optimized way to avoid tens of different implementations for same common action. \$\endgroup\$
    – Night2
    Sep 14 '19 at 7:39
  • \$\begingroup\$ 5. "Bots have perfect information of the current state of the board.", does this include current energy value of other players? \$\endgroup\$
    – Night2
    Sep 14 '19 at 7:45
  • \$\begingroup\$ @Night2 1 Interesting. It seems a bit fiddly. 2 This should actually come out to a quadratic expansion rate since where you can expand to is derived from perimeter, which grows linearly. 3 All expansions are resolved simultaneously (as in Conway's Game of Life), so player 1 does not win that tie. 4 Javascript is the likely plan since I intend to have a significant graphical component. 5 I'll have to think about it. That could be rather interesting as 'private' information. \$\endgroup\$
    – Beefster
    Sep 15 '19 at 3:00
  • \$\begingroup\$ 6. Proposal to spice things up: board is randomly generated, with some cells being unavailable for expansion. Uniform random, Perlin/Simplex noise, cellular automaton-based cave generation, etc. 7. Will the bots have access to the turn counter? 8. Maybe rotate and/or mirror the board provided to the bots so that each bot starts at, for example, the top-left corner from its perspective? \$\endgroup\$
    – Alion
    Sep 15 '19 at 10:36
  • \$\begingroup\$ 9. Allow bots to pre-calculate some data on load or game start. This will allow people to speed up their bots. Especially useful if you end up implementing 6. \$\endgroup\$
    – Alion
    Sep 15 '19 at 10:47
  • \$\begingroup\$ @Alion 6 That sounds pretty interesting. I'll probably expand the board slightly in that case. 7 Yes, they'll know what turn it is. 8 I don't think that adds much. I'm probably going to have to make copies of the board every turn anyway to make it impossible to cheat on accident though... 9 Seems reasonable. \$\endgroup\$
    – Beefster
    Sep 16 '19 at 0:39
  • \$\begingroup\$ "Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer ... will be passed to the bot, which will be seedable in the controller.". Why not make a custom random function available or override the default random generator and make the controller generate and handle the seeds? For example in JavaScript users can still use the normal Math.random(), but you can use this to make it deterministic: davidbau.com/archives/2010/01/30/… \$\endgroup\$
    – Night2
    Sep 21 '19 at 11:21
  • \$\begingroup\$ @Night2, yeah. I'll probably do that since I'm going to have to use an RNG library anyway. \$\endgroup\$
    – Beefster
    Sep 22 '19 at 2:32

Turing-complete regex subset

It's widely known that a programming language is one iff it's capable of addition of natural numbers and primality testing. In practice, this criterion has a high accuracy for distinguishing Turing-complete languages too.[citation needed]

Cops' challenge

Choose any of the programming languages available on tio.run. Write a regex that will define a subset of this programming language. The subset must still match the definition, though ideally this should be far from obvious.

Write two programs in this language that match this regex:

  1. Take two natural numbers, a and b, as input. Output a + b. The program must work for 0 ≤ a + b < 215.
  2. Take a natural number n as input. Output whether the number is prime. The program must work for 0 ≤ n < 215.

The behavior outside of this range is undefined. This means that you can output the correct answer, a cute cat ASCII art, an error, an invalid answer, invoke nasal demons, or anything else you can, or cannot, imagine.

Regex come in multiple flavors. Choose one. You can choose any flavor available on regex101, or Retina.

In your answer, include:

  • the programming language and regex flavor you chose
  • the regex delimiter and flags you chose (for example: //gm; does not apply to Retina)
  • the regex you wrote and its byte count
  • the byte counts of your two programs

Keep the programs hidden. If 7 days pass without anyone cracking your answer, you may reveal your two programs by editing them into your answer. This will make your answer safe. Your score then becomes your regex's bytecount (lower is better). Before your answer is safe, your score is positive infinity.

Robbers' challenge

Write two programs that prove the subset to be a valid programming language. The rules that apply here are the same that apply to the cops. Additionally, your programs must not exceed the cops' in length.

When you crack an answer, post your programs to the robbers' thread.

Meta questions

The above will be posted as the cops' thread, with the robbers' thread simply linking to it.

  • Any improvements to challenge structure? I've never done this before.
  • Do you see any loopholes that need addressing?
  • Are the allowed regex flavors reasonable?
  • Duplicates?
  • \$\begingroup\$ I think this is a duplicate of codegolf.stackexchange.com/questions/136150/… \$\endgroup\$ Sep 22 '19 at 18:11
  • 1
    \$\begingroup\$ @pppery Hmm. These are definitely pretty similar. On the other hand, regexes might allow more interesting answers. \$\endgroup\$
    – NieDzejkob
    Sep 22 '19 at 18:25
  • 1
    \$\begingroup\$ I'm not convinced this is a dupe since most of the interesting work here is in selecting the regex rather than in choosing a sequence, though I think the other challenge is cleaner. I think the optimal scoring regex will usually be to make an "unhash" that produces the appropriate programs. Unfortunately I don't have any suggestions at the moment to help fix that, but if you can then I think this is alright. \$\endgroup\$ Sep 22 '19 at 18:32
  • \$\begingroup\$ @FryAmTheEggman I can't see what you mean by "unhash" here. Could you elaborate? \$\endgroup\$
    – NieDzejkob
    Sep 22 '19 at 18:36
  • \$\begingroup\$ Consider this program which performs the first task. The regex that matches only programs like this would be short but but not very informative. I think doing this but making guessing the magic number arbitrarily hard would usually be the best approach in a given language. \$\endgroup\$ Sep 22 '19 at 18:43
  • \$\begingroup\$ @FryAmTheEggman Like, /^\.vC\d+$/? I think that making it complicated enough would take quite a lot of bytes. \$\endgroup\$
    – NieDzejkob
    Sep 22 '19 at 19:02
  • \$\begingroup\$ The point is that the number could be manipulated, so I could pad my program arbitrarily until I got a number that let me write a regex like ^...(2|10|76|345?)*$. That's neither very long nor easy to crack. \$\endgroup\$ Sep 22 '19 at 19:06
  • \$\begingroup\$ I like the idea of the challenge but I feel including the bit about Turing completeness is a bit of a red herring, it only really distracts from the challenge. \$\endgroup\$
    – Wheat Wizard Mod
    Sep 22 '19 at 21:30
  • \$\begingroup\$ To elaborate the particular part I like is regex selection part. I do agree that my challenge is a bit cleaner otherwise. \$\endgroup\$
    – Wheat Wizard Mod
    Sep 22 '19 at 21:31

Calculate the Ultraradical

  • 1
    \$\begingroup\$ I'd recommend removing the text with a strikethrough; I think it is just confusing. "Accurate to 6 significant digits" isn't a very good validity criterion since it would require testing each and every possible input the program could handle. I'd recommend saying it has to be that accurate for your test cases but not be hardcoded for them, or something like that. \$\endgroup\$ Sep 19 '19 at 19:33


  • 1
    \$\begingroup\$ For the tiebreak, what does code with the fewest bytes mean, given that we're outputting a county assignment? \$\endgroup\$
    – xnor
    Oct 7 '19 at 22:24
  • \$\begingroup\$ @xnor - I modified the scoring mechanism to not require tie breaks. Thanks to this modification, I expect the code submissions to be much more interesting. \$\endgroup\$ Oct 8 '19 at 17:06
  • \$\begingroup\$ I like your new assignment score and no longer having a code golf tiebreak.The leave-one-out looks kind-of complicated and might take a long time to run-- is there a way to simplify it? The challenge looks a lot more intimidating that when I last commented, though the idea looks the same. I guess you want to make sure people actually write code that kind-of generalizes rather than possible finding an assignment by hand. Maybe also consider something with the standard deviation in assignment place of the max-min ratio so there's also an incentive to try to balance populations in the middle? \$\endgroup\$
    – xnor
    Oct 8 '19 at 22:48
  • \$\begingroup\$ @xnor - Great points, thanks! I simplified things by cutting the number of leave-one-out instances by a factor of 10. (I selected these 10 counties based on political geography considerations.) I also toned down the math speak to make the challenge less intimidating. I thought about standard deviation instead of max-min, but max-min is closer to how we enforce one person, one vote in practice. \$\endgroup\$ Oct 9 '19 at 2:20

I came across this little web game Drench Its a fairly mindless game , I wrote a small JS snippet to play this game for me in the background of my browser, it cycles through and clicks on the 6 possible moves

let ind =0;
let games =0;
let wins =0;
let lastMoves = "";
  if (jQuery('.moveNum').text() != lastMoves) {
    lastMoves = jQuery('.moveNum').text();
    ind = ind%6;
  } else {
    if ((jQuery('.moveNum').text()*1)) {wins++;}

This Strategy wins about 3% of the time My question is, is there a more optimal strategy that will allow me to win a greater % of the time (without looking at the board)?

  • 3
    \$\begingroup\$ Hi and thanks for using the sandbox! Though this is a bit unusual for this site, I think your question is on-topic, just far too broad. "Can I do better" just isn't something you can really ask on the SE network. I think the best way for you to move forward is to fully explain the game in the body of your post, and then score submissions based on their win percentage. \$\endgroup\$ Sep 21 '19 at 19:37
  • 1
    \$\begingroup\$ I really like the idea though - I think win% is the way to go \$\endgroup\$ Sep 23 '19 at 15:20
  • 1
    \$\begingroup\$ Make this a code-challenge? To verify, you can run it for, for example, 500 times and calculate the winning percent? \$\endgroup\$
    – null
    Oct 13 '19 at 8:49
  • \$\begingroup\$ Coded this up in p5.js, you can play it here hoppingmad9.github.io/dench Happy to convert it to pure js if needed and could add an interface to get the board state and input moves. \$\endgroup\$
    – Sam Dean
    Oct 18 '19 at 12:14
  • \$\begingroup\$ oops, well I guess the code golf version can be called "Dench" not "Drench". I thought "Dench" was a weird name \$\endgroup\$
    – Sam Dean
    Oct 18 '19 at 15:29
  • \$\begingroup\$ Probably needs a time limit for each turn to prevent people trying every single possibility of moves \$\endgroup\$
    – Sam Dean
    Oct 25 '19 at 15:39

Create a safe crossing.

Given a string/number/array of any two distinct characters make the "squarest" 2D array that allows "someone" to cross from left to right or top to bottom "stepping" only on whichever character you have chosen as your stepping stone


Make the "squarest" array possible that contains a complete row or column of stepping stone characters. (clearer but takes away the fun story-ness)

"squarest" meaning smallest difference between the dimensions of the 2D array.


  • A string/number/array of your choosing consisting only of your two chosen distinct characters. So no error checking needed. Allow true/false values if input is array?
  • input will have at least 1 stepping stone character so that a valid solution is always possible 1 by x or x by 1
  • a minimum length of x? needed? might make it easier if there's some weirdness with very short arrays in the algorithms people come up with
  • the last row can be incomplete to allow for prime number length inputs and to more easily allow non trivial 1xX/Xx1 answers


The output should be the dimensions of the array

  • and specify the row or column to use?
  • print your 2D array so that the path can be seen graphically?

Test Cases

100100100 -> 3x3 array


11111000 -> 4x2 or 3x3 - 3x3 is squarer so is correct

1111    111
1000    110

11000011000101001001 -> 5x4


1000000000000 -> 12x1 - trivial as only 1 stepping stone


010111 -> 3x2 or 2x3 - either acceptable as both are only "1" away from square

010    01
111    01

This is code-golf so the shortest code in bytes wins.


  • allow diagonal crossings? does that make it a lot harder?
  • need a lot more test cases I think?
  • input spec
  • output spec
  • better/more tags?
24 25
27 28

You must log in to answer this question.

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