# 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 needs more feedback, but it's been ignored, you can ask for feedback in The Nineteenth Byte. It's not only allowed, but highly recommended!

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

## 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!

## I'm sorry, Code Golf

This challenge is inspired by a series of Garfield-inspired artwork in which Garfield is depicted as a horror creature, stalking his owner, Jon. Commonly referred to as "Creepy Garfield", the line "I'm sorry, Jon" can be found in one of the earliest Creepy Garfield images, created by DubbleBaby.

After being used over and over again by the Code Golf community, our beloved Jimmy has transformed - no longer bound to his weak, mortal body. He has become the embodiment of spaghetti code, the ascii manifestation of hours-long debugging sessions.

Take 3 ordered numerical inputs and output Jimmy's body

Inputs

Input is received in the form x y z where:

x is the number of left limbs (integer between 1 & 10)
y is the number of right limbs (integer between 1 & 10)
z is the number of heads (integer between 1 & 10)

----Sample Input----
2 8 1


Meta Note: I don't think increasing the possible amount of body parts will influence the solutions but please let me know if you think they should be higher.

Body Parts

Head =          <o>
Left Limb =     /
Right Limb =    \
Filler Limb =   |
Body Piece =    0


Body Generation Rules

   1. Left limbs must be attached to the left side of a body piece
(excl rule 3)
- Correct:  /0
- Incorrect: /<o>
- Incorrect: 0/
- Incorrect: /0\0\

2. Right limbs must be attached to the right side of a body piece
(excl rule 3)
- Correct: 0\
- Incorrect: <o>\
- Incorrect: \0

3. Limbs must not touch
- Correct: /00\
- Incorrect: /0\/0\

4. An external body piece without a limb must have a | in its place
- Correct: /0|
- Correct: |0|
- Correct: /00\
- Incorrect: /0
- Incorrect: 0\

5. Heads must be between body pieces (horizontally not vertically)
- Correct: 0<o>0
- Incorrect: 0<o><o>0
- Incorrect: 0<o>

6. All lines must be aligned centre
- Correct:      /0\
/0<o>0|
/0\

- Incorrect:    /0\
/0<o>0|
/0\

7. The bottom line of Jimmy's body must always contain a left and right limb
- Correct:      /0\
/0<o>0|
/0\

- Incorrect:    /0\
/0<o>0\
/0|

8. Jimmy's body must be whole and cannot be separated into sections
- Correct:    /0\
/0<o>0|

- Incorrect:    /0\   /0\   |0<o>0|

- Incorrect:      /0\

/0<o>0|


Examples

Input:
2 8 2

Sample Output:

/0<o>0<o>0\
|0\
|0\
|0\
|0\
|0\
|0\
/0\

OR

/0\
|0\
|0<o>0\
|0\
|0\
|0<o>0\
|0\
/0\


## Rules & Win Conditions

1. You may receive the stated input via any method into a program or function.
2. You may display the output in any clear and discernible way.
3. Your output must obey all Body Generation Rules.
4. The previous 3 rules must be followed for all 1000 combinations of inputs.
5. Standard loophole rules apply.

As this is , least amount of code in bytes wins.

• I don't like bonuses in code golf in general, and this one doesn't even affect the score so it's just an invitation to distract from the challenge Jul 16 '19 at 20:36
• (1) Whenever you see a bandwagon, run the other way. It's better to ask an interesting question than the nth variant on a theme. (2) That aside, there's no clear explanation of what the input is. Where are the values of that enum? Jul 17 '19 at 10:53
• @PeterTaylor (1) This challenge doesn't exist to hop on the bandwagon. I thought that generating an eldritch-like stick figure would be neat. If you don't think this is an interesting question, I'd love to hear your feedback on that. (2) I've amended the input section to be a bit clearer but I'm not sure what I was missing in the first place.
– BDM
Jul 17 '19 at 21:13
• What's missing is an explanation of the interpretation of the numbers. The input section defines the range of legal inputs but not the meaning of the inputs. Jul 17 '19 at 21:33
• @PeterTaylor Ah I understand now. Hopefully my recent edit solves this.
– BDM
Jul 17 '19 at 21:44
• Somewhat related ... I think?! Jul 21 '19 at 21:23

# String attractors

abcdefghijklmno
pqrstuvwxyz{|}~

¡,,#$%⅋,)(*+'-˙/ 0ƖᄅƐㄣϛ9ㄥ86:;>=<¿ @∀qƆpƎℲפHIſʞ˥WNO ԀQɹS┴∩ΛMX⅄Z]\[^‾ ,ɐqɔpǝɟƃɥᴉɾʞlɯuo dbɹsʇnʌʍxʎz}|{~  The rest of the characters are kept as-is(yes, the unprintable characters are in the ASCII character set). The characters that are larger than 0x7f will be mapped back by subtracting the character code by 128. If you are using a character that is larger than 256, modulo the character's character code by 128 before checking the availability. ## Rules • No standard loopholes, please. • Input and output will be taken with our standard input methods. • If you force Jono 2906 to change a key on their keyboard (allowing typing your specified character), you will get a penalty of +2 bytes for every key you add. • I don't think I quite follow. Are we given a character as input and need to output the upside-down version? Aug 27 '19 at 14:06 • (1) I still find the question confusing even as to the basic functionality required. The "Input/Output" section seems to me to say that it's a Kolmogorov problem, but the "Rules" section talks about input. (2) If a character remapping is involved, the question should list Unicode codepoints for the characters in question, and should list test cases with Unicode codepoints. (3) Is the last rule saying that the program must work as is and after mangling? Or is it just a gimmick ("Post your code upside down, but it only has to work the right way up")? Aug 28 '19 at 8:39 • "The rest of the characters are not kept as-is(yes, the unprintable characters in the ASCII character set)." should this not be there? As for that entire paragraph, if I understand correctly: unprintable characters < 33 (as well as 127) will be kept as is; printable ASCII characters displayed will be converted to upside down; other printable ASCII characters and any character above 127 will be modulo-128 before doing the same check. Aug 28 '19 at 9:24 • As for the last rule: we can only use those upside down characters in our source code, and when converting it to regular it should also work? So both programs ABC and ∀qƆ should work exactly the same? Aug 28 '19 at 9:25 ## Wrong position I typr re;atively accuratrly, but so,etimes I made a whole nlock of text illegible by shifting a key right. So I need a program that corrects my text back to its original meaning. ## Rules • You have to left shift on a standard English QWERTY keyboard. • Whitespace do not count for the procedure before left-shifting and are kept as-is in a standard left-shifting procedure. If the key is the leftmost letter/symbol on a keyboard(i.e. The ~key, Q key, A key, Z key.), the key is kept as-is. If you reach a control character while left-shifting (Caps lock and Shift), their effects will not be triggered and the character before left-shifting is kept. • This is a contest; the shortest answer wins. • Both the input and the output shall be given via our default methods. ## Representation of a subset of the QWERTY keyboard that you will need The two lines connected are possible values of the key: shifted/unshifted. ~!@#$%^&*()_+
1234567890-=

QWERTYUIOP{}|
qwertyuiop[]\

ASDFGHJKL:"
asdfghjkl;'

ZXCVBNM<>?
zxcvbnm,./

(Space)
(Space)


## Input

The input will always be a non-empty string conforming the rules above.

## Output

The output will be the input string corrected to the originally intended meaning.

## Examples:

Yjod ,sfr yjr, imjsppu/ -> This made them unhappy.
vpfr hp;g -> code golf


## Feedback

I think this is not a duplicate; however, is any part of this challenge unclear or needs improvements?

• I think you are mixing up left and right. Clearly, ~, Q, A and Z are leftmost keys, NOT rightmost. And your examples appear to be left-shifting, not right-shifting. Sep 7 '19 at 11:27
• "I think this is a duplicate" - so why sandbox it? Or did a not go missing in editing? Sep 9 '19 at 8:36
• Thank you. Predominantly my mouse was not working again, I didn't get around to fix this.
– user85052
Sep 9 '19 at 8:56
• "sonetimes" and "vlock" are shifted the wrong way. Sep 9 '19 at 16:20

# Path to Path Rearrangement

In the xkcd comic "Map of the Internet", a special fractal path was used, similar to this:

0  1  14 15
3  2  13 12
4  7  8  11
5  6  9  10


Ascii art version:

-0---1  14---15--16 19--20---21
|   |       |   |       |
3---2  13---12 17---18 23---22
|           |           |
4   7---8   11 30---29 24---25
|   |   |   |   |   |       |
5---6   9---10 31  28--27---26
|
58---57 54---53 32  35--36---37
|   |   |   |   |   |       |
59  56---55  52 33---34 39---38
|           |           |
60---61 50---51 46---45 40---41
|   |       |   |       |
63---62 49---+---47 44--43---42
\|/


This path, known as the Hilbert curve, has some interesting properties. Among other things, it can be flipped diagonally without changing most of those properties.

-0   3---4---5  58--59---60  63->
|   |       |   |       |   |
1---2   7---6  57---56 61---62
|           |
14---13  8---9  54---55 50---49
|   |       |   |       |   |
15  12--11---10 53--52---51   48
|                           |
16---17 30---31--32--33 46---47
|   |           |   |
19---18 29---28 35---34 45---44
|           |   |           |
20  23---24  27 36  39---40  43
|   |   |   |   |   |   |   |
21---22 25---26 37---38 41---42


Your task is to apply this transformation. Given a space on one path, find the corresponding location on the other. For example, the fourth space in the top path is located at (0, 2), which is the 14th space along the second path, so the correct output for 4 is 14.

As with similar challenges, this can be done as:

• An infinite sequence along the second path of the corresponding locations along the first path
• A function/program that takes a numbered position on the first path and returns the distance to that point on the second path.
• A function/program that takes a numbered position on the first path and returns all path 1 positions along path 2 to the point specified.

The first 64 terms of this sequence (zero indexed, add one to each for one indexed) are:

0 3 2 1 14 15 12 13 8 11 10 9 6 7 4 5 58 57 56 59 60 63 62 61 50 49 48 51 52 55 54 53 32 35 34 33 46 47 44 45 40 43 42 41 38 39 36 37 26 25 24 27 28 31 30 29 18 17 16 19 20 23 22 21


This is code golf, so shortest code in bytes wins.

## Meta Questions

• Do I need a better description of the paths?
• Is the challenge itself clear?
• Any other issues I should fix before posting?
• The default output formats for sequence challenges can be found in the tag wiki
– Jo King Mod
Sep 10 '19 at 4:03
• (1) Related. (2) I don't find "Find the location along the second path of a point on the first path" at all clear. It seems to be talking about output in 2D. I think it would be clearer to say "Given an index on the first path, output the index of the same coordinate on the second path". And then give a worked example (e.g. 4 vs 14). Sep 10 '19 at 10:53

## Maximize the Hello, world's in code permutations

In this task you should output this exact string: hi orb (because Earth is a sphere). However, here is the catch: you must output as many hi orb's as possible in all of your code permutations. Identical permutations do not count(e.g. aa's permutations count as one permutation)

Say you have a program abc that outputs this string. You should try your best to make acb, bac, bca, cab, and cba (i.e. the permutations of abc) also output this exact string.

## Rules

• Input/output must obey our standard methods.
• Your score is simply the factorial of the length of your code. You shall also present the following score: The score is counted in the negative of the length of your source code divided by the number of permutations that your code generates; (expression: -(source length/permutations).) Of course you want to keep your score as low as possible.
• All comment characters in your language are disallowed, in order to avoid collapsing into a radiation-hardening challenge.
• If you are using the filename as data, the filename must also count in the permutations.
• The source code length should be <1000. (Don't ask why, it's just an attempt of avoiding abusing the source code length.)

## Feedback

• Is it detailed enough?
• Is the input/output rules clear enough?

I don't think this is a duplicate because nobody has asked a question tagged with both permutation and hello-world. However, I worry that this challenge will collapse into a radiation-hardening challenge if you comment out a single character and then make sure that this will produce the same result, therefore making it a flavored version of this question and close to a duplicate.

• Can't you just extend your score by increasing your byte counnt, as long as you have some commented out part or no-op?
– Jo King Mod
Sep 19 '19 at 8:50
• Unneccecary NOPs are disallowed, and at least 1 permutation of your code must only contain relevant code and nops. is rather vague, since no-ops aren't really defined, nor is this challenge really that possible to increase score if you don't have no-ops, otherwise it will turn into a duplicate of the normal Hello World question
– Jo King Mod
Sep 19 '19 at 9:25
• This reminds me of a challenge I sandboxed a while ago, but deleted since it was clear it would produce only trivial answers
– Jo King Mod
Sep 19 '19 at 9:27
• code-golf scoring usually has lowest score (=code length) wins. If you break with that convention, you should mention it in the rules. I think a big problem with this is that for any non-trivial answer (Like H in HQ9+), the proof of correctness of the score is almost impossible, because unlike radiation-hardening, the amount of variants increases factorially instead of linearly with the code length. Sep 19 '19 at 11:52
• Hmm, it is okay, I will make the score negative then. I believe a program running the permutations of a string (not counting repeated ones) and evaluating them to check the result will be sufficient. Hmm, that's why the submittor needs to golf their code: to allow others to check their answers.
– user85052
Sep 19 '19 at 12:09
• That's where it's unfeasible: The highest-scoring answer in the challenge you linked has 96 bytes. That's 9.9*10^149 permutations to check if they output the correct result. Even assuming your implementation is the fastest possible, that would take years, just for that single answer. You can't brute-force determine the score, but using mathematical trickery to try and calculate the score by hand will be arduous and prone to errors. Sep 19 '19 at 13:10
• I don't think the limitations you have put are going to prevent this from falling apart. For example, this Pyth program works for any permutation of the code where only characters after the third " are permuted. Completely filling up the code allowed will achieve a score exceedingly close to zero. I don't think that is what you want, but I'm not really sure you can fix it (like what happened to Jo King), sorry. Sep 19 '19 at 18:38
• @FryAmTheEggman this particular snippet fails the rule that all code needs to be relevant. However, even if we tighten the rule to all code being life and necessary, that is, in one permutation, all code is executed, and a deletion of any statement resulting in the code not outputting "Hello World" any more, you can still cheese the challenge by bloating the code. The only way to stop that would be to change the scoring method to also use the factorial of the byte count, but then A) HQ9+ is unbeatable and B) It's a math challenge because you have to calculate the amount of viable permutations Sep 20 '19 at 10:06
• Instead of helo word, wouldn't it make more sense to just use a different phrase like greeting earthlings or something along those lines? I agree with @AdmBorkBork that helo just looks weird. I do think it shouldn't be hello world to prevent builtins, so helo word is already better, but it still looks weird and will raise questions for sure.. Sep 20 '19 at 12:38
• I don't understand the scoring. If we're scored only on the factorial of the length of code, why does it matter how many permutations output hi orb? I would figure that the number of ways that is output should factor into the scoring somehow... Sep 20 '19 at 14:11

# The Celestial Bureaucracy king-of-the-hill

Posted

• This sounds like a lot of fun. When the exam is asked, is it possible to know which bot gave the exam? Sep 18 '19 at 11:58
• You are given the ID of the bot via the parameter for ask, which allows you to identify if you've interacted with that bot before and if it's the Jade Emperor (because his ID is always -1). You won't get the name - if you want to identify the bot, you'll have to analyse its question and answer pattern. Sep 18 '19 at 12:08

# Creep Spread Territorial Control (WIP)

(probably)

Blah blah blah flavor blah blah blah something about Starcraft blah blah blah

# Gameplay

## Initial State

There is a 150x150 grid of square cells with approximately 7500 random cells missing in a symmetric Perlin noise pattern. There are four creep spread factions competing for dominance of this territory beginning as a single cell 10 cells in from a corner of the grid (one faction per corner). Each faction starts with 50 energy. The board does not wrap around at the edges.

## Expansion

Each turn, each faction earns 1 point of energy for each controlled cell plus 20 base energy. This energy is used for expansion. How much a cell costs to expand to depends on how many cells controlled by the same faction are in the Moore neighborhood of the target cell.

• 0 neighbors: cannot expand to this cell
• 1 neighbor: 50 energy
• 2 neighbors: 20 energy
• 3 neighbors: 12 energy
• 4 neighbors: 8 energy
• 5 neighbors: 5 energy
• 6 neighbors: 3 energy
• 7 neighbors: 2 energy
• 8 neighbors: 1 energy

There is no limit to how many cells can be expanded to in one turn other than energy costs. All expansions occur simultaneously. If two or more factions attempt to claim the same cell on the same turn, the one with the most neighbors of its own faction will claim the cell. If there is a tie, none of the factions claim that cell. Players whose expansions failed due to competition will not be refunded. Factions may expand onto each other's territory, stealing ownership of the cell.

## Game End

The game lasts 10,000 turns or until there is only one faction remaining, whichever happens first. The winner is the faction with the most owned cells. Ties are broken by remaining energy.

The overall winner will be resolved with a randomized pool where each bot plays an equal number of games followed by 12 games of the top 4 contenders. (one for each possible corner positioning)

# Coding

Write a bot that plays this game

• Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer between $$\0\$$ and $$\2^{32}-1\$$ will be passed to the bot, which will be seedable in the controller.
• Bots have perfect information of the current state of the board, which turn it is, and their own energy, but not the energy of other players.
• Bots may not remember anything between turns, but may initialize constants and utility functions at the beginning of each game.

The list of desired expansions is ordered. As soon as an invalid expansion target cell is encountered (whether by cost or lack of same-faction neighbors) in this list, the rest of the list will be ignored and a warning will be logged.

• So if I build at 0,1 and 1,0 on the same turn while having a cell at 0,0, the cost would be 2000, yeah? Are failed expansions refunded? Also, I think having a source of randomness would be good. Sep 13 '19 at 17:40
• @Veskah, that would cost 2000, correct. I'll add some rules about when failed expansions are refunded. Sep 13 '19 at 19:38
• Suggestions: 1. Maybe allow expanding to own territory too? Could be used as a defensive mechanism when you can predict that you are going to be attacked. (should be thought about, could be bad) 2. Maybe set a limit on how many cell expansions can happen per turn to avoid exponentially expansion? I'm thinking that a bot which gains some advantage might get unstoppable when it is unlimited. Sep 14 '19 at 7:33
• 3. More clarification in rules about expansions, for example if player 1 and 2 have a tie on this turn for cell X and they both go for it, but player 1 also goes for a neighbor of cell X in same turn, will player 1 win? (@Veskah mentioned another scenario too) 4. I would suggest using JavaScript so more people can write and run the code (anyone with a browser can do it), also a controller with some helper functions could be nice, for example a function which returns expansion cost for a cell in an optimized way to avoid tens of different implementations for same common action. Sep 14 '19 at 7:39
• 5. "Bots have perfect information of the current state of the board.", does this include current energy value of other players? Sep 14 '19 at 7:45
• @Night2 1 Interesting. It seems a bit fiddly. 2 This should actually come out to a quadratic expansion rate since where you can expand to is derived from perimeter, which grows linearly. 3 All expansions are resolved simultaneously (as in Conway's Game of Life), so player 1 does not win that tie. 4 Javascript is the likely plan since I intend to have a significant graphical component. 5 I'll have to think about it. That could be rather interesting as 'private' information. Sep 15 '19 at 3:00
• 6. Proposal to spice things up: board is randomly generated, with some cells being unavailable for expansion. Uniform random, Perlin/Simplex noise, cellular automaton-based cave generation, etc. 7. Will the bots have access to the turn counter? 8. Maybe rotate and/or mirror the board provided to the bots so that each bot starts at, for example, the top-left corner from its perspective? Sep 15 '19 at 10:36
• 9. Allow bots to pre-calculate some data on load or game start. This will allow people to speed up their bots. Especially useful if you end up implementing 6. Sep 15 '19 at 10:47
• @Alion 6 That sounds pretty interesting. I'll probably expand the board slightly in that case. 7 Yes, they'll know what turn it is. 8 I don't think that adds much. I'm probably going to have to make copies of the board every turn anyway to make it impossible to cheat on accident though... 9 Seems reasonable. Sep 16 '19 at 0:39
• "Bots must be deterministic. As a way to provide localized pseudorandomness, a random integer ... will be passed to the bot, which will be seedable in the controller.". Why not make a custom random function available or override the default random generator and make the controller generate and handle the seeds? For example in JavaScript users can still use the normal Math.random(), but you can use this to make it deterministic: davidbau.com/archives/2010/01/30/… Sep 21 '19 at 11:21
• @Night2, yeah. I'll probably do that since I'm going to have to use an RNG library anyway. Sep 22 '19 at 2:32

# Turing-complete regex subset

It's widely known that a programming language is one iff it's capable of addition of natural numbers and primality testing. In practice, this criterion has a high accuracy for distinguishing Turing-complete languages too.[citation needed]

## Cops' challenge

Choose any of the programming languages available on tio.run. Write a regex that will define a subset of this programming language. The subset must still match the definition, though ideally this should be far from obvious.

Write two programs in this language that match this regex:

1. Take two natural numbers, a and b, as input. Output a + b. The program must work for 0 ≤ a + b < 215.
2. Take a natural number n as input. Output whether the number is prime. The program must work for 0 ≤ n < 215.

The behavior outside of this range is undefined. This means that you can output the correct answer, a cute cat ASCII art, an error, an invalid answer, invoke nasal demons, or anything else you can, or cannot, imagine.

Regex come in multiple flavors. Choose one. You can choose any flavor available on regex101, or Retina.

• the programming language and regex flavor you chose
• the regex delimiter and flags you chose (for example: //gm; does not apply to Retina)
• the regex you wrote and its byte count
• the byte counts of your two programs

## Robbers' challenge

Write two programs that prove the subset to be a valid programming language. The rules that apply here are the same that apply to the cops. Additionally, your programs must not exceed the cops' in length.

# Meta questions

The above will be posted as the cops' thread, with the robbers' thread simply linking to it.

• Any improvements to challenge structure? I've never done this before.
• Do you see any loopholes that need addressing?
• Are the allowed regex flavors reasonable?
• Duplicates?
• I think this is a duplicate of codegolf.stackexchange.com/questions/136150/… Sep 22 '19 at 18:11
• @pppery Hmm. These are definitely pretty similar. On the other hand, regexes might allow more interesting answers. Sep 22 '19 at 18:25
• I'm not convinced this is a dupe since most of the interesting work here is in selecting the regex rather than in choosing a sequence, though I think the other challenge is cleaner. I think the optimal scoring regex will usually be to make an "unhash" that produces the appropriate programs. Unfortunately I don't have any suggestions at the moment to help fix that, but if you can then I think this is alright. Sep 22 '19 at 18:32
• @FryAmTheEggman I can't see what you mean by "unhash" here. Could you elaborate? Sep 22 '19 at 18:36
• Consider this program which performs the first task. The regex that matches only programs like this would be short but but not very informative. I think doing this but making guessing the magic number arbitrarily hard would usually be the best approach in a given language. Sep 22 '19 at 18:43
• @FryAmTheEggman Like, /^\.vC\d+$/? I think that making it complicated enough would take quite a lot of bytes. Sep 22 '19 at 19:02 • The point is that the number could be manipulated, so I could pad my program arbitrarily until I got a number that let me write a regex like ^...(2|10|76|345?)*$. That's neither very long nor easy to crack. Sep 22 '19 at 19:06
• I like the idea of the challenge but I feel including the bit about Turing completeness is a bit of a red herring, it only really distracts from the challenge.
– Grain Ghost Mod
Sep 22 '19 at 21:30
• To elaborate the particular part I like is regex selection part. I do agree that my challenge is a bit cleaner otherwise.
– Grain Ghost Mod
Sep 22 '19 at 21:31

• I'd recommend removing the text with a strikethrough; I think it is just confusing. "Accurate to 6 significant digits" isn't a very good validity criterion since it would require testing each and every possible input the program could handle. I'd recommend saying it has to be that accurate for your test cases but not be hardcoded for them, or something like that. Sep 19 '19 at 19:33
• For the tiebreak, what does code with the fewest bytes mean, given that we're outputting a county assignment?
– xnor
Oct 7 '19 at 22:24
• @xnor - I modified the scoring mechanism to not require tie breaks. Thanks to this modification, I expect the code submissions to be much more interesting. Oct 8 '19 at 17:06
• I like your new assignment score and no longer having a code golf tiebreak.The leave-one-out looks kind-of complicated and might take a long time to run-- is there a way to simplify it? The challenge looks a lot more intimidating that when I last commented, though the idea looks the same. I guess you want to make sure people actually write code that kind-of generalizes rather than possible finding an assignment by hand. Maybe also consider something with the standard deviation in assignment place of the max-min ratio so there's also an incentive to try to balance populations in the middle?
– xnor
Oct 8 '19 at 22:48
• @xnor - Great points, thanks! I simplified things by cutting the number of leave-one-out instances by a factor of 10. (I selected these 10 counties based on political geography considerations.) I also toned down the math speak to make the challenge less intimidating. I thought about standard deviation instead of max-min, but max-min is closer to how we enforce one person, one vote in practice. Oct 9 '19 at 2:20

I came across this little web game Drench Its a fairly mindless game , I wrote a small JS snippet to play this game for me in the background of my browser, it cycles through and clicks on the 6 possible moves

let ind =0;
let games =0;
let wins =0;
let lastMoves = "";
setInterval(function(){
if (jQuery('.moveNum').text() != lastMoves) {
lastMoves = jQuery('.moveNum').text();
ind++;
ind = ind%6;
jQuery('.pbutton:nth('+ind+')').click();
} else {
games++;
if ((jQuery('.moveNum').text()*1)) {wins++;}
jQuery('#myCanvas').click();
}
},200);


This Strategy wins about 3% of the time My question is, is there a more optimal strategy that will allow me to win a greater % of the time (without looking at the board)?

• Hi and thanks for using the sandbox! Though this is a bit unusual for this site, I think your question is on-topic, just far too broad. "Can I do better" just isn't something you can really ask on the SE network. I think the best way for you to move forward is to fully explain the game in the body of your post, and then score submissions based on their win percentage. Sep 21 '19 at 19:37
• I really like the idea though - I think win% is the way to go Sep 23 '19 at 15:20
• Make this a code-challenge? To verify, you can run it for, for example, 500 times and calculate the winning percent?
– null
Oct 13 '19 at 8:49
• Coded this up in p5.js, you can play it here hoppingmad9.github.io/dench Happy to convert it to pure js if needed and could add an interface to get the board state and input moves. Oct 18 '19 at 12:14
• oops, well I guess the code golf version can be called "Dench" not "Drench". I thought "Dench" was a weird name Oct 18 '19 at 15:29
• Probably needs a time limit for each turn to prevent people trying every single possibility of moves Oct 25 '19 at 15:39

# Create a safe crossing.

Given a string/number/array of any two distinct characters make the "squarest" 2D array that allows "someone" to cross from left to right or top to bottom "stepping" only on whichever character you have chosen as your stepping stone

### or

Make the "squarest" array possible that contains a complete row or column of stepping stone characters. (clearer but takes away the fun story-ness)

"squarest" meaning smallest difference between the dimensions of the 2D array.

## Input

• A string/number/array of your choosing consisting only of your two chosen distinct characters. So no error checking needed. Allow true/false values if input is array?
• input will have at least 1 stepping stone character so that a valid solution is always possible 1 by x or x by 1
• a minimum length of x? needed? might make it easier if there's some weirdness with very short arrays in the algorithms people come up with
• the last row can be incomplete to allow for prime number length inputs and to more easily allow non trivial 1xX/Xx1 answers

## Output

The output should be the dimensions of the array

• and specify the row or column to use?
• print your 2D array so that the path can be seen graphically?

## Test Cases

100100100 -> 3x3 array

100
100
100


11111000 -> 4x2 or 3x3 - 3x3 is squarer so is correct

1111    111
1000    110
00


11000011000101001001 -> 5x4

11000
01100
01010
01001


1000000000000 -> 12x1 - trivial as only 1 stepping stone

100000000000


010111 -> 3x2 or 2x3 - either acceptable as both are only "1" away from square

010    01
111    01
11


## Issues

• allow diagonal crossings? does that make it a lot harder?
• need a lot more test cases I think?
• input spec
• output spec
• better/more tags?

# ASCII Sum of your code

Encoding is nice, adding things is also nice. Let's do both !

Your task will be to create a program that read itself, convert every of its character into ASCII values and return the sum of those numbers.

## Example

Let's say your program is Hello, world !. Convert every character into ascii values

H  e   l   l   o   ,  (space) w   o   r   l   d   (space) !
72 101 108 108 111 44 32      119 111 114 108 100 32      33


Now, sum everything into a meaningless very useful value

72 + 101 + 108 + 108 + 111 + 44 + 32 + 119 + 111 + 114 + 108 + 100 + 32 + 33
= 1193


Here it is, Hello, world! returns 1193 !

## Rules

• The code have to read itself and calculate the result
• Standard loopholes are not allowed
• This is codegolf, so the fewer bytes wins.
• Non-standard languages with non-ASCII characters should use their own codepage's encodings (Thanks for @Veskah for this rule)

# Feedback

• Is the challenge clear enouth ?
• Is there an already existing challenge like this one ?
• is this considered as a duplicate of this challenge ?
• I would probably have non-standard languages use their codepage's encodings (pretty much all of them should be 8 bytes) to crunch their output. The big hammer approach would be to ban non-ASCII languages but I would not recommend that. Oct 23 '19 at 14:06
• Requiting the code to read itself and do the calculation is a non-observable requirement. Since it seems you don't want programs that just hardcode the value, I think the best way to be just to require the program take in an input string to use. Regardless, I don't really see room for interesting golfing in the challenge, since pretty much any normal-ish language has built-ins to take ASCII values and compute sums, and weird languages that don't have already done these as subtasks for many many challenges.
– xnor
Oct 25 '19 at 0:52
• @xnor Does this challenge with string input already exist ? Oct 25 '19 at 7:06
• I don't remember an exact one, but I'm finding very close ones: averaging ASCII values and summing then counting binary 1's, which was closed as a duplicate of one without the character adding. I also found an unrestricted quine challenge with the same task as yours. So I think there's a good chance this would be closed as a duplicate either way.
– xnor
Oct 25 '19 at 7:11
• Yup, the last one is quite the same as mine. Duplicate it is then. Oct 25 '19 at 7:13

# It's slashing time

(Inspired by Seven Slash Display)

You're lying in bed, awake. Sleepily, you turn your head to the alarm clock and read what time it is. Since you're lying down, the clock is facing diagonally, making it difficult to read. You decide to write a program to help you out (hey, you're awake anyway).

Given a "slashed" seven-segment display, output what time it is in 24-hour format.

      /\
/\
/\  /
\ \
. \/
/\ .
/
\/

2:03


You can choose where to place the : between the numbers (for example, evenly spaced as above or left-aligned as below, etc.), but the : must be present.

Some further examples:

       \
\
/\
/\
/ . /
\/\.
\  /
\

15:31

\
\/\
\
\
\.
\.

1:14


Here are the precise digit shapes:

/\
\ \
\/

\
\

/\
/
\/

/\
/\
/

\
\/\

/
\/\
/

/
\/\
\/

/\
\

/\
\/\
\/

/\
\/\
/


## Rules & Standard I/O boilerplate

• The time will always be valid. For example, you'll never receive something like 30:25 or 7:99 or the like.
• You're allowed to pad the input with whitespace however necessary (e.g., padding it to always be a rectangle with trailing spaces).
• Input always a valid time? Can we shift the dots? Oct 29 '19 at 19:01
• 2 in 2:03 is not aligned with other digits :(
– tsh
Oct 31 '19 at 8:53
• @tsh Indeed it wasn't. Thanks for the correction! Oct 31 '19 at 15:11

# Room volume as a function of paint on the walls/ceiling

Task: Write a function that will take in the size of a room (height, width, and length) and a number of paint layers (given that the layers are of a consistent thickness) and return the area of free space in the room after that many layers of paint are applied.

Requirements:

• Return the final area left in the room after the paint layers are added
• should be able to run on a room of any size
• The answer must account for the decreasing area in the room as each layer is applied.
• number of layers and paint layer thickness should both be inputs
• must account for walls and ceiling
• standard loopholes are disallowed

The winner is determined via byte count

• How thick is each coat of paint? Also, do you mean return the volume of free space in the room? Nov 14 '19 at 4:30

List of integers to pairs ?? Any suggestions for the title ??

Write a function or a full program taking a list of non negative integers numbers L that outputs a pair of numbers [X , Y] such that X %( Y + i ) == L [ i ] .

Output specifications

• You can output X Y in any order, just indicate it and be consistent.
• X Y are also unsigned integers, obviously Y must be greater than 0 to avoid modulo 0 errors.
• If your language doesn't support 0 indexed list you can consider X %( Y + i ) == L [ i + 1 ] ?? Any suggestions how to handle this ??

Example

[ 1, 2, 3 ] => [ 11, 2 ]

 11 %( 2 + 0 ) = 1
11 %( 2 + 1 ) = 2
11 %( 2 + 2 ) = 3


[ 10, 2 ] => [ 98, 11 ]

 98 %( 11 + 0 ) = 10
98 %( 11 + 1 ) = 2


# Test cases

[ input ] , [ output ] pairs

[ 0, 1, 2 ] ,  [ 5, 1 ]
[ 1, 2 ] ,  [ 5, 2 ]
[ 1, 2, 3 ] ,  [ 11, 2 ]
[ 1, 2, 3, 4, 5 ] ,  [ 59, 2 ]
[ 4, 3, 2, 1, 0 ] ,  [ 9, 5 ]
[ 6, 12, 18 ] ,  [ 3318, 18 ]
[ 27, 18, 9 ] ,  [ 279, 28 ]
[ 3, 9, 27 ] ,  [ 4059, 26 ]
[ 2, 4, 8, 16 ] ,  [ 8584, 14 ]
[ 0, 0, 0, 0, 0, 0 ] ,  [ 60, 1 ]
[ 1, 1, 1, 1 ] ,  [ 61, 2 ]
[ 120, 20 ] ,  [ 12220, 121 ]
[ 10, 2 ] ,  [ 98, 11 ]
[ 9, 8, 7, 0 ] ,  [ 1339, 10 ]
[ 0, 1, 4, 9, 2, 10, 4, 15, 10, 5, 0, 16, 12, 8, 4, 0, 22, 19, 16, 13 ] ,  [ 100, 10 ]
[ 9, 99, 90, 81, 72, 63, 54, 45, 36, 27 ] ,  [ 999, 99 ]


# Rules

• Input/output can be given by any convenient method.
• You can print it to STDOUT or return it as a function result.
• Either a full program or a function are acceptable.
• Standard loopholes are forbidden.
• This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

• For the testcases I think you can omit the outer parenthesis and the trailing comma. Furthermore I'd talk about nonnegative integers instead of unsigned integers. Nov 17 '19 at 16:44
• But I have another question: Is this problem always solvable? Nov 17 '19 at 16:44
• @flawr thanks I'll fix then. For the second question Idk.. Numbers increase extremely, I made a program for solving the problem and also a program to do the reverse(X,Y to list) I may do some test for each X,Y to a certain number.. Nov 17 '19 at 17:48
• I don't think [0,0,1,1] has a solution (consider the parity of X) cc @flawr Nov 17 '19 at 17:53
• @H.PWiz sadly yes Nov 17 '19 at 18:45
• @flawr and H.PWiz so if it's not always solvable do I have to delete this challenge? Nov 17 '19 at 18:47
• I dunno, you could guarantee that the input is solvable. Or you could ask a different (harder) question instead: "Is there a solution?" Nov 17 '19 at 19:06

# Create a block maze solver AI

A block maze is a maze in which goal is to complete a pathway by adding blocks.

It starts like this :

#..#.
#...#
..###
.#...
.#..#


# is a block (which can be crossed). . is empty space (which cannot be crossed).

The goal is to connect top-left corner S to the bottom-right corner E. Diagonals are not allowed.

S....
.....
.....
.....
....E


One possible solution for the example above is to add three blocks like this :

#..#.
#...#
#####
.#..#
.#..#


Think about a man who want to cross a river with crocodiles . using huge stone blocks #.

The task is to create a program that take a grid as input and return a solution as output.

## Scoring

The sum of all blocks required to solve all solutions in a 1.000 test case file I will provide.

The winning program is the one that use the fewest blocks to solve all mazes.

## Rules

• All grids are 25 x 25.
• Start / end points are always top-left / bottom-right corners. There is always a block on those points.
• There is always one guaranteed solution (which can be found by filling all empty spaces)
• Program must be entirely deterministic; pseudorandom solutions are allowed, but the program must generate the same output for the same test case every time. If two programs take the same number of steps (e.g. they both found the optimal solutions), the shorter program will win.

The program should return the solution as a sequence of blocks x-y coordinates (the coordinates of blocks to add to solve maze) in the format of your choosing :

11-3;15-6;19-12


## Meta

• I cannot think of a simple algorithm that returns an optimal (best possible) solution in a reasonable time. I expect programs to use some heuristics to get non-optimal/near-optimal solutions. I made the grids 25 x 25 to make it challenging enough and prevent simple solutions like brute force.
• Is this a duplicate? There is lot of related questions but I couldn't find anything related to block maze.
• The tags are . Anything else?

EDIT : as AlienAtSystem pointed out in comments, there is an optimal algorithm for all cases. I made some tests: even a slightly modified Dijkstra's algorithm will work (it will find shortest path in a short time). I will not post this challenge as it is trivial. I leave it here in case someone else would have same idea.

• By fewest total steps, do you mean cumulatively? Nov 20 '19 at 10:07
• I mean the sum of all blocks. If solution for maze01 use 4 blocks and solution for maze02 use 5 blocks, it is 4+5 = 9 blocks in total. The lowest is the best. Someone who has 7+1=8 blocks will win. I have edited answer. Nov 20 '19 at 10:37
• You should allow people to have any output format as long as it has x first, y second. None of the mazes are duplicate. I can't think of any other tags. This should be good to post. Nov 20 '19 at 10:49
• Should we add a test suite of some sort? Or how are you going to verify the score of a submission? But in general the challenge looks clear. A few questions: I assume there are some test cases among the 1000 requiring us to go right/up for the optimal solution, instead of only going left/down? Are the input-characters strict, or could we also use for example 012 for @.x respectively as integer-matrix? One other relevant tag: [path-finding] Nov 20 '19 at 13:25
• @KevinCruijssen I am planning to provide a program to validate solutions. right/up : some mazes might be shorter to solve that way but it is not allowed. The goal is go from top-left to bottom-right (not to cross from left to right). character set : programs should use the same characters as the test file. Anyway, using 012 might be a good idea (I might update the test file with such chars). There is no @ character in the test file since the start / end position are always the same. Nov 20 '19 at 14:31
• @tigrou Ah ok, so @ is not part of the input. In that case a binary-matrix with just 0s and 1s would be a suitable input format I guess. As for the right/up: I meant it for an input like this pastebin. With this maze you could walk from the top-left to bottom-right with just 2 x insertions (at the _ positions), but you'd have to travel up and left in the path from the top-left to bottom-right. But if I understand correctly we only travel right and down, so this would be the solution (with 4 insertions at _) instead? Nov 20 '19 at 18:38
• @KevinCruijssen : both solutions you posted are valid. You can go up / down / left right at any moment. Nov 20 '19 at 18:42
• I can think of an algorithm that should be optimal for all test cases. This could result in the tie-breaker problem if other people realize it, too. Nov 22 '19 at 6:32
• @AlienAtSystem : optimal algo : is it because of my test cases (which have some flaws) or the maze challenge in general ? Nov 22 '19 at 8:20
• @tigrou In general. It can be translated into a shortest path challenge over a considerably smaller graph. While A* wouldn't work on that one, other algorithms will. This wouldn't be short in terms of bytes, although I suspect not that much compared to other approaches, given that some part tasks need to be done by everyone. Nov 22 '19 at 9:35
• I think you don't need to give up entirely right away. While this doesn't work as test-battery challenge because it's too easy to get everything right, it should be good for posting as generic code golf. Nov 22 '19 at 13:36

## OEIS A125959

https://oeis.org/A125959 is a sequence I submitted. It is the following array, which then repeats:

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


This is a rather useful array for quickly calculating the digital root of the product of any two numbers (i.e the iterative sum of the digits of the product). See the OEIS link if you're interested in the details.

The challenge is to print the array in the shortest number of bytes.

None

# Output

The above array. It can be output as strings with new lines, or as a nested array, or an array of strings; but not as a single-line sequence (i.e. the 2d-nature of the array must be reflected in your output).

• So it's the multiplication table mod 9, except 0s are 9's?
– xnor
Nov 25 '19 at 12:58
• @xnor is it? I hadn't spotted that before. Does that stop it being an interesting challenge? Nov 25 '19 at 13:49
• I believe it does (because it is "create a 10x10 table of the function (-~a*-~b-1)%9+1" now). Nov 25 '19 at 14:05
• I think it makes it too similar to generic print-a-multiplication table challenges, but others might disagree.
– xnor
Nov 26 '19 at 2:10

# Times have changed!

(pun intended)

## Preface

As mathematics progressed, mathematicians agreed upon the 'order of operations', to prevent mathematical expressions from becoming ambiguous.

Given the expression $$\7 \times 6 + 5 \times 3\$$ we know to first evalulate multiplication, giving $$\ 42 + 15\$$, which is equal to $$\57\$$.

But what if another group of mathematicians had agreed to evaluate addition before multiplication? This expression would become $$\ 7 \times 11 \times 3\ = 231\$$: which is different from our answer by an error of $$\305\%\$$!

## The Challenge

Given a mathematical expression containing + (addition), * (multiplication), and the digits 0123456789, we can find:

• $$\E_1\$$ - the 'real' value of the expression, when multiplication takes precendence.
• $$\E_2\$$ - the 'alternate' value of the expression, when addition takes precedence.

Your task is to write a program or function which, given a string representing an expression, calculates and outputs the percentage error, $$\\frac{|E_1 - E_2|}{E_1} \times 100\$$.

## Rules

• WIP.
• Related Dec 1 '19 at 22:33
• @ChasBrown do you think it's similar enough to call this challenge a dupe? Dec 27 '19 at 14:14

## Quick intro

So i was playing cookie clicker yesterday, and I thought about something. We keep producing cookies, without any loss. What if your cookies failed? This is where I thought about a clicker that would cook a cookie. Don't click too much, or the cookie will be overcooked!

• Your function will have to randomly select a number between 5 and 10 : it will establish the cooking duration of your cookie (and so, the number of time you'll have to call the function to cook your delicious cookie).
• Each time you call that function, it will iterate the baking process of your cookie.
• Your function should return "Undercooked" if your cookie is not fully cooked, "Overcooked" if you ... overcooked it, and "Cooked" when the cookie is baked just right.

## Example

Since I'm bad at explaining things, an example will show you more clearly what needs to be done. Let's call my function bake() :

bake()    // The random number generated is 6, so i need to call my function 6 times
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()
Undercooked

bake()    // We hit the 6th function call, the cookie is baked.
Cooked

bake()    // The 7th call overcooked the cookie. Congratulation, you ruined it.
Overcooked


## Rules

• The random number of iterations has to be set the first time you call the function. It has to be between 5 and 10 (inclusive).
• A cookie has to be undercooked before being cooked, and has to be cooked before being overcooked. The 3 steps have to be reachable. A cookie can't uncook itself, therefore you can't go from cooked to undercooked, or from overcooked to cooked (it's too late, you ruined the cookie anyway).
• The function can have as many parameters as you please.
• Classic rules apply, no standard loopholes
• This is codegolf, so the shortest code wins.

## Meta

• Is the challenge clear enough ?
• Should I go with this method to iterate the "baking" process ?
• Are there some rules I could add to make it more exciting ?
• Does this challenge exist already ?
• Should we bake pies instead ?
• I'm assuming bake() will take no parameters and will have to store the count somehow, which means you might want to include some rules about file and global variable I/O. I also did a small editing pass. Dec 2 '19 at 16:14
• @Veskah I never thout about restricting bake()'s parameters, gonna edit the rules to include this particulatiry. Also, thanks for the edits. Dec 3 '19 at 8:12
• I don't think I understand what you are trying to accomplish. Why do you refer to the submission always as a function? Could it not be a program? Similarly, your edit to allow arbitrarily many parameters conflicts with the general tone that seems to imply that we should be storing state between calls. I think you will want to try explaining the task simply, perhaps even to the level of a non-programmer. Dec 8 '19 at 19:47
• I don't think this is possible? Surely you can't tell what direction is involved with the mirrors, e.g. /1, can you tell if the pointer started on 1 going east vs /` going north?
– Jo King Mod
Dec 18 '19 at 9:10
• @JoKing Hm yeah I think your right. I will try a little more but you are right that mirrors can't be used.
– Grain Ghost Mod
Dec 18 '19 at 15:06
• @JoKing I actually do think this is possible.
– Grain Ghost Mod
Dec 18 '19 at 15:15