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


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.


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.


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

  • \$\begingroup\$ What if I posted on the sandbox a long time ago and get no response? \$\endgroup\$
    – None1
    Commented May 15 at 14:05
  • \$\begingroup\$ @None1 If you don't get feedback for a while you can ask in the nineteenth byte \$\endgroup\$
    – mousetail
    Commented May 29 at 13:27

4703 Answers 4703

83 84
86 87

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:

enter image description here

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

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


Decimal to String with Mandatory Length



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.



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


  • 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 , 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. :/
  • 1
    \$\begingroup\$ Suggest testcase: "0.0000000001", 10 -> ".000000000", "0", 10, "0000000000" \$\endgroup\$
    – tsh
    Commented Jan 13, 2020 at 1:50
  • \$\begingroup\$ @tsh Added (although I've used n=15 instead of 10 so I could add it to the other list instead of creating two separated test cases for the n=10. Principle remains the same for your test cases, so thanks for the suggestion! \$\endgroup\$ Commented Jan 13, 2020 at 7:44
  • \$\begingroup\$ @tsh Your test case actually made me realize that s="0.0000000001", n=10 should be "100000E-15" instead for the most accurate result. Will have to do some fixes to my reference implementation. \$\endgroup\$ Commented Jan 13, 2020 at 7:54
  • \$\begingroup\$ Why should it be 100E-17, not 1.0E-15? The rule makes me confusing. \$\endgroup\$
    – tsh
    Commented Jan 13, 2020 at 9:14
  • \$\begingroup\$ @tsh 1.0E-15 would be allowed as well. I still have to change the rules after realizing that 0.00000 would be an incorrect result for s="0.0000000001", n=7, but both 100E-17 and 1.0E-15 are allowed, since they are of length 7 and retain the same exact value as 0.0000000001. I currently don't have the time to revise the rules, test cases, and reference implementation unfortunately (and if I delete the Sandbox post temporarily I can't search back for it). \$\endgroup\$ Commented Jan 13, 2020 at 9:17
  • \$\begingroup\$ You say this challenge asks for exactly 15 characters long but you then have outputs of varying length. I assume you want the latter. I'm being pedantic, I know, but it's the only thing I can find to fix at the moment ;) \$\endgroup\$
    – lyxal
    Commented Jan 13, 2020 at 9:28
  • \$\begingroup\$ @Jono2906 I've changed the part at the output-section. I hope it's a bit clearer now? \$\endgroup\$ Commented Jan 13, 2020 at 9:33
  • \$\begingroup\$ @KevinCruijssen it is clearer now. I mean, as I said, I was just being pedantic about things. \$\endgroup\$
    – lyxal
    Commented Jan 13, 2020 at 9:34
  • \$\begingroup\$ @Jono2906 Well, it was still a valid remark that I agree with, so thanks. :) \$\endgroup\$ Commented Jan 13, 2020 at 9:36
  • \$\begingroup\$ Just another thing: Perhaps The decimal string input is guaranteed to be valid and non-empty should be The decimal string input is guaranteed to be a valid float and non-empty \$\endgroup\$
    – lyxal
    Commented Jan 13, 2020 at 10:41
  • \$\begingroup\$ @Jono2906 Textual there isn't a difference between decimal/double/float, though. I had the sentence in my head as "the decimal string input is guaranteed to be (a) valid (decimal) and non-empty". I could change it to that if it makes it clearer, but talking about decimal first and float after that is more confusing than clarifying imho. But if you indeed meant "the decimal string input is guaranteed to be a valid decimal and non-empty" I'll change it. \$\endgroup\$ Commented Jan 13, 2020 at 11:49
  • \$\begingroup\$ @KevinCruijssen Yep, I indeed meant decimal. I've no clue why I said float. \$\endgroup\$
    – lyxal
    Commented Jan 13, 2020 at 20:10

Form a subset that is a continuous range


Implement a bag without replacement



Yet another Colatz challenge


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.


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:


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:


Then divide by 3 we get this:


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:


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, rules

This is code golf, shortest code wins

  • \$\begingroup\$ Actually, I don't know the colatz sequence. I do know the Collatz sequence... ;P \$\endgroup\$
    – DLosc
    Commented Feb 15, 2023 at 18:48

Capture the Flag... with a twist

  • \$\begingroup\$ I'm having trouble understanding the challenge. Could you add an example with a bit more explanation? \$\endgroup\$ Commented Jan 18, 2023 at 23:51
  • \$\begingroup\$ @Jacob - added. Let me know if I need to add another one. \$\endgroup\$
    – The Thonnu
    Commented Jan 19, 2023 at 7:24

Implement a 2Fuck Interpreter


Output code to sort a list without looping

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.


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.

enter image description here

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?

  • \$\begingroup\$ What if my language does not support arrays that have themselves as sub-array? E.g. it is impossible to construct if you can't get a reference to (only the value of) an array. \$\endgroup\$
    – Adám
    Commented Dec 28, 2022 at 7:51
  • \$\begingroup\$ @Adám Add explicit allowance \$\endgroup\$
    – l4m2
    Commented Dec 28, 2022 at 7:55
  • \$\begingroup\$ "Since some language don't support recursive array, it's also allowed to take a list of list of indices, each index meaning the responding list." feels like this sentence change the whole challenge into another one... \$\endgroup\$
    – tsh
    Commented Dec 29, 2022 at 7:57
  • \$\begingroup\$ @tsh How? Just each X[i] => C[X[i]] \$\endgroup\$
    – l4m2
    Commented Dec 29, 2022 at 8:41
  • \$\begingroup\$ Is a=[[[]]]; a[0][0][0]=[[[a[0][0]]]]; a valid testcase? \$\endgroup\$
    – tsh
    Commented Dec 29, 2022 at 8:58
  • \$\begingroup\$ @tsh Should be covered by [A=[B],B=[A]] \$\endgroup\$
    – l4m2
    Commented Dec 29, 2022 at 9:03
  • \$\begingroup\$ I cannot understand your [A=[B],B=[A]], is this some valid syntax in some language? \$\endgroup\$
    – tsh
    Commented Dec 29, 2022 at 10:06
  • \$\begingroup\$ @tsh x=[A=[],B=[]],A[0]=B,B[0]=A input or [ <ref *1> [ [ [Circular *1] ] ], <ref *2> [ <ref *1> [ [Circular *2] ] ] ] output \$\endgroup\$
    – l4m2
    Commented Dec 29, 2022 at 14:00

Knook to Mate... With Portals!

  • \$\begingroup\$ In this image you may want to mark someway that B3 can't be reached, right now you use the arrow both to mean inclusive range and just the endpoint \$\endgroup\$
    – mousetail
    Commented Jan 20, 2023 at 6:42
  • \$\begingroup\$ cdn.discordapp.com/attachments/968416999808057344/… is d6 also valid? \$\endgroup\$
    – l4m2
    Commented Jan 20, 2023 at 7:14
  • \$\begingroup\$ @l4m2 d6 is indeed also valid. Positions may have multiple solutions \$\endgroup\$
    – lyxal
    Commented Jan 20, 2023 at 8:03

Longest N-Sum Sub-Array

Write a program or function which when given an array of non-negative integers and a number \$N\$, output the longest contiguous sub-array whose sum of elements adds up to \$N\$:

$$S = \{ (x, y) : \sum_{n=x}^{y} a_n = N \}$$

$$\text{Output: } argmax_S (y - x)$$


  • If there are multiple solutions, output any of them or all of them (choose one).
  • You may output the solution in any reasonable format, which must allow for the following point.
  • There will always be a solution, but it can be the empty list.
  • \$N \ge 0\$.

Test cases

[input array], N -> [output array]

[1, 0, 0, 1, 0], 1 -> [0, 0, 1, 0]
[1, 0, 0, 1, 0], 0 -> [0, 0]
[1, 2, 3, 4, 5], 0 -> []
[1, 2, 3, 4, 5], 5 -> [2, 3]
[4, 3, 1, 1, 0, 5, 2], 8 -> [1, 0, 5, 2]
[0], 0 -> [0]
[], 0 -> []

This is , so shortest code in bytes wins.

  • \$\begingroup\$ Related, Related \$\endgroup\$
    – c--
    Commented Jan 16, 2023 at 14:37

Toggle my Comments

Write a program which takes a string as input. If the string is a syntactically valid comment in the program's language, the program must output an uncommented version of the string. Otherwise, it must output a syntactically valid commented version. Programs may use either multiline or single-line comments. Languages that do not support comments may not compete.

Python example

Input: spaghetti
Possible output: #spaghetti
Possible output: # spaghetti

Input: # spaghetti
Output: spaghetti

Input: #spaghetti
Output: spaghetti

Toggle Hangul Vowel Harmony

(This post is partly self-plagiarized.)


Given a Hangul syllable, toggle its vowel harmony.

Introduction to Hangul syllables

Hangul(한글) is the Korean writing system invented by Sejong the Great. Hangul syllables are allocated in Unicode point U+AC00 – U+D7A3. A Hangul syllable consists of an initial consonant, a vowel, and an optional final consonant.

The initial consonants are:

ㄱ ㄲ ㄴ ㄷ ㄸ ㄹ ㅁ ㅂ ㅃ ㅅ ㅆ ㅇ ㅈ ㅉ ㅊ ㅋ ㅌ ㅍ ㅎ

The vowels are:

ㅏ ㅐ ㅑ ㅒ ㅓ ㅔ ㅕ ㅖ ㅗ ㅘ ㅙ ㅚ ㅛ ㅜ ㅝ ㅞ ㅟ ㅠ ㅡ ㅢ ㅣ

The final consonants are:

(none) ㄱ ㄲ ㄳ ㄴ ㄵ ㄶ ㄷ ㄹ ㄺ ㄻ ㄼ ㄽ ㄾ ㄿ ㅀ ㅁ ㅂ ㅄ ㅅ ㅆ ㅇ ㅈ ㅊ ㅋ ㅌ ㅍ ㅎ

For example, has initial consonant , vowel , and final consonant .

South Korean dictionary order

The consonants and vowels above are sorted in South Korean dictionary order. The syllables are firstly sorted by initial consonants, secondly by vowels, and finally by (optional) final consonants.

The Unicode block for Hangul syllables contains every consonant/vowel combinations, and is entirely sorted in South Korean dictionary order.

The Unicode block can be seen here, and the first 256 characters are shown for illustrative purpose:


Vowel Harmony

Korean vowels express vowel harmony as positive-negative pairs. They're paired like the followings:

(Positive) - (Negative)
ㅏ - ㅓ
ㅐ - ㅔ
ㅑ - ㅕ
ㅒ - ㅖ
ㅗ - ㅜ
ㅘ - ㅝ
ㅙ - ㅞ
ㅚ - ㅟ
ㅛ - ㅠ
(ㅡ, ㅢ, and ㅣ lack counterparts)



It's a dog!

  • \$\begingroup\$ Picture show tail something like leg but don't touch floor; I usually see tail in real life touch floor with lot laid, though \$\endgroup\$
    – l4m2
    Commented Jan 22, 2023 at 5:37
  • 1
    \$\begingroup\$ You may want to specify that the legs need to be separate (i.e. cannot share a common "border"). As per the tail one option is to simplify the task only to check a simple tail (or a "tail ending"), e.g. (space)_ \\ [_ and the leftmost bracket touches the left border (and perhaps is the only non-space character there). \$\endgroup\$
    – pajonk
    Commented Jan 24, 2023 at 13:53

Determine the Octet(/Duplet/18-electron) Rule



An address is decoded as follow:

   reg eax ecx edx ebx esp ebp esi edi  0  sib
    id  0   1   2   3   4   5   6   7   -   -
+0      00  01  02  03  /   /   06  07  /   04
+imm8   40  41  42  43  /   45  46  47  /   44
+imm32  80  81  82  83  /   85  86  87  05  84

where sib means the following byte parsed as follow:

    +  eax ecx edx ebx esp ebp/imm32*esi edi
   eax  00  01  02  03  04     05     06  07
   ecx  08  09  0a  0b  0c     0d     0e  0f
   edx  10  11  12  13  14     15     16  17
   ebx  18  19  1a  1b  1c     1d     1e  1f
     0  20  21  22  23  24     25     26  27
   ebp  28  29  2a  2b  2c     2d     2e  2f
   esi  30  31  32  33  34     35     36  37
   edi  38  39  3a  3b  3c     3d     3e  3f
 2*eax  40  41  42  43  44     45     46  47
 2*ecx  48  49  4a  4b  4c     4d     4e  4f
 2*edx  50  51  52  53  54     55     56  57
 2*ebx  58  59  5a  5b  5c     5d     5e  5f
 2*esp  60  61  62  63  64     65     66  67
 2*ebp  68  69  6a  6b  6c     6d     6e  6f
 2*esi  70  71  72  73  74     75     76  77
 2*edi  78  79  7a  7b  7c     7d     7e  7f
 4*eax  80  81  82  83  84     85     86  87
 4*ecx  88  89  8a  8b  8c     8d     8e  8f
 4*edx  90  91  92  93  94     95     96  97
 4*ebx  98  99  9a  9b  9c     9d     9e  9f
 4*esp  a0  a1  a2  a3  a4     a5     a6  a7
 4*ebp  a8  a9  aa  ab  ac     ad     ae  af
 4*esi  b0  b1  b2  b3  b4     b5     b6  b7
 4*edi  b8  b9  ba  bb  bc     bd     be  bf
 8*eax  c0  c1  c2  c3  c4     c5     c6  c7
 8*ecx  c8  c9  ca  cb  cc     cd     ce  cf
 8*edx  d0  d1  d2  d3  d4     d5     d6  d7
 8*ebx  d8  d9  da  db  dc     dd     de  df
 8*esp  e0  e1  e2  e3  e4     e5     e6  e7
 8*ebp  e8  e9  ea  eb  ec     ed     ee  ef
 8*esi  f0  f1  f2  f3  f4     f5     f6  f7
 8*edi  f8  f9  fa  fb  fc     fd     fe  ff
* imm32 if no another imm

If an imm8 or imm32 is used, the value is followed after, little-endian.

Given a value of {0,1,2,4,8}*reg+{reg,0}+imm32, output a shortest expression of the address.

Test cases

eax => 00
eax+8 => 40 08
eax+128 => 80 80 00 00 00
esp => 04 24
ebp => 45 00
4*eax => 04 85 00 00 00 00
2*eax => 04 00
2*esp => 04 60 00 00 00 00 

Sandbox Notes

  • Since it's modified(enabled to allow esp*4), and I'd allow use of id, should I remove the eax expression?

Translate to plorcly borglar


How to find the counterfeit coin?


How spherical is my ellipsoid?


Find opposite string

  • \$\begingroup\$ What do you mean by “opposite mirror letter” \$\endgroup\$ Commented Feb 15, 2023 at 20:43
  • \$\begingroup\$ @Jacob "opposite mirror letter from the English alphabet" - it means that a must be replaced with z, b must be replaced with y and so on. In general let's we have some letter which index in alphabet is Index then it must be replaced with letter which index is 25 - Index (25 if zero based and 26 if 1 based) \$\endgroup\$
    – EzioMercer
    Commented Feb 15, 2023 at 21:22

Random point inside boundary


Given a signed int64, convert into base -2 integer. + - & | ^ ~ cost 1. =, variable name, constant are free. Other operations disallowed. Lowest cost win.


3D rotation matrix to quaternion


Number Clusters


Injectively saturate bit strings


Elevator movement order

  • \$\begingroup\$ Is it possible to have the first input also in the array? If so, how to handle that case? \$\endgroup\$
    – pajonk
    Commented Feb 22, 2023 at 5:25
  • \$\begingroup\$ @pajonk Can you please explain why do you need only first input in array and why not all inputs in one array? I don't like to mix the inputs because they separated by meaning \$\endgroup\$
    – EzioMercer
    Commented Feb 22, 2023 at 8:47
  • \$\begingroup\$ I meant a test case like 0, 3, [0,4,-2,-5,2,-4,1,5] --> ? - where to sort the 0 from the array? Or such input combination will never appear? Also, will the array never contain duplicates? \$\endgroup\$
    – pajonk
    Commented Feb 22, 2023 at 10:33
  • \$\begingroup\$ @pajonk 1. The zero is the floor where elevator already stopped it can not be in the order of future destinations. 2. There can not be a duplicates, also in the input array can not be the same number as in second input because this floor already exist in the order. Please inform me if this information MUST BE in challenge, I will add it :) \$\endgroup\$
    – EzioMercer
    Commented Feb 22, 2023 at 11:31
  • 1
    \$\begingroup\$ I think not specifying those conditions in the challenge body may prompt similar questions on main, so yes, please add it :) \$\endgroup\$
    – pajonk
    Commented Feb 22, 2023 at 11:36
  • \$\begingroup\$ @pajonk Done. Thank you! \$\endgroup\$
    – EzioMercer
    Commented Feb 22, 2023 at 13:12

Simultaneously solve N-queens and no-3-in-line


Consolidate a 6-axis Vector

  • \$\begingroup\$ I suggest specifying that the input will contain only integers. Also, as I read it, there is always one Consolidated Vector for any given input - is it the case? \$\endgroup\$
    – pajonk
    Commented Feb 23, 2023 at 12:53
  • \$\begingroup\$ @pajonk good points, I've added that information. Yes, there is only valid valid solution per input. \$\endgroup\$
    – Pavel
    Commented Feb 23, 2023 at 20:50

Decoding a non injective bit matrix encoding

  • \$\begingroup\$ Is the size always even? If not, how do you define quadrants? \$\endgroup\$ Commented Feb 27, 2023 at 3:43
  • \$\begingroup\$ The side can be odd, in which case the boundaries are obtained by dividing the side length and flooring it. I've edited the statement to clarify this, thank you for pointing it out! \$\endgroup\$ Commented Feb 27, 2023 at 13:21

Sum of strings (UTF-16 codepoints)

  • \$\begingroup\$ I thought this was a dupe but can't find anything that really matches this. By "the module of sum by the 65536" do you mean "the sum, modulo 65536"? \$\endgroup\$ Commented Feb 26, 2023 at 22:37
  • \$\begingroup\$ @Jacob Yes, exactly. If you can rephrase this sentence correctly, I will be grateful to you! \$\endgroup\$
    – EzioMercer
    Commented Feb 26, 2023 at 22:40
  • 1
    \$\begingroup\$ If the resulting sum is greater than 65535 (maximum UTF-16 codepoint), take the sum \$\mod{65535}\$ \$\endgroup\$ Commented Feb 26, 2023 at 23:13
83 84
86 87

You must log in to answer this question.

Not the answer you're looking for? Browse other questions tagged .