

Sandbox FAQ







  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal





Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.


Get the Sandbox Viewer to view the sandbox more easily!


3369 Answers 3369

96 97
99 100

Posted to the main forum

  • 1
    \$\begingroup\$ We do have occasional fastest code challenges, and many of them get great answers. For objective scoring, (unfortunately) it is necessary to score it on your machine because the specifics of OS/CPU/RAM/storage device/whatever can change the relative run time of two programs. One suggestion is to use smaller test cases (reduce board size and number of ships) so that programs can be tested without waiting for hours. \$\endgroup\$ – Bubbler Dec 1 '20 at 10:01
  • \$\begingroup\$ I can, for instance. set up a Linux virtual machine for the tests. And yes, it is possible to parameterise so as to have a scale of complexity: highest complexity gives authoritative score but lower ones used for weeding. \$\endgroup\$ – user46773 Dec 1 '20 at 15:07
  • 1
    \$\begingroup\$ I'd suggest posting a valid board as the example and then a separate invalid one to illustrate that point. \$\endgroup\$ – Xcali Dec 3 '20 at 4:21
  • \$\begingroup\$ @Xcali - good point. I will do that. \$\endgroup\$ – user46773 Dec 3 '20 at 13:01

Play the percussion for Ravel's Boléro


The Boléro by Maurice Ravel is a piece of music characterised by a consistent snare drum pattern, repeated over and over, at unchanging tempo. This task is very challenging for a human performer, who must maintain the beat without rushing the tempo, or increasing the volume too quickly.

That's why you're going to write a program to do it!

I want your program to do something at the tempo and rhythm specified. It can output a key to a console, produce a beep, make a window pop up, have a graphical display flash colour; anything at all is acceptable, as long as it is A) observable to a human, and B) does not need human interaction for the program to continue. So if you make a pop-up, you should not require someone to click it away before the next pop-up can appear.

Using a tempo of 60 bpm (a bit slow but Ravel liked it played slowly), the whole rhythm takes exactly 6 seconds to play through. Here are the timings for when your program must send out some kind of signal, the unit being seconds. I'll tolerate divergences from the ideal of up to 0.02 seconds in either direction.


Note that here the final beat, at exactly 6 seconds, is the first beat of the next iteration of the rhythm; the next percussion hit occurs at 6.50, then 6.67, and 6.83, etcetera.

So, make your program produce that rhythm indefinitely. Choose whatever output you want. It's , so the shortest code wins!

For the sandboxers; I have considered using either this question as is, or having it be a popularity contest with added the stipulations that it ends after 170 repetitions and that the output somehow gradually gets intenser throughout that time, like the music does. The con is that popularity contests are a bit messier; but I would love to see creative ways to display the rhythm.

  • 1
    \$\begingroup\$ You should add an explanation for people who cannot read music; not everyone knows what a triplet is, or what bpm means. \$\endgroup\$ – Robin Ryder Dec 6 '20 at 13:50
  • \$\begingroup\$ @RobinRyder No knowledge of sheet music is needed; the picture is just illustrative. The list of timings is accurate. \$\endgroup\$ – KeizerHarm Dec 6 '20 at 15:29
  • \$\begingroup\$ The list of timings is accurate at 60 bpm, but not at other tempos. \$\endgroup\$ – Robin Ryder Dec 6 '20 at 16:16
  • 1
    \$\begingroup\$ @RobinRyder Very well, I will make 60 bpm the only accepted tempo and just have the timings be the final specification. \$\endgroup\$ – KeizerHarm Dec 6 '20 at 20:09

Simon says "Make me a game"

Forked from this closed question.

Create a "Simon says" game.

Take an input \$n\$, for number of levels, and \$k\$, for number of buttons and do the following:

  • Create a square area for the buttons.(at least 100x100 pixels in size.)

  • Divide it into k rectangular buttons of equal size. k will always be even.

  • Each button should be of a different color, and none of them should be the same color as the background.

  • The game should proceed as follows:

    • Starting level is 1. Level number should be displayed at the top.

    • Get a random order in which the buttons should "light up". The number of clicks should be level number + 4.

    • In that same sequence, display a visual indicator on each button, so the user knows what order they should click the buttons in.

    • There should be at least a 200ms delay between each visual indication.

    • If the user clicks them in the correct order, move on to the next level, and repeat the above steps. Otherwise, display "Game Over" at the bottom of the screen.

Here is a playable demo for k=4, Courtesy of Gabriele D'Antona.


  • Is this specification clear?

  • Any thoughts/feedback?

  • Should there be a limit on the values of n and k?


Animal-Alphabetical Sequence

  • 1
    \$\begingroup\$ Seems like a cool challenge except for the part where you have to start from the googolth element. I'd suggest starting from the beginning instead. \$\endgroup\$ – Beefster Dec 16 '20 at 17:51
  • \$\begingroup\$ Also, JAMBU won't appear anywhere in the output since none of the other animals have Js in them. Same for ZEBRA and maybe others. You might consider choosing different animal names, dropping your 5-letter theme, and ensuring that all 26 letters can possibly exist in the sequence. \$\endgroup\$ – Beefster Dec 19 '20 at 0:12

Answers made up from older answers

In this challenge, your task is to take a number as input, and determine whether it is the number of previous answers. For example, the third answer would print/return a truthy value is given 2, and a falsey value for any other input.

However, all answers must be made up of previous answers. For example, if the existing answers were +1, t()==1, and _=>inpu, some allowed answers would be:

  • t()==1+1
  • _=>input()==1+1
  • +1+1+1+1

Examples of answers that would not be allowed:

  • 1+
  • 1+1
  • _=>+1
  • (newline)

For the output/return format, this is a list of the allowed formats I'll use for this challenge.

Scoring and initial allowed parts of answers coming soon.


  • What should the title be?
  • Any recommended initial allowed parts?
  • Is this easy to read/understand?
  • \$\begingroup\$ This is understandable, and seems to make a fun challenge. You should probably restrict having the same language twice (although i'm assuming that's implied) because that would make it boring. The title could be like "Answer Recycling" or something, but I'm not very creative with titles. \$\endgroup\$ – Gio D Dec 27 '20 at 6:14
  • \$\begingroup\$ @GioD Oh, I forgot about that, I'll make sure to add that restriction. Thanks for the title suggestion, too! \$\endgroup\$ – Redwolf Programs Dec 27 '20 at 6:16
  • \$\begingroup\$ No problem, I just like the idea of recycling being used in a problem. Are people allowed to submit more than once? because this definitely seems like a fun challenge. My idea of a first program would just be "0" in retina, but that seems like it wouldn't make for a lot of creativity \$\endgroup\$ – Gio D Dec 27 '20 at 6:17
  • \$\begingroup\$ @GioD I'd probably just restrict posting more than one answer in a row. Glad to see there's some interest in this challenge! \$\endgroup\$ – Redwolf Programs Dec 27 '20 at 6:20
  • \$\begingroup\$ My idea for initial characters were "0", "1", " ", newline, and "=" although that might not work as well as I think it would. I'd recommend experimenting, since I'm fairly new to code golfing and i don't know most of the languages out there. \$\endgroup\$ – Gio D Dec 27 '20 at 6:30
  • 2
    \$\begingroup\$ I don't see how the parts list gets expanded with each answer. If it doesn't, how do different answers get created? \$\endgroup\$ – Xcali Dec 29 '20 at 3:07
  • \$\begingroup\$ @Xcali That's an issue I was thinking about, I think my solution will be allowing each answer to add one new part. For example, if the current parts are a, bc, and d, I could answer abcfdabc, so the new parts list would be a, bc, d, abcfdabc \$\endgroup\$ – Redwolf Programs Dec 29 '20 at 3:13

Implement ASCII -> GSM-7 (SMS) text packing

SMS messages can store 160 ASCII characters into 140 characters. It does this by chopping off the top bit from each byte and packing them together.

The simplified steps:

  1. Convert the string to binary little endian ASCII.
  2. Remove the top bit from each byte.
  3. Pack them together so there are no gaps.
  4. If applicable, pad the final byte with zero bits.

So, take the text "Test0123".

First, we convert it to little endian binary.

0x54     0x65     0x73     0x74     0x30     0x31     0x32     0x33
00101010 10100110 11001110 00101110 00001100 10001100 01001100 11001100

Then, we chop off the last (most significant) bit of each octet:

0010101  1010011  1100111  0010111  0000110  1000110  0100110  1100110

Then, we pack them together into a 7 byte array:

0xd4     0xf2     0x9c     0x0e     0x8b     0xc9     0x66
00101011 01001111 00111001 01110000 11010001 10010011 01100110

In the case of bitwise operations, it is a simple funnel shift.

The basic algorithm in C is here for an 8 byte ASCII string. However, your algorithm must accept any length.

void ascii_to_gsm7_8_bytes(uint8_t *buf, const char *str)
    buf[0] = (str[0] >> 0) | (str[1] << 7);
    buf[1] = (str[1] >> 1) | (str[2] << 6);
    buf[2] = (str[2] >> 2) | (str[3] << 5);
    buf[3] = (str[3] >> 3) | (str[4] << 4);
    buf[4] = (str[4] >> 4) | (str[5] << 3);
    buf[5] = (str[5] >> 5) | (str[6] << 2);
    buf[6] = (str[6] >> 6) | (str[7] << 1);

The input can either be a string (optionally with a provided length) or an input from stdin which is terminated with a newline or EOF.

The string will be a non-empty printable ASCII string that is 160 bytes or less. It is safe to assume that all bytes are 0x20 <= x < 0x80, meaning the last MSB bit is cleared beforehand.

Important: While strings can be null terminated, you are not allowed to use that null terminator for padding the last byte.

Output will be the packed string.

The output can either be printed as a list of values (base 10 or base 16) to stdout or returned in an output array.

Test cases (output is in hex):

Input text -> Output (hex)
"" -> Empty strings do not need to be handled.
"Úñíçódé" -> Unicode does not need to be handled, only ASCII.
"Hi!" -> {0xc8, 0x74, 0x08}
"Test0123" -> {0xd4, 0xf2, 0x9c, 0x0e, 0x8b, 0xc9, 0x66}

More test cases will be added if this is accepted.

This is , so the shortest code in bytes per language wins.

  • 2
    \$\begingroup\$ You should probably provide example input/outputs for so that it's easy for people to test their program and to get a grasp of what the program is asking. \$\endgroup\$ – Gio D Dec 27 '20 at 6:31
  • \$\begingroup\$ I updated the rules to make them more clear, removed the 140 byte requirement, and added an example and a few test cases \$\endgroup\$ – EasyasPi Dec 27 '20 at 22:10
  • \$\begingroup\$ 1. Bonuses to a score are generally frowned upon. 2. I'm confused about the output format. What is needed? 3. Why the null requirement added to the end? I don't see that in the SMS spec. 4. What's the winning criteria? \$\endgroup\$ – Xcali Dec 28 '20 at 17:47
  • \$\begingroup\$ Is this better? \$\endgroup\$ – EasyasPi Dec 28 '20 at 18:45

Isosceles triangle truncations

Most triangles are not isosceles. Here is an example:

A ____ C
 |   /
E|  /
 | /D

However, we can cut this triangle into two smaller triangles, one of which is isosceles. We can do this in a number of ways:

  • By cutting from C to E, we create isosceles triangle BEC. (Due to limitations of ASCII art, you'll just have to imagine that E is in the correct place.)
  • By cutting from A to D, we create isosceles triangle ADB.
  • By cutting from A to D, we create isosceles triangle ADC. (This always happens for right-angled triangles, of course. It's hard to draw ASCII art triangles that are neither right-angled nor isosceles.)

Each triangle can be derived in turn from the original triangle by fixing one of the three sides (which will be the base of the new triangle) and the smaller of the two adjacent angles, adjusting the other base angle as necessary.

Your challenge is, given a triangle of three points A, B and C in any reasonable format, is to output at least one of its isosceles triangle truncations.

It must be possible to obtain all three truncations for a given triangle. This is typically achieved by permuting the parameters of the function, but you can use some other input method if you wish. In any case please indicate how to obtain all truncations.

Example: For an input of (0, 0), (0, 4) and (8, 0), the output might be (0, 0), (4, 2), (8, 0); (0, 0), (0, 4), (4, 2); (3, 0), (0, 4), (8, 0). Alternatively, the output might just be (3, 0), and to obtain (4, 2) you would have to input the triangle in a different order.

You may assume that the input triangle is not isosceles (or equilateral, for those languages that allow parameters that are surds rather than floating-point decimals). For instance, for programs that normally output all truncations, they might simply return a single equilateral triangle unchanged.

Your method should be theoretically exact even if the code suffers from floating-point limitations.



possible chess moves in choice format

the goal is to make a function that takes in a board in choice format and color and outputs all possible moves.

for example: ['pawn',1,1] -> ['pawn',1,2], ['pawn',1,3].

  • \$\begingroup\$ Glad to see you took my advice and posted this here. I don't think fastest code is a good winning criterion - a queen on a central square has a maximum of 27 moves available to her, so even with 16 unrestricted queens (an impossible situation) a player would have 432 moves, which would be solvable instantly in most languages. I would suggest codegolf as a winning criterion \$\endgroup\$ – Level River St Jan 5 at 22:10
  • 1
    \$\begingroup\$ I suggest you develop this with: 1. full definition of input and output format 2. Consideration of the following: do we have to consider castling, double square advance for unmoved pawns, en passant? 3. Do we have to consider pawn promotion, and does promotion to different pieces (a queen or knight for example) count as a different move? 4. What pieces can a player be expected to have? a) the normal 16 at the start of the game, b) the normal 16 after some/all pawns have been promoted c) some more bizarre set of pieces? 5. Should moves leaving king in check be included / excluded from output? \$\endgroup\$ – Level River St Jan 5 at 22:17
  • 2
    \$\begingroup\$ Suggested input format: White pieces RNBKQ and P, black pieces rnbkq and p on an 8x8 grid. By the way welcome to the site. \$\endgroup\$ – Level River St Jan 5 at 22:18
  • \$\begingroup\$ I recommend you look through the existing chess questions and make this one sufficiently different. Here's a couple I've seen before (and answered one of them) but then forgot about codegolf.stackexchange.com/q/45179/15599 and codegolf.stackexchange.com/q/89429/15599 \$\endgroup\$ – Level River St Jan 7 at 16:19
  • \$\begingroup\$ Are chess libraries allowed? \$\endgroup\$ – Razetime Jan 8 at 10:55
  • \$\begingroup\$ @Razetime no, chess libraries are not allowed. \$\endgroup\$ – someone Jan 8 at 20:17

Divisor chains


A simple path in the divisor graph of {1,...,n} is a sequence of distinct numbers between 1 and n such that if k immediately follows m, then either k divides m or m divides k.


(1) Return a list of integers that represents the lexicographically earliest longest, simple path in the divisor graph of {1,...,n}.

Implement a named function with one argument, f(n), n a positive integer; you can assume n <= 33. The function takes the argument for input.

No print statements (or other I/O-statements) are allowed in the function; the return is a list (or tuple or array). The use of external library functions is not allowed.

(2) A print statement that prints the output of (1): print(f(n)). The function name print is not obligatory and the print function can use standard libraries.


(1) For n = 10 the call f(10) returns [4, 8, 1, 5, 10, 2, 6, 3, 9].

(2) print(f(10)). We do not fix the format of the returned list. The output might also look like 4 8 1 5 10 2 6 3 9 or any other convenient way.


This is code-golf with restricted-time, so the shortest code in bytes wins if it can run the test above on TIO https://tio.run/ without timing out. Only the code of the generating function f is counted, without the print statement.

Tags: code-golf, restricted-time, math, sequence


Lazy Robot Monkey Problem

Question Summary

You have made a robot monkey. The purpose of the robot is to move through the trees and try to reach as many as possible monkeys before running out of battery. You have to follow some rules while moving.

You are give a interlinked tree in the following format :

enter image description here

Here each 1 is a monkey and each 0 is an empty place.

Each note can have multiple parents and Childs but unlike a Graph its direction is downward.

The robot monkey has a initial energy value.

The robot Monkey can move through the nodes following certain rules:

  • Going up to the parent node needs 4 units energy.
  • Going down to the child node needs 2 units energy.
  • There may be some food at some nodes. Each times the monkey eats its energy increases by food value.
  • The monkeys energy can never be negative.
  • The monkey cannot eat more than the initial energy value.

What to do?

You are given the initial node (where your robot monkey is initially sitting).

The node is in the following format :

class Node:
    parents = [] # Will have all the parents
    children = [] # Will have all the children
    isMonkey = 1 # May be 0
    foodValue = 0 # May be anything

You are also given a initial food value and the number of monkeys in the tree.

You now have to find how many monkeys can you maximum meet with before your battery dies.(by going to the same position)

Your answer should be in format:

def monkeyMeet(initialNode, energy, totalMonkeys):
    # write your code here

Or in any other programming language.

The size of the tree may be huge.

  • 2
    \$\begingroup\$ Is this code golf? You need to have a way to have entries be compared (within a language). \$\endgroup\$ – xnor Jan 12 at 9:10

SimpleHearts KOTH


SimpleHearts is a four player trick-taking card game similar to Hearts, with a few simplifications. Hearts has several possible rule variations, and the rules I will use are outlined here.

For each game, each of the four players are dealt 13 of the cards in a standard deck. After that, there will be 13 "tricks", and during each trick the players will take turns playing exactly one of their cards. Each trick will consist of the following:

  • One player leads the trick by playing a card. The suit of this card is the "led suit". On the first trick the player with the 2 of clubs must lead with the 2 of clubs, on the following tricks whoever won the previous trick will lead.

    The leader may not lead a heart until another player has played a heart or the Qs (Queen of Spades). Exception: if the leader only has hearts in their hand, they may lead one of their hearts. The leader may lead the Qs at any time.

  • In a clockwise fashion, each player will take their turn playing one card in their hand of the led suit. If the player has no cards of the led suit, they may play any card. Exception: On the very first trick, no one after the leader may play a heart or the Qs, unless all of their cards are hearts or the Qs (obviously absurdly unlikely).

  • After all four players play a card, whichever player played the highest value card of the led suit wins the trick. Ace is highest value and 2 is lowest. The winner of the trick receives 1 point for every heart played by anyone in the trick, and 13 points if the Qs was played in the trick.

  • Repeat, with the winner leading the next trick.

The objective of the game is to receive as few points as possible. After all 13 tricks are played, the score of each player is the total number of points they took during gameplay. Important exception: if one player takes all possible points, i.e. the 13 hearts and the Qs, they receive 0 points and all other players receive 26 points (this is called "shooting the moon").

Key differences from standard Hearts:

  • There is no passing cards

  • Scores are not cumulative in the standard way (the scoring system of this particular challenge will be explained next).

Gameplay and Scoring

This is a KOTH challenge, meaning the objective is to create a bot (in this case a Python function) which will compete against other submitted bots in the game of SimpleHearts. All subsets of size 4 of the set of submissions will play against each other in N matches of 4 games each. For sandbox: N is tbd, should be as high as reasonably possible.

The dealing of the cards will be identical in each of the 4 games in a match, except rotated. For example, suppose the players are A, B, C, and D. In the second game player B will have the same hand player A had in game 1, C will have B's game 1 hand, etc. This is to reduce the impact of random chance, as one player being dealt a bad hand will affect all players equally in theory.

Each submission's final score will be the sum of their scores in all the games they played. The winner will be the submission with the lowest final score. In the case of a tie, the oldest submission will win.

Technical Requirements

Each submission will be a Python function (for sandbox: this is an arbitrary choice, is there a better one?) which takes as parameters:

  • A list of 2-tuples representing the cards in their hand. Each tuple will be of the form (12, 's') with the number representing the value of the suit and the string representing the suit, being one of s, h, d, c. For simplicity's sake the numbers are from 2 to 14, and we do not care about encoding "Queen" or "Ace". Therefore the Queen of Spades is (12, 's'), Ace of Diamonds is (14, 'd'), and the 2 of clubs is (2, 'c').

  • A list of 4 integers representing the scores of each player so far in the current game. The first element of the list is your score, then the player to your left, then the player across, then the player to your right.

    Note: leading with hearts is allowed if and only if you only have hearts, or someone has a nonzero score.

  • A list of 4 lists of tuples representing which cards have been played and by whom. The first list will be the cards you played, in order. The second list will be the cards played by the player on your left, in order. Etc.

  • A list of 0-3 tuples representing the cards that have been played in the trick, in order.

As output, the submission must return a single tuple representing a card in its hand, which is legal to play according to the rules of SimpleHearts. Of course, the function may choose to ignore any of these inputs but if it makes an illegal output, it is disqualified. In testing, I will force whoever has the 2 of clubs to lead with it on the first hand, ignoring the contents of the function.

The submission must be deterministic, i.e. will always produce the same output on the same input (so pseudorandom numbers with a set seed are allowed).

All submissions must be at most 100 000 characters.

The challenge will end 14 days after this prompt is posted, after which I will test all valid submissions against each other in the manner I described.

For sandbox

This prompt is still WIP, but I appreciate any comments. I intend to create a controller and some example submissions, but only after Sandbox folk deem the challenge to be good enough.

Is there any reasonable way to make the requirements easier or the game simpler? Cause this post is kinda long.

  • \$\begingroup\$ 1. You should probably forbid tampering with the environment/other bots. 2. You probably should clarify what happens if a bot throws an exception, and what happens during a disqualification (do the round with the disqualified bot simply not count or does a dummy bot come into play) 3. There is nothing wrong with a python function but it is worth noting that most koth competitions are either a JS function or a Java abstract class. 4. Also, it might be worth adding some sort of timeout for the bots. \$\endgroup\$ – Aiden4 Jan 20 at 18:25
  • \$\begingroup\$ So you're not playing with the rule that if one player wins all 124 points, then their score changes to 0 and the other players get 124 each instead? The risk there the most fun part of hearts! \$\endgroup\$ – pxeger Jan 21 at 10:06
  • \$\begingroup\$ @pxeger I'm not sure what you mean. I did mention shooting the moon, but what do you mean winning all 124 points? \$\endgroup\$ – 79037662 Jan 21 at 14:52
  • \$\begingroup\$ @79037662 I missed that because I've never heard it described as "shooting the moon". 124 is the sum of the available points in the scoring system I know (2+3+4+5+6+7+8+9+10+10(J)+10(Q)+10(K)+15(A)+25(QS)) \$\endgroup\$ – pxeger Jan 21 at 15:00
  • \$\begingroup\$ @pxeger In the standard ruleset, all hearts are worth 1 each and QS is worth 13 :) \$\endgroup\$ – 79037662 Jan 21 at 15:15

The UTM theorem

Let denote the set of natural numbers. Let A × B denote the Cartesian product of A and B. Let A ⇀ B denote the set of partial functions from A to B.

The UTM theorem says that there exists a computable function u : ℕ × ℕ ⇀ ℕ such that, for every computable function f : ℕ ⇀ ℕ, there exists a p : ℕ such that, for every x : ℕ, u(p, x) ≃ f(x). That is, there exists a universal computable function (analogous to the universal Turing machine).

Implement such a function in your language. Shorter is better.

Example: Python (57 chars)

lambda p,x:eval(p.to_bytes(p.bit_length()//8+1,'big'))(x)
  • \$\begingroup\$ Are you sure you can emulate a while loop in Python eval? \$\endgroup\$ – Bubbler Jan 19 at 6:33
  • 2
    \$\begingroup\$ Also, this has the same problem as your other sandboxed challenge in that eval does the job in many languages. \$\endgroup\$ – Bubbler Jan 19 at 6:41
  • \$\begingroup\$ @Bubbler It should be able to emulate (some variant of) the lambda calculus, which requires only pure functions. \$\endgroup\$ – user76284 Jan 19 at 7:05

Radical of an integer

The radical of an integer (written as \$\mathrm{rad}(n)\$) is defined as the product of all prime numbers that divide it. This it A007947.

For example, since \$ 504 = 2^3 \cdot 3^2 \cdot 7 \$, \$ \mathrm{rad}(504) = 2 \cdot 3 \cdot 7 = 42 \$.


Your task is to write a function or a program which takes a number as the input, and output its radical.

You don't have to handle any cases where the input isn't an integer or isn't positive (you don't have to handle 0).

Test cases:

504 -> 42
6 -> 6
57 -> 57
1024 -> 2
9 -> 3
1 -> 1

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

  • \$\begingroup\$ I think you can omit the "input/output in any base" part ("the output base must match the input base" is especially unnecessary) and let the answers use any sensible, consistent integer I/O as allowed in our defaults. Other than that, nice challenge. \$\endgroup\$ – Bubbler Jan 19 at 7:02
  • \$\begingroup\$ Suggested test case: 1 -> 1. \$\endgroup\$ – Bubbler Jan 19 at 7:03
  • \$\begingroup\$ What is the behaviour for negative numbers and zero? \$\endgroup\$ – pxeger Jan 19 at 11:15
  • \$\begingroup\$ @pxeger You don't have to handle any cases where the input isn't an integer or isn't positive (you don't have to handle 0). \$\endgroup\$ – Command Master Jan 19 at 12:16
  • \$\begingroup\$ @CommandMaster whoops, missed that \$\endgroup\$ – pxeger Jan 19 at 13:49
  • \$\begingroup\$ This is A007947, which describes it as "Largest squarefree number dividing n". \$\endgroup\$ – xnor Jan 20 at 10:27
  • 2
    \$\begingroup\$ Duplicate \$\endgroup\$ – caird coinheringaahing Jan 20 at 20:55
  • 1
    \$\begingroup\$ Dang, I should stop using built-in SE search for finding duplicates. \$\endgroup\$ – Bubbler Jan 21 at 0:24
  • \$\begingroup\$ @Bubbler I was pretty sure I recognized the challenge, it was xnor's comment that lead me to it (searched "squarefree number is:q") \$\endgroup\$ – caird coinheringaahing Jan 21 at 9:07

Cosmic ray hacking

Cosmic background radiation can cause random bit flips in electronics. For this reason, some mission-critical computers undergo radiation hardening. Your task is to use your magic bit flip gun to hack in to a program and make it print something different.

Cops' challenge

  • Write a program or function that outputs a determinate, non-empty string of your choice (which you should specify).
  • Choose a different, determinate string of your choice (which you should specify).
  • Also specify a number n which is the number of bit flips the robbers should perform on your answer in order to get it to output the second string.


Robbers' challenge

Choose an uncracked cop submission written by another user. Find a program that differs by exactly n bit flips from the original cop's program, and outputs the string s (where n and s are specified by the cop). First valid crack for each cop answer wins.


  • Your program must be written in the same language and version as the cop's
  • Your program must use the same I/O method as the cop's, unless they specify otherwise
  • Flipping the same bit twice (which does nothing to the whole string) is allowed, but it takes up 2 of your available bit flips.


Cops - Python 3, 8 bytes

Prints 5.


Using 1 bit flip, change this program to print 4.

Robbers - Cracks example answer


Because the ASCII digit 5 is 00110101, and 4 is 00110100 (the last bit has been flipped)


  • Should I change the scoring system?
  • This is related to , but I don't think it actually is. Is this right? Or maybe or would be better? (?)
  • refers to the limit that the cop imposes on the robber, rather than the scoring system - is this an acceptable use of the tag?
  • Is this clear enough?
  • Is this a duplicate of an existing challenge?
  • Any other feedback?
  • \$\begingroup\$ How are cops' answers scored? \$\endgroup\$ – the default. Jan 21 at 14:11
  • \$\begingroup\$ @thedefault. code-golf; it's in the cops' rules section \$\endgroup\$ – pxeger Jan 21 at 14:45

Write a Brainfuck compiler + decompiler!

Many Brainfuck compilers will convert to a different language instead of compiling directly.

Your job is to write not only a compiler in language X which compiles Brainfuck to the same language as the compiler, but also a decompiler which takes code compiled with said compiler and outputs equivalent Brainfuck.


  • No embedding the original/stripped source code or similar loopholes. You know what I mean.
    • Additionally, no outputting an interpreter with the original source code.
  • The compiler must accept whitespace and comments
  • Optimizations are allowed and encouraged, as long as you can convert these back to Brainfuck.
  • The input will always be a valid Brainfuck program
  • You are not required to print comments in the decompiler, however, excess comments and whitespace are allowed in the output as long as the program is valid. However, these lower your score. 🙂
  • You do not need to handle excess whitespace or comments in the decompiler, you can assume it was code directly generated by your compiler.
    • Therefore, it is also guaranteed to be valid code.
  • No executing the compiled code.
  • The compiler must generate correct code and run without any helpers.
    • You are allowed to be flexible with the cell size as long as it is at least 8 bits.
    • You are allowed to be flexible with the tape size as long as it is at least 30,000 elements. A wrapping tape is not required.
    • EOF can store either 0, -1, or leave unchanged

Your score will be the following:

(compiler size in bytes + decompiler size in bytes) × (compiled size of factor.bf in bytes ÷ size of factor.bf in bytes)

This is , so the most votes wins. This is because there can be some creative and boring solutions. Golfing is still encouraged.

  • \$\begingroup\$ Couldn't there be multiple BF programs that compile to the same "byte code" due to optimisations? \$\endgroup\$ – Adám Jan 20 at 14:38
  • \$\begingroup\$ Good catch. I added a note about that. I emphasized that you are decompiling YOUR code, and optimizations are not required, and if you do add optimizations, they must decompile to the same code (so basically, don't optimize if you want to win 😏) \$\endgroup\$ – EasyasPi Jan 20 at 14:41
  • 1
    \$\begingroup\$ Am I allowed to add hints in my code that identify what the original BF was? \$\endgroup\$ – Adám Jan 20 at 15:13
  • \$\begingroup\$ Hmm..yeah that is kind of difficult to rule out. I am going to change it to include the size of the code output in the score to discourage it. \$\endgroup\$ – EasyasPi Jan 20 at 15:18
  • \$\begingroup\$ So is the total score the size of the compiler plus the size of the decompiler? Can they be a single program doing both? \$\endgroup\$ – Adám Jan 20 at 15:21
  • \$\begingroup\$ Any restrictions on what target languages are allowed? \$\endgroup\$ – Adám Jan 20 at 15:22
  • 1
    \$\begingroup\$ So am I understanding it right that the compiler and the target language must be identical? \$\endgroup\$ – Adám Jan 20 at 15:22
  • 1
    \$\begingroup\$ Can the decompiler be a macro? Also, I know it's not recommended often, but this wouldn't be too bad as a popularity challenge. \$\endgroup\$ – user Jan 20 at 16:22
  • 1
    \$\begingroup\$ Should the cells be wrapping or not? \$\endgroup\$ – Aiden4 Jan 20 at 16:28
  • \$\begingroup\$ I don't think it's possible to support comments without embedding them into the code. \$\endgroup\$ – the default. Jan 21 at 4:31
  • \$\begingroup\$ I mean that your compiler must accept comments, but it is not required to preserve them. I also made some of the changes suggested in the comments \$\endgroup\$ – EasyasPi Jan 21 at 12:39
  • \$\begingroup\$ Can we have EOF as no change? That's a somewhat common way of handling EOF \$\endgroup\$ – Jo King Jan 23 at 5:03
  • \$\begingroup\$ Note that if it's too hard then it won't be popular anyway. (writing an optimizing compiler alone is a very difficult task, and who would read that?) \$\endgroup\$ – user202729 Jan 28 at 9:30
  • \$\begingroup\$ Still not quite understand about what "embedding" means here. The program translated / synthesized is required to include what the source code do. So it will always embedding the source code by some how. Is it valid if I simply replace +-<>[],. by 01234567 and then convert it back? May I simply submit a brainf**k (or bf variance) program say ,[.,]? \$\endgroup\$ – tsh Feb 5 at 2:32
  • \$\begingroup\$ Yeah I should try to clarify that. \$\endgroup\$ – EasyasPi Feb 5 at 2:36


This challenge was originally the "Among Us" challenge in the "Misc" category of YASCON CTF 2020. (The link includes an answer to that challenge. Click at your own risk.)

You're given a lot of files, only 1 of which is different from every other files. Your job is to find that 1 different file.


  • Input: the file names of all the files to be searched through.
  • Output: the name of the 1 different file.

Avoid burying the important details of your challenge in a mound of unimportant details. Be concise. Include what needs to be included.

It is guaranteed to have $n+1$ files, of which $n \ge 2$ files are the exact same, and 1 different file.

This is a . Least bytes wins.

Example Input and Output


1.txt 2.jpg 3.png 4.mp3


(3.png is different)


  • \$\begingroup\$ 'Answer the following questions for your readers . . . Avoid burying the important details of your challenge in a mound of unimportant details. Be concise. Include what needs to be included.' This is what you are supposed to do as the challenge writer, not part of the spec. \$\endgroup\$ – Dingus Jan 26 at 22:30
  • 1
    \$\begingroup\$ Do you have permission to repost this challenge here? \$\endgroup\$ – Dingus Jan 26 at 22:30
  • \$\begingroup\$ Well I got permission to upload the challenge and its files anywhere from that CTF, so yes. \$\endgroup\$ – John Zhau Jan 27 at 3:10

Create a playable, unbeatable Tic Tac Toe game

The challenge is to write the smallest possible Tic Tac Toe game where the opponent is an unbeatable AI. The requirements are as follows:

  • The opponent should be an unbeatable AI (self-playing opponent that can't lose)
  • The game should be able to detect win/draw/loss and end if this happens (without crashing)
  • The input should be the player move (square index or something like that)
  • The game should be able to handle invalid input and act appropriate if this happens (ask for input again)
  • The game must be displayed graphically on a classic 3x3 format with X:s, O:s and empty squares. The display should be in line vertically and horizontally, se below examples. The display needs to happen after at least every human move to be able to follow the progress.

As long as these conditions are fulfilled you are free to solve it in any way you'd like.

Rules of Tic Tac Toe: Each player (X and O) takes turn placing their marker on the 3x3 board. The game ends in a win if the player gets 3 in a row, loss if opponent gets 3 in a row, and draws if the board gets full.

Challenge winning criterion: Smallest code in bytes.

Example view of a valid input/output gameplay:

[' ', ' ', ' ']
[' ', ' ', ' ']
[' ', ' ', ' ']

Your move: 3
[' ', ' ', 'X']
[' ', ' ', ' ']
[' ', ' ', ' ']

[' ', ' ', 'X']
[' ', 'O', ' ']
[' ', ' ', ' ']

Your move: 6
[' ', ' ', 'X']
[' ', 'O', 'X']
[' ', ' ', ' ']

[' ', ' ', 'X']
[' ', 'O', 'X']
[' ', ' ', 'O']

Your move: 8
[' ', ' ', 'X']
[' ', 'O', 'X']
[' ', 'X', 'O']

['O', ' ', 'X']
[' ', 'O', 'X']
[' ', 'X', 'O']

Example of invalid gameplay (not horizontally or vertically in line and not using X and O as markers, which makes it hard to see what is going on):

Your move: 4
[, , ]
[0, , ]
[, , ]

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

Your move: 9
[1, , ]
[0, , ]
[, , 0]

Suggested tags: tic-tac-toe, code-golf

  • \$\begingroup\$ Good draft. Now you're well on the way to a properly specified challenge. Thank you for using the sandbox! \$\endgroup\$ – Adám Feb 2 at 7:45
  • \$\begingroup\$ I assume that by "graphically" you include e.g. text-based in a console. You might want to make that clear. \$\endgroup\$ – Adám Feb 2 at 7:45
  • \$\begingroup\$ Who makes the first move? \$\endgroup\$ – Adám Feb 2 at 7:46
  • \$\begingroup\$ Thanks, updated. I don't udnerstand what you mean with the text based comment though. I feel like this thing is getting worse than writing for some government, really killing the joy to be honest. \$\endgroup\$ – eligolf Feb 2 at 7:53
  • 2
    \$\begingroup\$ It is stricter than government writings; the latter can be vague and instead rely on the courts to disambiguate later. We don't have that luxury here. But while painful for the challenge writer, it is exactly what makes it enjoyable for the challenge answerer. I highly recommend that you answer a few existing challenges before attempting the, frankly monumental, task of writing your own. This will give you an appreciation for well-specified challenges. I've been here for years, and have an order of magnitude more answers than challenges, and yes, my early challenges were problematic too. \$\endgroup\$ – Adám Feb 2 at 8:00
  • \$\begingroup\$ Updated with tags and winning criterion \$\endgroup\$ – eligolf Feb 2 at 8:05
  • \$\begingroup\$ Suggested tags (remember that the max is 5): interactive, game, board-game, grid, ai-player. \$\endgroup\$ – Adám Feb 2 at 8:09
  • 2
    \$\begingroup\$ I'd suggest paring down this challenge to what I think is the most interesting part, making the unbeatable AI. That is, just require writing a function/program that takes in a single game state and outputs an optimal move, without needing to handle the game flow. \$\endgroup\$ – xnor Feb 2 at 20:28
  • \$\begingroup\$ @xnor, that could also be an idea! \$\endgroup\$ – eligolf Feb 3 at 5:00
  • \$\begingroup\$ @Adám, could I try that or xnors idea in the real questions thread now? \$\endgroup\$ – eligolf Feb 3 at 5:40
  • 1
    \$\begingroup\$ @eligolf I like xnor's idea, as game flow as already been done before, e.g. here. However, I generally recommend allowing at least a week in the sandbox (wait for a couple of upvotes here) since some people visit the site on a weekly schedule (e.g. only on weekends, or only during work). It's code golf ― what's the rush? If, after a week, you've not gotten enough feedback here, consider asking for more feedback in the chat room. \$\endgroup\$ – Adám Feb 3 at 6:57
  • \$\begingroup\$ I found a similar challenge: codegolf.stackexchange.com/q/152064/20260 \$\endgroup\$ – xnor Feb 3 at 7:26

Ratios to Ben Johnston's Notation

Given a just intonation ratio, express it as a note name in Ben Johnston's notation relative to C.

You can take your input as a rational number (if your language has a rational type) or as a pair of integers. You have to handle ratios with a prime limit of 19, or in other words, ratios whose prime factorizations don't contain any primes above 19.

Use the following characters for the accidentals:

+ - 81/80
# b 25/24
7 L 35/36
^ v 33/32
13 _13 65/64
17 _17 51/50
19 _19 95/96

Output them in the following order:

  • 7, ^, 13, 17, 19
  • #, b
  • L, v, _13, _17, _19
  • +, -

7, 13, 17, and 19 should be separated by commas when they occur adjacently in order to avoid ambiguity.

Test cases:

1/1 -> C
2/1 -> C
3/2 -> G
4/3 -> F
5/4 -> E
5/3 -> A
6/5 -> Eb
7/4 -> B7b
7/5 -> G7b
9/5 -> Bb
9/8 -> D
10/9 -> D-
11/8 -> F^
16/9 -> Bb+
17/16 -> C17#
21/16 -> F7+
25/24 -> C#
32/27 -> Eb-
34/19 -> A17_19#
78/77 -> C13Lv
81/64 -> E+
160/147 -> C#LL-
323/280 -> D17,19L-
416/405 -> D13bb-
441/440 -> Db7v+
1029/1024 -> Db777+
6144/6125 -> CbLL-
531441/524288 -> B#+++
4194304/4117715 -> A#LLLLLLL---
  • \$\begingroup\$ Same issue as the other challenge, I didn't read the link and the question is not self-contained. \$\endgroup\$ – user202729 Feb 8 at 2:42

Find all enharmonic equivalences of an arbitrary EDO

Given integers n and s, print all pairs of enharmonically equivalent pitch classes in n-EDO, such that each note of a pair has at most s sharps and flats.

Note names are assigned such that F, C, G, D, A, E, and B form a chain of n-EDO's best approximation to 3/2 (that is, \$n \log_2(3/2)\$ steps, rounded to the nearest integer, or the "fifth"). "#" adds seven fifths, and "b" subtracts seven fifths; you can have as many of one as you want or none at all. (Note that in some EDOs, such as 24, there are some pitches that can't be written with only sharp and flat accidentals.)

Note that C# = Db means the same thing as Db = C#. Your code should output only one of these, but which one you output is up to you.

Be prepared to handle these situations:

  • # and b might not raise or lower the pitch
  • # might lower the pitch
  • E and F might be the same note
  • F might be lower than E

Your code should work for at least all integers n in [1, 200] and all integers s in [0, 50].

Test output

(12, 1)

F# = Gb
Fb = E
F = E#
C# = Db
Cb = B
C = B#
G# = Ab
D# = Eb
A# = Bb

(19, 1)

Fb = E#
Cb = B#

(19, 2)

F# = Gbb
F## = Gb
Fbb = E
Fb = E#
F = E##
C# = Dbb
C## = Db
Cbb = B
Cb = B#
C = B##
G# = Abb
G## = Ab
D# = Ebb
D## = Eb
A# = Bbb
A## = Bb

(22, 2)

Fbb = C#
Fb = C##
F## = Bbb
Cbb = G#
Cb = G##
Gbb = D#
Gb = D##
Dbb = A#
Db = A##
Abb = E#
Ab = E##
Ebb = B#
Eb = B##

(31, 3)

Fbbb = D#
Fbb = D##
Fb = D###
F## = Abbb
F### = Abb
Cbbb = A#
Cbb = A##
Cb = A###
C## = Ebbb
C### = Ebb
Gbbb = E#
Gbb = E##
Gb = E###
G## = Bbbb
G### = Bbb
Dbbb = B#
Dbb = B##
Db = B###

(32, 3)

F## = Dbbb
F### = Dbb
Fbbb = A#
Fbb = A##
Fb = A###
C## = Abbb
C### = Abb
Cbbb = E#
Cbb = E##
Cb = E###
G## = Ebbb
G### = Ebb
Gbbb = B#
Gbb = B##
Gb = B###
D## = Bbbb
D### = Bbb

(53, 4)

F#### = Dbbbb
Fbbbb = A###
Fbbb = A####
C#### = Abbbb
Cbbbb = E###
Cbbb = E####
G#### = Ebbbb
Gbbbb = B###
Gbbb = B####
D#### = Bbbbb

(5, 0)

F = E
C = B

(7, 1)

Fb = F
Fb = F#
F = F#
Cb = C
Cb = C#
C = C#
Gb = G
Gb = G#
G = G#
Db = D
Db = D#
D = D#
Ab = A
Ab = A#
A = A#
Eb = E
Eb = E#
E = E#
Bb = B
Bb = B#
B = B#

(9, 1)

Fb = G
F = G#
Fb = A#
F# = Eb
Cb = D
C = D#
Cb = E#
C# = Bb
Gb = A
G = A#
Gb = B#
Db = E
D = E#
Ab = B
A = B#

(11, 1)

F# = Db
Fb = A
F = A#
C# = Ab
Cb = E
C = E#
G# = Eb
Gb = B
G = B#
D# = Bb

(13, 1)

F# = Cb
Fb = B
F = B#
C# = Gb
G# = Db
D# = Ab
A# = Eb
E# = Bb
  • \$\begingroup\$ I think most people prefer that questions should not include background knowledge that not most people know without explanation. \$\endgroup\$ – user202729 Feb 3 at 0:58
  • \$\begingroup\$ Do you have any ideas about reducing the amount of background knowledge required and making the question more accessible? \$\endgroup\$ – bb94 Feb 3 at 1:49
  • \$\begingroup\$ I didn't read it... \$\endgroup\$ – user202729 Feb 3 at 1:51

Implement bottom (encode)

  • \$\begingroup\$ The general policy is to provide an explanation for concepts that most people don't know inside the question itself. [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 3 at 14:02
  • \$\begingroup\$ @user202729 Is this better? \$\endgroup\$ – Orangutan Feb 3 at 17:58
  • \$\begingroup\$ Suggested test case: invalid utf8, invalid surrogate, empty string, some char with unicode value > 0x10000, combined emoji, combining mark in unicode. \$\endgroup\$ – user202729 Feb 3 at 23:22
  • \$\begingroup\$ Generally people don't like things like "must take input on stdin, must take output on stdout, must take input in UTF8 encoding, must check for invalid UTF8, must return exit code 1". You can still keep it, but I did warn you. \$\endgroup\$ – user202729 Feb 3 at 23:28
  • \$\begingroup\$ I removed the full program requirement and the UTF-8 validation so there also shouldn’t be any need for an exit code. I also added some more test cases and a rule on an empty string \$\endgroup\$ – Orangutan Feb 4 at 2:16
  • \$\begingroup\$ Since I don't have emoji font installed, you can include a textual explanation on the input/output pairs. (like AB (byte value: 65, 66) -> 50, 10, 5, byte-separator, 50, 10, 5, 1, something like that) \$\endgroup\$ – user202729 Feb 4 at 2:18
  • \$\begingroup\$ I'm not sure how much this would help as you still need the endpoints/emoji in the source. Maybe having an emoji font installed isn't too strict of a requirement? If you still want to test would string comparisons work? That way you don't even need to look at any of the outputs, just see if tests pass \$\endgroup\$ – Orangutan Feb 4 at 11:43
  • \$\begingroup\$ It's recommended that you delete the sandbox post and edit it into a link to the main post after you post it. \$\endgroup\$ – user202729 Feb 4 at 14:19
  • \$\begingroup\$ By the way, the sandbox FAQ recommends that people leave posts in the sandbox for at least 72 hours (apparently nobody reads that?) \$\endgroup\$ – user202729 Feb 4 at 14:19

Is the Skat null game safe? [WIP]

For everyone who knows the card game Skat. Did you ever wondered when playing a null game: is this really safe to win regardless the other player cards? Well, let's try to solve this question with code.

The Skat game

Skat is card game with 32 cards. There are four colours: Diamonds ♦️, Hearts ♥️, Spades ♠️ and Clubs ♣️. Each colour has: Ace, King, Queen, Jack, 10, 9, 8 and 7. Three players are playing, so each one get 10 cards. The remaining two cards are called Skat and remain covered. Before each game it is to decide which of the three players plays alone against the other two which play together. The alone player gets the possibility to exchange one or two of his cards against one or two of the covered cards in the Skat. More about Skat can be read on Wikipedia.

The null game

There are times when get so bad cards, i.e. no Aces and no Jacks, that they will indeed really good, namely when you can't make any points, not even a trick with the cards.

The task

Write a program that will determine if an input of ten cards of the 32 cards will guarantee that the player will win the null game, i.e. the player won't get any tricks regardless how the other 22 cards are distributed for the other two players and whether or not the alone player is in forehand. You can assume any reasonable input and output that suits you. For convenience a reasonably sorting of the cards can also be assumed.

One note to the forehand rule: it is assumed that the alone player wants to win so he or she won't sabotage the game with drawing an Ace or similar high cards.

Test cases

Let's assume an array of two character strings where the first represents the colour (D for Diamond, etc.) and the second the value (7, 8, 9, X, J, Q, K, A) E.g ['D7','D8','D9','H7','H8','C7','C8','CX','CQ','CA'] will result in true indicating that this null game cannot be lost.

[more to come]

This is code-golf so the shortest code wins.

  • 1
    \$\begingroup\$ (you didn't specify what's the condition for winning in the game...) \$\endgroup\$ – user202729 Feb 7 at 16:11
  • 1
    \$\begingroup\$ I enjoy playing Skat, so this challenge looks promising even though it still misses some important parts in order to be accessible for people who have never heard about Skat. For the sake of simplicity (as the challenge already looks rather hard) I'd suggest to drop the forehand part (and assume one of the opponents plays first). Otherwise it needs to be specified which cards are allowed to be played. \$\endgroup\$ – Laikoni Feb 15 at 22:33
  • \$\begingroup\$ Thanks for the comments. Will try to find some time for improving this. \$\endgroup\$ – jmizv Feb 19 at 9:14

Colorize a diff, unified format

  • \$\begingroup\$ Print to stdout? What about displaying it on the screen or write an image? (you know there are standard output formats... \$\endgroup\$ – user202729 Feb 5 at 17:11
  • \$\begingroup\$ @user202729 They will print to stdout with ANSI escape sequences, I have edited my question. \$\endgroup\$ – Deadbeef Feb 5 at 17:16
  • \$\begingroup\$ (just noticed that you're a new user. Anyway) people generally don't like restrictive input/output format. (codegolf.meta.stackexchange.com/questions/2447/…) And the command-line parsing appears to be unrelated to the challenge (except making it "looks like a typical Unix tools") \$\endgroup\$ – user202729 Feb 6 at 0:38
  • 1
    \$\begingroup\$ @user202729 I agree, I changed it so it doesn't have the restriction anymore \$\endgroup\$ – Deadbeef Feb 7 at 2:42
  • \$\begingroup\$ you may want to ban usage of git tools from shell for this challenge. \$\endgroup\$ – Razetime Feb 8 at 2:52
  • \$\begingroup\$ @Razetime "Do X without Y" (including banning built-ins) is not recommended. Boring answers will usually be downvoted anyway. \$\endgroup\$ – user202729 Feb 8 at 11:46

Catch the fruit (Abandoned)

I feel that this is too complex to be a good code-golf question, and has too many things to specify for it to be anywhere near serviceable. Anybody willing to make this idea into a proper question can do so.

Implement a osu!catch style game.


osu!catch is a rhythm game where the player moves a "basket" to catch "fruits" falling from the top of the screen to the beat of a song. Think pong, but with timing.

It is highly recommended to watch this video before reading the question.

Here's a gameplay example from Bubbler: [osu!catch] Hitsuji to Ojisan - XENO [Spec's Overdose]


You are required to take the following inputs:

  • Time: How long your program is supposed to run.

  • Approach Rate: This is the speed at which the "fruits" are supposed to fall down.

  • Beatmap: An array of [time, x position, value] triplets where:

    • Time: you must support time in seconds, at the very least. Higher precision is encouraged.
    • X position: Where it will fall from.
    • Value: The size of the "fruit" will decrease with it's value.


Play area

  • The canvas must be in a 4:3 aspect ratio.
  • The score must be displayed at the top of the screen, in the middle. You do not need to align it.
  • The score starts at 0.
  • Use a dark background(#222222, preferably).

The player

  • The player must be of a rectangular shape, white in color.
  • Height: 1/50 of canvas height, Width: 1/6 of canvas width.
  • The player must be at the bottom of the screen, movable using any two keys of your choice.
  • The player must have a "dash" button. Their speed must increase 0.5x when they hold the dash button.
  • When the player collects a fruit, it must disappear, and it's value must be added to the score.
  • When the player misses a fruit, there should be an indicative visual cue where the fruit fell.(a small red square, preferably)
  • The player must be constrained within the canvas.


  • Fruit must be square in shape, and red in color.
  • Fruits must fall from the top of the screen, outside the viewport(unless unsupported).
  • Max fruit size is 0.1 × height. Size scales inversely with value.
  • Fruit speed must be related to the approach rate i.e. Higher approach rate must make the fruits fall faster. You may do this however you like, but please be reasonable.
  • The lower edge of the fruit must touch the bottom of the screen at it's time value.


This is . Shortest answer in each language wins.


  • Is the specification simple enough?
  • I am planning on making a separate challenge for this. Is that a better idea?
  • Is the specfication clear?
  • Any further feedback?
  • \$\begingroup\$ You most likely already have this in mind, but you can add the game tag. Also, I think you should not leave too many stuff to the golfers, as they could do anything with the oppurtunities (e.g they could just increase the speed by 0 by pressing the dash button). What happens when the player goes outside the canvas? \$\endgroup\$ – SunnyMoon Nov 18 '20 at 20:50
  • \$\begingroup\$ @SunnnyMoon Good points. I've changed those things, and I'll proofread it again to see if there are any more mistakes. Thanks a lot. \$\endgroup\$ – Razetime Jan 28 at 2:48

Which Ninjutsu am I casting?


  • 1
    \$\begingroup\$ Bad title considering that validation is the smallest part of the challenge, but it looks pretty good otherwise \$\endgroup\$ – Unrelated String Feb 9 at 12:58
  • 1
    \$\begingroup\$ @UnrelatedString I changed the title. \$\endgroup\$ – SjoerdPennings Feb 9 at 13:08
  • \$\begingroup\$ (note that it's recommended (in the sandbox FAQ) to leave sandbox posts for at least 72 hours. \$\endgroup\$ – user202729 Feb 11 at 6:31

Trilobaccis' speed

The challenge is inspired by this beautiful one: Speed of Lobsters. And it's similar to this other one: Is it a lobster number?.

The word Trilobacci is a blend of Tribonacci and Lobster.

About tribonacci, quoting Wikipedia:


Regarding lobsters and speed, they refer to this subreddit where people have fun editing the text of images to create new phrases.

The challenge

The challenge is to "blank out" the digits of given numbers (let's say a,b,c) using the digit of other numbers (say x,y,z) which you have to find by yourself, and then tell whether you could use all the digits from x,y,z to blank out some (or even all) of the digits from a,b,c.

Being more specific: given three positive integers in ascending order, which are necessarily part of a tribonacci sequence (at least the one they can generate), find the three numbers that generated the sequence and use them to blank out the original input numbers according to the lobsters rules.
Then output a truthy value if you used all the digits from the found numbers, or a falsy value if you are left with digits that couldn't be used to blank out the input digits.

For the numbers generating the sequence, I mean the the three smallest non-negative integers being part of the sequence.

Lobsters rule!

Start taking the first digit of the first number of x,y,z and blank out its first occurrence in the digits of a,b,c. Then proceed with the next digit from x,y,z looking for its first occurrence in a,b,c, starting from where you left.



[ 13, 23, 43 ]

you'll find out that they are part of a sequence generated by

[ 1, 3, 3 ]

so then you can proceed at the speed of lobsters:

[ 1, 3, 3 ]   --->   [ 13, 23, 43 ]
              \  /
[ X, 3, 3 ]   --->   [ *3, 23, 43 ]

[ X, X, 3 ]   --->   [ **, 23, 43 ]

[ X, X, X ]   --->   [ **, 2*, 43 ]

And in this case you output a truthy value because you used all the digits from [ 1, 3, 3 ].

The numbers [ 903, 1661, 3055 ] are also generated by [ 1, 3, 3 ], but the output for them is a falsy value:

[ 1, 3, 3 ]   --->   [ 903, 1661, 3055 ]
              \  /
[ X, 3, 3 ]   --->   [ 903, *661, 3055 ]

[ X, X, 3 ]   --->   [ 903, *661, *055 ]

[ X, X, 3 ]   --->   [ 903, *661, *055 ] can't find any 3 after the last blanked digit


Three integers. (One by one, into an array, as one or more a strings, split like bananas, etc.)
You can even take them in descending order if like.


Choose a truthy and a falsy value and be consistent with them.

Standard rules apply for your answer, with standard I/O conventions, while default Loopholes are forbidden.

It would be nice if you could provide an easy way to try your program and possibly an explanation of how it works.

This is , the shortest wins.

Test cases



  • Any feedback / suggestion?
  • I thought about considering the digits of x,y,z as always, but blanking out their occurrence in a,b,c from right-to-left, so that who participated to the previous lobster challenges would have to renew this part of the answer. Do you think it would be a good thing?
  • 1
    \$\begingroup\$ Nice challenge, maybe a bit convoluted but I like it. I'd mention somewhere that the numbers in a tribonacci sequence need to all be positive, otherwise for example [1,3,3] could come after [-1,1,3] and there would be no beginning. I believe going left-to-right or right-to-left in the last step does not make any difference, if one of them is possible the other one will be as well \$\endgroup\$ – Leo Feb 10 at 5:30
  • \$\begingroup\$ @Leo I am going to highlight "For the numbers generating the sequence, I mean the the three smallest non-negative integers being part of the sequence." And I'll specify that the input is positive. Regarding the right-to-left, thing, I expressed it so badly: I meant considering the digits of x,y,z LtR as always, but blanking their occurrence in a,b,c in RtL direction. Since you are already finding the sequence in reverse, it could make sense to rename the challenge like Retrolobacci and do the LtR thing, but I don't know. \$\endgroup\$ – Sheik Yerbouti Feb 10 at 11:25
  • 1
    \$\begingroup\$ Oh, sorry, I had missed the part about non-negative integers! To make it completely dumb-proof (read: Leo-proof) you could add a "positive" also to the input description section. Also, some people will probably want to take the input numbers backwards, I don't know if this is already a default but it may be worth explicitly allowing it in the text. I think Trilobacci sounds better than Retrolobacci, but other than that I have no opinion on LtR vs RtL :) \$\endgroup\$ – Leo Feb 10 at 22:07
  • \$\begingroup\$ @Leo I added the backward input, thank you! I don't like Retrolobacci either, it could be "Trilobaccis' speed, when running backwards", maybe too long but somehow funny. \$\endgroup\$ – Sheik Yerbouti Feb 10 at 22:23


Print all the Tamil characters in any order you like. They should be 12 vowels, 18 consonants and the special symbol ஃ .

Your code should not print anything except for those letters but it can print one letter per line.

The consonants are: க் ங் ச் ஞ் ட் ண் த் ந் ப் ம் ய் ர் ல் வ் ழ் ள் ற் ன்

The vowels are: அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ

Shortest code wins

  • 1
    \$\begingroup\$ @user Done. I hope it helps. \$\endgroup\$ – Anush Feb 11 at 14:59
  • \$\begingroup\$ There isn't really a point in doing this: 31 bytes, copy-paste the letters. \$\endgroup\$ – fasterthanlight Feb 11 at 21:19
  • \$\begingroup\$ @fasterthanlight if you add the print statement do you think you won’t be able to do any better? Also, how would you do it in C for example? \$\endgroup\$ – Anush Feb 11 at 21:25
  • \$\begingroup\$ I don't specialize in C. For example, in O5AB1E, you can just do ,"க் ங் ச் ஞ் ட் ண் த் ந் ப் ம் ய் ர் ல் வ் ழ் ள் ற் ன் அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ ஃ in 33 bytes, excluding spaces \$\endgroup\$ – fasterthanlight Feb 11 at 21:30
  • \$\begingroup\$ @fasterthanlight and no more compact way to go over the relevant Unicode characters? \$\endgroup\$ – Anush Feb 11 at 21:32
  • \$\begingroup\$ @fasterthanlight what about if I changed it to printing all the Unicode Tamil symbols? \$\endgroup\$ – Anush Feb 11 at 21:35
  • \$\begingroup\$ Could you also include the Unicode codepoints of the characters? I think that would make it easier for solvers to consider strategies for generating them. \$\endgroup\$ – xnor Feb 11 at 22:40
  • \$\begingroup\$ @xnor yes I will do that. Do you think 31 characters is too few for it to be interesting? \$\endgroup\$ – Anush Feb 12 at 8:39
  • 1
    \$\begingroup\$ @Anush I think it depends how the code points are distributed, whether they're not too random or too ordered. \$\endgroup\$ – xnor Feb 12 at 21:12

Generate a "Pi-ey" number

Generate the smallest integer of the form \$x^x\$ with \$10^{n-1}\cdotπ\$ digits, rounded down, given \$n\$. If there is no such number, take the nearest number that has as many digits of \$π\$ in its digit count. For example, if \$n=5\$, then the number of digits would be 31415. If there was no such number of form \$x^x\$, then take the nearest digit count similar to 31415, like 31414 and 31416.

If there are multiple values of \$x\$ that will work, whichever one is closer to \$3.1415926e3141...\$ will be the chosen value. For instance, if two solutions for \$n=5\$ were \$1.234e31414\$ and \$1.234e31416\$, we would select the former, as it is closer to \$3.1415926...e31415\$.

Test cases:

Glitchy picture


  • Shortest amount of bytes of code wins
  • Please post the number of bytes as well as the runtime for \$n=5\$.
  • It is recommended that you post your score (below), but is not required.


  • Your score will be based on your program time and length. \$\text{score} = \text{program length in bytes} + 10 \times \text{time to execute in seconds}\$
  • \$\begingroup\$ The first paragraph seems unclear to me. For the \$n\pi\$ digits, do we round that down, or to the nearest integer? The second sentence seems a little unclear as well, do you mean to find the number that's closest to having \$n\pi\$ digits? If so, if there are multiple (let's say \$1.1234e313\$ and \$1.1234e315\$), which one should be chosen? \$\endgroup\$ – Redwolf Programs Feb 11 at 21:20
  • \$\begingroup\$ @RedwolfPrograms For the \$n\pi\$ digits, round down. For you second question, if \$n=5\$, you would find the closest number of form \$x^x\$ with 31415 digits. If there is no such number, with 31415 digits, then find the nearest number with a digit count closest to 31415 (i.e. 31414, 31416, etc). To answer your last question, the number that is closer to \$3.141926535...e314\$ will be selected if there are multiple. \$\endgroup\$ – fasterthanlight Feb 11 at 21:24
  • \$\begingroup\$ I'd recommend editing that into the post, when you include that information it's much more clear. Also, you might want to put the test cases in as text rather than an image to make them easier to copy-paste. Other than that, it looks clear to me, but I'd wait a day or two to make sure nothing else is unclear. (Don't worry, it's way better than my first post :p) \$\endgroup\$ – Redwolf Programs Feb 11 at 21:28
  • 1
    \$\begingroup\$ Program length plus time in what? Seconds? On what machine? Combining length and speed in this way is very sensitive to how the speed is measured. Taking a step back, getting this tradeoff to be balanced and interesting for golfers is very hard, possibly impossible across a wide range of languages of varying golfiness and speed. I'd strongly recommend against this, especially for your first challenge. I think either code-golf or fastest-code would be better. \$\endgroup\$ – xnor Feb 11 at 22:09
  • \$\begingroup\$ @xnor I have changed my post so that it will be easier, with point bonuses as needed \$\endgroup\$ – fasterthanlight Feb 11 at 22:20
  • 2
    \$\begingroup\$ @fasterthanlight Bonuses have fallen really out of favor with the community. Including this many large bonuses is virtually guaranteed to get your challenge downvoted. \$\endgroup\$ – xnor Feb 11 at 22:22
  • \$\begingroup\$ Thanks for moving your post to the sandbox. I generally agree with xnor that trying to score in this way is ill-advised, but if you want to continue with it you should decide for which values you will test the speed. In addition, assuming I am understanding correctly, the output is the full value \$ x^{x} \$. I think it is possible that an efficient answer will spend more time printing out this number than it would take to calculate it, which seems to somewhat defeat the purpose. \$\endgroup\$ – FryAmTheEggman Feb 12 at 0:27
  • \$\begingroup\$ @FryAmTheEggman So how can you tell when a program is done calculating something? \$\endgroup\$ – fasterthanlight Feb 12 at 1:28
  • \$\begingroup\$ Ah, sorry I meant to suggest that just asking for \$ x \$ should solve the problem. \$\endgroup\$ – FryAmTheEggman Feb 12 at 3:50

Compute the analysis spectrum

This is based on a task I had in work a few years back.

A diode-array detector (DAD) is a kind of chromatography detector which fires light into a sample and detects the strength of the light that passes through it at different wavelengths. From this you can determine, among other things, the contents or the purity of the sample.

Most detectors can only detect on one wavelength. A DAD however can scan across a spectrum of wavelengths, typically from 190nm to 650nm. From that spectrum we can then pick out the wavelengths that we're interested in. Maybe for our sample we want to analyse it at wavelengths 300nm, 350nm, and 550nm. These are called 'channels'.

Each wavelength may also have a bandwidth across which the signal strength is averaged. If we have analyse on wavelength 420nm, with a bandwidth of 10nm, the range for that channel would be from 415nm to 425nm (5nm lower, 5nm higher than the base wavelength). However, this bandwidth is optional.

The DAD we'll be working with does not take a set of channels, but rather we must provide it with a minimum wavelength and a maximum wavelength to detect across. This will be our task.

The Challenge

Write a program or function that, when given a collection of channels, determines the lowest and highest wavelength to analyse across for these channels.

For this challenge, a channel consists of an integer wavelength, and an optional integer bandwidth. The wavelength can be positive or negative, but the bandwidth is always positive.

Bandwidths can be odd numbers, but in that case you would then shrink it down to an even number.

The upper limit can be the same as the lower limit, but can never be smaller.

Also, you can safely assume that at least one channel is given to your code.

Example 1

Channel 1
Wavelength = 420
Bandwidth = 10

For channel 1, the base wavelength is 420 and the bandwidth is 10.

Channel 1's lower range is the base wavelength minus half of the bandwidth. In this case, it's 420 - (10 / 2) = 415. The upper range is the base wavelength plus half of the bandwidth: 420 + (10 / 2) = 425.

Answers: Lower = 415, upper = 425

Example 2

Channel 1
Wavelength = 394
Bandwidth = 19

Channel 2
Wavelength = 500
Bandwidth = N/A

For channel 1, the base wavelength is 394 and the bandwidth is 19. Because the bandwidth is an odd number, and our DAD cannot accept floating-point numbers, we can round it down to 18.

Channel 1's lower range is the base wavelength minus half of the bandwidth. In this case, it's 394 - (18 / 2) = 385. The upper range is the base wavelength plus half of the bandwidth: 394 + (18 / 2) = 403.

Channel 2 has no bandwidth, so it's range is just at its base wavelength: 500.

Comparing the channel ranges, channel 1 has the minimum lower limit with 385. Channel 2 has the maximum upper limit, with 500.

Answers: Lower = 385, upper = 500

Test cases

Test case 1:

Wavelength 1 = 400
Bandwidth 1 = N/A

Answers: lower = 400, upper = 400


Test case 2:

Wavelength 1 = 200
Bandwidth 1 = 15

Answers: lower = 193, upper = 207


Test case 3:

Wavelength 1 = 394
Bandwidth 1 = 19

Wavelength 2 = 500
Bandwidth 2 = N/A

Answers: lower = 385, upper = 500


Test case 4:

Wavelength 1 = 394
Bandwidth 1 = 40

Wavelength 2 = 500
Bandwidth 2 = 10

Wavelength 3 = 380
Bandwidth 3 = 5

Answers: lower = 374, upper = 505


The range that you must produce must consist of an integer lower limit and an integer upper limit. This particular DAD cannot accept decimal numbers, so while your code may accept and output floating-point types, the values themselves must be whole numbers.

Computing this range is important for other settings on the DAD. Therefore, you may not take just any input and return an extremely small lower limit and/or an extremely large upper limit. Your outputs must be based on your inputs.

Standard rules apply, including the default I/O rules. Similarly, default loopholes are forbidden.

Finally, this is so shortest answer in bytes wins.

Sandbox Questions

  • Is the challenge itself too complex or too easy?
  • Is the requirement for whole-numbered outputs valid, or does it seem a little bit arbitrary?
  • Are the examples and the test cases useful?
  • Finally, would this be an interesting challenge?
  • \$\begingroup\$ Some notes: (1) is it guaranteed that the outputted "lower value" will always be strictly greater than zero? (2) It appears that most people will want to take N/A bandwidth as zero. (3) of course requiring floor/ceil is "valid", whether it's arbitrary is up to people. (4) while I can understand the challenge, it's mainly because I read the provided example explanation, so I can't be entirely sure that the rules part is clear enough. [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 13 at 2:44

Print the nth sequence from oeis

The input is one natural number n - the sequence number

Your task is to put this numeric link https://oeis.org/A (example of a link with n = 1: https://oeis.org/A1), then you should get the html of this page and get the sequence from there


n -> sequence
1 -> 0, 1, 1, 1, 2, 1, 2, 1, 5, 2, 2, 1, 5, 1, 2, 1, 14, 1, 5, 1, 5, 2, 2, 1, 15, 2, 2, 5, 4, 1, 4, 1, 51, 1, 2, 1, 14, 1, 2, 2, 14, 1, 6, 1, 4, 2, 2, 1, 52, 2, 5, 1, 5, 1, 15, 2, 13, 2, 2, 1, 13, 1, 2, 4, 267, 1, 4, 1, 5, 1, 4, 1, 50, 1, 2, 3, 4, 1, 6, 1, 52, 15, 2, 1, 15, 1, 2, 1, 12, 1, 10, 1, 4, 2
3 -> 1, 1, 1, 1, 2, 2, 1, 2, 2, 2, 3, 2, 2, 4, 2, 2, 4, 2, 3, 4, 4, 2, 3, 4, 2, 6, 3, 2, 6, 4, 3, 4, 4, 4, 6, 4, 2, 6, 4, 4, 8, 4, 3, 6, 4, 4, 5, 4, 4, 6, 6, 4, 6, 6, 4, 8, 4, 2, 9, 4, 6, 8, 4, 4, 8, 8, 3, 8, 8, 4, 7, 4, 4, 10, 6, 6, 8, 4, 5, 8, 6, 4, 9, 8, 4, 10, 6, 4, 12, 8, 6, 6, 4, 8, 8, 8, 4, 8, 6, 4
5 -> 1, 2, 2, 3, 2, 4, 2, 4, 3, 4, 2, 6, 2, 4, 4, 5, 2, 6, 2, 6, 4, 4, 2, 8, 3, 4, 4, 6, 2, 8, 2, 6, 4, 4, 4, 9, 2, 4, 4, 8, 2, 8, 2, 6, 6, 4, 2, 10, 3, 6, 4, 6, 2, 8, 4, 8, 4, 4, 2, 12, 2, 4, 6, 7, 4, 8, 2, 6, 4, 8, 2, 12, 2, 4, 6, 6, 4, 8, 2, 10, 5, 4, 2, 12, 4, 4, 4, 8, 2, 12, 4, 6, 4, 4, 4, 12, 2, 6, 6, 9, 2, 8, 2, 8
6 -> 1, 1, 2, 2, 3, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 13, 13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18
8 -> 1, 1, 2, 2, 3, 4, 5, 6, 7, 8, 11, 12, 15, 16, 19, 22, 25, 28, 31, 34, 40, 43, 49, 52, 58, 64, 70, 76, 82, 88, 98, 104, 114, 120, 130, 140, 150, 160, 170, 180, 195, 205, 220, 230, 245, 260, 275, 290, 305, 320, 341, 356, 377, 392, 413, 434, 455, 476, 497, 518, 546
9 -> 1, 1, 1, 2, 2, 3, 4, 5, 6, 8, 10, 12, 15, 18, 22, 27, 32, 38, 46, 54, 64, 76, 89, 104, 122, 142, 165, 192, 222, 256, 296, 340, 390, 448, 512, 585, 668, 760, 864, 982, 1113, 1260, 1426, 1610, 1816, 2048, 2304, 2590, 2910, 3264, 3658, 4097, 4582, 5120, 5718, 6378




  • \$\begingroup\$ The issue with the requirement is that it's non-observable. While it's true that sometimes we judge answers by understanding it (especially when answerers have to prove something about the answers), most people consider it problematic. \$\endgroup\$ – user202729 Feb 12 at 13:13
  • \$\begingroup\$ Language having no random function a problem, we have rules for that. \$\endgroup\$ – user202729 Feb 12 at 13:13
  • \$\begingroup\$ Meta post about non-observable requirement: codegolf.meta.stackexchange.com/questions/11197/… \$\endgroup\$ – user202729 Feb 12 at 13:19
  • \$\begingroup\$ You could make it observable by requiring that the results of intermediate steps be output. \$\endgroup\$ – xnor Feb 12 at 20:31
  • \$\begingroup\$ even in this case people can still always output the sum... (although it will probably not save that much) (besides you can remove the "rules" part) \$\endgroup\$ – user202729 Feb 13 at 5:43
  • \$\begingroup\$ Remark: by default "random" means "all values are possible in theory". codegolf.meta.stackexchange.com/questions/17563/… [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 13 at 5:45
  • \$\begingroup\$ Maybe I didn't understand you properly @user202729, but the elements in a do cover all values possible in theory, as long as their sum is 1. \$\endgroup\$ – SketchySketch Feb 13 at 10:42
  • \$\begingroup\$ Yes, generally it's not a problem. \$\endgroup\$ – user202729 Feb 13 at 10:45
  • \$\begingroup\$ As I 've said above , people might skip the final compare solution, although I see no way to enforce it. Otherwise clear enough [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 15 at 2:06
  • \$\begingroup\$ I think your "print" in step 3 and "return" in step 5 is to say that both these results should be output, but it should allow both to be printed or returned in a pair. I'd suggested rewording to say that these two things need to be "output", which is generic enough to cover both functions and programs. The short-circuiting in step 1 of outputting a negative number is not ideal because it's Requiring multiple types as return value. I'd suggest thinking if there's a way to avoid that. \$\endgroup\$ – xnor Feb 15 at 4:36
  • \$\begingroup\$ It's not clear to me in step 2 what is required for a random array of non-negative reals summing to 1. Must it be uniform on that (n-1)-dimensional space? See this meta post. I think you should say explicitly what is expected -- the meta post that user202729 linked to isn't really definitive. \$\endgroup\$ – xnor Feb 15 at 4:40
  • \$\begingroup\$ Fixed @xnor, is it okay now? \$\endgroup\$ – SketchySketch Feb 15 at 7:00
  • \$\begingroup\$ Yes about the randomness, but see my other comment. \$\endgroup\$ – xnor Feb 15 at 7:28
  • \$\begingroup\$ @xnor What about changing the negative number in step 1 into throwing an error / exception? For step 3 & 5, what about saying "output" these two results? \$\endgroup\$ – SketchySketch Feb 15 at 7:56
  • \$\begingroup\$ @SketchySketch Throwing an error/exception might also be too language specific. Maybe just allow any behavior that's not output of the form in the later steps? Though, is this complication of checking n>=4 even worth having in the challenge? Its seems like a straightforward extra bit to add in. You could just have the input guarantee that n>=4. \$\endgroup\$ – xnor Feb 16 at 6:17
96 97
99 100

You must log in to answer this question.

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