text:
Lost in translation
This is a cops-and-robbers if you are not familiar with the format click the tag to go to the wiki.  There will not be a robbers' thread for this question.
Cops
Your task as Cops is to select two sequences from the Online Encyclopedia of Integer Sequences and write a program that takes the nth element of one sequence as input and outputs the nth element of the second sequence.  You then make an answer including the code and omitting the sequences selected.  Robbers will attempt to find the sequences you selected and if one manages to find the sequences you had in mind or some other sequences for which your program you must mark your answer as Cracked.  If a robber informs you with a crack that you believe is not valid you may present a proof that it is not a crack.  Otherwise you must mark it so.
As per the usual answers that have been uncracked for 7 days are eligible to be marked safe.  A Cop may mark their answer as safe by revealing the sequences that they had in mind. Once safe an answer may no longer be cracked.
The goal is to minimize the byte count of your program while remaining uncracked.
Example
The following Python code translates the nth element of A000290 (the square numbers) into A000217 (the triangular numbers):
lambda x:sum(range(0,int(x**.5+1)))

Stipulations and Requirements

If you choose a sequence that has not been proven to be finite you must output all terms that might exist not just the ones listed on the OEIS page
As an exception to the previous rule languages without infinite precision integers do not have to output or input numbers outside of their range.
The size of your input sequence must not have been proven to be smaller than the output sequence.
Your input sequence must not have any repeat elements (otherwise the task is pretty much impossible)
The OEIS includes an index on their page (the first number after the "OFFSET" header) by default this is your offset for n (n equals the index for the first element on the sequence) if you choose another index you must indicate so in your answer.
If you choose a offset different from the one listed on the OEIS you must still map all elements in your input sequence to the corresponding element in your output sequence.
If your program receives an input that is not in the input sequence it may do whatever it wishes (undefined behavior).  However it is probably in your best interest for it to still output an integer.
It is unsportsmanlike to intentionally make your code difficult to run, be it by making it time consuming to execute or through non-free language selection.  While I will enforce the latter I cannot objectively enforce the former.  However I implore you, for the sake of fun, not to attempt the former as it makes the challenge specifically more difficult for those with weaker computers.

Robbers
Your task as Robbers is to select uncracked, unsafe answers and find the sequences they map between.  If you find solution a solution that works (not necessarily the Cops' intended solution) comment the sequences on the appropriate answer.
Robbers should not worry to much about verifying that two particular sequences are a solution, one should post a solution if it matches all of the entries on OEIS. If that is not the sequence that a cop had in mind the cop may offer a proof that it is incorrect or mark it as cracked if they cannot find one.

How can a robber be sure that his answer is right for all inputs? Do they have to prove it mathematically?

"As per the usual answers that have been uncracked for 7 days can be marked safe." The "as per usual" should include that the answer is only safe once the intended solution has been revealed to ensure the answer's validity.

@Leo A robber should post a solution if it matches all of the entries on OEIS.  If that is not the sequence that  a cop had in mind they may offer a proof that it is incorrect or mark it as cracked if they cannot find one.  I will update the robber's thread.

Can a cop make a function that he cannot prove to be correct? For example, mapping Mersenne number to the corresponding even perfect number is correct iff there are no odd perfect numbers, which is unknown. The robber still can crack this, because he mustn't prove anything. But it looks like the first requirement bans such things, because the perfect number sequences has not proven to be finite and you can't also be sure that you output all the existing terms.

It's hard to draw the line between common assumptions and unproven ideas. In the interest of clarity, I'd say you have to be able to prove that your answer works.

@Wolfram I am going to have to side with Dennis at this point.  You must be able to prove that your mapping will work.

"If you choose a sequence that has not been proven to be finite you must output all terms that might exist not just the ones listed on the OEIS page", what about languages with no arbitrary big integers?

@betseg for finite languages you must only work up to the limit of you language.

I have a feeling that some really nice solutions can be cracked in a dumb way like https://oeis.org/A000004 -> https://oeis.org/A000012

How come there is no robber's thread for this?

@Wolfram Your input sequence must not have any repeat elements

@1000000000 Because the robbers' thread's answers would consist of nothing but two OEIS identifiers.

@Dennis I guess that's a good point. It's a bummer though that there is no way for people to receive rep for finding cracks as it appears that that is pretty tricky for this challenge.

Jelly, 14 bytes (Cracked by @Wolfram)
+66%444µ111<µ¡

Try it online!
It should be fairly obvious what this does. In fact, for the benefit of the non-Jelly users, I'll even give an explanation:
Explanation
+66%444µ111<µ¡
       µ    µ¡  Run the transformation
+66%444           "add 66, then modulo 444"
        111<    once if 111 is less than the input, zero times otherwise

The question is, why does it do this?
Crack
The sequences in question were A201647 and A201647. They're finite, and differ only in the last 2 elements:

3, 5, 7, 9, 11, 15, 21, 165, 693
3, 5, 7, 9, 11, 15, 21, 231, 315

Thus, if the input is low, I leave it the same, and I simply fit a function to the transformation of the last two.

@WheatWizard: If you think you can get an advantage from that, go for it. But you'll have to be fast, as if someone else tests it with the cache enabled, they'll end up polluting the cache for everyone after them.

@WheatWizard disable output cache makes sure you get a fresh result from the server, but that fresh result will still get cached.

@WheatWizard Or add a cache breaker when you test it: a randomly selected string as part of a comment or an unused input field.

+1 this answer is really simple in nature, but still poses a challenge to the robbers

http://oeis.org/A201647 -> http://oeis.org/A201648

Jelly, 7 bytes (Cracked by @JonathanAllan)
ÆFḅÆdÆẸ

Try it online!
What it does
ÆFḅÆdÆẸ  Main link. Argument: n

ÆF       Factor n into prime-exponent pairs.
   Æd    Compute σ, the number of divisors of n.
  ḅ      Convert each pair from base σ to integer.
     ÆẸ  Yield the integer whose prime signature (infinite sequence of all prime
         exponents, including zeroes, in order) is equal to the result.

There may well be other valid mappings, but the one that I think you had in mind was primes - A000040 to 2^(2p+1), p prime - A100626.

@JonathanAllan I came to A000040 -> A100626 as well, though you beat my slow fingers

We can also see that it will hold: when the input is a prime, p, ÆF yields (p,1), and Æd yields 2, so ḅ gets us 2p+1, which means ÆẸ will yield the first prime, 2, raised to the power of that result, 2^(2p+1).

@JonathanAllan Yes, that's what I was going for.

Processing, 184 bytes, SAFE!
int x(int y){int b=TRIANGLES-MITER;for(int i=OVERLAY/BURN;i>#fffffe;b*=(int)pow(y,(MOVE-HAND+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=QUAD/DARKEST);return b;}

A function that takes in an int and returns an int. As long as the input number is in int's range, the program should work fine.
This isn't slow, just unreadable. Good luck!

I am surprised this submission has lasted this long. Oh well, at least it's the first safe submission :)
A000578 to A000290
In other words: the cubes to the squares.
Explanation
While answering No strings (or numbers) attached, I discovered a list of Processing constants that represent ints. For example, CORNER has a value of 0. The full list can be found here. To find the value of a constant, you can just print it.
Using this, I decided to swap certain numbers with combinations of these constants to obfuscate it. So, here's what you get when you substitute the constants with their respective int values.
int x(int y){int b=9-8;for(int i=512/8192;i>#fffffe;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(color(0)*color(-1)))),i-=16/16);return b;}

Even now, the full clear code isn't revealed. The colours are remaining. In Processing, colour variables have int values, for example white (#ffffff) is -1, #fffffe is -2, #fffffd is -3, and so on. This can be found by printing the colour. So let's simplify the colours.
int x(int y){int b=9-8;for(int i=512/8192;i>-2;b*=(int)pow(y,(13-12+0.)/(int)sqrt(red(color(-1<<16))/(int)log(-16777216*-1))),i-=16/16);return b;}

We're about halfway there :) To understand the values, we need to simplify the numerical expressions.
int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)log(16777216))),i-=1);return b;}

Much clearer! Now let's simplify the logarithm.
int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/(int)16.6...)),i-=1);return b;}

int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/(int)sqrt(red(color(-65536))/16)),i-=1);return b;}

Almost over! Now we have to figure out this (int)sqrt(red(color(-65536))/16)) mouthful. color(-65536) is red, so rgb(255, 0, 0). Now the red() function returns the value of the red component in the argument (which is a colour). So how much red is there in red? The answer is 255. With that we get
(int)sqrt(255/16))
(int)sqrt(15)
(int)3.8...
3

Substituting this in the program results in:
int x(int y){int b=1;for(int i=0;i>-2;b*=(int)pow(y,(1.)/3),i-=1);return b;}

Yay, it's done!
int x(int y){                        // y is the cube
  int b=1;                           // variable that holds the final result
  for(int i=0;                       // for-loop that
          i>-2;                      // loops twice
          b*=(int)pow(y,(1.)/3),     // multiply b by the cube root of y
          i-=1);                     // decrement the looping variable
  return b;                          // finally return b
}

To sum it up, this returns the square (done by multiplying twice in the for-loop) of the cube root of the input number.

Python 3, 256 bytes (Cracked!)
from math import*
def p(i,m):
 r=0;d=floor(log(i))
 for y in range(d):r+=(pow(16,d-y-1)%(8*y+m))/(8*y+m)
 o=-1;y=d
 while r!=o:o=r;r+=pow(16,d-y-1)/(8*y+m);y+=1
 return r
def q(n):r=4*p(n,1)-2*p(n,4)-p(n,5)-p(n,6);return floor((1-(-r%1)if r<0 else r%1)*16)

Try it online!
Sorry if this code looks horrendous, I think this is my first Python golf. The casting in Python makes it easier to code.

I assume the function in question is q?

Also the variable k seems to be unused so you can save some bytes by removing it.

Is it A001671 to A062964?

@WheatWizard yes, thanks, and yes.

Mathematica (or whatever) — Cracked!
f[x_] := Quotient[ 366403414911466530559405368378193383110620062 -
    755296348522256690003418238667147075159564695 x +
    525778437135781349270885523650096958873079916 x^2 -
    156594194215500250033652167655133583167162556 x^3 +
    20861131421245483787723229627506507062999392 x^4 -
    1181515772235154077024719095229309394979146 x^5 +
    29382627265060088525632055454760915985604 x^6 -
    308672970015057482559939241399297150364 x^7 +
    1087516675449597417990589334580403666 x^8 -
    312989984559486345089577524231879 x^9,
  265451130886621254401938908479744271974400 ]

I know Mathematica is non-free software, but this function is trivial to port to whatever favorite language you want to run it in. It literally computes the value of the given degree-9 polynomial evaluated at the input integer, then takes the integer quotient of that value and the 42-digit number on the last line. For example, f[100] evaluates to -3024847237.

A003173 to A165892. Not really a programming problem, though ;)

Anyway, since mathematica isn't free, I wrote this to turn it into a python function

@Leo: Great job! There's an Easter egg in the function too; did you find it? :D

Uhhh... Nope :(

To map one nine-element set to another nine-element set, I'd only need a polynomial of degree 8. You could draw the (correct) conclusion that there's one more input value I mapped to a specific output value. Let me know if (when) you find it :)

I've tried to find something, but it's hard when the best method that comes to my mind is trying a lot of numbers and looking at the result to see if it's nice :) Any hint?

Sure, let's see: the secret input has four digits, and for it (just like for the other nine inputs), the integer-quotient is unnecessary—the polynomial value is exactly divisible by the 42-digit denominator.

f(3173)=165892 is it that?

Let us continue this discussion in chat.

@Leo Mathematica IS free. http://www.wolfram.com/programming-lab/?source=nav


text:
Counting in binary nybbles
This challenge is to output to your terminal, window, canvas or screen the numbers zero to 10 inclusive. Each outputted number must be shown as a 4-bit wide nybble, so zero must show as 0000 and so on.
You may separate each number outputted with a space, comma or carriage return. Smallest solution wins but the numbers can be displayed in any order you like as long as there are no repeating numbers in your sequence.
Entries in low-level binary languages need not worry about the comma or white space separators if it is not possible to output with commas or white spaces (i.e., the standard output is limited to binary only, or your solution is for an early computer kit such as the KIM-1 which has a limited digital display).

Yes, spaces, commas, a comma and then a space or a "\r\n" equivalent in your chosen language.

No sorry as that looks like 4 individual zero digits and not a 4-bit wide binary number.

Not that I'm really sure to write such an answer, but would it be OK to output some extra nibbles in addition to the 11 required ones?

They're nibbles, not nybbles.

Not according to the Commodore 64 Programmers reference guide

An example of how to do this in Commodore BASIC V2 is here: http://pastebin.com/2VTTMZgU using DEF FN

SmileBASIC, 26 bytes
FOR I=0TO&HA?BIN$(I,4)NEXT

MATL, 6 bytes
0:10YB

Try it at MATL Online
Explanation
0:10    % Create the array [0...10]
YB      % Convert this array to a binary string where each number is
        % placed on a new row
        % Implicitly display the result

05AB1E, 9 8 bytes
T         # push 10
 4ã       # cartesian product repeat with 4
   R      # reverse list
    T>£   # take the first 11 elements of the list
      »   # join by newline and display

Try it online!

Wait... the Cartesian product of the digits of a number? That's just...

JavaScript, 46 bytes
for(i=15;i++<26;)alert(i.toString(2).slice(1))

Why use a padding function when you can simply add 16 to each number and slice off the first binary digit?

Japt, 7 bytes
GôA,_¤Å

And here I was thinking Japt was doomed to be longer than every other golfing language...
Test it online!
Explanation
GôA,_¤Å  // Implicit: A = 10, G = 16
GôA      // Create the inclusive range [G...G+A].
    _    // Map each item Z to Z
     ¤   //   .toString(2)
      Å  //   .slice(1).
         // Implicit: output result of last expression

Normally commas can be removed in Japt, but this one is there because of a bug: _ normally means function(Z){Z, but for some reason the compiler thinks A_ means function(A,Z){Z.

Nice one. I got stuck at Aô_¤

Bash + GNU utils, 26

4 bytes saved thanks to @Dennis

seq -w 0 1010|sed /[2-9]/d

Try it online.

seq -w 0 1010 should work.

@Dennis Thanks - I don't remember using the -w option to seq before.

Bash + Unix utilities, 29 26 bytes
dc -e2o8927II^*8/p|fold -4

Try it online!
This is the same length as @DigitalTrauma/@Dennis's solution, but uses a completely different method.
Output is:
1010
0010
0110
0001
1001
0101
0100
0111
0011
1000
0000

(Any order is allowed.)

Pure Bash, 34 bytes
echo 0{0,1}{0,1}{0,1} 10{00,01,10}

Try the pure Bash version online!
Output is:
0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010

J, 6 bytes
#:i.11

Thanks to miles for cutting it down to 6 bytes!

#:i.11 should work just as well

I'm not sure this is valid, as per the answer to a now deleted comment.

@Adám I can't view it. Could you please explain why it's not vaild?

Because it generates a n×4 Boolean array, which prints as digits with spaces in-between. But the comment seems to imply that spaces are not allowed inside the binary numbers.

Python 3.6, 36 35 bytes
i=11
while i:i-=1;print(f"{i:04b}")

-1 byte thanks to @JonathanAllan
Python 3.5 and earlier:
i=11
while i:i-=1;print("{:04b}".format(i))

Try it online!

i=11 (new line) while i:i-=1;print(f"{i:04b}"), for 35.

Jelly, 7 bytes
2Bṗ4ṫ6Y

Try it online!
(5 bytes if trailing lines of nybbles are allowed, 2Bṗ4Y)
How?
Prints in descending order.
2Bṗ4ṫ6Y - Main link, no arguments
2B      - 2 converted to binary -> [1,0]
  ṗ4    - Cartesian 4th power -> [[1,1,1,1], [1,1,1,0], ..., [0,0,0,0]]
                            i.e.  16       , 15         ..., 0
    ṫ6  - tail from 6th item  -> [[1,0,1,0], [1,0,0,1], ..., [0,0,0,0]]
                            i.e.  10       , 9        , ..., 0
      Y - join with line feeds
        - implicit print

An alternative 7-byter is 2ṗ4Ịṫ6Y, the [1,0] is replaced with [1,2] and Ị is the "is insignificant" monad (abs(z)<=1), converting 2s to 0s.

CJam, 12 bytes
B{G+2b1>}%N*

Try it online!
Explanation
The Cartesian power approach would have been my choice, but was already taken.
So this generates numbers from 0 to 10, and for each it adds 16 and converts to binary. Adding 16 ensures that the required leading zeros are produced, together with an extra leading one which is removed.
B             e# Push 11
 {      }%    e# Map over "11", implicitly converted to the array [0 1 ... 10]
  G+          e# Add 16. This makes sure there will be 5 binary digits: a leading 1
              e# which will have to be removed and the remaining, valid digits
    2b        e# Convert to array of binary digits
      1>      e# Remove first digit
          N*  e# Join by newlines. Implicitly converts arrays to strings

PHP, 33 bytes
while($i<11)printf('%04b ',$i++);

Intel 8080 machine code, MITS Altair 8800, 10 bytes
00 00 00 00 00 00 00 00 76

Listing:
0000   00   NOP
0001   00   NOP
0002   00   NOP
0003   00   NOP
0004   00   NOP
0005   00   NOP
0006   00   NOP
0007   00   NOP
0008   00   NOP
0009   00   NOP
000A   76   HLT

Uses the CPU's program counter (PC, aka instruction pointer) to count from 0 to 10 then halt.  The output display is conveniently in nibble format already.
Output:
Output is displayed on Blinkenlights A3-A0.

Try it online!

MATLAB / Octave, 13 bytes
dec2bin(0:10)

Online Demo

Jelly, 8 bytes
2Ḷṗ4ḣ11Y

Try it online!
How it works
2Ḷṗ4ḣ11Y  Main link.

2Ḷ        Unlength 2; yield [0, 1].
  ṗ4      Take the fourth Cartesian power.
    ḣ11   Head 11; discard all but the first eleven elements.
       Y  Join, separating by linefeeds.

Jelly, 10, 9, 8 bytes
⁴r26BḊ€Y

Try it online!
I'm not that great at jelly, so I'd be open to any tips!
This uses Emigna's first algorithm

Thanks to Dennis for shaving off two bytes making me tie his own answer. :P
Explanation:
      Ḋ€    # Return all but the first element of each item in the list:
⁴r26        #   [16, 17, 18, ... 26]
     B      #   Converted to binary
        Y   # And joined with newlines

Ḋ€ saves a byte.

@Dennis Ah, that makes sense. Thanks!

⁴r27 saves another one.

Python 2, 38 36 bytes
n=16;exec"print bin(n)[3:];n+=1;"*11

Thanks to @DJMcMayhem for golfing off 2 bytes!
Try it online!

for n in range(11):print bin(n+16)[3:] also at 38 bytes.

n=16;exec"print bin(n)[3:];n+=1;"*11 is two shorter

@DJMcMayhem It is indeed. Thanks! :)

RProgN, 15 Bytes
~16.aL1{2B26q}:

This has been a very good modivation to add a pad function. The entirety of ]L4\-'0'\m\., more than half the code, is to pad.
_Saved 6 bytes thanks to @ETHProductions, that's the pad function cut in half.
Explained
~16.aL1{2B26q}:
~               # Zero Space Segment
 16.            # The literal number 16
    aL          # The length of the Alphabet
      1         # The literal number 1
       {     }: # For each number between 16 and 26 inclusive
        2B      # Convert to base 2
          26q   # Get the characters between 2 and 6 inclusive.

Try it online!

length of the Alphabet Nice way to save a byte ;-)

BF, 121 101 bytes
,....>,.<...+.>.<-..+.-.>.<..+..>.<-.+.-..>.<.+.-.+.>.<-.+..-.>.<.+...>.<.-...>.<+.-..+.>.<.-.+.-.!0

Requires a trailing newline. Makes use of ! symbol (so, check the box that says !) with this interpreter (try it online!).
Potentially 51 bytes if each operator was considered as 4 bits

You should specify (or additionally add a byte) for the ! checkbox being enabled.

Whoops, I'm new to that and thought it encoded it in the URL. Will specify... wait, actually, I think it's already specified in the second sentence (?), will clarify that a bit

Retina, 36 33 bytes

%%%%
+`(^|\b)%
0$%'¶$%`1
11!`\d+

Try it online!
Explanation

%%%%
Replace the empty (non-existent) input with %%%%.
+`(^|\b)%
0$%'¶$%`1

On the first run of this stage, it will match ^% and essentially replace the text %%%% with the two lines 0%%% and 1%%%. The stage will loop until the output stops changing. On the second run, it will match \b% (since digits count as word characters and % doesn't), and replace the groups by duplicating them and adding 0 to one copy and 1 to the other: 0%%% becomes the lines 00%% and 01%% (and the same sort of thing for 1%%%). Through this loop all 16 bitstrings will be produced, linefeed separated.
11!`\d+

The first 11 matches of \d+ (a run of at least 1 digit) are retrieved. The matches are output in a linefeed-separated list.

I'm curious in understanding how this 0$%'¶$%1line works. What do$%, `1, '¶` represent?

@KritixiLithos Sorry I didn't explain the specifics, it's a bit convoluted :P. $%\`` represents everything before the match on the same line, and $%'is everything after the match on the same line.¶is a literal linefeed. So basically the replacement matches the first%on a line and replaces it with0plus the rest of the line it was on, a newline, the beginning of the line it was on, and a1`. Of course, the beginning and end of the line it was on are untouched by the replacement because they weren't part of the match.

So it's not putting a copy of the line after itself, but rather inserting the end of the line, a newline, and the beginning of the line in between the beginning and end of the line that remain intact.

Ah thanks, that was helpful  :) (I'm trying to learn Retina now)

In which case, I think you can use `G11`` as the last line of the regex instead

C 170 120 bytes
n,i,m,k[4]={0};f(){for(m=0;m<=10;m++){n=m;i=0;for(;n;i++){k[i]=n;n/=2;}for(i=4;i>0;i--)printf("%d",k[i-1]%2);puts("");}}

Ungolfed version:
void f()
{
    int n,i,m,k[4]={0};

   for(m=0;m<=10;m++)
   {
      n=m;
      i=0;

      for(;n;i++)
      {
         k[i]=n;
         n/=2;
      }
      for(i=4;i>0;i--)
         printf("%d",k[i-1]%2);

      puts("");
   }
}

Can definitely be shortened!?
@Ahemone Awesome idea, Thanks!
Should work now!
Try it online!

the first for loop in your golfed version should go to 4 rather than 3, but that doesn't matter because the loop can be eliminated entirely and the second for loop can start from 0. You can also just use while(n), but compacting the while loop down into a for loop saves more again. n/=2 will also save you a byte over the shift. You're also missing a terminating } on the golfed version causing an error on compilation.

@Ahemone Fixed the } and improved the code, 50 bytes shorter based on your idea.

102 bytes

Ruby, 25 bytes
11.times{|n|puts"%04b"%n}

C, 75 68 69 bytes
Approach 1: 75 73 74 bytes
m;p(i){putchar(i?m&i?49:48:9);}r(){for(m=11;m--;p(4),p(2),p(1),p(0))p(8);}

Try it online!

Approach 2: 68 69 bytes
m,n,o;f(){for(m=11;m--;)for(n=m,o=5;o--;n*=2)putchar(o?n&8?49:48:9);}

Try it online!

Suggest m,n;f(o) instead of m,n,o;f()

C#, 96 bytes

Golfed
()=>{for(int i=0;i++<11;)System.Console.WriteLine(System.Convert.ToString(i,2).PadLeft(4,'0'));}

Ungolfed
() => {
    for( int i = 0; i++ < 1; )
        System.Console.WriteLine( System.Convert.ToString( i, 2 ).PadLeft( 4, '0' ) );
}

Full code
using System;

namespace Namespace {
    class Program {
        static void Main( string[] args ) {
            m();

            Console.ReadLine();
        }

        static void m() {
            for( Int32 i = 0; i++ < 11; )
                Console.WriteLine(
                    Convert.ToString( i, 2 ). // Converts the number to binary code
                    PadLeft( 4, '0' ) );      // Fills the number with the missing '0's
        }
    }
}

Releases

v1.0 - 96 bytes - Initial solution.

I like the release version you added - are you going to include RC versions as well? \o/

Going to be honest, don't know what RC means... This is how I try to post my solutions in PPCG

RC means 'Release Candidate' - i.e., you'd send out a few versions with minor differences and await to see which is the most stable by your RC number. So if you had version A and version B, you could have v1.0-RCa and v1.0-RCb or something.

Oh, that. No. If I make another release, I increment the Version Number right away.

R - 23
We can use intToBin function from the R.utils package:
R.utils::intToBin(0:10)

[1] "0000" "0001" "0010" "0011" "0100" "0101" "0110" "0111" "1000" "1001" "1010"

C, 68 bytes
f(){puts("0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010");}

Somehow, this is the shortest C answer so far…
EDIT: I was missing 1000 somehow. Well, it’s still winning.

Isn't this missing 8? (1000)

Commodore VIC-20/VC-20/C64 - 95 69 68 67 tokenized BASIC bytes used (obfuscated and minimized)
0dEfnb(x)=sgn(xandb):fOi=0to10:b=8:fOj=0to3:?rI(stR(fnb(i)),1);:b=b/2:nE:?:nE

Copy and paste the above text into WinVice, for instance. Just about fits onto 80 characters on a Commodore 64.
Here's the non-obfuscated symbolic listing for illustrative purposes:
0 DEF FN B(X)=SGN(X AND B)
1 FOR I=0 TO 10
2  LET B=8
3  FOR J=0 TO 3
4   PRINT RIGHT$(STR$(FN B(I)),1);
5   LET B=B/2
6  NEXT J
7  PRINT
8 NEXT I

Of course this may be minimised and further obfuscated. Explanation:
The DEF FN command in line zero is a simple function which accepts one numeric parameter. This will give the algebraic sign the number passed to it as a parameter, in this case is ANDed with the value B (declared elsewhere, but becomes global once declared).
Line 1 starts the loop counter I
Line 2 sets the value of the 3rd BIT.
Line 3 starts loop counter J (we want bits 0 - 3 essentially).
Line 4 gets the STR$ value (string value) of the function FN B(I), this is then passed to the RIGHT$ command as CBM BASIC auto-pads outputted numbers with a white space, so we get the last character in the string created by STR$.
Line 5 moves the BIT counter down one (like x >> 1 in C I suppose).
Line 6 moves the J loop up one.
Line 7 prints a new line (line echo PHP_EOL; in PHP).
Line 8 moves the I loop up one.
I've 'nested' the listing in the example to better show the loop and loop order.

Thanks, I've done this in the obfuscated version above (although not the NEXT J one) - I'll give it a go for that as well, saving another BASIC byte!

Python 2, 44 bytes
for x in range(11):print bin(x)[2:].zfill(4)

This uses the zfill function which works like rjust except it always padds with 0 so you don't waste bytes on an argument.

Wait what, this whole time I've been wasting bytes making my own padding function? (lambda k,l:' '*(len(k)-l)+k) Wow... +1 just because of this :D

Pyke, 8 bytes
TFw0+b2t

Try it here!
TFw0+b2t - for i in range(10):
  w0+    -    i+16
     b2  -   bin(^)
       t -  ^[:-1]

Also 8 bytes:
TF 4@b2t

Try it here!
   4@    - set_bit(4, i)

Ruby, 38 bytes
11.times{|i|puts i.to_s(2).rjust 4,?0}

-1 byte by getting rid of the parentheses: 11.times{|i|puts i.to_s(2).rjust 4,?0}

Pyth - 8 7 bytes
<5^_`T4

Try it online here.

stacked, 30 bytes
11:>[2 baserep'0'4 pad out]map

Try it online!
11:> is a range from 0 to 10. The rest is rather self-explanatory.
Other solutions that I've found:
11:>[bits 4 dpad''join out]map
11:>[bits 4 dpad$tostrmap]map out
11~>15+[bits behead''join out]map
16 26|>[bits behead''join out]map

BF, 134 bytes
I'm sure this can be shortened--it's pretty much my first BF golf.
++++++++++[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]>>+>[-->>+>]<<<[<<<]>>[>[>>-[<<+.->]<[>]>-[<<.>]<[>]>++>]<-[<<<-]++<<[<<<]>.>-]

Try it online! Assumes a tape infinite in both directions, like the interpreter at TIO uses. An interpreter where < at the left end of the tape is a no-op would save three bytes.
Explanation
More than half of the code (the first 77 bytes, to be precise) is spent initializing the tape. The steps go like this:
++++++++++
10|

[>+>+>+++++>>>+++++>>>+++++>>>+++++[<<<]>>>-]
 0|10|10|50| 0| 0|50| 0| 0|50| 0| 0|50|

>>+>[-->>+>]<<<[<<<]>>
 0|10|11|48| 0| 1|48| 0| 1|48| 0| 1|48| 0| 1|

The cells initialized to 1 store the bits of our number plus 1: 1 represents a zero bit and 2 represents a one bit.
The initialization phase ended with the pointer on the 11. Now we use this cell to run 11 iterations of our loop:
[>          Move to the first 48
 [>>-       While we're still on a 48, move 2 cells over and decrement
  [         The cell's value now equals the bit it represents; if it's not 0:
   <<+.-    Move to the 48, increment, output, and decrement again
   >        Move to the next cell, which holds a 0
  ]         Leave the loop
  <[>]>     Pointer shenanigans to get back on the cell representing the bit
  -         Decrement again: cell is 255 for a zero bit, 0 for a one bit
  [         If cell is not 0:
   <<.>     Move to the 48, output, and move to the 0 cell
  ]
  <[>]>++   Get back on the bit's cell; increment back to original value
  >         Move to the next 48
 ]          Loop exits once we've output all four bits
            Now we increment the binary number: a one bit turns into a zero bit and
            carries; a zero bit turns into a one bit and doesn't carry
 <-         Move back to the rightmost bit cell and decrement
 [          If it is not 0, it must represent a one
  <<<-      Leave it decremented, go to the next bit cell and decrement it too
 ]          Loop exits on a bit cell that represented a zero
 ++         Increment it twice (to represent a one)
 <<[<<<]    Move back to first cell on tape
 >.         Move to 10 cell and output (newline)
 >-         Move to loop counter cell and decrement
]

C, 110? bytes
n,i,m,k[4]={0};f(){for(m=-1;(n=++m)<11;i=0){for(;n;n>>=1)k[i++]=n;for(i=4;i--;)printf("%d",k[i]&1);puts("");}}

Ungolfed:
int f() {
    int n,i,m,k[4]={0};
    for(m=-1;(n=++m)<11;i=0) {
        for(;n;n>>=1)
            k[i++]=n;
        for(i=4;i--;)
            printf("%d",k[i]&1);
        puts("");
    }
}

Common Lisp, 41 39 34 32
2+5=7 bytes removed thanks to PrzemysławP.
I am using the FORMAT function function, for printing a number as binary with padding and separators, called with the magic number 8800979740570 (a.k.a. 8012345679A in base 16):
CL-USER> (format t"~,,,4:b"8800979740570)
1000,0000,0001,0010,0011,0100,0101,0110,0111,1001,1010

I used to do the same with 123456789A, but as noted by PrzemysławP, the order does not matter and we can save some bytes. This is because with the original order, the leading zeros would be done as padding and would not be separated into groups of 4 digits; here, by starting with 1000, we don't need any padding. In addition to that, I also removed the mincol argument (53) because I don't need to specify the size of the number anymore.
Formatted output of integers
The documentation for format (see above) is detailed for ~D (decimal base) but the same applies to other ones (hex ~X, binary ~B, octal ~O, custom ~R). Note that for floats there are other arguments.
The most general format is ~mincol,padchar,commachar,commaintervalD, but note that the two last arguments, commachar and commainterval are only meaningful if D has a colon-modifier :D, which by default separate digits by groups of 3 (commainterval is a custom value, instead of 3), inserting the commachar character between such groups, by default a comma.
The mincol argument is one that is found in other format directives and specifies the horizontal space allocated for the thing being printed. When the actual size required is smaller, a padding might be applied (left or right, or both for some directives). The padding fills the remaining space with padchar, a character. When the actual size is bigger, the layout might not be pretty but the object is printed fully.
More precisely (from the above link):

~D Decimal. An arg, which should be an integer, is printed in decimal
  radix. ~D will never put a decimal point after the number. ~mincolD
  uses a column width of mincol; spaces are inserted on the left if the
  number requires fewer than mincol columns for its digits and sign. If
  the number doesn't fit in mincol columns, additional columns are used
  as needed.
~mincol,padcharD uses padchar as the pad character instead of space.
The @ modifier causes the number's sign to be printed always; the
  default is to print it only if the number is negative.
The : modifier
  causes commas to be printed between groups of three digits
the third
  prefix parameter may be used to change the character used as the
  comma. Thus the most general form of ~D is ~mincol,padchar,commacharD.
X3J13 voted in March 1988 (FORMAT-COMMA-INTERVAL) to
  add a fourth parameter, the commainterval. This must be an integer; if
  it is not provided, it defaults to 3. This parameter controls the
  number of digits in each group separated by the commachar.
By extension, each of the ~B, ~O, and ~X directives accepts a
  commainterval as a fourth parameter, and the ~R directive accepts a
  commainterval as its fifth parameter.

Padding and separators
Note that the padding characters are not grouped, as explained above. For example, the zeros in front of the numbers are not separated:
 CL-USER> (format t "~10,'0:d" 12345)
 000012,345

... there is no easy way to combine format parameters to output:
 000,012,345

... that's why I first added the zeros and a comma explicitly in the answer. This is not necessary anymore.

Nice solution! You can save 2 bytes with: (format t"0000,~49,'0,,4:b"78187493530) - instead of space use comma as separator

Could you explain how does this directive work? ~mincol,padchar, and what later? I know 4 is length of group and :b for binary system. Are there more arguments later? Does it work similiar to ~R?

@PrzemysławP I added some explanations. It is the same for ~R, but with five parameters (the first one is the radix, i.e. the base).

(format t"~53,,,4:b"8800979740570) saves additional 5 bytes - uses fact that any order is allowed.

@PrzemysławP That's clever, I didn't pay attention to the order. Btw, I also  removed "53" because in fact the size is not necessary. Thanks a lot.

SAS, 39 bytes
Not very creative...
data t;do i=0 to 10;put i binary4.;end;

Ruby, 44 bytes
(0..10).each{|e|puts (16+e).to_s(2)[-4..-1]}

Common Lisp, 41 bytes
(dotimes(i 11)(format t"~5,,,'0<~B ~>"i))

Different method than other CL submission.

Perl 6, 25 22 bytes
printf "%04b "x 11,^11

Fairly similar to the ruby answer.
EDIT: Saved 3 bytes by removing parantheses.

Java 8, 195 bytes
interface C{static void main(String[]a){for(int i=0;i++<11;)System.out.println(((java.util.function.Function<String,String>)x->("0000"+x).substring(x.length())).apply(Integer.toString(i-1,2)));}}

I am never golfing in Java again...
-2 bytes thanks to ceilingcat

REXX, 32 bytes
do i=0 to 10
  say x2b(d2x(i))
  end

Japt, 6 bytes
Aò¤ù'0

Test it
Aò¤ù'0
A          :10
 ò         :Range [0,A]
  ¤        :Convert each to binary
   ù       :left pad each to length of longest
    '0     :  With "0"

Haskell, 92 bytes
0#_="";b#n=(if even$n`div`b then"0"else"1")++(div b 2#n)
main=putStr.unwords.map(8#)$[0..10]

Try it online!

Java 8, 77 bytes
()->{for(int i=43;i>=0;i--)System.out.print(((i/4>>i%4)&1)+(i%4==0?" ":""));}

For each number, print one bit at a time by bit shifting then masking with &1.

Perl 5, 22 bytes
printf'%04b 'x11,0..10

Try it online!

Rust, 37 bytes
||for i in 0..11{print!("{:04b} ",i)}

Try it online!

Forth (gforth), 57 bytes
: f 11. do 4. do j 3 i - rshift 2 mod 1 .r loop cr loop ;

Try it online!
Explanation

Loop from 0 to 10 (inclusive)

For each iteration:
Loop from 0 to 3, print the character at that index (with no space)
Print a newline

Code Explanation
: f                 \ start a new word definition
  11.               \ place 11 and 0 on stack
  do                \ loop from 0 to 10
    4.              \ place 4 and 0 on the stack
    do              \ loop from 0 to 3
      j             \ place outer loop index (current number) on stack
      3 i -         \ get the position of the digit we care about
      rshift 2 mod  \ get the value at that position
      1 .r          \ print the binary digit with no space appended
    loop            \ end the inner loop
    cr              \ print a newline
  loop              \ end the outer loop
;                   \ end the word definition

MathGolf, 9 bytes
Ar☻+mÅà╞n

Try it online.
Explanation:
Ar        # Push a list in the range [0,11): [0,1,2,3,4,5,6,7,8,9,10]
  ☻+      # Add 16 to each: [16,17,18,19,20,21,22,23,24,25,26]
    m     # Map each value to,
     Å    # using the following two commands:
      à   #  Convert the value to a binary string
       ╞  #  And remove the first digit
    n     # After the map: join the list by newlines
          # (after which the entire stack joined together is output implicitly)

The first four bytes could alternatively be A╒E+:
A╒        # Push a list in the range [1,11]: [1,2,3,4,5,6,7,8,9,10,11]
  E+      # Add 15 to each: [16,17,18,19,20,21,22,23,24,25,26]

x86-16, IBM PC DOS, 28 bytes
Binary (build NIB.COM with xxd -r):
00000000: b30a 53b1 04d2 e3b8 000e d0d3 1430 cd10  ..S..........0..
00000010: e2f5 b820 0ecd 105b 4b79 e7c3            ... ...[Ky..

Unassembled listing:
B3 0A       MOV  BL, 10         ; set initial counter
        NIB_LOOP:
53          PUSH BX             ; save counter in BX
B1 04       MOV  CL, 4          ; shift / loop 4 times
D2 E3       SHL  BL, CL         ; shift left one nibble/nybble
        BIT_LOOP:
B8 0E00     MOV  AX, 0E00H      ; BIOS write to console / zero AL
D0 D3       RCL  BL, 1          ; rotate left one bit, MSB into carry
14 30       ADC  AL, '0'        ; add carry bit to '0' ASCII char
CD 10       INT  10H            ; write to console
E2 F5       LOOP BIT_LOOP       ; keep looping to next bit
B8 0E20     MOV  AX, 0E20H      ; BIOS write to console / space
CD 10       INT  10H            ; write to console
5B          POP  BX             ; restore counter
4B          DEC  BX             ; is >= 0?
79 E7       JNS  NIB_LOOP       ; if so, keep looping
C3          RET                 ; exit to DOS

Output

Standalone PC DOS executable .COM program.  Output is to console, descending separated by spaces.

Wren, 107 106 bytes
for(i in[0,1])for(j in[0,1])for(k in[0,1])[0,1].each{|l|
System.printAll([i,j,k,l])
if(i==1&&k==1)Fn.x()
}

Try it online!
Explanation
for(i in[0,1])for(j in[0,1])for(k in[0,1])[0,1].each{|l| // Define all those binary digits
System.printAll([i,j,k,l])                                // Print all the binary digits
if(i==1&&k==1)                                            // If the number has reached 10,
              Fn.x()                                      // Execute an undefined command in the Fn class
                                                          // That breaks out of all of the 4 for loops and stops the program
}

Vyxal Rj, 38 bitsv2, 4.75 bytes
₀ƛΠṅ∷

Try it Online!
Bitstring:
10101010010101010011110101110100101100

VYXAL FOREVER RAHHHHH
₀ƛΠṅ∷
₀      # push 10
 ƛ     # map over the range [0,10] (R flag)
  Π    # binary string
   ṅ   # padded to length 8
    ∷  # second half

Created with the help of Luminespire.

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Shortest Code to Legitimately Slack Off
I'm a developer, and I don't feel like doing my work. I know from XKCD that the best excuse for slacking off is that your code's compiling. Because of this, I think I need some code that will compile forever! And because I'm lazy and don't want to have to type much, this has to be done with the shortest code possible.
So, your task is to write a program that is syntactically valid, but will cause the compiler to enter an infinite loop.
Specifications

You must use a language that has a compiler, obviously.
Specify the implementation used in each solution.
This is code-golf, so the shortest valid solution (in bytes) wins.
The compiler can terminate from running out of memory or stack space.

@obarakon I disagree.  Code from the other challenge cannot be ported to this challenge with any ease.  The challenges while the both involve infinite looping are fundamentally different.

@obarakon Not a dupe of this question either, as it's not code-golf.

Related

Does JIT compilation count as compilation?

@Downgoat I'd say so.

Related

Are answers valid which terminate eventually because the compiler runs out of memory/recursion depth?

@MartinEnder Yes, edited.

I'm not sure it fits this challenge (and even if it does it would score terribly), but for those interested here's how I would do it in Java : define an annotation processor(ideone snippet) which you'll use when invoking javac with its -processor option. It makes the compilation of any class hang forever.

@Aaron there's shorter in vanilla Java 5+ without any custom annotation processor ;)

For the answers that result in crashing the compiler: For the purpose of slacking, I would think you still want it to take as long as you can to crash.

If you want something minimal to tie up your printer as long as possible, try sending instructions to generate the mandlebrot set to your printer: https://www.mitchr.me/SS/exampleCode/postscript/mandelbrot.ps.html

Must the implementation exist before this question?

@PyRulez Yes, as is standard with code-golf. If it did not, you must mark your answer as non-competing.

Japt, 2 bytes
`ÿ

You can test this online here, but I wouldn't recommend it as it will freeze your browser.
Explanation
Japt uses the shoco library for compressing strings. A backtick tells the compiler to decompress everything until the next backtick or the end of the file. Each byte does the following:

00-7F are left intact.
80-BF each transform into a common lowercase two-letter pair (at, oo, th, etc.).
C0-DF each consume the next byte and transform into a common four-letter string.
E0-EF each consume the next three bytes and transform into a "common" eight-letter string (starting at Whererer and going downhill from there).
F0-F7 break the decompressor, though it still returns everything up to the breaking byte.
F8-FF cause the decompressor to enter into an infinite loop. I'm not sure why this is, as I'm not very familiar with the inner workings of the shoco library (and the JavaScript code is completely unreadable), but it's quite handy in this case.

I don't believe there is any other way to mess with the Japt compiler, but you never know...

What do you mean it's unreadable. Clearly you just aren't trying hard enough.

I wish there was an emscripten decompiler...

TikZ (pdfTeX 3.14159265-2.6-1.40.17), 85 79 74 24 22 21 bytes
A bunch of bytes saved thanks to wchargin
One byte saved thanks to Chris H
\input tikz
\tikz\pic

I actually encountered this one by accident when I was working on homework.  I spent quite a while waiting for it to compile before I realized what was happening.
This has two parts:
\input tikz

This loads the TikZ package
and:
\tikz\pic

This starts a \tikz environment and a draw command.
What is going on
The pdflatex compiler has trouble with \tikz\pic, and enters interactive mode causing it to stall indefinitely.

(1/2) I can't reproduce this. I get "Runaway argument? \draw l\end {document} ! File ended while scanning use of \tikz@next." pdflatex 3.1415926-2.5-1.40.14 (TeX Live 2013/Debian). tikz 2010/10/13 v2.10. This is standard apt install texlive-full on Ubuntu 14.04.

(2/2) That said, this can be reduced to an equivalent TeX program by stripping off the LaTeX cruft: \input tikz newline \tikz\draw l\bye (29 bytes). Confirm by replacing with \tikz\draw (0, 0) -- (1, 1);\bye and inspecting the output.

@wchargin I am using the same version of pdfTeX 3.14159265-2.6-1.40.17 (TeX Live 2016)  and it does indeed loop indefinitely.  Thanks for the tips.

I love these recent TikZ submissions.

You can save a byte by using \pic instead of \draw` -- exactly the same behaviour (tested using tikz 1.142)

@ChrisH Thanks I was trying to think of a three letter TikZ command.

@WheatWizard while I'd been waiting for an excuse to use \pic until a couple of days ago

I can't believe I'm actually advocating not using TikZ, but surely the use of it is overkill here.  What's wrong with the old \def\a{\a}\a (12 bytes)?  Or, as this is code golf and ~ is active by default, \def~{~}~ (9 bytes)?

@LoopSpace Nothing is wrong with them I just didn't know the existed.  If you would like to make your own answer then feel free.

@WheatWizard Done.  I wasn't sure if TikZ and TeX were close enough that they should be the same or separate answers.  Plus I've never posted to this SE before so wasn't sure of the etiquette.

There's no error here; TeX is just waiting for more input (it puts you at the interactive * prompt). What makes you think the compiler is going on compiling forever? It's actually done processing whatever you gave it, and is idly waiting for more.

@ShreevatsaR Thanks!  I've updated the answer to reflect this.

Java, 102 95 89 88 78 bytes
class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>a=new B<>();}

This terminates with a StackOverflowError which happens because the generic resolution system can't decide a root against which to resolve the other generics.
Credits where due.
What happens here?

A<T> is just there to have a 1-letter parent. It's generic. I could have used List, but the imports and repetition of 4 letters are too long.
B<T> declares a basic generic.
B extends A is required to have a hierarchy between B and A.
extends A<A> creates a self reference on A<T>.
A<? super B> triggers the lookup for generics on A<T>
B<B<T>> creates a self-reference on B<T>.
A<...> a=new B<>() forces the usage of the generics, instead of simply the definition of those, forcing the resolution when compiling B, and not afterwards.
A<?super B creates a non-self-reference, so we have both a reference to one type and to another in the generics of A.
B<A> creates a non-self-reference, so we have both a reference to one type and to another in the generics of B.

Now, the type A has generics type A and B, but which is to be chosen? Forget about self, let's try to resolve B. Ping.
Okay, B has generics type A and B, but which is to be chosen? Forget about self, let's try to resolve A. Pong.
This kind of recursion can't really be avoided because there are legitimate cases like A<B<A<B<A<B<Object>>>>>>: for example a JSON object: List<Map<String,Map<String,List<Map<String,List<String>>>>>>.
Compilation result
$ javac NoCompile.java

The system is out of resources.
Consult the following stack trace for details.
java.lang.StackOverflowError
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2587)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)
        at com.sun.tools.javac.code.Types$UnaryVisitor.visit(Types.java:3260)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2592)
        at com.sun.tools.javac.code.Types$23.visitClassType(Types.java:2579)
        at com.sun.tools.javac.code.Type$ClassType.accept(Type.java:554)

On my system, the stack trace stops after showing 1024 lines, which are actually the 4 same lines repeated 256 times, thus proving an infinite recursion. I'll spare you that whole trace.
Savings

102 → 95 bytes: replaced interface+implements with class+extends.
95 → 89 bytes: replaced Long with A (twice).
89 → 88 bytes: used diamond operator (new B<A>() → new B<>()) .
88 → 78 bytes: moved the variable declaration to a class member, thanks to VoteToClose.

What am I looking at

You can shorten this to 78 bytes with: class A<T>{}class B<T>extends A<A<?super B<B<T>>>>{A<?super B<A>>b=new B<>();}

@VoteToClose You're looking at a prime example of undecidability in Java's generics. Each generic is supposed to be resolved against a common root to which is then a validated against. The thing here is that the generic of  B contains a undecidable reference to the generic of A which in turn contains an undecidable reference to the generic of B. When the resolver can't decide, it checks included references, but here both generics refer to each other in an undecidable way (mostly thanks to self references and the super keyword. So the resolver actually ping-pongs between the two generics.

I was thinking about creating a compile-time problem with cyclical annotations: public @interface X {@X(x=X.class)Class<? extends X> x();}... But I quickly realized why that wouldn't work lol.

C, 18 bytes
#include __FILE__

Compilers will usually give up after recursing about 200 times.
Does DOM construction count as a compilation step? If so, then x.htm:
<iframe src=x.htm>

I remember that recursive framesets used to crash IE4 so hard that it sometimes took down important OS components with it. So the HTML there probably counts.

@ais523, that's because, in the IE4 days, Internet Explorer was an "important OS component".

A bit of tweaking and it is valid PHP: <?include __FILE__;.

Can't post this answer because my rep isn't high enough, but two alternatives are: #include "/dev/zero" and #include "/dev/stdin"  -- be careful running the first one!!

When a page includes iframe which the same src as itself then about:blank is loaded. This would work, but it not counts as "compilation step": <iframe src=# onload=onload=this.src='?'+Date.now()>

@rrauenza So I don't have to do something potentially dangerous to satisfy my curiosity, what does #include "/dev/zero" do?

When I tried it gcc's memory usage began quickly growing without bound, the system became unresponsive, and my watchdog eventually kicked in and rebooted.  It was fairly amusing :)

None of these seem to work on clang! It just exits immediately with an error, and if you include a basic main function then #include "/dev/zero" succeeds with no errors and no warnings even. GCC, though...

GNU Makefile, 8 7 bytes
One byte saved thanks to KonradRudolph
Saved as Makefile and invoked by make:
x:;make

This will produce an infinite build recursion on the first target found "x".
Needless to say that you don't really want to run this fork bomb on your production server. :-)
make
make[1]: Entering directory `/path/to/my/dir'
make
make[2]: Entering directory `/path/to/my/dir'
make
make[3]: Entering directory `/path/to/my/dir'
make
make[4]: Entering directory `/path/to/my/dir'
make
make[5]: Entering directory `/path/to/my/dir'
make
make[6]: Entering directory `/path/to/my/dir'
make
make[7]: Entering directory `/path/to/my/dir'
make
...

Alternate version, 5 bytes
Suggested by KonradRudolph:
x:;$_

$_ is a reference to the last argument of the previous command. More specifically, it is resolved here as the absolute path to the command being executed -- which is make itself.
This should work fine in a genuine Bash environment, but not on Windows+MinGW.

Hmm, I don't think make does really compile the Makefile (it just interprets it).

@zeppelin You're right, this is probably a borderline answer. That said, submissions that involved macro recursion at the preprocessor level will never start to compile any actual code either.

It fits the intended goal: having an infinite build process. +1!

Perl, 15 13 bytes
BEGIN{{redo}}

Try it online!
Now with 2 bytes saved: @Zaid reminded me of a terser way to do a loop in Perl.
This is pretty simple: it just installs a parser hook with an infinite loop in, making the code take infinitely long to parse. (Perl's nice in that it allows you to run arbitrary code in the middle of the parse; the parser hooks are specified in Perl itself, and frequently used to do things like import libraries or change the parsing rules for an identifier you want to treat like a keyword.) The Try it online! link above gives the -c option (to compile the code to verify the syntax for correctness, but not run it), to prove that the infinite loop happens at compile time.
In case you're wondering about "compile time" in a scripting language: Perl actually compiles to bytecode and then runs the bytecode, but this is a detail that's rarely relevant when programming it. The -MO= command line option family can be used to do things with the bytecode other than running it (although not with this program, as the infinite loop happens before the bytecode can be generated).

a:goto a looks nice too (same bytecount sadly).

BEGIN{{redo}} will save you a few bytes

C++, 60 58
template<class T>class a{a<T*>operator->();};a<int>i=i->b;

This recursivly creates instances of class a with different template parameters. GCC 7.0 stops after 900 recursion levels with tons of errors about operator-> being private but for example ICC 17 and Microsoft (R) C/C++ Optimizing Compiler 19 time out on godbolt.
Problem with that is that probably all compilers will run out of memory at some point in time so even without recursion limits this will stop. The same probably applies to the Clojure answer, too.
Edit: 2 bytes saved by bolov - Thanks

shorter: a<int>i=i->b;

Interestingly g++-6.3.1 fails painfully on this, but fails a lot more gracefully if you replace class with struct.

@Pockets like I stated in my answer that's because the operator-> is defaulted private within a class. Within a struct it's public and therefore i->b may access it.

gcc 4.4.7 seems to hang indefinitely here. Waiting for infinity or for it to show output, whichever comes first. Will update

@osuka_ is it still running?

@Christoph nope, it crashed with a SIGSEGV after I left it running for a couple days. Forgot to update, though - thanks for the reminder!

C++, 37 30 29 bytes
int f(auto p){f(&p);},a=f(0);

It uses the future auto function parameter. It was proposed into C++17, but I don't think it made it. gcc however supports it as an extension.
Basically
void foo(auto p);

is equivalent to
template <class T>
void foo(T p);

The code tries to instantiate f recursively with different template arguments. gcc fails with

fatal error: template instantiation depth exceeds maximum of 900 (use
  -ftemplate-depth= to increase the maximum)

With -ftemplate-depth=10000 I got it to spit "Killed - processing time exceeded" on godbolt.
Check it on godbolt

1 byte saved by Quentin. Thank you.

One byte can be saved by using int as the return type :)

Indeed, auto function parameters didn't make it into C++17; and also int f() { ... }, a; isn't a legal declaration last time I checked. (You can't mix function declarations with variable declarations like that.) What you've got here is an extremely GCC-specific dialect of C++. Not that there's anything wrong with that in this context. :)

Common Lisp, 8 bytes
#.(loop)

The compiler will try to read a form and will encounter the sharpsign-dot reader macro, which evaluates code at read time and uses its result as the form to compile. Here, the code being executed is an infinite loop.

TeX, 9 bytes
\def~{~}~

TeX works by expanding macros.  Most of the time, TeX's macros (also called control sequences) are of the form \name but it is also possible to define certain characters as macros, these are called active characters.  The character ~ is active by default in plain TeX and so can be used as a macro name without further declaration.  The \def~{~} in the above defines ~ so that it expands to ~.  That is, whenever TeX encounters ~ then it replaces it by ~ and then re-examines the replacement, meaning that it encounters a wholly new occurrence of ~ and replaces that by ~.  This defines the infinite loop.  All that is then needed is to start the loop and that's what the final ~ does.

Added in edit
To make this properly compiled, invoke as:
pdftex -ini "&pdftex \def~{~}~"

The -ini flag says that pdftex should compile a new format file.  This is a precompiled set of definitions which can be loaded when TeX is later invoked to speed up processing a document (LaTeX2e is an example of this).  I guess that the &pdftex adds a few bytes, taking the total to 17.

Does this happen at compile time? The question requires the infinite loop to happen while compiling, not when running.

@ais523 Hadn't fully thought about that bit.  I was riffing off the TikZ answer.  I've added an alternative that is definitely compiled, at the expense of a few more bytes.

@ais523: As always, "compiling" and "running" are two sides of the same coin. Personally, I think of TeX source code as "compiling" into PDF documents (which are then "executed" by viewing), in the same way that C++ source code is "compiled" into .exe files (which are then "executed" by running). But you could also think of the pdftex program as "interpreting" TeX input to produce a PDF as "output" — in the same way that the g++ program "interprets" C++ input to produce an .exe file as "output". ;)

Haskell, 25+17=42 bytes
a= $(let a='a':a in[|a|])

A simple Haskell metaprogram which defines an infinite value and attempts to compute that value at compile time.
Invoke with ghc -XTemplateHaskell <file.hs> (+17 for the parameter to the compiler)

Does $(let a=a in a) not work (for 32 bytes)?

Nope! GHC is too smart. Any infinite loop of the form let a = a in a gets rewritten to an exception, which simply causes a compiler error as opposed to an infinite loop. (although perhaps this would work with a different Haskell compiler, but I don't have one on hand to try)

It works with runghc for me, so I’d say it’s valid. (Actually, it works with ghc, too. 8.0.1 here.)

Really? I'm on ghc 8.0.1 as well - for me it gives Exception when trying to run compile-time code:  <<loop>>, both in the interpreter and when compiling... technically the code above dies with an exception as well, but a stack overflow, which is explicitly allowed by the spec - and if you had infinite memory, it would really loop forever. The <<loop>> exception fires far before my machine runs out of memory.

This is very interesting, a= $(let a=a in a) gives me an infinite loop in GHCi, version 8.8.4

gradle, 10 9 bytes
for(;;){}

with the above code placed in a build.gradle file. Gradle uses groovy as its base language so we are really talking about groovy here, but as the question was about build time I figured gradle would be more appropriate.
Running any gradle build commands with the above code prints the pointy-haired-boss-compatible build status line:
$ gradle tasks
> Configuring > 0/1 projects > root project

if you are aiming for a raise, add the debug -d flag for:
$ gradle -d tasks
14:56:25.522 [INFO] [org.gradle.internal.nativeintegration.services.NativeServices] Initialized native services in: .gradle/native
14:56:25.757 [DEBUG] [org.gradle.launcher.daemon.client.DaemonClient] Executing build 84908c0d-f28d-4c57-be61-40eaf0025e16.1 in daemon client {pid=27884}
14:56:25.761 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface tun0
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.762 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%tun0
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a loopback interface? false
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Is this a multicast interface? true
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x:x:x:x:x:x:%eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote address /x.x.x.x
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding remote multicast interface eth1
14:56:25.764 [DEBUG] [org.gradle.internal.remote.internal.inet.InetAddresses] Adding IP addresses for network interface lo
<snip>
14:57:07.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
14:57:07.056 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
> Configuring > 0/1 projects > root project

which in addition to looking impressively complicated also updates with a new set of:
15:07:57.054 [DEBUG] [org.gradle.launcher.daemon.server.Daemon] DaemonExpirationPeriodicCheck running
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.054 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Waiting to acquire shared lock on daemon addresses registry.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Lock acquired.
15:07:57.055 [DEBUG] [org.gradle.cache.internal.DefaultFileLockManager] Releasing lock on daemon addresses registry.

status lines every 10 seconds making it look like the build is busy doing important technical...stuff.

SWI-Prolog, 34 bytes
term_expansion(_,_):-repeat,1=0.

Explanation
term_expansion/2 is something that gets called automatically by the compiler before actually compiling code to transform some terms in the source code into other terms.
Here, we introduce a new rule for term_expansion/2: repeat,1=0..
repeat/0 is a predicate which always succeeds, and provides an infinite number of choice points.
1=0 is trying to unify 1 with 0, which is always false. This will cause the compiler to backtrack to repeat (since it always provides a choice point) and try 1=0 again, etc.

Doesn't work in GNU Prolog, so I'm assuming this is implementation-specific. You might want to put the name of a compiler in the heading. (I'm assuming SWI Prolog.)

@ais523 Thanks, didn't check on other distribs, but since compiler stuff is usually pretty specific, I should have known better...

@ais523 However according to this, you might be able to use expand_term instead (as it says term_expansion cannot be used like here in GNU Prolog). It doesn't work with expand_term on SWI though.

GNU Make, 44
.PHONY:x
$(MAKEFILE_LIST):x;sleep 1;touch $@

I can't claim credit for this.  It is derived from Robert Mecklenburg's book Managing Projects with GNU Make: The Power of GNU Make for Building Anything.

When make executes this makefile, it sees the makefile is out of date (because the .PHONY target is out of date, so it executes the touch command, which updates the timestamp of the makefile.  Then make re-reads the file and discovers the makefile is out of date.... Well you get the idea.

I prefer this to the other Make answer because it does not use recursion.  On my VM, the other Make answer continues forking processes and at somewhere around 7,000 deep, the VM grinds to an unresponsive halt.  However, with this answer it is able to continue indefinitely without eating up system resources.  You really will be able to slack off with this build.  I've gone over 1,000,000 iterations with no apparent system degradation.
Note I had to add the sleep 1 so that the makefile timestamp is actually updated every time.  You can change this to sleep 0.01 if you want it to burn through iterations a bit faster.

GNU Forth, 15 bytes
Golfed
: : [do] [loop]

Re-defines (re-compiles) the word : and invokes an immediate infinite loop [do] [loop] inside the new definition (right at the compile time).

One category of words don't get compiled. These so-called immediate words get executed (performed now) regardless of whether the text interpreter is interpreting or compiling.

Try It Online !

C, 31 bytes (16 + 15 for -mcmodel=medium)
main[-1llu]={1};

Inspired by Digital Trauma. Compile with the -mcmodel=medium flag.
Good luck compiling this, you'll need 1.8 yottabytes of RAM and disk space.

I might be misunderstanding how this works, but does this actually loop forever? It seems like it'd just take an impossibly long amount of time/amount of resources to compile.

Clojure, 21 bytes
(defmacro a[]`(a))(a)

Ties up the compiler by defining a macro that repeatedly emits calls to itself.
On my phone, this causes the REPL to hang and lag the device. On my laptop, this fails outright with a StackOverflow.
Unfortunately the StackOverflow happens instantly, but it's still valid according to the rules.

MSBuild, 130 bytes
<Project xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
    <Target Name="X">
        <Exec Command="msbuild"/>
    </Target>
</Project>

Save this as a file with .proj extension, and run with msbuild from the command prompt. MSBuild will run its only target which simply spawns another msbuild process.

Is the indentation required for this to work? What about the newlines? It's normally possible to golf out whitespace.

No, it's just easier to read. The character count doesn't include whitespace.

Ah right. In that case you should probably mention that in the body of the post.

Haskell (GHC, without Template Haskell or custom rewrite rules), 138
{-#LANGUAGE FlexibleContexts,UndecidableInstances#-}
data A x=A
class C y where y::y
instance C(A(A x))=>C(A x)where y=A
main|A<-y=pure()

Theoretically, this enters an infinite loop in much the same way the C++ approach does: the polymorphic method y is instantiated to ever more convoluted types. In practice, the default allotted stack size actually overflows quickly:
$ ghc-7.10 wtmpf-file14146.hs
[1 of 1] Compiling Main             ( wtmpf-file14146.hs, wtmpf-file14146.o )

wtmpf-file14146.hs:5:9:
    Context reduction stack overflow; size = 101
    Use -fcontext-stack=N to increase stack size to N
      C (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A (A t0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))
    In a stmt of a pattern guard for
                   an equation for ‘main’:
      A <- y
    In an equation for ‘main’: main | A <- y = pure ()

Credits to Luke Palmer.

Mathematica 33 Bytes
Compile[{},Evaluate@While[True,]]

The code will attempt to symbolically evaluate the argument prior to compilation, and the argument itself is an infinite loop.  The While function has a null second argument since it's not important.

"prior to compilation" Yeah...no.

Please provide a valid argument. https://reference.wolfram.com/language/tutorial/CompilingWolframLanguageExpressions.html

The question is, does the loop happen during the Compile call or before it?

Haskell (ghc), 32 + 2 = 34 bytes
{-#RULES""main=main#-}
main=main

run with ghc -O <file>. Triggers a rewrite rule for the main function which rewrites to the same thing. The only unfortunate feature is that ghc is smart enough to detect this and stop after 100 iterations. I don't know of an easy way to disable this behavior.

Rust, 18 bytes
include!(file!());

Classic self-include. Rustc is annoyingly sane though, and by default will bail out after 128 recursions, and it expands depth-first so exponential growth doesn't work either. The same applies to the C and C++ solutions though.

Boo, 25 bytes
macro l:
 x=0 while 1>0
l

This defines a macro, which executes at compile time, which executes an infinite loop, and then invokes the macro.

Factor, 29 16
<< [ t ] loop >>

The part between << >> is executed at parse time.
As for what [ t ] loop does, I'll let you guess...
You can put that in the Listener as is, or add it to any vocabulary or script file with the corresponding boilerplate stuff.

PHP, 19 bytes
<?include __FILE__;

Nim, 25 bytes
static:
 while 0<1:echo 2

Try it online!
Compile with --maxLoopIterationsVM:10000000000000000. The compiler on TIO is old and doesn't support this flag.

Julia 1.0, 16 bytes
@generated !x=!x

not a full program but a function, since Julia compiles functions the first time they are called
I'm pretty sure that's a compile-time infinite loop, since @code_llvm (which only compiles the function whithout executing it) also loops forever
Try it online!

Scala 3, 47 bytes
type T[X]=X match{case 1=>T[X]}
val x:T[1]= ???

Try it in Scastie!
Terminates saying "Recursion limit exceeded."

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Print 0-255 in grey code
Gray Code is a number system where only 1 bit of the number changes from one number to the next number.  Print the 8 bit Gray Code values of 0 to 255.
Shortest Code wins!
Start of output:
 0 00000000
 1 00000001
 2 00000011
 3 00000010
 4 00000110
 5 00000111
 6 00000101
 7 00000100
 ...

You only have to print the Gray Code in binary.  The decimal numbers in the example are just for reference.

Are we required to print the canonical Grey code, or just any 8-bit Grey code will do?

i'm probably missing something, but don't two bits (the first and last) change  from 0 to 1?

@Maltysen that would be a typo. Good catch.

in binary is a tad unclear. Does it have to be ones and zeroes, one per line, and padded to 8 bits (as in the example) or is the output format more liberal (list of strings, list of arrays, no left-padding, etc.)? Also, you say print. Does that mean returning the output from a function is not allowed?

Is the first digit on the second row supposed to be a 1?

@AlbertRenshaw No it's not. It's a typo.

Looks like we've had this challenge already.

Ruby, 48 33 Bytes
15 Bytes saved thanks to G B
256.times{|i|puts "%08b"%(i^i/2)}

You could use string interpolation to make it shorter: "%08b"%x is the same as `b.to_i(2).rjust(8,?0)

And i^(i>>1) is the same as i^i/2

C, 89 bytes
(Note: Leading Zeros Omitted from output)
q;main(a){a--;for(q=a^(a>>1);q;)printf("%c%i",8207,q%2),q/=2;puts("");a<256?main(a+2):0;}

I use a very neat trick in this one:

It converts a decimal to gray code (base 10), then convert that to binary which will print the grey number in reverse order. But before each time I output the mirrored grey number, I print U+200F or char(8207) which is a Right-To-Left marker character which causes output to be mirrored (and on the right side of my screen). Mirroring my backwards grey number outputs, thus making them forward, proper grey numbers (At least to human eyes, to the computer they are still backwards).

Notice the numbers are different in the LTR output, they are mirrored grey numbers.

(Note: Leading Zeros Omitted from output)

81 bytes

Jelly, 10 bytes
⁹ḶH+^ḶBḊ€Y

Try it online!

PHP, 43 40 bytes
unpadded
for(;$i<256;$i++)printf("%b\n",$i^$i/2);

+2 bytes for padded: replace %b with %08b.
Thanks @user63956 for reminding me of printf.

You can use printf("%08b\n", ...) in the padded version and inline the increment: $i/2^$i++.

@user63956 Thanks for reminding me of printf. I already tried that increment; it should work, but it doesn´t.

Python, 53 bytes
for i in range(256): print(bin(i^(i>1))[2:].zfill(8))

If you switch to python2 you can swap i^(i>1) to i^i/2 because python2's division operator automatically rounds down. I was just in the middle of writing an answer when xnor closed it, it came to 49 bytes.


text:
As Easy As A-B-C
Input
A string that contains at most one of each of the letters A, B, and C. They may be in any order. The empty string is valid input.
Note: A previous version of this challenge used the letters LEJ instead of ABC and they may still be used if desired.
Output
A string of the A, B, C letters that were not present in the input. They may be in any order.
If the output would be the empty string then simply giving no output is valid, if that makes sense for your implementation. (e.g. you don't need to actually call print on an empty string.)
Examples

If the input is B then the output should either be CA or AC since A and C are not present in the input.
If the input is the empty string then the output should be ABC or any permutation since none of the three letters are present in the input.
If the input is CAB then the output should be the empty string because all three letters are present in the input.

Test Cases
There are so few input cases that we can enumerate all of them:
in -> out1 | out2 | out3 | ...
ABC -> ""
ACB -> ""
BCA -> ""
BAC -> ""
CAB -> ""
CBA -> ""
AB -> C
AC -> B
BC -> A
BA -> C
CA -> B
CB -> A
A -> BC | CB
B -> CA | AC
C -> AB | BA
"" -> ABC | ACB | BCA | BAC | CAB | CBA

All valid outputs for each input are given, separated by |'s. "" represents the empty string
Scoring
The shortest code in bytes wins. But keep in mind that you may get more recognition for solving the challenge in a unique way rather than in a short way ;)

Is a list of characters acceptable for output, or must it be a string?

@Mego It must be a string (or be displayed as a string by default).

Cumbersome I/O format

@Mego It doesn't seem that cumbersome considering the difficulty of the task and shortness of the string.

The task is set difference between a constant and an input. Requiring that everything be done in strings is cumbersome with regards to the difficulty of the actual task.

In fact, since the challenge is really just set difference between a constant and an input, it's a dupe of this challenge.

I vaguely remember a more exact dupe match where you had to subtract the input from a constant set.

@xnor That's the best one I could find. If you find a better dupe target, feel free to change it.

@xnor Any chance you're thinking of Helka's recent challenge?

@MartinEnder No, I remember it as being from a while ago.

Can inputs contain letters outside of "ABC"? The specification: "A string that contains at most one of each of the letters A, B, and C" does not exclude such inputs.

Related

Do you have to output all combinations or were you just showing all possible outputs separated by "|" ?

@theonlygusti The input should only contain ABC

@AlbertRenshaw "All valid outputs for each input are given, separated by |'s."

Related

Python 3, 29 27 22 bytes
lambda x:{*"ABC"}-{*x}

-2 bytes thanks to Jonathan Allan
-5 bytes thanks to Rod

print(*{*"LEJ"}-{*input()}) saves 2. (tested on 3.5 and 3.6).

You can also turn into a lambda for -5 bytes

I love python ❤

@theonlygusti Whatever happened to <3 and ♥?

@theonlygusti : I would love python if I can replace lamda with

Jelly, 4 bytes
Thanks to @DuctrTape for the prod about the change and the presence of "ABC" in Jelly's dictionary.
“ḃ»ḟ

Try it online!
“ḃ» looks up the entry "ABC" in Jelly's dictionary, ḟ is the filer discard dyad which discards the characters found in the input from that list of characters. The result is implicitly printed.

For a lower case version the dictionary entry to use can be either of "abac" (“c») or "abaca" (“i»).

When the challenge was "LEJ" only 6 bytes could be achieved in the upper case variant, since no dictionary entries exist with that set of characters, leaving us to create the list of characters “LEJ” (or a permutation thereof).
The lowercase variant faired better at 5 bytes due to the presence of the word "jell" (“ẎṄ»).

I like how most of the code just generates the string "ABC", and the actual program itself is one character.  Classic jelly.

05AB1E, 6 4 bytes
Saved 2 bytes using the new žR command as suggested by Kevin Cruijssen
žRsм

Try it online!
or as a Test Suite
Explanation
   м  # remove the character of
  s   # the input
žR    # from the string "ABC"

Shouldn't an input of only J return EL, LE?

Nice! Just as an FYI, inputs can also be represented as """{input}""", which also works for empty strings :).

@carusocomputing: It can return either (in this case it returns LE).

@Adnan: Good point. Never used the triple-string input except with multiline input. Will have to remember that :)

I find it hard to believe there isn't a built in to push ABC that is less than 4 bytes. •CÞ•h is 5... 2ÝAè is lowercase and still 4...

@carusocomputing: ABC or CAB could be pushed in 3 chars as for example '±ì, but it would be lowercase, so converting to uppercase it would still be 4 :(

Can be 4 bytes now

@KevinCruijssen: Thanks! Do you know if žR has been useful before?

@Emigna Tbh no. I think it was added because of this challenge perhaps, but I personally haven't used it before.

Bash + coreutils, 15 bytes
tr -d x$1<<<LEJ

Try it online!
I'd like to omit the x, but then tr -d would be missing an argument when the input string was empty.  (The x doesn't do any harm, since there aren't any x's in the here-string LEJ.) I'd normally write tr -d "$1", but doing it the way I did is one byte shorter than that.

I had the same thoughts - even with the quotes - immediately, too.

Retina, 14 bytes
Byte count assumes ISO 8859-1 encoding.
$
¶ABC
D`.
A1`

Try it online!
Explanation
$
¶ABC

Append a second line containing ABC.
D`.

Deduplicate the characters. This deletes every character from the second line which already appears in the first line.
A1`

Discard the first line.

How exactly does the `1`` part of the antigrep stage work?

@KritixiLithos Numbers in the configuration string are limits. 1 generally means "only do X once". How exactly limits work (i.e. what X is) depends on the stage type you're using. For antigrep stages, Retina first checks which lines match the regex (here, every line, since the regex is empty), but then the limit means "only discard the first matching line". Similarly, if it was a grep stage it would mean "only keep the first matching line". The semantics of all limits are listed on the wiki.

Java 7, 73 58 bytes
String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

15 bytes saved thanks to @KritixiLithos.
Test code:
Try it here.
class M{
  static String c(String s){return"EJL".replaceAll("[ "+s+"]","");}

  public static void main(final String[] a) {
    System.out.print("LEJ=" + c("LEJ") + "; ");
    System.out.print("LJE=" + c("LJE") + "; ");
    System.out.print("EJL=" + c("EJL") + "; ");
    System.out.print("ELJ=" + c("ELJ") + "; ");
    System.out.print("JLE=" + c("JLE") + "; ");
    System.out.print("JEL=" + c("JEL") + "; ");
    System.out.print("LE=" + c("LE") + "; ");
    System.out.print("LJ=" + c("LJ") + "; ");
    System.out.print("EJ=" + c("EJ") + "; ");
    System.out.print("EL=" + c("EL") + "; ");
    System.out.print("JL=" + c("JL") + "; ");
    System.out.print("JE=" + c("JE") + "; ");
    System.out.print("L=" + c("L") + "; ");
    System.out.print("E=" + c("E") + "; ");
    System.out.print("J=" + c("J") + "; ");
    System.out.print("\"\"=" + c(""));
  }
}

Output:
LEJ=; LJE=; EJL=; ELJ=; JLE=; JEL=; LE=J; LJ=E; EJ=L; EL=J; JL=E; JE=L; L=EJ; E=JL; J=EL; ""=EJL

Can you do "["+s+"]" instead of s.replaceAll("(.)","$1|")?

@KritixiLithos Smart. It fails for the empty String, but by adding a space (or any other character that isn't EJL) it works again, which is still a lot shorter. :)

Actually, 7 bytes
"LEJ"-Σ

Try it online!
"LEJ"-Σ
"LEJ"    the letters
     -   exclude letters present in input
      Σ  concatenate

Pyth, 5 bytes
-"ABC

Test it here
Expands to
-"ABC"Q
-       # Filter on absence
 "ABC"  # Literal string
      Q # Input

abc can be written as <G3

@Maltysen yeah muddyfish used that, but it is lowercase anyway =\

JavaScript ES6, 41 39 38 Bytes
s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

Saved 2 bytes thanks to Arnauld.
Saved 1 bytes thanks to LarsW.

f=s=>eval(`'ABC'.replace(/[${s}]/g,'')`)

console.log(f("AB"));

I'm on mobile, so I can't test my code, but this should work I think: s=>eval\'ABC'.replace(/[${s}]/g,'')``

Nice work! Being able to say .join\`saves you two characters over the solution I had come up with:f=s=>"ABC".replace(RegExp(`[${s}]`,'g'),"")` .

@LarsW That exact code didn't seem to work, but adding brackets around the template string did and saved one byte. Thanks!

MATL, 10 8 bytes
Saved two bytes thanks to Suever. setdiff is shorter than ismember.
'ABC'iX-

Try it here!
Explanation
'ABC'      % Create a string literal
     i     % User input
      X-   % Set difference, between two elements of the stack

Yes, this might have been a trivial task, but I'm quite satisfied I managed to solve it with MATL all by myself. I never said it was the shortest solution... Thanks Suever!

V, 10 bytes
CLEJ<ESC>Ó[<C-r>"]

Try it online!
Hexdump:
00000000: 434c 454a 1bd3 5b12 225d                 CLEJ..[."]

Explanation
Input is on the first line of the buffer. So something like:
EL

and the cursor is on the first character. So we delete the input (which stores it in register ") and enter insert mode simultaneously using C.
Once in insert mode, the characters LEJ are inserted, after which I return to normal mode using <ESC>.
Now we have to remove all the characters that are present in the input.
Ó                       " remove every
 [<C-r>"]               "  character that appears in the input
                        " synonym of Vim's :s/[<C-r>"]//g

And once this happens, we are left with the remaining letters in the buffer.

Ruby, 27 19 18 bytes
->s{"ABC".tr s,""}

-1 byte thanks to Martin Ender

Haskell, 27 26 bytes
import Data.List
("ABC"\\)

Try it online! Usage: ("ABC"\\) "CB" yields "A".
\\ is the set difference operator, the parenthesis form a so called section which is a short form for the lamda (\x -> "ABC" \\ x).

Without import: (same byte count thanks to @nimi)
f x=[c|c<-"ABC",all(/=c)x]

Try it online! Usage: f "CB" yields "A".

Other approaches:
f x=filter(`notElem`x)"ABC"
(`filter`"ABC").flip notElem
f x=[c|c<-"ABC",notElem c x]

I hope (\\) will be moved to Prelude soon.

@theonlygusti I hope it won't; this isn't really a sensible operation for lists (at least not unless you explicitly state you want list-as-set). The default operation for that task should be Data.Set.difference.

@ceasedtoturncounterclockwis why is it not sensible? Besides, the only reason I desire it moved is because it is useful, frequently.

@theonlygusti it's not sensible in the sense that if you find yourself using it, it's a sign that you're probably using the wrong data structure. Lists can have duplicate elements, an order, and they may be lazily constructed (even infinite). (\\) respects none of this. Data types that are intended for this behaviour have a structure that makes them generally quite a bit more effecient, safer (because no possible stability etc. assumptions can be broken) and exposing a more comfortable interface.

@ceasedtoturncounterclockwis what, yes it does. "The first instance of..." but nvm

Brain-Flak, 120 + 3 = 123 bytes
<>((((((((()()){}){}){}){}){}())())())<>{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

It is run with the -c flag, adding 3 bytes
Try it online!
Explanation
Overall this program pretty much does the right stack set minus the left stack with the right stack initialized to CBA and the left stack initialized to the input.
Annotated Code
<>((((((((()()){}){}){}){}){}())())())<> # Switch to right stack, push CBA, switch back
{({}(<()>)){(([({})]<>({}))){(<({}<>{})<>([{}]{}<>)>)}{}}{}{}<>{}{({}<>)<>}{}}<>

More explanation to come...

GNU sed, 34 29 bytes
Includes +1 for -r
-5 thanks to Digital Trauma
s/^/ABC/
:
s/(.)(.*)\1/\2/
t

Try it online!
For some reason TIO doesn't work with extended regex (-r), so I had to wrap it in BASH.

s/^/ABC/        # put ABC at the beginning of the string
:               # nameless label
s/(.)(.*)\1/\2/ # remove a duplicate letter
t               # branch to the nameless label if something changed

The newline, -n and P are unnecessary.  Also you can wrap this up in bash to get it to work in TIO.  No idea why -r doesn't work. https://tio.run/nexus/bash#DcmxDYAwDATA/qdIR4JELCjp7F8jooIFCPubb@/mc5ftLUtOu8yDhhPTam@1r23sNg7Dl0tCB2cg6Agn6AGGy8VSoUwEPZg/

@DigitalTrauma Thanks! I was thinking there would be characters besides A, B, and C when I wrote this.

Mathematica, 37 bytes
Complement@@Characters@{"ABC",#}<>""&

Is there a reason you used strings here rather than lists of characters?

@GregMartin habit, I guess

just that I think it comes out shorter if you can avoid Characters

Octave, 29 27 bytes
Saved two bytes thanks to Suever, by creating the string 'ABC', inside the ismember call.
@(s)x(~ismember(x='ABC',s))

We use ~ismember() as logical indices to the variable x. The peculiar thing is, we create x='ABC' inside ismember, not in front of it. The order Octave sees this:
@(s)                        % Anonymous function that takes a string s as input
                x='ABC'     % Create a variable x with the characters 'ABC'
       ismember(x='ABC',s)  % True for elements that are in both x and s. False otherwise.
      ~ismember(x='ABC',s)  % Negate this, so that we keep the characters that aren't in s
@(s)x(~ismember(x='ABC',s)) % Use the logical vector as indices to x and return the result

Carrot, 15 bytes
I found a bug with returning matches and empty strings. So I just fixed it
ABC^//[^#]/gS""

Try it online! (copy & paste)
Explanation
ABC^                   //sets stack (just a string, not an array) to "ABC"
    /                  //return match(es) of:
     /[^#]/g           // `#` is the placeholder for the input
                       // so effectively, this returns the matches of any character not present in the input
                       // applied on the stack
                       //this returns an array of all the matches of the regex
            S""        //join all the elements of the array using "", the empty string

CJam, 7 bytes
"ABC"l-

Try it online! (As a linefeed-separated test suite.)

MATLAB / Octave, 20 bytes
@(x)setdiff('ABC',x)

Online Demo

C#, 50 Bytes 32 Bytes 47 Bytes 35 Bytes
where i is the input:
i=>string.Join("","ABC".Except(i));

Full app tested in LINQPad
void Main()
{
    var testcases = new Dictionary<string,string[]>
    {
        ["ABC"] = new[]{""},
        ["ACB"] = new[]{""},
        ["BCA"]  = new[]{""},
        ["BAC"]  = new[]{""},
        ["CAB"]  = new[]{""},
        ["CBA"]  = new[]{""},
        ["AB"] = new[]{"C"},
        ["AC"] = new[]{"B"},
        ["BC"] = new[]{"A"},
        ["BA"] = new[]{"C"},
        ["CA"] = new[]{"B"},
        ["CB"] = new[]{"A"},
        ["A"] = new[]{"BC","CB"},
        ["B"] = new[]{"CA","AC"},
        ["C"] = new[]{"AB","BA"},
        [""] = new[]{"ABC","ACB","BCA","BAC","CAB","CBA"},
    };

    var output = "";

    foreach(var input in testcases.Keys)
    {
        var expect = testcases[input];
        var actual = GetResult(input);
        if(!expect.Contains(actual)) throw new ApplicationException($"{input}:{string.Join(",",expect)}:{actual}");
        output+=$"{input} -> {actual}\n";
    }
    output.Dump();
}

// Define other methods and classes here
private string GetResult(string input){
    return string.Join("","ABC".Except(i));
}

Test results

ABC ->
ACB ->
BCA ->
BAC ->
CAB ->
CBA ->
AB -> C
AC -> B
BC -> A
BA -> C
CA -> B
CB -> A
A -> BC
B -> AC
C -> AB
-> ABC

That's not a valid answer, it has to be a function or a program, not a code snippet.

Ah. My bad. First timer here. So i need the print part in it?

@MichaelCoxon: You either need to make the entry into an entire program, which compiles (not recommended in C#, it has a lot of boilerplate), or into a function that can be called multiple times; at the moment it's just a statement. In C#, it's nearly always easiest to make it into a function by creating a lambda, that takes input via its arguments, and returns via its return value.

string.Join("",...) -> string.Concat(...) Saves 1 byte

Japt, 13 12 bytes
"ABC"r"[{U}]

Saved a byte thanks to ETHproductions.
Try it online!

Nice, thanks for using Japt! You can remove the trailing quote to save a byte.

APL, 7 bytes
'ABC'∘~

~ is set subtraction, ∘ is compose, so this is a function that returns ABC minus the characters in its input.

Jellyfish, 9 bytes
PNI
 "ABC

Try it online!
In more conventional notation, this program translates to:
P(N("ABC", I))

I is the input, N is list difference, and P is output.

Perl 5.9.9 79 38 37 35 bytes
perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'

(not sure of the counting rules here - have included switches but not the perl command).
> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print' AB
C
> perl -le '$_="ABC";eval"y/$ARGV[0]//d";print'
ABC

(adjusted counts after adjudication comment below)

Will that work for empty input?

Now I fixed the transcription error (had "..", typed {,,} here...)

Your code is 35 bytes long. (34 +1 for the -l flag). :)

Thanks. The -l is for prettification (as in a newline at the end of the output.). wasn't sure if that was necessary from the contest rules.

With 5.14+, you can do perl -pe'$_=eval"ABC=~y/$_//dr"' for only 23 bytes (22 + 1 for -p).

Common Lisp, 71 bytes
The largest entry at the moment, but at least it is readable ;-)
(lambda(s)(coerce(set-difference'(#\A #\B #\C)(coerce s'list))'string))

Pyth, 4 bytes
-<G3

Try it here!
 <G3 -  alphabet[:3]
-    - input-^

Note this uses lower case which might not be acceptable

C, 53 bytes
b=64;c(char*a){while(b<67)putchar(++b*!strchr(a,b));}

If implicit declarations of string.h are not allowed, 72 bytes, to add #include<string.h>
Try it online!

or something a bit more fun at 75 bytes
a[128]={};b=64;c(char*d){while(*d)++a[*d++];while(b<67)putchar(b*!a[++b]);}

Try it online!

52 bytes

Batch, 101 bytes
@set/ps=
@for %%c in (L E J)do @call set d=%%s:%%c=%%&call:c %%c
:c
@if "%d%"=="%s%" set/pd=%1<nul

Takes input on STDIN, which means that %1 is empty when the code falls through into the helper subroutine and nothing gets printed.

R, 47 40 bytes
gsub(paste0("[",scan(,""),"]"),"","ABC")

Try it online!
Replaces any letters in the input string with the empty string.

Vyxal, 6 bytes
‛ėġ⇧$F

Try it Online!
     F # Remove from...
‛ėġ⇧   # "ABC"
    $  # The input

Raku, 21 bytes
{'ABC'.trans($_=>"")}

Try it online!
Transliterates all of the characters in the input string into the null string.

Lua, 41 bytes
print((('LEJ'):gsub('['..(...)..']',''))

Befunge, 40 39 bytes
~2p~2vv:<_>"C"-#v_@
8p2~p<>,0^g2::+1<*8

Try it online!

PHP, 43 40 bytes
<?=preg_replace("([Z$argv[1]])","",ABC);

Z added to character class to work around missing terminating ]  warning for empty input.
no regex, 43 bytes:
<?=str_replace(str_split($argv[1]),"",ABC);

str_split splits input to array of single characters
str_replace replaces all occurences of each array element in ABC with the empty string

Regex like "/[Z$argv[1]]/" seems to work with empty input as well, and saves 3 bytes.

VB.Net, 65 bytes
Sub F(s)
Console.Write(String.Join("","ABC".Except(s)))
End Sub

A subroutine (function) that takes the input string, and removes each character present in the input from the string "ABC". Then it joins the resulting characters back into a string, before printing them to the console.

Pure bash, 59 bytes
If the newline isn't necessary, removing the final "echo" takes it down to 54 bytes.
for i in A B C
{
[ X${1//$i/} = X$1 ] && echo -n $i
}
echo

Clojure, 39 bytes
#(apply str((group-by(set %)"ABC")nil))

Transforms input string into set of characters, and then uses it as a function by which it groups string "ABC". For example, if the input string is "B" then the result is {nil [\A \C], \B [\B]} and all we have to do is take value by key nil and convert it to string. Beats Common Lisp!
See it online

Go, 158 153 151 146 bytes
condensed:
package main;import(."os";."fmt");func main(){b:=[3]int{65,66,67};for _,e:=range Args[1]{b[e-65]=1};Print(string(b[0])+string(b[1])+string(b[2]))}

uncondensed:
package main

import (
    ."os"
    ."fmt"
)

func main() {
    //A,B,C are represented as 65,66,67 in int
    b := [3]int{65, 66, 67}
    //Loop through the ABC argument.
    for _,e := range Args[1]{
        //Find the letter that exists. If it's A then b[65-65] -> b[0] -> A
        //We replace the integer, with 1 which is equal to an empty string if converted.
        b[e-65] = 1
    }
    //Covert each int to string.
    Print(string(b[0])+string(b[1])+string(b[2]))
}

Scala, 23 bytes
(s:String)=>"ABC"diff s

Mathematica 38 Bytes
""<>Complement@@Characters/@{"ABC",#}&

splits out the characters of the input string and the string "ABC" and performs their complement and a shorthand StringJoin.

PHP, 61 bytes
<?=implode("",array_diff(["A","B","C"],str_split($argv[1])));

perl 5.18, 35 bytes
print"ABC"=~s/[@{[shift||" "]}]//gr

Examples:
perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr' A        # BC
perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr' BC       # A
perl -le'print"ABC"=~s/[@{[shift||" "]}]//gr'          # ABC

Perl 6, 38 bytes
say join "","ABC".split(get.split(""))

Example found in close to every "remove substring" answer.
EDIT: Fixed the mistake when AC it returns ABC

For input “AC” this outputs “ABC”… ☹

@manatwork holy cow, well.... I can acctually see how that is happening.. Darn finding a fix now

CJam, 7 bytes
"abc"l-

Explanation:
"abc"l-
"abc"   e#Push ['a','b','c']
     l  e#Push input
      - e#Remove input from ['a','b','c']
        e#Implict output

Gema, 44 characters
\A=@set{r;ABC}
?=@set{r;@subst{?=;$r}}
\Z=$r

Sample run:
bash-4.3$ printf CB | gema '\A=@set{r;ABC};?=@set{r;@subst{?=;$r}};\Z=$r'
A

Japt, 7 bytes
Input & output as strings.
;3îB kU

Try it
Input & output as arrays of characters.
3õdI kU

Try it

Bash, 22 bytes
x=ABC
echo ${x//[$1]/}

Try it online!
Zsh, 20 bytes
x=ABC
<<<${x//[$1]/}

Try it online!
Nothing crazy, just remove matches from the string "ABC"

Japt, 7 bytes
"ABC"kU

Run it online | Run the testcases

As Embodiment of Ignorance pointed out:
6 bytes if lowercase input/output is acceptable:
`¯b`kU

Run it online

If lowercase is allowed, 6 bytes: https://petershaggynoble.github.io/Japt-Interpreter/?v=2.0a0&code=YK9iYGtV&input=ImFiIg==

Ruby, 16 bytes
Inspired by Sean’s Raku answer.
$_="ABC".tr$_,""

Attempt This Online!

Thunno 2, 5 bytes
ʋABCḍ

Try it online!
Explanation
ʋABCḍ  # Implicit input
ʋABC   # Push "ABC"
    ḍ  # Symmetric set difference
       # Implicit output