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

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

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

# Can my favourite team still become Football Champion? code-golf

As a fan of an at most moderately successful footballBE team, towards the end of the season I often wonder whether my favourite team still has any theoretical chance left of becoming champion. Your task in this challenge is to answer that question for me.

# Input

You will recieve three inputs: the current table, the list of remaining matches, and the current position of the team we are interested in.

Input 1: The current table, a sequence of numbers were the i-th number are the points gained by team i so far. For example, the input [93, 86, 78, 76, 75] encodes the following table (only the last column is of importance):

Input 2: The remaining matches, a sequence of tuples where each tuple (i,j) stands for a remaining match between team i and j. In the above example, a second input of [(1,2), (4,3), (2,3), (3,2), (1,2)] would mean that the remaining matches are:

Chelsea vs Tottenham, Liverpool vs Man. City, Tottenham vs Man. City, Man. City vs Tottenham, Chelsea vs Tottenham


Input 3: The current position of the team we are interested in. For example, an input of 2 for the above example would mean that we'd like to know whether Tottenham can still become champion.

# Output

For each remaining match of the form (i,j), there are three possible outcomes:

• Team i wins: Team i gets 3 points, team j gets 0 points
• Team j wins: Team i gets 0 points, team j gets 3 points
• Draw: Team i and j both get 1 point

You must output a truthy value if there is some outcome for all remaining games such that at the end, no other team has more points than the team specified in the 3rd input. Otherwise, output a falsy value.

Example: Consider the exemplary input from the above section:

Input 1 = [93, 86, 78, 76, 75], Input 2 = [(1,2), (4,3), (2,3), (3,2), (1,2)], Input 3 = 2

If team 2 wins all its remaining matches (i.e. (1,2), (2,3), (3,2), (1,2)), it gets 4*3 = 12 additional points; none of the other teams gets any points from these matches. Let's say the other remaining match (i.e. (4,3)) is a draw. Then the final scores would be:

 Team 1: 93, Team 2: 86 + 12 = 98, Team 3: 78 + 1 = 79, Team 4: 76 + 1 = 77, Team 5: 75


This means that we have already found some outcome for the remaining matches such that no other team has more points than team 2, so the output for this input must be truthy.

# Details

• You may assume the first input to be an ordered sequence, i.e. for i < j, the i-th entry is equal to or greater than the j-th entry. The first input may be taken as a list, a string or the like.
• You may take the second input as a string, a list of tuples or the like. Alternatively, you may take it as a two-dimensional array a where a[i][j] is the number of entries of the form (i,j) in the list of remaining matches. For example, a[1][2] = 2, a[2][3] = 1, a[3][2] = 1, a[4][3] = 1 corresponds to [(1,2), (4,3), (2,3), (3,2), (1,2)].
• For the second and third input, you may assume 0-indexing instead of 1-indexing.
• You may take the three inputs in any order.

Please specify the exact input format you chose in your answer.

Side node: The problem underlying this challenge was shown to be NP-complete in "Football Elimination is Hard to Decide Under the 3-Point-Rule". Interestingly, if only two points are awarded for a win, the problem becomes solvable in polynomial time.

# Test Cases

All test cases are in the format Input1, Input2, Input3.

Truthy:

• [93, 86, 78, 76, 75], [(1,2), (4,3), (2,3), (3,2), (1,2)], 2
• [50], [], 1
• [10, 10, 10], [], 3
• [15, 10, 8], [(2,3), (1,3), (1,3), (3,1), (2,1)], 2

Falsy:

• [10, 9, 8], [], 2
• [10, 9, 9], [(2,3), (3,2)], 1
• [21, 12, 11], [(2,1), (1,2), (2,3), (1,3), (1,3), (3,1), (3,1)], 2

# Winner

This is , so the shortest correct answer (in bytes) wins. The winner will be chosen one week after the first correct answer is posted.

Closely related to Words from periodic table of elements (but that one is closed due to unclear specification?).

Closely related to Find the Chemistry of a name (probably a dupe, slightly different requirements though).

Closely related to [Br]eaking Code Golf [Ba]d (allows strings to be not expressible as solely a sequence of element abbreviations).

May I get a community consensus, whether this is better specified and/or sufficiently different to not be immediately closed as a dupe?

## Elementize a string

Convert an input string to a concatenation of chemical element abbreviations.

Write a program/function/procedure etc. which will take as input a string/array of characters/pointer to a string etc. and return/print/display the same string expressed as a concatenation of chemical element abbreviations.

For example, takagi can be expressed as TaKAgI (i.e. the abbreviations for Tantalum(Ta), Potassium(K), Silver(Ag), Iodine(I)).

For this challenge you must use the following element name abbreviations:

{"H", "He", "Li", "Be", "B", "C", "N", "O", "F", "Ne", "Na", "Mg",
"Al", "Si", "P", "S", "Cl", "Ar", "K", "Ca", "Sc", "Ti", "V", "Cr",
"Mn", "Fe", "Co", "Ni", "Cu", "Zn", "Ga", "Ge", "As", "Se", "Br",
"Kr", "Rb", "Sr", "Y", "Zr", "Nb", "Mo", "Tc", "Ru", "Rh", "Pd",
"Ag", "Cd", "In", "Sn", "Sb", "Te", "I", "Xe", "Cs", "Ba", "La",
"Ce", "Pr", "Nd", "Pm", "Sm", "Eu", "Gd", "Tb", "Dy", "Ho", "Er",
"Tm", "Yb", "Lu", "Hf", "Ta", "W", "Re", "Os", "Ir", "Pt", "Au",
"Hg", "Tl", "Pb", "Bi", "Po", "At", "Rn", "Fr", "Ra", "Ac", "Th",
"Pa", "U", "Np", "Pu", "Am", "Cm", "Bk", "Cf", "Es", "Fm", "Md",
"No", "Lr", "Rf", "Db", "Sg", "Bh", "Hs", "Mt", "Ds", "Rg", "Cn"}


These are the elements with numbers 1 through 112. You may optionally also use the abbreviations for elements 113 through 118:

{"Nh", "Fl", "Mc", "Lv", "Ts", "Og"}


You may not, however, use the placeholder three-letter abbreviations for not yet named elements, such as "Uuo" (Ununoctium).

If the input string cannot be expressed by the above abbreviations, you shall return one of the following:

• a falsey value (clearly distinct from element names, in other words A would not be valid, even though there is no element "A"; something like 0, null, false, newline is fine)
• an empty string
• exit without output
• exit with an error
• something similarly unambiguous signifying failure and not returning some incorrect output that could be accidentally misinterpreted as an answer (suggestions to make this specification clearer?)

Possible output, using example input takagi:

• an appropriately capitalized string: TaKAgI.
• a flat array of characters {"T", "a", "K", "A", "g", "I"} with appropriate capitalization.
• a list of strings (capitalized or not) separated by newlines or as separate members of an array, etc., e.g. ta \n k \n ag \n i.

The rule of thumb is that the division into separate elements must be clear. Please comment if additional clarification is needed!

You may assume the input to be a single word consisting only of letters.

Compression is not the intent of this challenge! Boiler-plate code that fetches the list of elements from somewhere, hard-coding the lists of abbreviations, assuming the list of abbreviations to be stored in a variable or passed as a second argument to your function is OK and should not be included in the byte count.

Sample input -> sample output
no -> No             // as in Nobelium, alternatively see next line
no -> NO             // Nitrogen-Oxygen, either one is valid
helium -> falsey output
heliam -> HeLiAm
fog -> FOg           // If using 118 elements, falsey otherwise.
ppcg -> falsey       // I'm really, really sorry


Suggestions of further test cases are appreciated.

This is code-golf, shortest code wins.

• Potassium is K, not P. – CalculatorFeline Jun 1 '17 at 2:44
• @calculator brain-fart, fixed, thanks. – LLlAMnYP Jun 1 '17 at 4:35
• I think it makes more sense to work on improving the existing closed question than to post a duplicate. – Peter Taylor Jun 1 '17 at 6:30
• @Peter I should have realized sooner, that a [chemistry] tag exists here. I'm not sure I'm at ease with modifying someone else' challenge (distorting their intent?) and potentially invalidating others' answers... – LLlAMnYP Jun 1 '17 at 6:37

# How many substitutions till palindromization?

Given a string, find the minimum number of character substitutions needed so that the string is a palindrome.

E.g. the string abchefa needs 2 substitutions, so it can take any of the following paths:

abchefa -> afchefa -> afehefa
-> afchcfa
-> abehefa -> afehefa
-> abeheba
-> abchcfa -> afchcfa
-> abchcba
-> abcheba -> abeheba
-> abchcba


You must return a minimal number, e.g. abc can use 3 substitutions (abc -> dbc -> ddc -> ddd) but it really only needs 1 (abc -> aba) so you must return 1.

The string will only contain printable ASCII, no newlines.

Input
Output

0

A
0

!@
1

1234567890
5

!"#%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_abcdefghijklmnopqrstuvwxyz{|}~ 47 aaabaaacaqadaaq 3 o_O WTF RLY?! 6  # Rules • You can take the string as a string or as a list of chars, but not as a list of strings • You must return a minimal value in a generally accepted output format. • I thought there was a near-dupe somewhere, but I'm pretty sure this is the one I was thinking of... – ETHproductions Jun 1 '17 at 23:38 • Actually this might be a dupe of this: perform any answer for all indexes in the string, sum, divide by two. – ETHproductions Jun 1 '17 at 23:41 • @ETHproductions You spoiled the hidden way to do it... – Erik the Outgolfer Jun 2 '17 at 5:39 • I'm pretty sure I've seen an exact dupe, although it might still be in the sandbox; codegolf.stackexchange.com/q/95343/194 is a generalisation. – Peter Taylor Jun 2 '17 at 9:00 # Write machine code that also works when left rotated one byte Write machine code for a CPU that runs and does something. The twist is that your code should run and do something else, without errors, if it is left rotated one byte. Suggestions? Ideas? Thoughts? Let me know. • So is this "any code that doesn't crash if rotated"? Generally it's best to give a specific task, not just "do something", or else it's quite broad. – Geobits Oct 26 '16 at 0:15 • This is completely uninteresting in any instruction set which has one-byte instructions. E.g. in x86 the byte that's rotated away can be INC, and then the "something else" is just the same function with an offset to one of the arguments. – Peter Taylor Oct 26 '16 at 7:53 • Far too broad, IMO. Also very, very easy in machine code dialects which have single-byte jump instructions, or any instruction that has a single-byte opcode plus X bytes of data, where X is no shorter than the length of the jump instruction; this describes almost every machine code dialect in existence. – user62131 Jun 2 '17 at 15:03 • What about reversing it? – anna328p Jun 2 '17 at 16:49 ## Reverse divmod ## Introduction The divmod function is one that is included in many standard libraries and is defined as follows: Or, in other words, divmod(a,b) returns a list containing the integer quotient of a/b (i.e. floor(a/b)) and mod(a,b) (i.e. the remainder in the division of a/b). Your challenge is not to implement the divmodfunction, but rather reverse it. ## Input You will take two integers x and y as input, in any reasonable input format (two integers, list, etc.). Both x and y are guaranteed to be in the range -2^31 to 2^31-1, inclusive. ## Output The output of your code shall be two integers, in any reasonable output format (two integers, list, etc.). Note that you must output the two integers in such a way that a human is able to distinguish one from another. These two integers should be an a and b such that divmod(a,b)==(x,y) (i.e. floor(a/b)==x && mod(a,b)==y). Please specify in your answer how these two integers are outputted if it is not immediately clear (for example, if you output b before a). Remember that this is , so shortest solution in bytes wins! • Note to self: add I/O examples – GamrCorps Jun 3 '17 at 2:10 • So: given x and y output x*b+y, b for any b > y if y is positive or b < y if y is negative? Or have I missed something? – Peter Taylor Jun 3 '17 at 12:59 • @PeterTaylor No you haven't, I realized that the challenge is much simpler than I originally thought (because of the method you mentioned). I am going to try and increase the difficulty later. – GamrCorps Jun 3 '17 at 13:05 # Help me golf my numbers! (Part 2) code-challengetest-battery Thanks for all your help in Part 1! I recently just found out that my language also supports expressions, and we can use those to make our numbers even shorter! # Challenge Write a full program that takes in a list of integers less than 2^53-1. For each integer, rewrite it in the shortest way possible using expressions, and output the result. # Allowed operators The operators below are given in order of precedence from highest to lowest, with groups separated by empty lines. (These precedence levels are the same as Python.) All binary operators are left-associative, except exponentiation, which is right-associative. Note that some operators are two bytes in length. **: Exponentiation * : Multiplication / : Integer Division % : Modulus + : Addition - : Subtraction ~ : Bitwise NOT <<: Left shift >>: Right shift & : Bitwise AND ^ : Bitwise XOR | : Bitwise OR  You may use decimal, hexadecimal, or scientific notation to represent integers in your output (the answers to Part 1 will help you choose the shortest representation for each integer). You may also use parentheses to group subexpressions. # Scoring I will post a list of 1000 integers to be used as the test battery. A program's score will be the size of the output for the provided test, where the lowest score wins. A solutions is invalid if any of the expressions do not evaluate to the given integer. There will also be an execution time limit of 20 minutes for all 1000 inputs (roughly 1 second per input) in order to discourage brute-force solutions. Numbers for the test battery will be chosen according to the following algorithm: def choose(): msb = randint(0, 52) return randint(0, 1 << msb)  with duplicates filtered out. # Sandbox • Is there anything here that can be clarified? • Anything else that can make this challenge more fun? • Sandbox #2 - I don't think bitwise operators will make it too broad. #3 The community has generally agreed that penalties do not make the challenge any more interesting. General advice- make some more rules. Clarify what you mean by "shorten them as much as possible", I had to read that three times to understand. And what do you mean by takes a list of integers? How does one shorten a list using arithmetic? – MD XF Jun 2 '17 at 22:32 • You should specify how your expressions handle precedence and associativity. I assume expressions can use any number literals? – xnor Jun 2 '17 at 22:38 • I think it would be good to say something about you're choosing numbers for the test battery. If they are random, heuristic solutions will be effective (or maybe just hardcoding?). Or, if you intentionally choose inputs that benefit from rarely-useful operations like %, that would be useful to optimize for. – xnor Jun 2 '17 at 22:41 • @xnor Yes, they may. I'll add information about precedence and associativity as well. – musicman523 Jun 2 '17 at 22:41 • @xnor Good point. My plan was to choose randomly, do you think this is a good idea? – musicman523 Jun 2 '17 at 22:42 • I think random would be good. Maybe with some bias towards shorter numbers so they're not all 50-ish bits. It might hard though to beat hardcoding, though the bitwise operations might help. Perhaps you could try to hand-optimizing some random numbers and see how well you do. I think you also need something to rule out brute-force solutions, like a run-time bound. – xnor Jun 2 '17 at 22:46 • I feel like this might be a dupe. – Shaggy Jun 3 '17 at 10:54 • @Shaggy could you link to the duplicate please? – musicman523 Jun 3 '17 at 12:12 • I haven't figured out the right search terms to get me there yet. – Shaggy Jun 3 '17 at 12:29 • @xnor I added a possible algorithm for choosing numbers as well as a time bound. Do you think this is ready for posting? – musicman523 Jun 3 '17 at 18:39 • @musicman523 Having thought about it a bit more, I worry hardcoding the number is too effective. It seems really unlikely a random number allows a shorter arithmetic expression than its digit length. I'm not even sure such a number would appear in 1000 samples. – xnor Jun 3 '17 at 19:14 • I agree. I previously entered 'there can be only one' ( codegolf.stackexchange.com/questions/92962/there-can-be-only-1 ), which was simliar but only allowed using '1'. I don't believe the operators will be useful for almost all numbers, and if you require an operator is used people will just use '+1' most of the time. While a break from your original plan, you could (for example) require using scientific notation, with one number before and after the 'e', so things like '2e5' and '3e7'. That would make operators required and useful. – Chris Jefferson Jun 4 '17 at 21:12 • Maybe make operators cost less than digits. e.g each operator is 2 and each digit is 5 in order to discourage hardcoding – H.PWiz Jul 9 '17 at 15:53 • Not a bad idea. I'll probably revive this at some point. Thanks guys! – musicman523 Jul 9 '17 at 18:43 ## Insert a simulated Ken Thompson virus into a program code-golfcode-generation A Ken Thompson virus is a virus that infects your compiler and other programs. Since it infects all your tools, you can not detect it without using tools from before the virus was introduced. Your will create a prototype for inserting the Ken Thompson virus into code. The goal of this virus will be to allow you to (fake) destroy any computer running a program infected with it. Inserting a Ken Thompson virus is defined as follows. Start with an input program P. Your program will output a modified program Q that works as follows: • If the input to Q is aNouIQ5xKvUfdZVzo0Xs, it will output BOOM (in a real Ken Thompson virus, this would actually do something bad, but since it this is a fake virus, outputing BOOM is done instead). • For any other input to Q, run program P with that input • If the output of P is valid source code in the language you are using, insert the Ken Thompson virus into it and then Q will output the resulting infected program. • Otherwise, the output of Q is just the output of P. You will write a program that takes P's code as input and produces Q's code as output. You can use either a currently (at the time of this post) existing programming language, or a subset of one, for this challenge. (The idea is that language you are using would be the target language of some self-compiling compiler, but this is not required.) Since you want to be as subtle as possible, the shortest code (in bytes) wins! # Find the Harmonic Mean The harmonic mean of a sequence of numbers is the reciprocal of the arithmetic mean of the reciprocal of each number. For example, the harmonic mean of [1, 2, 3] is 1/((1/1+1/2+1/3)/3) = 3/(1/1+1/2+1/3). ### Input A list/array/tuple/string with some delimeter/etc. of positive integers which fit within the standard integer/float type of your language of choice. ### Output The harmonic mean of those integers, accurate to at least 6 (?) decimal places. ### Test Cases input => output 1 4 4 => 2.0 1 2 3 => 1.63636 527 => 527.0 52 33 400 => 52.6548 7 20 333 45 1 => 4.10481  • Sub-challenge of this. – FryAmTheEggman Jun 6 '17 at 1:28 • If you're going to specify the output accuracy in decimal places you need to restrict the input such that it's possible. A 64-bit floating point number (double) can represent about 16 significant decimal figures, but it can represent numbers up to a bit more than 10^300. – Peter Taylor Jun 6 '17 at 7:30 • @PeterTaylor not really sure how to handle this... I want people to be able to use the most natural method without allowing silly abuses such as "I can only handle one decimal place" or something. – Cyoce Jun 6 '17 at 7:40 • If you guarantee that there will be at most 20 numbers, all in the range 1E-8 to 1E8 then I think that should easily be sufficient. – Peter Taylor Jun 6 '17 at 8:46 ## The problem As I sometimes build bots, I often came across real time image reading. The goal in this problem is to be able to identify a character given pixel representation with the minimal amount of tests. For that, you will have to generate a tree that can identify any char. ## Input • A list of frequency • A png file containing each char in a 1 wide red box. Its exact color is #ed1c24 and it is not present in any of the chars. ## Output A series of specific test that can identify any char. A test is defined by the pixel coordinates, the exact colour to check, the list of chars to have this pixel and the list of chars that donot. ## Example Let's have a look at only four chars (number 1-4) of equal frequency. Here we could say that we check for the for pixel in 0,0 (upper left corner). If it is white, it means it's a 1, otherwise we check for the pixel 1,0 (to the right of the upper left corner). If this one is white, it's a 4, otherwise we check for the pixel in 2,2 (the blanck beetween the 3 and the box). If it is white, it's a 3, otherwise it's a 2. That way we can identify any number in 3 tests at most. If we calculate our score with this layout, it would be 0.25x1 + 0.25x3 + 0.25x3 + 0.25x2 = 2.25 so on average our tree needs 2.25 pixel reading to identify a number. The solution that lead to that is written like this: [0,0], [255,255,255], [1], [2,3,4] [1,0], [255,255,255], [4], [2,3] [2,2], [255,255,255], [3], [2]  However the best solution for this example has a score of 2. One of the trees that lead to that is [0,1], [255,255,255], [1,4], [2,3] [0,0], [255,255,255], [1], [4] [2,2], [255,255,255], [3], [2]  ## Rules • Count each time you read a pixel. • Use the number frequency to average your score • Your score is the sum of the char frequency times the number of pixels read to identify this number. • What do you mean by 'any number'? If it is more than 1,2,3,4, you should demonstrate what these additional numbers look like. – NonlinearFruit Jun 7 '17 at 13:26 • Good point. I meant any chars, I extended the problem while writting it. I will fix this – Philippe Jun 7 '17 at 13:48 # Sources and Strings The challenge: Output a string with the same length as the source code. The requirements: • Standard loopholes apply, etc., etc. • Input may not be taken • The output must be deterministic (for scoring purposes) • Output must be a string • Functions and full programs are allowed, no snippets though The scoring: This is , so the shortest code in bytes wins. However, for each individual character in the source that has a match in the outputted string, your byte score is increased by 2 bytes. Examples of scoring (of course, most of these aren't working programs): Program Output Score nn ng 2+(1*2)=4 print('h'*14); hhhhhhhhhhhhhh 14+(1*2)=16 print('prnt'*4); prntprntprntprnt 16+(8*2)=32 q q 1+(1*2)=3 qwertyuiop mmmmmmmmmm 10+(0*2)=10 System.out.println("lol"); Invalid=Infinity points  # Prime Factors Zip Take an integer strictly greater than 2, for example 66. Its prime factors are [2,3,11], when ordered from smallest to biggest. If we zip the digits of those factors, we get [231,1]. Multiplying them yields the integer 231. If we apply this process back on 231, we get 371. If we apply this multiple times, we get the following sequence: 66 231 371 225 3355 5676 290082 770229 174999300 121860997014 6330393355581 40168037420160 6869559509647641812624 0  At this point, we stop because 0 cannot be factored. We say that 0 is the prime factors zip of 66. If we start with 19, we get the following sequence: 19 9 33 31 3 3 …  Here, we can see that once we reach 3, we will always get 3. Therefore, 3 is the prime factors zip of 19. If we start with 22, we get the following sequence: 22 21 37 21 37 …  Here, we can see that once we reach 21, we will always get the loop [21,37]. Therefore, [21,37] is the prime factors zip of 22. Note that it is possible for an integer to be its own prime factors zip (e.g. 5) or that it is contained in its prime factors zip (e.g. 23 which has prime factors zip [23,6]). ## Task Given an integer strictly greater than 1, output its prime factors zip. This is , so the shortest answer in bytes wins. ### Test Cases Input Prime factors zip 7 7 46 0 48 [22103,72463] 100 0 113 3 1337 [337,63]  ### Sandbox I have no idea (nor have I checked extensively) if it is possible than this procedure never loops for some integers. • I'd suggest explaining "zip" more precisely. I think it is more commonly called "transpose" and you could try to visualise it by drawing out a matrix? For the never looping thing, I think you can just say the programs don't have to handle that. – FryAmTheEggman Jun 9 '17 at 14:22 # Color the Grayscale Given an image containing only grayscale colors (for RGB, R==G==B), and a RGB value (that is not grayscale), color the image with your given color. //Is there a formula that does this? If so this can definitely have objective input and output. Should this be like a lot of the other challenges? # Draw an XBox Here's an X: \ / \/ /\ / \  And here's a Box: +----+ | | | | | | | | +----+  So, for an XBox, just draw an X in a Box: +----+ |\ /| | \/ | | /\ | |/ \| +----+  Your input will be a number (in any standard way) that will represent the size of the box. To output the above box, this could be the number of -/|\s (4), or the number of lines/columns (6), or even the intercept of the second diagonal (5) would be acceptable. (Don't ask me to accept the base256 encoding of the output though, as that's one of the many banned standard loopholes.) Your program or function should then output (in any standard way) the XBox of the given size. If the \/s cross in the same character, place an X (as per Draw a big slash X). For example, here's an XBox three sizes larger than the one above: +-------+ |\ /| | \ / | | \ / | | X | | / \ | | / \ | |/ \| +-------+  This is , so the shortest program wins! • in some obvious way unclear/subjective – MD XF Jun 9 '17 at 16:35 • @MDXF 4 examples weren't sufficient? – Neil Jun 9 '17 at 17:04 • I'm just warning you that it could get closed for being too broad due to that statement. – MD XF Jun 9 '17 at 17:05 • I agree with @MDXF – Beta Decay Jun 9 '17 at 18:03 • @BetaDecay That's all very well, but I'm unclear as to what you want. – Neil Jun 9 '17 at 19:15 • Just a basic explanation of how scaling works. Some examples would suffice – Beta Decay Jun 9 '17 at 21:32 • I've added an example. – Neil Jun 10 '17 at 0:42 • @MDXF Here's my problem. I just tried implementing this in Charcoal, and came up with Try it online!. As it turns out, to produce those example XBoxes I actually need sizes of 7 and 10, but I didn't want to penalise that choice of input just because I hadn't predicted that particular scaling. – Neil Jun 10 '17 at 13:42 • @BetaDecay If you still have any further input it would be appreciated. – Neil Jun 12 '17 at 12:06 • Related – Kevin Cruijssen Jun 15 '17 at 11:57 • @KevinCruijssen Ugh, I even have an answer on that question... I guess the use of specific characters doesn't really sufficiently distinguish this one. – Neil Jun 15 '17 at 12:42 • @Neil Well, using /+x\ instead of just * does make it a bit trickier, but it's indeed a bit too similar imho. – Kevin Cruijssen Jun 15 '17 at 13:11 # This question is up for adoption! If you would like to finish and post it, please include a little mention for @gryphon :) # Battle of the Bots ## Your Task Program a bot to compete in a battle with other bots. Each robot has fifteen flags situated around their exterior. Your goal is to have at least one flag left on your robot for as long as possible. Each turn you will move diagonally (or not at all) on a square grid with a width/length equal to the number of bots competing squared (attempting to move off the edge of the grid will result in either you moving adjacent to your previous position, or no movement at all if attempting to move from a corner), and use two or less of the four weapons/shields that are situated facing along the horizontal and vertical rows of the grid. You will choose which weapon you would prefer to have in each of your four slots at the beginning of the game. After 2,500 turns, each bot with flags remaining will receive a 500 point bonus, and the game will end. If all flags have been destroyed before this time, the game will end then. The winner will be the person with the most points at the end of 1,000 matches. ## Your Code Each bot will begin in a randomly chosen location on the playing field (bots may be on top of each other). Your code will take the form of two python 2.7 functions, one named (name of your submission) start, which will take no input and return 4 values, one for each weapon/shield slot. The first value will be the top of the bot, and they will continue in clockwise order. The integer values to be returned and weapons/shields they represent are shown below: 1: Firestarter, a weapon that will start a fire adjacent to the bot. Fires start at class 1 and increment upward every turn. If, at the start of a bot's turn they are on top of a fire they lose flags equal to the level of the fire. If a fire is at level 3, it spreads fires of level 1 to all directly (not diagonally) adjacent squares that are not already on fire. When a fire reaches level 8, rather than becoming a level 8 fire, it dies, turning back to an "O" on the map, having used up all available burning material. It may then be lit on fire again in the future. 2: Laser, a weapon that destroys one flag on any bot in a straight line from its firing point outwards from the bot. 3: Buzzsaw, a weapon that destroys five flags on any bot adjacent to the bot using it on the side it is used on. 4: Shield, a defensive mechanism that protects flags from lasers and buzzsaws, and is unaffected by our next weapon. 5: Acid Sprayer, a weapon that destroys the weapon facing it on any bot within three spaces of the bot using it in a straight line (not an arc) from its mounting point Your second function will receive, first the turn number, second a map of the battlefield in a string, with "R" representing robots (including itself), "O" representing empty space, and the level a fire is at representing any fires. The end of a row will be shown with a semicolon ";". For example, if the battlefield looks like this: OORO131OO OOOOO1OOO ROOOOOOOO OOOOOOOOO OOOOOOOOO OOOOOOOOO OOOOOOOOO OOOOOROOO OOOOOOOOO  Each bot will receive this: OORO131OO;OOOOO1OOO;ROOOOOOOO;OOOOOOOOO;OOOOOOOOO;OOOOOOOOO;OOOOOOOOO;OOOOOROOO;OOOOOOOOO  Next, the bot will receive its X coordinate, and then its Y coordinate, 0 indexed and with the top left corner being 0,0. Finally, the bot will receive how many flags it has remaining. If multiple bots are in the same square, only a single "R" will be shown. If a bot is standing on the same square as a fire, only the fire will be shown. A bot can tell if it is standing on a fire if its own X and Y coordinates show an integer rather than a "R". ## Sample Bots Will show sample bots here when they are completed ## Controller Will show controller here when it is completed ## Additional Rules • No copying other bots, or copying with only minor changes. • No messing around with the judging process, other bots, or writing programs to acquire information that does not come from the inputs given to them, randomizers, or other legitimate sources of information. • No writing bots specifically designed to prop up other bots. • Maximum of three submissions per user. # Meta: Is the explanation clear enough? Are there any loopholes for programs to exploit? Any tags other than ? • There are a few points which I think could be clearer. 1. The description of the goal ("on average ... one or more flags left on it for the longest period of time") doesn't seem to match the actual scoring mechanism. 2. Must the weapon selection be deterministic? 3. Does a fire spread to adjacent cells on the turn that it becomes level 3 or on the next turn? 4. How do multiple fires interact? 5. Having burnt to level 8, can a cell be set on fire again in the future? 6. Does the acid sprayer work along the same axis-aligned line as the laser, or does it hit in a semicircle? – Peter Taylor Jun 5 '17 at 11:00 • 7. How does a bot know whether the cell it is currently standing in is on fire? 8. I assume that movement is blocked at the edges, but this could be more explicit. – Peter Taylor Jun 5 '17 at 11:01 • Edited to fix concerns. – Gryphon Jun 6 '17 at 17:15 • you should probably use classes rather than two functions, since the ability to remember how opponents behave is useful. – Destructible Lemon Jun 7 '17 at 23:23 • @DestructibleLemon, I've actually moved on from this challenge now, so consider it abandoned. If you want, you can take it over. – Gryphon Jun 7 '17 at 23:25 • But... if I did that I would have three koths on the waiting list! – Destructible Lemon Jun 7 '17 at 23:29 • Wow, that is a lot. I dropped it because I'm working on a new language, but I may readopt it if no one else does after I'm finished. – Gryphon Jun 7 '17 at 23:36 # Patch Tuesdays Calendar Context Patch Tuesday happens every second Tuesday of the month, Microsoft and other companies release their monthly security patch on that Tuesday. Challenge The challenge is to write a program that writes 24 consecutive Patch Tuesdays dates separated by newline to the console. The Tuesdays must be the ones of the current year and the next year (not a parameter). Date format must be mm/dd/yyyy. Winning Code with the fewest bytes wins, there are no bonuses. Meta Is there a good write up with conventions for golf questions? ## Challenge My challenge, is for you to generate a Menger Sponge based on the level/iteration given. You need to draw it in 3d, see the Specifications below! 3D Specifications • You can use existing 3D libraries Examples Inputs: 0, 1, 2, 3 Outputs: ## Background Information What is a Menger Sponge In mathematics, the Menger sponge (also known as the Menger universal curve) is a fractal curve. It is a three-dimensional generalization of the Cantor set and Sierpinski carpet Properties See https://en.wikipedia.org/wiki/Menger_sponge#Properties (too long to copy and paste) How do I construct the sponge? 1. Begin with a cube (first image). 2. Divide every face of the cube into 9 squares, like a Rubik's Cube. This will sub-divide the cube into 27 smaller cubes. 3. Remove the smaller cube in the middle of each face, and remove the smaller cube in the very center of the larger cube, leaving 20 smaller cubes (second image). This is a level-1 Menger sponge (resembling a Void Cube). 4. Repeat steps 2 and 3 for each of the remaining smaller cubes, and continue to iterate ad infinitum. The second iteration gives a level-2 sponge (third image), the third iteration gives a level-3 sponge (fourth image), and so on. The Menger sponge itself is the limit of this process after an infinite number of iterations. Credit Background info taken from this wikipedia page on Menger Sponges. ## Good Luck! Remember this is the shortest program wins! ## HELP I need help with specifications for the 3d output: Since 3D is now required (invalidating existing answers), I think the question is now unclear. There is a lot you need to specify for 3D including but not limited to viewing angle, projection, lighting, shading. • This may be a bit too much for the usual golfing techniques. 3D graphics isn't easy to golf. – Daffy Jun 13 '17 at 21:32 • @Daffy Then, should I try making it a coding challenge? – Noah Cristino Jun 13 '17 at 21:33 • @downvoters - Noah has listened to advice and posted this in sandbox. If you downvote, please give some specific indication of what you think could be improved – Digital Trauma Jun 13 '17 at 21:33 • @NoahCristino Personally, I think it would make a better coding challenge, yes. – Daffy Jun 13 '17 at 21:35 • @Daffy If the question is about implementing a 3D rendering engine (I don't think it is) then you are probably right. However, if the OP chooses to allow the use of existing 3D libraries (which would not be untypical for this site), then I don't see a problem with it being code-golf – Digital Trauma Jun 13 '17 at 21:35 • @Daffy Ok, well I still need to specify the 3d specifications better. – Noah Cristino Jun 13 '17 at 21:35 • @DigitalTrauma I would like to keep it code golf, since people have already coded it like this guy: youtube.com/watch?v=LG8ZK-rRkXo – Noah Cristino Jun 13 '17 at 21:36 • I'll edit and say that you can use existing 3d libraries. – Noah Cristino Jun 13 '17 at 21:37 • @Daffy who said challenges need to be easy? There's a question with 250+ upvotes asking for Tetris inside of Conway's game of life... – steenbergh Jun 14 '17 at 14:33 • @steenbergh Hah! Very very good point. – Daffy Jun 14 '17 at 19:56 • Could output be as a list of vertices, with you providing a default renderer? This would eliminate the need for a 3d-render on the part of the answerer, might simplify things a bit... – steenbergh Jun 16 '17 at 11:03 • @steenbergh What if it was the x, y, z coordinates of each block? – Noah Cristino Jun 16 '17 at 18:16 • @NoahCristino That would come too far off of your 3d-idea, I believe. Unless you'd make this about voxels, perhaps?. – steenbergh Jun 16 '17 at 19:14 • @steenbergh but, you still technically outputting a representation of a Menger Sponge – Noah Cristino Jun 16 '17 at 19:49 # I Got All Night ## Meta • Is this interesting? • Has this already been submitted? • Issues/loopholes in the rules? • Suitable tags? ## The goal Make a program that takes as much time as possible to complete. That's it. ## Rules • It must not be infinite. while(1){} will not be accepted. • You must be able to show how long it will take. Either through calculating it or by measuring it. • It must be doing something non-trivial. for(var x=0; x<1000000000000; x++){y++;} will not be accepted. ## Scoring Your score is the time it takes to complete in milliseconds divided by the size of the program in bytes. Round to the nearest point if needed. For example, if your program is 95 bytes long and takes 3 hours to complete, your score is (3*60*60*1000)/95 = 113,684 (rounded) • busy beaver tag? – Destructible Lemon Jun 15 '17 at 2:29 • also nontrivial is a bad requirement – Destructible Lemon Jun 15 '17 at 2:29 • The main issue here is that time taken isn't objectively measurable on regular computers. Further, "trivial" is also not objective. Any computable task is largely equivalent to the for loop you have, besides some "minor" details. – FryAmTheEggman Jun 15 '17 at 2:29 • also be prepared for answers that would go past the heat death of the universe – Destructible Lemon Jun 15 '17 at 2:29 • @DestructibleLemon Please don't post so many short comments, this isn't a chat room. Take time to think through what you want to say, and say it all at once. You can edit your comments for a couple minutes to add more details you realised that you omitted. – FryAmTheEggman Jun 15 '17 at 2:32 • @FryAmTheEggman The wording I was going to use was "useful" instead of "non-trivial", but I figured that was even less descript. Do you have any suggestions for that? Also, what if I write a python script that measures computer speed (i.e. spinning around in a loop for 10 seconds, incrementing a variable) to normalize for different computer speeds? – Daffy Jun 15 '17 at 2:37 • @DestructibleLemon That's what I meant by Either through calculating it or by measuring it. If you can calculate that your program will take 15 billion years, then it's completely usable. Converting 15 billion years to milliseconds might be a hassle though ;) – Daffy Jun 15 '17 at 2:38 • You would have to run all the submissions yourself then, however the problem will then be answers that take too long to verify. Calculations would be very difficult to say, for example, what if my program will only run on some ancient computer, will I be able to use that clock time? Also what about context switches/interrupts/etc? Generally I don't think this kind of challenge works, it's sort of like why world records for "shortest concert" don't exist anymore: programs that take forever are not really programs. – FryAmTheEggman Jun 15 '17 at 2:46 • I think this ground has been well-covered by existing challenges to make large numbers and this would add anything new. – xnor Jun 15 '17 at 3:29 # Help me play Battleship! array-manipulationcode-golfgrid Battleship is a two-player guessing game in which each player guesses the placement of the opponent's ships, placed on a grid. Each column is labeled with a letter, and each row with a number. The label starts from top left (A and 1), and descends as you move right/down. Each player is given two grids, one for placing ships, and one for guessing the enemy's ship placement. Each player places 5 ships -- one ship of length 5, one ship of length 4, two ships of length 3, and one ship of length 2 -- on her grid, either horizontally or vertically. The players should not share their ship placements. After placing all ships, each player takes turn guessing the opponent's ship placements. The guessing player guesses one position, and the defending player must announce "hit" or "miss," depending on whether she (the defending player) had a ship there. When all positions of a ship is hit, it is "sunk." The player who sinks all of the opponent's ships win. This is an example of a battleship board (taken from Wikipedia): ## Task Given the list of guesses a player has made, construct a 10x10 array that represents the board. ## Rules • The input can take any reasonable format, as long as it is explained. Some examples are [[position, result], [position, result], ...] and [[hit positions], [miss positions]]. • The output array can have any characters, as long as empty, "hit," and "miss" squares are distinguishable from one another. (e.g. unknown = 0, hit = 1, miss = 2) • You may not take the list of unknown grid positions in the input. ## Test Cases Pastebin link # Sandbox • Is this challenge interesting? • Are there any dupes? (I couldn't find one) • Did I include too much detail in the introduction? (If so, what should I remove?) • Are my test cases sufficient? # Star Trekkin' Just an idea at this stage; wanted to get it down lest I forget it. I'll come back to it in a few days to work out the details. ## Challenge Generate an ASCII art representation of the USS Enterprise with an animated, randomised ASCII starfield behind it. Programming Challenge: Winning criterion is the shortest byte program which can tell me (x, y) which number "x" was doubled in the list, and which number "y" was removed from the list of 1000 numbers from 1 to 1000. Given a list of 1000 positive integers in random order, find the integer that is repeated more than once, the integers that are not present in the range [1,1000] and output the count of the repeated integer present in the list. The format of the list is a space deliminated text file such as this: 779 990 5 814 353 627 173 797 714 619 802 719 895 966 325 275 158 322 215 271 631 232 175 10 397 892 124 26 287 878 757 754 508 871 255 363 159 482 400 247 223 857 862 18 434 919 335 586 65 579 828 943 366 874 999 238 289 362 600 321 193 863 613 930 143 107 879 530 284 110 437 426 981 546 924 701 441 941 43 614 542 727 694 351 643 794 563 476 834 624 804 634 776 672 57 597 338 748 908 156 297 234 444 598 891 925 163 229 791 326 944 182 262 987 734 582 910 567 132 28 645 962 994 6 917 617 64 106 304 404 88 93 849 882 677 749 254 12 399 897 329 988 31 379 654 25 646 134 445 327 577 848 673 551 408 405 806 244 40 601 497 177 972 526 545 796 755 630 663 423 428 562 610 1 686 548 281 101 154 747 763 32 236 368 956 639 522 507 792 771 693 147 728 203 845 615 889 931 440 299 348 707 235 320 295 803 513 703 940 717 205 150 702 189 183 296 875 575 454 492 194 425 126 657 976 570 809 945 825 168 890 217 656 29 550 684 188 78 221 446 523 952 676 900 583 484 933 268 608 708 665 17 963 212 253 432 964 858 909 316 155 120 114 210 477 319 647 822 409 388 818 308 77 102 373 929 113 402 841 213 470 877 648 968 135 309 824 690 844 463 323 240 706 391 653 372 985 346 788 510 991 554 494 44 915 758 756 989 759 659 534 142 939 675 378 974 345 462 54 942 681 1000 7 716 415 42 264 996 438 464 386 350 197 141 84 123 127 811 853 516 60 49 277 70 986 98 733 905 978 103 390 230 501 449 731 34 370 541 958 466 251 71 108 846 260 576 830 100 140 529 869 333 303 664 589 856 777 427 187 184 305 766 829 136 456 786 401 737 961 475 412 887 178 91 698 448 433 62 519 832 314 957 861 898 683 983 515 893 220 817 979 149 267 3 63 458 473 139 970 835 666 119 967 695 343 242 947 41 47 623 973 53 354 74 816 121 471 151 246 369 499 45 593 691 376 111 46 226 83 431 274 606 506 265 753 79 387 451 883 525 479 744 162 949 8 292 95 97 324 823 315 152 394 671 718 347 836 50 195 360 812 566 725 612 923 537 911 620 51 328 243 19 556 592 288 334 298 873 655 443 705 66 767 604 285 760 896 474 406 73 918 688 667 914 730 729 826 959 774 543 594 192 27 948 912 491 419 341 518 55 146 787 495 904 172 469 761 840 626 637 144 616 465 712 660 785 365 250 636 384 208 2 174 864 839 741 410 621 342 442 245 568 998 485 216 960 224 239 782 855 291 355 860 807 936 920 56 669 561 697 112 270 715 913 938 364 851 467 751 468 450 995 609 490 72 674 713 640 185 801 361 742 38 784 167 225 743 692 790 907 859 762 569 115 521 116 200 580 632 997 85 82 249 207 486 218 196 14 932 867 429 258 125 793 69 865 385 902 222 531 611 658 318 935 980 808 23 105 722 300 520 30 420 286 662 227 581 745 585 928 330 638 358 587 16 452 635 736 489 252 89 951 137 591 721 880 555 204 535 769 9 820 605 854 148 128 934 396 480 307 161 711 750 704 651 696 133 813 789 517 263 775 553 75 992 293 190 916 273 602 461 11 977 202 764 483 76 52 773 723 870 872 498 359 868 67 544 504 279 833 599 48 171 687 80 547 336 417 642 181 558 906 256 219 81 866 810 709 186 668 572 145 209 739 682 847 752 720 332 393 770 965 574 629 176 746 306 138 798 15 528 778 392 457 726 337 39 86 380 160 493 211 436 180 241 795 94 955 837 214 584 954 117 549 59 340 805 367 927 633 946 738 819 487 557 768 4 37 827 596 511 628 381 68 679 838 179 603 680 13 231 650 35 700 735 975 595 502 301 424 527 678 950 280 532 649 685 710 539 903 248 276 571 500 435 560 109 926 588 278 414 509 237 169 740 885 118 430 382 689 481 311 199 993 821 261 447 540 357 92 129 131 953 375 377 852 61 191 228 937 122 418 439 573 198 331 302 505 644 283 421 416 36 894 884 831 22 24 104 876 371 272 622 312 578 459 395 455 536 374 969 403 565 269 389 552 90 164 922 781 503 460 524 206 356 130 259 533 294 157 901 422 290 514 982 641 661 478 559 496 282 512 266 257 538 765 564 96 783 724 843 317 411 799 652 488 310 349 313 413 453 886 58 971 20 921 618 815 850 99 339 87 21 472 699 33 607 800 352 899 233 166 780 407 625 670 201 170 383 772 344 376 881 984 590 165 732 153 398 842  For example in this list 376 is repeated twice, and 888 is removed once. In this challenge a number "x" can only be repeated "once", so the number "888" can only be removed once, so an acceptable output for a programmed answer is this "(x, y)" where "x" is the number repeated twice, and "y" is the number removed. I attempted to make this programming question, but because I included a bonus for web-scraping, and the format of the output for an answer was not clear it didn't receive positive reviews. So I would like suggestions I how I can make this challenge clearer. Thank you. Here is my challenge and the comments I received. • I have gone through and made the challenge clearer here: hastebin.com/ucesohawok.md Feel free to use or disregard this. However, one of my suggestions is to loosen the I/O formats (meaning stating input and output can be in any reasonable format). This would mean that the list could be taken as a list/array instead of a string. Same thing for output. This is ultimately up to you, but note that it is discouraged to restrict I/O formats as you have done. – GamrCorps Jun 15 '17 at 20:26 • Thank you very much. – xyz123 Jun 15 '17 at 20:47 • My first reaction was that this is too straightforward to golf, but thinking more led to some interesting tricks. I think this is a nice challenge. – xnor Jun 16 '17 at 0:14 • I suggest relaxing the input format and also allow a list or array of numbers. – Laikoni Jun 17 '17 at 7:00 # Working For The Weekend ## Option 1 Taking no input, output true if today is Saturday or Sunday or false otherwise. ## Option 2 Taking no input, output how many days, from today, until the weekend. Sunday: 0 Monday: 5 Tuesday: 4 Wednesday: 3 Thursday: 2 Friday: 1 Saturday: 0  ## Sandbox • Which option do you prefer? • Too trivial? • Dupe? • Allow local times to be used or require UTC? (I wanna say UTC) • true & false or truthy & falsey? (if option 1) • Working or Livin' For The Weekend? • 1) option 2 is less trivial and so Peter Taylor may not downvote / 2) Local times, not UTC / 3) truthy & falsey if you choose option 1 / 4) Working For The Weekend – caird coinheringaahing Jun 16 '17 at 14:28 • In my opinion this is far too trivial to be interesting. I feel in general time based questions are pretty boring. I don't feel it provides anything that hasn't been covered extensively by other date/time questions. – Wheat Wizard Jun 16 '17 at 14:32 What could I add to improve this post? I have some questions that are inside of brackets. # Introduction A farmer needs help calculating the least time it will take him to pick his fruit each day. # Challenge • This farmer has X orchards. • Each orchard has Y [is Y the correct variable to use here? does it matter?] fruits in it. If the orchard has no fruits, then it will contain the string "none". • The farmer has a list, this list contains the fruit he must pick. • The farmer will only go down the list in order • You must calculate how long it will take the farmer to pick his fruit on each day. ### More on the orchards • All of the orchards are in a line. • Each orchard is exactly 1 unit [should I say unit or kilometer?] away from the next and previous one. • The farmer can go up and down the line, but may not jump from one orchard to another # Input and Output You will receive an input in the following format: X *string* *string* *string* *string* *string* *string* *string* //ect. Y *string* *string* *string* *string* *string* *string* *string* *string* //ect.  X is the number of orchards • Everything after X and before Y is an orchard containing a/some string(s), each string is a different fruit in that orchard. Y is the number of days that the farmer must gather fruit. • Each day consists of two strings that are different fruits. • You must find what orchard these strings are in and calculate the difference. ### Input Rules: 1. Each fruit name string will be one word with no spaces 2. [Should I add more here? if so, what should I add?] ### Real Example Still confused? Maybe this will clear it up: Input 6 none apple orange pear pear none orange lemon pumpkin pumpkin lettuce flowers peas 4 peas lettuce apple orange apple pumpkin flowers orange  output: [ 0, 1, 3, 1 ] ### Explanation Input: • 6 the number of orchards • A set of 6 orchards containing fruit, each orchard on a new line. • 4 the number of days on the farmers list. • A set of 4 fruits to compare, each pair of fruits is on a new line. Output: • Output an array of the differences between each set of fruits. • The difference between peas and lettuce is 0, because they are in the same orchard. • The difference between apples and oranges is 1 because they are one orchard apart. • The difference between apples and pumpkins is 3 Because they are three orchards apart. • The difference between flowers and oranges is 1 because they are one orchard apart. Annotated input/output 6 orchards a none b apple c orange pear pear d none e orange lemon pumpkin f pumpkin lettuce flowers peas -- 4 fruits peas lettuce 0 apple orange 1 apple pumpkin 3 flower orange 1 -- output: [ 0, 1, 3, 1 ]  • I would only use the name y one time, as using it for two different things makes this a little confusing. – Gryphon Jun 21 '17 at 20:07 # Studio 54 Studio 54 was a famous nightclub in Manhattan. The club is referenced in the Futurama episode Rebirth in which the crew visits a nightclub called Studio 122133. The mathematical expression 122133 evaluates to (1 x 1) x (2) x (3 x 3 x 3) = 1 x 2 x 27 = 54. ## Challenge Determine whether a positive integer is a "studio number." We define a studio number to be a number n that can be expressed as the product of a set of distinct positive integers that does not include n, each of which is raised to the power of one of the numbers in the set. Or, more mathematically: You should have a consistent output value for "is a studio number" and "is not a studio number," and nothing else. ## Test cases These are inexhaustive lists and are just meant for basic ad-hoc testing. Studio numbers: 4 12 16 18 52 54 64 68 72 88 96  Not studio numbers: 1 2 9 10 11 42 53 55 69 77 87 90  Computed by this script. ## Sandbox I'm going off of this for the two consistent outputs, but I'm not really sold either way. I could also change the requirements to be to output the "studio" representation of the number. Does the math-y bit help? Could I make the studio number definition clearer? I've been unable to find any "nice" properties of these numbers that allow for methods besides brute force. Would this still be interesting enough to golf? I could also add a "reasonable time" limit that would enforce some non-naive code to reject bad attempts, but I'm not sure that's much better. The studio numbers do not appear to be a sequence recorded on the OEIS. • You say "does include n", but I think you mean, "does not include n". – Esolanging Fruit Jun 17 '17 at 22:32 • @Challenger5 Uhhh, whooops... Thanks :) – FryAmTheEggman Jun 17 '17 at 22:37 # Only HeLlO WoRLd is allowed. We are all familiar that "Hello World" is the 1st introductory program that most people learn when they first start to program. Then programmers go on to greater and better programs. But who says they have to go on to greater and better programs? What if all other programs were censored? # Your Task: Write a computer program that takes in standard input. If the standard input is any case-insensitive version of HeLlO WoRLd, do nothing. If the Standard input is anything other than a case insensitive HeLlO WoRLd, print an infinite loop of a HELLO WORLD matrix to the standard output. To print an infinite HELLO-WORLD-Matrix, randomly sort the letters of "HELLO" and the letters of "WORLD", join the two words with a space as if you were saying HELLO WORLD, although you are probably saying "HELLO DWROL", " OELLH LWODR" gibberish with an occasional "HELLO WORLD". Then just keep printing all this gibberish to the standard output. ELHOL WRDLO HOELL LDWRO LOELH DLWRO EOLHL DRLOW LHELO OLRWD OLELH LODRW EOHLL LWROD LLOHE OWDRL HLLEO OLRWD LEHOL LOWDR OLLHE WROLD OLEHL DLRWO OHLEL OWDLR LLHEO OWDRL LLEHO ROLWD HELOL WLORD HLOLE LWODR LHOEL ODLWR OLEHL DWORL LLHEO OWDRL LHOLE WORDL LOLHE WLODR HLLOE WRODL HOLLE LDORW EOLHL WODLR ELOHL DRWLO LHELO LRDWO HLOEL RLDWO LHOLE DOWLR OLELH DOLWR OLLEH WORLD LHLOE RWLDO OELLH LWODR LEHLO DOLRW EOHLL DWRLO HELLO WORLD LOLEH ODWRL HOLLE WDLOR LHEOL LORWD LLOHE OLDWR OHLLE DRLOW LOEHL LODWR OHLLE ODRLW HOLEL LWDRO HOLEL DWROL ELOLH RWOLD EOLHL WDLOR LHOLE WRODL HLLEO ODLRW HLELO LDWOR HLELO WLDRO HLLOE DRWLO HOLEL OLWRD OELHL WORDL HOELL LDRWO LLEHO WORLD OLELH DLOWR OLHEL LDWRO ELOLH DWROL EHLLO WDLRO OLELH LDROW LHEOL WORLD OLEHL LWDRO OELHL RWLOD LEOLH RWOLD HLOLE DRLOW LOELH RWLOD LHELO LODWR LLOHE LWDRO LOEHL OWDLR LEHOL WORDL OLEHL RWLDO LOELH LOWDR HEOLL LODRW HLOLE RLODW LLEHO DWORL LLOHE DWOLR LLHEO RODWL OLLEH DLWOR LHEOL ORDWL HLEOL OWDRL LELOH LDROW HELLO LDWRO HOELL ODWLR OEHLL ROWDL EHOLL WRLDO HLOLE WRLDO LLHEO WDRLO LOLEH OLDWR OEHLL RLWDO OELHL DLORW LLHEO RDWOL HLLOE OLDRW OLLHE LRODW OELLH LDROW LEHOL LOWDR LEHLO DRLOW HOLEL WROLD LHELO LORWD EHLLO LWODR HLOLE OLRDW LOLHE OLRWD LOLHE DORWL LOHEL WDLRO OHELL RWOLD LEHLO RLWDO HLEOL LWRDO OELLH LWORD HELLO LDROW OLHLE LWDRO  There is actually only one "HELLO WORLD" amid all this gibberish Winning criterion: shortest program in bytes. • What is an infinite loop of a HELLO WORLD matrix? – user42649 Jun 18 '17 at 16:08 • Actually, I think I would like to up the challenge and request that HELLO WORLDS be printed to the standard output in a tab deliminated string with the letters randomly sorted, so occassionally the standard output would get HELLO WORLD HELLO WORLD ... But it would mostly get "EHLLO DWORL HEOW LLROD ... etc. – xyz123 Jun 18 '17 at 16:11 • I updated my HELLO WORLD INFINITE matrix problem and made it more difficult. You should check it out. Is there anyway that I can have the tab separation show up on the problem the same way it shows up on the edit tab? – xyz123 Jun 18 '17 at 17:01 • You may want to say "anagram of..." instead of "randomly sort the letters of..." – Mr. Xcoder Jun 18 '17 at 17:29 • Are there rules about the horizontal and vertical spacing of your matrix, and the number of helloworldoids per line? This needs to be explicitly specified or else explicitly left flexible. – user62131 Jun 19 '17 at 18:54 • What do you think would make the challenge the most fun? – xyz123 Jun 20 '17 at 3:54 # Golfing a Busy Turing Machine ## For the sandbox This question is really hard, and the solution is restricted to one "language" – a 1-tape, 2-symbol Turing Machine. So I'm not sure if it belongs on PPCG. I've written up a basic description below, but can go into more detail if anyone is interested. ## Question I recently came across a paper that explicitly presents a 7910-state 1-tape, 2-symbol Turing machine that cannot be proven to run forever in ZFC, assuming ZFC is consistent. It also cites codegolf.stackexchange.com! The existence of this Turing machine proves that calculating BB(7910) is independent of ZFC. So, we know that we can calculate up to at least BB(4), and definitely can't calculate BB(7910) and above. Can you create a Turing Machine with under 7910 states that cannot be proven to run forever in ZFC? The author designed two custom-purpose programming languages (Laconic and TMD) to create this Turing Machine. In order to improve upon his work, I imagine you could go one of three ways: 1. Optimize his algorithm in Laconic such that it encodes the interpreter or Friedman's mathematical statement (section 3.1) more tersely. 2. Optimize TMD so individual instructions are translated to fewer states. 3. Find a simpler statement whose truth implies the consistency of ZFC, and encode that instead of Friedman's statement. 4. Go another direction entirely! ## Winning criteria The Turing Machine with the fewest number of states that cannot be proven to run forever in ZFC, wins. The length of the code you used to generate this Turing Machine is irrelevant. You don't win if you compute BB(5), but you do get eternal fame. • There's currently a huge loophole in the question: you can just present a Turing machine that trivially halts, without violating any of the rules. Defining this unambiguously is going to be hard; the problem is that the submitter has to prove that the Turing machine always halts, but also prove that the Turing machine can't be proven to always halt, which is almost a contradiction (and only works because the first "prove" is subjective but the last objective; but how do you enforce a subjective criterion?). That said, I like the question and it'd be nice if it could be made to work. – user62131 Jun 19 '17 at 19:24 • It's also worth noting that the vast majority of PPCG users won't understand the question no matter how precisely you try to word it. That probably isn't a problem for the people who are interested in or are willing to learn computability theory, but expect a large number of wrong answers that misunderstand the question and have to be deleted. – user62131 Jun 19 '17 at 19:25 • @ais523 "Cannot be proven to run forever" is a subtle point – it's not that it doesn't run forever but that it's impossible to prove whether or not it does. If the submitter can prove that the Turing machine always halts, then it would not be a valid submission. Or if it were, would solve the halting problem. I should clarify to say "cannot be proven either to halt or to run forever." My big concern is your second comment, though. In any case, this post explains the main points in the paper, and is very accessible and worth reading independent of PPCG! scottaaronson.com/blog/?p=2725 – vroomfondel Jun 19 '17 at 19:33 • Right, I think the correct framing of this problem is "produce a Turing machine that cannot be proven to halt and cannot be proven not to halt". (Of course, we know it won't halt in practice, because if it did, you could prove it halts by running it, but that should be left out of the framing of the question.) That makes it clearer what's going on to people who haven't seen the problem in question beforehand. I wonder if opening this up to other languages might not be interesting too: brainfuck, for example, is a good fit for this challenge. Things like Jelly probably aren't though. – user62131 Jun 19 '17 at 19:36 • @ais523 The way to construct a program like this is usually to say "this machine halts iff conjecture A is true" where conjecture A's truth implies the consistency of ZFC. – vroomfondel Jun 19 '17 at 19:37 • Opening up to other languages seems reasonable enough, especially as I imagine it wouldn't be too hard to write a brainfuck to 1-tape turing machine transpiler – vroomfondel Jun 19 '17 at 19:38 • I can tell you haven't read the discussion about this in the comments of two blog posts in Aaronson's blog, because Stefan O'Rear one-upped with a search for a contradiction in ZFC in about 1900 states. See github.com/sorear/metamath-turing-machines . NB codegolf.stackexchange.com/q/79620/194 was also inspired by that discussion, although in a slightly different direction. See cheddarmonk.org/papers/laver.pdf for a 64-state machine which is not known to halt in ZFC, but is proven to halt assuming a rank-into-rank cardinal. – Peter Taylor Jun 19 '17 at 22:17 • @PeterTaylor very cool, thanks! I generally try to steer clear of comment-reading on blogs, but I should probably make an exception for academic ones. – vroomfondel Jun 19 '17 at 22:20 • @PeterTaylor I just noticed that the Laver paper is yours. Super impressive. I'd love to know if/when you ever end up publishing it – vroomfondel Jun 19 '17 at 22:31 • Any answer to this is also an answer to Write a program whose nontermination is independent of Peano arithmetic. Turing machine answers are welcome. (Though I’m not sure how we score those in bytes… perhaps the entropy measure (2n lg (4n + 1))/8?) Also (conjecturally) related: Laver table computations and an algorithm that is not known to terminate in ZFC. – Anders Kaseorg Jun 23 '17 at 20:44 # Grouped Keyboard Scores In the above graphic, one can see 12 distinct color groups, which roughly correspond to columns on a keyboard. The following is a plaintext representation of which characters occur in each group. Group 1: ~ \n\t Group 2: !1QqAaZz Group 3: @2WwSsXx Group 4: #3EeDdCc Group 5:4RrFfVv
Group 6:  %5TtGgBb
Group 7:  ^6YyHhNn
Group 8:  &7UuJjMm
Group 9:  *8IiKk<,
Group 10: (9OoLl>.
Group 11: )0Pp:;?/
Group 12: _-{["'+=}]|\


Challenge: Sort characters in the input according to their position in the aforementioned table. For input "Hello, World!", the output would be " !WedrH,llool". The relative order of characters within the same group does not matter, so the output " !WderH,llloo" is just as acceptable.

Scoring: Let P be the product of the number of characters in each non-empty section. Let S be the number of sections your program uses. Then, your score is P × S.

For example, the program QAZ would have a score of 3, and QWERTY would have a score of 6. 12321 would have a score of 12. The lowest such score wins.

Here is a code snippet for scoring your submission:

var sections = [
"~\t\n ",
"!1QqAaZz",
"@2WwSsXx",
"#3EeDdCc",
"\$4RrFfVv",
"%5TtGgBb",
"^6YyHhNn",
"&7UuJjMm",
"*8IiKk<,",
"(9OoLl>.",
")0Pp:;?/",
"_-{[\"'+=}]|\\"
];

function getSection(chr){
for(var i = 0; i < sections.length; i++){
if(sections[i].indexOf(chr) >= 0){
return i;
}
}
return -1;
}

function score(program){
// group by sections
var sectionHolder = [];
var foundSections = [];
for(var i = 0; i < program.length; i++){
var chr = program[i];
var index = getSection(chr);
if(index < 0)
return "n/a\nInvalid character: " + chr;

if(!sectionHolder[index])
sectionHolder[index] = [];

sectionHolder[index].push(chr);

if(foundSections.indexOf(index) < 0)
foundSections.push(index);
}

var S = foundSections.length;
var P = foundSections.map(function(e){
return sectionHolder[e].length;
}).reduce(function(a, c){
return a * c;
}, 1);;

return S * P;
}
var output, code;
output = document.getElementById("output");
code = document.getElementById("code");
});
function update(){
output.innerHTML = "";
output.appendChild(document.createTextNode(
"Score = " + score(code.value)
));
}
* { font-family: Consolas, monospace; }
#output { white-space: pre; }
<textarea id="code" oninput="update();"></textarea>

<div id="output"></div>

## Test cases

Note: ␉ represents a tab and ␤ represents a newline.

 "input" => "output"

"Hello, World!" => " !WedrH,llool"
"Grouped Keyboard Scoring" => "  aSededcrrrGbgynuKiooop"
"QWERTYUIOPqwertyuiop" => "QqWwEeRrTtYyUuIiOoPp"
"2017 + 42 = something" => "    122se4tghn7mio0+="
"Tab␉ulator" => "␉aarTbtulo"
"Hello␤World" => "␤WedrHllool"

• Should group one be: ~ \n\t? – Magic Octopus Urn Jun 19 '17 at 14:33
• @carusocomputing Yes, indeed – Conor O'Brien Jun 19 '17 at 16:16

# Call a library function

Given a single int32, a path to a Dynamic Link Library (.dll) or Shared Library (.so), and the name of a function, return the single int32 result of calling the function on the single int32.

### Examples

On 64 bit Linux: 0 /usr/lib64/libm-2.24.so fesetround0

On 64 bit Linux: 1 /usr/lib64/libm-2.24.so fesetround1

On 32 bit Linux: 1023 /usr/lib/libm-2.24.so fesetround1

On 32 bit Linux: 1024 /usr/lib/libm-2.24.so fesetround0

On 64 bit Windows: inp please\edit\filename.dll fnameout

On 64 bit Windows: inp please\edit\filename.dll fnameout

• Please help me find a suitable DLL! – Adám Jun 19 '17 at 19:53
• This needs to specify that the function takes a single int32 as argument and returns a single int32. – user62131 Jun 19 '17 at 19:58
• @ais523 Thanks, done. – Adám Jun 19 '17 at 20:03
• Where's the int32 in the Windows examples? – Peter Taylor Jun 19 '17 at 20:36
• @PeterTaylor I need help with a dll that's commonly found on Windows. – Adám Jun 19 '17 at 20:38
• It's worth noting in the testcases that although libm is very commonly seen on Linux, the exact file path tends to vary from distribution to distribution. (For example, it's different on Fedora and Ubuntu.) – user62131 Jun 19 '17 at 21:59
• @ais523 Can you edit the Linux samples to replace "Linux" with "Fedora" and "Ubuntu" and give the correct paths? – Adám Jun 19 '17 at 22:00
• @Adám: Not easily, they frequently change as a result of the system being updated, and it depends on processor architecture (not just bit depth) and sometimes even configuration. Just tell people to find the path to their own libm library for the appropriate architecture. (Note that the situation on Windows is much worse, because it doesn't ship even standard DLLs like libm by default.) – user62131 Jun 19 '17 at 22:02
• @ais523 Just as plausible example, I mean. – Adám Jun 19 '17 at 22:03

# What is the maximum number of backslashes (escape characters) required to mean one backslash?

If you want to use a regex to look for a backslash, you have to escape that backslash, so that the character after it isn't escaped instead. But if you then have to store this regex in a string (in a c-style language, for instance), you need to double the number of backslashes, so that a regex string to match \stuff\ would need to be "\\\\stu(f+)\\\\" (and I had to further double the backslashes to post it in StackOverflow, but that isn't executable so doesn't count).

In your answer, explain the language and the (reasonable) situation, from either real or made-up business needs, and the answer with the most backslashes (per final, output backslash) will get upvoted (permanently) and accepted (until a better one comes along). If using AutoHotKey or another language that has a different escape character (for instance, ), then instances of that character will count instead of backslashes.

This question is not how many backslashes could you use in some esoteric code-golfing language to eventually calculate to a backslash, otherwise I don't think there would be an upper limit. This instead is about feasible scenarios that force you to use a lot of backslashes.

• I feel as though this simply devolves into finding as many languages as possible that have something like eval. You can't enforce "reasonableness" as it isn't objective. Sorry, but I don't think this kind of challenge is a good fit for our site. But thank you for using the sandbox! – FryAmTheEggman Jun 19 '17 at 20:35

# Meta

• Is this a good idea?
• Is the point system good?
• If so, are the point values good? I based them off of how difficult I imaged each part to be.

## Overview

Randall Munroe, author of the webcomic XKCD, posted a comic a while back about a joke programming language and how it gets types confused.

Here's the comic in question

Your job is to write an interpreter for a slightly modified version of this language.

## Rules

• If your language supports it, it must be a live interpreter where all input lines start with [#]> (where # is the line number) and all outputs must start with =>.
• If your language does not support it, you may substitute this with reading all the lines on the input and printing out each output on its own line, still starting with =>. Remember to keep track of line numbers.
• All commands must be usable in any order and with any parameters (within reason)
• Each command you implement correctly is worth the listed point value. See scoring to find your final score.

### Integers plus numeric strings (1 point)

Given an int and a string containing a number (in that order) calculate the numeric sum of them, then return the result as a string with quotes surrounding it.

[1]> 2 + "2"
=> "4"
[2]> 6 + "13"
=> "19"


### Numeric strings plus lists (1 point)

Given a numeric string and a list, append the numeric value to the list and return the list as a string.

[1]> "3" + []
=> "[3]"
[2]> "7" + [1,4]
=> "[1,4,7]"


### Dividing by zero (1 point)

Any number divided by zero returns a NaN object. This does not have quotes around it.

[1]> 1/0
=> NaN


### NaN plus integer (2 points)

Given a NaN object and an integer, pretend it's a string and increment the leading character, carrying over if needed. The result does not have quotes.

[1]> (5/0)+2
=> NaP
[2]> NaN+256
=> NbN


You do not need to use ASCII for this, any character set works, as long as it includes at minimum the 52 uppercase and lowercase letters.

You will never have to add a result from this to another integer. (For example, NaP+4 is invalid)

### String plus string (1 point)

Given two strings, remove swap the first and last quotes with single quotes and return the result.

[1]> ""+""
=> '"+"'
[2]> "Hello"+"world"
=> 'Hello"+"world'


### List of integers plus integer (3 points)

Given a list of integers (or an empty list) and another integer, return True or False based on whether the new integer matches the linear pattern.

It will follow this rule:

If the list has 0 or 1 items, return True regardless (everything matches).
Determine the pattern of the list by subtracting every item by the item right before it. If the pattern is inconsistent, return False regardless (nothing matches).
Otherwise, check if the new integer matches the pattern. If it does, return True. If it doesn't, return False.

[1]> [1, 2, 3, 4] + 5
=> True
[2]> [5, 7, 9, 11] + 13
=> True
[3]> [6, 5, 4, 3] + 2
=> True
[4]> [2, 4, 6, 8] + 9
=> False
[5]> [1, 2, 1, 4] + 5
=> False


### Range(a, b) (1 point)

With the Range function given two numbers, return a list of numbers from a to b.

[1]> Range(1, 5)
=> [1, 2, 3, 4, 5]
[2]> Range(3, 6)
=> [3, 4, 5, 6]
[3]> Range(6, 4)
=> [6, 5, 4]


### Plus integer (1 point)

Given simply "+" and an integer, return the line number plus the integer.

[1]> +2
=> 3
[2]> +2
=> 4
[3]> +1
=> 4


### Single digit plus single digit (2 points)

Given two single digit integers a and b, replace all future instances of a in the output with (a+b)%10 (where % means modulo, essentially wrap around if the result is more than 1 digit). Return Done. This effect is superficial and has no effect on math. This only affects output, not input.

[1]> 3+2
=> Done
[2]> Range(1, 6)
=> [1, 2, 5, 4, 5, 6]
[5]> 1+2
=> Done
[4]> Range(1, 6)
=> [3, 2, 5, 4, 5, 6]


### Floor (1 point)

Draw an ascii art floor with the number at the bottom. The specifications are 3 lines of only pipes, then a line with a pipe, 3 underscores, the number, and 3 underscores.

[1]> Floor(4.7)
=> |
=> |
=> |
=> |___4.7___
[2]> Floor(105.3)
=> |
=> |
=> |
=> |___105.3___


## Scoring

Add up the points you've earned. Your score is now calculated as (15-points) * bytecount. Lower is better.

## Notes

• You do not have to account for mixing functions. For example, Range(Floor(2.3)) is invalid.
• Whitespace may be added or removed as is convenient.
• Double quotes or single quotes may be used as convenient (as long as you use the opposite for "String plus string")
• Any brackets may be used for lists, as long as it's consistent.
• A few commands were omitted from the original comic because I couldn't figure out a way to make it well specified.
• Scoring is broken: it goes up when you implement more features, but down when you golf bytes off the program. Those should probably both aim in the same direction. Also, even if you change "multiply" to "divide", you're still only scoring on the average number of bytes per feature (which incentivizes only implementing one feature, the shortest). The normal fix is to divide the byte count by the square of the points from features, lower is better. – user62131 Jun 19 '17 at 7:52
• If your language supports this, do that. If not, do this is not a very good idea. Also, reading multiple lines and the => prefix seems like it's just extra code for no good reason. – Okx Jun 19 '17 at 7:56
• @ais523 Ah thanks for catching that. What I meant was, you take your point score and calculate (15-points)*bytes. If you get all of them, your score is simply your byte count. If you get a few of them, your score is larger accordingly. Lower is better. – Daffy Jun 19 '17 at 18:29
• @Okx The => prefix is to keep with the style of the comic. And reading multiple lines is important because some of the commands affect things in the future, which you wouldn't see if you can't input multiple lines. I see what you mean though about if this, that, if not, this. Do you think the interactive approach is better or the non-interactive one? – Daffy Jun 19 '17 at 18:31
• – Martin Ender Jun 20 '17 at 9:15
• @MartinEnder I would argue that is not a dupe. That question hopes to simulate the comic's output, without making it general. Return values to functions can be hardcoded. Mine has stricter specifications. – Daffy Jun 21 '17 at 6:10

# Counting from 0 - 100

I posted this question, but it was not taken very well, so I wanted to put it through the sandbox and get some feedback/help before re-posting.

# Challenge

Output all numbers from 0-100. Without using any of your languages built in loops.

### Loops that are not allowed

This list contains, but is not limited to

• For loops
• While loops
• Do While loops
• Goto Statment
• In Range

# Rules

• I really don't think this is a good idea for a challenge. It would either be builtins, like this in Jelly, or printing literal strings, with maybe some clever compression. – scatter Jun 20 '17 at 14:37
• Ok, I will leave it here in the sandbox incase anyone else thinks that they have a way to make it better. But I will not post it. – zoecarver Jun 20 '17 at 14:38
• @Christian Definitely golfable too. – Erik the Outgolfer Jun 20 '17 at 14:49
• – musicman523 Jun 20 '17 at 15:04
• "but is not limited to" - I think you're going to need to be more explicit than that. Does array mapping count as a loop, for example? – Shaggy Jun 20 '17 at 15:42
• @EriktheOutgolfer I actually had that ready to post when this challenge was posted in PPCG, but it was deleted before I had the chance to. I was just too lazy to look up the atom list when commenting on this post :P – scatter Jun 20 '17 at 16:33
• "Without loops in your code" is a non-observable requirement. I don't think there is a good way to do what you want at all, since there are so many ways to "loop" that you can't possibly define them all. Take this for example. – FryAmTheEggman Jun 21 '17 at 1:20
• This is what Fry is referring to with "non-observable requirement". In general imposing restrictions on which features answers can use is highly problematic. a) There are many many languages that don't have to constructs you explicitly disallow, but which may have similar constructs which aren't in the spirit of the restriction either. But b) "not limited to" doesn't fly because who is to decide whether any given construct is a loop or not? There are even languages where you can write loops without any specific syntax element for them. – Martin Ender Jun 21 '17 at 8:58
• In general, if you find yourself having to impose explicit restrictions on the allowed approaches to a challenge, it's often a sign that it's not a great idea in the first place. I assume this is why the challenge wasn't received well in the first place. – Martin Ender Jun 21 '17 at 8:59