Al jugar golf con códigos, habrá momentos en los que necesitará un volcado hexadecimal de su código, generalmente porque ha utilizado caracteres no imprimibles. Entonces, ¿por qué no hacer un programa que Hex Dumps mismo?

El reto

Este desafío es, sin entrada, generar un volcado hexadecimal de su código fuente en el siguiente formato:

0000: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0010: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0020: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................
0030: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00  ................

O, por ejemplo, si su programa fue print("SomeString"):rep(123)

0000: 70 72 69 6e 74 28 5c 22 53 6f 6d 65 53 74 72 69  print("SomeStrin
0010: 6e 67 5c 22 29 3a 72 65 70 28 31 32 33 29        g"):rep(123)

Detalles específicos

El volcado hexadecimal se divide en filas de tres partes, cada fila representa 16 bytes de su código fuente.

La primera parte es la dirección de memoria. Especifica dónde comienza la fila actual en su código. Escrito como un número hexadecimal de 2 bytes, seguido de un :, luego un espacio.

El segundo, es el volcado hexadecimal en sí. Esto es 16 bytes de su código fuente, escrito en forma hexadecimal separados por espacios. Esto debería ser una representación de bytes precisa utilizando la codificación de su código.

Por último, después de un espacio de dos espacios, es el código en sí. Esto es simplemente 16 caracteres de su código, con caracteres no imprimibles escritos como.

Notas

• Este es un desafío de quine , por lo que se aplican las reglas estándar de quine .
• Y este también es un desafío de código de golf , por lo que se aplican las lagunas estándar .
• Como se muestra en el segundo ejemplo, no escriba bytes después de EOF, en su lugar use espacios en blanco.
• El espacio en blanco al final está bien.
• Las incorporaciones al volcado hexadecimal, si tiene una en este formato específico, no están prohibidas, pero están mal vistas.
• Los caracteres no imprimibles se refieren a cualquier carácter que, representado como un solo byte, no puede representarse como un glifo espaciado único. Para UTF-8, significa esto 0-31, 128-255. Para la página de códigos Jelly , como todos los caracteres se pueden representar como un glifo espaciado, no hay caracteres no imprimibles.

V , 39 bytes

ñi241"qp:%!xxd
Î4x
Íøø / &
f&3i ÿ

Pruébalo en línea!

Tenga en cuenta que normalmente V usa la codificación latin1, donde esto es 36 bytes (que es lo que dice TIO), pero este envío usa UTF-8 donde tiene 39 bytes.

Esto es prácticamente solo una modificación de la plantilla V-quine sobre la que escribí.

Perl, 81 bytes

#!perl -l
$_=q($%+=print"00$%0: @{[unpack'(H2)*']}  $_"for"\$_=q($_);eval"=~/.{16}/g);eval

Contando el shebang como uno. Tener la longitud del código en múltiplo de 16 ahorra bastante en el formateo. Utilizando evalpara reasignarse $_a sí mismo prestado de ais523 .

Salida:

0000: 24 5f 3d 71 28 24 25 2b 3d 70 72 69 6e 74 22 30  $_=q($%+=print"0
0010: 30 24 25 30 3a 20 40 7b 5b 75 6e 70 61 63 6b 27  0$%0: @{[unpack'
0020: 28 48 32 29 2a 27 5d 7d 20 20 24 5f 22 66 6f 72  (H2)*']}  $_"for
0030: 22 5c 24 5f 3d 71 28 24 5f 29 3b 65 76 61 6c 22  "\$_=q($_);eval"
0040: 3d 7e 2f 2e 7b 31 36 7d 2f 67 29 3b 65 76 61 6c  =~/.{16}/g);eval

Pruébalo en línea!

Perl + xxd + corte, 61 bytes

$_=q(open F,"|xxd -g1|cut -c5-";print F"\$_=q($_);eval");eval

Pruébalo en línea!

Este es un constructor universal de quine en Perl + una llamada a xxdy cutpara hacer el hexdumping. Ninguno de los programas en cuestión tiene una función para hacer un hexdump en el formato de la pregunta; sin embargo, se xxd -g1acerca mucho, por lo que es posible usarlo cutpara recortar la salida en la forma correcta.

El constructor universal de quine es $_=q("\$_=q($_);eval");eval, que crea una copia de su propio código fuente en la memoria, y puede modificarse para realizar operaciones arbitrarias en él. En este caso, utilizo open "|"y printcanalizo la entrada a programas externos, lo xxdque hace la mayor parte del trabajo hexdumping y cutlo cambia al formato requerido.

JavaScript (ES6) 229 219 162 bytes

Gracias a @Neil por guardar muchos bytes

Nota

Muchas personas piensan que acceder al código fuente de una función de la forma en que lo hago es hacer trampa, pero según @Dennis, está bien. Como tal, dejaré mi respuesta aquí.

Código

f=_=>([...c=`f=`+f].map(d=>d.charCodeAt()[t=`toString`](16)).join‌​` `+` `.repeat(46)).match(/.{48}/g).map((s,i)=>`00${i[t](16)}0: `+s+c.substr(i*16,16)).join`\n`

Uso

f()

Simplemente llame a la función sin argumentos.

Salida

0000: 66 3d 5f 3d 3e 28 5b 2e 2e 2e 63 3d 60 66 3d 60 f=_=>([...c=`f=`
0010: 2b 66 5d 2e 6d 61 70 28 63 3d 3e 63 2e 63 68 61 +f].map(c=>c.cha
0020: 72 43 6f 64 65 41 74 28 29 5b 74 3d 60 74 6f 53 rCodeAt()[t=`toS
0030: 74 72 69 6e 67 60 5d 28 31 36 29 29 2e 6a 6f 69 tring`](16)).joi
0040: 6e 60 20 60 2b 60 20 60 2e 72 65 70 65 61 74 28 n` `+` `.repeat(
0050: 34 36 29 29 2e 6d 61 74 63 68 28 2f 2e 7b 34 38 46)).match(/.{48
0060: 7d 2f 67 29 2e 6d 61 70 28 28 73 2c 69 29 3d 3e }/g).map((s,i)=>
0070: 60 30 30 24 7b 69 5b 74 5d 28 31 36 29 7d 30 3a `00${i[t](16)}0:
0080: 20 60 2b 73 2b 63 2e 73 75 62 73 74 72 28 69 2a  `+s+c.substr(i*
0090: 31 36 2c 31 36 29 29 2e 6a 6f 69 6e 60 5c 6e 60 16,16)).join`\n`                                     

Ruby, 128 112 bytes

eval b='7.times{|y|$><<"%04x:"%y*=16;c=("eval b="+(a=39.chr)+b+a)[y,16];c.chars{|x|$><<" %x"%x.ord};puts"  "+c}'

Sin rastro de nueva línea.

Gracias primo por la idea de alinear con el límite de 16 bytes.

Salida

0000: 65 76 61 6c 20 62 3d 27 37 2e 74 69 6d 65 73 7b  eval b='7.times{
0010: 7c 79 7c 24 3e 3c 3c 22 25 30 34 78 3a 22 25 79  |y|$><<"%04x:"%y
0020: 2a 3d 31 36 3b 63 3d 28 22 65 76 61 6c 20 62 3d  *=16;c=("eval b=
0030: 22 2b 28 61 3d 33 39 2e 63 68 72 29 2b 62 2b 61  "+(a=39.chr)+b+a
0040: 29 5b 79 2c 31 36 5d 3b 63 2e 63 68 61 72 73 7b  )[y,16];c.chars{
0050: 7c 78 7c 24 3e 3c 3c 22 20 25 78 22 25 78 2e 6f  |x|$><<" %x"%x.o
0060: 72 64 7d 3b 70 75 74 73 22 20 20 22 2b 63 7d 27  rd};puts"  "+c}'