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

Is it a legal atomic chess move?

Answer 2

Print the most uncommon character

code-golf self-referential

Your task is to write a full program or function that prints the character(s)* that appears in your code the least. For example, if my code was AAAABBBBCCCDDD, then the program should print CD or DC.

Rules

• All printed characters must appear at least three times in your code, but you will print only one character for each.
• You are only printing those character(s). If your language always includes a trailing newline, then that is allowed.
• All printed characters must be printable characters or newlines.
• If multiple characters all appear the least, you must print them all, without separation. Order does not matter.
• The program or function cannot be empty, so it has to be a minimum of three characters long.
• This is code-golf, so the shortest code in bytes wins.

_{*Where "character(s)" is mentioned in the rules above, exceptions may be made for languages like TI-Basic or Piet which do not use characters.}

Meta

• Are there any similar questions to this?
• Should I change the rules?

Answer 3

Find the nth number where the digit sum equals the number of factors

Answer 4

Range of ASCII values

Answer 5

Join Columnar Strings

Tags: code-golfstring

Answer 6

Merged strings

Not sure if this is already done

Basically, take two strings of reasonable length (like <32 chars) of numbers and X's and find the shortest superposition of those strings such that there's no 2 numbers at the same position. Number+X or X+X is allowed. Print the result.

Examples:

["01XX02","10XX2"]
-----
010X02

["5234XXX","431XXX"]
-----
523431XXX

Note:

• Even if the string ends with X's, print those X's as they're part of the strings.
• Oh and the result must start with the first string. (like test 4)

Tests:

1234   | 345    -> 12345
6573   | 2625   -> 65732625
11X    | 12     -> 112
XX1XX  | XX2XX  -> XX12XX
X1X2X3 | 1XX234 -> X1X2234

Scoring

The program with the least bytes wins!

Answer 7

><> numbers metagolf coding-challengemeta-golfrestricted-complexity

Answer 8

KotH: Don't Kill the Curve!

In this KotH, you will take a test at school. Your goal, of course, is to get the highest grade, up to a maximum of 110%. This score consists of your actual grade, curved, as well as 10% which is the average of other students' scores, since your teacher wants to encourage students to study together.

You have a minimum of 100 turns leading up to the test. You can use these to either:

• Study: This add a point to your score (initially 0), unless your score is already 100
• Tutor: Adds two points to the score of any other student, up to a max of 100
• Arson: Majorly disrupt another student's life, dropping their score by 10 points (down to a minimum of zero), and negating their next 10 actions as they rebuild their life

Arson requires a lengthy jail sentence, meaning that your next 10 actions are also negated. If you have fewer than 10 actions left, you miss the test, and must retake it, making the maximum score you can receive (after the curve, before the bonus from other students) 70 points. Your real score is still used in the class average. Note that being an arson victim in the last 10 turns does not prevent you from taking the test; it only prevents you from studying, tutoring, or paying it forward.

You can also miss the test by taking more than 100 turns. After 100 turns you can only tutor or commit arson against other students which have not yet taken the test. Missing the test normally still has the same impact as if you had missed it while in jail, so it is likely only an effective strategy if you would otherwise receive a score below 70 (perhaps due to being an arson victim or avid tutor).

The test is also curved. Whichever student has the highest raw score will have theirs adjusted to 100, and that same shift will be applied to all other students. The curve is not taken into account for student averages, so if all students receive a 20% raw score, they would receive 102% as their final score (if they did not miss the test).

Information:

You are aware of all other students' scores on previous tests, your own "preparedness" (the raw score you would get if you took the test now), and the list of students who are recovering from arson and/or in jail.

Answer 9

Smallest and largest 100-bit square with maximum Hamming weight

Answer 10

Two-leg train journey

Joseph wants to travel by train from town A to town C. There is no direct train, so he wants to transfer in town B. You get the railway timetables from A to B and from B to C, and the latest time when Joseph needs to arrive to C. Compute the latest time that Joseph can arrive to the railway station in A and still be in time.

Times are given as integers between 0 and 1440, meaning the number of minutes from midnight on the day of the journey. A schedule from a town to another is given as a list of pairs, each pair made of two times, namely the time when the train departs from the first station and the time when it arrives to the second station. Your program gets three inputs: the train schedule from town A to town B, the train schedule from town B to town C, and the time when Joseph has to arrive to C the latest. Your program must output a single time, namely the latest time when Joseph has to be on station A.

The transfer at B is immediate, so if the first train arrives to B at exactly the same time as the second train departs from B then Joseph can transfer. You can assume that there are enough trains that Joseph can arrive at the required time or earlier. You can also assume that each schedule is sorted by departure time, but you cannot assume that the schedule is sorted by arrival time. For example, in the example input below, the first train from B departs at time 319 (meaning 09:27) and arrives at time 567 (meaning 9:27), but the second train departs at 366 and arrives at 539, overtaking the first train. Joseph is in a hypothetical country where trains always run exactly in time according to their schedule.

Here's a non-golfed example solution in Python 3. The function transfer solves the problem. The function travel takes just one schedule and finds when you have to arrive to the station where the trains in that schedule start.

def travel(schedule, arrival):
    departure = -2000
    for train in schedule:
        if train[1] <= arrival and departure < train[0]:
            departure = train[0]
    return departure
def transfer(schedule0, schedule1, arrival1):
    return travel(schedule0, travel(schedule1, arrival1))

Here's how we invoke the above example solution with an example input triple.

print(transfer(
    ((270, 294), (337, 357), (390, 414), (457, 477), (510, 534), (577, 597), (630, 654), (697, 717), (750, 774), (817, 837), (870, 894), (937, 957), (990, 1014), (1057, 1077), (1110, 1134), (1230, 1254), (1338, 1362)),
    ((319, 567), (366, 539), (540, 714), (545, 809), (780, 954), (785, 1055), (900, 1074), (905, 1169), (1025, 1280), (1140, 1324)),
    720))

This prints 510, which is the correct output for these inputs. In station A, Joseph will take the train at time 510 (meaning 08:30), arrive to B at time 534 (08:54), get on the second train at time 540 (09:00), and arrive to C at time 714 (11:54), which is not later then the deadline time 720 (12:00).

This is a slightly modified version of an easy programming homework problem that I posed many years ago. I am shamelessly copying the single example input from there, since I'm too lazy to make up a new one.

Golf Sandbox, besides all the other feedback, please tell me what tags I should use.

Answer 11

A decimal-based unit of time

Answer 12

Is this position a pure mirror mate?

Answer 13

Flip the order of operations code-golf

Answer 14

Friend or Foe?

Answer 15

No, thanks!

In the game “No Thanks!” playing cards numbered 3 to 35 are shuffled in a deck and 11 chips distributed to each player. The first player flips over a card and can then decide either to take the card, or to place a chip on top of it and to pass it on.

The card continues to be passed around until a player decides to take the card along with its chips. The same player flips over the next card and continues the procedure.

At the end of the game, the value of their cards get added up. Each chip they own is worth a negative point. The player with the lowest number of points wins.

Should a player have cards in succession (e.g. 18, 19, and 20), then the card with the lowest value (18) will be considered.

Rules

• 9 cards will be removed from the deck at the start of the game

• You will be participating with 2 other players

• Everyone’s cards will always be visible

• You do not have access to the amount of chips that others possess. You can, however, keep track of them.

Answer 16

Find the smallest turing machine that solves the self-counting problem

Answer 17

RADD decomposition of an integer

Answer 18

Maximum of outer product of integer vectors (in linear time)

Answer 19

Calculate the McCombination

In 2002, McDonald's advertised a McChoice menu of 8 items, labelled with "40,312 combinations." However, this number is far greater than the actual number of combinations (255; 2^8=256, minus 1 for empty meal). What the McDonald's marketing team calculated was how many different ways you could arrange a meal containing all 8 items (8! = 40,320), but subtracted 8 from the total to remove 1-item combinations. Since their original calculation was incorrect, the final result is meaningless.

The McCombination of a number n is the factorial of n, minus n.

Task:

Given an integer greater than 0 as input, output the McCombination of that number.

Test cases:

8 -> 40312
4 -> 20
9 -> 362871
3 -> 3
1 -> 0

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

Answer 20

Guess the song title code-golf string

Answer 21

Division between two strings

Inverse function of this challenge

To multiply two strings, you take two strings and compare each character. The character with the highest code point is then added to the output. If they are equal, simply add the character to the output.¹

Given an input and the output, provide a random² input such that multiplying the two inputs returns the output. Each possible input should be possibly generated. If there's no possible input, output nothing or something that isn't a string(crashing is fine, but not infinite loop)².

^{1 I know it's not a multiply but that's copyed as-is
2 Otherwise a cat solves the question}

code-golf

Answer 22

WIP: clarify

Connect WEST and EAST using n pipe.

This is an example output, where n=9.

You can make sub-component, which each pin behave an extra pipe. Sub-component cost 2 pipe. Following is n=19. (The sub-component at the center is image above) You can also make sub-component in sub-component, and et infinitum.

It has same cost and behavior as

Thing change when n=35, where using sub-component only cost 33 pipe:

Now given odd n>8, output the minimum cost to connect WEST and EAST using n pipe.

9 => 9
19 => 19
35 => 33

code-golf

Answer 23

Decimal to String with Mandatory Length

Tags: code-golfstringfloating-pointconversion

Introduction:

Inspired by this SO question, which asks for the most accurate precision of decimal values using either rounding or scientific notation as string, with at most 15 characters long. This would include the -, ., and E in the output-string.

Challenge:

Inputs:

• A decimal value \$s\$
• An integer output-length \$n\$

Output:

• A string of the most accurate representation of the given decimal value, with a length exactly equal to the output-length \$n\$. NOTE: the linked SO question ask for at most 15 characters long, but this challenge asks for exactly \$n\$ characters long instead.

Challenge rules:

• The output-length input is guaranteed to be \$n\geq7\$
• The decimal input is guaranteed to be valid and non-empty
• You are allowed to take the input-decimal \$s\$ as string
• The input-decimal is guaranteed to only contain the characters 0123456789-., and will not start with an . (but 0. instead), nor start with unnecessary leading 0s like 001.23 instead of 1.23 (except for 0.).
• The output-string is guaranteed to only contain the characters 0123456789-.E (or e instead of E if you choose so). The input-format restrictions mentioned one bullet-point above, do NOT apply for the output-format however!
• If the length of the integer part of a number (including - for negative values) is larger than the given output-length: use a scientific notation (with either e or E) and rounded precision. I.e. with inputs s = "-987654321987654321.987654321"; n = 15, the output is supposed to be one of these: ["-987654321.99E9", "-9876543219.9E8", "-98765432199.E7"]
• It is allowed to add leading 0s to get to length \$n\$ without changing its decimal (base-10) value. I.e. with inputs s = "-123.00"; n = 15, the output "-00000000000123" would be valid.
• It is allowed to add trailing 0s to the decimal parts to get to length \$n\$ without changing its decimal (base-10) value. I.e. with inputs s = "-1.23"; n = 15, the output "-1.230000000000" or "-1.2300000000E0" are both valid. (With inputs s = "-0.123456789123456789"; n = 15, the only possible output is "-.1234567891235".)
• Please specify which rounding type your language is using! (E.g. HALF_UP, HALF_DOWN, HALF_EVEN, BANKERS, etc.) My test cases where this is relevant use HALF_UP.
• If multiple outputs are possible, just output one, multiple, or all of them.

General rules:

• This is code-golf, so shortest answer in bytes wins.
  Don't let code-golf languages discourage you from posting answers with non-codegolfing languages. Try to come up with an as short as possible answer for 'any' programming language.
• Standard rules apply for your answer with default I/O rules, so you are allowed to use STDIN/STDOUT, functions/method with the proper parameters and return-type, full programs. Your call.
• Default Loopholes are forbidden.
• If possible, please add a link with a test for your code (i.e. TIO).
• Also, adding an explanation for your answer is highly recommended.

Test cases:

All these test cases will use the output-length as 15 (and rounding mode HALF_UP):

Input:                           Possible Outputs:
"987654321987654321.987654321"   "987654321.988E9","9876543219.88E8","98765432198.8E7","987654321988.E6"
"-987654321987654321.987654321"  "-987654321.99E9","-9876543219.9E8","-98765432199.E7"
"1234567891234567.123456789"     "1234567.89123E9","12345678.9123E8","123456789.123E7","1234567891.23E6","12345678912.3E5","123456789123.E4"
"-1234567891234567.123456789"    "-1234567.8912E9","-12345678.912E8","-123456789.12E7","-1234567891.2E6","-12345678912.E5"
"0.123456789123456789"           ".12345678912346"
"-0.123456789123456789"          "-.1234567891235"
"5.5555555555555555555555555"    "5.5555555555556"
"-5.5555555555555555555555555"   "-5.555555555556"
"123456789123456"                "123456789123456"
"-123456789123456"               "-123456.78912E9","-1234567.8912E8","-12345678.912E7","-123456789.12E6","-1234567891.2E5","-12345678912.E4"
"123.00"                         "123.00000000000","0123.0000000000","00123.000000000","000123.00000000","0000123.0000000","00000123.000000","000000123.00000","0000000123.0000","00000000123.000","000000000123.00","0000000000123.0","00000000000123.","000000000000123","123.000000000E0","0123.00000000E0","00123.0000000E0","000123.000000E0","0000123.00000E0","00000123.0000E0","000000123.000E0","0000000123.00E0","00000000123.0E0","000000000123.E0","12.3000000000E1","012.300000000E1","0012.30000000E1","00012.3000000E1","000012.300000E1","0000012.30000E1","00000012.3000E1","000000012.300E1","0000000012.30E1","00000000012.3E1","1.23000000000E2","01.2300000000E2","001.230000000E2","0001.23000000E2","00001.2300000E2","000001.230000E2","0000001.23000E2","00000001.2300E2","000000001.230E2","0000000001.23E2",".123000000000E3","0.12300000000E3","00.1230000000E3","000.123000000E3","0000.12300000E3","00000.1230000E3","000000.123000E3","0000000.12300E3","00000000.1230E3","000000000.123E3","1230.0000000E-1","01230.000000E-1","001230.00000E-1","0001230.0000E-1","00001230.000E-1","000001230.00E-1","0000001230.0E-1","00000001230.E-1","000000001230E-1","12300.000000E-2","012300.00000E-2","0012300.0000E-2","00012300.000E-2","000012300.00E-2","0000012300.0E-2","00000012300.E-2","000000012300E-2","123000.00000E-3","0123000.0000E-3","00123000.000E-3","000123000.00E-3","0000123000.0E-3","00000123000.E-3","000000123000E-3","1230000.0000E-4","01230000.000E-4","001230000.00E-4","0001230000.0E-4","00001230000.E-4","000001230000E-4","12300000.000E-5","123000000.00E-5","1230000000.0E-5","12300000000.E-5","123000000000E-5","123000000.00E-6","1230000000.0E-6","12300000000.E-6","123000000000E-6","1230000000.0E-7","12300000000.E-7","123000000000E-7","12300000000.E-8","123000000000E-8","123000000000E-9"
"-123.00"                        "-123.0000000000","-0123.000000000","-00123.00000000","-000123.0000000","-0000123.000000","-00000123.00000","-000000123.0000","-0000000123.000","-00000000123.00","-000000000123.0","-0000000000123.","-00000000000123","-123.00000000E0","-0123.0000000E0","-00123.000000E0","-000123.00000E0","-0000123.0000E0","-00000123.000E0","-000000123.00E0","-0000000123.0E0","-00000000123.E0","-000000000123E0","-12.300000000E1","-012.30000000E1","-0012.3000000E1","-00012.300000E1","-000012.30000E1","-0000012.3000E1","-00000012.300E1","-000000012.30E1","-0000000012.3E1","-1.2300000000E2","-01.230000000E2","-001.23000000E2","-0001.2300000E2","-00001.230000E2","-000001.23000E2","-0000001.2300E2","-00000001.230E2","-000000001.23E2","-.12300000000E3","-0.1230000000E3","-00.123000000E3","-000.12300000E3","-0000.1230000E3","-00000.123000E3","-000000.12300E3","-0000000.1230E3","-00000000.123E3","-1230.000000E-1","-01230.00000E-1","-001230.0000E-1","-0001230.000E-1","-00001230.00E-1","-000001230.0E-1","-0000001230.E-1","-00000001230E-1","-12300.00000E-2","-012300.0000E-2","-0012300.000E-2","-00012300.00E-2","-000012300.0E-2","-0000012300.E-2","-00000012300E-2","-123000.0000E-3","-0123000.000E-3","-00123000.00E-3","-000123000.0E-3","-0000123000.E-3","-00000123000E-3","-1230000.000E-4","-01230000.00E-4","-001230000.0E-4","-0001230000.E-4","-00001230000E-4","-12300000.00E-5","-123000000.0E-5","-1230000000.E-5","-12300000000E-5","-123000000.0E-6","-1230000000.E-6","-12300000000E-6","-1230000000.E-7","-12300000000E-7","-12300000000E-8"

TODO: Fix the possible outputs of the other test cases as well:

"0.123"                          ".12300000000000"
"-0.123"                         "-.1230000000000"
"1.23"                           "1.2300000000000"
"-1.23"                          "-1.230000000000"
"0.000000000000001"              "10000000000E-25"
"0"                              "000000000000000"

All these test cases will use the output-length as 7 (and rounding mode HALF_UP):

Input:                           Output:
"987654321987654321.987654321"   "9.88E17"
"-987654321987654321.987654321"  "-9.9E17"
"1234567891234567.123456789"     "1.23E15"
"-1234567891234567.123456789"    "-1.2E15"
"0.123456789123456789"           ".123457"
"-0.123456789123456789"          "-.12346"
"5.5555555555555555555555555"    "5.55556"
"-5.5555555555555555555555555"   "-5.5556"
"123456789123456"                "1.23E14"
"-123456789123456"               "-1.2E14"
"123.00"                         "0000123" or "01.23E2" or "1.230E2"
"-123.00"                        "-000123" or "-12.3E1"
"0.123"                          ".123000"
"-0.123"                         "-.12300"
"1.23"                           "1.23000"
"-1.23"                          "-1.2300"
"0.000000000000001"              "100E-17" or "1.0E-15"
"0"                              "0000000",".000000","0.00000","00.0000","000.000","0000.00","00000.0","000000.","0E12345","000E-98"",etc.,etc. :/

Answer 24

Form a subset that is a continuous range

Answer 25

Implement a bag without replacement

Tags: code-golfdata-structuresrandom

Answer 26

Yet another Colatz challenge

Background

We all know and love the colatz sequence. It goes like this:

• If a number is divisible by 2, divide by 2
• Otherwise, multiply by 3 and add 1.

The Colatz conjecture theorizes that if you repeat this process for any number, you'll eventually reach 1.

Binary

If you write colatz numbers in binary, any numbers divisible by 2 will be followed by a 0. This means we can ignore any trailing 0s at the end of the number in binary notation, as the 0s will be removed first anyways. Thus we only need to consider the odd numbers. For the purpose of this challenge, we'll write it like this:

1[0]

This means "1 followed by any number of 0s". Every colatz number must pass through this number in this form at some point (since no odd number * 3 + 1 = 1). If we then subtract 1, we get this:

[1]

Then divide by 3 we get this:

[01]

Note that only even numbers of 1 are divisible by 3, so we only consider them. Here, we can prove that the last odd number in any numbers colatz sequence must be of this form. Of course, the ancestors in the same family will look like that:

[01][0]

Continuing the pattern

We can continue the pattern to find general forms for the nth ancestor of 1 in the colatz sequence. We start like this:

-1 [01]00[1]
/3 [000111]00[01][0]
-1 [000111]00[01]00[1] (or if [01] is repeated 0 times [000111]00011011111[1])
/3 [000010010111101101000010010111101101]00[000111]00[01][0]

Note: Now, when subtracting 1 the pattern branches. Numbers inside the brackets can be repeated 0 or more times. If they are repeated at least once the 1 can "absorb" the -1 from the right and prevent it from effecting the pattern to it's left. However, if repeated 0 times subtracting one would also flip the 0s to it's left until the first 1 is encountered. For the purpose of this challenge you only need to consider the branch of the path where each pattern is repeated at least once.

The challenge

Your task is to output the general form of the nth-element in the odd only colatz sequence, assuming the branch where each pattern appears at least once.

• Output must be in binary
• You may use any reasonable method to mark which sequences can be repeated
• You may choose to output only the odd or only the even members of the sequence if you want
• You can loop forever, or output the nth element given a n, sequence rules

This is code golf, shortest code wins

Answer 27

Capture the Flag... with a twist

Answer 28

Implement a 2Fuck Interpreter

Answer 29

Output code to sort a list without looping code-golfrestricted-source

Given a integer n, output the source code for a program or function that can sort a list of n elements without looping. For any n there are a finite number of possible orderings so this has to be possible.

Looping includes any way to run code a variable number of times. It also includes recursion or using any built-ins that internally loop. (including your sort builtin) Branching is ok.

The code you submit may have loops, just the code outputted may not.

The lists you sort will be positive integers in the range \$ 1 \leq n \leq 2^{16} - 1\$. Note 0 is excluded. The list may contain duplicate elements.

For example:

N	Possible Output
1	|x:&mut[u16;1]|()
2	|x:&mut[u16;2]|*x=if x[1]>x[0]{[x[0],x[1]]}else{[x[1],x[0]]}

Note the program you output can be as long as you like, your score is only the length of the program that generates the sorting function.

The program you output may be in a different language then the generating program, in this case list both languages in your header. Both may use any IO format from our standard input/output methods list.

Answer 30

Given an array of array of array of ..., convert it into a string. Brackets should be used to show depth.

However, the input may include loops (e.g. an array containing itself), which would lead to an infinite output without extra rule. Therefore, if an array has been expanded twice (and is trying to expand a third time), it should be expanded into something else.

Since some languages don't support recursive arrays, it's also allowed to take a list of list of indices \$[A_1,A_2,\ldots]=[[a_{11}, a_{12},\ldots],[a_{21},a_{22},\ldots],\ldots]\$, where each integer \$a_{ij}\$ should be replaced with the expanded array \$A_j\$.

Shortest code wins.

Test cases:

raw	indices	result
[]	[]	[]
[[],[]]	[1,1],[]	[[],[]]
A=[A,A]	[0,0]	[[-,-],[-,-]]
[A=[B],B=[A]]	[1,2],[2],[1]	[[[[[-]]]],[[[[-]]]]]

Function in javascript to convert indices into array:

function indices2array(arr) {
    var ret = arr.map(_=>[]);
    for (var i in arr) {
        for (var j of arr[i]) ret[i].push(ret[j]);
        ret[i].id = +i;
    }
    return ret[0];
}

---

Idea from recursive iframe. On Firefox, it expands using this rule.

A<br><iframe src="B.html"></iframe>
B<br><iframe src="A.html"></iframe>
X<br><iframe height="400" src="A.html"></iframe><iframe height="400" src="B.html"></iframe>

Given function that expands once, is it easy to expand twice?