Sandbox for Proposed Challenges

Question

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

Sandbox FAQ

Posting

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

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

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

Discussion

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

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

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

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

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

Other

Search the sandbox / Browse your pending proposals

The sandbox works best if you sort posts by active.

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

Answer 1

Introduction

Wardialing was a very interesting way to try to hack people back in the '80s and '90s. When everyone used dial-up, people would dial huge amounts of numbers to search for BBS's, computers, or fax machines. If it was answered by a human or answering machine, it hung up and forgot the number. If it was answered by a modem or a fax machine, it would make note of the number.

Challenge

Your job is to make a URL wardialer. Something that tests and checks if it's a valid website from one letter of the alphabet.

Constraints

• Program must take user input. This input has to be a letter of the alphabet, no numbers. Just one letter of the alphabet and form multiple URLs that start with the letter.
• Standard loopholes apply.
• You must make 8 URLs from 1 letter, and test to see if it is a valid site.
• If you hit an error (not a response code), instead of leaving it blank, go ahead and return a 404
• If you hit a redirect (3xx), return a 200 instead.
• You may output the results in any reasonable format, as long as it includes the website name, status codes for all the websites and the redirects
• This is Code Golf, so shortest amount of bytes wins.

What counts as a URL for this challenge?

http://{domain-name}.{com or net or org}

For this challenge, the domain name is should only be 4 letters long, no more, no less.

What should I test?

For each 4 letter domain name, test it against three top-level domains (.com, .net, .org). Record all the response codes from each URL, remember from the constraints that any (3xx) should return 200 and be recorded as a redirect in the output and any error getting to the website should result in a 404.

Input

a

Output

+---------+------+------+------+------------+
| Website | .com | .net | .org | Redirects? |
+---------+------+------+------+------------+
| ajoe    | 200  | 200  | 200  | .com, .net |
+---------+------+------+------+------------+
| aqiz    | 200  | 404  | 404  | no         |
+---------+------+------+------+------------+
| amnx    | 200  | 503  | 404  | .com       |
+---------+------+------+------+------------+
| abcd    | 200  | 404  | 200  | .com       |
+---------+------+------+------+------------+
| ajmx    | 200  | 503  | 404  | no         |
+---------+------+------+------+------------+
| aole    | 200  | 200  | 200  | .com       |
+---------+------+------+------+------------+
| apop    | 404  | 200  | 200  | .net       |
+---------+------+------+------+------------+
| akkk    | 200  | 200  | 200  | .com       |
+---------+------+------+------+------------+

Answer 2

Program Equilibrium Iterated Prisoner's Dilemma Tournament

This is an iterated prisoners dilemma tournament. You are to make a bot that plays the prisoners dilemma against the other contestants, but with a twist- you can perfectly simulate your opponent!

Iterated Prisoner's Dilemma

The prisoner's dilemma is a two-player game in which players can choose to either "Cooperate" or "Defect" against their opponent. The payoff matrix for the prisoner's dilemma looks like this:

                           Player 2
                       C              D

                 ------------------------------
                |              |               |
            C   |    (3, 3)    |    (0, 5)     |
                |              |               |
Player 1        |------------------------------|
                |              |               |
            D   |    (5, 0)    |    (1, 1)     |
                |              |               |
                 ------------------------------

In the iterated prisoner's dilemma, multiple rounds are played in succession, and players can use their knowledge of the previous rounds when making a decision.

The twist

Bots are also allowed to run their opponent and examine the output before making a move. This allows for significantly more complex strategies in which bots can simulate their opponents to determine if it is safe to cooperate with them, as well as attempt to exploit less sophisticated players.

Simulation

There will be a program available in the path called simulate that you can use to simulate what your opponent would do against you

Usage:

simulate [instruction to your own bot] [fake history to the opponent]

Example:

simulate cooperate 00 10 01 11 01 10

All arguments are optional, and you may also use underscore _ for no argument. If you do not explicitly state the history, the real history will be used.

Example output from the simulate program:

01

The first number is you, the second is your opponent. 0 means defect, 1 means cooperate.

The instruction

It wouldn't be much use to simulate what your opponent would do against you, because he'd probably simulate you right back, and then you'd be stuck in an infinite loop.
The instruction is your way to simulate what the opponent would do against another agent. You could for instance have a cooperate instruction that causes your bot to cooperate mindlessly, to see what the opponent would do if you were to cooperate.

Input

Your program will be given the following input at the beginning of each round:

Instruction (if any)
Your score
Your opponents score
Current round number
Complete history of past interactions with this bot. Space separated: the first number is you, the second is your opponent

Example:

cooperative
5
2
3
00 10

Output

0 for defect or 1 for cooperate, with any number of leading characters. Trailing characters (including 0 or 1's) will be ignored.

Example:

1

The tournament

The tournament will be round-robin elimination: Each bot will play one match against all other bots, where a match consists of 100 rounds of the prisoner's dilemma. At the end of the round-robin round, the lower-scoring half of the tournament pool will be eliminated. This process will be repeated until only one bot remains, or there is a tie.

Rules

• Your program has to run on Linux. Please provide a brief description of how to run your program if possible
• Your program has to give an answer within 5 seconds. Failing to do so will be interpreted as defect.
• Your program may not perform multiple simulations at the same time
• You may only enter a single bot, this is to prevent people from entering multiple bots that cooperate
• You may not read or write any files. If this is required by your language, please state so in your answer.
• You may not in any way store state between rounds. This is to prevent bots from figuring out whether they are being simulated.
• If you exploit another loophole to figure out whether you are being simulated, you will be disqualified. Guessing (or strategical testing) is obviously allowed

About the host computer

Arch Linux 4.10.13-1
Intel(R) Core(TM) i7-7500U CPU @ 2.70GHz, 4 cores
16 GB RAM
I will disconnect from the internet while running the tournament

Disclosure

I got the idea as well as some of the text from this Github repository. I have not directly asked the author for permission to use the challenge, but he said that "if you want to run this tournament on your own, you are more than welcome to" in a blogpost.

Leaderboard

I will update this periodically whenever new bots enter.

Meta

How do I best discourage/prevent players from intentionally using every bit of their time limit to sabotage other players trying to simulate them? I am thinking random time limits and/or penalties

Answer 3

Identify the variable case

Your task is to write a function which determines which casing convention a provided variable name belongs to:

• camelCase
• kebab-case
• Train-Case
• snake_case
• SCREAMING_SNAKE_CASE
• PascalCase
• Ada_Case (not a real term, but apparently the standard casing used in Ada)

Your function should return one of the above strings, either exactly as above, or as spaced title-case: "Train case", "Screaming snake case".

Casings that include - or _ may include leading or trailing -s or _s (eg, __MY_SNAKE__ or -webkit-kebab).

Multiple consecutive upper case letters are allowed in mixed casings, as long as they follow a lower case letter (MyXMLDocument, This-CSS-Crap).

Where an input fits multiple schemes (eg, F or foo), you may return any valid classification.

If an input does not fit one of the above schemes (eg stu-pid_case), you must return something different. You may also throw an error.

The input string is guaranteed to be at least one character, and begin with a character matching /[a-zA-Z_-]/. Every other character will match /[a-zA-Z0-9$-]/

This is code-golf, so shortest length in bytes wins. Standard loopholes forbidden. Standard input and output methods.

Test cases

myFunkyVariable => camelCase
no-op => kebab-case
TEST2 => SCREAMING_SNAKE_CASE
__c => snake_case
XML-Madness => Error
Get_Input => Ada_Case
i => camelCase (or snake_case)
char2int_factory => snake_case

Answer 4

21 = (1 + 3 + 5 + 7 + 9) - (1 + 3)

Sandbox question:
Is this different enough from the original challenge?

---

Background

• This is a sequel to my previous challenge, but this time with a slightly more interesting practical application (the factorization of the input).

• It is based on 1) the fact that any odd integer n can be expressed as the difference of two squares a² - b² and 2) the well known formula:

  

The task

You're given a positive odd integer n. Your task is to determine how many iterations of the following algorithm need to be processed to reach n.

• Initialization: find the highest integer k such that k² ≤ n. Build the list L = [ 1, 3, 5, ..., 2k-1 ].
• Iteration:
  • Step #1: If the sum of the terms of L equals n, stop here.
  • Step #2: Increment k and append 2k-1 to L.
  • Step #3: While the sum of the terms of L is greater than n, remove the first term from the list. Go on with step #1.

All iterations (either full or partial) must be counted. In other words, you must return the number of times step #1 was executed.

Example #1

This is a trivial example for the perfect square n = 9:

• Initialization: k = 3 because 3² ≤ 9 < 4², which leads to L = [ 1, 3, 5 ].
• Step #1: 1 + 3 + 5 = 9. We're done.

We went through one iteration. So the expected result is 1.

Example #2

Here is what we get for n = 21:

• Initialization: k = 4 because 4² ≤ 21 < 5², which leads to L = [ 1, 3, 5, 7 ].
• Step #1: 1 + 3 + 5 + 7 = 16, which does not equal n.
• Step #2: We increment k and we add 2k + 1 = 2 x 5 - 1 = 9 to the list: L = [ 1, 3, 5, 7, 9 ].
• Step #3: We remove the first term from the list: L = [ 3, 5, 7, 9 ]. The sum of the terms is now 24, which is still greater than n. So we remove another term: L = [ 5, 7, 9 ].
• Step #1 : 5 + 7 + 9 = 21. We're done.

We went through two iterations. So the expected result is 2.

Example #3

Below is a summary of all steps for a slightly more complex example with n = 145.

Initialization: k = 12 because 12² ≤ 145 < 13².

Iteration | Step | k  | L                                 | Sum
----------+------+----+-----------------------------------+----
    1     |  1   | 12 | 1,3,5,7,9,11,13,15,17,19,21,23    | 144
          |  2   | 13 | 1,3,5,7,9,11,13,15,17,19,21,23,25 | 169
          |  3   | 13 | 11,13,15,17,19,21,23,25           | 144
----------+------+----+-----------------------------------+----
    2     |  1   | 13 | 11,13,15,17,19,21,23,25           | 144
          |  2   | 14 | 11,13,15,17,19,21,23,25,27        | 171
          |  3   | 14 | 17,19,21,23,25,27                 | 132
----------+------+----+-----------------------------------+----
    3     |  1   | 14 | 17,19,21,23,25,27                 | 132
          |  2   | 15 | 17,19,21,23,25,27,29              | 161
          |  3   | 15 | 19,21,23,25,27,29                 | 144
----------+------+----+-----------------------------------+----
    4     |  1   | 15 | 19,21,23,25,27,29                 | 144
          |  2   | 16 | 19,21,23,25,27,29,31              | 175
          |  3   | 16 | 23,25,27,29,31                    | 135
----------+------+----+-----------------------------------+----
    5     |  1   | 16 | 23,25,27,29,31                    | 135
          |  2   | 17 | 23,25,27,29,31,33                 | 168
          |  3   | 17 | 25,27,29,31,33                    | 145
----------+------+----+-----------------------------------+----
    6     |  1   | 17 | 25,27,29,31,33                    | 145

We went through 6 iterations. So the expected result is 6.

Factorization of the input

This paragraph is for illustration purposes only. It describes how the factorization of the input can be deduced from the result of the algorithm.

Factorization of 21:

• 21 = 5 + 7 + 9 = (1 + 3 + 5 + 7 + 9) - (1 + 3)
• 21 = 5² - 2²
• 21 = (5 + 2)(5 - 2)
• 21 = 7 x 3

Rules and clarifications

• The input is guaranteed to be a positive odd integer. It may be either a composite integer or a prime.
• You're required to process any odd n in [ 1, ..., 65535 ] in less than one minute on mid-range hardware.
• Given enough time, your program/function should theoretically work for any value of n that is natively supported by your language. If it doesn't, please explain why in your answer.
• You may use any other method instead of the described one as long as it returns the correct result.
• This is code golf, so the shortest answer in bytes wins!

Test cases

To be completed

Answer 5

Dungeon of Botdom

Bots will play a variant of this game:

https://boardgamegeek.com/boardgame/150312/welcome-dungeon

(Our version will be played by one bot versus another bot, and there will only be one character, which may or may not be in the actual game, and it will be repeated a bunch.)

Essentially, there is a deck of cards, with enemies on each card. players take turns either passing, or drawing a card and either a) placing it in the initially empty dungeon or b) removing a piece of gear and discarding the enemy. enemies have different hit points, which affects the damage done to a bot traversing the dungeon. When everyone but one player has passed, they enter the dungeon. when a bot is traversing the dungeon, they will encounter the enemies placed in the dungeon in LIFO order (the card on top is taken first) (if I take out some items this may be irrelevant). enemies are instantly defeated if the player has a corresponding item, otherwise the player takes damage equal to the enemies number. if a player makes it through the dungeon, they get one point. get two points to win the match. if they fall while traversing the dungeon, they lose one chance. fail twice, and the opponent wins the match.

What this means, is that you might want to do one of two things: make the dungeon too dangerous to survive without your opponent thinking it is, and passing, or making the opponent bot believe the dungeon is too dangerous, when it is not, and running through the dungeon and succeeding.

We'll have a good ol' round robin of a 1000 rounds each or some such. the nice thing about this game is that the rounds are short, because once you finish the deck, a player automatically enters the dungeon.

Answer 6

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

As a fan of an at most moderately successful football^BE 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 code-golf, so the shortest correct answer (in bytes) wins. The winner will be chosen one week after the first correct answer is posted.

Answer 7

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.

Answer 8

How many substitutions till palindromization?

code-golfstringpalindrome

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.

Additional testcases:

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.

Answer 9

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.

---

code-challenge

Answer 10

Reverse divmod

code-golf number

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 code-golf, so shortest solution in bytes wins!

Answer 11

Help me golf my numbers! (Part 2) code-challenge test-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?

Answer 12

Insert a simulated Ken Thompson virus into a program code-golf code-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!

Answer 13

Find the Harmonic Mean

code-golf

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

Answer 14

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.

Answer 15

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 code-golf, 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

Answer 16

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 code-golf, 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.

Answer 17

Color the Grayscale

code-golf image-processing

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 popularity-contest like a lot of the other image-processing challenges?

Answer 18

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

Answer 19

Print all video urls of YouTube channel codegolf

Inspired by Count the videos in a Youtube Playlist, the input will be the "VIDEOS" view from a channel like this one:

https://www.youtube.com/channel/UCzwJRQXMXkaB9KlqUdFD74Q/videos

The output will be a complete, newline-delimited list of all video urls the respective channel has to offer. It would look something like

https://www.youtube.com/watch?v=JxNfccUIQCU
https://www.youtube.com/watch?v=lOr0XIHFhlk
https://www.youtube.com/watch?v=o3tZElWLrbc

This is codegolf, so shortest answer wins.

---

Comments:

• I am unsure whether the permitted use of Google's YouTube API might be a good idea. It requires an API_KEY and can only retrieve 50 results per request.

Thanks for the feedback.

Answer 20

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?

Answer 21

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 code-golf 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.

Answer 22

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)

---

code-golfbusy-beaver

Answer 23

Help me play Battleship! array-manipulation code-golf grid

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?

Answer 24

Star Trekkin'

code-golf ascii-art animation

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.

Answer 25

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.

Programming Challenge: Tell me which number I repeated, how many times, and which one I skipped?

Answer 26

Working For The Weekend

code-golf date

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?

Answer 27

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 ]

Answer 28

Studio 54

code-golf decision-problem number

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 1²2¹3³. The mathematical expression 1²2¹3³ 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.

Answer 29

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.

Answer 30

Golfing a Busy Turing Machine

code-golf turing-machine busy-beaver

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.