Khi chơi gôn, sẽ có lúc bạn cần Hex Dump của mã, thường là do bạn đã sử dụng các ký tự không thể in được. Vì vậy, tại sao không thực hiện một chương trình mà Hex Dumps chính nó?

Các thách thức

Thách thức này là, không có đầu vào, đưa ra kết xuất Hex của mã nguồn theo định dạng sau:

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

Hoặc, ví dụ, nếu chương trình của bạn là 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)

Cụ thể

Kết xuất hex được chia thành các hàng gồm ba phần, mỗi hàng đại diện cho 16 byte mã nguồn của bạn.

Phần đầu tiên là địa chỉ bộ nhớ. Nó chỉ định nơi hàng hiện tại bắt đầu trong mã của bạn. Được viết dưới dạng số thập lục phân 2 Byte, theo sau là a :, sau đó là khoảng trắng.

Thứ hai, là chính Hex Dump. Đây là 16 byte Mã nguồn của bạn, được viết ở dạng thập lục phân cách nhau bởi khoảng trắng. Đây phải là một biểu diễn byte chính xác bằng cách sử dụng mã hóa mã của bạn.

Cuối cùng, sau một khoảng cách hai không gian, là chính mã. Đây chỉ đơn giản là 16 ký tự mã của bạn, với các ký tự Không in được viết dưới dạng.

Ghi chú

• Đây là một thách thức về quine , vì vậy Quy tắc tiêu chuẩn được áp dụng.
• Và đây cũng là một thử thách chơi gôn , vì vậy, lỗ hổng tiêu chuẩn được áp dụng.
• Như trong ví dụ thứ hai, không viết byte sau EOF, thay vào đó hãy sử dụng khoảng trắng.
• Trailing khoảng trắng là tốt.
• Inbuilts to Hex dump, nếu bạn tình cờ có một định dạng cụ thể này, không bị cấm nhưng được tán thành.
• Các ký tự không in được đề cập đến bất kỳ ký tự nào, được biểu thị dưới dạng một byte đơn, không thể được biểu diễn dưới dạng một glyph cách nhau. Đối với UTF-8, điều này có nghĩa là 0-31, 128-255. Đối với Jelly Codepage , vì tất cả các ký tự có thể được biểu diễn dưới dạng glyph cách đều nhau, không có ký tự Không in được.

V , 39 byte

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

Hãy thử trực tuyến!

Lưu ý rằng thông thường V sử dụng mã hóa latin1, trong đó đây là 36 byte (đó là những gì TIO nói) nhưng bài nộp này đang sử dụng UTF-8 với 39 byte.

Đây là khá nhiều chỉ là một sửa đổi của mẫu V-quine tôi đã viết về.

Perl, 81 byte

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

Đếm số shebang là một. Có độ dài mã là bội số của 16 tiết kiệm khá nhiều về định dạng. Sử dụng evalđể gán lại $_cho chính nó mượn từ ais523 .

Đầu ra:

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

Hãy thử trực tuyến!

Perl + xxd + cut, 61 byte

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

Hãy thử trực tuyến!

Đây là một hàm tạo quine phổ quát trong Perl + một lệnh gọi xxdvà cutthực hiện hexdumping. Không có chương trình nào trong câu hỏi có phần dựng sẵn để thực hiện hexdump theo định dạng trong câu hỏi; tuy nhiên, xxd -g1rất gần và vì vậy có thể sử dụng cutđể cắt đầu ra thành hình dạng chính xác.

Hàm tạo quine phổ quát là $_=q("\$_=q($_);eval");eval, tạo ra một bản sao của mã nguồn của chính nó trong bộ nhớ và có thể được sửa đổi để thực hiện các hoạt động tùy ý trên nó. Trong trường hợp này, tôi sử dụng open "|"và printchuyển đầu vào vào các chương trình bên ngoài, xxdphần lớn công việc hexdumping và cutthay đổi nó thành định dạng cần thiết.

JavaScript (ES6) 229 219 162 byte

Cảm ơn @Neil vì đã tiết kiệm rất nhiều byte

Ghi chú

Khá nhiều người nghĩ rằng việc truy cập mã nguồn của một chức năng theo cách tôi làm là gian lận, nhưng theo @Dennis, nó ổn. Như vậy, tôi sẽ để lại câu trả lời của tôi ở đây.

Mã

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`

Sử dụng

f()

Đơn giản chỉ cần gọi hàm không có đối số.

Đầu ra

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

Không có dấu vết dòng mới.

Cảm ơn primo cho ý tưởng sắp xếp theo ranh giới 16 byte.

Đầu ra

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