# Quine outputs itself in binary

Your task, if you wish to accept it, is to write a program that outputs its own source code in the binary UTF-8 representation.

# Rules

• The source must be at least 1 byte long.

• Your program must not take input (or have an unused, empty input).

• The output may be in any convient format.

• Optional trailing newline is allowed.

• Notice that one byte is 8 bits, and the length of the binary UTF-8 representation is necessarily a multiple of 8.

• This is so all usual golfing rules apply, and the shortest code (in bytes) wins.

• Standard loopholes are forbidden.

# Example

Let's say your source code is Aä$$€h, its corresponding UTF-8 binary representation is 010000011100001110100100001001000010010011100010100000101010110001101000. If I run Aä$$€h the output must be 010000011100001110100100001001000010010011100010100000101010110001101000.

A      --> 01000001
ä      --> 1100001110100100
$--> 00100100$      --> 00100100
€      --> 111000101000001010101100
h      --> 01101000
Aä€h --> 010000011100001110100100001001000010010011100010100000101010110001101000


# String to binary UTF-8 converters

• By "binary", do you mean a string representation of the binary values, i.e. a string consisting of only 1's and 0's? – user77406 Feb 4 '19 at 18:38
• @mdahmoune Now that's already much better. The question remains how to represent something as UTF-8. Notice that Unicode representation is mainly based on the looks of a character (only occasionally on semantic meaning). What if no assigned Unicode glyph looks like a character in the source code? Unicode also has many look-alikes (homoglyphs). How does one decide which one to use? E.g. Dyalog APL has an AND function which may be encoded as 01011110 or 0010011100100010 in UTF-8 (they look pretty alike: ^ vs ∧) – Adám Feb 4 '19 at 19:44
• Better example: 01111100 and 0010001100100010 encode | and ∣. – Adám Feb 4 '19 at 19:51
• @Adám I think it would be fair to output any binary sequence that corresponds to a symbol that will compile/run in a certain implementation of a language. – qwr Feb 4 '19 at 20:09
• How about machine code? (Commodore C64 takes 28 bytes assuming the machine code itself is the "source") – Martin Rosenau Feb 4 '19 at 21:18

# V, 28 (or 16?) Latin 1 bytes (35 UTF-8 bytes)

ñéÑ~"qpx!!xxd -b
ÎdW54|D
Íßó


Try it online!

Hexdump (in Latin 1):

00000000: f1e9 d17e 2271 7078 2121 7878 6420 2d62  ...~"qpx!!xxd -b
00000010: 0ace 6457 3534 7c44 0acd dff3            ..dW54|D....


Output (binary representation of the same code in UTF-8, not Latin 1):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010


Explanation:

ñéÑ~"qpx            " Standard quine. Anything after this doesn't affect the
" program's 'quine-ness' unless it modifies text in the buffer
!!xxd -b    " Run xxd in binary mode on the text
Î                   " On every line...
dW                 "   delete a WORD
54|              "   Go to the 54'th character on this line
D             "   And delete everything after the cursor
Í                   " Remove on every line...
ó                 "   Any whitespace
ß                  "   Including newlines


Or...

# V, 16 bytes

ñéÑ~"qpx!!xxd -b


Try it online!

Output:

00000000: 11000011 10110001 11000011 10101001 11000011 10010001  ......
00000006: 01111110 00100010 01110001 01110000 01111000 00100001  ~"qpx!
0000000c: 00100001 01111000 01111000 01100100 00100000 00101101  !xxd -
00000012: 01100010 00001010                                      b.


OP said:

The output may be in any convenient format.

This outputs in a much more convenient format for V :P (but I'm not sure if that's stretching the rules)

# CJam, 20 bytes

{s"_~"+{i2b8Te[}%}_~


Try it online!

Surprised to see CJam winning! we'll see how long that lasts...

# 05AB1E, 105 bytes

0"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J"D34çýÇbεDg•Xó•18в@ƶà©i7j0ìëR6ôRíć7®-jšTìJ1®<×ì]ð0:J


05AB1E has no UTF-8 conversion builtins, so I have to do everything manually..

Explanation:

-part:

The shortest for 05AB1E is this one: 0"D34çý"D34çý (14 bytes) provided by @OliverNi. My answer uses a modified version of that quine by adding at the ... here: 0"D34çý..."D34çý.... A short explanation of this quine:

0               # Push a 0 to the stack (can be any digit)
"D34çý"        # Push the string "D34çý" to the stack
D       # Duplicate this string
34ç    # Push 34 converted to an ASCII character to the stack: '"'
ý   # Join everything on the stack (the 0 and both strings) by '"'
# (output the result implicitly)


Challenge part:

Now for the challenge part of the code. As I mentioned at the top, 05AB1E has no UTF-8 conversion builtins, so I have to do these things manually. I've used this source as reference on how to do that: Manually converting unicode codepoints into UTF-8 and UTF-16. Here a short summary of that regarding the conversion of Unicode characters to UTF-8:

1. Convert the unicode characters to their unicode values (i.e. "dЖ丽" becomes [100,1046,20029])
2. Convert these unicode values to binary (i.e. [100,1046,20029] becomes ["1100100","10000010110","100111000111101"])
3. Check in which of the following ranges the characters are:
1. 0x00000000 - 0x0000007F (0-127): 0xxxxxxx
2. 0x00000080 - 0x000007FF (128-2047): 110xxxxx 10xxxxxx
3. 0x00000800 - 0x0000FFFF (2048-65535): 1110xxxx 10xxxxxx 10xxxxxx
4. 0x00010000 - 0x001FFFFF (65536-2097151): 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx

There are also ranges for 5 or 6 bytes, but let's leave them out for now.

The character d will be in the first range, so 1 byte in UTF-8; character Ж is in the second range, so 2 bytes in UTF-8; and character 丽 is in the third range, so 3 bytes in UTF-8.

The x in the pattern behind it are filled with the binary of these characters, from right to left. So the d (1100100) with pattern 0xxxxxxx becomes 01100100; the Ж (10000010110) with pattern 110xxxxx 10xxxxxx becomes 11010000 10010110; and the 丽 (100111000111101) with pattern 1110xxxx 10xxxxxx 10xxxxxx becomes 1110x100 10111000 10111101, after which the remaining x are replaced with 0: 11100100 10111000 10111101.

So, that approach I also used in my code. Instead of checking the actual ranges, I just look at the length of the binary and compare it to the amount of x in the patterns however, since that saves a few bytes.

Ç               # Convert each character in the string to its unicode value
b              # Convert each value to binary
ε             # Map over these binary strings:
Dg           #  Duplicate the string, and get its length
•Xó•       #  Push compressed integer 8657
18в    #  Converted to Base-18 as list: [1,8,12,17]
@   #  Check for each if the length is >= to this value
#  (1 if truthy; 0 if falsey)
ƶ            #  Multiply each by their 1-based index
à           #  Pop and get its maximum
©          #  Store it in the register (without popping)
i            #  If it is exactly 1 (first range):
7j          #   Add leading spaces to the binary to make it of length 7
0ì        #   And prepend a "0"
ë            #  Else (any of the other ranges):
R           #   Reverse the binary
6ô         #   Split it into parts of size 6
Rí       #   Reverse it (and each individual part) back
ć           #   Pop, and push the remainder and the head separated to the stack
7®-        #   Calculate 7 minus the value from the register
š      #   Add it at the start of the remainder-list again
Tì          #   Prepend "10" before each part
J         #   Join the list together
1®<×        #   Repeat "1" the value from the register - 1 amount of times
ì       #   Prepend that at the front
]             # Close both the if-else statement and map
ð0:          # Replace all spaces with "0"
J         # And join all modified binary strings together
# (which is output implicitly - with trailing newline)


See this 05AB1E answer of mine (sections How to compress large integers? and How to compress integer lists?) to understand why •Xó•18в is [1,8,12,17].

# JavaScript (Node.js), 60 bytes

-15 bytes from @Neil and @Shaggy

f=_=>[...Buffer(f=+f)].map(x=>x.toString(2).padStart(8,0))


Try it online!

• padStart(8,0) saves 2 bytes. – Neil Feb 4 '19 at 21:57
• The spec allows for output to be in any convenient format so you could keep the map and ditch the join to output an array of bits – Shaggy Feb 4 '19 at 23:35
• 60 bytes with output as an array of bytes. – Shaggy Feb 4 '19 at 23:46
• Thanks @Neil and @Shaggy!! – Luis felipe De jesus Munoz Feb 5 '19 at 2:35

# Rust, 187 bytes

fn f(o:u8){for c in b"go!g)n;t9(zgns!b!ho!c#%#/huds)(zhg!b_n <27zqshou )#z;19c|#-b_n(:|dmrdzg)1(:|||go!lho)(zg)0(:|".iter(){if c^o!=36{print!("{:08b}",c^o);}else{f(0);}}}fn main(){f(1);}


Try it online!

<say "<$_>~~.EVAL".ords.fmt("%08b",'')>~~.EVAL  Try it online! The standard quine with .fmt("%08b",'') formats the list of ordinal values into length 8 binary and joins with an empty string. # Perl 5, 42 bytes $_=q(say unpack'B*',"\$_=q($_);eval");eval


TIO

# Java 10, 339308265227225186 184 bytes

v->{var s="v->{var s=%c%s%1$c;return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}";return 0+new java.math.BigInteger(s.format(s,34,s).getBytes()).toString(2);}  -8 bytes thanks to @NahuelFouilleul removing the unnecessary &255 (and an additional -35 for bringing to my attention that the full program specs of the challenge had been revoked and a function is allowed now as well..) -41 bytes thanks to @OlivierGrégoire. Try it online. Explanation: -part: • var s contains the unformatted source code String • %s is used to put this String into itself with s.format(...) • %c, %1$c and 34 are used to format the double-quotes (")
• s.format(s,34,s) puts it all together

Challenge part:

v->{                         //  Method with empty unused parameter and String return-type
var s="...";               //   Unformatted source code String
return 0+                  //   Return, with a leading "0":
new java.math.BigInteger( //    A BigInteger of:
s.format(s,34,s)        //     The actual source code String
.getBytes())           //     Converted to a list of bytes (UTF-8 by default)
.toString(2);}            //    And convert this BigInteger to a binary-String

• 265 bytes using lambda, also because all source is ascii seems unsigned int c&255 is not needed – Nahuel Fouilleul Feb 5 '19 at 13:32
• @NahuelFouilleul The original question stated "You must build a full program." and "Your output has to be printed to STDOUT.", hence the verbose border-plate code I have instead of a lambda function returning a String. Good point about not needing &255 however since we don't use any non-ASCII characters, thanks! – Kevin Cruijssen Feb 5 '19 at 13:34
• ok i'm not yet very familar with the usages, but other languages like javascript give a lambda returning a string, also i don't understand why in java we don't count the type and the final semicolon when using lambda where could i find rules? – Nahuel Fouilleul Feb 5 '19 at 13:44
• Well, that's where I'm lost. However I tried and here's a new candidate for 184 bytes. Tell me if I'm wrong somewhere ;) – Olivier Grégoire Feb 5 '19 at 14:37
• @OlivierGrégoire Ah, nice approach! Completely forgot about BigInteger being pretty short for converting to binary-Strings. And 2 more bytes by changing the return'0'+ to return 0+. Hmm, why is that leading 0 necessary btw? It confuses me that all inner binary-Strings have this leading 0, but the very first one not when using BigInteger.toString(2).. – Kevin Cruijssen Feb 5 '19 at 14:44

# Python 2, 68 67 bytes

_="print''.join(bin(256|ord(i))[3:]for i in'_=%r;exec _'%_)";exec _


Try it online!

-1 bytes by removing the space after 'in' (thanks @mdahmoune)

• -1 byte: u can drop the space after in – mdahmoune Feb 5 '19 at 18:24
• you haven't updated your TIO link. also, I tried to do '%08b'%ord(i) instead of bin(256|ord(i))[3:], but it didn't work for some reason – Jo King Feb 6 '19 at 9:50

# R, 138 114 bytes

x=function(){rev(rawToBits(rev(charToRaw(sprintf("x=%s;x()",gsub("\\s","",paste(deparse(x),collapse="")))))))};x()


Try it online!

Uses R’s ability to deparse functions to their character representation. The revs are needed because rawToBits puts the least significant bit first. as.integer is needed because otherwise the bits are displayed with a leading zero.

Edited once I realised that any convenient output was allowed. Also was out by one on original byte count.

# C# (Visual C# Interactive Compiler), 221 bytes

var s="var s={0}{1}{0};Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(string.Concat(string.Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));


Try it online!

# C# (Visual C# Interactive Compiler) with flag /u:System.String, 193 bytes

var s="var s={0}{1}{0};Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));";Write(Concat(Format(s,(char)34,s).Select(z=>Convert.ToString(z,2).PadLeft(8,'0'))));


Try it online!

# Bash + GNU tools, 48 bytes

trap -- 'trap|xxd -b|cut -b9-64|tr -dc 01' EXIT
`

TIO

• thanks, updated indeed it's the shortest variation otherwise should be removed from trap output – Nahuel Fouilleul Feb 5 '19 at 11:21