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

Using cryptographic functions in a cops and robbers challenge

Almost every cops and robbers challenge will have the following requirement:

Using cryptographic functions such as hashes or PRNGs is disallowed

...and for good reason. A trivial answer such as if (hash(input) == "[ example_hash ]") return true is near impossible to crack, yet requires almost no ingenuity on the part of the cop.

Some very specific challenges may not be susceptible to trivial solutions like these, but the default should be to consider hashing functions a loophole. I'm surprised this isn't already here, I think it would save everyone a lot of typing if this was the default policy :D

Answer 2

Using an inconsistent I/O format to encode information

For example, for a hypothetical challenge where the output could only ever be two or eleven, submitting the python program

lambda x:print"11"

and claiming that it outputs in unary for certain inputs and in decimal for other inputs should not be allowed, even though outputting in either of these bases is usually allowed.

Likewise, for a decision-problem challenge, submitting the python function

lambda i:type(i)is str

and claiming it takes input as a singleton list for inputs that match the challenge's criteria and as a string otherwise shouldn't be allowed, even though taking input as a singleton list is usually allowed.

Answer 3

Outputting Unicode characters in graphical-output challenges

If a challenge requires an image to be output, outputting a Unicode character instead is not acceptable. In graphical-output challenges, the output should always be an image.

Answer 4

Exactly duplicating another answer

This specifically came up for me in a king-of-the-hill contest. In particular, this contest had a random component, so replicating a submission could allow one to win by luck.

In general, duplicate submissions are uninteresting, and do not add anything to any sort of contest, king of the hill, code golf or otherwise.

Importantly, even if the posters came up with the answers separately, duplicate answers should still be banned.

Answer 5

Sidestepping in a theorem-proving challenge

A theorem-proving challenge is about proving a statement (= constructing a value of the given type) given in a specific host language (designed for theorem proving, most likely Lean or Coq).

One problem with this is that the host language may have various utilities that allow writing a "proof" that is not actually a sound proof of the given statement. This loophole bans any kind of answer that does this, including (but not limited to):

• Using a feature that introduces explicit holes in a proof (in Lean, sorry, axiom, admit)
• Using a feature that allows introducing a value of False (in Lean, constant)
• Proving a similar-looking, but not identical statement. e.g. in Lean,

  local notation a `=` b := true
  theorem X (n : ℕ) :
    ((list.nat.antidiagonal n).map (function.uncurry nat.choose)).sum
    = n.succ.fib := trivial
  

  is not considered a valid proof of

  theorem X (n : ℕ) :
    ((list.nat.antidiagonal n).map (function.uncurry nat.choose)).sum
    = n.succ.fib
  

Answer 6

Storing information in platform specifications

We often allow people to require certain qualities of the machine their answer is run on, (for example Operating System). However we should disallow requiring the program to be run on a certain specification to store information used for the challenge.

For example the language Nullary only has zero length programs instead deriving its source from the time since epoch. Similar languages could be created to exploit things such as monitor/terminal size, screen brightness, volume or even Operating System.

These types of answers should be disallowed.

Answer 7

Note: Per community consensus, languages/language versions are allowed regardless of when they were created, and as such this loophole is no longer enforced.

Features added to a pre-existing language, after the challenge was posted

See Covfefify a string. This might been solved in 45 bytes using:

select covfefify(:a) from dual@datadictionary

This isn't the same as these pre-existing loopholes:

• Using a made-up language specifically designed for the challenge: it is not a made-up language; it is a programming language in use.
• Using prior knowledge to circumvent other loopholes: it is not made up.
• Creating a new compiler for a language after a challenge was posted: it is not creating a new compiler, but extending an existing grammar.

None of these covers the scenario where an existing language is extended by a new function.

Answer 8

Exploiting the controller in a King-of-the-Hill challenge

I'm surprised that this wasn't here before, but this answer found a loophole to exploit in the KotH problem that should really be sealed off. (The rules of the challenge at time of writing only forbade using code that modifies the controller or the other bots, so the bot in question returned NaN instead knowing that the way it interacts with comparison operations would ensure that it would always be eliminated last.)

Answer 9

Empty answers to questions requiring an interpreter

If a question asks for an implementation of a language or a machine, the language/machine itself is a terribly boring answer. In particular:

1. "Simulating" a machine on that machine by accepting the initial state as its own initial state and producing the final state as its own final state.

2. "Interpreting" a language using an empty program that "accepts input" as the rest (i.e., all) of what's fed to the interpreter.

Answer 10

Bypassing restricted-source by storing data in the file name

Consensus says that it is perfectly fine to store data in the file name as long as that is added to the byte count. However, this doesn't seem entirely appropriate in restricted-source questions, since it could bypass the restrictions.

An example (which is what spurred me to write this) is this answer which was disqualified by the challenge author because the filename followed the restrictions and not the file content. I don't think this is the right approach. That answer was written in Pxem, a language where the program is often stored in the file name and the file itself is empty.

I think the best solution here is not actually to ban storing data in the file name for restricted-source challenges, which gives Pxem and some similar languages an inherent disadvantage, but instead to restrict submissions to one of:

• typical programs, where the filename doesn't matter, and the content adheres to the restrictions
• empty or functionally meaningless program content, but where the filename must adhere to the restrictions instead

There are still a few cases where this won't work (slashes and null bytes in Unix-like filesystems, and more on Windows), but I imagine we can just declare that as long as it works in theory it's fine.

Answer 11

---

Using a very high base (like base Graham’s number) in a challenge where you need to output a big number

---

In my answer, I just outputted 10, and claimed it was in base number that is bigger than any number printed in the challenge by another submission. And of course, this seems like cheating.

---

The answer has been deleted, so here is the exact answer, quoted. I had to change a bit of the markdown to fit it in a quote, but it looks the same.

Vyxal, \$\operatorname g\left(f_{\varphi(1,0,0)+7}(256^{26})\right)\$ where \$\operatorname g(x) = x \uparrow^x x\$ (outputs in base \$\operatorname g\left(f_{\varphi(1,0,0)+7}(256^{26})\right) \times {10}^6\$), 10 bytes

››››››››››

Try it online!

Non base-10 numbers haven't been banned... so we have a new winner!

Related comment

---

For context, here is the question.

---

Answer 12

Precomputing data (including compile-time computation) to achieve lower runtime in fastest-code challenges

Consider a challenge where solutions must print out as many Fibonacci numbers as possible within a certain time limit. A C++ solution might look like this:

#include <iostream>
using namespace std;
int main() {
    int a = 1, b = 1, c = 0;
    while(true) {
        cout << b << endl;
        c = b;
        b = a+b;
        a = c;
    }
    return 0;
}

This is a perfectly valid solution. All of the computation is done at runtime, and its score can be determined fairly.

Now, consider the following solution (adapted from this SO answer):

#include <iostream>
#include <cstdint>
using namespace std;
template<uintmax_t N>
struct fibonacci : integral_constant<uintmax_t, fibonacci<N-1>{} + fibonacci<N-2>{}> {};

template<> struct fibonacci<1> : integral_constant<uintmax_t,1> {};
template<> struct fibonacci<0> : integral_constant<uintmax_t,0> {};

int main() {
    const uintmax_t max = 10000ull;
    cout << fibonacci<1>() << endl;
    cout << fibonacci<2>() << endl;
    cout << fibonacci<3>() << endl;
    // ...
    cout << fibonacci<10000>() << endl;
    return 0;
}

This program (compiled with g++ -o template_fib template_fib.cpp -std=c++14 -ftemplate-depth=12257) shifts the burden of computing the 10000 Fibonacci numbers to the compiler. At runtime, it's simply outputting 10000 constant values.

Such solutions which attempt to cheat the scoring system by doing all of the computation during a time where the clock is not running should either not be allowed, or be required to count their compilation time into their score.

An actual example of this.

Answer 13

Outputting a Lazy list/Lazy data type in fastest-code challenges

This just moves the computation to after runtime. For example, in Python, the code:

def f():
    return 492084389428**209480438084, 6356425635**23984723879

takes a very long time to run. However, if you use the yield keyword to generate a Lazy List:

def f():
    yield 492084389428**209480438084
    yield 6356425635**23984723879

it returns the result instantly, without computing it. However, when you iterate through it:

x = f()
print(next(x))
print(next(x))

It takes a really long time, since the computation was moved here, after the runtime.

Answer 14

Cracking your own answer (including using an alt account) in a cops-and-robbers challenge.

It would just allow you to get a large number of points with no effort! Plus, it doesn’t even make any sense to do that.

Answer 15

Infinite output programs that wouldn't give all output given infinite resources

Example, loophole-violating code to output all integers:

bigint i = 0;
for(;;) bigint_print(i++);

This would never output negative numbers, even given unlimited resources, so it does not fulfil the challenge's requirements. A program that does fulfil the requirements would be:

bigint i = 0;
for(;;) {
    bigint_print(i++);
    bigint_print(-i);
}

Answer 16

Teaming up in a KOTH

Each KOTH bot must try for its own win. If a bot has logic that specifically benefits a different bot, especially a bot by the same author, that wouldn't be fair. Then you could "win" simply by submitting a large number of teaming bots.

Conversely, targeting a specific bot to hurt them is also unfair. Of course, efficient counter-play is part of any winning strategy, but long as you are targeting a range of bots and not anyone specific that is ok.

It is also OK if your winning strategy ends up benefiting some other bot without explicitly targeting it.

Examples that would violate this:

• https://codegolf.stackexchange.com/a/248557/91213

Answer 17

Making an OS specifically designed for the challenge

In this sandboxed challenge, it says you can use any environment you want. So I thought, what if you made a specific OS where the Python distribution that was made for the OS had a feature that played the tune in just a single function call? Surely that would be cheating?

Answer 18

Using non-programming languages ^{(irrelevant to "golfing" languages)}

Not to be confused with golfing languages. This loophole definitely has nothing to do with golfing languages.

A purported programming language should be accepted as such if and only if it is capable of addition of natural numbers and primality testing of natural numbers.

Follow the link for a more complete definition.

Related meta post: Do submissions have to be answered with a programming language?

That is, to use something that was not considered a programming language in our criteria. I don't think this was really forbidden before. So here is something everybody can vote.

If this is forbidden, you cannot use languages such as HQ9+ or Text in any challenges. You have to use the less familiar Help, WarDoq! or /// instead, in most cases, or simply cannot compete if your code involves some more creative features that nobody invented a rule-compliant counterpart of the language having them. In this way we could possibly encourage users to program, not to find something "creative" or obscure.

If not, you can use any language as long as the person who created a compiler or interpreter calls it a language, unless forbidden by other per site or per question rules. If there is a good reason to add this restriction (such as in some cops-and-robbers questions), you should specify that explicitly. If the term "programming language" is mentioned somewhere, by default, it refers to languages satisfying our criteria.

Answer 19

Storing information in type of input

Imagine a language with billions kinds of arrays and you choose one type as input to do the job, which is silly

Answer 20

A script invoking itself as a form of looping/recursion, where the filename has to be a specific name

e.g. I answered a question with PowerShell which included sleep 1;t where the script had to be called t.ps1 and saved in the PATH, so it would call itself.

I considered it maybe reasonable because running programs is part of what shell scripts do, and there's no reference to it in this meta topic as a standard loophole. The closest is about hiding information in the filename, e.g. a file called "hello world".

People commented to say relying on the filename is frowned upon, so I'm submitting it here so it can be voted on and be on record as approved/denied in future. Is it a loophole, or is it valid in the same way as an answer might say "requires version 3 or above" or "only works in a particular interpreter"?

Answer 21

Using MetaGolfScript in a polyglot challenge

So you write an answer in GolfScript. By definition, it will also work in all MetaGolfScript languages, of which there are infinitely many, allowing you to get an arbitrarily high score, and win the challenge. Surely this is cheating?

Note: GolfScript is allowed, just not MetaGolfScript.

References

A non-empty MetaGolfScript-N program behaves identically to the same program in GolfScript, regardless of N.

From the MetaGolfScript wiki page on esolangs.org.

Answer 22

Builtins in sequence challenges that solve the challenge completely

I know we don't like disallowing builtins, but having a builtin in a sequence challenge solve the entire thing is a bit too much. While it's be nice to add it as a side note, show off what your language can do!

Answer 23

Using comments to circumvent character requirements/restrictions

It's cute and makes you laugh once, but when you see it several times over several challenges, it just becomes facetious and contrary to the spirit of the game.

Example: https://codegolf.stackexchange.com/a/12370/5358

Answer 24

Sending error messages to the null device

... instead of avoiding them.

This should either be forbidden or add to the byte count, as setting options to suppress messages do.

example

Answer 25

Compressing your source code

Some language provide builtin facilities to compress data and execute the result as source code. I consider this to be a standard loophole, especially when the challenge is counted in characters instead of bytes.

Answer 26

Using built-in functions to do the work

Mathematica is a big one for this, with Fibonacci[n] to calculate the n'th Fibonacci number.... I have no objection to these being posted as a side note within the main answer though - that is interesting and helps me learn different languages capabilities.

Another one that encounters this more often than most is with Assembly, especially with questions requiring bitwise-related operations, such as ARM's rbit reversing the bits in place or Haswell's pext to extract bits according to a mask.