This "sandbox" is a place where Code Golf users can get feedback on prospective challenges they wish to post to main. This is useful because writing a clear and fully specified challenge on your first try can be difficult, and there is a much better chance of your challenge being well received if you post it in the sandbox first.

Sandbox FAQ


To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.


The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

  • Parts of the challenge you found unclear
  • Comments addressing specific points mentioned in the proposal
  • Problems that could make the challenge uninteresting or unfit for the site

You don't need any qualifications to review sandbox posts. The target audience of most of these challenges is code golfers like you, so anything you find unclear will probably be unclear to others.

If you think one of your posts requires more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended! Be patient and try not to nag people though, you might have to ask multiple times.

It is recommended to leave your posts in the sandbox for at least several days, and until it receives upvotes and any feedback has been addressed.


Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

To add an inline tag to a proposal, use shortcut link syntax with a prefix: [tag:king-of-the-hill]. To search for posts with a certain tag, include the name in quotes: "king-of-the-hill".

Get the Sandbox Viewer to view the sandbox more easily!


4201 Answers 4201

114 115
117 118

Golfing on a Budget

The Task

Every answer should take a positive number as input, and print/return every number in reverse down to zero (inclusive), in any reasonable format. For example:

10    -> "10 9 8 7 6 5 4 3 2 1 0"
8     -> [8, 7, 6, 5, 4, 3, 2, 1, 0]
1000  -> [["1", "0", "0", "0"], ["9", "9", "9"], ["9", "9", "8"], ...]

The requirements

Every program has $100 to spend.

The cost of each byte is determined by \$2^{t-1}\$, where \$t\$ is the number of times the byte has appeared in previous programs in addition to the current one.

For example, assuming it's the first program, x->x++ would cost $10. Each - and > are $1, and each x and + are $2.

  • 2
    \$\begingroup\$ In some sense, doesn't this become a contest of speed to solution? The earlier I post, the lower my score. It also severely advantages certain languages that don't use ASCII. \$\endgroup\$
    – Xcali
    Dec 3, 2020 at 4:17
  • \$\begingroup\$ Also, what's the criteria for winning? What is the reason for the $100? \$\endgroup\$
    – Xcali
    Dec 3, 2020 at 4:25
  • \$\begingroup\$ @Xcali This is currently a very rough idea, so I didn't have any winning criterion decided on yet. What I was trying to do was make it so that it would be harder to come up with valid answers as time went on, but I think the execution ended up really bad here. \$\endgroup\$ Dec 3, 2020 at 4:27

Perfect radicals

  • Posted

Perfect radicals


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, 2020 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, 2020 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, 2020 at 4:21
  • \$\begingroup\$ @Xcali - good point. I will do that. \$\endgroup\$
    – user46773
    Dec 3, 2020 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\$ Dec 6, 2020 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, 2020 at 15:29
  • \$\begingroup\$ The list of timings is accurate at 60 bpm, but not at other tempos. \$\endgroup\$ Dec 6, 2020 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, 2020 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, 2020 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, 2020 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, 2020 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\$ Dec 27, 2020 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, 2020 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\$ Dec 27, 2020 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, 2020 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, 2020 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\$ Dec 29, 2020 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, 2020 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, 2020 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, 2020 at 17:47
  • \$\begingroup\$ Is this better? \$\endgroup\$
    – EasyasPi
    Dec 28, 2020 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.

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


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\$ Jan 5, 2021 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\$ Jan 5, 2021 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\$ Jan 5, 2021 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\$ Jan 7, 2021 at 16:19
  • \$\begingroup\$ Are chess libraries allowed? \$\endgroup\$
    – Razetime
    Jan 8, 2021 at 10:55
  • \$\begingroup\$ @Razetime no, chess libraries are not allowed. \$\endgroup\$
    – someone
    Jan 8, 2021 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, 2021 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, 2021 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, 2021 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, 2021 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, 2021 at 15:00
  • \$\begingroup\$ @pxeger In the standard ruleset, all hearts are worth 1 each and QS is worth 13 :) \$\endgroup\$
    – 79037662
    Jan 21, 2021 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, 2021 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, 2021 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, 2021 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, 2021 at 7:02
  • \$\begingroup\$ Suggested test case: 1 -> 1. \$\endgroup\$
    – Bubbler
    Jan 19, 2021 at 7:03
  • \$\begingroup\$ What is the behaviour for negative numbers and zero? \$\endgroup\$
    – pxeger
    Jan 19, 2021 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\$ Jan 19, 2021 at 12:16
  • \$\begingroup\$ @CommandMaster whoops, missed that \$\endgroup\$
    – pxeger
    Jan 19, 2021 at 13:49
  • \$\begingroup\$ This is A007947, which describes it as "Largest squarefree number dividing n". \$\endgroup\$
    – xnor
    Jan 20, 2021 at 10:27
  • 2
    \$\begingroup\$ Duplicate \$\endgroup\$ Jan 20, 2021 at 20:55
  • 1
    \$\begingroup\$ Dang, I should stop using built-in SE search for finding duplicates. \$\endgroup\$
    – Bubbler
    Jan 21, 2021 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\$ Jan 21, 2021 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\$ Jan 21, 2021 at 14:11
  • \$\begingroup\$ @thedefault. code-golf; it's in the cops' rules section \$\endgroup\$
    – pxeger
    Jan 21, 2021 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, 2021 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, 2021 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, 2021 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, 2021 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, 2021 at 15:21
  • \$\begingroup\$ Any restrictions on what target languages are allowed? \$\endgroup\$
    – Adám
    Jan 20, 2021 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, 2021 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, 2021 at 16:22
  • 1
    \$\begingroup\$ Should the cells be wrapping or not? \$\endgroup\$
    – Aiden4
    Jan 20, 2021 at 16:28
  • \$\begingroup\$ I don't think it's possible to support comments without embedding them into the code. \$\endgroup\$ Jan 21, 2021 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, 2021 at 12:39
  • \$\begingroup\$ Can we have EOF as no change? That's a somewhat common way of handling EOF \$\endgroup\$
    – Jo King Mod
    Jan 23, 2021 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\$
    Jan 28, 2021 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, 2021 at 2:32
  • \$\begingroup\$ Yeah I should try to clarify that. \$\endgroup\$
    – EasyasPi
    Feb 5, 2021 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, 2021 at 22:30
  • 1
    \$\begingroup\$ Do you have permission to repost this challenge here? \$\endgroup\$
    – Dingus
    Jan 26, 2021 at 22:30
  • \$\begingroup\$ Well I got permission to upload the challenge and its files anywhere from that CTF, so yes. \$\endgroup\$ Jan 27, 2021 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, 2021 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, 2021 at 7:45
  • \$\begingroup\$ Who makes the first move? \$\endgroup\$
    – Adám
    Feb 2, 2021 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, 2021 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, 2021 at 8:00
  • \$\begingroup\$ Updated with tags and winning criterion \$\endgroup\$
    – eligolf
    Feb 2, 2021 at 8:05
  • \$\begingroup\$ Suggested tags (remember that the max is 5): interactive, game, board-game, grid, ai-player. \$\endgroup\$
    – Adám
    Feb 2, 2021 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, 2021 at 20:28
  • \$\begingroup\$ @xnor, that could also be an idea! \$\endgroup\$
    – eligolf
    Feb 3, 2021 at 5:00
  • \$\begingroup\$ @Adám, could I try that or xnors idea in the real questions thread now? \$\endgroup\$
    – eligolf
    Feb 3, 2021 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, 2021 at 6:57
  • \$\begingroup\$ I found a similar challenge: codegolf.stackexchange.com/q/152064/20260 \$\endgroup\$
    – xnor
    Feb 3, 2021 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\$
    Feb 8, 2021 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\$
    Feb 3, 2021 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, 2021 at 1:49
  • \$\begingroup\$ I didn't read it... \$\endgroup\$
    Feb 3, 2021 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\$
    Feb 3, 2021 at 14:02
  • \$\begingroup\$ @user202729 Is this better? \$\endgroup\$
    – Orangutan
    Feb 3, 2021 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\$
    Feb 3, 2021 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\$
    Feb 3, 2021 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, 2021 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\$
    Feb 4, 2021 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, 2021 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\$
    Feb 4, 2021 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\$
    Feb 4, 2021 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\$
    Feb 7, 2021 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, 2021 at 22:33
  • \$\begingroup\$ Thanks for the comments. Will try to find some time for improving this. \$\endgroup\$
    – jmizv
    Feb 19, 2021 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\$
    Feb 5, 2021 at 17:11
  • \$\begingroup\$ @user202729 They will print to stdout with ANSI escape sequences, I have edited my question. \$\endgroup\$
    – Deadbeef
    Feb 5, 2021 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\$
    Feb 6, 2021 at 0:38
  • 1
    \$\begingroup\$ @user202729 I agree, I changed it so it doesn't have the restriction anymore \$\endgroup\$
    – Deadbeef
    Feb 7, 2021 at 2:42
  • \$\begingroup\$ you may want to ban usage of git tools from shell for this challenge. \$\endgroup\$
    – Razetime
    Feb 8, 2021 at 2:52
  • \$\begingroup\$ @Razetime "Do X without Y" (including banning built-ins) is not recommended. Boring answers will usually be downvoted anyway. \$\endgroup\$
    Feb 8, 2021 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, 2020 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, 2021 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\$ Feb 9, 2021 at 12:58
  • 1
    \$\begingroup\$ @UnrelatedString I changed the title. \$\endgroup\$ Feb 9, 2021 at 13:08
  • \$\begingroup\$ (note that it's recommended (in the sandbox FAQ) to leave sandbox posts for at least 72 hours. \$\endgroup\$
    Feb 11, 2021 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:

The tribonacci numbers are like the Fibonacci numbers, but instead of starting with two predetermined terms, the sequence starts with three predetermined terms and each term afterwards is the sum of the preceding three terms.

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, 2021 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\$
    – anotherOne
    Feb 10, 2021 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, 2021 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\$
    – anotherOne
    Feb 10, 2021 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\$
    – user7467
    Feb 11, 2021 at 14:59
  • \$\begingroup\$ There isn't really a point in doing this: 31 bytes, copy-paste the letters. \$\endgroup\$ Feb 11, 2021 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\$
    – user7467
    Feb 11, 2021 at 21:25
  • \$\begingroup\$ I don't specialize in C. For example, in O5AB1E, you can just do ,"க் ங் ச் ஞ் ட் ண் த் ந் ப் ம் ய் ர் ல் வ் ழ் ள் ற் ன் அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ ஔ ஃ in 33 bytes, excluding spaces \$\endgroup\$ Feb 11, 2021 at 21:30
  • \$\begingroup\$ @fasterthanlight and no more compact way to go over the relevant Unicode characters? \$\endgroup\$
    – user7467
    Feb 11, 2021 at 21:32
  • \$\begingroup\$ @fasterthanlight what about if I changed it to printing all the Unicode Tamil symbols? \$\endgroup\$
    – user7467
    Feb 11, 2021 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, 2021 at 22:40
  • \$\begingroup\$ @xnor yes I will do that. Do you think 31 characters is too few for it to be interesting? \$\endgroup\$
    – user7467
    Feb 12, 2021 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, 2021 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\$ Feb 11, 2021 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\$ Feb 11, 2021 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\$ Feb 11, 2021 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, 2021 at 22:09
  • \$\begingroup\$ @xnor I have changed my post so that it will be easier, with point bonuses as needed \$\endgroup\$ Feb 11, 2021 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, 2021 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\$ Feb 12, 2021 at 0:27
  • \$\begingroup\$ @FryAmTheEggman So how can you tell when a program is done calculating something? \$\endgroup\$ Feb 12, 2021 at 1:28
  • \$\begingroup\$ Ah, sorry I meant to suggest that just asking for \$ x \$ should solve the problem. \$\endgroup\$ Feb 12, 2021 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\$
    Feb 13, 2021 at 2:44
114 115
117 118

You must log in to answer this question.

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