What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, 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. 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, replace the post here with a link to the challenge and delete it.

See the Sandbox FAQ for more information on how to use the Sandbox.

The Sandbox works best if you sort posts by "active".

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

To add an inline tag to a proposal use shortcut link syntax with a prefix: [tag:king-of-the-hill]


3113 Answers 3113

92 93
95 96

Let's trick Bob

Bob and I are rivals. We constantly try to "hack" each other, even though neither of us has a clue about hacking or cybersecurity. The other day, when Bob left his laptop for a coffee break, I found the source code for his website. This project also contained a file called usernamesAndPasswords.json! Intrigued, I opened it, but realized the passwords were hashed*. Looking at the code, it seems Bob was using Java's String#hashCode method.

While I could have done some harm right then and there, I don't want Bob to realize what happened, else he might start shutting down his laptop before going for coffee. Rather, I would like to sign in to Bob's website as Bob and wreak havoc there using my admin privileges while Bob's asleep.


Given an integer between \$-2^{32}\$ and \$2^{32}-1\$ (inclusive), output a string (any string) that, when hashed using Java's hashCode method, outputs that integer.

To hash a string in Java, you basically interpret it as a base 31 number:

  • Each char in the string (chars are unsigned 16 byte integers) is treated like an int (signed 32 byte integer).
  • The last character is multiplied by \$31^0\$, the second-to-last character is multiplied by \$31^1\$, and so on, until the first character is multiplied by \$31^{n-1}\$, where \$n\$ is the length of the string.
  • All of these products are summed together to get the final hashcode.

int arithmetic is used for all of the operations: exponentiation (multiplication can overflow at each step), multiplication, and addition. Because of this, it is very likely that two strings will have a hash collision.

Here's a sample implementation in Java:

int hash = 0;
for (char c : string.toCharArray())
  hash = 31 * hash + c;
return hash;


  • Since this is , the shortest code in bytes wins.
  • The maximum password length is 20.

*Looking back, this is probably how Bob "hacked" me before. Perhaps making a file called passwords.txt wasn't such a great idea after all.

Questions for Meta:

  • Is the backstory too long and boring?
  • Is this a duplicate?
  • What should the max password length be?
  • \$\begingroup\$ I think this is an interesting challenge, but it could be more interesting as [fastest-code] in my opinion, since for codegolf the shortest solutions would probably be boring brute-force ones \$\endgroup\$ – Command Master Feb 17 at 7:06
  • 1
    \$\begingroup\$ @CommandMaster Nope, this is way too easy for fastest code. \$\endgroup\$ – user202729 Feb 17 at 8:29
  • \$\begingroup\$ 20 is definitely sufficient. \$\endgroup\$ – user202729 Feb 17 at 8:29
  • \$\begingroup\$ Can programs output unprintable characters? \$\endgroup\$ – user202729 Feb 17 at 8:29
  • \$\begingroup\$ @user20729 Yes. \$\endgroup\$ – user Feb 17 at 12:07
  • \$\begingroup\$ Can there be unpaired (invalid) surrogate in the string? \$\endgroup\$ – user202729 Feb 18 at 4:39
  • \$\begingroup\$ @user202729 I don’t understand what that is. If you’re talking about invalid Unicode, go ahead, as ling as the chars work, it’s fine \$\endgroup\$ – user Feb 18 at 4:45
  • \$\begingroup\$ So it's "as long as it works in java (7/8/9/10/11)? \$\endgroup\$ – user202729 Feb 18 at 4:46
  • \$\begingroup\$ @user202729 Well, as long as it works with the algorithm described above. Who knows if Java's own implementation may change in the future? \$\endgroup\$ – user Feb 18 at 14:10


  • 3
    \$\begingroup\$ The main issue with fastest-code is that you need to specify the specification of a machine to judge solutions on, and a set of test cases. (note that 8x8x8 is probably too small for meaningful timing) (There's also golf-cpu and atomic-code-golf, but I don't see the former used much) [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 13 at 2:40
  • \$\begingroup\$ @user202729 Thank you for the comments. Already updated. \$\endgroup\$ – JimmyHu Feb 13 at 11:03
  • \$\begingroup\$ I can't tell if N=16 is sufficient (the input data size is N^3, the time complexity is probably O(N^3 log(N)) -- or O(N^6)? I don't know), but because of the fluctuation in runtime because of various reasons, make sure that the run time of the fastest solution on the largest test case is at least a few seconds so it can be reliably measured. \$\endgroup\$ – user202729 Feb 13 at 11:11
  • \$\begingroup\$ @user202729 Thank you for the mentioned point about the fluctuation in runtime. I choose N = 16, 25 and 30 for measuring. If there is any other issue of this challenge, please let me know. \$\endgroup\$ – JimmyHu Feb 15 at 1:44
  • 1
    \$\begingroup\$ there might be several languages with built in for this. // there might be n^3 log n solutions which will be very fast anyway, but (I think) it's okay to fix the test cases later (I assume you're solving it in n^6?) -- but in this case whether the challenge is interesting is another matter. // Otherwise looks good. [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 15 at 3:07


Book cipher

A Book cipher is a very unique method of a encipher. Here's how's it done:

  • You have a book / a document or a article (something full of text, the more pages of text the better).
  • You have a message to convey (a secret, of some sort)
  • You simply-put read trough the text and the secret message (may come from input, or reading it from 2 separate files) - split it into words (so, separate spaces, commas and [dots]) so, ',' , '.' and spaces is the only requirement, how is not really that hugely important and you keep the count of how many words there are in the text, now input the secret message (note, the secret's words must be in the text, so if you secret was "My Secret" then, the words "My" and "Secrets" must both exist in the text.) and output the position of the inputted secret message. (E.g if the word "My" was nearly at the first page, maybe the 20th Word in the text, the program should print out '20'. Same with the word "Secrets", if that maybe were later, (let say the 93th word in the text) then your program should print out '93'.

Note the data type of input and output:

output numbers: Integers.

Input numbers: Integers

( Excluding if the secret actually contains a number, then it does not need to be treated as a int. Can be a plus if it does but is not necessary.)

Mini Example:

document.txt - file that contains text.

Secret: "My Secret"

(in the text, this is the 20th and the 93th word) (Note, this is only a made up secret, it is not from a real file, or a real input) a more better example is below.

Program input:

You enter "My Secret"

Program output:



And, again - you enter those numbers(**Integers**):

20 93

Program outputs:



this is just to show how input and outputs are related to each other.

For reference (if needed) You have a Python3 implementation available at my GitHub page, to see a book cipher in action here: GitHub - Book cipher in Py3

  • Why is this challenge interesting?

I personally think this is a educational (and interesting) challenge ( one might also exercise, because of how simple it might seem to make, but really took myself - literally years to even know how to implement this correctly)

Interesting article to get some background of what Cicada3301 is (not my site) - https://www.clevcode.org/cicada-3301/

Wikipedia: Cicada3301

I created this challenge both to, see other peoples methods of solving this (you are free to use any programming language!) and also - how long it would take others (For me, really I think it took more than 4 years actually - even in Python3. It looks simple but, for me - really not)

  • A motivating fact: There are still so little info (especially on example codes) on the internet(at least by the time writing this challenge) about just, book cipher implementations


I would highly suggest making dedicated functions for this challenge

  • (instead of writing all code in the main() function - but it's totally fine to have it all in main!)


Here's how the program should read, process, and output the result:

First, take the text (the book/document, with the lots of text, (not the secret)) and:

Note: The text can either be entered or read from a file. You choose this.

  1. read it (From a file, or enter it as input)
  2. split it into words (by, I.e detecting '.', spaces(' '), and commas ',') (Or if you already have split the input & are ready to move on to step 3, do that :) )
  3. count the number of words.

Repeat this process with the Secret input part.

So, the input secret part should be:

  • read it (from, again a file or enter it as input)
  • split it (i.e if your input was "My Secret" - split it into words like so: "My" "Secret")

My Python3 implementation only separate spaces.

The Key sequence - this is the nth words your text contains, e.g the 93th word in above example "Secrets".

The winner will be chosen by how short the code is. (So, the shortest code = win)

Example Input and Output

example file used 'document1.txt'in this section is available at the GitHub page. as well as the Python3 file used in the example below.

The output of your program should match the output of the Python3 program.


python3 bookcipher.py

input text: a house with a Bob inside


you entered these words: ['a', 'house', 'with', 'a', 'Bob', 'inside']







Input again: (decrypting)

input key-sequence sep. With spaces: 2 3 5 2 0 30







  • \$\begingroup\$ I am new, this is the first challenge, but feel free to edit/ask for clarification/ anything! Thanks, I hope the guys at the orig. Post led me to the right place; if this is not the correct place(or way!) to add proposal; please tell me how I would go around of doing that! //Have a Corona Free week! \$\endgroup\$ – William Martens Feb 17 at 11:34
  • 3
    \$\begingroup\$ You're in the right place. Well done! \$\endgroup\$ – Adám Feb 17 at 12:14
  • \$\begingroup\$ @Adam thanks; I am still a bit new here, but should I wait now - or what specifically should I do ? \$\endgroup\$ – William Martens Feb 17 at 17:56
  • 1
    \$\begingroup\$ Welcome to Code Golf, this is a pretty good challenge! I would suggest being a bit more liberal with the input format (allowing solutions to read from STDIN or take the "book" as a function argument instead of reading from a file). I would also suggest splitting this up into two challenges - encrypting and decrypting - but that's up to you. As for what you should do now - just wait a few days so you can get feedback and modify your question, and then you can post on the main site. \$\endgroup\$ – user Feb 17 at 19:42
  • 1
    \$\begingroup\$ If your proposal goes unnoticed for a really long time, you might also want to ask others to review it in the site's chat room. \$\endgroup\$ – user Feb 17 at 19:50
  • \$\begingroup\$ I generally recommend leaving challenges here for minimum a week as people ave various schedules, e.g. only visiting on weekends or only on (certain) weekdays. \$\endgroup\$ – Adám Feb 17 at 20:11
  • \$\begingroup\$ Just to make sure... did you address all the problems raised in the comments under the main site post? \$\endgroup\$ – user202729 Feb 18 at 13:02
  • \$\begingroup\$ @user202729 Oh, maybe not - fixed now though, thanks for pointing it out, and okay with the chat - got it :) \$\endgroup\$ – William Martens Feb 18 at 19:24
  • 1
    \$\begingroup\$ (note that I'm not the same user as [user]. Even the chat highlight is wrong) \$\endgroup\$ – user202729 Feb 19 at 9:09
  • 2
    \$\begingroup\$ The text could be more concise and flow more logically. Right now I see five sections: (1) description of the cipher, (2) example (3) personal background, (4) requirements for the code, (5) more examples. I think you should aim to merge (1) and (4) where possible (there's some redundancy there), and likewise (2) and (5). (3) is not really relevant and should (I think) be deleted. \$\endgroup\$ – Dingus Feb 20 at 1:15
  • 2
    \$\begingroup\$ I also suggest formatting the examples using code blocks instead of block quotes. \$\endgroup\$ – Dingus Feb 20 at 1:15

Subbasis. Generate. Discrete?


Given finitely many finite sets, interpret them as a subbasis to generate a space, and decide whether the resulting topology is discrete.

Introduction to Topology

Given a set \$X\$, a topology \$\mathcal{T}\$ over \$X\$ is a subset of the power set \$\mathcal{P}(X)\$ such that:

  • \$\emptyset, X \in \mathcal{T}\$.

  • For all \$\space \mathcal{U} \subset \mathcal{T}\$, \$\bigcup\mathcal{U} \in \mathcal{T}\$.

  • For all \$Y_1, Y_2 \in \mathcal{T}\$, \$Y_1 \cap Y_2 \in \mathcal{T}\$.

Members of a topology are said to be open. So the rules above in plaintext are:

  • The empty set and \$X\$ itself are open.

  • The union of arbitrarily many open sets is open.

  • The intersection of finitely many open sets is open.

Endowed with a topology, \$X\$ is said to be a (topological) space.

If \$\mathcal{T} = \mathcal{P}(X)\$, \$\mathcal{T}\$ is said to be discrete.

Basis and Subbasis

A subset \$\mathcal{B}\$ of the power set \$\mathcal{P}(X)\$ is said to be a basis (pl. bases) of a set \$X\$ if:

  • For all \$x \in X\$, there exists \$B \in \mathcal{B}\$ such that \$x \in B\$.

  • For all \$B_1, B_2 \in \mathcal{B}\$, there exists \$C \in \mathcal{B}\$ such that \$C \subset B_1 \cap B_2\$.

We take every subset \$\mathcal{U} \subset \mathcal{B}\$ and declare \$\bigcup\mathcal{U}\$ to be open to generate a topology \$\mathcal{T}\$. Note that \$\mathcal{B} \subset \mathcal{T}\$ always holds.

If we omit the second requirement, we have a subbasis of \$X\$. A subbasis generates a topology by also declaring the intersection of finitely many members to be open.

Input and Output

Given a set of finitely many finite sets \$\mathcal{S}\$, \$X\$ shall be implicitly defined as \$\bigcup\mathcal{S}\$. Note that by this, the first requirement for bases always holds.

The input/output format is flexible. In every case, inputs that don't fit in your input format fall in don't care situation.



  • \$\emptyset\$ (Generates \$X = \emptyset\$ and \$\mathcal{T} = \{\emptyset\}\$)

  • \$\{\emptyset\}\$ (Ditto)

  • \$\{\{0\}\}\$ (Generates \$X = \{0\}\$ and \$\mathcal{T} = \{\emptyset, \{0\}\}\$)

  • \$\{\emptyset,\{0\}\}\$ (Ditto)

  • \$\{\{1\}\}\$ (Generates \$X = \{1\}\$ and \$\mathcal{T} = \{\emptyset, \{1\}\}\$)

  • \$\{\{0\},\{1\}\}\$ (Generates \$X = \{0,1\}\$ and \$\mathcal{T} = \{\emptyset, \{0\},\{1\},\{0,1\}\}\$)

  • \$\{\{0\},\{1\},\{0,1\}\}\$ (Ditto)

  • \$\{\{0\},\{1\},\{2\}\}\$ (Generates \$X = \{0,1,2\}\$ and \$\mathcal{T} = \{\emptyset, \{0\},\{1\},\{2\},\{0,1\},\{0,2\},\{1,2\},\{0,1,2\}\}\$)

  • \$\{\{0,1\},\{0,2\},\{1,2\}\}\$ (Ditto)


  • \$\{\{0,1\}\}\$ (Generates \$X = \{0,1\}\$ and \$\mathcal{T} = \{\emptyset,\{0,1\}\}\$)

  • \$\{\{0,1\},\{1\}\}\$ (Generates \$X = \{0,1\}\$ and \$\mathcal{T} = \{\emptyset,\{1\},\{0,1\}\}\$)

  • \$\{\{0\},\{1,2\}\}\$ (Generates \$X = \{0,1,2\}\$ and \$\mathcal{T} = \{\emptyset, \{0\},\{1,2\},\{0,1,2\}\}\$)

  • \$\{\{0,1\},\{1\},\{2\}\}\$ (Generates \$X = \{0,1,2\}\$ and \$\mathcal{T} = \{\emptyset, \{1\},\{2\},\{0,1\},\{1,2\},\{0,1,2\}\}\$)

  • 2
    \$\begingroup\$ This looks math-heavy. To get a better chance of having it reviewed (because people, including me, tend to skip long sandbox posts) you can ask in chat and leave it in for a while. \$\endgroup\$ – user202729 Feb 18 at 3:28
  • \$\begingroup\$ So, if I'm understanding correctly, defining U(S) as the union of all members of S and P(S) as the powerset of S, you are asking whether {U(x) for x in P(X)} == P(U(X))? In this case a more to the point description like this one could be useful... You can leave the math background in (maybe shorten it a little bit) for people interested, but it shouldn't be the only description for the challenge. \$\endgroup\$ – Leo Feb 19 at 1:08
  • \$\begingroup\$ @Leo Figuring out a simple algorithm to solve the challenge can be part of it. (although after the first answer is posted people can just use the same algorithm, however nobody is forced to look at the answers; besides the "original" answer tend to be upvoted proportionally anyway) \$\endgroup\$ – user202729 Feb 19 at 9:13
  • 1
    \$\begingroup\$ @Leo (your notation is confusing because you use X for the input while OP uses it for U(input), but it looks correct) [please review other sandbox posts] \$\endgroup\$ – user202729 Feb 19 at 9:31
  • \$\begingroup\$ @user202729 I agree that figuring out the algorithm is part of the challenge, but having to understand several paragraph of relatively advanced math concepts is a bit detrimental to the challenge itself, in my opinion. Moreover, mine is not necessarily the best algorithm, just a simpler description of the requirements. You are right about the different notation, sorry for the ambiguity \$\endgroup\$ – Leo Feb 19 at 12:37

Decode an 8086 MOD R/M

I think this might be fun. Or, it might be torture, idk. 😛 If this is popular, I might add a sequel for the significantly more complex 32-bit encoding 😏

Time for a mini objdump.

An 8086 MOD R/M field is laid out like so:

mm   rrr  rrm | (iiiiiiii) | (iiiiiiii)
76   543  210 |  76543210  |  76543210

REG is a register. Quite unintuitively, the register names are not in alphabetical order.

Note that you can safely assume a word register, not a half byte register, and that the destination is a register.

REG |  0 |  1 |  2 |  3 |  4 |  5 |  6 |  7 |
Name| AX | CX | DX | BX | SP | BP | SI | DI |

MOD determines the length and format of the instruction.

 0  | [MEM] or [ADDR]
 1  | [MEM+/-disp8] (signed 8-bit immediate)
 2  | [MEM+/-disp16] (signed 16-bit little endian immediate)
 3  | REG

MEM is parsed as so:

MEM  |    0    |    1    |    2    |    3    |   4  |   5  |   6   |   7  |
Name | [BX+SI] | [BX+DI] | [BP+SI] | [BP+DI] | [SI] | [DI] | [BP]* | [BX] |
*when MOD==0, [BP] is replaced by an absolute 16-bit address.

Just [BP] is encoded as [BP+0].

I am going to represent MOD R/M as octal, and addresses/displacements as hex. It really bugs me how few people write it this way, as it makes much more sense.

So, for example:

MOD  r  r/m
 3   0    0
reg  |    |
    AX,  AX

 0   2    0
mem  |    |

 1   3   7 , 23
M+D8 |   |   |
    BX, [BX+0x23]

 2   2   1 , BC 6A
M+D16|   |    | /


  • You may take your input as a packed integer, byte array, string in any mix of bases, or whatever. I'm not picky. I personally wrote them as mixed hex and octal.
  • You will always get 3 bytes, however, in true objdump spirit, those extra bytes will be random. The first byte is all you need to determine the length.
  • Not all cases will be the most efficient encoding.
  • In the output:
    • It may be returned as a single string, or printed.
    • It is case insensitive
    • It can have excess spaces or tabs, but it must be on one line.
    • It can have an optional trailing newline
    • Displacements and addresses can be in any base, however, do note that displacements are signed two's complement and will be subtracted if negative. So, for 100 FF, AX,[BX+SI+0xFF] is wrong.
    • Leading zeroes and displacements of zero are fine.

Test cases (irrelevant bytes are in italics):

300 73 A2 -> AX,AX
312 01 82 -> CX,DX
337 3E 1C -> BX,DI
020 24 AF -> DX,[BX+SI]
137 23 6B -> BX,[BX+0x23]
066 34 21 -> SI,[0x1234]
166 00 10 -> SI,[BP+0x00]
221 BC 6A -> DX,[BX+DI+0x6ABC]
124 FF EF -> CX,[SI-0x01]
224 FF FF -> CX,[SI-0x0001]
240 00 00 -> SP,[BX+SI+0x0000]
  • \$\begingroup\$ How is "300" 3 bytes? It looks like 3 octal digits. \$\endgroup\$ – user202729 Feb 20 at 9:43
  • \$\begingroup\$ Is that better? \$\endgroup\$ – EasyasPi Feb 20 at 10:43
  • \$\begingroup\$ What is R/M? Why is MEM 3 bits long? \$\endgroup\$ – user202729 Feb 20 at 11:25
  • 1
    \$\begingroup\$ Since you list out the bytes as bits (appropriately), it would probably be clearer if you also included the binary values in the tables for reg/mod/mem. Using the octal/hex format is probably also going to confuse people - I think labeling your examples with what base is being used may help. \$\endgroup\$ – FryAmTheEggman Feb 20 at 18:19

I ain't no Fortunate Prime

The primorial \$p_n\#\$ is the product of the first \$n\$ primes. The sequence begins \$2, 6, 30, 210, 2310\$.

A Fortunate number, \$F_n\$, is the smallest integer \$m > 1\$ such that \$p_n\# + m\$ is prime. For example \$F_7 = 19\$ as:

$$p_7\# = 2\times3\times5\times7\times11\times13\times17 = 510510$$

Adding each number between \$2\$ and \$18\$ to \$510510\$ all yield composite numbers. However, \$510510 + 19 = 510529\$ which is prime.

Let us generalise this to integer sequences beyond primes however. Let \$\Pi(S,n)\$ represent the product of the first \$n\$ elements of some infinite set \$S ⊆ \mathbb N\$. In this case, \$p_n\# = \Pi(\mathbb P,n)\$. We can then define a new type of numbers, generalised Fortunate numbers, \$F(S,n)\$ as the smallest integer \$m > 1\$ such that \$\Pi(S,n) + m \in S\$.

You are to take an integer \$n\$ and an infinite set of positive integers \$S\$ and output \$F(S,n)\$.

As \$S\$ will be a set, you don't need to handle well-known sequences with duplicate elements (e.g. Fibonacci).

You may take input in any reasonable representation of an infinite set. That includes, but is not limited to:

  • An infinite list, if your language is capable of handling those (e.g. Haskell)
  • A black box function which returns the next element of the series each time it is queried
  • A black box function which returns two distinct values to indict whether it's argument is a member of that sequence or not

If you have another method you are considering using, please ask in the comments about it's validity.

This is so the shortest code in bytes wins


I'll walk through a couple of examples, then present a list of test cases below.

\$n = 1, S = \{2, 1, 3, 4, 7, ...\}\$

Here, \$S\$ is the Lucas numbers. First, we get \$\Pi(S, 1) = 2\$. Next, we begin at \$m = 2\$ and start calculating \$Pi(S, 1) + m = 2 + m\$. Immediately, \$2 + m = 4\$ which is a member of \$S\$. Therefore, \$m = 2\$.

\$n = 5, S = \{1, 2, 6, 24, 120, ...\}\$

Here, \$S\$ is the factorials from 1. First, \$\Pi(S, 5) = 1\times2\times6\times24\times120 = 34560\$. We then find the next factorial greater than \$34560\$, which is \$8! = 40320\$ and subtract the two to get \$m = 40320 - 34560 = 5760\$.

\$n = 3, S = \{6, 28, 496, 8128, ...\}\$

Here, \$S\$ is the set of perfect numbers. First, \$\Pi(S, 3) = 6\times28\times496 = 83328\$. The next perfect number is \$33550336\$, so \$m = 33550336 - 83328 = 33467008\$

Test cases

F(S, n)

{2,3,5,7,11,...} (prime numbers)

{1,3,6,10,15,...} (triangular numbers)

Any n
{1,2,3,4,...} (positive integers)

{1,4,9,16,25,...} (squares)

{4,6,9,10,14,...} (semiprimes)


  • Is this clear enough?
    • More specifically, is the input format clear enough? Does it make sense? Any suggestions to improve it?
  • Is this a duplicate? Preliminary searches suggest no, but does it ring any bells?
  • Tags are , and . Any others?
  • Any further feedback?
  • \$\begingroup\$ So \$ m>1 \$ is \$ m\ge 2 \$? what a long statement. \$\endgroup\$ – user202729 yesterday
  • \$\begingroup\$ A set doesn't have an order. Did you mean "the product of the \$ n \$ smallest elements in the set"?(which is well-defined because the natural numbers are well-ordered) \$\endgroup\$ – user202729 yesterday
  • \$\begingroup\$ Okay, \$ S \$ is not strictly increasing. But (1) it should be called a "sequence" instead (not a set or a series)(2) that makes the problem undecidable because the element of interest might be arbitrarily far in the sequence. \$\endgroup\$ – user202729 yesterday

Create a QR quine

(a "qruine" if you will)

Design a QR code that legibly spells with its pixels (or the space between them) the text that it scans to.

For example, this QR code scans to the letter A, and also spells out A in white:

enter image description here

It does not matter what the scanned and displayed text is; it does not have to be coherent or readable.

The winner is the person with the longest text.

  • \$\begingroup\$ This is a really cool idea, but I'm not quite sure what you mean. (pulls out qr code scanner) Oh, never mind, it really does just scan as 'A'. This surprises me for how big it is. \$\endgroup\$ – Beefster 18 hours ago
  • \$\begingroup\$ Does this count as code-golf? \$\endgroup\$ – A username 12 hours ago

Posted link

New contributor
Alex bries is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.
  • 1
    \$\begingroup\$ The test cases are rather confusing. Are they missing the expected output? In addition, your statement about "dots" is rather odd - do you mean all non-letter characters should be ignored, or just punctuation, or just periods? You should definitely also specify what characters can appear in the input. \$\endgroup\$ – FryAmTheEggman 2 days ago
  • 1
    \$\begingroup\$ I think I get it, but it needs to be explained better. For each value of n less than the length of the word, the letters that are n slots from the beginning and n slots from the end of the word should both be made uppercase if either of them is upper case. \$\endgroup\$ – Xcali 2 days ago
  • 1
    \$\begingroup\$ Perhaps replacing "slot" by "position"/"character" is easier (perhaps it's a perl term? I don't know), but otherwise clear enough. [please review other sandbox posts] \$\endgroup\$ – user202729 yesterday

What is the next repdigit?

A repdigit \$r\$ is a number containing repeated instances of the same digit \$d\$. It can be represented as:

\$r = d \cdot \frac{10^i-1}{9}\$, \$i \ge 0\$, \$1 \le d \le 9 \$


Given two positive integers \$n,j \in \mathbb{N} \$, where \$j \le n\$. Determinine the next repdigit \$r = k \cdot n + j\$ , where \$k \in \mathbb{N}\$, such that there is no other repdigit \$r'\$, with \$\exists{r'}: n + j \le r' < r\$.

You can take the two integers and give the resulting repdigit in any convenient way.

This is , so the shortest code in bytes wins.


\$n = 57, j = 51\$; we get the next possible repdigit by using \$k=3\$. The equation would be: \$ r = 3 \cdot 57 + 51 = 222\$

Test cases

(n,j)    -> r
(1,1)    -> 2
(2,1)    -> 3
(2,2)    -> 4
(3,2)    -> 5
(14,8)   -> 22
(18,18)  -> 666
(19,8)   -> 3333
(22,6)   -> 666
(46,6)   -> 88888888
(46,27)  -> 1111111
(57,33)  -> 888
(57,51)  -> 222
(114,29) -> 77777
(129,17) -> 11111
(141,93) -> 3333333

Used python 3 code for calculating the repdigits:

I use praosylen's answer to check if a number is a repdigit.

def next_repdigit(n,j):
  k = 1
    r = k * n + j
    s = str(r)
    if(len(set(s))<2): # check if repdigit
      return r

Try it online!

To avoid misunderstandings: \$0 \notin \mathbb{N}\$

New contributor
Michael Chatiskatzi is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.
  • \$\begingroup\$ Related, with \$ j = 0 \$ and \$ n = 1 \$. Right now I would be inclined to say they are dupes, since modifying the loop seems like it would usually be the best response. However, there are a few answers in the other question that I think won't work here without more significant changes. \$\endgroup\$ – FryAmTheEggman yesterday

Output function from one to another

I tried to post this twice and I gained negative feedback, so I will put what I have in mind here if anyone is interested.

Get a certain output function from one programming language and transfer to another. You'll be recreating an output function that came from a different programming language.


  1. It should function the same way as the original function. All things that function can do should be applied to the recreated one. For example, Python's print() has certain keywords like end.
  2. Syntax doesn't matter. Example, if you can't use the << for cout, don't use it. Use what's available.
  3. The function should be able to output the same errors like the original. Replicate the same errors from the original function. If impossible, leave it out.
New contributor
Mark Giraffe is a new contributor to this site. Take care in asking for clarification, commenting, and answering. Check out our Code of Conduct.
  • 1
    \$\begingroup\$ "Get a certain output function from one programming language and transfer to another." To clarify, is the challenge to write source code which works in two different languages and does the same thing? What's the winning condition because this sounds very trivial. For example, print does the same thing in many languages. \$\endgroup\$ – 79037662 20 hours ago
  • 1
    \$\begingroup\$ Actually that doesn't mesh with "syntax doesn't matter". The point of this challenge is completely unclear, could you please clarify it? \$\endgroup\$ – 79037662 20 hours ago

Write a Deadfish~ writer & golfer

Deadfish~ is a language with a couple of basic commands, and an accumulator which starts at 0:

i - increment accumulator
d - decrement accumulator
s - square accumulator
{...} - repeat the statement inside 10 times. 
(...) - if accumulator = 0, skip statement
o - output accumulator as number
c - output result as number
w - output "Hello, world!"
h - halt

Additionally, if at any point the accumulator is -1 or 256, it is reset to 0.

Your challenge is to write a program that, when given a string containing valid ASCII only, outputs a valid Deadfish~ program that outputs the given string.


Your score is the size (in bytes) of your program plus the size of the program generated by plugging The quick brown fox jumps over the lazy dog into your program. This can't be hard-coded. E.g. if your program is 200 bytes and it outputs a 300-byte program for The quick brown fox jumps over the lazy dog, your score is 500.

Lowest score wins.


Greetings, world!

A man, a plan, a canal, panama!



Buffalo buffalo Buffalo buffalo buffalo buffalo Buffalo buffalo

For each of these, your program should output a valid Deadfish~ program that outputs the given string.

  • 1
    \$\begingroup\$ This isn't very different from bfcat, and I'm not sure it's more interesting. \$\endgroup\$ – Wezl 2 hours ago

Sandbox Questions:

  • Is this unambiguous?
  • Any other tags?

Filetype colors

For anyone who has spent a headache trying to understand dir_colors with GNU ls, this may be the post for you!

We're going to ignore parsing LS_COLORS, or matching globs, and instead we'll focus solely on the interesting part: taking the struct stat.st_mode and getting the associated two-character keys which determine how it will be colored. (We're only focusing on information that can be gathered from st_mode, so don't worry about ca, no, or mh)

Input: An stat.st_mode, in any convenient integer format that is at least 16-bits.

Output The corresponding ordered list of two-character codes for an inode with that st_mode, in fallback order. Since all codes are two characters, the concatenated string (e.g.: "twowstdi") is also acceptable, as it is still unambiguous. Additionally, printing the codes in reverse order (di st ow tw) is also fine, as long as it is consistent for all inputs.


  • Input: 17389 (in octal: 0041755)
  • Output: ["st", "di"] (the sticky bit 0001000 is set, and it is an directory 0040000.)

Test cases (these are in octal, and a symbolic equivalent for your convenience):

 Input    Symbolic   List of codes | Note:
-------  ----------  ------------- | -----
0140000  s---------   so           | socket
0147777  srwsrwsrwt   so           | suid/sgid/sticky/other-writeable does not apply
0120000  l---------   ln           | symbolic link (you MAY choose to output "or" instead)
0127777  lrwsrwsrwt   ln           |
0060000  b---------   bd           | block device
0067777  brwsrwsrwt   bd           |
0020000  c---------   cd           | character device
0027777  crwsrwsrwt   cd           |
0010000  p---------   pi           | pipe
0017777  prwsrwsrwt   pi           |

0040755  drwxr-xr-x   di           | directory
0041755  drwxrwxr-t   st di        | sticky bit set
0040002  d-------w-   ow di        | other-writable
0041777  drwxrwxrwt   tw ow st di  | sticky + other-writeable
0046000  d--S--S---   di           | suid/sgid only apply to normal files

0100000  ----------   fi           | normal file
0100000  ---------T   fi           | sticky bit only applies to directories
0100100  ---x------   ex fi        | executable file
0100010  ------x---   ex fi        |
0100001  ---------x   ex fi        |
0104000  ---S------   su fi        | suid
0106777  -rwsrwsrwx   su sg ex fi  | suid has priority over sgid and executable
0102000  ------S---   sg fi        | sgid
0102777  -rwxrwsrwx   sg ex fi     | sgid has priority over executable

0110000  ?---------  <undefined>   | Unknown filetype

No support necessary, but brownie points for:

0150000  D---------   do  | door
  • \$\begingroup\$ What format is the input is? Octal? // this is definitely not common knowledge. \$\endgroup\$ – user202729 yesterday
  • \$\begingroup\$ The input is an integer, I wrote it in octal in the table because that's a typical way permissions are shown. I'll add a note in the table. \$\endgroup\$ – GammaFunction 21 hours ago
  • \$\begingroup\$ @user202729 Do you think that's clear enough? \$\endgroup\$ – GammaFunction 14 mins ago
  • \$\begingroup\$ Added a link to the inode(7) manpage, and an LS_COLORS table. \$\endgroup\$ – GammaFunction 5 mins ago

The only differences that matter

Cops' task

Write two programs (or functions) A and B in the same version of the same programming language. They also should be called in the same way, meaning you can't write one program and one function. Each should accept an integer n and output the term n of a different integer sequence on OEIS.

You should reveal a substring of each of A and B. Call them PA and PB. If one instance of PA is replaced by PB from A, it should become B. That means every byte except the reveal part in A and B should be exactly the same. You also reveal the lengths of A and B, and the two OEIS sequences. You don't reveal the programming language you use.

Your answer is cracked if a robber finds two programs A' and B' that also print the elements in the two integer sequences respectively, where A' is no longer than A, and A' with one instance of PA replaced by PB is also B'. They don't have to be the same with your original A and B. And they don't have to be in the same programming language as yours, as long as they are in the same programming language themselves.

If your answer isn't cracked 7 days after you post the answer, you can reveal your language and the original A and B and mark the answer safe, and it will be immune to future crack. Your answer can still be cracked if you don't do it.

Your score is max(len(A)+len(PA)*5, len(B)+len(PB)*5). The safe answer posted before a certain date with the minimum score wins.

For example, if your two programs are The first program and The second program, you can reveal first and second. Your score is 18 + 6*5 = 48. And a robber can crack your answer by <<first>> <<second>> if they work. But you can also reveal first pro and second pro to prevent this crack.

Please post your answer using this template:

# <length of PA> / <length of A> bytes, <length of PB> / <length of B> bytes, score <score>, <open / safe / cracked>

Part of program A (outputing [<OEIS number>](<OEIS link>)):

    <code of PA>

Part of program B (outputing [<OEIS number>](<OEIS link>)):

    <code of PB>

<any other explanations>

Robbers' task

(To do.)

  • \$\begingroup\$ Do robbers have to produce the same program, or any program? \$\endgroup\$ – Nathan Merrill Oct 28 '16 at 14:47
  • \$\begingroup\$ There are two tricky edge cases around character encodings which the question needs to address. 1. It talks about substrings of A and B, saying that every byte except the revealed ones must be the same. If A and B differ in one Unicode codepoint, such that in UTF-8 they differ in only one byte but it's part of a three-byte sequence, can I post just that one byte as PA/PB or must I post the three-byte sequence? (I.e. are the substrings operating on the bytes or on the codepoints?) \$\endgroup\$ – Peter Taylor Oct 28 '16 at 20:57
  • \$\begingroup\$ 2. If my program is in APL using an 8-bit encoding, do robbers answering in a language other than APL have to have the same bytes in the part of their file corresponding to PA/PB or the same Unicode codepoints? \$\endgroup\$ – Peter Taylor Oct 28 '16 at 20:57
  • \$\begingroup\$ @NathanMerrill Any program. \$\endgroup\$ – jimmy23013 Oct 28 '16 at 21:05
  • \$\begingroup\$ @PeterTaylor I'm considering requiring every program to be in printable ASCII (and tabs and newlines), as some special characters effectively banned many languages. But I'm not sure about newlines, which have the \r problem. \$\endgroup\$ – jimmy23013 Oct 28 '16 at 21:09
  • \$\begingroup\$ Maybe I'll just say \r\n is counted one byte in this challenge, and is interchangeable with \n. But the programs in one submission must use only \n or only \r\n. \$\endgroup\$ – jimmy23013 Oct 28 '16 at 21:13
  • \$\begingroup\$ An example would make this easier to understand, \$\endgroup\$ – xnor Oct 29 '16 at 6:08
  • 2
    \$\begingroup\$ I'm skeptical about having the programming language be a free variable. If a cop writes an answer using a verbose language, a robber can comment out all the visible parts and stuff a terse language answer into the cracks. \$\endgroup\$ – feersum Oct 29 '16 at 11:24
  • \$\begingroup\$ @feersum But that's the whole point of all the requirements. If you comment out all the visible parts, both your programs usually should output the same thing. But I realized it's easy to have some workarounds in languages such as Befunge. I may try to find a way to ban them, or just abandon this post. \$\endgroup\$ – jimmy23013 Oct 31 '16 at 0:59

Translation Polyglot

Your task is to write a program which runs in two distinct programming languages to translate text. Input should be translated between each language i.e. running your code in Code Language A translates from language 1 to 2, while running your code in Code Language B translates from language 2 to 1.


  • Code Languages must be distinct, two versions of the same language are disallowed
  • Your code may be a full program or function
  • Your code must take one string (or nearest equivalent) as input. Input may be user input, function arguments, or other reasonable form
  • Output may be a function return, output to STDOUT, or other reasonable form. I do not care about trailing newlines or spaces
  • Your code may translate from/to any language on the official language list on Wikipedia. List the languages in your answer
  • To accomplish your goal, you may use prebuilt language tanslation dictionaries such as the ones found here.
  • If you read your dictionary as an external file, only the code to read in the file (f = open("dictionary.txt", 'r') in Python) counts towards your byte count. If your dictionary is hardcoded in, only count the bytes required to make it syntatically valid code (s="word1_in_english word1_in_french ..." would be 4 (s="")). Essentially, do not include the dictionary as part of your submissions byte count.
  • The dictionary you use must have been created before this post (including sandbox time). You may not modifiy the dictionary in any way.
  • Any built-in translation tools are disallowed. Built-in dictionaries are ok, but whatever code used to import them into your code must be included in the byte count

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

  • \$\begingroup\$ wait... Are you actually asking for machine translation? Seems very difficult. Haven't you ever seen bad translator? If it actually is machine translation, this won't work, because of the different resolution of the languages (like converting a jpg to a png and expecting the same quality back) \$\endgroup\$ – Destructible Lemon Nov 1 '16 at 4:11
  • \$\begingroup\$ It's really just value lookup. I'm not asking people to to make their own dictionary, just use a pre-built and accept whatever it translates \$\endgroup\$ – wnnmaw Nov 1 '16 at 13:45
  • \$\begingroup\$ But that doesn't really satisfy Language A produces output O from input I, while running in Language B produces output I from input O. \$\endgroup\$ – Destructible Lemon Nov 1 '16 at 22:04
  • \$\begingroup\$ Ah, now I see the source of confusion. Updated text to require basic translation, not symmetric translation \$\endgroup\$ – wnnmaw Nov 2 '16 at 11:53
  • \$\begingroup\$ Also I don't think translation is objective enough for code golf... \$\endgroup\$ – Destructible Lemon Nov 3 '16 at 5:30

What in the heck just happened?

I want you to write a program that will bleep out the H-word, regardless of where it occurs, whether it is inside of another word or a stand-alone word, whether capitalized or not.

Input and Output

The inputs and outputs of your program may be any of the following: an array of characters, a string, or any other standard data structure which does the job. However, the output must match the case of the input.


In the format of Input: Output
A Shell gas station : A Sheck gas station
Hell is a very bad place to be. : Heck is a very bad place to be.
Ella fell and Nelly dug a well. : Ella fell and Nelly dug a well.
Chellsea Thell bought shells. : Checksea Theck bought shecks.

Standard loopholes apply, and the entry submitted by [insert date here] with the lowest number of bytes as defined by the Meta will win.

  • 1
    \$\begingroup\$ I can't say for sure, as I don't have an exact reference, but I'm pretty sure a simple find and replace challenge has been done before. \$\endgroup\$ – ATaco Feb 13 '17 at 0:19
  • 1
    \$\begingroup\$ "Hell" and "heck" are both "H-words", so you need to be clearer. Also, I feel like this is a duplicate. Though these are milder swear words, I think someone did one with swear words in general and it got deleted. If you're going to make a find/replace challenge, it's simple enough to make it about something else. \$\endgroup\$ – mbomb007 Feb 13 '17 at 0:19
  • \$\begingroup\$ Ah, I see. So, are you saying I should change what's being replaced or what my idea is? \$\endgroup\$ – Drew Christensen Feb 14 '17 at 0:50

Google Logo in Conway's Game of Life

Conway's Game of Life base challenges are always fun so here is a new one.

This is Google's Logo (if you have not somehow seen it): Google Logo

The font is called Product Sans. Your job is to replicate this logo (no color of course) in 800x439px just like the image (just the letters).

Have fun! This is a popularity contest so the most votes wins. :D Good luck. Of course, this may not be possible but, you never know until you try.

Usual rules apply.

Inspired by this.

  • 6
    \$\begingroup\$ "looks like" isn't a tight enough specification for a challenge. \$\endgroup\$ – user45941 May 29 '17 at 21:20
  • 1
    \$\begingroup\$ Also consider some method besides first-past-the-post, that winning criteria doesn't really work well with this site. \$\endgroup\$ – FryAmTheEggman May 30 '17 at 0:22
  • 1
    \$\begingroup\$ So the answer could replicate it at the 0th generation? \$\endgroup\$ – Peter Taylor May 30 '17 at 10:48
  • \$\begingroup\$ @PeterTaylor Good point \$\endgroup\$ – arodebaugh May 30 '17 at 13:14
  • \$\begingroup\$ @FryAmTheEggman Popularity contest? \$\endgroup\$ – arodebaugh May 30 '17 at 13:14
  • \$\begingroup\$ @Mego Also good point \$\endgroup\$ – arodebaugh May 30 '17 at 13:15
  • \$\begingroup\$ OK I updated stuff maybe it will make this challenge better \$\endgroup\$ – arodebaugh May 30 '17 at 13:16
  • 3
    \$\begingroup\$ 1. I don't see how the change you've made addresses my previous point. 2. Pop-con is barely any better than fastest-gun-in-the-west. 3. It's possible to test whether this is possible or not (I highly doubt it) by running the CA backwards. \$\endgroup\$ – Peter Taylor May 30 '17 at 16:09

The 2017 Loader contest

Here's a thing: Let's do the bignum bakeoff again.

Because why not.

What to do

Write a program in less than 256 characters that outputs the biggest number you can.
Yep, that's it. Biggest return value wins.

We'll run the program on a VM with infinite memory. (How do we do this?)


  • 256 chars max, excluding whitespace
  • Different leagues for each language
  • Output however you want
    • No explicitly printing numbers until your loop runs out. Print the number you generate directly. {1}
  • Program must terminate
  • No implementation-dependent shenanigans.
  • Implementation-independent shenanigans is encouraged.
  • ints are infinite.
  • Program must return the same number every time
  • Submission must include the approximate return value in any suitable googological notation.
  • Whitespace is space, tab, newline, formfeed, and return
    • BrainF***: Whitespace is all non-[]+-<> characters

{1} Allowed ways to return: printf("%d", num); return num;, etc.
Banned ways to return: for(;num>0;num--)printf("99999");, etc.

This is not a dupe of...

This because you can put any characters you want, not just non-digits; because we're hard-limiting the characters.

Suggested rules

  • No floats: float double long double, etc
  • No strings or chars
  • No bitfeilds
  • No looking at Command-line args

Next year's contest will be named after this year's winner, for no particular reason.



  • How do you even test these programs?
  • What other rules should we have?
  • \$\begingroup\$ You don't actually explain the rules of the challenge, we would have to go to that link to find out what we are supposed to do. Aside from that, I think this has a lot of problems with your typing restrictions if these are not limited to C, but limiting it to C wouldn't really fit the spirit of the site. I think you may want to rethink how you want to approach this question. \$\endgroup\$ – FryAmTheEggman May 29 '17 at 16:43
  • \$\begingroup\$ @FryAmTheEggman "Typing restrictions"? (Added proper instructions) \$\endgroup\$ – SIGSTACKFAULT May 29 '17 at 16:45
  • \$\begingroup\$ Your post doesn't describe how people win. Is it by the largest possible number? Anyway, the problems are things like not counting whitespace, which can easily result in degenerate answers, as well as things like I/O streams and whatnot. All of your extra rules seem entirely based around C with no regard for other languages, which will not go well. \$\endgroup\$ – FryAmTheEggman May 29 '17 at 16:48
  • 4
    \$\begingroup\$ In answer to "Because why not": because it will be closed as a dupe. \$\endgroup\$ – Peter Taylor May 29 '17 at 17:59
  • \$\begingroup\$ Here's a couple of rules I would consider. 1. Program must generate the same result every time (e.g. not based on timer, probability, or the like). 2. Submissions should include, if not the exact resulting number, at least a best estimate, in scientific notation if need be. \$\endgroup\$ – Computronium May 30 '17 at 18:32
  • \$\begingroup\$ Scientific notation? People will post answers that far, far exceed that. In fact, Mathematica, 22: Fold[Power,2~Range~9999] It's 2^3^4^...^9999. That's not being represented anytime soon. \$\endgroup\$ – CalculatorFeline May 31 '17 at 3:31
  • 1
    \$\begingroup\$ This is a duplicate, and is also going to come down a lot to whether or not you allow programs that exceed the computational capacity of any existing computer. (If you require programs to work on a physical computer, the best they can possibly do is to use the entirety of memory as a counter and print out 9s over and over again. If you don't, the answers can easily be large enough that you need to use notation invented specifically for describing the number, because all other notations are not enough.) \$\endgroup\$ – user62131 May 31 '17 at 22:40
  • \$\begingroup\$ If your code can simulate a Turing machine, it becomes hard to judge who the winner is, and whether an answer is valid at all. \$\endgroup\$ – anatolyg Jun 1 '17 at 20:35
  • \$\begingroup\$ Re your latest edit: you're wrong. The question it's a dupe of also has a hard limit to the number of characters; in fact it's a harder one, but the best answers could be copied with slight tweaking to take advantage of the extra space. And the digit restriction turned out not to be a serious problem: the winning answer would gain extremely little from being able to use digits. \$\endgroup\$ – Peter Taylor Jun 2 '17 at 9:07

Golf Cubically code

Your task is to optimize Cubically source code using one or more optimizations in this post.

How this challenge works:

  • You will choose one or more optimizations below and write a program (in the language of your choice) that performs those optimizations on a Cubically program.
  • Your program will take a Cubically program as input using any allowed input methods, and output a Cubically program using any allowed output methods.
  • The first answer to successfully perform all optimizations wins!


1. Face turn arguments

Before a face turn is performed, the interpreter calculates turns = turns mod 4. So R5 would be equivalent to R1 which is equivalent to R, R7 is equivalent to R3 which is equivalent to R', etc. Also note that R11111 is equivalent to R5, and R22 is equivalent to nothing at all.

Performing this optimization will mean evaluating all arguments to an R, L, U, D, M, E, or S command and shortening them as much as possible.

Test cases:

Relevant code -> Optimization
R11           -> R2
R1            -> R
L33           -> L2
U22           ->
D222          -> D2
M11111        -> M
E00001        -> E
S9            -> S

2. Repeated face turn

When multiple calls to the same face turn command are present right next to each other, they can clearly be golfed. For example, R2R1 is equivalent to R3. UUU is equivalent to U3. F2F2F2F2 is equivalent F8.

Test cases:

Relevant code -> optimization
R2R2R2        -> R6            (R2 if you also choose optimization 1)
LLL           -> L3
UU            -> UU or U2
D3D2D1        -> D6            (D2 if you also choose optimization 1)

3. "Set notepad to" commands

There are some commands that, instead of adding to/subtracting from/multiplying by/dividing by the notepad, just assign to it. Here are all such commands:


When called with multiple arguments, since each argument calls the command separately, only the final argument is relevant. So =123 is equivalent to =3, _00000 is equivalent to _0, and :12345678987654321 is equivalent to 1.

Test cases:

Relevant code -> Optimization
_333          -> _3
=12321        -> =1
+54321        -> +54321
:55           -> :5
/55           -> /55

4. Repeated non-face-turn commands

When multiple face turn commands are present right by each other, their arguments can simply be added together. Commands do not act this way. While R2 calls R with 2, =2 calls = with the face sum of the front face (face index 2).

To perform this optimization, when multiple commands outside of RLUDFBMES appear next to each other, simply remove the duplicated commands without removing the arguments.

Relevant code -> Optimization
_1_1_1_1      -> _1111         (_1 if you also choose optimization 3)
%11%22%33     -> %112233       (%3 if you also choose optimization 3)
+12345+67+8   -> +12345678

5. Nonexistent commands

Go check out the Cubically commands page and you'll see that there are plenty of characters that are not commands. For example, there are no commands that are lowercase letters.

To perform this optimization, remove all nonexistent commands and their arguments from the Cubically source. If the commands also have arguments, you must remove the arguments so that they are not passed to the previous command.

Test cases:

Relevant code -> Optimization
moo cow moo   -> 
moo2cow2moo   -> 
misteR2 FOO   -> R2F
FEAR ME.      -> ERME
u1U2u3U4u5U6  -> U2U4U6   (nothing if you also choose optimization 1, U12 if you also choose optimization 2)

6. Non-implicit commands

There are lots of implicit commands in Cubically (RLUDFBMES()$~&E!), but there are plenty that need to be called with arguments. So %%%% is equivalent to nothing at all while %%2%% is equivalent to %2.

Test cases:

Relevant code -> Optimization
%%%%          -> 
$$$$          -> $$$$
++2++2++2     -> +2+2+2                 (+222 if you also choose optimization 4)
+++>--<-      -> Not Brainf**k, sorry!  (:P)


I'll add more optimizations later.

  • \$\begingroup\$ Clarification on R123: That's the same as R6 and R2, not R3, right? Digits are summed, there are multidigit numbers? That would be better to specify \$\endgroup\$ – isaacg Aug 17 '17 at 20:13
  • \$\begingroup\$ A few things: first, I can't find the tag "fgitw", is there a typo? Second, does optimization 1 require handling F and B as well, or just the currently listed ones? Third, in optimization 3 most of the listed commands seem invalid because the notepad is used in calculation and then overwritten with the output; for example =11 is not the same as =1 in most circumstances. In fact, I think only _: are valid. Fourth, is the winning answer one which performs all optimizations in a single program, or one which contains a separate program for each optimization? \$\endgroup\$ – Kamil Drakari Aug 18 '17 at 18:03

Proper Kerning

Kerning is the adjustment of spacing between pairs of letters in order to obtain an aesthetic result. When kerning is applied automatically by a program (typically whatever editor you're using), it is said to be automatic. There are two types of automatic kerning. The one used in this challenge is metric kerning. With metric kerning, the amount of space between pairs of letters is dictated by the kerning tables found in the font file.

Given a TrueType font file, output the kerning values for each mapping in the kerning table for ASCII characters 48 - 122 inclusive.



l="A" r="C" v="-15"
l="A" r="G" v="-15"
l="A" r="J" v="23"
l="A" r="O" v="-23"
l="A" r="Q" v="-23"
l="A" r="T" v="-160"
l="A" r="U" v="-32"
l="A" r="V" v="-89"
l="A" r="W" v="-80"
l="A" r="Y" v="-150"
l="A" r="t" v="-52"
l="A" r="v" v="-38"
l="A" r="y" v="-41"
l="A" r="?" v="-68"
l="B" r="A" v="-20"
l="B" r="T" v="-48"
l="B" r="V" v="-25"
l="B" r="W" v="-24"
l="B" r="X" v="-44"
l="B" r="Y" v="-57"
l="B" r="Z" v="-20"
l="B" r="f" v="-20"
l="B" r="t" v="-20"
l="B" r="v" v="-20"
l="B" r="x" v="-15"
l="B" r="y" v="-20"
l="C" r="G" v="-18"
l="C" r="J" v="12"
l="C" r="O" v="-18"
l="C" r="Q" v="-18"
l="C" r="T" v="10"
l="D" r="A" v="-30"
l="D" r="J" v="-22"
l="D" r="T" v="-23"
l="D" r="V" v="-24"
l="D" r="W" v="-14"
l="D" r="X" v="-31"
l="D" r="Y" v="-39"
l="D" r="Z" v="-22"
l="E" r="A" v="-22"
l="E" r="C" v="-24"
l="E" r="G" v="-24"
l="E" r="O" v="-32"
l="E" r="Q" v="-32"
l="E" r="S" v="-20"
l="E" r="Z" v="-10"
l="E" r="a" v="-34"
l="E" r="c" v="-28"
l="E" r="d" v="-30"
l="E" r="e" v="-37"
l="E" r="f" v="-64"
l="E" r="o" v="-37"
l="E" r="q" v="-30"
l="E" r="t" v="-24"
l="E" r="v" v="-48"
l="E" r="w" v="-34"
l="E" r="y" v="-48"
l="F" r="A" v="-115"
l="F" r="C" v="-18"
l="F" r="G" v="-18"
l="F" r="J" v="-109"
l="F" r="O" v="-18"
l="F" r="Q" v="-18"
l="F" r="S" v="-29"
l="F" r="X" v="-22"
l="F" r="Z" v="-11"
l="F" r="a" v="-55"
l="F" r="c" v="-28"
l="F" r="d" v="-20"
l="F" r="e" v="-30"
l="F" r="o" v="-28"
l="F" r="q" v="-20"
l="F" r="s" v="-35"
l="G" r="T" v="-10"
l="G" r="V" v="-10"
l="G" r="W" v="-9"
l="G" r="Y" v="-30"
l="G" r="v" v="-29"
l="G" r="w" v="-22"
l="G" r="x" v="-14"
l="G" r="y" v="-30"
l="J" r="A" v="-35"
l="J" r="X" v="-20"
l="K" r="C" v="-78"
l="K" r="G" v="-80"
l="K" r="O" v="-97"
l="K" r="Q" v="-97"
l="K" r="S" v="-18"
l="K" r="U" v="-29"
l="K" r="W" v="-34"
l="K" r="a" v="-34"
l="K" r="c" v="-40"
l="K" r="d" v="-33"
l="K" r="e" v="-37"
l="K" r="f" v="-25"
l="K" r="m" v="-32"
l="K" r="n" v="-32"
l="K" r="o" v="-37"
l="K" r="p" v="-32"
l="K" r="q" v="-33"
l="K" r="r" v="-32"
l="K" r="s" v="-18"
l="K" r="t" v="-38"
l="K" r="u" v="-32"
l="K" r="v" v="-101"
l="K" r="w" v="-95"
l="K" r="y" v="-85"
l="L" r="C" v="-22"
l="L" r="G" v="-47"
l="L" r="J" v="25"
l="L" r="O" v="-45"
l="L" r="Q" v="-45"
l="L" r="T" v="-150"
l="L" r="U" v="-44"
l="L" r="V" v="-147"
l="L" r="W" v="-118"
l="L" r="Y" v="-167"
l="L" r="f" v="-23"
l="L" r="t" v="-38"
l="L" r="v" v="-78"
l="L" r="w" v="-72"
l="L" r="y" v="-79"
l="O" r="A" v="-23"
l="O" r="J" v="-27"
l="O" r="T" v="-55"
l="O" r="V" v="-25"
l="O" r="W" v="-22"
l="O" r="X" v="-64"
l="O" r="Y" v="-55"
l="O" r="Z" v="-38"
l="O" r="x" v="-12"
l="O" r="z" v="-10"
l="P" r="A" v="-151"
l="P" r="J" v="-140"
l="P" r="T" v="-9"
l="P" r="V" v="-10"
l="P" r="X" v="-35"
l="P" r="Y" v="-11"
l="P" r="Z" v="-29"
l="P" r="a" v="-44"
l="P" r="c" v="-43"
l="P" r="d" v="-34"
l="P" r="e" v="-41"
l="P" r="f" v="12"
l="P" r="o" v="-41"
l="P" r="q" v="-34"
l="P" r="s" v="-32"
l="P" r="t" v="12"
l="P" r="y" v="12"
l="Q" r="J" v="41"
l="Q" r="T" v="-47"
l="Q" r="V" v="-25"
l="Q" r="W" v="-12"
l="Q" r="X" v="12"
l="Q" r="Y" v="-46"
l="Q" r="g" v="59"
l="Q" r="j" v="79"
l="Q" r="x" v="31"
l="Q" r=";" v="60"
l="Q" r="]" v="32"
l="R" r="C" v="-18"
l="R" r="G" v="-19"
l="R" r="O" v="-20"
l="R" r="Q" v="-20"
l="R" r="S" v="-27"
l="R" r="T" v="-20"
l="R" r="V" v="-28"
l="R" r="W" v="-18"
l="R" r="Y" v="-30"
l="R" r="e" v="-36"
l="R" r="o" v="-42"
l="R" r="v" v="-26"
l="R" r="w" v="-33"
l="R" r="y" v="-33"
l="S" r="A" v="-15"
l="S" r="J" v="-9"
l="S" r="T" v="-14"
l="S" r="V" v="-14"
l="S" r="W" v="-15"
l="S" r="X" v="-13"
l="S" r="Y" v="-20"
l="S" r="v" v="-23"
l="S" r="w" v="-17"
l="S" r="y" v="-25"
l="T" r="A" v="-160"
l="T" r="C" v="-42"
l="T" r="G" v="-59"
l="T" r="J" v="-65"
l="T" r="O" v="-58"
l="T" r="Q" v="-58"
l="T" r="S" v="-10"
l="T" r="T" v="28"
l="T" r="a" v="-160"
l="T" r="c" v="-177"
l="T" r="d" v="-147"
l="T" r="e" v="-182"
l="T" r="g" v="-151"
l="T" r="m" v="-127"
l="T" r="n" v="-127"
l="T" r="o" v="-182"
l="T" r="p" v="-127"
l="T" r="q" v="-147"
l="T" r="r" v="-127"
l="T" r="s" v="-153"
l="T" r="u" v="-127"
l="T" r="v" v="-92"
l="T" r="w" v="-86"
l="T" r="x" v="-90"
l="T" r="y" v="-93"
l="T" r="z" v="-142"
l="T" r=";" v="-114"
l="T" r=":" v="-134"
l="U" r="A" v="-45"
l="U" r="J" v="-40"
l="V" r="A" v="-96"
l="V" r="C" v="-18"
l="V" r="G" v="-25"
l="V" r="J" v="-80"
l="V" r="O" v="-27"
l="V" r="Q" v="-27"
l="V" r="S" v="-12"
l="V" r="V" v="9"
l="V" r="a" v="-114"
l="V" r="c" v="-103"
l="V" r="d" v="-87"
l="V" r="e" v="-102"
l="V" r="g" v="-100"
l="V" r="m" v="-50"
l="V" r="n" v="-50"
l="V" r="o" v="-86"
l="V" r="p" v="-50"
l="V" r="q" v="-87"
l="V" r="r" v="-50"
l="V" r="s" v="-90"
l="V" r="u" v="-50"
l="V" r="y" v="-35"
l="V" r="z" v="-82"
l="V" r=";" v="-108"
l="V" r=":" v="-73"
l="W" r="A" v="-93"
l="W" r="C" v="-22"
l="W" r="G" v="-22"
l="W" r="J" v="-88"
l="W" r="O" v="-22"
l="W" r="Q" v="-22"
l="W" r="S" v="-10"
l="W" r="X" v="-13"
l="W" r="a" v="-71"
l="W" r="c" v="-78"
l="W" r="d" v="-72"
l="W" r="e" v="-75"
l="W" r="g" v="-54"
l="W" r="m" v="-60"
l="W" r="n" v="-60"
l="W" r="o" v="-86"
l="W" r="p" v="-60"
l="W" r="q" v="-72"
l="W" r="r" v="-60"
l="W" r="s" v="-73"
l="W" r="u" v="-60"
l="W" r="v" v="-34"
l="W" r="y" v="-53"
l="W" r=";" v="-156"
l="X" r="C" v="-57"
l="X" r="G" v="-65"
l="X" r="O" v="-57"
l="X" r="Q" v="-57"
l="X" r="S" v="-20"
l="X" r="d" v="-44"
l="X" r="e" v="-39"
l="X" r="g" v="-9"
l="X" r="o" v="-38"
l="X" r="q" v="-44"
l="X" r="t" v="-31"
l="X" r="u" v="-38"
l="X" r="v" v="-55"
l="X" r="w" v="-49"
l="X" r="y" v="-43"
l="Y" r="A" v="-152"
l="Y" r="C" v="-67"
l="Y" r="G" v="-67"
l="Y" r="J" v="-112"
l="Y" r="O" v="-66"
l="Y" r="Q" v="-66"
l="Y" r="S" v="-17"
l="Y" r="Z" v="-10"
l="Y" r="a" v="-134"
l="Y" r="c" v="-159"
l="Y" r="d" v="-131"
l="Y" r="e" v="-147"
l="Y" r="f" v="-62"
l="Y" r="g" v="-142"
l="Y" r="i" v="-32"
l="Y" r="j" v="-49"
l="Y" r="m" v="-94"
l="Y" r="n" v="-94"
l="Y" r="o" v="-153"
l="Y" r="p" v="-94"
l="Y" r="q" v="-131"
l="Y" r="r" v="-94"
l="Y" r="s" v="-115"
l="Y" r="t" v="-44"
l="Y" r="u" v="-94"
l="Y" r="v" v="-69"
l="Y" r="w" v="-62"
l="Y" r="x" v="-70"
l="Y" r="y" v="-65"
l="Y" r="z" v="-100"
l="Y" r=";" v="-138"
l="Y" r=":" v="-154"
l="Z" r="A" v="-11"
l="Z" r="C" v="-25"
l="Z" r="G" v="-24"
l="Z" r="O" v="-24"
l="Z" r="Q" v="-24"
l="Z" r="W" v="-7"
l="Z" r="Y" v="-7"
l="Z" r="a" v="-10"
l="Z" r="c" v="-12"
l="Z" r="d" v="-18"
l="Z" r="e" v="-31"
l="Z" r="o" v="-29"
l="Z" r="q" v="-18"
l="Z" r="v" v="-45"
l="Z" r="w" v="-38"
l="Z" r="y" v="-37"
l="a" r="f" v="-12"
l="a" r="t" v="-19"
l="a" r="v" v="-34"
l="a" r="w" v="-14"
l="a" r="x" v="-19"
l="a" r="y" v="-38"
l="b" r="f" v="-17"
l="b" r="s" v="-10"
l="b" r="t" v="-9"
l="b" r="v" v="-10"
l="b" r="w" v="-10"
l="b" r="x" v="-41"
l="b" r="y" v="-10"
l="b" r="z" v="-28"
l="c" r="a" v="-17"
l="c" r="o" v="-17"
l="e" r="f" v="-18"
l="e" r="t" v="-11"
l="e" r="v" v="-10"
l="e" r="w" v="-10"
l="e" r="x" v="-31"
l="e" r="y" v="-13"
l="e" r="z" v="-20"
l="f" r="a" v="-40"
l="f" r="c" v="-45"
l="f" r="d" v="-53"
l="f" r="e" v="-51"
l="f" r="f" v="-20"
l="f" r="g" v="-60"
l="f" r="o" v="-43"
l="f" r="q" v="-53"
l="f" r="s" v="-27"
l="f" r="v" v="13"
l="f" r="w" v="6"
l="f" r="y" v="10"
l="f" r="z" v="-20"
l="g" r="a" v="-38"
l="g" r="c" v="-12"
l="g" r="d" v="-19"
l="g" r="e" v="-17"
l="g" r="g" v="19"
l="g" r="o" v="-14"
l="g" r="q" v="-19"
l="g" r="t" v="-31"
l="h" r="f" v="-12"
l="h" r="t" v="-19"
l="h" r="v" v="-34"
l="h" r="w" v="-14"
l="h" r="x" v="-19"
l="h" r="y" v="-38"
l="k" r="a" v="-35"
l="k" r="c" v="-48"
l="k" r="d" v="-56"
l="k" r="e" v="-66"
l="k" r="o" v="-69"
l="k" r="q" v="-56"
l="k" r="s" v="-19"
l="k" r="t" v="-10"
l="k" r="u" v="-26"
l="m" r="f" v="-12"
l="m" r="t" v="-19"
l="m" r="v" v="-34"
l="m" r="w" v="-14"
l="m" r="x" v="-19"
l="m" r="y" v="-38"
l="n" r="f" v="-12"
l="n" r="t" v="-19"
l="n" r="v" v="-34"
l="n" r="w" v="-14"
l="n" r="x" v="-19"
l="n" r="y" v="-38"
l="o" r="v" v="-9"
l="o" r="w" v="-8"
l="o" r="x" v="-40"
l="o" r="y" v="-11"
l="o" r="z" v="-27"
l="p" r="f" v="-17"
l="p" r="s" v="-10"
l="p" r="t" v="-9"
l="p" r="v" v="-10"
l="p" r="w" v="-10"
l="p" r="x" v="-41"
l="p" r="y" v="-10"
l="p" r="z" v="-28"
l="q" r="g" v="10"
l="r" r="a" v="-42"
l="r" r="c" v="-30"
l="r" r="d" v="-28"
l="r" r="e" v="-27"
l="r" r="g" v="-28"
l="r" r="o" v="-33"
l="r" r="q" v="-28"
l="r" r="s" v="-35"
l="r" r="v" v="19"
l="r" r="w" v="11"
l="r" r="y" v="10"
l="s" r="f" v="-19"
l="s" r="t" v="-23"
l="s" r="v" v="-31"
l="s" r="w" v="-10"
l="s" r="x" v="-22"
l="s" r="y" v="-37"
l="s" r="z" v="-18"
l="t" r="a" v="-25"
l="t" r="c" v="-25"
l="t" r="d" v="-23"
l="t" r="e" v="-22"
l="t" r="o" v="-20"
l="t" r="q" v="-23"
l="t" r="t" v="-29"
l="v" r="a" v="-30"
l="v" r="c" v="-25"
l="v" r="d" v="-20"
l="v" r="e" v="-20"
l="v" r="f" v="11"
l="v" r="g" v="-28"
l="v" r="o" v="-19"
l="v" r="q" v="-20"
l="v" r="s" v="-9"
l="v" r="t" v="10"
l="v" r="v" v="12"
l="v" r="w" v="12"
l="v" r="y" v="12"
l="v" r="z" v="-26"
l="w" r="a" v="-23"
l="w" r="c" v="-20"
l="w" r="d" v="-18"
l="w" r="e" v="-18"
l="w" r="f" v="6"
l="w" r="g" v="-18"
l="w" r="o" v="-19"
l="w" r="q" v="-18"
l="w" r="s" v="-18"
l="w" r="t" v="4"
l="w" r="v" v="12"
l="w" r="w" v="8"
l="w" r="y" v="12"
l="w" r="z" v="-17"
l="x" r="a" v="-37"
l="x" r="c" v="-46"
l="x" r="d" v="-44"
l="x" r="e" v="-54"
l="x" r="o" v="-55"
l="x" r="q" v="-44"
l="x" r="s" v="-12"
l="x" r="t" v="6"
l="x" r="u" v="-20"
l="y" r="a" v="-31"
l="y" r="c" v="-26"
l="y" r="d" v="-24"
l="y" r="e" v="-25"
l="y" r="f" v="10"
l="y" r="g" v="-26"
l="y" r="o" v="-24"
l="y" r="q" v="-24"
l="y" r="s" v="-19"
l="y" r="t" v="10"
l="y" r="v" v="12"
l="y" r="w" v="8"
l="y" r="y" v="10"
l="y" r="z" v="-17"
l="z" r="a" v="-34"
l="z" r="c" v="-45"
l="z" r="d" v="-46"
l="z" r="e" v="-46"
l="z" r="f" v="-10"
l="z" r="g" v="-17"
l="z" r="o" v="-45"
l="z" r="q" v="-46"
l="z" r="s" v="-22"
l="z" r="u" v="-10"
l="z" r="v" v="-18"
l="z" r="w" v="-22"
l="z" r="y" v="-18"


This is , so the shortest answer (in bytes) wins.


I know this challenge is going to need a lot of work before it's ready for main. Please hold criticisms for now. Helpful ideas and thoughts are welcome.

  • \$\begingroup\$ I'm not sure that the problem is well defined. There's a reason it's called font hinting: the rendering application is free to take it into account or not, or even to apply more complex logic. E.g. some fonts have multiple sets of font hints for different contexts. There are other complex issues. A font can have Latin and Cyrillic letters and define hints for kerning between pairs of Latin and pairs of Cyrillic but not between Latin and Cyrillic; however, some letters may have identical glyphs, so a judgement on whether the kerning is "correct" might be ambiguous. Then there's antialiasing. \$\endgroup\$ – Peter Taylor May 24 '17 at 6:15
  • \$\begingroup\$ @PeterTaylor Good notes. I will likely restrict the character set. I just wanted to start getting ideas down in the sandbox. \$\endgroup\$ – Poke May 24 '17 at 6:51
  • \$\begingroup\$ Very ambiguous. \$\endgroup\$ – anna328p May 25 '17 at 17:48
  • \$\begingroup\$ @Mendeleev It's not done yet. I'm aware it's ambiguous. \$\endgroup\$ – Poke May 26 '17 at 16:10
  • \$\begingroup\$ Looking at developer.apple.com/fonts/TrueType-Reference-Manual/RM06/… I can see a number of issues to address. 16- vs 32-bit entries? Should multiple tables be combined or printed separately? All tables or only tables with certain coverage values? Which of the four defined formats need to be supported? Do you have a test case which covers glyph index differing from codepoint? \$\endgroup\$ – Peter Taylor Sep 16 '17 at 17:28
  • \$\begingroup\$ @PeterTaylor I have a proof of concept that I wrote (it's the reason I have taken so long to update this) and I'm planning to address all of your questions. Thanks for doing a bit of research to help me out, though :] \$\endgroup\$ – Poke Sep 16 '17 at 18:57
  • \$\begingroup\$ Downvoter, why? \$\endgroup\$ – Poke Oct 4 '17 at 21:03

Six Flags over HTTP

Let's say you need to transmit six boolean flags in a URL string. Obviously you could do it with six ones or zeroes, but you want better compression. With a little math you can pack them into two characters using 0-7 octal.

How about mapping all six to a single ASCII character? Here we have a problem: you are not allowed to use , / ? : @ & = + $ # or space. Now the range of printable ASCII no longer has 64 valid characters in a row.

In Javascript (or another language that can run from a web page, if any), what is the shortest code for a pair of functions to encode and decode this data, between an array of six booleans and a single character?

  • \$\begingroup\$ -1 language restriction, most languages have HTTP libraries so I think any language should be allowed \$\endgroup\$ – ASCII-only Sep 24 '17 at 13:11
  • \$\begingroup\$ This challenge could be improved by rephrasing it to: "Write a bijective function between an array of six booleans and a single printable character excluding the characters ,/?:@&=+$# ". Mentioning that the encoder and decoder should be separate programs/functions would be helpful. Also, may the encoder and decoder share code? \$\endgroup\$ – fireflame241 Sep 24 '17 at 22:08

Count letter frequency

Inspired by question Tweetable hash function challenge, you should take the English dictionary used there and produce a program or function that outputs the the absolute and relative frequency of each character. It is CASE SENSITIVE and the APOSTROPHE is also accountable as a real letter.

Example of a valid output format (but with stupid guessing values):

A      5566    20%
Z        60     0.2%
a     27000    30%
z       120     0.01%
'       450     3.5%

It is , but no answer will be accepted. Wanna know shortest script for each language.

  • 1
    \$\begingroup\$ -1 (01) Don't rely on another challenge to define yours; include all the information we need in your write-up. (02) Make an effort to come up with some actual test cases - do you honestly expect us to verify our solutions against "stupid guessing values"? \$\endgroup\$ – Shaggy Sep 30 '17 at 0:55

Is it a perfect loop?

Your task is to take a GIF or an animated image in any reasonable format as input (including taking the file name of a GIF in the current directory), and output whether it is a "perfect loop" - that is, the frames transition seamlessly from the end to the start, and a human cannot notice where it starts and ends at first glance. Return or print a truthy value if it is a perfect loop, otherwise print or return a falsy value.


Winners will be determined from the percentage of test cases they get correct. In the event of a tie, highest votes wins. You can view test cases at https://ghostbin.com/paste/m3yaw. Show your score against the test cases when you post.


If you are not taking input in a GIF, please provide a program that will convert a GIF to your desired format.

Images corresponding to a truthy value have been taken from /r/perfectloops and for falsy test cases, /r/almostperfectloops and /r/gifs.


  • Hard coding is not allowed (violates standard loophole 1 and 2).
  • You must provide consistent results for the same GIF (no randomness)
  • Remember, this is not , so byte count is not needed in your solution. Just post the language name and add the percentage correct when I comment.
  • \$\begingroup\$ I'm not sure it's as simple as comparing the first to the last frame, if it is we'd have duplicate frames. is this challenge allowing HTTP requests? \$\endgroup\$ – tuskiomi Oct 17 '17 at 21:15
  • \$\begingroup\$ If hashing the inputs is not allowed, then you should clearly define what constitutes a “perfect loop”. It's not good to extrapolate from a handful of test cases where the pass/fail cases are very similar. \$\endgroup\$ – japh Oct 18 '17 at 14:31

Highest code size∕output ratio to generate a large executable section inside an elf file.

Your challenge is to create the shortest code in your language of choice or the tools of your choice (like objcopy) that will create an elf file with a the executable section as large as possible.
I mean that if I extract the.text section of the elf binary, the resulting extracted file should be at least 90% of the elf binary.


  • The program should takes the desired section size as input.
  • The .text section name needs to corresponds to the executable section.
  • The type of the .text section should bePROGBITSand it should contains instructions.
  • The elf file should have a .shstrtab section.
  • The .text section should be readable and writable.
  • The target architecture should be Pnacl or armelv7 or x86_64.
  • The elf file should be valid and pass Google nacl’s validation whitelist in order to be loaded (but I don´t care if the sandbox segfault).
    If you have no idea about what Google native client is, just create a script that call the patched version of binutils from the nacl_sdk, or make sure the elf file is valid and can be executed on Linux.

Of course, you normally can’t use a compiler because it would takes too much computational years in order to finish.


The answer with the highest code size∕program output ratio.

  • 1
    \$\begingroup\$ Why not make scoring output size / code size? \$\endgroup\$ – anna328p Apr 4 '17 at 3:49
  • \$\begingroup\$ Make it a code-challenge \$\endgroup\$ – anna328p Apr 4 '17 at 3:49
  • \$\begingroup\$ This is essentially the same challenge as this one, and would be closed as a duplicate. Although it's not exactly the same, some answers to the previous question would require very little modification and answers to this question would also require very little modification to be answers to the other one. \$\endgroup\$ – Peter Taylor Apr 4 '17 at 8:37
  • \$\begingroup\$ @Alt-F4 : it was a code challenge. \$\endgroup\$ – user2284570 Apr 4 '17 at 21:52
  • \$\begingroup\$ @PeterTaylor : they were no answer to the previous question. In order to be closed as a duplicate the target needs to be already answered. You known it was closed an unclear, so please suggest change to make this answer clearer. \$\endgroup\$ – user2284570 Apr 4 '17 at 21:54
  • \$\begingroup\$ Huh? It's open and has 15 answers. \$\endgroup\$ – Peter Taylor Apr 4 '17 at 22:09
  • \$\begingroup\$ @PeterTaylor sorry, I thought to an another question that was closed as unclear and didn’t take time to read your link. In that case NO, the aim is to not use the compiler in order to actually build the file. This normally can’t be done with a compiler or an assembler. \$\endgroup\$ – user2284570 Apr 4 '17 at 22:16
  • \$\begingroup\$ Can't it? Why not? \$\endgroup\$ – wizzwizz4 Dec 16 '17 at 19:55
  • \$\begingroup\$ Wait... shortest code that generate any program? Or what? Don't think this is a good idea... \$\endgroup\$ – user202729 Jan 6 '18 at 12:10

Removing a Letter adds a Letter

Your program should output nothing when unaltered, however, when any single character is removed it should have an output length of 1. This extends to any number of characters being removed from the program, as long as there is, at minimum, a single character remaining.

For example, if my program were abcdefg, it should output nothing if unaltered.

However, if I were to remove a and d from this program to get bcefg, it should output any two printable characters that represent 16 bytes of information (2 characters for 2 characters removed).

  • So if bcefg outputs (00,AA,etc...) this is valid.

Taking this further, if we were to remove all but the letter g we'd need an output of 6 characters.

  • So if g outputs ('000000','@$^%@(',etc...) this is valid.

Your program must function for all possible combinations of removals that are possible, that is to say each single letter in your program should be a valid program.


  • You may "lock" pieces of the code, each locked byte counts for 2-bytes instead of 1-byte.
    • Locked bytes will never be removed.
    • For instance, if my program was abcdefg and bcd is locked, the shortest program we'll get is abcd,bcde,bcdf and bcdg.
    • If bcd was locked in abcdefg it'd be 10 bytes, not 7.
  • The program may output any byte to represent 1 removed character, N-bytes for N removed chars in the code itself.
  • \$\begingroup\$ The rule only leads to totally locked code \$\endgroup\$ – l4m2 Mar 13 '18 at 0:13
  • \$\begingroup\$ @l4m2 hah. I disagree. \$\endgroup\$ – Magic Octopus Urn Mar 13 '18 at 0:58
  • \$\begingroup\$ But more constructively, increase the penalty? Limit locked chars? \$\endgroup\$ – Magic Octopus Urn Mar 13 '18 at 1:04
  • \$\begingroup\$ Maybe require an unlocked percent? \$\endgroup\$ – l4m2 Apr 6 '18 at 10:52


Is this question already available (duplicate)?

Are things too vague?

Does providing the example help or hinder?

Tidy the Pantry (easy)

I hate grocery shopping, particularly the part where I put groceries away--so I'm calling upon the collective hive-mind to handle that.


Your challenge is to take a 1D-list of groceries and a 2D pantry as input; and output an newly assorted pantry. The two variables can be of your type choice, and in any order, but please specify what item types your program requires (e.g. string, array, etc.).

Rules & Additional info.


  • This is code golf, so the shortest answer in bytes wins


  • The pantry should be ordered alphabetically (A - Z, left to right, top to bottom)
    • For simplicity, the pantry is case-insensitive
  • The pantry must retain its horizontal size (but trailing newlines are optional)
  • "Pockets" (empty spaces) should be filled between items (i.e. only the last item is allowed to have a trailing pocket)
  • If the pantry is too small for the incoming groceries, then the pantry must replace older items (Z being the oldest, A the youngest)
    • Z from groceries is younger than A in pantry
  • Standard loopholes are forbidden

Examples ([ and ] are used for readability)

Input (4x4 pantry):

[A][A][ ][ ]
[ ][ ][B][ ]
[C][ ][ ][ ]
[ ][ ][ ][D]



[ ][ ][ ][ ]
[ ][ ][ ][ ]

Input (2x2 pantry):





Example solution

JavaScript ES6 (989 bytes)

// (String, String) -> String
let organise = (pantry, groceries) => {
  let n = pantry.split("\n").sort((a, b) => b.length - a.length); // used at the end of the function for horizontal sizing
  n = n[0].length;

  pantry = pantry
    .replace(/\W/g, "") // get rid of all non-alphanumeric characters
    .split("");         // turn the string into an array

  // we need the properties of the new array
  // so the extra `pantry = pantry` is needed
  pantry = pantry
    .slice(0, pantry.length - groceries.length) // go ahead and remove the last overlapping elements
    .concat(groceries)                          // add the groceries to the pantry
    .join("")                                   // turn into a string
    .split("")                                  // turn into an array
    .sort()                                     // sort the array
    .join("");                                  // turn into a string

    return pantry.replace(RegExp(`(.{${n}})`, 'g'), "$1\n");

/** Testing below **/

console.log("Test #2:\n" + organise(
Q     W


Test Cases:

Test #1, 4x4 pantry

TVCX <- pantry

XYXY <- groceries
AAAB <- expected output

Test #2, 7x6 pantry

Q     W


Test #3, 10x10 pantry



Test #4, 16x16 pantry pantry

U          JHOLK


Test #5, 2x2 pantry


[no groceries]
  • 1
    \$\begingroup\$ why divide the program score? \$\endgroup\$ – RedClover Feb 26 '18 at 19:03
  • 1
    \$\begingroup\$ I recommend you do count by bytes otherwise someone is just going to encode their entire program in Chinese characters and win. \$\endgroup\$ – HyperNeutrino Feb 26 '18 at 19:09
  • \$\begingroup\$ @labela--gotoa To get a golfed score (smaller programs get a smaller score), should I change it? \$\endgroup\$ – Ephellon Dantzler Feb 26 '18 at 19:13
  • \$\begingroup\$ @EphellonDantzler I don't understand why not just normal scoring...? \$\endgroup\$ – RedClover Feb 26 '18 at 19:14
  • \$\begingroup\$ LOL, that's why I set in in Sandbox first @labela--gotoa \$\endgroup\$ – Ephellon Dantzler Feb 26 '18 at 19:16
  • 1
    \$\begingroup\$ Some notes on your reference implementation: 1 It appears far too soon in the challenge. 2 It's not 1768 bytes. 3 You need to ungolf it and make it readable or it's not much use. 4 As it's JS, create a Snippet for it. 5 Is it necessary? It seems to be thrown in there to try to patch over any holes in the challenge spec. \$\endgroup\$ – Shaggy Feb 26 '18 at 23:17

Interpret pseudocode

Wikipedia says pseudocode

is intended for human reading rather than machine reading.


A program in pseudocode is not an executable program.

I don't care.

Make a pseudocode interpreter that can run pseudocode that fits the rules described below*. This is based on the IB pseudocode guide, but it is simplified quite a bit to make it fit for the challenge.

Pseudocode specifications

This is a simplified pseudocode to make the challenge less tedious. The pseudocode language has no strings, no arrays, no classes, no methods, and no variables other than integers.

Basic syntax

Comments that start at // and end at a newline (like java one-line comments). // is not necessarily followed by a space, and the comment may be empty. Example:

A = 2 + 3 // I can't write five because my keyboard is broken

Statements are separated by newlines. Lines may be empty (without statements). The exact number of spaces doesn't matter, and spaces are not required. The language is case sensitive.


All variables are global, and can be accessed anywhere. They do not need to be declared. To keep things simple, all variables can be assumed to be integers. All variable names are UPPERCASE, and consist only of letters. Your program should at least handle integers from -256 to 256. A wider range is not a requirement.

Variables are assigned values using this syntax:

VARIABLE = Expression

Where VARIABLE can be any uppercase name and expression can be any integer expression, as discussed below.


A = 5
B = A + 3


An expression can be:

  • An integer, like 42
  • A variable, like NUMBER
  • A binary operation on two other expressions, like NUMBER + 5. There are only four operations: +, -, *, /. Division rounds integers down.

Expressions can be surrounded by parentheses to indicate that they need to be evaluated first. To keep things simple, all expressions are evaluated from left to right no matter what the operations are (unless there are parentheses that specify otherwise), so

A = 2 - RM * 9 + 3 / NUMBER
B = 1 + 2 * (3 - 4) / 6

is equivalent to

A = (((2 - RM) * 9) + 3) / NUMBER
B = ((1 + 2) * (3 - 4)) / 6

Boolean expressions

Boolean expressions can compare two expressions using == (equality), != (not equal to), < (less than), and > (greater than). They are only used for control flow, as discussed below (there are no boolean variables).

Control flow

There are four types of control flow. They can be infinitely nested in all combinations.


if (booleanExpression) then
    // statements (discussed below)


if (booleanExpression) then
    // statements (discussed below)
    // other statements

Loop while

loop while (booleanExpression)
    // do stuff

Where booleanExpressions are boolean expressions. The ifs work the same as in normal programming languages. The while loop is a simple while loop.

The booleanExpressions will always be surrounded by (). The pseudocode is very flexible with spaces, and any number of spaces is valid.

Loop for

loop VARIABLE from Expression1 to Expression2
    // things to do over and over again
end loop

Where Expression1 and Expression2 are expressions that are evaluated before the loop begins and their values are stored until the loop finishes. The content of the loop is executed for every integer from the result of Expression1 to that of Expression1, inclusive. At every iteration, the index variable (VARIABLE in this case) is updated.


loop I from 3 to 5





output(Expression) outputs the evaluated expression. It's like println in programming languages. So:


prints 2, followed by a newline.

output() with no arguments should print a newline.

Other statements

If the interpreter encounters any other statement that looks like a method call with no arguments, it should pretend it's executing it. For example,


should print (together with a newline):

executing lightsoff
executing gohome

In other words, executing [Method name] should be printed. All statements will be lowercase and will consist entirely of letters.

Keywords cannot be statements. You do not have to deal with the following (it will not appear in the pseudocode): - if() - endif() - loop() - while() - etc.

However, statements that start with keywords are valid. For example, loophole() should print executing loophole, even though loop() itself is not valid.

Challenge rules

  • Your program should take a string as input. It can also take something equivalent, like an array of characters. But you can't take an array of strings; your program must itself separate the lines and tokens. You can also take a file as input.
  • Your program should print the output of the pseudocode in any reasonable form.
  • No standard loopholes.
  • There are no restrictions on what your program should do when given invalid pseudocode.
  • This is code golf. The shortest code in bytes wins.

Example output


A = 3
output(A) // prints 3
B = 4 + A * 2
output(A + B + 1 * 3)

Should give:

executing helloworld


loop NUM from 2 to 20 // cycle through possible prime numbers
    COUNT = 0
    loop DIV from 2 to NUM // cycle through possible divisors
        if(NUM/DIV*DIV == NUM) then // if the number is exactly divisible
            COUNT = COUNT + 1
    if (COUNT == 2) then // if number is prime

Should give:



Tricky cases that your interpreter should handle:

// empty comment:
// empty line:

    // more comment testing // ///

if     (3<4) then
    endoftheworld() // a statement
    // endif in a comment doesn't count
// loops can be empty:
loop I from 0 to 10
output(I) // variables are global
    if(3<4) // nesting is ok
// spacing doesn't matter:
output   (2+   8   - 1   )
loop             while(2<1)

Should output:

executing endoftheworld
executing ifff
executing endifnot
excecuting ok

*Technically, once pseudocode follows rules as strict as those described here, it is arguably not pseudocode anymore. Wikipedia says it's called skeleton code.

Any suggestions?

I double-checked all the specifications, but if anything seems reasonably unclear, please let me know.

  • \$\begingroup\$ Actually that's because the challenge is uninteresting. \$\endgroup\$ – Xwtek May 3 '18 at 2:11
  • \$\begingroup\$ @Akangka thanks for the feedback. How do you think it could be made more interesting? \$\endgroup\$ – Reinis Mazeiks May 3 '18 at 16:47
  • \$\begingroup\$ Unfortunately, there is nothing to improve. You have to find other challenge. Also, it is not pseudo-code. \$\endgroup\$ – Xwtek May 4 '18 at 3:03
  • \$\begingroup\$ @Ok, thanks. I'll try to think of something. Also, read the *note. :) \$\endgroup\$ – Reinis Mazeiks May 5 '18 at 19:39

Common Logic Gates

Given positive integer n, make a common n-to-1 gate with fewest input, i.e. make a function f: {0,1}k ↦ {0,1} with smallest k that, for each function g: {0,1}n ↦ {0,1}, there exists {ak}, such that each element ai in the sequence map to one of 0, 1, x1, x2, x3, ..., xn, satisfying that, for each {xn}, g(x1, x2, x3, ..., xn) = f(a1, a2, a3, ..., an).


To make a common 1-to-1 gate, your circuit must take at least 2 input:

f(A,B) = A XOR B

For a buffer gate (g = x1 ↦ x1), let A=0 and B=Input (a1 = 0, a2 = x1); for a not gate (g = x1 ↦ ¬x1) , let A=1 and B=Input (a1 = 1, a2 = x1).

Alternatively, you can use f(A,B) = A AND NOT B. For a buffer gate, let B=0 and A=Input; for a not gate, let A=1 and B=Input.

To make a common 2-to-1 gate, the circuit must take at least 4 input bits: (The two inputs are represented as a and b)

f(A,B,C,D) = ((A AND B) OR (C AND NOT B)) XOR D

00 01 10 11 A B C D
0  0  0  1  a b 0 0
0  0  1  0  0 b a 0
0  1  1  0  a a a b
0  1  1  1  1 b a 0
1  0  0  0  1 b a 1
1  0  0  1  0 a 1 b
1  1  0  1  0 b a 1
1  1  1  0  a b 0 1

Output can be an boolean expression with reasonable logic gates, or just the output corresponding to all possible input of the n-to-1 function f (the truth table of f). If there are more than one possible functions, you can output any of them.

Shortest code in bytes win.

Code that matches the requirement:

function solve(n) { // n positive int
    var res = [], tmp=[], inmap=[], need=[];
    for (var i=1; ; i++) {
        for (var _res=0; _res<2**(2**i); _res++) {
            var valid = 1;
            for (var j=0; j<2**i; j++)
                tmp[j] = Math.floor(_res/2**j)%2;
            for (var _need=0; _need<2**(2**n); _need++) {
                for (var j=0; j<2**n; j++) 
                    need[j] = Math.floor(_need/2**j)%2;
                var valid2 = 0;
                for (var _inmap=0; _inmap<(n+2)**i; _inmap++) {
                    var valid3 = 1;
                    for (var j=0; j<i; j++) 
                        inmap[j] = Math.floor(_inmap/(n+2)**j)%(n+2) - 1;
                    for (var j=0; j<2**n; j++) {
                        var bits = 0;
                        for (var k=0; k<i; k++) {
                            if (inmap[k]==-1 || (inmap[k] && (j>>(inmap[k]-1))%2))
                                bits |= 1 << k;
                        if (tmp[bits] != need[j]) 
                            valid3 = 0;
                    valid2 |= valid3;
                if (!valid2) valid = 0;
            if (valid) 
                res.push (tmp.slice());
        if (res.length) 
            return res[AnyNonNegativeIntegerLessThan(res.length)];
        // binary index input

function AnyNonNegativeIntegerLessThan(x) { if(R>=x) throw ("end"); return R;}
for (R=0; ; R++) { console.log (solve(1)); }

  • \$\begingroup\$ You don't define what an n-to-1 gate is anywhere in your question. \$\endgroup\$ – Wheat Wizard Mar 27 '18 at 1:00
  • \$\begingroup\$ @user202729 @user56656 n-to-1 gate means a gate with n input and 1 output. common n-to-1 logic gate mean a logic gate that can be used to replace any n-to-1 gate with some proper wiring. You can treat a logic gate as a ROM(so you can decide for each input what the output is) \$\endgroup\$ – l4m2 Mar 27 '18 at 1:15
  • \$\begingroup\$ Output gates or ROM \$\endgroup\$ – l4m2 Mar 27 '18 at 1:25
  • \$\begingroup\$ You should put the definitions in the challenge. "that can be used to replace any n-to-1 gate with some proper wiring" is still not very clear, you should define more carefully what you mean by proper wiring. \$\endgroup\$ – Wheat Wizard Mar 27 '18 at 3:22
  • \$\begingroup\$ I assume you mean functions g: {0,1}^n -> {0,1}, right? Why do you specify x_0 and x_-1? Shouldn't x just be a vector with indices 1,2,3,...,n? \$\endgroup\$ – flawr Mar 27 '18 at 14:07
  • \$\begingroup\$ Is {a_k} just a subset of {1,2,3,...,n}? Or can we have a_1=a_2=a_3=1 for example? \$\endgroup\$ – flawr Mar 27 '18 at 14:09
  • \$\begingroup\$ {a_k} seems not a multiset. It should be an array or say a sequence of numbers \$\endgroup\$ – l4m2 Mar 27 '18 at 14:43
  • \$\begingroup\$ So you're asking for something which outputs answers to codegolf.stackexchange.com/q/24983/194 ? \$\endgroup\$ – Peter Taylor Mar 28 '18 at 11:33
  • \$\begingroup\$ @PeterTaylor No. it requires to use NAND gate to make up one circult that do the thing. Also 24983 is a 1-of-4 (74LS153), not a 4-to-1 gate common 2-to-1 \$\endgroup\$ – l4m2 Mar 28 '18 at 12:41
  • \$\begingroup\$ (+) Any reason for downvoting? Downvoting in the sandbox indicates that the challenge is incomplete, if you don't leave a comment the OP can't know what is wrong. \$\endgroup\$ – user202729 Mar 29 '18 at 4:48
  • \$\begingroup\$ @user202729, there are already comments indicating that this question is going to attract close votes as unclear if it's posted to main in the current state. \$\endgroup\$ – Peter Taylor Mar 29 '18 at 10:59
  • \$\begingroup\$ @user56656 Are the issues fixed now? \$\endgroup\$ – user202729 Mar 31 '18 at 15:16
  • \$\begingroup\$ @flawr Are the issues fixed now? \$\endgroup\$ – user202729 Mar 31 '18 at 15:16
  • 1
    \$\begingroup\$ No I still think the explanation is quite bad and the notation is not very clear \$\endgroup\$ – flawr Mar 31 '18 at 16:15
  • \$\begingroup\$ A reference implementation is no substitute for a clear specification. The first paragraph is where you need to focus your efforts. \$\endgroup\$ – Peter Taylor Mar 31 '18 at 19:32

Is the program 32 or 64 bits?

Assignment is simple to explain: write the shortest code you need to determine whether an executable binary program supplied as parameter is 32 or 64 bits.

If there is a different kind of bitness, you can also do for it, but is not mandatory.

What I really don't want is telling me you support other bitnesses and after I get 32 or 64 as a result.

Valid outputs for 32:

32 bit
32 bits

The same pattern for 64.

No accepted answer.

  • \$\begingroup\$ I think you're missing a word somewhere in the region of "determine supplied" \$\endgroup\$ – Kamil Drakari Apr 4 '18 at 19:43
  • \$\begingroup\$ @KamilDrakari thanks. \$\endgroup\$ – sergiol Apr 4 '18 at 19:53
  • \$\begingroup\$ Executable on Windows or Linux machine? What if (... maybe ...) the program is a valid executable for both "bitness" but do different things? \$\endgroup\$ – user202729 Apr 5 '18 at 1:30
  • \$\begingroup\$ Of the output formats you allow, I think the first one will result in the shortest code in every single language. Because of this, you might as well just specify that the output should be the number 32 or the number 64. \$\endgroup\$ – Nathaniel Apr 5 '18 at 8:03
  • \$\begingroup\$ This made me wonder what to do about shell scripts, which are executable programs, but require another file to interpret them and as such aren't 32-bit or 64-bit per se. Maybe it would be best to specify "executable binary file" to not have to deal with that mess. \$\endgroup\$ – Angs Apr 5 '18 at 11:22
  • \$\begingroup\$ @Angs: Thanks. Changed. \$\endgroup\$ – sergiol Apr 5 '18 at 11:27
  • \$\begingroup\$ @user202729: I don't care. Windows, Linux, Mac, whatever, ... \$\endgroup\$ – sergiol Apr 5 '18 at 11:28
  • \$\begingroup\$ @Nathaniel: It is intentional. If you have a language feature called bitness(program) returning 32bits you do not need to waste more bytes removing the bits part! \$\endgroup\$ – sergiol Apr 5 '18 at 11:30
  • \$\begingroup\$ The word "challenge" is not really true, at least for ELF. It's absolutely trivial. \$\endgroup\$ – Peter Taylor Apr 6 '18 at 20:20
  • \$\begingroup\$ @PeterTaylor : Changed, thanks. \$\endgroup\$ – sergiol Apr 6 '18 at 21:20
  • \$\begingroup\$ The real "challenge" is to know the executable file format, so this becomes more of a puzzle than a challenge. And for puzzles, people can just copy others' solution and port to other languages. // Consider having some popular file format in the challenge itself so people don't have to look up them? \$\endgroup\$ – user202729 Apr 7 '18 at 11:19
  • \$\begingroup\$ @user202729: My initial idea was to ask only for Windows .exe files but I changed my mind because it was too limiting. Without such restrictions the question becomes multi-platform. \$\endgroup\$ – sergiol Apr 7 '18 at 11:38

The challenge

  • Write a Discord bot with a single command, !oldest, that gives the oldest user in the server that the command that was run in.

  • Gracefully failing in DM channels is not required.

  • Assume the bot's token is this invalid token: MjM4NDk0NzU2NTIxMzc3Nzky.CunGFQ.wUILz7z6HoJzVeq6pyHPmVgQgV4.
    If the token is compressed in the program, provide instructions on how to change it so I can test it.

Sample discord.py implementation

import discord
client = discord.Client()
async def on_message(M):
  N=sorted([x.id for x in M.server.members])[1]
  await client.send_message(M.channel, str(M.server.get_member(N)))
  1. Get a list of every user in the server
  2. Sort their snowflake IDs
  3. Print the username and discriminator of the member with the smallest ID.

No API for your language? Have fun.

Standard loopholes forbidden, etc, etc.

Shortest code in bytes wins.


I originally posted this question on the main site, but I deleted it, as it turns out I'm bad at writing these. Please forgive me.

  • 1
    \$\begingroup\$ I'm sure I've seen this already, but with comments saying that it needed a lot more information to be self-contained. It still needs a lot more information to be self-contained. \$\endgroup\$ – Peter Taylor May 5 '18 at 11:11
  • \$\begingroup\$ Yep. I've edited the question to clarify. \$\endgroup\$ – SIGSTACKFAULT May 5 '18 at 12:35
  • 2
    \$\begingroup\$ Are you talking about discord servers? Other than form the example this is not clear at all. What is a DM channel? What is a token in this context? \$\endgroup\$ – flawr May 5 '18 at 13:02
  • \$\begingroup\$ A: Clarify that you're talking about Discord B: When you make a challenge that requires a library does that mean I can use a library that conveniently has the command you're asking of? \$\endgroup\$ – IQuick 143 May 6 '18 at 2:12

Divide two strings

One day, I saw the challenge to multiply two strings and I thought I might be able to do one better.

That challenge was fake. It was elementwise maximum. It was not real multiplication. So I set out to make something real. Real division between two strings.

I quickly realized that this would make an amazing challenge, as the algorithm was surprisingly complex and interesting to implement.

I then realized that it was actually easily reduced into a mere few operations. I'm still doing the challenge, though.

Enough with the backstory. Let's go.


To divide two strings, do the following, where x is the first string and y the second:

  • If x does not contain y, return a space and a period concatenated to x.
    • For example, testx and blah would become .textx, with a space at the beginning.
  • Otherwise, return every occurrence of y in x, a period, then y divided by x with every occurrence of y removed, with all the periods removed.
    • For example, eestestst and est would become estest.est.


Write a program or function that, given two strings via standard input, returns the first string divided by the second.

You may assume that neither input string contains a space, newline or period, and that the operation does not require more than 10 layers of recursion.

Test cases

test, es => es. es
test, blah =>  .test
okayye, y => yy. y
testes, es => eses. es
battat, at => atat. at
see, es =>  .see
see, e => ee. e
same, same => same. 
aabb, ab => ab.ab 
eestestst, est => estest.est
aheahahe, aheah => aheah.aheah ah


As this is , the submission with the least amount of bytes wins.

Sandbox questions

  • Is this a duplicate?
  • Have I missed anything?
  • Does anything need further explaining?
  • Is there an issue with the concept of the challenge?
  • \$\begingroup\$ What for aabb / ab? \$\endgroup\$ – l4m2 Jun 1 '18 at 12:42
  • \$\begingroup\$ okayye, y => yy. okay typo? \$\endgroup\$ – l4m2 Jun 1 '18 at 12:42
  • \$\begingroup\$ The test case battat, at => atat. by seems like it should be battat, at => atat. bt instead. \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 13:47
  • 1
    \$\begingroup\$ It seems odd to me that when no characters are matched the output format is {matched characters (empty)}<space>.{unmatched characters} while the format when there are matches becomes {matched characters}.<space>{unmatched characters}. I would much rather see consistent ordering of the . and <space> \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 13:50
  • \$\begingroup\$ @KamilDrakari 2 / 4 is 0.5, not .05, when 4 is not contained within 2 at all. Thus it makes no sense for test / blah to be . test when blah is not contained within test. We treat a space essentially like a zero would be with normal numbers. \$\endgroup\$ – LyricLy Jun 1 '18 at 22:15
  • 1
    \$\begingroup\$ @LyricLy 6/4 is 1.5 not 1.05. If you're treating space as 0 then there shouldn't be any space after the dot in any of the test cases. \$\endgroup\$ – Kamil Drakari Jun 1 '18 at 22:58
  • \$\begingroup\$ @KamilDrakari Actually, you're right. I was entirely mistaken because you get a fraction from 1 / remainder, not original number / remainder. Meaning this entire thing is wrong and I need to figure out a good replacement for 1 in string form. \$\endgroup\$ – LyricLy Jun 2 '18 at 3:32
  • \$\begingroup\$ Fixed the issues. \$\endgroup\$ – LyricLy Jun 2 '18 at 3:50
  • \$\begingroup\$ I accept downvotes, but I'd appreciate suggestions on how to improve the idea, or at least an explanation of what's wrong with it, so I know why I shouldn't post it. \$\endgroup\$ – LyricLy Jun 2 '18 at 8:18
92 93
95 96

You must log in to answer this question.

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