457
\$\begingroup\$

What is the Sandbox?

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

To post to the Sandbox, scroll to the bottom of this page or click on the "Add Proposal" link below, and click "Answer This Question". Click "OK" when it asks if you really want to add another answer. Write your challenge just as you would when actually posting it. You may also add some notes about specific things you would like to clarify before posting it. Other users will help you improve your challenge by rating and discussing it. When you think your challenge is ready for the public, go ahead and post it, replace the post here with a link to the challenge and delete it.

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

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

Add Proposal

Search the Sandbox

Browse your pending proposals

Get the Sandbox Viewer to view the sandbox more easily

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

\$\endgroup\$
  • \$\begingroup\$ How are tags added to questions? \$\endgroup\$ – guest271314 Jan 9 at 7:51
  • \$\begingroup\$ @guest271314 You can use this markup to create a tag in a draft: [tag:code-golf] \$\endgroup\$ – DJMcMayhem Aug 29 at 15:19
  • \$\begingroup\$ Why no featured anymore? Can't we have it auto-added or something? \$\endgroup\$ – JL2210 Sep 26 at 15:57
  • 1
    \$\begingroup\$ @JL2210 We now have a permanent info box that links to the Sandbox, so the featured tag isn't necessary \$\endgroup\$ – caird coinheringaahing Sep 29 at 13:43
  • \$\begingroup\$ I think the sentence 'replace the post here with a link to the challenge and delete it' may specify that the deletion should be done immediately . \$\endgroup\$ – AZTECCO Oct 5 at 19:39

2558 Answers 2558

1
\$\begingroup\$

Dice Roller

Since I have played a lot of tabletop role playing games, I am looking for an easy to use dice roller. But also being lazy, I would like to have the shortest possible solution, making this code-golf.

Input

You will receive as input a string, composed of 2 or 4 variables.

In the case of 2 parameters, both non-negative numbers, they represent the number of dice and the value of the dice rolled.

Examples:

"2 6" means rolling 2 6-sided die (colloquially written 2d6).
"3 8" means rolling 3 8-sided die (3d8).

In the case where 4 parameters are given, the first 2 are still numbers, as in the case of 2 parameters. The third and forth parameters represent a dice modifier, and whether the modified applies to the dice individually or the sum of all rolled values, respectively. The third parameter is a (possibly) signed number (e.g.: 2, +1, -2, ...), and the forth is a character string, either 'ind' (if the modifier applies to the individual dice) or 'all' (applies to the total sum of the dice rolled).

Examples:

"2 6 +1 ind" means rolling 2 6-sided die, and a modifier of +1 is applied to each individual die (can be written 2d(6+1)).
"3 8 -4 all" means rolling 3 8-sided die, and a modifier of -4 is applied to the sum of the roll (can be written (3d8)-4).

Dice Properties

  • Only the following dice are acceptable (second parameter): 2 3 4 6 8 10 12 20 100.

  • Regardless of modifier, a dice gives at least a value of 1 when an individual modifier is applied (so for example, "1 6 -10 ind" will return a value of 1, the minimum value allowed by this stipulation). There is no max value to an individual modifier.

  • When a modifier is applied to the sum of the dice rolled (4th parameter is "all"), the sum can be less that the number of dice rolled. For example, "2 6 -20 all" will give a sum range of -18 to -8, as the lowest value of 2d6 is 2 and highest value is 12, pre-modifier. There is no min or max value to a this modifier.

Output

The output will be the values of the individual dice rolled, and the sum of all the dice.

Valid examples:

"2 6" => "3 6 : 9"
"3 8" => "1 8 5 : 14"
"2 6 -1 ind" => "1 2 : 3"
"2 6 -10 ind" => "1 1 : 2"
"3 8 +1 ind" => "2 9 6 : 17"
"2 6 10 all" => "3 6 : 19"
"2 6 -10 all" => "3 6 : -1"

Invalid examples (incorrect results):

"2 6" => "3 7 : 10" (7 is not a valid result on a 6-sided die)
"3 8" => "1 8 : 9" (not enough dice rolled)
"3 8" => "1 8 5 4 : 18" (too many dice rolled)
"2 6 -1 ind" => "1 6 : 7" (6 is not a valid result on a 6-sided die with a -1 modifier applied)
"2 6 -1 ind" => "0 5 : 5" (the die has to have a minimum value of 1 with individually applied modifier)
\$\endgroup\$
  • \$\begingroup\$ There's this. As far as I can tell, the only difference is the exact input format and your fourth parameter. I can't say whether or not people will close it as a duplicate (although there's a good chance they will, because all it does is optionally multiply the bonus by the number of dice), but it might generally be unpopular if the community feels it doesn't add anything interesting over an existing challenge. \$\endgroup\$ – Martin Ender Apr 4 '17 at 18:51
  • \$\begingroup\$ @MartinEnder The forth parameter, limits on which dice can be rolled and the negative value modifiers. As for as I can see, the question you linked to doesn't have any consideration for XdY-Z, which I wanted to include as it introduces the minimum 1 constraint for the dice rolls. But that's why I put it in the sandbox first, to see what the community thinks :) \$\endgroup\$ – AntonH Apr 4 '17 at 18:55
  • \$\begingroup\$ @MartinEnder Would it maybe work if I posted a link to that question, but also specified the differences between the questions? \$\endgroup\$ – AntonH Apr 4 '17 at 18:57
  • 1
    \$\begingroup\$ I personally don't think that the max(1, roll) makes a sufficient difference. I know it's frustrating when you put a lot of effort into a challenge spec and it turns out to have already been done (the same or similarly), but if it's almost the same as an existing challenge, it's usually better to try something else. It's ultimately up to you, of course. \$\endgroup\$ – Martin Ender Apr 4 '17 at 19:06
  • \$\begingroup\$ @MartinEnder It got stuck in my head and wouldn't leave, so I had to get it down :P I'll wait a bit to see if anyone else has anything else to add, but if it doesn't go anywhere, it's fine. \$\endgroup\$ – AntonH Apr 4 '17 at 19:13
  • \$\begingroup\$ @MartinEnder I wouldn't close it as a dupe. They're similar, to be sure, but a big chunk of the linked challenge is input parsing and validation, which isn't present here. I also think that the fourth parameter (ind vs all, though I would suggest to let people use two distinct values rather than string-matching) coupled with the possibility of negative modifiers all combine to make this challenge distinct. \$\endgroup\$ – AdmBorkBork Apr 4 '17 at 19:28
  • \$\begingroup\$ @AdmBorkBork Instead of "ind"/"all", would you suggest numerical (0/1) or letter ('i'/'a'), or something else? \$\endgroup\$ – AntonH Apr 4 '17 at 19:33
  • 1
    \$\begingroup\$ Any of the above. If input parsing isn't the primary goal of your challenge (and it doesn't seem to be), don't limit folks on what inputs they and their chosen language can use best. \$\endgroup\$ – AdmBorkBork Apr 4 '17 at 19:41
1
\$\begingroup\$

Find the Translation Table

Given two strings, find the translation table between the two, if the translation is not possible, output false. Probably most easily defined through examples:

Valid Cases

bat,sap = ["bt","sp"]

sense,12312 = ["se","12"]

rabid,snail = ["rabd","snal"]

Falsy Cases

banana,angular = false (not the same length, impossible).

animal,snails = false (different character patterns, not a translation).

Rules

  • Input may be as a 2 element array or as 2 separate inputs.
  • Output can be as an array, on separate lines or space delimited, but must be similar to how I have it shown.
  • False output may be 0, -1 or false. If your language uses something different, ask.

Sandbox Questions

Should I allow inputs of different length to be part of the translation? This will increase the complexity of the question by 100%. I'd suggest using - as the marker for a removal of a character in the translation to make it work. While it makes it more complicated, if this already exists I planned to use that to avoid a duplicate. Let me know what you think. I really like the extension idea though.

\$\endgroup\$
  • \$\begingroup\$ Would empty string "" be an acceptable falsy output? Or empty list []? \$\endgroup\$ – mbomb007 Apr 6 '17 at 21:50
  • 1
    \$\begingroup\$ Shouldn't the second valid test case be ["sen","123"]? \$\endgroup\$ – Laikoni Apr 6 '17 at 22:46
  • 1
    \$\begingroup\$ 1. The examples suggest, but the spec does not state, that trivial translations should be excluded. Or would ["rabid","snail"] also be an acceptable output for rabid,snail? What about ["rabidz","snailz"]? 2. The comment "(different character patterns, not a translation)" seems misleading to me. E.g. given input abc,ddd I would expect that despite having different character patterns the output should be truthy: to wit ["abc","ddd"]. 3. Does the order of the elements in the translation tables matter? I.e. would ["tb","ps"] be acceptable output for the first example? \$\endgroup\$ – Peter Taylor Apr 7 '17 at 10:03
1
\$\begingroup\$

QR Code Editing: Minimum Change

? This is pretty non-trivial, and finding optimal solutions is probably computationally difficult.

QR codes are a way to represent URLs and other strings of text using a 2D image. What you might not know, however, is that a significant portion of a QR code is error-correction or unused space.

In this challenge, your program will be given a square of 1s and 0s representing a QR code. This QR code may not be functional, or it may be valid or point to some destination. Your program will also receive a string, representing the data that the new QR code should be encoded with. The goal of the program is edit the original QR code to contain the new content, but also to do it with as few pixel-flips as possible.

Here's an image describing some parts of the QR format:

enter image description here

QR code art generator, demonstrating how much of a QR code's space can be modified without changing the content: https://www.qrpixel.com/

Spec is only partially completed, I'll probably have to find some decent resources on QR code formats and error correction.

\$\endgroup\$
  • \$\begingroup\$ sound like it will make an interesting challenge once the spec is fleshed out. I assume you're going to include all the qr code info that we need? \$\endgroup\$ – Liam Apr 9 '17 at 22:36
1
\$\begingroup\$

Pratt certificates

(bumping this proposal to see if there's any interest or comments. If so, speak now; if not, I'll delete)

Your task: write code that generates a Pratt certificate for a prime number, and write code that verifies an existing Pratt certificate.

What's a Pratt certificate?

A Pratt certificate for a prime number p is a proof, of a particular type, that p is indeed prime. Historically, it was used in situations where proving the primality of p required a computation that was slow due to factoring p-1, but verifying the certificate (once the initial computation generated it) was quite fast.

A Pratt certificate for p is a recursive structure consisting of three parts: the prime p itself; a "witness" integer g (which is actually a primitive root modulo p; see the next section for its properties); and Pratt certificates for all primes dividing p-1. The prime p=2 is special: a Pratt certificate for 2 is just 2 itself.

For example, here is a Pratt certificate for p=3911:

{3911, 13, {2, {5, 2, {2}}, {17, 3, {2}}, {23, 5, {2, {11, 2, {2, {5, 2, {2}}}}}}}}

The witness is 13, and the prime factors of 3911-1 are 2, 5, 17, and 23; each of those new primes itself has a Pratt certificate, which are respectively 2, {5, 2, {2}}, {17, 3, {2}} and {23, 5, {2, {11, 2, {2, {5, 2, {2}}}}}. In this last Pratt certificate, the prime factors of 23 are 2 and 11, so a Pratt certificate for 11 must be included, and so on.

How do we generate a Pratt certificate?

Given a prime p, a Pratt certificate can be generated by finding a primitive root g modulo p; factoring p-1 into primes (keeping only one copy of each prime factor); and recursively generating Pratt certificates for every prime factor of p-1.

How do we verify a Pratt certificate?

Given a prime p, a witness g, and the prime factors q1, q2, ... of p-1, a Pratt certificate is verified by checking:

  • that p-1 has no prime factors other than q1, q2, ...;
  • that the power g^(p-1) is congruent to 1 modulo p;
  • that none of the smaller powers g^((p-1)/q1), g^((p-1)/q2), ... are congruent to 1 modulo p; and
  • that each of the Pratt certificates of q1, q2, ... are themselves valid.

Scoring and technicalities

You must write two programs or functions (or one of each): one that takes a prime number as input and returns its Pratt certificate; and one that takes an input formatted like a Pratt certificate and returns a truthy or falsy value depending on whether it is an actual Pratt certificate.

  • You may choose any reasonable format for the Pratt certificate: nested lists (like the examples in this question), indented multiline strings (like the example on the Wikipedia page), or something similar that a human being could be trivially trained into parsing by eye. You may use any reasonable convention for the trivial Pratt certificate for 2.
  • However: whatever format you choose for the Pratt certificate, your certificate-generating code must output the same format that you take as input to your certificate-verifying code. Note that your certificate-verifying code must be capable of verifying any possible Pratt certificate (in your format) for p, not just the one your other program generates for p.
  • If you want, you may write a single program or function that accomplishes both tasks; in that case, your code can either determine which task is being asked of it implicitly from the input, or it can allow the user to instruct it which task to perform in some reasonable way.
  • Regardless of whether you use one or two programs, no calculation can be shared or saved between different runs of the code. The programs must work correctly, on any individual prime input and on any individual certificate-shaped input, if it is the first time that code is ever being run on that system.
  • You don't have to handle bogus input. You may always assume that the input to your first program is an actual prime number, and that your input to the second program syntactically matches your Pratt certificate format.
  • Built-ins that generate or verify Pratt certificates are not allowed. Other types of built-ins (for example, those that factor integers, raise integers to powers in modular arithmetic, find primitive roots) are acceptable.
  • This is , so shorter code (in bytes) is better. If two programs are used, the total number of bytes in both programs is the score; if one program is used, its number of bytes is the score.

Example Pratt certificates given prime inputs

(Note that there are many possible witnesses for any given prime, but the rest of the certificate is unique up to reordering.)

31 -> {31, 3, {2, {3, 2, {2}}, {5, 2, {2}}}}
127 -> {127, 3, {2, {3, 2, {2}}, {7, 3, {2, {3, 2, {2}}}}}}
229 -> {229, 6, {2, {3, 2, {2}}, {19, 2, {2, {3, 2, {2}}}}}}
1093 -> {1093, 5, {2, {3, 2, {2}}, {7, 3, {2, {3, 2, {2}}}}, {13, 2, {2, {3, 2, {2}}}}}}
65537 -> {65537, 3, {2}}

(All the above outputs are examples of truthy inputs for the Pratt-certificate checking code.)

Example falsy inputs for Pratt-certificate checking

{31, 2, {2, {3, 2, {2}}, {5, 2, {2}}}}
{31, 3, {2, {3, 2, {2}}}
{31, 3, {2, {3, 2, {2}}, {5, 2, {2, {3, 2, {2}}}}}}
{127, 2, {2, {3, 2, {2}}, {5, 2, {2}}}}
{85, 4, {6, 5, {5, 2, {2}}}, {14, 3, {13, 2, {2, {3, 2, {2}}}}}}
\$\endgroup\$
1
\$\begingroup\$

Median fractals

I define 'Median fractal' as this.

Median fractal L1 is a equilateral triangle.

for median fractal Ln, Draw Ln-1, then for each triangle, draw all 3 medians in the triangle.

You will be given an integer n, draw Ln.


Sandbox

Any suggestions, guys?

\$\endgroup\$
  • \$\begingroup\$ Would benefit from 1. A definition of the median of a vertex; 2. Diagrams of L_2 and L_3; 3. A better name. It's a variant on triangle centre fractals, but perhaps would be best called the vertex-median fractal. \$\endgroup\$ – Peter Taylor Apr 15 '17 at 12:12
  • \$\begingroup\$ I'm not sure what exactly "draw all 3 medians in the triangle" means. I think providing images of the first few fractals would help a lot to make the construction better understandable. \$\endgroup\$ – Laikoni Apr 17 '17 at 7:42
  • \$\begingroup\$ Should add: graphical output questions should at the very least specify minimum sizes to avoid trivial answers which give a 1x1 pixel bitmap output - although I suspect answers will favour vector graphics formats. \$\endgroup\$ – Peter Taylor Apr 18 '17 at 16:24
1
\$\begingroup\$

These would be separate questions, and each would link to the other.

Cops: Make a bad password policy

Over the years, people have come up with some pretty bad password policies. Your challenge is to make such a policy, and to make a program that takes advantage of the weakness of this policy to brute force passwords written in it (a "crack"). For details on what constitutes a "crack", see the robber thread [link]. It should restrict the user to as small a selection of passwords as possible. Robbers will attempt to find cracks for your policy. If your answer is uncracked after 7 days, you make mark it safe by posting your crack. The "worst" uncracked policy (that is, the one that allows the fewest passwords) wins.

A "policy" is defined as a list of well-defined restrictions ("rules") on valid passwords. Here is an example:

  • Passwords must contain only digits, letters, and the characters '*&^'.
  • Passwords must be at most 8 characters long.
  • Passwords must not contain dictionary words (if you use this one, you must use a freely and programmatically accessible dictionary and tell us where to find it).

Policies:

  • must contain no more than 10 rules,
  • may not involve encryption of any kind, and
  • must be clear and unambiguous

For example, these would be a bad rules:

  • The MD5 hash or zipfile of the password must not contain the letter "a". (Uses encryption of a sort)
  • Passwords may not contain special characters. (It's unclear what counts as a special character)

Your answer must contain both the policy and the number of passwords it allows.

Robbers: Crack the bad password policy

Over the years, people have come up with some pretty bad password policies. Your challenge is to crack such a policy. These can be found in the cops thread [link]. To crack a policy, write a program to brute force passwords that adhere to that policy. Your program must run in linear time on the number of possible passwords allowed by the policy. You may do this by enumerating or iterating over all possible passwords in some way, such as by calling a function (called, for example, guessPassword) for each possible password. One option is to simply hardcode the possible passwords, if there are only a few. Here is an example (JavaScript):

function* getPasswords() {
    yield* ['a', 'b', 'c'];
}

Or, using the second approach:

function bruteForce() {
    for (let pw of ['a', 'b', 'c']) {
        if (guessPassword(pw)) {
            return pw;
        }
    }
}

Whoever cracks the most policies wins.


Sandbox

  • Is the linear time approach good? My original thought was just "your program must halt in a reasonable time", but that seems too vague, and this allows a person to crack even policies with a lot of possible passwords (though those hopefully wouldn't win anyway).
  • I could also just say, "pick a password in your policy and robbers will try to crack it", maybe having the cops supply a hash of the password.
\$\endgroup\$
  • 1
    \$\begingroup\$ I'm worried that this sort of challenge needs far too many arbitrary-seeming restrictions on the policy to make it work. The restriction against prime numbers is already fairly arbitrary, for example. Additionally, "linear time" doesn't make sense here; there's a finite number of possible passwords (according to the victory condition), meaning that any program that enumerates them runs in O(1) (thus faster than linear) by definition. Also, I think it's fairly easy to encode an NP-complete problem into the challenge in an understandable way; many are pretty intuitive. \$\endgroup\$ – user62131 Apr 17 '17 at 9:30
  • \$\begingroup\$ @ais523 Okay, if I require cops to have valid cracks, a few of those restrictions go away, since we don't have to worry about people making policies that are impossible to crack. Also, I know the programs would technically all be constant time, but I'm not sure how else to specify what constitutes a "fast" crack. I could just say, "must run in a few minutes on my machine" or something. \$\endgroup\$ – Brian McCutchon Apr 17 '17 at 16:12
  • \$\begingroup\$ "I'm not sure how else to specify what constitutes a "fast" crack" is IMO evidence that this idea is not workable. \$\endgroup\$ – Peter Taylor Apr 17 '17 at 17:57
1
\$\begingroup\$

shortest angular path

Let's say you have a robot and you measure the orientation of a wheel (e.g. for tracking the exact distance), but the sensor just returns an angle between -180° and 180°. Then you have the problem that even if the wheel just moved three degrees from 179° to 182° the sensor will tell you that the wheel made a jump from 179° to -178°. This makes analyzing and interpreting the data a little bit cumbersome. Given a list of subsequent measurements your goal is now "smoothing" them out, such that from each entry A to the next B, in the list ([...,A,B,...]) there is at most a 180° jump.

Details

  • You can also assume other (single number) representations of angles, e.g. radians (0 to 2*pi) or gradian (0 to 400) or number of turns (0 to 1).
  • If it is more convenient, you can assume that the sensor will return data in [0°,360°] instead of [-180°,180°].
  • Which way you go if the jump is exactly 180° (or -180° or 540° etc.) is up to you.

Examples

[0 10 90 80 180 -130 -90 -120 -143 170 0] (Input)
[0 10 90 80 180 230 270 240 217 170 0]    (Output)
\$\endgroup\$
1
\$\begingroup\$

Smooth an array

A typical signal processing operation consists in smoothing a signal to reduce noise.

A very basic way to perform such smoothing, on an array of integers, is using the following formula:

enter image description here

where y'_t is the smoothed value at index t, y_t is the original value at index t, and where β is a smoothing parameter (in [0,1]). Note that y' = floor(y + 0.5) is the classic round half up operation.

For t = 0, there is no y'_(t-1), thus we set that y'_0 = y_0.

Applying that operation on a sequence of integers pictured below on the left, produces the sequence of integers pictured below on the right:

enter image description here

Challenge

Given a list of integers and β, output that list of integers smoothed in that way.

All integers of the list will be guaranteed to be in the interval [1, sup) where sup is the maximum integer representable in the integer type you use in your language. All integers of the input must be taken, and all integers of the output must be printed, in the decimal base (unless your language does not support decimal numbers, in which case you may use the standard base your language uses).

The input list is guaranteed to have at least 2 elements. You may take that input list in any way or format that is sensible in your language.

β is guaranteed to be in [0,1].

Test cases

TODO add more

List                               β     Output
[1,2,7,3,11,13,26,5,18,4,3,2,1]    0.5   [1,2,5,4,8,11,19,12,15,10,7,5,3]

Scoring

This is , so the shortest answer in bytes wins.

\$\endgroup\$
1
\$\begingroup\$

Output the Name of a Number

Idea from a recent question on math SE.


Write a program or a function that takes an integer from range 0 to 255 (inclusive) and outputs the name of its unsigned 8-bit binary representation. Input can be in any integer format you like, but the outputted name must match the number's unsigned 8-bit representation.

The name of the number is determined by the positions of its binary digits that are 1:

1 − John
10 − Watson
11 − Watson John
100 − Kevin
101 − Kevin John
110 − Kevin Watson
111 − Kevin Watson John

Let the names for the eight bits be Laura, William, James, Mary, Alice, Kevin, Watson, and John.

So now the name of 255 (11111111 in binary) is:

Laura William James Mary Alice Kevin Watson John

Zero doesn't have a name under this system so you may output an empty string or nothing at all. Trailing whitespace is allowed for all outputs.

Test cases:

<input (as decimal)>
<8-bit binary>
<output>

10
00001010
Alice Watson

42
00101010
James Alice Watson

128
10000000
Laura

189
10111101
Laura James Mary Alice Kevin John

55
00110111
James Mary Kevin Watson John

96
01100000
William James

37
00100101
James Kevin John

0
00000000


255
11111111
Laura William James Mary Alice Kevin Watson John

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

\$\endgroup\$
1
\$\begingroup\$

Optimize for the Test Cases

Given a set of test cases (pairs of input and output strings) as input, output a program in a programming language of your choice that consistently and deterministically produces the correct output for each input.

Rules

  • You may choose any programming language for the output programs, so long as it is a programming language by our definition, it existed prior to the creation of this challenge, and it is capable of taking arbitrary ASCII strings as input and producing arbitrary ASCII strings as output.
  • Your solution must use the same programming language for all inputs. The output programs do not need to be in the same language as the solution.
  • The output program must consistently and deterministically produce the correct output for each input. That means that, no matter how many times the program is run, it will always produce the correct output (barring any uncontrollable accidents like cosmic rays twiddling bits). PRNGs are allowed so long as a constant seed is provided (making the output consistent and deterministic).
  • The test cases' inputs are provided without quotes, but you may require that the input be quoted if it is necessary or convenient (as per our usual policy on quoted input). However, you must either always or never have quotes on the input - you can't have some with quotes and some without.
  • It does not matter what the output program does for inputs that are not part of the specific test case the program was created for.
  • You may optionally take the number of test cases as input, if that is convenient or necessary.
  • Every input in a set of test cases will be mapped to a unique output. Input values will not be repeated within a set of test cases (so [(3, 5), (3, 6)] wouldn't be a valid test case).

Scoring

Your score will be equal to the sum of the byte counts of all generated programs for the set of scoring cases. Lowest score wins. This is a competition within output languages, not a competition between output languages, so don't be afraid to choose a language that is more verbose than others. I reserve the right to change the scoring cases should it be necessary.

Examples

A C++ program that outputs (poorly-golfed) Python functions:

#include <iostream>
#include <string>
#include <sstream>

using namespace std;

const string function_skeleton_start = "lambda s:{";
const string function_skeleton_end = "}[s]";

int main() {
    int N = 0;
    string in, out;
    stringstream program;
    program << function_skeleton_start;
    cin >> N;
    cin.ignore();
    for(int i = 0; i < N; ++i) {
        getline(cin, in);
        getline(cin, out);
        program << "'" << in << "':'" << out << "',";
    }
    program << function_skeleton_end;
    cout << program.str() << endl;
    return 0;
}

An example input:

2
foo
bar
bar
foo

The corresponding output:

lambda s:{'foo':'bar','bar':'foo',}[s]

Test Cases

(TBD)

\$\endgroup\$
  • \$\begingroup\$ I'd be very interested to see some of the answers this challenge would get +1 \$\endgroup\$ – MD XF May 10 '17 at 1:21
1
\$\begingroup\$

Output "Hello, World!"... Even before it runs?

Please note that this challenge only applies to languages that have a build stage and a build log.

Output "Hello, World!" to the build log. The program may or may not be compiled successfully, the job is to just output "Hello, World!" somewhere in the build log.

Example (C/C++)

#pragma message("Hello, World!")
\$\endgroup\$
  • 1
    \$\begingroup\$ could it be more interesting as a rosetta-stone challenge? \$\endgroup\$ – John Dvorak May 13 '17 at 9:32
1
\$\begingroup\$

Output the Balmer Series

Challenge

Write a program which outputs the following image (note, it is an svg):

It is the emission spectrum of hydrogen, caused by the Balmer series: https://en.wikipedia.org/wiki/Hydrogen_spectral_series#5

Your program must not read the image from the internet or a local file.

The image may be to an image file or a graphics window. If not a vector, the image sides must be greater than 400 pixels.

Your image must have the same colours and same ratios of spacing between each line.

Winning

Shortest code wins.

\$\endgroup\$
  • \$\begingroup\$ What does it mean to output the image "exactly"? It's obviously not pixel-for-pixel for two reasons: firstly, because the image isn't raster, and secondly, because the spec allows for variation in image size. \$\endgroup\$ – Peter Taylor May 12 '17 at 22:22
1
\$\begingroup\$

Extension of MIME-Type

Your task, given this list of extension and MIME-types, is to choose exactly 20 of them and create a program that takes in either e, the extension, or m, the MIME-Type, and outputs its counterpart.


Example (if my set was [.pdf, .doc]):

Cases to handle:

f('.pdf') = application/pdf
f('application/pdf') = .pdf
f('application/msword') = .doc
f('.doc') = application/msword

Cases you don't have to touch:

f('Nonsense') = [Error, null, false, whatever]

I & O

  • Input will be a single string, so will output.
  • You must handle 20 mime-type combinations and mention which ones you are handling.
  • Trailing spaces and newlines are fine.
  • Extensions always include the preceding period.
  • When choosing a long extension like .cryptocode, if you return the MIME-type of .cryptocode for an input of .cry it will be considered an invalid submission, remember this.

Winning

\$\endgroup\$
  • 3
    \$\begingroup\$ kolmogorolofvlfoao-complexity??? \$\endgroup\$ – programmer5000 May 17 '17 at 0:06
  • \$\begingroup\$ Could you add a pastebin with the list in this format: .123<tab>application/vnd.lotus-1-2-3<newline>.3dml<tab>text/vnd.in3d.3dml to make reading easier? \$\endgroup\$ – programmer5000 May 17 '17 at 0:09
  • \$\begingroup\$ Be sure to include the list in the question itself when you post this on main. We want questions to be self-contained. \$\endgroup\$ – John Dvorak May 17 '17 at 3:53
  • 2
    \$\begingroup\$ "When choosing a long extension like .cryptocode, if you return the MIME-type of .cryptocode for an input of .cry it will be considered an invalid submission, remember this." - why? Do I have to detect if the input is one of my set? This will reduce my compression ratio significantly. \$\endgroup\$ – John Dvorak May 17 '17 at 3:56
  • \$\begingroup\$ @JanDvorak it's too big for posting here, and if pastebin goes does a lot of the internet would lose a lot of data. \$\endgroup\$ – Magic Octopus Urn May 25 '17 at 17:04
  • \$\begingroup\$ @programmer5000 you can post it if you want. \$\endgroup\$ – Magic Octopus Urn Aug 27 '17 at 2:59
  • \$\begingroup\$ Concerning the "exactly 20" requirement: Are we allowed to output anything we want if fed something not in that 20 or does it need to output a falsey value? The addition of the word "whatever" added confusion for me. \$\endgroup\$ – Engineer Toast Mar 13 '18 at 14:22
  • \$\begingroup\$ @programmer5000 Tab-separated version for OP's benefit. \$\endgroup\$ – Engineer Toast Mar 13 '18 at 14:31
1
\$\begingroup\$

Is it a number?


Given an input, output truthy if it is a valid floating point number, and falsy if it is not. The format that is used in this challenge is [-][<integer>][.][<integer>][e[-]<integer>], where square brackets specify optional values. At least one group in the first section ("mantissa") needs to exist.

Here are some examples of inputs:

Valid

100
-100
10.245
-12.44
.5
-.2
0.3
-0.776
3365883.0000112
5e3         # equal to 5000
-.5245e3    # equal to -524.5
155.0e-3    # equal to 0.155
-5e-1       # equal to -0.5
.           # equal to 0.0

Invalid

feed me numbers
-5-3
5..2
4160e
e4
543tomatoes234
123 456
-3e0.15
4q2

Rules

  • Standard loopholes apply
  • This is a , shortest answer wins. However, it will not be accepted.

\$\endgroup\$
  • \$\begingroup\$ For reference, -?\d*(\d+|\.\d*)(e-?\d+)? will match it if it's a number; it will match parts though so beware of that. \$\endgroup\$ – user42649 May 17 '17 at 4:15
  • \$\begingroup\$ How to handle empty input, and is -0 valid? \$\endgroup\$ – Pavel May 17 '17 at 4:19
  • \$\begingroup\$ @Phoenix Empty input is invalid. -0 is valid for this challenge. \$\endgroup\$ – dkudriavtsev May 17 '17 at 4:19
  • \$\begingroup\$ Please add those as test cases. \$\endgroup\$ – Pavel May 17 '17 at 4:57
  • 1
    \$\begingroup\$ Also, -, e, .e4, -e4, -. \$\endgroup\$ – Pavel May 17 '17 at 4:58
  • 1
    \$\begingroup\$ This has definitely been done before here \$\endgroup\$ – caird coinheringaahing May 17 '17 at 6:55
  • 1
    \$\begingroup\$ How is . equal to 0.0? Will the valid inputs be as integers, strings or either? \$\endgroup\$ – Shaggy May 17 '17 at 12:33
  • \$\begingroup\$ @Shaggy This is meant to represent floating point literals. Valid inputs are strings. \$\endgroup\$ – dkudriavtsev May 17 '17 at 21:12
1
\$\begingroup\$

Don't break the bridges!

Introduction:

You are a worker, who is in charge of managing a set of bridges, connecting a square grid of "nodes":

N - N - N
|   |   |
N - N - N
|   |   |
N - N - N

(the grid here is 3 by 3, but they can be larger).

Each of the bridges has a set capacity from 1 to 10, and each of the bridges has a number of cars over them, also from 1 to 10.

  • If a bridge has a higher capacity than the number of cars on that bridge, then it is considered "safe", and you can cross over it.
  • If a bridge's capacity and number of cars going over it are equal, then it is considered "stable". It won't collapse, but you can't cross over it.
  • If a bridge has a lower capacity than the number of cars on that bridge, then it is considered "collapsing", and you only have a limited amount of time to fix it.

When a bridge has n capacity and m cars, with n smaller than m, the time it takes to collapse is:

      m + n
ceil( ----- )
      m - n

You must take materials (and therefore reduce the bridge's capacity) from other bridges and arrive to those bridges on time to fix them! To get materials from a bridge, you must cross over it. For example, take this small arrangement:

A - B

The bridge between A and B (which we'll call AB) has 3 capacity, and let's say you're on A, and want to take 1 material. To take the material, simply cross from A to B.

Now, AB has 2 capacity, and you have 1 material on you. You may only cross over bridges that are "safe", though (or if you're fixing a bridge, which is explained in the next paragraph).

To fix a bridge, you must go over it, thereby depositing all materials needed to fix the bridge. For example, in the example above, if AB had 1 capacity and 2 cars currently on it, and you had 2 material on you, once you cross the bridge you will have 1 material, because that is all that's required to fix the bridge.

You must fully cross a broken bridge before the bridge collapses, otherwise it will break. Each crossing of a bridge takes 1 hour, and the time it takes for the bridge to collapse is shown in the formula above. For example:

A
|
B
|
C - D

In this example, if your starting node was A, and CD only had a "lifespan" of 2 hours, the bridge would collapse before you can get to it (crossing AB takes 1 hour, crossing BC takes another hour).

Task:

Your task is to make a program that calculates, given a list of bridges, which are represented themselves as lists of two elements (first element is capacity, second element is cars on the bridge), whether or not it's possible to fix all of the bridges. The bridges work from top-to-bottom, left-to-right - so an input of

[[3 2] [3 2] [2 5] [5 1]]

means that the actual grid looks like this:

    3
 A --- B
 |  2  |
3|2   2|5
 |  5  |
 C --- D
    1

So AB has a capacity of 3 and 2 cars, AC has a capacity of 3 and 2 cars, BD has a capacity of 2 and 5 cars, and CD has a capacity of 5 and 1 car.

Rules / Specs:

  • Your program must work for, at least, 10 * 10 grids.
  • Your program may accept the input as either a string with any delimiter, or a list of lists (see example I/O).
  • Your program must output the same value for true for all true values, and it must output the same value for false for all false values.
  • You can either submit a full program or a function.

Example I/O:

[[5 5] [5 5] [1 1] [3 3]] => true
[[2 5] [2 2] [3 3] [1 2]] => false
[[3 2] [3 2] [2 5] [5 1]] => true

NOTE, you can take the input like this as well:
[[3, 2], [3, 2], [2, 5], [5, 1]] (Python arrays)
3,2,3,2,2,5,5,1                  (Comma-separated string)
3 2 3 2 2 5 5 1                  (Space-separated string)
\$\endgroup\$
  • \$\begingroup\$ "You may only cross over bridges that are "safe", though. To fix a bridge, you must go over it". Huh? \$\endgroup\$ – Peter Taylor May 20 '17 at 10:53
  • \$\begingroup\$ @PeterTaylor Fixed. \$\endgroup\$ – Qwerp-Derp May 20 '17 at 11:02
  • \$\begingroup\$ Will the input always have a square number of elements? \$\endgroup\$ – ETHproductions May 20 '17 at 11:38
  • \$\begingroup\$ @ETHproductions The nodes are square, but the input won't always have a square number of elements, because the number of paths diverges from the number of nodes (4 for 2 * 2, 12 for 3 * 3, etc.). I'm all ears to better input formats, I understand this one would be hard to process. \$\endgroup\$ – Qwerp-Derp May 20 '17 at 11:40
  • \$\begingroup\$ Ah, so it'll always be a number of the form 2*n*(n-1), or 4 times a triangular number. Not sure if there is any better input format... \$\endgroup\$ – ETHproductions May 20 '17 at 12:33
1
\$\begingroup\$

How many times?

Inspired by Rotational symmetry of string.

Given a string, return its shortest substring that, when repeated a number of times, will produce the original string, as well as the number itself.

Test cases:

"ABCDABCDABCDABCD" => "ABCD", 4
"AAAAAAAAAA" => "A", 10
"ABCDEFGHIJKLMNOPQRSTUVWXYZ" => "ABCDEFGHIJKLMNOPQRSTUVWXYZ", 1
"" => "", 0
"Don't repeat yourself. Don't repeat yourself. " => "Don't repeat yourself. ", 2

Rules:

  • You may return the substring and the number in any format you'd like, as long as it's consistent and clear i.e. you can always separate the number correctly from the substring e.g. abc12 isn't allowed since you can't determine whether abc is to be repeated 12 times or abc1 is to be repeated 2 times. The substring must be returned verbatim, while the number can be returned in any generally allowed format per meta consensus.
  • The substring must be the shortest possible.
  • For the empty string, you must return "" and 0.

Sandbox

  • Is the challenge description golfed enough? :P
  • May I improve the return/output format?
\$\endgroup\$
  • \$\begingroup\$ Pleas can you change the abc2 should be repeated 1 time to abc1 should be repeated 2 times? It makes more sense. \$\endgroup\$ – caird coinheringaahing May 20 '17 at 21:16
  • \$\begingroup\$ @RandomUser Typo; should be fixed. \$\endgroup\$ – Erik the Outgolfer May 20 '17 at 21:17
  • \$\begingroup\$ Related, supertask \$\endgroup\$ – Peter Taylor May 21 '17 at 7:02
  • \$\begingroup\$ What range of characters are possible within the string? Can newlines occur? \$\endgroup\$ – Steve Bennett May 21 '17 at 8:58
  • \$\begingroup\$ Also, why not just specify that the output format is "12\nabc"? Otherwise there may be arguments on everyone's answers about whether or not they meet the requirements. \$\endgroup\$ – Steve Bennett May 21 '17 at 8:59
  • \$\begingroup\$ @SteveBennett And that's what the second question in the "Sandbox" section is for. Please note that I do not intend to restrict the output format like this. \$\endgroup\$ – Erik the Outgolfer May 21 '17 at 11:47
1
\$\begingroup\$

Add a language to a quine


Add a language to a quine program. Your program must output itself in all languages used so far.

Second to last answer wins after no answers have been posted for two weeks.


\$\endgroup\$
  • \$\begingroup\$ this is hard mode of existing challenge? \$\endgroup\$ – Destructible Lemon May 24 '17 at 3:58
  • \$\begingroup\$ @DestructibleLemon Basically. \$\endgroup\$ – dkudriavtsev May 24 '17 at 3:58
  • \$\begingroup\$ @Okx So that you can't win by posting an answer which is impossible to add onto. \$\endgroup\$ – ETHproductions May 25 '17 at 15:12
1
\$\begingroup\$

Build a simple 2D game engine

Write a program that take input specifying specs of a simple 2D game regarding the following:

  • GUI: a space where you can print text
  • Scene: a 2D stage where player\enemy move
  • Input Scheme: a way to check for input
  • Player: one object
  • Enemy: one or more objects
  • Coin: one object
  • Engine: manage running scenes

The program should offer the following instructions:

  • generate: create an object & place it in the scene
  • destroy: destroy an object or hide it from the scene
  • move: move an object to a different location, or apply motion
  • collision: check if two objects are colliding or interlacing
  • write: write to GUI
  • param: create, modify, or read an integer
  • terminate: stop running update, and run end
  • a way to do an if-else

A Scene should at least have the following functions:

  • start: sequence of instructions, applied once when the scene is fired
  • update: sequence of instructions, applied N-times per second
  • end: sequence of instructions, applied once when the scene is terminated

Example

Input the game spec

GUI:1,10

SCENE:5,10

START: GEN(p1,PLAYER,5,1); GEN(e1,ENEMY,4,4); GEN(c1,COIN,3,6); PARAM(r1,0)

UPDATE:  IF(COLLISION(p1,c1), DESTROY(c1);PARAM(r1,PARAM(r1)+1));
         IF(COLLISION(p1,e1), DESTROY(p1);TERMINATE);
          IF(INPUT(ARROW-UP), MOVE(p1,-1,0));
        IF(INPUT(ARROW-DOWN), MOVE(p1,+1,0));
        IF(INPUT(ARROW-LEFT), MOVE(p1,0,-1));
       IF(INPUT(ARROW-RIGHT), MOVE(p1,0,+1));
       WRITE(g1,r1)

END: IF(PARAM(r1)=1, WRITE(g1,"YOU WON"), WRITE(g1,"GAME OVER"))

Output an interactive game

[ 0        ] <----- G:GUI (1 x 10)
+----------+
|          | <--- S:Scene (5 x 10)
|          |
|      C <-|----- C:Coin
|   E <----|----- E:Enemy
|P <-------|----- P:Player
+----------+
  • game starts with player, one enemy, one coin
  • you can control the player with arrow keys
  • if player come in contact with enemy, player disappear then it ends
  • if player come in contact with coin, coin disappear then it's counted
  • when game ends, if coin count is 1 you win, otherwise you lose

Meta

  • What tags to use?
  • How can I simplify the requirements so that it's possible to solve it with languages of simple means?
  • I haven't seen many challenges like this, to write a program which parse instructions to create an interactive program within it, what do you think?
\$\endgroup\$
1
\$\begingroup\$

Distinct strict partition counts


Related

The Task

Write a function or program that, given a positive integer n, returns or prints an array (or list, set, etc.) of length l such that each index i contains the count of distinct partitions of size i of n (one-indexed) and l is the maximum size of partitions for n.

Definition

Let f(n) implement the task described.

Consider f(10)

10 may be broken into the following distinct partitions:

10         // Size 1
9,1        // Size 2
8,2
7,3
6,4
7,2,1      // Size 3
6,3,1
5,4,1
5,3,2
4,3,2,1    // Size 4

There are:

  • 1 distinct partitions of size 1.
  • 4 distinct partitions of size 2.
  • 4 distinct partitions of size 3.
  • 1 distinct partitions of size 4.

Therefore, f(10) returns [1, 4, 4, 1].

Test Cases

TODO

\$\endgroup\$
  • \$\begingroup\$ A008289. \$\endgroup\$ – Peter Taylor May 24 '17 at 21:25
  • \$\begingroup\$ @PeterTaylor Thank you. I was dreading the larger test cases. \$\endgroup\$ – Addison Crump May 24 '17 at 21:35
  • \$\begingroup\$ in my opinion this suggestion is quite clearly defined and simple, I like it - but it didn't attract votes nor critique .. do people find it too mathematical? I was going to propose something similar related to enumerating Standard Young Tableaux given a partition shape \$\endgroup\$ – jayprich Aug 22 '18 at 10:14
1
\$\begingroup\$

Show key code

Inspired by the showkey command.

Task

You have to output the key and if is a key-up or a key-down event. I exemplify:

enter image description here

The output I want:

Key X Down
Key X Up

for both the instants you press or release a key.

You can output it on a console or on a GUI.

It is , so shorter code wins.

\$\endgroup\$
  • 1
    \$\begingroup\$ I don't think this is currently clear. What keys correspond to what key codes? You should include either a list, or some source where one can determine which keys correspond to which codes. \$\endgroup\$ – Sriotchilism O'Zaic May 27 '17 at 0:18
  • \$\begingroup\$ @WheatWizard i think, there is standard. Also, if not, there will be keyboard/language-related key code table \$\endgroup\$ – Евгений Новиков Jul 31 '17 at 11:48
1
\$\begingroup\$

Set The Shapes

Updated on 23/05/17 with new shapes & questions

Challenge

Let s be the sequence of polygonal numbers with S sides and t be the sequence of polygonal numbers with T sides. Take the set union of the first n elements of s and the first n elements of t.

Input

3 integers, n, s & t where:

  • n>0, 2<(s,t)<13 and s!=t
  • The values of s & t each represent a different polygonal number type:
  3 = Triangle
  4 = Square
  5 = Pentagon
  6 = Hexagon
  7 = Heptagon
  8 = Octagon
  9 = Nonagon
 10 = Decagon
 11 = Hendecagon
 12 = Dodecagon

Output

An array of the set union of the first n numbers of shapes s and t in ascending order.

Example

(assuming 0-based indexing)

  • Input: n=5, s=3, t=4
  • The first 5 triangular numbers are 0, 1, 3, 6, 10
  • The first 5 square numbers are 0, 1, 4, 9, 16
  • Output: [0, 1, 3, 4, 6, 9, 10, 16]

Rules

  • Input must be 3 separate integers
  • Output must be an array (or equivalent in your chosen language)
  • If your chosen language isn't capable of handling either or both of the above then standard I/O methods apply
  • s & t are guaranteed to be different but you must be able to handle them being input in either order - smallest first or largest first
  • This is so lowest byte count wins

Test Cases

Input: 5, 3, 4
0-Based Output: [0, 1, 3, 4, 6, 9, 10, 16, 20]
1-Based Output: [1, 3, 4, 6, 9, 10, 15, 16, 25]

Input: 10, 9, 8
0-Based Output: [0, 1, 8, 9, 21, 24, 40, 46, 65, 75, 96, 111, 133, 154, 176, 204, 225, 261]
1-Based Output: [1, 8, 9, 21, 24, 40, 46, 65, 75, 96, 111, 133, 154, 176, 204, 225, 261, 280, 325]

Input: 1, 7, 6
0-Based Output: [0]
1-Based Output: [1]

Input: 8, 3, 3
Invalid input as both shapes are the same

Input: 0, 2, 17
Invalid input as n<1, s<3 and t>12

Bonus Idea 1

Brownie points if you want to increase the range for s & t and include some other polygons (e.g., star, dodecagon).

Bonus Idea 2

Alter the challenge to only require that solutions be able to handle 5(?) different shapes with a score reduction for each additional shape, up to a maximum of 10(?).


Questions

This is my first challenge (inspired, in part, by this) so all feedback very much welcome.

  • Should I add or remove any tags?
  • Is the above sufficiently different from this and this?
    (Votes: 2 for this not being a dupe, 2 for it being a dupe of the second linked challenge)
  • Does everything read OK & make sense?
  • Should I include the formula for each shape in the question?
    I'm leaning towards "yes" as:
    1. For those that know them, figuring them out won't be a challenge
    2. For those that don't, figuring them out wouldn't add to the challenge
    3. As soon as one person posts a solution containing the formulas, that makes them available to everyone else anyway.
  • Should there be more (e.g., star, tridecagon+) or less possible shapes?
  • Would it improve the challenge if I allowed solutions to pick a smaller subset of 5(?) shapes to work with? How about if that subset had to be sequential (e.g., 3-7 or 5-9 but not 3,5-8)?
  • What test cases should I add?
  • Do the bonus ideas add to or detract from the challenge?
    Answered: Bonuses are generally bad.
  • Is there a better name I can give this challenge?
  • Should I be asking any other questions?!
\$\endgroup\$
  • \$\begingroup\$ Yeah if you want to make it bigger just add the polygons and require them. But right now it looks to be a big enough handful. \$\endgroup\$ – Christopher May 17 '17 at 10:14
  • 1
    \$\begingroup\$ The two linked challenges don't seem similar enough to make this a duplicate (to me). \$\endgroup\$ – trichoplax May 17 '17 at 10:18
  • 2
    \$\begingroup\$ 1. I don't find "the first n numbers of both shapes" very clear. In fact, I can't find a single English phrase which cleanly expresses the meaning I reverse engineered from the example. I think it takes a few sentences or a mathematical expression. 2. The example looks wrong: what happened to 15? 3. I disagree with trichoplax: IMO this is a duplicate of the second linked question. \$\endgroup\$ – Peter Taylor May 17 '17 at 10:51
  • \$\begingroup\$ Thanks for your comments, @PeterTaylor. 1. Could you suggest some wording for the intro to make it clearer? 2. Yep, I messed that up in an edit - it's fixed now. 3. Fair enough, that's one vote for it being a dupe and one vote against - I'll update to reflect that. \$\endgroup\$ – Shaggy May 17 '17 at 10:55
  • 2
    \$\begingroup\$ Let S be the sequence of polygonal numbers with s sides and T be the sequence of polygonal numbers with t sides. Take the set union of the first n elements of S and the first n elements of T. \$\endgroup\$ – Peter Taylor May 17 '17 at 11:16
  • \$\begingroup\$ Many thanks, @PeterTaylor; I've edited that in. \$\endgroup\$ – Shaggy May 17 '17 at 11:21
  • \$\begingroup\$ I agree with Peter - this is too close to the second linked challenge. \$\endgroup\$ – Mego May 29 '17 at 10:23
  • \$\begingroup\$ Thanks for the feedback, @Mego. That ties the vote; guess this stays in the sandbox a little longer, so. \$\endgroup\$ – Shaggy May 29 '17 at 10:28
1
\$\begingroup\$

Dodge your death!

Introduction

"Muhuhuhahahah!" The mad scientist laughs. "You're trapped in my own little game!"

In front of you is a deadly pit of snakes, while behind you is a bottomless chasm. There's no way out, you're stuck!

"Two steps in front of you is the snake pit, and two steps behind you is the chasm. But! Before you move, you MUST write down a sequence of steps, forwards and backwards, and give them to me. But! because I'm feeling a bit evil today, I can make you take, instead of every step, every nth step, where n is less than your sequence length!

Choose wisely, now."

What's the maximum number of steps you can take before your imminent death?

Task

The intro above is a twist on the Erdős discrepancy conjecture, which was recently proven true (if you want to understand more about this, go to this video, by James Grime - I "stole" the twist question off of him).

The answer to the intro is 11 steps, but I won't go too in-depth with a proof. The answer, if the distance between you and the two "dangers" were 3 steps, is 1160 steps, although that isn't validated properly yet.

Your task is to make a program that generates the longest sequence of steps you can for a larger x, where x is the number of steps between you and the two dangers. For the purposes of this challenge, + represents a step forward, and - represents a step back.

So, an output for an input 2 is:

+--+-++--++

Which works, no matter what n the mad scientist chooses. For our challenge, x = 5.

Rules:

  • Your entire program should fit into your answer. However, if it doesn't fit, please provide an additional Github repository, or something similar.
  • You may update both your answer and program, if you can get a better score via optimisation.
  • In your answer, you must have:
    • Your program, in its entirety
    • The amount of steps generated - this will be your final score.
      • You must also provide an online version of the sequence in a Pastebin, or something similar. This is so we can check your answer.
    • The time your final score was last updated, so I don't have to check your history
  • You may NOT hardcode sequences beforehand
  • Your program must work for all x (where x is the number of steps between you and the pit & chasm), but you only need to provide the score for x = 5.

The answer with the largest score wins!

Meta:

  • What tags should I put in?
  • What things should I fix / elaborate?
  • For the "link to text file containing sequence" thing, I'm worried that the files might eventually get really big, as answers are more and more sophisticated. Is there any way to counteract that?
\$\endgroup\$
  • 1
    \$\begingroup\$ 1. "Your task is to make a program that generates the longest sequence of steps possible for a larger x" doesn't actually seem to be true: later text implies that you want something that terminates in a reasonable time rather than something which finds the actual optimum. 2. "The accepted answer will be the answer with the highest score, a week after the challenge is posted" is something which we've been discouraging for about the past five years. 3. For n=3 isn't the maximum possible actually 1160? \$\endgroup\$ – Peter Taylor May 31 '17 at 11:52
  • \$\begingroup\$ @PeterTaylor I got confused with what you meant by 2 for a while... you mean that the answer shouldn't be determined in time at all, right? \$\endgroup\$ – Qwerp-Derp May 31 '17 at 12:04
  • \$\begingroup\$ Yes, exactly. Accept the best answer after a week if you want, but don't imply that there's a deadline to submit answers. \$\endgroup\$ – Peter Taylor May 31 '17 at 13:34
  • \$\begingroup\$ Very closely related. The rules aren't quite the same, but this may nonetheless be similar enough to be a duplicate. Also, "your program must fit into your answer" is a meaningless length restriction; these sequences are highly compressible, so there's no reason not to calculate the best possible answer for n=5, hardcode it, and still have length left for a feeble attempt at other lengths. \$\endgroup\$ – user62131 May 31 '17 at 21:47
  • \$\begingroup\$ @ais523 The maximum length for n = 5 is extremely high, though, if I'm not mistaken. That would certainly make it extremely difficult to compress, and even if it was compressed, there's a very high chance of being beaten by some other answer. Also, that challenge's primary goal is code-golf, whereas mine doesn't focus on code golf at all, rather, generating the longest sequence possible. I can make n higher if you want. \$\endgroup\$ – Qwerp-Derp Jun 1 '17 at 8:00
  • \$\begingroup\$ @ais523 I got rid of the "program must fit into your answer" thing. \$\endgroup\$ – Qwerp-Derp Jun 1 '17 at 8:20
  • \$\begingroup\$ You go back and forth between x being the input and n being the input (the number of steps). It'd be better to be consistent. Also, instead of saying your program generates the longest sequence of steps possible, which can't be done because we don't know how long that sequence is, you should instead say that it generates as long a sequence as you can, or something like that. \$\endgroup\$ – isaacg Jun 1 '17 at 9:40
  • \$\begingroup\$ @isaacg Fixed both issues! \$\endgroup\$ – Qwerp-Derp Jun 1 '17 at 11:24
1
\$\begingroup\$

Data Categorization with a Si(g)n

Background:

Machine learning is a very powerful tool for categorizing data. It can help find a function that splits some already known data so that unknown values can be predicted. Typically, this function should be simple so that it does not "overfit" the data. As it turns out, previous studies have found out that the simple function f(x) = sgn(sin(ax)) can split most data into two categories with only a single coefficient to adjust! This will definitely (not) prevent overfitting, and should (not) be used for every application of machine learning.

sgn(x) is the sign function of x. As Wikipedia says,

         / -1 if x<0,
sgn(x) = |  0 if x=0,
         \  1 if x>0.

Data overfitting demonstration

Input:

Two ordered sets/arrays/lists of integers {m1, m2, m3, ...} and {n1, n2, n3, ...}.

You can take input as 2 lines of input, an array with the two arrays m and n as its elements, or any other reasonable method of input.

Output:

A value of a such that sgn(sin(ax)) equals 1 when x = m1, m2, m3, ..., and -1 when x = n1, n2, n3, ...

If no such value of a exists, you can output any non-numerical value.

Test cases:

Example inputs will be in the form [[m1, m2, m3, ...], [n1, n2, n3, ...]]
Input                  | Output
[[1, 5],    [2, 3]]    | 1.75
[[2, 3, 6], [5]        | 4.5
[[1, 3, 5], [2, 4, 6]] | 3.1415925
[[1, 6],    [2, 3]]    | Random junk
[[2, 3, 4], [1]]       | <Anything non-numerical>
\$\endgroup\$
  • 1
    \$\begingroup\$ Is there a way to determine whether it is possible to find such a value? If yes, could you please add that to the challenge, if no, then I think this challenge is impossible to solve. Other than that you should probably define what happens for sign if the argument is zero. Is it enough if it we get a solution for a finite precision implementation of sin (but there would actually be no solution)? \$\endgroup\$ – flawr May 30 '17 at 18:27
  • \$\begingroup\$ I guess with a fast enough oscillation, there should be a solution for any data set in which there are not two points of opposite categories with the same x value. \$\endgroup\$ – feersum May 31 '17 at 16:29
  • \$\begingroup\$ @flawr When I designed the challenge, I didn't know if there was a solution. But, that's what made it interesting. While actually making the test cases and verifying them, I found a good method of finding possible values, and also test it they exist. However, I thought that it was the analysis of the function that made the challenge interesting, and so I wanted people to find their own methods of finding an answer. I'll maybe add some bounds to where you need to check, but I don't want to just straight up give away a possible answer that everyone will copy. \$\endgroup\$ – K Zhang May 31 '17 at 21:07
  • \$\begingroup\$ @feersum I had previously thought that that was the case, but it turns out that some data sets do not have a solution. I put 2 of them in the test cases section. \$\endgroup\$ – K Zhang May 31 '17 at 21:20
  • \$\begingroup\$ "Two sets/arrays/lists of numbers": define numbers. All of the test cases use integers, but restricting it to integers vs permitting doubles makes a big difference. \$\endgroup\$ – Peter Taylor Jun 1 '17 at 11:20
  • \$\begingroup\$ @PeterTaylor I've restricted the inputs to be integers only \$\endgroup\$ – K Zhang Jun 1 '17 at 11:54
  • \$\begingroup\$ @feersum It is relatively easy to see that the last test case does not have a solution. \$\endgroup\$ – flawr Jun 1 '17 at 12:30
1
\$\begingroup\$

Odd with Odds, Even with Evens

Given an input integer n, express it as a sum of numbers with the following properties:

  • If n is even, the numbers used to sum should be even.
  • If n is odd, the integers used to sum should be odd.
  • Any integer used (x) should be 0 < x <= ceiling(n/2).
  • All numbers used in the summation should be unique.
    • If there are no set of distinct odd/even integers that sum to n, return -1.
  • Output may be as an array or delimited string.

Examples

Input | Output       | Comments
------+--------------+-------------------------------------------
2     | -1           | 0 < ? <= 1 = [1] (No evens, not possible)
12    | [6,4,2]      | Order is arbitrary, [2,6,4] is fine.
24    | [8,4,12]     | [2,4,6,12] works too.
9     | [1,3,5]      | Odd cases are a bit trickier to think about.
      |              | ceiling(9/2) = ceiling(4.5) -> 1 < x <= 5 -> [1,3,5]       
1     | -1           | c(1/2) = c(.5) -> 1 < x < 1 -> []
13    | [1,5,7]      | c(13/2) = c(6.5) -> 1 < x <= 7 -> [1,3,5,7]
27    | [13,11,3]    | Etc...

The numbers you use for each answer and how you get to the numbers you used do not matter, the only thing that matters is that they adhere to the spec. The order of the numbers does not matter, and you may have different results than provided.

This is , first person to mail Bill the contents of Hillary Clinton's private mailserver wins.

\$\endgroup\$
  • 1
    \$\begingroup\$ "no unique sum of odd/even integers" --> "no set of distinct odd/even integers that sum to" \$\endgroup\$ – Steve Bennett May 26 '17 at 5:21
1
\$\begingroup\$

What's wrong with asterisk?

Background

I work as a telephony engineer, and work with an open-source telephony system called Asterisk.

Often, our customers have issues with their phones, and we have to do some troubleshooting. The first method we try is an Asterisk command called sip show peers, which lists all the devices connected to the Asterisk system, as well as their status.

The challenge is quite simple, parse a simplified version of the output of sip show peers, and tell me what's wrong!

Input

Input will be multiple lines of text, formatted as such:

201 OK (34ms)
SIP OK (7ms)

This is split into 2 sections: [Device number] [status]

The device number will always be 3 digits, and begin with either a 2 or a 3

If the status is OK, the ping is also shown in parentheses.

The last line of the input will always be the SIP.

You can always assume there will be at least 1 device, and the SIP will always be present.

Devices will always have the status OK or the status UNREGISTERED.

The SIP will always have the status OK or the status UNKNOWN

Devices and the SIP will only show their latency if their status is OK

Output

If any device who's device number begins with a 2 has a latency greater than 100ms, you should output Device [device num] is lagging!

If any device who's device number begins with a 3 has a latency greater than 200ms, you should output Device [device num] is lagging!

If the SIP's latency is greater than 500ms, you should output Their SIP trunk is lagging!

If the SIP's status shows as UNKNOWN, you should output The system isn't live yet!

If a device's status is UNREGISTERED, you should output Device [device num] is down! unless every device except for SIP has the status UNREGISTERED, in which case you should instead output Their internet is probably down! once.

You should output all of the above conditions that are met, meaning if three 2## devices have a latency greater than 100ms, you should output Device [device num] is lagging for each one`

If none of the above conditions are met, output I don't know what's wrong!

Each line of output should be separated with a newline. Trailing newlines are accepted.

Testcases

201 OK (43ms)
202 OK (17ms)
301 OK (111ms)
SIP OK (7ms)

I don't know what's wrong!


201 OK (143ms)
202 OK (17ms)
301 OK (111ms)
SIP OK (7ms)

Device 201 is lagging!


201 UNREGISTERED
202 OK (17ms)
301 OK (411ms)
SIP OK (7ms)

Device 201 is down!
Device 301 is lagging!


201 UNREGISTERED
202 OK (17ms)
301 OK (411ms)
SIP UNKNOWN

Device 201 is down!
Device 301 is lagging!
The system isn't live yet!


201 UNREGISTERED
202 UNREGISTERED
301 UNREGISTERED
SIP OK (9ms)

Their internet is probably down!


201 OK (143ms)
202 OK (17ms)
301 OK (111ms)
SIP OK (607ms)

Device 201 is lagging!
Their SIP trunk is lagging!

Scoring

This is so fewest bytes in each language wins!

\$\endgroup\$
  • \$\begingroup\$ So if there's only one device and it's UNREGISTERED then we output both Device is down and Internet is probably down; if there are two devices and they're both UNREGISTERED then we just say that the Internet is down; and if there are three devices of which two are unregistered then we don't output anything? \$\endgroup\$ – Peter Taylor Jun 2 '17 at 8:54
  • \$\begingroup\$ @PeterTaylor no. If there's only one device and it's UNREGISTERED, then all devices are unregistered, so you output only Internet is probably down. If there are 3 devices and 2 are unregistered you output Device is down for the 2 that are unregistered \$\endgroup\$ – Skidsdev Jun 2 '17 at 8:56
  • \$\begingroup\$ Is this challenge meant to be about compression? If so, it should probably be tagged like that. If not, the answers for the various cases need to be simpler; at present, they're sufficiently complex that compressing them is likely to save bytes. (Note that unlike many challenges I give this feedback on, making compressing the output part of the challenge doesn't seem entirely inappropriate, so you may well decide to just roll with it.) \$\endgroup\$ – user62131 Jun 2 '17 at 15:00
1
\$\begingroup\$

Let's not collide

Contextualization

You might have heard about Re-Volt, a pretty old video game. Its collision system for cars is somewhat interesting : the body of the vehicle gets transformed into a simplified 3d convex shape which is then filled with spheres.

Example

Challenge

Your objective is to produce a code that will, provided a 2d shape and the number of wanted circles, output a similar result to the picture above. That is represent the polygon as accurately as possible with circles.

The two dimensional shape shall be a convex polygon of N vertices. The spheres will of course have the position and the diameter your code defines as optimal.

Your code should be able to take an input representing any irregular convex polygon (the format matters little as long as it can process at least a 10-vertices shape) and an input corresponding to the number of spheres that should fill the polygon.

Because it is impossible to fill completely and perfectly an N-gon with a finite amount of spheres, a tolerance is of course needed so your circles may have a portion (<10%) located outside the polygon. The circles may (and probably should) intersect at some points.

The output must be graphical.

Test cases

You should test your code with the following three polygons and with 5, 10 and 25 circles.

Polygon n°1 (10 vertices)

[[1,0],[7.5,0],[15,0],[15.5,1.5],[15,2],[7,4],[4,4],[0.75,2.75],[0,2],[0.25,0.5]]

Polygon n°2 (5 vertices)

[[0,0],[11,0],[11,2],[7,4],[0,4]]

Polygon n°3 (8 vertices)

[[1,0],[15,0],[15.5,1],[15,2.5],[10,4.5],[2,4.5],[1,4],[0.5,1]]

Questions

• Are the rules and the objectives clear enough ? Does the challenge make sense ?

• How should I define a winner (is a winner mandatory) ?

• Is it a good idea to leave the choice of the input to the coder ?

• Does this challenge already exist and this is a duplicate of some sort ?

• Are there any english mistakes ?

• Is the challenge actually a realistic thing to suggest ?

Any and all suggestions are welcome since this is my first post here.

\$\endgroup\$
  • \$\begingroup\$ It's currently unclear exactly what sort of sphere packings are expected for the inside of the polyhedron; are you just tiling the surface, or the interior too? You also need some sort of objective way to define how well the spheres tile the surface (because people will just submit solutions that don't even try, unless you require them to optimize for that somehow). Generally speaking, the victory condition for this sort of challenge should be code length for an optimal output (if an optimal output is easy), or the best possible output (if an optimal output is hard). \$\endgroup\$ – user62131 Jun 2 '17 at 14:56
  • 2
    \$\begingroup\$ In terms of English mistakes, you seem to be confusing "polygon" (which is 2-dimensional) with "polyhedron" (which is 3-dimensional), or possibly "circle" with "sphere"; I find it hard to figure out whether the question's asking for a 2D or 3D solution. With respect to input, it's generally best to leave it flexible unless doing so would be exploitable. Also, unless you made the image yourself, you need to give credit to the image creator (and verify that the copyright requirements on the image are suitable). \$\endgroup\$ – user62131 Jun 2 '17 at 14:58
  • \$\begingroup\$ @ais523 Thanks for these suggestions. In fact, I was thinking about taking the 3d concept and applying it to 2d. That would translate by "fill the polygon with N circles (disks ?) so that these circles occupy as much surface as possible without them being more than 10% out of the polygon". \$\endgroup\$ – z3r0 Jun 2 '17 at 18:13
  • \$\begingroup\$ @ais523 Concerning the victory condition, I don't know how to measure the optimality of an output so I guess it'd have to be a code golf. Finally, regarding the image, I didn't produce the image I use, however, I'm part of the community the image originates from and I'm pretty sure there would be no problems at all. If necessary, I'll add my own or will credit the user (I only know his forum nickname). \$\endgroup\$ – z3r0 Jun 2 '17 at 18:17
1
\$\begingroup\$

Fairly Cut a Ham Sandwich in Half

In this challenge we consider a discrete version of the ham sandwich theorem. In our case the theorem says:

Given two sets of points in a plane, there is a line that simulaneously bisects both sets.

So given two disjoint sets of distinct integral points in the plane, your task is finding a line of the form a*x + b*y = c that bisects these two sets and outputs the integers a,b,c.

  • Both (strict) half planes have to contain the same number of points of per set.
  • The line can contain input points, these are then not counted to either of the sides (e.g. when a set contains an odd number of points, or all points are on one line.)
  • The line is not necessarily unique.
  • The mentioned representation of a given line is unique up to an integral multiple (e.g. (m*a)*x + (m*b)*y = (m*c) represents the same line as above), but you do not have to output the fully reduced form.

Examples

As we said above, the output is not necessarily unique, so the presented outputs here are just examples. All the outputs are give in the form a,b,c.

Input: [(1,2),(1,4),(2,1),(2,3),(3,2),(3,4),(4,1),(4,3)] [(1,1),(1,3),(2,2),(2,4),(3,1),(3,3),(4,2),(4,4)]
Output: 410,640,2625 (410x + 640y = 2624)
        1,1,5 (x+y=5)
        0,2,5 (2y=5)

In the following we see three valid outputs:

Input: [(1,1),(2,2)] [(1,2),(2,1)]  
Output: 2,5,10 (2x+5y = 10)

(more to be added)

\$\endgroup\$
  • \$\begingroup\$ The best solution to this as written is probably brute force (or even randomized brute force, i.e. keep picking random lines until one of them works). You should probably either explicitly allow that, or else design a rule to disallow it. \$\endgroup\$ – user62131 Jun 6 '17 at 23:26
1
\$\begingroup\$

Print a shuffled deck of cards

\$\endgroup\$
  • \$\begingroup\$ What prevents me from outputting the cards in the same order every time? It's hard to specify randomness, as we've seen in other meta posts. You could say "I will run your program 100 times; no two outputs should be identical" since the probability of this happening is miniscule if the output is truly randomized. \$\endgroup\$ – musicman523 Jun 2 '17 at 23:05
  • \$\begingroup\$ I believe "all permutations must have an equal opportunity of being chosen" is what is usually used. \$\endgroup\$ – totallyhuman Jun 3 '17 at 0:57
  • 2
    \$\begingroup\$ I don't think having to output the Unicode card characters adds anything to the challenge and the answers (except for bytes...). \$\endgroup\$ – totallyhuman Jun 3 '17 at 0:58
  • \$\begingroup\$ All I see in my browser is a bunch of rectangles with diagonals. \$\endgroup\$ – Dennis Jun 3 '17 at 21:30
  • \$\begingroup\$ @Dennis Install the Noto fonts. \$\endgroup\$ – dkudriavtsev Jun 4 '17 at 1:09
  • \$\begingroup\$ "all permutations must have an equal opportunity of being chosen" is actually EXTREMELY difficult, the random number generators of most languages aren't up to that -- even making sure every combination can come up is quite tricky as you need 225 bits of randomness. \$\endgroup\$ – Chris Jefferson Jun 4 '17 at 21:15
  • \$\begingroup\$ Please delete this now that it is posted. \$\endgroup\$ – programmer5000 Aug 1 '17 at 16:08
  • \$\begingroup\$ @programmer5000 It's already only a title \$\endgroup\$ – dkudriavtsev Aug 1 '17 at 23:30
  • 1
    \$\begingroup\$ It should still be deleted. \$\endgroup\$ – totallyhuman Aug 10 '17 at 20:59
1
\$\begingroup\$

Collatz Bearings

Everyone knows the collatz conjecture. It is that this function:

Collatz Conjecture

when repeatedly applied on a positive non-zero integer will reach one.

There are many ways to visualise this. Inspired by this post, with the original source of this method here, this is how we will do it:

Start at 1, with a northward bearing. The next numbers will be one unit (of any, consistent) size, and x degrees clockwise (+x) if it is even, and x degrees anticlockwise (-x) if it is odd.

An example of this can be seen here (Though it starts with an eastward bearing). It uses a few hundred random starting points and goes backwards. But it's probably easier to build it backwards.

Visualisation of the Collatz conjecture

Here is a graph-like visualisation, showing the first 8 levels:

First 8 levels

There can be collisions.

Your task is to take two numbers, which would correspond to 2 nodes on that tree, and return the bearing of the second node to the first node.

Input

3 numbers. Positive integer a, Positive integer b, and angle x, in any unit you desire. b > a > 0, x is the angle of seperation, in it's simplest form (mod 360 for degrees, mod 2pi for radians, or having the upper half be negative if you wish.) a and b are guaranteed to be in different places (e.g., you won't have a = 20 and b = 21.)

Output

Using the method described above, the bearing of b from a in the graph, in the units of the input angle.

Scoring

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

Note

If the Collatz Conjecture is eventually proven wrong, you do not need to take inputs where repeated application does not reach 1.

\$\endgroup\$
  • \$\begingroup\$ I don't understand what we're supposed to do. If we start at 1 then we'll go 1 -> 4 -> 2 -> 1 so we should draw a chain LLRLLRLLR.... The supplied image doesn't look like that chain. \$\endgroup\$ – Peter Taylor Jun 5 '17 at 14:55
  • \$\begingroup\$ 1 is the starting point. Then you go clockwise up to 2. It's a really zoomed out image, I'll post a zoomed in one with numbers \$\endgroup\$ – Artyer Jun 5 '17 at 14:56
  • \$\begingroup\$ I think what's missing is something to say that the iteration is backwards. At least, that's how I can make sense of the graph: "It uses a few hundred random starting points" still confuses the issue. "The bearing of the second angle to the first angle" is also rather confusing: judging by the Output section I think it should be node rather than angle. \$\endgroup\$ – Peter Taylor Jun 5 '17 at 22:26
1
\$\begingroup\$

Efficiently find the median

Background

Computer scientists have spent a long time looking into ways of sorting data faster. One of the known discoveries is that if you can use the actual values of the data, sorting can be faster than if you can only compare them.

Finding the median of a list is a similar operation to sorting it (you can trivially implement it via sorting the list, then taking the element in the middle). However, if you're in an environment where you can only compare list elements (as opposed to looking at the elements directly), this is not typically the fastest way to find the median, as sorts are hurt more badly by the comparison restriction than finding the nth item is. What's the fastest way? Well, finding that is what this challenge is about. (However, you may want to read this Wikipedia article to get some ideas of the approaches that are typically used. I can't guarantee that the algorithm given there is the best, though, especially on a problem of the limited size given here.)

The task

Write a program that finds the index of the median element within a list of 31 elements. However, the program may not take the list as input, and may not inspect its values directly. Rather, the program may only make comparisons to determine which of two indexes corresponds to the larger element, via calling a separate comparison function. (In other words, your program deals entirely with list indexes, not list values.)

In order to avoid solutions that brute-force their way through all possible algorithms, you must be able to run at least one worst-case input (i.e. an input that takes the maximum possible number of comparisons), using a comparison function which simply compares two array elements, in under 10 minutes on some computer you have access to. (Solutions which do not use brute force to find an algorithm are unlikely to get anywhere near this time bound.)

Clarifications

  • You may assume that all the list elements are distinct, i.e. the comparison function will always specify that one of the elements is larger, no matter how they're compared.
  • You may choose the format in which the comparison function provides output, but there must only be two possible outputs (meaning "item at first index is larger" and "item at second index is larger") for any possible query; you can't return values that mean "item at second index is much larger" or anything like that.
  • The comparison function will act consistently, i.e. if it claims that the list item at index A is larger than the list item at index B, it will always claim that; and if it also claims that the list item at index B is larger than the list item at index C, it will additionally claim that the list item at index A is larger than the list item at index C.
  • You may take the comparison function as input, or assume that it's already defined with a specific name. This is not , so there's no need to try to exploit the freedom you have here to save bytes; feel free to write it in the most readable way. (The comparison function itself is not part of the submission, but you should probably include one for testing purposes and an example of what it looks like.)
  • You may exploit the knowledge that the input list is exactly 31 elements long, if you wish (your program doesn't have to work in other cases, although of course it can if you want it to).
  • If your language doesn't have functions, you may write the comparison function via a source code insertion, so long as the rest of the code doesn't attempt to inspect its internals. (However, you may as well just pick a different language in this case; the scoring method is based entirely on the algorithm you use, and picking a different language won't change your score at all.)

Victory condition

Your score for this challenge is equal to the maximum number of times the comparison function can be called during a run of the program. Obviously, lower is better.

In the case of a tie, the first submission achieving the optimal score will win. (In other words, you don't gain anything from copying someone else's solution but golfing the code, or the like; you'll have to find an algorithmic improvement.)

Sandbox questions

Is this scoring method , , or ? I guess I'd want to call it (by analogy with ) but that doesn't exist and I'm not sure it should be created. EDIT: None of the above, it's .

\$\endgroup\$
  • 2
    \$\begingroup\$ I would expect the first answer to get a perfect score (because why submit one which doesn't?), at which point the question is dead. \$\endgroup\$ – Peter Taylor Mar 22 '17 at 12:32
  • \$\begingroup\$ @PeterTaylor: I expect a perfect score to be fairly hard to accomplish on this challenge. I'm not sure the optimal algorithm is known, and the problem's too large to bruteforce. \$\endgroup\$ – user62131 Mar 22 '17 at 14:43
  • \$\begingroup\$ I don't see anything in the question which rules out brute force. \$\endgroup\$ – Peter Taylor Mar 28 '17 at 8:41
  • \$\begingroup\$ Oh, I was thinking of bruteforcing an algorithm before writing the program, which isn't possible with currently available amounts of computational power. You're right that you could just write a program that bruteforces all possible algorithms at runtime and then runs the fastest (although it would clearly be impossible to test). I should probably place a limit on runtime in order to fix that. \$\endgroup\$ – user62131 Mar 28 '17 at 15:11

You must log in to answer this question.

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