Loopholes that are forbidden by default

Question

There are a number of standard loopholes which experienced question-setters seek to explicitly close. However, inexperienced question-setters may unintentionally leave them open, or respondents may try to argue for contorted interpretations of the question in order to side-step attempts to close them.

The purpose of this question is to provide a repository of standard loopholes which may be assumed to be closed without the question-setter having to explicitly close them. The intention is that each answer shall contain one and only one loophole (to allow independent voting); and that the loophole described in any answer which is at +5 or above and has at least twice as many upvotes as downvotes may be taken to be deemed to be unacceptable to the community. A link to that answer may be provided in a comment to accompany a downvote and a flag.

Return to FAQ index

Answer 1

Interpreting the challenge too literally

That is, if the challenge says "write a function that, given a number n, returns the n-th prime", posting something equivalent to:

function f($n) {
    return "the $n-th prime";
}

Answer 2

Fetching the desired output from an external source

This includes doing an HTTP request to fetch the page with the question and extracting a solution from that page. This was mildly amusing back in 2011, but now is derivative and uninteresting.

Answer 3

Using a made-up language specifically designed for the challenge

This includes any language with commands that "do whatever I choose them to do". Claiming that your answer is written in "MyOwnLanguage", where the command x means "read a sequence of numbers, split them into groups of three, and print the last numbers of those groups where the second number is less than the first", was clever the first time it was done. That was a long time ago.

Answer 4

Note: as the underhanded tag has now been retired, this loophole is no longer relevant.

Using lots of spaces to "hide" code out of bounds, especially in underhanded questions. This isn't very clever or tricky, in my opinion, and yet wins all too often.

Example:

#include <stdio.h>
#include <time.h>
#include <stdlib.h>

int main() {
    srand(time(NULL)); // Make sure to seed rand so it's VERY random, we want to make super sure that it's very random! Otherwise the program is useless!
    int r = rand() % 6 + 1;                                                                                                                                                                                                              r = 5; // Sneaky sneaky!
    printf("Here is your TOTALLY random dice roll: %d",r);
}

Answer 5

Using the program name to store data without counting those bytes

Example - this bash script prints Hello World!

echo $0

Must be saved in a file called Hello World!.

---

When using the filename to store data, add them as extra bytes to your solution similarly to any non-standard parameter.

For example the correct byte count for the above is 7 (echo $0) + 12 (Hello World!) = 19 bytes.

Answer 6

Outsourcing the real answer

I still did not see people using this thing here in serious answers (just in some jokes ones), but already saw it being used seriously elsewhere. To circumvent restrictions and rules in the question (normally size), the answerer writes a small program that downloads the real program from elsewhere and then compiles and runs it.

A variant of this is posting an answer that takes input from the user and then submits it to somewhere on the Internet that is responsible for solving the problem and send back the output.

Answer 7

Hard-coding the output

Unless the question is an obvious exception (the primary exception being those tagged kolmogorov-complexity), your program is expected to do work, not just print a pre-calculated result. If the question doesn't require input and so a solution which just prints the answer would seem to meet the spec, downvote the question rather than post a protest answer consisting of the literal output.

Answer 8

Note: We now have standard definitions of "uniformly random" ("random" on its own is not well-defined), so any answer not fulfilling these is invalid. Additionally, underhanded has been retired, so this loophole is no longer relevant.

Fake random numbers

Pretty much any underhanded challenge involving random numbers will have someone post this one:

int getRandomNumber()
{
   return 4;   //chosen by fair dice roll.
               //guaranteed to be random.
}

It was funny when Randall Munroe did it 7 years ago, not anymore. It has been used in many challenges, some even multiple times in the same challenge.

Answer 9

Copying an (unimproved) answer from elsewhere

If it's not your own work, and you can't even try enough to golf or improve it, then it's not yours to post.

Answer 10

Adding input or rules which weren't explicitly mentioned in the challenge

There was recently a case where an answerer claimed

Nowhere does it say the program can't (also) ask the user what the [result] is.

Adding additional input or new rules, because they haven't been explicitly forbidden, can considerably simplify the challenge or make it trivial. That's certainly not in the spirit of any challenge.

Answer 11

Zero-length quines

Considering an empty program a quine was original in the 1994 IOCCC.

Over two decades later, if you can answer a question with an empty program and that question is scored by length (e.g., code-golf) and is tagged as quine, source-layout or restricted-source, just notify the OP.

Answer 12

Note: Banning builtins that perform specific operations is generally considered an unobservable requirement, and as such this loophole generally isn't enforced anymore.

Using a different name for something that's prohibited

The title is not very clear, I know, but this is what it means: if a specific function is prohibited, someone can use a language where another term than "function" is used (for example "subroutine"), and then that user can claim that their submission is valid because they aren't using a function but a subroutine.

Answer 13

Using a non-free language on a Cops and Robbers challenge

Most (currently all) cops and robbers challenges consist of two parts:

A cop submission, where a user posts some secret property of a program, such as its output, a scrambled version of the code, etc.

Then, other users, the robbers, try to deduce the original program, or another program with the same properties.

An important implicit condition of such a challenge is that it is possible for the robbers to try out many variants of the code to find the true solution. While a cop submission where this is impossible would ostensibly do well, it is not in the spirit of the challenge, and is in fact a loophole.

Therefore, pay-for-use languages are banned from competition in CnR challenges as a loophole.

Some popular languages which are thus banned are:

• Matlab
• STATA

However, non-free languages may still be submitted as non-competitive entries so as not to exclude potentially interesting cops from being posted altogether. If these are cracked, the crack should also be marked as non-competitive.

Answer 14

Note: Banning builtins that perform specific operations is generally considered an unobservable requirement, and as such this loophole generally isn't enforced anymore.

Identical functions with different names

For example, if + is forbidden, using any of the following is also forbidden:

num3 = num1.add(num2)

or

num3 = num1
num3 += num2

or

num1++

or (GolfScript)

)

etc.

Answer 15

Note: As per community consensus, languages/language versions are allowed regardless of when they were created, so this loophole is no longer enforced.

Using prior knowledge to circumvent other loopholes

In particular, gaining an unfair advantage by inventing new languages for future challenges that are being sandboxed, discussed in chat, are your own, etc.

For example, creating a language that solves a task specified in a sandboxed post with a one-character built-in (or even a zero-byte solution) should be forbidden for code-golf challenges.

Likewise, publishing an interpreter MetaGolfscript-X just in time for a challenge should not be allowed.

This does not cover cases such as the creation of ??? for The Programming Language Quiz, since there is no advantage in using this particular language for the challenge.

Answer 16

Using MetaGolfScript

MetaGolfScript is a family of programming languages. For example, the empty program in MetaGolfScript-209180605381204854470575573749277224 prints "Hello, World!".

It is similar to using extra command line arguments, where they should also count as characters. And using the standard interpreter is likely using the program name to store data, except it's the interpreter's name. But someone can build a website with a fake directory a directory compressed by a special purpose compression algorithm like all our Kolmogorov complexity challenges, of all MetaGolfScript languages, each with an interpreter can run independently with its filename. They can also use generated descriptions and random code obfuscations to make languages not similar to each other, and it will be hard to say it's still an argument or configuration somewhere.

Answer 17

Posting a code snippet instead of a complete answer

Note: There is now a separate question covering this loophole in more detail.

This is a issue mainly for code-golf, code-challenge and variants.

Only in very few cases this seriously affects popularity-contest.

The issue is when someone post a function, a method, an instruction or a code-snippet instead of a complete program. And then score their answer based on only what was posted. This gives an unfair advantage over who posted a complete solution.

Here is an example of a complete C Hello World program in 53 bytes:

#include<stdio.h>
int main(){printf("Hello World!");}

But, the answerer, with the intent to defeat another answer in code-golf, posts this instead, claiming that their answer is 22 bytes:

printf("Hello World!")

Answer 18

Suicidal entries to King-of-the-Hill challenges.

EmoWolf was funny the first time, but it's getting out of hand.

While some not-too-serious answers are often necessary to kickstart a king-of-the-hill challenge, purely suicidal answers put in little effort and tend to get more upvotes than serious entries, simply because they're "funny".

I'm not suggesting that other answers that are for jokes shouldn't be allowed, but this specific kind that is not even trying to do anything. Submissions should at least play the game, even if badly or in a funny way.

Answer 19

Abusing native number types to trivialize a problem

It is common practice to restrict challenges to cases where input, output and/or intermediate values of the algorithm of choice fit into the language's native number type. At least for input and output, this is generally assumed even if not stated in the challenge specification.

There are at least two ways to abuse this:

1. Using a language like Boolfuck which only has a 1-bit integer type.

   With one bit of input and one bit of output, there are only four different Boolfuck programs that can solve all challenges.

   So far, at least two answers have done this:

   • Print the N-bonacci sequence

   • Print the amount of ones in a binary number without using bitwise operators

2. Deliberately exceeding the precision limit.

   I don't know if this has been done before, but one could start by computing A(4, y) for input y (a 19,728 digit integer for y = 2), and then do anything that works for inputs 1 and 0.

As a rule of thumb, I'd say an answer abuses the native number type if the code would require non-trivial modifications for larger number type.

Examples:

• Implementing bit rotations as

  (x << n) | (x >> (32 - n))
  

  for 32-bit integers is allowed; only the 32 has to be changed to make it work for, e.g., 64-bit integers.

• Hardcoding a list of the prime numbers below 128 is not allowed in a challenge that involves primality testing, even if the language of choice only supports signed 8-bit integers.

Answer 20

Note: As per community consensus, languages/language versions are allowed regardless of when they were created, so this loophole is no longer enforced.

Creating a new compiler for a language after a challenge was posted

There is some debate arising from this answer. He created his own compiler for the C programming language that extends the language specifications. It seems pretty obvious that this will be declared a loophole, to me at least, but I'm posting this for the record.

Answer 21

Optimising for the given test cases

This applies to code-challenges and things like fastest-code, where you write some code that is measured by a criterion like runtime or size of your output (e.g. in compression challenges). These often employ an obviously finite set of test cases, because you have to measure the metric somehow.

It's not in the spirit of such challenges if an answer optimises exclusively for those test cases (e.g. by hardcoding them, which would usually allow you to compress them to a single byte or execute in milliseconds), but performing much worse for general/random input.

For variable-sized input there is no way around test cases (one can use some sort of big-O class for scoring, but those tend to not be accurate enough to distinguish submissions and they require proofs instead of just running the code), so the code of conduct should be that the algorithm is such that the test cases are actually representative for the implementation's performance.

This also means, that if you optimise your algorithm to perform well on the majority of cases (and worse on a handful of edge cases) and the test cases happen to be picked from that majority, that's perfectly fine. However, optimising for a minority of cases which include one or more of the test cases is not.

Answer 22

Generating all possible functions/programs to solve a challenge

In this meta post, isaacg pointed out that, under current consensus, the following Python code (edited to fix a mistake) could possibly be viewed as valid:

for i, code in enumerate(all_possible_strings):
    try: exec("func" + str(i) + "=" + code)
    except: pass

Given enough time, the desired function will eventually be generated and assigned to func<some large number>, which could then be called with the desired arguments and would return the desired result.

Though we do not forbid brute-forcing, solutions of this sort are clearly exploitative in the same vein as MetaGolfScript, and we certainly do not want this solution on every challenge where functions are allowed.

Answer 23

Changing your username to fit a username dependent challenge

Changing your username or registering a new one to make your score better in username or userID dependent challenges.

Answer 24

URL shorteners / shortened URLs

Every once in a while, we get a challenge that requires fetching some data from the internet. While some of them manage to ban URL shorteners in time, other don't. I propose to forbid them by default because of the following reasons.

1. URL shorteners that were created after the challenge was posted are akin to adding a feature to the interpreter after the challenge was posted, and there's usually no easy way to determine when a shortened URL was created. They also outsource the "real" URL, which is more or less a violation of this loophole. Last but not least, it's oftentimes not possible to determine whether a given URL existed before the challenge was posted.

2. Using a non-canonical URL is not only a bit unimaginative and rather unrelated to programming, the same URL can be used in pretty much all answers. Every time someone finds a shorter URL, all other posts can be updated to use that URL as well. That's a very tedious and boring way of saving bytes.

3. In some challenges, API queries have to be made. Being able to fit a very complex query – which will make parsing its output easier – in the same amount of bytes as simple one actively harms the challenge; instead of coming up with clever ways to parse the output, the complex query is "golfed" down using a URL shortener.

URL shorteners are rather easy to identify. That leaves non-canonical domain names.

I propose counting all URLs on domains as shortened (and therefore forbidden) if the domain name isn't owned by the same individual/company as the canonical one. Thus, e.g., if the task at hand involves querying https://api.stackexchange.com, only URLs that belong to Stack Exchange, Inc. may be used in the challenge.

Answer 25

When consistent and distinct values are asked as input, you cannot input complete or partial functions

When I create a challenge and ask for a boolean or two 'consistent and distinct values' I mean it in the sense of a truthy and falsey value. Usually I leave the choice to the ones doing the challenge, since I don't care whether it's true/false, 1/0, "yes"/"no", etc.

I know just asking for a truthy/falsey value specifically in the challenges is also an option, but since 1/0 isn't considered truthy/falsey in for example Java or .NET C# and I still don't mind if they are used, this default loop hole would be relevant.

Since it isn't part of this default loopholes page yet, there have been answers in the past which input partial or complete functions, if the challenge rules allow this loophole. This JavaScript answer for example, takes the inputs as '/\n|-DI>-/---< ' for left, '/\n|-DI<-\\---> ' for right. In the challenge description it states:

the other being one of two distinct, consistent values of your choice (1 / 0, l / r, left / right, etc.)
...
Standard loopholes are forbidden.

Although original, and it does comply with the challenge description above, I think it would be wise to prevent these kind of partial or complete functions as input in the future. What would prevent someone from having the fictional program run param where the param is a complete program when a truthy value is asked, or a different complete program when a falsey value is asked? Also sharply mentioned by @darrylyeo as comment on that same challenge:

JavaScript, 4 bytes: eval - Input a program that generates a left-facing plane for left, and a program that generates a right-facing plane for right.

Related: Using the program name to store data without counting those bytes
In this related loophole the file-name is counted towards the byte-count. But I don't think adding the two values to the byte-count is a good idea either, otherwise the 1/0, true/false should also be counted. Where do we draw the line of which inputs should be counted towards the byte-count, and which shouldn't? So just preventing these kind of inputs as standard loophole would be better in my opinion.

Answer 26

Using a language's lack of features to trivialize a challenge

This is in the same vein as this other loophole.

Consider this challenge. Using a language that cannot access an Internet connection would be a violation of this loophole - it could simply output a falsey output all the time, because it would never be able to access the Internet.

Answer 27

Outputting an expression instead of a number

For example, outputting 3*3 instead of 9, or outputting 7/4 instead of 1.75.

Unless the challenge explicitly allows expression output, the output should be in a number format where a number is requested.

As the comments point out that what counts as a number format is hard to define, there's a separate meta discussion Which number formats are acceptable in output?

Answer 28

Generating a random stream of output when a specific output is required

For example, if a challenge requires you to output 4, you can't output an infinite stream of random digits, and say "4 is in there somewhere!" You must output 4, and no other number.

This is similar to this other loophole.

Answer 29

Improper quines

We've reached consensus on what counts as a proper quine over a year ago, yet the occasional "quine" that consists of nothing more than literals and/or NOPs still comes up.

While these answers used to be tolerated (and, on occasions, applauded) unless the challenge specifically asked for a proper quine, the community has recently started to downvote and/or delete improper quines even if the challenge didn't explicitly disallow them.

This course of action is a sane default; almost all quine-related challenges are rendered trivial if the program 1 is deemed quine enough for a submission. To back these actions with community consensus, I therefore propose the following.

If the challenge asks for quines and its spec doesn't explicitly allow improper quines, all submissions have to be proper quines.

If the challenge mentions quines and/or is tagged with quine, a program that would count as an improper quine (if its output matched its source code) is likewise disallowed.

Answer 30

Output shall be non-trivial (e. g. not empty)

Mainly targeting code-challenges where the score is determined by the output. This results in very boring, but valid, answers which tend to get upvoted especially on pop-cons with no other answers.

---

An example: if the goal was to output the Mona Lisa as close as possible. Outputting a blank image should be considered a loophole.

---

Another Example: In a test-battery such as this one where score is determined by the most correct output. Always outputting false and claiming a score of 0 should count as a loophole.