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

# Is my triangle on the lattice? decision-problemcode-golfgeometry

Posted on the main site.

# Is it a Lobster Number?

## Posted

• I like the idea, but the fact that prime numbers don’t count seems a bit arbitrary.
– user
Jan 23, 2021 at 21:11
• It definitely is a bit arbitrary, but I felt that it made sense as an edge case, since while it is a prime factor, it is already the number itself, and there are no other factors. The related (but not identical) OEIS sequence also seems to have made this distinction, so it seemed reasonable. It also has the simple explanation that lobsters are not needed to get the result for the prime numbers, and shouldn't be overly difficult to work around in golfing, as all you need is a single comparison (is there only one factor, or is the first factor equal to the number). Jan 23, 2021 at 21:35
• Yeah, that makes sense, and it's not a deal-breaker for me, it would just make writing an answer slightly more annoying :)
– user
Jan 23, 2021 at 21:36
• @user - Posted since there seems to be no general problems with the question. Jan 24, 2021 at 15:04
• Well, I don't see any problems with it myself, but it would have been good to let it sit a few more days to get more feedback
– user
Jan 24, 2021 at 15:07
• @user - I'll keep that in mind, this is my first question here, this site is quite a bit different from the other StackExchange sites. Jan 24, 2021 at 15:13

## BF memory layout optimizer (posted).

See the notes in the revision history.

• (upvote this comment if you want a variant with [fastest-code] instead.) Jan 31, 2021 at 2:11
• (upvote this comment if you want both a [code-golf] version and a [fastest-code] version.) Jan 31, 2021 at 2:11
• (upvote this comment if you want only a [code-golf] version.) Jan 31, 2021 at 2:11

Note:

• as you can probably tell, this is a simpler variation; however the poster of the other sandbox post has not been visiting the site for a while.
• because of the current situation, I recently (after the 2 upvotes is made) changed the winning criteria. Is there any problem with the description?
• What info should be included in the header?...

## Efficient table-lookup computation

• (ah, right. The sandbox is still as inactive as usual.) Jan 30, 2021 at 17:16
• Or it could be that the challenge is simply a little hard to read.) Jan 31, 2021 at 14:45
• If two answers have the same A+B, is the one with lower A or lower B considered better, or is there no tie-breaker? Feb 2, 2021 at 8:43
• @Dingus No, see the meta post about challenge having multiple winning conditions. codegolf.meta.stackexchange.com/questions/19041/… Feb 2, 2021 at 10:19
• There's no consensus on that meta question. I think you should state that if two answers have the same A+B then they score the same. Feb 2, 2021 at 10:37
• @Dingus +1 is not a consensus? Feb 2, 2021 at 10:42
• A post is considered as a consensus only if it's at >= +10 and upvotes >= 2*downvotes. So +5/-4 (at the time of writing) is closer to a controversy than a consensus. I guess many people have just feelings without enough justification about whether it's fine or not. I personally view it as a good challenge, so I upvoted it. Feb 8, 2021 at 23:20
• A minor nitpick: In your Python code, adding string to a number is invalid. I guess you meant to take the inputs as strings, e.g. m1 = "0" etc. Feb 8, 2021 at 23:21
• For the lack of sandbox feedback, I usually leave my challenges for at least a week, regularly asking for feedback in the chat (at least 2 or 3 times before moving to main). Feb 8, 2021 at 23:24
• @Bubbler Fixed. Feb 9, 2021 at 1:41
• to me it looks like the given method to generate a single score from A and B only adds confusion, especially the "combined score" part... what's the advantage compared to a simpler formula like A^2+B^2? (I would be in favour of just using A and B and letting all pareto-optimal solutions win, but I understand that at the moment there's not enough consensus for this)
– Leo
Feb 12, 2021 at 8:57
• @Leo Because it doesn't encourage these solutions, obviously? -- (I think that the solution with minimum A is pretty interesting, but I'd like to see a solution that generates reasonably-good parametrized solutions too.) Feb 12, 2021 at 9:53
• @Leo as explained in the linked meta post -- (did I explain it clearly enough?) that method would allow essentially the same "every solutions win" situation by letting every such "winning" solution improves the "combined" score. (and is the only one that I can come up with with that condition) Feb 12, 2021 at 9:54
• The problem with the combined score is that you have two scores again, the "normal" one and the "combined" one... Does only one or the other count for "victory"?
– Leo
Feb 12, 2021 at 10:29
• @Leo Obviously the combined one. Note that the criteria is chosen so that the combined score is always better than or equal to the normal score, and the combined score is always better than the previous combined score. Feb 12, 2021 at 10:32

# Generalise perfect numbers

• Better having a statement "in this challenge $\sigma^n(k)$ denotes...". It can be interpreted as $(\sigma(k))^n$ too. Feb 24, 2021 at 4:15
• Can answers assume that "the sequence is infinite"? Feb 24, 2021 at 4:16
• @user202729 Addressed both questions Feb 28, 2021 at 1:18

# Byte-sized Huffman Coding (WIP)

Huffman codings are a method to compress data with certain frequency properties, usually text. Normally, these operate on bits rather than bytes, but this challenge will instead operate on whole bytes instead. Since you wouldn't get any benefit otherwise, you can represent multiple consecutive characters with a sequence of one or more bytes, for instance '. ' (a period followed by a space) could be represented by byte 1, 'The' could be represented with byte 2, and 'Ishmael' could be represented by a 255 then a 7 (among many other sequence codings).

# Challenge

Create a program that compresses a plain-text version of a work of literature by returning a byte-wise Huffman coding table and a sequence of bytes that represents the text with that table.

## Rules and Assumptions

• You may assume that the text is written in English and uses only printable ASCII characters plus space, newline, and tab.
• It must be a proper Huffman coding; no mapping may be the prefix of another.
• Not all Huffman sequences need to be mapped to a particular character sequence; you could, for instance, not have 7 mapped to anything or not have 255, 39 mapped to something, but have every other 1 and 2 byte sequence mapped to something.
• The returned coding table must be able to encode every possible sequence of valid characters (as per the first assumption above). The simplest way to do this is to make sure that every individual character is mapped to a Huffman byte sequence.
• It can be possible to encode a body of text multiple ways using the returned encoding table. If both ca and at are mapped to byte sequences, cat could be encoded two ways. This is totally fine.
• Case must be preserved.
• Runs do not need to be deterministic, i.e. two runs of the same program with the same input could produce different Huffman tables and compressed output.
• Your program must return a result within a reasonable amount of time to be considered a valid solution. (If you want a hard limit, I'll say 5 minutes on a 2GHz Intel dual-core i5 with 16 GB RAM running Windows 10)

## Scoring

Your results will be run against a corpus of (TBD) 12 publicly available literary (and non-fiction) works. For each work of literature, your score will be the size, in bytes, of the compressed text, plus the total length of all text strings mapped to a byte sequence in the Huffman-coding table. Your overall score is the total score across all 12 works.

Lowest score wins.

### Literature list

• The King James Bible
• Hamlet by William Shakespeare
• Dracula by Bram Stoker
• Frankenstein by Mary Shelley
• On the Origin of Species by Charles Darwin
• Moby-Dick by Herman Melville
• Little Women by Louisa May Alcott
• Tom Sawyer by Mark Twain
• Pride and Prejudice by Jane Austen
• The Hound of the Baskervilles by Arthur Conan Doyle
• < Something that entered the public domain in 2019 because it was published in 1923 >
• < Something written in the last 20 years willingly released into the public domain or with a Creative Commons license that allows derivative works >

### Sandbox

At least one of the last two literary works should preferably be written by a female and/or non-white author to hopefully make writing styles diverse enough to make hard-coded Huffman tables ineffective. Each work should be comparable in length to the other works.

Links to these books (in plain text) would be appreciated. Substitution suggestions are welcome.

• If you want to vary writing styles, is there a non-fiction work that only contains the allowed characters? Sep 24, 2019 at 23:21
• @trichoplax The most notable non-fiction book I can think of for that would be "On the Origin of Species" by Charles Darwin. I've also thought about throwing in the King James bible. Maybe I could bump up the total to 12 works. I also probably will drop War and Peace because the plain text version I found was machine converted and has issues. Sep 25, 2019 at 15:21
• Regarding plain text books, have you checked Project Gutenberg? They have plaintext versions of many of their books. Sep 25, 2019 at 18:35
• I have no idea how much sample text is a good amount for this challenge (number of books, length of books) but it's probably worth doing some kind of rough check that there is enough text to give variation between answers (no optimal solution) while still being little enough text that running in a reasonable time is realistic (doesn't require weeks of work before an answer is efficient enough to meet the time restriction). Maybe others can suggest good ways of approximating this? Sep 25, 2019 at 20:16
• @trichoplax so basically you suggest sampling out, say, a few chapters instead of the whole book and then reducing the required runtime? I'm open to that, especially since the word count difference between Hamlet and the Bible is so big. The interesting thing about the Bible is that it has a ton of different authors, so it would almost be better to have the first chapter of each book instead of inserting, say, the entirety of Genesis. Sep 26, 2019 at 4:41
• I couldn't guess at this point whether more text or less text would be better, and I don't have a way of estimating, just wondering if anyone else does. Sep 26, 2019 at 7:32
• I see no problem with 5 minutes as a rough time limit. I'd lean towards a time limit that allows someone to write a quick answer and then improve on it gradually, to encourage more participants. How long that needs to be for the text you settle on I don't know. As long as you're confident an optimal solution can't be found, you could just time a naive approach and then choose a time that doesn't exclude that. Then you can get lots of early answers to get the competition going, but still have open ended improvement over the long term Sep 26, 2019 at 7:38
• Not to say that this isn't an interesting challenge as it is but I do wonder if it wouldn't be more interesting without requiring that we use Huffman Encoding? Sep 27, 2019 at 22:21

# What's the odd one out?

• Looks like this but a bit more interesting Mar 9, 2021 at 13:35
• Great challenge! Seems ready to be posted
– user100690
Mar 9, 2021 at 16:03

# Sociable sequences

• You probably need to describe what a proper divisor is. Separately, I'm not sure how great requiring infinite output is. I'd probably consider allowing another optional argument that limits how many sequences to output? Nov 12, 2020 at 19:47
• @FryAmTheEggman I've updated the challenge to be closer to the normal [sequence] I/O rules Nov 26, 2020 at 15:23
• So is 25 a 1-sociable number, since its divisors sum to 6, and then there's a cycle?
– user
Jan 6, 2021 at 21:04
• @user No, $25$ is not a $1$-sociable number. "They are numbers whose proper divisor sums form cycles beginning and ending at the same number". $25$'s "cycle" is $25 \to 6 \to 6 \to \cdots$, which does not begin and end with the same numbers. I'll edit that in though Feb 22, 2021 at 17:50
• That "begin and end at the same number" is unclear. (it's a cycle, it neither begins nor ends) Perhaps "the initial number is inside the cycle". Feb 24, 2021 at 4:30
• Should that "given value" be interpreted as "value that will be given as input"? Feb 24, 2021 at 4:31
• That "does not diverge" sounds like a terribly hard conjecture... EDIT indeed it is. en.wikipedia.org/wiki/Catalan%E2%80%93Dickson_conjecture ("likely false"), and looks like that the sequence you came up with already have a name. Feb 24, 2021 at 4:32
• with that, it's problematic, you'd better specify that "If there are $n$ such numbers, the answer must provably finish printing them all without assuming the conjecture" -- although for most approaches it isn't that hard. Feb 24, 2021 at 4:38

# Write an interpreter generator

• Can an input contain one or more operations? like a + 1 - 4 * 8? Is input guaranteed to be valid? Mar 22, 2021 at 17:11
– user100690
Mar 22, 2021 at 17:12
• Another suggestion, you might make it a code-challenge, where the objective will be to generate as short output as possible (Which means to golf the generated interpreter as much as possible), where the original source code length will not matter, so people can work for their code more peacefully, But code-golf (original challenge) one is good too. Mar 22, 2021 at 17:14
• @Wasif hmm... not a bad idea at all. This challenge does seem more effective with the code-challenge tag, I will edit that into the answer.
– user100690
Mar 22, 2021 at 17:17
• @Wasif on second thought, I'm not really sure how you would actually test the length of the output... it would not be fair for one answerer to test with a 100-command language while another tests with a simple 1-command language. Thanks for the suggestion, but code-golf seems like the better option for now.
– user100690
Mar 22, 2021 at 17:19
• OK, also how would handle destructive input like a / 0, which attempts to divide the accumulator by 0, which would result into crashing the interpreter? Mar 22, 2021 at 17:22
• the input is valid doesn't seem like a good enough description, let me change that
– user100690
Mar 22, 2021 at 17:22
• "each command is one letter long." so, highest number of inputs are 26? Mar 22, 2021 at 17:33
• Can we pre-define the input array in the header section of Try It Online? Mar 22, 2021 at 17:35
• @Wasif yes, that can be inferred from that fact. Not sure what the header is, because I don't really use tio
– user100690
Mar 23, 2021 at 6:23
• Header section means the part where you write code, is not added to the byte count. Mar 23, 2021 at 6:52
• Let us continue this discussion in chat. (Automatically comments were moved there because lengthy conversations cannot be run in comments) Mar 23, 2021 at 6:52
• I've edited this to a stub now that it's been posted Mar 23, 2021 at 15:40
• @ChartZBelatedly thank you, forgot to do that
– user100690
Mar 23, 2021 at 16:05

# Keep PPCG running in Game of Life

• "Minimally destroying CGCC", "Keep PPCG running". Hmm, someone doesn't like the name change :). May I ask why you have this proposal too, though?
– user
Mar 22, 2021 at 19:24
• @OriginalOriginalOriginalVI Because the two tasks are different, and I very much doubt answers to the two will be trivially similar Mar 22, 2021 at 19:38
• Right now you could just place a glider in the box and it would run forever. Maybe redefine 'fixed position'? Mar 23, 2021 at 8:16
• @Ausername "If any spaceships or patterns of infinite growth are generated, the board will never reach a "fixed state" and such cases are invalid submissions." A glider is a spaceship Mar 23, 2021 at 13:13
• Oh ok, didn't see that bit. Mar 23, 2021 at 19:37

## Limit of lists code-golf

You're given a never-ending sequences of lists, each of which appends some number of values to the end of the previous one. That is, each list is a prefix of the next.

3
3,1,4
3,1,4,1
3,1,4,1
3,1,4,1
3,1,4,1,5,9,2,6
...


While some steps may leave the list unchanged, its length grows unboundedly, giving an infinite list in the limit. Your goal is to output this infinite list.

Note that you can't know a-priori how many lists you must read to get, say, the 5th value in the infinite list, just that you'll eventually hit a list with 5 or more elements.

Input and output:

The list elements are digits 0-9. You may treat them as characters if you wish.

The input and output are both infinite lists. These can be represented in various ways, and may be different for the input and output.

• An infinite list or stream
• A stateful method or black-box function that produces a new value with each call
• Repeatedly reading from STDIN or writing to STDOUT, or file buffers or the like

A mapping from index to value isn't allowed for input or output. The output must be uniform, without chunks of digits grouped together.

Sandbox: Infinite list I/O is hard. Any suggestions?

• "Your goal is to output this infinite list" - can you clarify that it's by taking later elements from the lists that get later and later in the input list - I had to read this several times to understand that. Also, while I don't think there's any getting around the infinite input requirement, perhaps you could change the output to standard sequence rules to make it more flexible? Mar 27, 2021 at 18:04
• Is the first list guaranteed to be one element long? Or can it be any length? Can it (and any subsequent lists) be empty? Mar 27, 2021 at 18:09
• You should probably specify the intermediate output/s needs to be as soon as it's available from the input infinite lists, or at least in finite time, so noone can submit tail -1 Mar 27, 2021 at 18:21

• Yay, a lisp challenge! Does each 'a' mean a car and each 'd' a cdr?
– user
Mar 24, 2021 at 21:56
• @OriginalOriginalOriginalVI yeah, but I'm to lazy to have written a description in english so far. I guess I'll get to it eventually :P Mar 24, 2021 at 21:58
• Fortunately the common lisp hyperspec already describes the bulk of it well. Mar 24, 2021 at 22:22
• You might want to make the reference implementation a link to TIO (unless it doesn't work on TIO, of course)
– user
Mar 24, 2021 at 22:23
• @OriginalOriginalOriginalVI Why? (I can't access TIO anyway) Mar 24, 2021 at 22:25
• Meh, I just don't like those code snippets, and it makes it easier to pull out of the question, modify the input, and stuff. These code snippets sometimes break for me. If you can't access TIO, though, it doesn't matter, of course.
– user
Mar 24, 2021 at 22:26
• posted Mar 25, 2021 at 15:04
• I've edited this down to a stub now that it's been posted Mar 28, 2021 at 14:01
• It's unclear what kind of expressions we have to deal with, but it looks good, and interesting . E.g. do we have to handle expr |> function(with_one_parameter)? Mar 25, 2021 at 15:27
• @Wezl I was thinking the expression could be anything with printable non-whitespace ASCII but I realize now that could be problematic. I'll change it to be more restrictive. Mar 25, 2021 at 15:30
• @Wezl I specified that you may assume all functions will take only one parameter, so you do not have to handle expr |> function(with_one_parameter). Mar 25, 2021 at 15:39
• Why do some piped expressions have () and some do not? Are we meant to support both of these? Mar 26, 2021 at 4:45
• @Ausername It's to demonstrate that both are valid, but as I state in the rules you need only support one convention. Mar 26, 2021 at 13:17

# What's my TIO uniqueness?

– user
Mar 23, 2021 at 20:59
• Maybe you could say "undefined" instead of 0 in the sentence "The TIO uniqueness of a language for which this is impossible is 0". Also, do you want submissions to store all 680 language names in the code? Mar 24, 2021 at 23:58
• @Bubbler Changed to undefined, it fits better. Yes, submissions should have some way of storing the names, be it in an external file or in the program itself etc. Mar 25, 2021 at 0:02
• @FryAmTheEggman Given that there are 680, I think it may be impractical to include the full list in the question, which is why I linked to this gist with all languages and their outputs Mar 25, 2021 at 0:20
• Ah, sorry, I missed the link. Mar 25, 2021 at 3:44
• "subsequence" tag? Why?
– tsh
Mar 29, 2021 at 8:58
• @tsh Because the TIO uniqueness depends on the shortest substring that isn't common with any other language Mar 29, 2021 at 18:49
• but substring is not subsequence
– tsh
Mar 30, 2021 at 0:32
• @tsh No, but [substring] isn't a tag, and [subsequence] is the best alternative Mar 30, 2021 at 21:37

• You should generally include the definition of things like this directly in the challenge rather than just linking to a Wikipedia article on it, so people don't have to go to an external site Apr 8, 2021 at 8:42
• I think it would be clearer if you used boolean true/false for "is this valid", rather than "invalid" vs "valid". You might also want to change classification to decision-problem Apr 8, 2021 at 8:46
• @pxeger Thanks. Included both suggestions. Apr 8, 2021 at 15:55
• Is this means the input should always be a string / list of characters? May I take input as an array of 4 integers / a 32 bit unsigned integer / a built-in type for IP address (if there is one)?
– tsh
Apr 13, 2021 at 3:57

# Interpret control characters like a terminal

• As "your program does not need to interpret backslash escape sequences - the input will contain the literal control codes themselves.", I'd suggest actually including the characters in the test cases, or at least including a TIO link (or pastebin etc.) with the literal characters Apr 12, 2021 at 13:14
• @cairdcoinheringaahing \r isn't really usable on the web because it will be converted to a newline, and most languages have their own literal syntax for entering those characters anyway, so I think it wouldn't really help Apr 12, 2021 at 13:18
• Suggest a aaaaaaa\b\b\b\t case, do TAB fill them space?
– l4m2
Apr 15, 2021 at 4:17
• @l4m2 thanks - that helped me discover some subtle bugs in my reference implementation too Apr 15, 2021 at 9:01

# A Self-Referential Sentence

## The Story

One day, you decide that you want a sentence that tells you where in the sentence the letter T occurs (excluding whitespace and punctuation). Out of curiosity, you try to make one. Messing around a little you get

T is the first, fourth, eleventh, sixteenth, twenty-fourth, ....

Oh dear, this sentence appears to run forever. But you now think you have an interesting number sequence, so you slap it into the OEIS search bar and lo and behold you find sequence A005224, Aronson's sequence. And better yet, an interesting code-golf problem that no appears to have posed before!

Your task is to write a program that takes in a single positive integer, n, as input and gives the position of the n-th "t" in the above sentence (indexing begins at 1 for the sake of this problem). For example, an input of 1 should return 1, while 2 should return 4. The input number will not exceed 4 decimal digits in length (i.e. the maximum input is 9999)

As always, the shortest code in bytes wins, and standard loopholes apply.

## The Meta

Ok, so I have a couple of questions, since this my first sandbox post.

1. What can I do to flesh out this problem? This seems short, especially for a CGSE prompt. Should I somehow flesh out the heading fluff? Or should I add something more to the task itself?
2. I was pretty thorough in my search of the sandbox and main site for similar problems, but I could always have missed something, so please let me know if this is a duplicate.
3. Is the 4 digit input limit reasonable? Should I raise it or lower it? Remove it entirely? Since I'm not providing a file with ordinal strings, it seems like having a restriction on the size of the input is quite important.
4. Finally, please let me know if there's any other glaring problems in this prompt, this is both a first draft, and my first attempt at a code-golf prompt (since high-school).
• Nice first challenge! I'd suggest following the standard sequence I/O rules and allowing programs to output either the first $n$, the $n$th term or all terms. Additionally, forcing 1-indexing (for the sequence) doesn't improve the challenge any more than allowing either 0 or 1 indexing. I cannot find any challenge that could be a dupe through some searching, so this looks to be 100% original. Finally, I'd recommend including either test cases or the first 10 or so terms in the challenge body Apr 24, 2021 at 16:21
• @cairdcoinheringaahing 1-indexing is fundamental to the recursive definition of this sequence, as “T is the zeroth, third, tenth, twelfth, seventeenth, twentieth, …” is quite a different sequence (not just off by one). Apr 25, 2021 at 18:25
• @AndersKaseorg I meant 0 indexing in the input, not in the position of the T (e.g. n = 0 would output 1, n = 1 would output 4, etc.) Apr 25, 2021 at 18:27

# diddly darn posted

• Tag chess? Apr 12, 2021 at 6:43
• My god, this is amazing. I can't wait to see the full version! Apr 12, 2021 at 9:48
• It's not clear to me what should be output in the non-deterministic cases. Do we have to output all possibilites?
– kops
Apr 22, 2021 at 23:35
• Addtionally, what do you want the result of this to be: ,v, \n >,A \n ^<B (pastebin; is multline code possible in a comment?) Rules as written I think it's a tie since the center cell is reached twice but it's not clear this is desirable.
– kops
Apr 22, 2021 at 23:37
• @kops it's okay for the board to result in a tie. Apr 22, 2021 at 23:43
• And the point is to output the result of the board, which may not be deterministic Apr 22, 2021 at 23:43
• So each possibility has to be output with the correct probability in the non-deterministic cases? And for the specific board in my second comment, it's very much morally an A victory, not a tie, but the technicality of passing through the same cell going in different directions makes it a tie in these rules which I find a bit weird.
– kops
Apr 22, 2021 at 23:46
• @kops no it is not the probability but the result of running it once. That result may vary. And even though that may seem like it should be a win for A, it could be the result of some clever play from B to trick A into thinking they've won Apr 22, 2021 at 23:50
• @Lyxal I didn't mean to say the probability itself should be output, but that for each possibility, the probability of that possibility being output has to be correct?
– kops
Apr 22, 2021 at 23:56
• @kops you only ever output one result - the winner of the game when evaluated. Because there are commands that change the direction, it can be impossible to 100% tell who wins. I was simply pointing out that there is more than one possible output for such boards. Apr 22, 2021 at 23:59

# Rob the King: Hexagonal Mazes

Consider the following hexagonal maze:

     E . \ . . .
. . . \ . \ .
. . . . \ . \ .
_ _ _ _ . \ . \ .
. / . . . . . . | .
. | . . _ _ _ _ / . .
. \ . \ . . . / . .
. \ . \ . . / . .
. \ . \ . . . .
. \ . \ / . .
. \ . | . X


E represents the entrance, X the exit. |_/\ are walls and . are free spaces. In order to navigate from E to X, we can move to any free space in the up to 6 immediately surrounding spaces. The path from E to X, marked with P is:

     E P \ P P P
. . P \ P \ P
. . . P \ P \ P
_ _ _ _ P \ P \ P
. / . . . P P P | P
. | . . _ _ _ _ / . P
. \ . \ . . . / . P
. \ . \ . . / . P
. \ . \ . . . P
. \ . \ / . P
. \ . | . X


This isn't the only path, but the others are trivial variations on it.

# Cops

You are to write a function in Python 3 which takes a positive integer $$\n \ge 2\$$ and returns a hexagonal maze of side-length $$\n\$$, as shown above. The maze will meet the following criteria:

• The only characters in the output are EX.|_\/, space and newline
• The hexagon is shown as a hexagon. That means:
• The first $$\n\$$ lines will have one more non-space character than the previous line (the first has $$\n\$$ non-space characters), separated by a single space, and offset from adjacent lines
• The first $$\n\$$ lines have one fewer leading space than the previous line (the first line has $$\n - 1\$$ leading spaces)
• The next $$\n - 1\$$ lines have one more leading space than the previous line
• The next $$\n - 1\$$ lines will have one fewer non-space character than the previous line, separated by a single space, and offset from adjacent lines
• Lines may not have trailing whitespace
• The E is the first non-space character on the first line, and the X is the last non-space character on the last line
• There is at least 1 valid path that connects the E and the X, only moving from one free space to an adjacent free space.

How your program generates these mazes is entirely up to you. It could randomly places walls in the grid, ensuring there is always at least one path left, or it could only block the center row except for one gap, or anything else.

You may return either a multi-line string, or a list of lines. Lines should have appropriate space padding at the start, and may have a consistent amount of trailing spaces. "Consistent" here means either the same number on each line, or padding each line to the same length.

The Robbers will be writing maze-solving programs that try to solve your mazes, so you should aim to generate mazes that are somewhat difficult to solve.

This is not , you are under no obligation to golf your submission.

Additionally, you may submit multiple submissions. You may not include anything in your submission that attempts to communicate with other submissions, attempts to interfere with other submissions or the controller or anything that could be malicious. If you do, your submission will be disqualified

Empty mazes of sizes $$\n = 2, 3, 4, 5, 6\$$:

                                                                 E . . . . .
E . . . .            . . . . . . .
E . . .          . . . . . .          . . . . . . . .
E . .        . . . . .        . . . . . . .        . . . . . . . . .
E .      . . . .      . . . . . .      . . . . . . . .      . . . . . . . . . .
. . .    . . . . .    . . . . . . .    . . . . . . . . .    . . . . . . . . . . .
. X      . . . .      . . . . . .      . . . . . . . .      . . . . . . . . . .
. . X        . . . . .        . . . . . . .        . . . . . . . . .
. . . X          . . . . . .          . . . . . . . .
. . . . X            . . . . . . .
. . . . . X


# Robbers

You are to write a Python 3 function that takes in the return value of a cop's answer. It may also take the number of sides, $$\n\$$, as an argument if you so wish. The input will only contain EX_|/\. and space, and newlines if inputting as a multiline string. It will either be a multiline string or a list of lines. Your function should handle both.

Your function should then output the maze with any valid path connecting the E and X using only connected free spaces. You may show the path with any character aside from EX_|/\., space or newline.

This is not , you are under no obligation to golf your submission.

Additionally, you may submit multiple submissions. You may not include anything in your submission that attempts to communicate with other submissions, attempts to interfere with other submissions or the controller or anything that could be malicious. If you do, your submission will be disqualified

## Scoring

The scoring will take the form of a round-robin, similar to challenges. Every cop will be paired up with every robber, and the following will happen with each pair:

• The controller will call the cop's function 5 times with $$\n = 2\$$ as an argument, saving each of the 5 mazes. The cop will have 1 minute to produce each maze
• It will then pass each maze to the robber to solve. The robber will have 1 minute per maze to produce a correct output.
• If all 5 mazes are correctly solved by the robber within 1 minute each, the controller goes again, but with $$\n = 3\$$, and so on, increasing the $$\n\$$ by one, until either:
• The robber fails to solve a maze within 1 minute
• The robber produces an incorrect solution to an input maze
• The cop fails to return a maze within 1 minute
• The cop returns a maze with no path

At this point, both the cop and the robber receive points equal to the highest $$\n\$$ that neither of them failed. If the cop failed, the robber receives an additional point, and if the robber failed, the cop receives an additional point instead.

If both the cop and the robber reach $$\n = 50\$$ without failing, they both receive $$\50\$$ points.

After all pairs have be run, the cop and robber with the most points are the respective winners

# Meta

• If you want to automate the scoring process, you might want to restrict the I/O further, e.g. only allow stdin/stdout as a hexagon-shaped multi-line string. (I'm suggesting stdio because I assume you want to allow different languages.) Looks interesting, though I have a slight feeling that a full Dijkstra impl in C will almost surely win as a robber. Apr 12, 2021 at 23:01
• @Bubbler Good point, I've updated the I/O to be stricter. Apr 12, 2021 at 23:22
• @Bubbler I've decided to limit it to Python 3 functions, as I was struggling to make a controller that would allow any language to compete Apr 23, 2021 at 15:49
• It's a minor thing, but maybe change E and X to A and B? It seems more logical that way Apr 24, 2021 at 15:52
• @pxeger I chose E and X as "entrance" and "exit" respectively, but I doubt it'll affect any solutions as opposed to A/B Apr 24, 2021 at 16:06

# CDGLF:TMN2APL

## Meta questions:

• Is this a duplicate? (I've looked and there are several challenges with operator precedence, but there are large differences such as floor/ceiling and the output format)
• How can I objectively define "equivalent expressions"? Should I write a reference interpreter or answer?
• Would it be more interesting going the other way?
• Should answers be required to reject invalid input? Seems not
• Should I I've replaced the unicode operators ×÷⌈⌉⌊⌋ with ascii symbols */{}[].
• Is the exponentiation operator necessary? (It might just make the challenge more cumbersome because of its different associativity)
• It was previously APL2TMN. I'm changing it to TMN2APL to make it more interesting. Apr 22, 2021 at 14:42
• TMN's +-×÷ are left-associative, but in APL everything is right-associative. The equivalent of TMN 3-5÷2+1 in APL is (3-5÷2)+1; APL 3-(5÷2)+1 is 3-((5÷2)+1). Apr 22, 2021 at 23:41
• Thanks, I completely forgot about associativity. I don't think my grammar handles it, however, so I'm not sure exactly how to resolve this. Apr 22, 2021 at 23:44
• Also, I suggest to state the output format (APL) in the same way as you did for the input format (TMN), and state the precedence and associativity (for both TMN and APL) separately in plain English for those who are not familiar with parser grammars. And I think input validation is unnecessary here. Apr 22, 2021 at 23:52
• I think the Unicode operators definitely should be replaced with ASCII, because otherwise it's 10 bytes used on every answer. This would require you to remove or change the output syntax of exponentiation, but I don't really feel like it adds much tbh. Apr 24, 2021 at 15:57
• @pxeger I've changed it, and I agree. Apr 25, 2021 at 0:53

# Time bomb KoTH

• Enforcing determinism prevents luck based winning, which I personally like. Adds a sense of balance. May 1, 2021 at 15:59
• Determinism also means anyone can run a simulation of the game on their own machine. The game then devolves into aggressive metagaming and iteratively updating one's bots to always beat the opponents'. If you decide to enforce determinism among the bots, you must have some outside source of randomness to prevent players from simply simulating the entire game and instead actually formulate a strategy that is robust enough to still work well in the face of unknowns. May 2, 2021 at 9:57
• I personally like a bit of non determinism to spice things up but then this came along. So you have to be careful. May 2, 2021 at 9:58
• @EnderShadow8 yeah I saw that answer. In the current design, the array for the numbers selected in the previous round will be initialized with random numbers on the first round, giving the initial seed of randomness May 2, 2021 at 15:36
• Another thing to consider: high numbers will have very small winning chances, and the entire game is biased towards low numbers (they come first, they don't subtract much, large numbers take many points on explosion vs large numbers give many points on success). So all "smart" bots will choose <= n / 2 numbers, but then the trigger will also be lower, so bots have to choose even lower numbers. That can lead to a case of positive feedback. It may or may not cause problems, but it may be good to keep that in mind.
– FZs
May 2, 2021 at 19:24
• And to the determinism topic: a viable compromise between determinism and randomness could be made: making the only allowed non-deterministic part a seeded PRNG function provided by the controller. The PRNG seeds used for the official ranking are kept secret, but it's still possible to replicate the given match by using the same seed.
– FZs
May 2, 2021 at 19:58
• @FZs That's true. I may need to buff the reward for larger numbers to encourage playing them. Also about the determinism topic, after some searching I found some method to provide a seeded random, and I think I'm going to try that. May 3, 2021 at 7:41
• More about the determinism: I decided to decide the secret seed before the challenge starts and provide the hash to prove that I won't change the key mid-challenge. May 3, 2021 at 9:14
• I've edited this down to a stub now that it's been posted to save space May 3, 2021 at 14:17

# Count up to 21

21 is a game my teachers had my classmates and I play in order to kill some time. The game works as follows:

• All contestants stand in a circle. The aim is to count to 21, one by one.
• At any time, any player may begin the counting by saying 1.
• The plays then continue the counting by saying the next number. However, if multiple players say the number at the same time, the count resets, and someone has to say 1 again.
• The first player who says 21 is "out", and the game begins again with the same contestants except for the "out" player(s)
• The final player left is disqualified, and the entire game begins again. The last player not disqualified wins.

We are going to run a challenge, where bots aim to play this game.

You are to write a function in Python 3 that takes a list of lists $$\L\$$ as argument. Each list in $$\L\$$ represents a round in the game, with the last element being the most recent. The $$\i\$$th element of each list always corresponds to the same bot. Each list in $$\L\$$ will contain $$\n\$$ integers between $$\0\$$ and $$\21\$$, where $$\n\$$ is the number of contestants left in the game. The lists are either all $$\0\$$s, or are $$\n-1\$$ $$\0\$$s and a single non-zero value $$\v\$$.

If a list is all $$\0\$$s, either it is the first round, or the counter was reset in the previous round.

That function should then return either:

• $$\0\$$, meaning that your bot stays quiet
• $$\v+1\$$, meaning that your bot is attempting to guess this round

And that's it!

The competition will work exactly as described above. The controller will run 100 games. Each game will works as follows:

• The first round begins with all $$\n\$$ contestants. They will count up to 21, eliminating each contestant as they count to 21, and resetting the count to 0. The final player left is then eliminated, and the next round with $$\n-1\$$ contestants is run. At the end, the final player left standing wins
• The player with the most wins after 100 games wins overall

You may not include anything in your submission that attempts to communicate with other submissions, attempts to interfere with other submissions or the controller or anything that could be malicious. If you do, your submission will be disqualified

If any game has more than 10000 rounds, it'll be terminated and no player will win.

## Example bot

This is Random:

import random

def bot(history):
return random.choice([0, max(history[-1]) + 1])

• Infinite loops might happen quite often Apr 28, 2021 at 1:51
• @RedwolfPrograms Put a limit of 10000 rounds per game Apr 28, 2021 at 20:32
• TNB Feedback link Apr 28, 2021 at 21:16
• So, if next number is 21: Is there any reason a bot will not to say 21 in that round?
– tsh
Apr 29, 2021 at 1:30
• I feel like someone's going to just add a bot to say every single number no matter what. Apr 29, 2021 at 10:54
• @tsh If multiple bots say 21, none of them win and the count resets Apr 29, 2021 at 11:51
• Can you post the code to run the game so we can test our bots? Apr 29, 2021 at 21:05
• @fasterthanlight I haven't written the controller yet, so no Apr 29, 2021 at 22:57
• but if i will lost their turn if i dont say 21, and the worst case is a tie if I say 21? So any reason I try to be silent?
– tsh
Apr 30, 2021 at 5:10
• Because there's no reason to not say 21, infinite loops are probably going to occur no matter what. You might want to consider adding a rule regarding this to prevent infinite loops (or if everyone but 1 says a number the bot who said 0 can be eliminated) Apr 30, 2021 at 12:44
• Just wondering, is saving state between different turns allowed? Or between rounds? Or between games? You also don't seem to distinguish between rounds and turns (i.e times when the count resets vs. opportunities to guess), which may cause confusion. Also, a suggestion: Maybe let each game have only a small subset of the bots as contestants, so that if there's that one bot who always says 21 as soon as possible, it would just harm itself rather than ruining the challenge. (Sorry for this long block of text.)
– user101133
May 4, 2021 at 3:42
• Interestingly, this is completely different from the game of 21 I know. May 23, 2021 at 15:57

# Distance between vowels

## Objective

Given two vowels represented in single IPA characters, calculate the distance between them.

## Vowels

Vowels are characterized by three factors: Height, backness, and roundedness. Here, all vowels have the three characteristics as integers.

### Unrounded vowels (z = 0)

    x=0       x=1       x=2       x=3       x=4
y=6 i(U+0069)           ɨ(U+0268)           ɯ(U+026F)
y=5           ɪ(U+026A)           ʊ(U+028A)
y=4 e(U+0065)           ɘ(U+0258)           ɤ(U+0264)
y=3                     ə(U+0259)
y=2 ɛ(U+025B)           ɜ(U+025C)           ʌ(U+028C)
y=1 æ(U+00E6)           ɐ(U+0250)
y=0 a(U+0061)                               ɑ(U+0251)


(I know, Wikipedia states ʊ as rounded, but official IPA doesn't specify the roundedness of ʊ. It will be considered unrounded for this challenge.)

### Rounded vowels (z = 1)

    x=0       x=1       x=2       x=3       x=4
y=6 y(U+0079)           ʉ(U+0289)           u(U+0075)
y=5           ʏ(U+028F)
y=4 ø(U+00F8)           ɵ(U+0275)           o(U+006F)
y=3
y=2 œ(U+0153)           ɞ(U+025E)           ɔ(U+0254)
y=1
y=0 ɶ(U+0276)                               ɒ(U+0252)


## Metric

Your metric $$\d\$$ shall fit the usual definition of metric:

• $$\d(v,w)=0\$$ if and only if $$\v=w\$$

• For all $$\v\$$ and $$\w\$$, $$\d(v,w)=d(w,v)\$$

• For all $$\v\$$, $$\w\$$ and $$\x\$$, $$\d(v,x)≤d(v,w)+d(w,x)\$$

As an additional constraint, the norm $$\\Vert\cdot\Vert\$$ induced by $$\d\$$ shall satisfy:

• For all $$\x≠0\$$, $$\y\$$ and $$\z\$$, $$\\Vert(0,y,z)\Vert<\Vert(x,y,z)\Vert\$$

• For all $$\x≠0\$$, $$\y\$$, $$\z\$$ and $$\k>1\$$, $$\\Vert(x,y,z)\Vert<\Vert(kx,y,z)\Vert\$$

• Analogous rules for the y-axis and z-axis

All of these apply only to the vowels above. All other inputs fall in don't care situation.

## Rules

• Input format is flexible. It may be two chararacters, or a single string containing two charcters. In any case, every input that doesn't fit in your format falls in don't care situation.

• Output format is also flexible.

# Memory KoTH

Memory is a game where a bunch of pairs of identical cards are laid upside down, and you try to find pairs while only looking at two at a time.

In this KoTH, the way it will work is:

The game will be played on a 4096-item array, and the "cards" will be integers 0-2047.

Each bot takes its turn in order. It has access to the results of previous moves (Up to its previous turn), but their only storage is a single integer.

# Spec

The controller will be written in Javascript.

The bot has a move function, which must return two integers: The positions of both its guesses, in the form [g1, g2], where both are integers between 0 and 4095, and must not be gone already (see below).

The most recent move of every bot, including itself, in the form of an array of [g1,g2,r1,r2], where r1 and r2 are the first and second values revealed. The first item of this will be your bot's most recent guess, and the rest will be the other bots. This will be the global variable prev, and is readonly.

A picture of the entire grid, as a 4096-item array, left to right and top to bottom, where 0 means gone and 1 means still there. This will be the global variable grid, and is readonly.

An array of values that are gone. This will be the global variable gone, and is readonly.

A single ArrayBuffer(50), a 50-bit set of raw binary data. See the docs for help on how to access this. This will be the property this.storage, and can be used to store data.

Writing to globals is banned.

# Game

The bots will take their turn in a predetermined randomised order.

If a bot's moves are two tiles with the same value, those tiles are removed from the game area, and that bot gets a point.

The game ends when all tiles are gone, and the bot with the most points wins. In case of a tie, the bot that is last in the randomised order wins.

Bots should be a Javascript object like:

{
name: "A bot",
move(){
// insert code here
}
}


# Meta

Should I change storage limit or grid size?

• Shouldn't the bot be able to see the values of gone items? May 15, 2021 at 9:03
• @CommandMaster True, will add. May 15, 2021 at 21:02
• This doesn't really matter too much but if it were up to me, personally, I would change the storage limit from $[1,2^{50}]$ to $[0,2^{50}-1]$ so it's a bitstring of length 50
– hyper-neutrino Mod
May 18, 2021 at 6:10
• @hyper-neutrino Oh yes, that's what I intended. May 18, 2021 at 6:11
• What if two bots tie? May 18, 2021 at 8:18
• @StackMeter The one that is last in the randomised order wins. I'll add that. May 18, 2021 at 8:41
• Wouldn't it be easier to use a Uint8Array rather than a Bigint? Purely for ease of use. May 20, 2021 at 12:51
• Also need to make it clear that writing to globals is banned, since that's a legal play right now May 20, 2021 at 12:52
• @EnderShadow8 Yes, writing to globals is banned. May 20, 2021 at 20:07
• @EnderShadow8 How would I format this Uint8Array? Like how many items would it need to be restricted to? May 20, 2021 at 20:07
• Up to you. It's just a more convenient method of storing data that's a certain size. May 20, 2021 at 23:32
• @EnderShadow8 Actually, I think a BigInt would be better for this challenge, as remembering a single tile is 23 bits, which would be confusing to fit into a Uint8Array. May 21, 2021 at 4:22
• Just make it a plain ArrayBuffer and DataView. That's easier. I don't like using bit operations to extract data from integers. May 21, 2021 at 4:42
• @EnderShadow8 Ok. May 21, 2021 at 4:43
• Are you considering giving the bot the result of its first guess before asking for its second? That would introduce a new layer to the strategy. Eg. explore on the first move and defend or attack on the second May 21, 2021 at 5:04

# Generate a UK number platecode-golfstringdaterandom

• I'd suggest saying AANNXXX or something like that instead of AA12XXX so it's clear the age identifier isn't always 12 (that's clarified later, but still).
– user
Apr 28, 2021 at 18:12
• Just a note: the last 3 characters can't be either Q or I May 1, 2021 at 18:13
• @cairdcoinheringaahing I thought that too, but I found no mention of it in the government document so I kept it as the whole alphabet. shrug May 1, 2021 at 19:37
• There's a Q in the alphabet for the first letter, but then you say the alphabet, minus IJQTUXZ. May 5, 2021 at 18:13
• @Arnauld yep, that shouldn't be there. Too much muscle memory from typing the alphabet correctly I guess :þ May 5, 2021 at 19:15

# I'm Lazy: Close my Parens

• It's clear what to do with ], but what does [ represent? Is it the same as just (? Jun 1, 2021 at 22:00
• Why is ([(] invalid but [(] is not? Will there ever be multiple ] in a row? Jun 1, 2021 at 22:05
• @DJMcMayhem ([(] is invalid because it is the same as [(] but with an unmatched ( at the beginning since the ] only closes the [. There may be multiple ] in a row. Jun 1, 2021 at 22:08
• So basically ] matches as many open parens as possible until it hits a [ at which point it has to stop? Jun 1, 2021 at 22:10
• @DJMcMayhem yes. Should I add that to the question for clarity? Jun 1, 2021 at 22:12
• Yes, I think that would help. Jun 1, 2021 at 22:17
• Not sure if lisp tag is appropriate, because the challenge itself doesn't have to do with lisp.
– qwr
Jun 2, 2021 at 14:43
• Tag: balanced-string? Jun 3, 2021 at 10:47
• @pxeger nice tag-finding skills :) I'll add that. Jun 3, 2021 at 13:04
• @qwr How else do I get the tag badge :P Jun 3, 2021 at 13:07

# But, Is It Art?

• I think it is clear, but the second example of "is not equivalent to" is a little unnecessary in my opinion. Jun 2, 2021 at 10:03