# What is the Sandbox?

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

See the Sandbox FAQ for more information on how to use the Sandbox.

## Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]

# Pi or Phi?

Given a positive integer $$\n\$$ where $$\n \geq 10\$$ as input, determine whether $$\n\$$ occurs in the first 100 digits of pi (after the decimal), the first 100 digits of phi, or both.

### Reference

"The first 100 digits" refers to the 100 digits after the decimal place in each number

First 100 digits of Phi:

(1.)6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911374


First 100 digits of Pi:

(3.)1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679


### Input

• You can assume that the input will appear in the first 100 digits of at least one of the two numbers (pi or phi)

• Input can be taken as a number, string or any other reasonable format

• The input number will have 2 or more digits and won't exceed 100 digits

### Output

Output should be one of three consistent values:

• One to represent that the number appears in (the first 100 digits of) Pi (but not phi)

• Another value to represent that the number appears in (the first 100 digits of) Phi (but not pi)

• Another value to represent that the number appears in Both

## Examples

Input: 113

Output: Phi since the substring 113 appears in the first 100 digits of phi, but not in the first 100 digits of pi.

Input: 793

Output: Pi since the substring 793 appears in the first 100 digits of pi, but not in the first 100 digits of phi.

Input: 84

Output: Both since the substring 84 appears both in the first 100 digits of pi and in the first 100 digits of phi.

## Test Cases

113 -> Phi
793 -> Pi
84 -> Both
618 -> Phi
141 -> Pi
86 -> Both
3398 -> Phi
3993 -> Pi
39 -> Both
374 -> Phi
679 -> Pi
35 -> Both
072 -> Phi
078 -> Pi
117 -> Both
1798057628621 -> Phi
71693993751058209 -> Pi
803 -> Both
811 -> Phi
10 -> Pi
11 -> Both

• This seems like mostly a challenge to compute digits of pi or phi, which feels like a chameleon challenge. – xnor Jun 8 at 7:51
• I think at 100 digits I agree with xnor, but if you made the number of digits smaller I would expect some kind of compression to be a better approach. That said, I'm not sure it is then terribly different from other compression based questions since I don't think phi or pi have any exploitable structure. I do think there is a good idea somewhere in here, I'm just not sure this is it. – FryAmTheEggman Jun 9 at 16:33

# Print the SARS-Cov-2 (COVID-19) genome code-golfkolmogorov-complexity

## Background

As you probably learned in biology class, DNA and RNA are composed of strands of nucleotides; each nucleotide consists of a chemical called a base together with a sugar and a phosphate group. The information stored in the DNA or RNA is coded as a sequence of bases. DNA uses the bases A, C, G, and T (standing for adenine, cytosine, guanine, and thymine), while RNA uses A, C, G, and U (with uracil replacing thymine).

## Challenge

The genome of SARS-Cov-2, the virus that causes COVID-19, has been fully sequenced. This genome is a sequence of 29,903 bases, each base being one of A, C, G, or U, since it's an RNA virus.

The challenge is to output that sequence using as few bytes in your program as possible (code golf). You can write either a full program or a function.

Because the names A, C, G, and U are arbitrary, you can use any 4 characters you want instead:

• You must use exactly 4 characters (they must be pairwise distinct--two or more can't be equal).
• Each one of the 4 characters must be a printable ASCII character in the range from '!' to '~', inclusive (ASCII 33 to 126). In particular, this does not include the space character or the newline character.
• Each of the 4 characters you use must always represent the same one of A, C, G, and U -- no changing in the middle!

Your output should be the precise text at the following link, with A, C, G, and U replaced by whichever 4 characters you selected, and you may optionally follow the entire sequence with one or more newline characters (but no newlines or other extraneous characters at the beginning or in the middle are allowed):

Click to see the required output. (Including all 29,903 characters here would cause this to exceed a StackExchange maximum size.)

Because you can use any 4 distinct characters you want, it's acceptable to use, for example, lower-case instead of upper-case, or to use T instead of U, or to use 0123 instead of ACGU, or even to output the complementary strand (with A and U switched, and C and G switched).

## Restrictions

Standard loopholes are prohibited as usual. In particular, it's not allowed to retrieve information online or from any source other than your program. You also can't use any built-in which yields genomic data or protein data (these would generally retrieve data from the Internet so they wouldn't be allowed anyway, but some languages may have this facility built in internally; use of such functionality is prohibited whether implemented internally or externally).

I've set up a way to check that your program's output is correct. Just copy and paste your program's output into the argument in this verification program on TIO and run it.

## Other Info

Some facts that may or may not be of help:

1. There are 29,903 bases in the sequence. The counts for the individual bases are:

• A 8954
• C 5492
• G 5863
• U 9594
2. If you simply code each of the 4 bases in 2 bits, that would get you down to 7476 bytes (plus program overhead), so any competitive answer is likely to be shorter than that.

3. The source for the data can be found at this web page at NIH; scroll down to ORIGIN. The data is written there in lower-case letters, and 't' is used instead of 'u', apparently because DNA sequencing techniques were used.

4. There are variant strains of SARS-Cov-2 known (the base sequences are slightly different, and the length varies a bit); I believe the one here is the first one sequenced, from Wuhan.

5. Groups of 3 consecutive bases code for particular amino acids, so it might be useful to analyze the data in groups of 3. But there are non-coding areas where the number of bytes isn't necessarily a multiple of 3, so you may not want to just divide the data into groups of 3 starting at the beginning. If it might be useful, you can find more info on the structure of the virus RNA here (but this probably isn't needed).

Disclaimer: I'm not a biologist. If anyone has any corrections or improvements on the underlying biology (or anything else, of course), please let me know!

Happy golfing!

• Mathematica has ResourceData["Genetic Sequences for the SARS-CoV-2 Coronavirus"]. It fetches data from the internet, but somebody like me could argue that it's allowed because it's sort of built-in, so I think you should disallow coronavirus genome built-ins here. I get 7846 bytes for Bubblegum with zopfli (probably because the raw storage mode in DEFLATE always stores >=1 byte per source byte, and the other ones have various LZ77 stuff in the Huffman tree, increasing overhead for non-compressible parts, assuming I understand DEFLATE correctly) – the default. Jun 7 at 13:30
• @mypronounismonicareinstate Thanks for pointing that out -- I added in something to handle that. The challenge now specifically prohibits any use of built-in genomic data or protein data. This should take care of somebody somehow getting, for instance, a related virus genome and then just compressing the diff. – Mitchell Spector Jun 7 at 18:23
• I'm sorry to say that somebody has beaten you to it. – Dingus Jun 10 at 1:28
• @Dingus Yes, I just noticed that. I voted to close the other question as a duplicate. Posting in the Sandbox for a couple of days first is the recommended procedure, after all, so my challenge has priority. I've gone ahead and moved it to the main site. (And I think it's better though thought out, and it has a verification program -- plus it benefited from mypronounismonicareinstate's comment about Mathematica built-ins.) – Mitchell Spector Jun 10 at 1:43
• @MitchellSpector I agree that yours is better thought out. The verification program is a great feature - obviously a bit of work went into creating it. I'll leave my answer posted pending the outcome of the close vote. Not because I don't support your claim to priority, but for the sake of my own priority in posting the first answer. – Dingus Jun 10 at 1:52
• @Dingus -- Thank you! I have no problem with answers being posted to both challenges as long as they're still open. (I think the other one should be closed, but I also don't believe in penalizing answerers for problems with a question.) If I had let it linger in the Sandbox for a month, it would be fair game, but it's only been there for a couple of days, which is the right way to do it. – Mitchell Spector Jun 10 at 1:55

Alice decided to improve the security of her website by sending first five characters of an SHA-1 hash to Bob's Leaked Password Detection Service. However, she made two mistakes that let Eve decode the passwords: sending passwords over HTTP and checking the password after each character of a password is typed. Eve asked you for help in decoding the passwords, however she cannot really program, so needs your help in implementing password cracking algorithm as a computer program or function.

Eve eavesdropped the requests for following hashes from Alice.

516B9
379FC
19C2A
9D4E1
08506
F808E
A7F93
5BAA6


How could you decode this password? Well, you can brute-force all lowercase letters. In this case the only letter whose hash starts with 516B9 is p. The hash of letter p is 516B9783FCA517EECBD1D064DA2D165310B19759.

Knowing that the password starts with p, you can brute-force the second character. In this case, the only possible character is a. The hash of pa is 379FC0D5299A71AC0F171FBB5AFB262829B4E765

You can continue to brute-force letters one by one to figure out the password was password (5BAA61E4C9B93F3F0682250B6CF8331B7EE68FD8). Well, that was simple.

Not all passwords are that simple however. Consider the following requests:

4DC7C
A84FD
467D7
BD79D
12D83


First three characters of this password are simple: rxr (467D7856C648A79A096D339A2CE5FC929658967D).

With the fourth character it gets more complicated. BD79D matches for rxrf (BD79DEC8435B8BA509A25F419F31CC2ACDE2FF0A) and rxrp (BD79DC20901B11468F8369B5B0D15894F3D96A5E). There is an ambiguity, but as it turns out, it can be resolved by trying both ways. If you assume the password starts with rxrp there is no valid letters to continue with. However, if you assume the password starts with rxrf, then it's possible to append a, resulting in rxrfa (12D83D3A429CD7D64E9A532C05C2C00C35032A94), which is a valid solution.

All passwords will be composed entirely out of lowercase letters. You can assume all inputs have a solution and there are no inputs that could possibly resolve to multiple passwords (for instance ["4DC7C", "A84FD", "467D7", "BD79D"] is an invalid input because it can match both "rxrf" and "rxrp").

There are no case requirements on the input. Your program is allowed to assume the input is lowercase. Your program is allowed to assume the input is uppercase.

The program must not take longer to execute than 24 hours for a 25 characters long password.

It is allowed to use external libraries or language built-in functions for computation of SHA-1 hash.

# Example Input and Output

This is a JSON.

[
{
"input": [
"516B9",
"379FC",
"19C2A",
"9D4E1",
"08506",
"F808E",
"A7F93",
"5BAA6"
],
},
{
"input": [
"07C34",
"593B7",
"0262F",
"CED65",
"23612",
"4EF76",
"B7A87"
],
"output": "letmein"
},
{
"input": [
"84A51",
"87DDA",
"83F67",
"E6FB0",
"5157D",
"82CD7",
"6F655",
"43426"
],
"output": "codegolf"
},
{
"input": [
"7A81A",
"DB3D4",
"FE05B",
"E7280",
"32726",
"30AE9",
"2C61A",
"A9E46",
"15D98",
"F780A",
"3E949",
"F4BF2",
"6A5C4",
"C4554",
"FA2EA",
"48A40",
"5DD7F",
"5284E",
"C0B8D",
"20D59",
"9184C",
],
"output": "onetwothreefourfivesix"
},
{
"input": [
"84A51",
"87DDA",
"26CA7",
"9D925",
"08A23",
"BE075",
"3179A",
"5D904",
"54C70",
"47790",
"5D3B5",
"0E4CE",
"004C7",
"EC8A8",
"131A6",
"7F47F",
"41BC6",
"FCF07",
"D62BD",
"DD14F",
"6A141",
"EE184",
"595F8",
"9D303",
"BFD36"
],
"output": "correcthorsebatterystaple"
},
{
"input": [],
"output": ""
},
{
"input": [
"4DC7C",
"A84FD",
"467D7",
"BD79D",
"12D83"
],
"output": "rxrfa"
},
{
"input": [
"4DC7C",
"A84FD",
"467D7",
"BD79D",
"7B743"
],
"output": "rxrpa"
}
]

• I wonder whether MD5 might be preferred over SHA1 - as in, more likely to exist in the language without having to load external libraries? – streetster Jun 18 at 16:25
• Languages without a hashing builtin or library would have effectively two challenges: implementing the hash and doing the key part of the challenge. There are already challenges for MD5, SHA-1, and SHA-256 e.g. codegolf.stackexchange.com/questions/81195/implement-sha-256. I see two resolutions to this: 1. not count byte count of the hash; or 2. use a simple hash, such as the digits after the decimal point in the square root of the sum of code points – fireflame241 Jun 18 at 22:19
• You could allow a black-box function as input that computes the SHA256 hash to make this more competitive for languages without builtins. – S.S. Anne Jun 24 at 2:32

# Posted at Baba if you, flag is win

• There are a lot of possible rules (I think a little less than 2^9, as for each X and Y either X is Y or X is not Y, and there are 3*3=9 (X, Y) choices). Is there any documentation on what's the behavior of each rule combination? // i.e., even in this simplified version there are still a lot of fuzzy details on how the rules behaves. – user202729 Jun 22 at 15:04
• @user202729 , Thank you for your input. I’ll take out the clause about “no non-core packages” as suggested. In terms on the moves after win, I think the easiest thing will be to say that one can assume the input sequence to end on a winning move. If a longer sequence is given, that’s undefined behaviour and the program can do whatever. – MarcinKonowalczyk Jun 22 at 16:55
• @user202729 Finally, I admit I'm not certain what is your source of confusion. The rules work just like in the main game (with the caveat of everything is stop), and I've specified a lot of tricky cases both in this post and in the accompanying GitHub repo. Arguably, the code on GitHub specifies the problem precisely (as it is an execution of it). I've also added test cases to allow one to check the behaviour. I'm not sure what else could I do? – MarcinKonowalczyk Jun 22 at 17:00
• The default for kolmogorov-complexity is that the exact, constant string must be output, so I suggest no leading spaces allowed. Some languages can't output in certain forms (e.g. printing) without a trailing newline, so I'd say it's okay (instead of "print this logo", I'd suggest saying "output this logo exactly as the following string") – fireflame241 Jun 27 at 7:45

# Posted: Laguerre Polynomials

• Do you mean $L_n(x)$ by y(x) (under The Challenge)? Also, the challenge and rules have a conflict (four or five decimal places?) – Bubbler Jul 9 at 23:56
• hopefully it is clearer now @Bubbler – golf69 Jul 10 at 1:20
• You realize that when x get huge, that means arbitrary-precision arithmetic?... perhaps require "4 decimal places for the provided examples" instead. – user202729 Jul 10 at 2:20
• triangle of coefficients: oeis.org/A021010 – qwr Jul 10 at 3:54

# Posted: The Cantor Functioncode-golfmathfractal

• I think the definition of $f_n$ would be clearer if defined recursively like in the Wikipedia page section "Iterative construction". – xnor Jul 19 at 10:14

# Migrate Try it online! to CommonMark

Try it online! generates old-style MarkDown code blocks which indent all lines with 4 spaces and then optionally precedes the block with a language comment.

Furthermore if the code block can't be parsed by old-style MarkDown (e.g. it has a leading newline, common in Retina answers), then it instead uses a <pre><code> block, with HTML escapes for all nonprinting characters.

Your program or function must take a whole TIO post, and change its code block into CommonMark style.

Examples:

# [Python 2], 16 bytes

<!-- language-all: lang-python -->

print "Python 2"

[Try it online!][TIO-kdaf9y51]

[Python 2]: https://docs.python.org/2/
[TIO-kdaf9y51]: https://tio.run/##K6gsycjPM/r/v6AoM69EQSkAzFcwUvr/HwA "Python 2 – Try It Online"


becomes

# [Python 2], 16 bytes

 python
print "Python 2"


[Try it online!][TIO-kdaf9y51]

[Python 2]: https://docs.python.org/2/
[TIO-kdaf9y51]: https://tio.run/##K6gsycjPM/r/v6AoM69EQSkAzFcwUvr/HwA "Python 2 – Try It Online"


which displays as

# Python 2, 16 bytes

print "Python 2"


Try it online!

while

# [Retina 0.8.2], 13 bytes

<pre><code>
Retina 0.8.2
</code></pre>

[Try it online!][TIO-kdafdbm1]

[TIO-kdafdbm1]: https://tio.run/##K0otycxL/P@fKwjMUDDQs9Az@v8fAA "Retina 0.8.2 – Try It Online"


becomes

# [Retina 0.8.2], 13 bytes



Retina 0.8.2


[Try it online!][TIO-kdafdbm1]

[TIO-kdafdbm1]: https://tio.run/##K0otycxL/P@fKwjMUDDQs9Az@v8fAA "Retina 0.8.2 – Try It Online"


which displays as

# Retina 0.8.2, 13 bytes


Retina 0.8.2


Try it online!

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

# Where are the traps? code-golfnumbersequence

### Background Partially copied from my related challenge

The trapped knight sequence is a finite integer sequence of length 2016, starting from 1, and has the following construction rules:

1. Write a number spiral in the following manner:
17 16 15 14 13 ...
18  5  4  3 12 ...
19  6  1  2 11 ...
20  7  8  9 10 ...
21 22 23 24 25 ...
1. Place a knight on 1.
2. Move the knight to the grid with the smallest number it can go that has not been visited before, according to the rules of chess (i.e. 2 units vertically and 1 unit horizontally, or vice versa).
3. Repeat until the knight gets stuck.

It is known that the sequence ends at 2084 where the knight is trapped. But here is a twist. Suppose a knight can step back to the previous grid whenever it is stuck, and choose the grid with the next smallest number possible. By doing so, the sequence can be further extended until it is stuck again at 2720. Then, the knight steps back and choose another path, which further extends the sequence until it is stuck again at 3325...

Then, we call these numbers at which the knight is being trapped "traps". So we now know that the first few traps are at 2084, 2720, 3325, ... and it continues to infinity.

### Challenge

Write a shortest program or function, receiving an integer $$\N\$$ as input, output the first $$\N\$$ traps in the extended trapped knight sequence.

### Values

The first 100 terms of the sequence are as follows.

  2084,   2720,   3325,   3753,   7776,   5632,   7411,   8562,  14076,   8469,
9231,  22702,  14661,  21710,  21078,  25809,  27112,  24708,  19844,  26943,
26737,  32449,  31366,  45036,  37853,  37188,  43318,  62095,  67401,  68736,
70848,  62789,  63223,  69245,  85385,  52467,  71072,  68435,  76611,  84206,
81869,  70277,  81475,  83776,  70767,  84763,  99029,  82609, 103815,  86102,
93729, 100614, 108039,  82111,  99935,  85283, 109993, 119856, 119518, 116066,
109686,  92741, 124770,  92378, 104657, 125102, 107267, 107246, 117089, 117766,
99295, 121575,  98930, 117390, 123583, 112565, 122080, 111612, 111597,  97349,
105002, 130602, 133509, 153410, 127138, 143952, 153326, 157774, 122534, 136542,
163038, 134778, 140186, 162865, 171044, 159637, 171041, 174368, 184225, 152988


### Winning Criteria

The shortest code of each language wins. Restrictions on standard loopholes apply.

# Convert LifeOnTheEdge to LifeOnTheSlope

Your task here is to take a LifeOnTheEdge pattern and convert it to LifeOnTheSlope.

A LifeOnTheEdge pattern is composed of these four characters: |_L . A pattern corresponds to a certain arrangement of "on" edges in a square grid. The pattern is placed in the grid first with the characters in the cells, and each of the four letters specifies the state of the edges on the left and the bottom of that cell. | means the edge on the left is on, _ means the bottom edge is on, L means both of them are on and   means neither of them are on.

For example the following LifeOnTheEdge:

|_L
|


translates to:

. . . . .
|   |
. ._._. .
|
. . . . .


Your task is however convert it to LifeOnTheSlope. LifeOnTheSlope is a LifeOnTheEdge equivalent but only uses three symbols: /\ . You should rotate the pattern 45-degree clockwise, for example the above example translates to:

/

/\/
\


# Sandbox

I'm not sure if I described the problem clearly. Improvements on the wording and other things?

• Nice challenge! The task is clear, I just think you may specify if and how leading/trailing newlines/spaces are allowed, for example in the example there may be a trailing space. And also.. Are the set of characters strictly fixed? People usually ask for free sets, for example some values [1,2,3,0] instead of |_L but since this is ascii-art I think it's fine to have a fixed set. Let's see if anyone else has any opinion. – AZTECCO Aug 2 at 12:35
• @AZTECCO For the second question I'm fine with both options. This convertion is a thing that annoys me in my CA exploration. – null Aug 2 at 12:38

# Identify the tonic from a key signature

## Objective

Given a key signature in major, output its tonic.

## Input

An integer from -14 to +14, inclusive. Its absolute value is the numbers of flats/sharps. Negative number represents flats, and positive number represents sharps. Note that theoretical keys are also considered.

## Mapping

Note the use of Unicode characters ♭(U+266D; music flat sign), ♯(U+266F; music sharp sign), 𝄪(U+1D12A; musical symbol double sharp), and 𝄫(U+1D12B; musical symbol double flat).

-14 → C𝄫
-13 → G𝄫
-12 → D𝄫
-11 → A𝄫
-10 → E𝄫
-9 → B𝄫
-8 → F♭
-7 → C♭
-6 → G♭
-5 → D♭
-4 → A♭
-3 → E♭
-2 → B♭
-1 → F
0 → C
1 → G
2 → D
3 → A
4 → E
5 → B
6 → F♯
7 → C♯
8 → G♯
9 → D♯
10 → A♯
11 → E♯
12 → B♯
13 → F𝄪
14 → C𝄪

Output must be a string. Whitespaces are permitted everywhere.

## Rule

• Invalid inputs fall in don't care situation.
• "Or a sequence of bytes representing a string in some existing encoding"? (I think this should be the default, but I don't remember seeing any meta post about it) – user202729 Aug 4 at 6:06

# Source Code Byte Frequency - Posted here

Changes from the original idea:

• Without the requirement of fixed representation of the result (percentage and trimming).
• With constraint: source code must be at least 1 byte long
• Changed from character to byte, plus removing the constraint of SBCS languages only.
• This may qualify for the quine tag but I'm not so sure about that – golf69 Aug 4 at 6:40
• Trimming the output may be difficult for some languages, maybe you could also allow fractions, or require that the output is only accurate to x decimal places? Something to consider when writing a challenge is if a rule actually contributes to the problem or is just an accessory of sorts (here I think the main problem is finding the proportions, and rounding is an accessory) – golf69 Aug 4 at 6:47
• @golf69 I'm also not sure about quine... About the trimming, my intention on the trimming and percentage format was to add a little bit of "work" that the program should do and make the frequencies a bit more different/challenging. Do you think I should drop the trimming part from the challenge? – SomoKRoceS Aug 4 at 9:05
• I do think so, yes (also it might be better received that way) – golf69 Aug 4 at 17:21
• I do not think the average person who does not use this site will know what a SBCS is, so it is probably still worth explaining. Alternatively, I think it would be cleaner to just require that the input be a byte and the output reflects the frequency of that byte. That way you don't eliminate multibyte languages from using it to their benefit, and I don't think it allows any "cheating." – FryAmTheEggman Aug 4 at 21:52
• Sounds okay to me. I agree that it is better to avoid elimination of multi-byte languages. – SomoKRoceS Aug 4 at 22:03
• The thing I try to avoid is to get a lot of 0 bytes answers (for languages that print 0 as default). So I want to add a task that the program should do, like printing in percentage format. So the question is, before I reduced the trimming task, if this is enough to achieve that. – SomoKRoceS Aug 5 at 9:06
• Posted here with some changes listed in this edited answer. – SomoKRoceS Aug 9 at 16:50

# Simulate simple Bloons Tower Defense!

For those who are unaware of this legendary series of video games, here is a link.

You are going to be given an integer number and type of bloon wave and two integers describing the damage and pierce (max amount of bloons you can damage in one attack) of each attack. Your task is to output in how many attacks can you destroy the bloon wave.

## Bloon types

For simplicity, there will be no special properties like fortified, regrow, camo e.t.c. White bloons will also not be present as, without special properties, they are the same as black bloons

Name - health - what it pops into
BAD   - 20000 - 3x DDT and 2x ZOMG
ZOMG - 4000  - 4x BFB
BFB   - 700   - 4x MOAB
MOAB - 200   - 4x Ceramic
DDT   - 350   - 6x Ceramic
Ceramic - 60    - 1x Rainbow
Rainbow - 1     - 2x Zebra
Zebra   - 1     - 2x Black
Black   - 1     - 2x Pink
Pink    - 1     - 1x Yellow
Yellow  - 1     - 1x Green
Green   - 1     - 1x Blue
Blue    - 1     - 1x Red
Red     - 1     - Nothing!


## I/O

Input: A string describing the type of bloon, and three integers: the amount of bloons in the wave, attack damage and attack pierce

Output: An integer describing how many attacks are needed for destroying the whole wave.

## Examples

Note: If there is not enough pierce n to attack the whole wave, then only the first n bloons are attacked

Input: Rainbow 3 2 10
Starting: 3x Rainbow
Attack 1: 12x Black
2: 20x Yellow 2x Black
3: 10x Blue 10x Yellow 2x Black
4: 10x Yellow 2x Black
5: 10x Blue 2x Black
6: 2x Black
7: 4x Yellow
8: 4x Blue
9: Done!
Output: 9


This is the 4/0/x Sniper Monkey:

Input: BFB 1 30 1
1: BFB(670)
2: BFB(640)
...
13: BFB(10)
14: 4x MOAB(180)
15: 1x MOAB(150) 3x MOAB(180)
...
19: 1x MOAB(30) 3x MOAB(180)
20: 4x Ceramic(60) 3x MOAB(180)
21: 1x Ceramic(30) 3x Ceramic(60) 3x MOAB(180)
22: 3x Ceramic(60) 3x MOAB(180)
...
27: 1x Ceramic(30) 3x MOAB(180)
28: 3x MOAB(180)
...
69: 1x Ceramic(30)
70: Done!


This is codegolf, so lowest byte-count wins

• This is extremely complicated. I feel like this will be in unanswered for a while. – Razetime Aug 10 at 17:04
• In the second example, how is ceramic destroyed without giving out any lower class bloons? – Bubbler Aug 11 at 0:31
• +1 because btd is awesome lol. However this is a very complicated challenge, even for people who know how the mechanics work. It might be better if you limit the problem to 1 pierce only – thesilican Aug 18 at 23:34
• or you could even do a challenge that simply requires calculating the RBE for a bloon wave, that could still be an interesting challenge – thesilican Aug 18 at 23:35
• actually RBE calculating is probably a bit too simple – thesilican Aug 19 at 0:02

# Solve the Halting Problem for Oneplis

Oneplis is a "very simple esolang" (I don't want to count this one toward my esolangs) made by me which only have three commands. As you can probably see from the name, it is a subset of 1+, along the lines of Befinge.

The three commands are:

• 1, which pushes 1. (Obviously!)
• +, which pops the top two numbers and pushes their sum. (Obviously!)
• #, pops a number n and jumps to the instruction after the nth (0-based) #.

Oneplis is almost certainly a (very limited) push-down automaton, since it's impossible to decrement a number and impossible to retrieve elements arbitrary deep in the stack! Oh, and the only way to read a number is with #, which cannot handle arbitrarily large numbers!

This is , so shortest code wins! Your output should be truthy for halting, and falsy for non-halting. You can use any set of five characters for the instructions. Don't care if it jumps to a non-existence # or trying to execute + when there are <2 numbers on the stack.

## Test cases

11+ -> True
1##1# -> False
1## -> True
11+1+###11+# -> True
11+##1#1 -> False


# Sandbox

• Test cases?

• Shall I require the answers to deal with errors?

• For "nth #", is it 1- or 0-based? (I guess it's 0-based, but you need to be explicit on it anyway.) – Bubbler Aug 20 at 9:39
• @Bubbler Uh, ok. It's 0-based in 1+, but 0-based indexing does not make any sense in this challenge anyway, it's impossible to push 0... Should I change it to 1-based? – null Aug 20 at 9:42
• I don't think it's that nonsense, as the only effect is that all instructions between first and second #s are unreachable. – Bubbler Aug 20 at 9:47
• @Bubbler Oh, okay then. So if no one objects I'll post this to main. – null Aug 20 at 10:15
• if you don't plan to require answers to deal with errors then also mention that they don't need to worry about popping from an empty stack – Mukundan314 Aug 20 at 11:20
• Or: errors terminate the program. – user253751 Aug 24 at 13:29
• @user253751 Yes, that's also good. Although, I prefer it this way. – null Aug 24 at 13:43

# Noncommutative Quineoid Triple

This is the hard mode of Quineoid Triple

Write three different programs such that all of the following properties hold:

• $$\ A(B) = C \$$
• $$\ B(C) = A \$$
• $$\ C(A) = B \$$
• $$\ A(C) = -B \$$
• $$\ B(A) = -C \$$
• $$\ C(B) = -A \$$
• $$\ A(A) = \epsilon \$$
• $$\ B(B) = \epsilon \$$
• $$\ C(C) = \epsilon \$$

Where:

• $$\ f(g) \$$ is the output obtained from feeding the program text of $$\g\$$ into program $$\f\$$
• $$\ -x \$$ is the program text of $$\x\$$ in reverse (reversed in terms of either raw bytes or unicode codepoints)
• $$\ \epsilon \$$ is the empty string / an empty output

# Rules and Scoring

• This is , so the shortest program length total, in bytes wins.
• Standard quine rules apply.
• Each program can be in any language. Any number of them may share languages or each may use a different language.
• Use any convenient IO format as long as each program uses a consistent convention.
• Functions are allowed, as this counts as "any convenient IO".
• The result of feeding anything other than program text of one of the three programs is undefined.

# All Potential Keys That'll Fit The Lock

## Introduction:

You're a key maker, and want to access something from a safe that has a lock. Unfortunately, the key to that lock is lost, so you'll have to make a new one. You have access to a bunch of blank keys, to which you can add notches to turn it into actual keys. You also have loads of keys with notches already applied lying around.

## Challenge:

Given a list of list of digits (all of equal length) representing the list of keys with notches you have lying around, where each digit represents the height of the notch 'column', as well as an integer list of digits of the key you want to make for the lock of the safe, output all keys you should potentially make in order to try to open the lock.

How would we determine this? Here an example:
Let's say the key that's supposed to go into the lock is [7,5,2,5] (where the first digit is at the opening of the lock). And let's say the list of keys you have available is [[2,5,3,5],[3,7,5,8],[8,2,1,0],[6,3,6,6],[7,9,5,7],[0,2,2,1]] (where the last digits are the tips of the keys).

Here is how far we can insert each key into the lock:

Let's take the first key [2,5,3,5] as more in-depth example:

[2,5,3,5]         # First notch:  5<=7, so it fits
[7,5,2,5]     # Second notch: 5<=5 & 3<=7, so it fits
# Third notch:  5>2 (& 3<=5 & 5<=7), so it can't be inserted that far into the lock
# Based on this key we now know the following about the safe-key:
# First notch:  >=5
# Second notch: >=5
# Third notch:  <5


Here a visual representation, to perhaps better understand it, where the blue cells are key [2,5,3,5], the yellow parts is the key that's supposed to go into the lock [7,5,2,5], and the black parts are the lock itself:

As for the other keys:

[3,7,5,8]         # First notch: 8>7, so it can't even be inserted into the lock at all
[7,5,2,5] # base on this key we now know the following about the safe-key:
# First notch:  <8

[8,2,1,0]         # First notch:  0<=7, so it fits
[7,5,2,5]       # Second notch: 0<=5 & 1<=7, so it fits
# Third notch:  0<=2 & 1<=5 & 2<=7, so it fits
# Fourth notch: (0<=5 & 1<=2 & 2<=5 &) 8>7, so it can't be inserted that far
# Based on this key we now know the following about the safe-key:
# First notch:  >=2 & <8
# Second notch: >=1
# Third notch:  >=0 (duh)
# Fourth notch: nothing; we couldn't insert it to due to first notch

[6,3,6,6]         # First notch:  6<=7, so it fits
[7,5,2,5]   # Second notch: 6>5 (& 6<=7), so it can't be inserted that far
# Based on this key we now know the following about the safe-key:
# First notch:  >=6
# Second notch: <6

[7,9,8,7]         # First notch:  7<=7, so it fits
[7,5,2,5]   # Second notch: 7>5 & 8>7, so it can't be inserted that far
# Based on this key we now know the following about the safe-key:
# First notch:  >=7 & <8
# Second notch: <7

[0,2,2,1]         # First notch:  1<=7, so it fits
[7,5,2,5]         # Second notch: 1<=5 & 2<=7, so it fits
# Third notch:  1<=2 & 2<=5 & 2<=7, so it fits
# Fourth notch: 1<=5 & 2<=2 & 2<=5 & 0<=7, so it fits
# Based on this key we now know the following about the safe-key:
# First notch:  >=2
# Second notch: >=2
# Third notch:  >=2
# Fourth notch: >=1


Combining all that:

# First notch:  ==7 (>=7 & <8)
# Second notch: ==5 (>=5 & <6)
# Third notch:  >=2
# Fourth notch: >=1


Leaving all potential safe-keys (72 in total):

[[1,2,5,7],[1,3,5,7],[1,4,5,7],[1,5,5,7],[1,6,5,7],[1,7,5,7],[1,8,5,7],[1,9,5,7],[2,2,5,7],[2,3,5,7],[2,4,5,7],[2,5,5,7],[2,6,5,7],[2,7,5,7],[2,8,5,7],[2,9,5,7],[3,2,5,7],[3,3,5,7],[3,4,5,7],[3,5,5,7],[3,6,5,7],[3,7,5,7],[3,8,5,7],[3,9,5,7],[4,2,5,7],[4,3,5,7],[4,4,5,7],[4,5,5,7],[4,6,5,7],[4,7,5,7],[4,8,5,7],[4,9,5,7],[5,2,5,7],[5,3,5,7],[5,4,5,7],[5,5,5,7],[5,6,5,7],[5,7,5,7],[5,8,5,7],[5,9,5,7],[6,2,5,7],[6,3,5,7],[6,4,5,7],[6,5,5,7],[6,6,5,7],[6,7,5,7],[6,8,5,7],[6,9,5,7],[7,2,5,7],[7,3,5,7],[7,4,5,7],[7,5,5,7],[7,6,5,7],[7,7,5,7],[7,8,5,7],[7,9,5,7],[8,2,5,7],[8,3,5,7],[8,4,5,7],[8,5,5,7],[8,6,5,7],[8,7,5,7],[8,8,5,7],[8,9,5,7],[9,2,5,7],[9,3,5,7],[9,4,5,7],[9,5,5,7],[9,6,5,7],[9,7,5,7],[9,8,5,7],[9,9,5,7]]


## Challenge rules:

• Assume we'll know all notches when it doesn't fit, even though the lock would in reality be a black box. Let's just assume the key maker is very experienced, and can feel such a thing. What I mean by this, is for example shown with key [7,9,8,7] in the example above. It fails at the second stage because of both 7>5 and 8>7. In reality we wouldn't know which of those two caused it to be blocked and making us unable to insert the key any further, but for the sake of this challenge we'll assume we know all of them if there are more than one.
• Also note that for [8,2,1,0] we don't know anything about the fourth notch, because we couldn't insert it past the third.
• Also, in reality the key maker could test some of the keys he makes after testing all existing ones to further decrease the amount of potential keys he has to make, so the number would be much lower than 72 in the example, but for the sake of this challenge we'll just determine all possible locks based on the given existing keys once.
• You can take the I/O in any reasonable format. Can be a list of strings or integers (note that leading 0s are possible for the keys) instead of the list of lists of digits I've used.
• You can assume all keys of the input have the same length, which is $$\1\leq L\leq10\$$.
• You are allowed to take the safe-key input in reversed order, and/or all keys in the list in reversed order. Make sure to mention this in your answer if you do!
• You can assume the safe-key is not in the list of other keys.

## General rules:

• This is , so shortest answer in bytes wins.
Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.

## Test cases:

Input safe-key:   [7,5,2,5]
Input other keys: [[2,5,3,5],[3,7,5,8],[8,2,1,0],[6,3,6,6],[7,9,5,7],[0,2,2,1]]
Output:           [[1,2,5,7],[1,3,5,7],[1,4,5,7],[1,5,5,7],[1,6,5,7],[1,7,5,7],[1,8,5,7],[1,9,5,7],[2,2,5,7],[2,3,5,7],[2,4,5,7],[2,5,5,7],[2,6,5,7],[2,7,5,7],[2,8,5,7],[2,9,5,7],[3,2,5,7],[3,3,5,7],[3,4,5,7],[3,5,5,7],[3,6,5,7],[3,7,5,7],[3,8,5,7],[3,9,5,7],[4,2,5,7],[4,3,5,7],[4,4,5,7],[4,5,5,7],[4,6,5,7],[4,7,5,7],[4,8,5,7],[4,9,5,7],[5,2,5,7],[5,3,5,7],[5,4,5,7],[5,5,5,7],[5,6,5,7],[5,7,5,7],[5,8,5,7],[5,9,5,7],[6,2,5,7],[6,3,5,7],[6,4,5,7],[6,5,5,7],[6,6,5,7],[6,7,5,7],[6,8,5,7],[6,9,5,7],[7,2,5,7],[7,3,5,7],[7,4,5,7],[7,5,5,7],[7,6,5,7],[7,7,5,7],[7,8,5,7],[7,9,5,7],[8,2,5,7],[8,3,5,7],[8,4,5,7],[8,5,5,7],[8,6,5,7],[8,7,5,7],[8,8,5,7],[8,9,5,7],[9,2,5,7],[9,3,5,7],[9,4,5,7],[9,5,5,7],[9,6,5,7],[9,7,5,7],[9,8,5,7],[9,9,5,7]]

Input safe-key:   [3]
Input other keys: [1,6,2,9]
Output:           [[2],[3],[4],[5]]

Input safe-key:   [4,2]
Input other keys: [[4,1],[3,7],[4,4],[2,0]]
Output:           [[1,4],[1,5],[1,6],[2,4],[2,5],[2,6],[3,4],[3,5],[3,6]]


TODO: More to come

# Questions for the Sandbox:

• Should I perhaps let people output the amount of keys the key maker should make, instead of a list of the actual potential keys? (So the example would result in 72 in that case.)
• Any missing tags?
• Any missing rules?
• Anything unclear?
• Anything incorrect in my example?
• Any suggested test cases?

Posted to main

# Surround a string with "friendliness pellets" code-golf

Posted.

• Suggested test case: In this world, it's KILL or BE killed. Also, a reference program would be a good addition. – Lyxal Aug 5 at 9:11
• Done! hysterical Flowey laughter – Razetime Aug 5 at 10:54
• Setting a maximum number of characters would be unambiguous, rather than 'length lesser than your console's width'. – Dingus Aug 5 at 10:57
• I made the threshold to be lesser than 100. – Razetime Aug 5 at 11:01
• This is exactly how I imagined the challenge would look like. Good job! I look forward to seeing you post it when it's time to do so! – Lyxal Aug 5 at 11:01
• The specific rules that define the ellipses should be described explicitly, not inferred from either the test cases or the example code. For instance, it appears that all ellipses are expected to be 11 lines high, but this is nowhere stated. – Dingus Aug 5 at 11:23
• Ok, I fixed that in the question. – Razetime Aug 5 at 11:25
• (not a problem with the challenge, just a general comment) The circle looks ugly... (you can change the challenge to be "draw an ASCII art of a you circle surrounding something -- with some circle-drawing algorithm or specification -- but I think there's already some similar challenge? Besides, the current version is easier) – user202729 Aug 5 at 11:38
• I'm not sure whether one exists. Bresenham's Algorithm geeksforgeeks.org/bresenhams-circle-drawing-algorithm exists, but I feel like that would be a very different type of question. – Razetime Aug 5 at 11:45
• The ellipse spec is still not detailed enough. It looks like you have set spacing rules for each line - what are they? Is it allowed to make the ellipse wider than the minimum size needed to contain the string? – Dingus Aug 5 at 13:09
• I added an ellipse template, annd padding rules. – Razetime Aug 6 at 2:12
• – Dingus Aug 7 at 12:35
• Yes, very close, but not exactly the same. – Razetime Aug 9 at 4:52
• Sure, the specific shapes/characters are different. But the underlying challenge of surrounding a string with an ASCII shape (a horizontally and vertically symmetric one, at that) is the same. – Dingus Aug 9 at 23:37

# Brainfuck arbitrary precision multiplication

## Goal

The goal is to multiply two numbers in the shortest amount of cycle.

## The Input

The input is two numbers written decimally separated by a space. The number is NOT restricted by the size of the integer inside of the cells. The program must accept arbitrary sized integer

## The Output

The output is a single integer written decimally.

## Brainfuck variants used

Since the flavors of the Brainfuck is important in this challenge, you are required to use this flavor

### Memory

The memory is an array of cells, unbounded to the left and the right, with 8-bit integer as the contents.

### Input/Output

The input and the output uses ASCII symbol mapping. EOF is interpreted as \0 char.

### Looping

The [ means that "check the current cell. If it's zero, jump to the instruction after the matching ]" The ] means that "jump to the matching [." no cycle is taken in this instruction.

### Cycle

Every instruction takes a single cycle every time it's executed except for ]. ] is a free instruction.

### Reference implementation

For the reference implementation, use copy.sh with this option:

1. Cell size (Bits): 8
2. Dynamic (infinite) Memory: yes
3. End of input: char: \0
4. Count instructions

## Scoring

The program with lowest worst computational complexity (counted by using cycle metric as explained above, and in x where x is the length of the largest input in base 10) is the winner. In case of a tie, the winner is a program that takes the least cycle to execute 1234567890*987654321

• fastest-code is the winning criterion tag, so you don't need code-challenge. To lower the obstacle before starting to work on the challenge, I suggest to use the copy.sh online interpreter as the standard. (I think it satisfies the cycle count rule?) – Bubbler Sep 3 at 7:02
• @Bubbler Actually, I designed my challenge with copy.sh as the reference. The only difference is that the memory tape is not unbounded to the left. – Xwtek Sep 3 at 7:25
• You can set "memory overflow behavior" to "abort" for that. – Bubbler Sep 3 at 7:39
• @Bubbler It's not possible to have both infinite memory and abort as memory overflow behavior. I changed the challenge so that the memory is also unbounded to the left. – Xwtek Sep 3 at 7:42
• Can we make assumptions such as 'the number of digits in the numbers is less than X' or 'the number of digits in the number of digits in the numbers is less than X'? – the default. Sep 5 at 14:32
• @thedefault. No. The program must handle arbitrary sized number. – Xwtek Sep 5 at 15:57
• @Xwtek So it would be impossible to answer it in a flavor with 30000 cells of one byte each? I think the limit on the size of each number should be half of the number of cells (and thus infinite for flavors with infinite cells) – Redwolf Programs Sep 9 at 23:30
• @RedwolfPrograms Yes, it's impossible. Maybe I'll make a challenge to minimize memory use, but for now, you have to use infinite flavors. "I think the limit on the size of each number should be half of the number of cells" Not necessarily, I bet you need much more memory than that. – Xwtek Sep 11 at 2:20

# The Turing Text Tape code-golf

## Introduction

Ah, INTERCAL...
As much as I'd like encourage everyone to Try it Online sometime, text output is just painful.
According to the docs it uses the "Turing Text Model". While an... interesting concept, using it is about as much fun as shooting yourself in the foot. And what do we do with a task like this? Automate it.

## The Turing Text Model

The characters INTERCAL knows are printed on a circular tape that can only be moved in the positive direction. Printing is done by passing tape head movement commands in an array to the READ OUT statement. Every ASCII character is written on the inside of that tape (The outside has the characters for the input on it, duh). This results in the characters' bytes being on the tape in reverse. Also the tape head moves backwards along the character list, because its positioning is based on the outside of the tape.
The head starts at position 0.

Now the magic starts. I'll be using Truttle1's explanation on how to achieve output.

1. Set up an array with the output length.
2. Fill the entries in the array with tape head movement values.
1. Find the current character's ASCII value in binary
2. Reverse it and convert back a number n.
3. Subtract n from the current head postion and modulo by 256 if needed, resulting in a value r
4. r is the value you need to store in the array
5. The head is now at position n.
3. DO READ OUT the array.

• Array is pre-initialized with 0, first index is 1
• INTERCAL uses extended 8-bit ASCII characters, hence the tape length of 256.
• Between 1/3rd and 1/5th of all lines have to start with PLEASE. Note that in that case you drop the DO for GIVE UP and READ OUT, but not for anything else, as seen in the first example.

## Challenge

Given an input string, output a valid INTERCAL program that prints that string and terminates.

## Examples

Prints "BUZZ"

DO ,1 <- #4
DO ,1 SUB #1 <- #190
DO ,1 SUB #2 <- #152
PLEASE DO ,1 SUB #3 <- #336


Whitespace is optional. The following prints "FIZZ"

DO,1<-#4DO,1SUB#1<-#158DO,1SUB#2<-#208DO,1SUB#3<-#312PLEASEREADOUT,1PLEASEGIVEUP


(Examples shamelessly stolen from Truttle1's FizzBuzz program from the video.)

You can find an ungolfed reference implementation in python 3 here

## Rules

• No standard loopholes
• This is , shortest code wins.
• You can expect input >= 1, ASCII characters only.
• The program may not throw any errors apart from the RANDOM COMPILER BUG.

## Sandbox stuff

• Is there anything that can be worded better?
• Are there some edge-cases that need an example?
• Should I add any rules; if so, which?

### EDIT

• Removed unneeded info/rule

# Take 6!

A good card game is a wonderful thing. I got me a nice fresh set of Take 6! Too bad though, I have no-one to play with. And so I turn to you!

## The Game

The game is played with a set of 104 cards, numbered 1 to 104 inclusively. Each card has a number of 'cows' attached. Here's a quick Python function to calculate the number of cows:

def cows(card):
out = 1
if(card % 5) == 0:
out += 1
if(card % 10) == 0:
out += 1
if(card % 11) == 0:
out += 4
if(card % 5) == 0:  # C-c-c-combo
out += 1
return out


Therefore, there is a total of

• 1 card with 7 cows (number 55)

• 8 cards with 5 cows (the other multiples of 11: 11, 22, 33, 44, 66, 77, 88, 99)

• 10 cards with 3 cows (multiples of ten: 10, 20, 30, 40, 50, 60, 70, 80, 90, 100)

• 9 cards with 2 cows (other multiples of five: 5, 15, 25, 35, 45, 65, 75, 85, 95)

• 76 cards with 1 cow (all other cards)

The game is played by up to 10 players.

Each player is given 10 cards. 4 cards are placed on the table as the starts of 'rows'. Then 10 turns of play take place. Then, results are calculated.

### A turn

Each player selects one of their remaining cards. At the same time, they reveal their selected cards.

Going in the order of lowest card number, the player whose card it is must place it into a row according to rules:

1. If there is a row with the top card of a lower number than the player's and no such row with a lower number exists, their card must be placed at the end of the row. If their card is the sixth in a row, they take the first 5 cards and put them on their result pile, leaving theirs as the new start.

2. If no such row exists, they must pick one of the rows, take all the cards there to their result pile, and leave their card as the new start.

Examples:

row tops: 10 20 30 40

played: 25

must be placed on the row with a 20, creating the configuration 10 25 30 40 with a possible cow gain

row tops: 10 20 30 40

played: 9

pick any row, creating for example 10 20 9 40, but guaranteed to gain cows

### Counting

The sum of cow values of the cards in a player's result pile is their score. The lower the score the better.

Scores may be added up over several games, creating an overall score for a match.

## Bots

Bots will be standalone programs. Everything belonging to a bot will be placed in a single directory, the name of the directory will be used as the name of the bot. A launch script named launch (may be the entire bot) must be provided. If necessary, a compilation script named build may be provided. Both scripts shall be placed directly in the bot's directory and should use shebangs to specify how they are to be run.

Bots shall not interfere with other bots, the controller, or the git repositories used.

The bots will have the option of storing extra information in files in their own directory. It will be wiped when a fresh series is being run (such as after adding a new bot).

An override input format may be provided. I intend to use StringTemplate for this, I'll write up some details when working on the controller. The default format will have all messages newline-terminated.

Once launched, the bot will be first given their cards, as a list of card numbers, where the numbers may or may not be ordered.

The default format will be

cards 0 1 2 3 4 5 6 7 8 9


No response is expected.

For each round, the bot will be prompted with the current state of the grid, that is the number of cards in each row, the sum of cows in each row and the top number card in the row.

The default format will be

count 1 2 3 4

cows 5 6 7 8

top 11 20 22 35


The bot shall answer with the number of one of its remaining cards.

The list of all the cards used by all bots in the round will be given to each bot. Not that this includes the bot's own card. The order of bots in this message will be consistent within a game.

The default format will be

used 0 1 2 3 4 5 6 7 8 9


No response is expected.

If the placement rule 2. has to be invoked, the bot will receive a message containing the board state at the time when it needs to pick a row

The default format will be

pickrow

count 1 2 3 4

cows 5 6 7 8

top 11 20 22 35


The bot shall respond with the number of the row it wishes to take. The rows will be 0-indexed for this.

If the bot's move results in a gain of result cows, it will be informed of which cards and how many cows it has gained (note that the lower the number the better).

The default format will be

cardgain 1 2 3 4 5

cowgain 6


No response is expected.

At the end, all bots will be shown their score as well as all the scores of others, in the order consistent with the used cards message.

The default format will be

score 30

others 0 1 2 3 4 5 6 7 8


No response is expected.

If the bot makes an invalid move, it will be delivered a special message informing it of such. From that point the bot's current game is over. It gets 100 points of penalty.

The default format will be

invalid


A timely shutdown is expected.

The bot may of course try to save information to its private file at any time, including at the end.

After the final message, the bot shall terminate in a timely manner.

Scoring will be added up over many games, number depends on how fast the games end up running, but at least 100 sounds reasonable to me.

Bots will be placed in a separate github repository TODO for easy setup and reseting. Bots that need a compilation script but don't have one will be given one.

## Controler

Work has started at https://github.com/MrRedstoner/Take6KOTH

The controller will be designed to run in Java 1.8+, using the Process API to launch bots.

# Notes:

While the number of bots is too low, it will be padded to 10 by using multiples of primitive bots. The tournament style once 11+ submissions exist is for now playing all subsets of size 10.

I intend to write up at least a few primitive bots, to get the games going. Something like using cards in the order they were given, or randomly. These will also demonstrate the custom input functionality. Maybe even one that uses external input, to let me play for fun!

Limits for execution time, storage of data etc. are not given at this time. If bots start to behave excessively limits may be added.

Sandbox notes:

Any better idea for tournament?

Should bots be given the names of their competitors as well? Currently leaning towards yes.

Planned tags:

• Even though most people can read python, you should still include a written description of how the cows are counted. As it is, your program counts twice for it being divisible by 5 in the case of 55, is that intentional? – FryAmTheEggman 2 days ago
• @FryAmTheEggman it is indeed intentional, it's a combo for a reason :D. The result also matches what wikipedia describes about the game. Should have some more to edit soon so I'll make the change then. – Mr Redstoner 2 days ago
• But when do you take 720?? /s – Jo King 2 hours ago

## I've Got The Key, I've Got The Secret

A cryptography challenge in 2 parts.

## Part 1

Implement a pair of programs in any language (the two programs could be in different languages if you wanted) to encode and decode a string of plaintext.

## Input and Output

The encoder must take the plaintext (and an optional key) and return an encoded string. The decoder must take the cyphertext (and an optional key) and return the plaintext exactly as it was given to the encoder.

## Restrictions

• The encoding and decoding code must be entirely implemented in the language - no libraries or cryptography functions may be used.
• The code (encoder+decoder) cannot be longer than 1024 characters.

The cyphertext.

## Output

The plaintext that generated the ciphertext.

## Scoring

I will upvote all answers to part 1 which have working encryption and have obviously made an attempt at golfing their answer.

In order to be eligible to win, an entrant will have to have taken part in both parts of the question. Overall score will be (length of shortest program that cracks your code-(length of encoder+length of decoder)). Highest score wins and winning entrant's entries will be accepted on both questions.

• The obvious place for this to fall flat on its face is if someone is able to implement AES or something similar within the 1024 character restriction. – Gareth Jun 13 '12 at 13:06
• Probably better if the methods of the part one programs are disclosed in non-obfuscated language, though with the short length restriction this may not be necessary. – dmckee --- ex-moderator kitten Jun 13 '12 at 15:23
• Forget AES: RSA is easily doable. That aside, you need to define "crack" in part 2. – Peter Taylor Jun 13 '12 at 15:35
• Also, it's not clear whether "optional key" means that it's optional to make the algorithm unkeyed (doesn't make much sense, I admit) or optional to supply it, in which case it uses a default key. – Peter Taylor Jun 13 '12 at 15:42
• @PeterTaylor I just put optional in to leave it up to the implementer whether or not they wanted to have the key input or hard-coded (or use no key). I'd have thought everyone would have the key input into their program, but I didn't want anyone to feel forced into it by the spec. Hmm, if RSA is doable within the character restriction I'll end up with a load of unbreakable codes which would make for a pretty crap part 2. By crack I meant cyphertext goes in, some time later plaintext comes out. Would restricting the character count further help, or is this question beyond help? – Gareth Jun 13 '12 at 16:05
• On that definition of crack, I can brute force for the length of the decoder plus a few bytes to iterate over all keys of the right length and some heuristics to check plausibility of the plaintext. The brute force cracker might even be shorter than the decoder if the decoder wasn't written in GolfScript... I think this question may be beyond help. – Peter Taylor Jun 13 '12 at 16:28
• @PeterTaylor Okay, thanks. I like the 'build your own - knock everyone else's down' aspect of this question though. I'll have to find another area where it could apply. – Gareth Jun 13 '12 at 16:34
• @Gareth I too like the competitive nature of this idea. I'm looking forward to a question with this plan in mind! – Gaffi Jun 13 '12 at 19:31
• I think it would be better to split this into a "cops" post and a "robbers" post. – wizzwizz4 Feb 16 '17 at 9:46
• @wizzwizz4 Wow, this is another blast from the past. I think this pre-dates the cops-and-robbers tag. I always seem to be ahead of my time. :-) – Gareth Feb 16 '17 at 9:49

# Countability of Sets of Finite Sets

The aim of this challenge is to code-golf a program which returns an iterator that will iterate over all possible non-empty finite sets of positive integers.

So if running long enough, this iterator should eventually touch on {1}, {2, 5}, {3, 6, 112} (ie none of these should occur "at infinity")

You may choose the order in which you iterate over these sets, but the order must satisfy the following requirement:

Under a particular ordering, if S is the i'th set to be returned by the iterator, then we shall call i the index of set S.

Let a restriction (k,T) be an assertion about a set S that says S has size k and T is a subset of S.

For a given restriction (k,T) and iterator IT, let the restricted iterator be the iterator which takes sets returned by IT and filters out sets that don't satisfy the assertion, iterating only over the ones that do. In other words, if IT iterates over the sequence of all sets, the restricted iterator iterates over the subsequence satisfying (k,T). Now if S is the n'th set returned by the restricted iterator, then we'll call n the restricted index of S with respect to (k,T)

Your ordering must satisfy the property that for any restriction there exists a polynomial P(x) such that for any set satisfying the restriction (with index i and restricted index n), i < P(n)

Note that the following ordering is not acceptable:

{1} {2} {1, 2} {3} {1, 3} {2, 3} {1, 2, 3} {4} {1, 4} {2, 4}...

This is the sequence that comes from counting 1, 2, 3, 4, 5, 6... and listing the set bits in the binary representation of each number.

This is because the restriction (1, {}) satisfies only the sets {1}, {2}, {3}, {4}... whose index i as a function of their restricted index is i=2^(n-1) which is not bounded by any polynomial

## Sandbox Questions

The reason for the strange requirement at the end is to disqualify any variants on the most natural ordering which simply counts upwards from 1 and enumerates the set bits in each number. In this ordering, the n'th set of length-one occurs at index 2^n which is non-polynomial.

I posted this problem originally, but didn't think of the obvious solution and so I left out the final restriction. I'd like to re-post it with the extra restriction. But first I'd like to know what people think. Is there a better way I can word that restriction or a more natural restriction I could impose instead?

• I don't understand the extra restriction, so I can't suggest a rewording, but I can say that it needs one. (In particular: what is k? And what function does T serve? Is it really a parameter of the property?) – Peter Taylor Jun 18 '12 at 8:25
• I don't understand it either. Maybe a sample of an ordering, satisfying the requirement, and another one, violating it, would help. – user unknown Jun 18 '12 at 15:31
• I understand the restriction now, although I haven't worked through the full implications. Does allowing T to be non-empty make a significant difference at all? – Peter Taylor Jun 19 '12 at 6:52
• I don't know. It may not. I guess the size part is the important part. I was just thinking that the ordering should be such that you run into all kinds of sets frequently. – dspyz Jun 20 '12 at 7:17

## The One with Two Parts

The aim of this challenge is to create a pair of functions which scramble and unscramble any given piece of text.

Part 1

In part one you post your scrambling function, along with the length in characters and language of your unscrambling function (but NOT its code). The length of the scrambler does not affect your score so you needn't golf it unless you want to. The two functions may be written in different languages if you wish.

Input/Output

The scrambling function should take one argument only - a string containing the input text - and return a string containing the scrambled text. The unscrambling function should also take only one argument - the scrambled text - and return the original text. The input text will be limited to characters in the ASCII set range from 0 to 127.

Part 2

In part two you try to beat your opponents' scores for their unscrambling functions. You MUST use the language they specify for their unscrambler in part one. Please give just one answer to this question containing all your unscrambling functions making it clear which question in part one each function unscrambles (maybe each answer in part one should give its scrambler a name for identification?).

Once the closing date (TBA) has passed all participants should post their unscrambling functions in their answer to part one to prove the length, language and functionality of their function.

Scoring The participants score will be calculated as follows: (unscrambler length from part one) - (shortest unscrambler length from part two). The participant with the lowest score wins and will have their answers accepted on both parts of the challenge. To be eligible to win a participant must have taken part in both parts of the question.

Example

In part 1:

• Bob posts a Python answer and says his unscrambler is a 165 character Python function.
• Fred posts a GolfScript answer and says his unscrambler is a 59 character GolfScript function.
• Joe posts a JavaScript answer and says his unscrambler is a 180 character PHP function.
• Jim posts a Ruby answer and says his unscrambler is 163 character Ruby function.

In part 2:

• Bob posts an 82 character GolfScript function to unscramble Fred's scrambled text. He also posts a 175 character PHP function to unscramble Joe's scrambled text.
• Fred posts a 181 character PHP function to unscramble Joe's scrambled text.
• Joe posts a 150 character Python function to unscramble Bob's scrambled text.
• Jim posts a 156 character Python function to unscramble Bob's scrambled text. He also posts a 91 character GolfScript function to unscramble Fred's scrambled text.

The scores:

• Bob scores 165 - 150 = 15
• Fred scores 59 - 82 = -23
• Joe scores 180 - 175 = 5
• Jim scores 163 - 0 = 163

so Fred wins.

Miscellaneous

I suggest that the closing date be two weeks after the challenge begins, and that unscramblers be posted to part one within 48 hours of closing date in order to be eligible.

• Are there any rules regarding scrambling? i.e. is "Stockholm"->"Stockhoml" a valid scramble? (it may not matter, but I'm curious. And to be clear, the scoring is the difference between your opponent's unscrambler length and your own for the same language? – Gaffi Jul 16 '12 at 16:39
• @Gaffi No, you scramble however you want. If you want to just output the text as given that's ok, but you probably won't win with that strategy. The aim is to do it in a way that is easy for you to unscramble but difficult for all the others. That way your score will be smaller. Yes, the score is the difference between your score and the score of the best of your opponents' attempts. I'll add an example to make that bit clearer I think. – Gareth Jul 16 '12 at 21:27
• I think this gives an advantage to people who use (relatively) obscure languages. If the scrambler is written in J and the descrambler in GolfScript then only people who know both can realistically attempt a descrambler. (NB the rules don't say how the score works if no-one attempts a particular unscrambler). – Peter Taylor Jul 17 '12 at 6:59
• I did consider saying that programs that had no attempts at beating them were not eligible to win, but then I thought that if they were scored as though the shortest attempt to beat them was 0 then they wouldn't have much of an advantage. I'll add that into the example scoring. What do you think? I want to encourage answers that are clever or well obfuscated rather than written in Malbolge or something like that. – Gareth Jul 17 '12 at 7:28
• Does it mean that since no one attempts to solve Jim's Ruby challenge his chances are minimal that he'll win? That would discourage complicated scramblers or difficult languages. – Howard Jul 17 '12 at 17:12
• @Howard As it stands, yes that's how it would work. The alternative, as Peter Taylor points out, is that people using obscure languages have an advantage. I'm not sure how else I might score unscramblers that no-one has attempted to beat. Maybe give them a score of 0? Please, if you or anyone else has any suggestions for making the challenge as inclusive as possible, let me know. – Gareth Jul 17 '12 at 17:51

## Compile BF to TM

Your task is to write a compiler accepting a Brainfuck program (previous challenge: Interpret Brainfuck, wikipedia: Brainfuck) as input and outputting a Turing Machine which produces identical output when supplied with the same (correct) input.

You may select the output format from among the various formats accepted by the answers to Turing Machine Simulator.

The following links may also be useful.
An introduction to programming in BF
BF is Turing-complete
Programming a Turing Machine
Programming Praxis: Turing Machine Simulator

Equivalently, you may write a Brainfuck interpreter in TM, or any partial compilation/interpretation which results in a TM program as described above.

If we consider squares of the TM tape to represent bits (blank=0, mark=1) of the BF memory, then eight squares represent a cell. Each BF instruction translates to a minimum of 8 states of the Turing Machine.

'>' "advance" (++ptr) could be implemented by eight states (sixteen transitions):

adv8 _ adv7 R _


where 'link' represents the first state of the following instruction.

'<' "rewind" (--ptr) can be implemented similarly by making leftward movements and rewriting the same symbol just read.

'+' "increment" (++*ptr) can be implemented by a ripple-carry from the Least Significant Bit to the Most Significant Bit, borrowing "rewind" states to back-up to normal position. If the LSB is on the left, it would look something like this:

inc8 _ link N 1
inc8 1 inc7 R _
inc7 _ rew1 N 1
inc7 1 inc6 R _
inc6 _ rew2 N 1
inc6 1 inc5 R _
inc5 _ rew3 N 1
inc5 1 inc4 R _
inc4 _ rew4 N 1
inc4 1 inc3 R _
inc3 _ rew5 N 1
inc3 1 inc2 R _
inc2 _ rew6 N 1
inc2 1 inc1 R _
inc1 _ rew7 N 1
inc1 1 overflow N 1


where overflow is a HALT state.

For I/O, the simplest way I can think is to place all input on the tape after the memory area, and expand the alphabet to include a symbol indicating the dividing line between the memory portion and the input portion of the tape. In fact, by expanding the cell size to nine squares, this symbol can serve as an input pointer, advancing as the input is consumed. (So "advance" and "rewind" now need 9 states each.) And another new symbol is written in front of the current memory cell to serve as the memory pointer. Inputting a byte therefore consists of schleping each bit over the entire space between the two tape positions with something like this:

input _ set-memptr L _
input 1 set-memptr L 1
set-memptr _ find-inptr R *
find-inptr _ find-inptr R _
find-inptr 1 find-inptr R 1
find-inptr $schlep-bit R$
schlep-bit _ schlep-blank L _
schlep-bit 1 schlep-one L 1
schlep-blank $schlep-blank L$
schlep-blank _ schlep-blank L _
schlep-blank 1 schlep-blank L 1
schlep-blank * deposit-blank R *
schlep-one $schlep-one L$
schlep-one _ schlep-one L _
schlep-one 1 schlep-one L 1
schlep-one * deposit-one R *
deposit-blank _ etc R _
deposit-blank 1 etc R _
deposit-one _ etc R 1
deposit-one 1 etc R 1


where "etc" represents going to get the next bit in similar fashion.

To perform a loop (all BF loops are "while" loops, so the exit control is at the beginning and the end has a simple goto back to the beginning), we need first to check is the current cell is zero,

zero8 _ zero7 R _
zero8 1 body R 1
zero7 _ zero6 R _
zero7 1 left1 L 1
zero6 _ zero5 R _
zero6 1 left2 L 1
zero5 _ zero4 R _
zero5 1 left3 L 1
zero4 _ zero3 R _
zero4 1 left4 L 1
zero3 _ zero2 R _
zero3 1 left5 L 1
zero2 _ zero1 R _
zero2 1 left6 L 1
zero1 _ exit-loop R _
zero1 1 left7 L 1
left7 _ left6 L _
left7 1 left6 L 1
left6 _ left5 L _
left6 1 left5 L 1
left5 _ left4 L _
left5 1 left4 L 1
left4 _ left3 L _
left4 1 left3 L 1
left4 _ left3 L _
left4 1 left3 L 1
left3 _ left2 L _
left3 1 left2 L 1
left2 _ left1 L _
left2 1 left1 L 1
left2 _ loop-body L _
left2 1 loop-body L 1
...
loop-body-final _ zero8 N _
loop-body-final 1 zero8 N 1


So assuming the machine starts at tape-location 0, and the input is on the tape starting at 0 and going to the right, the "startup code" for this arrangement would be

startup _ place$L _ startup 1 place$ L 1
place$_ left270000 L$
left270000 _ left269999 L _
...


Jeez! The output is going to be HUGE! It might be better to treat the BF memory as negative-indexed and reverse all the _L_s and _R_s in 'advance', 'rewind', 'increment', and 'decrement'.

Questions:

Bonuses for optimizations? If I can implement this myself and provide a complete example output, The bonus could be "subtract the difference between your program's output for the example input with the example output". So eliminating states would be far more valuable than shrinking the code. One could possibly achieve a negative score!

Edit: Actually I think this is unreasonable unless the Turing Machine is augmented with non-reading (movement-only or epsilon) transitions. Duplicating every letter of the alphabet just to move over one square is just ridiculously painful. That means this challenge won't link-up nicely with the other one. :(

What about, instead of implementing the compiler, just devise a translation scheme (as above) that leads to a smaller output for a trivial sample program (based on calculating, rather than coding)? "Back of the envelope" compiler.

• "How much detail on BF do I need to supply? Can I simply reference the BF question?" A link to almost any site that describes the language will do. – dmckee --- ex-moderator kitten Nov 5 '12 at 16:52
• Winning condition? – Peter Taylor Nov 6 '12 at 13:43
• "Longest prefix containing syntactically-correct Malbolge!" :) ... I'd say have none at all. Perhaps the questioner should be required to accept their own example answer? – luser droog Nov 6 '12 at 18:08
• @PeterTaylor Apologies for my last comment. I thought we were on my other answer about the [fun] tag. . . . This one would be a golf: shortest code by character count. But I think a clever system of bonuses could make it interesting. – luser droog Nov 7 '12 at 10:06
• The "Equivalently, you may write a Brainfuck interpreter in TM" option doesn't play very well with being a code golf - how are you going to count the length of the TM? – Peter Taylor Nov 7 '12 at 11:15
• @PeterTaylor Since the TM question specified 5-tuples, I think it's sufficient to count the tuples (== transitions). You can reduce states by increasing the alphabet (or vice versa), but the transitions would remain constant, I think. – luser droog Nov 8 '12 at 5:25
• I'd like to adopt (work on and post) this challenge if you don't want to. Would I be able to? If you do not respond to this message within two weeks, by community guidelines, I am allowed to take it over. – MD XF Aug 18 '17 at 3:23
• Yes, please. If you can do something with it, strike while the iron is hot. – luser droog Aug 18 '17 at 4:19

## Polygon prefixes

Polygons are named after the number of sides that they have. A pentagon has 5 sides, an octagon has 8 sides. But how are they named? What's the name for a 248-sided polygon?

All polygons are suffixed with -gon. There are specific prefixes for each polygon depending on the number of sides. Here are the prefixes for the lower numbers:

3 - tri
4 - tetra
5 - penta
6 - hexa
7 - hepta
8 - octa
9 - nona
10 - deca
11 - undeca
12 - dodeca
13 - triskaideca
20 - icosa


Polygons with 21 to 99 sides have a different system. Take the prefix for the tens digit (found on the left column), the ones digit (right column below), and then stick a "kai" between them to get (tens)(ones)gon.

20 - icosi       | 1 - hena
30 - triaconta   | 2 - di
40 - tetraconta  | 3 - tri
50 - pentaconta  | 4 - tetra
60 - hexaconta   | 5 - penta
70 - heptaconta  | 6 - hexa
80 - octaconta   | 7 - hepta
90 - nonaconta   | 8 - octa
| 9 - nona


The 3-digit sided polygons are named in a similar fashion. A 100-sided polygon is called a hectogon. Take the hundreds digit, find it on the column for ones digits, then stick a "hecta" to its right. Now number off the tens and ones like above: (hundreds)hecta(tens)(ones)gon. If the hundreds place digit is a 1, don't put the prefix behind "hecta".

So, given an integer (3 <= n <= 999), return the name of an n-sided polygon. n-gon is not a valid answer :P

As with all code golf, shortest code wins.

Is the description good? Would it be harder if I instead asked for the number of sides, given a name?

• What is a 101-sided figure called? "hectahenagon"? Is "hena" from the column for ones digits you mention? If so, then what is a 111-sided figure called? I'd say "hectaundecagon", but then that comes from a column where "hena" is not present. – Gaffi Feb 11 '13 at 11:15
• @Gaffi: Yep, it's hectahenagon, from what Google says. – beary605 Feb 11 '13 at 16:03
• I am going to take this if you allow me or if you don't respond – Christopher May 30 '17 at 1:13

## Self-Golfing Code?

I don't know if I just didn't search hard enough, but I couldn't find any challenge regarding self-golfing code, or rather, any code that can deterministically reduce another set of text code to a much smaller program, yet still compile/run.

For example, take this:

int main() {
std::cout<<"Hello world 1!"<<std::endl;
std::cout<<"Hello world 2!"<<std::endl;
std::cout<<"Hello world 3!"<<std::endl;
std::cout<<"Hello world 4!"<<std::endl;
std::cout<<"Hello world 5!"<<std::endl;
}


And output this (as one possible solution):

#define A std::cout<<"Hello world
#define B !"<<std::endl;
#define C B A
int main() {
A 1 C 2 C 3 C 4 C 5 B
}


Alternative:

Sub MySub()
Dim aNumber As Integer
Dim someString As String
aNumber = 123
someString = "abc"
MsgBox aNumber
MsgBox someString
End Sub


into (again, as one possible solution)

Sub m()
Dim a As Integer
Dim s As String
a = 123
s = "abc"
MsgBox a
MsgBox s
End Sub


Do we have a challenge for this?

If not, here are some rules I envision:

• Golfing code need not be in the same language as code to be golfed.
• Since compilers/running of code varies, newly golfed code must still run under same environment.
• Possible challenge scoring (multiple options -- thinking code golf):
• 1: Shortest golfing code wins (not my favorite, since you can minimally shorten the base code, yet still write the shortest program).
• 2: Shortest output of a set of pre-defined code (potentially limiting if participants are unfamiliar with the options available)
• 3: Combination of length of golfing code and the output result of the same as input. (Ratio, summation, etc.) -- This I think is my preferred option.
• 4: Multi-player Ratio of golfed size of other participants' own code versus their original submission. (Similar limitations to that of point #2.)
• Sounds more like an auto-golfer than obfuscation. Seems like it would be very hard to make it a fair contest unless you pick a language to golf, and even then it had better be a simple language (no platform dependency issues or compiler options). – Peter Taylor Feb 13 '13 at 15:15
• @PeterTaylor My examples are golfing, but either would work. Perhaps golfing would be simpler, then? I agree that the options for usable languages makes this a bit messy... Would one challenge per language be acceptable? (i.e. aligned with most challenges that are language-agnostic) – Gaffi Feb 13 '13 at 17:36
• Language-agnostic to mean means that you can write a program to do it in any language. Since the language to be golfed can be different from the submitted program, I don't see any incompatibility between making the problem "Write a program to golf Piet" and being language-agnostic. – Peter Taylor Feb 15 '13 at 0:18
• @PeterTaylor So then you see no problem with one question per language on which to operate? Are there any proposed scoring algorithms you particularly like/dislike? – Gaffi Feb 15 '13 at 12:02
• That depends on what you mean. If you're planning to post 10 questions at once, yes, that would be a problem. But I don't see a problem with posting a well-defined "Auto-golf Piet" and following it up two months later with "Auto-golf Perl 5". – Peter Taylor Feb 16 '13 at 10:19
• Scoring is an issue. The halting problem means that it's impossible to write an optimal solution, so the scoring must take into account how good the solution is. I think option 3 is the best, and you'll want a big test set (maybe a few kB taken from a real-world open source project) with coverage of the language features. – Peter Taylor Feb 16 '13 at 10:22
• Btw, your first example doesn't work. You can't have unmatched quotes in preprocessor directives. Don't know why. – MD XF Jan 13 '18 at 18:03
• I honestly think this would be fine if you did something like solely maco-golfing, making it somewhat language agnostic because of gcc -E. – Zacharý Nov 10 '18 at 14:36