A Complementary Quine

Question

Write a quine that outputs the complement of the source code from the smallest containing power of two. Here's an example:

IN : source
OUT: \r\x11\x0b\x0e\x1d\x1b

The largest code point in the string "source" is the letter u, which is 117. The smallest containing power of 2 would be 128, so all the code points are taken as complements from 128.

1. s: 128 - 115 = 13. Code point 13 is a carriage return.
2. o: 128 - 111 = 17. Code point 17 is "device control 1"
3. u: 128 - 117 = 11. Code point 11 is a vertical tab.

And et cetera. Here's another example:

IN : R¡Ṡ
OUT: ᾮὟƠ

The largest code point is the character Ṡ, which is 7776. The smallest containing power of 2 is 2^13 (8192), so each character is complemented from 8192.

All of the standard loopholes apply. A program must consist of some explicit data or code. A variable containing some data by default would be considered implicit data, and therefore not allowed.

If your language inevitably outputs a trailing newline, it can be disregarded.

Answer 1

Retina, 2 1 byte

P

Outputs

0

Explained

P actually has no special meaning in retina, but retina treats it like a regex against the input, and counts the matches. As there's no input, there's no matches, so it returns 0, which is the exact inverse of this.

Try it online!

This is using an older version of Retina, which outputs a newline with the zero. This is not the case in the latest version.

Answer 2

Neim, 1 byte

Try it online!

Uses Neim's code-page, where is byte 0xd0 (208) and the printed result, 0, is byte 0x30 (48) which is as required (256-208).

is an instruction to get the nth element of a list. Both n and the list are implicit since they are missing and neim outputs implicitly too.

Answer 3

RProgN 2, 17 18 bytes

«` .S{c$256\-o}r. 

Output

U àÒ\x85\x9DÜÎËʤÓ\x91\x83\x8EÒà

Where \x numbers are to be considered literal.

Explained

«` .S{c$256\-o}r. 
«                   # Push a function based on the remainder of the program and run it.
 ` .                # Append a space to the end, which stringifies it. As the stringification removes unnecessary spaces, this re-adds the leading one, making it a valid quine.
    S               # Convert it to a stack of characters.
     {        }r    # Replace each character based on a function.
      c             # Get the character code
       $256         # Push 256 literally.
           \-       # Flip them and subtract, giving 255 - char code, which is equivalent to the bitwise not of the char code.
             o      # Get the character this represents.
                .   # Reduce with Concatenation, turning it back into a string. Implicitely output.

Try it online!

Answer 4

C, 178 bytes

char*u,*s="char*u,*s=%c%s%c;main(){char t[256];sprintf(t,s,34,s,34);for(u=t;*u;++u)*u=128-*u;puts(t);}";main(){char t[256];sprintf(t,s,34,s,34);for(u=t;*u;++u)*u=128-*u;puts(t);}

Try it online!

Answer 5

JavaScript, 121 bytes

f=a=>[...a='f='+f].map(a=>(m=(a=a.charCodeAt())>m?a:m,a),m=0).map(a=>String.fromCharCode(2**-~(Math.log2(m)|0)-a)).join``

Try it online!

Answer 6

Python 2, 93 bytes

s='s=%r;print"".join(chr(128-ord(i))for i in s%%s)';print"".join(chr(128-ord(i))for i in s%s)

Try it online!