Sandbox for Proposed Challenges

Question

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".

Answer 1

graphical-output code-golf geometry

Draw an American flag for any amount of states

The flag of the United States of America goes by many names. The Stars and Stripes. Old Glory. The Last Known Non-Erotic Usage Of The Verb 'To Spangle'.

It is also one of the few flags semi-regularly updated. The red and white stripes represent the 13 original states, but one more star has been added to the blue canton for every state that joined the union later. This last happened in 1960, when Hawaii got in. Flag designs with 51 stars are already waiting for when Puerto Rico or Washington D.C. are made states, but this vexillologist is lazy. You are to make a program that can draw the flag with any number of stars desired!

Specification

Here's a neat image of the official, government-standardised design for the current U.S. flag:

Disregard the contents of the canton for now. Your program must draw a flag that adheres to only the ratios I give here:

• A (the height of the flag) = 1
• B (the width of the flag) = 19/10
• C (the height of the canton) = 7/13
• D (the width of the canton) = 19/25
• L (the height of any stripe) = 1/13

Because raster solutions are not exact and this flag is commonly misdrawn anyway, there's tolerance of 2% for every ratio, taking the flag height as the base.

Furthermore, the correct colours must be used.

• Every odd-numbered stripe must be this shade (hex): #B22234
• The blue canton must be in this shade: #3C3B6E
• Every even-numbered stripe, and every star, must be in this shade: #FFFFFF

Conversions to other colour coordinate systems can be found on the wiki page as well.

Stars

Your program must takes as input any integer between 0 and 200, and draw that number of stars within the canton. The following rules apply.

• Each star must have five outer points and be five-fold rotationally symmetrical.
• Each star must be the same size.
• The bounding circles of stars may overlap, but the surface of the stars itself may not overlap.
• The bounding circles of the stars may go outside the canton, but the surface of the stars itself may not go outside the canton.

• I don't want solutions that just place every star on the same line; that would leave a lot of blue canton untouched, which would be a waste. So, as a rule, the combined surface area of the bounding circles of every star in the canton must be at least 20% of the surface area of the canton.

  Since overlapping bounding circles still count, you get a formula for the minimum width w of the star, where a is the area of the canton and n the number of stars: . See here for how it's derived.

Other specifications

There's no minimum or maximum size for your output image, though I recommend something that will allow 200 stars to fit but still be demonstrably star-shaped. When they are only a few pixels high, it becomes hard to argue that they have the required amount of points. Obviously, for vector solutions any size is permissible.

This is code-golf, so the smallest program wins!

Test cases

Because I gave no specific arrangement of the stars (you may arrange them however you want), there is an infinite number of correct and incorrect solutions for each number of stars. These are just examples of valid and invalid solutions:

Valid:

Invalid (stars too small):

Valid:

Invalid (stars of unequal size, going out of the canton):

Invalid (stars have too many points, stripes have wrong colours, colours are the wrong hue, proportions are wrong):

Sandbox

Do I need more test cases? Any other feedback?

Answer 2

Excessively complicated Game of Life king-of-the-hill

In the excessively complicated version of the Game of Life, the world is a \$W \times H\$ square torus with a grid of squares. Each square has a rulestring attached to it - by default, B/S. Each square has a dead or alive cell in it. Each alive cell is controlled by a player. Every turn, if there is not an alive cell in a square, it is born iff the part between B and / contains the number of alive neighbours. Every turn, if there is an alive cell in a square, it survives iff the part after S contains the number of alive neighbours. Cells are considered adjacent if they have a common edge or a corner. A cell is not adjacent with itself. Cells controlled by other players also count as alive neighbours.

For example, normal Conway's Game of Life cells have the B3/S23 rulestring: cells are born if they have exactly 3 alive neighbours, and survive if they have 2 or 3.

Each player starts with a B/S012345678 cell, placed uniformly randomly.

Each cell knows a 3x3 array of numbers from \$-1\$ to \$1\$, representing adjacent cells (including self). \$1\$ in it means an ally cell, \$0\$ means a dead cell, and \$-1\$ means an enemy cell, and a 3x3 array of rulestrings for adjacent cells.

Every turn, every cell can alter one bit of the rulestring of any adjacent square (including its own) - that is, remove or add a number from it (or, alternatively, it can do nothing).

When cells are born, the player they belong to is chosen semi-randomly: the odds of the cell being assigned to a player are proportional to the number of cells they contributed to the cell's birth.

A player is eliminated when all their cells die. When \$N\$ turns passed, or when only one player remains, the game ends. A full point is distributed between all remaining players proportionally to the number of cells they control (dead cells don't count).

Clarifications

• Rulestrings are attached to squares, not to cells. When a cell dies, the rulestring on its square is not changed.
• No cell can be born with zero alive adjacent cells (that is, rulestrings cannot start with B0).
• When multiple cells attempt to alter the same bit in a rulestring, it is only affected once.

Challenge

Define a pure function \$(nearbyStates, nearbyRules)\to(\Delta x, \Delta y, index)\$ to be used as the algorithm for your cells. To do nothing, output an index of 0.

Otherwise, an index of 1 corresponds to toggling B1, 2 to B2 and so on until B8, the index 9 is skipped, then an index of 10 corresponds to toggling S0, 11 to S1 and so on until S8.

Winning criterion

\$X\$ games are run, and the leaderboard is formed by sorting participants by the total number of points.

This is king-of-the-hill, so whoever wins wins!

Sandbox stuff

• Is this a good idea?
• Is the description of the game clear?

I think I decided that the language for submissions will be Javascript. Now I have to write a controller.

Besides the obvious Javascript option, I am considering C++ with a Javascript engine (probably V8). This can multiply the performance by \$\%NUMBER\_OF\_PROCESSORS\% \cdot \frac{cppPerformance}{jsPerformance} \cdot \frac{myC++skill}{myJSskill}\$, which can be quite large. Unfortunately, that might also muptiply the challenge's popularity by \$\frac{webBrowserLoadingSpeed}{programInstallationSpeed}\$, which can be quite small! Would that be a good idea?

Answer 3

Symmetrical difference code-golf

Post'd.

Answer 4

Posted on the main site.

Answer 5

Help, I've mixed my week up!

My dog ate my calendar, and now my days are all mixed up. I tried putting it back together, but I keep mixing up the days of the week! I need some help putting my calendar back together, with the days in the correct order.

And since I need my calendar put together as fast as possible, don't waste my time by sending me superfluous bytes. The fewer bytes I have to read, the better!

Input

The days of the week, in any order. Input can be taken as a list of strings, or a space separated string, or any reasonable way of representing 7 strings (one for each day of the week).

The strings themselves are all capitalized, as weekdays should be, so the exact strings are:

Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
Sunday

Output

The days of the week, in sorted order (Monday - Sunday). Output can be as a list of strings, or printed with some delimiter.

Disclaimer

Note that this is a kolmogorov-complexity challenge, with the added benefit of being able to use the input to shorten your code. You are not required to use the input if you don't want to.

Examples

To see example input and output, you can consult this python script.

For the sandbox

If there are any issues with the input/output specification, or if anything is unclear, please leave a comment.

Tags: code-golf kolmogorov-complexity sorting string random calendar

Answer 6

Fold my ACGT proteins code-golf string biology chemistry

Quoting Wikipedia, "Protein folding is the physical process by which a protein chain acquires its native 3-dimensional structure, a conformation that is usually biologically functional, in an expeditious and reproducible manner.". I don't know what that means but by means of a game called Foldit it seems we can use protein folding in some way to help and fight diseases.

Please bear in mind that the task described was inspired by the isolated meaning of the words in "protein folding" and doesn't necessarily translate into how protein folding really works! i.e. the title is just a pun.

Task

Your task is to take a string matching the regex /^[ACGT]+$/ and return the number of times the string can be "folded". A string can be folded if and only if:

• It's length is even;
• The first half of the string is the reverse of the second half of the string.

Input

Acceptable input formats include but are not limited to:

• strings
• character lists
• codepoint lists

Output

The output is an integer; I don't think there's much room to wiggle here, but let me know if you really wanted to return something else.

Test cases:

Python reference implementation

'A' -> 0
'AAA' -> 0
'AAAAA' -> 0
'TAAAAAAA' -> 0
'ATAAAAAA' -> 0
'AATAAAAA' -> 0
'AAATAAAA' -> 0
'AAAATAAA' -> 0
'AAAAATAA' -> 0
'AAAAAATA' -> 0
'AAAAAAAT' -> 0
'TGCAACGTTGCAACGT' -> 2
'ACGTTGCAACGTTGCAACGTTGCAACGTTGCA' -> 3
'TGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGTTGCAACGT' -> 4
'TACCCCATTACCCCAT' -> 2
'TTTT' -> 2
'TATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTATTAT' -> 5
'AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA' -> 6
'CCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCCC' -> 6
'GGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGGG' -> 6
'TTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTTT' -> 6
'TAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAATTAAT' -> 5
'GCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCGGCCG' -> 5
'CATTACCATTACCATTACCATTAC' -> 3
'CATTACCATTACCATTACCATTAC' -> 3
'CATACCATACCATACCATACCATACCATACCATACCATAC' -> 3

Answer 7

Integers in cosine

Posted

Answer 8

Bilibili AV/BV Code Conversion

Answer 9

Minimise my List of Error Codes

SANDBOX - One Option for a Challenge

Given a set of error codes, formed of letters (A-Z) and numbers (0-9), output a string that represents the set of error codes in a concise format, as follows:

• Where two or more error codes share some first characters, there is no need to repeat those characters in the output
• Individual errors in the output are comma-separated (or in separate array indices, if preferred)

e.g:

• E1,E2 -> E1,2
• E1,W1 -> E1,W1
• ERR001, ERR002, ERR101, WAR001 -> ERR001,2,101,WAR001 or WAR001,ERR001,2,101
• WARN001, ERR001 -> WARN001,ERR001
• EAR001, ERR001 -> EAR001,RR001
• E001, E001 -> E001,
• A, B, C01, D002 -> A,B,C01,D002
• D002, DC01, DC0A, DC0B -> D002,C01,A,B or DC01,A,B,002 or DC0A,B,1,002etc.

Basically, when decoding, each character after the comma replaces the characters at the end of the previous error code.

SANDBOX - Alternative Challenge?

Decode a string of error codes, as per the above format, to extract the individual list of error codes again

SANDBOX - Questions

I know the spec is incomplete above - this is a placeholder for when I have time to write a better spec.

Is this an interesting code-golf challenge? Which of the two options would work best? Or could it be the sum of the two (encoder and decoder)?

Answer 10

Inspired by Draw this planar graph.

Your input represents an ascending sequence, e.g. 1 2 3 4. You can require the sequence as input, or you can just input the length. The explanation assumes 1-indexing but you can use 0-indexed or even a-indexed input if you adjust the algorithm appropriately.

At each step, you can exchange any digit of value n with the digit n places to its right. So the valid second steps are 2 1 3 4 and 1 4 3 2. Eventually you want to end up at the reverse sequence 4 3 2 1, which is the only permutation that has no legal steps.

Please output all possible sequences of steps from the input sequence to its reverse.

You should support sequences of up to at least 10 elements.

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

Answer 11

Inspired by Wizard creating a jewelry.

Given an input list of positive integers, calculate the minimum cost of creating the list from the following operations:

1. Appending a positive integer costs the value of the integer.
2. Incrementing the entire list costs 2.
3. Exchanging two consecutive elements of the list costs 1.

Example: The list 1 4 9 16 25 could be constructed as follows:

• Append 1
• Append 8
• Append 17
• Increment
• Increment
• Increment
• Increment
• Increment
• Append 1
• Swap 22 with 1
• Swap 13 with 1
• Swap 6 with 1
• Increment
• Increment
• Increment
• Append 1
• Swap 25 with 1
• Swap 16 with 1
• Swap 9 with 1
• Swap 4 with 1

This costs 51, which is an improvement over simply appending the integers, as that is a cost of 54.

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

Answer 12

Reduce the entropy of the input...

Spec

Given two arguments:

• A list containing 2 or more positive integers (from 0 to artificial limit of 2^32)
• A positive number defining the 'entropy allowance'

Return a sublist containing elements up until the entropy allowance is used up.

For this challenge, we define 'entropy' as the difference in bits between numbers in the list; also known as the Hamming distance.

Note that no 'entropy' is used up when flipping the bits in the first number, only used when flipping subsequent bits.

Examples

Worked example (MSB...LSB), keeping the numbers low to keep things simple:

Example 1:

List: [1, 2, 3, 4, 5, 6] Allowance: 4

1 => 0000 0001 - ignore implicit change from 0, total used = 0
2 => 0000 0010 - change of 2 bits, total used = 2
3 => 0000 0011 - change of 1 bit, total used = 3 
4 => 0000 0100 - change of 3 bits, total used = 6 (would exceed allowance)
5 => 0000 0101 - change of 1 bit, total used = 7
6 => 0000 0110 - change of 2 bits, total used = 9

Output: [1, 2, 3]

Example 2:

List: [255, 0, 127, 64, 32, 100] Allowance: 23

255 => 1111 1111 - ignore implicit change from 0, total used = 0
0   => 0000 0000 - change of 8 bits, total used = 8
127 => 0111 1111 - change of 7 bit, total used = 15
64  => 0100 0100 - change of 6 bits, total used = 21
32  => 0010 0000 - change of 2 bit, total used = 23
100 => 0110 0100 - change of 2 bits, total used = 25

Output: [255, 0, 127, 64, 32]

Meta

Is this interesting enough a challenge? Is it just a chameleon (is it just the hamming distance with extra steps)? Thoughts?

If it's not shot down for being a plain, any ideas for a better title?

Answer 13

The smallest positive integer that cannot be printed in fewer than %NUMBER% bytes of %LANGUAGE% code-challenge

All numbers mentioned below are positive integers. All programs mentioned below output exactly 1 number (including functions that return it).

For every number, there must be at least one program in your language that outputs it. Besides, the problem of determining what number the program outputs must be undecidable without making the assumption that the program halts.

The challenge itself is to choose a number \$N\$ and find the smallest number \$M\$ that cannot be output by a program shorter than \$N\$ ordinary units of measurement used for your language (usually bytes). You have to prove your solution correct. A strong mathematical proof is not necessary, but it should be reasonably convincing for somebody knowledgeable in your programming language.

The answer with the largest \$M\$ wins.

Sandbox stuff

• In this challenge, non-golfing languages seem to have a serious advantage. I think scoring by \$M\$ instead of \$N\$ is better at reducing the advantage of Lenguage-like languages to manageable levels and preventing ties; is that correct?
• Is the code-challenge tag appropriate?
• Title suggestions?

Answer 14

Can this month tell the day-of-the-week? code-golf decision-problem date

June 2020 is a month in which June 1st corresponds to Monday, June 2nd corresponds to Tuesday, ... June 7th corresponds to Sunday. For reference, here's the cal of June 2020.

      June 2020     
Su Mo Tu We Th Fr Sa
    1  2  3  4  5  6
 7  8  9 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
28 29 30            

Given a year and a month in the format [year, month], output two distinct values that tell whether this month can tell the day-of-the week.

Test cases

[2020,6] -> True
[2021,2] -> True
[1929,4] -> True

[1969,1] -> False
[1997,5] -> False
[2060,1] -> False
```

Answer 15

Self-distances completion - Minimum k to get them all

Related minor code-golf challenge

Consider \$A = (a_1,\dots,a_k)\ k\ge2 \$ a sequence of positive integers, in which all elements are different.

The self-distances completion of a sequence like \$A\$ it's performed recursively as follow:

Starting from \$i=2\$, while \$a_i\in A:\$ _{(loop until the last element)}

• If \$d=|a_i-a_{i-1}|\$ is not already in \$A\$, append \$d\$ to \$A\$
• Increase \$i\$

The resulting sequence \$A^\circ\$ is presumably longer than \$A\$, nevertheless can't contain more than \$n\$ terms.

Examples

$$ A = (2,\ 9,\ 13,\ 15) \mapsto A^\circ = (2,\ 9,\ 13,\ 15,\ 7,\ 4,\ 8,\ 3,\ 5)\\ A = (2,\ 9,\ 13) \mapsto A^\circ = (2,\ 9,\ 13,\ 7,\ 4,\ 6,\ 3)\\ A = (2,\ 9) \mapsto A^\circ = (2,\ 9) $$

Task

If we pick a number \$n\ge 2\$, we can ask what's the minimum length \$k_n\$ of \$A\$ such that \$A^\circ\$ contains all the numbers up to \$n\$.

(Note that \$\max A = \max A^\circ\$ so \$n\$ has to be in \$A\$)

• Generate the sequence of \$k_n\$ starting from \$n=2\$.

This is fastest-code.

I'll run your code on my machine (Windows 10, i7-7500U) for 30 minutes.
Obviously longer sequence is better. In case of a tie, who gets to the last term faster wins.
Your submission must not use more than 8GB of memory.
Please include instructions for how to compile/run your code.

First values and more info

 n. k_n - first A* example found (how many A of lenght k_n that satisfy the condition)

 2.  2  - 1 2 (2)
 3.  2  - 1 3 2 (4)
 4.  2  - 4 1 3 2 (2)
 5.  2  - 5 4 1 3 2 (1)
 6.  3  - 1 6 2 5 4 3 (19)
 7.  3  - 3 1 7 2 6 5 4 (10)
 8.  3  - 6 1 8 5 7 3 2 4 (3)
 9.  4  - 6 1 9 2 5 8 7 3 4 (80)
10.  4  - 10 1 8 3 9 7 5 6 2 4 (39)
11.  4  - 6 8 1 11 2 7 10 9 5 3 4 (18)
12.  4  - 8 12 1 10 4 11 9 6 7 2 3 5 (7)
13.  4  - 5 3 12 13 2 9 1 11 7 8 10 4 6 (2)
14.  5  - 6 14 3 1 13 8 11 2 12 5 9 10 7 4 (68)
15.  5  - 9 13 3 1 15 4 10 2 14 11 6 8 12 5 7 (17)
16.  5  - 11 16 2 15 12 5 14 13 3 7 9 1 10 4 8 6 (9)
17.  5  - 14 15 9 13 17 1 6 4 16 5 2 12 11 3 10 8 7 (1)
18.  5  - 15 18 6 16 17 3 12 10 1 14 9 2 13 5 7 11 8 4 (1)
19.  6  - 16 10 18 1 4 19 6 8 17 3 15 13 2 9 14 12 11 7 5 (38)
20.  6  - 14 5 20 17 1 19 9 15 3 16 18 10 6 12 13 2 8 4 11 7 (8)
21.  6  - 12 19 3 21 20 6 7 16 18 1 14 9 2 17 13 5 15 4 8 10 11 (1)
22.  6  - 20 12 19 3 21 22 8 7 16 18 1 14 9 2 17 13 5 15 4 10 11 6 (1)
23.  7  - 22 4 23 14 16 1 21 18 19 9 2 15 20 3 10 7 13 5 17 6 8 12 11 (46)
24.  7  - 15 21 1 23 13 10 24 6 20 22 3 14 18 2 19 11 4 16 17 8 7 12 9 5 (14)
25.  8  - 19 23 2 22 9 1 25 7 4 21 20 13 8 24 18 3 17 5 16 6 15 14 12 11 10 (942)
26.  8  - 18 25 8 2 24 1 21 26 7 17 6 22 23 20 5 19 10 11 16 3 15 14 9 13 12 4 (254)
27.  8  - 27 1 25 20 6 22 18 3 26 24 5 14 16 4 15 23 2 19 9 12 11 8 21 17 10 13 7 (74)

The veeery elementary program I used. There aren't any optimizations, it's just for reference.

For the purpose of the challenge you don't have to output examples nor the count. k_n is sufficient

(It doesn't appear in OEIS).

Conjectures

• The sequence of \$k_n\$ is monotonically increasing
• \$k_{n+1}=k_{n}\lor k_{n+1}=k_{n}+1\$

Sandbox

• It's all clear and does it makes sense?
• Any suggestion for a "lighter" name of the process other than "self-distance completion"?

Answer 16

Pi or Phi?

Task

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

Answer 17

Print the SARS-Cov-2 (COVID-19) genome code-golf kolmogorov-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).

Verifying Your Program

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!

Answer 18

Pwning Passwords code-golf

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"
    ],
    "output": "password"
  },
  {
    "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",
      "32AD9"
    ],
    "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"
  }
]

Answer 19

Posted at Baba if you, flag is win

Answer 20

Logo Pack LAPACK (Posted)

Answer 21

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]

[Retina 0.8.2]: https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d
[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]

[Retina 0.8.2]: https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d
[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 code-golf, so the shortest program or function that breaks no standard loopholes wins!

Answer 22

Where are the traps? code-golfnumbersequence

Related: Trapped Knight Sequence The Path Of The Wildebeest

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 ...

2. Place a knight on 1.
3. 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).
4. 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.

Answer 23

Convert LifeOnTheEdge to LifeOnTheSlope

code-golfascii-art

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?

Answer 24

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.

Answer 25

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.

Answer 26

Simulate simple Bloons Tower Defense!

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

The task

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

Answer 27

Solve the Halting Problem for Oneplis

code-golf halting-problem

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 code-golf, 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?

Answer 28

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 code-golf, 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.

Answer 29

Sandbox note: This is partially inspired by There's a fault in my vault!, which I thought had some interesting ideas in it. This is my effort to frame those ideas in a clearer fashion.

---

Cops/Robbers: Create a weak block cipher

cops-and-robberscryptography

In cryptography, we often use block ciphers, which are a form of keyed encryption. More specifically, for a plain text string \$s\$ and a secret key \$k\$, we design an encryption function \$E(s, k)\$ and a decryption function \$D(\hat{s}, k)\$ such that if we encrypt and then decrypt the text with the same key, we get back our original text. That is, we have \$D(E(s,k),k) = s\$ for all possible strings \$s\$ and \$k\$.

One security property a good block cipher has is that it is resistant against key-recovery attacks. This means that if we have the ability to run \$E(s, k)\$ and \$D(\hat{s}, k)\$ for various choices of \$s\$ and \$\hat{s}\$ and collect pairs of encrypted and decrypted text we cannot tell what the key is.

In this challenge, you will design a simple block cipher that is intentionally vulnerable to a key recovery attack, and challenge others to try and exploit it.

The Cops' Challenge

1. Design a block cipher. Design an encryption function \$E(s,K)\$ and decryption function \$D(\hat{s},k)\$ that take strings (or your language's closest equivalent) of a fixed length \$16\$ bytes and a key of fixed length \$16\$ bytes and outputs a string of length \$16\$ bytes. Your \$E\$ and \$D\$ functions must have the property that \$D(E(s,k),k) = s\$ for all 16-byte strings \$s\$ and \$k\$.¹ The functions must be deterministic (not use any randomness) and pure (not rely on any outside state). Your \$E\$ and \$D\$ must work within the integer/float precision of your language. Specifically, you may not treat floating point as if it's arbitrary precision, nor may you assume integers of arbitrary size if your language utilizes fixed-size integers.
2. Implement a secret key-recovery attack on your block cipher. Write a program that makes calls to \$E\$ and \$D\$ for a secret, unknown key \$k\$ and fully recovers the key by observing properties of the input/output pairs. The key must be recovered with probability \$1\$ - you may not rely on probabilistic approaches.² You must treat \$E\$ and \$D\$ as black boxes, from which you can only observe their input and output. This means you must not utilize runtime introspection, timing information, or other side effects of the implementation. You must only pass full \$16\$ byte strings to \$E\$ and \$D\$, and not any other type. This means you may not rely on special objects with overloaded operators or similar to glean information about how the input is processed by \$E\$ and \$D\$. Your attack may be adaptive, in that it decides which strings to pass in based on outputs to previous strings. To enforce a practicality limit, your attack must work for a combined total of strictly less than \$2^{16}\ = 65536\$ calls to \$E\$ and \$D\$ for any key \$k\$. If the block cipher you design has the property that for keys \$k_1\$ and \$k_2\$ that \$E(s,k_1)=E(s,k_2)\$ and \$D(s,k_1)=D(s,k_2)\$ for all \$s\$, then we call these keys functionally identical, and your attack may recover any functionally identical key to the original.

That's it! You will reveal both the encryption and decryption functions \$E\$ and \$D\$, and challenge the robbers to find your key recovery attack (or possibly a different one).

Clearly, the challenge is to design your \$E\$ and \$D\$ to look secure, but they have some catastrophic weakness that allow you to recover the key with very few calls. Another approach is to 'trapdoor' the function in some way only known to you. In the spirit of Kerckhoffs's principle, you are encouraged to post a short explanation of what your \$E\$ and \$D\$ do, especially if they are written in an esoteric language.

You may use cryptographic functions if you wish, but using them presents several practical problems. Hashing functions are designed to be one way and your are unlikely to be able to design both an encryption and decryption function that utilizes them. Symmetric ciphers have both encryption and decryption, but is unlikely to allow the key recovery attack outlined here.

If no-one mounts a successful attack in 7 days, you may post your key recovery attack and mark your answer as safe, which prevents it from being cracked. Note your submission can still be cracked until your reveal your attack.

Your answer is invalid if you do not follow the rules set above. Your answer can be declared invalid even after it is marked safe, if it turns out your revealed attack does not obey the rules.

The shortest safe submission, calculated as the sum of the bytes of the two functions \$E\$ and \$D\$, wins. Your functions must be named.

The Robbers' Challenge

1. Find a vulnerable answer. That is an answer, which hasn't been cracked yet and which isn't safe.
2. Crack it by designing a key recovery attack. Your attack must follow the rules outlined in the cops section. To recap, this means:
   • The total number of calls to \$E\$ and \$D\$ with the key \$k\$ must be strictly less than \$2^{16}\$
   • You must only pass \$16\$ byte strings to \$E\$ and \$D\$, and must have the key \$k\$ initially be unknown
   • The attack may be adaptive but must work to recover any 16 byte key \$k\$ (or a functionally identical key)
   • You must treat \$E\$ and \$D\$ as black box, and may not use runtime introspection, timing information, etc.

If you've found such a attack, post an attack on the robber's thread linking back to the answer. If possible, you should post a link to an online interpreter which allows others to run your attack for various keys \$k\$. You are encouraged to post how your answer works, and the maximum number of calls your approach makes to \$E\$ and \$D\$. If your attack does not recover the key, but instead a functionally identical one, explain (briefly) why they are functionally identical.

You must not crack your own answer.

The user who cracked the largest number of answers wins the robbers' challenge. Ties are broken by the sum of bytes of cracked answers (more is better).

Example #1

Python 3, 133 bytes (cop)

E=lambda s,k:''.join(chr((ord(c)+ord(d))%256) for c,d in zip(s,k))
D=lambda s,k:''.join(chr((ord(c)-ord(d))%256) for c,d in zip(s,k))

Try it online!

My program computes the sum of \$s_i\$ and \$k_i\$ for each \$i\$.

Python 3, cracks xxx's answer

leaked_key = E('\0'*16,k)
print('key = %s' % leaked_key)

Try it online!

My crack completes in \$1\$ call and uses that fact that \$0 + k = k\$.

Example #2

Python 3, 147 bytes (cop)

def E(s,k):
 o=''
 V=[*range(256)]
 j=0
 for i in range(16):
  j+=V[i]+ord(k[0])
  j%=256
  V[i],V[j]=V[j],V[i]
  o+=chr(ord(s[i])^j)
 return o
D=E

Try it online!

My program uses a complicated thing.

Python 3, cracks yyy's answer

leaked_key = ''
for c in range(256):
 if E('f'*16,chr(c))==E('f'*16,k):
  leaked_key = chr(c)+'x'*15
  break

print('key = %s' % leaked_key)
assert E('abcdabcdabcdabcd', leaked_key) == E('abcdabcdabcdabcd', k)
assert D('abcdabcdabcdabcd', leaked_key) == D('abcdabcdabcdabcd', k)

Try it online!

They only ever use the first byte of the key, so we can just bruteforce the first byte and pad with anything to get a functionally identical key. This involves a maximum of \$256\$ calls to \$E\$ with the secret key.

---

<sup>1. This means that if your language uses null-terminated strings, such as C, then you should be using memcpy-type operations instead of string operations. Since the input length is fixed as 16 bytes, this should be no issue.
2. This requirement forbids most kinds of Birthday attack.</sup>

---

Questions to sandbox users:

• I know this is a lot to take in. Is it clear?
• Can anyone think of a trivial way to trapdoor \$E\$ and \$D\$ with eg. a hashing function? I don't think it's possible, but I could be wrong.

Answer 30

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: king-of-the-hill