Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

To post to the sandbox, scroll to the bottom of this page and click "Answer This Question". Click "OK" when it asks if you really want to add another answer.

Write your challenge just as you would when actually posting it, though you can optionally add a title at the top. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it.

When you think your challenge is ready for the public, go ahead and post it, and replace the post here with a link to the challenge and delete the sandbox post.

Discussion

The purpose of the sandbox is to give and receive feedback on posts. If you want to, feel free to give feedback to any posts you see here. Important things to comment about can include:

• Parts of the challenge you found unclear
• Comments addressing specific points mentioned in the proposal
• Problems that could make the challenge uninteresting or unfit for the site

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

Brainfuck arbitrary precision multiplication

fastest-code code-challenge brainfuck

Goal

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

The Input

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

The Output

The output is a single integer written decimally.

Brainfuck variants used

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

Memory

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

Input/Output

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

Looping

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

Cycle

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

Reference implementation

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

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

Scoring

The winner is the program that is: (later number is for tiebreaker)

1. The program with lowest computational complexity (counted by using cycle metric as explained above, and in x where x is the length of the largest input in base 10) is the winner.
2. The program with lowest space complexity (counted by finding the rightmost cell reached by program)
3. The program that takes the least cycle to execute 1234567890*987654321
4. The program that takes the least memory to execute 1234567890*987654321
5. The shortest code

Computational complexity is determined in terms of the number of digits each arguments have.

Answer 2

Posted.

Answer 3

Jelly's Untruth

Answer 4

Generalised Taxicab Numbers

Answer 5

posted

Answer 6

Is my triangle on the lattice? decision-problem code-golf geometry

Posted on the main site.

Answer 7

Is it a Lobster Number?

Posted

Answer 8

BF memory layout optimizer (posted).

See the notes in the revision history.

[please review other sandbox posts]

Answer 9

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

Posted: Efficient table-lookup computation

Answer 10

Generalise perfect numbers

Answer 11

Byte-sized Huffman Coding (WIP)

code-challenge compression text

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.

Answer 12

What's the odd one out?

Answer 13

Sociable sequences

Answer 14

Write an interpreter generator

Answer 15

Keep PPCG running in Game of Life

Answer 16

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?

Answer 17

cadaddadadaddddaddddddr - linked list accessing

Answer 18

Un-pipe an Elixir expression

Answer 19

What's my TIO uniqueness?

Answer 20

Rejecting invalid IPv4 addresses

Answer 21

Interpret control characters like a terminal

Answer 22

You are kinda Replacable to Me

Answer 23

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!

---

The Task

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.

---

Tags: code-golf sequence number

---

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

Answer 24

diddly darn posted

Answer 25

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 code-golf, 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 code-golf, 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 king-of-the-hill 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

• Thoughts? I'm not aware of any similar challenges that combine cops-and-robbers with king-of-the-hill, other than this
• Is this clear enough?
• Tags are king-of-the-hill, cops-and-robbers, hexagonal-grid, maze and python
• Any further feedback?

Answer 26

Interpret Gelatin

Answer 27

CDGLF:TMN2APL

code-golf parsing compiler string

---

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)

Answer 28

Time bomb KoTH

Answer 29

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

Answer 30

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.