Wenn Sie dies akzeptieren möchten, müssen Sie ein Programm schreiben, das seinen eigenen Quellcode in der binären UTF-8- Darstellung ausgibt .

Regeln

• Die Quelle muss mindestens 1 Byte lang sein.

• Ihr Programm darf keine Eingaben annehmen (oder eine nicht verwendete, leere Eingabe haben).

• Die Ausgabe kann in einem beliebigen praktischen Format erfolgen.

• Optional ist eine nachgestellte Newline zulässig.

• Beachten Sie, dass ein Byte 8 Bit umfasst und die Länge der binären UTF-8-Darstellung notwendigerweise ein Vielfaches von 8 ist.

• Dies ist Code-Golf, daher gelten alle üblichen Golfregeln, und der kürzeste Code (in Bytes) gewinnt.

• Standardlücken sind verboten.

Beispiel

Angenommen, Ihr Quellcode ist Aä$$€hdie entsprechende binäre UTF-8-Darstellung 010000011100001110100100001001000010010011100010100000101010110001101000.

Wenn ich laufe, Aä$$€hmuss die Ausgabe sein 010000011100001110100100001001000010010011100010100000101010110001101000.

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

String zu binären UTF-8-Konvertern

• Probieren Sie es online aus!

• utf8-convert

V , 28 (oder 16?) Lateinische 1 Bytes (35 UTF-8 Bytes)

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

Probieren Sie es online aus!

Hexdump (in Latein 1):

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

Ausgabe (binäre Darstellung desselben Codes in UTF-8, nicht in Latein 1):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

Erläuterung:

ñéÑ~"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

Oder...

V , 16 Bytes

ñéÑ~"qpx!!xxd -b

Probieren Sie es online aus!

Ausgabe:

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 sagte:

Die Ausgabe kann in einem beliebigen geeigneten Format erfolgen.

Dies wird in einem viel bequemeren Format für V: P ausgegeben (aber ich bin mir nicht sicher, ob dies die Regeln erweitert).

CJam , 20 Bytes

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

Probieren Sie es online aus!

Überrascht zu sehen, wie CJam gewinnt! _{wir werden sehen, wie lange das dauert ...}

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 hat keine integrierten UTF-8-Konvertierungsfunktionen, daher muss ich alles manuell ausführen .

Probieren Sie es online aus oder stellen Sie sicher, dass es sich um eine Quine handelt .

Erläuterung:

Quine-Teil :

Das kürzeste Quine für 05AB1E ist dieses: 0"D34çý"D34çý( 14 Bytes ) bereitgestellt von @OliverNi . Meine Antwort verwendet eine modifizierte Version dieses Quines, indem ich ...hier Folgendes hinzufüge : 0"D34çý..."D34çý.... Eine kurze Erklärung dieser 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)

Herausforderungsteil:

Nun zum Herausforderungsteil des Codes. Wie oben erwähnt, verfügt 05AB1E über keine integrierten UTF-8-Konvertierungsfunktionen, daher muss ich diese Dinge manuell ausführen. Ich habe diese Quelle als Referenz verwendet, um dies zu tun: Manuelles Konvertieren von Unicode-Codepunkten in UTF-8 und UTF-16 . Hier eine kurze Zusammenfassung der Konvertierung von Unicode-Zeichen in UTF-8:

1. Konvertieren Sie die Unicode-Zeichen in ihre Unicode-Werte (dh "dЖ丽"wird [100,1046,20029])
2. Konvertieren Sie diese Unicode-Werte in Binärwerte (dh [100,1046,20029]wird ["1100100","10000010110","100111000111101"])
3. Überprüfen Sie, in welchem ​​der folgenden Bereiche die Zeichen sind:
   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

Es gibt auch Bereiche für 5 oder 6 Bytes, aber lassen wir sie vorerst weg.

Das Zeichen dbefindet sich im ersten Bereich, also 1 Byte in UTF-8; Zeichen Жliegt im zweiten Bereich, also 2 Bytes in UTF-8; und Zeichen 丽liegt im dritten Bereich, also 3 Bytes in UTF-8.

Die xim Muster dahinter sind mit der Binärdatei dieser Zeichen von rechts nach links gefüllt. So ist die d( 1100100) mit Muster 0xxxxxxxwird 01100100; das Ж( 10000010110) mit Muster 110xxxxx 10xxxxxxwird 11010000 10010110; und das 丽( 100111000111101) mit Muster 1110xxxx 10xxxxxx 10xxxxxxwird 1110x100 10111000 10111101, wonach die verbleibenden xersetzt werden durch 0: 11100100 10111000 10111101.

Also, diesen Ansatz habe ich auch in meinem Code verwendet. Anstatt die tatsächlichen Bereiche zu überprüfen, schaue ich mir nur die Länge der Binärdatei an und vergleiche sie mit der Menge xin den Mustern, da dies einige Bytes spart.

Ç               # 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
        j       #   Add leading spaces to the head binary to make it of that length
         š      #   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)

Sehen Sie diese 05AB1E Antwort von mir (Abschnitte Wie große natürliche Zahlen zu komprimieren? Und Wie zu komprimieren integer Listen? ) Zu verstehen , warum •Xó•18вist [1,8,12,17].

JavaScript (Node.js) , 60 Byte

-15 Bytes von @Neil und @Shaggy

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

Probieren Sie es online aus!

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!l`ho)(zg)0(:|".iter(){if c^o!=36{print!("{:08b}",c^o);}else{f(0);}}}fn main(){f(1);}

Probieren Sie es online aus!

Perl 6 , 46 Bytes

<say "<$_>~~.EVAL".ords.fmt("%08b",'')>~~.EVAL

Probieren Sie es online aus!

Das Standard-Quine mit .fmt("%08b",'')formatiert die Liste der Ordnungswerte in binäre Länge 8 und verbindet sich mit einer leeren Zeichenfolge.

Perl 5, 42 Bytes

$_=q(say unpack'B*',"\$_=q($_);eval");eval

TIO

Java 10, 339 308 265 227 225 186 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 dank @NahuelFouilleul , der das Unnötige entfernt &255(und zusätzlich -35, um mich darauf aufmerksam zu machen, dass die vollständigen Programmspezifikationen der Herausforderung widerrufen wurden und eine Funktion jetzt ebenfalls zulässig ist ..)
-41 Bytes dank @ OlivierGrégoire .

Probieren Sie es online aus.

Erläuterung:

Quine-Teil :

• var s enthält den unformatierten Quellcode String
• %s wird verwendet, um diesen String mit sich selbst in sich zu setzen s.format(...)
• %c, %1$cUnd 34werden verwendet , um die doppelten Anführungszeichen zu formatieren ( ")
• s.format(s,34,s) fasst alles zusammen

Herausforderungsteil:

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      

Python 2 , 68 67 Bytes

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

Probieren Sie es online aus!

Eine Änderung dieser Antwort

-1 Bytes durch Entfernen des Leerzeichens nach 'in' (danke @mdahmoune)

R , 138 114 Bytes

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

Probieren Sie es online aus!

Verwendet die Fähigkeit von R, Funktionen auf ihre Zeichendarstellung zu beschränken. Die revs werden benötigt, weil rawToBitsdas niedrigstwertige Bit an erster Stelle steht. as.integerwird benötigt, da sonst die Bits mit einer führenden Null angezeigt werden.

Bearbeitet, als ich merkte, dass jede bequeme Ausgabe erlaubt war. Auch war um eins bei der ursprünglichen Byteanzahl.

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

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'))));

Probieren Sie es online aus!

C # (Visual C # Interactive Compiler) mit Flag /u:System.String, 193 Byte

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'))));

Probieren Sie es online aus!

Bash + GNU-Tools, 48 ​​Byte

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

TIO