Ketika bermain golf kode akan ada saat-saat di mana Anda memerlukan Hex Dump dari kode Anda, biasanya karena Anda telah menggunakan karakter yang tidak diinginkan. Jadi, mengapa tidak membuat program yang Hex Dumps sendiri?

Tantangan

Tantangan ini adalah, tanpa input, mengeluarkan Hex Dump kode sumber Anda dalam pemformatan berikut:

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  ................

Atau, misalnya, jika program Anda 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)

Spesifik

Dump hex dibagi menjadi baris tiga bagian, setiap baris mewakili 16 byte kode sumber Anda.

Bagian pertama adalah alamat memori. Ini menentukan di mana baris saat ini dimulai dalam kode Anda. Ditulis sebagai angka Byte 2 Heksadesimal, diikuti oleh :, lalu spasi.

Yang Kedua, adalah Hex Dump itu sendiri. Ini adalah 16 byte Kode Sumber Anda, ditulis dalam bentuk Heksadesimal yang dipisahkan oleh spasi. Ini harus merupakan representasi byte yang akurat menggunakan pengkodean kode Anda.

Terakhir, setelah celah dua ruang, adalah kode itu sendiri. Ini hanya 16 karakter kode Anda, dengan karakter yang tidak dapat dicetak ditulis sebagai.

Catatan

• Ini adalah sebuah Quine tantangan, sehingga Standard Quine Aturan berlaku.
• Dan ini adalah tantangan kode-golf juga, jadi Standard Loopholes berlaku.
• Seperti yang ditunjukkan pada contoh kedua, jangan menulis byte setelah EOF, alih-alih gunakan spasi putih.
• Trailing whitespace baik-baik saja.
• Inbuilt ke Hex dump, jika Anda memilikinya dalam format spesifik ini, tidak dilarang tetapi disukai.
• Karakter yang tidak dapat dicetak mengacu pada karakter apa pun yang, yang direpresentasikan sebagai hanya satu byte, tidak dapat direpresentasikan sebagai mesin terbang spasi tunggal. Untuk UTF-8, ini berarti 0-31, 128-255. Untuk Jelly Codepage , karena semua karakter dapat direpresentasikan sebagai mesin terbang spasi tunggal, tidak ada karakter yang tidak dapat dicetak.

V , 39 byte

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

Cobalah online!

Perhatikan bahwa biasanya V menggunakan pengkodean latin1, di mana ini adalah 36 byte (yang merupakan apa yang dikatakan TIO) tetapi pengiriman ini menggunakan UTF-8 di mana 39 byte.

Ini cukup banyak hanya modifikasi dari template V-quine yang saya tulis.

Perl, 81 byte

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

Menghitung shebang sebagai satu. Memiliki panjang kode menjadi kelipatan 16 menghemat cukup banyak pada pemformatan. Menggunakan evaluntuk menetapkan ulang $_untuk dirinya sendiri dipinjam dari ais523 .

Keluaran:

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

Cobalah online!

Perl + xxd + cut, 61 byte

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

Cobalah online!

Ini adalah konstruktor quine universal di Perl + panggilan ke xxddan cutuntuk melakukan hexdumping. Tak satu pun dari program yang dimaksud memiliki builtin untuk melakukan hexdump dalam format dalam pertanyaan; Namun, xxd -g1sangat dekat dan jadi mungkin digunakan cutuntuk memotong output ke bentuk yang benar.

Konstruktor quine universal adalah $_=q("\$_=q($_);eval");eval, yang membuat salinan kode sumbernya sendiri dalam memori, dan dapat dimodifikasi untuk melakukan operasi sewenang-wenang di dalamnya. Dalam hal ini, saya menggunakan open "|"dan printmenyalurkan input ke program eksternal, xxdyang melakukan sebagian besar pekerjaan hexdumping dan cutyang mengubahnya ke dalam format yang diperlukan.

JavaScript (ES6) 229 219 162 byte

Terima kasih kepada @Neil untuk menghemat banyak byte

Catatan

Cukup banyak orang berpikir bahwa mengakses kode sumber suatu fungsi sama dengan cara saya melakukannya, tetapi menurut @ Dennis, tidak masalah. Karena itu, saya akan meninggalkan jawaban saya di sini.

Kode

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`

Pemakaian

f()

Cukup panggil fungsi tanpa argumen.

Keluaran

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

Tanpa membuntuti baris baru.

Terima kasih untuk ide menyelaraskan ke batas 16-byte.

Keluaran

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