Durante il gioco del codice ci saranno momenti in cui hai bisogno di un dump esadecimale del tuo codice, di solito perché hai usato caratteri non stampabili. Quindi, perché non creare un programma che Hex Dumps stesso?

La sfida

Questa sfida è, dato nessun input, produrre un dump esadecimale del codice sorgente nella seguente formattazione:

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, ad esempio, se il tuo programma lo era 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)

specifiche

Il dump esadecimale è suddiviso in righe di tre parti, ciascuna delle quali rappresenta 16 byte del codice sorgente.

La prima parte è l'indirizzo di memoria. Specifica dove inizia la riga corrente nel codice. Scritto come un numero esadecimale di 2 byte, seguito da un :, quindi da uno spazio.

Il secondo, è lo stesso Hex Dump. Sono 16 byte del codice sorgente, scritti in forma esadecimale separati da spazi. Questa dovrebbe essere una rappresentazione in byte accurata usando la codifica del codice.

Infine, dopo uno spazio vuoto di due, è il codice stesso. Questo è semplicemente 16 caratteri del tuo codice, con caratteri non stampabili scritti come.

Appunti

• Questo è un Quine sfida, quindi Regole Quine standard si applicano.
• E questa è anche una sfida al golf del codice , quindi si applicano le scappatoie standard .
• Come mostrato nel secondo esempio, non scrivere byte dopo EOF, utilizzare invece gli spazi bianchi.
• Lo spazio bianco finale va bene.
• Gli incorporati alla discarica esadecimale, se ti capita di averne uno in questo formato specifico, non sono vietati ma sono disapprovati.
• I caratteri non stampabili si riferiscono a qualsiasi carattere che, rappresentato come un solo byte, non può essere rappresentato come un glifo a spaziatura singola. Per UTF-8, questo mezzo 0-31, 128-255. Per la Jelly Codepage , poiché tutti i personaggi possono essere rappresentati come un glifo a spaziatura singola, non ci sono caratteri non stampabili.

V , 39 byte

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

Provalo online!

Si noti che normalmente V utilizza la codifica latin1, dove sono 36 byte (che è ciò che dice TIO) ma questa presentazione utilizza UTF-8 dove è 39 byte.

Questo è praticamente solo una modifica di V-quine di cui ho scritto.

Perl, 81 byte

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

Contando lo shebang come uno. Se la lunghezza del codice è un multiplo di 16 si risparmia parecchio sulla formattazione. Usando evalper riassegnare $_a se stesso preso in prestito da ais523 .

Produzione:

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

Provalo online!

Perl + xxd + cut, 61 byte

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

Provalo online!

Questo è un costruttore di quine universale in Perl + una chiamata a xxde cutper fare il dump esadecimale. Nessuno dei programmi in questione ha un builtin per fare un hexdump nel formato nella domanda; tuttavia, si xxd -g1avvicina molto ed è quindi possibile utilizzarlocut per tagliare l'output nella forma corretta.

Il costruttore di quine universale è $_=q("\$_=q($_);eval");eval, che crea una copia del proprio codice sorgente in memoria e può essere modificato per eseguire operazioni arbitrarie su di esso. In questo caso, utilizzo open "|"e convoglio printl'input in programmi esterni, il xxdche fa la maggior parte del lavoro di hexdumping e cutche lo cambia nel formato richiesto.

JavaScript (ES6) 229 219 162 byte

Grazie a @Neil per aver salvato molti byte

Nota

Molte persone pensano che accedere al codice sorgente di una funzione nel modo in cui lo faccio sia barare, ma secondo @Dennis, va bene. Come tale, lascerò la mia risposta qui.

Codice

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()

Basta chiamare la funzione senza argomenti.

Produzione

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`                                     

Rubino, 128 112 byte

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}'

Senza trascinare newline.

Grazie primo per l'idea di allinearsi al limite di 16 byte.

Produzione

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}'