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

Sandbox FAQ


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

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

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


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

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

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

If you think one of your posts needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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


Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Get the Sandbox Viewer to view the sandbox more easily!


3554 Answers 3554

102 103
105 106

Surprisingly, I don't think there has been a question about Whyte notation before. I suspect the ASCII challenge is a bit too easy, but not sure how many people are interested in a graphical challenge. Thoughts? Comments?

Whyte notation

Write a program which turns a string containing a valid (subset of) Whyte notation into an ASCII/graphical representation.

Whyte notation is a system for succinctly describing the arrangement of wheels on a steam locomotive. For the purpose of this challenge, a valid input consists of:

  • one or more wheelsets, joined by a + symbol
  • where each wheelset is of the form l-d1[-d2...]-t, where:
    • l is an integer specifying the number of leading wheels (small wheels at the front of the wheelset that aren't powered, but help keep it on the tracks)
    • d1 (and d2 etc) is the number of driving wheels (large wheels powered by a steam engine) coupled together. If there is more than one number, it means multiple coupled sets of driving wheels. (All the sets are powered by the same engine, but using different sets of cylinders - divided drive)

(Multiple wheelsets means an articulated locomotive, that is, two engines powered by the same boiler, but able to rotate independently, which is good for getting powerful locomotives around tight bends).

For instance:

  • 2-4-0 means a locomotive with 2 leading wheels (1 axle), 4 driving wheels (2 axles), and no trailing wheels. We can represent it like this: o-O=O
  • 4-8-8-2 means a locomotive with 4 leading wheels, two coupled sets of 8 driving wheels, and 2 trailing wheels. We can represent it like this: o-o-O=O=O=O-O=O=O=O-o
  • 2-4-2+2-4-2 means an articulated locomotive with two wheelsets. Each one consists of 2 leading wheels, 4 driving wheels and 2 trailing wheels. We can represent it like this: o-O=O-o:o-O=O-o

A Baldwin 2-4-0 locomotive: 2 leading wheels, 4 driving wheels, no trailing wheels

Image: A Baldwin 2-4-0 locomotive: 2 leading wheels, 4 driving wheels, no trailing wheels.


Input is a string (or equivalent) that is valid in this subset of Whyte notation. You may assume:

  • Leading and trailing wheel counts are even integers in the range 0-6 inclusive.
  • Driving wheel counts are even integers in the range 2-14 inclusive.
  • There are 1-4 coupled sets of driving wheels per wheelset.
  • There are 1-2 wheelsets.

Output (ASCII)

The rules for output are thus:

  • the train is always facing left, so the leading wheels are at the start of the input and output strings.
  • leading and trailing wheels are represented as one o per 2 wheels, joined by -
  • each set of driving wheels are represented as one O per 2 wheels, joined by =.
  • sets of driving wheels are joined by -
  • wheelsets are joined by :

Output (graphical)

Alternatively, you may output a graphical representation of a similar type: a series of circles from left to right. At a minimum:

  • all wheel circles must have a dark stroke and light fill, with the stroke no more than 10% the width of the circle
  • the lowest point of all wheel circles must be equal (they all touch the same imaginary track)
  • all wheel circles of a given type must be the same size
  • leading/trailing wheels must have a diameter in the range 20-50% of the diameter of driving wheels
  • coupled sets of driving wheels must be indicated by a horizontal line connecting their centres*.
    • * you may offset this line up to 40% of a driving wheel diameter in any direction to maintain artistic integrity
  • non-coupled wheels must not be connected, and have a space in the range 25-50% of the diameter of a driving wheel between them.
  • for an articulated locomotive, the two wheelsets must be separated by a space of between 100% and 150% of a driving wheel diameter.


This is code golf, shortest program in bytes wins. Standard rules/loopholes apply. There are two categories: ASCII output and graphical output.

  • \$\begingroup\$ Make it one or the other, otherwise it's too confusing. \$\endgroup\$
    – emanresu A
    May 10 at 9:41

Is this code golf too simple? Do I need to add more? Has something similar been done before?

The idea of this golf is to convert a string of 3 or more characters to a grammatically correct list.


12345 becomes 1, 2, 3, 4, and 5.

ab5 becomes a, b, and 5.

A comma and space is to be inserted between each character, and the last character should be preceded by "and", and be followed by a period. Your code should be able to handle up to 50 characters in series.

  • \$\begingroup\$ Well, you need to flesh out your challenge a little more. I'd suggest putting the last paragraph at the top and adding more test cases. However, I don't know how interesting this would be. \$\endgroup\$
    – rues
    May 10 at 21:38
  • \$\begingroup\$ May input contains whitespace characters and / or comma? \$\endgroup\$
    – tsh
    May 11 at 2:32

How Many Students are in our clubs?

You are a principal in CG High School, and you want your school fliers to include data on how many students are part of any particular set of clubs. You command your secretary to get this data, but they goofed up.

Instead of giving you the data on how many students attend (for example) tech club, math club, and spanish club as their only clubs, they included students who attend more clubs, like the arts club! You decide to fix the data yourself.


Your school has n clubs, and for each subset of the n clubs, you have data on how many students attend the clubs in that subset (but potentially more clubs).

In this challenge, you want to output data for each subset which tells you how many students attend exactly those clubs in that subset (and no others).


We represent each subset as an n digit binary number by placing a 1 in the ith position if the ith club is in the subset. For example, the number 3, in binary, is 11, meaning that it represents the subset of the first and second clubs.

The input (zero-indexed) list is of length 2^n, with the secretary's data for a particular subset placed at the index representing that subset (as in the previous paragraph).

The output is also a list of length 2^n, with the data changed.


  • List of length 2^n of non-negative integers
  • (Optional) positive integer n


  • List of length 2^n of non-negative integers

Test Cases

[41,16,15,14,5,5,6,2] -> [10,8,6,5,3,3,4,2]

More to be added


I worded this challenge really poorly: any help on explaining this better?


[Draft] Write out the 2x2 Hamiltonian Circuit

Unlike the 3x3 Rubik's Cube, which famously has over 43 quintillion possible positions, the 2x2 Pocket Cube "only" has about 3.7 million positions, making a Hamiltonian circuit (a set of moves that visits every position exactly once) perfectly feasible to output or store in its entirety.

The full circuit was posted by cuBerBruce in 2011 on the SpeedSolving Forums. You don't need to understand any Rubik's cube notation to complete this challenge. You only need to understand simple string replacements (in the form of a context-free grammar), in that lower case letters are "non-terminal" and can be replaced with longer strings, while upper case letters are "terminal", in that they are "atomic" and cannot be replaced further. For example, given b=URURUR and a=bURUR, you can replace the b in a to get a=URURURURUR, and you cannot expand a any further.

One additional detail: if a letter is followed by an apostrophe, you replace the letter and the apostrophe in the string with the inverse of the moves. That means the the entire string is reversed and the direction of all moves is reversed: U becomes V and vice versa, R <-> S, and F <-> G. More formally, (ab)'=b'a', so for example a'=(bURUR)'=R'U'R'U'b'=SVSV(URURUR)'=SVSVSVSVSV.

Todo: upload full move list and compute hash


  • \$\begingroup\$ Should you maybe allow to choose whatever tokens you want instead of U,V,R,S,F,G, as long as there's only a single valid way to parse it to the tokens? \$\endgroup\$ May 13 at 9:36
  • \$\begingroup\$ @CommandMaster this question is a kolmogorov-complexity question, about producing a constant string, and I intend all solutions to be able to be verified by hash \$\endgroup\$
    – qwr
    May 13 at 9:41

Posted here

  • \$\begingroup\$ I think the explanation for how the game works could be a bit clearer. How many cards are dealt each round? How is the trump card chosen? \$\endgroup\$ May 12 at 21:19
  • \$\begingroup\$ @RedwolfPrograms Fixed. \$\endgroup\$ May 12 at 21:24



The concept of a function to add months to a date, without overflowing if we reach the end of the month, is implemented in many languages/packages. In Teradata SQL it's ADD_MONTHS, here are some examples:

ADD_MONTHS('2021-01-31', 1)   => 2021-02-28
ADD_MONTHS('2021-01-30', 1)   => 2021-02-28
ADD_MONTHS('2021-02-28', 1)   => 2021-03-28
ADD_MONTHS('2021-02-28', -12) => 2020-02-28

However, Teradata SQL has a function that goes a step further, namely OADD_MONTHS. The behaviour of this one is similar, but when given an end-of-month date, it always returns an end-of-month date.
To illustrate the difference:

ADD_MONTHS('2021-02-28', 1)  => 2020-03-28
OADD_MONTHS('2021-02-28', 1) => 2020-03-31

The task

You are given as input:

  • a date D in any reasonable format (including your language's native date/datetime type, a string, number of days/seconds from a fixed point, etc.),
  • an integer n (positive/negative/0).

You should output:

  • a date n months apart from D,
  • if the month n months apart from D has fewer days then the day-of-month of D, output the end of that month,
  • if D is an end-of-month date, output the end of the month.

Any reasonable output form is acceptable (including your language's native date/datetime type, a string, number of days/seconds from a fixed point, etc.)

You may assume the input and target dates are after 1600-01-01 and the date is well defined (so no 2021-03-32). You may use the Georgian calendar or any similar calendar implementing standard month lengths and taking into account leap years.

If you have a builtin specifically for this, consider including a non-builtin answer as well to make your answer more interesting.

Test cases

D, n             => output     (explanation)
2021-01-31, 1    => 2021-02-28 (no overflow)
2020-12-31, 1    => 2021-01-31 (next year)
2020-12-01, 1    => 2021-01-01 (next year)
2021-01-31, -1   => 2020-12-31 (previous year)
2021-01-30, -1   => 2020-12-30 (previous year)
2021-01-01, -1   => 2020-12-01 (previous year)
2020-12-30, 2    => 2021-02-28 (no overflow)
2021-01-30, 2    => 2021-03-30 (skipping over 28-day February)
2021-01-30, 3    => 2021-04-30 (skipping over 28-day February)
2021-03-30, -2   => 2021-01-30 (skipping over 28-day February)
2021-02-28, 1    => 2021-03-31 (end-of-month -> end-of-month)
2020-02-28, -1   => 2020-01-28 (leap year - 28.02 is not end-of-month)
2020-02-28, 1    => 2020-03-28 (leap year - 28.02 is not end-of-month)
2021-02-28, -12  => 2020-02-29 (end-of-month -> end-of-month)


  • do we have something similar already?
  • do I need to clarify the task more/less?
  • 1
    \$\begingroup\$ Some more testcases: 2020-12-31, 1 (Year wrap), 2020-12-01, 1, 2021-01-31, -1, 2021-01-01, -1, 2020-02-28, -1 (the input is not last day of Feb due to leap year), 2020-02-28, 1, 2021-01-30, 2 (is add 2 months as same as add 1 month twice?), 2021-01-30, 3, 2021-03-30, -2 \$\endgroup\$
    – tsh
    May 11 at 2:18
  • \$\begingroup\$ @tsh, thanks, I added those. \$\endgroup\$
    – pajonk
    May 11 at 5:31
  • \$\begingroup\$ Since you start the dates so long in the past, you need to specify a calendar - and what to do for corrections that cause anomalies. Alternatively, you can specify that these don't count. But you need to then go over specifically what does count (leap years, etc.). \$\endgroup\$ May 13 at 3:21
  • \$\begingroup\$ @FryAmTheEggman I didn't think of that - what would be a cut off to avoid the anomalies? Is '2000-01-01' OK? \$\endgroup\$
    – pajonk
    May 13 at 11:07
  • 1
    \$\begingroup\$ Unfortunately I'm not familiar enough with these things to know for certain. Definitely another problem is that some of these anomalies are only for particular regions, so the result of a built-in would vary depending on your location settings. I haven't been able to find a "list" of such things. This is always a bit of a problem with calendar stuff, you may be better off saying something like: "the dates won't include any irregular behaviour." Probably also worth asking for a second opinion! \$\endgroup\$ May 13 at 14:55
  • \$\begingroup\$ @FryAmTheEggman Ok, thanks. I specified the Georgian calendar as it seems to be the most widely implemented in computer systems. \$\endgroup\$
    – pajonk
    May 13 at 19:09

You want to have some drinks. Each bottle of drink has a drink itself and \$n\$ other parts (the bottle, etc.) \$P_1, P_2, ..., P_n\$. Thus when buying a bottle of drink, you also get one of each of \$P_1, P_2, ..., P_n\$.

You can buy a bottle of drink using 1 dollar, \$a_1 P_1\$s, \$a_2 P_2\$s, ..., or \$a_n P_n\$s.

Given the amount of dollars \$b\$ and amount of each part you have \$c_1, c_2, ..., c_n\$[1], how many bottles of drink can you have?

You may choose to borrow some parts, aka. having a negative amount of some parts during the buying and drinking, so long as after the whole process you don'thave negative amount. But beware that simply giving each part a value and use the actual worth of the drink itself may fail. See example (*) below.

Also, you need to handle Infinity results correctly. I'd accept format Infinity, , 1/0, for other formats ask here or on meta for a default.

Test cases:

n, a, b, c => resuly
1, [2], 5, [0] => 10 // Borrow 10 P1, buy 10BoD, and return
1, [2], 0, [10] => 10
2, [3,4], 1, [0,0] => 1 // (*)
2, [3,3], 1, [0,0] => 3 // (**)
2, [2,2], 0, [0,0] => Infinity
2, [1,2], 0, [0,1] => Infinity

(*) If you get 2, you result in 2 \$P_1\$s and 2 \$P_2\$s, neither of which afford one BoD and therefore you can't pay.

However, if you just claim that each \$P_1\$ worth $0.333 and each \$P_2\$ worth $0.250, then the drink itself worth $0.417, and you can drink two of them, which is incorrect.

(**) Even though you can't get 2 as that gives you 2 \$P_1\$s and 2 \$P_2\$s, which is not enough to pay; getting 3 gives you 3 \$P_1\$s and 3 \$P_2\$s, and with the initially $1 you can pay the fee of 3 bottles of drink.

One sentence meaning:

Given \$n, \{a_i\}, b, \{c_i\}, i=1..n\$, find the largest integer \$r\$, maybe infinite, such that \$b+\sum_{i=1}^n\left\lfloor\frac{c_i+r}{a_i}\right\rfloor\ge r\$.

Input range:

  • \$n>0, a_i>0, b, c_i\ge 0\$

Sandbox Notes

  • Should I take c input or just assume it's zero at [1]?
  • \$\begingroup\$ I mostly get the problem statement from the first three paragraphs, but the rest of the challenge sort of loses me. I can piece together a bit from the test cases. If you added a more worked through example perhaps I could help rephrase the parts of the challenge I don't get right now. \$\endgroup\$
    – Grain Ghost Mod
    May 14 at 15:24
  • \$\begingroup\$ @WheatWizard Is treating borrowing as having negative amount of parts or pay after drinking better? Also fixed a bug in test cases. And do such question have an English usualseen version? \$\endgroup\$
    – l4m2
    May 14 at 16:12

Implement the ordering monoid


Mimic Haskell's (<>) :: Ordering -> Ordering -> Ordering.

What's the fuss?

This particular monoid is rather useful for comparing sequential containers lexicographically.


Though Ordering is defined as a three-element enumeration, in this challenge, the format of the 2 inputs and the output is arbitrary.

The 2 inputs and the output must be the same domain, and their classification of their values (see below) also must be the same. This restriction is due to that (<>) is associative.

Any input outside of the domain falls in don't care situation.


The elements of the domain shall be classified to 3 categories: Negative, zero, and positive.

  • If the left operand is negative, output a negative value.

  • If the left operand is zero:

    • If the right operand is negative, output a negative value.

    • If the right operand is zero, output a zero value.

    • If the right operand is positive, output a positive value.

  • If the left operand is positive, output a positive value.


A Python 3 implementation of this operation:

lambda x,y: x if x != 0 else y

This has integers as the domain, and classifies integers by their signature.

  • 2
    \$\begingroup\$ looks like in many languages this will just be an "or" builtin \$\endgroup\$ May 14 at 23:04
  • \$\begingroup\$ I want to say this might be clearer if the spec for the operation just used the names LT, EQ, and GT, but the example domain leads to the unfortunate revelation that your example solution could be simply lambda x,y:x or y... \$\endgroup\$ May 14 at 23:08
  • \$\begingroup\$ @Wzl How would an "or" operator act? Bitwise "or" is commutative, while (<>) isn't. \$\endgroup\$ May 15 at 0:26
  • \$\begingroup\$ Python 3: lambda x,y: x or y \$\endgroup\$ May 15 at 9:25
  • \$\begingroup\$ Finally, I am the outgolfer. \$\endgroup\$ May 15 at 9:25
  • \$\begingroup\$ Javascript: $=>_=>$||_ \$\endgroup\$
    – Makonede
    May 24 at 20:19

Generate simultaneous equations

You've been tasked to write maths exam questions, but you're getting quite bored of coming up with simultaneous equations with integer solutions, so you decide to write a program to generate them. Because this is a school test, the questions mustn't be too easy, but they also mustn't be trivial.

The simultaneous equations should be of the form:

$$ ax + by = R $$ $$ cx + dy = S $$

where \$ a \$, \$ b \$, \$ c \$, \$ d \$, \$ R \$, \$ S \$ are integers. The equations must have exactly one set of solutions, the solutions must both be integers, and \$ x \$ must not equal \$ y \$.

The random generation method you choose is completely up to you, as long as there are at least 100 distinct equations that could be generated each with a non-zero probability. If the coefficients or equations are swapped, they count as the same (this is to discourage hard-coding of valid equations).

You may output in any reasonable format, such as a string "-1x-2y=3;4x+5y=6" or a list of 6 integers like [-1, -2, 3, 4, 5, 6]. The format must be consistent for all outputs.


Valid              x   y
-1x-2y=0; 4x+5y=6  4  -2

Invalid              Notes
-1x-2y=7; 4x+5y=6    Non-integer solutions
-1.5x-3y=0; 4x+5y=6  Non-integer coefficients
0x+2y=8; 2x+2y=6     Zero coefficients
3x+4y=1; 6x+8y=2     Infinitely many solutions
3x+4y=1; 6x+8y=3     No solutions

TODO: add more examples



  • Is this a duplicate?
  • Is this clear enough?
  • Any other feedback?
  • \$\begingroup\$ I'm not sure if this is too trivial \$\endgroup\$
    – tsh
    May 17 at 2:59
  • \$\begingroup\$ @tsh A lot of Kolmogorov questions are therefore even more "trivial". \$\endgroup\$ May 20 at 12:59


Based square-free words

A square-free word is a word that contains no squares, i.e. contains no adjacent repeating subwords. For example, 0123 is square-free, while 0112 and 012123 are not (because 11 and 1212 are repetitions, respectively).

In base-1 there is only one square-free word: 0. In base-2 there are 6 square-free words: 0, 1, 01, 10, 010, 101. In base-3 and up there are infinitely many.

The challenge

Given a base N and a length L, output a square-free word of length L in base N, or a distinct falsy value (or an error) if no such word exists. Both the base and the length will be positive integers.
Alternatively, you may take an alphabet instead of a base as input, e.g. you may take "ABC" as an input instead of base-3 and give output in that alphabet.

Any reasonable input-output, standard restrictions, code golf.

Test cases

Other similar outputs are also valid.

Base  Length  Output
2     1       0
2     2       01
2     3       010
2     4       Error or a distinct falsy value
3     4       0121
3     5       01210
3     50      01210212012101202102012021201021012010212021020120


Given an real polynomial equation \$c_0+c_1x+c_2x^2+...+c_nx^n=0\$, count how many real roots it has.

You can and need to assume infinite precision. You can assume repeated root doesn't exist.[1]

You can take input [c0,c1,...,cn], [cn,...,c1,c0], or just the polynomial or the equation in your language support.

Test cases:

1=0 => 0
0=0 => Infinity
2+1x=0 => 1
3+4x+1x^2=0 => 2
6+4x+1x^2=0 => 0
0+0x+0x^2+1x^3+0x^4=0 => 1

Sandbox Notes

[1] Is checking repeated root always possible?

  • \$\begingroup\$ This feels like a factorisation code-golf, though the question is still very good \$\endgroup\$ May 18 at 16:40
  • \$\begingroup\$ @StackMeter But you can't solve some poly eq? \$\endgroup\$
    – l4m2
    May 19 at 3:20
  • \$\begingroup\$ Do you have a reason to believe it is solvable in finite time? \$\endgroup\$
    – Bubbler
    May 25 at 1:03
  • \$\begingroup\$ Also, in your last example (x^3=0 in simplified form), 0 is the repeated root. \$\endgroup\$
    – Bubbler
    May 25 at 1:06

Golf Code Golf

Given the transcript (what I mean by full transcript is you can access all days of the transcript) of The Nineteenth Byte (the general chat room of code golf), output the full transcript in text form (you only have to include messages, though including other things is allowed. You can use any format as long as it includes the poster and contents of each message. As for people changing names, the way you handle this is up to you, do whichever is shortest). You can access the full transcript in your code, but you cannot access any other external sources.

Since this is code golf, shortest answer wins, and standard loopholes are not allowed

  • \$\begingroup\$ Any feedback would be helpful, since this is my first question idea here. \$\endgroup\$ May 18 at 20:14
  • \$\begingroup\$ By "access the full transcript" what do you mean? There's no single page with the entire transcript, so do you mean all pages that are https://chat.stackexchange.com/transcript/240/<date>? \$\endgroup\$ May 18 at 20:18
  • \$\begingroup\$ @cairdcoinheringaahing yes that is what I meant, I’ll update it now, thank you. \$\endgroup\$ May 18 at 20:21
  • \$\begingroup\$ You'll need to be much more specific about what "text form" is. I'm assuming ...people talk... is not correct, but there are a huge amount of formats, such as person: message and <person> message, not even considering stars, multi-line messages, and users changing their usernames \$\endgroup\$ May 18 at 20:29
  • \$\begingroup\$ @Wzl I edited it, is it more clear now or is there something I missed? \$\endgroup\$ May 18 at 20:48
  • \$\begingroup\$ If people are as lazy as me I think they'll just output the raw HTML, since it complies with your constraints (however I think this is a good thing as answers shouldn't be required to parse HTML) \$\endgroup\$ May 18 at 20:54

JS onelineriser

JavaScript is a very easy language to onelinerise. All one has to do is insert a semicolon in the correct locations and concatenate every line.

Your task is to write a program that, given a valid JS program, returns a program in one line but is otherwise identical to the input.


  • Clarifications?
  • Any edge cases where any operation other than inserting semicolons is required?
  • Should I include basic JS syntax in the question or provide a link?
  • \$\begingroup\$ I think you should ask the programs to minimize the amount of semicolons placed. \$\endgroup\$
    – Razetime
    May 19 at 2:42
  • 3
    \$\begingroup\$ You definitely need to tell where one needs to insert ;s. \$\endgroup\$
    – Adám
    May 19 at 2:42
  • \$\begingroup\$ I know where one should place semis but I'm not exactly clear whether those semis are necessary. However, I intended this to be a code-golf and not a code-challenge (shortest source) \$\endgroup\$ May 19 at 2:59
  • 2
    \$\begingroup\$ Either the input code is guaranteed to conform to a format where some simple rules can be applied (and you'll have to include these rules in the challenge), or this is going to require a full parsing and syntax analysis -- which is probably far too complicated for a code-golf challenge. \$\endgroup\$
    – Arnauld
    May 19 at 22:14
  • \$\begingroup\$ Can I make the whole input toJson and then feed it to eval? This is valid since ES2019. (And CSP is never a part of ES specification, so that doesn't matter.) \$\endgroup\$
    – tsh
    May 20 at 2:26
  • \$\begingroup\$ Other than inserting semicolons: remove comments. For example, foo(); // do something<line-break>bar();. And remember to keep line break in comments. For example, ()=>{return//<line-break>42;}. More terrible comments: `${()=>{return // this is a comment in template string. <line-break> }}`. Even even terrible edge case: If hashbang proposal landed... \$\endgroup\$
    – tsh
    May 20 at 10:35
  • \$\begingroup\$ @tsh tbh comments aren't "code" so to speak, so I might not actually have those test cases. They would be hell to deal with. \$\endgroup\$ May 20 at 12:46
  • \$\begingroup\$ Can I just warp the code eval? (ok also asked by tsh) \$\endgroup\$
    – l4m2
    Jun 6 at 5:04

Return shortest integer-is-one-of function

Given a number of integers as input, your task is to write a function in JS, which returns a function that checks if an inputted integer is any of those. For example, f([1, 2, 4]) would return a function which would return true if given 1, 2, or 4, and false for any other inputs.


Your function will take any nonzero number of integers. There will not be any duplicates. This should return either a function, or a string containing the function's code.

The returned function should take a single integer as input. If the input is one of the integers inputted into the original function, it should return a truthy value, and a falsy one otherwise. You may also choose to return any two consistent values, or a consistent value for one possiblity (such as 0 for truthy) and any other value for the other.


This is metagolf, meaning the average of the byte counts of the returned programs for a certain set of inputs will be your score. This set of inputs will consist of:

  • All combinations one to four integers from -10 to 10
  • A random group of 2000 inputs consisting of between five and ten integers between -100 and 100
  • A random group of 1000 inputs consisting of between two and six integers between -10000 and 10000

Optimizing your solution for these specific test cases is disallowed.


  • I will generate a random list of test cases that will be used for scoring when I post this
  • This is my first time writing a metagolf challenge. Any improvements y'all can think of?
  • I think the number of bytes should be limited in the submitted function (not the generated ones). Suggestions?
  • Too many test cases? Too few?
  • \$\begingroup\$ The option to return a function is only available in JS, I'm assuming? I think you should disallow it, because it's unclear how you measure the size of a function object. \$\endgroup\$ May 21 at 14:22
  • \$\begingroup\$ Maybe you should include test cases with more than six integers? If not, is it allowed for a solution to be optimized for small sizes? (given that it's a a minority in the input space) \$\endgroup\$ May 21 at 14:23
  • \$\begingroup\$ @CommandMaster Oh, I meant to restrict this to JS anyway, wasn't sure if I was going to do that or not. It should be possible in any language with first class functions, though. If I open it up to any language I'll allow returning a string with a program. I'll add some test cases with more items. \$\endgroup\$ May 21 at 14:56
  • \$\begingroup\$ If you return a function, how do you count the byte count of it? \$\endgroup\$ May 21 at 15:14
  • \$\begingroup\$ .toString() (plus it's pretty likely they'll return a string form of the function anyway) \$\endgroup\$ May 21 at 15:28
  • 2
    \$\begingroup\$ .toString() doesn't work for that, for example in function f(i) { var l = a=>a+i return x=>l(x) } f().toString() is just x=>l(x), while that's clearly not the length of the code you want to count (it's also unclear what code you do want to count in such a case) \$\endgroup\$ May 21 at 15:39
  • 1
    \$\begingroup\$ @CommandMaster The functions will need to be independent from the meta function. As in, no closures/accessing variables in the above scope. \$\endgroup\$ May 21 at 15:55

Gabriel's Horn


  • 1
    \$\begingroup\$ 1. I don't think I've seen anything very similar. 2. Wording looks fine to me (mainly because the image helps a lot) 3. I don't have a strong opinion on this. Either way should be fine. 4. Looks correct. 5. Actually the whole challenge is simply "generate a specific arithmetic progression based on the input", which can be seen as not so interesting, and it has very little to do with Gabriel's Horn itself. Maybe a better title would be "Convince me Gabriel's Horn is possible"? \$\endgroup\$
    – Bubbler
    May 18 at 0:28

Print a BigNum

Your task is to take an arbitrary precision unsigned integer, separated into 7-bit parts (a.k.a. base 128), and output it in base 10.


All arithmetic for conversion (excluding basic indexing) must be done only using values \$-2^{15}\le x \le 2^{15}-1\$, or in simpler terms, the range of a signed 16-bit integer.

So for example, something like this in Python would be illegal because a[i]<<i*7 and sum are capable of making a number larger than \$2^{15}-1\$.

lambda a:str(sum(a[i]<<i*7for i in range(len(a))))

Note that you are not required to explicitly use 16-bit integers or mask every time.

Your algorithm must be able to handle numbers of any length, if the resources are available.

Assume all inputs to be valid and the shortest possible length.


The input is a list of numbers, each 0-127, in big or little endian order. You only need to handle up to 224 bits, or 32 base 128 digits, though.

Any reasonable encoding format is fine, as long as all digits are in base 128 and the length is variable. You could do this: 122 bananas, 0 bananas, 20 bananas, 12 apples, I don't care. ULEB128 is allowed if that is easier.

The output can be either an ASCII string or printed to standard output, all in base 10. These must be ordered in big endian (as if you were to print it).

Test cases

Inputs are in little endian order.

[0] -> 0
[1] -> 1
[127] -> 127
[99] -> 99
[0, 0, 1] -> 16384
[127, 0, 0, 0, 127] -> 34091303039
[21, 26, 111, 58] -> 123456789
[1, 78, 123, 61, 102, 86, 17, 32, 74, 41, 114, 79, 1] -> 31415926535897932384626433
[63, 29, 51, 105, 61, 107, 45, 70, 105, 97, 38, 36, 121, 15, 77, 24, 72, 4, 52, 56, 6, 5, 36, 38, 87, 10, 37, 26, 96, 16, 21, 110] -> 23203475113112158652497114438750306328443726354045579113768791363263
  • 3
    \$\begingroup\$ What does "All calculations must use a maximum of 16 bits" exactly mean? Does it mean I can only use 16 bits RAM (including registers)? \$\endgroup\$
    – tsh
    May 20 at 7:54
  • \$\begingroup\$ You probably want to limit the absolute value, otherwise someone could calculate -<ans>, convert it to a string, and remove the first character \$\endgroup\$ May 21 at 7:38
  • \$\begingroup\$ Your algorithm must be able to handle numbers of any length given a large enough buffer. So given a number with >2^15 base-128 digits how to access? \$\endgroup\$
    – l4m2
    May 21 at 8:46

What is the link to your answer?


Your task is to create a program taking the input that returns the link to your answer. You can find a link to your answer by clicking at the share button on your answer.


  1. Standard loopholes apply except for searching for the answer online. In fact, you are expected to find the answer online.
  2. You are allowed to use curl or the equivalent, but you are not allowed to use any html parser library or built-in. If you need to import the library, the import declaration does NOT count into the code size as long as you don't rename any identifiers.
  3. You are not allowed to assume the link to your answer. You have to search this page for your submission. If you remove your submission and readd it, and your code breaks, you fail the challenge.
  4. You may still assume your username, the contents of your code, and the programming language/byte count you are using. You are not allowed to assume the description below your code. If you edit the description part of the submission and the code breaks, you fail the challenge. You may assume that the code of each submission is unique and no one copies your submission into another answer.


This is so, the shortest answer in bytes wins.

  • 2
    \$\begingroup\$ What prevents me from simply hardcoding my output? \$\endgroup\$ May 20 at 9:24
  • 1
    \$\begingroup\$ @StackMeter If you delete your answer, and post again the same answer, and it break, it fails the challenge. \$\endgroup\$
    – Xwtek
    May 20 at 9:42
  • \$\begingroup\$ thanks for the clarification \$\endgroup\$ May 20 at 9:44
  • \$\begingroup\$ What if my language has built-in for HTML parser (Yes, JavaScript running in browsers , aka. BOM, does have one)? Also, what will happen if I post 2 answers to this question? \$\endgroup\$
    – tsh
    May 20 at 9:46
  • \$\begingroup\$ Can I assume no one else will contain my code as part of an answer/comment? \$\endgroup\$ May 20 at 10:12
  • \$\begingroup\$ @CommandMaster Yes \$\endgroup\$
    – Xwtek
    May 20 at 11:43
  • \$\begingroup\$ @tsh 1. You have to avoid using that built-in, 2. You have to be able to distinguish your submissions. \$\endgroup\$
    – Xwtek
    May 20 at 11:44
  • \$\begingroup\$ [tag: self-referential] ? \$\endgroup\$ May 21 at 5:10

Recreate the Stack Overflow logo


Lowest effort to fill the bucket

There are two man, Paul and Jhon, who can move only along a line; they are real persons so Paul cannot goes to the right of John and Jhon cannot goes to the left of Paul. At time 0 they start at the opposite ends of the line.

Paul |------X1----X2----BUCKET--------X3-----X4-----| Jhon

Their goal is to pickup the balls along the line (denoted as Xn) and fill the bucket in the lowest time. The time needed to go from A to B along the line is equal to the distance from A to B.

For the challenge the balls are 20 and they are located on the line in the following way:

  1. Paul = 0
  2. X1 = 1
  3. X2 = 2
  4. X3 = 3
  5. x4 = X5 = x6 = 5
  6. BUCKET = 8
  7. X7 = 10
  8. X8 = 11
  9. X9 = X10 = X11 = 15
  10. X12 = 20
  11. X13 = X14 = X15 = 22
  12. X16 = X17 = X18 = 28
  13. X19 = 29
  14. X20 = 30
  15. Jhon = 32

Which is the best sequence to reach they goal?


Verify the Perfect Rectangle

According to Wolfram Mathworld, a perfect rectangle is defined to be a rectangle that can be divided into squares of different side lengths.

In this challenge, we are going to verify whether or not an arrangement is a perfect rectangle.

For the input, there should be at least 3n+2 non-negative integers in it:

  • The first two numbers should show the size of the rectangle.
  • Rest of the 3n numbers should describe n squares.
  • Each square should be described with 3 numbers, which are the side length(>0) and the position(x, y).
  • Position should be consistent throughout the whole input. For example, If the program gets the position of the bottom left corner of the square for one time, it should do that every other time as well.

For the output, the program should print a truthy value if the given arrangement is a perfect rectangle, and a falsey value otherwise.

  • Every squares should be different in side length.
  • There should be neither overlaps nor voids.

Test cases(Note that any input and output formats are acceptable if they are reasonable):

-> True #This is the first example in the above link. 

-> True #This is the second example in the above link. 

-> False #There are sqaures of same sizes. 

-> False #There are overlaps and voids. 

This is , which means that codes with least bytes win.


Create a non-renewable world

In Minecraft, we can split all possible items into two categories: renewable and non-renewable. All non-renewable items are simply items that are not renewable.

Minecraft worlds are not infinite, meaning that, for some resources, there are only a finite number available. This number is often huge, but it is finite. For example, diamond ore can only be obtained by mining blocks that are generated when the world is created, meaning that there is only a finite number of them in any given world.

However, some resources can be obtained infinitely. For example, as Raid Captains will spawn indefinitely, it is possible to obtain an arbitrarily large number of Ominous Banners, dropped when you kill a Raid Captain. Or, as you can create an infinite water source, and you can get infinite iron by killing Iron Golems, it is possible to get an infinite number of Water Buckets.

Any resource for which it is possible to obtain an arbitrary amount of is called renewable, and there are a lot of these. Any item that is not renewable is non-renewable. There are 40 of these that are obtainable in a classic Minecraft 1.16 survival world. They are:

A Netherite Tool               Netherite Armor                Ancient Debris                 Block of Diamond              
Block of Netherite             Coal Ore                       Cobweb                         Conduit                       
Dead Bush                      Diamond                        Diamond Ore                    Dragon Egg                    
Dragon Head                    Elytra                         Emerald Ore                    Enchanted Golden Apple        
Enchantment Table              Gilded Blackstone              Gold Ore                       Heart of the Sea              
Iron Ore                       Jukebox                        Lapis Lazuli Ore               Large Fern                    
Lava Bucket                    Lodestone                      Nether Gold Ore                Netherite Ingot               
Netherite Scrap                Iron/Gold/Diamond Horse Armor  Pigstep Music Disc             Quartz Ore                    
Redstone Ore                   Shulker Box                    Shulker Shell                  Snout Banner Pattern          
Sponge                         Tall Grass                     Thing Banner Pattern           Wet Sponge              

Your task is to get as many of these 40 items as you can. A Netherite Tool means any of a Netherite Sword, Pickaxe, Axe, Shovel or Hoe. Netherite Armor is any of a Netherite helmet, Chestplate, Leggings or Boots. Iron/Gold/Diamond Horse Armor means that any of these three are acceptable. Leather Horse Amor is not.

You should create a vanilla Minecraft Java Edition world, in 1.16.5, in Hardcore difficulty. You then have until you die in that world to collect all 40 of these items, or as many as you can. You should provide a double chest containing 1 of each of these and nothing else.

In order to verify attempts, you should provide the save file of your world, as a zip file.

The user who gets the most of these 40 items before dying wins. If multiple users get all 40 items, the user who gets all 40 within the fewest in-game days, which can be found by pressing F3.


  • You may not change the game rules of the world from the default, nor may you change any other option during world creation aside from the seed. To be fully clear, you may change exactly 3 things from the default values after clicking "Create New World":
    • The name of the world
    • The gamemode, switching from Survival to Hardcore
    • Optionally, the seed, which may be any value of your choosing
  • While in the world, you may not enable commands. This is typically done by pausing the game, opening the world to LAN and enabling commands, but, regardless of how you may do it, enabling commands is completely forbidden.
  • You may not use any mods, datapacks or anything else that can modify the default behaviour of the game. Texture packs are perfectly fine.
  • I will be testing and confirming each world submitted, so you should not include anything in the save file that isn't generated by the world. You may not edit the save file directly, only by interacting with the world
  • Items are allowed to be enchanted, renamed or otherwise legitimately modified in game

Additionally, as of snapshot 21w20a, there are 18 new non-renewable resources (ignoring products from Deepslate and Cobbled Deepslate), and Lava Buckets are noew renewable:

Block Of Raw Copper        Block Of Raw Gold         
Block Of Raw Iron          Budding Amethyst          
Calcite                    Cobbled Deepslate         
Copper Ore                 Deepslate                 
Deepslate Diamond Ore      Deepslate Gold Ore        
Deepslate Iron Ore         Deepslate Lapis Lazuli Ore
Deepslate Redstone Ore     Raw Copper                
Raw Gold                   Raw Iron                  
Spore Blossom              Tuff     

This brings the total number of non-renewable items in the latest version to 57

I will offer a +500 bounty to a submission which also includes a save file for a world which:

  • Is a vanilla Minecraft Java Edition snapshot 21w20a Hardcore world
  • Meets the requirements for the main challenge
  • Has 3 chests with all 57 non-renewable items, as listed above


  • Is this clear enough?
  • Are there any ways this can be exploited, so that users can trivialise the task? How can I prevent those exploits?
  • Is it a good challenge?
  • Tags are , and (meta discussion). Any suggestions?
  • Minecraft is not free, thus limiting those who can compete. Is this a significant problem?
  • Any further feedback?
  • \$\begingroup\$ I don't think minecraft being not free is a relevant problem here \$\endgroup\$ May 27 at 18:32
  • \$\begingroup\$ I'm sure I saw a way to renew Spore Blossoms in one of the recent snapshots \$\endgroup\$
    – pxeger
    May 27 at 18:35
  • 2
    \$\begingroup\$ There are, frankly, trivial ways to exploit this system. For it to be more or less uncheatable you would need a speedrun-style verification system requiring full screen recording and ideally livestreaming for the whole thing. I don't think it's a good fit for the site, to be honest, because there's really nothing code-related about it (Code Golf and Coding Challenges), and because it's too complex to implement a reliable verification system. You could try proposing it as a category extension on speedrun.com, though \$\endgroup\$
    – pxeger
    May 27 at 18:41
  • 4
    \$\begingroup\$ Honestly this might be better as an off-TNB hosted competitive event where a bunch of people can stream (to minimize cheating) and attempt to get [as many of] these resources [as quickly as possible], if we want this to be a thing for people in this community to do for fun. In any case, this was a cool idea initially, but I do agree with pxeger that there isn't really anything in scope for CGCC about this. \$\endgroup\$
    – hyper-neutrino Mod
    May 27 at 18:52
  • \$\begingroup\$ Is Bedrock allowed? \$\endgroup\$
    – emanresu A
    May 28 at 5:30
  • \$\begingroup\$ If you do make it a TNB event (or even if you don't?), maybe the scoring system should take into account the rarity of each item. So coal ore scores 1 point and enchanted golden apple scores 10 or something \$\endgroup\$
    – pxeger
    May 28 at 13:11
  • \$\begingroup\$ Question - are we allowed to start with anything, as long as we get the items from the world itself? \$\endgroup\$ May 28 at 16:04

for (a.length of a)

A recent conversation in The Nineteenth Byte about language design brought about discussion of an "interesting" snippet of JavaScript code:

for (a.length of a) console.log(a)

This loops over the elements of a, but assigns each element to the length of a, and prints out a on each iteration.

  • When an array's length is assigned, it is resized to the length, with excess elements being removed from the end, and additional elements filled with undefined
  • When an array's length is assigned to undefined, an error occurs
  • The loop will halt if the number of iterations is ever greater than a.length

Depending on the contents of a, this produces some wild results.

TODO: finish this post. Posted without finishing to test if Redwolf Program's Sandbox Posts bot is working :)


Given a black-box function f(x) which take a value x and output true for \$p(x)\$, an unknown continious monotone function(not knowing even whether it's increasing), probable; and false otherwise. Output an infinite sequence \$a_n\$ such that \$\lim_{n\rightarrow \infty}p(a_n)=0.5\$. You can assume that the result exists.

Reasonable I/O allowed. Shortest code win.

A possible solution:

for i=1..infty
    S = [i/2] * i*i*2
    for j=0..i*i*2-1
        for k=1..i
            if f(j/i-i)
    print minPos([t*t for t in S])/i-i

Try It Online!

  • \$\begingroup\$ So we are given two functions f and p and need to define an infinite sequence? \$\endgroup\$
    – Quelklef
    Mar 26 at 1:55
  • \$\begingroup\$ You're not given p, and you're to find a such that p(a)=0.5 \$\endgroup\$
    – l4m2
    Mar 26 at 5:58
  • \$\begingroup\$ If we are not given p, how are we supposed to find a? Do you want us to generate an a that works for every p? \$\endgroup\$
    – Quelklef
    Mar 26 at 6:51
  • \$\begingroup\$ @Quelklef Try some a and adjust till probable is 0.5 \$\endgroup\$
    – l4m2
    Mar 26 at 7:19
  • 2
    \$\begingroup\$ I completely do not understand. Is it possible you could provide an example solution in your problem? That may help others confused like me. \$\endgroup\$
    – Quelklef
    Mar 26 at 15:13
  • \$\begingroup\$ Say, \$ p\left(x\right) = \frac{4\pi + 2\arctan\left(x\right)}{5\pi} \$. How can you find out such a sequence \$ a_n \$ let \$ \lim_{n\to\infty}p(a_n)=0.5 \$ \$\endgroup\$
    – tsh
    Mar 29 at 8:44
  • \$\begingroup\$ Even if we can safely assume that there is a value \$x\$ that \$p\left(x\right)=0.5\$, I don't think anyone can provide sequence would even convergent with a non-zero probable. \$\endgroup\$
    – tsh
    Mar 29 at 8:51

duplicate :(


Convert Lambda Calculus to SKI-notation

Lambda calculus is a formal system in mathematical logic for expressing computation based on function abstraction and application using variable binding and substitution.

However, it's possible to translate pure lambda calculus into SKI-notation. This can be preformed by building an AST for the lambda calculus, converting it through multiple substitution steps where it contains a mixture of lambda calculus and SKI-notation, until a pure SKI-notation expression is reached.

As this is code golf, there is some flexibility on your I/O so that you may be able to accept the lambda calculus and output the SKI-notation as a tree but the examples will use a string-based notation.

  • (c1), where c1 is an arbitrary expression that does not contain a lambda (represented here by >), does not require further substitution.
  • (c1(c2)), where c1 and c2 are arbitrary expressions, can be substituted with (s1(s2)), where s1 and s2 are the result of performing any necessary substitutions on c1 and c2.
  • (x1>x1) can be substituted with I.
  • (x1>c1) (where c1 can be an arbitrary expression as long as it does not contain a reference to x1) can be substituted with (Ks1), where s1 is the result of performing any necessary substitutions on c1.
  • (x1>(x2>x1)) can be substituted with K.
  • (x1>(x2>e1)) (where e1 is an arbitrary expression that is depends on but is not x1) can be substituted by performing substitutions on (x2>e1) resulting in s2 and then performing substitutions on (x1>s2).
  • (x1>c1(e2)) (where c1 can be an arbitrary expression as long as it does not contain a reference to x1) can be substituted with (s1(s2)), where s1 and s2 are the result of performing any necessary substitutions on c1 and (x1>e2).
  • (x1>e1(e2)) can be substituted with (S(s1)(s2)), where s1 and s2 are the result of performing any necessary substitutions on (x1>e1) and (x1>e2).

Naturally function application associates left-to-right, so in the case of (x1>c1(c2)(e3)(c4)) this needs to be substituted using the last rule as if it was (x1>(c1(c2)(e2))(c4)), which requires generating substitutions for (x1>c1(c2)(e2)) and (x1>c4), but then (x1>c1(c2)(e2)) can use the penultimate rule, turning into c1(c2)(x1>e2), with (x1>e2) still needing to be substituted.

Given an input expression of lambda calculus, please convert it to SKI-notation. You must use the above substitutions at a minimum, but you can perform additional reductions if you wish, so for instance if you use a string-based notation then you may simplify ((S)(K)) to (SK) or even SK depending on context.

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

  • \$\begingroup\$ I'm a little unclear as to whether we can output any SKI expression so long as it is equivalent to the input and you are just laying out an example algo or whether we have to output the result of that algo (plus optional substitutions). \$\endgroup\$
    – Grain Ghost Mod
    May 29 at 11:23
  • \$\begingroup\$ I think also a definition of what it means to be equivalent between the two systems and within the systems themselves would be helpful. \$\endgroup\$
    – Grain Ghost Mod
    May 29 at 11:24
  • \$\begingroup\$ @WheatWizard You have to show that you do no worse than the example aglo. In theory the post will have enough examples so that you just need to be able to match or beat all of the examples. \$\endgroup\$
    – Neil
    May 29 at 12:44
  • \$\begingroup\$ I'll have to work on that definition because I don't want to accidentally be too restrictive or indeed lenient. \$\endgroup\$
    – Neil
    May 29 at 12:48
  • \$\begingroup\$ Closely related: unrestricted conversion challenge, metagolf version \$\endgroup\$
    – Bubbler
    Jun 7 at 7:01

Conic Sections (simplified)

Given the equation of a non-parabolic conic section, output its characteristics.


This assumes prior knowledge of hyperbolas and ellipses, as well as their characteristics. (This includes circles; they are a special case of the ellipse with eccentricity of zero.)


A non-parabolic (to simplify things) conic section given in the standard equation form. To simplify things further (because the main point is not to perform linear algebra magic) there will be no xy term. This is an example of a valid equation:

x^2+6x+y^2-8y+15=0 // string form
[1,6,1,-8,15]      // array form

These are not:

x^3+5x^2+7x+4=0 // because the degree of the equation is 2
x^2+5xy+y^2-4=0 // because there should be no `xy` term
x^2+3x+7=0      // because there should be `x` and `y` terms.

Note that the conic section can also be taken as an array as shown above. If so, please specify the order of the array; I am flexible when it comes to this format, As long as there are 5 elements with nonexistent terms represented by zero (like no y term in x^2+5x+y^2+14=0) and that the terms they represent are x^2 x y^2 y c where c is a constant. The equation will always be <expression> = 0.


Output should be the type of section, center, horizontal radius, vertical radius, foci and eccentricity (in whatever desired order). This can be output as a string or an array as long as it is clear. A valid output for x^2+6x+y^2+8y+16=0 (or its array equivalent) would be:

["ellipse", [-3, -4], 3, 3, [[-3, -4]], 0]


-3 -4
-3 -4

or similar.

(no need to output "circle" because it is a special case of the ellipse)


  • duplicate?
  • should I edit in info on conic sections?
  • should I create the characteristics tag?
  • \$\begingroup\$ One issue with the x^2+5xy+y^2-4=0: It is a valid conic section (hyperbola). \$\endgroup\$ May 30 at 21:01
  • \$\begingroup\$ @fasterthanlight I know, but we are not considering xy terms in this challenge. \$\endgroup\$
    – user100690
    May 31 at 8:01

Is this a trivial brainfuck NOP?

Brainfuck is Turing-complete*, which means determining the behaviour of an arbitrary program is undecidable. However, we can get arbitrarily close to this if we limit ourselves to detecting a limited subset of programs.

For this challenge, we will detect a limited subset of NOPs - that is, snippets of programs which have no effect including on the brainfuck interpreter's state - which I have declared "trivial NOPs".

Here is a recursive definition of a trivial NOP:

  • the empty string is a trivial NOP
  • snippets consisting only of characters outside the set []<>+-,. (that is, characters which are ignored in Brainfuck), are trivial NOPs
  • the concatenation of two trivial NOPs is also a trivial NOP
  • snippets of any of the following forms, where X is another trivial NOP, are also trivial NOPs:
    • +X-
    • -X+
    • <X>
    • >X<

We will assume brainfuck has unlimited tape length. Overflow also does not need to be considered, because if a cell rolls over due to a +, a - can then underflow it back and it will still be a NOP.

Any snippet containing , or . is not a NOP because it performs impure I/O, and any snippet containing [ or ] is undecidable, so must be assumed to be not a NOP.

Your task is to, given a brainfuck snippet as a string or list of characters, determine whether it is a trivial NOP, and output two distinct values corresponding to true and false.



(empty string)


<+>+<->-             (note: even though this is a NOP, it's not a trivial NOP)



  • Can you think of any other classes of brainfuck snippet that are simple to detect as doing nothing?
  • Is this a duplicate?
  • Is this clear enough?
  • Any other feedback?

Back to the sandbox.

Challenge will be initially done on TBD, although I may do it again after that sometimes. Also, programs will be launched with a launcher shell script.


You are a programmer who has been requested to create a program that wipes out other similar programs. However, you need to have your program fight others to see how it does in the field.


You are to make a program that can run on a Debian 10 VM. If the language you use is not available by default on Debian 10, you must provide instructions or a link to the compiler.


Submissions are to be formatted as follows:

# Name, Language



More description and explanation

Link to compiler download and/or download instructions for Debian 10 GNU/Linux (also add compiler options to use when compiling.)

Requirements for being included

Your answer must have at least one upvote. You also need to include an emergency off switch and test the switch to be included, and provide the source code and have tested it on a Debian 10 VM. Also, its growth rate must be hypothetically sub-exponential (this is to stop excessively laggy answers. If you don't know what growth rate to go with, go with linear (\$O(x)\$) or Polynomial (\$O(x^2)\$,\$O(x^3)\$,etc.).


To win, you need to be the last process of the bunch, by killing other processes through a system call. If you kill important processes that result in the VM breaking, that round is ignored for scoring. A total of 100 rounds will be run, and you get a point if you are the last "malicious" process around. If there's a tie, the tiers will be put in a tiebreaker.

Pseudocode for submission example

I don't know much about coding yet, so here's some pseudocode (feel free to convert it to a real programming language and mark it as such:

Example, Pseudocode

This program simply kills processes with the word "MalicousProcess", unless it's "MalicousProcess-Example"

def Example () {
  while (system(ps aux | grep "MalicousProcess") != null) {
    for each process != "MalicousProcess-Example" {
      kill process
  return 0

fictitious compiler

Please provide more recommendations.

  • \$\begingroup\$ "This is to stop joke answers, suicidal answers (sorry EmoWolf), and malware if it shows up." I doubt it will stop joke answers (including EmoWolf). \$\endgroup\$ May 25 at 21:17
  • \$\begingroup\$ Well, then it may stop bad joke answers and malware (like :(){ :|:& };: ). Also, I sure hope stack exchange doesn't run all inputs through bash. \$\endgroup\$
    – 4D4850
    May 25 at 21:25
  • 2
    \$\begingroup\$ @4D4850 Don't worry about malware; we follow riules here :p \$\endgroup\$ May 25 at 22:30
  • \$\begingroup\$ Ok Redwolf. I'll remove the justification part, but still keep the policy. \$\endgroup\$
    – 4D4850
    May 26 at 11:50
  • \$\begingroup\$ Also, this is a little off topic, but why's your comment the only one that appears when you don't expand the comments? \$\endgroup\$
    – 4D4850
    May 26 at 12:14
  • \$\begingroup\$ @4D4850 Redwolf's comment has been upvoted, so it is viewed by stack exchange as the most important/helpful/funny comment, and the others are less important \$\endgroup\$ May 26 at 14:16
  • \$\begingroup\$ Anyway, can any of you provide any more recommendations, or do you think it's ready to be posted? \$\endgroup\$
    – 4D4850
    May 26 at 18:01
  • \$\begingroup\$ Disallowing a rate of O(e^x) doesn't disallow all exponential solutions. Is that intended? If not you should probably require it tl be subexponential \$\endgroup\$ May 28 at 6:05
  • \$\begingroup\$ Thanks for pointing that out. I'll make that change now. \$\endgroup\$
    – 4D4850
    May 28 at 14:44
  • \$\begingroup\$ Provided no recommendations are made by Sunday 9:00 Central time, I'll post this question on the main site. \$\endgroup\$
    – 4D4850
    May 28 at 23:37
  • \$\begingroup\$ Ok, I'm posting the question. \$\endgroup\$
    – 4D4850
    May 31 at 13:11
  • \$\begingroup\$ Nevermind. Back to the Sandbox. \$\endgroup\$
    – 4D4850
    May 31 at 15:51

Demonstrate some easier abstract algebra

From my related challenge, Demonstrate some advanced abstract algebra

Consider a binary operator \$*\$ that operates on a set \$S\$. For simplicity's sake, we'll assume that \$*\$ is closed, meaning that its inputs and outputs are always members of \$S\$.

Let's define some basic terms describing the properties of \$*\$. We can say that \$*\$ can have any of these properties, if they hold for all \$a,b,c \in S\$:

  • Commutative: \$a*b = b*a\$
  • Associative: \$(a*b)*c = a*(b*c)\$
  • Distributive: \$a*(b+c) = (a*b)+(a*c)\$, for some binary operator \$+\$ on \$S\$

We can also define 3 related properties, for a unary operation \$-\$ on \$S\$:

  • Anti-commutative: \$a*b = -(b*a)\$
  • Anti-associative: \$(a*b)*c = -(a*(b*c))\$
  • Anti-distributive: \$a*(b+c) = -((a*b)+(a*c))\$

Finally, we define 3 more, that only describe \$*\$ if the complete statement is true for \$a,b,c \in S\$:

  • Non-commutative: There exists \$a, b\$ such that \$a*b \ne b*a\$ and \$a*b \ne -(b*a)\$
  • Non-associative: There exists \$a, b, c\$ such that \$(a*b)*c \ne a*(b*c)\$ and \$(a*b)*c \neq -(a*(b*c))\$
  • Non-distributive: These exists \$a,b,c\$ such that \$a*(b+c) \ne (a*b)+(a*c)\$ and \$a*(b+c) \ne -((a*b)+(a*c))\$

We now have 9 distinct properties a binary operator can have: commutativity, non-commutativity, anti-commutativity, associativity, non-associativity, anti-associativity, distributivity, non-distributivity and anti-distributivity.

This does require two operators (\$-\$ and \$+\$) to be defined on \$S\$ as well. For this challenge we'll use standard integer negation and addition for these two, and will be using \$S = \mathbb Z\$.

Obviously, any given binary operator can only meet a maximum of 3 of these 9 properties, as it cannot be e.g. both non-associative and anti-associative.

Let's create a "table" of these properties:

Commutative Associative Distributive
Regular Commutative Associative Distributive
Anti Anti-commutative Anti-associative Anti-distributive
Non Non-Commutative Non-associative Non-distributive

Your task is to write 3 programs (either full programs or functions. You may "mix and match" if you wish).

Each of these 3 programs will:

  • take two integers, in any reasonable format and method

  • output one integer, in the same format as the input and in any reasonable method

  • be a surjection \$\mathbb Z^2 \to \mathbb Z\$ (takes two integers as input and outputs one integer). This means that for any distinct output, there is at least one input that yields that output

  • has exactly 3 of the 9 above properties. However, those three properties muse be in different rows and columns in the above table from each other. This means that it can be (for example) commutative, non-associative, anti-distributive; non-commutative, anti-associative, distributive; or anti-commutative, associative, non-distributive. But, it cannot be (for example) commutative, associative, distributive; non-commutative, non-associative, non-distributive; or non-commutative, anti-distributive, anti-associative.

This is ; the combined lengths of all 3 of your programs is your score, and you should aim to minimise this.

Additionally, you should include some form of proof that your programs do indeed have the required properties and do not satisfy the other properties. Answers without these are not considered valid.


  • \$\begingroup\$ There exists no anti-distributive surjection when \$S=\mathbb Z\$. Maybe there exists one when \$S=(\mathbb Z/2\mathbb Z)^k\$, but I haven't found one yet. \$\endgroup\$ Jun 16 at 9:12
  • \$\begingroup\$ I would remove the constraint that the operator be a surjection, and just impose that it be non-constant. If you convince yourself that such an anti-distributive operator exists, you could post the challenge, but I would change it to "write 3-9 programs, such that each property is verified by (at least) one program". That would be an incentive to have programs which verify several properties at once, but make it more manageable. \$\endgroup\$ Jun 16 at 9:18
  • \$\begingroup\$ Also, there are problems with your "anti-associativity": if b = 1, then (a*b)*c = a*(b*c). \$\endgroup\$
    – anatolyg
    Jun 16 at 10:43
  • \$\begingroup\$ @RobinRyder If \$ S=(\mathbb Z / 2\mathbb Z)^k\$, aren't anti-distributive operators the same as distributive operators? \$\endgroup\$
    – Nitrodon
    Jun 16 at 14:21
  • \$\begingroup\$ @Nitrodon Yes, of course you are right. \$\endgroup\$ Jun 16 at 15:03

Pickleball Doubles Scoring

  • \$\begingroup\$ Welcome to Code Golf, and thanks for using the Sandbox! I've fixed some formatting for you - on our site, you have to use \$ instead of $ for MathJax. At the moment, this challenge is missing an objective scoring criterion - I'm guessing you want code-golf? \$\endgroup\$
    – pxeger
    May 31 at 7:17
  • \$\begingroup\$ @pxeger: Thank you. Yes, I was thinking code golf. Would it be better to take the END state as [0,0,0] so that the format of all inputs is the same? Is there a place to get the standard verbiage for code golf? \$\endgroup\$ May 31 at 13:43
  • \$\begingroup\$ Yes, I think [0, 0, 0] is a good idea - but I think the best option is to allow answers to choose a value to represent the END state depending on their language (in some it may be easier to use null, or take a string or something...). Re verbiage, there's Standard definitions of terms within specifications, but you can also just look at the various policy posts for more information. If you have specific questions, you can always ask in our chatroom, The Nineteenth Byte. \$\endgroup\$
    – pxeger
    May 31 at 14:51
  • \$\begingroup\$ I've edited this down to a stub now that it's been posted to save space \$\endgroup\$ Jun 1 at 15:15
102 103
105 106

You must log in to answer this question.

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