Sandbox for Proposed Challenges

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

Sandbox FAQ

Posting

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
• Problems that could make the challenge uninteresting or unfit for the site

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Get the Sandbox Viewer to view the sandbox more easily!

Ragtag Band of Misfits

(Guaging interest)

This is a sort of sequel to Adventurers in the Ruins, taking place in a 2D dungeon, using a multi-agent team

A group of five adventurers enters a dungeon and wants to get the best loot. There are other parties competing for loot. Each party member has different abilities, health, stamina amounts, and carry capacity. Each has independent knowledge and must exchange information via a speak action.

The dungeon is made of rooms connected on a 2D grid. A room may have 1-4 doors. Some doors may be one-way. Rooms may have treasures, monsters, and traps.

As in the prequel challenge, treasure requires bidding and all actions resolve simultaneously with a specific priority on action types.

Party members

There are five classes of characters comprising each party

1. Quartermaster
• 100kg carry capacity, 10 HP, 1000 stamina, 5 power
• Can heal party members in the same room
2. Ranger
• 50kg carry capacity, 10 HP, 1000 stamina, 8 power
• Can see and attack monsters in adjacent rooms that are connected by a door
3. Fighter
• 50kg carry capacity, 25 HP, 1000 stamina, 8 power
• Double damage to monsters
4. Thief
• 30kg carry capacity, 10 HP, 1500 stamina, 5 power
• Automatically detects booby trapped treasures and can take them without triggering the trap
• Can steal treasure from enemy adventurers in the same room
• Can booby trap a treasure, making it appear twice as valuable, but dealing damage to whoever picks it up.
• Effective bid on treasures is doubled. Wins ties on treasure bids except against other thieves.
5. Wizard
• 20kg carry capacity, 8 HP, 1500 stamina, 4 power
• Can communicate telepathically with any single teammate without needing to be in the same room. This is a two-way channel of communication.
• Can telepathically visit the room a teammate is currently in, seeing its contents and doors and enabling teleportation to that room
• Can teleport self or ally in same room to any previously visited room or the same room as any ally.
• Can teleport any ally to the current room
• Carried treasure does not increase cost for moving between rooms or teleporting
• Deals half damage to monsters

Actions available to adventurers of all classes

• Move between rooms
• Exit the dungeon (if in the starting room)
• Speak (can be combined with certain actions)
• Send a message to the wizard
• Pick up a treasure (bidding rules work the same as the first challenge)
• Gift a treasure to another party member in the same room
• Drop a treasure
• Attack a monster
• Attack a rival adventurer in the same room
• Guard (prevent oncoming attacks and theft attempts)
• Wait

Communication

Adventurers can communicate by speaking, which will be heard by all teammates in the same room. Speaking requires no stamina and can be combined with movement or gifting, but is limited to be a 20-character string. (Use of emojis for increased message density is fair game)

Combat

A power must be specified when attacking a monster. This cannot be higher than the adventurer's power rating. That amount of stamina will be expended and the monster will be damaged by that amount. If the monster is still alive after all attacks have resolved, the monster will then deal its damage split among all combatants that attacked that turn, minimum of 1 damage.

If adventurers are outnumbered by monsters in any room, the monsters will attack anyone attempting to pick up treasure for 1 damage each.

Defeating a monster will cause the monster to drop up to 3 treasures (typically more valuable than the others in the room) and the characters who attacked the monster that turn will level up, gaining 1 power.

Attacking a rival adventurer will deal one fifth of the damage normally dealt to monsters, but will not result in a counterattack. Attacking an adventurer who either guards or moves into another room will result in a miss. It is possible for adventurers to kill each other on the same turn since attacks resolve simultaneously.

Coding

You will write a bot for each party member. They may not share data (other than constants and libraries).

Battle of Wits (Where is the Poison?)

The battle of wits is a well-known scene from the Princess Bride.

Two bots will face off in a battle of wits: one poisons a wine goblet and the other chooses which to drink from (the other player drinks from the other goblet). Whoever drinks the poison loses. This will be repeated until one bot wins 20 rounds, with who poisons the goblet being randomized each time. Each match, you will be able to see the entire history of which goblet was chosen and you will also have access to the other player's decision function (Related). All submissions will be evaluated in a round-robin tournament, with ties being broken by who has the fewest losses across all games. Further ties will be resolved by who has the fewest losses to the contesting opponents. If there is a perfect intransitive relationship among three or more bots, all of them will be considered tied for first place.

This is equivalent to the matching pennies game in terms of who wins a round. The poisoner is equivalent to the penny matcher and the chooser is equivalent to the non-matcher.

• How about, to make it more interesting, let the bots read each other's source code?
– Jo King Mod
Apr 19, 2019 at 4:51
• @JoKing ooh. That's genius! Similar to this? Apr 19, 2019 at 6:00

Output the Visible Spectrum in RGB

Light with wavelength between ~380 and 780 nanometers is considered to be within the visible spectrum. One can approximate the colors of the visible spectrum in RGB space by linearly interpolating the wavelength at specific ranges. The ranges and corresponding formulae for a wavelength wl are given below, assuming each color value is a real between 0 and 1:

• [380-440): r = (440 - wl) / (440 - 380), g = 0, b = 1
• [440-490): r = 0, g = (wl - 440) / (490 - 440), b = 1
• [490-510): r = 0, g = 1, b = (510 - wl) / (510 - 490)
• [510-580): r = (wl - 510) / (580 - 510), g = 1, b = 0
• [580-645): r = 1, g = (645 - wl) / (645 - 580), b = 0
• [645-780): r = 1, g = 0, b = 0

Note that in this system, the interpolation formula is cyclic with the color components, and changes sign with respect to the range maximum or minimum.

The challenge

Given an integer wavelength between 380 and 780, output the RGB value using the above interpolations.

Output may be a list of floats in [0,1] or integers between [0,255] in the format (r,g,b), or a valid RGB hex code.

This is code golf, so the shortest code in bytes wins!

Test cases

Rounding errors to within 0.01 in float format or to within 1 in integer format are acceptable.

wl=400 --> (0.29, 0.0, 0.65) or (73,0,165) or #4900A5
wl=530 --> (0.28, 1.0, 0.0)  or (72,255,0) or #48FF00
wl=640 --> (1.0, 0.07, 0.0)  or (255,19,0) or #FF1300
wl=750 --> (1.0, 0.0, 0.0)   or (255,0,0)  or #FF0000


Bonus

At extreme ranges of the visible spectrum, human perception is not as good. This can be modeled as a loss of intensity by multiplying the RGB values computed above by a factor f for specific cutoff points:

• wl < 420: f=0.3+0.7*(wl-380)/(420-380)
• wl > 700: f=0.3+0.7*(780-wl)/(780-700)

The total (r,g,b) including the perception factor is therefore (f*r, f*g, f*b)

• I changed your post slightly; feel free to revert if you dislike my changes. May 3, 2019 at 20:19
• I also want to notify you of the fact that we have MathJax enabled, so you could TeX your equations. May 3, 2019 at 20:22

Approximating Roots

(If you can think of a better title, then please suggest it!)

One day, when I was bored in maths class, I learned of a neat trick for solving the real cube root of a number!

Let's use the number $$\79,507\$$ as an example.

First, take digit in the one's place and compare it to this table:

$$\begin{array} {|r|r|} \hline \text{Extracted Digit} &\text{Resulting Digit} \\ \hline \text{1} &\text{1} \\ \text{2} &\text{8} \\ \text{3} &\text{7} \\ \text{4} &\text{4} \\ \text{5} &\text{5} \\ \text{6} &\text{6} \\ \text{7} &\text{3} \\ \text{8} &\text{2} \\ \text{9} &\text{9} \\ \text{0} &\text{0} \\ \hline \end{array}$$

In this example, the Resulting Digit will be $$\3\$$ since the digit in the one's place is $$\7\$$.

Next, remove all digits that are less than $$\10^3\$$:

$$79507 → 79$$

Then, find the largest perfect cube that does not exceed the input:

$$64 < 79$$

$$\64=4^3\$$, thus the next digit needed is $$\4\$$.

Finally, multiply the digit found in the previous step by $$\10\$$ and add the Resulting Digit found in the first step:

$$10*4+3=43$$

Thus, the cube root of $$\79,507\$$ equals $$\43\$$.

However, there a neat quirk about this trick: it doesn't apply to only cubed numbers. In fact, it works with all $$\n>1\$$ where $$\n\bmod2\ne0\$$.

The steps mentioned above can be summed up in this generalization for an $$\n\$$ power:

• Step 1) Take the digit in the one's place in the input. Compare it to the one's place digit of the $$\n\$$th powers of $$\1\$$ to $$\10\$$, then use the corresponding digit.

• Step 2) Remove all digits of the input less than $$\10^n\$$. Compare the resulting number to the perfect powers definied in Step 1. Use the $$\n\$$th root of the largest perfect power less than said number.

• Step 3) Multiply the number from Step 2 by 10 then add the number from Step 1. This will be the final result.

Given two positive integers $$\n\$$ and $$\m\$$, return the $$\n\$$th root of $$\m\$$.

Input:

• Two positive integers $$\n\$$ and $$\m\$$.

• $$\m\$$ is guaranteed to be a perfect $$\n\$$th power of an integer.

• $$\n\$$ is guaranteed to be odd and greater than $$\2\$$. (This method doesn't work if $$\n\$$ is even.)

Output:

• The $$\n\$$th root of $$\m\$$.

Rules:

• This is , so the fewer bytes, the better!

• Standard I/O rules apply.

• The output must be calculated using the aforementioned method.

• No builtins allowed that already calculate this. A prime example being TI-BASIC's x√ command.

• That's a pretty neat trick! I guess I'm not the only one who gets bored in math class. Also, I think you made an error on your test case, it says 10 x 4 + 4 rather than + 3 May 5, 2019 at 14:03
• @RedwolfPrograms yes, I believe so! Guess my finger slipped on the keyboard May 5, 2019 at 16:31
• Is there anything else I should change about this post before I post it on main? Not sure what to call this challenge tbh May 5, 2019 at 20:05
• At the beginning of the question, it states that the method only works on perfect cubes, but it later says that it works on all odd numbers > 2. Other than that I don't see many issues, but I'd leave it here for a day or so just in case. May 5, 2019 at 20:09
• Good point! I think that I should remove that line, as it is invalidated later on, as you said. May 5, 2019 at 20:18
• Posting to main! Let's hope that this challenge fares well. May 7, 2019 at 13:25
• "The output must be calculated using the aforementioned method" falls foul of Things to avoid: Non-observable program requirements. May 7, 2019 at 14:18
• @PeterTaylor it may not be observable directly, but the source code will be able to indicate whether the method was used or not. May 7, 2019 at 14:25

Background

Ada is a programming language that is not exactly known for its terseness.

However, its array literal syntax can in theory allow for fairly terse array specifications. Here is a simple EBNF description of the array literal syntax (passable to bottlecaps.de:

array ::= positional_array | named_array
positional_array ::= expression ',' expression (',' expression)*
named_array ::= component_association (',' component_association)*
| expression (',' expression)* ',' 'others' '=>' expression
component_association ::= discrete_choice_list '=>' expression
discrete_choice_list ::= discrete_choice ('|' discrete_choice)*
discrete_choice ::= expression ('..' expression)?


We will limit ourselves to 1-dimensional arrays of integers for simplicity. This means that we will use only integers for the expression values. Perhaps in a future challenge we could try something more advanced (like declaring variables and multidimensional arrays). You do not have to golf the integer literals.

Challenge

The goal of this challenge is to output the shortest byte-count Ada array literal for a given input array. Note that Ada arrays can start from whatever index is desired, so you can pick what you wish the starting index to be as long as each value is sequential. In this example I choose to start at 1, which is idiomatic for Ada, however you can choose to start at any other integer.

Input

Your input will consist of a list of integers, in whatever form is convenient.

Output

Your output will be a string of text representing the shortest valid Ada array literal that represents the list of input integers. You may use any starting index you wish on this array, but your choice (whatever it is) must be specified in your answer (the starting index may also be dynamic).

Do not modify the representation of the input integers, keep them in decimal format. This challenge does not cover golfing of integer values.

Examples

Here are some examples:

Simple: [1, 2, 3] -> (1,2,3)
Range: [1, 1, 1, 1, 1, 1, 1,] -> (1..7=>1)
Others: [1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1] -> (6=>2,others=>1)
Multiple Ranges: [1,1,1,1,1,2,2,2,2,2,1,1,1,1,1,2,2,2,2,2,1,1,1,1,1] -> (6..10|16..20=>2,others=>1)
Tiny Ranges: [1,1,2,2,1,1,1,1,1] -> (3|4=>2,others=>1)
Far Range: [[1]*5, [2]*100, [3]*5] -> (1..5=>1,6..105=>2,others=>3)
Alternation: [1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2,1,2] -> (1|3|5|7|9|11|13|15|17=>1,others=>2)
Big Number: [1234567890,1,1234567890] -> (2=>1,1|3=>1234567890)
Big-ish Number: [1234567,1,1234567] -> (1234567,1,1234567)


Minimum Requirements

• Support at least 100 numbers and inputs of at least 256 numbers in length.

• Produce the correct result for all such inputs (including putting 'others' at the end)

• Terminate (preferably on TIO) for each of the above inputs in under a minute.

Reference Implementation

Try it online!

This implementation uses the input as its array, with each character being a number. Capital letters are special constants for large values. The program argument is the 'start index' to use.

The "code" section in the TIO link is a correct solution to the problem, while the "header" and "footer" implement the test structure.

• Your syntax doesn't match the examples; although I don't know Ada, I do know VHDL (which uses the same array syntax), and I think allowing others => in a named array (like the examples do, and the syntax doesn't) is correct. As for the challenge more generally, the specification is clear but you're missing a victory condition. code-golf is our most common victory condition here because it works well for a wide range of problems; I don't see any reason why it would work badly for this one, and don't think any of the usual alternatives are better. May 7, 2019 at 22:43
• Oh, one other suggestion is that having more functionality in the reference implementation than is required in users' answers is confusing. You might want to try explaining more clearly what the linked TIO program does, and explaining it as something like "a tool to try out various inputs, supporting abbreviations for some larger inputs, and seeing what the intended output is". May 7, 2019 at 22:50
• One other thing that could improve the question: specify what sort of input the program should take (presumably a list of integers), and what sort of output the program should produce (presumably a string). You don't need to define terms like "list" and "string" precisely; people will use whatever definitions make sense for their language. You should probably say something like "for the purposes of this challenge, numbers in the output should be in decimal; you do not have to golf them", because golfing of the output integers could change their length and thus which array syntax is optimal. May 7, 2019 at 22:53
• I've added some clarifications. May 9, 2019 at 14:51
• "Do not modify the representation" is a bit unclear: the language that people use might be taking input in a format other than decimal, but in that case we still want decimal in the output. Apart from that, I think everything is fine now (and that particular issue isn't unclear enough to make the question closeable, IMO, although close votes are often hard to predict). May 13, 2019 at 16:22
• I see what you mean, I'll adjust that and post it. Thanks for the help! May 13, 2019 at 16:35

Arithmetic quine

Write a quine.
Well that's not very original challenge so let's spice things up.

Challenge

Write a quine which when once or multiple times appended to itself (see Appending) then performs an arithmetic operation of your choice.
You can implement as many operations from the as you want (see Scoring, Operations)

Example:
Let's say my code were foobar. This would return foobar because it's a quine.
Now foobarfoobar would preform + operation on two input numbers.
foobarfoobarfoobar could preform a * operation.

Note: which operation you choose for whatever number of appended copies doesn't matter but you have to write it down in your answer.

Example: Your code might be 4 times appended to preform addition, or it might need to be appended 5 times. It doesn't matter as long as you write the full list of the operations you implemented and the number of concatenations needed.

Operations

The list of operations you are allowed to implement is:

Addition
Subtraction
Multiplication
Integer Division
Integer exponentiation
Integer Factorial


Scoring

score = bytes/(n_operations + 1)

Bytes mean the bytes of the initial un-appended program.

Appending

All languages (even if 2D) must be appended by simply concatenating the program two or more times.

• What operations should I add or how should I make this more clear? Apr 29, 2018 at 7:37
• If not duplicate it be good
– l4m2
Apr 29, 2018 at 11:14
• I expect that this would be extremely difficult. Hyperprogramming is a similar challenge with only addition, multiplication, and exponentiation where its achievability was called into question. Apr 30, 2018 at 6:19
• In my opinion, all languages should be treated equally. Otherwise there would be a lot of disputes (for example: (1) what about Cubix or Hexagony or Wumpus or Quadrefunge, where the layout is not directly rectangular but still >1D? (2) if my language is not 2D can I append horizontally? (3) Can I use a codepage where newline is a different character from \x10? ) May 2, 2018 at 12:22
• Can we read our own source code, or do default loopholes and quine rules apply? May 8, 2019 at 13:30
• @EsolangingFruit I have the feeling this challenge is easier than that one though. Appending the entire source code allows you to utilize the length, whereas duplicating every character gives all kind of trouble which is harder to overcome/ignore. PS: I've prepared a solution which works with all six operations. Those operations are just examples, right? I could add more if I want to? May 8, 2019 at 13:49
• Prepared a solution with nine operations, and will add more later on. :) Looking forward seeing this go live. May 8, 2019 at 13:57
• @KevinCruijssen May I know which operations, I'll probably add them to the list May 8, 2019 at 14:05
• @KevinCruijssen The list was supposed to be a full list but I don't see why we couldn't expand it, also I'm considering adding a score to each operation, since some are harder to accomplish than others. May 8, 2019 at 14:09
• @IQuick143 Well, the ones I have right now are: addition; subtraction; multiplication; integer division; exponentiation; factorial; square; square-root; 1/n. But I could easily add more like regular division; modulo; +1; +2; -1; -2; signum; absolute difference; base-conversion to; base-conversion from; xor; bitwise-and; bitwise-or; negate; halve; double; length; etc. etc. haha ;p So maybe it's good to have a list instead of leaving the choice to everyone. ;) I would personally use add; subtract; divide; int-divide; multiply; exponent; modulo (all requiring two inputs) May 8, 2019 at 16:48
• But I'll leave the choice to you. If you want to keep the original six operators that's fine as well. (In which case I would change the sentence to "The list of operations you are allowed to implement:") May 8, 2019 at 16:50
• @KevinCruijssen I was thinking of changing the metric to score = bytes * (operations_language_can_implement - implemented_operations + 1), because some languages might not be able to handle floats for instance, what do you think? May 11, 2019 at 13:46
• @JoKing Thanks for the grammar help. May 11, 2019 at 13:47
• @IQuick143 Doesn't that give an unfair advantage to those languages? Let's say language A can and has implemented 5 operations in X+5 bytes. And language B can and has implemented 10 operations in X+10 bytes. Although both will get get 1 in the (operations_language_can_implement - implemented_operations + 1) part of your scoring, the byte-count of B is X+10, so 5 bytes higher than A's X+5, even though it implemented more operations.. I would keep the scoring as is, and have a select list of operations to implement. If a language can't handle it, it's score would be higher to reflect that. May 13, 2019 at 9:06
• And if you want to keep it with integers only, you could perhaps use the following six operation all requiring two inputs: add; subtract; int-divide; multiply; exponent; modulo? May 13, 2019 at 9:07

Print some very large numbers

Not sure if this has been done before. Write a program that takes in a scientific format number (as two inputs, a mantissa and an exponent), and outputs a decimal representation of that number (as a string). The trick is that this must go far beyond most languages number limits.

The mantissa will always be within 1 ≤ mantissa ≤ 10 or mantissa = 0.

The exponent will always be a 32-bit signed integer.

Example:

1, 100 -> 10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

3.543235, 200 -> 354323500000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000

3.3333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333, 10 -> 33333333333.333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333

5.3282, -71 -> 0.000000000000000000000000000000000000000000000000000000000000000000000053282

0, 999999 -> 0

• Nice challenge, but can we use our language's scientific notation, E.g. some languages don't use the +, or use a different minus?
May 20, 2019 at 11:09
• Maybe even allow taking mantissa and exponent as separate inputs?
May 20, 2019 at 11:12
• Don't forget to add some example cases with negative exponent and one with an integer mantissa. Oh, and also a 0 case.
May 20, 2019 at 11:13
• Will input always be in canonical format; 1≤|mantissa|<2 or mantissa=0. Can there be leading and trailing 0s in input? How about in output?
May 20, 2019 at 11:15
• I like the idea of taking the mantissa and exponent as seperate inputs. Then we can do away with the string parsing part of the challenge and just focus on handling big numbers (by giving the inputs as floating point numbers). May 21, 2019 at 1:15

Do X with Y code-golfascii-art

Your task is to create a X made of nested 3x3 lowercase Ys, with n levels of nesting. Here is how a X looks like (this is also the output for n = 0):

y y
y
y y


A 0-level nested lowercase Y is just y. To nest a lowercase Y a level further, you arrange 4 copies of it like this:

y y
y
y


Here is the output for n = 1:

y y   y y
y     y
y     y
y y
y
y
y y   y y
y     y
y     y


Here is the output for n = 2 (I typed all of this by hand; excuse any mistakes):

y y   y y         y y   y y
y     y           y     y
y     y           y     y
y y               y y
y                 y
y                 y
y y               y y
y                 y
y                 y
y y   y y
y     y
y     y
y y
y
y
y y
y
y
y y   y y         y y   y y
y     y           y     y
y     y           y     y
y y               y y
y                 y
y                 y
y y               y y
y                 y
y                 y


Input

A non-negative integer n. You may choose the levels of nesting to be either 0- or 1- indexed.

Output

A X made of nested 3x3 lowercase Ys, with n levels of nesting, as a string, list of lines as strings, or outputted directly.

Sandbox stuff

• Is anything missing?
• Is the specification of the X clear enough?
• heavily related question. I'm not 100% convinced this is different enough to not be a dupe, but I'd try to get some more feedback before posting/abandoning this. Jun 3, 2019 at 21:37
• I think this would be a duplicate. My experience with porting an answer from yet another 3*3 fractal challenge was that I only needed to make a small change in the code.
– xnor
Jun 4, 2019 at 4:49
• I have no idea if should I post this or not, as this both is +3 and seems to receive feedback as a possible duplicate. Jun 13, 2019 at 14:53

Atomic Handshakes

Introduction

Here you are. At a party, with two drinks in your hands. Your friend just went to the bathroom and you don't really know anyone else here. And so you wait. Or do you?

There is a century old hypothesis known as Six Degrees of Separation. The hypothesis states, that any other person in the world is connected to you as a friend of a friend of a friend etc.. It would essentially only take you six handshakes to connect with any other person on this planet. But is there actually any truth in this hypothesis? That's what we're about to find out in this challenge!

A similar question also finds its way into my own field of expertise: chemistry. Hence the title. Chemistry is the study of molecules, and molecules get very complex very fast. All (for the sake of simplicity) atoms in a molecule are connected. For certain types of analysis, one may need to know how many connections (bonds) it takes to get from one atom to another.

The Challenge

In a set of N people, each person has a maximum of N-1 direct connections. Based on this information, it is your task to deduce for every person what the lowest number of connections is to get to every other person.

People (and atoms too) can have similar names. Therefore, instead of a name, every person will get a unique identifier. To make things easy, the identifier will be a non-negative integer and the integers are all consecutive. How convenient!

Input

An array-like object of size N which lists the first-degree connections for each person.

Output

A two-dimensional, symmetrical array of size NxN which shows for each person the shortest distance to every other person.

Challenge rules

• All people are connected: there are no loners or isolated groups in the input
• Circular connections are allowed, but
• Only the shortest connection must be output as more ways lead to Rome

Examples

As the theory may still be somewhat confusing, I will include a network graph for each example. This should make it a lot easier to understand what we're talking about. Here goes!

Example 1

Consider the connected set

0---1---2---3
|   |
4---5---6


For this network, our input array will be

[[1]          # Since 0 is connected only to 1
[0 2]        # Since 1 is connected to 0 and 2
[1 3 4]      # Since 2 is connected to 1, 3 and 4
[2 5]        # Et cetera
[2 5]
[3 4 6]
[5]]


Which should result in the following output (excluding comments):

# Distance from
# 0 1 2 3 4 5 6
# To
[[0 1 2 3 3 4 5]   # 0
[1 0 1 2 2 3 4]   # 1
[2 1 0 1 1 2 3]   # 2
[3 2 1 0 2 1 2]   # 3
[3 2 1 2 0 1 2]   # 4
[4 3 2 1 1 0 1]   # 5
[5 4 3 2 2 1 0]]  # 6


Example 2

Consider the connected set

.-------.
|       |
|   0   |
|   |   |
|   1---2---3---.
|   |   |   |   |
'---4---5---6   |
|           |
7---8---9---'


For this network, our input array will be

[[1]          # Since 0 is connected only to 1
[0 2 4]      # Since 1 is connected to 0, 2 and 4
[1 3 4 5]    # Since 2 is connected to 1, 3, 4 and 5
[2 6 9]      # Et cetera
[1 2 5 7]
[2 4 6]
[3 5]
[4 8]
[7 9]
[3 8]]


Which should result in the following output (excluding comments):

# Distance from
# 0 1 2 3 4 5 6 7 8 9
# To
[[0 1 2 3 2 3 4 3 4 4]   # 0
[1 0 1 2 1 2 3 2 3 3]   # 1
[2 1 0 1 1 1 2 3 3 2]   # 2
[3 2 1 0 2 2 1 3 2 1]   # 3
[2 1 1 2 0 1 2 1 2 3]   # 4
[3 2 1 2 1 0 1 2 3 3]   # 5
[4 3 2 1 2 1 0 3 3 2]   # 6
[3 2 3 3 1 2 3 0 1 2]   # 7
[4 3 3 2 2 3 3 1 0 1]   # 8
[4 3 2 1 3 3 2 2 1 0]]  # 9


Example 3

Consider the connected set

.---0---.
|   |   |
1---2---3
|   |   |
'---4---'


For this network, our input array will be

[[1 2 3]      # Since 0 is connected to 1, 2 and 3
[0 2 4]      # Since 1 is connected to 0, 2 and 4
[0 1 3 4]    # Et cetera
[0 2 4]
[1 2 3]]


Which should result in the following output (excluding comments):

# Distance from
# 0 1 2 3 4
# To
[[0 1 1 1 2]   # 0
[1 0 1 2 1]   # 1
[1 1 0 1 1]   # 2
[1 2 1 0 1]   # 3
[2 1 1 1 0]]  # 4

• In short, all pairs shortest path. Single-route shortest path would definitely be closed as a duplicate; I would say there's a significant chance that the consensus will be that this is also a duplicate of one of the questions in path-finding. Jul 5, 2019 at 10:59

Too many spies

You are fighting an extensive network of enemy spies. You know that each spy has at least one (sometimes multiple) fake identities they like to use. You'd really like to know how many spies you're actually dealing with.

Luckily, your counter-intelligence agents are doing their job and can sometimes figure out when two fake identities are actually controlled by the same enemy spy.

That is to say:

• Your agents don't always know when two fake identies have the same spy behind them, however
• If an agent tells you two fake identities are controlled by the same spy, you trust they are right.

Agent messages

Agents send you cryptic messages telling you which identities have the same spy behind them. An example:

You have 2 agents and 5 fake identities to deal with.

The first agent sends you a message:

Red Red Blue Orange Orange


This means they think there are 3 spies:

• the first one (Red) controlls identities 1 and 2
• the second one (Blue) controlls identity 3
• the third one (Orange) controlls identities 4 and 5

The second agent sends you a message:

cat dog dog bird fly


This means they think there are 4 spies:

• the first one (cat) controlls identitiy 1
• the second one (dog) controlls identities 2 and 3
• the third one (bird) controlls identity 4
• the fourth one (fly) controlls identity 5

Compiling the intel we see:

Identities:   id1    id2    id3    id4    id5
Agent 1:    |--same-spy--|       |--same-spy--|
Agent 2:           |--same-spy--|
Conclusion: |-----same-spy------||--same-spy--|


This means there are at most 2 spies.

Notes

Identities owned by the same spy do not have to be consecutive, i.e. a message like:

dog cat dog


is valid.

Also, the same word might be used by two different agents - that does not mean anything, it's just a coincidence, e.g.:

Agent 1: Steam Water Ice
Agent 2: Ice Ice Baby


Ice is used by both agents - the Ice used by the first agent is unrelated to the two occurences of Ice used by the second agent.

Challenge

Compile all your agents' intel and figure out how many enemy spies there really are. (To be more precise, get the lowest upper bound, given the limited information you have.)

The shortest code in bytes wins.

Input and Output spec

The input is a list of n lines, which represent n messages from agents. Each line consists of k space-separated tokens, same k for all lines. Tokens are alphanumeric, arbitrary length. Case matters.

The output should be a single number, representing the number of distinct spies, based on your agents' intel.

Examples

Example 1

Input:

Angel Devil Angel Joker Thief Thief
Ra Ra Ras Pu Ti N
say sea c c see cee


Output:

2


Example 2

Input:

Blossom Bubbles Buttercup
Ed Edd Eddy


Output:

3


Example 3

Input:

Botswana Botswana Botswana
Left Middle Right


Output:

1


Example 4

Input:

Black White
White Black


Output:

2

• The core problem of union set is nicely presented, but the input requirements are rather too restrictive. The question will be better received if the input is permitted to be received as an array of arrays or any other reasonable list format. See codegolf.meta.stackexchange.com/q/7853/194 Jul 16, 2019 at 8:22

Originally posted on main site, moved here for more suggestions. Better scoring mechanics required.

Introduction

I've been browsing all those challenges and was thinking "yeah, they're good, but what if we make GoL one?", so here it goes.

Challenge

Build starting setting for either Conway's Game of Life or other similar cellular automaton (restricted to ones with binary cell state) which after known amount of generation will include square area containing representation of QR code decodable to string "Hello, world!".

• Cell (non-empty state) is interpreted as black pixel, no cell as white.
• Your automation should take at least one generation until result (no hardcoded results allowed).
• Your automation operates on infinite board.
• Not sure if this option will be useful, but you can specify scaling ratio: single integer, setting side of square encoding single pixel. Pixel's color is color of cell dominating by count in it (you can specify 50/50 edge case resolution in your answer). Obviously, in this case side of output area should be proportional to scaling ratio. This option doesn't affect scoring.
• It's not necessary, but nice to provide either link to online demo or .rle file.

Example result

Decodes to "Hello, world!"

Scoring

score = (initial amount of cells)^2*(number of generations until result) + (number of cells out of output area)*5


Lower score is better.

Happy GoLfing!

• I think this challenge is interesting, although I suggest that the scoring criterion be a combination of the number of initially on cells and the number of generations necessary to get to the final output, without counting the number of on cells in the output (otherwise there's an aspect of QR code golf in the challenge as well, which complicates matters more). Also, I don't really understand the 4th bullet point. Finally, you seem to want to allow different binary cellular automata to compete, just like different languages. Is this true? Jul 14, 2019 at 22:48
• @EriktheOutgolfer Why would including amount of cells out of output area be bad? It only counts cells which aren't part of QR code, so it seems acceptable. 4th point may probably need some illustrations to make it easier to get (or just remove that). You got the last part right. Jul 14, 2019 at 23:34
• Oh, I misread the "out of output" part. So you allow extraneous on cells outside of the QR code with a penalty? Jul 14, 2019 at 23:36
• @EriktheOutgolfer I think that is more or less fine to have some cells on field as long as output in specified area is correct by itself. Jul 14, 2019 at 23:37
• Could you clarify what classes of automata are eligible? You've specified only binary (two possible cell states). What neighbourhoods are valid? Only the standard 3 by 3 Moore neighbourhood, or also other size and shape neighbourhoods like Von Neumann neighbourhoods? Must all cells in the neighbourhood contribute equally to the outcome (a totalistic automaton) or can different patterns of the same number of "on" cells give different results? Jul 16, 2019 at 21:06
• Where you choose to draw the line is entirely up to you, but it could have a large effect on the nature of the challenge. For example, if arbitrary size and shape neighbourhoods are allowed, with rulesets based on the arrangement of "on" cells rather than just how many are "on", it may be possible to choose a ruleset that gives the output in a single step (maybe - I haven't thought it through). Whether you see that as a bad thing or an interesting way of solving the challenge will determine how restrictive you choose to be. Personally I'd stop short of allowing quite that much flexibility... Jul 16, 2019 at 21:09
• Is there a standard for QR that avoids all disagreement as to what's a valid code? On further thought, it might be better just to requre a fixed output pattern, like some pixel version of Heelo World, and not have the whole QR layer.
– xnor
Jul 16, 2019 at 21:35
• In particular, following @xnor's comment, does "decodable to" mean that errors are allowed as long as they're below the threshold for correction? Jul 17, 2019 at 10:55

How long's left? code-golfwordtext-processingdate

Posted here.

• Shouldn't the third test case be FifTy Nine MiNutes And ForTy Six SeConds? Jul 9, 2019 at 19:26
• @EriktheOutgolfer Thanks, fixed Jul 9, 2019 at 19:27
• @Shaggy the challenge here isn't to calculate the number of syllables: it's to find the first number that has the same number of syllables as the distance from the current time. Jul 11, 2019 at 21:14
• Ah, OK, I get it now. Yeah, I think that's sufficiently different, so; ignore my previous comment! Jul 11, 2019 at 21:17
• Could you please clarify how many syllable each number has? (A list should help.)
– tsh
Jul 12, 2019 at 7:38
• @tsh done, see now. Jul 12, 2019 at 15:05

Character Frequency in a String

Posted here.

• i dislike the special case of space
– Jo King Mod
Jul 21, 2019 at 1:25
• @JoKing If there was no special case for space, a string like 1 a would look something like 1 1; 1;a 1. Also, it's for the challenge. Jul 21, 2019 at 3:19
• I'm with @JoKing on this; nothing is added to the challenge by special-casing spaces. Jul 21, 2019 at 21:08
• I'd like to further say that restricting the output this much doesn't seem to add much to this challenge. Why isn't, for example, a list of pairs acceptable? I can't find any justification for your output rules. That's not to say you can't do it, but I have a hard time imagining it will be popular. Jul 22, 2019 at 18:58
• Jul 23, 2019 at 20:15
• @AdmBorkBork, having since given it a try in JS, I'm pretty sure there's a closer (potential) dupe target than that. Jul 23, 2019 at 22:12
• Having posted this, you should delete the sandbox post.
Jul 24, 2019 at 6:29

Golf range minimum queries of a list

Looks like this post hasn't gotten any problems called out, but also not that much support. If you could leave even a brief comment if you don't like it, that would be much appreciated.

(Inspired by the first problem solved in Stanford’s advanced data structures course.)

Despite the academicese-heavy name, the problem we're going to solve is almost unbearably simple.

We have a list of numbers.

[31, 41, 59, 26, 53, 58, 97]


We're going to cut some contiguous snippet out of that list of numbers.

[31, 41, 59, 26, 53, 58, 97]
|41, 59, 26, 53|


And then we're going to find the minimum of that snippet. In this case, that's quite obviously 26. That's all.

And the obvious solution is pretty fast, too, with O(n) time and O(1) space in the size of the list:

minval = arbitrarily large value
for (i=first snippet index, i<last snippet index, i++)
if (list[i]<minval) minval = list[i]


So what's with the fastest-algorithm?

Where it gets interesting is when you try to see how efficient you can make it when you have a fixed list but a large number of range minimum queries -- snippets to find the minimum of. This version of the problem is useful, for example, if you have a huge time series you want to load only once, but you want to find the minimum of many different subintervals of that time series.

In such a scenario, it would actually be faster in practice to literally precompute all n**2/2 queries, store it in a table, and then just retrieve data from that table for an O(1) time and O(n**2) space solution. ^dynamic programming solution taken from the Stanford slides

And then if you're clever enough, you realize that you only have to store each query with size that's a power of two -- you can just combine those power-of-two minima to sum to an arbitrarily sized query, and achieve the same results with constant time and linearithmic rather than quadratic space.

Interestingly, if you keep optimizing, you can get to an O(1) time and O(n) space solution using a sort of augmented list known as a Fischer-Heun structure. I'd love to go into the details of the structure here, but explaining how it weaves into Cartesian tree building on fixed-size snippets would make this question about 50 pages long. It's explained in the Wikipedia page linked in the title (which I've copied here), however, along with several faster-than-linear intermediate structures.

(If you can get past a research paywall, here's the original Fischer & Heun 2011 paper. And if you’d prefer the much more verbose but much more hand-holdy Stanford lecture style, here are the follow-up slides that goes into this solution, including lots of intermediates.)

The challenge

You can either write a full program or a function that calculates the result of a series of range minimum queries given a fixed list. Scoring is set up such that in general, the shortest and most-efficient-over-lots-of-queries code wins.

Input:

A list of integers xs, followed by a series of i, j pairs denoting the start and end of the snippet, inclusive (so the 26 example above uses indices i=1 and j=4). The list of integers is guaranteed to have at least one integer, and 0 <= i <= j < len(xs). This can be taken in any format that works best for your language — for example, one list for xs and one list of tuples for the i, j pairs; or maybe all the different pairs as a variable number of arguments. For a full program that takes in input from stdin, I’ll fix a format for the input:

xs[0] xs[1] xs[2] xs[3] ...
i1 j1
i2 j2
i3 j3
...


Output:

An ordered collection of the range minima for each i, j query, in the same order that they were given. In case an unordered map (such as a Python dictionary) from each i, j query to its range minimum works better for your language, that will also be allowed as an output; as long as it's obvious which minimum is related to which query.

Once again, for a full program that prints to stdout or a file, I’ll fix the format to have each range minimum on each newline (trailing newlines permitted).

Scoring:

Lower score is better; score is determined by

at(b)^2+as(b)


Where b is the byte count of your code, at is the asymptotic runtime Ө(n) of the algorithm in the size of xs interpreted as a function of n, and as is the asymptotic space usage Ө(n) in the size of xs interpreted as a function of n.( All constant coefficients in such Ө(n) expressions must be 1, and only the fastest growing term may be kept in expressions, as is standard.)

Therefore, the above pseudocode solution, which uses Ө(n) time and Ө(1) space, and is 126 characters, would have a score of (b => b**2 + 1)(126)=15876+1=15877. (Of course, the pseudocode isn't really valid since it's missing a construct to deal with multiple queries, and also because it's uncompilable pseudocode...)

Test cases:

Input:

31 41 59 26 53 58 97
1 4
0 2
5 6


Output:

26
31
58


Input:

1
0 0
0 0


Output:

1
1


Input:

-4 28 31 -54
0 0
0 1
0 2
0 3
1 1
1 2
1 3
2 2
2 3
3 3


Output:

-4
-4
-4
-4
28
28
-54
31
-54
-54


Sandbox Questions:

• Would the asymptotic runtime count as a non-observable requirement?

• is this too long and/or abstruse lol

• I’m not sure how to word the scoring section to narrow down the most obvious, basic O(n) expression — an algorithm that’s Ө(n) is also Ө(n/16384-50000) by definition. Is what I have clear enough? Have I left any loopholes?

• I kind of wanted to encourage people to try to implement Fischer-Heun or one of the more time-efficient intermediates in the slides, without restricting them to one particular algorithm (e.g. challenge: you have to make a Fischer-Heun structure). Does the scoring system make sense for this? Is it fair to have, for example, a Jelly answer using the naive algorithm in 3 bytes (score 10) compete with a Jelly answer using the Fischer-Heun structure in 30 bytes (score 31); but a naive Python answer with score 3000+ compete against with a Python Fischer-Heun with score 300?

• [tag:tag-name]
Jul 30, 2019 at 19:06

Introduction

Recently, me and a couple of my friends decided to play some cards, and one of them suggested the game 'Irish Snap', which was the inspiration for this challenge. However, I later learnt that the game has a lot of different rules that work ,some of which are listed here. The rules that are in this challenge aren't currently listed on that page, hence the name, 'Variant Rules'

The Challenge

Given an array of 3 cards, output a truthy or falsey value depending on if they make a valid snap in a game of Irish snap.

Input

The input will be an array of 3 numbers, ranging from 1-13 inclusive, with 11 being jack, 12 being queen and 13 being king. The last number in the array will be the number at the top of the stack of cards.

Rules

The 4 different criteria for if cards make an Irish snap are a snap:

• The top and middle cards are the same
• The top and middle cards have a difference of one
• The top and bottom cards are the same
• The top and bottom cards have a difference of one

If any of these criteria are met, you must output a truthy value. As well as this, for the two criteria that require the cards to have a difference of one, it 'wraps around', meaning that an ace and a king are considered to have a difference of one, and vice versa.

Test Cases

Input -> Output
1 13 7 -> False
1 4 13 -> True
9 3 6 -> False
8 9 7 -> True
2 6 5 -> True
12 5 11 -> True
10 4 8 -> False
12 13 7 -> False
9 7 10 -> True
7 3 1 -> False

• Wikipedia describes a substantially different game under the same name. Is there any less ambiguous name for this? Aug 6, 2019 at 8:27
• Although I don't think there is a less ambiguous name for it that I can find, the version I described is a combination of the alternate rules listed below the section you linked: 'conventional snap', 'runs', 'sandwiches' and the last rule I listed is basically a combination of 'runs' and 'sandwiches'. How could I change the name to reflect this? Aug 6, 2019 at 8:38
• Should I change the name to "Ultimate Snap", as that's what Wikipedia says those rules are commonly referred to as? Aug 6, 2019 at 8:42
• I think runs as described requires all three cards and in the right order. Maybe "Irish snap: variant rules" would be a suitable title, and the introduction can reference Wikipedia and say that the exact rules we'll be using aren't listed (at time of writing the question). Aug 6, 2019 at 8:49
• Ok, I've added in all of those suggestions Aug 6, 2019 at 11:23
• As our token Irishman, I endorse the keeping of "Irish Snap" in the challenge name! Aug 7, 2019 at 21:22
• Do you think I'll be able to post this now? Aug 20, 2019 at 9:44

Truth Table Composition

Given 2 or more truth tables, output the "shortest" way to compose the first N-1 tables to form the last (Nth) table.

Rules

• Standard loopholes/io rules apply.
• Input is a "list" of truth tables
• A truth table is a "list" of rows that contain the inputs and the corresponding output
• The input will always be the same length for a given table
• There must be $$\ 2^N \$$ rows in a given table, where N is the number of inputs in the table
• Each row must have distinct input
• Inputs and outputs must both be "booleany" e.g.:
• true/false
• 1/0
• truthy/falsey
• "Bob"/"Sally"
• The input can be in any reasonable format.
• Any of the formats shown here are reasonable.
• Taking the output first (ie for &: 1,1,1;0,0,1;0,1,0;0,0,0) is reasonable.
• Input that requires non-trivial logic to convert is not reasonable.
• Output is a "nested structure"
• Each level of the nest contains information of the:
• Truth table that was used
• The ordered inputs (of this structure)
• If a node is a leaf (one of the inputs to the final truth table) it must:
• Be distinguishable from the other nodes
• Contain the index of the input to the final table
• Output format must be reasonable (see details under input)
• "Shortest" is measured by the number of nodes in the output structure.
• It will always be possible to construct the last table with the first N-1.
• You do not need to handle invalid input.
• This is , so the answer with the smallest asymptotic time complexity wins! Answers that do not aim to be efficient are also welcomed.

Yes, I'm done with rules now. Sorry.

Test Cases

For these test cases, the output is explained below. Note that this is not the output format you have to use! - $N is the Nnt input to the final table (0-indexed) - N(...) is the Nnt input table applied to ... (also 0-indexed) - Arguments are comma separated and are in this format. - Note that N() is different from $N; the former is the Nnt truth table applied to nothing (only valid in the case of truth tables 1 and 0), and the latter is the Nnt input to the final table.

Input:
(anything)

1 0 0
0 1 1
0 0 0
1 1 1

Output:
$1 (length 1; leaf; gives the second input)  Input: 1 0 0 1 1 1 1 0 0 1 0 1 0 1 0 0 1 0 1 1 1 0 0 0 1 0 1 0 Output: 0($1) (length 2; the first table (not) applied to the second input)

Input:
1 0
0 1

1

0

Output:
0(1()) (length 2; the first table (not) applied to the second table (true))

Input:
0 1
1 0

1

1 0
0 1

Output:
0($0) (length 2; the first table (not) applied to the first input to the final table)  Input: 0 1 1 0 1 1 1 0 1 0 1 0 0 0 0 0 1 1 1 0 1 1 1 0 1 0 0 0 1 1 0 0 1 1 1 0 1 0 0 0 Output: 1(2($0,$1),0(1($0,$1))) (length 8; "(A | B) & !(A & B)")  Meta I think more test cases are needed, but am unsure what to add. This is my firstsecond challenge, so all feedback is welcome! • The idea is good, I think. I had trouble understanding at first read though, and didn't understand at all your $ things. I suppose $1 is the same as 1() but I'm not sure. Suggested test case: Input : (1,0;0,1) ; (1) ; (1,0;0,1) with Output : 0() and not 0(1()) or 1(0()). Aug 13, 2019 at 14:40 • @V.Courtois $0 is the first input to the final table, $1, the second etc. 0(...) is the first input table, 1(...) is the second, etc. Any recommendations on a better format? Aug 13, 2019 at 14:43 • @V.Courtois Added your test case, though 0() is not a valid output as (1,0;0,1) takes in 1 input, not zero, it should be 0($0) Aug 13, 2019 at 14:46
• Do you mean \$0 is the input on the first row of the output table? It got even more foggy... Plus, isn't a truth table's order meaningless? I mean, you even swapped the order of the rows in the last test case. And I just noticed now the # notation... Would you mind clarifying it all? Those signs are nowhere defined in the challenge ^^' Aug 13, 2019 at 14:52
• OH ; and by re-reading all the text I saw that your & is strange: why does 0&0 get 1?? Aug 13, 2019 at 14:53
• @V.Courtois The "&" is not an &, it is an iff/not xor Aug 13, 2019 at 14:54
• Oh my bad then, I didn't know for this one. Aug 13, 2019 at 14:56
• @V.Courtois Tomorrow I’ll revise the test case format Aug 14, 2019 at 0:38
• @V.Courtois I explained & slightly revised the notation; is it clearer now? If you have any suggestions, they would be very welcome. Aug 14, 2019 at 12:30
• Ah yeah, it looks clearer now. The test case of length 8 is really helpful in the process, too, for guys like me that in general read the test cases before reading what is the actual challenge about :) Let's hear other points of view about this challenge, for my part I don't see any problem now. Aug 14, 2019 at 12:38
• You can remove the "Exception: if there are 0 inputs, there must be 1 row." line, $2^0=1$. Aug 15, 2019 at 22:16
• For languages that support ND array, a ND array (each dimension has size 2) would be a natural representation of a N-ary truth table. Aug 16, 2019 at 4:44
• In your example is "1 1 1" = "(1, 1) -> 1" or "1 <- (1, 1)"? Aug 16, 2019 at 4:46
• Also: do you know any polynomial time solution to this problem? Aug 16, 2019 at 4:48
• @EriktheOutgolfer shame. I'll fix that. Aug 16, 2019 at 13:16

Planting Steiner Trees

In the following we are talking about Steiner trees, which are similar to minimal spanning trees: The goal is connecting all nodes via some paths such that the resulting graph that is as short as possible. In contrast to minimal spanning trees when constructing steiner trees you can add additional nodes.

In the following we are talking about points in the real 2d plane and when we are talking about distances and lengths, we are talking about the euclidean distance.

Also, a graph will comprise a set of points where the edges are straight lines between pairs of those points. The length of a graph will be the sum of the length of all edges.

So a steiner tree is a shortest graph connecting all given points possibly with inserting additional points. The following image shows the difference between a minimall spanning tree (blue) and a steiner tree (red).

It is known that it is very difficult to find steiner trees.

Write a program that accepts a list of 2d points and tries to find/approximate a steiner tree of minimal length connecting those points by possibly introducing more points. (It does not have to find the an actual steiner tree.)

The program should output a list of all the points (including coordinates) of the constructed graphs, a list of all edges (including their lengths), the total length of the graph and a graphical representation of the grap.

The program should have a running time of no more than about half a minute for each of the examples on a reasonable computer.

You should also explain how your algorithm works.

Scoring

The program must be evaluated on all the [NOT YET] given test cases. The score is the sum of the total length of all test cases. The lowest score wins.

Test cases

Square:
(0,0),(0,1),(1,1),(1,0)

Nonagon:
(cos(2*pi*a/9),sin(2*pi*a/9)) for a = 0,1,...,8

(0,0),(0,1),(1,0),(1,1),(2,0),(2,1),(3,0),(3,1),(4,0),(4,1),(5,0),(5,1)


Meta: I need to find a good set of test cases. Suggestions are appreciated.

If you have any suggestions, feel free to edit/add. Any improvements of the text are appreciated too.

@El'endia Starman Pointed out some interesting n-gon configurations

• It is known that Steiner trees for regular n-gons where 7 <= n <= 12 are simply the n-gon with one side removed. 4,5,6 all have interesting configurations though. Oct 31, 2015 at 0:03

Shortest Persistent Object in 5-Char JS

The []+= subset of JavaScript is known to be Turing-complete. A key part of the construction is obtaining persistent objects whose properties can be set and retrieved in a loop.

Most expressions won't evaluate to constant values. For example, [] != [] when compared by reference. However, some expressions, such as [].name, return the same object every time they are evaluated.

The following should hold when e is substituted with your submission:

• (e) instanceof Object (this includes functions and arrays)
• (e) == (e)

This is , so the shortest valid submission (measured in bytes) wins.

What's this constructed number's starter?

• The confusing part is how you mix single and multiple digit numbers. Sep 3, 2019 at 16:44
• @Beefster Could you elaborate on how that confuses you, so that I can try to address it? Sep 3, 2019 at 17:49
• "A concatenated number is a number that can be built this way through the use of the multiples of single digit numbers: 1,2,3,4,5,6,7,8,9 A.K.A an element in one of these 9 sequences" - I can see the pattern in the example, but this is not very friendly to skimming. Maybe explain what is going on the 3 example? The other thing is that this doesn't really feel like it needs to be limited into multiples of 1 digit numbers. Sep 3, 2019 at 20:47
• @Beefster I'll explain through the 3 sequence to make it clearer. It doesn't need to be limited to 1 digit numbers, although that guarantee that no element will ever be in more than 1 sequence, and is just how I decided to write the challenge. Sep 3, 2019 at 21:17
• I think you might try to find another name (or maybe do not name it at all) for "concatenated number" to avoid the possible confusion of concatenating single and multiple digit numbers. The recurrence is a much clear definition of such sequences and I think that should be put at the very beginning of the description.
– Joel
Sep 3, 2019 at 23:13
• "Is this clear enough? Is it easily understand what a concatenated number is?" Completely clear imo, although I agree with @Joel: $10a + b$ isn't really concatenating, so the title is a bit confusing for multi-digit numbers later on in the sequences. "Any other tag suggestions?" [sequence] maybe? And [integer] perhaps, although probably not; [number] would be enough here, and whether you'd use an [integer] or [string] is up to the user. "Is this a duplicate?" Couldn't find anything like it. "Any further feedback?" Some (large) test cases would be nice. Sep 4, 2019 at 7:30
• @Joel I've changed the name to constructed numbers, as it should avoid any confusion and still makes it easier to refer to numbers that meet the criteria Sep 4, 2019 at 9:06

43 quintillion permutations

• I think the requirement for 1:1 mapping is a bit much. I think it would be much more reasonable to only require that there is at least one numeric representation for every possible permutation and that every whole number corresponds to exactly one permutation. I can't even begin to wrap my mind around a solution that ensures there are no duplicate states on the way up to 43-whatever quintillion, but I can think of a few that could theoretically encode any permutation, but with duplicates in the mapping. Dec 11, 2018 at 22:20
• More on "every whole number corresponds to exactly one permutation" - the number of permutations of a rubik's cube requires a minimum of 66 bits to represent, so arbitrary-length integers are already a requirement to implement this challenge, therefore it is totally reasonable to need arbitrarily long integers to represent all permutations. Dec 11, 2018 at 22:23
• @Beefster I have been toying with the idea of converting this to a code challenge, where your score is the number of unique permutations you are able to output. Dec 11, 2018 at 22:51
• The issue with that is that it's trivial to cover all the permutations by associating each bit in the binary representation as whether or not to rotate a certain side 1-quarter turn clockwise. The other issue is that it's very difficult to calculate the minimum number needed to represent all permutations for any given algorigthm. I like the idea of making it a code challenge better than code golf, but I can't think of a good criteria either. Dec 11, 2018 at 23:05
• I think with a few minor clarifications this would be a great code golf challenge; I think it'd be great to see a non-golfed example program to show how it can be done. Also, as Beefster pointed out, a 64bit int cannot represent all required numbers, does you don't have to worry about the practicalities of actually taking in inputs greater than your language can handle mean I can still use a 64-bit int? Can I use a signed 64-bit int (assuming that makes the code shorter for some reason). Aug 19, 2019 at 10:06
• Additionally, what are the restrictions on display? Do I have to use the colors WGRBOY? Can I display the cube flipped for some numbers? (W center on bottom, Y center on top, etc) Can I display it rotated? Aug 19, 2019 at 10:09
• @Shelvacu The idea I'm trying to get across is that due to the potential size of the input, answers don't have to actually perform correctly for each and every input, assuming that the reason why they don't perform correctly is because the input is outside whatever limit the language/type has. So if a Javascript answer works perfectly for all inputs between 1 and 2^53-1, but fails for 2^53 because the input is out of bounds for Javascript, that's completely fine. If it failed for 2^53 because the algorithm used breaks after that many inputs, that's not fine. Aug 19, 2019 at 10:27
• @Shelvacu I'll loosen and clarify the output restrictions in the post itself Aug 19, 2019 at 10:27

Cleaning the dishes

In this task, you will be given a bar of soap with a width of 1 or more units, which will be inputted as an integer. You will also be given a plate, which you will have to clean, using the soap as few times as you can. The plate will be inputted as a an array of 2 different characters, one of which is the 'dirty' character, and one of which is the 'clean' character. The plate will be at least 1 character. You will have to output an array with the 'clean' character representing the plate, and a third unique character to represent in what positions the bar of soap was placed. None of these 3 unique characters may be whitespace.

How much the soap cleans:

n//2-1 on each side for odd n
n//2-1 on the left side of the soap bar for even n
n//2   on the right side of the soap bar for even n


Input

An integer greater than or equal to 1. A series of 2 unique characters to represent clean portions and dirty portions. Here, '=' represents a dirty portion, and '-' represents a clean portion. '+' represents where the soap was placed.

IN : OUT

3 ===- : -+--
32 ================================ : ---------------+----------------
1 ==== : ++++
5 ----- : -----
4 -====- : --+---
3 -====- : --+-+-
7 === : +--
6 - : -
6 -==-===- : ---+----
5 -==--==- : ---+--+-
3 -==--==- : --+--+--


Rules

• There are multiple solutions. Any one of them are acceptable, as long as they use the soap the minimum amount of times possible.
• This is a contest, so the shortest answer in bytes wins!
• The plate may only be non-whitespace characters, and have 2 unique characters.
• The soap may only be one non-whitespace character, unique from the other 2 used in the plate.
• Standard loopholes are not allowed.

Posted: Cleaning the dishes

• If "soap input may only contain the characters '0' through '9', and may be multiple characters", then can it not be passed as an integer argument to a function? Sep 4, 2019 at 4:15
• i already specified rules about soap input in the first paragraph, so i will erase that rule. Sep 4, 2019 at 20:34
• There seem to be multiple possible outputs, e.,g.: 3 =-=-= could be either +--+- or -+--+, yes? If that is true, can we output any of them? Sep 7, 2019 at 23:34
• Yes, any output is acceptable, as long as it works, and is the minimum. Sep 7, 2019 at 23:53

Battleship KotH

This is a pretty rough idea to start but I figured I would drop it in the sandbox so that people can start to think about it and I will remember to do it.

The idea here is a that combines the game, battleship with .

The rough idea is that two enemies would face off, each turn irradiating a location in their opponents source code. Then the opponents source code would be recompiled and then try and attack back.

• We will likely want to limit the size of the board to a specific rectangular size

• I would like there to be a feedback from shooting your opponent (in the game battleship this is hit/miss) so that you are doing more than just firing randomly. Perhaps programs might irradiate a single bit (flipping its value) and get back its value before it was irradiated.

Language choice is a bit tough since I would like something multipurpose and flexible but I don't want to have to deal with the security issues that are involved in compiling and running a fully featured programming language.

• radiation-hardening tends to work best with deletion. This is going to need a maximum byte count to be fair, otherwise the best strategy is excessive amounts of whitespace and comments. Love the idea though. Sep 17, 2019 at 14:22
• You don't actually have to limit yourself to a specific language on this one. It wouldn't be that hard to use a shell script to run whatever languages are available. One question though: is each program able to read the source code of the other or is each attack supposed to be blind? If you're worried about security, you could run the controller in a docker container or VM. Sep 17, 2019 at 14:26

Injection from two strings to one string

• Do you think that a reasonably number of languages won't implement the following: convert the strings into numbers (e.g. treat each character as a base 128 digit) then give a resulting string of those two numbers joined by some other character? I haven't spent too long thinking about it but that seems very short in most languages. I suppose there are other variants though where you map characters to some subset and then join them. Sep 24, 2019 at 20:42
• @FryAmTheEggman I imagine the solution used is going to depend on the language: what builtins it has, if it's more high-level or low-level, etc. But there may well end up being a prevalent algorithm. Sep 24, 2019 at 20:57
• Why strings? Lists of integers, (even restricted to a range) work as well but don't have the complexities that strings do when it comes to printables etc. I feel like the simpler challenge is going to be the better one.
– Wheat Wizard Mod
Sep 26, 2019 at 3:30
• @FryAmTheEggman Don't worry, I've thought of a totally different approach that I think would be shorter for many languages.
– xnor
Sep 26, 2019 at 4:46
• @SriotchilismO'Zaic Restricting the character set seems to me like a reasonably simple detail, while making it about strings encourages creativity with string operations, converting to string representations, etc. Also, I personally think string input/output is much more appealing to look at and easier to consume than a list of numbers. Sep 26, 2019 at 14:38

Hexdumps used with xxd look something like this:

00000000: 666f 6f20 6261 7220 7370 616d 2065 6767  foo bar spam egg
00000010: 730a                                     s.


Your task is to convert a hexdump in this form in to the number of bytes used.

Rules:

• Usual loopholes forbidden.
• This is , so shortest valid answer in bytes wins.
• You may or may not include the newline at the end of text (0a). This means that if the hexdump ends in a newline (0a), that input may have it's output reduced by one.
• An empty input must output 0.

Test cases:

00000000: 4865 6c6c 6f2c 2077 6f72 6c64 2120 4865  Hello, world! He
00000010: 6c6c 6f2c 2077 6f72 6c64 210a            llo, world!.


returns 27 or 26

00000000: 0a                                       .


returns 1 or 0

00000000: 6368 616c 6c65 6e67 650a                 challenge.


returns 10 or 9

00000000: 4865 6c6c 6f2c 2077 6f72 6c64 21         Hello, world!


returns 13




returns 0

Sandbox:

• Is this clear?
• Is this a duplicate?
• Other tags?
• Does the extra rule mean that the input can have an optional trailing newline, or that the results in all of your test cases could be reduced by 1? If you mean the former I recommend adding a test case that doesn't end with a newline. If you mean the latter then I recommend explicitly saying the file will end with a newline character. Also I suppose this is a string challenge. Thanks again for using the sandbox :) Oct 3, 2019 at 20:55
• @FryAmTheEggman It means that all test cases could be reduced by one. This was intended as a code golf byte counter, and the newline most certainly isn't usually included. I'll clarify this and add another test case to highlight it. Oct 4, 2019 at 15:17
• So: discard all the input except the last line, and parse hex? Or just output the last line and claim that your output is in hex? IMO it would be a more interesting problem with xxd input, where the last line is not present. Oct 5, 2019 at 9:00
• @PeterTaylor If I were to switch to xxd, would that be a valid edit, or would that be too big a change such that I would have to post another challenge? Oct 5, 2019 at 9:45
• I'm sure far more significant edits have been made to sandboxed challenges in the past. Oct 5, 2019 at 13:10
• @PeterTaylor In that case, edited. Oct 5, 2019 at 14:52

Java vs C++

Now posted at Time to settle this: Java vs C++

• How vital is the validation to the challenge? Aug 27, 2019 at 21:01
• @UnrelatedString I think it's fairly integral if the story is considered. Gotta inform the user that they're feeding you crap. Also it should add an extra element of challenge. Aug 27, 2019 at 21:07
• @MrRedstoner Validation is generally considered tedious by the users of this site, rather than challenging. I'd recommend reconsidering - clearly the validation code could make use of the submissions as a subroutine. There are also a couple near dupes 1 2 but I haven't found a precise dupe. That said, thanks for using the sandbox! Aug 28, 2019 at 0:36
• getHTTP would result in... get_h_t_t_p? get_http? Error? Some other thing? Aug 28, 2019 at 1:42
• @ChasBrown should be get_h_t_t_p, I shall add that. @FryAmTheEggman While I considered it part of the story, if those are the standards I figure I'll remove it and say the validation was done by a previous part of code. Aug 28, 2019 at 5:24
• "If it is neither, output/return a falsey value." I would change this to something like "If it is neither, any unspecified behavior is fine (return a falsey value; give an error; try to convert it somehow anyway; etc.)." As mentioned by @FryAmTheEggman, validation is usually considered a distraction of the actual challenge (and can sometimes even double the code of the program/function for those answering), so most challenges assume the given input will always be valid. Apart from that the entire challenge looks fine, so +1 from me. Thanks for using the Sandbox! :) Aug 28, 2019 at 9:32
• @KevinCruijssen Dang it missed that during the edit. Thanks for telling me! Aug 28, 2019 at 10:42
• What should be returned from an input of a__b (two underscores)? Aug 29, 2019 at 1:03
• @ValueInk That would be invalid input. 'You may assume all input to be valid'. Therefore I refer you to the ANSI C standard for undefined behaviour. Aug 29, 2019 at 6:00

Can Jimmy escape the ghosts?

Posted: Can Jimmy escape the ghosts?

• S'all good, no problem Oct 17, 2019 at 14:05

Universal Self-correcting Program

The idea here is to make a program that can tolerate errors in its own code, while still functioning correctly.

Since "error" is too broad, we will define it by a single bit flip. Of course, more tolerant versions, that could accept swapping any character with any other character would still be valid.

This program is universal in the sense that you can write any other self-correcting program (with the same tolerance) -- more on that later.

Importantly:

1) This program takes as input a triple-redundancy string of characters, and outputs a corrected string.

2) This program executes correctly with any bit flip in its own code.

(1) Triple redundancy codes

A triple redundancy code consists of simply repeating each bit, character or byte 3 times. In this case we use characters.

Correction is done by taking the majority of the characters, so (A,A,B) is corrected to A, (A,B,B) is corrected to B and so on.

AAA => A
AAB => A
HHHEEELLXLLLXOO => HELLO


This is a very crude an inefficient code for correcting single bit errors, but it is the least complex, which is why I think may be the best choice here. Hamming codes are better but a little more complex.

(2) Error tolerance

Our program will be defined as error tolerant if it performs the desired decoding function for any single bit flip in its own code. It may take longer for some inputs or when some flips occur, but it should always terminate.

Putting it together

The error-tolerant program can receive as input a (possibly faulty) program, and outputs a error-free program. Therefore, if a single-bit error occurs anywhere in the system comprised of (decoder,input program), a corrected program will still be output.

Observation

I don't actually know if this is possible, quite possibly it won't be achievable in every language. If it is too hard, we may relax the tolerable errors.

Scoring

The score will reflect the reliability of your program to errors. Tolerance is simply the number of bit flips you code accepts anywhere. It must be at least 1 (accept 1 bit flip anywhere). Size is the length of your program in bytes.

The score is Score = Size / 2^Tolerance

Lowest score wins.

Note: Several other challenges are possibly solved by solving this one (which would make sense given its universality!) by hardcoding the input.

Detect if your program has been mutated

Write a program that always outputs “2012” - even if it's modified!

This solves the "Who Watches the Watchmen?" problem involved in error correcting programs, like in this challenge:

since the decoding program itself tolerates errors (what good would be an error correcting program that is itself in error? :p).

• Check the radiation-hardening tag for duplicates and rules clarifications, too. Mar 7, 2018 at 19:17
• @AdmBorkBork Thanks, I wasn't aware of that. It appears no one has proposed a Universal radiation hardener yet (this is universal only in the sense of bit flip errors; those are actually a good model for radiation though!).
– Real
Mar 7, 2018 at 19:30
• Again Lenguage win lol
– l4m2
Jan 8, 2019 at 14:53
• Even though your scoring involves code length you should use code-challenge instead of code-golf for challenges that are not solely scored by code length. Jan 10, 2019 at 20:14

Golfing with 2s

It is well-known that all positive integers can be represented via a sum of powers of 2. For example, 13=2^3+2^2+2^0. We can rewrite the 3 and 0, to get 13=2^(2+2/2)+2^2+2^(2-2). A shorter representation might be 13=2^2^2-2-2/2, or a more repetitive one 13=2+2+2+2+2+2+2/2

Challenge

Your task is, given a nonnegative integer as input, output/return a string containing only 2s and elementary operations, which when evaluated will yield that integer. These operations are +, -, *, /, ^, and appropriate parentheses. Use of multiple consecutive 2s (22, 222, etc) is not allowed.

However, the string should tend to be one of the shorter representations of the integer in question. So for the above example with 13, 2^2^2-2-2/2 and 2^2^2-2/2-2 are the shortest representations.

The input can be in any convenient format, but the output must be in the above format, either to a file or STDIO.

Scoring

Short code and efficient representation are both prioritized, so the score is the length in bytes plus the average length of the returned string for 9, 57, 554, 1894, 25993, 113193, 2998225, and 52748566.

Rules

Standard loopholes not allowed

Some degree of brute forcing is allowed, but the program must be able to handle each of the test cases in under a minute each.

Example outputs

0            2-2
1            2/2
2            2
3            2+2/2
4            2^2
5            2^2+2/2
6            2^2+2
7            2^2+2+2/2
8            2*2*2
9            2*2*2+2/2
10           2*2*2+2
57           2^(2^2+2)-2^2-2-2/2
554          2*2^(2*2*2)+2*2^2^2+2*2*2+2
1894         2*2^(2*2*2+2)-(2^2^2-2)*(2*2*2+2+2/2)
25993        (2*2^(2*2*2+2)-2*2^(2*2*2)-2^2-2-2/2)*(2^2^2+2/2)
113193       2*2^2^2^2-(2^(2*2*2+2)-2^(2^2+2)-2^2^2-2-2/2)*(2^2^2+2+2/2)
2998225      (2*2^2^2^2-(2^(2*2*2+2)-2*2*2-2-2/2)*(2*2*2+2+2/2))*(2^2^2+2*2*2+2/2)
52748566     (2*2^(2^2^2+2^2)-2^2^2^2-2*2^(2*2*2+2)-2*2^(2*2*2)-2^(2*2*2)-2*2*2-2/2)*(2^2^2-2-2/2)*2

• It doesn't have to be optimal. It should tend to be optimal but you can trade it out for a much shorter program if it helps. Dec 8, 2019 at 8:10
• It might be a good idea to clarify length - do you mean the actual string length or the number of operations and 2s used? Dec 8, 2019 at 20:19
• Added clarification for both. To Fry, I mean the string length, but I'm not entirely sure what the difference is. Dec 9, 2019 at 0:39
• Can we use the numbers 22, 222, etc. in the output? Dec 10, 2019 at 16:33
• No. Will add clarification for that as well. Dec 12, 2019 at 0:33
• Can we submit a function that takes a value and returns a string? Typically you should try and avoid restricting input and output, and just rely on the community standards
– Jo King Mod
Dec 13, 2019 at 3:26
• in reasonable time I know this is hard to specify, but as it stands it is too broad: what is meant by "reasonable time"? Some previous challenges say things like "it should run within a minute on a modern computer for inputs less than..." Dec 16, 2019 at 9:47
• Yeah, I'm not really sure how to specify it further. I only really added it because when I showed this challenge to my friend, they wrote a brute-force that goes through every string with those 8 characters and finds the shortest one, and it would take a few minutes for inputs > 30. Does being able to run each of the test cases in under a minute sound good? Dec 16, 2019 at 19:15
• That's the usual tactic, though you should probably specify what computer it is run on, since some will be faster than others. A possible idea could be the answerer has to run the biggest test case to completion, which should eliminate the worst of the brute force scripts
– Jo King Mod
Dec 18, 2019 at 7:33
• Giving the integers you'll be testing with might allow people to optimise those specific inputs sneakily - maybe ask for a TryItOnline link and then give every answer a score yourself? Just a suggestion. Dec 27, 2019 at 19:10

Eats, shoots and leaves

As you know, a panda eats shoots and leaves. Your task today is to write a panda in as few bytes as possible.

       1
/ \
7   5
/ \   \
2   6   9
/ \   \
3   8   4


Here this tree has two branches, 1-7-6 and 1-5-9. The branch 1-7-6 has a shoot 2 and leaves 3 and 8, while the branch 1-5-9 has a leaf 4. After eating the shoots and leaves, your panda should output the following tree:

       1
/ \
7   5
\   \
6   9


If your panda is a program or function, it must output the tree in the same format that you input it. Alternatively it can be a subroutine that modifies the tree in-place.

If it helps, you can assume that the tree has at least two nodes, and/or that each node has at most two child nodes.

No standard loopholes.

• What is a shoot, and what is a leaf? Is this question asked to remove all leaf nodes (nodes without children) in a tree?
– tsh
Jan 13, 2020 at 1:30
• @tsh For the purposes of the story, a shoot is a node which has no child nodes but whose parent has at least one grandchild node. Otherwise as you notice it has no effect on the outcome.
– Neil
Jan 13, 2020 at 10:58

Bucket and Minimize

Post here

• @FryAmTheEggman thanks for the info. updated Jan 21, 2020 at 9:40
• "floor(12%5)+1 into 12 mod 5 buckets, and floor(12%5) in the rest". Shouldn't those floor(12%5) be floor(12/5) based on your $\left\lfloor\frac{|L|}{N}\right\rfloor+1$ formula? Jan 22, 2020 at 10:40
• @KevinCruijssen er, yes. keeping things conventional. in my preferred language (k4) % is float division. i'll update it to avoid confusion. thanks! Jan 22, 2020 at 12:27
• Ah ok. In most languages I know % is modulo and / is division. :) I thought maybe % was integer-division in your language of choice, making the floor` obsolete. But your edit is indeed clearer. Jan 22, 2020 at 12:47
• I would recommend cleaning the body of this answer and linking to the actual challenge: codegolf.stackexchange.com/q/198406/75323
– RGS
Feb 2, 2020 at 21:07
• @RGS cleaned up Feb 2, 2020 at 23:55