# Sandbox for Proposed Challenges

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

## Posting

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.

## Discussion

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.

## Other

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!

# The max() is not enough

The max() is not enough

• This could do with a better title, any suggestions? Oct 2, 2018 at 22:14
• "Max is only half the story" Oct 3, 2018 at 2:06
• What if the largest integer in the list is not unique, do we output the second largest? I.e., with the list [1,8,4,8] do we output nothing because the 8 is duplicated, or do we output 4 instead being the largest unique integer? EDIT: Scratch the italic part before. Also, I assume we can take the input in any reasonable format? As an integer list, integer-array, integer-stream, comma-separated string, newline- or space-delimited STDIN, etc? Or is it mandatory to input it in a comma-separated string format? Oct 3, 2018 at 8:24
• Ignore the first question. Just noticed it's either nothing if all values in the list are unique, or the max otherwise (even if the largest is not unique). In that case: Can the list contain negative integers or zero? And are we allowed to output another falsey value instead of an empty output? Oct 3, 2018 at 8:25
• Can we have more test cases with all elements equal
– Jo King Mod
Oct 3, 2018 at 10:05
• I have a 5-byter ready, it's a great challenge if it isn't a duplicate!
– maxb
Oct 3, 2018 at 12:40
• @Quintec Great suggestion to focus on "max" - definitely inspired the new title! Oct 4, 2018 at 13:13
• @KevinCruijssen / Anyone: I think failing to follow the rules to the letter should be permissible BUT carry some level of bytes as a penalty. I'm not sure what the usual is here - how about 15 bytes each for either using some other input format and for outputting garbage instead of no output? Oct 4, 2018 at 13:13
• @JoKing Of course, although I'm curious to know - is this somehow non-trivial to infer from the existing cases? What's the catch? :P Oct 4, 2018 at 13:13
• @maxb This will like be up "for real" sometime tomorrow UK time. Good luck! Oct 4, 2018 at 13:13
• Nah, but it would help people catch if their solutions are invalid. Also, I would discourage byte bonuses/penalties, and just let solutions take input how they like rather than overriding the site defaults
– Jo King Mod
Oct 4, 2018 at 13:28
• @ElectricWarr The default is usually to have a flexible input and output formats. But if you insist on having a string comma-separated input, then I will use a split by comma instead to make it into a list in my program itself instead of taking the 15 bytes penalty, considering my full program with list input is just 5 bytes, and changing the comma-separated string to a list is +4 bytes (way below 15 ;p). I would advice to don't use penalties or bonusses at all for challenges btw (and use flexible I/O, but the I/O choice is still up to you of course if you insist on comma-separated strings). Oct 4, 2018 at 13:31
• Btw, about "Assume input integers may be more than one digit but no larger than 4 bytes", your last test case has 6-byte numbers? Oct 4, 2018 at 13:36
• @KevinCruijssen I figure I'll try strict requirements this time around and if it's a problem I'll avoid them in future. On 6-byte numbers - ha! - good point, I'll reword that. Of course I should have foreseen that here of all places "bytes" is a measure of length first and as a quantity of information second! Oct 4, 2018 at 13:46
• Polyglot, 30 bytes Takes +15 for not taking any input and +15 for not outputting anything
– Jo King Mod
Oct 5, 2018 at 1:54

# Formulize the sum: Faulhaber's formula

Sums of the form Σkⁿ over k in 1..x can be turned into a polynomial of x whenever n is a natural number.

### Examples

Σ1 = x
Σk = (1/2)x²+(1/2)x
Σk²= (1/3)x³+(1/2)x²+(1/6)x


### Criteria

You will take n as a non-negative integer input and output the coefficients in reduced fraction form of the resulting polynomial from leading coefficient down to the last non-zero coefficient.

This is code-golf, shortest code wins.

### Test cases

0 #=> 1
1 #=> 1/2 1/2
2 #=> 1/3 1/2 1/6
3 #=> 1/4 1/2 1/4  0
4 #=> 1/5 1/2 1/3  0 -1/30
5 #=> 1/6 1/2 5/12 0 -1/12


(extra spacing here is just for clarity and is not necessary.)

• 0 is positive? non-negative is better. Nov 23, 2017 at 13:40
• Fixed @user202729 Nov 23, 2017 at 13:41
• Is outputting floating point coefficient allowed? Is errors from floating point imprecision allowed? Nov 23, 2017 at 13:43
• @user202729 No, because you get some fractions like 5/12 or 1/3 with non-terminating decimal expansions. Nov 23, 2017 at 13:45
• What about the latter question? / Is errors from integer overflow (for large arguments) allowed? Nov 23, 2017 at 13:47
• @user202729 Yes, though you program should be able to handle up to, say, n = 20. Nov 23, 2017 at 13:48
• I think the answer for 3 should be 1/4 1/2 1/4. Nov 20, 2018 at 17:03
• @alephalpha thanks Nov 21, 2018 at 18:31
• Don't we already have a Bernoulli numbers challenge? Nov 26, 2018 at 19:45

# The Hungry Moose

Moose face harsh conditions during the winter. According to one source:

Their winter foods are lower quality than what they eat in summer and provides less energy, consequently, they need to eat more of it. During harsh winters, having both extreme cold temperatures and deep snow, moose expend more energy than they take in and many can starve.

## Challenge

At noon on day 1, a hungry moose starts at a food source (the top left corner). Each morning, the moose may either walk to any 8-adjacent square or stay in place. Each evening, the moose clears the food and snow from its location (adding its net nutritional value to its calorie store and setting that value in the array to 0), and before the end of the day loses 1 calorie to the extreme cold.

The moose dies when its calorie store falls to 0 or below at the end of a day. In particular, if the value at the upper-left corner is 1, 0, or negative, the moose dies on day 1.

### Input

A 2D array of integers. Negative numbers represent calorie-negative deep snow.

### Output

The maximum number of days the moose can survive (counting day 1 as a full day).

### Test cases (add)

6 0 -2 3
0 0 -5 -5
0 0 -1 3
8

42 -100 1
-100 -100 2
3 4 5
42

5 -3 1
1 -9 9
12

• What happens if all the array values are all negative? Does the moose survive a single day or none at all? Nov 22, 2018 at 20:21
• A worked example would be useful. You also need to clarify if we can wrap around the array. Nov 25, 2018 at 14:28

## Inscriptio Labyrinthica

In the burial place of King Silo of Asturias there is an inscription that reads SILO PRINCEPS FECIT (King Silo made this).

The first letter is found in the very middle, and from there one reads by going in any non-diagonal direction radiating outward. The final letter is found on all four corners. In this challenge, you'll generalize the process to make them.

## Input

A string (or equivalent), and an integer. You may make the following assumptions about the input:

• The string will have an odd length.
• The integer will be an odd number between 1 and one less than twice the length of the string.

## Output

An inscriptio labyrinthica for the string, using the integer for the height (see models). Output should be each letter with no spaces, line break as default to your system/language.

## Test cases

Note that an input of 1 or (length * 2 - 1) will result in a horizontal or vertical palindrome.

 Input: FOO, 3    Input: BAR, 1    Input: BAR, 3    Input: BAR, 5

Output: OOO      Output: RABAR    Output: RAR       Output: R
OFO                               ABA               A
OOO                               RAR               B
A
R

Input: ABCDE, 5   Input: ABCDE, 3   Input: *<>v^, 3

Output: EDCDE     Output: EDCBCDE           ^v>v^
DCBCD             DCBABCD           v><>v
CBABC             EDCBCDE           ><*<>
DCBCD                               v><>v
EDCDE                               ^v>v^


## Scoring

This is so shortest answer in bytes wins. Standard loopholes forbidden.

(I feel like I've seen one similar, but searching around I couldn't find it, and I happened to be reading about this king when I got the idea).

## Questions

In my original proposal, I had listed as a bonus to draw reading lines, but feedback was bonuses in code golf are discouraged. I still like that idea and am thinking about integrating it as a a main part of the challenge, but don't know if that would over complicate it or actually make it more interesting. The output for REI, 3 in such a case would be

I←E→I
↑ ↑ ↑
E←R→E
↓ ↓ ↓
I←E→I


The idea is that it would prevent simple flipping of data after calculating a quarter or half of the but still perhaps allow for some creative ways (I can think of some creative ways to do it shortly in some languages, but maybe it'll be overly complicated for others).

• @trichoplax I've updated the challenge based on your feedback, let me know what you think. Jun 30, 2019 at 17:20
• Looks good to me. +1 Jun 30, 2019 at 18:24
• you should now edit this to a link to the post and delete it. Thanks! Jul 24, 2019 at 19:11

# Golf the truth and null values

In many programming languages there is a null and/or other special values. Sometimes they don't follow the normal rules of boolean operations. They may not even agree with the values of the same name in other languages.

Here are some different kinds of the "extended" boolean values, either borrowed from some languages or invented myself:

• False.
• True.
• Absent. All operations between absent and another operand return the other operand.
• Whatever. All operations between whatever and another operand returns whatever (itself).
• Partial. If the result can be decided using the other operand, return that. Otherwise return partial (itself).
• Error. An error as the first operand works like whatever, and an error as the second operand works like partial, except that "itself" means error. It has higher precedence than whatever and partial.

Your task is to define all these values in your language, and the 2 operations and or.

To be clear, the 2 operations should work exactly as in the following tables. The left column represents the first operand, and the top row the second operand.

and F T A W P E       or F T A W P E
F F F F W F F        F F T F W P E
T F T T W P E        T T T T W T T
A F T A W P E        A F T A W P E
W W W W W W W        W W W W W W W
P F P P W P E        P P T P W P E
E E E E E E E        E E E E E E E


## Rules

You could use anything distinct and consistent to represent these values. You don't have to use a truthy value to represent true, or a falsy value to represent false. You are allowed and encouraged to use values that contain useful code, i.e. this loophole is not forbidden.

You are allowed to use actual errors or exceptions to represent some of the values. In this case the definition of that value should throw the same error, instead of represent the caught error. But the caught errors or the output messages should be distinct and consistent. Alternatively, you may choose to include STDERR in the output of your code, and use the printed message string as a normal value.

You may choose to pass functions generating and returning the values but doing nothing else to your code as input, in place of the values themselves, without counting the extra code.

You may use different ways of input/output for different values, as long as it is consistent for each kind of value, and it is possible to tell apart the first and the second operand.

You are allowed to use builtin functions and operators without boilerplate, in any argument order, even if you cannot save them in something callable in your language.

There could be some common code shared by all the 8 definitions and appear only once as header/footer. Other than that, the 8 definitions of operations and values must work independently from each other. The only way you can call something defined in the values in the operations is through a valid input method (e.g. you cannot set a variable in a value and read it in an operation).

Your score is the length of common code * 12 + the total length of the 2 operations * 6 + the total length of the values. Smallest score wins. The length of a value is either the length of the code generating it, or the length of itself unquoted if all the values are strings and you choose this way.

## Abandoned rules

You are allowed to use operators, or chains of operators and values to represent the 2 operations, even if you cannot save them in something callable in your language. You may require the operands to appear at specific positions, but each operand must appear exactly once and be grouped together. You may choose whether to save operands in variables previously, and don't count the assignment if it doesn't add new information in the assignment (e.g. by changing its type). This makes it possible to use the built-in operators with short-circuit evaluation in languages that don't allow redefining them and preserve this characteristic, and may also make it shorter in some other languages.

Previous scoring: total length of the 2 operations * 50 + the total length of the values.

## Possible follow-up

Original title: All the weirdness about the nulls

Extended tables including Valid in a previous version, Reverse aka Opposite by Zgarb, and Possible.

and T F N O W E V R P     or T F N O W E V R P
T T F T O W E ? F T      T T T T T W T T T T
F F F F F W F F F F      F T F F O W E ? T F
N T F N O W E ? ? ?      N T F N O W E ? ? ?
O O F O O W E ? O O      O T O O O W E ? O T
W W W W W W W ? W W      W W W W W W W ? W W
E E E E E E E ? E E      E E E E E E E ? E E
V T F ? O F F ? ? ?      V T T ? T F F ? T ?
R F F ? O W ? ? ? ?      R T T ? O W ? ? ? ?
P T F ? O W ? ? ? ?      P T F ? T W ? ? ? ?


• Default, that is opposite to Opposite.
• Merge Possible with Valid.

## Sandbox questions

1. Will this be too easy in some languages that already have all of them?

In languages that has True defined to be -1 and unifies bitwise and logical operations, most integers would works as Partial. GCD/LCM in APL is similar to this. SQL null is Whatever Partial. Most languages that has shortcut evaluation has errors as Error. Not sure about Absent, though.

(Maybe the easiest way to find out is to post this question. It doesn't make the answer bad. But it's just some consideration in the sandbox for me to decide whether I'll post a stronger version.)

2. Allowing "operators and chains of operators" seems to open a can of worms. Should I just remove this rule?

• How about Opposite that behaves like the negation of the other operand? Dec 11, 2016 at 19:10
• @Zgarb Too similar to Other. For the "2 more to be added", I intended to make it possible to write expressions to 1) decide whether a variable is a specific value, and 2) return a specific value if a variable is true, or false otherwise. This may make the list more useful later. Dec 11, 2016 at 19:42
• @Zgarb I gave up and even removed one, to make hardcoding the tables less likely to be the optimal way. Dec 13, 2016 at 17:56
• if(whatever){/*???*/} Dec 13, 2016 at 20:23
• @Zgarb I forgot this post for some reasons. Now I found your idea quite interesting. But I'll post the first version without it, and may add a stronger version if it worked well or is too easy, and may name it Degenerate to make most of the other results from operations make sense. Apr 30, 2019 at 8:40

# Knight's tour

A knight's tour is a sequence of moves of a knight on a chessboard such that the knight visits every square only once. For those who are not aware of how knights in chess work, knights are capable of moving in an L shape:

Tours generally apply to a regular chessboard of size $$\8\$$ however, it can be calculated for other sizes. For example, for a chessboard of size $$\5\$$, a possible knight's tour is:

Each grid size has quite a few combinations, for example, when $$\n = 5\$$, there are $$\1728\$$ possible tours and for a regular chessboard (where $$\n = 8\$$), there are $$\19591828170979904\$$. This is OEIS A165134.

## Challenge

Write a program/function that takes a grid size $$\n\$$ and outputs a possible valid board of integers.

### Specifications

• Standard I/O rules apply.
• Standard loopholes are forbidden.
• $$\n > 4\$$
• This challenge is not about finding the shortest approach in all languages, rather, it is about finding the shortest approach in each language.
• Built-in functions that compute this sequence are allowed but including a solution that doesn't rely on a built-in is encouraged.
• Explanations, even for "practical" languages, are encouraged.

### Test cases

Yet to come.

• "Your code will be scored in bytes, usually in the encoding UTF-8, unless specified otherwise.": So a Jelly answer will need to specify "Jelly (Jelly codepage)" or else it needs to count bytes of a unicode encoded source? Why not leave it out and let the tag code-golf handle the rules. And instead of generating test-cases, you could just add a program that validates the result as there are a lot of possible answers . Sep 22, 2018 at 14:19
• @ბიმო Heh, I did this back with all my challenges when I was obsessed with creating "the perfect challenge template." I'll remove it. As for the test cases/validation program, I'll probably do both. Jul 12, 2019 at 1:55
• @lirtosiast Oops, turns out I had mistaken the meaning of the Wikipedia section I just linked. I'll specify that a submission is not required to work on any $n < 4$. Jul 12, 2019 at 2:00
• Another Mathematica built-in is coming~
– tsh
Jul 12, 2019 at 7:27
• Can output be a list of coordinates?
– tsh
Jul 12, 2019 at 7:29
• Having both test cases and a validator sounds good to me too Jul 14, 2019 at 7:59

# Babel on and on (working title...)

## Background

Babel is a cornerstone of modern web development. It takes Javascript using new or proposed ECMAscript features and "transpiles" it into an older language version, so that browsers can run it without updates. In order to do this it inserts its own shim methods, and own custom transforms.

## The Challenge

Your objective is to write the Javascript code which produces the largest babel output in characters. Your code must be less than or equal to 128 bytes in length

Babel has an online, interactive compiler which you can access HERE. It's highly recommended that you use this to form your answer. If you work locally, you are restricted to modifying only the settings that the babel website allows you to modify.. There is a guide on installing babel at the end of the question.

## Rules

• For consistency, you may use a Babel version between 7, but not above 8.* (when it eventually comes).
• You may change the interactive REPL's settings, source type, presets, options, and env-presets. You may change these settings locally if you are using a local installation of babel.
• You may only provide one input file.
• You may not exceed 128 bytes in your input file.
• You may not add your own plugins.
• You may not use the loophole listed below, or any of the standard loopholes.
• You may not use error output as a result. babel must transpile the code successfully under one of the allowed configurations.
• Neither your input or output need to run, or halt. The compilation just needs to output something.

# Examples

41 in, 1075 out

{t: [...(function*(){let [a,b]=[1,2]})]}


32 in, 1101 out

export class b{d=function*(){}}


125 in, 7336 out

const b = function*(){return function*(){return function*(){return function*(){return function*(){return function*(){}}}}}};


# Scoring

You must provide both the code and the settings you are using. For users of the online REPL, a link with the settings set in the URL suffices. The answer with the largest output with an input less than or equal to 128 bytes wins. Unlike many challenges of this nature, settings do not cost any bytes of input.

# Setting up a local environment (OPTIONAL)

Most of the people doing this challenge will probably use babel's online transpiler to complete it. In the event that the website is taken down in the future or made inadequate for the challenge, it can be completed locally. Make a folder for the challenge, and in a shell in that folder, try something like the following:

Install Babel (globally - you could do it locally)
sudo npm install -g @babel/core @babel/cli
Set your .babelrc with a preset (in this case env)
echo '{"presets": ["@babel/preset-env"]}' > .babelrc
Install babel's dependencies
npm install --save-dev @babel/preset-env @babel/core

Then, given an input file test.js, you can figure out your output score with

babel test.js | wc -c

# Questions

This is my first time ever posting one of these. Does everything look on the up-and-up?

Also, should this incorporate "the less characters of input, the better?". I kept trying to think of ways to reward a large output for a small input, but every way I considered changed the tone of the challenge significantly.

Also also, I know that codegolf users don't like being constrained to one language. Is this bound to be an exception or will that stop the question in its tracks?

Proposed Tags: [BUSY BEAVER], [Javascript], [CODE CHALLENGE]

• Hi and thanks for using the sandbox! I'll start right off by saying I don't know enough about babel to particularly talk about if this will be interesting. I think this kind of challenge is fine, just like regex-golf. This should probably be tagged code-challenge and shouldn't be tagged compiler. I am concerned that you tie everything to an external site. While I doubt the site will go down, what happens when they update babel? Will it break the challenge? Since this is a bit abnormal, you may want to ask on meta (specifically about the online scoring) or in chat for more feedback. Jul 1, 2019 at 21:56
• @FryAmTheEggman thanks for the tags and pointing me to meta for this, I think I'll wind up clarifying things over there. And also, about the foreign site - it's not required, but makes it far, far easier. That's why I edited in the clause about being able to do it locally. If the site is used, the settings are query parameters in the URL (but could be interpreted even if it went down). And contestants can do it locally, provided they post the settings they use, and use the same version. So I'm not too worried about tying it to a site, since it's just for convenience. Jul 2, 2019 at 12:52
• We discourage language specific challenges when there is no reason for it, but here it is clearly part of the challenge so I see no problem at all. Jul 16, 2019 at 20:42
• Having a fixed number of input bytes to work with can be awkward in language agnostic challenges as it's difficult to choose a suitable number that doesn't make it too difficult / too easy for some languages. Since everyone is using the same language here a fixed 128 bytes seems reasonable. Your examples already show it doesn't need to be higher. You could consider lower, depending on how you want the challenge to go. With 128 bytes there's a good chance some outputs will be too large to fit in the 65536 character answer length limit, but I don't see that as a problem either. Looks good to me Jul 16, 2019 at 20:47

## Castilian Numerals

A little known (but actually real) number system are the Castilian numerals. They were an odd mix of a digital and positional counting system used in Spain in the late middle ages. There are certain qualities about them, however, that make them not entirely straight forward to generate when you have lots of them in a group, in particular the fact they would be aligned by thousands places. Your challenge will be to print a vertical list of numbers, correctly spaced.

## Description of the Numerals

A Castilian numeral is, in effect, a Roman numeral, but only uses 1-999, uses additives for 4 (IIIJ), 9 (VIIIJ), and 900 (DCCCC), and subtractives for 90 (XC) and 400 (CD). Both methods were commonly used for 40 (XL, XXXX). Additionally, final Is were written as Js, such that the sequence 1-6 goes J, IJ, IIJ, IIIJ, V, VJ. (This means standard Roman numeral generators will likely not be much help.) They were generally written lowercase, but for this challenge we'll use all uppercase.

For values under between 1-999, the fact that the letters indicated numerals was made clear by the presence of a symbol that looks like a U. Generally the numerals themselves were right aligned:

1          U           J
2          U          IJ
999        U DCCCXCVIIIJ


For values between 1000-999999, everything we would place to the left of the comma would be rendered as if it were its own independent 3-digit number and romanized, and the reminder placed to the right, such that

  1,000    J U
1,001    J U          J
21,030  XXJ U        XXX
500,444    D U CDXXXXIIIJ


For values 1,000,000-999,999,999, an additional separator was used, Qto, but for our purposes, we'll just use Q. It would only be used if the number was over 1,000,000, unlike the U that always separated it.

  1,000,000       J Q       U
1,000,001       J Q       U            J
1,001,000       J Q     J U
1,001,001       J Q     J U            J
123,456,789  CXXIIJ Q CDLVJ U DCCLXXXVIIIJ


As should be noticed, within each grouping of three (arabic) digits, everything is right aligned, with the thousands/million separators all in alignment. Because 0 didn't exist, it would just be left blank.

## Input

A sequence of integers in whatever format you feel gives you the best advantage (a list, an array, a series, etc). You may assume that the integers are between 1 and 999,999,999.

## Output

A printed list of Castilian numerals, properly aligned on different lines. Note the restrictions on 4/9: mandatory additives are 4,9,900; mandatory subtractives are 90 and 400; 40 is valid either way. The numerals for 1-999 should be right aligned, with a single space on either side of Q or U (there may be padding spaces, but the single longest numeral in each grouping will have the single space). Newlines may be whatever is native to your system/language.

## Rules

This is code golf. Fewest bytes wins. Standard loopholes forbidden.

## Test cases

Comments/observations are given after # and not part of the output.

Given: 1,2,3
U   J
U  IJ
U IIJ   # one space between U and I

Given: 1,1000,10,100
U J
J U     # trailing space not required
U X
U C

Given: 123,4,5678,111111111,90,12345,6789012
U    CXXIIJ
U        IV
V U DCLXXVIIJ   # single space between U and the longest numeral
CXJ Q       CXJ U       CXJ   # Q only appears if >= 10^7
U        XC
XIJ U  CCCXXXXV   # also valid CCCXLV
VJ Q DCCLXXXIX U       XIJ   # single space between Q and the longest numeral


## Polyglot wrappers

Many polyglots are a disastrous mess of unmaintainable code. Let's make this different.

Challenge

Make a polyglot "wrapper" such that code from two or more languages may be embedded in the file without modification.

Example

Consider the following polyglot wrapper for Bash and Python:

'''true'
B
exit 0
#'''
P


This wrapper can be used such that B can be replaced by an arbitrary bash script, and P can be replaced by an arbitrary python script.

After the scripts have been injected into the wrapper, running the resulting polyglot via either interpreter (bash or python) will result in functionally identical behavior as the original input scripts.

Rules

1. Your wrapper must support the injection of 2 or more languages
2. Your wrapper can use arbitrary markers for the string->script replacement
3. The markers must be at least 1 byte in size (no line number tricks)
4. Assume the replacement will be done by first replacing all markers with sufficiently long and random data, such that conflicts between the marker literals and contents of the input code cannot exist. However, your markers cannot conflict with the contents of the wrapper itself.
5. The behavior of the original input programs must not be altered by the wrapper. Ex: an input program that returns 0 must return 0 when run from your wrapper. An input program that crashes must still crash.
6. The winner is the polyglot wrapper that supports the most languages, with a tie breaker of smallest size (in bytes).
7. Allowances shall be made for a program that accesses itself on disk. Obviously no polyglot wrapper could correctly return identical output for a script that outputs its own file size.

Question for the sandbox

Is this sufficiently unique and understandable? Are there any loopholes I haven't covered?

• What if, for example the bash script contains '''? Is that what rule 4 is talking about, since I don't really understand that rule.
– Jo King Mod
Sep 2, 2019 at 5:51
• I'm indeed wondering the same as @JoKing. What if the content of the code we'd potentially insert into the wrapper contains something that could break the wrapper or other program itself? For example, let's say I submit 0W, where 0 is a wrapper for a 05AB1E program, and W for a Whitespace program. 05AB1E in general ignores all whitespaces between commands and Whitespace ignores all characters except for spaces/tabs/newlines. But what happens if the potential 05AB1E program contains a string with a space/tab/newline in it, which would interfere with the Whitespace program? Sep 2, 2019 at 9:25
• Perhaps make it such that the inner programs are a turing complete subset of the parent language, such that the overall program will always run correctly. Answers would have to make a list of restrictions placed on the language subsets, as well as prove that they are still turing complete, and can't 'break out' of their wrappers, nor have effects on other sections of the program
– Jo King Mod
Sep 2, 2019 at 12:08
• Would this work as a cops and robbers? Cops provide wrappers and robbers provide code that breaks the wrappers? Sep 3, 2019 at 11:49
• Good catch, everyone! I'll have to think about this some more. Cops and robbers sounds like a good way to make that problem into a feature, @trichoplax Sep 3, 2019 at 14:16
• Your example can break in a different way too. An unterminated here-doc in bash will continue until the end of the script: B = cat << EOF Sep 8, 2019 at 6:29

# Translate a simple sentence from Toki Pona

• grammatical construct - this term seems too general. why not call these predicate marker and object marker, or simply "li" and "e" in quotes?
– ngn
Oct 25, 2019 at 11:44

# Is it a Snake Cube?

A snake cube is a quite popular wooden puzzle. There are usually 27 cubes threaded on an elastic string. Each cube has a hole that either goes straight through from one face to the opposite face, or that makes a 90° bend, that means it exits through a face that is adjecent to the one it enters. (And the two end cubes into which this string enters. Two adjecent cubes on that string can rotate against eachother. The goal is rotating them all such that the whole "snake" forms a large 3x3x3 cube.

Images from Wikipedia (1)(2)

Obviously we cannot have any random sequence of the straight/90° pieces if we want to get a cube in the end. This leads us to the

### Challenge

Given a sequence of the types of the inner 25 cubes of a "snake", determine whether it is possible to form a cube.

# Example

I will here use the symbol T for a piece with a straight hole, and F for a piece with a 90° hole. The example in the image would be encoded (from the bottom left to the top right) as

TFFFTFFTFFFTFTFFFFTFTFTFT


### Details

• You can take the input as a string or list/array or any other type of sequence.
• You can use different symbols for the two types, you could also take booleans or integers.
• The output is also flexible: You're can have two distinct output, one for each case, but they must be consistent. If it is not obvious (e.g. True/False) please specify which one means what.

### Examples

No cube possible:

TFTFTFTFTFTFTFTFFTFFFTFFF (we have 8 consecutive (overlapping) straight runs of length 3)
TFTFTFTFFFFTFTFFFTFFTFFTT (we have a straight run of four pieces at the end)


Cube possible:

TFFFTFFTFFFTFTFFFFTFTFTFT
TFTFTFTFFFFTFTFFFTFFTFFFT

• Oh hey, I have that exact cube, but I forgot how to put it back together again
– Jo King Mod
Dec 14, 2019 at 2:44
• @JoKing ...then I should maybe modify the challenge and ask for the solution as output :P Dec 14, 2019 at 9:37
• Don't worry, I dug it out of the drawer it was stuck in and finally solved it
– Jo King Mod
Dec 16, 2019 at 7:07

# Rennab

Reverse banneR

In the language of your own choosing write a program or function that takes as input the output of the super-handy-for-the-farsighted tool banner. And simply outputs the original text.

Example 1a of banner output on Linux:

> banner 'Code Golf'

XXXX              XX                    XXXX            XX       XX
X    X              X                   X    X            X      X
X                    X                  X                  X      X
X        XXXXX   XXXXX   XXXXX          X        XXXXX     X     XXXX
X       X     X X    X  X     X         X       X     X    X      X
X       X     X X    X  XXXXXXX         X   XXX X     X    X      X
X       X     X X    X  X               X     X X     X    X      X
X    X X     X X    X  X     X          X    X X     X    X      X
XXXX   XXXXX   XXXXXX  XXXXX            XXXX   XXXXX   XXXXX   XXXX


Example 1b of rennab program that runs on Linux and takes input from stdin as lines of strings, and outputs to stdout, and supports the characters: [' ', 'C', 'G', 'd', 'e', 'f', 'l', 'o']:

> banner 'Code Golf' | rennab
Code Golf


Example 2a of banner output on Linux:

> banner ':-)'

X
X
X
X                X
X
XXXXXXX     X
X
X
X               X
X
X


Example 2b of rennab program that runs on Linux and takes input from stdin as lines of strings, and outputs to stdout, and supports the characters: [':', '-', ')']:

> banner ':-)' | rennab
:-)


Choose what ever characters (minimum of 3) you want to support but that effects your score (see Rules below).

Rules

• Program or function - your choice.
• Input the output of banner in whatever format you'd like (eg 2d array of characters, list of strings, reading from stdin straight from the horse's mouth, &c).
• For this challenge we'll use Cedar Solutions' open-source GNU/GPL banner implementation common on Linux. Prints horizontally only with a fixed size.
• Output the original text in whatever format you'd like, return character at the end optional (eg as a string, a list of characters, as output to stdout, &c).
• You can assume only the characters supported are input.
• You must support a minimum of 3 characters.
• Score is calculated by this formula (where $$\n\$$ is the number of code bytes and $$\c\$$ is the number of characters supported): $$\n - 8c\$$.
• Scores can be negative.
• No standard loopholes.
• Lowest score wins.

Questions

• Has this been done before?
• Is the score formula any good? Any and all suggestions welcome.
• Is the question any good? Any and all feedback welcome.
• Shouldn't banner output be rotated 90 degrees? When I was testing banner, everything was sideways, not horizontal. Jan 13, 2020 at 20:55
• @Jono2906 The output in my post is copy/pasted straight from my Linux terminal. Jan 13, 2020 at 21:57
• Huh, serves me right for using Unix. Jan 13, 2020 at 21:59
• @Jono2906 Found out there's a few different types of banner implementations out there thanks to your comments. I've picked the one I'm used to and noted that in the post. Thanks :-) Jan 15, 2020 at 10:59
• No problem! I learnt something myself as well (the banner command and also that different OS's implement commands differently). Jan 15, 2020 at 11:02
• This is pretty similar, just a different big-character set. Jan 17, 2020 at 19:50
• This one is also really close, with just slight modifications to the big-character set. Jan 17, 2020 at 19:52

## Reversed Iota's code-golf

I didn't invent this challenge, but I find it very interesting to solve.

For every input number, e.g.:

4


Generate a range from 1 to that number:

[1 2 3 4]


And then, for every item in that list, generate a list from 1 to that number:

[[1] [1 2] [1 2 3] [1 2 3 4]]


Then, reverse every item of that list.

[[1] [2 1] [3 2 1] [4 3 2 1]]


## Notes:

• 1 being a loose item is allowed, since flattening will not matter with this anyway.
• To preserve the spirit of the challenge, the range has to be 1-indexed.
• How should output be formatted? Jan 26, 2020 at 16:20
• This old challenge is pretty similar. The regular challenge isn't really a dupe, but one of the more common ways to get the bonus was to do essentially this. I don't think I would close it because the old one has a bonus, but I can't speak for everyone. Jan 26, 2020 at 19:01
• A naming suggestion: Reveresed Iota's Jan 27, 2020 at 9:05
• May the initial 1 be a loose item instead of a list [1]? I.e. 3 bytes in Jelly. Jan 28, 2020 at 13:37

# Is it a doubling sequence?

Posted here:

Is it a doubling sequence?

• Can the input array be empty or of length 1?
– Jo King Mod
Feb 12, 2020 at 1:45
• @JoKing In that case, the output must be vacuously True, I guess. Feb 12, 2020 at 4:47
• @JoKing good question, I edited the input to only handle arrays with two or more numbers. Feb 12, 2020 at 13:16
• The initial set of squares should have a guaranteed distance from each other set of squares. grid needs better specification. What does "nearby square" mean? Other than that, solid spec. Oct 31, 2018 at 13:12
• 1) The wording is weird on the Game of Life rule explanation. Please take a look at the Wikipedia page and clarify them. Currently, I'm not sure if a cell can change color if it's surrounded by more opponents than allies. Also, it seems to be implied that a live cell surrounded by 3 neighbors dies (which I'm pretty sure wasn't your intention). 2) What happens when no colors remain on the board? 3) Nitpick: the "this" in "it has at this time" threw me off - "that" instead, perhaps? Oct 31, 2018 at 13:18
• 4a) Since there's no explicit ban on cooperation, it's allowed by default. Was this your intention? 4b) Can bots communicate with each other? 5) Can bots store data across games? 6) Can we get a more easy-to-use system of storing data within one game? Scopes are useful for this: function externalFunc() { /* Storage */ return function gameLoopFunc(args) { /* Code */ }; } 7) next is not very robust. Some people (including myself) will remake the game simulation to gain access to more advanced functionality. 8) What happens if the returned value isn't within 2 cells of one of my own cells? Oct 31, 2018 at 13:30
• 9a) Why is selecting a live cell that is not your own a legal move, despite not doing anything? 9b) Is it legal to pass a move always? If so, what should we return if we want to pass a turn? 9b2) If it's not legal to pass a turn... why? It sounds pretty useful and makes sense. Please consider it. Oct 31, 2018 at 13:33
• @NathanMerrill Thanks, I've clarified that now. Oct 31, 2018 at 13:46
• @Alion I've fixed 1, 3. I've removed next - good point (7). I've changed access to localStorage to access to this, clears between games (5,6). I've changed the scoring to a percentage and clarified draws (2). I've clarified that passing values out of bounds is illegal (8) and what (9a) does. I've also made passing legal (9b/c). (4) I did intend for cooperation (but not communication) to be legal; I've clarified that. Thanks for all the help! Oct 31, 2018 at 14:02
• Splendid work. That being said, I'm not done yet. 10) Typos: id > it (line 2 of rule explanation), bot's > bots' (last restriction). 11) Can bots modify the grid passed to them (in the non-malicious sense)? 12) Black doesn't immediately strike me as a living cell. I'd recommend specifying that there exist neutral living cells (I only realized this during my 4th reading). 13) What format should submissions be? Template and example submissions both work. 14) Controller: If you haven't already, you should check out Dave's JS KotH framework. Oct 31, 2018 at 15:21
• 15) You've opened Pandora's Box with cooperation restriction. I'll illustrate what I mean with several abstract examples. GrudgeBot and PassiveBot: GrudgeBot will not attack PassiveBot, because PassiveBot doesn't bother GrudgeBot. FriendlyBot: Attempts to make friends with bots that it comes into contact with by testing if they will attack it. 2 instances would quickly team up after meeting each other. AlgoBot: Runs simulations and tests how well other bots play according to its idea of "optimal". 2 instances quickly realize that the other is playing optimal or near-optimal moves and team up. Oct 31, 2018 at 15:40
• 15 cont.) So, where do you draw the line? 16) performance.now() for timing purposes. Introduces unpredictability, but lets bots police their own time instead of their creators having to wildly guess the right values. Allowed or not? 17) cellular-automata, game, grid (maybe). Oct 31, 2018 at 15:44
• Whew, what a rampage. Despite all of that, I'm impatiently looking forward to this hitting main. Expect to see me there immediately. Keep up the good work! Oct 31, 2018 at 15:47
• Thank you very much! I've fixed (10)-(12). I'll add an example submission when I'm finished the controller - and I will definitely check out that framework! (15) - Good point, but I don't want to give an advantage to people who build multiple bots. I've added a clarification that a test for "too much cooperation" is preset move sequences and the like - identifying a bot by its strategy is okay. There's room for interpretation, but I trust that non-malicious entries will be reasonable. All of your examples I'm okay with. :) I will add some tags. Oct 31, 2018 at 15:58
• @Alion I know it's taken way too long for me to get around to this, but if you're still interested... Feb 17, 2020 at 17:32

## Is it a Happy Number? code-golfdecision-problem

A repost of this challenge (if I got the policy right).

Given a single positive integer (which can also be taken as a list of digits or a string), output whether the number terminates at 1 . Truthy/falsy follows the language's convention, or you can choose exactly one value for truthy and another for falsy. (This sequence is A007770.)

Your program should theoretically support all non-negative integers; however, if your language doesn't support unbounded integers, you may only support integers up to 2147483647.

## Procedure

Suppose you have the number 193.

• Square every individual digit in the number. Therefore the number's individual digits becomes:
[1] [81] [9]

• Sum all these individual digits:
92

• Repeat this procedure until it stabilizes at 1 or a 37-cycle like the following:
37-58-89-145-42-20-4-16-37


It has been shown that the procedure will always produce either one of these two outputs.

## Test cases

Here is a sample program generating the test cases. Here is a step by step reduction of all input between 1 and 100.

1 -> true
2 -> false
3 -> false
4 -> false
5 -> false
6 -> false
7 -> true
8 -> false
9 -> false
10 -> true
11 -> false
12 -> false
13 -> true
14 -> false
15 -> false
16 -> false
17 -> false
18 -> false
19 -> true
20 -> false
21 -> false
22 -> false
23 -> true
24 -> false
25 -> false
26 -> false
27 -> false
28 -> true
29 -> false
30 -> false
31 -> true
32 -> true
33 -> false
34 -> false
35 -> false
36 -> false
37 -> false
38 -> false
39 -> false
40 -> false
41 -> false
42 -> false
43 -> false
44 -> true
45 -> false
46 -> false
47 -> false
48 -> false
49 -> true
50 -> false
51 -> false
52 -> false
53 -> false
54 -> false
55 -> false
56 -> false
57 -> false
58 -> false
59 -> false
60 -> false
61 -> false
62 -> false
63 -> false
64 -> false
65 -> false
66 -> false
67 -> false
68 -> true
69 -> false
70 -> true
71 -> false
72 -> false
73 -> false
74 -> false
75 -> false
76 -> false
77 -> false
78 -> false
79 -> true
80 -> false
81 -> false
82 -> true
83 -> false
84 -> false
85 -> false
86 -> true
87 -> false
88 -> false
89 -> false
90 -> false
91 -> true
92 -> false
93 -> false
94 -> true
95 -> false
96 -> false
97 -> true
98 -> false
99 -> false

• Is there an upper bound for inputs? I think one thing to consider is whether you want answers to implement the square-summing operation, or to try to compress or overfit some heuristic that works for say, 1 to 100.
– xnor
Mar 28, 2020 at 10:46
• Falsy numbers belong to A007770. Mar 29, 2020 at 22:49
• @Arnauld Nice catch + Title suggestion!
– user92069
Mar 30, 2020 at 0:25
• With the term "happy number" in hand, I found a probable duplicate.
– xnor
Mar 30, 2020 at 8:37
• Ugh, why do I always have duplicate ideas recently...
– user92069
Mar 30, 2020 at 9:01
• @xnor This is a dupe indeed, but the other challenge is very old and it seems like it requires a full program with a cumbersome output format. So maybe we should rather close the old challenge as a dupe of this one instead? (I'm not sure about the right policy here.) Mar 30, 2020 at 10:38
• We did once repost Kolakoski one and closed the old one as dupe (with relevant meta discussion). But this case is a bit different because the author of the old challenge is no longer active. Mar 30, 2020 at 23:00
• @Arnauld Good point, that old challenge is sure showing its rust.
– xnor
Mar 30, 2020 at 23:14

# Posted

Solve a Picross Row

• I don't think it is a dupe of full nonogram solver. I recommend allowing flexible I/O formats though (e.g. values other than 0,1,2 to mark each cell state). May 6, 2020 at 7:54
• To make the challenge more self-contained, consider adding a brief introduction to picross/nonogram and its rules. May 6, 2020 at 9:18

# Implement an HTML renderer code-golfascii-art

Note: This challenge explaination is very much incomplete - it merely contains ideas that will require revising to form a proper challenge post.

The premise of the challenge is to write a program that take an HTML document as an input, and outputs an ASCII equivalent. Obviously, working with real HTML is not possible, so this challenge will use a very limited and modified subset of HTML.

Here is an example of a potential input:

<body>
<h1>A Document</h1>
<div>
<span>Hello, this is some text</span>
<img> 8 2 </img>
</div>
</body>


Which would yield the following output:

+--------------------+
|A DOCUMENT          |
|                    |
|+------------------+|
||Hello, this is som||
||e text            ||
||+--------+        ||
|||@~@~@~@~|        ||
|||~@~@~@~@|        ||
||+--------+        ||
|+------------------+|
+--------------------+


## HTML elements that will be implemented:

<span> - Renders text between the tags, wrapping when necessary.

Example:

<body>
<span>
This is a span element.
You can write text in here.
</span>
</body>


Output:

+--------------------+
|This is a span eleme|
|nt. You can write te|
|xt in here.         |
|                    |
|                    |
|                    |
|                    |
|                    |
|                    |
|                    |
+--------------------+


(Extra explanation needed to clarify whitespace and character set issues)

<p> (Explanations are omitted to save space)

<h1> - <h6>

<div>

<img>

## Sandbox questions/remakrs

• I believe it is possible to write an unambiguous and specific set of rules for how an "HTML document" should be rendered
• It will require lots of careful explanation, wording, and ample examples
• However this challenge seems very long and complicated and it seems like it might not be in the spirit of a code golf challenge

What do you guys think?

• "I believe it is possible" -- Yes, rewriting a subset of the HTML Spec for ASCII is possible. However, successful challenges tend to keep it simple. I'd suggest using just span and div and using no attributes. In addition, parsing has probably been done before and is cumbersome, so I'd suggest allowing input as a pre-parsed AST to focus on the key challenge of ASCII-art generation Jul 9, 2020 at 6:16
• Personally I would keep only body, div, span and img, altho img should follow a set pattern inside of it. I would also suggest making height and width attributes mandatory, in all tags.
– Dion
Jul 20, 2020 at 6:08

# Solve a 2xN Maze (posted)

• Now that this has been posted to main, could you delete this proposal to create more space for new answers? Sep 25, 2020 at 1:04

# Does the naïve fill suffice?

A bot is positioned in a rectangular grid. By preference it will paint in a west direction, but if it cannot it will paint in a south, east or if all else fails north direction. Sometimes this can lead it to fill the grid, but other times it gets stuck. The following examples show how the path (indicated by ascending digits) of the bot on a given grid varies depending on its starting position:

1


The bot is always able to fill a 1×1 grid, since simply by existing it has already painted the grid.

14    21    43    34
23    34    12    21


The bot is always able to fill a 2×2 grid. As a consequence of its painting direction preferences it normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise.

16    21    65    ..    56    65    165    216    321    654     345    456
25    36    14    21    43    34    234    345    456    123     216    321
34    45    23    34    12    21


The bot usually fills a 2×3 grid, except when it starts in the middle right square. On the other hand, it always fills a 3×2 grid; its painting direction preferences cause it to paint clockwise if it starts in the bottom middle or bottom right cell, otherwise anticlockwise.

189    21.    321    87.    987    ...    987    ...    987
276    387    498    165    216    321    236    345    456
345    456    567    234    345    456    145    216    321


The bot is able to fill a 3×3 grid when it starts in one of the even squares. It's mathematically impossible for the bot to fill it when it starts in an odd square, but I have included these positions for completeness.

Your task is to solve the of whether the bot is able to fill a given grid from a given starting point. You can assume that the grid size is a positive integer and that the starting point lies within the grid. You can take the grid size and starting point in any consistent order, as separate inputs, a pair of pairs or a list of 4 elements, or any other reasonable input format. The starting point can be 0-indexed or 1-indexed. You can use any two consistent outputs, or you can output using any values that your language considers truthy or falsy, but not both. Please include your input and output format in your answer.

The directions west, south, east or north correspond to decrementing the x-coordinate, incrementing the y-coordinate, incrementing the x-coordinate and decrementing the y-coordinate respectively.

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

Test cases (0-indexed, width height x y):

4 4 0 0 -> True
4 4 1 1 -> False
4 4 2 2 -> True
4 4 3 3 -> True
4 7 1 3 -> False

• What's the "naive fill" algorithm exactly? Jul 12, 2020 at 11:24
• Comment: it's hard for me to figure out that each "column" (separated by space) represents a x*y board. Consider clarifying that. Jul 12, 2020 at 11:25
• @user202729 The very first two sentences are supposed to describe it, just move in the first available preferred direction until you can't move any more and paint as you go.
– Neil
Jul 12, 2020 at 14:11
• Some comments: (1) You don't seem to define that "naïve fill" is. (2) It took me a while to undersdtand the meaning of the numbers 14, 21 etc mean the 2nd example, and similarly in others. After a while I realized that each "code section" contains several examples stacked horizontally. You should make thast more obvious (maybe increasing horizontal space, or explaining it in the text) Jul 12, 2020 at 15:47
• (3) "It normally traverses anticlockwise except when it starts in the bottom right corner when it traverses clockwise": what does "normally" mean here? How do we know/choose the direction the robot follows? Or maybe this is the definition of "naïve fill"? (4) Why can't the robot fill the 2×3 case when it starts in the middle right square? That is, why doesn't start by moving up instead of left? (5) In general, but I find it all quite confusing... maybe it's me, but consider explaining the challenge with more detail Jul 12, 2020 at 15:47
• @LuisMendo (1) The bot paints as it goes. It prefers to go west, but when it can't go west tries south, then east, then north. That's all there is to it. (2) I've added some more text and spacing. (3) "normally" means "most of the time it ends up doing this". (4) Because its first preferred direction is west so it ends up painting itself into a corner.
– Neil
Jul 12, 2020 at 16:53
• (1) It prefers to go west, but when it can't go west tries south, then east, then north. That phrasing makes it much totally clear. (Now I see that's probably what you meant with by preference) Include it in the text? (3) I still find the word normally confusing there, as if that were an additional degree of freedom. Also, I see now that except when it starts in the bottom right corner when it traverses clockwise is a consequence of (1). I suggest you explicitly state something like "As a consequence of the rule for direction choice, ..." Jul 12, 2020 at 17:03
• @LuisMendo Fair enough; I've tweaked the text again now.
– Neil
Jul 12, 2020 at 17:35
• I really like this challenge, but I wonder whether the title could be a little more descriptive/catchy - perhaps 'Can the bot fill the grid?' or similar? Jul 14, 2020 at 15:00
• @Dingus "Can the naïve bot fill the grid?" counts as similar, right?
– Neil
Jul 14, 2020 at 17:23
• Ooh, that's even better. Immediately makes me curious to find out what the naïve bot is. Jul 15, 2020 at 0:35

## A Spherical Die

### Inspiration

I have a spherical die, but it's a cheap one so it doesn't work properly. When I roll it, it doesn't always land directly on a "face" marking, but instead can result in an ambiguous result ("is that a 6, a 4 or a 2?")

### Assumptions

Assume the die is a perfect, evenly-weighted Unit Sphere (i.e. all points on the surface are radius 1cm from the center) , such that a "roll" can result in any point on the sphere being the uppermost point (the "roll value").

Assume that, if the die is placed or rolled such that 1 is at the "north pole", the conventions of a normal die will follow, i.e:

• 6 will be at the "south pole"
• 4, 5, 3, 2 will be on the "equator", clockwise in that order, equidistant around the sphere.

So, before it's rolled, the die looks like this:

### The Challenge

Given a simulated roll of the die (i.e. coordinates representing the top of the die after it's rolled) with the conditions above, identify the closest value (1-6) to that point (i.e. what the roll value should resolve to).

Input

A co-ordinate on the sphere.

There are a few co-ordinate systems used for spheres, the two I'm familiar with (and so will provide examples in) are as follows:

• P(1, φ, Θ) where φ is the "azimuth angle" (0..360), Θ is the "polar angle" (0..180)

• P(x,y,z) where $$\x^2+y^2+z^2=1\$$

(note: the conversion between the two is: x = cos(φ)·sin(Θ); y = sin(φ)·sin(Θ); z = cos(Θ))

for clarity:

• roll "1" is at P(1,n,0)
• roll "2" is at P(1,270,90)
• roll "3" is at P(1,180,90)
• roll "4" is at P(1,0,90)
• roll "5" is at P(1,90,90)
• roll "6" is at P(1,n,180)

Output

The nearest value (1-6) to that point. If the point is equidistant to two or more points, output any one of them.

Usual exclusions etc. apply.

• Does anyone know the maths for this? Feel free to edit it in! Nov 22, 2019 at 9:40
• I'm not sure I understand: You want us to generate a random point on a sphere and output the face of the die it corresponds to? Nov 22, 2019 at 9:57
• yeah, so generate a random point on the sphere, then find the nearest "face" - i.e. the nearest of the 6 points (top, bottom, 4 points on opposite sides around middle) Nov 22, 2019 at 11:11
• This will be exactly equivalent to a uniform distribution over 6 values, just based on the symmetry of the situation. Nov 22, 2019 at 12:33
• @AlienAtSystem yes, all outcomes are equally likely; but the challenge is determining which number any given point on the face of the sphere is closest to Nov 22, 2019 at 13:04
• That's not the challenge as posted. Right now, it's "Takes no input, returns the number the (internally generated) random point is closest to" which is, under the consensus of no unobservable requirements simply equal to "Takes no input, returns uniform random value from 1-6". If you want the challenge to be "Input is point on sphere, output is number it's closest to", then write that. Nov 22, 2019 at 13:09
• @AlienAtSystem I've edited to try and make it clearer what I'm looking for. Is it clearer now? Nov 22, 2019 at 13:15
• It's clearer that my point still stands. Look, "Make Voronoi cells on sphere" and "Generate uniformly random points on sphere" are both good challenges. But when put together like that, they annihilate each other and give you an extremely quick shortcut right from Input (None) to output (a die roll) that doesn't require calculation of either part. Nov 22, 2019 at 13:21
• @AlienAtSystem thanks for the feedback, I'd never heard of a Voronoi cell before. What I'm asking, then, is "generate a random point on a sphere and say which Voronoi cell that point is in". Can you explain why that doesn't work? Note that I'm asking for both the point and the cell to be output, not just the cell - otherwise I agree, given the "no unobservable requirements" rule it would be possible to just generate a random number and pretend you'd done it properly (although that would be against the spirit of it) Nov 22, 2019 at 13:24
• Would it be better for the point on the sphere to be the input, then? Nov 22, 2019 at 13:27
• If you want the challenge to be about finding the points it's closest to, yes. Nov 22, 2019 at 13:31
• I want it to be a good challenge on this theme, whatever that would look like :) Nov 22, 2019 at 13:33
• Although I don't think the current challenge is bad, it's usually best to not have multiple challenges into one nor multiple outputs (since some languages aren't able to output more than once very easily). The two challenges are: 1. Generate a random coordinate on a sphere (in whichever coordinate system you want); 2. Given a (random) coordinate on a sphere, output the dice-value closest to it. No. 1 already is a challenge, so I agree it might be better to rewrite it to challenge No. 2. I do like the general idea though, so +1 from me. Nov 22, 2019 at 14:36
• It would also need some info about the size of the sphere, and what to do when the coordinate is exactly in the center between two or three poles. Nov 22, 2019 at 14:39
• Note that the actual implementation is very simple, as explained in chat. Jul 15, 2020 at 2:43

Note: this challenge is a work-in-progress, so suggestions would be appreciated

Questions for meta:

• How can I prevent people from just using SHA or MD5 one-way compression?
• are these language restrictions fair?
• is this scoring system fair?
• are there any obvious cheap answers?
• what other tags should be added?
• what should the challenge title be?
• will these restrictions adequately prevent people trying to cheat their way through?
• should a limit be put on a password length? Should I limit passwords to ASCII printable characters?

# The challenge

Your challenge is to first choose a "password" (please do not use your actual password). Then, you will create a program which will output a truthy value if and only if this password is given as input, falsy otherwise. Your goal will be to make it so others are unable to reverse-engineer this password (and you will keep this password secret for now).

# Scoring

Note that you may use any tools at your disposal (online tools, brute-force attacks, modified code, etc) to extract someone else's password from their code.

Of all the safe answers, the one with the shortest source code (i.e. ) wins!

# Rules

To make things fair for everyone, you may only use languages that appear on TIO, or languages that have well-written documentation and are used somewhat widely. You must also provide a link to try your code online that anyone can access (as such, you may not use languages behind paywalls like MATLAB but Octave is still on the table because it's free).

Even if you don't want to post an answer, feel free to try to crack any of the existing answer's passwords! If you get a password, you can simply leave a comment on that answer and that answer will be cracked.

# Note

If you edit the code in your answer, the two week period will reset! You may edit any explanations in your answer freely (I will verify that any answers marked safe did not cheat).

tags: code-golf

• Example answer Aug 19, 2020 at 12:38
• Surely any cryptographic hash function (which are implemented in many languages) will make it easy to generate an impossible-to-crack answer? For instance, in R I can write test=scan(,'');if(digest::digest(test,"md5")=="b6778692586dc649267723ccc3356fad")TRUE else FALSE and I'll be pretty confident that nobody will crack my password... Aug 19, 2020 at 15:10
• That is a good point. It seems like this challenge is similar to just writing a hash function. You might want to add other ideas to make the challenge more interesting Aug 19, 2020 at 16:06
• That's what I was about to write, any hash function with a hidden default salt depending on the language, or anything like that, could be hiding the password easily enough. Aug 19, 2020 at 16:06
• @DominicvanEssen is this an actual MD5 hash? I was unable to reverse it (note that a lot of MD5 hashes can be reversed with online tools like this). Note that for this challenge people would be allowed any and all tools at their disposal to crack passwords. This means people are very much allowed to reverse-engineer code in any ways they please Aug 19, 2020 at 16:06
• Answering in many esolangs could hide the password easily enough, too. If I answer in Lenguage, Unary, Mariolang,... Aug 19, 2020 at 16:07
• @V.Courtois this is true, but the point is not to read the password in the source code. The point of the challenge would be to reverse-engineer their code to crack a password (so documentation and online tools are all fair game). Also, Unary will likely be an invalid language because people must be able to actually run the program online (and Unary programs are usually way too big to run online) Aug 19, 2020 at 16:08
• Now that I think about it, any type of loop could hide the password easily enough, too. But even with what I said before and what I'm saying now, I think this challenge has to exist (if not existing already), because having many valid answers is not a problem (not to me, at least). Aug 19, 2020 at 16:09
• @DominicvanEssen also, even if nobody can reverse your password, that's still fine - the winner of this challenge is whoever has the shortest code out of all the uncracked passwords. In other words, this is still a codegolf challenge, but answers can be disqualified if anyone finds the password. So, if you want to win but you don't have the shortest code, you simply have to crack other people's passwords! Aug 19, 2020 at 16:15
• @DanielH. Yes, my example was an actual MD5 hash (the password was mypassword). You're right that some hash functions can be reversed, but there are many cryptographically-secure ones for which this is difficult. Aug 19, 2020 at 16:17
• @DominicvanEssen I'm unfamiliar with MD5 hashes, but when I converted mypassword to an MD5 hash using three different online tools I got 34819d7beeabb9260a5c854bc85b3e44 every time instead of the hash in your answer. Could you please provide a TIO link for the R code (when I copy-pasted it into TIO it didn't work for me and I'm unfamiliar with R)? I'd like to try experimenting with MD5 Aug 19, 2020 at 16:22
• I'm afraid that the R 'digest' library is not installed on TIO (making a link was the first thing I tried). Aug 19, 2020 at 16:25
• But, after some research, it turns-out that R adds some (consistent) extra characters to the string by default before applying MD5. This behaviour can be switched off, at which point mypassword indeed hashes to 34819d7beeabb9260a5c854bc85b3e44. Aug 19, 2020 at 16:46
• how many letters are the passowrds capped at? Are unprintables allowed? Aug 20, 2020 at 3:30
• @Razetime I might add a restriction of 16 characters, ASCII printables only. I will have to try to balance this cap though - if it's too short, passwords can easily be brute-forced. If it's too long, everyone will just use one-way compression and passwords will never be cracked Aug 20, 2020 at 11:24

# Stroke Count of a Chinese Numeral codegolfPosted

• Related (not dupe). Stroke count is actually good idea because it avoids the need to hardcode Chinese characters. The description looks clear enough to me. Aug 5, 2020 at 3:11
• Might be useful: tio.run/… Aug 5, 2020 at 11:45
• (to read the test cases) Aug 5, 2020 at 11:45
• Has it been posted to main? I can't seem to find it. Aug 21, 2020 at 10:02
• @V.Courtois posted.
– att
Aug 25, 2020 at 4:54

### All work and no play but it gets thinner every time

Your objective is to output the unique string with the following properties:

• Each paragraph consists entirely of repetitions of the sentence All work and no play makes Jack a dull boy.
• The first paragraph is a single line with exactly one repetition of the sentence.
• Each line of each subsequent paragraph is shorter than the longest line of the previous paragraph.
• Each line contains as many words of the sentence as possible without exceeding the length limit, and no trailing whitespace.
• Paragraph ends when its next line would be identical of some previous line of the same paragraph, possibly terminating the last sentence early.
• The last paragraph has the same width as the longest word in the sentence (5).
• There's a pair of line ends between each pair of paragraphs, a single line end after the last paragraph, and no line end before the first paragraph.

The string produced by these rules has: 5025 bytes when using Windows line ends (CR LF) or 4796 bytes using Linux line ends (LF); 229 line ends; 103 full repetitions of the sentence and 11 partial repetitions. It can be compressed into a 249-byte deflate stream (bubblegum code). The full string is included below for reference.

All work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes Jack
a dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work and
no play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull boy.

All work and no play makes Jack a dull
boy. All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy. All
work and no play makes Jack a dull

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes Jack
a dull boy. All work and no play

All work and no play makes Jack a
dull boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work and
no play makes Jack a dull boy. All
work and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull boy.

All work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a

All work and no play makes Jack
a dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play

All work and no play makes Jack
a dull boy. All work and no
play makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no play
makes Jack a dull boy. All work
and no play makes Jack a dull
boy. All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work and
no play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull boy.

All work and no play makes
Jack a dull boy. All work
and no play makes Jack a
dull boy. All work and no
play makes Jack a dull
boy. All work and no play
makes Jack a dull boy. All
work and no play makes

All work and no play
makes Jack a dull boy.

All work and no play
makes Jack a dull
boy. All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy. All
work and no play

All work and no
play makes Jack a
dull boy. All work
and no play makes
Jack a dull boy.

All work and no
play makes Jack a
dull boy. All
work and no play
makes Jack a dull
boy. All work and
no play makes
Jack a dull boy.

All work and no
play makes Jack
a dull boy. All
work and no play
makes Jack a
dull boy. All

All work and no
play makes Jack
a dull boy. All
work and no

All work and
no play makes
Jack a dull
boy. All work
and no play
makes Jack a
dull boy. All
work and no
play makes

All work and
no play
makes Jack a
dull boy.

All work
and no play
makes Jack
a dull boy.

All work
and no
play makes
Jack a
dull boy.

All work
and no
play
makes
Jack a
dull boy.

All work
and no
play
makes
Jack a
dull
boy. All
work and
no play

All
work
and no
play
makes
Jack a
dull
boy.

All
work
and
no
play
makes
Jack
a
dull
boy.

• So a sentences can span one or more lines? Was thinking the sentences got shorter until you said there's 103 full repetitions. No clear explanation on what exactly paragraphs, paragraph widths, sentences, lines, and line ends are. Sep 28, 2020 at 15:05
• @Noodle9 I've added some of the reference output; would the reference suffice to explain those? Sep 28, 2020 at 15:30
• Can you simply add the whole output? (I still don't understand it) Sep 28, 2020 at 15:37
• @thedefault. added. I didn't want to clutter the sandbox. Sep 28, 2020 at 15:39
• Alternative name: Write a novel for Jack Torrance Sep 28, 2020 at 15:51
• Better to say what you mean by these terms. Maybe a template of the output where lines are, say, seperared by newline characters. Sentences are substring of "..." containing only whole words and ended by a period. Paragraphs are seperated by two newlines. Or whatever it actually is. Sep 28, 2020 at 17:07

# Make a quine that shrinks and grows

Write a program that outputs another program that is:

• Larger in bytes than the original
• Outputs a program that is smaller than itself that also obeys these rules and is larger than the original program

Basically the output should alternate between larger than the previous program and smaller than it, while increasing in total size as it goes.

Related

• Perhaps it should be "larger than the program two before" rather than "larger than the original?" As stated, a 5-length program could output a 7-length, which outputs a 6-length, which then oscillates between 7 and 6, not growing in total size as it goes. Oct 8, 2020 at 18:51
• Probably should be named something other than a quine because I find that term misleading for the challenge you described. Oct 14, 2020 at 21:12

# Strobogrammatic Numbers

### Definition

A number which is rotationally symmetrical, i.e., it'll appear the same when rotated by 180 deg in the plane of your screen. The following figure illustrates it better,

(source: w3resource.com)

Given a number as the input, determine if it's strobogrammatic or not.

# Examples

• Truthy
1
8
0
69
96
69169
1001
666999
888888
101010101

• Falsey
2
3
4
5
7
666
969
1000
88881888
969696969


# Rules

• The number is guaranteed to be less than a billion.
• We are considering 1 in it's roman numeral format for the sake of the challenge.
• Input can be taken as number, or an array of chars, or as string.
• Output would be a truthy/falsey value.
• This is a , so fewest bytes will win!

# Meta

• Although I've tried a search, but is this a duplicate?
• Is the challenge's text clear enough?
• Any tricky/interesting test case?
• Similar Dec 22, 2020 at 2:03

# Explain a Code Golf Answer code-golfstring

## Background

When writing Code Golf answers, it is often a good idea to add an explanation of the code so the reader understands what's going on. For example, this this answer by @Makonede (abridged):

        θ  # last element of
Σ          # the input, sorted in increasing order by
1¢    # the number of ones of
%       # modulo
žJ        # 4294967296
b      # in binary


The full program is written on the first line, then a blank line, then on each successive line, a little snippet of the program, aligned using spaces with its position in the full program, and then some comments on the right-hand side explaining each part.

I, for one, find writing and aligning these explanations tedious, so let's outsource it to a program.

Given a program as a string, and a list of sets of pairs of start/end indices to form an inclusive range, output each sub-string defined by the indices on a new line, indented to its respective position in the whole string, with a # at the end of the line, padded so that there are two spaces before the # after the last sub-string, ready for the user to add their explanation.

## Rules

• You may use 0-based or 1-based indexing
• You are guaranteed to receive valid, non-overlapping ranges, which together cover the whole string
• You may assume the program string contains no newlines, tabs or other unprintable characters, and no double-width characters
• Standard I/O rules and loopholes apply
• This is , so shortest code in bytes wins

## Examples (1-based indexing)

Inputs: abcdwxyz, (1-8)
Output:

abcdwxyz  #


Inputs: abcdwxyz, (5-7), (1-2),(8-8), (3-4)
Output:

    wxy   #
ab     z  #
cd      #


Inputs: <<<$[grep -c wx$0-grep -c y\z $0];:<<'Q', (6-20), (22-37), (4-5),(38-38),(21-21), (1-3), (39-39), (40-40), (41-45)] Output:  grep -c wx$0                           #
grep -c y\z $0 #$[               -                ]         #
<<<                                            #
;        #
:       #
<<'Q'  #


# Meta

• Is this a duplicate?
• Is this clear enough?
• Any other feedback?
• Related Dec 24, 2020 at 10:32
• @Razetime I would say this is a dupe :-( Dec 24, 2020 at 13:35
• I'd say this is simpler and more suited for code golf because it functions without the need for a complex priority system. You may want to request more opinions on the nineteenth byte. Dec 24, 2020 at 17:51

# Interpret Interval Notation

• @Adám yes to ∪ and -ish characters. I also broadened the scope to all meaningful intervals, so ranges may overlap and [5,5] (all integers x where 5<=x<=5)is [5] but not [5,5) (all integers x where 5<=x<5) and (5,5) (all integers x where5<x<5) are undefined. Dec 22, 2020 at 21:07
• All integers x where 5<=x<5 would be [], no?
Dec 22, 2020 at 22:25
• I'd put all the undefined cases separately, or at least at the end.
Dec 23, 2020 at 0:09
• Typo: the [9,13] test case should either be [9,13) or 13 is missing from the output. Dec 23, 2020 at 2:35
• undefined cases should be undefined behavior instead. Otherwise, one need to handle it separately which feels bad. Otherwise, it's a good challenge :) Dec 23, 2020 at 11:22
• If you allow other symbols for the brackets, make sure to prohibit other phrases as that can be abused.
Dec 23, 2020 at 15:16
• @Adám what do you mean by phrases? Dec 23, 2020 at 16:06
• @pxeger Multi-character constructs. It'd allow solutions to require an input format that contained the necessary code such that the solution becomes an eval.
Dec 23, 2020 at 16:46
• Related Dec 24, 2020 at 10:44
• Is parsing a string necessary? Could you also allow other constructs (tuples with a marker to show if they're open or closed)?
– user
Dec 25, 2020 at 21:56
• Just asking frankly, did you forgot to post this, or is something yet missing? Jan 4, 2021 at 2:59
• @user I am going to say no to other constructs otherwise, it is basically a duplicate of the related challenge. Jan 4, 2021 at 15:03
• @vrintle Something like that. I haven't really been active since just before Christmas. I'll probably post it this afternoon. Jan 4, 2021 at 15:04

# Implement a zipwith function

• APL or J will win this with 2 bytes (that's the shortest possible score, right?)
Jan 14, 2021 at 21:23
• Required tag: restricted-source
Jan 14, 2021 at 21:24
• Why the builtin restriction? Jan 14, 2021 at 21:45
• @RedwolfPrograms To avoid trivialising the challenge Jan 14, 2021 at 21:52
• @Adám 1) if those 2 bytes are a builtin, then no, otherwise, very possible. 2) Why [restricted-source]? Jan 14, 2021 at 21:52
• Any reason for banning that builtin in Haskell and Jelly? What's wrong with people submitting that as answer? They won't get upvoted much anyway. And it still lets people use builtins in other languages.
– user
Jan 14, 2021 at 22:14
• @cairdcoinheringaahing No, that'd be prohibited by your source restrictions rule on an exact built-in. Rather, it'd be a more general built-in (so not "exact") plus a parameter that makes the general built-in choose the required behaviour.
• Allowing the built-in and seeing how many languages have it could be interesting in its own right. Or, generalize the problem to nzipwith, which takes an n-ary function and n sequences (and optionally the value n) and call the function for each n-tuple from the n sequences. Jan 15, 2021 at 6:10
• I've softened the builtin ban to simply encourage people to post a non-builtin answer as well. @Bubbler Possibly, but I think it'd be a good challenge to simply have the basic zipwith given that it's a fairly common functional programming construct Jan 15, 2021 at 14:39
• I find the former ban on Jelly's "` interesting considering that there's no way to really pass it a function. Jan 26, 2021 at 9:36