Podczas gry w golfa będziesz potrzebować zrzutu heksadecymalnego kodu, zwykle dlatego, że używałeś znaków niedrukowalnych. Dlaczego więc nie stworzyć programu, który sam Hex Zrzuca?

Wyzwanie

Wyzwanie polega na tym, aby bez danych wejściowych wyprowadzić zrzut heksadecymalny kodu źródłowego w następującym formacie:

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

Lub, na przykład, jeśli twój program był 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)

Specyfika

Zrzut heksadecymalny jest podzielony na wiersze po trzy części, z których każdy reprezentuje 16 bajtów kodu źródłowego.

Pierwsza część to adres pamięci. Określa, gdzie zaczyna się bieżący wiersz w kodzie. Zapisany jako 2-bajtowa liczba szesnastkowa, po której następuje :spacja.

Drugi to sam Hex Dump. Jest to 16 bajtów kodu źródłowego, zapisanych w formie szesnastkowej, oddzielonych spacjami. Powinna to być dokładna reprezentacja bajtów z wykorzystaniem kodowania twojego kodu.

Wreszcie, po dwóch odstępach, sam kod. Jest to po prostu 16 znaków kodu, a znaki niedrukowalne zapisane jako.

Notatki

• To jest Quine wyzwanie, więc standardowe Zasady Quine zastosowania.
• Jest to również wyzwanie dla golfa , dlatego obowiązują standardowe luki .
• Jak pokazano w drugim przykładzie, nie zapisuj bajtów po EOF, zamiast tego użyj białych znaków.
• Końcowe białe znaki są w porządku.
• Wbudowane w zrzut heksowy, jeśli zdarzy się, że masz taki w tym konkretnym formacie, nie są zbanowane, ale są rozczarowane.
• Znaki niedrukowalne odnoszą się do każdego znaku, który reprezentowany jako pojedynczy bajt, nie może być reprezentowany jako pojedynczy glif z odstępami. UTF-8, oznacza 0-31, 128-255. W przypadku strony kodowej Jelly , ponieważ wszystkie znaki mogą być reprezentowane jako pojedynczy glif, odstępy między znakami nie występują.

V , 39 bajtów

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

Wypróbuj online!

Zauważ, że normalnie V używa kodowania Latin1, gdzie jest to 36 bajtów (tak mówi TIO), ale to przesłanie używa UTF-8, gdzie jest 39 bajtów.

To właściwie modyfikacja szablonu V-quine , o którym pisałem.

Perl, 81 bajtów

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

Licząc shebang jako jeden. Mając długość kodu będącą wielokrotnością 16, oszczędza się sporo na formatowaniu. Używanie evaldo zmiany przypisania $_do siebie zapożyczone z ais523 .

Wynik:

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

Wypróbuj online!

Perl + xxd + cięcie, 61 bajtów

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

Wypróbuj online!

Jest to uniwersalny konstruktor quine w Perlu + wywołanie xxdi cutwykonanie zrzutu heksadecymalnego. Żaden z omawianych programów nie ma wbudowanego narzędzia do wykonania zrzutu heksadecymalnego w formacie podanym w pytaniu; jest jednak xxd -g1bardzo blisko i dlatego można go używaćcut do przycięcia wyjścia do właściwego kształtu.

Jest to uniwersalny konstruktor quine $_=q("\$_=q($_);eval");eval, który tworzy kopię własnego kodu źródłowego w pamięci i może być modyfikowany w celu wykonywania na nim dowolnych operacji. W tym przypadku używam open "|"iprintxxd przesyłam dane wejściowe do zewnętrznych programów, które wykonują większość operacji heksdumpingowych i cutzmieniają je w wymagany format.

JavaScript (ES6) 229 219 162 bajtów

Dzięki @Neil za zaoszczędzenie wielu bajtów

Uwaga

Sporo osób uważa, że ​​dostęp do kodu źródłowego funkcji w ten sposób, w jaki to robię, jest oszustwem, ale według @Dennis jest w porządku. Dlatego zostawię tutaj swoją odpowiedź.

Kod

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`

Stosowanie

f()

Wystarczy wywołać funkcję bez argumentów.

Wynik

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`                                     

Rubin, 128 112 bajtów

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

Bez końcowego znaku nowej linii.

Dzięki primo za pomysł wyrównania do granicy 16 bajtów.

Wynik

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