Wiadomość Arecibo to międzygwiezdna wiadomość radiowa z 1974 r., Niosąca podstawowe informacje o ludzkości i Ziemi, wysłana do gromady gwiazd M13 w nadziei, że inteligencja pozaziemska może ją odebrać i odszyfrować ... Wiadomość składała się z 1679 cyfr dwójkowych, około 210 bajtów ...

Liczba 1679 została wybrana, ponieważ jest to półpierwsza (iloczyn dwóch liczb pierwszych), która ma być ułożona prostokątnie jako 73 rzędy przez 23 kolumny. Alternatywne ustawienie, 23 wiersze po 73 kolumny, tworzy niezrozumiały zestaw znaków (podobnie jak wszystkie inne formaty X / Y).

To jest wiadomość z dodanym kolorem, aby wyróżnić poszczególne części. Rzeczywista transmisja binarna nie zawierała informacji o kolorze.

Źródło: Wikipedia

Twoim zadaniem jest wyprowadzenie komunikatu Arecibo w dokładnie takim układzie 23x73, jak pokazano na obrazku. Każdy z tych formatów wyjściowych jest dopuszczalny:

• Tekst, używając jednego znaku dla jednych, a drugiego dla zer (przy użyciu zwykłych reguł rozdzielania wierszy)
• Tablica 2D dwóch różnych wartości
• Obraz 23x73 z dwoma wyraźnymi kolorami
• A nieprzerwany strumień 1679 pozycji o dwóch różnych wartościach (tj. Dowolnym z powyższych formatów, ale płaski).
• 1679-bitowa liczba całkowita. Wskaż kolejność bitów i bajtów (endianness) w swoim rozwiązaniu.

Dla Twojej wygody, oto wersja do wklejenia (również przykładowy wynik w formacie tekstowym):

00000010101010000000000
00101000001010000000100
10001000100010010110010
10101010101010100100100
00000000000000000000000
00000000000011000000000
00000000001101000000000
00000000001101000000000
00000000010101000000000
00000000011111000000000
00000000000000000000000
11000011100011000011000
10000000000000110010000
11010001100011000011010
11111011111011111011111
00000000000000000000000
00010000000000000000010
00000000000000000000000
00001000000000000000001
11111000000000000011111
00000000000000000000000
11000011000011100011000
10000000100000000010000
11010000110001110011010
11111011111011111011111
00000000000000000000000
00010000001100000000010
00000000001100000000000
00001000001100000000001
11111000001100000011111
00000000001100000000000
00100000000100000000100
00010000001100000001000
00001100001100000010000
00000011000100001100000
00000000001100110000000
00000011000100001100000
00001100001100000010000
00010000001000000001000
00100000001100000000100
01000000001100000000100
01000000000100000001000
00100000001000000010000
00010000000000001100000
00001100000000110000000
00100011101011000000000
00100000001000000000000
00100000111110000000000
00100001011101001011011
00000010011100100111111
10111000011100000110111
00000000010100000111011
00100000010100000111111
00100000010100000110000
00100000110110000000000
00000000000000000000000
00111000001000000000000
00111010100010101010101
00111000000000101010100
00000000000000101000000
00000000111110000000000
00000011111111100000000
00001110000000111000000
00011000000000001100000
00110100000000010110000
01100110000000110011000
01000101000001010001000
01000100100010010001000
00000100010100010000000
00000100001000010000000
00000100000000010000000
00000001001010000000000
01111001111101001111000

Jeśli z jakiegoś powodu Twój język ma wbudowane narzędzie do wiadomości Arecibo, nie możesz go używać.

Powodzenia!

AKTUALIZACJA: Zaakceptowałem odpowiedź 05AB1E, ponieważ jako pierwsza była krótsza niż oryginalna wiadomość. Nie pozwól, aby zniechęciło Cię to do nowych rozwiązań.

AKTUALIZACJA 2019-09-09: Zaakceptowana odpowiedź została przeniesiona do nowej odpowiedzi 05AB1E, ponieważ zastępuje poprzednią odpowiedź 05AB1E. Ten sam punkt dotyczy poprzedniej aktualizacji; nowe rozwiązania wciąż mile widziane.

05AB1E , 182 bajty

•sv¯ö¨₁ÿ.ÛïžôΔ¨γ_Ígv…=Bм„Ð.(ܦi´…ε±G½0^/₃öRÛž¼¤"āêL!ˆ6‘Gā܇ðв₁÷Ã7€₂䬂Cć¨g¾†@÷[_-68¯a∍iG*6ÆîÆ;>éjζãÎÂ+ºžnî¼ć'(ÝÞΔ‹∞ÉݹÕ5λ₆*a|§oÄmôæ¨;—:hž¥ð¢ocË'¨%¡4Ćáß©ìća;FÁ?iˆèεƒʒ•Ž6–FD4‰`3ÊD?i-

Wypróbuj online! (używa 1dla 0 i 0dla 1, zgodnie z pytaniem).

Wypróbuj online! (5 bajtów dłużej, 0dla 0 i 1dla 1, dodano nowe wiersze dla czytelności).

Większość kodu to podstawowa stała N liczby całkowitej 255, reszta to dekoder asymetrycznego systemu liczbowego , wykorzystujący zakodowane prawdopodobieństwo 75% / 25% (rzeczywista częstotliwość 0 wynosi 76,35%, co jest tak bliskie 75%, że to zaoszczędziłoby tylko 1,2 bitu w ładunku, podczas gdy ładne i okrągłe 75% pozwala nam zaoszczędzić kilka bajtów w dekoderze).

Ž6–F                  # repeat the following 1679 times:
    D                 #  duplicate N
     4‰`              #  divmod 4: pushes N / 4, N % 4 on the stack
        3Ê            #  is N % 4 != 3 ? (boolean 1 or 0)
          D?          #  print a copy
            i-        #  if it's 1, subtract: N = N - (N / 4)
                      #  (otherwise, N = N / 4, since that's the top of the stack)

Oto koder ANS, który wygenerował stałą: Wypróbuj online!

Î                          # start from N = 0
 Rv         ]              # for each bit in the reversed input:
   4*                      #  N *= 4
     yi                    #  if the bit is 1:
       3+                  #   N += 3
         ë                 #  else:
          3÷               #   N /= 3 (integer division)
             ₅B'•.ø        # compress N as base-255

05AB1E , 215 210 200 bajtów

Zaoszczędzono 15 bajtów dzięki Magic Octopus Urn

•cOž¤4é57ñΛ\Ö₃BαöĀíL½₅üBdoÙRθLγ¨G×Tćú$G(˜ƒ¦!€R»SDrµCnJ†d∊ζ·<8‡T@|‹ï=BζćósxG\ÙÎ$¿o₁5/ÔŸÇBûXé-”a::Ž]°∊y;ζ]MÜβ‘иL”β{üÃÇíäc€÷›ÎU=}¨иaŸdY`»¾ÚUβ:ô©¦β†₅DGŠβ3Jêθ,äá!ícqšVÖ›lÈΣ¯pε €êʃDpÙ/¬Žλ8:ãÿ3=€.Þć•3BY¾4×:

Wypróbuj online! lub z dodatkowym formatowaniem

Base-255 zakodowany ciąg znaków trynowych z wystąpieniami 0000zastąpionymi przez 2.

Java, 688 678 590 379 361 bajtów

Zwraca ciąg.

n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replace("2","0000")

-10 bajtów, zwracając nieprzetworzony strumień (stara odpowiedź)
-88 bajtów, używając liczb podstawowych 10 (dzięki @ceilingcat!)
-211 bajtów (wiedziałem, że można grać w golfa!), Używając zakodowanego w bazie 36 BigInteger (dzięki @JollyJoker !)
-18 bajtów przy użyciu innej zakodowanej liczby całkowitej (dzięki jeszcze raz @JollyJoker)

Wypróbuj online!

Wyjaśnienie:

n->new java.math.BigInteger("base36 string",36) // Decode the base-36 integer.
   .toString(3)                                 // Re-encode as ternary
   .replace("2","0000")                         // Replace 2 with "0000"
                                                // Implicit return

Galaretka , 213 bajtów

“H²ɓ¶Ṡḷ€ẹ]ƒf*ḳḢ&ƁṇOḥ{ḄṫwỊ+oLạʋߢH9¢¹÷ỴɗÇ⁶ƲƙæḊẋ3³=1!VƇƁ'D⁺3Ỵɱ©⁵%fȯez#ƈjƒżṆo.ZF⁶ċṢ⁶ọṛb9Ȯƒd?ƁUĠt4ẇ,ḞġƒµƭfʠƁP§÷øȤŻPɲẋ(¢ß¢(⁽3¶ṙėɗy@ṁYȮL~e⁷ƤĊ§nỊṅµṠ°@7ẠB>Ġ⁻İ}uy¡½:esOpḢt}qS©HÞṬĖṛṇḣ9÷;ESḢ,Ẉ^ṙpƲ©tṃwçnẒṆ¡⁻Jıƒị£-&Ɱ*ẋʂżoȯÑḢɼ’

Wypróbuj online!

Bawiłem się kodowaniem Huffmana, ale poprawa rozmiaru danych została przeważona przez dodatkowy kod. Jako taka, jest to po prostu zakodowana wersja bazowa 250 pożądanego wyjścia. Dane wyjściowe składają się z liczb całkowitych, które po zdekodowaniu jako bijective base 2 dają listę 1D 1s i 2s. Dzięki @Emigna za zwrócenie uwagi na zmianę zasad.

Wypróbuj online - z dalszym dekodowaniem w celu zademonstrowania wyników!

Jeśli preferowane jest bardziej konwencjonalne kodowanie binarne, tutaj jest takie, które koduje całkowitą reprezentację odwróconej wiadomości binarnej. Najbardziej znaczący bit liczby całkowitej reprezentuje początek wiadomości.

Brainfuck, 2360 2008 1938 bajtów

-[>+<-----]>---......+.-.+.-.+.-.+.-............+.-.+.-.....+.-.+.-.......+.-.<++++[->.+.-..<]>+.-.+..-.<+++++++++[->.+.-<]>..+.-..+.-<++++++[->......<]>.+.<++[->.-...................+..-.+<]>.-..................+.-.+.-.+.-..................+.....-<++++++++[->....<]>+..-....+...-...+..-....+..-...+.-.............+..-..+.-....+..-.+.-...+..-...+..-....+..-.+<++++[->.-.+....<]>.-<+++++[->.....<]>.+.-.................+.-............................+.-.................+......-.............+.....-.......................+..-....+..-....+...-...+..-...+.-.......+.-.........+.-....+..-.+.-....+..-...+...-..+..-.+.-.+.....-.+.....-.+.....-.+.....-..........................+.-......+..-.........+.-...........+..-...............+.-.....+..-..........+......-.....+..-......+.....-..........+..-.....<+++[->........+.-<]>.....+.-......+..-.......+.-.......+..-....+..-......+.-..........+..-...+.-....+..-...............+..-..+..-.............+..-...+.-....+..-.........+..-....+..-......+.-.......+.-......+.-........+.-.....+.-<++[->.......+..-........+.-...+.-.<]>........+.-.......+.-<++++[->.....+.-..<]>..........+..-.........+..-........+..-.........+.-...+...-.+.-.+..-...........+.-.......+.-..............+.-.....+.....-............+.-....+.-.+...-.+.-..+.-.+..-.+..-......+.-..+...-..+.-..+.......-.+...-....+...-.....+..-.+...-.........+.-.+.-.....+...-.+..-..+.-......+.-.+.-.....+......-..+.-......+.-.+.-.....+..-......+.-.....+..-.+..-<+++++++[->.....<]>+...-.....+.-..............+...-.+.-.+.-..<++++++[->.+.-<]>..+...-.........+.-.+.-.+.-.+.-................+.-.+.-..............+.....-................+.........-............+...-.......+...-.<++[->........+..-...<]>....+..-.+.-.........+.-.+..-<++[->.....+..-..+..-..<]>..+.-...+.-.+.-.....+.-.+.-...+.-..<+++[->..+.-...+.-<]>........+.-...+.-.+.-...+.-............+.-....+.-.<++[->...+.-.........<]>+.-..............+.-..+.-.+.-...........+....-..+.....-.+.-..+....-...

Wypróbuj online!

Prawdopodobnie wkrótce zagram w golfa.

Deadfish ~ , 1115 1088 1084 bajtów

oooooo{i}ooo{d}iod{o}{i}c{d}ooiodoiodoooooiodoiodoooooooiodoo{i}c{ii}is{iiii}doooio{{{d}}}oioodooiodo{i}coooooooo{d}o{{i}}oo{{d}i}c{d}{oo}ooo{i}c{d}{o}ooioodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}{o}ioodoiodooooooooo{i}c{d}oooooooooiodoiodoiodooooooooo{i}c{d}oooooooooiooooodooooooooo{i}c{d}{oo}ooo{i}c{d}ioodooooiooodoooioodooooioodooo{i}c{d}iod{o}oooioodooiodoooo{i}c{d}ioodoiodoooioodoooioodooooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiod{o}oooooooiodo{i}c{d}{oo}ooo{i}c{d}ooooiod{o}oooooooiod{i}c{d}ioooood{o}oooioooood{i}c{d}{oo}ooo{i}c{d}ioodooooioodooooiooodoooioodooo{i}c{d}iodoooooooiodoooooooooiodoooo{i}c{d}ioodoiodooooioodoooiooodooioodoiodo{i}c{d}iooooodoiooooodoiooooodoioooood{i}c{d}{oo}ooo{i}c{d}oooiodooooooioodoooooooooiodo{i}c{d}{o}iood{o}o{i}c{d}ooooiodoooooiood{o}iod{i}c{d}iooooodoooooioodooooooioooood{i}c{d}{o}iood{o}o{i}c{d}ooiodooooooooiodooooooooiodoo{i}c{d}oooiodooooooioodoooooooiodooo{i}c{d}ooooioodooooioodooooooiodoooo{i}c{d}ooooooioodoooiodooooioodooooo{i}c{d}{o}ioodooioodooooooo{i}c{d}ooooooioodoooiodooooioodooooo

Wypróbuj online!

Jeśli ktoś ma cierpliwość do gry w golfa dalej, pozdrawiam cię z wyprzedzeniem. : P

-27 bajtów, drukując cyfry 10 i 100 w miejscach, w których ma to zastosowanie.
-4 bajty, drukując trzy 1000 i jeden 1001 w wierszu 3

Piet , 1763 kodeksów

Wysyła strumień zera i jedynki (bez podziałów linii).

Rozmiar kodu 1:

Rozmiar kodu 4, dla łatwiejszego oglądania:

Wyjaśnienie

• Najpierw pchnij wartownik na stos -1.
• Następnie wciśnij komunikat Arecibo w odwrotnej kolejności (ponieważ jest to stos), używając kodowania długości przebiegu.
• Na koniec naprzemiennie między dwiema pętlami, jedną drukującą zera i drugą drukującą.
  • Licznik pętli jest bieżącą wartością stosu, zmniejszaną aż do zera, w którym to momencie jest odrzucany i przełączamy się na drugą pętlę.
  • Pomiędzy pętlą zerową a pętlą jedyną sprawdź wartość wartownika, wychodząc, jeśli ją znaleziono.

Notatki

Program podąża ścieżką spiralną, zgodnie z ruchem wskazówek zegara, od lewego górnego rogu do środka. Rozproszone czarne bloki, które z grubsza podążają po przekątnych, są kontrolą przepływu. Oto ślad z NPiet .

Pracuję nad tym od dnia, w którym wyzwanie się zwiększyło, ale zajęło trochę czasu, aby napisać wiadomość na „obrazku”! Najpierw napisałem ostatnie pętle i wartość wartownika, a następnie zbudowałem wiadomość od środka na zewnątrz. (Ponieważ Piet zawsze zaczyna wykonywanie od lewego górnego rogu, spodziewałem się, że będę musiał tasować i obracać obraz, aby uniknąć nadmiaru białych znaków, ale pasuje idealnie!)

Ciekawostka: kodowanie długości w Piet (samo w sobie) nie oszczędza miejsca. Potrzeba n koderów jednego koloru, aby wypchnąć wartość n na stos, lub n koderów o różnych kolorach, aby wypchnąć tyle jedności na stos. Tak czy inaczej jest to ta sama liczba kodów. Ale większe liczby podane przez RLE oznaczają, że możesz używać sztuczek arytmetycznych (np. Zamiast pushowania 9, możesz pushować 3, powielać i mnożyć), aby zmniejszyć liczbę koderów i bloków o zabawnych kształtach, aby wypełnić dostępne białe znaki.

Nie byłam pewna, jak liczyć punkty za wpisy Piet. Znalazłem niektóre, które wydają się liczyć wszystkie kody, a inne, które jawnie liczą tylko te, które są aktywnie używane. Właśnie policzyłem ich wszystkich; ignorowanie białych kodów (nawet tych, przez które program nigdy się nie porusza) wydaje się podobne do ignorowania białych znaków w bardziej typowym języku programowania.

Aha, i właśnie teraz (dwie godziny po opublikowaniu) zdałem sobie sprawę, że straciłem ostatnią chwilę pracując nad tym. Chciałem przyciąć prawie całkowicie biały ostatni rząd i kolumnę, więc przetasowałem rzeczy ... w tym czarne bloki kontroli przepływu. Ale krawędzie obrazu działają tak samo jak czerń! Gdybym tylko to zapamiętał, nie musiałbym poświęcać tyle czasu na zastanawianie się nad zawiłościami DP i CC ...

C # (interaktywny kompilator Visual C #) , 366 332 329 319 bajtów

int i;foreach(var g in"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ")Write(Convert.ToString(g,2).PadLeft(12-i++%2,'0'));

Zastąpić wszystkie wystąpienia ␀z \0do testu.

Wypróbuj online!

C # (interaktywny kompilator Visual C #) , 305 bajtów, 210 znaków

_=>"*ЀʂЄ࢈ҲપԤ␀␀␀؀ȀȀȀ؀␀␀సؘࠀƐഘؚ྾ߟ␀␀Ā␀␀ྀ␀␀రܘࠈഌΚ྾ߟ␀␀ă␀ྃ␀ȁăÃ1`ƀ1`ÃĂȃЃЁȂĀ`ÀƀȺ؀Ȃ␀ȏЀȗɛ'Ŀஇ7;ȅ?ȅ0ȍЀ␀␀΂␀ΨՕ΀Ŕ␀ŀЀ?܀àǀƀ`̀°٠Ƙѐʈш҈EB@Ѐޟɸ".Select((g,i)=>Convert.ToString(g,2).PadLeft(12-i%2,'0'))

To samo z powyższym, zamień na ␀z, \0aby przetestować. Wyjście jako IEnumerable<string>.

Wypróbuj online! (Dzięki uprzejmości Jo King)

Perl 6 , 368 bajtów

.say for :36('FJXOE0PDDNF5Y5EHGB8M9SWMXQOXIKIT9F6ZKWWDEACHCBGXL1N2H60CN0CJ4EMKF7D6MODSKYJVNR4SFTDR6NSM421LQ67B6MWF0G5BQATFOJJJBQ0UFQM64T0MWSQN41C4S5D1QR5KJM2L9UTYMMKUBBQWY45YCMRGO8ZRGTQH7LXMZBUASLCTKX30IH0AYKYEPHO8HFHX8GAY5WM38YOSUX0HABYSH2PPBLRDRZIN5ANAQ3V8PLOZ6EHC0UI95EVJVYD1820T6J14HGX85NWFQET2NWOMSNUT0JW4LHMY90X094TEE9KXJXSNN6YPERFQW').base(2).substr(1).comb(23)

Wypróbuj online!

Długi ciąg jest komunikatem jako pojedyncza liczba bazowa 36 (z pojedynczym prefiksem 1 bit dla zachowania zer wiodących), który jest następnie konwertowany z powrotem na binarny i drukowany 23 bity na raz.

Wolfram Language (Mathematica) , 383 bajty

StringPartition[Uncompress@"1:eJylVNsRwjAM44s92KBaBTZgAUZhZXqtHUuOWrgjfSRRHFlO4tyer/vjfb1clq0gHirZLRjby986hppcT5p+L3BmgJ3t4Ul4GsNyG++7YbaXLh0ZTPhXa4Sn+X/s9Qfk3Hx2cOaSIuNYaVu5laschvgzSqAjHeZBhilKgKBDEhw0upJRg+HOK4MyNC29sfbc3RV0VPDqeLiRTsG1ulExq1IitpunOa7asnYM9siDZ6eidUCkEzBOUbCkGIig4aTyUGBYWAX6W6aXIWGGI/HlhmsqzSU0QTZjkMVpaX5sBsm1OGKVg1qdjKP0EdyqZBRLhukn8DLBQav6kccgz8OKfgBzjj6Z",23]

Wypróbuj online!

Node.js , 333 bajty

Zwraca ciąg binarny o długości 1679 znaków.

_=>Buffer(")SI)=.);1K?>>>2333A3,93/I3>3)g33)AEAAI)5JQZJTddda3)*3*33+3,e)*e3)//0/1+)1C/7Cgggg3395)9)A3IY)h*IH),39+)995*)AA-)59Y)*O3Z,)//*)91**)A*-)Y+1)I11+)I1)/)5)Y*0?)+)I)-0Y)1@;_*7<gaE/a)Q7[*9HM+IY16I33)a1)*^.><I+S3.38I)*hY)7)a)Y)A,9*A5Y/A:9=9K:1I-=9)19I)9*329)GH<").map(x=>s+=(x-51&&x-41).toString(2).padStart(x-51?6:12,0),s='')&&s

Wypróbuj online! (ze sformatowanym wyjściem)

JavaScript (ES8), 413 bajtów

Zwraca ciąg binarny o długości 1679 znaków.

_=>atob('AsKoAFBQEiIlwpVVUk!!ABwo!DQ!Gg!V!Aw7g!!GHGHCi!yGjHChsK+w7vDr8K!!Q!Q!!g!/DgAHDs!AGGHDhiAgCGhjwprDu8Ovwr4!ABAw4AQAcK!MKDAD8GB8OAD!QCAQQMBAYYEAMQwABwpgAMQwBwoYEBAgEEBgEQDAIwoAgIMKAwoDCgMKABgDDgDAEdcKACAgAEHwAIXTCtgTDpMO+w6HDgcK4AsKDwrIFB8OkCgwINg!!A4IAB1FVTDoArCo!U!/CgAB/w4ADwoDDoAwAYDQBYMOMBmEUFEIkSMKARR!woQgAQB!MKUAHnDtA'.split`!`.join`AA`).replace(/[\s\S]/g,c=>c.charCodeAt().toString(2).padStart(8,0))

Wypróbuj online! (ze sformatowanym wyjściem)

Bubblegum, 275 236 bajtów

00000000: e006 8e00 e45d 0018 6988 6507 a228 f86f  .....]..i.e..(.o
00000010: f042 c62f d4d7 b99e 38bc 56c4 52e8 2630  .B./....8.V.R.&0
00000020: 8aaa 7252 d47d 5ef4 c96a 511f 6842 423f  ..rR.}^..jQ.hBB?
00000030: 4532 ca9f 22d3 1633 e0c4 665a d5dc 4e68  E2.."..3..fZ..Nh
00000040: 7b09 76ae 3c7e f9d4 fa4a 05e0 4163 c580  {.v.<~...J..Ac..
00000050: c585 a383 2396 4ca9 1f48 a4b9 744e 37c8  ....#.L..H..tN7.
00000060: 68c5 af23 645d 59a7 542a e6d1 23b9 3aba  h..#d]Y.T*..#.:.
00000070: f0e6 2738 dfd5 b0a3 c6a3 60bf c5b6 5ae6  ..'8......`...Z.
00000080: 7893 30a8 ae04 edf9 298b b777 4d56 285b  x.0.....)..wMV([
00000090: cb74 07cc 7a7b a399 3dc7 c6e7 b693 e715  .t..z{..=.......
000000a0: d908 876e 001f 7408 3c6a 5fcd 37cb 02c4  ...n..t.<j_.7...
000000b0: 93de 33c2 a11e 5bac cd12 d99a fac3 e0fa  ..3...[.........
000000c0: 5268 94f7 d640 0f73 cede f79d 821f 39d1  Rh...@.s......9.
000000d0: dc49 ff06 6962 6c31 dc29 a077 01c3 7690  .I..ibl1.).w..v.
000000e0: 85ef bbec 31d7 5c7f f9fc 8c00            ....1.\.....

Wypróbuj online!

narzędzia bash + GNU, 351 bajtów

base64 -d<<<H4sIAPnNrVwCA6WUCRLDIAwDv8T+/3NNG4wvkTBTcisGSyA8xrcxj9Ds02F+Z7yuf3hnPyz0vYEGz+FG3IKBs+x3oL2PSh0TM/PnaGamft9nPUCew3uCp5RBWdRKGz+qNJn8qRKkkNaTBgeVIFXWOdi8VCaIeUnsfHo6TXpaFa3H5olf6J5MuIHLoEi0uKcRFCvEXG4xseglKzZg7kpYJSLMA3M7wXKR+/L2WiK0kvg+TDASLp6Co1KEVIlVmFzhCktRhBBDdSZYU1xKHrmDUllcWpNR/YNW2QNcHtF0rSySb0MXk/SDUgEwG5gfLvQDxuEdDo8GAAA=|gunzip

TIO

MathGolf , 223 220 bajtów

'06*"x·<×J× Ç×►B×ê\"@$↕!◙è0♥f░×→0×♠p└☺α?×└•×◙×P♣p¬è:×►∟××××←♦♠♣≥â☻┘A☺▄αp⌂r☻[║►×>◘×♦♦└:☻↑`×♥@@@@►►@♦↑ ☻♀◘☻♦☻☻├×å↑×╠×Ç!♠ 0♀◘↑◘☻♦◘×♠α♥â▼ÇA×└×◘` ×××▀≈}═14♦►►π0♀××°×α•×►×××☻×◘××└≈}_├↑♪↓×─0♫♥×××|××*××♪×Ç♠×└×××× ⌐¬╩↕◄○((×T☺"$à+

Wypróbuj online!

Wyjaśnienie

'0                push single character "0"
  6*              repeat 6 times
    "..."         push the magic string
         $        convert to ordinal
          à       convert to binary string
           +      pop a, b : push(a+b) (add the 6 zeroes)
                  below is the footer
            L/    divide into groups of 23 characters
              n   join array with newlines into string

Perl 5 , 460 bajtów

printf"%023b",oct"0x$_"for qw/15400 141404 4444b2 555524 0 600 1a00 1a00 2a00 3e00 0 61c618 400190 68c61a 7df7df 0 80002 0 40001 7c001f 0 618718 404010 68639a 7df7df 0 81802 1800 41801 7c181f 1800 100804 81808 61810 18860 1980 18860 61810 81008 101804 201804 200808 101010 80060 60180 11d600 101000 107c00 10ba5b 1393f 5c3837 283b 10283f 102830 106c00 0 1c1000 1d4555 1c0154 140 7c00 1ff00 701c0 c0060 1a00b0 330198 228288 224488 22880 21080 20080 9400 3cfa78/

Wypróbuj online!

Python 2 , 336 bajtów

print bin(int('gVQAKCgJERLKqqkgAAAAAMAABoAADQAAKgAAfAAAAAMOMMQAGQ0Yw19998AAAAgAAgAAABAAB+AA+AAADDDjEBAENDHNffffAAAAIGAIAMAAQYAfgwPgBgAIBAIIGAgMMCAGIYAAzAAYhgDDAgIEAggMAiAYBEAQEEBAQEADAGAYAjrABAQACD4AELpbAnJ/cODcAUHZAoPyBQYEGwAAAAAcEAA6iqpwBVAACgAHwAA/4AHAcAYAMBoAsGYDMIoKIRIkQCKIAEIQAIAgAEoAPPp4'.decode('base64').encode('hex'),16))[3:]

Wypróbuj online!

Wyświetla ciąg bajtów

Java (OpenJDK 8) , 364 bajty

n->new java.math.BigInteger("in95mzupnpa2r0khpoepyql6ioqyn413avucdtfay6indx4wh9dehe3sn18klobtf4z9g9q17umqmwpegr2khb5eqinn7azl4jpfp2a8eui0xfrx5qwrou6gd65jh4ge3ls14k5lu7qrvmg6942ms29u5rb8fa6yrdhfoh5zoi9bdi7uh5ig0u0ff9kounth8sh357x7qox4m3oqviqsbrvakonbka4ahp21bgzi5v1akzzuqoncszhpabbru9q1uo2g11zr73iuyiqr5ikr69zn7cdv7e1lhd6ese9",36).toString(3).replaceAll("2","0000")

Wypróbuj online!

Objaśnienie: Najpierw musiałem n->new java.math.BigInteger(str,36).toString(2), po prostu przekonwertować liczbę radix 36 na binarną, ale to wymagało dziewięciu dodatkowych znaków dla wiodących zer. Potem wpadłem na pomysł kodowania przez zera niektórych zer jako dwójek. Wydaje się, że długość czterech zer minimalizuje długość promienia 36, ​​więcn->new java.math.BigInteger(str,36).toString(3).replaceAll("2","0000")

Zobacz dyskusję pod tą odpowiedzią, aby znaleźć poprawkę wiodących zer na @ KevinCruijssen

[Python 2] , 345 bajtów

s=''
for c in")pG/K(K*j$h%kk$ppjGE&I6S6S5[5eCv~vw0x&z$wgqcde$e=G4G?G4eG0e:vv~w*G,gn$wy$uuuuG=G)I,G.I2G(I-eG(I)e-I0G+G+G(G)I*G*vI)G-w'I2y0w'I,vI)G*G)G+G(G*I+W+I+W,G*G(G*G*G*G/I,I+I,iq.G*G1G(e/g$c%sG)m%md~$M(},K(cO)K(eO)K(I)G(aE$M(G1c$hpoI,pG3K1e3eU/M*M,I.I*S,Q(y*y'hG(ng&j$j$G+hW/g'G/G,G1k.d$e$mN":c=ord(c)-35;s+=[bin(c-35)[2:],'0'*c][c<35]
print s

Zakodowałem długość ciągów 0 jako bajt zaczynający się od chr (31). Następnie zakodowałem pozostałe 10101 jako liczby binarne od chr (70) do chr (126). Ciągi binarne, które nie pasowały, zostały podzielone na mniejsze części.

Edycja: zmniejszono do 326 bajtów. Dzięki Jo King

Edycja: Naprawiono błąd w programie generatora kodu

Edycja: Edycja końcowa

Zsh , 577 bajtów

spróbuj online !!

S=fxxxxibxxdxxfyzzzyx1yxxxxxxxxyyywl2ij1xxhj1xxhixxxhi5iw2d3c2d2cxl2bxc2az2c2d2ax4x4x4x5wcxpxwdxp15m5w2d2d3c2cxfxhxc1xxc2c2y1xx4x4x4x5wc1f2ixj2kd1e2j15e2f5j2kb1h1hyc1f2gzd2d2fzaf2c1d2ej2b2gf2c1d2ed2d2f1dc1f1hzb1g2hya1h2hya1i1gzb1g1g1dc1l2ed2h2gbz2xx2ibzd1lbzb5jb1dx2xyx1x2fy2yy6x3d3e2a3ixxd2x2b1fxxd6b1fxxd2db1e2a2jwb3e1lb2xxzxxxxx1b3ixxxynxxeh5jf9hd3g3fc2k2eb2a1ix2da2b2g2b2cazxxdxzzazyzyzzezxz1ge1d1d1ge1i1ggyxxia3y4xy3z
for X in ${(s::)S};{case $X in
[a-w])V=$[##$X-96];printf 0%.s {1..$V};;[1-9])V=$[##$X-48];printf 1%.s {1..$V};;[x-z])V=$[##$X-119];printf $[10**$V];;esac}

Zastosowano niestandardową logikę kodowania. Łańcuch Sma 421 znaków i może być nieco bardziej skompresowany. Litery a-wreprezentują powtarzające się 0s. Liczby 1-9reprezentują powtarzające się 1s. Litery x y zreprezentują 10 100 1000odpowiednio.

Może powinienem był spróbować kodowania parą bajtów lub Ascii85 .

Bash , 702 697 bajtów

xxd -r -p<<X|xz -dc
fd377a585a000004e6d6b4460200210116000000742fe5a3e006d7010c5d
0018698865079cf6752c9e9a501a87a798b4844f9fcfdaaf87733b9d8239
48c816d860a938767f6cb81299f3e8a638effe3068c0e096a8949c81d706
7dff3ec44e5df185b3a48e5b5857724386e8c37cfbd5c856b12614ee78ec
c41df4db3aea71fd3a8fa474905609f78eb3fd66e246557965e4ab6dfd67
efbd9202f542ded9cf98a6401ee2d23afb2f544bd2442c6f428fd612397c
f2c6ec50847ddccc5832185e487712e5a7676b97058d7e485d5a3536166a
44ab3c689c93073cdda73b5306a83c4cd268e79db238bfa2d08ac912a578
75020bc7828342d5a62ce367aff7fd89290336128d119fa4272da2b2a79f
5973c71935af054f2d91c1bd3ea4847a3502d6dc8c975114dacf8a4de600
622d80986dbb0cd00001a802d80d00001b16e2a7b1c467fb020000000004
595a
X

Wypróbuj online!

Rubinowy , 362 bajtów

puts"5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0".to_i(36).to_s(2).rjust(1679,?0)

Liczba całkowita zapisana w bazie 36. Z pewnością istnieje bardziej skuteczny sposób kompresji liczby całkowitej, np. Za pomocą zliblub base64.

Wypróbuj online!

[C ++ (VC ++) (ale testowany również z gcc)], 585 bajtów

#define l(x,y)for(int x=0;x<y;x++)
void f(){const char*a="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";int x=1679;l(i,365){int d=a[i],c=0;d-=(d>47&d<58)?48:((d>64&d<71)?55:0);if(d>70&d<91)c=91-d,d=a[i-1];for(c;c>=0;c--)l(j,4){if(x--)cout<<(int)((d&(8>>j))>0);}}}

Wypróbuj online!

wersja bez golfa (brakuje przerwy po 1679-tym elemencie i trwa do 1680-tej):

#include <stdio.h>
#include <iostream>
using namespace std;
int main()
{
    const char arecibo[]="02A800505012Y595Y240U180YD0Y1A0Y540YF80V61C618800321A3186BEFBEF80X10Y40W20YFC001F0X1861C620200868639AFBEFBE0W40C0100180Z83003F0607C00C001008041030101860400C430Z19800310C018604040804101804403008802020808080800600C030047580080800107C002174B604E4FEE1C1B80283B20507E40A0C08360U3820Z751554E00AA0Z140ZF80Z7FC00380E00C0060340160CC06611414422448804510Z8420010040Z940079F4F0";
    int i = 0,j;
    while (i<sizeof(arecibo)-1)
    {   
        char digit = arecibo[i];
        int count=0;
        if (digit >= '0' & digit <= '9')
        {
            digit -= '0';
        }
        else if (digit>='A'& digit<='F')
        {
            digit -=  'A'-10;
        }
        else if (digit > 'F'&digit<='Z')
        {
            //digit does not contain any valid hex digit in this case
            count = 'Z' - digit+1; //digit = Z means repeat 2 more times...
            digit = arecibo[i - 1];
        }
        for (count; count >= 0; count--)
        {
            for (j = 0; j<4; j++)
            {
                cout << (int)(((digit)&(8 >> j))>0);
            }
        }
        i++;
    }
    return 0;
}

jako wyjaśnienie: połączyłem 73 wiersze próbki wyjściowej podane do jednej długiej linii. zakodowałem je w systemie szesnastkowym, gdzie kolejność bitów to msbfirst (używając tego programu https://github.com/Marc-Bender/longBinaryStreamToHex/releases/download/addedErrorCode-4/longBinaryStreamToHex.exe ) skróciłem wyjście o około 70 Cyfry szesnastkowe za pomocą liter „G” - „Z” jako znaku powtarzającego ostatnią cyfrę przez określony czas (Z = 2 razy więcej, Y = 3 razy więcej…) reszta powinna być względnie samoobjaśniająca dla golfistów . nadużywanie preprocesora w celu skrócenia pętli, nadużywanie ,operatora i tym podobnych.

Format wyjściowy to nieprzerwany strumień 1679 wartości 1/1.

Perl 6,348 bajtów

{"000000"~:36<5r0afnfm8wyke8tfy1pwt7xnuaxyh3wodfp7bhsdufyw0xbdp1pumrz2xir652tuc0ss9oec8yad9vefivd66j126wybhefgk2lv38uqqiur11u26q275jk3h2ucithd59awpaenqpqi1pszh52179zw0ddqtbrvo6kyrrgv8c34pqrp83j8estjp63v29t4hqp9yg2hhzjlq1e9zqx6gh20n9lsttimz3nbq060ritrphxaru7quwmv3oujhd9xjddpbacq4bnpf270znhgto59yn0980itylf95pxw9x7rvkvi7mfql1sx46puo8rg4dq0>.base(2)}

Na podstawie rozwiązania Java Benjamina Urquharta .

Używa prostego strumienia 0 i 1 znaków. Poniższy link zawiera kod do upiększenia wyniku.

Wypróbuj online!

Tcl , 366 bajtów

binary scan [binary decode base64 QBUACgpIRKSpqkoCAAAAgAEAsAAAWAAAKgAAHwAAAGA4hhEATFiMYX3f9wEAAAgAIAAAAAQA8AOADwAAGIZjBAQQFsZZ3/d9AAAAAgMIgAEAwQD8YOADMAAIECAIDAgYBgIwwgCAGQCMMIBhICAQIAgYIAIMEAEEBAEBAQFgAAMMIK4BEBAACD4AhC5tICd/h4MdQMFNoOAnUDAQbAAAAAAcBACuqCoHUAUAKADwAQD+A8ABBzAABiyABjNghigoQiQSAaIIACEEgAACACkAni8P] b* z
puts [join [regexp -all -inline .{23} $z] \n]

Wypróbuj online!

C ++ (z biblioteką wieloprecyzyjną Gnu), 359 bajtów

To wyprowadza ciąg jako jedną linię. Używa „1” dla 0 i „0” dla 1: /

Po prostu odczytuje osadzony ciąg jako bazę 62 i drukuje go jako bazę 2.

Służy g++ -g arecibo.cpp -lgmp -lgmpxxdo kompilowania i łączenia

#include<gmpxx.h>
main(){mpz_out_str(stdout,2,class_mpz("vuXXKBYAu1hPsJPbFSf49akyFd0bjJbMIV3upYndU8kYFPsXcpRUK6c9qnzLfORxkxGL7ZfoSwgSxFbCrydjHL603QcxexopAzoYAcAyEiENJJU2vQA2zM8NDbeY6nHgL8rfFoPJaclwxx6TeKeOEknEQHzp7C4la3o8xijBQLOVweFZ1CI9dXy2VQhgnuwF5FeW5mQ909pRMxhn6G3RJ1QEtkS7oGMZYHM03fh4fj391IoYLGVv3iUVuTrV2ghz9CUa9hfGYrdhGoVE2w1inYalYl",62).get_mpz_t());}

Perl 6 , 276 bajtów

:122[q{3tD!gLF['u#.K>'uCG8cvJZ[on1Z<D!	`Fhqq-_V'"qQn+n0h\:b,vXjo&1TMFaW;wvX;eUS
(ueelNSu,y93\kjGI&?UU/38 :ndi4Y5cyC+ME\g7LWaS;QLjtD^L+aVd(XW%gy\8'Eqk-+f72S5J?(r5!m^5px T[Z'3&jd0lZ'/x%#(}.ords].base(2)~~S/.//.say

Wypróbuj online!

Wyjścia jako seria 1679 0 i 1. Możesz mieć go w różnych liniach, dodając .comb(23)>>przedsay .

Wyjaśnienie:

:122["...".ords]                     # Convert the string from base 122
                .base(2)             # To base 2
                        ~~S/.//      # Remove the leading 1
                               .say  # And print

Prawdopodobnie mogę zapisać bajty, używając wyjścia jako liczby całkowitej 1679 bitów lub odwracając reprezentację bitów.

C ++ (gcc) , 748 bajtów

#define l(X,Y)if(z[i]==#X[0])z.replace(i,1,#Y);
void f(){std::string z = {"ab1eeedala1ebeeheal1mmma1fa1g1eeeeeeea1a1alddhgdbcdgdacedgdacedgdeeedgdndgddhgqiafbcag1dbfa1blceafafbcegcinnnlddhgmddegddhgb1ddelcidbnlddhgqqiafag1hedeblcebcaf1acegcinnnlddhgmhcdegdacdagb1bfda1lcibfhcildacdaga1d1d1almhcheagbqch1blhcmbqgdacachghcmbqgbqch1blmh1d1aga1hfd1aledcd1aledeheaga1heheblmdbqgbcdchga1af1efdga1hedbla1bndala1b1f1ea1fflh1aia1acccl1f1bibff1ldeebf1fla1h1ebfccla1h1ebfbla1bffdalddhgaibedblaieemeeeeelaideeeealdh1ehldcidalhcccidlbihf1hlafdafbgacedefblfachfacagemebeemagema1ma1magbememhgbeb1b1hgbedehghea1edalfcacieacca0"};for(int i=0;i<1751;i++){l(q,cb)l(n,fi)l(m,ae)l(i,c1)l(h,ba)l(g,0l)l(f,0c)l(e,01)l(d,bb)l(c,11)l(b,aa)l(a,00)l(l,\n)printf("%c",z[i]);}}

Wypróbuj online!

Zastępując najczęściej używane podciągi nową postacią, aż nie będzie już tego warta

Python 3 , 331 bajtów

exit(''.join(bin(i)[3:]for i in b'`UP@JB`IDQKJjjd`@@@@@L@@Ah@@CP@@J`@@_@@@@@LNLLP@FPtXpu}}}|@@@@`@@`@@@A@@A~@@~@@@CCCcDA@DMCGM____@@@@HF@H@L@@PX@_`pO`A`@HA@HHF@`LLB@FHX@@s@@Xa`CC@`HD@``L@b@XAD@PDDA@PD@C@F@X@ck@A@P@BCx@DKi[@gI\x7f\\NC\\@TGY@hOrAPXDFp@@@@@\\D@@zbjipAU@@B`@Gp@@\x7fx@G@\\@X@LAh@lFXCLHhJHQHdPBJH@DHP@H@`@Dh@OOix')[1:])

Wypróbuj online!