Su tarea, si desea aceptarlo, es escribir un programa que genere su propio código fuente en la representación binaria UTF-8 .

Reglas

• La fuente debe tener al menos 1 byte de longitud.

• Su programa no debe tomar entrada (o tener una entrada vacía no utilizada).

• La salida puede estar en cualquier formato conveniente.

• Se permite la nueva línea final opcional.

• Observe que un byte es de 8 bits, y la longitud de la representación binaria UTF-8 es necesariamente un múltiplo de 8.

• Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).

• Las lagunas estándar están prohibidas.

Ejemplo

Digamos que su código fuente es Aä$$€h, su representación binaria UTF-8 correspondiente es 010000011100001110100100001001000010010011100010100000101010110001101000.

Si ejecuto Aä$$€hla salida debe ser 010000011100001110100100001001000010010011100010100000101010110001101000.

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

Cadena a convertidores binarios UTF-8

• Pruébalo en línea!

• utf8-convert

V , 28 (¿o 16?) Latín 1 bytes (35 UTF-8 bytes)

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

Pruébalo en línea!

Hexdump (en latín 1):

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

Salida (representación binaria del mismo código en UTF-8, no en latín 1):

110000111011000111000011101010011100001110010001011111100010001001110001011100000111100000100001001000010111100001111000011001000010000000101101011000100000110111000011100011100110010001010111001101010011010001111100010001000000110111000011100011011100001110011111110000111011001100001010

Explicación:

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

O...

V , 16 bytes

ñéÑ~"qpx!!xxd -b

Pruébalo en línea!

Salida:

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

La salida puede estar en cualquier formato conveniente.

Esto sale en un formato mucho más conveniente para V: P (pero no estoy seguro de si eso está estirando las reglas)

CJam , 20 bytes

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

Pruébalo en línea!

¡Sorprendido de ver ganar a CJam! _{veremos cuánto dura eso ...}

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 no tiene funciones integradas de conversión UTF-8, así que tengo que hacer todo manualmente .

Pruébelo en línea o verifique que sea una quine .

Explicación:

quine -parte:

La quine más corta para 05AB1E es esta: 0"D34çý"D34çý( 14 bytes ) proporcionada por @OliverNi . Mi respuesta utiliza una versión modificada de ese quine añadiendo al ...aquí: 0"D34çý..."D34çý.... Una breve explicación de esta 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)

Parte del desafío:

Ahora para el desafío parte del código. Como mencioné en la parte superior, 05AB1E no tiene incorporadas conversiones UTF-8, por lo que tengo que hacer estas cosas manualmente. He usado esta fuente como referencia sobre cómo hacer eso: convertir manualmente puntos de código unicode en UTF-8 y UTF-16 . Aquí un breve resumen de eso con respecto a la conversión de caracteres Unicode a UTF-8:

1. Convierta los caracteres unicode a sus valores unicode (es decir, se "dЖ丽"convierte en [100,1046,20029])
2. Convierta estos valores unicode a binario (es decir, se [100,1046,20029]convierte ["1100100","10000010110","100111000111101"])
3. Compruebe en cuál de los siguientes rangos están los caracteres:
   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

También hay rangos para 5 o 6 bytes, pero dejémoslos fuera por ahora.

El personaje destará en el primer rango, por lo que 1 byte en UTF-8; el carácter Жestá en el segundo rango, entonces 2 bytes en UTF-8; y el carácter 丽está en el tercer rango, por lo que 3 bytes en UTF-8.

En xel patrón detrás de él se rellenan los binarios de estos caracteres, de derecha a izquierda. Entonces el d( 1100100) con patrón se 0xxxxxxxconvierte en 01100100; el Ж( 10000010110) con patrón se 110xxxxx 10xxxxxxconvierte en 11010000 10010110; y el 丽( 100111000111101) con el patrón 1110xxxx 10xxxxxx 10xxxxxxse convierte 1110x100 10111000 10111101, después de lo cual los restantes xse sustituyen con 0: 11100100 10111000 10111101.

Entonces, ese enfoque también lo usé en mi código. xSin embargo, en lugar de verificar los rangos reales, solo miro la longitud del binario y lo comparo con la cantidad de patrones, ya que eso ahorra algunos 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
        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)

Ver este 05AB1E respuesta mío (secciones cómo comprimir grandes números enteros? Y ¿Cómo listas de números enteros comprimir? ) Para entender por qué •Xó•18вes [1,8,12,17].

JavaScript (Node.js) , 60 bytes

-15 bytes de @Neil y @Shaggy

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

Pruébalo en línea!

Óxido , 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);}

Pruébalo en línea!

Perl 6 , 46 bytes

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

Pruébalo en línea!

La línea estándar con .fmt("%08b",'')formatos de la lista de valores ordinales en binario de longitud 8 y se une con una cadena vacía.

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 gracias a @NahuelFouilleul eliminando lo innecesario &255(y un -35 adicional por llamar mi atención sobre que las especificaciones completas del programa del desafío habían sido revocadas y ahora también se permite una función ...)
-41 bytes gracias a @ OlivierGrégoire .

Pruébalo en línea.

Explicación:

quine -parte:

• var s contiene el código fuente sin formato String
• %s se usa para poner esta cadena en sí misma con s.format(...)
• %c, %1$cy 34se utilizan para formatear las comillas dobles ( ")
• s.format(s,34,s) lo pone todo junto

Parte del desafío:

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 _

Pruébalo en línea!

Una modificación de esta respuesta

-1 bytes eliminando el espacio después de 'in' (gracias @mdahmoune)

R , 138114 bytes

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

Pruébalo en línea!

Utiliza la capacidad de R para dispersar funciones a su representación de personaje. Los revs son necesarios porque rawToBitspone el bit menos significativo primero. as.integeres necesario porque de lo contrario los bits se muestran con un cero a la izquierda.

Editado una vez que me di cuenta de que se permitía cualquier salida conveniente. También estaba fuera por uno en el recuento de bytes original.

C # (compilador interactivo de Visual C #) , 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'))));

Pruébalo en línea!

C # (compilador interactivo de Visual C #) con indicador /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'))));

Pruébalo en línea!

Bash + herramientas GNU, 48 bytes

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

TIO